codemaxxing 0.2.1 → 0.3.1

package/README.md

@@ -121,11 +121,56 @@ codemaxxing --provider openrouter
 ### 🔥 Streaming Tokens
 Real-time token display. See the model think, not just the final answer.
 
-### ⚠️ Tool Approval
-Dangerous operations (file writes, shell commands) require your approval. Press `y` to allow, `n` to deny, `a` to always allow for the session.
+### ⚠️ Tool Approval + Diff Preview
+Dangerous operations require your approval. File writes show a **unified diff** of what will change before you say yes. Press `y` to allow, `n` to deny, `a` to always allow.
+
+### 🏗️ Architect Mode
+Dual-model planning. A "planner" model reasons through the approach, then your editor model executes the changes.
+- `/architect` — toggle on/off
+- `/architect claude-3-5-sonnet` — set the planner model
+- Great for pairing expensive reasoning models with fast editors
+
+### 🧠 Skills System (21 Built-In)
+Downloadable skill packs that teach the agent domain expertise. Ships with 21 built-in skills:
+
+**Frontend:** react-expert, nextjs-app, tailwind-ui, svelte-kit
+**Mobile:** react-native, swift-ios, flutter
+**Backend:** python-pro, node-backend, go-backend, rust-systems
+**Data:** sql-master, supabase
+**Practices:** typescript-strict, api-designer, test-engineer, doc-writer, security-audit, devops-toolkit, git-workflow
+**Game Dev:** unity-csharp
+
+```
+/skills              # Browse & install from registry
+/skills install X    # Quick install
+/skills on/off X     # Toggle per session
+```
+
+Project-level config: add `.codemaxxing/skills.json` to scope skills per project.
+
+### 📋 CODEMAXXING.md — Project Rules
+Drop a `CODEMAXXING.md` in your project root for project-specific instructions. Auto-loaded every session. Also supports `.cursorrules` for Cursor migrants.
+
+### 🔧 Auto-Lint
+Automatically runs your linter after every file edit and feeds errors back to the model for auto-fix. Detects eslint, biome, ruff, clippy, golangci-lint, and more.
+- `/lint on` / `/lint off` — toggle (ON by default)
 
 ### 📂 Smart Context (Repo Map)
-Automatically scans your codebase and builds a map of functions, classes, and types. The model knows what exists where without reading every file.
+Scans your codebase and builds a map of functions, classes, and types. The model knows what exists where without reading every file.
+
+### 📦 Context Compression
+When conversation history exceeds 80k tokens, older messages are automatically summarized to free up context. Configurable via `contextCompressionThreshold`.
+
+### 💰 Cost Tracking
+Per-session token usage and estimated cost in the status bar. Pricing for 20+ common models. Saved to session history.
+
+### 🖥️ Headless/CI Mode
+Run codemaxxing in scripts and pipelines without the TUI:
+```bash
+codemaxxing exec "add error handling to api.ts"
+codemaxxing exec --auto-approve "fix all lint errors"
+echo "add tests" | codemaxxing exec
+```
 
 ### 🔀 Git Integration
 Opt-in git commands built in:
@@ -138,18 +183,23 @@ Opt-in git commands built in:
 ### 💾 Session Persistence
 Conversations auto-save to SQLite. Pick up where you left off:
 - `/sessions` — list past sessions
+- `/session delete` — remove a session
 - `/resume` — interactive session picker
 
 ### 🔄 Multi-Provider
 Switch models mid-session without restarting:
 - `/model gpt-4o` — switch to a different model
 - `/models` — list available models from your provider
+- Native Anthropic API support (not just OpenAI-compatible)
+
+### 🎨 14 Themes
+`/theme` to browse: cyberpunk-neon, dracula, gruvbox, nord, catppuccin, tokyo-night, one-dark, rosé-pine, synthwave, blood-moon, mono, solarized, hacker, acid
 
 ### 🔐 Authentication
-One command to connect any LLM provider. OpenRouter OAuth (browser login for 200+ models), Anthropic subscription linking, Codex/Qwen CLI import, GitHub Copilot device flow, or manual API keys. Use `codemaxxing login` or `/login` in-session.
+One command to connect any LLM provider. OpenRouter OAuth, Anthropic subscription linking, Codex/Qwen CLI import, GitHub Copilot device flow, or manual API keys.
 
 ### 📋 Smart Paste
