Skip to content

The agent that turns websites into APIs!

16.7 KB
Raw Blame
"""Rich Terminal UI for Claude SDK interactions."""

import json
from typing import Any

from rich.console import Console
from rich.padding import Padding
from rich.text import Text

from .branding import print_cli_logo
from .theme import (
    APP_TAGLINE,
    BRAND_MARK,
    BRAND_WORDMARK,
    MODE_COLORS,
    THEME_DIM,
    THEME_PRIMARY,
    THEME_SECONDARY,
)

ERROR_CTA = "If an unexpected error occurred, please create an issue at https://github.com/kalil0321/reverse-api-engineer/issues/new"


# Tool icons for visual clarity (minimalist text)
TOOL_ICONS = {
    "Read": "rd",
    "Write": "wr",
    "Edit": "ed",
    "Bash": "sh",
    "Glob": "ls",
    "Grep": "gp",
    "WebSearch": "ws",
    "WebFetch": "wf",
    "Task": "tk",
    "AskUserQuestion": "??",
    "mcp": "◇",
    "browser_navigate": "br",
    "browser_click": "br",
    "browser_type": "br",
    "browser_snapshot": "br",
    "browser_tabs": "br",
    "browser_lock": "br",
    "browser_unlock": "br",
    "default": "> ",
}

# Tool colors (minimalist)
TOOL_COLORS = {
    "Read": THEME_DIM,
    "Write": THEME_DIM,
    "Edit": THEME_DIM,
    "Bash": THEME_DIM,
    "Glob": THEME_DIM,
    "Grep": THEME_DIM,
    "WebSearch": THEME_DIM,
    "WebFetch": THEME_DIM,
    "default": THEME_DIM,
}


