glaip-sdk 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

glaip_sdk/cli/slash/accounts_controller.py

@@ -170,7 +170,9 @@ class AccountsController:
         callbacks = AccountsTUICallbacks(switch_account=_switch_in_textual)
         active = next((row["name"] for row in rows if row.get("active")), None)
         try:
-            run_accounts_textual(rows, active_account=active, env_lock=env_lock, callbacks=callbacks)
+            # Inject TUI context for theme support
+            tui_ctx = getattr(self.session, "tui_ctx", None)
+            run_accounts_textual(rows, active_account=active, env_lock=env_lock, callbacks=callbacks, ctx=tui_ctx)
         except Exception as exc:  # pragma: no cover - defensive around Textual failures
             self.console.print(f"[{WARNING_STYLE}]Accounts browser exited unexpectedly: {exc}[/]")
 

glaip_sdk/cli/slash/session.py

@@ -6,6 +6,7 @@ Authors:
 
 from __future__ import annotations
 
+import asyncio
 import importlib
 import os
 import shlex
@@ -51,6 +52,7 @@ from glaip_sdk.cli.slash.prompt import (
     to_formatted_text,
 )
 from glaip_sdk.cli.slash.remote_runs_controller import RemoteRunsController
+from glaip_sdk.cli.slash.tui.context import TUIContext
 from glaip_sdk.cli.transcript import (
     export_cached_transcript,
     load_history_snapshot,
@@ -186,6 +188,7 @@ class SlashSession:
         self._update_notifier = maybe_notify_update
         self._home_hint_shown = False
         self._agent_transcript_ready: dict[str, str] = {}
+        self.tui_ctx: TUIContext | None = None
 
     # ------------------------------------------------------------------
     # Session orchestration
@@ -215,6 +218,22 @@ class SlashSession:
 
     def run(self, initial_commands: Iterable[str] | None = None) -> None:
         """Start the command palette session loop."""
+        # Initialize TUI context asynchronously
+        try:
+            self.tui_ctx = asyncio.run(TUIContext.create())
+        except RuntimeError:
+            try:
+                loop = asyncio.get_event_loop()
+            except RuntimeError:
+                self.tui_ctx = None
+            else:
+                if loop.is_running():
+                    self.tui_ctx = None
+                else:
+                    self.tui_ctx = loop.run_until_complete(TUIContext.create())
+        except Exception:
+            self.tui_ctx = None
+
         ctx_obj = self.ctx.obj if isinstance(self.ctx.obj, dict) else None
         previous_session = None
         if ctx_obj is not None:

glaip_sdk/cli/slash/tui/__init__.py

@@ -1,6 +1,14 @@
 """Textual UI helpers for slash commands."""
 
+from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter, ClipboardResult
 from glaip_sdk.cli.slash.tui.context import TUIContext
+from glaip_sdk.cli.slash.tui.keybind_registry import (
+    Keybind,
+    KeybindRegistry,
+    format_key_sequence,
+    parse_key_sequence,
+)
+from glaip_sdk.cli.slash.tui.toast import ToastBus, ToastVariant
 from glaip_sdk.cli.slash.tui.remote_runs_app import (
     RemoteRunsTextualApp,
     RemoteRunsTUICallbacks,
@@ -10,9 +18,17 @@ from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities, detect_termin
 
 __all__ = [
     "TUIContext",
+    "ToastBus",
+    "ToastVariant",
     "TerminalCapabilities",
     "detect_terminal_background",
     "RemoteRunsTextualApp",
     "RemoteRunsTUICallbacks",
     "run_remote_runs_textual",
+    "KeybindRegistry",
+    "Keybind",
+    "parse_key_sequence",
+    "format_key_sequence",
+    "ClipboardAdapter",
+    "ClipboardResult",
 ]

glaip_sdk/cli/slash/tui/accounts.tcss

@@ -11,7 +11,7 @@
 
 #env-lock {
     padding: 0 1 0 1;
-    color: yellow;
+    color: $warning;
     height: 1;
 }
 
@@ -45,6 +45,7 @@
     padding: 0 1 0 1;
     margin: 0 0 0 0;
     height: 1fr;
+    border: tall $primary;
 }
 
 #status-bar {
@@ -58,11 +59,12 @@
 }
 
 #status {
-    padding: 0 1 0 1;
-    margin: 0;
-    color: cyan;
+    height: 3;
+    padding: 0 1;
+    color: $secondary;
 }
 
+
 .form-label {
     padding: 0 1 0 1;
 }
@@ -73,7 +75,7 @@
 
 #form-status, #confirm-status {
     padding: 0 1;
-    color: yellow;
+    color: $warning;
 }
 
 #form-test {

glaip_sdk/cli/slash/tui/accounts_app.py

@@ -23,7 +23,10 @@ from glaip_sdk.cli.slash.accounts_shared import (
     env_credentials_present,
 )
 from glaip_sdk.cli.slash.tui.background_tasks import BackgroundTaskMixin
+from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter
+from glaip_sdk.cli.slash.tui.context import TUIContext
 from glaip_sdk.cli.slash.tui.loading import hide_loading_indicator, show_loading_indicator
+from glaip_sdk.cli.slash.tui.theme.catalog import _BUILTIN_THEMES
 from glaip_sdk.cli.validators import validate_api_key
 from glaip_sdk.utils.validation import validate_url
 
@@ -51,6 +54,13 @@ except Exception:  # pragma: no cover - optional dependency
     LoadingIndicator = None  # type: ignore[assignment]
     ModalScreen = None  # type: ignore[assignment]
     Static = None  # type: ignore[assignment]
