context-compress 2026.3.21 → 2026.5.0

package/dist/server.js

@@ -1,62 +1,28 @@
-import { readFileSync, realpathSync, statSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
 import { SubprocessExecutor } from "./executor.js";
 import { debug } from "./logger.js";
-import { isPrivateHost, resolveAndValidate } from "./network.js";
 import { detectRuntimes, hasBun } from "./runtime/index.js";
 import { SessionTracker } from "./stats.js";
 import { ContentStore, cleanupStaleDbs } from "./store.js";
-import { ALL_LANGUAGES } from "./types.js";
-import { detectInjectionPatterns, limitConcurrency } from "./utils.js";
-const LANGUAGE_ENUM = ALL_LANGUAGES;
+import { registerBatchExecuteTool } from "./tools/batch-execute.js";
+import { registerDiscoverTool } from "./tools/discover.js";
+import { registerExecuteFileTool } from "./tools/execute-file.js";
+import { registerExecuteTool } from "./tools/execute.js";
+import { registerFetchAndIndexTool } from "./tools/fetch-and-index.js";
+import { registerIndexTool } from "./tools/index-content.js";
+import { registerSearchTool } from "./tools/search.js";
+import { registerStatsTool } from "./tools/stats.js";
+import { createIntentFilter } from "./util/intent-filter.js";
+import { getVersion } from "./util/version.js";
 const projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
-function isWithinProject(absPath) {
-    try {
-        const normalized = realpathSync(resolve(absPath));
-        const realProjectDir = realpathSync(projectDir);
-        return normalized === realProjectDir || normalized.startsWith(`${realProjectDir}/`);
-    }
-    catch {
-        // Path doesn't exist yet — fall back to string check
-        const normalized = resolve(absPath);
-        return normalized === projectDir || normalized.startsWith(`${projectDir}/`);
-    }
-}
-function getVersion() {
-    try {
-        const __dirname = dirname(fileURLToPath(import.meta.url));
-        const pkgPath = join(__dirname, "..", "package.json");
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        return pkg.version ?? "1.0.0";
-    }
-    catch {
-        return "1.0.0";
-    }
-}
-/** Shorten labels based on compression level */
-function compactLabel(normal, level) {
-    if (level === "ultra") {
-        // Ultra: strip markdown, minimize verbiage
-        return normal
-            .replace(/\*\*/g, "")
-            .replace(/Use search\(queries: \[\.\.\.]\) to retrieve.*$/gm, "→ search() for more")
-            .replace(/Searchable terms: .+$/gm, "");
-    }
-    if (level === "compact") {
-        return normal.replace(/Use search\(queries: \[\.\.\.]\) to retrieve full content of any section\./, "→ search() for details");
-    }
-    return normal;
-}
+const MAX_CONCURRENT_EXECUTIONS = 8;
+const EXECUTION_LIMIT_ERROR = "Error: too many concurrent executions. Try again shortly.";
 export async function createServer(config) {
     const version = getVersion();
     debug("Version:", version);
-    // Cleanup stale databases from previous sessions
     cleanupStaleDbs();
-    // Detect runtimes in parallel
     const runtimes = await detectRuntimes();
     const bunDetected = hasBun(runtimes);
     debug("Runtimes detected:", runtimes.size);
@@ -71,10 +37,11 @@ export async function createServer(config) {
         store = new ContentStore(":memory:");
         dbFallback = true;
     }
-    const tracker = new SessionTracker();
+    const cumulativeFile = config.persistDb
+        ? join(config.dbDir ?? join(projectDir, ".context-compress"), "stats.json")
+        : undefined;
+    const tracker = new SessionTracker(cumulativeFile);
     let activeExecutions = 0;
-    const MAX_CONCURRENT_EXECUTIONS = 8;
-    const EXECUTION_LIMIT_ERROR = "Error: too many concurrent executions. Try again shortly.";
     async function withExecutionLimit(fn) {
         if (activeExecutions >= MAX_CONCURRENT_EXECUTIONS) {
             throw new Error(EXECUTION_LIMIT_ERROR);
@@ -87,37 +54,25 @@ export async function createServer(config) {
             activeExecutions--;
         }
     }
-    function applyIntentFilter(output, intent, sourceLabel) {
-        if (Buffer.byteLength(output) <= config.intentSearchThreshold)
-            return output;
-        const indexed = store.index(output, sourceLabel);
-        tracker.trackIndexed(Buffer.byteLength(output));
-        const searchResults = store.search(intent, { limit: 3 });
-        const terms = store.getDistinctiveTerms(indexed.sourceId);
-        let filtered = `Indexed ${indexed.totalChunks} sections from ${sourceLabel}.\n`;
-        filtered += `${searchResults.results.length} sections matched "${intent}":\n\n`;
-        for (const hit of searchResults.results) {
-            filtered += `  - **${hit.title}**: ${hit.snippet.slice(0, 200)}\n`;
+    const applyIntentFilter = createIntentFilter({ config, store, tracker });
+    const shutdown = () => {
+        try {
+            tracker.saveCumulative();
         }
-        if (terms.length > 0 && config.compressionLevel !== "ultra") {
-            filtered += `\nSearchable terms: ${terms.join(", ")}\n`;
+        catch {
+            /* ignore */
         }
-        filtered += "\nUse search(queries: [...]) to retrieve full content of any section.";
-        return compactLabel(filtered, config.compressionLevel);
-    }
-    // Graceful shutdown: kill subprocesses and close the database on exit
-    const shutdown = () => {
         try {
             executor.shutdown();
         }
         catch {
-            // Ignore errors during shutdown
+            /* ignore */
         }
         try {
             store.close();
         }
         catch {
-            // Ignore errors during shutdown
+            /* ignore */
         }
     };
     process.on("SIGINT", shutdown);
@@ -133,474 +88,29 @@ export async function createServer(config) {
         shutdown();
         process.exit(1);
     });
-    // Search throttling state
-    const searchCalls = [];
     const server = new McpServer({
         name: "context-compress",
         version,
     });
-    // ─── Tool: execute ──────────────────────────────────────
-    server.tool("execute", `Execute code in a sandboxed subprocess. Only stdout enters context — raw data stays in the subprocess. Use instead of bash/cat when output would exceed ~5KB. ${bunDetected ? "(Bun detected — JS/TS runs 3-5x faster) " : ""}Available: ${ALL_LANGUAGES.join(", ")}.
-
-PREFER THIS OVER BASH for: API calls (gh, curl, aws), test runners (npm test, pytest), git queries (git log, git diff), data processing, and ANY CLI command that may produce large output. Bash should only be used for file mutations, git writes, and navigation.`, {
-        language: z.enum(LANGUAGE_ENUM).describe("Runtime language"),
-        code: z
-            .string()
-            .describe("Source code to execute. Use console.log (JS/TS), print (Python/Ruby/Perl/R), echo (Shell), echo (PHP), fmt.Println (Go), or IO.puts (Elixir) to output a summary to context."),
-        intent: z
-            .string()
-            .optional()
-            .describe("What you're looking for in the output. When provided and output is large (>5KB), indexes output into knowledge base and returns section titles + previews — not full content. Use search(queries: [...]) to retrieve specific sections."),
-        timeout: z.number().default(30000).describe("Max execution time in ms"),
-    }, async ({ language, code, intent, timeout }) => {
-        const codeBytes = Buffer.byteLength(code);
-        if (codeBytes > 1_024_000) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: code too large (${(codeBytes / 1024).toFixed(0)}KB). Max 1MB.`,
-                    },
-                ],
-            };
-        }
-        let result;
-        try {
-            result = await withExecutionLimit(() => executor.execute({ language, code, timeout }));
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            return { content: [{ type: "text", text: msg }] };
-        }
-        if (result.networkBytes) {
-            tracker.trackSandboxed(result.networkBytes);
-        }
-        let output = result.stdout;
-        if (result.stderr && result.exitCode !== 0) {
-            output += `\n\nSTDERR:\n${result.stderr}`;
-        }
-        // Intent-driven filtering for large outputs
-        if (intent) {
-            output = applyIntentFilter(output, intent, `execute:${language}`);
-        }
-        const responseBytes = Buffer.byteLength(output);
-        tracker.trackCall("execute", responseBytes);
-        return { content: [{ type: "text", text: output }] };
-    });
-    // ─── Tool: execute_file ─────────────────────────────────
-    server.tool("execute_file", "Read a file and process it without loading contents into context. The file is read into a FILE_CONTENT variable inside the sandbox. Only your printed summary enters context.\n\nPREFER THIS OVER Read/cat for: log files, data files (CSV, JSON, XML), large source files for analysis, and any file where you need to extract specific information rather than read the entire content.", {
-        path: z.string().describe("Absolute file path or relative to project root"),
-        language: z.enum(LANGUAGE_ENUM).describe("Runtime language"),
-        code: z
-            .string()
-            .describe("Code to process FILE_CONTENT. Print summary via console.log/print/echo/IO.puts."),
-        intent: z.string().optional().describe("What you're looking for in the output."),
-        timeout: z.number().default(30000).describe("Max execution time in ms"),
-    }, async ({ path: filePath, language, code, intent, timeout }) => {
-        const codeBytes = Buffer.byteLength(code);
-        if (codeBytes > 1_024_000) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: code too large (${(codeBytes / 1024).toFixed(0)}KB). Max 1MB.`,
-                    },
-                ],
-            };
-        }
-        const absPath = resolve(projectDir, filePath);
-        if (!isWithinProject(absPath)) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: path "${filePath}" is outside the project directory`,
-                    },
-                ],
-            };
-        }
-        let result;
-        try {
-            result = await withExecutionLimit(() => executor.executeFile({
-                language,
-                code,
-                filePath: absPath,
-                timeout,
-            }));
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            return { content: [{ type: "text", text: msg }] };
-        }
-        let output = result.stdout;
-        if (result.stderr && result.exitCode !== 0) {
-            output += `\n\nSTDERR:\n${result.stderr}`;
-        }
-        // Intent-driven filtering
-        if (intent) {
-            output = applyIntentFilter(output, intent, `file:${filePath}`);
-        }
-        const responseBytes = Buffer.byteLength(output);
-        tracker.trackCall("execute_file", responseBytes);
-        return { content: [{ type: "text", text: output }] };
-    });
-    // ─── Tool: index ────────────────────────────────────────
-    server.tool("index", "Index documentation or knowledge content into a searchable BM25 knowledge base. Chunks markdown by headings (keeping code blocks intact) and stores in ephemeral FTS5 database. The full content does NOT stay in context — only a brief summary is returned.\n\nWHEN TO USE:\n- Documentation (API docs, framework guides, code examples)\n- README files, migration guides, changelog entries\n- Any content with code examples you may need to reference precisely\n\nAfter indexing, use 'search' to retrieve specific sections on-demand.", {
-        content: z
-            .string()
-            .optional()
-            .describe("Raw text/markdown to index. Provide this OR path, not both."),
-        path: z
-            .string()
-            .optional()
-            .describe("File path to read and index (content never enters context)."),
-        source: z.string().optional().describe("Label for the indexed content"),
-    }, async ({ content, path: filePath, source }) => {
-        let text;
-        let label = source ?? "indexed content";
-        if (filePath) {
-            const absPath = resolve(projectDir, filePath);
-            if (!isWithinProject(absPath)) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Error: path "${filePath}" is outside the project directory`,
-                        },
-                    ],
-                };
-            }
-            try {
-                const fileStat = statSync(absPath);
-                if (fileStat.size > 50 * 1024 * 1024) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Error: file "${filePath}" is too large (${(fileStat.size / 1024 / 1024).toFixed(1)}MB). Max 50MB.`,
-                            },
-                        ],
-                    };
-                }
-                text = readFileSync(absPath, "utf-8");
-                label = source ?? filePath;
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
-                return {
-                    content: [{ type: "text", text: `Error reading "${filePath}": ${msg}` }],
-                };
-            }
-        }
-        else if (content) {
-            const contentBytes = Buffer.byteLength(content);
-            if (contentBytes > 50 * 1024 * 1024) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Error: content too large (${(contentBytes / 1024 / 1024).toFixed(1)}MB). Max 50MB.`,
-                        },
-                    ],
-                };
-            }
-            text = content;
-        }
-        else {
-            return {
-                content: [{ type: "text", text: "Error: provide either 'content' or 'path'" }],
-            };
-        }
-        const result = store.index(text, label);
-        tracker.trackIndexed(Buffer.byteLength(text));
-        const summary = `Indexed "${label}": ${result.totalChunks} chunks (${result.codeChunks} with code). Use search(queries: [...]) to retrieve sections.`;
-        tracker.trackCall("index", Buffer.byteLength(summary));
-        return { content: [{ type: "text", text: summary }] };
-    });
-    // ─── Tool: search ───────────────────────────────────────
-    server.tool("search", "Search indexed content. Pass ALL search questions as queries array in ONE call.\n\nTIPS: 2-4 specific terms per query. Use 'source' to scope results.", {
-        queries: z
-            .array(z.string())
-            .describe("Array of search queries. Batch ALL questions in one call."),
-        source: z
-            .string()
-            .optional()
-            .describe("Filter to a specific indexed source (partial match)."),
-        limit: z.number().default(3).describe("Results per query (default: 3)"),
-    }, async ({ queries, source, limit }) => {
-        // Progressive throttling
-        const now = Date.now();
-        searchCalls.push(now);
-        // Clean old entries outside window
-        while (searchCalls.length > 0 && searchCalls[0] < now - config.searchWindowMs) {
-            searchCalls.shift();
-        }
-        const callCount = searchCalls.length;
-        if (callCount > config.searchBlockAfter) {
-            const msg = "Too many search calls in quick succession. Use batch_execute instead to run commands and search in one call.";
-            tracker.trackCall("search", Buffer.byteLength(msg));
-            return { content: [{ type: "text", text: msg }] };
-        }
-        const effectiveLimit = callCount > config.searchReduceAfter ? 1 : Math.min(limit, config.searchLimit);
-        const allResults = [];
-        let totalBytes = 0;
-        for (const query of queries) {
-            if (totalBytes > config.searchMaxBytes)
-                break;
-            const result = store.search(query, { source, limit: effectiveLimit });
-            let block = `## ${query}\n`;
-            if (result.corrected) {
-                block += `(corrected to: "${result.corrected}")\n`;
-            }
-            if (result.results.length === 0) {
-                block += "No results found.\n";
-            }
-            else {
-                for (const hit of result.results) {
-                    block += `\n--- [${hit.source}] ---\n### ${hit.title}\n\n${hit.snippet}\n`;
-                }
-            }
-            allResults.push(block);
-            totalBytes += Buffer.byteLength(block);
-        }
-        if (callCount > config.searchReduceAfter) {
-            allResults.push(`\n⚠ Search rate limited (${callCount} calls in ${config.searchWindowMs / 1000}s). Results reduced to 1 per query.`);
-        }
-        const output = allResults.join("\n---\n\n");
-        tracker.trackCall("search", Buffer.byteLength(output));
-        return { content: [{ type: "text", text: output }] };
-    });
-    // ─── Tool: fetch_and_index ──────────────────────────────
-    server.tool("fetch_and_index", "Fetches URL content, converts HTML to markdown, indexes into searchable knowledge base, and returns a ~3KB preview. Full content stays in sandbox — use search() for deeper lookups.\n\nBetter than WebFetch: preview is immediate, full content is searchable, raw HTML never enters context.", {
-        url: z.string().describe("The URL to fetch and index"),
-        source: z.string().optional().describe("Label for the indexed content"),
-    }, async ({ url, source }) => {
-        // SSRF protection: only allow http/https and block internal addresses
-        try {
-            const parsed = new URL(url);
-            if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-                return {
-                    content: [{ type: "text", text: "Error: only http/https URLs are allowed" }],
-                };
-            }
-            if (isPrivateHost(parsed.hostname)) {
-                return {
-                    content: [
-                        { type: "text", text: "Error: internal/private URLs are not allowed" },
-                    ],
-                };
-            }
-        }
-        catch {
-            return {
-                content: [{ type: "text", text: `Error: invalid URL "${url}"` }],
-            };
-        }
-        // DNS rebinding protection: resolve hostname and verify the IP is not private
-        let resolvedIp = null;
-        try {
-            const validated = await resolveAndValidate(url);
-            resolvedIp = validated.resolvedIp;
-        }
-        catch (err) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${err instanceof Error ? err.message : "DNS validation failed"}`,
-                    },
-                ],
-            };
-        }
-        const label = source ?? url;
-        // Use executor to fetch and convert HTML to markdown in subprocess
-        const fetchCode = buildFetchCode(url, resolvedIp);
-        let result;
-        try {
-            result = await withExecutionLimit(() => executor.execute({
-                language: "javascript",
-                code: fetchCode,
-                timeout: 30_000,
-            }));
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            return { content: [{ type: "text", text: msg }] };
-        }
-        if (result.exitCode !== 0 || !result.stdout.trim()) {
-            const errMsg = `Failed to fetch ${url}: ${result.stderr || "empty response"}`;
-            tracker.trackCall("fetch_and_index", Buffer.byteLength(errMsg));
-            return { content: [{ type: "text", text: errMsg }] };
-        }
-        const markdown = result.stdout;
-        tracker.trackSandboxed(result.networkBytes ?? 0);
-        const injectionWarnings = detectInjectionPatterns(markdown);
-        const indexed = store.index(markdown, label);
-        tracker.trackIndexed(Buffer.byteLength(markdown));
-        // Return ~3KB preview
-        const preview = markdown.slice(0, 3072);
-        const terms = store.getDistinctiveTerms(indexed.sourceId);
-        let output = `Indexed "${label}": ${indexed.totalChunks} chunks.\n\n`;
-        output += `**Preview:**\n${preview}`;
-        if (markdown.length > 3072)
-            output += "\n…(truncated)";
-        if (terms.length > 0) {
-            output += `\n\nSearchable terms: ${terms.join(", ")}`;
-        }
-        output += "\n\nUse search(queries: [...]) to retrieve full content of any section.";
-        if (injectionWarnings.length > 0) {
-            output += `\n\n⚠ Content safety notice: detected patterns (${injectionWarnings.join(", ")}). Review indexed content before relying on it.`;
-        }
-        tracker.trackCall("fetch_and_index", Buffer.byteLength(output));
-        return { content: [{ type: "text", text: output }] };
-    });
-    // ─── Tool: batch_execute ────────────────────────────────
-    server.tool("batch_execute", "Execute multiple commands in ONE call, auto-index all output, and search with multiple queries. Returns search results directly — no follow-up calls needed.\n\nTHIS IS THE PRIMARY TOOL. Use this instead of multiple execute() calls.\n\nOne batch_execute call replaces 30+ execute calls + 10+ search calls.\nProvide all commands to run and all queries to search — everything happens in one round trip.", {
-        commands: z
-            .array(z.object({
-            label: z.string().describe("Section header for this command's output"),
-            command: z.string().describe("Shell command to execute"),
-        }))
-            .describe("Commands to execute as a batch."),
-        queries: z
-            .array(z.string())
-            .describe("Search queries to extract information from indexed output. Use 5-8 comprehensive queries."),
-        timeout: z.number().default(60000).describe("Max execution time in ms (default: 60s)"),
-    }, async ({ commands, queries, timeout }) => {
-        // Execute commands with bounded concurrency (max 4 parallel)
-        const commandResults = await limitConcurrency(commands.map((cmd) => async () => {
-            const result = await withExecutionLimit(() => executor.execute({
-                language: "shell",
-                code: cmd.command,
-                timeout,
-            }));
-            return { label: cmd.label, result };
-        }), 4);
-        // Build combined output with markdown sections
-        let combined = "";
-        const inventory = [];
-        for (let i = 0; i < commandResults.length; i++) {
-            const settled = commandResults[i];
-            const label = commands[i].label;
-            if (settled.status === "fulfilled") {
-                const { result } = settled.value;
-                const output = result.stdout || "(no output)";
-                combined += `## ${label}\n\n${output}\n\n`;
-                const lineCount = output.split("\n").length;
-                inventory.push(`- **${label}**: ${lineCount} lines`);
-            }
-            else {
-                combined += `## ${label}\n\n(error: ${settled.reason})\n\n`;
-                inventory.push(`- **${label}**: error`);
-            }
-        }
-        // Index combined output
-        const indexed = store.index(combined, "batch_execute");
-        tracker.trackIndexed(Buffer.byteLength(combined));
-        // Run all search queries
-        const searchResults = [];
-        let totalBytes = 0;
-        for (const query of queries) {
-            if (totalBytes > config.batchMaxBytes)
-                break;
-            // Try scoped search first, then global fallback
-            let result = store.search(query, { source: "batch_execute", limit: 5 });
-            if (result.results.length === 0) {
-                result = store.search(query, { limit: 5 });
-            }
-            let block = `## ${query}\n\n`;
-            if (result.results.length === 0) {
-                block += "No results found.\n";
-            }
-            else {
-                for (const hit of result.results) {
-                    block += `--- [${hit.source}] ---\n### ${hit.title}\n\n${hit.snippet}\n\n`;
-                }
-            }
-            searchResults.push(block);
-            totalBytes += Buffer.byteLength(block);
-        }
-        const terms = store.getDistinctiveTerms(indexed.sourceId);
-        let output = `**Inventory** (${commands.length} commands):\n${inventory.join("\n")}\n\n`;
-        output += searchResults.join("\n---\n\n");
-        if (terms.length > 0) {
-            output += `\n\nSearchable terms: ${terms.join(", ")}`;
-        }
-        tracker.trackCall("batch_execute", Buffer.byteLength(output));
-        return { content: [{ type: "text", text: output }] };
-    });
-    // ─── Tool: stats ────────────────────────────────────────
-    server.tool("stats", "Returns context consumption statistics for the current session. Shows total bytes returned to context, breakdown by tool, call counts, estimated token usage, context savings ratio, and visual charts.", {}, async () => {
-        const report = tracker.formatReport();
-        tracker.trackCall("stats", Buffer.byteLength(report));
-        return { content: [{ type: "text", text: report }] };
-    });
-    // ─── Tool: discover ─────────────────────────────────────
-    server.tool("discover", "Shows what's in the knowledge base and suggests optimization opportunities. Lists all indexed sources, chunk counts, searchable terms, and recommends next actions. Use this to understand what data is available for search.", {}, async () => {
-        const storeStats = store.getStats();
-        const snap = tracker.getSnapshot();
-        const lines = [];
-        lines.push("## Knowledge Base Discovery\n");
-        if (storeStats.totalSources === 0) {
-            lines.push("No content indexed yet. Use these tools to build the knowledge base:\n");
-            lines.push("- `batch_execute` — run commands and auto-index output");
-            lines.push("- `execute` with `intent` — auto-indexes large output");
-            lines.push("- `index` — index documentation or files");
-            lines.push("- `fetch_and_index` — fetch and index web pages");
-        }
-        else {
-            lines.push("| Metric | Value |");
-            lines.push("|--------|-------|");
-            lines.push(`| Indexed sources | ${storeStats.totalSources} |`);
-            lines.push(`| Total chunks | ${storeStats.totalChunks} |`);
-            lines.push(`| Vocabulary size | ${storeStats.vocabularySize} |`);
-            lines.push(`| Trigram index | ${storeStats.hasTrigramTable ? "active" : "lazy (not yet needed)"} |`);
-            // List indexed sources
-            const sources = store.listSources();
-            if (sources.length > 0) {
-                lines.push("\n### Indexed Sources\n");
-                for (const src of sources) {
-                    lines.push(`- **${src.label}** — ${src.chunkCount} chunks${src.codeChunks > 0 ? ` (${src.codeChunks} with code)` : ""}`);
-                }
-            }
-            // Show top searchable terms
-            const terms = store.getDistinctiveTerms();
-            if (terms.length > 0) {
-                lines.push("\n### Top Searchable Terms\n");
-                lines.push(terms.slice(0, 20).join(", "));
-            }
-        }
-        // Optimization suggestions
-        lines.push("\n### Optimization Suggestions\n");
-        const totalCalls = Object.values(snap.calls).reduce((a, b) => a + b, 0);
-        if (totalCalls === 0) {
-            lines.push("- Start by using `batch_execute` to run multiple commands at once");
-        }
-        else {
-            const searchCalls = snap.calls.search ?? 0;
-            const executeCalls = snap.calls.execute ?? 0;
-            const batchCalls = snap.calls.batch_execute ?? 0;
-            if (executeCalls > 3 && batchCalls === 0) {
-                lines.push("- **Use batch_execute** — you've made multiple execute calls that could be batched into one");
-            }
-            if (searchCalls > 5) {
-                lines.push("- **Batch your searches** — pass multiple queries in a single search() call");
-            }
-            if (storeStats.totalChunks > 50) {
-                lines.push("- **Use source filtering** — scope searches with `source` parameter for faster, targeted results");
-            }
-            if (storeStats.totalSources === 0 && totalCalls > 2) {
-                lines.push("- **Index more content** — use `intent` parameter in execute calls to auto-index large output");
-            }
-        }
-        if (dbFallback) {
-            lines.push("\n⚠ **Warning:** Persistent DB creation failed — using in-memory storage. Indexed data will not survive restarts.");
-        }
-        const output = lines.join("\n");
-        tracker.trackCall("discover", Buffer.byteLength(output));
-        return { content: [{ type: "text", text: output }] };
-    });
-    // ─── Transport ──────────────────────────────────────────
+    const ctx = {
+        config,
+        store,
+        tracker,
+        executor,
+        projectDir,
+        bunDetected,
+        dbFallback,
+        withExecutionLimit,
+        applyIntentFilter,
+    };
+    registerExecuteTool(server, ctx);
+    registerExecuteFileTool(server, ctx);
+    registerIndexTool(server, ctx);
+    registerSearchTool(server, ctx);
+    registerFetchAndIndexTool(server, ctx);
+    registerBatchExecuteTool(server, ctx);
+    registerStatsTool(server, ctx);
+    registerDiscoverTool(server, ctx);
     return {
         async start() {
             const transport = new StdioServerTransport();
@@ -609,80 +119,4 @@ PREFER THIS OVER BASH for: API calls (gh, curl, aws), test runners (npm test, py
         },
     };
 }
