glaip-sdk 0.6.19__py3-none-any.whl → 0.7.27__py3-none-any.whl

glaip_sdk/cli/slash/tui/layouts/harlequin.py

@@ -0,0 +1,184 @@
+"""Harlequin layout base class for multi-pane TUI screens.
+
+This module provides the HarlequinScreen base class, which implements a modern
+multi-pane "Harlequin" layout pattern for data-rich TUI screens. The layout uses
+a 25/75 split with a list on the left and detail content on the right.
+
+The Harlequin pattern is inspired by the Harlequin SQL client and provides:
+- Left Pane (25%): ListView or compact table for item selection
+- Right Pane (75%): Detail dashboard showing all fields, status, and action buttons
+- Black background (#000000) that overrides terminal transparency
+- Primary Blue borders (#005CB8)
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+try:  # pragma: no cover - optional dependency
+    from textual.screen import Screen
+    from textual.widget import Widget
+except Exception:  # pragma: no cover - optional dependency
+
+    class Screen:  # type: ignore[no-redef]
+        """Fallback Screen stub when Textual is unavailable."""
+
+        def __class_getitem__(cls, _):
+            """Return the class for typing subscripts."""
+            return cls
+
+    Widget = None  # type: ignore[assignment]
+
+if TYPE_CHECKING:
+    from glaip_sdk.cli.slash.tui.context import TUIContext
+
+try:  # pragma: no cover - optional dependency
+    from glaip_sdk.cli.slash.tui.toast import Toast, ToastContainer
+except Exception:  # pragma: no cover - optional dependency
+    Toast = None  # type: ignore[assignment, misc]
+    ToastContainer = None  # type: ignore[assignment, misc]
+
+# GDP Labs Brand Palette
+PRIMARY_BLUE = "#005CB8"
+BLACK_BACKGROUND = "#000000"
+
+
+if Widget is not None:
+
+    class HarlequinContainer(Widget):
+        """Base container for the Harlequin layout."""
+
+        DEFAULT_CSS = """
+        HarlequinContainer {
+            layout: horizontal;
+        }
+        """
+
+    class HarlequinPane(Widget):
+        """Pane container for Harlequin layout sections."""
+
+        DEFAULT_CSS = """
+        HarlequinPane {
+            layout: vertical;
+        }
+        """
+
+else:
+    HarlequinContainer = None  # type: ignore[assignment, misc]
+    HarlequinPane = None  # type: ignore[assignment, misc]
+
+
+class HarlequinScreen(Screen[None]):  # type: ignore[misc]
+    """Base class for Harlequin-style multi-pane screens.
+
+    This screen provides a 25/75 split layout with a left pane for navigation
+    and a right pane for details. The layout uses a black background that
+    overrides terminal transparency and primary blue borders.
+
+    Subclasses should override `compose()` to add their specific widgets to
+    the left and right panes. Use the container IDs "left-pane" and "right-pane"
+    to target specific panes in CSS or when querying widgets.
+
+    Example:
+        ```python
+        class AccountHarlequinScreen(HarlequinScreen):
+            def compose(self) -> ComposeResult:
+                yield from super().compose()
+                # Add widgets to left and right panes
+                self.query_one("#left-pane").mount(AccountListView())
+                self.query_one("#right-pane").mount(AccountDetailView())
+        ```
+
+    CSS:
+        The screen includes default styling for the Harlequin layout:
+        - Black background (#000000) for the entire screen
+        - Primary blue borders (#005CB8) for panes
+        - 25% width for left pane, 75% width for right pane
+    """
+
+    CSS = """
+    HarlequinScreen {
+        background: #000000;
+        layers: base toasts;
+    }
+
+    #harlequin-container {
+        width: 100%;
+        height: 100%;
+    }
+
+    #left-pane {
+        width: 25%;
+        border: solid #005CB8;
+        background: #000000;
+    }
+
+    #right-pane {
+        width: 75%;
+        border: solid #005CB8;
+        background: #000000;
+    }
+
+    #toast-container {
+        width: 100%;
+        height: auto;
+        dock: top;
+        align: right top;
+        layer: toasts;
+    }
+    """
+
+    def __init__(
+        self,
+        *,
+        ctx: TUIContext | None = None,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        """Initialize the Harlequin screen.
+
+        Args:
+            ctx: Optional TUI context for accessing services (keybinds, theme, toasts, clipboard).
+            name: Optional name for the screen.
+            id: Optional ID for the screen.
+            classes: Optional CSS classes for the screen.
+        """
+        super().__init__(name=name, id=id, classes=classes)
+        self._ctx: TUIContext | None = ctx
+
+    def compose(self) -> Any:
+        """Compose the Harlequin layout with left and right panes.
+
+        This method creates the base 25/75 split layout. Subclasses should
+        call `super().compose()` and then add their specific widgets to the
+        left and right panes.
+
+        Returns:
+            ComposeResult yielding the base layout containers.
+        """
+        if HarlequinContainer is None or HarlequinPane is None:
+            return
+
+        # Main container with horizontal split (25/75)
+        yield HarlequinContainer(
+            HarlequinPane(id="left-pane"),
+            HarlequinPane(id="right-pane"),
+            id="harlequin-container",
+        )
+
+        # Toast container for notifications
+        if Toast is not None and ToastContainer is not None:
+            yield ToastContainer(Toast(), id="toast-container")
+
+    @property
+    def ctx(self) -> TUIContext | None:
+        """Get the TUI context if available.
+
+        Returns:
+            TUIContext instance or None if not provided.
+        """
+        return self._ctx

glaip_sdk/cli/slash/tui/loading.py

@@ -1,58 +1,80 @@
 """Shared helpers for toggling Textual loading indicators.
 
