glaip-sdk 0.7.7__py3-none-any.whl → 0.7.12__py3-none-any.whl

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

@@ -6,9 +6,11 @@ import logging
 from enum import Enum
 from typing import Literal
 
+from glaip_sdk.cli.account_store import AccountStore, AccountStoreError
 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
+from glaip_sdk.cli.tui_settings import persist_tui_theme
 
 logger = logging.getLogger(__name__)
 
@@ -30,11 +32,13 @@ class ThemeManager:
         *,
         mode: ThemeMode | str = ThemeMode.AUTO,
         theme: str | None = None,
+        settings_store: AccountStore | None = None,
     ) -> None:
         """Initialize the theme manager."""
         self._terminal = terminal
         self._mode = self._coerce_mode(mode)
-        self._theme = theme
+        self._theme = self._normalize_theme_name(theme)
+        self._settings_store = settings_store
 
     @property
     def mode(self) -> ThemeMode:
@@ -70,10 +74,12 @@ class ThemeManager:
     def set_mode(self, mode: ThemeMode | str) -> None:
         """Set auto/light/dark mode."""
         self._mode = self._coerce_mode(mode)
+        self._persist_preferences()
 
     def set_theme(self, theme: str | None) -> None:
         """Set explicit theme name (or None to use the default)."""
-        self._theme = theme
+        self._theme = self._normalize_theme_name(theme)
+        self._persist_preferences()
 
     def _coerce_mode(self, mode: ThemeMode | str) -> ThemeMode:
         """Coerce a mode value to ThemeMode enum, defaulting to AUTO on invalid input."""
@@ -84,3 +90,23 @@ class ThemeManager:
         except ValueError:
             logger.warning(f"Invalid theme mode '{mode}', defaulting to AUTO")
             return ThemeMode.AUTO
+
+    def _persist_preferences(self) -> None:
+        if self._settings_store is None:
+            return
+        try:
+            persist_tui_theme(mode=self._mode.value, name=self._theme, store=self._settings_store)
+        except (OSError, AccountStoreError) as exc:
+            # Log recoverable errors (permissions, I/O) as warnings
+            logger.warning(f"Failed to persist TUI theme preferences: {exc}")
+        except Exception as exc:
+            # Log unexpected errors at error level for debugging
+            logger.error(f"Unexpected error persisting TUI theme preferences: {exc}", exc_info=True)
+
+    def _normalize_theme_name(self, theme: str | None) -> str | None:
+        if not isinstance(theme, str):
+            return None
+        cleaned = theme.strip()
+        if not cleaned or cleaned.lower() == "default":
+            return None
+        return cleaned

glaip_sdk/cli/slash/tui/toast.py

@@ -1,18 +1,20 @@
-"""Toast notification helpers for Textual TUIs.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-"""
+"""Toast widgets and state management for the TUI."""
 
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum
+from typing import Any, cast
+
+from rich.text import Text
+from textual.message import Message
+from textual.widgets import Static
 
 
 class ToastVariant(str, Enum):
-    """Toast message variant."""
+    """Toast message variant for styling and behavior."""
 
     INFO = "info"
     SUCCESS = "success"
