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

glaip_sdk/cli/transcript/launcher.py

@@ -20,9 +20,7 @@ from glaip_sdk.cli.transcript.capture import StoredTranscriptContext
 from glaip_sdk.cli.transcript.viewer import ViewerContext, run_viewer_session
 
 
-def should_launch_post_run_viewer(
-    ctx: Any, console: Console, *, slash_mode: bool
-) -> bool:
+def should_launch_post_run_viewer(ctx: Any, console: Console, *, slash_mode: bool) -> bool:
     """Return True if the viewer should open automatically."""
     if slash_mode:
         return False

glaip_sdk/cli/transcript/viewer.py

@@ -6,16 +6,12 @@ Authors:
 
 from __future__ import annotations
 
-from collections.abc import Callable, Iterable
-from dataclasses import dataclass
-from datetime import datetime, timezone
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
 import click
 from rich.console import Console
-from rich.markdown import Markdown
-from rich.text import Text
 
 try:  # pragma: no cover - optional dependency
     import questionary
@@ -25,28 +21,20 @@ except Exception:  # pragma: no cover - optional dependency
     Choice = None  # type: ignore[assignment]
 
 from glaip_sdk.cli.transcript.cache import suggest_filename
-from glaip_sdk.icons import ICON_DELEGATE, ICON_TOOL_STEP
-from glaip_sdk.rich_components import AIPPanel
-from glaip_sdk.utils.rendering.renderer.debug import render_debug_event
-from glaip_sdk.utils.rendering.renderer.panels import create_final_panel
-from glaip_sdk.utils.rendering.renderer.progress import (
-    format_elapsed_time,
-    is_delegation_tool,
+from glaip_sdk.cli.utils import prompt_export_choice_questionary, questionary_safe_ask
+from glaip_sdk.utils.rendering.layout.progress import is_delegation_tool
+from glaip_sdk.utils.rendering.viewer import (
+    ViewerContext as PresenterViewerContext,
+    prepare_viewer_snapshot as presenter_prepare_viewer_snapshot,
+    render_post_run_view as presenter_render_post_run_view,
+    render_transcript_events as presenter_render_transcript_events,
+    render_transcript_view as presenter_render_transcript_view,
 )
 
 EXPORT_CANCELLED_MESSAGE = "[dim]Export cancelled.[/dim]"
 
 
-@dataclass(slots=True)
-class ViewerContext:
-    """Runtime context for the viewer session."""
-
-    manifest_entry: dict[str, Any]
-    events: list[dict[str, Any]]
-    default_output: str
-    final_output: str
-    stream_started_at: float | None
-    meta: dict[str, Any]
+ViewerContext = PresenterViewerContext
 
 
 class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
@@ -57,18 +45,18 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         console: Console,
         ctx: ViewerContext,
         export_callback: Callable[[Path], Path],
+        *,
+        initial_view: str = "default",
     ) -> None:
         """Initialize viewer state for a captured transcript."""
         self.console = console
         self.ctx = ctx
         self._export_callback = export_callback
-        self._view_mode = "default"
+        self._view_mode = initial_view if initial_view in {"default", "transcript"} else "default"
 
     def run(self) -> None:
         """Enter the interactive loop."""
-        if not self.ctx.events and not (
-            self.ctx.default_output or self.ctx.final_output
-        ):
+        if not self.ctx.events and not (self.ctx.default_output or self.ctx.final_output):
             return
         if self._view_mode == "transcript":
             self._render()
@@ -79,15 +67,14 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
     # Rendering helpers
     # ------------------------------------------------------------------
     def _render(self) -> None:
+        """Render the transcript viewer interface."""
         try:
             if self.console.is_terminal:
                 self.console.clear()
         except Exception:  # pragma: no cover - platform quirks
             pass
 
-        header = (
-            f"Agent transcript viewer · run {self.ctx.manifest_entry.get('run_id')}"
-        )
+        header = f"Agent transcript viewer · run {self.ctx.manifest_entry.get('run_id')}"
         agent_label = self.ctx.manifest_entry.get("agent_name") or "unknown agent"
         model = self.ctx.manifest_entry.get("model") or self.ctx.meta.get("model")
         agent_id = self.ctx.manifest_entry.get("agent_id")
@@ -103,66 +90,18 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
                 self.console.print(f"[dim]{' · '.join(subtitle_parts)}[/]")
             self.console.print()
 
-        query = self._get_user_query()
-
         if self._view_mode == "default":
-            self._render_default_view(query)
+            presenter_render_post_run_view(self.console, self.ctx)
         else:
