alysis-code 0.13.0__py3-none-any.whl

alysis_code/cli_impl/tui/footer.py

@@ -0,0 +1,218 @@
+"""The pinned footer — Alysis Code's own status grammar (not a Cline clone).
+
+Two lines, each split left/right against the terminal width::
+
+    ◇ alysis · <Model>            context: <P>% left · <N> tokens · $<cost>
+    <persona> · <mode> · <user> · <workspace> · ⎇ <branch>
+
+The execution-mode badge on line 2 is the only approval indicator: it alone says
+what runs unattended and what stops to ask. Line 2 has no right half — the old
+``sensitive: ask``/``sensitive: auto`` tail was a second, independent switch that
+could auto-answer every prompt ``safe`` mode raised while the badge still read
+``safe``, so it was folded into the modes rather than kept alongside them.
+
+The left side is clipped (with an ellipsis) when it would collide with the
+right side, so the layout never wraps. Returned as prompt_toolkit
+``FormattedText`` with ``class:`` styles resolved by the application's Style.
+"""
+
+from __future__ import annotations
+
+from prompt_toolkit.formatted_text import FormattedText
+
+from .content import pretty_model_label
+from .state import TuiState
+
+_BRAND_MARK = "◇"
+_BRANCH_MARK = "⎇"
+_SUBAGENT_MARK = "↪"
+_DOT = "  ·  "
+
+# Compact labels for the execution-mode badge (full names live in the /mode popup).
+_MODE_SHORT = {
+    "review": "safe",
+    "auto": "fast",
+    "readonly": "read",
+    "fullaccess": "full",
+}
+
+# Full-word labels for the persona badge (state.persona is empty when persona
+# modes are disabled, which hides the half entirely). All four personas render
+# so the Tab cycle is always visible — including landing back on code. Full
+# words by deliberate choice: "dbg·fast" read as noise, "debug · fast" reads
+# as state.
+_PERSONA_SHORT = {
+    "code": "code",
+    "architect": "architect",
+    "ask": "ask",
+    "debug": "debug",
+}
+
+Fragments = list[tuple[str, str]]
+
+
+def _visible_len(fragments: Fragments) -> int:
+    return sum(len(text) for _style, text in fragments)
+
+
+def _format_context_left(pct: float | None) -> str:
+    """Render the context gauge honestly at integer resolution.
+
+    ``None`` (no successful measurement yet) reads ``n/a`` rather than a
+    fabricated number. ``100``/``0`` appear only when the window is genuinely
+    full/empty; any partially-used window reads 1–99, so a live session never
+    rounds up to a misleading ``100`` — the honesty the sibling ``.1f`` HUD
+    keeps, made integer-clean for the footer.
+    """
+    if pct is None:
+        return "context: n/a"
+    if pct >= 100.0:
+        return "context: 100% left"
+    if pct <= 0.0:
+        return "context: 0% left"
+    return f"context: {min(99, max(1, round(pct)))}% left"
+
+
+def _format_cost(state: TuiState) -> str:
+    """Render the session cost honestly.
+
+    A dollar figure when pricing is known, else ``n/a`` — so an unmetered/free
+    model with real usage never reads as a fake ``$0.0000``. A trailing ``+N``
+    flags calls whose cost could not be metered (partial total)."""
+    if state.cost_display:
+        return state.cost_display
+    cost = state.cost_usd
+    base = "n/a" if cost is None else f"${cost:.4f}"
+    if state.cost_unknown_calls > 0:
+        return f"{base} +{state.cost_unknown_calls}"
+    return base
+
+
+def _clip_fragments(fragments: Fragments, max_width: int) -> Fragments:
+    """Trim styled fragments from the end so the visible width fits max_width."""
+    if max_width <= 0:
+        return []
+    out: Fragments = []
+    used = 0
+    for style, text in fragments:
+        if used + len(text) <= max_width:
+            out.append((style, text))
+            used += len(text)
+            continue
+        remaining = max_width - used
+        if remaining >= 2:
+            out.append((style, text[: remaining - 1] + "…"))
+        elif remaining == 1:
+            out.append((style, "…"))
+        break
+    return out
+
+
+def _line1(state: TuiState) -> tuple[Fragments, Fragments]:
+    left: Fragments = [
+        ("class:tui.footer.mark", f"{_BRAND_MARK} "),
+        ("class:tui.footer.brand", "alysis"),
+        ("class:tui.footer.dim", _DOT),
+        ("class:tui.footer.model", pretty_model_label(state.model_name)),
+    ]
+    right: Fragments = []
+    if state.usage_hud_enabled:
+        right.extend(
+            [
+                ("class:tui.footer.context", _format_context_left(state.context_pct)),
+                ("class:tui.footer.dim", _DOT),
+                ("class:tui.footer.value", f"{state.tokens:,} processed"),
+                ("class:tui.footer.dim", _DOT),
+                ("class:tui.footer.value", _format_cost(state)),
+            ]
+        )
+    return left, right
+
+
+def _line2(state: TuiState) -> tuple[Fragments, Fragments]:
+    left: Fragments = []
+    if state.forge_mode:
+        # A distinct violet chip so the forge session is unmistakable at a glance
+        # (green stays the chat accent). No glyph — a wide emoji would throw off the
+        # width math that keeps the footer from wrapping.
+        label = "FORGE"
+        if state.forge_run_id:
+            label = f"{label} {state.forge_run_id}"
+        left.append(("class:tui.footer.forge", label))
+    if state.exec_mode:
+        # Glanceable execution-mode badge; amber when in the unguarded full mode.
+        # A non-default persona prefixes it (e.g. "arch·read") so the gate half
+        # of the badge is never hidden by the persona half.
+        short = _MODE_SHORT.get(state.exec_mode, state.exec_mode)
+        persona_short = _PERSONA_SHORT.get(state.persona, "")
+        if persona_short:
+            short = f"{persona_short} · {short}"
+        mode_style = (
+            "class:tui.footer.mode.warn"
+            if state.exec_mode == "fullaccess"
+            else "class:tui.footer.mode"
+        )
+        if left:
+            left.append(("class:tui.footer.dim", _DOT))
+        left.append((mode_style, short))
+    active_subagents = state.active_subagents or (
+        (state.active_subagent,) if state.active_subagent else ()
+    )
+    active_subagent_count = len(active_subagents)
+    if active_subagent_count:
+        # One fixed-width badge keeps parallel children visible without letting
+        # their names crowd the rest of the footer.
+        if left:
+            left.append(("class:tui.footer.dim", _DOT))
+        noun = "subagent" if active_subagent_count == 1 else "subagents"
+        left.append(
+            (
+                "class:tui.footer.subagent",
+                f"{_SUBAGENT_MARK} {active_subagent_count} {noun}",
+            )
+        )
+    if state.username:
+        if left:
+            left.append(("class:tui.footer.dim", _DOT))
+        left.append(("class:tui.footer.user", state.username))
+    if state.workspace:
+        if left:
+            left.append(("class:tui.footer.dim", _DOT))
+        left.append(("class:tui.footer.workspace", state.workspace))
+    if state.branch:
+        if left:
+            left.append(("class:tui.footer.dim", _DOT))
+        left.append(("class:tui.footer.branch", f"{_BRANCH_MARK} {state.branch}"))
+
+    # No right tail: the execution-mode badge above already states the approval
+    # policy, and a second indicator alongside it could only ever agree (noise)
+    # or disagree (a lie). Shift+Tab cycles the mode itself; the hint is
+    # intentionally not advertised in the footer.
+    right: Fragments = []
+    return left, right
+
+
+def _compose(left: Fragments, right: Fragments, width: int) -> Fragments:
+    if width <= 0:
+        return []
+    # Right side has priority and is right-aligned; clip it to the full width if it
+    # alone would overflow (narrow terminals), then fit the left into what's left.
+    right = _clip_fragments(right, width)
+    right_len = _visible_len(right)
+    left = _clip_fragments(left, max(0, width - right_len - 1))
+    gap = max(0, width - _visible_len(left) - right_len)
+    return [*left, ("", " " * gap), *right]
+
+
+def footer_fragments(state: TuiState, *, width: int = 80) -> FormattedText:
+    """Build the 2-line footer as FormattedText for the given terminal width."""
+    l1_left, l1_right = _line1(state)
+    l2_left, l2_right = _line2(state)
+    fragments: Fragments = []
+    fragments.extend(_compose(l1_left, l1_right, width))
+    fragments.append(("", "\n"))
+    fragments.extend(_compose(l2_left, l2_right, width))
+    return FormattedText(fragments)
+
+
+__all__ = ["footer_fragments"]

