symphony-code 0.0.1__py3-none-any.whl

coding_agent/tui/runtime/turn.py

@@ -0,0 +1,206 @@
+"""Agent-turn worker mixed into CodingAgentApp."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Callable, Mapping
+
+from textual import work
+from textual.widgets import Static
+
+from coding_agent.tui.chrome import TopBar, display_workspace_path, footer_hint, render_footer
+from coding_agent.tui.composer.input import PromptInput
+from coding_agent.tui.runtime.sink import HarnessEvent
+from coding_agent.tui.screens.history import load_session_history
+from core_ai.types import Content
+from core_harness import HarnessCancelled, HarnessLimitExceeded, HarnessResult
+
+STREAM_PAINT_INTERVAL_S = 1 / 15
+
+
+class TurnSurface:
+    """Harness event routing and the exclusive agent-turn worker."""
+
+    def _set_status(self, _value: str) -> None:
+        """Repaint the footer from run state; the header only when the model changes.
+
+        Usage events refresh this often. Re-reading git and rebuilding the
+        top bar on every token made the composer stutter during a live run.
+        """
+        hint = footer_hint(question_pending=self._pending_question_id is not None)
+        self.query_one("#status", Static).update(
+            render_footer(
+                self._ui_state,
+                hint=hint,
+                workspace=display_workspace_path(self.workspace),
+            ),
+            # The footer has fixed width/height; metrics only change its paint.
+            layout=False,
+        )
+        model_id = self._ui_state.model_id or getattr(self, "model_id", "") or ""
+        if model_id != getattr(self, "_topbar_model", None):
+            self._topbar_model = model_id
+            self.query_one("#topbar", TopBar).set_context(self.workspace, model_id)
+
+    def _schedule_stream_flush(self, callback: Callable[[], None]) -> None:
+        """Coalesce stream paints to keep Markdown/widget work bounded."""
+        # A structural event can drain paints before this timer fires. Keep
+        # the newest generation's callback rather than stranding its updates.
+        self._stream_flush_callback = callback
+        if getattr(self, "_stream_flush_timer", None) is not None:
+            return
+
+        def _run() -> None:
+            self._stream_flush_timer = None
+            pending = self._stream_flush_callback
+            self._stream_flush_callback = None
+            if pending is not None:
+                pending()
+
+        self._stream_flush_timer = self.set_timer(STREAM_PAINT_INTERVAL_S, _run)
+
+    def set_context_metrics(self, tokens_used: int, context_limit: int) -> None:
+        """Restore context usage for a resumed session before its first run."""
+        metrics = self._ui_state.metrics
+        metrics.tokens_used = tokens_used
+        metrics.context_limit = context_limit
+        metrics.context_left = max(context_limit - tokens_used, 0)
+        metrics.utilization = tokens_used / context_limit if context_limit else None
+        self._set_status("")
+
+    @work(exclusive=False)
+    async def load_session_history(self) -> None:
+        if self._agent is None:
+            return
+        await load_session_history(self._agent, self)
+        await self.restore_subagents()
+
+    def _collect_run_events(self, payload: Mapping[str, Any]) -> None:
+        """Tag mid-run journal events as collected after the final output."""
+        agent = getattr(self, "_agent", None)
+        store = getattr(agent, "persistence", None)
+        collect = getattr(store, "collect_run_events", None)
+        if not callable(collect):
+            return
+        session_id = str(
+            payload.get("session_id") or getattr(agent, "session_id", "") or ""
+        )
+        run_id = str(payload.get("run_id") or "")
+        if not session_id:
+            return
+
+        async def _persist() -> None:
+            annotate = getattr(store, "annotate_run_completed", None)
+            if callable(annotate):
+                elapsed = payload.get("elapsed_seconds")
+                await annotate(
+                    session_id=session_id,
+                    run_id=run_id,
+                    completion_verb=str(payload.get("completion_verb") or ""),
+                    duration=str(payload.get("duration") or ""),
+                    elapsed_seconds=float(elapsed) if isinstance(elapsed, (int, float)) else None,
+                )
+            await collect(session_id=session_id, run_id=run_id or None)
+
+        self.run_worker(_persist, exclusive=False, group="collect_run_events")
+
+    def feed_voice(self, text: str) -> None:
+        from coding_agent.tui.composer.voice_mode import feed_voice
+
+        feed_voice(self, text)
+
+    def on_harness_event(self, message: HarnessEvent) -> None:
+        payload = message.payload or {}
+        if message.event_type == "agent_spawned":
+            self._on_agent_spawned(payload)
+            return
+        if message.event_type in {"agent_completed", "agent_failed"}:
+            self._on_agent_finished(message.event_type, payload)
+            return
+        if payload.get("parent_id"):
+            self._on_child_event(message.event_type, payload)
+            if message.event_type == "question_asked":
+                self._show_child_question(payload)
+            return
+        if message.event_type == "question_asked":
+            self._show_question(payload)
+            return
+        if self._presenter is not None:
+            self._presenter.handle(message.event_type, payload)
+        if message.event_type in {
+            "run_completed",
+            "run_failed",
+            "run_cancelled",
+            "run_limit_exceeded",
+        }:
+            self._collect_run_events(payload)
+
+    on_control_plane_event = on_harness_event
+
+    @work(exclusive=True, group="run_agent")
+    async def run_agent(self, user_input: Content) -> None:
+        generation = self._run_generation
+        try:
+            await self._run_agent_turn(user_input)
+        except (HarnessCancelled, HarnessLimitExceeded, asyncio.CancelledError):
+            if self._presenter is not None:
+                self._presenter.flush_stream_to_log()
+        except Exception as exc:  # noqa: BLE001
+            if self._presenter is not None:
+                self._presenter.flush_stream_to_log()
+            # run_failed already raised the composer banner. Anything else
+            # that escaped the harness, including SSL, uses that same banner.
+            if self._ui_state.detail != "failed" and self._presenter is not None:
+                self._presenter._show_banner("run_failed", {"message": str(exc)})
+        finally:
+            if generation != self._run_generation:
+                # A newer turn already started; do not clobber its busy state
+                # or dispatch the queue a second time.
+                return
+            child_question_pending = bool(
+                self._pending_question_id and self._pending_question_agent_id
+            )
+            cancel_reason = self.sink.cancel_reason if self.sink.cancelled else None
+            dispatch_queued = (
+                not child_question_pending
+                and bool(self._queued_turns)
+                and cancel_reason not in {"user_cancel", "quit"}
+            )
+            if dispatch_queued:
+                # Skip the idle chrome/focus pass — it forced a full layout
+                # immediately before the next turn mounted more widgets.
+                self.call_after_refresh(self._start_turn, self.pop_queued_turn())
+                return
+            if self._presenter is not None:
+                self._ui_state.phase = "paused" if child_question_pending else "idle"
+                self._presenter.refresh_chrome()
+            self._busy = False
+            if self._reload_queued:
+                from coding_agent.tui.commands.manager import reload_project
+
+                self._reload_queued = False
+                self.run_worker(reload_project(self), exclusive=False)
+            if not child_question_pending:
+                self._pending_question_id = None
+                self._pending_question_default = ""
+            self.sink.reset_cancel()
+            voice_addon = getattr(self, "_voice_addon", None)
+            if getattr(voice_addon, "_armed", False):
+                # Failed/cancelled runs do not reach the harness after_run hook.
+                from coding_agent.tui.composer.voice_mode import close_voice_addon
+
+                close_voice_addon(self)
+            if getattr(self, "_voice_active", False):
+                # The composer is hidden. Leave focus alone until voice mode ends.
+                return
+            prompt = self.query_one("#prompt", PromptInput)
+            if not child_question_pending:
+                prompt.submit_on_enter = True
+            prompt.disabled = False
+            self._update_composer_hint()
+            prompt.focus()
+
+    async def _run_agent_turn(self, user_input: Content) -> HarnessResult:
+        assert self._agent is not None
+        result = await self._agent.run(user_input)
+        return result

coding_agent/tui/screens/__init__.py

@@ -0,0 +1,54 @@
+"""TUI screens: modal host plus resume, history, file selector, and inspectors."""
+
+from coding_agent.tui.screens.context import ContextBucketChip, ContextModal
+from coding_agent.tui.screens.diff import DiffFileCard, DiffModal
+from coding_agent.tui.screens.extensions import ExtensionsModal
+from coding_agent.tui.screens.file_selector import (
+    FileOption,
+    WorkspaceFileIndex,
+    active_file_mention,
+    complete_file_mention,
+    file_matches,
+)
+from coding_agent.tui.screens.history import load_session_history
+from coding_agent.tui.screens.learning import LearningCard, LearningModal
+from coding_agent.tui.screens.langfuse import LangfuseSetupScreen
+from coding_agent.tui.screens.modal import (
+    ContentModal,
+    EmptyState,
+    ModalBase,
+    ModalCloseButton,
+    ModalScroll,
+)
+from coding_agent.tui.screens.onboard import OnboardApp, ProviderOnboardScreen, ProviderWizard
+from coding_agent.tui.screens.resume import ResumeApp, SessionOption, load_session_options
+from coding_agent.tui.tools.images import ImageModal
+
+__all__ = [
+    "ContentModal",
+    "ContextBucketChip",
+    "ContextModal",
+    "DiffFileCard",
+    "DiffModal",
+    "ExtensionsModal",
+    "EmptyState",
+    "FileOption",
+    "WorkspaceFileIndex",
+    "ImageModal",
+    "LearningCard",
+    "LearningModal",
+    "LangfuseSetupScreen",
+    "ModalBase",
+    "ModalCloseButton",
+    "ModalScroll",
+    "OnboardApp",
+    "ProviderOnboardScreen",
+    "ProviderWizard",
+    "ResumeApp",
+    "SessionOption",
+    "active_file_mention",
+    "complete_file_mention",
+    "file_matches",
+    "load_session_history",
+    "load_session_options",
+]

coding_agent/tui/screens/ask.py

@@ -0,0 +1,69 @@
+"""Ask-user question and approval flow mixed into CodingAgentApp."""
+
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from core_harness import Answer
+
+from coding_agent.tui.composer.input import PromptInput, QueuedPrompt
+from coding_agent.tui.composer.slash_menu import SlashMenu
+
+
+class QuestionSurface:
+    """Ask-user composer flow mixed into CodingAgentApp."""
+
+    def _show_question(self, payload: Mapping[str, Any]) -> None:
+        request_id = str(payload.get("request_id") or "")
+        question = str(payload.get("question") or "")
+        choices = [str(choice) for choice in payload.get("choices") or []]
+        default = str(payload.get("default") or "")
+        kind = str(payload.get("kind") or "")
+        if not request_id or not question:
+            self.add_notice("The agent sent an invalid question request.", "error")
+            return
+        self._pending_question_id = request_id
+        self._pending_question_agent_id = str(payload.get("agent_id") or "") if payload.get("parent_id") else ""
+        self._pending_question_default = default
+        self._ui_state.phase = "paused"
+        self._ui_state.detail = "waiting for user"
+        self._update_composer_hint()
+        menu = self.query_one(
+            "#approval-menu" if kind == "approval" else "#slash-menu",
+            SlashMenu,
+        )
+        menu.set_question(
+            question,
+            choices,
+            default=default,
+            kind=kind,
+        )
+        prompt = self.query_one("#prompt", PromptInput)
+        prompt.submit_on_enter = kind == "approval"
+        prompt.disabled = False
+        # Keep a follow-up the user is already typing; approval choices live
+        # in the menu, not in the composer.
+        if not prompt.value.strip():
+            prompt.value = "" if choices else default
+            prompt.cursor_position = len(prompt.value)
+        prompt.focus()
+        queued = getattr(self, "_queued_turns", None)
+        if queued:
+            self.query_one("#queued-prompt-row", QueuedPrompt).refresh_queue(queued)
+
+    async def _answer_question(self, answer: str) -> None:
+        request_id = self._pending_question_id
+        if request_id is None:
+            return
+        self._pending_question_id = None
+        self._pending_question_agent_id = ""
+        self._pending_question_default = ""
+        self.query_one("#slash-menu", SlashMenu).set_commands(())
+        self.query_one("#approval-menu", SlashMenu).set_commands(())
+        self.submit_op(Answer(request_id, answer or ""))
+        self._ui_state.phase = "thinking" if self._busy else "idle"
+        self._ui_state.detail = "resuming" if self._busy else "ready"
+        prompt = self.query_one("#prompt", PromptInput)
+        prompt.submit_on_enter = True
+        prompt.disabled = False
+        self._update_composer_hint()

coding_agent/tui/screens/context.py

@@ -0,0 +1,195 @@
+"""Context inspector."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from rich.text import Text
+from textual import events
+from textual.binding import Binding
+from textual.containers import Container, Horizontal
+from textual.widgets import Static
+
+from coding_agent.tui.screens.modal import EmptyState, ModalBase, ModalCloseButton, ModalScroll
+from coding_agent.tui.theme import CONTEXT_MODAL_CSS
+from core_harness.context import ContextMessage, ContextReport
+
+_ROLE_COLORS = {
+    "system": "#738794",
+    "user": "#8eafc2",
+    "assistant": "#c7b66e",
+    "tool": "#79a985",
+}
+
+_ROLE_SHORT = {
+    "system": "SYS",
+    "user": "MSG",
+    "assistant": "AST",
+    "tool": "TOOL",
+}
+
+
+def _token_label(value: int) -> str:
+    if value >= 10_000:
+        return f"{value / 1000:.1f}k"
+    return f"{value:,}"
+
+
+def _meter_bar(fraction: float, width: int = 22) -> str:
+    clamped = max(0.0, min(1.0, fraction))
+    filled = int(round(clamped * width))
+    return "█" * filled + "░" * (width - filled)
+
+
+class ContextBucketChip(Static, can_focus=True):
+    """Clickable role filter for the context breakdown."""
+
+    def __init__(self, role: str, caption: str, *, active: bool = False) -> None:
+        self.role = role
+        classes = "context-chip context-chip-active" if active else "context-chip"
+        super().__init__(caption, classes=classes)
+
+    def on_click(self, event: events.Click) -> None:
+        event.stop()
+        screen = self.screen
+        if isinstance(screen, ContextModal):
+            screen.set_filter(self.role)
+
+    def on_key(self, event: events.Key) -> None:
+        if event.key in {"enter", "space"}:
+            event.stop()
+            screen = self.screen
+            if isinstance(screen, ContextModal):
+                screen.set_filter(self.role)
+
+
+class ContextModal(ModalBase[None]):
+    """Small interactive breakdown of model context."""
+
+    CSS = CONTEXT_MODAL_CSS
+    BINDINGS = [
+        Binding("escape", "close_modal", "Close", show=False, priority=True),
+        Binding("left", "prev_filter", "Previous", show=False),
+        Binding("right", "next_filter", "Next", show=False),
+    ]
+
+    def __init__(self, report: ContextReport) -> None:
+        super().__init__()
+        self.report = report
+        self._filter: Optional[str] = None
+        self._filters: tuple[str, ...] = ("all",) + tuple(
+            bucket.role for bucket in report.buckets if bucket.count
+        )
+
+    def compose(self):  # type: ignore[no-untyped-def]
+        with Container(id="context-pane", classes="modal-pane"):
+            with Horizontal(id="context-header"):
+                yield Static("Context", id="context-title")
+                yield ModalCloseButton("Esc", id="modal-close")
+            yield Static(self._render_meters(), id="context-meters")
+            with Horizontal(id="context-buckets"):
+                for role, caption in self._chip_captions():
+                    yield ContextBucketChip(role, caption, active=role == "all")
+            yield Static(self._render_meta(), id="context-meta")
+            with ModalScroll(id="context-body", classes="modal-body"):
+                if not self.report.messages:
+                    yield EmptyState(
+                        "No conversation yet",
+                        "Send a prompt first. /context then splits messages vs tool results.",
+                    )
+                else:
+                    yield Static(self._render_rows(), id="context-list", markup=False)
+            yield Static(
+                "← → switch view   ·   click to filter",
+                id="context-hint",
+                classes="modal-footer",
+            )
+
+    def set_filter(self, role: str) -> None:
+        self._filter = None if role in {"", "all"} else role
+        self._refresh()
+
+    def action_prev_filter(self) -> None:
+        self._nudge_filter(-1)
+
+    def action_next_filter(self) -> None:
+        self._nudge_filter(1)
+
+    def _nudge_filter(self, step: int) -> None:
+        current = self._filter or "all"
+        if current not in self._filters:
+            current = "all"
+        index = self._filters.index(current)
+        self.set_filter(self._filters[(index + step) % len(self._filters)])
+
+    def _chip_captions(self) -> list[tuple[str, str]]:
+        chips = [("all", f"All  {_token_label(self.report.stored_tokens)}")]
+        for bucket in self.report.buckets:
+            if not bucket.count:
+                continue
+            chips.append(
+                (bucket.role, f"{bucket.label}  {_token_label(bucket.tokens)}")
+            )
+        return chips
+
+    def _render_meters(self) -> Text:
+        stored = self.report.stored_tokens
+        limit = self.report.context_limit
+        stored_frac = stored / limit if limit else 0.0
+        text = Text()
+        text.append("context ", style="#686868")
+        text.append(f"{stored:,}", style="bold #d0d0d0")
+        text.append(" tok   ", style="#686868")
+        text.append(_meter_bar(stored_frac), style="#8eafc2")
+        if limit:
+            text.append(f"  {min(stored_frac * 100, 100):.0f}% of {limit:,}", style="#686868")
+        return text
+
+    def _render_meta(self) -> str:
+        active = "all messages" if self._filter is None else f"{self._filter} only"
+        meta = (
+            f"{self.report.message_count} messages  ·  "
+            f"{self.report.tool_result_count} tool results"
+        )
+        if self.report.stubbed_result_count:
+            meta += f"  ·  {self.report.stubbed_result_count} legacy stubs"
+        return f"{meta}  ·  {active}"
+
+    def _visible_messages(self) -> tuple[ContextMessage, ...]:
+        if self._filter is None:
+            return self.report.messages
+        return tuple(item for item in self.report.messages if item.role == self._filter)
+
+    def _render_rows(self) -> Text:
+        rows = Text()
+        visible = self._visible_messages()
+        if not visible:
+            rows.append("Nothing in this bucket.", style="#686868")
+            return rows
+        rows.append("TYPE  TOKENS  STATE   CONTENT\n", style="#555555")
+        for item in visible:
+            color = _ROLE_COLORS.get(item.role, "#bdbdbd")
+            short = _ROLE_SHORT.get(item.role, item.role[:3].upper())
+            rows.append(f"{short:<4} ", style=color)
+            rows.append(f"{_token_label(item.tokens):>6}", style="#c8c8c8")
+            if item.stubbed:
+                rows.append("  stub", style="#c67b82")
+            elif item.role == "tool":
+                rows.append("  full", style="#686868")
+            else:
+                rows.append("      ", style="#101010")
+            label = item.tool_name or item.preview
+            if item.tool_name and item.preview:
+                label = f"{item.tool_name} · {item.preview}"
+            rows.append(f"  {label[:64]}", style="#8a8a8a")
+            rows.append("\n")
+        return rows
+
+    def _refresh(self) -> None:
+        self.query_one("#context-meta", Static).update(self._render_meta())
+        listing = self.query("#context-list")
+        if listing:
+            listing.first().update(self._render_rows())
+        current = self._filter or "all"
+        for chip in self.query(ContextBucketChip):
+            chip.set_class(chip.role == current, "context-chip-active")

