symphony-code 0.0.1__py3-none-any.whl

coding_agent/tui/runtime/sink.py

@@ -0,0 +1,115 @@
+"""Textual sink for harness events.
+
+This is not a second control-plane product. It implements the harness
+``EventSink`` so the UI can observe the same events ``CoreHarness``
+emits. Cancel is a TUI action: it dismisses questions and cancels the
+run worker. The harness does not poll this object for cancel.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from textual.message import Message
+
+from core_harness import EventSink, ControlPlaneEventType, HumanInteraction
+
+
+class HarnessEvent(Message):
+    """Posted onto the Textual app when the harness emits an event."""
+
+    def __init__(
+        self,
+        event_type: Union[str, ControlPlaneEventType],
+        payload: Dict[str, Any],
+    ) -> None:
+        super().__init__()
+        if isinstance(event_type, ControlPlaneEventType):
+            self.event_type = event_type.value
+        else:
+            self.event_type = event_type
+        self.payload = payload
+
+
+# Back-compat alias used by older tests / imports.
+ControlPlaneEvent = HarnessEvent
+
+
+class TextualInteraction(HumanInteraction):
+    """The TUI's question slot. An unbound sink has nobody to ask."""
+
+    sink: "TextualEventSink"
+
+    async def request_user_input(self, *, default: str = "", **question: Any) -> str:
+        if self.sink._app is None:
+            return default
+        return await super().request_user_input(default=default, **question)
+
+
+class TextualEventSink(EventSink):
+    """TUI adapter: post events to the app and track the TUI's cancel state."""
+
+    interaction: TextualInteraction
+
+    def __init__(self, *, workspace: str | Path = ".") -> None:
+        super().__init__()
+        self._app: Any = None
+        self.workspace = Path(workspace).resolve()
+        self.interaction = TextualInteraction(self)
+        self._cancelled = False
+        self._cancel_reason = "cancelled"
+        self._cancel_parent: Optional[TextualEventSink] = None
+
+    def bind(self, app: Any) -> None:
+        self._app = app
+
+    def fork(self) -> "TextualEventSink":
+        """Child plane with the shared composer.
+
+        The TUI has one pending-question slot and answers on the parent plane,
+        so the child's interaction port is a fork of this one.
+        """
+        child = TextualEventSink(workspace=self.workspace)
+        child.bind(self._app)
+        child._cancel_parent = self
+        child.interaction = self.interaction.fork(child)
+        return child
+
+    async def deliver(self, event_type: str, payload: Dict[str, Any]) -> None:
+        if self._app is None:
+            return
+        # Register the waiter before posting the message.  The Textual event
+        # may be handled immediately, while AskUserTool only calls
+        # ``ask_user`` after ``emit`` returns.
+        if event_type == "question_asked":
+            request_id = str(payload.get("request_id") or "")
+            if request_id:
+                self.interaction.expect(request_id)
+        self._app.post_message(HarnessEvent(event_type, payload))
+
+    def request_cancel(self, reason: str = "user_cancel") -> None:
+        """Dismiss pending questions. The TUI cancels the run worker."""
+        self._cancelled = True
+        self._cancel_reason = reason
+        self.interaction.dismiss("Deny")
+
+    @property
+    def cancelled(self) -> bool:
+        if self._cancelled:
+            return True
+        parent = self._cancel_parent
+        return bool(parent is not None and parent.cancelled)
+
+    @property
+    def cancel_reason(self) -> str:
+        if self._cancelled:
+            return self._cancel_reason
+        parent = self._cancel_parent
+        if parent is not None and parent.cancelled:
+            return parent.cancel_reason
+        return self._cancel_reason
+
+    def reset_cancel(self) -> None:
+        self._cancelled = False
+        self._cancel_reason = "cancelled"

coding_agent/tui/runtime/state.py

