glaip-sdk 0.0.20__py3-none-any.whl → 0.1.3__py3-none-any.whl

glaip_sdk/cli/transcript/cache.py

@@ -124,9 +124,7 @@ def _json_default(value: Any) -> Any:
     return repr(value)
 
 
-def _write_manifest(
-    entries: Iterable[dict[str, Any]], cache_dir: Path | None = None
-) -> None:
+def _write_manifest(entries: Iterable[dict[str, Any]], cache_dir: Path | None = None) -> None:
     path = manifest_path(cache_dir)
     with path.open("w", encoding="utf-8") as fh:
         for entry in entries:
@@ -212,8 +210,7 @@ def latest_manifest_entry(cache_dir: Path | None = None) -> dict[str, Any] | Non
         return None
     return max(
         entries,
-        key=lambda e: _parse_iso(e.get("created_at"))
-        or datetime.min.replace(tzinfo=timezone.utc),
+        key=lambda e: _parse_iso(e.get("created_at")) or datetime.min.replace(tzinfo=timezone.utc),
     )
 
 
@@ -237,11 +234,7 @@ def export_transcript(
 ) -> Path:
     """Copy a cached transcript to the requested destination path."""
     directory = ensure_cache_dir(cache_dir)
-    entry = (
-        resolve_manifest_entry(run_id, directory)
-        if run_id
-        else latest_manifest_entry(directory)
-    )
+    entry = resolve_manifest_entry(run_id, directory) if run_id else latest_manifest_entry(directory)
     if entry is None:
         raise FileNotFoundError("No cached transcripts available for export.")
 
