@hasna/terminal 4.3.1 → 4.3.3

package/dist/mcp/tools/execute.js

@@ -0,0 +1,194 @@
+// Execute tools: execute, execute_smart, execute_diff, expand, browse, explain_error
+import { z } from "./helpers.js";
+import { compress, stripAnsi } from "../../compression.js";
+import { estimateTokens } from "../../tokens.js";
+import { processOutput } from "../../output-processor.js";
+import { storeOutput, expandOutput } from "../../expand-store.js";
+import { shouldBeLazy, toLazy } from "../../lazy-executor.js";
+import { diffOutput } from "../../diff-cache.js";
+import { recordSaving } from "../../economy.js";
+export function registerExecuteTools(server, h) {
+    // ── execute: run a command, return structured result ──────────────────────
+    server.tool("execute", "Run a shell command. Format guide: no format/raw for git commit/push (<50 tokens). format=compressed for long build output (CPU-only, no AI). format=json or format=summary for AI-summarized output (234ms, saves 80% tokens). Prefer execute_smart for most tasks.", {
+        command: z.string().describe("Shell command to execute"),
+        cwd: z.string().optional().describe("Working directory (default: server cwd)"),
+        timeout: z.number().optional().describe("Timeout in ms (default: 30000)"),
+        format: z.enum(["raw", "json", "compressed", "summary"]).optional().describe("Output format"),
+        maxTokens: z.number().optional().describe("Token budget for compressed/summary format"),
+    }, async ({ command, cwd, timeout, format, maxTokens }) => {
+        const start = Date.now();
+        const result = await h.exec(command, cwd, timeout ?? 30000);
+        const output = (result.stdout + result.stderr).trim();
+        // Raw mode — with lazy execution for large results
+        if (!format || format === "raw") {
+            const clean = stripAnsi(output);
+            if (shouldBeLazy(clean, command)) {
+                const lazy = toLazy(clean, command);
+                const detailKey = storeOutput(command, clean);
+                h.logCall("execute", { command, outputTokens: estimateTokens(clean), tokensSaved: 0, durationMs: Date.now() - start, exitCode: result.exitCode });
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                exitCode: result.exitCode, ...lazy, detailKey, duration: result.duration,
+                                ...(result.rewritten ? { rewrittenFrom: command } : {}),
+                            }) }],
+                };
+            }
+            h.logCall("execute", { command, outputTokens: estimateTokens(clean), tokensSaved: 0, durationMs: Date.now() - start, exitCode: result.exitCode });
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            exitCode: result.exitCode, output: clean, duration: result.duration, tokens: estimateTokens(clean),
+                            ...(result.rewritten ? { rewrittenFrom: command } : {}),
+                        }) }],
+            };
+        }
+        // JSON and Summary modes — both go through AI processing
+        if (format === "json" || format === "summary") {
+            try {
+                const processed = await processOutput(command, output);
+                const detailKey = output.split("\n").length > 15 ? storeOutput(command, output) : undefined;
+                h.logCall("execute", { command, outputTokens: estimateTokens(output), tokensSaved: processed.tokensSaved, durationMs: Date.now() - start, exitCode: result.exitCode, aiProcessed: processed.aiProcessed });
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                exitCode: result.exitCode,
+                                summary: processed.summary,
+                                structured: processed.structured,
+                                duration: result.duration,
+                                tokensSaved: processed.tokensSaved,
+                                aiProcessed: processed.aiProcessed,
+                                ...(detailKey ? { detailKey, expandable: true } : {}),
+                            }) }],
+                };
+            }
+            catch {
+                const compressed = compress(command, output, { maxTokens });
+                h.logCall("execute", { command, outputTokens: estimateTokens(output), tokensSaved: compressed.tokensSaved, durationMs: Date.now() - start, exitCode: result.exitCode });
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                exitCode: result.exitCode, output: compressed.content, duration: result.duration,
+                                tokensSaved: compressed.tokensSaved,
+                            }) }],
+                };
+            }
+        }
+        // Compressed mode — fast non-AI: strip + dedup + truncate
+        if (format === "compressed") {
+            const compressed = compress(command, output, { maxTokens });
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            exitCode: result.exitCode, output: compressed.content, duration: result.duration,
+                            ...(compressed.tokensSaved > 0 ? { tokensSaved: compressed.tokensSaved, savingsPercent: compressed.savingsPercent } : {}),
+                        }) }],
+            };
+        }
+        return { content: [{ type: "text", text: output }] };
+    });
+    // ── execute_smart: AI-powered output processing ────────────────────────────
+    server.tool("execute_smart", "Run a command and get AI-summarized output (80-95% token savings). Use this for: test runs, builds, git operations, process management, system info. Do NOT use for file read/write — use your native Read/Write/Edit tools instead (they're faster, no shell overhead).", {
+        command: z.string().describe("Shell command to execute"),
+        cwd: z.string().optional().describe("Working directory"),
+        timeout: z.number().optional().describe("Timeout in ms (default: 30000)"),
+        verbosity: z.enum(["minimal", "normal", "detailed"]).optional().describe("Summary detail level (default: normal)"),
+    }, async ({ command, cwd, timeout, verbosity }) => {
+        const start = Date.now();
+        const result = await h.exec(command, cwd, timeout ?? 30000, true);
+        const output = (result.stdout + result.stderr).trim();
+        const processed = await processOutput(command, output, undefined, verbosity);
+        const detailKey = output.split("\n").length > 15 ? storeOutput(command, output) : undefined;
+        h.logCall("execute_smart", { command, outputTokens: estimateTokens(output), tokensSaved: processed.tokensSaved, durationMs: Date.now() - start, exitCode: result.exitCode, aiProcessed: processed.aiProcessed });
+        return {
+            content: [{ type: "text", text: JSON.stringify({
+                        exitCode: result.exitCode,
+                        summary: processed.summary,
+                        structured: processed.structured,
+                        duration: result.duration,
+                        totalLines: output.split("\n").length,
+                        tokensSaved: processed.tokensSaved,
+                        aiProcessed: processed.aiProcessed,
+                        ...(detailKey ? { detailKey, expandable: true } : {}),
+                    }) }],
+        };
+    });
+    // ── execute_diff: run command with diff from last run ───────────────────────
+    server.tool("execute_diff", "Run a command and return diff from its last execution. Ideal for edit→test loops — only shows what changed.", {
+        command: z.string().describe("Shell command to execute"),
+        cwd: z.string().optional().describe("Working directory"),
+        timeout: z.number().optional().describe("Timeout in ms"),
+    }, async ({ command, cwd, timeout }) => {
+        const start = Date.now();
+        const workDir = cwd ?? process.cwd();
+        const result = await h.exec(command, workDir, timeout ?? 30000);
+        const output = (result.stdout + result.stderr).trim();
+        const diff = diffOutput(command, workDir, output);
+        if (diff.tokensSaved > 0) {
+            recordSaving("diff", diff.tokensSaved);
+        }
+        h.logCall("execute_diff", { command, outputTokens: estimateTokens(output), tokensSaved: diff.tokensSaved, durationMs: Date.now() - start, exitCode: result.exitCode });
+        if (diff.unchanged) {
+            return { content: [{ type: "text", text: JSON.stringify({
+                            exitCode: result.exitCode, unchanged: true, diffSummary: diff.diffSummary,
+                            duration: result.duration, tokensSaved: diff.tokensSaved,
+                        }) }] };
+        }
+        if (diff.hasPrevious) {
+            return { content: [{ type: "text", text: JSON.stringify({
+                            exitCode: result.exitCode, diffSummary: diff.diffSummary,
+                            added: diff.added.slice(0, 50), removed: diff.removed.slice(0, 50),
+                            duration: result.duration, tokensSaved: diff.tokensSaved,
+                        }) }] };
+        }
+        // First run — return full output (ANSI stripped)
+        const clean = stripAnsi(output);
+        return { content: [{ type: "text", text: JSON.stringify({
+                        exitCode: result.exitCode, output: clean,
+                        diffSummary: "first run", duration: result.duration,
+                    }) }] };
+    });
+    // ── expand: retrieve full output on demand ────────────────────────────────
+    server.tool("expand", "Retrieve full output from a previous execute_smart call. Only call this when you need details (e.g., to see failing test errors). Use the detailKey from execute_smart response.", {
+        key: z.string().describe("The detailKey from a previous execute_smart response"),
+        grep: z.string().optional().describe("Filter output lines by pattern (e.g., 'FAIL', 'error')"),
+    }, async ({ key, grep }) => {
+        const result = expandOutput(key, grep);
+        if (!result.found) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: "Output expired or not found" }) }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify({ output: result.output, lines: result.lines }) }] };
+    });
+    // ── browse: list files/dirs as structured JSON ────────────────────────────
+    server.tool("browse", "List files and directories as structured JSON. Auto-filters node_modules, .git, dist by default.", {
+        path: z.string().optional().describe("Directory path (default: cwd)"),
+        recursive: z.boolean().optional().describe("List recursively (default: false)"),
+        maxDepth: z.number().optional().describe("Max depth for recursive listing (default: 2)"),
+        includeHidden: z.boolean().optional().describe("Include hidden files (default: false)"),
+    }, async ({ path, recursive, maxDepth, includeHidden }) => {
+        const target = path ?? process.cwd();
+        const depth = maxDepth ?? 2;
+        let command;
+        if (recursive) {
+            command = `find "${target}" -maxdepth ${depth} -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' -not -path '*/.next/*'`;
+            if (!includeHidden)
+                command += " -not -name '.*'";
+        }
+        else {
+            command = includeHidden ? `ls -la "${target}"` : `ls -l "${target}"`;
+        }
+        const result = await h.exec(command);
+        const files = result.stdout.split("\n").filter(l => l.trim());
+        return { content: [{ type: "text", text: JSON.stringify({ cwd: target, files, count: files.length }) }] };
+    });
+    // ── explain_error: structured error diagnosis ─────────────────────────────
+    server.tool("explain_error", "Parse error output and return structured diagnosis with root cause and fix suggestion.", {
+        error: z.string().describe("Error output text"),
+        command: z.string().optional().describe("The command that produced the error"),
+    }, async ({ error, command }) => {
+        // AI processes the error — no regex guessing
+        const processed = await processOutput(command ?? "unknown", error);
+        return {
+            content: [{ type: "text", text: JSON.stringify({
+                        summary: processed.summary,
+                        structured: processed.structured,
+                        aiProcessed: processed.aiProcessed,
+                    }) }],
+        };
+    });
+}