@@ -30,7 +32,7 @@ DEFAULT_TOAST_DURATIONS_SECONDS: dict[ToastVariant, float] = {
 
 @dataclass(frozen=True, slots=True)
 class ToastState:
-    """Immutable toast payload."""
+    """Immutable toast notification state."""
 
     message: str
     variant: ToastVariant
@@ -38,16 +40,25 @@ class ToastState:
 
 
 class ToastBus:
-    """Single-toast state holder with auto-dismiss."""
+    """Toast state manager with auto-dismiss functionality."""
 
-    def __init__(self) -> None:
-        """Initialize the bus."""
+    class Changed(Message):
+        """Message sent when toast state changes."""
+
+        def __init__(self, state: ToastState | None) -> None:
+            """Initialize the changed message with new toast state."""
+            super().__init__()
+            self.state = state
+
+    def __init__(self, on_change: Callable[[ToastBus.Changed], None] | None = None) -> None:
+        """Initialize the toast bus with optional change callback."""
         self._state: ToastState | None = None
         self._dismiss_task: asyncio.Task[None] | None = None
+        self._on_change = on_change
 
     @property
     def state(self) -> ToastState | None:
-        """Return the current toast state."""
+        """Return the current toast state, or None if no toast is shown."""
         return self._state
 
     def show(
@@ -57,7 +68,14 @@ class ToastBus:
         *,
         duration_seconds: float | None = None,
     ) -> None:
-        """Set toast state and schedule auto-dismiss."""
+        """Show a toast notification with the given message and variant.
+
+        Args:
+            message: The message to display in the toast.
+            variant: The visual variant of the toast (INFO, SUCCESS, WARNING, ERROR).
+            duration_seconds: Optional custom duration in seconds. If None, uses default
+                duration for the variant (2s for SUCCESS, 3s for INFO/WARNING, 5s for ERROR).
+        """
         resolved_variant = self._coerce_variant(variant)
         resolved_duration = (
             DEFAULT_TOAST_DURATIONS_SECONDS[resolved_variant] if duration_seconds is None else float(duration_seconds)
@@ -80,23 +98,26 @@ class ToastBus:
             ) from None
 
         self._dismiss_task = loop.create_task(self._auto_dismiss(resolved_duration))
+        self._notify_changed()
 
     def clear(self) -> None:
-        """Clear the current toast."""
+        """Clear the current toast notification immediately."""
         self._cancel_dismiss_task()
         self._state = None
+        self._notify_changed()
 
     def copy_success(self, label: str | None = None) -> None:
-        """Show clipboard success toast."""
+        """Show a success toast for clipboard copy operations.
+
+        Args:
+            label: Optional label for what was copied (e.g., "Run ID", "JSON").
+        """
         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,
-        )
+        """Show a warning toast when clipboard copy fails."""
+        self.show(message="Clipboard unavailable. Text printed below.", variant=ToastVariant.WARNING)
 
     def _coerce_variant(self, variant: ToastVariant | str) -> ToastVariant:
         if isinstance(variant, ToastVariant):
@@ -121,3 +142,233 @@ class ToastBus:
 
         self._state = None
         self._dismiss_task = None
