monkeybot-cli 0.2.1__py3-none-any.whl

monkeybot_cli/chat_status_bar.py

@@ -0,0 +1,205 @@
+"""Context-window ring formatting for ``monkeybot chat``."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+_DIM = "\x1b[2m"
+_GREEN = "\x1b[32m"
+_YELLOW = "\x1b[33m"
+_RED = "\x1b[31m"
+_RESET = "\x1b[0m"
+
+DEFAULT_CONTEXT_WINDOW = 200_000
+_RING_GLYPHS = ("○", "◔", "◑", "◕", "●")
+
+
+@dataclass(frozen=True)
+class SessionUsageView:
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cost_usd: float = 0.0
+    last_prompt_tokens: int = 0
+    estimated_prompt_tokens: int = 0
+    summarization_threshold_tokens: int = 0
+    context_window_tokens: int = DEFAULT_CONTEXT_WINDOW
+
+
+def parse_usage_response(data: dict[str, object]) -> SessionUsageView:
+    def _int(key: str, default: int = 0) -> int:
+        val = data.get(key, default)
+        return int(val) if isinstance(val, (int, float)) else default
+
+    def _float(key: str, default: float = 0.0) -> float:
+        val = data.get(key, default)
+        return float(val) if isinstance(val, (int, float)) else default
+
+    cap = _int("context_window_tokens", DEFAULT_CONTEXT_WINDOW)
+    thresh = _int("summarization_threshold_tokens", 0)
+    if thresh <= 0:
+        thresh = max(1, int(cap * 0.85))
+    return SessionUsageView(
+        input_tokens=_int("input_tokens"),
+        output_tokens=_int("output_tokens"),
+        cost_usd=_float("cost_usd"),
+        last_prompt_tokens=_int("last_prompt_tokens"),
+        estimated_prompt_tokens=_int("estimated_prompt_tokens"),
+        summarization_threshold_tokens=thresh,
+        context_window_tokens=max(1, cap),
+    )
+
+
+def _ring_glyph(pct_used: int) -> str:
+    idx = min(len(_RING_GLYPHS) - 1, max(0, (pct_used + 12) // 25))
+    return _RING_GLYPHS[idx]
+
+
+def _ring_color(ring_numerator: int, threshold: int) -> str:
+    if ring_numerator >= threshold:
+        return _RED
+    if ring_numerator >= int(threshold * 0.75):
+        return _YELLOW
+    return _GREEN
+
+
+def _ring_markup_color(ring_numerator: int, threshold: int) -> str:
+    """Rich markup color name for the same thresholds as :func:`_ring_color`."""
+    if ring_numerator >= threshold:
+        return "red"
+    if ring_numerator >= int(threshold * 0.75):
+        return "yellow"
+    return "green"
+
+
+def _ring_parts(
+    *,
+    estimated_prompt_tokens: int,
+    last_prompt_tokens: int,
+    context_window_tokens: int,
+    summarization_threshold_tokens: int,
+) -> tuple[str, int, int, int]:
+    """Return ``(glyph, pct_used, ring_numerator, thresh)``."""
+    cap = max(1, context_window_tokens)
+    ring_numerator = estimated_prompt_tokens if estimated_prompt_tokens > 0 else last_prompt_tokens
+    thresh = max(
+        1,
+        summarization_threshold_tokens
+        if summarization_threshold_tokens > 0
+        else int(cap * 0.85),
+    )
+    pct_used = min(100, max(0, round((ring_numerator / cap) * 100)))
+    return _ring_glyph(pct_used), pct_used, ring_numerator, thresh
+
+
+def format_context_ring(
+    *,
+    estimated_prompt_tokens: int,
+    last_prompt_tokens: int,
+    context_window_tokens: int,
+    summarization_threshold_tokens: int,
+) -> str:
+    glyph, pct_used, ring_numerator, thresh = _ring_parts(
+        estimated_prompt_tokens=estimated_prompt_tokens,
+        last_prompt_tokens=last_prompt_tokens,
+        context_window_tokens=context_window_tokens,
+        summarization_threshold_tokens=summarization_threshold_tokens,
+    )
+    color = _ring_color(ring_numerator, thresh)
+    return f"{color}{glyph} {pct_used}%{_RESET}"
+
+
+def format_context_ring_plain(usage: SessionUsageView | None) -> str:
+    """Ring text without ANSI (for plain / non-color contexts)."""
+    if usage is None:
+        return "○ 0%"
+    glyph, pct_used, _, _ = _ring_parts(
+        estimated_prompt_tokens=usage.estimated_prompt_tokens,
+        last_prompt_tokens=usage.last_prompt_tokens,
+        context_window_tokens=usage.context_window_tokens,
+        summarization_threshold_tokens=usage.summarization_threshold_tokens,
+    )
+    return f"{glyph} {pct_used}%"
+
+
+def format_context_ring_markup(usage: SessionUsageView | None) -> str:
+    """Ring text with Rich markup colors for the Textual status bar."""
+    if usage is None:
+        return "[dim]○ 0%[/]"
+    glyph, pct_used, ring_numerator, thresh = _ring_parts(
+        estimated_prompt_tokens=usage.estimated_prompt_tokens,
+        last_prompt_tokens=usage.last_prompt_tokens,
+        context_window_tokens=usage.context_window_tokens,
+        summarization_threshold_tokens=usage.summarization_threshold_tokens,
+    )
+    color = _ring_markup_color(ring_numerator, thresh)
+    return f"[{color}]{glyph} {pct_used}%[/]"
+
+
+def format_status_line(usage: SessionUsageView | None, *, width: int) -> str:
+    if usage is None:
+        ring = f"{_DIM}○ 0%{_RESET}"
+    else:
+        ring = format_context_ring(
+            estimated_prompt_tokens=usage.estimated_prompt_tokens,
+            last_prompt_tokens=usage.last_prompt_tokens,
+            context_window_tokens=usage.context_window_tokens,
+            summarization_threshold_tokens=usage.summarization_threshold_tokens,
+        )
+    line = f" {ring}"
+    visible_budget = max(20, width - 1)
+    return line[:visible_budget]
+
+
+class UsageStore:
+    """Holds session usage for footer / plain status (no DECSTBM)."""
+
+    def __init__(self) -> None:
+        self._usage: SessionUsageView | None = None
+
+    @property
+    def usage(self) -> SessionUsageView | None:
+        return self._usage
+
+    def update(self, usage: SessionUsageView) -> None:
+        self._usage = usage
+
+    def update_context_hint(
+        self,
+        *,
+        estimated_prompt_tokens: int,
+        context_window_tokens: int = 0,
+        summarization_threshold_tokens: int = 0,
+    ) -> None:
+        base = self._usage or SessionUsageView()
+        cap = context_window_tokens if context_window_tokens > 0 else base.context_window_tokens
+        thresh = (
+            summarization_threshold_tokens
+            if summarization_threshold_tokens > 0
+            else base.summarization_threshold_tokens
+        )
+        self._usage = SessionUsageView(
+            input_tokens=base.input_tokens,
+            output_tokens=base.output_tokens,
+            cost_usd=base.cost_usd,
+            last_prompt_tokens=base.last_prompt_tokens,
+            estimated_prompt_tokens=estimated_prompt_tokens,
+            summarization_threshold_tokens=thresh,
+            context_window_tokens=cap,
+        )
+
+
+def format_voice_status(state: str, level_db: float | None = None) -> str:
+    """Rich markup voice indicator for the chat status bar."""
+    labels = {
+        "listening": "[green]● listening[/]",
+        "muted": "[dim]◌ muted[/]",
+        "ptt_held": "[cyan]⏺ PTT[/]",
+        "speaking": "[magenta]▶ speaking[/]",
+    }
+    base = labels.get(state, f"[dim]{state}[/]")
+    if level_db is None:
+        return base
+    # Map -40..0 dBFS to 0..4 bars
+    bars = max(0, min(4, int((level_db + 40) / 10)))
+    meter = "▁▂▃▄▅"[bars] if bars < 5 else "▅"
+    return f"{base} [dim]{meter}[/]"

monkeybot_cli/chat_theme.py

@@ -0,0 +1,91 @@
+"""Monkeybot chat TUI themes (dark / light)."""
+
+from __future__ import annotations
+
+import os
+
+from textual.theme import Theme
+
+THEME_DARK = "monkeybot-dark"
+THEME_LIGHT = "monkeybot-light"
+
+_DARK_VARS = {
+    "muted": "#71717a",
+    "disabled": "#52525b",
+    "border": "#2a2f3a",
+    "scrollbar": "#3d4450",
+    "hitl-surface": "#1a1810",
+    "hitl-text": "#fde68a",
+    "assistant": "#d4d4d8",
+    "tool-error": "#a16207",
+}
+
+_LIGHT_VARS = {
+    "muted": "#52525b",
+    "disabled": "#a1a1aa",
+    "border": "#d4d4d8",
+    "scrollbar": "#a1a1aa",
+    "hitl-surface": "#fef9c3",
+    "hitl-text": "#854d0e",
+    "assistant": "#3f3f46",
+    "tool-error": "#a16207",
+}
+
+MONKEYBOT_DARK = Theme(
+    name=THEME_DARK,
+    primary="#5b7cfa",
+    secondary="#a1a1aa",
+    accent="#5b7cfa",
+    foreground="#e4e4e7",
+    background="#0f1115",
+    surface="#151820",
+    panel="#151820",
+    success="#22c55e",
+    warning="#eab308",
+    error="#f87171",
+    dark=True,
+    variables=_DARK_VARS,
+)
+
+MONKEYBOT_LIGHT = Theme(
+    name=THEME_LIGHT,
+    primary="#4f6ef7",
+    secondary="#52525b",
+    accent="#4f6ef7",
+    foreground="#18181b",
+    background="#f4f4f5",
+    surface="#ffffff",
+    panel="#ffffff",
+    success="#16a34a",
+    warning="#ca8a04",
+    error="#dc2626",
+    dark=False,
+    variables=_LIGHT_VARS,
+)
+
+
+def _colorfgbg_prefers_light() -> bool | None:
+    """Return True/False if COLORFGBG indicates light/dark bg, else None."""
+    raw = os.environ.get("COLORFGBG", "").strip()
+    if not raw or ";" not in raw:
+        return None
+    # Format: foreground;background (decimal ANSI color indices).
+    # Light backgrounds are typically 7/15 (white) or high-intensity.
+    try:
+        bg = int(raw.rsplit(";", 1)[-1])
+    except ValueError:
+        return None
+    return bg in {7, 15}
+
+
+def resolve_theme_name(choice: str = "auto") -> str:
+    """Map ``auto|dark|light`` to a registered theme name."""
+    normalized = (choice or "auto").strip().lower()
+    if normalized == "light":
+        return THEME_LIGHT
+    if normalized == "dark":
+        return THEME_DARK
+    prefers_light = _colorfgbg_prefers_light()
+    if prefers_light is True:
+        return THEME_LIGHT
+    return THEME_DARK

monkeybot_cli/chat_tool_display.py

@@ -0,0 +1,334 @@
+"""Tool activity display helpers for ``monkeybot chat``."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+_SUBAGENT_HINT_MAX = 60
+_TITLE_HINT_MAX = 72
+_DETAIL_MAX = 8000
+_SHELL_TAIL_LINES = 40
+
+_TOOL_KIND: dict[str, str] = {
+    "run_command": "Shell",
+    "execute": "Shell",
+    "shell": "Shell",
+    "bash": "Shell",
+    "read_file": "Read",
+    "read": "Read",
+    "write_file": "Write",
+    "write": "Write",
+    "edit_file": "Edit",
+    "apply_patch": "Edit",
+    "str_replace": "Edit",
+    "grep": "Search",
+    "search": "Search",
+    "web_search": "Search",
+    "glob": "Glob",
+    "list_dir": "List",
+    "list_directory": "List",
+    "task": "Task",
+}
+
+_SHELL_TOOLS = frozenset({"run_command", "execute", "shell", "bash"})
+_READ_TOOLS = frozenset({"read_file", "read"})
+_EDIT_TOOLS = frozenset(
+    {"write_file", "write", "edit_file", "apply_patch", "str_replace"}
+)
+_PATH_TOOLS = _READ_TOOLS | _EDIT_TOOLS
+_SEARCH_TOOLS = frozenset({"grep", "search", "web_search"})
+_HINT_KEYS = frozenset(
+    {
+        "argv",
+        "command",
+        "args",
+        "arguments",
+        "shell",
+        "script",
+        "path",
+        "query",
+        "url",
+        "task",
+        "instructions",
+        "prompt",
+        "objective",
+        "subagent_type",
+        "type",
+        "persona",
+    }
+)
+
+_LANG_BY_SUFFIX: dict[str, str] = {
+    ".py": "python",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".js": "javascript",
+    ".jsx": "jsx",
+    ".json": "json",
+    ".md": "markdown",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".rs": "rust",
+    ".go": "go",
+    ".sh": "bash",
+    ".css": "css",
+    ".html": "html",
+    ".sql": "sql",
+}
+
+
+def collapse_hint(text: str) -> str:
+    return " ".join(text.split())
+
+
+def truncate_subagent_hint(text: str) -> str:
+    collapsed = collapse_hint(text)
+    if len(collapsed) <= _SUBAGENT_HINT_MAX:
+        return collapsed
+    return collapsed[:_SUBAGENT_HINT_MAX] + "…"
+
+
+def tool_hint(args: dict[str, object]) -> str:
+    """Summary of tool args for status lines."""
+    argv = args.get("argv")
+    if isinstance(argv, list) and argv:
+        return collapse_hint(" ".join(str(x) for x in argv))
+
+    cmd = args.get("command")
+    if isinstance(cmd, str) and cmd.strip():
+        extra = args.get("args")
+        if extra is None:
+            extra = args.get("arguments")
+        if isinstance(extra, list) and extra:
+            line = " ".join([cmd.strip(), *[str(x) for x in extra]])
+        else:
+            line = cmd.strip()
+        return collapse_hint(line)
+
+    for key in ("shell", "script", "path", "query", "url"):
+        val = args.get(key)
+        if isinstance(val, str) and val.strip():
+            return collapse_hint(val.strip())
+    keys = list(args.keys())
+    if len(keys) == 1:
+        key = keys[0]
+        val = args[key]
+        if isinstance(val, (str, int, bool, float)):
+            return collapse_hint(f"{key}: {val}")
+    if keys:
+        return f"{len(keys)} arg{'s' if len(keys) != 1 else ''}"
+    return ""
+
+
+def task_subagent_label(args: dict[str, object]) -> str:
+    for key in ("subagent_type", "type", "persona"):
+        val = args.get(key)
+        if isinstance(val, str) and val.strip():
+            return f"subagent:{val.strip()}"
+    return "subagent"
+
+
+def task_hint(args: dict[str, object]) -> str:
+    for key in ("task", "instructions", "prompt", "objective"):
+        val = args.get(key)
+        if isinstance(val, str) and val.strip():
+            return truncate_subagent_hint(val.strip())
+    return ""
+
+
+def tool_kind_label(tool: str) -> str:
+    key = tool.strip().lower().replace("-", "_")
+    if key in _TOOL_KIND:
+        return _TOOL_KIND[key]
+    cleaned = tool.strip().replace("_", " ").replace("-", " ")
+    return cleaned.title() if cleaned else "Tool"
+
+
+def resolve_tool_hint(tool: str, label: str, args: dict[str, object]) -> str:
+    """Shared hint used by collapsed titles and plain-path display."""
+    if tool == "task":
+        hint = task_hint(args)
+        if not hint and label.strip() and label.strip() != tool:
+            return truncate_subagent_hint(label.strip())
+        return hint
+    hint = tool_hint(args)
+    if not hint and label.strip() and label.strip() != tool:
+        return collapse_hint(label.strip())
+    return hint
+
+
+def tool_collapsed_title(tool: str, label: str, args: dict[str, object]) -> str:
+    """Short Cursor/Claude-style title: ``Shell  git status``."""
+    hint = resolve_tool_hint(tool, label, args)
+    if tool == "task":
+        base = task_subagent_label(args)
+        kind = "Task" if base == "subagent" else base
+    else:
+        kind = tool_kind_label(tool)
+    if hint and len(hint) > _TITLE_HINT_MAX:
+        hint = hint[:_TITLE_HINT_MAX] + "…"
+    return f"{kind}  {hint}" if hint else kind
+
+
+def tool_display(tool: str, label: str, args: dict[str, object]) -> str:
+    """Plain-path activity line: ``run_command — echo hi``."""
+    hint = resolve_tool_hint(tool, label, args)
+    if tool == "task":
+        base = task_subagent_label(args)
+        return base + (f" — {hint}" if hint else "")
+    return tool + (f" — {hint}" if hint else "")
+
+
+def tool_spinner_prefix(tool: str, label: str, args: dict[str, object]) -> str:
+    if tool == "task":
+        hint = resolve_tool_hint(tool, label, args)
+        base = "spawning " + task_subagent_label(args)
+        return base + (f" — {hint}" if hint else "")
+    return tool_display(tool, label, args)
+
+
+def _tool_key(tool: str) -> str:
+    return tool.strip().lower().replace("-", "_")
+
+
+def _primary_section_label(tool: str) -> str:
+    key = _tool_key(tool)
+    if key in _SHELL_TOOLS:
+        return "Command"
+    if key in _PATH_TOOLS:
+        return "Path"
+    if key in _SEARCH_TOOLS:
+        return "Query"
+    if key == "task":
+        return "Task"
+    return "Input"
+
+
+def _path_from_args(args: dict[str, object]) -> str:
+    path = args.get("path")
+    return path.strip() if isinstance(path, str) else ""
+
+
+def _language_for_path(path: str) -> str:
+    if not path:
+        return ""
+    return _LANG_BY_SUFFIX.get(Path(path).suffix.lower(), "")
+
+
+def _looks_like_diff(text: str) -> bool:
+    has_hunk = False
+    has_file = False
+    for line in text.splitlines()[:40]:
+        if line.startswith("@@"):
+            has_hunk = True
+        if line.startswith("--- ") or line.startswith("+++ "):
+            has_file = True
+        if has_hunk and has_file:
+            return True
+    return False
+
+
+def _truncate(text: str, max_chars: int) -> str:
+    if len(text) <= max_chars:
+        return text
+    return text[:max_chars] + "\n…"
+
+
+def _tail_lines(text: str, n: int = _SHELL_TAIL_LINES) -> str:
+    lines = text.splitlines()
+    if len(lines) <= n:
+        return text
+    omitted = len(lines) - n
+    return f"… ({omitted} earlier lines)\n" + "\n".join(lines[-n:])
+
+
+def _fence(body: str, lang: str = "") -> str:
+    fence = "```"
+    while fence in body:
+        fence += "`"
+    return f"{fence}{lang}\n{body.rstrip()}\n{fence}"
+
+
+def _format_search_result(result: str, max_chars: int) -> str:
+    lines: list[str] = []
+    for raw in result.splitlines():
+        line = raw.strip()
+        if not line:
+            continue
+        if line.startswith("http://") or line.startswith("https://"):
+            lines.append(f"- <{line}>")
+        elif "://" in line and " " in line:
+            # "Title https://..." style
+            parts = line.rsplit(None, 1)
+            if len(parts) == 2 and parts[1].startswith("http"):
+                lines.append(f"- [{parts[0]}]({parts[1]})")
+            else:
+                lines.append(f"- `{line}`")
+        else:
+            lines.append(f"- `{line}`")
+        if sum(len(x) for x in lines) > max_chars:
+            lines.append("- …")
+            break
+    return "\n".join(lines) if lines else "_empty_"
+
+
+def _extras_markdown(args: dict[str, object]) -> list[str]:
+    extras = [
+        f"- `{key}`: `{val}`"
+        if isinstance(val, (str, int, bool, float)) or val is None
+        else f"- `{key}`: `{val!r}`"[:200]
+        for key, val in args.items()
+        if key not in _HINT_KEYS
+    ]
+    if not extras:
+        return []
+    return ["", "**Args**", *extras]
+
+
+def format_tool_expand_body(
+    tool: str,
+    args: dict[str, object],
+    *,
+    result: str = "",
+    error: object = None,
+    max_chars: int = _DETAIL_MAX,
+) -> str:
+    """Human-readable expand body as markdown (not raw JSON dump)."""
+    key = _tool_key(tool)
+    parts: list[str] = []
+    primary = resolve_tool_hint(tool, tool, args)
+    if primary:
+        parts.append(f"**{_primary_section_label(tool)}**")
+        parts.append(f"`{primary}`")
+
+    parts.extend(_extras_markdown(args))
+
+    if error:
+        if parts:
+            parts.append("")
+        parts.append("**Error**")
+        parts.append(f"```\n{error}\n```")
+        return "\n".join(parts)
+
+    if not result:
+        return "\n".join(parts) if parts else "(no details)"
+
+    if parts:
+        parts.append("")
+    parts.append("**Result**")
+
+    if key in _READ_TOOLS:
+        lang = _language_for_path(_path_from_args(args))
+        parts.append(_fence(_truncate(result, max_chars), lang))
+    elif key in _EDIT_TOOLS and _looks_like_diff(result):
+        parts.append(_fence(_truncate(result, max_chars), "diff"))
+    elif key in _SHELL_TOOLS:
+        parts.append(_fence(_truncate(_tail_lines(result), max_chars), ""))
+    elif key in _SEARCH_TOOLS:
+        parts.append(_format_search_result(result, max_chars))
+    else:
+        text = _truncate(result, max_chars)
+        parts.append(_fence(text, ""))
+
+    return "\n".join(parts)