-            self._render_transcript_view(query)
-
-    def _render_default_view(self, query: str | None) -> None:
-        if query:
-            self._render_user_query(query)
-        self._render_steps_summary()
-        self._render_final_panel()
-
-    def _render_transcript_view(self, query: str | None) -> None:
-        if not self.ctx.events:
-            self.console.print("[dim]No SSE events were captured for this run.[/dim]")
-            return
-
-        if query:
-            self._render_user_query(query)
-
-        self._render_steps_summary()
-        self._render_final_panel()
-
-        self.console.print("[bold]Transcript Events[/bold]")
-        self.console.print(
-            "[dim]────────────────────────────────────────────────────────[/dim]"
-        )
-
-        base_received_ts: datetime | None = None
-        for event in self.ctx.events:
-            received_ts = self._parse_received_timestamp(event)
-            if base_received_ts is None and received_ts is not None:
-                base_received_ts = received_ts
-            render_debug_event(
-                event,
-                self.console,
-                received_ts=received_ts,
-                baseline_ts=base_received_ts,
-            )
-        self.console.print()
-
-    def _render_final_panel(self) -> None:
-        content = (
-            self.ctx.final_output
-            or self.ctx.default_output
-            or "No response content captured."
-        )
-        title = "Final Result"
-        duration_text = self._extract_final_duration()
-        if duration_text:
-            title += f" · {duration_text}"
-        panel = create_final_panel(content, title=title, theme="dark")
-        self.console.print(panel)
-        self.console.print()
+            snapshot, state = presenter_prepare_viewer_snapshot(self.ctx, glyphs=None)
+            presenter_render_transcript_view(self.console, snapshot)
+            presenter_render_transcript_events(self.console, state.events)
 
     # ------------------------------------------------------------------
     # Interaction loops
     # ------------------------------------------------------------------
     def _fallback_loop(self) -> None:
+        """Fallback interaction loop for non-interactive terminals."""
         while True:
             try:
                 ch = click.getchar()
@@ -183,6 +122,14 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
                 continue
 
     def _handle_command(self, raw: str) -> bool:
+        """Handle a command input.
+
+        Args:
+            raw: Raw command string.
+
+        Returns:
+            True to continue, False to exit.
+        """
         lowered = raw.lower()
         if lowered in {"exit", "quit", "q"}:
             return True
@@ -212,9 +159,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
             raw = str(path)
             return raw if len(raw) <= 80 else f"…{raw[-77:]}"
 
-        selection = self._prompt_export_choice(
-            default_path, _display_path(default_path)
-        )
+        selection = self._prompt_export_choice(default_path, _display_path(default_path))
         if selection is None:
             self._legacy_export_prompt(default_path, _display_path)
             return
@@ -240,42 +185,12 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         except Exception as exc:  # pragma: no cover - unexpected IO failures
             self.console.print(f"[red]Failed to export transcript: {exc}[/red]")
 
-    def _prompt_export_choice(
-        self, default_path: Path, default_display: str
-    ) -> tuple[str, Any] | None:
+    def _prompt_export_choice(self, default_path: Path, default_display: str) -> tuple[str, Any] | None:
         """Render interactive export menu with numeric shortcuts."""
-        if not self.console.is_terminal or questionary is None or Choice is None:
-            return None
-
-        try:
-            answer = questionary.select(
-                "Export transcript",
-                choices=[
-                    Choice(
-                        title=f"Save to default ({default_display})",
-                        value=("default", default_path),
-                        shortcut_key="1",
-                    ),
-                    Choice(
-                        title="Choose a different path",
-                        value=("custom", None),
-                        shortcut_key="2",
-                    ),
-                    Choice(
-                        title="Cancel",
-                        value=("cancel", None),
-                        shortcut_key="3",
-                    ),
-                ],
-                use_shortcuts=True,
-                instruction="Press 1-3 (or arrows) then Enter.",
-            ).ask()
-        except Exception:
+        if not self.console.is_terminal:
             return None
 
-        if answer is None:
-            return ("cancel", None)
-        return answer
+        return prompt_export_choice_questionary(default_path, default_display)
 
     def _prompt_custom_destination(self) -> Path | None:
         """Prompt for custom export path with filesystem completion."""
@@ -283,11 +198,12 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
             return None
 
         try:
-            response = questionary.path(
+            question = questionary.path(
                 "Destination path (Tab to autocomplete):",
                 default="",
                 only_directories=False,
-            ).ask()
+            )
+            response = questionary_safe_ask(question)
         except Exception:
             return None
 
@@ -299,9 +215,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
             candidate = Path.cwd() / candidate
         return candidate
 
-    def _legacy_export_prompt(
-        self, default_path: Path, formatter: Callable[[Path], str]
-    ) -> None:
+    def _legacy_export_prompt(self, default_path: Path, formatter: Callable[[Path], str]) -> None:
         """Fallback export workflow when interactive UI is unavailable."""
         self.console.print("[dim]Export options (fallback mode)[/dim]")
         self.console.print(f"  1. Save to default ({formatter(default_path)})")
