alysis-code 0.13.0__py3-none-any.whl

alysis_code/cli_impl/tui/state.py

@@ -0,0 +1,101 @@
+"""Mutable view-model for the full-screen TUI.
+
+Holds only what the footer/header need to render. The footer HUD fields
+(``context_pct`` / ``tokens`` / ``cost_usd``) are wired live: ``loop.py`` seeds
+them when the session is built and refreshes them after each turn (and mid-turn,
+throttled) from the session's usage summary + context cache. Other fields are
+toggled by the user via Tab (persona) / Shift+Tab (execution mode).
+
+``exec_mode`` mirrors ``session.mode`` and is the single authority for what the
+agent is allowed to do without asking. There is deliberately no second
+approval-policy flag here: an independent "auto-approve" toggle could silently
+answer every gate that ``review`` mode raised, leaving the footer advertising a
+guarded mode while the session behaved like ``fullaccess``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+PLAN_MODE = "plan"
+ACT_MODE = "act"
+
+# Shift+Tab cycles the execution mode in this order (wrapping). This is the same
+# set the /mode picker offers, kept in escalating-capability order so the cycle
+# reads as "loosen the guards one notch" rather than an arbitrary rotation.
+# ``fullaccess`` is included deliberately — the caller echoes its warning every
+# time the cycle lands there, so reaching the unguarded mode is never silent.
+EXEC_MODE_CYCLE: tuple[str, ...] = ("readonly", "review", "auto", "fullaccess")
+
+
+def next_exec_mode(current: str) -> str:
+    """Return the execution mode one step along :data:`EXEC_MODE_CYCLE`.
+
+    An unknown or empty ``current`` starts the cycle at its first entry, so a
+    session whose mode has not been synced yet still advances predictably
+    instead of raising.
+    """
+    normalized = str(current or "").strip().lower()
+    try:
+        index = EXEC_MODE_CYCLE.index(normalized)
+    except ValueError:
+        return EXEC_MODE_CYCLE[0]
+    return EXEC_MODE_CYCLE[(index + 1) % len(EXEC_MODE_CYCLE)]
+
+
+@dataclass
+class TuiState:
+    model_name: str = ""
+    # Non-empty while the shell is available but model calls are not (for
+    # example, a selected subscription still needs browser authentication).
+    connection_status: str = ""
+    tokens: int = 0
+    # Session cost. ``None`` means pricing is unknown (an unmetered/free model with
+    # real usage) — the footer renders that as "n/a" rather than a misleading
+    # "$0.0000". A literal 0.0 means nothing has been spent yet.
+    cost_usd: float | None = 0.0
+    cost_unknown_calls: int = 0  # calls whose cost couldn't be metered (footer "+N")
+    # Preformatted billing status (for example ``subscription`` or ``~$0.0123``).
+    # Empty retains the legacy numeric fallback for callers that do not have a
+    # UsageSummary available yet.
+    cost_display: str = ""
+    mode: str = ACT_MODE  # "plan" | "act"
+    exec_mode: str = ""  # execution mode: review | auto | readonly | fullaccess
+    # Active persona (code|architect|ask|debug); "" or "code" renders no
+    # persona badge — the execution-mode badge alone stays authoritative.
+    persona: str = ""
+    # Forge: True while the user is inside a Forge planning session (ui_mode ==
+    # "forge"); drives the footer FORGE badge + the forge-specific placeholder.
+    forge_mode: bool = False
+    forge_run_id: str = ""  # short run id shown in the FORGE badge, e.g. "run-1a2b"
+    # Name of the subagent currently running through auto-delegation; drives
+    # the footer badge so the user knows nested work is active. Empty otherwise.
+    active_subagent: str = ""
+    # Every concurrently running subagent, in start order. ``active_subagent``
+    # remains the compatibility view of the most recently started survivor.
+    active_subagents: tuple[str, ...] = ()
+    username: str = ""
+    workspace: str = ""  # short display form, e.g. "~/coder-plugin-install"
+    branch: str = ""  # git branch name, e.g. "feat/tui-rebuild"
+    usage_hud_enabled: bool = True
+    # Conversation headroom %, seeded from the session before first paint.
+    # ``None`` means "not measured yet" so a failed compute reads n/a in the
+    # footer instead of a fabricated 100%.
+    context_pct: float | None = None
+
+    @property
+    def plan_mode(self) -> bool:
+        return self.mode == PLAN_MODE
+
+    def toggle_mode(self) -> str:
+        self.mode = PLAN_MODE if self.mode == ACT_MODE else ACT_MODE
+        return self.mode
+
+
+__all__ = [
+    "TuiState",
+    "PLAN_MODE",
+    "ACT_MODE",
+    "EXEC_MODE_CYCLE",
+    "next_exec_mode",
+]

alysis_code/cli_impl/tui/subagent_identity.py

@@ -0,0 +1,66 @@
+"""Per-subagent visual identity — accent colour only.
+
+One tiny authority (like ``forge_status``) so the transcript spawn line, the
+live status, and the footer badge can never disagree about who a given
+subagent is. Activity comes from runtime events, never from role narration.
+Result attribution prints the registry name alone and deliberately does not
+consult this module — a subagent wears no per-agent symbol, so there is
+nothing to keep in sync.
+
+The name is the identity: the shared ``↪``/``↩`` marks say only that a nested
+run started or ended, never which agent it was. Colours are distinct from the
+fixed mode accents (green chat, violet forge, cyan brand) so a
+subagent badge never impersonates a mode. Custom subagents get a colour picked
+deterministically from the name — the same agent looks the same every run.
+"""
+
+from __future__ import annotations
+
+import zlib
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class SubagentIdentity:
+    color: str
+
+
+_BUILTIN_IDENTITIES: dict[str, SubagentIdentity] = {
+    "frontend-engineer": SubagentIdentity("#a371f7"),
+    # Silver keeps delegated work visually distinct from the main modes.
+    "visual-designer": SubagentIdentity("#c9d1d9"),
+    "explorer": SubagentIdentity("#58a6ff"),
+    "implementer": SubagentIdentity("#f0883e"),
+    "debugger": SubagentIdentity("#f47067"),
+    "verifier": SubagentIdentity("#79c0ff"),
+    "code-reviewer": SubagentIdentity("#db61a2"),
+    "dependency-scout": SubagentIdentity("#8c959f"),
+}
+
+_FALLBACK_COLORS: tuple[str, ...] = (
+    "#58a6ff",
+    "#f0883e",
+    "#db61a2",
+    "#39c5cf",
+    "#f47067",
+    "#d2a8ff",
+)
+
+
+def subagent_identity(name: str) -> SubagentIdentity:
+    """Identity for ``name`` (built-in aliases resolved, e.g. explore→explorer)."""
+    clean = str(name or "").strip().lower()
+    try:
+        from ...subagents import canonical_subagent_name
+
+        clean = canonical_subagent_name(clean) or clean
+    except Exception:  # noqa: BLE001 - identity lookup must never raise
+        pass
+    known = _BUILTIN_IDENTITIES.get(clean)
+    if known is not None:
+        return known
+    digest = zlib.crc32(clean.encode("utf-8", "replace"))
+    return SubagentIdentity(_FALLBACK_COLORS[digest % len(_FALLBACK_COLORS)])
+
+
+__all__ = ["SubagentIdentity", "subagent_identity"]

alysis_code/cli_impl/tui/subagent_panel.py

@@ -0,0 +1,186 @@
+"""Pure row construction for the terminal TUI's live subagent panel.
+
+The panel is a bounded live tail, not a transcript.  This module deliberately
+owns no prompt_toolkit state: callers supply the latest child status and the
+entries accumulated from incremental scheduler reads.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ...subagent_labels import subagent_identity
+
+ENTRY_BUFFER_CAP = 240
+
+_MIDDLE_DOT = "\u00b7"
+_ELLIPSIS = "\u2026"
+
+_S_HEAD = "class:tui.subpanel.head"
+_S_STATE = "class:tui.subpanel.state"
+_S_DIM = "class:tui.subpanel.dim"
+_S_TOOL = "class:tui.subpanel.tool"
+_S_RESULT = "class:tui.subpanel.result"
+_S_ASSISTANT = "class:tui.subpanel.assistant"
+_S_USER = "class:tui.subpanel.user"
+_S_HINT = "class:tui.subpanel.hint"
+
+_ENTRY_STYLE = {
+    "tool": (_S_TOOL, "\u25b8 "),
+    "tool_result": (_S_RESULT, "\u2713 "),
+    "tool_error": (_S_RESULT, "\u2717 "),
+    "assistant": (_S_ASSISTANT, "a: "),
+    "user": (_S_USER, "u: "),
+}
+
+
+def append_bounded_entries(
+    existing: list[dict[str, str]],
+    incoming: list[dict[str, str]],
+    *,
+    limit: int = ENTRY_BUFFER_CAP,
+) -> list[dict[str, str]]:
+    """Append normalized entries while retaining only the newest ``limit``."""
+    cap = max(1, int(limit))
+    combined = [*existing, *incoming]
+    return combined[-cap:]
+
+
+def _fit_segments(segments: list[tuple[str, str]], width: int) -> list[tuple[str, str]]:
+    out: list[tuple[str, str]] = []
+    used = 0
+    for style, value in segments:
+        text = str(value or "")
+        if not text:
+            continue
+        room = width - used
+        if room <= 0:
+            break
+        if len(text) <= room:
+            out.append((style, text))
+            used += len(text)
+            continue
+        clipped = text[: room - 1].rstrip() + _ELLIPSIS if room >= 2 else _ELLIPSIS
+        out.append((style, clipped[:room]))
+        break
+    return out
+
+
+def _elapsed_label(value: Any) -> str:
+    try:
+        elapsed_ms = max(0, int(value or 0))
+    except (TypeError, ValueError):
+        elapsed_ms = 0
+    if elapsed_ms < 1000:
+        return f"{elapsed_ms}ms"
+    seconds = elapsed_ms // 1000
+    if seconds < 60:
+        return f"{seconds}s"
+    minutes, seconds = divmod(seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m {seconds}s"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h {minutes}m"
+
+
+def quiet_time_label(status: dict[str, Any]) -> str:
+    """Return a deterministic quiet-age label once the existing interval passes."""
+    if str(status.get("state") or "").strip().lower() != "running":
+        return ""
+    try:
+        age_s = max(0.0, float(status.get("last_event_age_s") or 0.0))
+        threshold_s = max(0.0, float(status.get("activity_threshold_s") or 0.0))
+    except (TypeError, ValueError):
+        return ""
+    if threshold_s <= 0.0 or age_s < threshold_s:
+        return ""
+    return f"quiet {_elapsed_label(int(age_s * 1000))}"
+
+
+def _header_row(
+    status: dict[str, Any],
+    *,
+    width: int,
+    position: int,
+    total: int,
+) -> list[tuple[str, str]]:
+    name = subagent_identity(
+        status.get("subagent") or status.get("run_id") or "subagent",
+        status.get("label"),
+    )
+    state = str(status.get("state") or "unknown").strip()
+    workspace = str(status.get("workspace_view") or "shared").strip()
+    try:
+        steps = max(0, int(status.get("steps_completed") or 0))
+    except (TypeError, ValueError):
+        steps = 0
+    separator = f" {_MIDDLE_DOT} "
+    quiet = quiet_time_label(status)
+    return _fit_segments(
+        [
+            (_S_HEAD, name),
+            (_S_DIM, separator),
+            (_S_STATE, state),
+            (_S_DIM, separator),
+            (_S_DIM, _elapsed_label(status.get("elapsed_ms"))),
+            (_S_DIM, separator),
+            (_S_DIM, f"{steps} step{'s' if steps != 1 else ''}"),
+            (_S_DIM, separator),
+            (_S_DIM, workspace),
+            (_S_DIM, separator if quiet else ""),
+            (_S_DIM, quiet),
+            (_S_DIM, f"    view {max(1, position)}/{max(1, total)}"),
+        ],
+        width,
+    )
+
+
+def _entry_rows(entry: dict[str, str], width: int) -> list[list[tuple[str, str]]]:
+    kind = str(entry.get("kind") or "").strip()
+    style, lead = _ENTRY_STYLE.get(kind, (_S_DIM, "- "))
+    summary = " ".join(str(entry.get("summary") or "").split())
+    return [_fit_segments([(_S_DIM, lead), (style, summary)], width)]
+
+
+def subagent_panel_rows(
+    status: dict[str, Any],
+    entries: list[dict[str, str]],
+    *,
+    width: int,
+    height: int,
+    position: int,
+    total: int,
+) -> list[list[tuple[str, str]]]:
+    """Render header, newest body entries, and footer within ``height`` rows."""
+    width = max(12, int(width))
+    height = max(2, int(height))
+    body_height = max(0, height - 2)
+    selected: list[list[list[tuple[str, str]]]] = []
+    used = 0
+    for entry in reversed(entries):
+        wrapped = _entry_rows(entry, width)
+        if used and used + len(wrapped) > body_height:
+            break
+        room = body_height - used
+        if room <= 0:
+            break
+        selected.append(wrapped[:room])
+        used += min(len(wrapped), room)
+    body_rows = [row for group in reversed(selected) for row in group]
+    footer = _fit_segments(
+        [(_S_HINT, f"ctrl+b / ctrl+n to switch {_MIDDLE_DOT} esc to close")],
+        width,
+    )
+    return [
+        _header_row(status, width=width, position=position, total=total),
+        *body_rows,
+        footer,
+    ]
+
+
+__all__ = [
+    "ENTRY_BUFFER_CAP",
+    "append_bounded_entries",
+    "quiet_time_label",
+    "subagent_panel_rows",
+]