+        self._notify_changed()
+
+    def _notify_changed(self) -> None:
+        if self._on_change:
+            self._on_change(ToastBus.Changed(self._state))
+
+
+class ToastHandlerMixin:
+    """Mixin providing common toast handling functionality.
+
+    Classes that inherit from this mixin can handle ToastBus.Changed messages
+    by automatically updating all Toast widgets in the component tree.
+    """
+
+    def on_toast_bus_changed(self, message: ToastBus.Changed) -> None:
+        """Refresh the toast widget when the toast bus updates.
+
+        Args:
+            message: The toast bus changed message containing the new state.
+        """
+        try:
+            for toast in self.query(Toast):
+                toast.update_state(message.state)
+        except Exception:
+            pass
+
+
+class ClipboardToastMixin:
+    """Mixin providing clipboard and toast orchestration functionality.
+
+    Classes that inherit from this mixin get shared clipboard adapter selection,
+    OSC52 writer setup, toast bus lookup, and copy-success/failure orchestration.
+    This consolidates duplicate clipboard/toast logic across TUI apps.
+
+    Expected attributes:
+        _ctx: TUIContext | None - Shared TUI context (optional)
+        _clipboard: ClipboardAdapter | None - Cached clipboard adapter (optional)
+        _local_toasts: ToastBus | None - Local toast bus instance (optional)
+    """
+
+    def _clipboard_adapter(self) -> Any:  # ClipboardAdapter
+        """Get or create a clipboard adapter instance.
+
+        Returns:
+            ClipboardAdapter instance, preferring context's adapter if available.
+        """
+        # Import here to avoid circular dependency
+        from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter  # noqa: PLC0415
+
+        ctx = getattr(self, "_ctx", None)
+        clipboard = getattr(self, "_clipboard", None)
+
+        if ctx is not None and ctx.clipboard is not None:
+            return cast(ClipboardAdapter, ctx.clipboard)
+        if clipboard is not None:
+            return clipboard
+
+        adapter = ClipboardAdapter(terminal=ctx.terminal if ctx else None)
+        if ctx is not None:
+            ctx.clipboard = adapter
+        else:
+            self._clipboard = adapter
+        return adapter
+
+    def _osc52_writer(self) -> Callable[[str], Any] | None:
+        """Get an OSC52 writer function if console output is available.
+
+        Returns:
+            Writer function that writes OSC52 sequences to console output, or None.
+        """
+        try:
+            # Try self.app.console first (for Screen subclasses)
+            if hasattr(self, "app") and hasattr(self.app, "console"):
+                console = self.app.console
+            # Fall back to self.console (for App subclasses)
+            else:
+                console = getattr(self, "console", None)
+        except Exception:
+            return None
+
+        if console is None:
+            return None
+
+        output = getattr(console, "file", None)
+        if output is None:
+            return None
+
+        def _write(sequence: str, _output: Any = output) -> None:
+            _output.write(sequence)
+            _output.flush()
+
+        return _write
+
+    def _toast_bus(self) -> ToastBus | None:
+        """Get the toast bus instance.
+
+        Returns:
+            ToastBus instance, preferring context's bus if available, or None.
+        """
+        local_toasts = getattr(self, "_local_toasts", None)
+        ctx = getattr(self, "_ctx", None)
+
+        if local_toasts is not None:
+            return local_toasts
+        if ctx is not None and ctx.toasts is not None:
+            return ctx.toasts
+        return None
+
+    def _copy_to_clipboard(self, text: str, *, label: str | None = None) -> None:
+        """Copy text to clipboard and show toast notification.
+
+        Args:
+            text: The text to copy to clipboard.
+            label: Optional label for what was copied (e.g., "Run ID", "JSON").
+        """
+        adapter = self._clipboard_adapter()
+        writer = self._osc52_writer()
+        if writer:
+            result = adapter.copy(text, writer=writer)
+        else:
+            result = adapter.copy(text)
+
+        toasts = self._toast_bus()
+        if result.success:
+            if toasts:
+                toasts.copy_success(label)
+            else:
+                # Fallback to status announcement if toast bus unavailable
+                if hasattr(self, "_announce_status"):
+                    if label:
+                        self._announce_status(f"Copied {label} to clipboard.")
+                    else:
+                        self._announce_status("Copied to clipboard.")
+            return
+
+        # Copy failed
+        if toasts:
+            toasts.copy_failed()
+        else:
+            # Fallback to status announcement if toast bus unavailable
+            if hasattr(self, "_announce_status"):
+                self._announce_status("Clipboard unavailable. Text printed below.")
+
+        # Append fallback text output
+        if hasattr(self, "_append_copy_fallback"):
+            self._append_copy_fallback(text)
+
+
+class Toast(Static):
+    """A Textual widget that displays toast notifications at the top-right of the screen.
+
+    The Toast widget is updated via `update_state()` calls from message handlers
+    (e.g., `on_toast_bus_changed`). The widget does not auto-subscribe to ToastBus
+    state changes; the app must call `update_state()` when toast state changes.
+    """
+
+    DEFAULT_CSS = """
+    #toast-container {
+        width: 100%;
+        height: auto;
+        dock: top;
+        align: right top;
+    }
+
+    Toast {
+        width: auto;
+        min-width: 20;
+        max-width: 40;
+        height: auto;
+        padding: 0 1;
+        margin: 1 2;
+        background: $surface;
+        color: $text;
+        border: solid $primary;
+        display: none;
+    }
+
+    Toast.visible {
+        display: block;
+    }
+
+    Toast.info {
+        border: solid $accent;
+    }
+
+    Toast.success {
+        border: solid $success;
+    }
+
+    Toast.warning {
+        border: solid $warning;
+    }
+
+    Toast.error {
+        border: solid $error;
+    }
+    """
+
+    def __init__(self) -> None:
+        """Initialize the Toast widget.
+
+        The widget is updated via `update_state()` calls from message handlers
+        (e.g., `on_toast_bus_changed`). The widget does not auto-subscribe to
+        a ToastBus; the app must call `update_state()` when toast state changes.
+        """
+        super().__init__("")
+
+    def update_state(self, state: ToastState | None) -> None:
+        """Update the toast display based on the provided state.
+
+        Args:
+            state: The toast state to display, or None to hide the toast.
+        """
+        if not state:
+            self.remove_class("visible")
+            return
+
+        icon = "ℹ️"
+        if state.variant == ToastVariant.SUCCESS:
+            icon = "✅"
+        elif state.variant == ToastVariant.WARNING:
+            icon = "⚠️"
+        elif state.variant == ToastVariant.ERROR:
+            icon = "❌"
+
+        self.update(Text.assemble((f"{icon} ", "bold"), state.message))
+
+        self.remove_class("info", "success", "warning", "error")
+        self.add_class(state.variant.value)
+        self.add_class("visible")

