glaip-sdk 0.2.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

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,34 +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_AGENT, ICON_DELEGATE, ICON_TOOL_STEP
-from glaip_sdk.rich_components import AIPPanel
-from glaip_sdk.utils.rendering.formatting import (
-    build_connector_prefix,
-    glyph_for_status,
-    normalise_display_label,
+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,
 )
-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.utils.rendering.steps import StepManager
 
 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
@@ -108,66 +90,12 @@ 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:
-        """Render the default summary view.
-
-        Args:
-            query: Optional user query to display.
-        """
-        if query:
-            self._render_user_query(query)
-        self._render_steps_summary()
-        self._render_final_panel()
-
-    def _render_transcript_view(self, query: str | None) -> None:
-        """Render the full transcript view with events.
-
-        Args:
-            query: Optional user query to display.
-        """
-        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:
-        """Render the final result panel."""
-        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
@@ -259,38 +187,10 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
 
     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."""
@@ -298,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
 
@@ -364,523 +265,6 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         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:
-        """Extract user query from metadata or manifest.
-
-        Returns:
-            User query string or 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:
-        """Render user query in a panel.
-
-        Args:
-            query: User query string to render.
-        """
-        panel = AIPPanel(
-            Markdown(f"Query: {query}"),
-            title="User Request",
-            border_style="#d97706",
-        )
-        self.console.print(panel)
-        self.console.print()
-
-    def _render_steps_summary(self) -> None:
-        """Render steps summary panel."""
-        stored_lines = self.ctx.meta.get("transcript_step_lines")
-        if stored_lines:
-            body = Text("\n".join(stored_lines), style="dim")
-        else:
-            tree_text = self._build_tree_summary_text()
-            if tree_text is not None:
-                body = tree_text
-            else:
-                panel_content = self._format_steps_summary(self._build_step_summary())
-                body = Text(panel_content, style="dim")
-        panel = AIPPanel(body, title="Steps", border_style="blue")
-        self.console.print(panel)
-        self.console.print()
-
-    @staticmethod
-    def _format_steps_summary(steps: list[dict[str, Any]]) -> str:
-        """Format steps summary as text.
-
-        Args:
-            steps: List of step dictionaries.
-
-        Returns:
-            Formatted text string.
-        """
-        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:
-        """Extract timestamp from event metadata.
-
-        Args:
-            event: Event dictionary.
-
-        Returns:
-            Time value as float or 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:
-        """Parse received timestamp from event.
-
-        Args:
-            event: Event dictionary.
-
-        Returns:
-            Parsed datetime or 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:
-        """Extract final duration from events.
-
-        Returns:
-            Duration string or 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]]:
-        """Build step summary from stored steps or events.
-
-        Returns:
-            List of step dictionaries.
-        """
-        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]
-
-    def _build_tree_summary_text(self) -> Text | None:
-        """Render hierarchical tree from captured SSE events when available."""
-        manager = StepManager()
-        processed = False
-
-        for event in self.ctx.events:
-            payload = self._coerce_step_event(event)
-            if not payload:
-                continue
-            try:
-                manager.apply_event(payload)
-                processed = True
-            except ValueError:
-                continue
-
-        if not processed or not manager.order:
-            return None
-
-        lines: list[str] = []
-        roots = manager.order
-        total_roots = len(roots)
-        for index, root_id in enumerate(roots):
-            self._render_tree_branch(
-                manager=manager,
-                step_id=root_id,
-                ancestor_state=(),
-                is_last=index == total_roots - 1,
-                lines=lines,
-            )
-
-        if not lines:
-            return None
-
-        self._decorate_root_presentation(manager, roots[0], lines)
-
-        return Text("\n".join(lines), style="dim")
-
-    def _render_tree_branch(
-        self,
-        *,
-        manager: StepManager,
-        step_id: str,
-        ancestor_state: tuple[bool, ...],
-        is_last: bool,
-        lines: list[str],
-    ) -> None:
-        """Recursively render a tree branch of steps.
-
-        Args:
-            manager: StepManager instance.
-            step_id: ID of step to render.
-            ancestor_state: Tuple of ancestor branch states.
-            is_last: Whether this is the last child.
-            lines: List to append rendered lines to.
-        """
-        step = manager.by_id.get(step_id)
-        if not step:
-            return
-        suppress = self._should_hide_step(step)
-        children = manager.children.get(step_id, [])
-
-        if not suppress:
-            branch_state = ancestor_state
-            if branch_state:
-                branch_state = branch_state + (is_last,)
-            lines.append(self._format_tree_line(step, branch_state))
-            next_ancestor_state = ancestor_state + (is_last,)
-        else:
-            next_ancestor_state = ancestor_state
-
-        if not children:
-            return
-
-        total_children = len(children)
-        for idx, child_id in enumerate(children):
-            self._render_tree_branch(
-                manager=manager,
-                step_id=child_id,
-                ancestor_state=next_ancestor_state if not suppress else ancestor_state,
-                is_last=idx == total_children - 1,
-                lines=lines,
-            )
-
-    def _should_hide_step(self, step: Any) -> bool:
-        """Check if a step should be hidden.
-
-        Args:
-            step: Step object.
-
-        Returns:
-            True if step should be hidden.
-        """
-        if getattr(step, "parent_id", None) is None:
-            return False
-        name = getattr(step, "name", "") or ""
-        return self._looks_like_uuid(name)
-
-    def _decorate_root_presentation(
-        self,
-        manager: StepManager,
-        root_id: str,
-        lines: list[str],
-    ) -> None:
-        """Decorate root step presentation with friendly label.
-
-        Args:
-            manager: StepManager instance.
-            root_id: Root step ID.
-            lines: Lines list to modify.
-        """
-        if not lines:
-            return
-
-        root_step = manager.by_id.get(root_id)
-        if not root_step:
-            return
-
-        original_label = getattr(root_step, "display_label", None)
-        root_step.display_label = self._friendly_root_label(root_step, original_label)
-        lines[0] = self._format_tree_line(root_step, ())
-        if original_label is not None:
-            root_step.display_label = original_label
-
-        query = self._get_user_query()
-        if query:
-            lines.insert(1, f"     {query}")
-
-    def _coerce_step_event(self, event: dict[str, Any]) -> dict[str, Any] | None:
-        """Coerce event to step event format.
-
-        Args:
-            event: Event dictionary.
-
-        Returns:
-            Step event dictionary or None.
-        """
-        metadata = event.get("metadata")
-        if not isinstance(metadata, dict):
-            return None
-        if not isinstance(metadata.get("step_id"), str):
-            return None
-        return {
-            "metadata": metadata,
-            "status": event.get("status"),
-            "task_state": event.get("task_state"),
-            "content": event.get("content"),
-            "task_id": event.get("task_id"),
-            "context_id": event.get("context_id"),
-        }
-
-    def _format_tree_line(self, step: Any, branch_state: tuple[bool, ...]) -> str:
-        """Format a tree line for a step.
-
-        Args:
-            step: Step object.
-            branch_state: Branch state tuple.
-
-        Returns:
-            Formatted line string.
-        """
-        prefix = build_connector_prefix(branch_state)
-        raw_label = normalise_display_label(getattr(step, "display_label", None))
-        title, summary = self._split_label(raw_label)
-        line = f"{prefix}{title}"
-
-        if summary:
-            line += f" — {self._truncate_summary(summary)}"
-
-        badge = self._format_duration_badge(step)
-        if badge:
-            line += f" {badge}"
-
-        glyph = glyph_for_status(getattr(step, "status_icon", None))
-        failure_reason = getattr(step, "failure_reason", None)
-        if glyph and glyph != "spinner":
-            if failure_reason and glyph == "✗":
-                line += f" {glyph} {failure_reason}"
-            else:
-                line += f" {glyph}"
-        elif failure_reason:
-            line += f" ✗ {failure_reason}"
-
-        return line
-
-    def _friendly_root_label(self, step: Any, fallback: str | None) -> str:
-        """Generate friendly label for root step.
-
-        Args:
-            step: Step object.
-            fallback: Fallback label string.
-
-        Returns:
-            Friendly label string.
-        """
-        agent_name = self.ctx.manifest_entry.get("agent_name") or (self.ctx.meta or {}).get("agent_name")
-        agent_id = self.ctx.manifest_entry.get("agent_id") or getattr(step, "name", "")
-
-        if not agent_name:
-            return fallback or agent_id or ICON_AGENT
-
-        parts = [ICON_AGENT, agent_name]
-        if agent_id and agent_id != agent_name:
-            parts.append(f"({agent_id})")
-        return " ".join(parts)
-
-    @staticmethod
-    def _format_duration_badge(step: Any) -> str | None:
-        """Format duration badge for a step.
-
-        Args:
-            step: Step object.
-
-        Returns:
-            Duration badge string or None.
-        """
-        duration_ms = getattr(step, "duration_ms", None)
-        if duration_ms is None:
-            return None
-        try:
-            duration_ms = int(duration_ms)
-        except Exception:
-            return None
-
-        if duration_ms <= 0:
-            payload = "<1ms"
-        elif duration_ms >= 1000:
-            payload = f"{duration_ms / 1000:.2f}s"
-        else:
-            payload = f"{duration_ms}ms"
-
-        return f"[{payload}]"
-
-    @staticmethod
-    def _split_label(label: str) -> tuple[str, str | None]:
-        """Split label into title and summary.
-
-        Args:
-            label: Label string.
-
-        Returns:
-            Tuple of (title, summary).
-        """
-        if " — " in label:
-            title, summary = label.split(" — ", 1)
-            return title.strip(), summary.strip()
-        return label.strip(), None
-
-    @staticmethod
-    def _truncate_summary(summary: str, limit: int = 48) -> str:
-        """Truncate summary to specified length.
-
-        Args:
-            summary: Summary string.
-            limit: Maximum length.
-
-        Returns:
-            Truncated summary string.
-        """
-        summary = summary.strip()
-        if len(summary) <= limit:
-            return summary
-        return summary[: limit - 1].rstrip() + "…"
-
-    @staticmethod
-    def _looks_like_uuid(value: str) -> bool:
-        """Check if string looks like a UUID.
-
-        Args:
-            value: String to check.
-
-        Returns:
-            True if value looks like UUID.
-        """
-        stripped = value.replace("-", "").replace(" ", "")
-        if len(stripped) not in {32, 36}:
-            return False
-        return all(ch in "0123456789abcdefABCDEF" for ch in stripped)
-
-    @staticmethod
-    def _format_duration_from_ms(value: Any) -> str | None:
-        """Format duration from milliseconds.
-
-        Args:
-            value: Duration value in milliseconds.
-
-        Returns:
-            Formatted duration string or 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:
-        """Check if metadata represents a step event.
-
-        Args:
-            metadata: Event metadata dictionary.
-
-        Returns:
-            True if metadata represents a step event.
-        """
-        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]]]:
-        """Iterate step candidates from event.
-
-        Args:
-            event: Event dictionary.
-            metadata: Event metadata dictionary.
-
-        Yields:
-            Tuples of (step_name, step_info).
-        """
-        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]]]:
-        """Iterate tool call candidates from tool_info.
-
-        Args:
-            tool_info: Tool info dictionary.
-
-        Yields:
-            Tuples of (tool_name, tool_call_info).
-        """
-        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],
@@ -975,49 +359,6 @@ 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:
-        """Check if step is finished.
-
-        Args:
-            metadata: Event metadata.
-            event: Event dictionary.
-
-        Returns:
-            True if step is finished.
-        """
-        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,