feat(screens): implement multi-screen TUI with Textual

Add full multi-screen architecture replacing the single-screen approach:

Screens:
- auth.py: GitHub token entry and validation screen
- language.py: locale selection screen
- loading.py: async repo clone screen with progress
- dashboard.py: main hub showing cloned repo actions
- member_list.py: scrollable list of existing members
- member_form.py: full member profile form (name, email, socials, open questions)
- save_loading.py: async save/commit/push/PR workflow screen
- quit_confirm.py: modal confirmation dialog

Components:
- form_control.py: labelled form field with error display
- alias_entry.py: dynamic alias row (input + delete button)
- social_entry.py: dynamic social network row (select + URL + delete)
- layout.py: shared header/footer widgets

Author: zodiacfireworks

src/edit_python_pe/components/alias_entry.py

@@ -0,0 +1,17 @@
+from textual.containers import Horizontal
+from textual.widgets import Button, Input
+
+from ..strings import _
+from .form_control import FormControl
+
+
+class AliasEntry(FormControl):
+    def __init__(self, index: int) -> None:
+        self.index = index
+        self.alias_input = Input(placeholder=_("Alias"))
+        self.delete_btn = Button(
+            _("Delete"), id=f"delete_alias_{index}", variant="error"
+        )
+        super().__init__(
+            Horizontal(self.alias_input, self.delete_btn, classes="entry-row")
+        )

src/edit_python_pe/components/form_control.py