alysis_code/cli_impl/tui/forge_status.py

@@ -0,0 +1,136 @@
+"""Single source of truth for Forge task-status → visual bucket/glyph mapping.
+
+Historically the same four status sets (done / failure / obsolete / running)
+were copy-pasted into :mod:`...tui.app`, :mod:`...tui.surface`,
+:mod:`...commands.chat_tui_panels`, and :mod:`...commands.cli_common`, and had
+started to drift. This module holds them ONCE so the live Forge table, the
+``/show`` plan panel, and the end-of-run summary can never disagree about
+whether a task is done, failed, or still running.
+
+Kept deliberately pure (stdlib only, no package imports) so it is a leaf that
+any layer — the transcript model, the alt-screen renderer, or the standalone
+panel-spec builders — can import without pulling in the agent runtime or
+prompt_toolkit, and so it stays unit-testable in isolation.
+
+Matching is on the RAW, whitespace-stripped, lower-cased status string (the
+same semantics the individual sites used before consolidation). Callers that
+want canonicalisation (e.g. the plan panel) canonicalise first and pass the
+canonical value in — canonical statuses are already lower-case, so membership
+still resolves.
+"""
+
+from __future__ import annotations
+
+# Terminal-success states: the task is finished and satisfied.
+# ``completed_unverified`` (see ``...verification_repair``, spelled literally here to
+# keep this module import-free) means the work landed but no authoritative command
+# existed to check it. That is a completion, not a failure — a missing test runner
+# must never render as a red ✗ against work that is on disk.
+FORGE_DONE_STATES: frozenset[str] = frozenset({"done", "already_satisfied", "completed_unverified"})
+
+# Terminal-failure states: the task ended blocked/rejected/interrupted.
+FORGE_FAILURE_STATES: frozenset[str] = frozenset(
+    {
+        "failed",
+        "verify_failed",
+        "candidate_rejected",
+        "changes_requested",
+        "merge_conflict",
+        "blocked_integration",
+        "blocked",
+        "interrupted",
+        "cancelled",
+    }
+)
+
+# Non-executable / superseded states: excluded from done AND remaining counts.
+FORGE_OBSOLETE_STATES: frozenset[str] = frozenset({"superseded", "invalidated"})
+
+# Actively-executing states written to plan.json while a worker holds the task.
+FORGE_RUNNING_STATES: frozenset[str] = frozenset({"in_progress", "running", "executing", "active"})
+
+# Any state in which the task is no longer running (used to stop spinning a row
+# and prune it from the live "active workers" set).
+FORGE_TERMINAL_STATES: frozenset[str] = (
+    FORGE_DONE_STATES | FORGE_FAILURE_STATES | FORGE_OBSOLETE_STATES
+)
+
+
+def forge_status_bucket(status: str) -> str:
+    """Map a task status to a visual bucket.
+
+    Returns one of ``"done" | "failed" | "obsolete" | "running" | "remaining"``.
+    ``"remaining"`` covers planned/todo/unknown states (everything not otherwise
+    classified).
+    """
+    s = str(status or "").strip().lower()
+    if s in FORGE_DONE_STATES:
+        return "done"
+    if s in FORGE_FAILURE_STATES:
+        return "failed"
+    if s in FORGE_OBSOLETE_STATES:
+        return "obsolete"
+    if s in FORGE_RUNNING_STATES:
+        return "running"
+    return "remaining"
+
+
+def forge_status_is_terminal(status: str) -> bool:
+    """True when the task is no longer running (done, failed, or obsolete)."""
+    return str(status or "").strip().lower() in FORGE_TERMINAL_STATES
+
+
+def forge_status_glyph(status: str, *, active: bool = False, spinner: str = "") -> str:
+    """Return the one-column glyph for a task row.
+
+    ``✓`` done · ``✗`` failed · ``·`` obsolete · a spinner frame for a running
+    (or explicitly-active) task · ``○`` for everything still to do. ``active``
+    is the live-view flag for "the swarm is working this right now" — it spins a
+    task whose on-disk status has not yet flipped to a running state, but a
+    terminal (done/failed) status always wins so a finished row never spins.
+    """
+    bucket = forge_status_bucket(status)
+    if active and bucket not in ("done", "failed", "obsolete"):
+        return spinner or "◐"
+    if bucket == "done":
+        return "✓"
+    if bucket == "failed":
+        return "✗"
+    if bucket == "obsolete":
+        return "·"
+    if bucket == "running":
+        return spinner or "◐"
+    return "○"
+
+
+def forge_status_counts(statuses: object) -> tuple[int, int, int]:
+    """Return ``(done, failed, remaining)`` for an iterable of status strings.
+
+    Obsolete states are excluded from all three buckets (they are neither done
+    nor outstanding) — matching ``cli_common._forge_task_status_counts``.
+    """
+    done = failed = remaining = 0
+    for status in statuses or ():
+        bucket = forge_status_bucket(str(status))
+        if bucket == "done":
+            done += 1
+        elif bucket == "failed":
+            failed += 1
+        elif bucket == "obsolete":
+            continue
+        else:
+            remaining += 1
+    return done, failed, remaining
+
+
+__all__ = [
+    "FORGE_DONE_STATES",
+    "FORGE_FAILURE_STATES",
+    "FORGE_OBSOLETE_STATES",
+    "FORGE_RUNNING_STATES",
+    "FORGE_TERMINAL_STATES",
+    "forge_status_bucket",
+    "forge_status_is_terminal",
+    "forge_status_glyph",
+    "forge_status_counts",
+]