+    Theme = None  # type: ignore[assignment]
+
+if App is not None:
+    try:  # pragma: no cover - optional dependency
+        from textual.theme import Theme
+    except Exception:  # pragma: no cover - optional dependency
+        Theme = None  # type: ignore[assignment]
 
 TEXTUAL_SUPPORTED = App is not None and DataTable is not None
 
@@ -201,11 +211,12 @@ def run_accounts_textual(
     active_account: str | None,
     env_lock: bool,
     callbacks: AccountsTUICallbacks,
+    ctx: TUIContext | None = None,
 ) -> None:
     """Launch the Textual accounts browser if dependencies are available."""
     if not TEXTUAL_SUPPORTED:
         return
-    app = AccountsTextualApp(rows, active_account, env_lock, callbacks)
+    app = AccountsTextualApp(rows, active_account, env_lock, callbacks, ctx=ctx)
     app.run()
 
 
@@ -379,16 +390,18 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
 
     CSS_PATH = CSS_FILE_NAME
     BINDINGS = [
-        Binding("enter", "switch_row", "Switch", show=True),
-        Binding("return", "switch_row", "Switch", show=False),
-        Binding("/", "focus_filter", "Filter", show=True),
-        Binding("a", "add_account", "Add", show=True),
-        Binding("e", "edit_account", "Edit", show=True),
-        Binding("d", "delete_account", "Delete", show=True),
+        Binding("enter", "switch_row", "Switch", show=True) if Binding else None,
+        Binding("return", "switch_row", "Switch", show=False) if Binding else None,
+        Binding("/", "focus_filter", "Filter", show=True) if Binding else None,
+        Binding("a", "add_account", "Add", show=True) if Binding else None,
+        Binding("e", "edit_account", "Edit", show=True) if Binding else None,
+        Binding("d", "delete_account", "Delete", show=True) if Binding else None,
+        Binding("c", "copy_account", "Copy", show=True) if Binding else None,
         # Esc clears filter when focused/non-empty; otherwise exits
-        Binding("escape", "clear_or_exit", "Close", priority=True),
-        Binding("q", "app_exit", "Close", priority=True),
+        Binding("escape", "clear_or_exit", "Close", priority=True) if Binding else None,
+        Binding("q", "app_exit", "Close", priority=True) if Binding else None,
     ]
+    BINDINGS = [b for b in BINDINGS if b is not None]
 
     def __init__(
         self,
@@ -396,6 +409,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         active_account: str | None,
         env_lock: bool,
         callbacks: AccountsTUICallbacks,
+        ctx: TUIContext | None = None,
     ) -> None:
         """Initialize the Textual accounts app.
 
@@ -404,6 +418,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
             active_account: Name of the currently active account.
             env_lock: Whether environment credentials are locking account switching.
             callbacks: Callbacks for account switching operations.
+            ctx: Shared TUI context.
         """
         super().__init__()
         self._store = get_account_store()
@@ -411,6 +426,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         self._active_account = active_account
         self._env_lock = env_lock
         self._callbacks = callbacks
+        self._ctx = ctx
         self._filter_text: str = ""
         self._is_switching = False
 
@@ -449,6 +465,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
 
     def on_mount(self) -> None:
         """Configure table columns and load rows."""
+        self._apply_theme()
         table = self.query_one(ACCOUNTS_TABLE_ID, DataTable)
         table.add_column("Name", width=20)
         table.add_column("API URL", width=40)
@@ -752,6 +769,26 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
             return
         self.push_screen(ConfirmDeleteModal(name), self._on_delete_result)
 
+    def action_copy_account(self) -> None:
+        """Copy selected account name and URL to clipboard."""
+        name = self._get_selected_name()
+        if not name:
+            self._set_status("Select an account to copy.", "yellow")
+            return
+
+        account = self._store.get_account(name)
+        if not account:
+            return
+
+        text = f"Account: {name}\nURL: {account.get('api_url', '')}"
+        adapter = ClipboardAdapter()
+        result = adapter.copy(text)
+
+        if result.success:
+            self._set_status(f"Copied '{name}' to clipboard.", "green")
+        else:
+            self._set_status(f"Copy failed: {result.message}", "red")
+
     def _check_env_lock_hotkey(self) -> bool:
         """Prevent mutations when env credentials are present."""
         if not self._is_env_locked():
@@ -874,3 +911,23 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         filter_input = self.query_one(FILTER_INPUT_ID, Input)
         clear_btn = self.query_one("#filter-clear", Button)
         clear_btn.display = bool(filter_input.value or self._filter_text)
+
+    def _apply_theme(self) -> None:
+        """Register built-in themes and set the active one from context."""
+        if not self._ctx or not self._ctx.theme or Theme is None:
+            return
+
+        for name, tokens in _BUILTIN_THEMES.items():
+            self.register_theme(
+                Theme(
+                    name=name,
+                    primary=tokens.primary,
+                    secondary=tokens.secondary,
+                    accent=tokens.accent,
+                    warning=tokens.warning,
+                    error=tokens.error,
+                    success=tokens.success,
+                )
+            )
+
+        self.theme = self._ctx.theme.theme_name

glaip_sdk/cli/slash/tui/clipboard.py