@@ -0,0 +1,48 @@
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widget import Widget
+from textual.widgets import Static
+
+
+class FormControl(Vertical):
+    def __init__(
+        self,
+        *children: Widget,
+        label: str = "",
+        help_text: str = "",
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.label_text = label
+        self.help_text_content = help_text
+        self.children_widgets = children
+
+    def compose(self) -> ComposeResult:
+        if self.label_text:
+            yield Static(self.label_text, classes="form-label")
+
+        yield from self.children_widgets
+
+        if self.help_text_content:
+            yield Static(self.help_text_content, classes="form-help-text")
+
+        yield Static("", classes="form-error-text", id="error-msg")
+
+    def on_mount(self) -> None:
+        self.query_one("#error-msg", Static).display = False
+
+    def show_error(self, message: str) -> None:
+        error_static = self.query_one("#error-msg", Static)
+        error_static.update(message)
+        error_static.display = True
+
+        # Apply has-error class to self
+        self.add_class("has-error")
+
+    def clear_error(self) -> None:
+        error_static = self.query_one("#error-msg", Static)
+        error_static.update("")
+        error_static.display = False
+
+        # Remove has-error class from self
+        self.remove_class("has-error")

src/edit_python_pe/components/layout.py

@@ -0,0 +1,21 @@
+from textual.widgets import Static
+
+from ..strings import _
+
+
+class AppHeader(Static):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(
+            _("Welcome aboard to Python Perú"),
+            id="app-header",
+            **kwargs,
+        )
+
+
+class AppFooter(Static):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(
+            _("Proudly built with ❤️ in Perú"),
+            id="app-footer",
+            **kwargs,
+        )

src/edit_python_pe/components/social_entry.py

@@ -0,0 +1,48 @@
+from textual.containers import Horizontal
+from textual.types import NoSelection
+from textual.widgets import Button, Input, Select
+
+from ..constants import (
+    BITBUCKET_OPTION,
+    FACEBOOK_OPTION,
+    GITHUB_OPTION,
+    GITLAB_OPTION,
+    INSTAGRAM_OPTION,
+    LINKEDIN_OPTION,
+    X_OPTION,
+    YOUTUBE_OPTION,
+)
+from ..strings import _
+from .form_control import FormControl
+
+
+class SocialEntry(FormControl):
+    def __init__(self, index: int, value: str | NoSelection) -> None:
+        self.index = index
+        self.select = Select(
+            options=[
+                GITHUB_OPTION,
+                GITLAB_OPTION,
+                BITBUCKET_OPTION,
+                LINKEDIN_OPTION,
+                FACEBOOK_OPTION,
+                INSTAGRAM_OPTION,
+                X_OPTION,
+                YOUTUBE_OPTION,
+            ],
+            prompt=_("Social Network"),
+            value=value,
+        )
+        self.url_input = Input(placeholder=_("Social network URL"))
+        self.delete_btn = Button(
+            _("Delete"), id=f"delete_social_{index}", variant="error"
+        )
+
+        super().__init__(
+            Horizontal(
+                self.select,
+                self.url_input,
+                self.delete_btn,
+                classes="entry-row",
+            )
+        )

src/edit_python_pe/screens/auth.py

@@ -0,0 +1,59 @@
+import logging
+
+import keyring
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import Button, Input, Static
+
+from ..components.layout import AppFooter, AppHeader
+from ..strings import _
+from .loading import LoadingScreen
+from .quit_confirm import QuitConfirmScreen
+
+logger = logging.getLogger(__name__)
+
+
+class AuthScreen(Screen):
+    def compose(self) -> ComposeResult:
+        yield AppHeader()
+        with Vertical(id="auth-container"):
+            yield Static(_("Please enter your GitHub personal access token: "))
+            yield Input(password=True, id="github-token")
+            with Horizontal(id="auth-actions"):
+                with Horizontal(id="auth-actions-left"):
+                    yield Button(_("Login"), id="login-btn", variant="primary")
+                with Horizontal(id="auth-actions-right"):
+                    yield Button(_("Back"), id="auth-back")
+                    yield Button(_("Quit"), id="auth-quit", variant="error")
+        yield AppFooter()
+
+    def on_mount(self) -> None:
+        try:
+            token = keyring.get_password("edit-python-pe", "github_token")
+            if token:
+                self.query_one("#github-token", Input).value = token
+        except Exception:
+            logger.error("Failed to retrieve token from keyring", exc_info=True)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "login-btn":
+            token = self.query_one("#github-token", Input).value.strip()
+            if not token:
+                return
+
+            try:
+                keyring.set_password("edit-python-pe", "github_token", token)
+            except Exception:
+                logger.error("Failed to save token to keyring", exc_info=True)
+
+            self.app.push_screen(LoadingScreen(token))
+        elif event.button.id == "auth-quit":
+
+            def check_quit(quit_app: bool | None) -> None:
+                if quit_app:
+                    self.app.exit()
+
+            self.app.push_screen(QuitConfirmScreen(), check_quit)
+        elif event.button.id == "auth-back":
+            self.app.pop_screen()

src/edit_python_pe/screens/dashboard.py

@@ -0,0 +1,39 @@
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import Button
+
+from ..components.layout import AppFooter, AppHeader
+from ..strings import _
+from .member_form import MemberFormScreen
+from .member_list import MemberListScreen
+from .quit_confirm import QuitConfirmScreen
+
+
+class DashboardScreen(Screen):
+    BINDINGS = [
+        ("ctrl+q", "quit_app", "Quit"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        yield AppHeader()
+        with Vertical(id="dashboard-container"):
+            yield Button(_("Add New Member"), id="dash-add", variant="success")
+            yield Button(_("Edit Existing Member"), id="dash-edit", variant="primary")
+            yield Button(_("Quit"), id="dash-quit", variant="error")
+        yield AppFooter()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "dash-add":
+            self.app.push_screen(MemberFormScreen())
+        elif event.button.id == "dash-edit":
+            self.app.push_screen(MemberListScreen())
+        elif event.button.id == "dash-quit":
+            self.action_quit_app()
+
+    def action_quit_app(self) -> None:
+        def check_quit(quit_app: bool | None) -> None:
+            if quit_app:
+                self.app.exit(message=_("See you next time!"))
+
+        self.app.push_screen(QuitConfirmScreen(), check_quit)

src/edit_python_pe/screens/language.py

@@ -0,0 +1,93 @@
+from pathlib import Path
+
+from babel import Locale
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import Button, OptionList, Static
+
+from ..components.layout import AppFooter, AppHeader
+from ..strings import _, set_language
+from .auth import AuthScreen
+from .quit_confirm import QuitConfirmScreen
+
+
+def get_available_languages() -> dict[int, str]:
+    locales_dir = Path(__file__).parent.parent / "locale"
+    langs = ["en"]
+    if locales_dir.exists():
+        for item in sorted(locales_dir.iterdir()):
+            if item.is_dir() and (item / "LC_MESSAGES" / "messages.mo").exists():
+                langs.append(item.name)
+
+    unique_langs = []
+    for lang in langs:
+        if lang not in unique_langs:
+            unique_langs.append(lang)
+
+    return dict(enumerate(unique_langs))
+
+
+class LanguageScreen(Screen):
+    def compose(self) -> ComposeResult:
+        self.lang_map = get_available_languages()
+        options = []
+        for _idx, lang_code in self.lang_map.items():
+            try:
+                name = Locale(lang_code).get_display_name(lang_code)
+                display = str(name or lang_code).title()
+            except Exception:
+                display = lang_code
+
+            options.append(display)
+
+        yield AppHeader()
+        with Vertical(id="lang-container"):
+            yield Static(_("Select your language"), id="lang-label")
+            yield OptionList(
+                *options,
+                id="lang-select",
+            )
+            with Horizontal(id="lang-actions"):
+                yield Button(_("Continue"), id="lang-continue", variant="primary")
+                yield Button(_("Quit"), id="lang-quit", variant="error")
+        yield AppFooter()
+
+    def on_option_list_option_highlighted(
+        self, event: OptionList.OptionHighlighted
+    ) -> None:
+        lang_code = (
+            self.lang_map.get(event.option_index, "en")
+            if getattr(self, "lang_map", None) and event.option_index is not None
+            else "en"
+        )
+
+        set_language(lang_code)
+
+        # Update labels dynamically
+        self.query_one("#app-header", Static).update(_("Welcome aboard to Python Perú"))
+        self.query_one("#lang-label", Static).update(_("Select your language"))
+        self.query_one("#lang-continue", Button).label = _("Continue")
+        self.query_one("#lang-quit", Button).label = _("Quit")
+        self.query_one("#app-footer", Static).update(_("Proudly built with ❤️ in Perú"))
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "lang-quit":
+
+            def check_quit(quit_app: bool | None) -> None:
+                if quit_app:
+                    self.app.exit()
+
+            self.app.push_screen(QuitConfirmScreen(), check_quit)
+        elif event.button.id == "lang-continue":
+            # If the user clicks continue without highlighting an option,
+            # make sure we set default
+            opt_list = self.query_one("#lang-select", OptionList)
+            selected_idx = opt_list.highlighted
+            lang_code = (
+                self.lang_map.get(selected_idx, "en")
+                if getattr(self, "lang_map", None) and selected_idx is not None
+                else "en"
+            )
+            set_language(lang_code)
+            self.app.push_screen(AuthScreen())