class ClaudeUI:
    """Interactive terminal UI for Claude SDK operations."""

    def __init__(self, verbose: bool = True) -> None:
        self.console = Console()
        self.verbose = verbose
        self._tool_count = 0
        self._tools_used: list[str] = []

    def header(self, run_id: str, prompt: str, model: str | None = None, sdk: str | None = None, mode: str | None = None) -> None:
        """Display the session header."""
        print_session_header(self.console, run_id, prompt, model=model, sdk=sdk, mode=mode)

    def start_analysis(self) -> None:
        """Display analysis start message."""
        self.console.print(" [dim]decoding starting...[/dim]")
        self.console.print()

    def tool_start(self, tool_name: str, tool_input: dict | Any, call_id: str | None = None) -> None:
        """Display when a tool starts execution."""
        _ = call_id  # accepted for parity with json-stream; not rendered
        self._tool_count += 1
        self._tools_used.append(tool_name)

        args = self._coerce_tool_input(tool_input)
        icon = self._tool_icon_for(tool_name)
        header = self._tool_header_label(tool_name)
        input_summary = self._summarize_input(tool_name, args)

        self.console.print(f"  [dim]>[/dim] {icon} [white]{header}[/white]")
        if input_summary:
            self.console.print(f"      {input_summary}")

    def tool_result(self, tool_name: str, is_error: bool = False, output: str | None = None, call_id: str | None = None) -> None:
        """Display when a tool completes."""
        _ = call_id  # accepted for parity with json-stream; not rendered
        tl = tool_name.lower()
        if is_error:
            self.console.print(f"  [dim]![/dim] [red]{self._tool_header_label(tool_name)} failed[/red]")
            if output and self.verbose:
                err = str(output).strip().replace("\n", " ")
                if len(err) > 200:
                    err = err[:197] + "..."
                self.console.print(f"      [dim]{err}[/dim]")
        elif tool_name == "Bash" and output and self.verbose:
            # Display bash output
            output_str = str(output).strip()
            if output_str:
                output_lines = output_str.split("\n")
                max_lines = 30
                for line in output_lines[:max_lines]:
                    self.console.print(f"  [dim]│[/dim] [dim]{line}[/dim]")
                if len(output_lines) > max_lines:
                    self.console.print(f"  [dim]│[/dim] [dim]... ({len(output_lines) - max_lines} more lines)[/dim]")
        elif output and self.verbose and (tl.startswith("mcp") or "web" in tl or "fetch" in tl):
            preview = str(output).strip()
            if len(preview) > 400:
                preview = preview[:397] + "..."
            if "\n" in preview:
                lines = preview.split("\n")[:12]
                self.console.print("  [dim]│[/dim] [dim]result[/dim]")
                for line in lines:
                    self.console.print(f"  [dim]│[/dim] [dim]{line[:140]}{'…' if len(line) > 140 else ''}[/dim]")
            elif preview:
                self.console.print(f"  [dim]│[/dim] [dim]{preview}[/dim]")

    def todo_updated(self, todos: list) -> None:
        """Show agent todo list (Cursor / Claude todo-style tools)."""
        if not self.verbose or not todos:
            return

        icons = {
            "pending": "○",
            "in_progress": "›",
            "completed": "✓",
            "cancelled": "✗",
        }
        pending = sum(1 for t in todos if str(t.get("status", "")).lower() == "pending")
        done = sum(1 for t in todos if str(t.get("status", "")).lower() == "completed")
        active = [t for t in todos if str(t.get("status", "")).lower() == "in_progress"]

        summary_parts: list[str] = []
        if active:
            summary_parts.append(f"{len(active)} active")
        if pending:
            summary_parts.append(f"{pending} pending")
        if done:
            summary_parts.append(f"{done} done")
        summary = ", ".join(summary_parts) if summary_parts else f"{len(todos)} items"

        self.console.print(f"  [dim]todos[/dim] [white]{summary}[/white]")
        for t in todos[:14]:
            st = str(t.get("status", "pending")).lower()
            ic = icons.get(st, "·")
            line = (t.get("activeForm") or t.get("content") or "").strip() or "(empty)"
            if len(line) > 76:
                line = line[:73] + "..."
            self.console.print(f"      [dim]{ic}[/dim]  {line}")
        if len(todos) > 14:
            self.console.print(f"      [dim]… {len(todos) - 14} more[/dim]")
        self.console.print()

    def thinking(self, text: str, max_length: int = 500) -> None:
        """Display Claude's thinking/response text."""
        if not self.verbose:
            return

        if len(text) < 5:
            return

        display_text = text.replace("\n", " ").strip()
        if len(display_text) > max_length:
            display_text = display_text[:max_length] + "..."
        self.console.print(f"  [dim].. {display_text}[/dim]")

    def thinking_block(self, text: str, max_chars: int = 8000) -> None:
        """Print one cohesive model reasoning / reply block (not token-by-token).

        Used by the Cursor SDK path where the bridge streams fine-grained deltas;
        the engineer buffers those and flushes them here as a single visual unit.
        """
        if not self.verbose:
            return
        raw = (text or "").strip()
        if len(raw) < 2:
            return
        if len(raw) > max_chars:
            raw = raw[:max_chars] + "\n…"
        self.console.print()
        self.console.print(Padding(Text(raw, style="dim"), (0, 0, 0, 2)))
        self.console.print()

    def progress(self, message: str) -> None:
        """Display a progress message."""
        self.console.print(f"  [dim italic]{message}[/dim italic]")

    def success(self, script_path: str, local_path: str | None = None) -> None:
        """Display success message with generated script path."""
        self.console.print()
        self.console.print(" [dim]decoding complete[/dim]")
        self.console.print(f" [dim]internal:[/dim] [white]{script_path}[/white]")
        if local_path:
            self.console.print(f" [dim]synced:[/dim]   [white]{local_path}[/white]")
        self.console.print()

    def error(self, message: str) -> None:
        """Display error message."""
        self.console.print()
        self.console.print(f" [dim]![/dim] [red]error:[/red] {message}")
        self.console.print(f" [dim]{ERROR_CTA}[/dim]")

    def _coerce_tool_input(self, tool_input: Any) -> dict:
        if isinstance(tool_input, dict):
            return tool_input
        if isinstance(tool_input, str) and tool_input.strip():
            s = tool_input.strip()
            if s.startswith("{"):
                try:
                    parsed = json.loads(s)
                    return parsed if isinstance(parsed, dict) else {}
                except json.JSONDecodeError:
                    return {}
        return {}

    def _tool_icon_for(self, tool_name: str) -> str:
        if tool_name in TOOL_ICONS and tool_name != "default":
            return TOOL_ICONS[tool_name]
        tl = tool_name.lower()
        if tl.startswith("mcp"):
            return TOOL_ICONS.get("mcp", "◇")
        return TOOL_ICONS["default"]

    def _tool_header_label(self, tool_name: str) -> str:
        if not tool_name:
            return "tool"
        tl = tool_name.lower()
        if tl.startswith("mcp_"):
            rest = tool_name[4:].replace("__", " · ")
            rest = rest.replace("_", " ")
            if len(rest) > 56:
                return rest[:53].strip() + "…"
            return rest
        if len(tool_name) > 48:
            return tool_name[:45] + "…"
        return tool_name

    def _summarize_input(self, tool_name: str, tool_input: dict) -> str:
        """Create a brief summary of tool input."""
        tl = tool_name.lower()
        if tl in ("todowrite", "todo_write", "write_todos", "update_todos"):
            todos = tool_input.get("todos")
            if isinstance(todos, list):
                return f"[dim]{len(todos)} item(s)[/dim]"
            return "[dim]todos[/dim]"
        if tl == "call_mcp_tool":
            mn = tool_input.get("name") or tool_input.get("server") or tool_input.get("tool")
            if isinstance(mn, str) and mn:
                return f"[dim]{mn[:70]}{'…' if len(mn) > 70 else ''}[/dim]"
            return ""
        if tl.startswith("mcp"):
            keys = ("url", "path", "file_path", "command", "query", "pattern", "browserTab", "tabId", "text")
            for k in keys:
                v = tool_input.get(k)
                if isinstance(v, str) and v.strip():
                    vv = v.replace("\n", " ").strip()
                    cap = 72 if k in ("url", "path", "file_path") else 60
                    return f"[dim]{k}[/dim] [dim]{vv[:cap]}{'…' if len(vv) > cap else ''}[/dim]"
            args = tool_input.get("arguments")
            if isinstance(args, str) and args.strip().startswith("{"):
                try:
                    args = json.loads(args)
                except json.JSONDecodeError:
                    args = None
            if isinstance(args, dict):
                for k in keys:
                    v = args.get(k)
                    if isinstance(v, str) and v.strip():
                        vv = v.replace("\n", " ").strip()
                        return f"[dim]{k}[/dim] [dim]{vv[:70]}{'…' if len(vv) > 70 else ''}[/dim]"
            blob = json.dumps(tool_input, default=str)
            if len(blob) > 90:
                return f"[dim]{blob[:87]}…[/dim]"
            return f"[dim]{blob}[/dim]"
        if tool_name == "Read" or tl == "read":
            path = tool_input.get("file_path") or tool_input.get("path", "")
            return f"[dim]{self._truncate_path(path)}[/dim]"
        elif tool_name == "Write" or tl == "write":
            path = tool_input.get("file_path") or tool_input.get("path", "")
            return f"[dim]→ {self._truncate_path(path)}[/dim]"
        elif tool_name == "Edit" or tl == "edit":
            path = tool_input.get("file_path") or tool_input.get("path", "")
            return f"[dim]{self._truncate_path(path)}[/dim]"
        elif tool_name == "Bash" or tl in ("bash", "shell"):
            cmd = str(tool_input.get("command", ""))
            cmd = cmd.replace("\n", " ").strip()
            return f"[dim]$ {cmd[:60]}{'...' if len(cmd) > 60 else ''}[/dim]"
        elif tool_name in ("Grep", "Glob") or tl in ("grep", "glob"):
            pattern = tool_input.get("pattern", tool_input.get("query", ""))
            return f"[dim]'{pattern}'[/dim]"
        elif tool_name == "WebSearch" or tl == "websearch":
            query = tool_input.get("query", "")
            return f"[dim]'{query[:50]}{'...' if len(query) > 50 else ''}'[/dim]"
        elif tool_name == "WebFetch" or tl == "webfetch":
            url = tool_input.get("url", "")
            return f"[dim]{url[:60]}{'...' if len(url) > 60 else ''}[/dim]"
        elif tool_name == "browser_navigate":
            url = tool_input.get("url", "")
            return f"[dim]{url[:50]}{'...' if len(url) > 50 else ''}[/dim]"
        elif tool_name == "browser_click":
            ref = tool_input.get("elementRef", "")
            return f"[dim]ref={ref[:40]}{'...' if len(ref) > 40 else ''}[/dim]"
        elif tool_name == "browser_type":
            text = tool_input.get("text", "")[:30]
            return f"[dim]'{text}{'...' if len(text) >= 30 else ''}'[/dim]"
        elif tool_name == "browser_snapshot":
            return "[dim]page structure[/dim]"
        return ""

    def _truncate_path(self, path: str, max_len: int = 60) -> str:
        """Truncate a path for display."""
        if len(path) <= max_len:
            return path
        return "..." + path[-(max_len - 3) :]

    def sync_started(self, dest_dir: str) -> None:
        """Display when file sync starts."""
        self.console.print(f"  [dim]⟳ sync: active → {dest_dir}[/dim]")

    def sync_flash(self, message: str) -> None:
        """Display a brief sync notification."""
        self.console.print(f"  [dim]✓ {message}[/dim]")

    def sync_error(self, message: str) -> None:
        """Display a sync error."""
        self.console.print(f"  [dim]![/dim] [yellow]sync error:[/yellow] {message}")


