symphony-code 0.0.1__py3-none-any.whl

coding_agent/tui/chrome/footer.py

@@ -0,0 +1,274 @@
+"""Footer with workspace, context utilisation, and the active keyboard hint."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+from rich.console import Console, ConsoleOptions, Group, RenderResult
+from rich.table import Table
+from rich.text import Text
+from textual.widgets import Static
+
+from coding_agent.tui.theme import SYMPHONY_COLORS
+
+if TYPE_CHECKING:
+    from coding_agent.tui.runtime.state import RunMetrics, UiRunState
+
+SEGMENT_SEPARATOR = "   |   "
+IDLE_HINT = "esc cancel"
+QUESTION_HINT = "↵ approve   ↑↓ choose   esc deny"
+# Context stays a left-to-right block meter. These thresholds only recolor it,
+# the same way claude-hud warns as the window fills.
+CONTEXT_WARN = 70
+CONTEXT_CRITICAL = 85
+
+
+def footer_hint(*, question_pending: bool) -> str:
+    """Keyboard hint shown as the footer's last segment."""
+    return QUESTION_HINT if question_pending else IDLE_HINT
+
+
+def context_percent(metrics: RunMetrics) -> Optional[int]:
+    """Context-window utilisation as a whole percentage, or None when unknown."""
+    utilization = metrics.utilization
+    if utilization is None and metrics.context_limit:
+        if metrics.context_left is not None:
+            utilization = 1 - (metrics.context_left / metrics.context_limit)
+        else:
+            tokens = metrics.tokens_used or metrics.cumulative_tokens or metrics.total_tokens
+            utilization = tokens / metrics.context_limit
+    if utilization is None:
+        return None
+    return round(max(0.0, min(utilization, 1.0)) * 100)
+
+
+def footer_segments(state: UiRunState, *, hint: str) -> tuple[str, ...]:
+    """Return the context label, meter, and keyboard hint in display order."""
+    metrics = state.metrics
+    percent = context_percent(metrics)
+    label = f"{percent}% context" if percent is not None else "context unknown"
+    return (label, _context_count(metrics), hint)
+
+
+def _context_count(metrics: RunMetrics) -> str:
+    tokens = metrics.tokens_used or metrics.total_tokens or metrics.cumulative_tokens
+    if metrics.context_limit is not None:
+        return f"{tokens:,}/{metrics.context_limit:,}"
+    return f"{tokens:,}" if tokens else "—"
+
+
+def context_bar(state: UiRunState, *, width: int = 18) -> Text:
+    """Render a heavier left-to-right context meter followed by token counts.
+
+    The meter deliberately sits between the context label and its count: the
+    label is its anchor on the left, while the count anchors the right edge of
+    this small cluster. Full block glyphs make the one-line meter read more
+    clearly than the previous thin box-drawing line.
+    """
+    metrics = state.metrics
+    percent = context_percent(metrics) or 0
+    filled = round(max(0, min(percent, 100)) * width / 100)
+    tokens = metrics.tokens_used or metrics.total_tokens or metrics.cumulative_tokens
+    limit = metrics.context_limit
+    count = f"{tokens:,}/{limit:,}" if limit is not None else f"{tokens:,}"
+    result = Text()
+    # Usage fills from left to right. The glyph run is unchanged; only the
+    # fill color steps from accent to warning to critical as the window fills.
+    if percent >= CONTEXT_CRITICAL:
+        fill = SYMPHONY_COLORS["keyword"]
+    elif percent >= CONTEXT_WARN:
+        fill = SYMPHONY_COLORS["number"]
+    else:
+        fill = SYMPHONY_COLORS["accent"]
+    result.append("█" * filled, style=fill)
+    result.append("░" * (width - filled), style=SYMPHONY_COLORS["muted_dim"])
+    result.append(f" {count}")
+    return result
+
+
+def phase_label(state: UiRunState) -> str:
+    """Quiet left-hand activity word; empty while idle so the footer stays clean."""
+    if state.phase == "idle":
+        return ""
+    labels = {
+        "thinking": "thinking",
+        "streaming": "streaming",
+        "tool": "tool",
+        "paused": "paused",
+    }
+    return labels.get(state.phase, "working")
+
+
+def _phase_style(phase: str) -> str:
+    if phase == "paused":
+        return f"bold {SYMPHONY_COLORS['keyword']}"
+    if phase == "tool":
+        return f"bold {SYMPHONY_COLORS['number']}"
+    if phase == "thinking":
+        return f"bold {SYMPHONY_COLORS['function']}"
+    return f"bold {SYMPHONY_COLORS['string']}"
+
+
+@dataclass(frozen=True)
+class ResponsiveFooter:
+    """Rich renderable which preserves useful footer content as width changes."""
+
+    state: UiRunState
+    hint: str
+    workspace: str = ""
+
+    def __rich_console__(
+        self,
+        _console: Console,
+        options: ConsoleOptions,
+    ) -> RenderResult:
+        yield self._table(max(options.max_width, 1))
+
+    def _usage(self, *, meter: bool, count: bool) -> Text:
+        percent = context_percent(self.state.metrics)
+        label = f"{percent}% context" if percent is not None else "context unknown"
+        usage = Text(label, style=SYMPHONY_COLORS["foreground"], no_wrap=True)
+        if meter and percent is not None:
+            usage.append(SEGMENT_SEPARATOR, style=SYMPHONY_COLORS["edge"])
+            usage.append_text(context_bar(self.state))
+        elif count and percent is not None:
+            usage.append(" ")
+            usage.append(_context_count(self.state.metrics))
+        return usage
+
+    def _table(self, width: int) -> Table:
+        # The keyboard hint and context label are the two invariant pieces.
+        # Add the count, meter, activity and path only when each fits without
+        # forcing Rich to turn the invariant pieces into unreadable fragments.
+        label = self._usage(meter=False, count=False)
+        counted = self._usage(meter=False, count=True)
+        metered = self._usage(meter=True, count=True)
+        gap = 3
+        available = max(width - len(self.hint) - gap, 1)
+        usage = metered if len(metered.plain) <= available else counted
+        if len(usage.plain) > available:
+            usage = label
+
+        prefix = Text(no_wrap=True)
+        phase = phase_label(self.state)
+        # Phase and path are leftovers. They must not steal width from the
+        # context meter, or a live run drops the progress bar.
+        phase_cost = (len(phase) + 3) if phase else 0
+        remaining = available - len(usage.plain) - len(SEGMENT_SEPARATOR) - phase_cost
+        if phase and remaining >= 0:
+            prefix.append(phase, style=_phase_style(self.state.phase))
+        if self.workspace and remaining >= 8:
+            if prefix.plain:
+                prefix.append(SEGMENT_SEPARATOR, style=SYMPHONY_COLORS["edge"])
+            prefix.append(self.workspace, style=SYMPHONY_COLORS["muted"])
+
+        table = Table.grid(expand=True, padding=0)
+        if prefix.plain:
+            table.add_column(ratio=1, overflow="ellipsis", no_wrap=True)
+            table.add_column(no_wrap=True)
+            table.add_column(no_wrap=True)
+        else:
+            table.add_column(ratio=1, overflow="ellipsis", no_wrap=True)
+        table.add_column(justify="right", overflow="ellipsis", no_wrap=True)
+        right = Text(
+            f"{gap * ' '}{self.hint}",
+            style=SYMPHONY_COLORS["subtext"],
+            overflow="ellipsis",
+            no_wrap=True,
+        )
+        if prefix.plain:
+            separator = Text(SEGMENT_SEPARATOR, style=SYMPHONY_COLORS["edge"])
+            table.add_row(prefix, separator, usage, right)
+        else:
+            table.add_row(usage, right)
+        return table
+
+
+def render_footer(
+    state: UiRunState,
+    *,
+    hint: str,
+    workspace: str = "",
+) -> ResponsiveFooter:
+    """Render a footer that adapts its detail to the available terminal width."""
+    return ResponsiveFooter(state=state, hint=hint, workspace=workspace)
+
+
+DEFAULT_HINT = "Press ctrl+q to quit the app"
+
+
+def update_banner(event_type: str, payload: Optional[dict] = None) -> tuple[str, str] | None:
+    """Build the composer banner for one harness or UI event.
+
+    This is the same banner a model switch uses. ``None`` means the event
+    does not belong above the composer. The second string is the hint line.
+    """
+    payload = payload or {}
+    if event_type == "run_failed":
+        message = str(payload.get("message") or payload.get("error") or "").strip() or "The run failed."
+        lowered = message.lower()
+        if "bad_record_mac" in lowered or "bad record mac" in lowered:
+            message = "SSL connection failed · bad record mac. Try the turn again."
+        elif "ssl" in lowered or "certificate" in lowered:
+            message = f"SSL connection failed · {message}"
+        return message, DEFAULT_HINT
+    if event_type == "run_cancelled":
+        reason = str(payload.get("reason") or "Cancelled").replace("_", " ")
+        return reason[:1].upper() + reason[1:], "esc already pressed"
+    if event_type == "run_limit_exceeded":
+        limit = payload.get("limit") or "run limit"
+        message = str(payload.get("message") or f"Harness exceeded {limit}")
+        return message, DEFAULT_HINT
+    if event_type == "cancelling":
+        return "Cancelling…", "esc already pressed"
+    if event_type in {"model_changed", "effort_changed", "mode_changed", "personality_changed", "reloaded"}:
+        text = str(payload.get("text") or "").strip()
+        return (text, DEFAULT_HINT) if text else None
+    return None
+
+
+class ComposerOverlay(Static):
+    """A short-lived banner above the composer, matching the interrupt card."""
+
+    def __init__(self) -> None:
+        super().__init__(id="composer-overlay")
+        self.title = ""
+        self.hint = DEFAULT_HINT
+        self._hide_timer: Optional[object] = None
+        self.display = False
+
+    def show(self, title: str, hint: str = DEFAULT_HINT, *, seconds: float = 3.2) -> None:
+        """Replace the current overlay contents and restart the hide timer."""
+        self.title = title
+        self.hint = hint
+        body = Group(
+            Text(title, style=f"bold {SYMPHONY_COLORS['string']}"),
+            Text.from_markup(self._hint_markup(hint), style=SYMPHONY_COLORS["foreground"]),
+        )
+        self.update(body)
+        self.display = True
+        if self._hide_timer is not None:
+            self._hide_timer.stop()
+        self._hide_timer = self.set_timer(seconds, self.hide)
+
+    def hide(self) -> None:
+        self.display = False
+        self.title = ""
+        self.hint = DEFAULT_HINT
+        if self._hide_timer is not None:
+            self._hide_timer.stop()
+            self._hide_timer = None
+
+    @staticmethod
+    def _hint_markup(hint: str) -> str:
+        """Emphasize the first ctrl+key chord in the hint line."""
+        lowered = hint.lower()
+        marker = "ctrl+"
+        index = lowered.find(marker)
+        if index < 0:
+            return hint
+        end = index + len(marker)
+        while end < len(hint) and hint[end].isalnum():
+            end += 1
+        return f"{hint[:index]}[b]{hint[index:end]}[/b]{hint[end:]}"