-Paste large code blocks without breaking the UI. Multi-line pastes collapse into `[Pasted text #1 +N lines]` badges (like Claude Code).
+Multi-line pastes collapse into `[Pasted text #1 +N lines]` badges.
 
 ### ⌨️ Slash Commands
 Type `/` for autocomplete suggestions. Arrow keys to navigate, Tab or Enter to select.
@@ -159,11 +209,17 @@ Type `/` for autocomplete suggestions. Arrow keys to navigate, Tab or Enter to s
 | Command | Description |
 |---------|-------------|
 | `/help` | Show all commands |
+| `/connect` | Retry LLM connection |
 | `/login` | Interactive auth setup |
+| `/architect` | Toggle architect mode / set model |
+| `/skills` | Browse, install, manage skills |
+| `/lint on/off` | Toggle auto-linting |
 | `/model <name>` | Switch model mid-session |
 | `/models` | List available models |
+| `/theme` | Switch color theme |
 | `/map` | Show repository map |
 | `/sessions` | List past sessions |
+| `/session delete` | Delete a session |
 | `/resume` | Resume a past session |
 | `/reset` | Clear conversation |
 | `/context` | Show message count + tokens |
@@ -174,7 +230,17 @@ Type `/` for autocomplete suggestions. Arrow keys to navigate, Tab or Enter to s
 | `/git on/off` | Toggle auto-commits |
 | `/quit` | Exit |
 