@@ -259,9 +252,7 @@ def export_transcript(
         lines = cache_file.read_text(encoding="utf-8").splitlines()
         records = [json.loads(line) for line in lines if line.strip()]
     except json.JSONDecodeError as exc:
-        raise FileNotFoundError(
-            f"Cached transcript file is corrupted: {cache_file}"
-        ) from exc
+        raise FileNotFoundError(f"Cached transcript file is corrupted: {cache_file}") from exc
 
     with destination.open("w", encoding="utf-8") as fh:
         for idx, record in enumerate(records):
@@ -276,12 +267,8 @@ def export_transcript(
 def suggest_filename(entry: dict[str, Any] | None = None) -> str:
     """Return a friendly filename suggestion for exporting a transcript."""
     run_id = entry.get("run_id") if entry else uuid.uuid4().hex
-    created_at = (
-        entry.get("created_at") if entry else datetime.now(timezone.utc).isoformat()
-    )
-    timestamp = (
-        created_at.replace(":", "").replace("-", "").replace("T", "_").split("+")[0]
-    )
+    created_at = entry.get("created_at") if entry else datetime.now(timezone.utc).isoformat()
+    timestamp = created_at.replace(":", "").replace("-", "").replace("T", "_").split("+")[0]
     return f"aip-run-{timestamp}-{run_id}.jsonl"
 
 

glaip_sdk/cli/transcript/capture.py

@@ -8,8 +8,11 @@ from __future__ import annotations
 
 import json
 from dataclasses import dataclass
+from io import StringIO
 from typing import Any
 
+from rich.console import Console
+
 from glaip_sdk.cli.transcript.cache import (
     TranscriptPayload,
     TranscriptStoreResult,
@@ -65,11 +68,7 @@ def compute_finished_at(renderer: Any) -> float | None:
 
     if started_at is None:
         stream_processor = getattr(renderer, "stream_processor", None)
-        started_at = (
-            getattr(stream_processor, "streaming_started_at", None)
-            if stream_processor is not None
-            else None
-        )
+        started_at = getattr(stream_processor, "streaming_started_at", None) if stream_processor is not None else None
     if started_at is None or duration is None:
         return None
     try:
@@ -78,9 +77,7 @@ def compute_finished_at(renderer: Any) -> float | None:
         return None
 
 
-def extract_server_run_id(
-    meta: dict[str, Any], events: list[dict[str, Any]]
-) -> str | None:
+def extract_server_run_id(meta: dict[str, Any], events: list[dict[str, Any]]) -> str | None:
     """Derive a server-side run identifier from renderer metadata."""
     run_id = meta.get("run_id") or meta.get("id")
     if run_id:
@@ -107,9 +104,7 @@ def _coerce_meta(meta: Any) -> dict[str, Any]:
     return {"value": coerce_result_text(meta)}
 
 
-def register_last_transcript(
-    ctx: Any, payload: TranscriptPayload, store_result: TranscriptStoreResult
-) -> None:
+def register_last_transcript(ctx: Any, payload: TranscriptPayload, store_result: TranscriptStoreResult) -> None:
     """Persist last-run transcript references onto the Click context."""
     ctx_obj = getattr(ctx, "obj", None)
     if not isinstance(ctx_obj, dict):
@@ -172,6 +167,38 @@ def _format_step_display_name(name: str) -> str:
         return name
 
 
+def _extract_step_summary_lines(renderer: Any) -> list[str]:
+    """Render the live steps summary to plain text lines."""
+    if not hasattr(renderer, "_render_steps_text"):
+        return []
+
+    try:
+        renderable = renderer._render_steps_text()
+    except Exception:
+        return []
+
+    buffer = StringIO()
+    console = Console(file=buffer, record=True, force_terminal=False, width=120)
+    try:
+        console.print(renderable)
+    except Exception:
+        return []
+
+    text = console.export_text() or buffer.getvalue()
+    lines = [line.rstrip() for line in text.splitlines()]
+    half = len(lines) // 2
+    if half and lines[:half] == lines[half : half * 2]:
+        return lines[:half]
+    start = 0
+    prefixes = ("🤖", "🔧", "💭", "├", "└", "│", "•")
+    for idx, line in enumerate(lines):
+        if line.lstrip().startswith(prefixes):
+            start = idx
+            break
+    trimmed = lines[start:]
+    return [line for line in trimmed if line]
+
+
 def _collect_renderer_outputs(
     renderer: Any, final_result: Any
 ) -> tuple[
@@ -211,11 +238,13 @@ def _derive_transcript_meta(
     if step_summaries:
         meta["transcript_steps"] = step_summaries
 
+    step_lines = _extract_step_summary_lines(renderer)
+    if step_lines:
+        meta["transcript_step_lines"] = step_lines
+
     stream_processor = getattr(renderer, "stream_processor", None)
     stream_started_at = (
-        getattr(stream_processor, "streaming_started_at", None)
-        if stream_processor is not None
-        else None
+        getattr(stream_processor, "streaming_started_at", None) if stream_processor is not None else None
     )
     finished_at = compute_finished_at(renderer)
     model_name = meta.get("model") or model
@@ -236,16 +265,12 @@ def store_transcript_for_session(
     if not hasattr(renderer, "get_transcript_events"):
         return None
 
-    events, aggregated_output, final_output = _collect_renderer_outputs(
-        renderer, final_result
-    )
+    events, aggregated_output, final_output = _collect_renderer_outputs(renderer, final_result)
 
     if not (events or aggregated_output or final_output):
         return None
 
-    meta, stream_started_at, finished_at, model_name = _derive_transcript_meta(
-        renderer, model
-    )
+    meta, stream_started_at, finished_at, model_name = _derive_transcript_meta(renderer, model)
 
     payload: TranscriptPayload = build_transcript_payload(
         events=events,

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

@@ -25,14 +25,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.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.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]"
 
@@ -66,9 +72,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
 
     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()
@@ -85,9 +89,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         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")
@@ -128,9 +130,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         self._render_final_panel()
 
         self.console.print("[bold]Transcript Events[/bold]")
-        self.console.print(
-            "[dim]────────────────────────────────────────────────────────[/dim]"
-        )
+        self.console.print("[dim]────────────────────────────────────────────────────────[/dim]")
 
         base_received_ts: datetime | None = None
         for event in self.ctx.events:
@@ -146,11 +146,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         self.console.print()
 
     def _render_final_panel(self) -> None:
-        content = (
-            self.ctx.final_output
-            or self.ctx.default_output
-            or "No response content captured."
-        )
+        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:
@@ -212,9 +208,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,9 +234,7 @@ 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
@@ -299,9 +291,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,20 +337,13 @@ 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("[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")
-        )
+        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(
@@ -372,12 +355,17 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         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",
-        )
+        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()
 
@@ -460,6 +448,201 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
 
         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:
+        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:
+        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:
+        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:
+        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:
+        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:
+        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:
+        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]:
+        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:
+        summary = summary.strip()
+        if len(summary) <= limit:
+            return summary
+        return summary[: limit - 1].rstrip() + "…"
+
+    @staticmethod
+    def _looks_like_uuid(value: str) -> bool:
+        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:
         try:
@@ -560,11 +743,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         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:
@@ -590,9 +769,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         started_at = step.get("started_at")
         duration_value: float | None = None
 
-        if isinstance(event_time, (int, float)) and isinstance(
-            started_at, (int, float)
-        ):
+        if isinstance(event_time, (int, float)) and isinstance(started_at, (int, float)):
             try:
                 delta = float(event_time) - float(started_at)
                 if delta >= 0: