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

glaip_sdk/cli/slash/session.py

@@ -6,10 +6,13 @@ Authors:
 
 from __future__ import annotations
 
+import asyncio
 import importlib
 import os
 import shlex
 import sys
+import threading
+import time
 from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from difflib import get_close_matches
@@ -18,6 +21,7 @@ from typing import Any
 
 import click
 from rich.console import Console, Group
+from rich.live import Live
 from rich.text import Text
 
 from glaip_sdk.branding import (
@@ -32,16 +36,20 @@ from glaip_sdk.branding import (
     SUCCESS_STYLE,
     WARNING_STYLE,
     AIPBranding,
+    LogoAnimator,
 )
-from glaip_sdk.cli.auth import resolve_api_url_from_context
 from glaip_sdk.cli.account_store import get_account_store
+from glaip_sdk.cli.auth import resolve_api_url_from_context
 from glaip_sdk.cli.commands import transcripts as transcripts_cmd
 from glaip_sdk.cli.commands.configure import _configure_interactive, load_config
 from glaip_sdk.cli.commands.update import update_command
-from glaip_sdk.cli.hints import format_command_hint
+from glaip_sdk.cli.core.context import get_client, restore_slash_session_context
+from glaip_sdk.cli.core.output import format_size
+from glaip_sdk.cli.core.prompting import _fuzzy_pick_for_resources
+from glaip_sdk.cli.hints import command_hint, format_command_hint
 from glaip_sdk.cli.slash.accounts_controller import AccountsController
-from glaip_sdk.cli.slash.agent_session import AgentRunSession
 from glaip_sdk.cli.slash.accounts_shared import env_credentials_present
+from glaip_sdk.cli.slash.agent_session import AgentRunSession
 from glaip_sdk.cli.slash.prompt import (
     FormattedText,
     PromptSession,
@@ -51,19 +59,13 @@ 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,
 )
 from glaip_sdk.cli.transcript.viewer import ViewerContext, run_viewer_session
 from glaip_sdk.cli.update_notifier import maybe_notify_update
-from glaip_sdk.cli.utils import (
-    _fuzzy_pick_for_resources,
-    command_hint,
-    format_size,
-    get_client,
-    restore_slash_session_context,
-)
 from glaip_sdk.rich_components import AIPGrid, AIPPanel, AIPTable
 
 SlashHandler = Callable[["SlashSession", list[str], bool], bool]
@@ -145,6 +147,22 @@ def _quick_action_scope(action: dict[str, Any]) -> str:
     return "global"
 
 
+@dataclass
+class AnimationState:
+    """State for logo animation shared between threads.
+
+    Uses mutable lists for integer values to allow thread-safe updates
+    without requiring locks or atomic operations.
+    """
+
+    pulse_step: list[int]  # Current animation step position
+    pulse_direction: list[int]  # Direction of pulse (1 or -1)
+    step_size: list[int]  # Step size for animation
+    current_status: list[str]  # Current status message
+    animation_running: threading.Event  # Event signaling animation is running
+    stop_requested: threading.Event  # Event signaling stop was requested
+
+
 class SlashSession:
     """Interactive command palette controller."""
 
@@ -156,7 +174,11 @@ class SlashSession:
             console: Optional console instance, creates default if None
         """
         self.ctx = ctx
-        self.console = console or Console()
+        self._interactive = bool(sys.stdin.isatty() and sys.stdout.isatty())
+        if console is None:
+            self.console = AIPBranding._make_console(force_terminal=self._interactive, soft_wrap=False)
+        else:
+            self.console = console
         self._commands: dict[str, SlashCommand] = {}
         self._unique_commands: dict[str, SlashCommand] = {}
         self._contextual_commands: dict[str, str] = {}
@@ -165,7 +187,6 @@ class SlashSession:
         self.recent_agents: list[dict[str, str]] = []
         self.last_run_input: str | None = None
         self._should_exit = False
-        self._interactive = bool(sys.stdin.isatty() and sys.stdout.isatty())
         self._config_cache: dict[str, Any] | None = None
         self._welcome_rendered = False
         self._active_renderer: Any | None = None
@@ -189,6 +210,16 @@ 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
+
+    # Animation configuration constants
+    ANIMATION_FPS = 20
+    ANIMATION_FRAME_DURATION = 1.0 / ANIMATION_FPS  # 0.05 seconds
+    ANIMATION_STARTUP_DELAY = 0.1  # Delay to ensure animation starts
+
+    # Startup UI constants
+    INITIALIZING_STATUS = "Initializing..."
+    CLI_HEADING_MARKUP = "[bold]>_ GDP Labs AI Agents Package (AIP CLI)[/bold]"
 
     # ------------------------------------------------------------------
     # Session orchestration
@@ -229,11 +260,19 @@ class SlashSession:
                 self._run_non_interactive(initial_commands)
                 return
 
-            if not self._ensure_configuration():
+            self._maybe_show_update_prompt()
+            # Use animated logo during initialization if supported
+            animator = LogoAnimator(console=self.console)
+            if animator.should_animate() and self._interactive:
+                config_available = self._run_with_animated_logo(animator)
+            else:
+                # Fallback to static logo for non-TTY or NO_COLOR
+                config_available = self._run_with_static_logo(animator)
+
+            if not config_available:
                 return
 
-            self._maybe_show_update_prompt()
-            self._render_header(initial=not self._welcome_rendered)
+            self._render_header(initial=not self._welcome_rendered, show_branding=False)
             if not self._default_actions_shown:
                 self._show_default_quick_actions()
             self._run_interactive_loop()
@@ -241,6 +280,284 @@ class SlashSession:
             if ctx_obj is not None:
                 restore_slash_session_context(ctx_obj, previous_session)
 
+    def _initialize_tui_context(self) -> None:
+        """Initialize TUI context with error handling.
+
+        Sets self.tui_ctx to None if initialization fails.
+        """
+        try:
+            self.tui_ctx = asyncio.run(TUIContext.create(detect_osc11=False))
+        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(detect_osc11=False))
+        except Exception:
+            self.tui_ctx = None
+
+    def _run_initialization_tasks(
+        self,
+        current_status: list[str],
+        animation_running: threading.Event,
+        status_callback: Callable[[str], None] | None = None,
+    ) -> bool:
+        """Run initialization tasks with status updates.
+
+        Args:
+            current_status: Mutable list with current status message.
+            animation_running: Event to signal animation state.
+            status_callback: Optional callback to invoke when status changes.
+
+        Returns:
+            True if configuration is available, False otherwise.
+        """
+        # Task 1: TUI Context.
+        current_status[0] = "Detecting terminal..."
+        if status_callback:
+            status_callback(current_status[0])
+        self._initialize_tui_context()
+
+        # Task 2: Configuration.
+        current_status[0] = "Connecting to API..."
+        if status_callback:
+            status_callback(current_status[0])
+        if not self._ensure_configuration():
+            animation_running.clear()
+            return False
+
+        return True
+
+    def _update_pulse_step(
+        self,
+        state: AnimationState,
+        animator: LogoAnimator,
+    ) -> bool:
+        """Update pulse step and direction.
+
+        Args:
+            state: Animation state container.
+            animator: LogoAnimator instance for animation.
+
+        Returns:
+            True if animation should continue, False if should stop.
+        """
+        state.pulse_step[0] += state.pulse_direction[0] * state.step_size[0]
+        if state.pulse_step[0] >= animator.max_width + 5:
+            state.pulse_step[0] = animator.max_width + 5
+            state.pulse_direction[0] = -1
+            return not state.stop_requested.is_set()
+        if state.pulse_step[0] <= -5:
+            state.pulse_step[0] = -5
+            state.pulse_direction[0] = 1
+            return not state.stop_requested.is_set()
+        return True
+
+    def _create_animation_updater(
+        self,
+        animator: LogoAnimator,
+        state: AnimationState,
+        heading: Text,
+    ) -> Callable[[Live], None]:
+        """Create animation update function for background thread.
+
+        Args:
+            animator: LogoAnimator instance for animation.
+            state: Animation state container.
+            heading: Text heading for frames.
+
+        Returns:
+            Function to update animation in background thread.
+        """
+
+        def build_frame(step: int, status_text: str) -> Group:
+            return Group(heading, Text(""), animator.generate_frame(step, status_text))
+
+        def update_animation(live: Live) -> None:
+            """Update animation in background thread."""
+            while state.animation_running.is_set():
+                # Calculate next step
+                if not self._update_pulse_step(state, animator):
+                    break
+
+                # Update frame with current status
+                try:
+                    live.update(build_frame(state.pulse_step[0], state.current_status[0]))
+                except Exception:
+                    # Animation may be stopped, ignore errors
+                    break
+                time.sleep(self.ANIMATION_FRAME_DURATION)
+            state.animation_running.clear()
+
+        return update_animation
+
+    def _stop_animation_thread(
+        self,
+        animation_thread: threading.Thread,
+        state: AnimationState,
+    ) -> None:
+        """Stop animation thread gracefully.
+
+        Args:
+            animation_thread: Thread running animation.
+            state: Animation state container.
+        """
+        state.stop_requested.set()
+        state.step_size[0] = 3
+        animation_thread.join(timeout=1.5)
+        if animation_thread.is_alive():
+            state.animation_running.clear()
+            animation_thread.join(timeout=0.2)
+
+    def _run_animated_initialization(
+        self,
+        live: Live,
+        animator: LogoAnimator,
+        state: AnimationState,
+        heading: Text,
+        banner: Text,
+    ) -> bool:
+        """Run initialization tasks with animated logo.
+
+        Args:
+            live: Live context for animation updates.
+            animator: LogoAnimator instance for animation.
+            state: Animation state container.
+            heading: Text heading for frames.
+            banner: Text banner for final display.
+
+        Returns:
+            True if configuration is available, False otherwise.
+        """
+
+        def build_banner() -> Group:
+            return Group(heading, Text(""), banner)
+
+        update_animation = self._create_animation_updater(
+            animator,
+            state,
+            heading,
+        )
+
+        # Start animation thread.
+        animation_thread = threading.Thread(target=update_animation, args=(live,), daemon=True)
+        animation_thread.start()
+
+        # Small delay to ensure animation starts.
+        time.sleep(self.ANIMATION_STARTUP_DELAY)
+
+        def update_status(status: str) -> None:
+            state.current_status[0] = status
+
+        # Run initialization tasks.
+        if not self._run_initialization_tasks(
+            state.current_status,
+            state.animation_running,
+            status_callback=update_status,
+        ):
+            return False
+
+        # Stop animation and show final banner.
+        self._stop_animation_thread(animation_thread, state)
+        live.update(build_banner())
+        return True
+
+    def _run_with_animated_logo(self, animator: LogoAnimator) -> bool:
+        """Run initialization with animated logo.
+
+        Args:
+            animator: LogoAnimator instance for animation.
+
+        Returns:
+            True if configuration is available, False otherwise.
+        """
+        state = AnimationState(
+            pulse_step=[0],  # Use list for mutable shared state.
+            pulse_direction=[1],  # Use list for mutable shared state.
+            step_size=[1],
+            current_status=[self.INITIALIZING_STATUS],
+            animation_running=threading.Event(),
+            stop_requested=threading.Event(),
+        )
+        state.animation_running.set()
+        heading = Text.from_markup(self.CLI_HEADING_MARKUP)
+        banner = Text.from_markup(self._branding.get_welcome_banner())
+
+        def build_frame(step: int, status_text: str) -> Group:
+            return Group(heading, Text(""), animator.generate_frame(step, status_text))
+
+        try:
+            with Live(
+                build_frame(0, state.current_status[0]),
+                console=self.console,
+                refresh_per_second=self.ANIMATION_FPS,
+                transient=False,
+            ) as live:
+                return self._run_animated_initialization(
+                    live,
+                    animator,
+                    state,
+                    heading,
+                    banner,
+                )
+        except KeyboardInterrupt:
+            # Graceful exit on Ctrl+C
+            state.animation_running.clear()
+            # Align with static path: show heading and cancellation message
+            heading = Text.from_markup(self.CLI_HEADING_MARKUP)
+            self.console.print(Group(heading, Text(""), animator.static_frame("Initialization cancelled.")))
+            return False
+
+    def _run_with_static_logo(self, animator: LogoAnimator) -> bool:
+        """Run initialization with static logo (non-TTY or NO_COLOR).
+
+        Args:
+            animator: LogoAnimator instance for static display.
+
+        Returns:
+            True if configuration is available, False otherwise.
+        """
+        heading = Text.from_markup(self.CLI_HEADING_MARKUP)
+        banner = Text.from_markup(self._branding.get_welcome_banner())
+
+        def build_frame(status_text: str) -> Group:
+            return Group(heading, Text(""), animator.static_frame(status_text))
+
+        def build_banner() -> Group:
+            return Group(heading, Text(""), banner)
+
+        try:
+            with Live(
+                build_frame(self.INITIALIZING_STATUS),
+                console=self.console,
+                refresh_per_second=4,
+                transient=False,
+            ) as live:
+                # Run initialization tasks with status updates, reusing shared logic.
+                current_status = [self.INITIALIZING_STATUS]
+                animation_running = threading.Event()
+                animation_running.set()
+
+                # Update Live display when status changes via callback.
+                def update_display(status: str) -> None:
+                    """Update Live display with current status."""
+                    live.update(build_frame(status))
+
+                if not self._run_initialization_tasks(
+                    current_status, animation_running, status_callback=update_display
+                ):
+                    return False
+
+                live.update(build_banner())
+                return True
+        except KeyboardInterrupt:
+            self.console.print(Group(heading, Text(""), animator.static_frame("Initialization cancelled.")))
+            return False
+
     def _run_interactive_loop(self) -> None:
         """Run the main interactive command loop."""
         while not self._should_exit:
@@ -900,7 +1217,7 @@ class SlashSession:
         self._register(
             SlashCommand(
                 name="accounts",
-                help="✨ NEW · Browse and switch stored accounts (Textual with Rich fallback).",
+                help="✨ NEW · Browse and switch stored accounts.",
                 handler=SlashSession._cmd_accounts,
             )
         )
@@ -1273,6 +1590,7 @@ class SlashSession:
         *,
         focus_agent: bool = False,
         initial: bool = False,
+        show_branding: bool = True,
     ) -> None:
         """Render the session header with branding and status.
 
@@ -1280,14 +1598,16 @@ class SlashSession:
             active_agent: Optional active agent to display.
             focus_agent: Whether to focus on agent display.
             initial: Whether this is the initial render.
+            show_branding: Whether to render the branding banner.
         """
         if focus_agent and active_agent is not None:
             self._render_focused_agent_header(active_agent)
             return
 
         full_header = initial or not self._welcome_rendered
-        if full_header:
+        if full_header and show_branding:
             self._render_branding_banner()
+        if full_header:
             self.console.rule(style=PRIMARY)
         self._render_main_header(active_agent, full=full_header)
         if full_header:
@@ -1297,14 +1617,17 @@ class SlashSession:
     def _render_branding_banner(self) -> None:
         """Render the GL AIP branding banner."""
         banner = self._branding.get_welcome_banner()
-        heading = "[bold]>_ GDP Labs AI Agents Package (AIP CLI)[/bold]"
+        heading = self.CLI_HEADING_MARKUP
         self.console.print(heading)
         self.console.print()
         self.console.print(banner)
 
-    def _maybe_show_update_prompt(self) -> None:
+    def _maybe_show_update_prompt(self, *, defer: bool = False) -> None:
         """Display update prompt once per session when applicable."""
-        if self._update_prompt_shown:
+        if self._update_prompt_shown or (defer and not self._update_prompt_shown):
+            if defer:
+                # Just mark as ready to show, but don't show yet
+                return
             return
 
         self._update_notifier(

glaip_sdk/cli/slash/tui/__init__.py

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

glaip_sdk/cli/slash/tui/accounts.tcss

@@ -3,6 +3,18 @@
  * Keep layout compact: filter sits tight above the table; header shows active account.
  */
 
+Screen {
+    layers: base toasts;
+}
+
+#toast-container {
+    width: 100%;
+    height: auto;
+    dock: top;
+    align: right top;
+    layer: toasts;
+}
+
 #header-info {
     padding: 0 1 0 1;
     margin: 0;
@@ -11,7 +23,7 @@
 
 #env-lock {
     padding: 0 1 0 1;
-    color: yellow;
+    color: $warning;
     height: 1;
 }
 
@@ -41,10 +53,23 @@
     margin-left: 1;
 }
 
+Button:hover {
+    background: $surface-lighten-1;
+}
+
 #accounts-table {
     padding: 0 1 0 1;
     margin: 0 0 0 0;
     height: 1fr;
+    border: tall $primary;
+}
+
+#accounts-table > .datatable--row:hover {
+    background: $surface-lighten-1;
+}
+
+.sidebar-block:hover {
+    background: $surface-lighten-1;
 }
 
 #status-bar {
@@ -54,15 +79,15 @@
 
 #accounts-loading {
     width: 8;
-    display: none;
 }
 
 #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 +98,7 @@
 
 #form-status, #confirm-status {
     padding: 0 1;
-    color: yellow;
+    color: $warning;
 }
 
 #form-test {
@@ -84,3 +109,69 @@
 #form-actions {
     margin: 0 1 0 1;
 }
+
+/* Harlequin Layout Styling */
+
+#left-pane-title, #right-pane-title {
+    padding: 1;
+    text-style: bold;
+    border-bottom: solid $primary;
+    height: 3;
+}
+
+#harlequin-filter {
+    padding: 0 1;
+    margin: 1;
+    height: 3;
+}
+
+#harlequin-accounts-list {
+    padding: 0 1;
+    margin: 1;
+    height: 1fr;
+}
+
+#left-content {
+    height: 100%;
+}
+
+#right-content {
+    padding: 1;
+    height: 100%;
+}
+
+.detail-label {
+    padding: 0 1 0 0;
+    text-style: bold;
+    width: 12;
+}
+
+#detail-fields {
+    padding: 1 0;
+    height: auto;
+}
+
+#harlequin-detail-url,
+#harlequin-detail-key,
+#harlequin-detail-status {
+    padding: 0 1;
+    margin-bottom: 1;
+}
+
+#harlequin-detail-actions {
+    padding: 1 0;
+    margin-top: 1;
+    height: auto;
+}
+
+#harlequin-loading {
+    width: auto;
+    height: 3;
+    padding: 0 1;
+}
+
+#harlequin-status {
+    padding: 1;
+    margin-top: 1;
+    height: auto;
+}