@@ -0,0 +1,147 @@
+"""Clipboard adapter for TUI copy actions."""
+
+from __future__ import annotations
+
+import base64
+import os
+import platform
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+from collections.abc import Callable
+
+from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities, detect_osc52_support
+
+
+class ClipboardMethod(str, Enum):
+    """Supported clipboard backends."""
+
+    OSC52 = "osc52"
+    PBCOPY = "pbcopy"
+    XCLIP = "xclip"
+    XSEL = "xsel"
+    WL_COPY = "wl-copy"
+    CLIP = "clip"
+    NONE = "none"
+
+
+@dataclass(frozen=True, slots=True)
+class ClipboardResult:
+    """Result of a clipboard operation."""
+
+    success: bool
+    method: ClipboardMethod
+    message: str
+
+
+_SUBPROCESS_COMMANDS: dict[ClipboardMethod, list[str]] = {
+    ClipboardMethod.PBCOPY: ["pbcopy"],
+    ClipboardMethod.XCLIP: ["xclip", "-selection", "clipboard"],
+    ClipboardMethod.XSEL: ["xsel", "--clipboard", "--input"],
+    ClipboardMethod.WL_COPY: ["wl-copy"],
+    ClipboardMethod.CLIP: ["clip"],
+}
+
+
+class ClipboardAdapter:
+    """Cross-platform clipboard access with OSC 52 fallback."""
+
+    def __init__(
+        self,
+        *,
+        terminal: TerminalCapabilities | None = None,
+        method: ClipboardMethod | None = None,
+    ) -> None:
+        """Initialize the adapter."""
+        self._terminal = terminal
+        self._method = method or self._detect_method()
+
+    @property
+    def method(self) -> ClipboardMethod:
+        """Return the detected clipboard backend."""
+        return self._method
+
+    def copy(self, text: str, *, writer: Callable[[str], Any] | None = None) -> ClipboardResult:
+        """Copy text to clipboard using the best available method.
+
+        Args:
+            text: Text to copy.
+            writer: Optional function to write OSC 52 sequence (e.g., self.app.console.write).
+                   Defaults to sys.stdout.write if not provided.
+        """
+        if self._method == ClipboardMethod.OSC52:
+            return self._copy_osc52(text, writer=writer)
+
+        command = _SUBPROCESS_COMMANDS.get(self._method)
+        if command is None:
+            return self._copy_osc52(text, writer=writer)
+
+        result = self._copy_subprocess(command, text)
+        if not result.success:
+            return self._copy_osc52(text, writer=writer)
+
+        return result
+
+    def _detect_method(self) -> ClipboardMethod:
+        if self._terminal.osc52 if self._terminal else detect_osc52_support():
+            return ClipboardMethod.OSC52
+
+        system = platform.system()
+        if system == "Darwin":
+            return self._detect_darwin_method()
+        if system == "Linux":
+            return self._detect_linux_method()
+        if system == "Windows":
+            return self._detect_windows_method()
+        return ClipboardMethod.NONE
+
+    def _detect_darwin_method(self) -> ClipboardMethod:
+        return ClipboardMethod.PBCOPY if shutil.which("pbcopy") else ClipboardMethod.NONE
+
+    def _detect_linux_method(self) -> ClipboardMethod:
+        if not os.getenv("DISPLAY") and not os.getenv("WAYLAND_DISPLAY"):
+            return ClipboardMethod.NONE
+
+        for cmd, method in (
+            ("xclip", ClipboardMethod.XCLIP),
+            ("xsel", ClipboardMethod.XSEL),
+            ("wl-copy", ClipboardMethod.WL_COPY),
+        ):
+            if shutil.which(cmd):
+                return method
+        return ClipboardMethod.NONE
+
+    def _detect_windows_method(self) -> ClipboardMethod:
+        return ClipboardMethod.CLIP if shutil.which("clip") else ClipboardMethod.NONE
+
+    def _copy_osc52(self, text: str, *, writer: Callable[[str], Any] | None = None) -> ClipboardResult:
+        encoded = base64.b64encode(text.encode("utf-8")).decode("ascii")
+        sequence = f"\x1b]52;c;{encoded}\x07"
+        try:
+            if writer:
+                writer(sequence)
+            else:
+                sys.stdout.write(sequence)
+                sys.stdout.flush()
+        except Exception as exc:
+            return ClipboardResult(False, ClipboardMethod.OSC52, str(exc))
+
+        return ClipboardResult(True, ClipboardMethod.OSC52, "Copied to clipboard")
+
+    def _copy_subprocess(self, cmd: list[str], text: str) -> ClipboardResult:
+        try:
+            completed = subprocess.run(
+                cmd,
+                input=text.encode("utf-8"),
+                check=False,
+            )
+        except OSError as exc:
+            return ClipboardResult(False, self._method, str(exc))
+
+        if completed.returncode == 0:
+            return ClipboardResult(True, self._method, "Copied to clipboard")
+
+        return ClipboardResult(False, self._method, f"Command failed: {completed.returncode}")

glaip_sdk/cli/slash/tui/context.py

@@ -10,9 +10,15 @@ Authors:
 
 from __future__ import annotations
 
+import os
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
 from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities
+from glaip_sdk.cli.slash.tui.theme import ThemeManager
+
+if TYPE_CHECKING:
+    from glaip_sdk.cli.slash.tui.toast import ToastBus
 
 
 @dataclass
@@ -32,8 +38,8 @@ class TUIContext:
 
     terminal: TerminalCapabilities
     keybinds: object | None = None
-    theme: object | None = None
-    toasts: object | None = None
+    theme: ThemeManager | None = None
+    toasts: ToastBus | None = None
     clipboard: object | None = None
 
     @classmethod