-// ─── HTML to Markdown conversion code (runs in subprocess) ──
-function buildFetchCode(url, resolvedIp) {
-    let fetchSetup;
-    if (resolvedIp) {
-        // Pin connection to the resolved IP to prevent DNS rebinding (TOCTOU)
-        const pinnedUrl = new URL(url);
-        const originalHost = pinnedUrl.host;
-        pinnedUrl.hostname = resolvedIp;
-        fetchSetup = `
-const url = ${JSON.stringify(pinnedUrl.toString())};
-const resp = await fetch(url, { headers: { 'Host': ${JSON.stringify(originalHost)} }, redirect: 'error' });`;
-    }
-    else {
-        fetchSetup = `
-const url = ${JSON.stringify(url)};
-const resp = await fetch(url, { redirect: 'error' });`;
-    }
-    return `${fetchSetup}
-if (!resp.ok) { console.error("HTTP " + resp.status); process.exit(1); }
-const cl = resp.headers.get('content-length');
-if (cl && parseInt(cl, 10) > 10 * 1024 * 1024) {
-    console.error("Response too large: " + cl + " bytes"); process.exit(1);
-}
-const html = await resp.text();
-if (html.length > 10 * 1024 * 1024) {
-    console.error("Response body too large: " + html.length + " chars"); process.exit(1);
-}
-
-// Strip unwanted tags
-let md = html
-  .replace(/<script[^>]*>[\\s\\S]*?<\\/script>/gi, "")
-  .replace(/<style[^>]*>[\\s\\S]*?<\\/style>/gi, "")
-  .replace(/<nav[^>]*>[\\s\\S]*?<\\/nav>/gi, "")
-  .replace(/<header[^>]*>[\\s\\S]*?<\\/header>/gi, "")
-  .replace(/<footer[^>]*>[\\s\\S]*?<\\/footer>/gi, "");
-
-// Convert headings
-md = md.replace(/<h1[^>]*>(.*?)<\\/h1>/gi, "# $1\\n");
-md = md.replace(/<h2[^>]*>(.*?)<\\/h2>/gi, "## $1\\n");
-md = md.replace(/<h3[^>]*>(.*?)<\\/h3>/gi, "### $1\\n");
-md = md.replace(/<h4[^>]*>(.*?)<\\/h4>/gi, "#### $1\\n");
-
-// Convert code blocks
-md = md.replace(/<pre[^>]*><code[^>]*>(.*?)<\\/code><\\/pre>/gis, "\`\`\`\\n$1\\n\`\`\`\\n");
-md = md.replace(/<code[^>]*>(.*?)<\\/code>/gi, "\`$1\`");
-
-// Convert links
-md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\\/a>/gi, "[$2]($1)");
-
-// Convert lists
-md = md.replace(/<li[^>]*>(.*?)<\\/li>/gi, "- $1\\n");
-
-// Convert paragraphs
-md = md.replace(/<p[^>]*>(.*?)<\\/p>/gis, "$1\\n\\n");
-md = md.replace(/<br\\s*\\/?>/gi, "\\n");
-
-// Strip remaining tags
-md = md.replace(/<[^>]+>/g, "");
-
-// Decode entities
-md = md.replace(/&lt;/g, "<")
-  .replace(/&gt;/g, ">")
-  .replace(/&quot;/g, '"')
-  .replace(/&#39;/g, "'")
-  .replace(/&apos;/g, "'")
-  .replace(/&nbsp;/g, " ")
-  .replace(/&#(\\d+);/g, (_, n) => { const c = parseInt(n, 10); return c > 0 && c <= 0x10FFFF ? String.fromCodePoint(c) : ''; })
-  .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => { const c = parseInt(h, 16); return c > 0 && c <= 0x10FFFF ? String.fromCodePoint(c) : ''; })
-  .replace(/&amp;/g, "&");
-
-// Clean whitespace
-md = md.replace(/\\n{3,}/g, "\\n\\n").trim();
-
-console.log(md);
-`;
-}
 //# sourceMappingURL=server.js.map