glaip_sdk/cli/tui_settings.py

@@ -0,0 +1,125 @@
+"""Typed loader/saver for TUI preferences stored in config.yaml.
+
+This module implements the TUI preferences store as defined in
+`specs/architecture/tui-preferences-store/spec.md`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal, cast
+
+from glaip_sdk.cli.account_store import AccountStore, get_account_store
+
+ThemeModeValue = Literal["auto", "light", "dark"]
+
+_DEFAULT_THEME_MODE: ThemeModeValue = "auto"
+_DEFAULT_LEADER = "ctrl+x"
+_DEFAULT_MOUSE_CAPTURE = False
+
+
+@dataclass(frozen=True)
+class TUISettings:
+    """Resolved TUI preferences from config.yaml."""
+
+    theme_mode: ThemeModeValue = _DEFAULT_THEME_MODE
+    theme_name: str | None = None
+    leader: str = _DEFAULT_LEADER
+    keybind_overrides: dict[str, str] = field(default_factory=dict)
+    mouse_capture: bool = _DEFAULT_MOUSE_CAPTURE
+
+
+def load_tui_settings(*, store: AccountStore | None = None) -> TUISettings:
+    """Load TUI preferences from the CLI config file."""
+    store = store or get_account_store()
+    config = store.load_config()
+
+    tui = _as_dict(config.get("tui"))
+    theme = _as_dict(tui.get("theme"))
+    mode = _coerce_theme_mode(theme.get("mode"))
+    name = _normalize_theme_name(theme.get("name"))
+
+    keybinds = _as_dict(tui.get("keybinds"))
+    leader = keybinds.get("leader")
+    if not isinstance(leader, str) or not leader.strip():
+        leader = _DEFAULT_LEADER
+
+    overrides = _coerce_keybind_overrides(keybinds.get("overrides"))
+
+    mouse_capture = tui.get("mouse_capture")
+    if not isinstance(mouse_capture, bool):
+        mouse_capture = _DEFAULT_MOUSE_CAPTURE
+
+    return TUISettings(
+        theme_mode=mode,
+        theme_name=name,
+        leader=leader,
+        keybind_overrides=overrides,
+        mouse_capture=mouse_capture,
+    )
+
+
+def update_tui_settings(patch: dict[str, Any], *, store: AccountStore | None = None) -> None:
+    """Update TUI preferences, preserving unrelated config keys."""
+    store = store or get_account_store()
+    config = store.load_config()
+
+    existing = _as_dict(config.get("tui"))
+    config["tui"] = _merge_dict(existing, patch)
+
+    store.save_config_updates(config)
+
+
+def persist_tui_theme(*, mode: ThemeModeValue, name: str | None, store: AccountStore | None = None) -> None:
+    """Persist theme preferences in the tui.theme namespace."""
+    update_tui_settings(
+        {"theme": {"mode": _coerce_theme_mode(mode), "name": _serialize_theme_name(name)}},
+        store=store,
+    )
+
+
+def _as_dict(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return dict(value)
+    return {}
+
+
+def _coerce_theme_mode(value: Any) -> ThemeModeValue:
+    if isinstance(value, str):
+        lowered = value.strip().lower()
+        if lowered in {"auto", "light", "dark"}:
+            return cast(ThemeModeValue, lowered)
+    return _DEFAULT_THEME_MODE
+
+
+def _normalize_theme_name(value: Any) -> str | None:
+    if not isinstance(value, str):
+        return None
+    cleaned = value.strip()
+    if not cleaned or cleaned.lower() == "default":
+        return None
+    return cleaned
+
+
+def _serialize_theme_name(name: str | None) -> str:
+    if isinstance(name, str):
+        cleaned = name.strip()
+        if cleaned:
+            return cleaned
+    return "default"
+
+
+def _coerce_keybind_overrides(value: Any) -> dict[str, str]:
+    if not isinstance(value, dict):
+        return {}
+    return {key: val for key, val in value.items() if isinstance(key, str) and isinstance(val, str)}
+
+
+def _merge_dict(base: dict[str, Any], patch: dict[str, Any]) -> dict[str, Any]:
+    merged = dict(base)
+    for key, value in patch.items():
+        if isinstance(value, dict) and isinstance(merged.get(key), dict):
+            merged[key] = _merge_dict(cast(dict[str, Any], merged[key]), value)
+        else:
+            merged[key] = value
+    return merged

glaip_sdk/client/run_rendering.py

@@ -172,6 +172,63 @@ class AgentRunRenderingManager:
         finished_monotonic = monotonic()
         return final_text, stats_usage, started_monotonic, finished_monotonic
 
+    async def _consume_event_stream(
+        self,
+        event_stream: AsyncIterable[dict[str, Any]],
+        renderer: RichStreamRenderer,
+        final_text: str,
+        stats_usage: dict[str, Any],
+        meta: dict[str, Any],
+        skip_final_render: bool,
+        last_rendered_content: str | None,
+        controller: Any | None,
+    ) -> tuple[str, dict[str, Any], float | None]:
+        """Consume event stream and update state.
+
+        Args:
+            event_stream: Async iterable yielding SSE-like event dicts.
+            renderer: Renderer to use for displaying events.
+            final_text: Current accumulated final text.
+            stats_usage: Usage statistics dictionary.
+            meta: Metadata dictionary.
+            skip_final_render: If True, skip rendering final_response events.
+            last_rendered_content: Last rendered content to avoid duplicates.
+            controller: Controller instance.
+
+        Returns:
+            Tuple of (final_text, stats_usage, started_monotonic).
+        """
+        started_monotonic: float | None = None
+
+        async for event in event_stream:
+            if started_monotonic is None:
+                started_monotonic = monotonic()
+
+            parsed_event = self._parse_event(event)
+            if parsed_event is None:
+                continue
+
+            final_text, stats_usage = self._handle_parsed_event(
+                parsed_event,
+                renderer,
+                final_text,
+                stats_usage,
+                meta,
+                skip_final_render=skip_final_render,
+                last_rendered_content=last_rendered_content,
+            )
+
+            content_str = self._extract_content_string(parsed_event)
+            if content_str:
+                last_rendered_content = content_str
+
+            if controller and getattr(controller, "enabled", False):
+                controller.poll(renderer)
+            if parsed_event and self._is_final_event(parsed_event):
+                break
+
+        return final_text, stats_usage, started_monotonic
+
     async def async_process_stream_events(
         self,
         event_stream: AsyncIterable[dict[str, Any]],
@@ -207,35 +264,25 @@ class AgentRunRenderingManager:
             controller.on_stream_start(renderer)
 
         try:
-            async for event in event_stream:
-                if started_monotonic is None:
-                    started_monotonic = monotonic()
-
-                # Parse event if needed (handles both raw SSE and pre-parsed dicts)
-                parsed_event = self._parse_event(event)
-                if parsed_event is None:
-                    continue
-
-                # Process the event and update accumulators
-                final_text, stats_usage = self._handle_parsed_event(
-                    parsed_event,
-                    renderer,
-                    final_text,
-                    stats_usage,
-                    meta,
-                    skip_final_render=skip_final_render,
-                    last_rendered_content=last_rendered_content,
-                )
-
-                # Track last rendered content to avoid duplicates
-                content_str = self._extract_content_string(parsed_event)
-                if content_str:
-                    last_rendered_content = content_str
-
-                if controller and getattr(controller, "enabled", False):
-                    controller.poll(renderer)
-                if parsed_event and self._is_final_event(parsed_event):
-                    break
+            final_text, stats_usage, started_monotonic = await self._consume_event_stream(
+                event_stream,
+                renderer,
+                final_text,
+                stats_usage,
+                meta,
+                skip_final_render,
+                last_rendered_content,
+                controller,
+            )
+        except Exception as e:
+            err_msg = str(e)
+            reason = getattr(getattr(e, "result", None), "reason", None)
+            if reason:
+                final_text = f"⚠️ Guardrail violation: {reason}"
+            elif "⚠️ Guardrail violation" in err_msg or "Content blocked by guardrails" in err_msg:
+                final_text = err_msg
+            else:
+                raise e
         finally:
             if controller and getattr(controller, "enabled", False):
                 controller.on_stream_complete()