@@ -347,176 +261,22 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
             self.console.print(f"[red]Failed to export transcript: {exc}[/red]")
 
     def _print_command_hint(self) -> None:
-        self.console.print(
-            "[dim]Ctrl+T to toggle transcript · type `e` to export · press Enter to exit[/dim]"
-        )
-        self.console.print()
-
-    def _get_user_query(self) -> str | None:
-        meta = self.ctx.meta or {}
-        manifest = self.ctx.manifest_entry or {}
-        return (
-            meta.get("input_message")
-            or meta.get("query")
-            or meta.get("message")
-            or manifest.get("input_message")
-        )
-
-    def _render_user_query(self, query: str) -> None:
-        panel = AIPPanel(
-            Markdown(f"Query: {query}"),
-            title="User Request",
-            border_style="#d97706",
-        )
-        self.console.print(panel)
+        """Print command hint for user interaction."""
+        self.console.print("[dim]Ctrl+T to toggle transcript · type `e` to export · press Enter to exit[/dim]")
         self.console.print()
 
-    def _render_steps_summary(self) -> None:
-        panel_content = self._format_steps_summary(self._build_step_summary())
-        panel = AIPPanel(
-            Text(panel_content, style="dim"),
-            title="Steps",
-            border_style="blue",
-        )
-        self.console.print(panel)
-        self.console.print()
-
-    @staticmethod
-    def _format_steps_summary(steps: list[dict[str, Any]]) -> str:
-        if not steps:
-            return "  No steps yet"
-
-        lines = []
-        for step in steps:
-            icon = ICON_DELEGATE if step.get("is_delegate") else ICON_TOOL_STEP
-            duration = step.get("duration")
-            duration_str = f" [{duration}]" if duration else ""
-            status = " ✓" if step.get("finished") else ""
-            title = step.get("title") or step.get("name") or "Step"
-            lines.append(f"  {icon} {title}{duration_str}{status}")
-        return "\n".join(lines)
-
-    @staticmethod
-    def _extract_event_time(event: dict[str, Any]) -> float | None:
-        metadata = event.get("metadata") or {}
-        time_value = metadata.get("time")
-        try:
-            if isinstance(time_value, (int, float)):
-                return float(time_value)
-        except Exception:
-            return None
-        return None
-
-    @staticmethod
-    def _parse_received_timestamp(event: dict[str, Any]) -> datetime | None:
-        value = event.get("received_at")
-        if not value:
-            return None
-        if isinstance(value, str):
-            try:
-                normalised = value.replace("Z", "+00:00")
-                parsed = datetime.fromisoformat(normalised)
-            except ValueError:
-                return None
-            return parsed if parsed.tzinfo else parsed.replace(tzinfo=timezone.utc)
-        return None
-
-    def _extract_final_duration(self) -> str | None:
-        for event in self.ctx.events:
-            metadata = event.get("metadata") or {}
-            if metadata.get("kind") == "final_response":
-                time_value = metadata.get("time")
-                try:
-                    if isinstance(time_value, (int, float)):
-                        return f"{float(time_value):.2f}s"
-                except Exception:
-                    return None
-        return None
-
-    def _build_step_summary(self) -> list[dict[str, Any]]:
-        stored = self.ctx.meta.get("transcript_steps")
-        if isinstance(stored, list) and stored:
-            return [
-                {
-                    "title": entry.get("display_name") or entry.get("name") or "Step",
-                    "is_delegate": entry.get("kind") == "delegate",
-                    "finished": entry.get("status") == "finished",
-                    "duration": self._format_duration_from_ms(entry.get("duration_ms")),
-                }
-                for entry in stored
-            ]
-
-        steps: dict[str, dict[str, Any]] = {}
-        order: list[str] = []
-
-        for event in self.ctx.events:
-            metadata = event.get("metadata") or {}
-            if not self._is_step_event(metadata):
-                continue
-
-            for name, info in self._iter_step_candidates(event, metadata):
-                step = self._ensure_step_entry(steps, order, name)
-                self._apply_step_update(step, metadata, info, event)
-
-        return [steps[name] for name in order]
-
-    @staticmethod
-    def _format_duration_from_ms(value: Any) -> str | None:
-        try:
-            if value is None:
-                return None
-            duration_ms = float(value)
-        except Exception:
-            return None
-
-        if duration_ms <= 0:
-            return "<1ms"
-        if duration_ms < 1000:
-            return f"{int(duration_ms)}ms"
-        return f"{duration_ms / 1000:.2f}s"
-
-    @staticmethod
-    def _is_step_event(metadata: dict[str, Any]) -> bool:
-        kind = metadata.get("kind")
-        return kind in {"agent_step", "agent_thinking_step"}
-
-    def _iter_step_candidates(
-        self, event: dict[str, Any], metadata: dict[str, Any]
-    ) -> Iterable[tuple[str, dict[str, Any]]]:
-        tool_info = metadata.get("tool_info") or {}
-
-        yielded = False
-        for candidate in self._iter_tool_call_candidates(tool_info):
-            yielded = True
-            yield candidate
-
-        if yielded:
-            return
-
-        direct_tool = self._extract_direct_tool(tool_info)
-        if direct_tool is not None:
-            yield direct_tool
-            return
-
-        completed = self._extract_completed_name(event)
-        if completed is not None:
-            yield completed, {}
-
-    @staticmethod
-    def _iter_tool_call_candidates(
-        tool_info: dict[str, Any],
-    ) -> Iterable[tuple[str, dict[str, Any]]]:
-        tool_calls = tool_info.get("tool_calls")
-        if isinstance(tool_calls, list):
-            for call in tool_calls:
-                name = call.get("name")
-                if name:
-                    yield name, call
-
     @staticmethod
     def _extract_direct_tool(
         tool_info: dict[str, Any],
     ) -> tuple[str, dict[str, Any]] | None:
