cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/ui/footer.py

@@ -0,0 +1,166 @@
+"""
+CCT UI — ComposerFooter (the single badge row docked inside StickyComposer:
+`NOTEBOOK · provider/model · Workspace` on the left, live context readout
+center, minimal Permissions/Attach/Send glyphs right — flat dot-separated
+text badges, not a button toolbar, matching the reference terminal-chat
+aesthetic) and StatusLine (the compact bar CCTApp docks at the very
+bottom of the screen). Both render state and dispatch events/bubble
+presses to their parent — neither decides what a click means.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+TEXTUAL_AVAILABLE = True
+try:
+    from textual.containers import Horizontal
+    from textual.widgets import Static, Button
+    from textual.reactive import reactive
+except Exception:
+    TEXTUAL_AVAILABLE = False
+
+from .events import NotebookChanged, WorkspaceChanged, CommandExecuted
+from .. import ai_modes
+
+WORKSPACE_CYCLE = ["Workspace", "Kinetics", "Quantum", "Notebook A"]
+
+
+if TEXTUAL_AVAILABLE:
+
+    def _hex_blend(h1, h2, t):
+        """Linear interpolate two '#rrggbb' hex colors at t in [0, 1].
+        Returns a '#rrggbb' hex string — local helper so the mode badge
+        can render its 4-segment gradient bar without reaching into
+        theme internals (theme.blend takes RGB tuples, not hex)."""
+        a = [int(h1[i:i + 2], 16) for i in (1, 3, 5)]
+        b = [int(h2[i:i + 2], 16) for i in (1, 3, 5)]
+        return "#" + "".join(f"{int(round(x + (y - x) * t)):02x}"
+                             for x, y in zip(a, b))
+
+    class _Badge(Static):
+        """One flat, clickable text badge (no border/background chrome) —
+        the `Notebook` / `provider model` / `Workspace` pieces of
+        `NOTEBOOK \u00b7 openai/gpt-4o-mini \u00b7 Workspace`."""
+
+        def __init__(self, text, badge_id, on_click=None, classes="cct-badge"):
+            super().__init__(text, id=badge_id, classes=classes)
+            self._on_click = on_click
+
+        def on_click(self, event):
+            if self._on_click:
+                self._on_click()
+
+    class ComposerFooter(Horizontal):
+        """The single badge row along the bottom of the composer card:
+        `Notebook \u00b7 model \u00b7 Workspace` (left), live context (center),
+        three minimal glyph controls (right). One row, one component.
+        """
+
+        # Holds the AI-mode KEY ("notebook"/"agent"/"build"/"plan" — see
+        # ai_modes.py), not a display string. Reactive name kept as
+        # `notebook_mode` (rather than renamed to `ai_mode`) so the
+        # NotebookChanged event this posts, and ui/app.py's existing
+        # on_notebook_changed handler, didn't need touching to grow
+        # from a 2-way NOTEBOOK/AGENT toggle to the spec's 4 modes.
+        notebook_mode = reactive("notebook")
+        context_tokens = reactive(0)
+
+        def __init__(self, model_label="no model"):
+            super().__init__(id="cct-bottom-row")
+            self._model_label = model_label
+            self._workspace_i = 0
+
+        def _mode_badge_markup(self, mode_key):
+            accent = ai_modes.accent_hex(mode_key)
+            m = ai_modes.meta(mode_key)
+            # v0.7.8: per-mode gradient applied to the badge — a 4-segment
+            # ▮ bar blending the mode's two-stop gradient, then the icon in
+            # the start color and the label in the end color.
+            try:
+                gs, ge = ai_modes.gradient(mode_key)
+                bar = "".join(f"[{_hex_blend(gs, ge, t)}]\u25ae[/]"
+                              for t in (0.0, 0.33, 0.66, 1.0))
+                return f"{bar} [{gs} b]{m['icon']}[/] [{ge} b]{m['label']}[/]"
+            except Exception:
+                return f"[{accent} b]{m['icon']} {m['label']}[/]"
+
+        def compose(self):
+            with Horizontal(id="cct-left-controls"):
+                yield _Badge(self._mode_badge_markup(self.notebook_mode),
+                             "badge-notebook", self._toggle_notebook)
+                yield Static("\u00b7", classes="cct-badge-sep")
+                yield _Badge(self._model_label, "badge-model", self._open_model)
+                yield Static("\u00b7", classes="cct-badge-sep")
+                yield _Badge(WORKSPACE_CYCLE[0], "badge-workspace", self._cycle_workspace)
+            yield Static(id="cct-footer-spacer-left")
+            yield Static(self._status_text(), id="cct-center-status")
+            yield Static(id="cct-footer-spacer-right")
+            with Horizontal(id="cct-right-controls"):
+                yield Button("\U0001f6e1", id="btn-permissions", classes="cct-icon-btn", tooltip="Permissions & Security (🛡)")
+                yield Button("\U0001f4ce", id="btn-attach", classes="cct-icon-btn", tooltip="Attach file")
+                yield Button("\u27a4", id="btn-send", classes="cct-icon-btn cct-icon-send", tooltip="Send message (Enter)")
+
+        def _status_text(self):
+            return f"Context {self.context_tokens}K"
+
+        def watch_context_tokens(self, value):
+            try:
+                self.query_one("#cct-center-status", Static).update(self._status_text())
+            except Exception:
+                pass
+
+        def set_model_label(self, label):
+            self._model_label = label
+            try:
+                self.query_one("#badge-model", _Badge).update(label)
+            except Exception:
+                pass
+
+        def _toggle_notebook(self):
+            """Clicking the badge cycles Notebook -> Agent -> Build ->
+            Plan -> Notebook (spec section 3's four AI modes, up from
+            the old two-stop NOTEBOOK/AGENT toggle)."""
+            self.notebook_mode = ai_modes.next_mode(self.notebook_mode)
+            self.query_one("#badge-notebook", _Badge).update(
+                self._mode_badge_markup(self.notebook_mode))
+            self.post_message(NotebookChanged(self.notebook_mode))
+
+        def _open_model(self):
+            self.post_message(CommandExecuted("/model"))
+
+        def _cycle_workspace(self):
+            self._workspace_i = (self._workspace_i + 1) % len(WORKSPACE_CYCLE)
+            name = WORKSPACE_CYCLE[self._workspace_i]
+            self.query_one("#badge-workspace", _Badge).update(name)
+            self.post_message(WorkspaceChanged(name))
+
+    class StatusLine(Static):
+        """One compact bottom status line for the whole app — no boxes,
+        no oversized labels. `get_fields` is a zero-arg callable
+        returning [(label, value, tone), ...]; CCTApp supplies it and
+        calls `refresh_status()` when something worth showing changes,
+        instead of this widget reaching into backend state itself."""
+
+        def __init__(self, get_fields, id="cct-statusline"):
+            super().__init__(id=id)
+            self._get_fields = get_fields
+
+        def on_mount(self):
+            self.refresh_status()
+
+        def refresh_status(self):
+            from . import theme_css
+            tone_role = {"ready": "success", "warn": "warning", "err": "error", "": "text-muted"}
+            parts = []
+            for label, value, tone in self._get_fields():
+                color = theme_css.current_hex(tone_role.get(tone, "text-muted"))
+                text = f"[{color}]{value}[/]" if not label else f"{label} [{color}]{value}[/]"
+                parts.append(text)
+            self.update("   \u00b7   ".join(parts))
+
+else:
+    ComposerFooter = None
+    StatusLine = None
+

calc_terminal/ui/gestures_panel.py

@@ -0,0 +1,383 @@
+"""
+CAT UI — gestures_panel.py: Gesture Manager (spec section 23).
+
+Responsive: uses percentage widths, auto height, scroll, and stacked
+fallbacks for narrow terminals. Buttons use consistent sizing and
+plain-text labels (no emoji-width mismatches). Layout never clips.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+from ..gestures.bindings import GESTURE_TRIGGERS, GESTURE_TARGETS, GESTURE_ACTIONS
+from ..gestures.manager import list_gestures, add_gesture, delete_gesture, toggle_gesture, reset_defaults
+
+TEXTUAL_AVAILABLE = True
+try:
+    from textual.containers import Vertical, Horizontal, VerticalScroll
+    from textual.screen import Screen
+    from textual.widgets import Static, Button, Input, Select
+    from textual.binding import Binding
+except Exception:
+    TEXTUAL_AVAILABLE = False
+
+
+if TEXTUAL_AVAILABLE:
+
+    class _GestureRow(Horizontal):
+        def __init__(self, gesture):
+            super().__init__(classes="cct-gesture-row")
+            self.gesture = gesture
+
+        def compose(self):
+            g = self.gesture
+            enabled = g.get("enabled", True)
+            name = g.get("name","")
+            trg = g.get("trigger","")
+            tgt = g.get("target","")
+            act = g.get("action","")
+            keys = g.get("keys","")
+            detail = f"{keys} ({tgt}) -> {act}" if trg == "shortcut" and keys else f"{trg} on {tgt}  ->  {act}"
+            # Left: name + detail stacked, so narrow terminals don't clip
+            with Vertical(classes="cct-gesture-left"):
+                if enabled:
+                    yield Static(f"[b]{name}[/]", classes="cct-gesture-name")
+                else:
+                    yield Static(f"[dim]{name} (disabled)[/]", classes="cct-gesture-name")
+                yield Static(detail, classes="cct-gesture-detail")
+            # Right: actions - fixed width group that stays visible
+            with Horizontal(classes="cct-gesture-actions"):
+                label = "Disable" if enabled else "Enable"
+                yield Button(label, id=f"gesture-toggle-{g.get('id')}", classes="cct-btn cct-btn-sm")
+                yield Button("Delete", id=f"gesture-del-{g.get('id')}", variant="error", classes="cct-btn cct-btn-sm")
+
+        def on_button_pressed(self, event):
+            event.stop()
+            gid = self.gesture.get("id")
+            if event.button.id == f"gesture-toggle-{gid}":
+                toggle_gesture(gid)
+                for scr in self.app.screen_stack:
+                    if isinstance(scr, GesturesPanel):
+                        scr.refresh_gestures()
+                        break
+            elif event.button.id == f"gesture-del-{gid}":
+                delete_gesture(gid)
+                for scr in self.app.screen_stack:
+                    if isinstance(scr, GesturesPanel):
+                        scr.refresh_gestures()
+                        break
+
+
+    class GesturesPanel(Screen):
+        """Gesture Manager — responsive CAT-style manager panel."""
+
+        CSS = """
+        GesturesPanel { align: center middle; background: $app-background 60%; }
+
+        #gestures-box {
+            width: 84; height: auto; max-height: 42;
+            background: $surface; border: round $border;
+            padding: 0; overflow: hidden;
+            layout: vertical;
+        }
+        #gestures-titlebar {
+            height: 3; min-height: 3;
+            padding: 1 2 0 2; border-bottom: solid $border;
+            layout: horizontal;
+        }
+        #gestures-title { width: 1fr; text-style: bold; }
+        #gestures-subtitle { color: $text-faint; height: auto; padding: 0 2 1 2; }
+        #gestures-disabled { height: auto; padding: 2 2; align: center middle; }
+        .gestures-disabled-msg { color: $warning; text-style: bold; height: auto; text-align: center; padding-bottom: 1; }
+
+        #gestures-count {
+            height: 1; color: $text-faint;
+            padding: 0 2; margin-bottom: 1;
+        }
+
+        #gestures-list {
+            height: 1fr; min-height: 8; max-height: 20;
+            overflow-y: auto; overflow-x: hidden;
+            margin: 0 1; padding: 0 0;
+            scrollbar-gutter: stable; scrollbar-size: 1 1;
+            scrollbar-color: $border $surface;
+            scrollbar-color-hover: $accent $surface;
+        }
+        #gestures-empty {
+            color: $text-faint; padding: 2 1; text-align: center; height: auto;
+        }
+
+        .cct-gesture-row {
+            height: auto; min-height: 4;
+            padding: 1 1;
+            border-bottom: solid $border;
+            border-left: thick transparent;
+            layout: horizontal;
+            overflow: hidden;
+        }
+        .cct-gesture-row:hover {
+            border-left: thick $accent;
+            background: $surface-alt 40%;
+        }
+        .cct-gesture-left { width: 1fr; height: auto; min-width: 12; }
+        .cct-gesture-name { width: auto; height: 1; }
+        .cct-gesture-detail { width: auto; height: 1; color: $text-muted; }
+        .cct-gesture-actions {
+            width: auto; height: auto; min-width: 20;
+            layout: horizontal; align: center middle;
+        }
+        .cct-gesture-actions Button { margin-left: 1; min-width: 10; height: 3; }
+
+        /* Compact: stack left+actions vertically on very narrow terminals */
+        .cct-compact .cct-gesture-row { layout: vertical; min-height: 6; }
+        .cct-compact .cct-gesture-actions { width: 100%; padding-top: 1; }
+
+        /* Form — responsive: rows become vertical on narrow */
+        #gestures-form {
+            height: auto; padding: 1 2;
+            border-top: solid $border; background: $app-background 35%;
+        }
+        #gestures-form-title { height: 1; text-style: bold; color: $accent; padding-bottom: 1; }
+        #gestures-form-row1 { height: 3; margin-bottom: 1; }
+        #gestures-form-row1 Input { width: 1fr; }
+        #gestures-form-row2 {
+            height: auto; min-height: 3;
+            layout: horizontal; overflow-x: auto;
+            scrollbar-size: 1 1; scrollbar-gutter: stable;
+        }
+        #gestures-form-row2 Select { width: 1fr; min-width: 14; margin-right: 1; margin-bottom: 1; }
+        #gestures-form-row2 Button { min-width: 12; height: 3; }
+
+        #gestures-form-row3 {
+            height: 3; margin-top: 1; layout: horizontal;
+            display: none;
+        }
+        #gestures-form-row3.show { display: block; }
+        #gestures-form-row3 Input { width: 1fr; }
+        #gestures-shortcut-hint { color: $text-faint; height: 1; padding: 0 2; display: none; }
+        #gestures-shortcut-hint.show { display: block; }
+
+        .cct-compact #gestures-form-row2 { layout: vertical; }
+        .cct-compact #gestures-form-row2 Select { width: 100%; margin-right: 0; }
+
+        #gestures-actions {
+            height: auto; min-height: 3; padding: 1 2;
+            layout: horizontal; overflow-x: auto;
+            scrollbar-size: 1 1; scrollbar-gutter: stable;
+            border-top: solid $border;
+        }
+        #gestures-actions Button { margin-right: 1; margin-bottom: 1; min-width: 16; }
+
+        #gestures-hint {
+            height: auto; min-height: 2;
+            color: $text-faint; padding: 1 2;
+            text-align: center;
+            border-top: solid $border;
+        }
+
+        .cct-compact #gestures-box { width: 96; height: auto; }
+        """
+
+        BINDINGS = [Binding("escape", "cancel", "Cancel")]
+
+        def __init__(self):
+            super().__init__()
+
+        def compose(self):
+            # Extension guard: if Gestures is disabled/uninstalled, show disabled state
+            try:
+                from .. import extensions as _ext
+                if not _ext.is_enabled("gestures"):
+                    with Vertical(id="gestures-box"):
+                        with Horizontal(id="gestures-titlebar"):
+                            yield Static("Gestures & Shortcuts", id="gestures-title")
+                            yield Button("✕", id="gestures-close", classes="cct-ctrl")
+                        yield Static("Gestures is disabled — enable it in Extensions to use gestures and shortcuts.", id="gestures-subtitle")
+                        with Vertical(id="gestures-disabled"):
+                            yield Static("🔌 Gestures is currently disabled.", classes="gestures-disabled-msg")
+                            yield Button("Open Extensions", id="gestures-open-ext", variant="primary")
+                            yield Button("Close", id="gestures-close2")
+                    return
+            except Exception:
+                pass
+            with Vertical(id="gestures-box"):
+                with Horizontal(id="gestures-titlebar"):
+                    yield Static("Gestures & Shortcuts", id="gestures-title")
+                    yield Button("X", id="gestures-close", classes="cct-ctrl")
+                # v0.7.9.10 fix: Gestures is independent of MCP — never show
+                # "MCP server down" here. This panel manages only gestures/
+                # shortcuts (see gestures/manager.py), while MCP servers
+                # live exclusively in McpServersPanel (calc_terminal/mcp.py).
+                yield Static("Gestures: double-click/long-press/swipe. Shortcuts: custom key combos -> actions. (Independent of MCP servers)", id="gestures-subtitle")
+                yield Static("", id="gestures-count")
+                with VerticalScroll(id="gestures-list"):
+                    pass
+                with Vertical(id="gestures-form"):
+                    yield Static("Add new gesture / shortcut", id="gestures-form-title")
+                    with Horizontal(id="gestures-form-row1"):
+                        yield Input(placeholder="Name  (e.g. Shift+Enter -> Preview)", id="gestures-name")
+                    with Horizontal(id="gestures-form-row2"):
+                        yield Select([(t, t) for t in GESTURE_TRIGGERS], prompt="Trigger", id="gestures-trigger", value=GESTURE_TRIGGERS[0])
+                        yield Select([(t, t) for t in GESTURE_TARGETS], prompt="Target", id="gestures-target", value=GESTURE_TARGETS[0])
+                        yield Select([(a, a) for a in GESTURE_ACTIONS], prompt="Action", id="gestures-action", value=GESTURE_ACTIONS[0])
+                        yield Button("Add", id="gestures-add", variant="primary", classes="cct-btn-sm")
+                    with Horizontal(id="gestures-form-row3"):
+                        yield Input(placeholder="Shortcut keys (e.g. shift+enter, ctrl+s, ctrl+shift+p)", id="gestures-keys")
+                    yield Static("Hint: shift+enter, ctrl+s, ctrl+shift+p, f5, alt+enter ...", id="gestures-shortcut-hint")
+                with Horizontal(id="gestures-actions"):
+                    yield Button("Reset Defaults", id="gestures-reset", classes="cct-btn-sm")
+                    yield Button("Close", id="gestures-close2", variant="primary", classes="cct-btn-sm")
+                yield Static("Double-click editor -> VS Code  ·  preview -> fullscreen  ·  shortcut: shift+enter -> preview", id="gestures-hint")
+
+        def on_mount(self):
+            self.call_after_refresh(lambda: self.query_one("#gestures-box").add_class("open") if self.query_one("#gestures-box").has_class("open") is False else None)
+            try:
+                self.query_one("#gestures-box").add_class("open")
+            except Exception:
+                pass
+            self.call_after_refresh(self.refresh_gestures)
+            self._update_shortcut_row()
+            try:
+                if self.size.width < 76 or self.size.height < 30:
+                    self.query_one("#gestures-box").add_class("cct-compact")
+            except Exception:
+                pass
+            try:
+                self.query_one("#gestures-name", Input).focus()
+            except Exception:
+                pass
+
+        def _update_shortcut_row(self):
+            try:
+                trg = self.query_one("#gestures-trigger", Select).value
+                show = (trg == "shortcut")
+                row = self.query_one("#gestures-form-row3", Horizontal)
+                hint = self.query_one("#gestures-shortcut-hint", Static)
+                if show:
+                    row.add_class("show")
+                    hint.add_class("show")
+                else:
+                    row.remove_class("show")
+                    hint.remove_class("show")
+            except Exception:
+                pass
+
+        def on_select_changed(self, event):
+            # show/hide shortcut keys input when trigger changes
+            if getattr(event.select, "id", "") == "gestures-trigger":
+                self._update_shortcut_row()
+
+        def refresh_gestures(self):
+            try:
+                container = self.query_one("#gestures-list", VerticalScroll)
+                count_label = self.query_one("#gestures-count", Static)
+            except Exception:
+                return
+            try:
+                container.remove_children()
+            except Exception:
+                pass
+            gestures = list_gestures()
+            enabled = sum(1 for g in gestures if g.get("enabled"))
+            try:
+                count_label.update(f"{len(gestures)} gestures  ·  {enabled} enabled")
+            except Exception:
+                pass
+            if not gestures:
+                try:
+                    container.mount(Static("No gestures yet.\nAdd one below or reset to defaults.", id="gestures-empty"))
+                except Exception:
+                    pass
+                return
+            for g in gestures:
+                try:
+                    container.mount(_GestureRow(g))
+                except Exception:
+                    pass
+
+        def on_button_pressed(self, event):
+            bid = event.button.id
+            if bid == "gestures-open-ext":
+                try:
+                    self.dismiss(None)
+                    from .extensions_panel import ExtensionsPanel
+                    self.app.push_screen(ExtensionsPanel())
+                except Exception:
+                    self.dismiss(None)
+                return
+            if bid in ("gestures-close", "gestures-close2"):
+                self.dismiss(None)
+            elif bid == "gestures-reset":
+                reset_defaults()
+                self.refresh_gestures()
+                try:
+                    self.app._system_note("Gestures reset to defaults")
+                except Exception:
+                    pass
+            elif bid == "gestures-add":
+                try:
+                    name = self.query_one("#gestures-name", Input).value.strip() or "Custom gesture"
+                    try:
+                        trigger = self.query_one("#gestures-trigger", Select).value
+                    except Exception:
+                        trigger = None
+                    try:
+                        target = self.query_one("#gestures-target", Select).value
+                    except Exception:
+                        target = None
+                    try:
+                        action = self.query_one("#gestures-action", Select).value
+                    except Exception:
+                        action = None
+                    try:
+                        keys = self.query_one("#gestures-keys", Input).value.strip().lower() if trigger == "shortcut" else ""
+                    except Exception:
+                        keys = ""
+                    if not trigger or trigger not in GESTURE_TRIGGERS:
+                        trigger = GESTURE_TRIGGERS[0]
+                    if not target or target not in GESTURE_TARGETS:
+                        target = GESTURE_TARGETS[0]
+                    if not action or action not in GESTURE_ACTIONS:
+                        action = GESTURE_ACTIONS[0]
+                    # shortcut needs keys
+                    if trigger == "shortcut":
+                        if not keys:
+                            try:
+                                self.app._system_note("Enter shortcut keys (e.g. shift+enter, ctrl+s)")
+                            except Exception:
+                                pass
+                            return
+                    result = add_gesture(name, trigger, target, action, keys=keys)
+                    if result:
+                        self.refresh_gestures()
+                        try:
+                            self.query_one("#gestures-name", Input).value = ""
+                            self.query_one("#gestures-keys", Input).value = ""
+                        except Exception:
+                            pass
+                        try:
+                            self.app._system_note(f"Added {'shortcut' if trigger=='shortcut' else 'gesture'}: {name}")
+                        except Exception:
+                            pass
+                    else:
+                        try:
+                            self.app._system_note("Could not add — check values (duplicate shortcut or invalid keys)")
+                        except Exception:
+                            pass
+                except Exception as e:
+                    try:
+                        self.app._system_note(f"Could not add gesture: {e}")
+                    except Exception:
+                        pass
+
+        def action_cancel(self):
+            self.dismiss(None)
+
+        def on_key(self, event):
+            if event.key == "escape":
+                self.dismiss(None)
+
+else:
+    GesturesPanel = None