def get_model_choices() -> list[dict]:
    """Get available model choices for questionary."""
    return [
        {"name": "Sonnet 4.6 [Balanced]", "value": "claude-sonnet-4-6"},
        {"name": "Opus 4.6 [Power]", "value": "claude-opus-4-6"},
        {"name": "Haiku 4.5 [Speed]", "value": "claude-haiku-4-5"},
    ]


def print_brand_line(console: Console, *, version: str | None = None, version_color: str | None = None) -> None:
    """Print the * rae wordmark (optional version suffix)."""
    line = f" [{THEME_PRIMARY}]{BRAND_MARK}[/{THEME_PRIMARY}] [{THEME_SECONDARY}]{BRAND_WORDMARK}[/{THEME_SECONDARY}]"
    if version is not None:
        color = version_color or THEME_PRIMARY
        line += f" [{color}]v{version}[/{color}]"
    console.print(line)


def print_session_header(
    console: Console,
    run_id: str,
    prompt: str,
    model: str | None = None,
    sdk: str | None = None,
    mode: str | None = None,
    *,
    mode_label: str = "task",
) -> None:
    """Session header matching the site terminal-window pattern."""
    from . import __version__

    mode_color = MODE_COLORS.get(mode or "", THEME_PRIMARY)

    console.print()
    print_brand_line(console, version=__version__, version_color=mode_color)
    console.print(f" [{THEME_DIM}]━[/{THEME_DIM}] [{THEME_SECONDARY}]{run_id}[/{THEME_SECONDARY}]")
    if sdk:
        console.print(
            f" [{THEME_DIM}]sdk[/{THEME_DIM}]    [{THEME_SECONDARY}]{sdk}[/{THEME_SECONDARY}]"
            f" [{THEME_DIM}]|[/{THEME_DIM}] [{THEME_DIM}]model[/{THEME_DIM}]"
            f" [{THEME_SECONDARY}]{model or '---'}[/{THEME_SECONDARY}]"
        )
    else:
        console.print(
            f" [{THEME_DIM}]model[/{THEME_DIM}]  [{THEME_SECONDARY}]{model or '---'}[/{THEME_SECONDARY}]"
        )
    console.print(f" [{mode_color}]{mode_label}[/{mode_color}]   [{THEME_SECONDARY}]{prompt}[/{THEME_SECONDARY}]")
    console.print()