-Note: uses Textual's built-in LoadingIndicator as the MVP; upgrade to the
-PulseIndicator from cli-textual-animated-indicators.md when shipped.
+This module provides unified helpers for showing/hiding both the built-in
+Textual LoadingIndicator and the custom PulseIndicator.
 """
 
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import TYPE_CHECKING
+from typing import Any
 
-try:  # pragma: no cover - optional dependency
-    from textual.widgets import LoadingIndicator
-except Exception:  # pragma: no cover - optional dependency
-    LoadingIndicator = None  # type: ignore[assignment]
+from textual.widgets import LoadingIndicator
 
-if TYPE_CHECKING:  # pragma: no cover - type checking aid
-    from textual.widgets import LoadingIndicator as _LoadingIndicatorType
+from glaip_sdk.cli.slash.tui.indicators import PulseIndicator
 
-    LoadingIndicator: type[_LoadingIndicatorType] | None
 
-
-def _set_indicator_display(app: object, selector: str, visible: bool) -> None:
-    """Safely toggle a LoadingIndicator's display property."""
-    if LoadingIndicator is None:
+def _set_indicator_display(app: Any, selector: str, visible: bool) -> None:
+    try:
+        indicator = app.query_one(selector, PulseIndicator)
+        if visible:
+            indicator.display = True
+            indicator.start()
+        else:
+            indicator.stop()
+            indicator.display = False
         return
+    except Exception:
+        pass
+
     try:
-        indicator = app.query_one(selector, LoadingIndicator)  # type: ignore[arg-type]
+        indicator = app.query_one(selector, LoadingIndicator)
         indicator.display = visible
     except Exception:
-        # Ignore lookup/rendering errors to keep UI resilient
         return
 
 
 def show_loading_indicator(
-    app: object,
+    app: Any,
     selector: str,
     *,
     message: str | None = None,
     set_status: Callable[..., None] | None = None,
     status_style: str = "cyan",
 ) -> None:
-    """Show a loading indicator and optionally set a status message."""
+    """Show a loading indicator (PulseIndicator or LoadingIndicator) and optionally set a status message.
+
+    Args:
+        app: Textual app instance containing the indicator widget
+        selector: CSS selector for the indicator widget
+        message: Optional message to display in the indicator
+        set_status: Optional callback to set status message (for fallback display)
+        status_style: Style for status message if set_status is provided
+    """
     _set_indicator_display(app, selector, True)
+
+    try:
+        indicator = app.query_one(selector, PulseIndicator)
+        if message:
+            indicator.update_message(message)
+    except Exception:
+        pass
+
     if message and set_status:
         try:
             set_status(message, status_style)
         except TypeError:
-            # Fallback for setters that accept only a single arg or kwargs
             try:
                 set_status(message)
             except Exception:
                 return
 
 
-def hide_loading_indicator(app: object, selector: str) -> None:
-    """Hide a loading indicator."""
+def hide_loading_indicator(app: Any, selector: str) -> None:
+    """Hide a loading indicator (PulseIndicator or LoadingIndicator).
+
+    Args:
+        app: Textual app instance containing the indicator widget
+        selector: CSS selector for the indicator widget
+    """
     _set_indicator_display(app, selector, False)

glaip_sdk/cli/slash/tui/remote_runs_app.py

@@ -17,14 +17,20 @@ from dataclasses import dataclass
 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 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 textual.widgets import DataTable, Footer, Header, 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.indicators import PulseIndicator
 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, ToastContainer, ToastHandlerMixin
 
 logger = logging.getLogger(__name__)
 