coding_agent/tui/chrome/topbar.py

@@ -0,0 +1,259 @@
+"""Top bar: branch on the left, lab mark and model on the right.
+
+The mark is a single colored glyph. A terminal image widget was tried for the
+real SVG and rejected: assigning its image refreshes layout, and doing that
+from resize made the whole UI relayout forever, which froze scrolling.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Any, Optional
+
+from rich.cells import cell_len
+from rich.table import Table
+from rich.text import Text
+from textual import events
+from textual.widgets import Static
+
+from coding_agent.config.personalities import project_root
+from coding_agent.tui.theme import SYMPHONY_COLORS
+
+CLUSTER_GAP = " " * 4
+BRANCH_ICON = "⎇"
+
+
+def display_workspace_path(workspace: Path, home: Optional[Path] = None) -> str:
+    """Render a workspace path with the home directory collapsed to `~`."""
+    home = (home or Path.home()).resolve()
+    workspace = workspace.resolve()
+    if workspace == home:
+        return "~"
+    try:
+        relative = workspace.relative_to(home)
+    except ValueError:
+        return str(workspace)
+    return f"~/{relative.as_posix()}"
+
+
+def read_git_branch(workspace: Path) -> str:
+    """Return the checked-out branch for the repository containing `workspace`."""
+    git_dir = _locate_git_dir(workspace.resolve())
+    if git_dir is None:
+        return ""
+    try:
+        head = (git_dir / "HEAD").read_text(encoding="utf-8").strip()
+    except OSError:
+        return ""
+    if head.startswith("ref:"):
+        return head.removeprefix("ref:").strip().removeprefix("refs/heads/")
+    return head[:7]
+
+
+def read_git_dirty(workspace: Path) -> bool:
+    """True when the worktree has uncommitted changes. Never raises.
+
+    ``git status`` walks the worktree, so callers on the UI thread should not
+    run this on a short interval. The top bar probes it from a thread worker.
+    """
+    try:
+        probe = subprocess.run(
+            ["git", "-C", str(workspace), "status", "--porcelain", "--untracked-files=no"],
+            capture_output=True,
+            text=True,
+            timeout=1.5,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return False
+    return bool(probe.stdout.strip())
+
+
+def short_model_name(model: str) -> str:
+    """Drop the provider prefix so the pill reads like a Claude status line."""
+    name = model.split(":", 1)[-1] if model else ""
+    return name or model
+
+
+def _locate_git_dir(start: Path) -> Optional[Path]:
+    root = project_root(start)
+    if root is None:
+        return None
+    marker = root / ".git"
+    if marker.is_dir():
+        return marker
+    if not marker.is_file():
+        return None
+    try:
+        pointer = marker.read_text(encoding="utf-8").strip()
+    except OSError:
+        return None
+    if pointer.startswith("gitdir:"):
+        target = Path(pointer.removeprefix("gitdir:").strip())
+        return target if target.is_absolute() else root / target
+    return None
+
+
+def topbar_text(*, branch: str = "", model: str = "") -> Text:
+    """Render branch and model."""
+    clusters: list[str] = []
+    if branch:
+        clusters.append(f"{BRANCH_ICON} {branch}")
+    if model:
+        clusters.append(short_model_name(model))
+    return Text(CLUSTER_GAP.join(clusters), no_wrap=True)
+
+
+class TopBar(Static):
+    """Header with the branch on the left and the lab mark plus model on the right."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self._branch = ""
+        self._dirty = False
+        self._model = ""
+        self._label = ""
+        self._auth = ""
+        self._workspace: Optional[Path] = None
+        self._branch_timer = None
+        self._dirty_probe = False
+        super().__init__(*args, **kwargs)
+
+    def on_mount(self) -> None:
+        """Poll Git's HEAD so checkouts made outside the TUI appear promptly.
+
+        The branch itself is a tiny HEAD read. The dirty mark needs
+        ``git status``, which is slow enough to hitch the UI, so that probe
+        runs on a thread and only every couple of seconds.
+        """
+        self._branch_timer = self.set_interval(0.5, self._refresh_branch)
+        self._dirty_timer = self.set_interval(2.0, self._schedule_dirty_probe)
+
+    def on_unmount(self) -> None:
+        if self._branch_timer is not None:
+            self._branch_timer.stop()
+            self._branch_timer = None
+        dirty_timer = getattr(self, "_dirty_timer", None)
+        if dirty_timer is not None:
+            dirty_timer.stop()
+            self._dirty_timer = None
+
+    def _refresh_branch(self) -> None:
+        if self._workspace is None:
+            return
+        branch = read_git_branch(self._workspace)
+        if branch == self._branch:
+            return
+        self._branch = branch
+        if not branch:
+            self._dirty = False
+        self.update(self._render_row(max(self.content_size.width, 1)))
+
+    def _schedule_dirty_probe(self) -> None:
+        """Start one background dirty check. Skip when the last one is running."""
+        if self._workspace is None or not self._branch or self._dirty_probe:
+            return
+        self._dirty_probe = True
+        self.run_worker(
+            self._probe_dirty,
+            name="git-dirty",
+            group="git-dirty",
+            exclusive=True,
+            thread=True,
+            exit_on_error=False,
+        )
+
+    def _probe_dirty(self) -> None:
+        workspace = self._workspace
+        dirty = read_git_dirty(workspace) if workspace is not None else False
+        self.app.call_from_thread(self._apply_dirty, dirty)
+
+    def _apply_dirty(self, dirty: bool) -> None:
+        self._dirty_probe = False
+        if dirty == self._dirty:
+            return
+        self._dirty = dirty
+        self.update(self._render_row(max(self.content_size.width, 1)))
+
+    def set_context(
+        self,
+        workspace: Path,
+        model: str = "",
+        *,
+        label: str = "",
+        auth: str = "",
+    ) -> None:
+        self._workspace = workspace
+        branch = read_git_branch(workspace)
+        model = model or ""
+        if (
+            branch == self._branch
+            and model == self._model
+            and label == self._label
+            and auth == self._auth
+        ):
+            return
+        self._branch = branch
+        self._model = model
+        self._label = label
+        self._auth = auth
+        self.update(self._render_row(max(self.content_size.width, 1)))
+
+    def on_resize(self, event: events.Resize) -> None:
+        """Rebudget the model whenever the terminal changes width.
+
+        This only replaces renderable text. It must not refresh layout: a
+        layout refresh from resize re-enters this handler and freezes scroll.
+        """
+        content_width = max(event.size.width - self.styles.gutter.width, 1)
+        self.update(self._render_row(content_width))
+
+    def _branch_text(self) -> Text:
+        branch_label = self._branch
+        if self._label:
+            branch_label = (
+                f"{branch_label}  ›  {self._label}" if branch_label else self._label
+            )
+        left = Text(no_wrap=True, overflow="ellipsis")
+        if branch_label:
+            left.append(f"{BRANCH_ICON} ", style=f"bold {SYMPHONY_COLORS['number']}")
+            left.append(branch_label, style=SYMPHONY_COLORS["foreground"])
+            if self._dirty:
+                left.append(" *", style=f"bold {SYMPHONY_COLORS['number']}")
+        return left
+
+    def _model_text(self, width: int) -> Text:
+        model = self._model
+        if width >= 48:
+            model = short_model_name(model)
+        if not model:
+            return Text()
+        return Text(model, style=f"bold {SYMPHONY_COLORS['accent']}", no_wrap=True, overflow="ellipsis")
+
+    def on_click(self, event: events.Click) -> None:
+        """The model name is the right-hand cluster. Clicking it opens /model.
+
+        The branch occupies the left of the row, so a click past the midpoint
+        is the model. Opening the existing picker avoids a second modal.
+        """
+        if not self._model or event.x < max(self.content_size.width // 2, 1):
+            return
+        event.stop()
+        show = getattr(self.app, "show_model_picker", None)
+        if callable(show):
+            show()
+
+    def _render_row(self, width: int) -> Table:
+        """Text row. Width budgets keep a narrow terminal from cropping the header."""
+        row = Table.grid(expand=True, padding=0)
+        model = self._model_text(width)
+        model_width = min(max(cell_len(model.plain), 1), max(width // 2, 1))
+        row.add_column(ratio=1, overflow="ellipsis", no_wrap=True)
+        row.add_column(
+            justify="right",
+            overflow="ellipsis",
+            no_wrap=True,
+            max_width=model_width,
+        )
+        row.add_row(self._branch_text(), model)
+        return row

coding_agent/tui/commands/__init__.py

@@ -0,0 +1,45 @@
+"""Slash-command catalogs and handlers for the coding-agent TUI."""
+
+from coding_agent.commands.catalog import (
+    EFFORT_CATALOG,
+    EFFORTS,
+    SLASH_COMMANDS,
+    EffortOption,
+    ModelOption,
+    PersonalityOption,
+    SlashCommand,
+    command_matches,
+    find_model,
+    find_personality,
+    model_matches,
+    model_options,
+    personality_matches,
+    personality_options,
+)
+from coding_agent.tui.commands.manager import (
+    CommandManager,
+    effort_matches,
+    effort_options_for_model,
+    model_supports_effort,
+)
+
+__all__ = [
+    "CommandManager",
+    "EFFORT_CATALOG",
+    "EFFORTS",
+    "EffortOption",
+    "model_options",
+    "ModelOption",
+    "PersonalityOption",
+    "SLASH_COMMANDS",
+    "SlashCommand",
+    "command_matches",
+    "effort_matches",
+    "effort_options_for_model",
+    "find_model",
+    "find_personality",
+    "model_matches",
+    "model_supports_effort",
+    "personality_matches",
+    "personality_options",
+]

coding_agent/tui/commands/catalog.py

@@ -0,0 +1,35 @@
+"""Moved to :mod:`coding_agent.commands.catalog`; this path re-exports it for one release."""
+
+from coding_agent.commands.catalog import (
+    EFFORT_CATALOG,
+    EFFORTS,
+    SLASH_COMMANDS,
+    EffortOption,
+    ModelOption,
+    PersonalityOption,
+    SlashCommand,
+    command_matches,
+    find_model,
+    find_personality,
+    model_matches,
+    model_options,
+    personality_matches,
+    personality_options,
+)
+
+__all__ = [
+    "EFFORT_CATALOG",
+    "EFFORTS",
+    "SLASH_COMMANDS",
+    "EffortOption",
+    "ModelOption",
+    "PersonalityOption",
+    "SlashCommand",
+    "command_matches",
+    "find_model",
+    "find_personality",
+    "model_matches",
+    "model_options",
+    "personality_matches",
+    "personality_options",
+]