alysis_code/cli_impl/tui/markdown.py

@@ -0,0 +1,244 @@
+"""Markdown → prompt_toolkit fragment rows for the TUI transcript.
+
+A *completed* assistant reply is rendered through Rich's ``Markdown`` (the very
+renderer the classic CLI uses, so the two agree on how a reply looks) into ANSI,
+then converted to prompt_toolkit ``(style, text)`` rows. Streaming/partial text
+and plain prose skip this entirely and render as plain lines, so a half-open
+code fence never flashes mid-stream and a one-line answer is not reflowed.
+
+Kept free of any agent imports (Rich + prompt_toolkit only) so it unit-tests in
+isolation, and every public entry point is fail-safe: on any error it returns
+``None`` and the caller falls back to plain rendering.
+"""
+
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+from io import StringIO
+from typing import Any
+
+from pygments.style import Style as PygmentsStyle
+from pygments.token import Comment, Keyword, Name, Number, Operator, String
+
+from ...surface.styles import TerminalTheme
+
+# One visual line: a list of ``(style, text)`` fragments.
+Row = list[tuple[str, str]]
+
+# Matches the classic CLI's heuristic (rich_surface._looks_like_markdown) so the
+# TUI and the plain console agree on what counts as markdown worth rendering.
+_NUMBERED = re.compile(r"\d+\.\s")
+_FENCED_CODE_RE = re.compile(r"```[^\n]*\n(.*?)(?:\n```|$)", re.S)
+_CODE_FALLBACK_STYLE = "class:markdown.code"
+
+
+class _NeutralCodeStyle(PygmentsStyle):
+    """Syntax colours that preserve the terminal's own background."""
+
+    background_color = None
+    highlight_color = None
+    styles = {
+        Comment: "italic ansibrightblack",
+        Keyword: "bold ansimagenta",
+        Name.Builtin: "ansicyan",
+        Number: "ansicyan",
+        Operator: "bold",
+        String: "ansigreen",
+    }
+
+
+def _code_theme(theme: TerminalTheme) -> Any:
+    if theme == "dark":
+        return "monokai"
+    if theme == "light":
+        return "friendly"
+    return _NeutralCodeStyle
+
+
+# Rich wraps markdown links (e.g. "[apnews.com](https://…)") in an OSC 8 terminal
+# hyperlink — ``ESC]8;id=<n>;<url>ESC\ <anchor> ESC]8;;ESC\`` — whenever
+# legacy_windows is off, which _render_ansi deliberately sets so Rich emits ANSI
+# rather than Win32 console calls. prompt_toolkit's ANSI parser does not
+# understand OSC: it drops the ESC/ST control bytes but leaks the payload
+# ("8;id=1234;https://…" and "8;;") as visible text in the transcript (the stray
+# line users see after a web-search answer). OSC hyperlinks are not clickable
+# inside the alt-screen TUI anyway, so strip every OSC sequence; the anchor text
+# lives *between* the open and close markers and is left intact.
+_OSC_SEQUENCE_RE = re.compile(r"\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)")
+
+
+def looks_like_markdown(text: str) -> bool:
+    """True when ``text`` carries block-level markdown worth rendering.
+
+    Deliberately conservative: inline-only emphasis in a single paragraph is
+    left as plain text (rendering it would reflow newlines for no real gain).
+    """
+    clean = str(text or "")
+    if not clean.strip():
+        return False
+    if "```" in clean:
+        return True
+    has_multiple_lines = "\n" in clean
+    for line in clean.splitlines():
+        stripped = line.lstrip()
+        if not stripped:
+            continue
+        if stripped.startswith(("#", ">", "-", "*")):
+            return True
+        if _NUMBERED.match(stripped):
+            return True
+        if has_multiple_lines and stripped.count("|") >= 2:
+            return True
+    return False
+
+
+@lru_cache(maxsize=256)
+def _render_ansi(text: str, width: int, theme: TerminalTheme) -> str:
+    """Render markdown to ANSI at a fixed width and terminal theme.
+
+    Completed replies never change, so a redraw reuses the cached ANSI; only a
+    terminal resize or theme change forces a re-render.
+    """
+    from rich.markdown import Markdown
+
+    from ...surface.console import make_console
+
+    buf = StringIO()
+    console = make_console(
+        file=buf,
+        width=max(8, int(width)),
+        force_terminal=True,
+        color_system="truecolor",
+        highlight=False,  # no repr-highlighting of numbers/strings in prose
+        emoji=False,  # ":)" etc. stay literal
+        legacy_windows=False,  # emit ANSI escapes, not Win32 console calls
+    )
+    console.print(Markdown(text, code_theme=_code_theme(theme)))  # type: ignore[arg-type]
+    return _strip_osc_sequences(buf.getvalue())
+
+
+def _strip_osc_sequences(ansi: str) -> str:
+    """Drop OSC sequences (notably Rich's OSC 8 hyperlinks) prompt_toolkit leaks.
+
+    Only the escape wrappers are removed; a hyperlink's anchor text sits between
+    its open and close markers and survives, and CSI/SGR color sequences are left
+    untouched. See ``_OSC_SEQUENCE_RE`` for why this is needed.
+    """
+    return _OSC_SEQUENCE_RE.sub("", ansi)
+
+
+def _is_blank(row: Row) -> bool:
+    return not "".join(text for _style, text in row).strip()
+
+
+def _trim_row_right(row: Row) -> Row:
+    trimmed = list(row)
+    while trimmed:
+        style, text = trimmed[-1]
+        right_stripped = text.rstrip()
+        if right_stripped:
+            if right_stripped != text:
+                trimmed[-1] = (style, right_stripped)
+            break
+        trimmed.pop()
+    return trimmed
+
+
+def _split_row_to_width(row: Row, width: int) -> list[Row]:
+    safe_width = max(1, int(width))
+    rows: list[Row] = []
+    current: Row = []
+    current_len = 0
+    for style, text in row:
+        remaining = str(text)
+        while remaining:
+            available = safe_width - current_len
+            if available <= 0:
+                rows.append(_trim_row_right(current))
+                current = []
+                current_len = 0
+                available = safe_width
+            chunk = remaining[:available]
+            current.append((style, chunk))
+            current_len += len(chunk)
+            remaining = remaining[available:]
+    rows.append(_trim_row_right(current))
+    return [item for item in rows if item]
+
+
+def _fenced_code_line_keys(text: str) -> set[str]:
+    keys: set[str] = set()
+    for match in _FENCED_CODE_RE.finditer(str(text or "")):
+        for line in match.group(1).splitlines():
+            stripped = line.strip()
+            if stripped:
+                keys.add(stripped)
+    return keys
+
+
+def _apply_code_fallback_styles(rows: list[Row], text: str) -> list[Row]:
+    code_line_keys = _fenced_code_line_keys(text)
+    if not code_line_keys:
+        return rows
+    styled_rows: list[Row] = []
+    for row in rows:
+        row_text = "".join(fragment_text for _style, fragment_text in row).strip()
+        if row_text in code_line_keys and not any(style for style, _text in row):
+            styled_rows.append(
+                [
+                    (_CODE_FALLBACK_STYLE if fragment_text else style, fragment_text)
+                    for style, fragment_text in row
+                ]
+            )
+            continue
+        styled_rows.append(row)
+    return styled_rows
+
+
+@lru_cache(maxsize=256)
+def render_markdown_rows(
+    text: str,
+    width: int,
+    theme: TerminalTheme = "neutral",
+) -> list[Row] | None:
+    """Markdown-render ``text`` into rows of fragments, or ``None`` to render plain.
+
+    Returns ``None`` when the text is not markdown (so the caller keeps its plain
+    layout) or when rendering fails for any reason. Never raises. ``width`` is the
+    target content width in columns.
+
+    Memoized per ``(text, width, theme)`` — the transcript re-renders EVERY completed
+    reply on every redraw, and a streaming turn redraws many times a second, so
+    without this the full ANSI→fragments→wrap post-processing re-ran each frame
+    for each finished reply (cost grows with conversation length → visible lag).
+    Caching the ``_render_ansi`` string alone was not enough. The returned rows
+    are shared across frames, so callers MUST treat them as read-only (both
+    current callers build fresh lists rather than mutating in place).
+    """
+    if not looks_like_markdown(text):
+        return None
+    try:
+        from prompt_toolkit.formatted_text import ANSI, to_formatted_text
+        from prompt_toolkit.formatted_text.utils import split_lines
+
+        ansi = _render_ansi(text, int(width), theme)
+        fragments = to_formatted_text(ANSI(ansi.rstrip("\n")))
+        rows = []
+        for line in split_lines(fragments):
+            trimmed = _trim_row_right(list(line))
+            if not trimmed:
+                rows.append(trimmed)
+                continue
+            rows.extend(_split_row_to_width(trimmed, int(width)))
+    except Exception:
+        return None
+    # Trim trailing blank rows Rich pads on (the leading ones, if any, are kept so
+    # the caller can drop its accent marker on the first non-blank row).
+    while rows and _is_blank(rows[-1]):
+        rows.pop()
+    rows = _apply_code_fallback_styles(rows, text)
+    return rows or None
+
+
+__all__ = ["render_markdown_rows", "looks_like_markdown", "Row"]