agentcode-cli 1.0.0__py3-none-any.whl

mcp_client.py

@@ -0,0 +1,194 @@
+"""
+AgentCode — MCP (Model Context Protocol) client.
+
+Connects to MCP servers defined in .agentcode/mcp.json and exposes
+their tools to the agent loop alongside the built-in tools.
+
+Config format (.agentcode/mcp.json or ~/.agentcode/mcp.json):
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
+    },
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {"GITHUB_TOKEN": "ghp_..."}
+    }
+  }
+}
+
+Tools are exposed as mcp__<server>__<tool> (e.g. mcp__filesystem__read_file).
+"""
+
+import asyncio
+import json
+import os
+import threading
+from contextlib import AsyncExitStack
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+class _ServerConnection:
+    """Holds a live stdio connection to one MCP server."""
+
+    def __init__(self, name: str, config: dict):
+        self.name = name
+        self.config = config
+        self._session = None
+        self._stack: AsyncExitStack | None = None
+
+    async def start(self):
+        from mcp import ClientSession, StdioServerParameters
+        from mcp.client.stdio import stdio_client
+
+        env = os.environ.copy()
+        env.update(self.config.get("env") or {})
+
+        params = StdioServerParameters(
+            command=self.config["command"],
+            args=self.config.get("args", []),
+            env=env,
+        )
+        self._stack = AsyncExitStack()
+        read, write = await self._stack.enter_async_context(stdio_client(params))
+        self._session = await self._stack.enter_async_context(ClientSession(read, write))
+        await self._session.initialize()
+
+    async def stop(self):
+        if self._stack:
+            await self._stack.aclose()
+
+    async def list_tools(self):
+        return await self._session.list_tools()
+
+    async def call_tool(self, name: str, args: dict):
+        return await self._session.call_tool(name, args)
+
+
+class MCPManager:
+    """
+    Manages connections to one or more MCP servers.
+
+    Runs a persistent asyncio event loop in a background thread so the
+    synchronous agent loop can call MCP tools without restructuring.
+    """
+
+    def __init__(self):
+        self._loop = asyncio.new_event_loop()
+        self._thread = threading.Thread(target=self._loop.run_forever, daemon=True)
+        self._thread.start()
+        self._servers: dict[str, _ServerConnection] = {}
+        self._tool_map: dict[str, tuple[str, str]] = {}  # mcp__server__tool -> (server, tool)
+
+    def _run(self, coro, timeout: int = 30):
+        future = asyncio.run_coroutine_threadsafe(coro, self._loop)
+        return future.result(timeout=timeout)
+
+    def connect(self, name: str, config: dict) -> None:
+        conn = _ServerConnection(name, config)
+        self._run(conn.start())
+        self._servers[name] = conn
+        tools = self._run(conn.list_tools())
+        for tool in tools.tools:
+            key = f"mcp__{name}__{tool.name}"
+            self._tool_map[key] = (name, tool.name)
+
+    def is_mcp_tool(self, tool_name: str) -> bool:
+        return tool_name in self._tool_map
+
+    def get_tool_definitions(self) -> list[dict]:
+        """Return OpenAI-format tool definitions for all connected MCP tools."""
+        defs = []
+        for server_name, conn in self._servers.items():
+            tools = self._run(conn.list_tools())
+            for tool in tools.tools:
+                key = f"mcp__{server_name}__{tool.name}"
+                schema = tool.inputSchema if hasattr(tool, "inputSchema") else {
+                    "type": "object", "properties": {}
+                }
+                defs.append({
+                    "type": "function",
+                    "function": {
+                        "name": key,
+                        "description": f"[{server_name}] {tool.description or tool.name}",
+                        "parameters": schema,
+                    },
+                })
+        return defs
+
+    def call_tool(self, tool_name: str, args: dict) -> str:
+        if tool_name not in self._tool_map:
+            return f"Error: Unknown MCP tool '{tool_name}'"
+        server_name, original_name = self._tool_map[tool_name]
+        conn = self._servers[server_name]
+        try:
+            result = self._run(conn.call_tool(original_name, args))
+        except Exception as e:
+            return f"Error calling MCP tool '{tool_name}': {e}"
+
+        if not result.content:
+            return "Tool returned no content."
+        parts = []
+        for block in result.content:
+            if hasattr(block, "text"):
+                parts.append(block.text)
+            elif hasattr(block, "data"):
+                parts.append(f"[binary data: {len(block.data)} bytes]")
+        return "\n".join(parts) or "Tool returned no content."
+
+    def server_names(self) -> list[str]:
+        return list(self._servers.keys())
+
+    def shutdown(self):
+        for conn in self._servers.values():
+            try:
+                self._run(conn.stop(), timeout=5)
+            except Exception:
+                pass
+        self._loop.call_soon_threadsafe(self._loop.stop)
+
+
+# ── Config loading ─────────────────────────────────────────────────────────────
+
+def load_mcp_config(project_dir: str) -> dict:
+    config: dict = {}
+    for path in [
+        Path.home() / ".agentcode" / "mcp.json",
+        Path(project_dir) / ".agentcode" / "mcp.json",
+    ]:
+        if path.exists():
+            try:
+                data = json.loads(path.read_text())
+                config.update(data.get("mcpServers", {}))
+            except Exception as e:
+                console.print(f"[warning]⚠ Failed to parse MCP config {path}: {e}[/warning]")
+    return config
+
+
+def create_mcp_manager(project_dir: str) -> "MCPManager | None":
+    """Load config and connect to all configured MCP servers. Returns None if none configured."""
+    try:
+        import mcp  # noqa: check available
+    except ImportError:
+        return None
+
+    config = load_mcp_config(project_dir)
+    if not config:
+        return None
+
+    manager = MCPManager()
+    for name, server_config in config.items():
+        try:
+            manager.connect(name, server_config)
+            console.print(f"[dim]  MCP: connected to [bold]{name}[/bold] "
+                          f"({len([k for k in manager._tool_map if k.startswith(f'mcp__{name}__')])} tools)[/dim]")
+        except Exception as e:
+            console.print(f"[warning]⚠ MCP server '{name}' failed: {e}[/warning]")
+
+    return manager if manager._servers else None

