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

glaip_sdk/utils/rendering/renderer/config.py

@@ -24,10 +24,8 @@ class RendererConfig:
     live: bool = True
     persist_live: bool = True
 
-    # Debug visibility toggles
-    show_delegate_tool_panels: bool = False
-
     # Scrollback/append options
+    summary_max_steps: int = 0
     append_finished_snapshots: bool = False
-    snapshot_max_chars: int = 12000
-    snapshot_max_lines: int = 200
+    snapshot_max_chars: int = 0
+    snapshot_max_lines: int = 0

glaip_sdk/utils/rendering/renderer/stream.py

@@ -38,7 +38,7 @@ class StreamProcessor:
         Returns:
             Dictionary with extracted metadata
         """
-        metadata = event.get("metadata", {})
+        metadata = event.get("metadata") or {}
         # Update server elapsed timing if backend provides it
         try:
             t = metadata.get("time")
@@ -49,8 +49,8 @@ class StreamProcessor:
 
         return {
             "kind": metadata.get("kind") if metadata else event.get("kind"),
-            "task_id": event.get("task_id"),
-            "context_id": event.get("context_id"),
+            "task_id": metadata.get("task_id") or event.get("task_id"),
+            "context_id": metadata.get("context_id") or event.get("context_id"),
             "content": event.get("content", ""),
             "status": metadata.get("status") if metadata else event.get("status"),
             "metadata": metadata,

glaip_sdk/utils/rendering/renderer/toggle.py

@@ -0,0 +1,184 @@
+"""Keyboard-driven transcript toggling support for the live renderer.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+import time
+from typing import Any
+
+try:  # pragma: no cover - Windows-specific dependencies
+    import msvcrt  # type: ignore[import]
+except ImportError:  # pragma: no cover - POSIX fallback
+    msvcrt = None  # type: ignore[assignment]
+
+if os.name != "nt":  # pragma: no cover - POSIX-only imports
+    import select
+    import termios
+    import tty
+
+
+CTRL_T = "\x14"
+
+
+class TranscriptToggleController:
+    """Manage mid-run transcript toggling for RichStreamRenderer instances."""
+
+    def __init__(self, *, enabled: bool) -> None:
+        """Initialise controller.
+
+        Args:
+            enabled: Whether toggling should be active (usually gated by TTY checks).
+        """
+        self._enabled = enabled and bool(sys.stdin) and sys.stdin.isatty()
+        self._lock = threading.Lock()
+        self._posix_fd: int | None = None
+        self._posix_attrs: list[int] | None = None
+        self._active = False
+        self._stop_event = threading.Event()
+        self._poll_thread: threading.Thread | None = None
+
+    @property
+    def enabled(self) -> bool:
+        """Return True when controller is able to process keypresses."""
+        return self._enabled
+
+    def on_stream_start(self, renderer: Any) -> None:
+        """Prepare terminal state before streaming begins."""
+        if not self._enabled:
+            return
+
+        if os.name == "nt":  # pragma: no cover - Windows behaviour not in CI
+            self._active = True
+            self._start_polling_thread(renderer)
+            return
+
+        fd = sys.stdin.fileno()
+        try:
+            attrs = termios.tcgetattr(fd)
+        except Exception:
+            self._enabled = False
+            return
+
+        try:
+            tty.setcbreak(fd)
+        except Exception:
+            try:
+                termios.tcsetattr(fd, termios.TCSADRAIN, attrs)
+            except Exception:
+                pass
+            self._enabled = False
+            return
+
+        with self._lock:
+            self._posix_fd = fd
+            self._posix_attrs = attrs
+            self._active = True
+
+        self._start_polling_thread(renderer)
+
+    def on_stream_complete(self) -> None:
+        """Restore terminal state when streaming ends."""
+        if not self._active:
+            return
+
+        self._stop_polling_thread()
+
+        if os.name == "nt":  # pragma: no cover - Windows behaviour not in CI
+            self._active = False
+            return
+
+        with self._lock:
+            fd = self._posix_fd
+            attrs = self._posix_attrs
+            self._posix_fd = None
+            self._posix_attrs = None
+            self._active = False
+
+        if fd is None or attrs is None:
+            return
+
+        try:
+            termios.tcsetattr(fd, termios.TCSADRAIN, attrs)
+        except Exception:
+            pass
+
+    def poll(self, renderer: Any) -> None:
+        """Poll for toggle keypresses and update renderer if needed."""
+        if not self._active:
+            return
+
+        if os.name == "nt":  # pragma: no cover - Windows behaviour not in CI
+            self._poll_windows(renderer)
+        else:
+            self._poll_posix(renderer)
+
+    # ------------------------------------------------------------------
+    # Platform-specific polling
+    # ------------------------------------------------------------------
+    def _poll_windows(self, renderer: Any) -> None:
+        if not msvcrt:  # pragma: no cover - safety guard
+            return
+
+        while msvcrt.kbhit():
+            ch = msvcrt.getwch()
+            if ch == CTRL_T:
+                renderer.toggle_transcript_mode()
+
+    def _poll_posix(self, renderer: Any) -> None:  # pragma: no cover - requires TTY
+        fd = self._posix_fd
+        if fd is None:
+            return
+
+        while True:
+            readable, _, _ = select.select([fd], [], [], 0)
+            if not readable:
+                return
+
+            try:
+                data = os.read(fd, 1)
+            except Exception:
+                return
+
+            if not data:
+                return
+
+            ch = data.decode(errors="ignore")
+            if ch == CTRL_T:
+                renderer.toggle_transcript_mode()
+
+    def _start_polling_thread(self, renderer: Any) -> None:
+        if self._poll_thread and self._poll_thread.is_alive():
+            return
+        if not self._active:
+            return
+
+        self._stop_event.clear()
+        self._poll_thread = threading.Thread(
+            target=self._poll_loop, args=(renderer,), daemon=True
+        )
+        self._poll_thread.start()
+
+    def _stop_polling_thread(self) -> None:
+        self._stop_event.set()
+        thread = self._poll_thread
+        if thread and thread.is_alive():
+            thread.join(timeout=0.2)
+        self._poll_thread = None
+
+    def _poll_loop(self, renderer: Any) -> None:
+        while self._active and not self._stop_event.is_set():
+            try:
+                if os.name == "nt":
+                    self._poll_windows(renderer)
+                else:
+                    self._poll_posix(renderer)
+            except Exception:
+                # Never let background polling disrupt the main stream
+                pass
+            time.sleep(0.05)