def display_banner(console: Console, sdk: str | None = None, model: str | None = None) -> None:
    """Display minimalist startup banner with * rae branding."""
    # Redirected Windows streams may use a legacy encoding such as cp1252.
    divider = "--" if console.options.ascii_only else "━━"
    separator = "|" if console.options.ascii_only else "·"
    console.print()
    print_cli_logo(console)
    console.print(f"  [bold {THEME_PRIMARY}]{divider}[/bold {THEME_PRIMARY}]")
    if sdk and model:
        console.print(
            f"  [{THEME_DIM}]sdk[/{THEME_DIM}] [{THEME_SECONDARY}]{sdk}[/{THEME_SECONDARY}]"
            f" [{THEME_DIM}]{separator}[/{THEME_DIM}] [{THEME_DIM}]model[/{THEME_DIM}]"
            f" [{THEME_SECONDARY}]{model}[/{THEME_SECONDARY}]"
        )
    console.print()
    console.print(f"  [{THEME_DIM}]{APP_TAGLINE}[/{THEME_DIM}]")
    console.print()


def display_footer(console: Console) -> None:
    """Display minimalist footer."""
    from datetime import datetime

    from . import __version__

    time_str = datetime.now().strftime("%H:%M")

    console.print(
        f"\n [{THEME_DIM}][{THEME_PRIMARY}]{BRAND_MARK}[/{THEME_PRIMARY}]"
        f" v{__version__} {time_str} via cli[/{THEME_DIM}]"
    )
    console.print()