-## CLI Flags
+## CLI
+
+```bash
+codemaxxing                          # Start TUI
+codemaxxing login                    # Auth setup
+codemaxxing auth list                # Show saved credentials
+codemaxxing exec "prompt"            # Headless mode (no TUI)
+codemaxxing exec --auto-approve "x"  # Skip approval prompts
+codemaxxing exec --json "x"          # JSON output for scripts
+echo "fix tests" | codemaxxing exec  # Pipe from stdin
+```
 
 ```
 -m, --model <model>       Model name to use

package/dist/agent.d.ts

@@ -1,3 +1,4 @@
+import { type ConnectedServer } from "./utils/mcp.js";
 import type { ProviderConfig } from "./config.js";
 export interface AgentOptions {
     provider: ProviderConfig;
@@ -11,6 +12,9 @@ export interface AgentOptions {
     onToolApproval?: (name: string, args: Record<string, unknown>, diff?: string) => Promise<"yes" | "no" | "always">;
     onGitCommit?: (message: string) => void;
     onContextCompressed?: (oldTokens: number, newTokens: number) => void;
+    onArchitectPlan?: (plan: string) => void;
+    onLintResult?: (file: string, errors: string) => void;
+    onMCPStatus?: (server: string, status: string) => void;
     contextCompressionThreshold?: number;
 }
 export declare class CodingAgent {
@@ -35,6 +39,11 @@ export declare class CodingAgent {
     private systemPrompt;
     private compressionThreshold;
     private sessionDisabledSkills;
+    private projectRulesSource;
+    private architectModel;
+    private autoLintEnabled;
+    private detectedLinter;
+    private mcpServers;
     constructor(options: AgentOptions);
     /**
      * Initialize the agent — call this after constructor to build async context
@@ -53,6 +62,10 @@ export declare class CodingAgent {
      * Rebuild the repo map (useful after file changes)
      */
     refreshRepoMap(): Promise<string>;
+    /**
+     * Send a message, routing through architect model if enabled
+     */
+    send(userMessage: string): Promise<string>;
     /**
      * Stream a response from the model.
      * Assembles tool call chunks, emits tokens in real-time,
@@ -97,5 +110,26 @@ export declare class CodingAgent {
     getSessionDisabledSkills(): Set<string>;
     getActiveSkillCount(): number;
     getCwd(): string;
+    getProjectRulesSource(): string | null;
+    setArchitectModel(model: string | null): void;
+    getArchitectModel(): string | null;
+    setAutoLint(enabled: boolean): void;
+    isAutoLintEnabled(): boolean;
+    getDetectedLinter(): {
+        command: string;
+        name: string;
+    } | null;
+    setDetectedLinter(linter: {
+        command: string;
+        name: string;
+    } | null): void;
+    /**
+     * Run the architect model to generate a plan, then feed to editor model
+     */
+    private architectChat;
+    getMCPServerCount(): number;
+    getMCPServers(): ConnectedServer[];
+    disconnectMCP(): Promise<void>;
+    reconnectMCP(): Promise<void>;
     reset(): void;
 }

package/dist/agent.js

@@ -1,10 +1,12 @@
 import OpenAI from "openai";
 import Anthropic from "@anthropic-ai/sdk";
 import { FILE_TOOLS, executeTool, generateDiff, getExistingContent } from "./tools/files.js";
-import { buildProjectContext, getSystemPrompt } from "./utils/context.js";
+import { detectLinter, runLinter } from "./utils/lint.js";
+import { buildProjectContext, getSystemPrompt, loadProjectRules } from "./utils/context.js";
 import { isGitRepo, autoCommit } from "./utils/git.js";
 import { buildSkillPrompts, getActiveSkillCount } from "./utils/skills.js";
 import { createSession, saveMessage, updateTokenEstimate, updateSessionCost, loadMessages } from "./utils/sessions.js";
+import { loadMCPConfig, connectToServers, disconnectAll, getAllMCPTools, parseMCPToolName, callMCPTool } from "./utils/mcp.js";
 // Tools that can modify your project — require approval
 const DANGEROUS_TOOLS = new Set(["write_file", "run_command"]);
 // Cost per 1M tokens (input/output) for common models
@@ -73,6 +75,11 @@ export class CodingAgent {
     systemPrompt = "";
     compressionThreshold;
     sessionDisabledSkills = new Set();
+    projectRulesSource = null;
+    architectModel = null;
+    autoLintEnabled = true;
+    detectedLinter = null;
+    mcpServers = [];
     constructor(options) {
         this.options = options;
         this.providerType = options.provider.type || "openai";
@@ -102,7 +109,21 @@ export class CodingAgent {
     async init() {
         const context = await buildProjectContext(this.cwd);
         const skillPrompts = buildSkillPrompts(this.cwd, this.sessionDisabledSkills);
-        this.systemPrompt = await getSystemPrompt(context, skillPrompts);
+        const rules = loadProjectRules(this.cwd);
+        if (rules)
+            this.projectRulesSource = rules.source;
+        this.systemPrompt = await getSystemPrompt(context, skillPrompts, rules?.content ?? "");
+        // Detect project linter
+        this.detectedLinter = detectLinter(this.cwd);
+        // Connect to MCP servers
+        const mcpConfig = loadMCPConfig(this.cwd);
+        if (Object.keys(mcpConfig.mcpServers).length > 0) {
+            this.mcpServers = await connectToServers(mcpConfig, this.options.onMCPStatus);
+            if (this.mcpServers.length > 0) {
+                const mcpTools = getAllMCPTools(this.mcpServers);
+                this.tools = [...FILE_TOOLS, ...mcpTools];
+            }
+        }
         this.messages = [
             { role: "system", content: this.systemPrompt },
         ];
@@ -138,6 +159,15 @@ export class CodingAgent {
         this.repoMap = await buildRepoMap(this.cwd);
         return this.repoMap;
     }
+    /**
+     * Send a message, routing through architect model if enabled
+     */
+    async send(userMessage) {
+        if (this.architectModel) {
+            return this.architectChat(userMessage);
+        }
+        return this.chat(userMessage);
+    }
     /**
      * Stream a response from the model.
      * Assembles tool call chunks, emits tokens in real-time,
@@ -286,7 +316,15 @@ export class CodingAgent {
                         }
                     }
                 }
-                const result = await executeTool(toolCall.name, args, this.cwd);
+                // Route to MCP or built-in tool
+                const mcpParsed = parseMCPToolName(toolCall.name);
+                let result;
+                if (mcpParsed) {
+                    result = await callMCPTool(mcpParsed.serverName, mcpParsed.toolName, args);
+                }
+                else {
+                    result = await executeTool(toolCall.name, args, this.cwd);
+                }
                 this.options.onToolResult?.(toolCall.name, result);
                 // Auto-commit after successful write_file (only if enabled)
                 if (this.gitEnabled && this.autoCommitEnabled && toolCall.name === "write_file" && result.startsWith("✅")) {
@@ -296,6 +334,22 @@ export class CodingAgent {
                         this.options.onGitCommit?.(`write ${path}`);
                     }
                 }
+                // Auto-lint after successful write_file
+                if (this.autoLintEnabled && this.detectedLinter && toolCall.name === "write_file" && result.startsWith("✅")) {
+                    const filePath = String(args.path ?? "");
+                    const lintErrors = runLinter(this.detectedLinter, filePath, this.cwd);
+                    if (lintErrors) {
+                        this.options.onLintResult?.(filePath, lintErrors);
+                        const lintMsg = {
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: result + `\n\nLint errors detected in ${filePath}:\n${lintErrors}\nPlease fix these issues.`,
+                        };
+                        this.messages.push(lintMsg);
+                        saveMessage(this.sessionId, lintMsg);
+                        continue; // skip the normal tool message push
+                    }
+                }
                 const toolMsg = {
                     role: "tool",
                     tool_call_id: toolCall.id,
@@ -467,7 +521,15 @@ export class CodingAgent {
                         }
                     }
                 }
-                const result = await executeTool(toolCall.name, args, this.cwd);
+                // Route to MCP or built-in tool
+                const mcpParsed = parseMCPToolName(toolCall.name);
+                let result;
+                if (mcpParsed) {
+                    result = await callMCPTool(mcpParsed.serverName, mcpParsed.toolName, args);
+                }
+                else {
+                    result = await executeTool(toolCall.name, args, this.cwd);
+                }
                 this.options.onToolResult?.(toolCall.name, result);
                 // Auto-commit after successful write_file
                 if (this.gitEnabled && this.autoCommitEnabled && toolCall.name === "write_file" && result.startsWith("✅")) {
@@ -477,6 +539,22 @@ export class CodingAgent {
                         this.options.onGitCommit?.(`write ${path}`);
                     }
                 }
+                // Auto-lint after successful write_file
+                if (this.autoLintEnabled && this.detectedLinter && toolCall.name === "write_file" && result.startsWith("✅")) {
+                    const filePath = String(args.path ?? "");
+                    const lintErrors = runLinter(this.detectedLinter, filePath, this.cwd);
+                    if (lintErrors) {
+                        this.options.onLintResult?.(filePath, lintErrors);
+                        const lintMsg = {
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: result + `\n\nLint errors detected in ${filePath}:\n${lintErrors}\nPlease fix these issues.`,
+                        };
+                        this.messages.push(lintMsg);
+                        saveMessage(this.sessionId, lintMsg);
+                        continue;
+                    }
+                }
                 const toolMsg = {
                     role: "tool",
                     tool_call_id: toolCall.id,
@@ -632,6 +710,83 @@ export class CodingAgent {
     getCwd() {
         return this.cwd;
     }
+    getProjectRulesSource() {
+        return this.projectRulesSource;
+    }
+    setArchitectModel(model) {
+        this.architectModel = model;
+    }
+    getArchitectModel() {
+        return this.architectModel;
+    }
+    setAutoLint(enabled) {
+        this.autoLintEnabled = enabled;
+    }
+    isAutoLintEnabled() {
+        return this.autoLintEnabled;
+    }
+    getDetectedLinter() {
+        return this.detectedLinter;
+    }
+    setDetectedLinter(linter) {
+        this.detectedLinter = linter;
+    }
+    /**
+     * Run the architect model to generate a plan, then feed to editor model
+     */
+    async architectChat(userMessage) {
+        const architectSystemPrompt = "You are a senior software architect. Analyze the request and create a detailed implementation plan. List exactly which files to modify, what changes to make, and in what order. Do NOT write code — just plan.";
+        let plan = "";
+        if (this.providerType === "anthropic" && this.anthropicClient) {
+            const response = await this.anthropicClient.messages.create({
+                model: this.architectModel,
+                max_tokens: this.maxTokens,
+                system: architectSystemPrompt,
+                messages: [{ role: "user", content: userMessage }],
+            });
+            plan = response.content
+                .filter((b) => b.type === "text")
+                .map((b) => b.text)
+                .join("");
+        }
+        else {
+            const response = await this.client.chat.completions.create({
+                model: this.architectModel,
+                max_tokens: this.maxTokens,
+                messages: [
+                    { role: "system", content: architectSystemPrompt },
+                    { role: "user", content: userMessage },
+                ],
+            });
+            plan = response.choices[0]?.message?.content ?? "(no plan generated)";
+        }
+        this.options.onArchitectPlan?.(plan);
+        // Feed plan + original request to the editor model
+        const editorPrompt = `## Architect Plan\n${plan}\n\n## Original Request\n${userMessage}\n\nExecute the plan above. Follow it step by step.`;
+        return this.chat(editorPrompt);
+    }
+    getMCPServerCount() {
+        return this.mcpServers.length;
+    }
+    getMCPServers() {
+        return this.mcpServers;
+    }
+    async disconnectMCP() {
+        await disconnectAll();
+        this.mcpServers = [];
+        this.tools = FILE_TOOLS;
+    }
+    async reconnectMCP() {
+        await this.disconnectMCP();
+        const mcpConfig = loadMCPConfig(this.cwd);
+        if (Object.keys(mcpConfig.mcpServers).length > 0) {
+            this.mcpServers = await connectToServers(mcpConfig, this.options.onMCPStatus);
+            if (this.mcpServers.length > 0) {
+                const mcpTools = getAllMCPTools(this.mcpServers);
+                this.tools = [...FILE_TOOLS, ...mcpTools];
+            }
+        }
+    }
     reset() {
         const systemMsg = this.messages[0];
         this.messages = [systemMsg];

package/dist/cli.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
  * Codemaxxing CLI entry point
- * Routes subcommands (login, auth) to auth-cli, everything else to the TUI
+ * Routes subcommands (login, auth, exec) to handlers, everything else to the TUI
  */
 export {};

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * Codemaxxing CLI entry point
- * Routes subcommands (login, auth) to auth-cli, everything else to the TUI
+ * Routes subcommands (login, auth, exec) to handlers, everything else to the TUI
  */
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -21,6 +21,11 @@ if (subcmd === "login" || subcmd === "auth") {
     });
     child.on("exit", (code) => process.exit(code ?? 0));
 }