@@ -0,0 +1,145 @@
+"""Mutable TUI run state derived from harness control-plane events."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Mapping, Optional
+
+Phase = Literal["idle", "thinking", "streaming", "tool", "paused"]
+
+
+@dataclass
+class RunMetrics:
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    reasoning_tokens: int = 0
+    total_tokens: int = 0
+    cumulative_tokens: int = 0
+    estimated: bool = False
+    context_limit: Optional[int] = None
+    context_left: Optional[int] = None
+    tokens_used: int = 0
+    utilization: Optional[float] = None
+
+
+@dataclass
+class UiRunState:
+    """Tracks live streaming + metrics for the status/live panes."""
+
+    phase: Phase = "idle"
+    model_id: str = ""
+    turn: Optional[int] = None
+    stream_text: str = ""
+    reasoning_text: str = ""
+    tool_args_preview: str = ""
+    metrics: RunMetrics = field(default_factory=RunMetrics)
+    detail: str = ""
+
+    def reset_for_run(self, *, model_id: str = "") -> None:
+        # Context usage describes the active session, not just the next turn.
+        # Preserve it while clearing per-run token accounting so the footer
+        # does not briefly fall back to an empty/unknown state.
+        context = self.metrics
+        self.phase = "thinking"
+        self.model_id = model_id or self.model_id
+        self.turn = None
+        self.stream_text = ""
+        self.reasoning_text = ""
+        self.tool_args_preview = ""
+        self.metrics = RunMetrics(
+            context_limit=context.context_limit,
+            context_left=context.context_left,
+            tokens_used=context.tokens_used,
+            utilization=context.utilization,
+        )
+        self.detail = "starting"
+
+    def begin_turn(self, turn: int) -> None:
+        self.turn = turn
+        self.phase = "thinking"
+        self.stream_text = ""
+        self.reasoning_text = ""
+        self.tool_args_preview = ""
+        self.detail = f"turn {turn}"
+
+    def append_text(self, delta: str) -> None:
+        self.phase = "streaming"
+        self.stream_text += delta
+        self.detail = "streaming"
+
+    def update_usage(self, payload: Mapping[str, object]) -> None:
+        m = self.metrics
+        m.prompt_tokens = int(payload.get("prompt_tokens") or 0)
+        m.completion_tokens = int(payload.get("completion_tokens") or 0)
+        m.reasoning_tokens = int(payload.get("reasoning_tokens") or 0)
+        m.total_tokens = int(payload.get("total_tokens") or 0)
+        m.cumulative_tokens = int(payload.get("cumulative_tokens") or m.total_tokens)
+        m.estimated = bool(payload.get("estimated", False))
+
+    def set_context_limit(self, limit: Optional[int]) -> None:
+        """Apply a model context limit and recalculate all derived metrics."""
+        m = self.metrics
+        m.context_limit = limit
+        if limit is None or limit <= 0:
+            m.context_left = None
+            m.utilization = None
+            return
+        m.context_left = max(limit - m.tokens_used, 0)
+        m.utilization = min(m.tokens_used / limit, 1.0)
+
+    def update_context(self, payload: Mapping[str, object]) -> None:
+        m = self.metrics
+        limit = payload.get("context_limit")
+        left = payload.get("context_left")
+        used = payload.get("tokens_used")
+        m.context_limit = int(limit) if limit is not None else None
+        m.context_left = int(left) if left is not None else None
+        m.tokens_used = int(used) if used is not None else m.tokens_used
+        util = payload.get("utilization")
+        m.utilization = float(util) if util is not None else None
+
+    def update_after_compaction(self, payload: Mapping[str, object]) -> bool:
+        """Re-derive context metrics from a ``compaction_completed`` payload.
+
+        The harness reports the post-compact prompt size as an estimate; the
+        footer should reflect it immediately instead of waiting for the next
+        ``context`` event. Returns False when the payload carries no estimate.
+        """
+        after = payload.get("estimated_tokens_after")
+        if after is None:
+            return False
+        m = self.metrics
+        limit = payload.get("context_limit")
+        if limit is not None:
+            m.context_limit = int(limit)
+        m.tokens_used = int(after)
+        if m.context_limit:
+            m.context_left = max(m.context_limit - m.tokens_used, 0)
+            m.utilization = min(m.tokens_used / m.context_limit, 1.0)
+        else:
+            m.context_left = None
+            m.utilization = None
+        return True
+
+    def status_line(self, *, workspace: str = "") -> str:
+        m = self.metrics
+        parts: list[str] = []
+        if self.model_id:
+            parts.append(f"model={self.model_id}")
+        if workspace:
+            parts.append(f"ws={workspace}")
+        parts.append(f"phase={self.phase}")
+        if self.detail:
+            parts.append(self.detail)
+
+        tokens = m.tokens_used or m.total_tokens
+        est = "~" if m.estimated and tokens else ""
+        parts.append(f"tokens={est}{tokens}")
+
+        if m.context_limit is not None:
+            left = m.context_left if m.context_left is not None else "?"
+            parts.append(f"context_left={left}/{m.context_limit}")
+        elif m.context_left is not None:
+            parts.append(f"context_left={m.context_left}")
+
+        return "  ·  ".join(parts)