glaip-sdk 0.6.5b3__py3-none-any.whl → 0.7.17__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,18 @@ class SlashSession:
                 self._run_non_interactive(initial_commands)
                 return
 
-            if not self._ensure_configuration():
+            # 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 +279,283 @@ 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
+
+        # Task 3: Updates.
+        current_status[0] = "Checking for updates..."
+        if status_callback:
+            status_callback(current_status[0])
+        # Defer update prompt if we are in animated initialization to avoid blocking/cluttering
+        self._maybe_show_update_prompt(defer=bool(status_callback is None))
+        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)
+
+        # Run initialization tasks.
+        if not self._run_initialization_tasks(state.current_status, state.animation_running, status_callback=None):
+            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:
@@ -548,7 +863,7 @@ class SlashSession:
         try:
             # Use the modern account-aware wizard directly (bypasses legacy config gating)
             _configure_interactive(account_name=None)
-            self._config_cache = None
+            self.on_account_switched()
             if self._suppress_login_layout:
                 self._welcome_rendered = False
                 self._default_actions_shown = False
@@ -1211,6 +1526,33 @@ class SlashSession:
             self._client = get_client(self.ctx)
         return self._client
 
+    def on_account_switched(self, _account_name: str | None = None) -> None:
+        """Reset any state that depends on the active account.
+
+        The active account can change via `/accounts` (or other flows that call
+        AccountStore.set_active_account). The slash session caches a configured
+        client instance, so we must invalidate it to avoid leaking the previous
+        account's API URL/key into subsequent commands like `/agents` or `/runs`.
+
+        This method clears:
+        - Client and config cache (account-specific credentials)
+        - Current agent and recent agents (agent data is account-scoped)
+        - Runs pagination state (runs are account-scoped)
+        - Active renderer and transcript ready state (UI state tied to account context)
+        - Contextual commands (may be account-specific)
+
+        These broader resets ensure a clean slate when switching accounts, preventing
+        stale data from the previous account from appearing in the new account's context.
+        """
+        self._client = None
+        self._config_cache = None
+        self._current_agent = None
+        self.recent_agents = []
+        self._runs_pagination_state.clear()
+        self.clear_active_renderer()
+        self.clear_agent_transcript_ready()
+        self.set_contextual_commands(None)
+
     def set_contextual_commands(self, commands: dict[str, str] | None, *, include_global: bool = True) -> None:
         """Set context-specific commands that should appear in completions."""
         self._contextual_commands = dict(commands or {})
@@ -1246,6 +1588,7 @@ class SlashSession:
         *,
         focus_agent: bool = False,
         initial: bool = False,
+        show_branding: bool = True,
     ) -> None:
         """Render the session header with branding and status.
 
@@ -1253,14 +1596,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:
@@ -1270,14 +1615,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(
@@ -1340,14 +1688,16 @@ class SlashSession:
             f"[{ACCENT_STYLE}]{agent_info['id']}[/]"
         )
         status_line = f"[{SUCCESS_STYLE}]ready[/]"
-        status_line += " · transcript ready" if transcript_status["transcript_ready"] else " · transcript pending"
+        if not transcript_status["has_transcript"]:
+            status_line += " · no transcript"
+        elif transcript_status["transcript_ready"]:
+            status_line += " · transcript ready"
+        else:
+            status_line += " · transcript pending"
         header_grid.add_row(primary_line, status_line)
 
         if agent_info["description"]:
-            description = agent_info["description"]
-            if not transcript_status["transcript_ready"]:
-                description = f"{description}  (transcript pending)"
-            header_grid.add_row(f"[dim]{description}[/dim]", "")
+            header_grid.add_row(f"[dim]{agent_info['description']}[/dim]", "")
 
         return header_grid
 

glaip_sdk/cli/slash/tui/__init__.py

@@ -1,9 +1,36 @@
 """Textual UI helpers for slash commands."""
 
+from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter, ClipboardResult
+from glaip_sdk.cli.slash.tui.context import TUIContext
+from glaip_sdk.cli.slash.tui.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",
+    "ClipboardResult",
+    "PulseIndicator",
+]