+else if (subcmd === "exec") {
+    // Headless/CI mode — no TUI
+    const { runExec } = await import("./exec.js");
+    await runExec(process.argv.slice(3));
+}
 else {
     // TUI mode — import directly (not spawn) to preserve raw stdin
     await import("./index.js");

package/dist/config.d.ts

@@ -15,6 +15,8 @@ export interface CodemaxxingConfig {
         contextFiles: number;
         maxTokens: number;
         contextCompressionThreshold?: number;
+        architectModel?: string;
+        autoLint?: boolean;
     };
 }
 export interface CLIArgs {

package/dist/config.js

@@ -55,6 +55,7 @@ codemaxxing — your code. your model. no excuses.
 
 Usage:
   codemaxxing [options]
+  codemaxxing exec "prompt" [exec-options]
 
 Options:
   -m, --model <model>       Model name to use
@@ -63,11 +64,19 @@ Options:
   -u, --base-url <url>      Base URL for the provider API
   -h, --help                Show this help
 
+Exec options (headless/CI mode):
+  --auto-approve            Skip tool approval prompts
+  --json                    Output JSON instead of streaming text
+  -m, --model <model>       Model to use
+  -p, --provider <name>     Provider profile
+
 Examples:
   codemaxxing                                    # Auto-detect local LLM
   codemaxxing -m gpt-4o -u https://api.openai.com/v1 -k sk-...
   codemaxxing -p openrouter                      # Use saved provider profile
   codemaxxing -m qwen3.5-35b                     # Override model only
+  codemaxxing exec "fix the failing tests"       # Headless mode
+  echo "explain this code" | codemaxxing exec    # Pipe input
 
 Config: ~/.codemaxxing/settings.json
 `);

package/dist/exec.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Headless/CI execution mode — runs agent without TUI
+ * Usage: codemaxxing exec "your prompt here"
+ * Flags: --auto-approve, --json, --model <model>, --provider <name>
+ * Supports stdin pipe: echo "fix the tests" | codemaxxing exec
+ */
+export declare function runExec(argv: string[]): Promise<void>;

package/dist/exec.js

@@ -0,0 +1,164 @@
+/**
+ * Headless/CI execution mode — runs agent without TUI
+ * Usage: codemaxxing exec "your prompt here"
+ * Flags: --auto-approve, --json, --model <model>, --provider <name>
+ * Supports stdin pipe: echo "fix the tests" | codemaxxing exec
+ */
+import { CodingAgent } from "./agent.js";
+import { loadConfig, applyOverrides, detectLocalProvider } from "./config.js";
+import { disconnectAll } from "./utils/mcp.js";
+function parseExecArgs(argv) {
+    const args = {
+        prompt: "",
+        autoApprove: false,
+        json: false,
+    };
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        const next = argv[i + 1];
+        if (arg === "--auto-approve") {
+            args.autoApprove = true;
+        }
+        else if (arg === "--json") {
+            args.json = true;
+        }
+        else if ((arg === "--model" || arg === "-m") && next) {
+            args.model = next;
+            i++;
+        }
+        else if ((arg === "--provider" || arg === "-p") && next) {
+            args.provider = next;
+            i++;
+        }
+        else if (!arg.startsWith("-")) {
+            positional.push(arg);
+        }
+    }
+    args.prompt = positional.join(" ");
+    return args;
+}
+async function readStdin() {
+    // Check if stdin has data (piped input)
+    if (process.stdin.isTTY)
+        return "";
+    return new Promise((resolve) => {
+        let data = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => { data += chunk; });
+        process.stdin.on("end", () => resolve(data.trim()));
+        // Timeout after 1s if no data arrives
+        setTimeout(() => resolve(data.trim()), 1000);
+    });
+}
+export async function runExec(argv) {
+    const args = parseExecArgs(argv);
+    // Read from stdin if no prompt provided
+    if (!args.prompt) {
+        args.prompt = await readStdin();
+    }
+    if (!args.prompt) {
+        process.stderr.write("Error: No prompt provided.\n");
+        process.stderr.write("Usage: codemaxxing exec \"your prompt here\"\n");
+        process.stderr.write("       echo \"fix tests\" | codemaxxing exec\n");
+        process.stderr.write("\nFlags:\n");
+        process.stderr.write("  --auto-approve   Skip approval prompts\n");
+        process.stderr.write("  --json           JSON output\n");
+        process.stderr.write("  -m, --model      Model to use\n");
+        process.stderr.write("  -p, --provider   Provider profile\n");
+        process.exit(1);
+    }
+    // Resolve provider config
+    const rawConfig = loadConfig();
+    const cliArgs = {
+        model: args.model,
+        provider: args.provider,
+    };
+    const config = applyOverrides(rawConfig, cliArgs);
+    let provider = config.provider;
+    // Auto-detect local provider if needed
+    if (provider.model === "auto" || (provider.baseUrl === "http://localhost:1234/v1" && !args.provider)) {
+        const detected = await detectLocalProvider();
+        if (detected) {
+            if (args.model)
+                detected.model = args.model;
+            provider = detected;
+        }
+        else if (!args.provider) {
+            process.stderr.write("Error: No LLM provider found. Start a local server or use --provider.\n");
+            process.exit(1);
+        }
+    }
+    process.stderr.write(`Provider: ${provider.baseUrl}\n`);
+    process.stderr.write(`Model: ${provider.model}\n`);
+    process.stderr.write(`Prompt: ${args.prompt.slice(0, 100)}${args.prompt.length > 100 ? "..." : ""}\n`);
+    process.stderr.write("---\n");
+    const cwd = process.cwd();
+    let hasChanges = false;
+    let fullResponse = "";
+    const toolResults = [];
+    const agent = new CodingAgent({
+        provider,
+        cwd,
+        maxTokens: config.defaults.maxTokens,
+        autoApprove: args.autoApprove,
+        onToken: (token) => {
+            if (!args.json) {
+                process.stdout.write(token);
+            }
+            fullResponse += token;
+        },
+        onToolCall: (name, toolArgs) => {
+            process.stderr.write(`Tool: ${name}(${Object.values(toolArgs).map(v => String(v).slice(0, 60)).join(", ")})\n`);
+            if (name === "write_file")
+                hasChanges = true;
+        },
+        onToolResult: (name, result) => {
+            const lines = result.split("\n").length;
+            process.stderr.write(`  └ ${lines} lines\n`);
+            toolResults.push({ tool: name, args: {}, result });
+        },
+        onToolApproval: async (name, toolArgs, diff) => {
+            if (args.autoApprove)
+                return "yes";
+            // In non-interactive mode without auto-approve, deny dangerous tools
+            process.stderr.write(`⚠ Denied ${name} (use --auto-approve to allow)\n`);
+            return "no";
+        },
+        onMCPStatus: (server, status) => {
+            process.stderr.write(`MCP ${server}: ${status}\n`);
+        },
+    });
+    try {
+        await agent.init();
+        const mcpCount = agent.getMCPServerCount();
+        if (mcpCount > 0) {
+            process.stderr.write(`MCP: ${mcpCount} server${mcpCount > 1 ? "s" : ""} connected\n`);
+        }
+        await agent.send(args.prompt);
+        if (!args.json) {
+            // Ensure newline at end of output
+            process.stdout.write("\n");
+        }
+        else {
+            // JSON output mode
+            const output = {
+                response: fullResponse,
+                model: provider.model,
+                tools_used: toolResults.length,
+                has_changes: hasChanges,
+            };
+            process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+        }
+        await disconnectAll();
+        process.exit(hasChanges ? 0 : 2);
+    }
+    catch (err) {
+        await disconnectAll();
+        process.stderr.write(`Error: ${err.message}\n`);
+        if (args.json) {
+            process.stdout.write(JSON.stringify({ error: err.message }, null, 2) + "\n");
+        }
+        process.exit(1);
+    }
+}