@@ -50,6 +56,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 +66,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 +77,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 +105,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._clip_cache: ClipboardAdapter | None = None
+        self._local_toasts: ToastBus | None = None
 
     def compose(self) -> ComposeResult:
         """Render metadata and events."""
@@ -116,14 +146,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 ToastContainer(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 +182,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,15 +308,25 @@ 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; }}
-    #status-bar {{ height: 3; padding: 0 1; }}
-    #agent-context {{ min-width: 25; padding-right: 1; }}
-    #{RUNS_LOADING_ID} {{ width: 8; }}
-    #status {{ padding-left: 1; }}
+    #toast-container {{
+        width: 100%;
+        height: auto;
+        dock: top;
+        align: right top;
+        layer: toasts;
+    }}
+    #{RUNS_LOADING_ID} {{
+        width: auto;
+        display: none;
+    }}
+    #status-bar {{
+        height: 3;
+        padding: 0 1;
+    }}
     """
 
     BINDINGS = [
@@ -247,6 +345,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 +355,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,17 +365,45 @@ 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._clip_cache: ClipboardAdapter | None = None
         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
         self._table_spinner_active = False
 
+    @property
+    def clipboard(self) -> str:
+        """Return clipboard text for Input paste actions."""
+        if self._ctx is not None:
+            adapter = self._ctx.clipboard
+            if adapter is None:
+                adapter = ClipboardAdapter(terminal=self._ctx.terminal)
+                self._ctx.clipboard = adapter
+            result = adapter.read()
+            if result.success:
+                return result.text
+        if self._ctx is None and self._clip_cache is None:
+            self._clip_cache = ClipboardAdapter(terminal=None)
+        if self._clip_cache is not None:
+            result = self._clip_cache.read()
+            if result.success:
+                return result.text
+        return super().clipboard
+
+    @clipboard.setter
+    def clipboard(self, value: str) -> None:
+        setter = App.clipboard.fset
+        if setter is not None:
+            setter(self, value)
+
     def compose(self) -> ComposeResult:
         """Build layout."""
         yield Header()
-        table = DataTable(id=RUNS_TABLE_ID)
-        table.cursor_type = "row"
-        table.add_columns(
+        yield ToastContainer(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",
@@ -286,14 +414,24 @@ class RemoteRunsTextualApp(App[None]):
         )
         yield table  # pragma: no cover - interactive UI, tested via integration
         yield Horizontal(  # pragma: no cover - interactive UI, tested via integration
-            LoadingIndicator(id=RUNS_LOADING_ID),
+            PulseIndicator(id=RUNS_LOADING_ID),
             Static(id="status"),
             id="status-bar",
         )
         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 +453,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"
@@ -371,6 +509,26 @@ class RemoteRunsTextualApp(App[None]):
         """Track cursor position when DataTable selection changes."""
         self.cursor_index = getattr(event, "cursor_row", self.cursor_index)
 
+    def _handle_table_click(self, row: int | None) -> None:
+        if row is None:
+            return
+        table = self.query_one(RUNS_TABLE_SELECTOR, DataTable)
+        self.cursor_index = row
+        try:
+            table.cursor_coordinate = Coordinate(row, 0)
+        except Exception:
+            return
+        self.action_open_detail()
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:  # pragma: no cover - UI hook
+        """Handle row selection event from DataTable."""
+        self._handle_table_click(getattr(event, "cursor_row", None))
+
+    def on_data_table_cell_selected(self, event: DataTable.CellSelected) -> None:  # pragma: no cover - UI hook
+        """Handle cell selection event from DataTable."""
+        row = getattr(event.coordinate, "row", None) if event.coordinate else None
+        self._handle_table_click(row)
+
     def action_page_left(self) -> None:
         """Navigate to the previous page."""
         if not self.current_page.has_prev:
@@ -413,7 +571,7 @@ class RemoteRunsTextualApp(App[None]):
             self._update_status("Already loading run detail. Please wait…", append=True)
             return
         run_id = str(run.id)
-        self._show_loading("Loading run detail…", table_spinner=False)
+        self._show_loading("Loading run detail…", table_spinner=False, footer_message=False)
         self._queue_detail_load(run_id)
 
     async def action_export_run(self) -> None:
@@ -554,8 +712,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."""
@@ -606,7 +764,7 @@ class RemoteRunsTextualApp(App[None]):
         show_loading_indicator(
             self,
             RUNS_LOADING_SELECTOR,
-            message=message if footer_message else None,
+            message=message,
             set_status=self._update_status if footer_message else None,
         )
         self._set_table_loading(table_spinner)