router.py

@@ -0,0 +1,298 @@
+"""
+AgentCode - Cost-aware model router.
+
+Automatically picks the cheapest model that can handle the task.
+Simple questions get a fast, cheap model. Complex multi-file refactors
+get a powerful, expensive one.
+"""
+
+import re
+from dataclasses import dataclass, field
+from rich.console import Console
+
+console = Console()
+
+
+# ── Model Tiers ───────────────────────────────────────────────────────────────
+
+@dataclass
+class ModelTier:
+    """A model with its capabilities and pricing."""
+    name: str                    # LiteLLM model string
+    tier: str                    # "light", "medium", "heavy"
+    label: str                   # Human-readable label
+    input_cost_per_mtok: float   # $ per 1M input tokens
+    output_cost_per_mtok: float  # $ per 1M output tokens
+
+
+# ── Default Model Configs ─────────────────────────────────────────────────────
+# Users can override these via AGENTCODE.md or environment variables.
+# Costs are approximate as of mid-2026.
+
+ANTHROPIC_TIERS = [
+    ModelTier("claude-haiku-4-5-20251001", "light", "Haiku 4.5", 0.80, 4.00),
+    ModelTier("claude-sonnet-4-6", "medium", "Sonnet 4.6", 3.00, 15.00),
+    ModelTier("claude-opus-4-6", "heavy", "Opus 4.6", 15.00, 75.00),
+]
+
+OPENAI_TIERS = [
+    ModelTier("gpt-4o-mini", "light", "GPT-4o Mini", 0.15, 0.60),
+    ModelTier("gpt-4o", "medium", "GPT-4o", 2.50, 10.00),
+    ModelTier("gpt-5.5", "heavy", "GPT-5.5", 15.00, 60.00),
+]
+
+GEMINI_TIERS = [
+    ModelTier("gemini/gemini-2.0-flash", "light", "Gemini 2.0 Flash", 0.10, 0.40),
+    ModelTier("gemini/gemini-2.5-flash", "medium", "Gemini 2.5 Flash", 0.25, 1.00),
+    ModelTier("gemini/gemini-2.5-pro", "heavy", "Gemini 2.5 Pro", 1.25, 10.00),
+]
+
+# Provider configs keyed by prefix
+PROVIDER_TIERS = {
+    "anthropic": ANTHROPIC_TIERS,
+    "openai": OPENAI_TIERS,
+    "gemini": GEMINI_TIERS,
+}
+
+
+# ── Task Complexity Classification ────────────────────────────────────────────
+
+# Patterns that signal increasing complexity
+LIGHT_PATTERNS = [
+    r"\b(explain|what is|what are|what does|how does|describe|list|show|tell me)\b",
+    r"\b(read|cat|view|print|display|show me|open)\b",
+    r"\b(git status|git log|git diff)\b",
+    r"\b(hello|hi|hey|thanks|thank you)\b",
+    r"\b(format|lint|indent|rename)\b",
+    r"\b(typo|spelling|grammar|comment)\b",
+]
+
+MEDIUM_PATTERNS = [
+    r"\b(write|create|add|implement|build|make|generate)\b",
+    r"\b(fix|bug|error|debug|broken|failing|issue)\b",
+    r"\b(test|unit test|pytest|spec)\b",
+    r"\b(function|class|method|endpoint|route|api)\b",
+    r"\b(edit|update|change|modify)\b",
+    r"\b(install|setup|configure|deploy)\b",
+]
+
+HEAVY_PATTERNS = [
+    r"\b(refactor|restructure|redesign|rearchitect|overhaul)\b",
+    r"\b(migrate|migration|upgrade|convert|port)\b",
+    r"\b(entire|whole|all files|every file|codebase|full)\b",
+    r"\b(optimize|performance|bottleneck|profil)\b",
+    r"\b(security|vulnerability|audit|review all)\b",
+    r"\b(multi.?file|across files|multiple files)\b",
+    r"\b(design pattern|architecture|system design)\b",
+    r"\b(from scratch|ground up|complete|comprehensive)\b",
+]
+
+
+def classify_complexity(user_input: str) -> str:
+    """
+    Classify task complexity as 'light', 'medium', or 'heavy'.
+
+    Uses pattern matching on the user's prompt. This is intentionally
+    simple and transparent — users can see exactly why a model was chosen.
+    """
+    text = user_input.lower().strip()
+
+    # Score each tier
+    heavy_score = sum(1 for p in HEAVY_PATTERNS if re.search(p, text, re.IGNORECASE))
+    medium_score = sum(1 for p in MEDIUM_PATTERNS if re.search(p, text, re.IGNORECASE))
+    light_score = sum(1 for p in LIGHT_PATTERNS if re.search(p, text, re.IGNORECASE))
+
+    # Length heuristic: very long prompts are usually complex
+    if len(text) > 500:
+        heavy_score += 2
+    elif len(text) > 200:
+        medium_score += 1
+
+    # Multiple file references suggest complexity
+    file_refs = len(re.findall(r'\.\w{1,4}\b', text))  # .py, .js, .tsx, etc.
+    if file_refs >= 3:
+        heavy_score += 2
+    elif file_refs >= 2:
+        medium_score += 1
+
+    # Decision logic
+    if heavy_score >= 2:
+        return "heavy"
+    elif heavy_score >= 1 and medium_score >= 1:
+        return "heavy"
+    elif medium_score >= 1:
+        return "medium"
+    else:
+        return "light"
+
+
+# ── Router ────────────────────────────────────────────────────────────────────
+
+@dataclass
+class CostTracker:
+    """Track cumulative costs across a session."""
+    total_input_tokens: int = 0
+    total_output_tokens: int = 0
+    total_cost: float = 0.0
+    requests: list[dict] = field(default_factory=list)
+    last_turn_input: int = 0
+    last_turn_output: int = 0
+    last_turn_cost: float = 0.0
+
+    def begin_turn(self):
+        """Reset per-turn counters at the start of each agent loop call."""
+        self.last_turn_input = 0
+        self.last_turn_output = 0
+        self.last_turn_cost = 0.0
+
+    def record(self, model: str, input_tokens: int, output_tokens: int, cost: float):
+        self.total_input_tokens += input_tokens
+        self.total_output_tokens += output_tokens
+        self.total_cost += cost
+        self.last_turn_input += input_tokens
+        self.last_turn_output += output_tokens
+        self.last_turn_cost += cost
+        self.requests.append({
+            "model": model,
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "cost": cost,
+        })
+
+    def summary(self) -> str:
+        if not self.requests:
+            return "No requests yet."
+        lines = [
+            f"Session total: ${self.total_cost:.4f} "
+            f"({self.total_input_tokens:,} in / {self.total_output_tokens:,} out)",
+            f"Requests: {len(self.requests)}",
+        ]
+        # Show last 5 requests
+        for r in self.requests[-5:]:
+            lines.append(
+                f"  {r['model']}: ${r['cost']:.4f} "
+                f"({r['input_tokens']:,} in / {r['output_tokens']:,} out)"
+            )
+        if len(self.requests) > 5:
+            lines.append(f"  ... and {len(self.requests) - 5} earlier requests")
+        return "\n".join(lines)
+
+
+@dataclass
+class ModelRouter:
+    """
+    Cost-aware model router.
+
+    Automatically selects the cheapest model that can handle the task.
+    Falls back to the default model if no tier config is available.
+    """
+    provider: str = "anthropic"       # "anthropic" or "openai"
+    default_model: str = "claude-sonnet-4-6"
+    enabled: bool = True              # False = always use default_model
+    cost_tracker: CostTracker = field(default_factory=CostTracker)
+
+    # Allow per-tier overrides
+    light_model: str | None = None
+    medium_model: str | None = None
+    heavy_model: str | None = None
+
+    def get_tiers(self) -> list[ModelTier]:
+        """Get the tier config for the current provider."""
+        return PROVIDER_TIERS.get(self.provider, [])
+
+    def detect_provider(self, model_string: str) -> str:
+        """Detect provider from a model string."""
+        m = model_string.lower()
+        if "claude" in m or "anthropic" in m:
+            return "anthropic"
+        elif "gpt" in m or "openai" in m or "o1" in m or "o3" in m:
+            return "openai"
+        elif "gemini" in m or "google" in m:
+            return "gemini"
+        else:
+            return "unknown"
+
+    def route(self, user_input: str) -> tuple[str, str, str]:
+        """
+        Pick the best model for this task.
+
+        Returns:
+            (model_string, tier, reason) — the model to use, its tier,
+            and a human-readable explanation of why it was chosen.
+        """
+        if not self.enabled:
+            return self.default_model, "default", "routing disabled"
+
+        complexity = classify_complexity(user_input)
+
+        # Check for per-tier overrides first
+        if complexity == "light" and self.light_model:
+            return self.light_model, "light", self._reason(user_input, complexity)
+        elif complexity == "medium" and self.medium_model:
+            return self.medium_model, "medium", self._reason(user_input, complexity)
+        elif complexity == "heavy" and self.heavy_model:
+            return self.heavy_model, "heavy", self._reason(user_input, complexity)
+
+        # Use provider tier defaults
+        tiers = self.get_tiers()
+        if not tiers:
+            return self.default_model, "default", "no tier config for provider"
+
+        tier_map = {t.tier: t for t in tiers}
+        tier = tier_map.get(complexity)
+        if tier:
+            return tier.name, complexity, self._reason(user_input, complexity)
+
+        return self.default_model, "default", "no matching tier"
+
+    def _reason(self, user_input: str, complexity: str) -> str:
+        """Generate a human-readable reason for the routing decision."""
+        reasons = {
+            "light": "simple query — using fast, cheap model",
+            "medium": "standard coding task — using balanced model",
+            "heavy": "complex multi-step task — using powerful model",
+        }
+        return reasons.get(complexity, "unknown complexity")
+
+    def estimate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
+        """Estimate cost for a request."""
+        # Search all tiers for this model
+        for tiers in PROVIDER_TIERS.values():
+            for tier in tiers:
+                if tier.name == model:
+                    cost = (
+                        (input_tokens / 1_000_000) * tier.input_cost_per_mtok
+                        + (output_tokens / 1_000_000) * tier.output_cost_per_mtok
+                    )
+                    return cost
+        return 0.0  # Unknown model, can't estimate
+
+    def get_tier_info(self, model: str) -> ModelTier | None:
+        """Get tier info for a model."""
+        for tiers in PROVIDER_TIERS.values():
+            for tier in tiers:
+                if tier.name == model:
+                    return tier
+        return None
+
+
+def display_routing_decision(model: str, tier: str, reason: str, router: ModelRouter):
+    """Show the user which model was selected and why."""
+    tier_colors = {
+        "light": "green",
+        "medium": "yellow",
+        "heavy": "red",
+        "default": "cyan",
+    }
+    color = tier_colors.get(tier, "white")
+
+    tier_info = router.get_tier_info(model)
+    cost_hint = ""
+    if tier_info:
+        cost_hint = f" [dim](${tier_info.input_cost_per_mtok:.2f}/${tier_info.output_cost_per_mtok:.2f} per 1M tok)[/dim]"
+
+    console.print(
+        f"  [{color}]⚡ {tier.upper()}[/{color}] → "
+        f"[bold]{model}[/bold]{cost_hint} "
+        f"[dim]({reason})[/dim]"
+    )

