glaip-sdk 0.6.5b6__py3-none-any.whl → 0.7.12__py3-none-any.whl

glaip_sdk/cli/slash/tui/remote_runs_app.py

@@ -19,12 +19,16 @@ from typing import Any
 from rich.text import Text
 from textual.app import App, ComposeResult
 from textual.binding import Binding
-from textual.containers import Container, Horizontal
+from textual.containers import Container, Horizontal, Vertical
+from textual.coordinate import Coordinate
 from textual.reactive import ReactiveError
 from textual.screen import ModalScreen
 from textual.widgets import DataTable, Footer, Header, LoadingIndicator, RichLog, Static
 
+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.toast import ClipboardToastMixin, Toast, ToastBus, ToastHandlerMixin
 
 logger = logging.getLogger(__name__)
 
@@ -50,6 +54,7 @@ def run_remote_runs_textual(
     *,
     agent_name: str | None = None,
     agent_id: str | None = None,
+    ctx: TUIContext | None = None,
 ) -> tuple[int, int, int]:
     """Launch the Textual application and return the final pagination state.
 
@@ -59,6 +64,7 @@ def run_remote_runs_textual(
         callbacks: Data provider callback bundle.
         agent_name: Optional agent name for display purposes.
         agent_id: Optional agent ID for display purposes.
+        ctx: Shared TUI context.
 
     Returns:
         Tuple of (page, limit, cursor_index) after the UI exits.
@@ -69,15 +75,27 @@ def run_remote_runs_textual(
         callbacks,
         agent_name=agent_name,
         agent_id=agent_id,
+        ctx=ctx,
     )
     app.run()
     current_page = getattr(app, "current_page", initial_page)
     return current_page.page, current_page.limit, app.cursor_index
 
 
-class RunDetailScreen(ModalScreen[None]):
+class RunDetailScreen(ToastHandlerMixin, ClipboardToastMixin, ModalScreen[None]):
     """Modal screen displaying run metadata and output timeline."""
 
+    CSS = """
+    Screen { layout: vertical; layers: base toasts; }
+    #toast-container {
+        width: 100%;
+        height: auto;
+        dock: top;
+        align: right top;
+        layer: toasts;
+    }
+    """
+
     BINDINGS = [
         Binding("escape", "dismiss", "Close", priority=True),
         Binding("q", "dismiss_modal", "Close", priority=True),
@@ -85,14 +103,24 @@ class RunDetailScreen(ModalScreen[None]):
         Binding("down", "scroll_down", "Down"),
         Binding("pageup", "page_up", "PgUp"),
         Binding("pagedown", "page_down", "PgDn"),
+        Binding("c", "copy_run_id", "Copy ID"),
+        Binding("C", "copy_detail_json", "Copy JSON"),
         Binding("e", "export_detail", "Export"),
     ]
 
-    def __init__(self, detail: Any, on_export: Callable[[Any], None] | None = None):
+    def __init__(
+        self,
+        detail: Any,
+        on_export: Callable[[Any], None] | None = None,
+        ctx: TUIContext | None = None,
+    ) -> None:
         """Initialize the run detail screen."""
         super().__init__()
         self.detail = detail
         self._on_export = on_export
+        self._ctx = ctx
+        self._clipboard: ClipboardAdapter | None = None
+        self._local_toasts: ToastBus | None = None
 
     def compose(self) -> ComposeResult:
         """Render metadata and events."""
@@ -116,14 +144,17 @@ class RunDetailScreen(ModalScreen[None]):
         duration = self.detail.duration_formatted() if getattr(self.detail, "duration_formatted", None) else None
         add_meta("Duration", duration, "bold")
 
-        yield Container(
+        main_content = Vertical(
             Static(meta_text, id="detail-meta"),
             RichLog(id="detail-events", wrap=False),
         )
+        yield main_content
+        yield Container(Toast(), id="toast-container")
         yield Footer()
 
     def on_mount(self) -> None:
         """Populate and focus the log."""
+        self._ensure_toast_bus()
         log = self.query_one("#detail-events", RichLog)
         log.can_focus = True
         log.write(Text("Events", style="bold"))
@@ -149,6 +180,61 @@ class RunDetailScreen(ModalScreen[None]):
     def _log(self) -> RichLog:
         return self.query_one("#detail-events", RichLog)
 
+    def action_copy_run_id(self) -> None:
+        """Copy the run id to the clipboard."""
+        run_id = getattr(self.detail, "id", None)
+        if not run_id:
+            self._announce_status("Run ID unavailable.")
+            return
+        self._copy_to_clipboard(str(run_id), label="Run ID")
+
+    def action_copy_detail_json(self) -> None:
+        """Copy the run detail JSON to the clipboard."""
+        payload = self._detail_json_payload()
+        if payload is None:
+            return
+        self._copy_to_clipboard(payload, label="Run JSON")
+
+    def _detail_json_payload(self) -> str | None:
+        detail = self.detail
+        if detail is None:
+            self._announce_status("Run detail unavailable.")
+            return None
+        if isinstance(detail, str):
+            return detail
+        if isinstance(detail, dict):
+            payload = detail
+        elif hasattr(detail, "model_dump"):
+            payload = detail.model_dump(mode="json")
+        elif hasattr(detail, "dict"):
+            payload = detail.dict()
+        else:
+            payload = getattr(detail, "__dict__", {"value": detail})
+        try:
+            return json.dumps(payload, indent=2, ensure_ascii=False, default=str)
+        except Exception as exc:
+            self._announce_status(f"Failed to serialize run detail: {exc}")
+            return None
+
+    def _append_copy_fallback(self, text: str) -> None:
+        try:
+            log = self._log()
+        except Exception:
+            self._announce_status(text)
+            return
+        log.write(Text(text))
+        log.write(Text(""))
+
+    def _ensure_toast_bus(self) -> None:
+        """Ensure toast bus is initialized and connected to message handler."""
+        if self._local_toasts is not None:
+            return  # pragma: no cover - early return when already initialized
+
+        def _notify(m: ToastBus.Changed) -> None:
+            self.post_message(m)
+
+        self._local_toasts = ToastBus(on_change=_notify)
+
     @staticmethod
     def _status_style(status: str | None) -> str:
         """Return a Rich style name for the status pill."""
@@ -220,11 +306,18 @@ class RunDetailScreen(ModalScreen[None]):
             update_status(message, append=True)
 
 
-class RemoteRunsTextualApp(App[None]):
+class RemoteRunsTextualApp(ToastHandlerMixin, App[None]):
     """Textual application for browsing remote runs."""
 
     CSS = f"""
