chorus-cli 0.4.0

package/tools/coder.py

@@ -0,0 +1,970 @@
+#!/usr/bin/env python3
+"""
+Coder — A terminal coding agent powered by Claude.
+
+Usage:
+    coder.py                          Interactive REPL
+    coder.py --prompt "do something"  Headless mode — outputs JSON to stdout
+
+Environment variables:
+    ANTHROPIC_API_KEY    — Required. Your Anthropic API key (or Chorus pk- key).
+    CODER_PROXY_URL      — Optional. Chorus base URL (e.g. http://localhost:8081)
+    CODER_MODEL          — Model to use (default: claude-sonnet-4-5-20250929)
+    CODER_MAX_TOKENS     — Max response tokens (default: 16384)
+    CODER_SAFE_MODE      — Set to 1 to require approval for writes/edits/bash
+"""
+
+import anthropic
+import argparse
+import json
+import os
+import sys
+import glob as glob_module
+import subprocess
+import re
+import readline
+from pathlib import Path
+
+# ── Colors ──────────────────────────────────────────────────────────────────
+
+class C:
+    RESET   = "\033[0m"
+    BOLD    = "\033[1m"
+    DIM     = "\033[2m"
+    RED     = "\033[31m"
+    GREEN   = "\033[32m"
+    YELLOW  = "\033[33m"
+    BLUE    = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN    = "\033[36m"
+    GRAY    = "\033[90m"
+
+# ── Config ──────────────────────────────────────────────────────────────────
+
+MODEL = os.environ.get("CODER_MODEL", "claude-sonnet-4-5-20250929")
+MAX_TOKENS = int(os.environ.get("CODER_MAX_TOKENS", "16384"))
+SAFE_MODE = os.environ.get("CODER_SAFE_MODE", "").lower() in ("1", "true", "yes")
+
+def is_token_limit_error(err):
+    msg = str(err)
+    return "token limit exceeded" in msg or "rate_limit_error" in msg
+
+SYSTEM_PROMPT = """\
+You are a coding agent running in the terminal.
+Working directory: {cwd}
+
+You help with software engineering tasks: writing code, debugging, refactoring, \
+explaining code, running commands, and managing files.
+
+Formatting:
+- Your output is displayed raw in a terminal. Never use markdown.
+- No ## headers, **bold**, *italic*, [links](url), or bullet symbols like -.
+- Use blank lines, indentation, and CAPS for emphasis or section labels.
+- Use plain numbered lists (1. 2. 3.) when listing things.
+- For inline code references, just use the name directly (e.g. myFunction, not `myFunction`).
+- Keep responses short and scannable.
+
+{approach}Guidelines:
+- Be direct and concise. No filler.
+- Always use your tools. If a question can be answered by running a command (git, ls, etc.), use the bash tool — never guess.
+- Always read a file before editing it.
+- If edit_file fails with "old_string not found", re-read the file to get the actual current content before retrying. Never guess at file contents.
+- Use edit_file for targeted changes. Use write_file for new files or complete rewrites.
+- Prefer editing existing files over creating new ones.
+- Do not write new unit tests unless the project already has substantive test coverage.
+- Do not attempt to build or compile the project.
+- Don't add unnecessary comments, docstrings, or type annotations.
+- For bash commands, prefer non-interactive commands.
+- When asked about the codebase, use list_files and search_files to explore it.
+"""
+
+APPROACH_BLOCK = """\
+Approach:
+- Before making changes, read the relevant files and briefly state your approach.
+- For multi-file changes, outline which files you'll modify and in what order.
+- Do not start editing until you understand the existing code.
+
+"""
+
+# ── Tool Definitions ────────────────────────────────────────────────────────
+
+TOOLS = [
+    {
+        "name": "read_file",
+        "description": "Read a file's contents. Returns lines with line numbers.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "File path (relative to cwd or absolute)"},
+                "offset": {"type": "integer", "description": "Start line (1-indexed)"},
+                "limit": {"type": "integer", "description": "Max lines to read"},
+            },
+            "required": ["path"],
+        },
+    },
+    {
+        "name": "write_file",
+        "description": "Create or overwrite a file with the given content.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "File path to write"},
+                "content": {"type": "string", "description": "Full file content"},
+            },
+            "required": ["path", "content"],
+        },
+    },
+    {
+        "name": "edit_file",
+        "description": (
+            "Replace an exact string in a file with new content. "
+            "old_string must match exactly including whitespace/indentation. "
+            "Fails if old_string is not found or is ambiguous (found multiple times without replace_all)."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "File path to edit"},
+                "old_string": {"type": "string", "description": "Exact string to find"},
+                "new_string": {"type": "string", "description": "Replacement string"},
+                "replace_all": {"type": "boolean", "description": "Replace all occurrences (default: false)"},
+            },
+            "required": ["path", "old_string", "new_string"],
+        },
+    },
+    {
+        "name": "list_files",
+        "description": "List files matching a glob pattern. Use '**/*.ext' for recursive search.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "pattern": {"type": "string", "description": "Glob pattern (e.g. '**/*.py', 'src/**/*.ts')"},
+                "path": {"type": "string", "description": "Base directory (default: cwd)"},
+            },
+            "required": ["pattern"],
+        },
+    },
+    {
+        "name": "search_files",
+        "description": "Search file contents with regex. Returns matching lines with file:line: prefix.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "pattern": {"type": "string", "description": "Regex pattern to search for"},
+                "path": {"type": "string", "description": "Directory or file to search (default: cwd)"},
+                "include": {"type": "string", "description": "Glob to filter files (e.g. '*.py')"},
+            },
+            "required": ["pattern"],
+        },
+    },
+    {
+        "name": "bash",
+        "description": "Execute a shell command. Returns stdout, stderr, and exit code.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "command": {"type": "string", "description": "Shell command to run"},
+                "timeout": {"type": "integer", "description": "Timeout in seconds (default: 120)"},
+            },
+            "required": ["command"],
+        },
+    },
+]
+
+# ── Tool Implementations ───────────────────────────────────────────────────
+
+SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", ".tox", ".mypy_cache", "dist", "build"}
+
+
+def resolve_path(path):
+    p = Path(path).expanduser()
+    if not p.is_absolute():
+        p = Path.cwd() / p
+    return p
+
+
+def tool_read_file(path, offset=None, limit=None):
+    p = resolve_path(path)
+    if not p.exists():
+        return f"Error: File not found: {path}"
+    if not p.is_file():
+        return f"Error: Not a file: {path}"
+    try:
+        lines = p.read_text(encoding="utf-8", errors="replace").splitlines(True)
+        start = (offset - 1) if offset and offset > 0 else 0
+        end = (start + limit) if limit else len(lines)
+        numbered = [f"{i:>6}\t{line.rstrip()}" for i, line in enumerate(lines[start:end], start=start + 1)]
+        return "\n".join(numbered) if numbered else "(empty file)"
+    except Exception as e:
+        return f"Error reading file: {e}"
+
+
+def tool_write_file(path, content):
+    p = resolve_path(path)
+    try:
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(content, encoding="utf-8")
+        line_count = content.count("\n") + (1 if content and not content.endswith("\n") else 0)
+        return f"Wrote {line_count} lines to {path}"
+    except Exception as e:
+        return f"Error writing file: {e}"
+
+
+def tool_edit_file(path, old_string, new_string, replace_all=False):
+    p = resolve_path(path)
+    if not p.exists():
+        return f"Error: File not found: {path}"
+    try:
+        content = p.read_text(encoding="utf-8")
+        count = content.count(old_string)
+        if count == 0:
+            return f"Error: old_string not found in {path}. Make sure it matches exactly (including whitespace)."
+        if count > 1 and not replace_all:
+            return f"Error: old_string found {count} times in {path}. Use replace_all=true or provide more surrounding context to make it unique."
+        if replace_all:
+            new_content = content.replace(old_string, new_string)
+        else:
+            new_content = content.replace(old_string, new_string, 1)
+        p.write_text(new_content, encoding="utf-8")
+        return f"Edited {path} ({count} replacement{'s' if count != 1 else ''})"
+    except Exception as e:
+        return f"Error editing file: {e}"
+
+
+def tool_list_files(pattern, path=None):
+    base = resolve_path(path) if path else Path.cwd()
+    try:
+        matches = sorted(glob_module.glob(str(base / pattern), recursive=True))
+        results = []
+        for m in matches:
+            mp = Path(m)
+            # Skip entries inside ignored directories
+            try:
+                rel = mp.relative_to(Path.cwd())
+            except ValueError:
+                rel = mp
+            if any(part in SKIP_DIRS for part in rel.parts):
+                continue
+            results.append(str(rel))
+            if len(results) >= 200:
+                break
+        if not results:
+            return "No files matched."
+        out = "\n".join(results)
+        remaining = len(matches) - len(results)
+        if remaining > 0:
+            out += f"\n... and {remaining} more files"
+        return out
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def tool_search_files(pattern, path=None, include=None):
+    base = resolve_path(path) if path else Path.cwd()
+    try:
+        regex = re.compile(pattern)
+    except re.error as e:
+        return f"Invalid regex: {e}"
+
+    results = []
+    search_path = base if base.is_dir() else base.parent
+    file_pattern = include or "*"
+
+    try:
+        files = [base] if base.is_file() else sorted(search_path.rglob(file_pattern))
+        for fp in files:
+            if not fp.is_file():
+                continue
+            try:
+                rel_parts = fp.relative_to(search_path).parts
+            except ValueError:
+                rel_parts = fp.parts
+            if any(part in SKIP_DIRS for part in rel_parts):
+                continue
+            try:
+                text = fp.read_text(encoding="utf-8", errors="strict")
+            except (UnicodeDecodeError, PermissionError):
+                continue
+            for i, line in enumerate(text.splitlines(), 1):
+                if regex.search(line):
+                    try:
+                        rel = str(fp.relative_to(Path.cwd()))
+                    except ValueError:
+                        rel = str(fp)
+                    results.append(f"{rel}:{i}: {line.rstrip()}")
+                    if len(results) >= 100:
+                        break
+            if len(results) >= 100:
+                break
+        if not results:
+            return "No matches found."
+        return "\n".join(results)
+    except Exception as e:
+        return f"Error searching: {e}"
+
+
+def tool_bash(command, timeout=120):
+    try:
+        result = subprocess.run(
+            command, shell=True, capture_output=True, text=True,
+            timeout=timeout, cwd=str(Path.cwd()),
+        )
+        parts = []
+        if result.stdout:
+            parts.append(result.stdout)
+        if result.stderr:
+            parts.append(result.stderr)
+        output = "\n".join(parts).strip()
+        if result.returncode != 0:
+            output += f"\n(exit code: {result.returncode})"
+        return output if output else "(no output)"
+    except subprocess.TimeoutExpired:
+        return f"Command timed out after {timeout}s"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+TOOL_DISPATCH = {
+    "read_file": tool_read_file,
+    "write_file": tool_write_file,
+    "edit_file": tool_edit_file,
+    "list_files": tool_list_files,
+    "search_files": tool_search_files,
+    "bash": tool_bash,
+}
+
+
+def execute_tool(name, inputs):
+    fn = TOOL_DISPATCH.get(name)
+    if not fn:
+        return f"Unknown tool: {name}"
+    return fn(**inputs)
+
+
+# ── Reflection Nudge ──────────────────────────────────────────────────────
+
+REFLECT_NUDGE = (
+    "\n\n[Before continuing, verify this change is correct and consider "
+    "if there's a simpler approach.]"
+)
+
+
+def _should_nudge(name, inputs, result):
+    """Return True for substantive, successful file changes worth reflecting on."""
+    if result.startswith("Error"):
+        return False
+    if name == "write_file":
+        return inputs.get("content", "").count("\n") >= 10
+    if name == "edit_file":
+        return inputs.get("new_string", "").count("\n") >= 3
+    return False
+
+# ── Permissions ─────────────────────────────────────────────────────────────
+
+# Tools that are safe to auto-approve (read-only)
+AUTO_APPROVE = {"read_file", "list_files", "search_files"}
+
+# Tools that require user permission
+NEEDS_PERMISSION = {"write_file", "edit_file", "bash"}
+
+# Session-level "always allow" set — populated when user presses 'a'
+always_allowed = set()
+
+
+def show_tool_preview(name, inputs):
+    """Show a detailed preview of what the tool will do."""
+    print(f"  {C.DIM}{'─' * 60}{C.RESET}")
+
+    if name == "write_file":
+        path = inputs.get("path", "?")
+        content = inputs.get("content", "")
+        line_count = content.count("\n") + (1 if content and not content.endswith("\n") else 0)
+        print(f"  {C.YELLOW}write{C.RESET} {C.BOLD}{path}{C.RESET} {C.DIM}({line_count} lines){C.RESET}")
+        print(f"  {C.DIM}{'─' * 60}{C.RESET}")
+        # Show first/last few lines as preview
+        lines = content.splitlines()
+        preview_lines = 8
+        if len(lines) <= preview_lines * 2:
+            for line in lines:
+                print(f"  {C.GREEN}+ {line}{C.RESET}")
+        else:
+            for line in lines[:preview_lines]:
+                print(f"  {C.GREEN}+ {line}{C.RESET}")
+            print(f"  {C.DIM}  ... ({len(lines) - preview_lines * 2} more lines){C.RESET}")
+            for line in lines[-preview_lines:]:
+                print(f"  {C.GREEN}+ {line}{C.RESET}")
+
+    elif name == "edit_file":
+        path = inputs.get("path", "?")
+        old = inputs.get("old_string", "")
+        new = inputs.get("new_string", "")
+        replace_all = inputs.get("replace_all", False)
+        label = "edit (all)" if replace_all else "edit"
+        print(f"  {C.YELLOW}{label}{C.RESET} {C.BOLD}{path}{C.RESET}")
+        print(f"  {C.DIM}{'─' * 60}{C.RESET}")
+        for line in old.splitlines():
+            print(f"  {C.RED}- {line}{C.RESET}")
+        for line in new.splitlines():
+            print(f"  {C.GREEN}+ {line}{C.RESET}")
+
+    elif name == "bash":
+        cmd = inputs.get("command", "?")
+        print(f"  {C.YELLOW}${C.RESET} {C.BOLD}{cmd}{C.RESET}")
+
+    print(f"  {C.DIM}{'─' * 60}{C.RESET}")
+
+
+def request_permission(name, inputs):
+    """
+    Ask the user for permission to run a tool.
+    Returns True if allowed, False if denied.
+    Updates always_allowed if user picks 'a'.
+    """
+    if name in AUTO_APPROVE:
+        return True
+    if name in always_allowed:
+        return True
+
+    show_tool_preview(name, inputs)
+
+    while True:
+        try:
+            choice = input(f"  {C.YELLOW}Allow?{C.RESET} {C.DIM}[y]es / [n]o / [a]lways{C.RESET} ").strip().lower()
+        except EOFError:
+            return False
+
+        if choice in ("y", "yes", ""):
+            return True
+        elif choice in ("a", "always"):
+            always_allowed.add(name)
+            return True
+        elif choice in ("n", "no"):
+            return False
+        # anything else, re-prompt
+
+
+# ── Display Helpers ─────────────────────────────────────────────────────────
+
+TOOL_LABELS = {
+    "read_file": ("read", C.BLUE),
+    "write_file": ("write", C.GREEN),
+    "edit_file": ("edit", C.YELLOW),
+    "list_files": ("ls", C.CYAN),
+    "search_files": ("grep", C.MAGENTA),
+    "bash": ("$", C.RED),
+}
+
+
+def format_tool_header(name, inputs):
+    label, _ = TOOL_LABELS.get(name, (name, C.DIM))
+    if name in ("read_file", "write_file", "edit_file"):
+        detail = inputs.get("path", "")
+    elif name == "list_files":
+        detail = inputs.get("pattern", "")
+    elif name == "search_files":
+        detail = f"/{inputs.get('pattern', '')}/"
+    elif name == "bash":
+        cmd = inputs.get("command", "")
+        detail = cmd if len(cmd) <= 80 else cmd[:77] + "..."
+    else:
+        detail = ""
+    return f"{label} {detail}"
+
+
+def print_tool_call(name, inputs):
+    """Print a colored tool header."""
+    _, color = TOOL_LABELS.get(name, (name, C.DIM))
+    header = format_tool_header(name, inputs)
+    print(f"  {color}{header}{C.RESET}")
+
+
+def print_tool_result_summary(name, result):
+    lines = result.split("\n")
+    is_error = result.startswith("Error")
+    if is_error:
+        print(f"  {C.RED}{lines[0]}{C.RESET}")
+    elif len(lines) <= 3:
+        for line in lines:
+            print(f"  {C.DIM}{line}{C.RESET}")
+    else:
+        print(f"  {C.DIM}{lines[0]}{C.RESET}")
+        print(f"  {C.DIM}... ({len(lines)} lines){C.RESET}")
+
+# ── Context Pruning ────────────────────────────────────────────────────────
+
+# Keep full content for the last N messages; summarize older tool results.
+# This prevents input tokens from growing quadratically over long sessions.
+# Claude can always re-read files if it needs the content again.
+KEEP_RECENT = 6  # number of recent messages to keep verbatim
+
+
+def _estimate_tokens(messages):
+    """Rough token estimate: 1 token ≈ 4 chars."""
+    total = 0
+    for msg in messages:
+        content = msg.get("content", "")
+        if isinstance(content, str):
+            total += len(content)
+        elif isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict):
+                    total += len(str(item.get("content", "")))
+                else:
+                    # ContentBlock objects from the API
+                    if hasattr(item, "text"):
+                        total += len(item.text)
+                    elif hasattr(item, "input"):
+                        total += len(str(item.input))
+        else:
+            total += len(str(content))
+    return total // 4
+
+
+def _summarize_tool_result(tool_result):
+    """Replace a tool result's content with a short placeholder."""
+    content = tool_result.get("content", "")
+    if len(content) <= 200:
+        return  # already small, not worth summarizing
+
+    # Extract first meaningful line for context
+    first_line = content.split("\n", 1)[0].strip()
+    line_count = content.count("\n") + 1
+
+    if first_line.startswith("Error"):
+        # Keep error messages intact — they're small and Claude may need them
+        return
+
+    tool_result["content"] = f"[{line_count} lines, truncated to save context — re-read the file or re-run the command if needed]\n{first_line}"
+
+
+def _summarize_tool_use_input(block):
+    """Shrink large tool_use inputs in assistant messages (e.g. write_file content)."""
+    if not hasattr(block, "input") or not isinstance(block.input, dict):
+        return
+    content = block.input.get("content", "")
+    if isinstance(content, str) and len(content) > 500:
+        line_count = content.count("\n") + 1
+        block.input["content"] = f"[file content: {line_count} lines, truncated]"
+
+
+def prune_context(messages, token_budget=None):
+    """
+    Trim old tool results when conversation exceeds the token budget.
+    Keeps the first message (original prompt) and the last KEEP_RECENT
+    messages verbatim. Everything in between gets tool results summarized
+    and large tool_use inputs shrunk.
+    """
+    if token_budget is None:
+        token_budget = int(os.environ.get("CODER_TOKEN_BUDGET", "80000"))
+
+    est = _estimate_tokens(messages)
+    if est <= token_budget:
+        return
+
+    # Protected: first message + last KEEP_RECENT
+    prune_end = max(1, len(messages) - KEEP_RECENT)
+    before = est
+
+    for i in range(1, prune_end):
+        msg = messages[i]
+        content = msg.get("content")
+
+        if isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict) and item.get("type") == "tool_result":
+                    _summarize_tool_result(item)
+                # Shrink assistant tool_use inputs (e.g. write_file with full file content)
+                elif hasattr(item, "type") and item.type == "tool_use":
+                    _summarize_tool_use_input(item)
+
+    after = _estimate_tokens(messages)
+    saved = before - after
+    if saved > 0:
+        print(f"  {C.DIM}[pruned ~{saved:,} tokens from old context]{C.RESET}", file=sys.stderr, flush=True)
+
+
+# ── Streaming Response Handler ──────────────────────────────────────────────
+
+def stream_response(client, messages, system):
+    """Stream Claude's response, handling tool-use loops until done."""
+    while True:
+        printed_text = False
+
+        with client.messages.stream(
+            model=MODEL,
+            max_tokens=MAX_TOKENS,
+            system=system,
+            tools=TOOLS,
+            messages=messages,
+        ) as stream:
+            for event in stream:
+                if event.type == "content_block_delta":
+                    if hasattr(event.delta, "text"):
+                        sys.stdout.write(event.delta.text)
+                        sys.stdout.flush()
+                        printed_text = True
+
+            response = stream.get_final_message()
+
+        if printed_text:
+            print()  # newline after streamed text
+
+        # Add the full assistant message to conversation
+        messages.append({"role": "assistant", "content": response.content})
+
+        # If stop reason is tool_use, execute tools and loop
+        if response.stop_reason == "tool_use":
+            tool_results = []
+            for block in response.content:
+                if block.type == "tool_use":
+                    if SAFE_MODE and block.name in NEEDS_PERMISSION:
+                        # Safe mode: show preview and ask
+                        if request_permission(block.name, block.input):
+                            result = execute_tool(block.name, block.input)
+                        else:
+                            result = f"Permission denied: user rejected {block.name} call."
+                    else:
+                        # Default: just run it
+                        print_tool_call(block.name, block.input)
+                        result = execute_tool(block.name, block.input)
+                    # Truncate huge results
+                    if len(result) > 15000:
+                        result = result[:15000] + "\n... (output truncated)"
+                    if _should_nudge(block.name, block.input, result):
+                        result += REFLECT_NUDGE
+                    print_tool_result_summary(block.name, result)
+                    tool_results.append({
+                        "type": "tool_result",
+                        "tool_use_id": block.id,
+                        "content": result,
+                    })
+            messages.append({"role": "user", "content": tool_results})
+            prune_context(messages)
+            print()  # breathing room before next response
+        else:
+            # Print token usage
+            if hasattr(response, "usage") and response.usage:
+                inp = response.usage.input_tokens
+                out = response.usage.output_tokens
+                print(f"{C.DIM}[{inp} in / {out} out tokens]{C.RESET}")
+            break
+
+# ── Headless Prompt Mode ────────────────────────────────────────────────────
+
+def run_prompt(client, prompt, system):
+    """Run a single prompt non-interactively. Returns a JSON-serializable dict."""
+    messages = [{"role": "user", "content": prompt}]
+    files_modified = set()
+    files_created = set()
+    commands_run = []
+    errors = []       # fatal errors
+    warnings = []     # recoverable issues (edit retries, etc.)
+    total_input_tokens = 0
+    total_output_tokens = 0
+
+    # Agent loop — no streaming, log progress to stderr
+    max_turns = int(os.environ.get("CODER_MAX_TURNS", "65"))
+    turn = 0
+
+    while turn < max_turns:
+        turn += 1
+
+        try:
+            response = client.messages.create(
+                model=MODEL,
+                max_tokens=MAX_TOKENS,
+                system=system,
+                tools=TOOLS,
+                messages=messages,
+            )
+        except anthropic.APIError as e:
+            if is_token_limit_error(e):
+                print(f"\n{C.YELLOW}Token limit reached — stopping.{C.RESET}", file=sys.stderr, flush=True)
+                errors.append(str(e))
+                break
+            raise
+
+        # Per-turn token tracking
+        turn_in = turn_out = 0
+        if hasattr(response, "usage") and response.usage:
+            turn_in = response.usage.input_tokens
+            turn_out = response.usage.output_tokens
+            total_input_tokens += turn_in
+            total_output_tokens += turn_out
+
+        messages.append({"role": "assistant", "content": response.content})
+
+        if response.stop_reason == "tool_use":
+            tool_results = []
+            for block in response.content:
+                if block.type == "tool_use":
+                    # Track what's happening
+                    if block.name == "write_file":
+                        path = block.input.get("path", "")
+                        if resolve_path(path).exists():
+                            files_modified.add(path)
+                        else:
+                            files_created.add(path)
+                    elif block.name == "edit_file":
+                        pass  # tracked after execution below
+                    elif block.name == "bash":
+                        commands_run.append(block.input.get("command", ""))
+
+                    # Colored tool log to stderr
+                    _, color = TOOL_LABELS.get(block.name, (block.name, C.DIM))
+                    header = format_tool_header(block.name, block.input)
+                    print(f"  {color}{header}{C.RESET}", file=sys.stderr, flush=True)
+
+                    result = execute_tool(block.name, block.input)
+
+                    # Track successful edits
+                    if block.name == "edit_file" and not result.startswith("Error"):
+                        files_modified.add(block.input.get("path", ""))
+
+                    if result.startswith("Error"):
+                        err_msg = f"{block.name}: {result}"
+                        # Recoverable: file not found on read (exploring), edit match failures (retries)
+                        if (block.name == "read_file" and "not found" in result) or \
+                           (block.name == "edit_file" and "not found" in result):
+                            warnings.append(err_msg)
+                            print(f"  {C.YELLOW}{result.splitlines()[0]}{C.RESET}", file=sys.stderr, flush=True)
+                        else:
+                            errors.append(err_msg)
+                            print(f"  {C.RED}{result.splitlines()[0]}{C.RESET}", file=sys.stderr, flush=True)
+
+                    if len(result) > 15000:
+                        result = result[:15000] + "\n... (output truncated)"
+                    if _should_nudge(block.name, block.input, result):
+                        result += REFLECT_NUDGE
+
+                    tool_results.append({
+                        "type": "tool_result",
+                        "tool_use_id": block.id,
+                        "content": result,
+                    })
+
+            # Token usage for this turn
+            print(f"  {C.DIM}[{turn_in} in / {turn_out} out]{C.RESET}", file=sys.stderr, flush=True)
+
+            messages.append({"role": "user", "content": tool_results})
+
+            # Prune old tool results to prevent quadratic token growth
+            prune_context(messages)
+        else:
+            break
+
+    if turn >= max_turns:
+        errors.append(f"Hit max turns limit ({max_turns})")
+        print(f"{C.RED}Max turns reached ({max_turns}), stopping{C.RESET}", file=sys.stderr, flush=True)
+
+    # Final totals
+    print(f"{C.DIM}Coder finished: {turn} turns, {total_input_tokens} in / {total_output_tokens} out tokens{C.RESET}", file=sys.stderr, flush=True)
+
+    # Extract Claude's final text response
+    final_text = "".join(
+        block.text for block in response.content if block.type == "text"
+    ) if response else ""
+
+    # Ask Claude for a CodeRabbit-oriented summary (skip if we hit token limit)
+    # Uses a standalone minimal prompt — no conversation history, system prompt, or tools.
+    summary = final_text.strip()
+    if not any(is_token_limit_error(e) for e in errors):
+        summary_messages = [{
+            "role": "user",
+            "content": (
+                f"Summarize these code changes in 2-3 sentences for a code review tool.\n\n"
+                f"Files modified: {', '.join(sorted(files_modified)) or 'none'}\n"
+                f"Files created: {', '.join(sorted(files_created)) or 'none'}\n\n"
+                f"Agent's final notes:\n{final_text[:2000]}\n\n"
+                f"Focus on what changed, what was added/fixed, and why. Be specific. No preamble."
+            ),
+        }]
+
+        try:
+            summary_response = client.messages.create(
+                model=MODEL,
+                max_tokens=1024,
+                messages=summary_messages,
+            )
+
+            if hasattr(summary_response, "usage") and summary_response.usage:
+                total_input_tokens += summary_response.usage.input_tokens
+                total_output_tokens += summary_response.usage.output_tokens
+
+            summary = "".join(
+                block.text for block in summary_response.content if block.type == "text"
+            ).strip()
+        except anthropic.APIError as e:
+            if is_token_limit_error(e):
+                errors.append(str(e))
+            else:
+                raise
+
+    result = {
+        "completed": len(errors) == 0,
+        "summary": summary,
+        "files_modified": sorted(files_modified),
+        "files_created": sorted(files_created),
+        "commands_run": commands_run,
+        "usage": {
+            "input_tokens": total_input_tokens,
+            "output_tokens": total_output_tokens,
+        },
+    }
+    if errors:
+        result["errors"] = errors
+    if warnings:
+        result["warnings"] = warnings
+
+    return result
+
+# ── Main ────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Coder — AI coding agent powered by Claude")
+    parser.add_argument("-p", "--prompt", help="Run a single prompt headlessly and output JSON")
+    args = parser.parse_args()
+
+    # if not os.environ.get("ANTHROPIC_API_KEY"):
+    #     print(f"{C.RED}Error: ANTHROPIC_API_KEY not set.{C.RESET}", file=sys.stderr)
+    #     print("  export ANTHROPIC_API_KEY=sk-ant-... (or pk-... for proxy)", file=sys.stderr)
+    #     sys.exit(1)
+
+    proxy_url = os.environ.get("CODER_PROXY_URL")
+    if proxy_url:
+        client = anthropic.Anthropic(base_url=proxy_url.rstrip('/'))
+    else:
+        client = anthropic.Anthropic()
+    system = SYSTEM_PROMPT.format(cwd=os.getcwd(), approach=APPROACH_BLOCK)
+
+    # Load codebase map if available
+    map_file = Path.cwd() / ".coder" / "map.md"
+    if map_file.exists():
+        try:
+            map_content = map_file.read_text(encoding="utf-8").strip()
+            if len(map_content) > 20000:
+                map_content = map_content[:20000] + "\n\n... (map truncated — use list_files to explore further)"
+            system += f"\n\n{map_content}"
+            print(f"{C.DIM}Loaded codebase map ({map_content.count(chr(10))} lines){C.RESET}", file=sys.stderr)
+        except OSError:
+            pass
+
+    # ── Headless prompt mode ────────────────────────────────────────────
+    if args.prompt:
+        try:
+            result = run_prompt(client, args.prompt, system)
+            print(json.dumps(result, indent=2))
+            sys.exit(0 if result["completed"] else 1)
+        except anthropic.APIError as e:
+            print(json.dumps({
+                "completed": False,
+                "summary": f"API error: {e}",
+                "files_modified": [],
+                "files_created": [],
+                "commands_run": [],
+                "errors": [str(e)],
+            }, indent=2))
+            sys.exit(1)
+        except KeyboardInterrupt:
+            print(json.dumps({
+                "completed": False,
+                "summary": "Task interrupted.",
+                "files_modified": [],
+                "files_created": [],
+                "commands_run": [],
+                "errors": ["Interrupted by user"],
+            }, indent=2))
+            sys.exit(130)
+
+    # ── Interactive REPL mode ───────────────────────────────────────────
+    messages = []
+
+    mode_label = f" {C.YELLOW}(safe mode){C.RESET}" if SAFE_MODE else ""
+    print(f"\n{C.BOLD}{C.BLUE}Coder{C.RESET} {C.DIM}— AI coding agent{C.RESET}{mode_label}")
+    print(f"{C.DIM}Model: {MODEL}{C.RESET}")
+    print(f"{C.DIM}Dir:   {os.getcwd()}{C.RESET}")
+    print(f"{C.DIM}Commands: /clear /quit /help{C.RESET}")
+    print()
+
+    histfile = os.path.expanduser("~/.coder_history")
+    try:
+        readline.read_history_file(histfile)
+    except (FileNotFoundError, OSError, PermissionError):
+        pass
+    readline.set_history_length(1000)
+
+    try:
+        while True:
+            try:
+                user_input = input(f"{C.GREEN}>{C.RESET} ").strip()
+            except EOFError:
+                print("\nBye!")
+                break
+
+            if not user_input:
+                continue
+
+            if user_input in ("/quit", "/exit", "/q"):
+                print("Bye!")
+                break
+            if user_input == "/clear":
+                messages.clear()
+                print(f"{C.DIM}Conversation cleared.{C.RESET}\n")
+                continue
+            if user_input == "/help":
+                print(f"  {C.DIM}/clear    Clear conversation history{C.RESET}")
+                print(f"  {C.DIM}/quit     Exit coder{C.RESET}")
+                print(f"  {C.DIM}/model    Show current model{C.RESET}")
+                print(f"  {C.DIM}/tokens   Token estimate for conversation{C.RESET}")
+                if SAFE_MODE:
+                    print(f"  {C.DIM}/permissions        Show always-allowed tools{C.RESET}")
+                    print(f"  {C.DIM}/permissions reset   Reset all permissions{C.RESET}")
+                print(f"  {C.DIM}Ctrl+C   Cancel current response{C.RESET}")
+                print()
+                continue
+            if user_input == "/model":
+                print(f"  {C.DIM}{MODEL}{C.RESET}\n")
+                continue
+            if user_input == "/permissions":
+                if always_allowed:
+                    print(f"  {C.DIM}Always allowed: {', '.join(sorted(always_allowed))}{C.RESET}")
+                else:
+                    print(f"  {C.DIM}No tools always-allowed yet. (approve with 'a' when prompted){C.RESET}")
+                print()
+                continue
+            if user_input == "/permissions reset":
+                always_allowed.clear()
+                print(f"  {C.DIM}Permissions reset. All write tools will prompt again.{C.RESET}\n")
+                continue
+            if user_input == "/tokens":
+                chars = sum(
+                    len(json.dumps(m.get("content", ""))) for m in messages
+                )
+                print(f"  {C.DIM}~{chars // 4} tokens in conversation{C.RESET}\n")
+                continue
+
+            snapshot = len(messages)
+            messages.append({"role": "user", "content": user_input})
+
+            try:
+                print()
+                stream_response(client, messages, system)
+                print()
+            except KeyboardInterrupt:
+                del messages[snapshot:]
+                print(f"\n{C.DIM}(interrupted){C.RESET}\n")
+            except anthropic.APIError as e:
+                del messages[snapshot:]
+                print(f"\n{C.RED}API error: {e}{C.RESET}\n")
+
+    except KeyboardInterrupt:
+        print("\nBye!")
+    finally:
+        try:
+            readline.write_history_file(histfile)
+        except OSError:
+            pass
+
+
+if __name__ == "__main__":
+    main()