glaip_sdk/utils/rendering/step_tree_state.py

@@ -0,0 +1,102 @@
+"""State container for hierarchical renderer steps.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+
+from glaip_sdk.utils.rendering.models import Step
+
+
+@dataclass(slots=True)
+class StepTreeState:
+    """Track hierarchical ordering, buffers, and pruning metadata."""
+
+    max_steps: int = 200
+    root_order: list[str] = field(default_factory=list)
+    child_map: dict[str, list[str]] = field(default_factory=dict)
+    buffered_children: dict[str, list[str]] = field(default_factory=dict)
+    running_by_context: dict[tuple[str | None, str | None], set[str]] = field(
+        default_factory=dict
+    )
+    retained_ids: set[str] = field(default_factory=set)
+    step_index: dict[str, Step] = field(default_factory=dict)
+    pending_branch_failures: set[str] = field(default_factory=set)
+
+    def link_root(self, step_id: str) -> None:
+        """Ensure a step id is present in the root ordering."""
+        if step_id not in self.root_order:
+            self.root_order.append(step_id)
+
+    def unlink_root(self, step_id: str) -> None:
+        """Remove a step id from the root ordering if present."""
+        if step_id in self.root_order:
+            self.root_order.remove(step_id)
+
+    def link_child(self, parent_id: str, child_id: str) -> None:
+        """Attach a child step to a parent."""
+        children = self.child_map.setdefault(parent_id, [])
+        if child_id not in children:
+            children.append(child_id)
+
+    def unlink_child(self, parent_id: str, child_id: str) -> None:
+        """Detach a child from a parent."""
+        children = self.child_map.get(parent_id)
+        if not children:
+            return
+
+        if child_id in children:
+            children.remove(child_id)
+        # Clean up if the list is now empty
+        if len(children) == 0:
+            self.child_map.pop(parent_id, None)
+
+    def buffer_child(self, parent_id: str, child_id: str) -> None:
+        """Track a child that is waiting for its parent to appear."""
+        queue = self.buffered_children.setdefault(parent_id, [])
+        if child_id not in queue:
+            queue.append(child_id)
+
+    def pop_buffered_children(self, parent_id: str) -> list[str]:
+        """Return any buffered children for a parent."""
+        return self.buffered_children.pop(parent_id, [])
+
+    def discard_running(self, step_id: str) -> None:
+        """Remove a step from running context tracking."""
+        for key, running in tuple(self.running_by_context.items()):
+            if step_id in running:
+                running.discard(step_id)
+                if not running:
+                    self.running_by_context.pop(key, None)
+
+    def iter_visible_tree(self) -> Iterator[tuple[str, tuple[bool, ...]]]:
+        """Yield step ids in depth-first order alongside branch metadata.
+
+        Returns:
+            Iterator of (step_id, branch_state) tuples where branch_state
+            captures whether each ancestor was the last child. This data
+            is later used by rendering helpers to draw connectors such as
+            `│`, `├─`, and `└─` consistently.
+        """
+        roots = tuple(self.root_order)
+        total_roots = len(roots)
+        for index, root_id in enumerate(roots):
+            yield root_id, ()
+            ancestor_state = (index == total_roots - 1,)
+            yield from self._walk_children(root_id, ancestor_state)
+
+    def _walk_children(
+        self, parent_id: str, ancestor_state: tuple[bool, ...]
+    ) -> Iterator[tuple[str, tuple[bool, ...]]]:
+        """Depth-first traversal helper yielding children with ancestry info."""
+        children = self.child_map.get(parent_id, [])
+        total_children = len(children)
+        for idx, child_id in enumerate(children):
+            is_last = idx == total_children - 1
+            branch_state = ancestor_state + (is_last,)
+            yield child_id, branch_state
+            yield from self._walk_children(child_id, branch_state)