-    Screen {{ layout: vertical; }}
+    Screen {{ layout: vertical; layers: base toasts; }}
+    #toast-container {{
+        width: 100%;
+        height: auto;
+        dock: top;
+        align: right top;
+        layer: toasts;
+    }}
     #status-bar {{ height: 3; padding: 0 1; }}
     #agent-context {{ min-width: 25; padding-right: 1; }}
     #{RUNS_LOADING_ID} {{ width: 8; }}
@@ -247,6 +340,7 @@ class RemoteRunsTextualApp(App[None]):
         *,
         agent_name: str | None = None,
         agent_id: str | None = None,
+        ctx: TUIContext | None = None,
     ):
         """Initialize the remote runs Textual application.
 
@@ -256,6 +350,7 @@ class RemoteRunsTextualApp(App[None]):
             callbacks: Callback bundle for data operations.
             agent_name: Optional agent name for display purposes.
             agent_id: Optional agent ID for display purposes.
+            ctx: Shared TUI context.
         """
         super().__init__()
         self.current_page = initial_page
@@ -265,6 +360,7 @@ class RemoteRunsTextualApp(App[None]):
         self.current_rows = initial_page.data[:]
         self.agent_name = (agent_name or "").strip()
         self.agent_id = (agent_id or "").strip()