settings.py

@@ -0,0 +1,185 @@
+"""AgentCode settings — load and merge configuration from global, project, and CLI."""
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+DEFAULT_AUTO_APPROVE = [
+    "read_file", "list_directory", "search_files", "search_text",
+    "git_status", "git_log", "git_diff", "spawn_subagents",
+]
+
+
+@dataclass
+class PermissionsSettings:
+    auto_approve_all: bool = False
+    auto_approve: list[str] = field(default_factory=lambda: list(DEFAULT_AUTO_APPROVE))
+    deny: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ModelSettings:
+    default: str = "claude-sonnet-4-6"
+    routing: bool = True
+    light: str | None = None
+    medium: str | None = None
+    heavy: str | None = None
+
+
+@dataclass
+class LimitsSettings:
+    max_file_size: int = 1_000_000
+    max_output: int = 50_000
+    max_search_results: int = 100
+    max_iterations: int = 25
+
+
+@dataclass
+class Settings:
+    permissions: PermissionsSettings = field(default_factory=PermissionsSettings)
+    model: ModelSettings = field(default_factory=ModelSettings)
+    limits: LimitsSettings = field(default_factory=LimitsSettings)
+    hooks: dict[str, str] = field(default_factory=dict)
+
+
+# ── Merge helpers ─────────────────────────────────────────────────────────────
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    """Recursively merge override into base, returning a new dict."""
+    result = base.copy()
+    for key, val in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(val, dict):
+            result[key] = _deep_merge(result[key], val)
+        else:
+            result[key] = val
+    return result
+
+
+def _load_json(path: Path) -> dict:
+    try:
+        return json.loads(path.read_text())
+    except Exception:
+        return {}
+
+
+def _dict_to_settings(d: dict) -> "Settings":
+    """Construct a Settings from a merged raw dict, filling in defaults for missing keys."""
+    perms_d = d.get("permissions", {})
+    model_d = d.get("model", {})
+    limits_d = d.get("limits", {})
+    hooks_d = d.get("hooks", {})
+
+    return Settings(
+        permissions=PermissionsSettings(
+            auto_approve_all=bool(perms_d.get("auto_approve_all", False)),
+            auto_approve=list(perms_d.get("auto_approve", DEFAULT_AUTO_APPROVE)),
+            deny=list(perms_d.get("deny", [])),
+        ),
+        model=ModelSettings(
+            default=str(model_d.get("default", "claude-sonnet-4-6")),
+            routing=bool(model_d.get("routing", True)),
+            light=model_d.get("light") or None,
+            medium=model_d.get("medium") or None,
+            heavy=model_d.get("heavy") or None,
+        ),
+        limits=LimitsSettings(
+            max_file_size=int(limits_d.get("max_file_size", 1_000_000)),
+            max_output=int(limits_d.get("max_output", 50_000)),
+            max_search_results=int(limits_d.get("max_search_results", 100)),
+            max_iterations=int(limits_d.get("max_iterations", 25)),
+        ),
+        hooks=dict(hooks_d),
+    )
+
+
+# ── Public API ────────────────────────────────────────────────────────────────
+
+def load_settings(project_dir: str, cli_overrides: dict | None = None) -> "Settings":
+    """
+    Load settings by merging (later layers override earlier ones):
+      1. Built-in defaults
+      2. ~/.agentcode/settings.json       (global)
+      3. <project>/.agentcode/settings.json  (project)
+      4. cli_overrides                    (CLI flags, highest priority)
+    """
+    merged: dict = {}
+
+    global_path = Path.home() / ".agentcode" / "settings.json"
+    if global_path.exists():
+        merged = _deep_merge(merged, _load_json(global_path))
+
+    project_path = Path(project_dir) / ".agentcode" / "settings.json"
+    if project_path.exists():
+        merged = _deep_merge(merged, _load_json(project_path))
+
+    if cli_overrides:
+        merged = _deep_merge(merged, cli_overrides)
+
+    return _dict_to_settings(merged)
+
+
+def settings_sources(project_dir: str) -> dict[str, str | None]:
+    """Return paths to settings files that currently exist on disk."""
+    global_path = Path.home() / ".agentcode" / "settings.json"
+    project_path = Path(project_dir) / ".agentcode" / "settings.json"
+    return {
+        "global": str(global_path) if global_path.exists() else None,
+        "project": str(project_path) if project_path.exists() else None,
+    }
+
+
+# ── Starter template ──────────────────────────────────────────────────────────
+
+STARTER_SETTINGS: dict = {
+    "permissions": {
+        "auto_approve_all": False,
+        "auto_approve": [
+            "read_file", "list_directory", "search_files", "search_text",
+            "git_status", "git_log", "git_diff", "spawn_subagents"
+        ],
+        "deny": []
+    },
+    "model": {
+        "default": "claude-sonnet-4-6",
+        "routing": True,
+        "light": None,
+        "medium": None,
+        "heavy": None
+    },
+    "limits": {
+        "max_file_size": 1000000,
+        "max_output": 50000,
+        "max_search_results": 100,
+        "max_iterations": 25
+    },
+    "hooks": {}
+}
+
+SETTINGS_HELP = """\
+permissions.auto_approve_all  true to skip all permission prompts (like --auto-approve)
+permissions.auto_approve      tools that run without asking (default: read-only tools)
+permissions.deny              tools that are always blocked, regardless of other settings
+model.default                 default LLM model string (e.g. "claude-sonnet-4-6")
+model.routing                 enable cost-aware model routing (true/false)
+model.light/medium/heavy      override the model used for each routing tier
+limits.max_file_size          max bytes for read_file (default: 1,000,000)
+limits.max_output             max chars for tool output truncation (default: 50,000)
+limits.max_search_results     cap on results from search tools (default: 100)
+limits.max_iterations         max tool-call loops per turn (default: 25)
+hooks                         shell commands run before/after tool calls
+                              keys: pre_<tool>, post_<tool>, pre_tool, post_tool\
+"""
+
+
+def generate_starter_settings(project_dir: str) -> tuple[Path, bool]:
+    """
+    Write a starter settings.json to <project>/.agentcode/settings.json.
+    Returns (path, created): created=False if the file already existed.
+    """
+    path = Path(project_dir) / ".agentcode" / "settings.json"
+    existed = path.exists()
+    if not existed:
+        path.parent.mkdir(exist_ok=True)
+        path.write_text(json.dumps(STARTER_SETTINGS, indent=2))
+    return path, not existed