coding_agent/tui/screens/dashboard.py

@@ -0,0 +1,91 @@
+"""Live view of Symphony agents and the CPU, memory, and disk they use.
+
+The layout matches the subagent task list (``ctrl+g``): a centered option
+list whose rows refresh in place. Open it with ``/dashboard``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rich.text import Text
+from textual.widgets import OptionList
+from textual.widgets.option_list import Option
+
+from coding_agent.addons.persistence.active import ActiveSession, list_active
+from coding_agent.resources.usage import sample_usage
+from coding_agent.tui.screens.modal import ModalBase
+
+
+_KIND_COLOR = {"tui": "#d7a84b", "run": "#72a57a"}
+
+
+@dataclass
+class _Sample:
+    cpu_seconds: float | None = None
+    sampled_at: float | None = None
+
+
+class AgentDashboard(ModalBase[None]):
+    """Small list of every live Symphony agent and its resource use."""
+
+    CSS = """
+    AgentDashboard { align: center middle; background: #000000 60%; }
+    #agent-dashboard { width: 90%; height: 70%; border: round #484F58; background: #0A0A0A; }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._samples: dict[int, _Sample] = {}
+
+    def compose(self):  # type: ignore[no-untyped-def]
+        yield OptionList(id="agent-dashboard")
+
+    def on_mount(self) -> None:
+        self.query_one(OptionList).border_title = "Agents · CPU  RAM  disk · Esc back"
+        self.refresh_agents()
+        self.set_interval(1, self.refresh_agents)
+        self.query_one(OptionList).focus()
+
+    def refresh_agents(self) -> None:
+        options = self.query_one(OptionList)
+        highlighted = options.highlighted
+        options.clear_options()
+        records = list_active()
+        seen: set[int] = set()
+        for record in records:
+            seen.add(record.pid)
+            options.add_option(Option(self._row(record), id=str(record.pid)))
+        self._samples = {pid: sample for pid, sample in self._samples.items() if pid in seen}
+        if not records:
+            options.add_option(Option("No agents are running.", disabled=True))
+        else:
+            options.highlighted = min(highlighted or 0, len(records) - 1)
+
+    def _row(self, record: ActiveSession) -> Text:
+        previous = self._samples.get(record.pid, _Sample())
+        usage, cpu_seconds, sampled_at = sample_usage(
+            record.pid,
+            workspace=record.workspace or None,
+            previous_cpu_seconds=previous.cpu_seconds,
+            previous_at=previous.sampled_at,
+        )
+        self._samples[record.pid] = _Sample(cpu_seconds, sampled_at)
+        color = _KIND_COLOR.get(record.kind, "#a2adb8")
+        label = record.label.strip() or _workspace_name(record.workspace) or record.session_id[:8]
+        content = Text(f"{record.kind:4} ", style=color)
+        content.append(f"{_clip(label, 24):<24} ")
+        content.append(f"{_clip(record.model_id or 'model unset', 24):<24}", style="#737373")
+        content.append(f"  {usage.line()}", style="#a2adb8")
+        return content
+
+
+def _workspace_name(workspace: str) -> str:
+    return workspace.rstrip("/").rsplit("/", 1)[-1]
+
+
+def _clip(value: str, limit: int) -> str:
+    text = " ".join(value.split())
+    if len(text) <= limit:
+        return text
+    return text[: limit - 1].rstrip() + "…"