+        """Extract direct tool from tool_info.
+
+        Args:
+            tool_info: Tool info dictionary.
+
+        Returns:
+            Tuple of (tool_name, tool_info) or None.
+        """
         if isinstance(tool_info, dict):
             name = tool_info.get("name")
             if name:
@@ -525,6 +285,14 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
 
     @staticmethod
     def _extract_completed_name(event: dict[str, Any]) -> str | None:
+        """Extract completed tool name from event content.
+
+        Args:
+            event: Event dictionary.
+
+        Returns:
+            Tool name or None.
+        """
         content = event.get("content") or ""
         if isinstance(content, str) and content.startswith("Completed "):
             name = content.replace("Completed ", "").strip()
@@ -538,6 +306,16 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         order: list[str],
         name: str,
     ) -> dict[str, Any]:
+        """Ensure step entry exists, creating if needed.
+
+        Args:
+            steps: Steps dictionary.
+            order: Order list.
+            name: Step name.
+
+        Returns:
+            Step dictionary.
+        """
         if name not in steps:
             steps[name] = {
                 "name": name,
@@ -557,14 +335,18 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         info: dict[str, Any],
         event: dict[str, Any],
     ) -> None:
+        """Apply update to step from event metadata.
+
+        Args:
+            step: Step dictionary to update.
+            metadata: Event metadata.
+            info: Step info dictionary.
+            event: Event dictionary.
+        """
         status = metadata.get("status")
         event_time = metadata.get("time")
 
-        if (
-            status == "running"
-            and step.get("started_at") is None
-            and isinstance(event_time, (int, float))
-        ):
+        if status == "running" and step.get("started_at") is None and isinstance(event_time, (int, float)):
             try:
                 step["started_at"] = float(event_time)
             except Exception:
@@ -577,48 +359,14 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         if duration is not None:
             step["duration"] = duration
 
-    @staticmethod
-    def _is_step_finished(metadata: dict[str, Any], event: dict[str, Any]) -> bool:
-        status = metadata.get("status")
-        return status == "finished" or bool(event.get("final"))
-
-    def _compute_step_duration(
-        self, step: dict[str, Any], info: dict[str, Any], metadata: dict[str, Any]
-    ) -> str | None:
-        """Calculate a formatted duration string for a step if possible."""
-        event_time = metadata.get("time")
-        started_at = step.get("started_at")
-        duration_value: float | None = None
-
-        if isinstance(event_time, (int, float)) and isinstance(
-            started_at, (int, float)
-        ):
-            try:
-                delta = float(event_time) - float(started_at)
-                if delta >= 0:
-                    duration_value = delta
-            except Exception:
-                duration_value = None
-
-        if duration_value is None:
-            exec_time = info.get("execution_time")
-            if isinstance(exec_time, (int, float)):
-                duration_value = float(exec_time)
-
-        if duration_value is None:
-            return None
-
-        try:
-            return format_elapsed_time(duration_value)
-        except Exception:
-            return None
-
 
 def run_viewer_session(
     console: Console,
     ctx: ViewerContext,
     export_callback: Callable[[Path], Path],
+    *,
+    initial_view: str = "default",
 ) -> None:
     """Entry point for creating and running the post-run viewer."""
-    viewer = PostRunViewer(console, ctx, export_callback)
+    viewer = PostRunViewer(console, ctx, export_callback, initial_view=initial_view)
     viewer.run()