calc_terminal/ui/goodbye_screen.py

@@ -0,0 +1,100 @@
+"""Goodbye screen with ASCII art — shown on sign-out."""
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(1)
+
+TEXTUAL_AVAILABLE = True
+try:
+    from textual.screen import Screen
+    from textual.containers import Vertical
+    from textual.widgets import Static, Button
+    from textual.binding import Binding
+except Exception:
+    TEXTUAL_AVAILABLE = False
+
+_GOODBYE_CAT = [
+    "  /\\_/\\  ",
+    " ( o.o ) ",
+    "  > ^ <  ",
+]
+
+_GOODBYE_BLOCK = [
+    "░██████╗░░█████╗░░█████╗░██████╗░  ██████╗░██╗░░░██╗███████╗",
+    "██╔════╝░██╔══██╗██╔══██╗██╔══██╗  ██╔══██╗╚██╗░██╔╝██╔════╝",
+    "██║░░██╗░██║░░██║██║░░██║██║░░██║  ██████╦╝░╚████╔╝░█████╗░░",
+    "██║░░╚██╗██║░░██║██║░░██║██║░░██║  ██╔══██╗░░╚██╔╝░░██╔══╝░░",
+    "╚██████╔╝╚█████╔╝╚█████╔╝██████╔╝  ██████╦╝░░░██║░░░███████╗",
+    "░╚═════╝░░╚════╝░░╚════╝░╚═════╝░  ╚═════╝░░░░╚═╝░░░╚══════╝",
+]
+
+if TEXTUAL_AVAILABLE:
+    class GoodbyeScreen(Screen):
+        CSS = """
+        GoodbyeScreen { align: center middle; background: $app-background; }
+        #goodbye-box {
+            width: 72; height: auto; max-height: 24;
+            background: $surface; border: round $border;
+            padding: 1 2; align: center middle;
+        }
+        #goodbye-cat { color: $accent; height: auto; text-align: center; }
+        #goodbye-block { color: $text; height: auto; text-align: center; }
+        #goodbye-title { color: $accent; height: auto; text-align: center; padding-top: 1; text-style: bold; }
+        #goodbye-msg { color: $text-muted; height: auto; text-align: center; padding-top: 1; }
+        #goodbye-hint { color: $text-faint; height: 1; text-align: center; padding-top: 1; }
+        """
+        BINDINGS = [Binding("escape", "close", "Close"), Binding("enter", "close", "Close"), Binding("q", "close", "Close")]
+
+        def __init__(self, farewell="Session saved. See you soon! \U0001F43E"):
+            super().__init__()
+            self._farewell = farewell
+
+        def compose(self):
+            with Vertical(id="goodbye-box"):
+                # Try to use art.py if available for richer art
+                try:
+                    from .. import art as _art
+                    from .. import theme as _theme
+                    # Pick a nice cat variant
+                    cat_lines = _GOODBYE_CAT
+                except Exception:
+                    cat_lines = _GOODBYE_CAT
+                yield Static("\n".join(cat_lines), id="goodbye-cat")
+                yield Static("\n".join(_GOODBYE_BLOCK), id="goodbye-block")
+                yield Static("G O O D   B Y E", id="goodbye-title")
+                yield Static(self._farewell, id="goodbye-msg")
+                yield Static("Press Enter, Esc or Q to exit  \u00b7  Auto-close in 3s", id="goodbye-hint")
+
+        def on_mount(self):
+            self.set_timer(3.0, self._auto_close)
+
+        def _auto_close(self):
+            try:
+                self.dismiss(None)
+                self.app.exit()
+            except Exception:
+                pass
+
+        def on_key(self, event):
+            if event.key in ("escape", "enter", "q"):
+                self.dismiss(None)
+                try:
+                    self.app.exit()
+                except Exception:
+                    pass
+
+        def action_close(self):
+            self.dismiss(None)
+            try:
+                self.app.exit()
+            except Exception:
+                pass
+
+        def on_button_pressed(self, event):
+            self.dismiss(None)
+            try:
+                self.app.exit()
+            except Exception:
+                pass
+else:
+    GoodbyeScreen = None