@@ -48,4 +54,6 @@ class TUIContext:
             TUIContext instance with terminal capabilities detected.
         """
         terminal = await TerminalCapabilities.detect()
-        return cls(terminal=terminal)
+        theme_name = os.getenv("AIP_TUI_THEME") or None
+        theme = ThemeManager(terminal, theme=theme_name)
+        return cls(terminal=terminal, theme=theme)

glaip_sdk/cli/slash/tui/keybind_registry.py

@@ -0,0 +1,235 @@
+"""Keybinding registry helpers for TUI applications."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+DEFAULT_LEADER = "ctrl+x"
+_LEADER_TOKEN = "<leader>"
+
+_MODIFIER_ORDER = ("ctrl", "alt", "shift", "meta")
+_MODIFIER_SYNONYMS = {
+    "control": "ctrl",
+    "ctl": "ctrl",
+    "cmd": "meta",
+    "command": "meta",
+    "option": "alt",
+    "return": "enter",
+}
+
+_KEY_SYNONYMS = {
+    "esc": "escape",
+}
+
+_KEY_DISPLAY = {
+    "escape": "Esc",
+    "enter": "Enter",
+    "space": "Space",
+    "tab": "Tab",
+    "backspace": "Backspace",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class Keybind:
+    """A registered keybinding."""
+
+    action: str
+    sequence: tuple[str, ...]
+    description: str
+    category: str | None = None
+
+    def __repr__(self) -> str:
+        """Return a readable representation of the keybind."""
+        return (
+            f"Keybind(action={self.action!r}, sequence={self.sequence}, "
+            f"description={self.description!r}, category={self.category!r})"
+        )
+
+
+class KeybindRegistry:
+    """Central registry of keybindings and associated metadata."""
+
+    def __init__(self, *, leader: str = DEFAULT_LEADER) -> None:
+        """Initialize the registry."""
+        normalized = _normalize_chord(leader)
+        self._leader = normalized or DEFAULT_LEADER
+        self._keybinds: dict[str, Keybind] = {}
+
+    @property
+    def leader(self) -> str:
+        """Return the normalized leader chord."""
+        return self._leader
+
+    def register(
+        self,
+        *,
+        action: str,
+        key: str,
+        description: str,
+        category: str | None = None,
+    ) -> Keybind:
+        """Register a keybinding for an action."""
+        if action in self._keybinds:
+            raise ValueError(f"Action already registered: {action}")
+
+        sequence = parse_key_sequence(key)
+        keybind = Keybind(action=action, sequence=sequence, description=description, category=category)
+        self._keybinds[action] = keybind
+        return keybind
+
+    def get(self, action: str) -> Keybind | None:
+        """Return keybind for action, if present."""
+        return self._keybinds.get(action)
+
+    def actions(self) -> list[str]:
+        """Return sorted list of registered actions."""
+        return sorted(self._keybinds)
+
+    def matches(self, action: str, sequence: str | Iterable[str]) -> bool:
+        """Return True if the provided sequence matches the action's keybind."""
+        keybind = self._keybinds.get(action)
+        if keybind is None:
+            return False
+
+        candidate = _coerce_sequence(sequence)
+        return candidate == keybind.sequence
+
+    def format(self, action: str) -> str:
+        """Return a human-readable sequence for an action."""
+        keybind = self._keybinds.get(action)
+        if keybind is None:
+            return ""
+
+        return format_key_sequence(keybind.sequence, leader=self._leader)
+
+
+def parse_key_sequence(key: str) -> tuple[str, ...]:
+    """Parse a key sequence string into normalized tokens."""
+    tokens = [token for token in key.strip().split() if token]
+    normalized: list[str] = []
+
+    for token in tokens:
+        if token.lower() == _LEADER_TOKEN:
+            normalized.append(_LEADER_TOKEN)
+            continue
+
+        chord = _normalize_chord(token)
+        if chord:
+            normalized.append(chord)
+
+    return tuple(normalized)
+
+
+def format_key_sequence(sequence: tuple[str, ...], *, leader: str = DEFAULT_LEADER) -> str:
+    """Format a normalized sequence into a display string."""
+    rendered: list[str] = []
+
+    for token in sequence:
+        if token == _LEADER_TOKEN:
+            rendered.append(_format_token(leader))
+            continue
+        rendered.append(_format_token(token))
+
+    return " ".join(rendered)
+
+
+def _coerce_sequence(sequence: str | Iterable[str]) -> tuple[str, ...]:
+    if isinstance(sequence, str):
+        return parse_key_sequence(sequence)
+
+    tokens: list[str] = []
+    for token in sequence:
+        if not token:
+            continue
+        if token.lower() == _LEADER_TOKEN:
+            tokens.append(_LEADER_TOKEN)
+            continue
+        chord = _normalize_chord(token)
+        if chord:
+            tokens.append(chord)
+
+    return tuple(tokens)
+
+
+def _normalize_chord(chord: str) -> str:
+    """Normalize a key chord string to canonical form.
+
+    Normalization rules:
+    - Converts separators: both '-' and '+' are normalized to '+'
+    - Handles synonyms: 'control'/'ctl' -> 'ctrl', 'cmd'/'command' -> 'meta', 'option' -> 'alt'
+    - Deduplicates modifiers: 'ctrl+ctrl+l' -> 'ctrl+l'
+    - Orders modifiers: ctrl < alt < shift < meta (unknown modifiers sort last)
+    - Case-insensitive: 'Ctrl+L' == 'ctrl+l' == 'CTRL-L'
+
+    Args:
+        chord: Key chord string (e.g., "Ctrl+L", "ctrl-l", "CTRL+CTRL+L")
+
+    Returns:
+        Normalized chord string (e.g., "ctrl+l") or empty string if invalid.
+    """
+    parts = [part for part in chord.replace("-", "+").split("+") if part.strip()]
+    if not parts:
+        return ""
+
+    normalized_parts = [_normalize_key_part(part) for part in parts]
+    if len(normalized_parts) == 1:
+        return normalized_parts[0]
+
+    modifiers, key = normalized_parts[:-1], normalized_parts[-1]
+
+    seen: set[str] = set()
+    unique_mods: list[str] = []
+    for mod in modifiers:
+        if mod in seen:
+            continue
+        seen.add(mod)
+        unique_mods.append(mod)
+
+    unique_mods.sort(key=_modifier_sort_key)
+    return "+".join([*unique_mods, key])
+
+
+def _normalize_key_part(part: str) -> str:
+    token = part.strip().lower()
+    token = _MODIFIER_SYNONYMS.get(token, token)
+    return _KEY_SYNONYMS.get(token, token)
+
+
+def _modifier_sort_key(modifier: str) -> int:
+    try:
+        return _MODIFIER_ORDER.index(modifier)
+    except ValueError:
+        return len(_MODIFIER_ORDER)
+
+
+def _format_token(token: str) -> str:
+    if "+" in token:
+        return _format_chord(token)
+
+    return _KEY_DISPLAY.get(token, token)
+
+
+def _format_chord(chord: str) -> str:
+    parts = chord.split("+")
+    modifiers, key = parts[:-1], parts[-1]
+
+    rendered_mods: list[str] = []
+    for mod in modifiers:
+        if mod == "ctrl":
+            rendered_mods.append("Ctrl")
+        elif mod == "alt":
+            rendered_mods.append("Alt")
+        elif mod == "shift":
+            rendered_mods.append("Shift")
+        elif mod == "meta":
+            rendered_mods.append("Meta")
+        else:
+            rendered_mods.append(mod.title())
+
+    rendered_key = _KEY_DISPLAY.get(key, key)
+    if len(rendered_key) == 1 and rendered_key.isalpha():
+        rendered_key = rendered_key.upper()
+
+    return "+".join([*rendered_mods, rendered_key])

glaip_sdk/cli/slash/tui/terminal.py

@@ -89,7 +89,7 @@ class TerminalCapabilities:
 
         # Basic capability detection
         ansi = tty_available and term not in ("dumb", "")
-        osc52 = _detect_osc52_support()
+        osc52 = detect_osc52_support()
         mouse = tty_available and term not in ("dumb", "")
         truecolor = colorterm in ("truecolor", "24bit")
 
@@ -366,7 +366,7 @@ def _check_terminal_in_env(env_value: str, terminals: list[str]) -> bool:
     return any(terminal in env_value for terminal in terminals)
 
 
-def _detect_osc52_support() -> bool:
+def detect_osc52_support() -> bool:
     """Check if terminal likely supports OSC 52 (clipboard).
 
     Returns:

glaip_sdk/cli/slash/tui/theme/__init__.py

@@ -0,0 +1,15 @@
+"""Theme system primitives for Textual TUIs."""
+
+from __future__ import annotations
+
+from glaip_sdk.cli.slash.tui.theme.catalog import get_builtin_theme, list_builtin_themes
+from glaip_sdk.cli.slash.tui.theme.manager import ThemeManager, ThemeMode
+from glaip_sdk.cli.slash.tui.theme.tokens import ThemeTokens
+
+__all__ = [
+    "ThemeManager",
+    "ThemeMode",
+    "ThemeTokens",
+    "get_builtin_theme",
+    "list_builtin_themes",
+]

glaip_sdk/cli/slash/tui/theme/catalog.py

@@ -0,0 +1,79 @@
+"""Built-in theme catalog for TUI applications.
+
+This module implements Phase 2 of the TUI Theme System spec, providing a foundational
+set of 12 color tokens (primary, secondary, accent, background, background_panel, text,
+text_muted, success, warning, error, info). Additional tokens (e.g., diff.added,
+syntax.*, backgroundElevated, textDim) will be added in future phases per the spec's
+"100+ color tokens" requirement.
+"""
+
+from __future__ import annotations
+
+from glaip_sdk.cli.slash.tui.theme.tokens import ThemeModeLiteral, ThemeTokens
+
+_BUILTIN_THEMES: dict[str, ThemeTokens] = {
+    "gl-dark": ThemeTokens(
+        name="gl-dark",
+        mode="dark",
+        primary="#6EA8FE",
+        secondary="#ADB5BD",
+        accent="#C77DFF",
+        background="#0B0F19",
+        background_panel="#111827",
+        text="#E5E7EB",
+        text_muted="#9CA3AF",
+        success="#34D399",
+        warning="#FBBF24",
+        error="#F87171",
+        info="#60A5FA",
+    ),
+    "gl-light": ThemeTokens(
+        name="gl-light",
+        mode="light",
+        primary="#1D4ED8",
+        secondary="#4B5563",
+        accent="#7C3AED",
+        background="#FFFFFF",
+        background_panel="#F3F4F6",
+        text="#111827",
+        text_muted="#4B5563",
+        success="#059669",
+        warning="#B45309",
+        error="#B91C1C",
+        info="#1D4ED8",
+    ),
+    "gl-high-contrast": ThemeTokens(
+        name="gl-high-contrast",
+        mode="dark",
+        # High-contrast theme uses uniform colors (#FFFFFF on #000000) to maximize
+        # contrast for accessibility. Semantic distinctions (success/warning/error)
+        # are intentionally uniform to prioritize maximum readability over color
+        # coding, per accessibility best practices for high-contrast modes.
+        primary="#FFFFFF",
+        secondary="#FFFFFF",
+        accent="#FFFFFF",
+        background="#000000",
+        background_panel="#000000",
+        text="#FFFFFF",
+        text_muted="#FFFFFF",
+        success="#FFFFFF",
+        warning="#FFFFFF",
+        error="#FFFFFF",
+        info="#FFFFFF",
+    ),
+}
+
+
+def get_builtin_theme(name: str) -> ThemeTokens | None:
+    """Return a built-in theme by name."""
+    return _BUILTIN_THEMES.get(name)
+
+
+def list_builtin_themes() -> list[str]:
+    """List available built-in theme names."""
+    return sorted(_BUILTIN_THEMES)
+
+
+def default_theme_name_for_mode(mode: ThemeModeLiteral) -> str:
+    """Return the default theme name for the given light/dark mode."""
+    return "gl-light" if mode == "light" else "gl-dark"

glaip_sdk/cli/slash/tui/theme/manager.py

@@ -0,0 +1,86 @@
+"""Theme manager for TUI applications."""
+
+from __future__ import annotations
+
+import logging
+from enum import Enum
+from typing import Literal
+
+from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities
+from glaip_sdk.cli.slash.tui.theme.catalog import default_theme_name_for_mode, get_builtin_theme
+from glaip_sdk.cli.slash.tui.theme.tokens import ThemeTokens
+
+logger = logging.getLogger(__name__)
+
+
+class ThemeMode(str, Enum):
+    """User-selectable theme mode."""
+
+    AUTO = "auto"
+    LIGHT = "light"
+    DARK = "dark"
+
+
+class ThemeManager:
+    """Resolve active theme tokens from terminal state and user preferences."""
+
+    def __init__(
+        self,
+        terminal: TerminalCapabilities,
+        *,
+        mode: ThemeMode | str = ThemeMode.AUTO,
+        theme: str | None = None,
+    ) -> None:
+        """Initialize the theme manager."""
+        self._terminal = terminal
+        self._mode = self._coerce_mode(mode)
+        self._theme = theme
+
+    @property
+    def mode(self) -> ThemeMode:
+        """Return configured mode (auto/light/dark)."""
+        return self._mode
+
+    @property
+    def effective_mode(self) -> Literal["light", "dark"]:
+        """Return resolved light/dark mode."""
+        if self._mode == ThemeMode.AUTO:
+            return self._terminal.background_mode
+        return "light" if self._mode == ThemeMode.LIGHT else "dark"
+
+    @property
+    def theme_name(self) -> str:
+        """Return resolved theme name."""
+        return self._theme or default_theme_name_for_mode(self.effective_mode)
+
+    @property
+    def tokens(self) -> ThemeTokens:
+        """Return tokens for the resolved theme."""
+        chosen = get_builtin_theme(self.theme_name)
+        if chosen is not None:
+            return chosen
+
+        fallback_name = default_theme_name_for_mode(self.effective_mode)
+        fallback = get_builtin_theme(fallback_name)
+        if fallback is None:
+            raise RuntimeError(f"Missing default theme: {fallback_name}")
+
+        return fallback
+
+    def set_mode(self, mode: ThemeMode | str) -> None:
+        """Set auto/light/dark mode."""
+        self._mode = self._coerce_mode(mode)
+
+    def set_theme(self, theme: str | None) -> None:
+        """Set explicit theme name (or None to use the default)."""
+        self._theme = theme
+
+    def _coerce_mode(self, mode: ThemeMode | str) -> ThemeMode:
+        """Coerce a mode value to ThemeMode enum, defaulting to AUTO on invalid input."""
+        if isinstance(mode, ThemeMode):
+            return mode
+        try:
+            return ThemeMode(mode)
+        except ValueError:
+            logger.warning(f"Invalid theme mode '{mode}', defaulting to AUTO")
+            return ThemeMode.AUTO

glaip_sdk/cli/slash/tui/theme/tokens.py

@@ -0,0 +1,55 @@
+"""Theme token definitions for TUI applications."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+ThemeModeLiteral = Literal["light", "dark"]
+
+
+@dataclass(frozen=True, slots=True)
+class ThemeTokens:
+    """Color token set for a built-in theme."""
+
+    name: str
+    mode: ThemeModeLiteral
+
+    primary: str
+    secondary: str
+    accent: str
+
+    background: str
+    background_panel: str
+
+    text: str
+    text_muted: str
+
+    success: str
+    warning: str
+    error: str
+    info: str
+
+    def as_dict(self) -> dict[str, str]:
+        """Return color tokens as a plain dictionary.
+
+        Returns only color tokens (primary, secondary, accent, background, etc.),
+        excluding metadata fields (name, mode). This is intentional for use cases
+        like Textual TCSS mapping where only color values are needed.
+
+        Returns:
+            Dictionary mapping color token names to hex color strings.
+        """
+        return {
+            "primary": self.primary,
+            "secondary": self.secondary,
+            "accent": self.accent,
+            "background": self.background,
+            "background_panel": self.background_panel,
+            "text": self.text,
+            "text_muted": self.text_muted,
+            "success": self.success,
+            "warning": self.warning,
+            "error": self.error,
+            "info": self.info,
+        }

glaip_sdk/cli/slash/tui/toast.py

@@ -0,0 +1,123 @@
+"""Toast notification helpers for Textual TUIs.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from enum import Enum
+
+
+class ToastVariant(str, Enum):
+    """Toast message variant."""
+
+    INFO = "info"
+    SUCCESS = "success"
+    WARNING = "warning"
+    ERROR = "error"
+
+
+DEFAULT_TOAST_DURATIONS_SECONDS: dict[ToastVariant, float] = {
+    ToastVariant.SUCCESS: 2.0,
+    ToastVariant.INFO: 3.0,
+    ToastVariant.WARNING: 3.0,
+    ToastVariant.ERROR: 5.0,
+}
+
+
+@dataclass(frozen=True, slots=True)
+class ToastState:
+    """Immutable toast payload."""
+
+    message: str
+    variant: ToastVariant
+    duration_seconds: float
+
+
+class ToastBus:
+    """Single-toast state holder with auto-dismiss."""
+
+    def __init__(self) -> None:
+        """Initialize the bus."""
+        self._state: ToastState | None = None
+        self._dismiss_task: asyncio.Task[None] | None = None
+
+    @property
+    def state(self) -> ToastState | None:
+        """Return the current toast state."""
+        return self._state
+
+    def show(
+        self,
+        message: str,
+        variant: ToastVariant | str = ToastVariant.INFO,
+        *,
+        duration_seconds: float | None = None,
+    ) -> None:
+        """Set toast state and schedule auto-dismiss."""
+        resolved_variant = self._coerce_variant(variant)
+        resolved_duration = (
+            DEFAULT_TOAST_DURATIONS_SECONDS[resolved_variant] if duration_seconds is None else float(duration_seconds)
+        )
+
+        self._state = ToastState(
+            message=message,
+            variant=resolved_variant,
+            duration_seconds=resolved_duration,
+        )
+
+        self._cancel_dismiss_task()
+
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            raise RuntimeError(
+                "Cannot schedule toast auto-dismiss: no running event loop. "
+                "ToastBus.show() must be called from within an async context."
+            ) from None
+
+        self._dismiss_task = loop.create_task(self._auto_dismiss(resolved_duration))
+
+    def clear(self) -> None:
+        """Clear the current toast."""
+        self._cancel_dismiss_task()
+        self._state = None
+
+    def copy_success(self, label: str | None = None) -> None:
+        """Show clipboard success toast."""
+        message = "Copied to clipboard" if not label else f"Copied {label} to clipboard"
+        self.show(message=message, variant=ToastVariant.SUCCESS)
+
+    def copy_failed(self) -> None:
+        """Show clipboard failure toast."""
+        self.show(
+            message="Clipboard unavailable. Text printed below",
+            variant=ToastVariant.WARNING,
+        )
+
+    def _coerce_variant(self, variant: ToastVariant | str) -> ToastVariant:
+        if isinstance(variant, ToastVariant):
+            return variant
+        try:
+            return ToastVariant(variant)
+        except ValueError:
+            return ToastVariant.INFO
+
+    def _cancel_dismiss_task(self) -> None:
+        if self._dismiss_task is None:
+            return
+        if not self._dismiss_task.done():
+            self._dismiss_task.cancel()
+        self._dismiss_task = None
+
+    async def _auto_dismiss(self, duration_seconds: float) -> None:
+        try:
+            await asyncio.sleep(duration_seconds)
+        except asyncio.CancelledError:
+            return
+
+        self._state = None
+        self._dismiss_task = None

{glaip_sdk-0.7.0.dist-info → glaip_sdk-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glaip-sdk
-Version: 0.7.0
+Version: 0.7.1
 Summary: Python SDK and CLI for GL AIP (GDP Labs AI Agent Package) - Build, run, and manage AI agents
 Author-email: Raymond Christopher <raymond.christopher@gdplabs.id>
 License: MIT

{glaip_sdk-0.7.0.dist-info → glaip_sdk-0.7.1.dist-info}/RECORD

@@ -71,20 +71,27 @@ glaip_sdk/cli/core/rendering.py,sha256=QgbYzTcKH8wa7-BdR3UgiS3KBx1QYZjDcV2Hyy5ox
 glaip_sdk/cli/parsers/__init__.py,sha256=NzLrSH6GOdNoewXtKNpB6GwrauA8rb_IGYV6cz5Hn3o,113
 glaip_sdk/cli/parsers/json_input.py,sha256=kxoxeIlgfsaH2jhe6apZAgSxAtwlpSINLTMRsZZYboQ,5630
 glaip_sdk/cli/slash/__init__.py,sha256=J9TPL2UcNTkW8eifG6nRmAEGHhyEgdYMYk4cHaaObC0,386
-glaip_sdk/cli/slash/accounts_controller.py,sha256=-7v_4nTAVCqXySbOLtTfMpUpsqCzDTWmZYkBU880AzI,24803
+glaip_sdk/cli/slash/accounts_controller.py,sha256=SceJlc2F2ZdlSDkuWO3Js3akL89bVtQLyGM_oA-F2qI,24928
 glaip_sdk/cli/slash/accounts_shared.py,sha256=Mq5HxlI0YsVEQ0KKISWvyBZhzOFFWCzwRbhF5xwvUbM,2626
 glaip_sdk/cli/slash/agent_session.py,sha256=tuVOme-NbEyr6rwJvsBEKZYWQmsaRf4piJeRvIGu0ns,11384
 glaip_sdk/cli/slash/prompt.py,sha256=q4f1c2zr7ZMUeO6AgOBF2Nz4qgMOXrVPt6WzPRQMbAM,8501
 glaip_sdk/cli/slash/remote_runs_controller.py,sha256=a5X5rYgb9l6dHhvTewRUCj-hAo7mKRnuM_MwGvxs8jI,21363
-glaip_sdk/cli/slash/session.py,sha256=f6yetP4ih_x7MZCbv4sVQfqHH7JJYgxLY0Q6VHHWTes,64423
-glaip_sdk/cli/slash/tui/__init__.py,sha256=78O54cB5v0nt6vlC1hoXr8YDmST2RjZkq8PUeYratcE,518
-glaip_sdk/cli/slash/tui/accounts.tcss,sha256=xuQjQ0tBM08K1DUv6lI5Sfu1zgZzQxg60c9-RlEWB4s,1160
-glaip_sdk/cli/slash/tui/accounts_app.py,sha256=QDaOpVStS6Z51tfXcS8GRRjTrVfMO26-guHepqysU9k,33715
+glaip_sdk/cli/slash/session.py,sha256=Zn2hXND_Tfameh_PI8g4VIMd7GPWxwhtPNMN9p6cF7M,65081
+glaip_sdk/cli/slash/tui/__init__.py,sha256=oBUzeoslYwPKVlhqhgg4I7480b77vQNc9ec0NgdTC1s,977
+glaip_sdk/cli/slash/tui/accounts.tcss,sha256=BCjIuTetmVjydv6DCliY38Cze2LUEu7IY44sL5nIuLU,1194
+glaip_sdk/cli/slash/tui/accounts_app.py,sha256=6ihnAnzKD49eeXYW3dYWUAdUEyoXNFwoEoi3kS3WtXM,35999
 glaip_sdk/cli/slash/tui/background_tasks.py,sha256=SAe1mV2vXB3mJcSGhelU950vf8Lifjhws9iomyIVFKw,2422
-glaip_sdk/cli/slash/tui/context.py,sha256=oEw4P0ym77uPI0cbHiBam4xpSL2TT0OPvqpBo8gLR30,1835
+glaip_sdk/cli/slash/tui/clipboard.py,sha256=HL_RWIdONyRmDtTYuDzxJTS_mRcLxuR37Ac9Ug5nh40,4730
+glaip_sdk/cli/slash/tui/context.py,sha256=03mo2kgvpyUcNBYz7G2Uyu7X3FJlSUzVoP5Rt9MCZZY,2141
+glaip_sdk/cli/slash/tui/keybind_registry.py,sha256=_rK05BxTxNudYc4iJ9gDxpgeUkjDAq8rarIT-9A-jyM,6739
 glaip_sdk/cli/slash/tui/loading.py,sha256=nW5pv_Tnl9FUOPR3Qf2O5gt1AGHSo3b5-Uofg34F6AE,1909
 glaip_sdk/cli/slash/tui/remote_runs_app.py,sha256=RCrI-c5ilKV6Iy1lz2Aok9xo2Ou02vqcXACMXTdodnE,24716
-glaip_sdk/cli/slash/tui/terminal.py,sha256=SnMOuA6uGeQKA3sGEEM3yTm8j_1LzpYmqsJKyGEKWcg,12110
+glaip_sdk/cli/slash/tui/terminal.py,sha256=iC31XChTL34gXY6vXdSIX3HmD36tuA9EYTPZ2Sn4uOI,12108
+glaip_sdk/cli/slash/tui/toast.py,sha256=LP_myZwgnrdowrRxGK24lMlx7iZt7iOwFhrbc4NW0DY,3493
+glaip_sdk/cli/slash/tui/theme/__init__.py,sha256=rtM2ik83YNCRcI1qh_Sf3rnxco2OvCNNT3NbHY6cLvw,432
+glaip_sdk/cli/slash/tui/theme/catalog.py,sha256=G52eU3h8YI9D8XUALVg1KVZ4Lq65VnZdgPS3F_P7XLE,2544
+glaip_sdk/cli/slash/tui/theme/manager.py,sha256=X600J_WIBM1CHgsQeMFGFPuaVAFCINFcBXFWmeD4B5Q,2707
+glaip_sdk/cli/slash/tui/theme/tokens.py,sha256=ympMRny_d-gHtmnPR-lmNZ-C9SGBy2q-MH81l0L1h-Y,1423
 glaip_sdk/cli/transcript/__init__.py,sha256=yiYHyNtebMCu3BXu56Xm5RBC2tDc865q8UGPnoe6QRs,920
 glaip_sdk/cli/transcript/cache.py,sha256=Wi1uln6HP1U6F-MRTrfnxi9bn6XJTxwWXhREIRPoMqQ,17439
 glaip_sdk/cli/transcript/capture.py,sha256=t8j_62cC6rhb51oCluZd17N04vcXqyjkhPRcRd3ZcmM,10291
@@ -193,8 +200,8 @@ glaip_sdk/utils/rendering/steps/format.py,sha256=Chnq7OBaj8XMeBntSBxrX5zSmrYeGcO
 glaip_sdk/utils/rendering/steps/manager.py,sha256=BiBmTeQMQhjRMykgICXsXNYh1hGsss-fH9BIGVMWFi0,13194
 glaip_sdk/utils/rendering/viewer/__init__.py,sha256=XrxmE2cMAozqrzo1jtDFm8HqNtvDcYi2mAhXLXn5CjI,457
 glaip_sdk/utils/rendering/viewer/presenter.py,sha256=mlLMTjnyeyPVtsyrAbz1BJu9lFGQSlS-voZ-_Cuugv0,5725
-glaip_sdk-0.7.0.dist-info/METADATA,sha256=o7SZ0YWA7OLjK7DsXMcecJJZ0TZFtEjglxJNmdajLpk,8365
-glaip_sdk-0.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-glaip_sdk-0.7.0.dist-info/entry_points.txt,sha256=65vNPUggyYnVGhuw7RhNJ8Fp2jygTcX0yxJBcBY3iLU,48
-glaip_sdk-0.7.0.dist-info/top_level.txt,sha256=td7yXttiYX2s94-4wFhv-5KdT0rSZ-pnJRSire341hw,10
-glaip_sdk-0.7.0.dist-info/RECORD,,
+glaip_sdk-0.7.1.dist-info/METADATA,sha256=Pb8KaBV3ypCfgVvXTZd8mWSP_MgdaqFFdUTEmgPal5I,8365
+glaip_sdk-0.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+glaip_sdk-0.7.1.dist-info/entry_points.txt,sha256=65vNPUggyYnVGhuw7RhNJ8Fp2jygTcX0yxJBcBY3iLU,48
+glaip_sdk-0.7.1.dist-info/top_level.txt,sha256=td7yXttiYX2s94-4wFhv-5KdT0rSZ-pnJRSire341hw,10
+glaip_sdk-0.7.1.dist-info/RECORD,,