+        self._ctx = ctx
         self._active_export_tasks: set[asyncio.Task[None]] = set()
         self._page_loader_task: asyncio.Task[Any] | None = None
         self._detail_loader_task: asyncio.Task[Any] | None = None
@@ -273,9 +369,10 @@ class RemoteRunsTextualApp(App[None]):
     def compose(self) -> ComposeResult:
         """Build layout."""
         yield Header()
-        table = DataTable(id=RUNS_TABLE_ID)
-        table.cursor_type = "row"
-        table.add_columns(
+        yield Container(Toast(), id="toast-container")
+        table = DataTable(id=RUNS_TABLE_ID)  # pragma: no cover - mocked in tests
+        table.cursor_type = "row"  # pragma: no cover - mocked in tests
+        table.add_columns(  # pragma: no cover - mocked in tests
             "Run UUID",
             "Type",
             "Status",
@@ -292,8 +389,18 @@ class RemoteRunsTextualApp(App[None]):
         )
         yield Footer()  # pragma: no cover - interactive UI, tested via integration
 
+    def _ensure_toast_bus(self) -> None:
+        if self._ctx is None or self._ctx.toasts is not None:
+            return
+
+        def _notify(m: ToastBus.Changed) -> None:
+            self.post_message(m)
+
+        self._ctx.toasts = ToastBus(on_change=_notify)
+
     def on_mount(self) -> None:
         """Render the initial page."""
+        self._ensure_toast_bus()
         self._hide_loading()
         self._render_page(self.current_page)
 
@@ -315,7 +422,7 @@ class RemoteRunsTextualApp(App[None]):
         if self.current_rows:
             self.cursor_index = max(0, min(self.cursor_index, len(self.current_rows) - 1))
             table.focus()
-            table.cursor_coordinate = (self.cursor_index, 0)
+            table.cursor_coordinate = Coordinate(self.cursor_index, 0)
         self.current_page = runs_page
         total_pages = max(1, (runs_page.total + runs_page.limit - 1) // runs_page.limit)
         agent_display = self.agent_name or "Runs"
@@ -554,8 +661,8 @@ class RemoteRunsTextualApp(App[None]):
         if detail is None:
             self._update_status("Failed to load run detail.", append=True)
             return
-        self.push_screen(RunDetailScreen(detail, on_export=self.queue_export_from_detail))
-        self._update_status("Detail view: ↑/↓ scroll · PgUp/PgDn · q/Esc close · e export")
+        self.push_screen(RunDetailScreen(detail, on_export=self.queue_export_from_detail, ctx=self._ctx))
+        self._update_status("Detail view: ↑/↓ scroll · PgUp/PgDn · q/Esc close · c copy ID · C copy JSON · e export")
 
     def queue_export_from_detail(self, detail: Any) -> None:
         """Start an export from the detail modal."""

glaip_sdk/cli/slash/tui/terminal.py

@@ -0,0 +1,407 @@
+"""Terminal capability detection for TUI applications.
+
+This module provides terminal capability detection including TTY status, ANSI support,
+OSC 52 clipboard support, mouse support, truecolor support, and OSC 11 background
+color detection for automatic theme selection.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+import select
+import sys
+import time
+from dataclasses import dataclass
+from typing import Literal
+
+# Windows compatibility: termios and tty may not be available
+try:
+    import termios
+    import tty
+
+    _TERMIOS_AVAILABLE = True
+except ImportError:  # pragma: no cover
+    # Platform-specific: Windows doesn't have termios/tty modules
+    # This exception is only raised on Windows or systems without termios support
+    # Testing would require complex module reloading and platform-specific test setup
+    _TERMIOS_AVAILABLE = False
+
+
+@dataclass
+class TerminalCapabilities:
+    """Terminal feature detection results.
+
+    Attributes:
+        tty: Whether stdout is a TTY.
+        ansi: Whether ANSI escape sequences are supported.
+        osc52: Whether OSC 52 (clipboard) is supported.
+        osc11_bg: Raw RGB color string from OSC 11 query, or None if not detected.
+        mouse: Whether mouse support is available.
+        truecolor: Whether truecolor (24-bit) color is supported.
+    """
+
+    tty: bool
+    ansi: bool
+    osc52: bool
+    osc11_bg: str | None
+    mouse: bool
+    truecolor: bool
+
+    @property
+    def background_mode(self) -> Literal["light", "dark"]:
+        """Derive light/dark mode from OSC 11 background color.
+
+        Returns:
+            "light" if luminance > 0.5, "dark" otherwise. Defaults to "dark"
+            if osc11_bg is None.
+        """
+        if self.osc11_bg is None:
+            return "dark"
+
+        rgb = _parse_color_response(self.osc11_bg)
+        if rgb is None:
+            return "dark"
+
+        luminance = _calculate_luminance(rgb[0], rgb[1], rgb[2])
+        return "light" if luminance > 0.5 else "dark"
+
+    @classmethod
+    async def detect(cls, *, detect_osc11: bool = True) -> TerminalCapabilities:
+        """Detect terminal capabilities asynchronously with fast timeout.
+
+        This method performs capability detection including OSC 11 background
+        color detection with a 100ms timeout. The method completes quickly
+        (< 100ms) as required by the roadmap. OSC 11 detection may return None
+        if the terminal doesn't respond within the timeout; use
+        detect_terminal_background() for full 1-second timeout when needed.
+
+        Args:
+            detect_osc11: When False, skip OSC 11 background detection.
+
+        Returns:
+            TerminalCapabilities instance with detected capabilities.
+        """
+        tty_available = sys.stdout.isatty()
+        term = os.environ.get("TERM", "")
+        colorterm = os.environ.get("COLORTERM", "")
+
+        # Basic capability detection
+        ansi = tty_available and term not in ("dumb", "")
+        osc52 = detect_osc52_support()
+        mouse = tty_available and term not in ("dumb", "")
+        truecolor = colorterm in ("truecolor", "24bit")
+
+        osc11_bg: str | None = None
+        if detect_osc11 and tty_available and sys.stdin.isatty():
+            # OSC 11 detection: use fast path (<100ms timeout)
+            osc11_bg = await _detect_osc11_fast()
+
+        return cls(
+            tty=tty_available,
+            ansi=ansi,
+            osc52=osc52,
+            osc11_bg=osc11_bg,
+            mouse=mouse,
+            truecolor=truecolor,
+        )
+
+
+async def detect_terminal_background() -> str | None:
+    """Detect terminal background color using OSC 11 with full timeout.
+
+    This function can be called separately to await OSC 11 detection with the
+    full 1-second timeout. Useful for theme initialization where a slight delay
+    is acceptable.
+
+    Returns:
+        Raw RGB color string from terminal, or None if detection fails or times out.
+    """
+    if not sys.stdout.isatty() or not sys.stdin.isatty():
+        return None
+
+    if not _TERMIOS_AVAILABLE:
+        return None
+
+    return await _detect_osc11_full()
+
+
+async def _detect_osc11_fast() -> str | None:
+    """Fast-path OSC 11 detection (used by detect())."""
+    return await _detect_osc11_impl(timeout=0.1)
+
+
+async def _detect_osc11_full() -> str | None:
+    """Full-timeout OSC 11 detection (used by detect_terminal_background())."""
+    return await _detect_osc11_impl(timeout=1.0)
+
+
+def _read_osc11_char_with_timeout(start_time: float, timeout_seconds: float) -> str | None:
+    """Read a single character from stdin with timeout.
+
+    Args:
+        start_time: Start time for timeout calculation.
+        timeout_seconds: Maximum time to wait.
+
+    Returns:
+        Character read or None on timeout/error.
+    """
+    elapsed = time.time() - start_time
+    if elapsed >= timeout_seconds:
+        return None
+
+    try:
+        remaining = timeout_seconds - elapsed
+        ready, _, _ = select.select([sys.stdin], [], [], min(0.1, remaining))
+        if not ready:
+            return None
+
+        char = sys.stdin.read(1)
+        return char if char else None
+    except (OSError, ValueError):
+        return None
+
+
+def _check_osc11_complete(response_text: str, response_length: int) -> str | None:
+    """Check if OSC 11 response is complete.
+
+    Args:
+        response_text: Current response text.
+        response_length: Length of response characters.
+
+    Returns:
+        Matched color string if complete, None otherwise.
+    """
+    match = _match_osc11_response(response_text)
+    if match:
+        return match
+
+    # If we see BEL (\x07) terminator, check one more time then give up
+    if "\x07" in response_text and response_length >= 10:
+        return None
+
+    return None
+
+
+def _read_osc11_response_sync(timeout_seconds: float) -> str | None:
+    """Synchronously read OSC 11 response from stdin.
+
+    This runs in a thread to avoid blocking the event loop.
+
+    Args:
+        timeout_seconds: Maximum time to wait.
+
+    Returns:
+        Color string or None.
+    """
+    response_chars: list[str] = []
+    start_time = time.time()
+    max_chars = 200  # Reasonable limit to prevent infinite loops
+
+    while len(response_chars) < max_chars:
+        elapsed = time.time() - start_time
+        if elapsed >= timeout_seconds:
+            return None
+
+        char = _read_osc11_char_with_timeout(start_time, timeout_seconds)
+        if char is None:
+            # Check timeout again after failed read
+            if time.time() - start_time >= timeout_seconds:
+                return None
+            continue
+
+        response_chars.append(char)
+        response_text = "".join(response_chars)
+
+        result = _check_osc11_complete(response_text, len(response_chars))
+        if result is not None:
+            return result
+
+    return None
+
+
+async def _detect_osc11_impl(timeout: float) -> str | None:
+    """Internal OSC 11 detection implementation.
+
+    Args:
+        timeout: Maximum time to wait for terminal response in seconds.
+
+    Returns:
+        Raw RGB color string, or None on timeout/error.
+    """
+    if not _TERMIOS_AVAILABLE:
+        return None
+
+    old_settings = None
+    try:
+        # Save terminal settings
+        old_settings = termios.tcgetattr(sys.stdin)
+        tty.setraw(sys.stdin.fileno())
+
+        # Send OSC 11 query
+        sys.stdout.write("\x1b]11;?\x07")
+        sys.stdout.flush()
+
+        # Read response in a thread to avoid blocking
+        try:
+            result = await asyncio.wait_for(asyncio.to_thread(_read_osc11_response_sync, timeout), timeout=timeout)
+            return result
+        except TimeoutError:
+            return None
+
+    except Exception:
+        return None
+    finally:
+        # Restore terminal settings
+        if old_settings is not None:
+            try:
+                termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)
+            except Exception:
+                pass
+
+
+def _match_osc11_response(text: str) -> str | None:
+    """Extract OSC 11 color response from text.
+
+    Args:
+        text: Raw text from stdin.
+
+    Returns:
+        Color string (e.g., "rgb:RRRR/GGGG/BBBB") or None if not found.
+    """
+    # Match OSC 11 response: \x1b]11;...\x07
+    match = re.search(r"\x1b\]11;([^\x07\x1b]+)", text)
+    if match:
+        return match.group(1)
+    return None
+
+
+def _parse_color_response(color_str: str) -> tuple[int, int, int] | None:
+    """Parse RGB color from various terminal color formats.
+
+    Supports:
+    - rgb:RRRR/GGGG/BBBB (16-bit per channel)
+    - rgb:RR/GG/BB (8-bit per channel)
+    - #RRGGBB (hex)
+    - rgb(R,G,B) (decimal)
+
+    Args:
+        color_str: Color string from terminal.
+
+    Returns:
+        Tuple of (R, G, B) values in 0-255 range, or None if parsing fails.
+    """
+    if not color_str:
+        return None
+
+    try:
+        if color_str.startswith("rgb:"):
+            # Format: rgb:RRRR/GGGG/BBBB (16-bit) or rgb:RR/GG/BB (8-bit)
+            parts = color_str[4:].split("/")
+            if len(parts) == 3:
+                r_val = int(parts[0], 16)
+                g_val = int(parts[1], 16)
+                b_val = int(parts[2], 16)
+
+                # Convert 16-bit to 8-bit: if hex string has 4 digits, it's 16-bit
+                # and we take the high byte (>> 8). If 2 digits, it's already 8-bit.
+                if len(parts[0]) == 4:  # 16-bit format
+                    r_val = r_val >> 8
+                if len(parts[1]) == 4:  # 16-bit format
+                    g_val = g_val >> 8
+                if len(parts[2]) == 4:  # 16-bit format
+                    b_val = b_val >> 8
+
+                return (r_val, g_val, b_val)
+
+        elif color_str.startswith("#"):
+            # Format: #RRGGBB
+            if len(color_str) == 7:
+                r = int(color_str[1:3], 16)
+                g = int(color_str[3:5], 16)
+                b = int(color_str[5:7], 16)
+                return (r, g, b)
+
+        elif color_str.startswith("rgb("):
+            # Format: rgb(R,G,B)
+            parts = color_str[4:-1].split(",")
+            if len(parts) == 3:
+                r = int(parts[0].strip())
+                g = int(parts[1].strip())
+                b = int(parts[2].strip())
+                return (r, g, b)
+
+    except (ValueError, IndexError):
+        pass
+
+    return None
+
+
+def _calculate_luminance(r: int, g: int, b: int) -> float:
+    """Calculate relative luminance from RGB values.
+
+    Uses the relative luminance formula from WCAG:
+    L = 0.299*R + 0.587*G + 0.114*B
+
+    Args:
+        r: Red component (0-255).
+        g: Green component (0-255).
+        b: Blue component (0-255).
+
+    Returns:
+        Luminance value normalized to 0.0-1.0 range.
+    """
+    return (0.299 * r + 0.587 * g + 0.114 * b) / 255.0
+
+
+def _check_terminal_in_env(env_value: str, terminals: list[str]) -> bool:
+    """Check if any terminal name appears in environment value.
+
+    Args:
+        env_value: Environment variable value to check.
+        terminals: List of terminal names to search for.
+
+    Returns:
+        True if any terminal name is found in env_value.
+    """
+    return any(terminal in env_value for terminal in terminals)
+
+
+def detect_osc52_support() -> bool:
+    """Check if terminal likely supports OSC 52 (clipboard).
+
+    Returns:
+        True if terminal name suggests OSC 52 support.
+    """
+    term = os.environ.get("TERM", "").lower()
+    term_program = os.environ.get("TERM_PROGRAM", "").lower()
+    term_program_version = os.environ.get("TERM_PROGRAM_VERSION", "").lower()
+
+    # Known terminals that support OSC 52
+    osc52_terminals = [
+        "iterm",
+        "kitty",
+        "alacritty",
+        "wezterm",
+        "vscode",
+        "windows terminal",
+        "mintty",  # Windows terminal emulator
+    ]
+
+    # Check TERM_PROGRAM first (most reliable)
+    if term_program and _check_terminal_in_env(term_program, osc52_terminals):
+        return True
+
+    # Check TERM_PROGRAM_VERSION (VS Code uses this)
+    if term_program_version and _check_terminal_in_env(term_program_version, osc52_terminals):
+        return True
+
+    # Check TERM (less reliable but sometimes works)
+    if term and _check_terminal_in_env(term, osc52_terminals):
+        return True
+
+    return False

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",
+]