package/dist/mcp/tools/files.js

@@ -0,0 +1,290 @@
+// File tools: read_file, read_files, symbols, symbols_dir, read_symbol, edit, review
+import { z } from "./helpers.js";
+import { estimateTokens } from "../../tokens.js";
+import { getOutputProvider } from "../../providers/index.js";
+import { cachedRead } from "../../file-cache.js";
+export function registerFileTools(server, h) {
+    // ── read_file ─────────────────────────────────────────────────────────────
+    server.tool("read_file", "Read a file with summarize=true for AI outline (~90% fewer tokens). For full file reads without summarization, prefer your native Read tool (faster, no MCP overhead). Use this when you want cached reads or AI summaries.", {
+        path: z.string().describe("File path"),
+        offset: z.number().optional().describe("Start line (0-indexed)"),
+        limit: z.number().optional().describe("Max lines to return"),
+        summarize: z.boolean().optional().describe("Return AI summary instead of full content (saves ~90% tokens)"),
+        focus: z.string().optional().describe("Focus hint for summary (e.g., 'public API', 'error handling', 'auth logic')"),
+    }, async ({ path: rawPath, offset, limit, summarize, focus }) => {
+        const start = Date.now();
+        const path = h.resolvePath(rawPath);
+        const result = cachedRead(path, { offset, limit });
+        if (summarize && result.content.length > 500) {
+            const provider = getOutputProvider();
+            const outputModel = provider.name === "groq" ? "llama-3.1-8b-instant" : undefined;
+            const content = result.content.length > 8000 ? result.content.slice(0, 8000) : result.content;
+            const focusInstruction = focus
+                ? `Focus specifically on: ${focus}. Describe only aspects related to "${focus}".`
+                : `Describe what this source file does in 2-4 lines. Include: main class/module name, key methods/functions, what it exports, and its purpose.`;
+            const summary = await provider.complete(`File: ${path}\n\n${content}`, {
+                model: outputModel,
+                system: `${focusInstruction} Be specific — name the actual functions and what they do. Never just say "N lines of code."`,
+                maxTokens: 300,
+                temperature: 0.2,
+            });
+            const outputTokens = estimateTokens(result.content);
+            const summaryTokens = estimateTokens(summary);
+            const saved = Math.max(0, outputTokens - summaryTokens);
+            h.logCall("read_file", { command: path, outputTokens, tokensSaved: saved, durationMs: Date.now() - start, aiProcessed: true });
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            summary,
+                            lines: result.content.split("\n").length,
+                            tokensSaved: saved,
+                            cached: result.cached,
+                        }) }],
+            };
+        }
+        h.logCall("read_file", { command: path, outputTokens: estimateTokens(result.content), tokensSaved: 0, durationMs: Date.now() - start });
+        return {
+            content: [{ type: "text", text: JSON.stringify({
+                        content: result.content,
+                        cached: result.cached,
+                        readCount: result.readCount,
+                        ...(result.cached ? { note: `Served from cache (read #${result.readCount})` } : {}),
+                    }) }],
+        };
+    });
+    // ── read_files ────────────────────────────────────────────────────────────
+    server.tool("read_files", "Read multiple files in one call. Use summarize=true for AI outlines (~90% fewer tokens per file). Saves N-1 round trips vs separate read_file calls.", {
+        files: z.array(z.string()).describe("File paths (relative or absolute)"),
+        summarize: z.boolean().optional().describe("AI summary instead of full content"),
+    }, async ({ files, summarize }) => {
+        const start = Date.now();
+        const results = {};
+        for (const f of files.slice(0, 10)) { // max 10 files per call
+            const filePath = h.resolvePath(f);
+            const result = cachedRead(filePath, {});
+            if (summarize && result.content.length > 500) {
+                const provider = getOutputProvider();
+                const outputModel = provider.name === "groq" ? "llama-3.1-8b-instant" : undefined;
+                const content = result.content.length > 8000 ? result.content.slice(0, 8000) : result.content;
+                const summary = await provider.complete(`File: ${filePath}\n\n${content}`, {
+                    model: outputModel,
+                    system: `Describe what this source file does in 2-4 lines. Include: main class/module name, key methods/functions, what it exports, and its purpose. Be specific.`,
+                    maxTokens: 300, temperature: 0.2,
+                });
+                results[f] = { summary, lines: result.content.split("\n").length };
+            }
+            else {
+                results[f] = { content: result.content, lines: result.content.split("\n").length };
+            }
+        }
+        h.logCall("read_files", { command: `${files.length} files`, durationMs: Date.now() - start, aiProcessed: !!summarize });
+        return { content: [{ type: "text", text: JSON.stringify(results) }] };
+    });
+    // ── symbols ───────────────────────────────────────────────────────────────
+    server.tool("symbols", "Get a structured outline of any source file — functions, classes, methods, interfaces, exports with line numbers. Works for ALL languages (TypeScript, Python, Go, Rust, Java, C#, Ruby, PHP, etc.). AI-powered, not regex.", {
+        path: z.string().describe("File path to extract symbols from"),
+    }, async ({ path: rawPath }) => {
+        const start = Date.now();
+        const filePath = h.resolvePath(rawPath);
+        const result = cachedRead(filePath, {});
+        if (!result.content || result.content.startsWith("Error:")) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `Cannot read ${filePath}` }) }] };
+        }
+        // AI extracts symbols — works for ANY language
+        let symbols = [];
+        try {
+            const provider = getOutputProvider();
+            const outputModel = provider.name === "groq" ? "llama-3.1-8b-instant" : undefined;
+            const content = result.content.length > 8000 ? result.content.slice(0, 8000) : result.content;
+            const summary = await provider.complete(`File: ${filePath}\n\n${content}`, {
+                model: outputModel,
+                system: `Extract all symbols from this source file. Return ONLY a JSON array, no explanation.
+
+Each symbol: {"name": "symbolName", "kind": "function|class|method|interface|type|variable|export", "line": lineNumber, "signature": "brief signature"}
+
+For class methods, use "ClassName.methodName" as name with kind "method".
+Include: functions, classes, methods, interfaces, types, exported constants.
+Exclude: imports, local variables, comments.
+Line numbers must be accurate (count from 1).`,
+                maxTokens: 2000,
+                temperature: 0,
+            });
+            const jsonMatch = summary.match(/\[[\s\S]*\]/);
+            if (jsonMatch)
+                symbols = JSON.parse(jsonMatch[0]);
+        }
+        catch (err) {
+            // Surface the error instead of silently returning []
+            return { content: [{ type: "text", text: JSON.stringify({ error: `AI symbol extraction failed: ${err.message?.slice(0, 200)}`, file: filePath }) }] };
+        }
+        const outputTokens = estimateTokens(result.content);
+        const symbolTokens = estimateTokens(JSON.stringify(symbols));
+        h.logCall("symbols", { command: filePath, outputTokens, tokensSaved: Math.max(0, outputTokens - symbolTokens), durationMs: Date.now() - start, aiProcessed: true });
+        return {
+            content: [{ type: "text", text: JSON.stringify(symbols) }],
+        };
+    });
+    // ── symbols_dir ───────────────────────────────────────────────────────────
+    server.tool("symbols_dir", "Get symbols for all source files in a directory. AI-powered, works for any language. One call replaces N separate symbols calls.", {
+        path: z.string().optional().describe("Directory (default: src/)"),
+        maxFiles: z.number().optional().describe("Max files to scan (default: 10)"),
+    }, async ({ path: dirPath, maxFiles }) => {
+        const start = Date.now();
+        const dir = h.resolvePath(dirPath ?? "src/");
+        const limit = maxFiles ?? 10;
+        // Find source files
+        const findResult = await h.exec(`find "${dir}" -maxdepth 3 -type f \\( -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.java" -o -name "*.rb" -o -name "*.php" \\) -not -path "*/node_modules/*" -not -path "*/dist/*" -not -name "*.test.*" -not -name "*.spec.*" | head -${limit}`, process.cwd(), 5000);
+        const files = findResult.stdout.split("\n").filter(l => l.trim());
+        const allSymbols = {};
+        const provider = getOutputProvider();
+        const outputModel = provider.name === "groq" ? "llama-3.1-8b-instant" : undefined;
+        for (const file of files) {
+            const result = cachedRead(file, {});
+            if (!result.content || result.content.startsWith("Error:"))
+                continue;
+            try {
+                const content = result.content.length > 6000 ? result.content.slice(0, 6000) : result.content;
+                const summary = await provider.complete(`File: ${file}\n\n${content}`, {
+                    model: outputModel,
+                    system: `Extract all symbols. Return ONLY a JSON array. Each: {"name":"x","kind":"function|class|method|interface|type","line":N,"signature":"brief"}. For class methods use "Class.method". Exclude imports.`,
+                    maxTokens: 1500, temperature: 0,
+                });
+                const jsonMatch = summary.match(/\[[\s\S]*\]/);
+                if (jsonMatch)
+                    allSymbols[file] = JSON.parse(jsonMatch[0]);
+            }
+            catch { }
+        }
+        h.logCall("symbols_dir", { command: `${files.length} files in ${dir}`, durationMs: Date.now() - start, aiProcessed: true });
+        return { content: [{ type: "text", text: JSON.stringify({ directory: dir, files: files.length, symbols: allSymbols }) }] };
+    });
+    // ── read_symbol ───────────────────────────────────────────────────────────
+    server.tool("read_symbol", "Read a specific function, class, or interface by name from a source file. Returns only the code block — not the entire file. Saves 70-85% tokens vs reading the whole file.", {
+        path: z.string().describe("Source file path"),
+        name: z.string().describe("Symbol name (function, class, interface)"),
+    }, async ({ path: rawPath, name }) => {
+        const start = Date.now();
+        const filePath = h.resolvePath(rawPath);
+        const result = cachedRead(filePath, {});
+        if (!result.content || result.content.startsWith("Error:")) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `Cannot read ${filePath}` }) }] };
+        }
+        // AI extracts the specific symbol — works for ANY language
+        const provider = getOutputProvider();
+        const outputModel = provider.name === "groq" ? "llama-3.1-8b-instant" : undefined;
+        const summary = await provider.complete(`File: ${filePath}\nSymbol to extract: ${name}\n\n${result.content.slice(0, 8000)}`, {
+            model: outputModel,
+            system: `Extract the complete code block for the symbol "${name}" from this file. Return ONLY a JSON object:
+{"name": "${name}", "code": "the complete code block", "startLine": N, "endLine": N}
+
+If the symbol is not found, return: {"error": "not found", "available": ["list", "of", "symbol", "names"]}
+
+Match by function name, class name, method name (including ClassName.method), interface, type, or variable name.`,
+            maxTokens: 2000,
+            temperature: 0,
+        });
+        let parsed = {};
+        try {
+            const jsonMatch = summary.match(/\{[\s\S]*\}/);
+            if (jsonMatch)
+                parsed = JSON.parse(jsonMatch[0]);
+        }
+        catch { }
+        h.logCall("read_symbol", { command: `${filePath}:${name}`, outputTokens: estimateTokens(result.content), tokensSaved: Math.max(0, estimateTokens(result.content) - estimateTokens(JSON.stringify(parsed))), durationMs: Date.now() - start, aiProcessed: true });
+        return { content: [{ type: "text", text: JSON.stringify(parsed) }] };
+    });
+    // ── edit ───────────────────────────────────────────────────────────────────
+    server.tool("edit", "Find and replace in a file. For simple edits, prefer your native Edit tool (faster). Use this for batch replacements (all=true) or when you don't have a native Edit tool available.", {
+        file: z.string().describe("File path"),
+        find: z.string().describe("Text to find (exact match)"),
+        replace: z.string().describe("Replacement text"),
+        all: z.boolean().optional().describe("Replace all occurrences (default: first only)"),
+    }, async ({ file: rawFile, find, replace, all }) => {
+        const start = Date.now();
+        const file = h.resolvePath(rawFile);
+        const { readFileSync, writeFileSync } = await import("fs");
+        try {
+            let content = readFileSync(file, "utf8");
+            const count = (content.match(new RegExp(find.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")) || []).length;
+            if (count === 0) {
+                return { content: [{ type: "text", text: JSON.stringify({ error: "Text not found", file }) }] };
+            }
+            if (all) {
+                content = content.split(find).join(replace);
+            }
+            else {
+                content = content.replace(find, replace);
+            }
+            writeFileSync(file, content);
+            h.logCall("edit", { command: `edit ${file}`, durationMs: Date.now() - start });
+            return { content: [{ type: "text", text: JSON.stringify({ ok: true, file, replacements: all ? count : 1, diff: { removed: find.slice(0, 100), added: replace.slice(0, 100) } }) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: e.message }) }] };
+        }
+    });
+    // ── review ────────────────────────────────────────────────────────────────
+    server.tool("review", "AI code review of recent changes or specific files. Returns: bugs, security issues, suggestions. One call replaces git diff + manual reading.", {
+        since: z.string().optional().describe("Git ref to diff against (e.g., 'HEAD~3', 'main')"),
+        files: z.array(z.string()).optional().describe("Specific files to review"),
+        cwd: z.string().optional().describe("Working directory"),
+    }, async ({ since, files, cwd }) => {
+        const start = Date.now();
+        const workDir = cwd ?? process.cwd();
+        let content;
+        if (files && files.length > 0) {
+            const fileContents = files.map(f => {
+                const result = cachedRead(h.resolvePath(f, workDir), {});
+                return `=== ${f} ===\n${result.content.slice(0, 4000)}`;
+            });
+            content = fileContents.join("\n\n");
+        }
+        else {
+            const ref = since ?? "HEAD~1";
+            const diff = await h.exec(`git diff ${ref} --no-color`, workDir, 15000);
+            content = diff.stdout.slice(0, 12000);
+        }
+        const provider = getOutputProvider();
+        const outputModel = provider.name === "groq" ? "llama-3.1-8b-instant" : undefined;
+        const review = await provider.complete(`Review this code:\n\n${content}`, {
+            model: outputModel,
+            system: `You are a senior code reviewer. Review concisely:
+- Bugs or logic errors
+- Security issues (injection, auth, secrets)
+- Missing error handling
+- Performance concerns
+- Style/naming issues (only if significant)
+
+Format: list issues as "- [severity] file:line description". If clean, say "No issues found."
+Be specific, not generic. Only flag real problems.`,
+            maxTokens: 800, temperature: 0.2,
+        });
+        h.logCall("review", { command: `review ${since ?? files?.join(",") ?? "HEAD~1"}`, durationMs: Date.now() - start, aiProcessed: true });
+        return { content: [{ type: "text", text: JSON.stringify({ review, scope: since ?? files }) }] };
+    });
+    // ── write_files ─────────────────────────────────────────────────────────
+    server.tool("write_files", "Write multiple files in one call. Auto-creates parent directories. Saves N-1 round trips vs separate writes.", {
+        files: z.array(z.object({
+            path: z.string().describe("File path (relative or absolute)"),
+            content: z.string().describe("File content"),
+        })).describe("Files to write"),
+    }, async ({ files }) => {
+        const { writeFileSync, mkdirSync, existsSync } = await import("fs");
+        const { dirname } = await import("path");
+        const results = [];
+        for (const f of files.slice(0, 20)) {
+            try {
+                const filePath = h.resolvePath(f.path);
+                const dir = dirname(filePath);
+                if (!existsSync(dir))
+                    mkdirSync(dir, { recursive: true });
+                writeFileSync(filePath, f.content);
+                results.push({ path: f.path, ok: true, bytes: f.content.length });
+            }
+            catch (e) {
+                results.push({ path: f.path, ok: false, error: e.message?.slice(0, 100) });
+            }
+        }
+        h.logCall("write_files", { command: `${files.length} files` });
+        return { content: [{ type: "text", text: JSON.stringify({ written: results.filter(r => r.ok).length, total: results.length, results }) }] };
+    });
+}