@nxuss/lemma 0.9.3 → 1.0.1

package/dist/esm/mcp/tools.js

@@ -13,6 +13,12 @@ import { getProxyPort, safeResolvePath, logError, logWarn, estimateTokensFromRes
 import { runAnalysis, parseDiff } from "../pr-review/PRReviewEngine";
 import { ReviewStore } from "../pr-review/ReviewStore";
 import { runPRReview } from "../pr-review/reviewRunner";
+import { getBrain } from "../subconscious/TheBrainV2";
+import { collapseContext } from "../utils/ContextCollapser";
+import { getSymbolSurgicalContext } from "../utils/SymbolSurgicalContext";
+import { compressWormhole } from "../utils/WormholeCompressor";
+import { generateExecutiveReport } from "../utils/ExecutiveReport";
+import { surgicalASTInsert } from "../utils/SurgicalASTInsert";
 // ── Pro License Gate ──────────────────────────────────────────────────────────
 const LICENSE_FILE = path.join(os.homedir(), '.lemma-cache', 'license.json');
 let _proStatusCache = null;
@@ -30,11 +36,16 @@ function isProUser() {
     _proStatusCache = false;
     return false;
 }
+const FREE_TOOLS = new Set([
+    // Cache & Memory — the hook that shows instant value
+    "smarter_cache", "search_memory", "store_memory",
+    // Token optimization — shows what they're saving
+    "token_budget", "squeeze_prompt", "turbosqueeze",
+    // Utility — just enough to function
+    "read_workspace_file", "scrub_privacy", "summarize_long_text",
+]);
 const PRO_GATE_MESSAGE = [
-    "🔒 Lemma MCP requires a Pro license.",
-    "",
-    "All 32 MCP tools — including The Brain, zero-token static analysis,",
-    "PreCrime predictor, Coupling Radar, and Entropy Score — are Pro features.",
+    "🔒 This tool requires Lemma Pro.",
     "",
     "✨ Activate your license:",
     "  lemma activate <your-key>",
@@ -320,6 +331,67 @@ const toolDefinitions = [
             required: ["text"],
         },
     },
+    {
+        name: "get_symbol_surgical_context",
+        description: "Extrae quirúrgicamente la implementación de un símbolo específico (clase, función, interfaz) y las firmas (pero no la implementación completa) de todas sus dependencias locales del workspace. Ahorra hasta 90% de tokens.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Ruta relativa del archivo que contiene el símbolo" },
+                symbolName: { type: "string", description: "Nombre de la función, clase, tipo o interfaz a extraer" },
+            },
+            required: ["filePath", "symbolName"],
+        },
+    },
+    {
+        name: "wormhole_squeeze",
+        description: "Comprime código a formato WORMHOLE súper denso usando tokens de palabra clave y abreviación de variables reversible. Ideal para alimentar contextos de lectura al LLM.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: { type: "string", description: "El código fuente a comprimir" },
+            },
+            required: ["text"],
+        },
+    },
+    {
+        name: "generate_executive_roi_report",
+        description: "Genera un reporte ejecutivo en formato Markdown de Retorno de Inversión (ROI), dinero ahorrado en API, horas de desarrollo recuperadas y proyecciones de escala para la gerencia.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                teamSize: { type: "number", description: "Número de ingenieros en el equipo (default: 10)", default: 10 },
+                costPerDevHour: { type: "number", description: "Costo estimado en USD por hora de desarrollador (default: 50)", default: 50 },
+                targetPath: { type: "string", description: "Nombre de archivo del reporte generado (default: LEMMA_ROI_REPORT.md)", default: "LEMMA_ROI_REPORT.md" },
+            },
+        },
+    },
+    {
+        name: "surgical_ast_insert",
+        description: "Inserta quirúrgicamente código (métodos, propiedades, funciones) en una clase, interfaz o ámbito de archivo de TypeScript utilizando el AST Compiler. Evita escribir diffs de búsqueda y reemplazo grandes o reescribir todo el archivo. Ahorra 95% de tokens de salida.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Ruta del archivo TypeScript (relativo al root)" },
+                symbolName: { type: "string", description: "Nombre de la clase o interfaz donde insertar (opcional)" },
+                anchorSymbol: { type: "string", description: "Nombre del método o propiedad como anclaje (ej. 'login')" },
+                insertPosition: { type: "string", enum: ["before", "after", "start", "end"], description: "Posición relativa al anclaje (default: 'after')", default: "after" },
+                codeToInsert: { type: "string", description: "El código fuente exacto a insertar" },
+            },
+            required: ["filePath", "codeToInsert"],
+        },
+    },
+    {
+        name: "local_semantic_autofix",
+        description: "Intenta resolver errores de compilación o ejecución localmente consultando The Brain por tracebacks/mensajes similares. Si hay coincidencia, devuelve la solución/parche instantáneamente sin gastar tokens de LLM.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                errorMessage: { type: "string", description: "El traceback del error o mensaje de error a resolver" },
+            },
+            required: ["errorMessage"],
+        },
+    },
     {
         name: "compress_context",
         description: "Comprime el historial de conversación: resume turns antiguos vía Ollama, mantiene solo los últimos N intactos. Reduce contexto 70-80%. USAR antes de cada turno extendido.",
@@ -548,6 +620,11 @@ const toolHandlers = {
     diff_only: handleDiffOnly,
     batch_tool_calls: handleBatchToolCalls,
     turbosqueeze: handleTurboSqueeze,
+    get_symbol_surgical_context: handleGetSymbolSurgicalContext,
+    wormhole_squeeze: handleWormholeSqueeze,
+    generate_executive_roi_report: handleGenerateExecutiveRoiReport,
+    surgical_ast_insert: handleSurgicalAstInsert,
+    local_semantic_autofix: handleLocalSemanticAutofix,
     compress_context: handleCompressContext,
     smarter_cache: handleSmarterCache,
     token_budget: handleTokenBudget,
@@ -572,8 +649,8 @@ export function setupToolsHandlers(server, onToolCall) {
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
         const startTime = Date.now();
-        // ── Pro License Gate ────────────────────────────────────────────────────
-        if (!isProUser()) {
+        // ── Pro License Gate (granular: free tools work without license) ────────
+        if (!isProUser() && !FREE_TOOLS.has(name)) {
             onToolCall?.({
                 tool: name,
                 args: args || {},
@@ -636,22 +713,21 @@ async function handleSearchMemory(args) {
     if (!query)
         throw new Error("Query is required");
     try {
-        const port = getProxyPort();
-        const response = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`);
-        const results = response.data.results || [];
+        const brain = getBrain();
+        const results = brain.search(query, limit);
         if (results.length === 0) {
             return { content: [{ type: "text", text: "No relevant memories found in Lemma's Brain." }] };
         }
         const formatted = results
             .map((r, i) => {
-            return `Result ${i + 1} (Similarity: ${(r.similarity * 100).toFixed(1)}%)\nPrompt: ${r.prompt.substring(0, 300)}...\nResponse: ${typeof r.response === "string" ? r.response : JSON.stringify(r.response, null, 2)}`;
+            return `Result ${i + 1} (Similarity: ${(r.similarity * 100).toFixed(1)}%)\nPrompt: ${r.query.substring(0, 300)}...\nResponse: ${typeof r.response === "string" ? r.response : JSON.stringify(r.response, null, 2)}`;
         })
             .join("\n\n---\n\n");
         return { content: [{ type: "text", text: `Lemma found ${results.length} memories:\n\n${formatted}` }] };
     }
     catch (e) {
         logError("search_memory", e);
-        return { content: [{ type: "text", text: `Neural Search failed: ${e.message}. Is Lemma Proxy running?` }] };
+        return { content: [{ type: "text", text: `Local Search failed: ${e.message}` }] };
     }
 }
 async function handleStoreMemory(args) {
@@ -661,12 +737,8 @@ async function handleStoreMemory(args) {
     if (!query || !responseText)
         throw new Error("Query and response are required");
     try {
-        const port = getProxyPort();
-        const response = await axios.post(`http://localhost:${port}/api/memory/store`, {
-            query,
-            response: responseText,
-            provider,
-        });
+        const brain = getBrain();
+        const storeRes = brain.store(query, responseText, provider);
         const tokensSaved = Math.max(100, Math.floor(responseText.length / 4));
         reportSavings({
             source: "cache",
@@ -674,11 +746,11 @@ async function handleStoreMemory(args) {
             toolName: "store_memory",
             query: query.substring(0, 100),
         });
-        return { content: [{ type: "text", text: `Success: ${response.data.message}` }] };
+        return { content: [{ type: "text", text: `Success: Memory stored. ${storeRes.reason}` }] };
     }
     catch (e) {
         logError("store_memory", e);
-        return { content: [{ type: "text", text: `Failed to store memory in Lemma: ${e.message}. Is Lemma Proxy running?` }] };
+        return { content: [{ type: "text", text: `Failed to store memory in local Brain: ${e.message}` }] };
     }
 }
 async function handleGetRoutingAdvice(args) {
@@ -1246,24 +1318,20 @@ async function handleQueryHybridConsensus(args) {
     const threshold = typeof args?.threshold === "number" ? args.threshold : 0.8;
     if (!query)
         throw new Error("query is required");
-    const port = getProxyPort();
     const fullQuery = context ? `${query}\n\nContext: ${context}` : query;
     try {
-        const searchRes = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(fullQuery)}&limit=3`);
-        const results = searchRes.data.results || [];
+        const brain = getBrain();
+        const results = brain.search(fullQuery, 3);
         const topHit = results[0];
         if (topHit && topHit.similarity >= threshold) {
-            const savedTokens = Math.floor((topHit.response?.choices?.[0]?.message?.content?.length || 500) / 4);
+            const savedTokens = Math.floor((topHit.response?.length || 500) / 4);
             reportSavings({
                 source: "cache",
                 tokens: savedTokens,
                 toolName: "query_hybrid_consensus",
                 query: query.substring(0, 100),
             });
-            const responseText = typeof topHit.response === "string"
-                ? topHit.response
-                : topHit.response?.choices?.[0]?.message?.content ||
-                    JSON.stringify(topHit.response, null, 2);
+            const responseText = topHit.response;
             return {
                 content: [
                     {
@@ -1289,7 +1357,7 @@ async function handleQueryHybridConsensus(args) {
         logError("query_hybrid_consensus", e);
         return {
             content: [
-                { type: "text", text: `Hybrid Consensus failed: ${e.message}. Is Lemma Proxy running?` },
+                { type: "text", text: `Hybrid Consensus failed: ${e.message}` },
             ],
         };
     }
@@ -1300,7 +1368,6 @@ async function handleGetTelepathicHints(args) {
     const limit = typeof args?.limit === "number" ? args.limit : 5;
     if (!activeFile)
         throw new Error("activeFile is required");
-    const port = getProxyPort();
     const basename = path.basename(activeFile, path.extname(activeFile));
     const dirContext = path
         .dirname(activeFile)
@@ -1311,8 +1378,8 @@ async function handleGetTelepathicHints(args) {
     const ext = path.extname(activeFile).replace(".", "");
     const telepathicQuery = `${basename} ${dirContext} ${ext} patterns solutions architecture`;
     try {
-        const searchRes = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(telepathicQuery)}&limit=${limit}`);
-        const results = searchRes.data.results || [];
+        const brain = getBrain();
+        const results = brain.search(telepathicQuery, limit);
         if (results.length === 0) {
             return {
                 content: [
@@ -1326,11 +1393,8 @@ async function handleGetTelepathicHints(args) {
         let hintsText = `Telepathic Hints for \`${activeFile}\`\n*(${results.length} relevant memories surfaced from The Brain)*\n\n`;
         results.forEach((r, i) => {
             const similarity = (r.similarity * 100).toFixed(1);
-            const prompt = typeof r.prompt === "string" ? r.prompt.substring(0, 120) : "Unknown";
-            const responseContent = typeof r.response === "string"
-                ? r.response
-                : r.response?.choices?.[0]?.message?.content ||
-                    JSON.stringify(r.response).substring(0, 300);
+            const prompt = r.query || "Unknown";
+            const responseContent = r.response || "";
             hintsText += `### Hint ${i + 1} (${similarity}% match)\n`;
             hintsText += `**Memory:** ${prompt}\n\n`;
             hintsText += `${responseContent.substring(0, 400)}${responseContent.length > 400 ? "..." : ""}\n\n---\n\n`;
@@ -1350,7 +1414,7 @@ async function handleGetTelepathicHints(args) {
             content: [
                 {
                     type: "text",
-                    text: `Telepathic Hints failed: ${e.message}. Is Lemma Proxy running?`,
+                    text: `Telepathic Hints failed: ${e.message}`,
                 },
             ],
         };
@@ -1362,17 +1426,8 @@ async function handleSummarizeLongText(args) {
     const maxLength = args?.maxLength || 500;
     if (!text)
         throw new Error("text is required");
-    const host = process.env.OLLAMA_HOST || 'http://localhost:11434';
-    const model = process.env.OLLAMA_GEN_MODEL || 'llama3';
     try {
-        const prompt = `TASK: Summarize the following text concisely. Max ${maxLength} characters. Focus on key facts, decisions, and action items.\n\nTEXT:\n${text}`;
-        const resp = await axios.post(`${host}/api/generate`, {
-            model,
-            prompt,
-            stream: false,
-            options: { temperature: 0.1, num_predict: maxLength * 2 },
-        });
-        const summary = resp.data.response.trim();
+        const summary = collapseContext(text, { maxLength });
         reportSavings({
             source: "contextSqueeze",
             charsBefore: text.length,
@@ -1383,7 +1438,7 @@ async function handleSummarizeLongText(args) {
     }
     catch (e) {
         logError("summarize_long_text", e);
-        return { content: [{ type: "text", text: `Summarization failed: ${e.message}. Is Ollama running?` }] };
+        return { content: [{ type: "text", text: `Summarization failed: ${e.message}` }] };
     }
 }
 // ── Prune Conversation History ──────────────────────────────────────
@@ -1532,21 +1587,14 @@ async function handleCompressContext(args) {
     const recent = messages.slice(-keepRecent);
     const old = messages.slice(0, -keepRecent);
     let summary = "";
-    let summaryMethod = "trim";
+    let summaryMethod = "local-collapser";
     try {
-        const host = process.env.OLLAMA_HOST || 'http://localhost:11434';
-        const model = process.env.OLLAMA_GEN_MODEL || 'llama3';
-        const summaryPrompt = `Summarize the following conversation history into 2-3 concise sentences. Capture ONLY: key decisions made, code patterns established, unresolved issues. Be extremely brief.\n\n${JSON.stringify(old.map((m) => ({ role: m.role, content: typeof m.content === 'string' ? m.content.substring(0, 400) : '...' })))}`;
-        const resp = await axios.post(`${host}/api/generate`, {
-            model, prompt: summaryPrompt, stream: false,
-            options: { temperature: 0.1, num_predict: 300 },
-        });
-        summary = resp.data.response.trim();
-        summaryMethod = "ollama";
+        const oldText = old.map((m, i) => `[Turn ${i + 1} / ${m.role}]: ${typeof m.content === 'string' ? m.content : '...'}`).join('\n');
+        summary = collapseContext(oldText, { maxLength: 800 });
     }
-    catch {
+    catch (err) {
         summary = old.map((m, i) => `[Turn ${i + 1} / ${m.role}]: ${typeof m.content === 'string' ? m.content.substring(0, 150).replace(/\n/g, ' ') : '...'}`).join('\n').substring(0, 2000);
-        summaryMethod = "truncate";
+        summaryMethod = "truncate-fallback";
     }
     const oldLength = JSON.stringify(old).length;
     const summaryLength = summary.length;
@@ -1574,16 +1622,13 @@ async function handleSmarterCache(args) {
     const threshold = typeof args?.threshold === "number" ? args.threshold : 0.75;
     if (!query)
         throw new Error("query is required");
-    const port = getProxyPort();
     const fullQuery = context ? `${query}\n\nContext: ${context}` : query;
     try {
-        const searchRes = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(fullQuery)}&limit=5`);
-        const results = searchRes.data.results || [];
+        const brain = getBrain();
+        const results = brain.search(fullQuery, 5);
         const topHit = results[0];
         if (topHit && topHit.similarity >= threshold) {
-            const responseText = typeof topHit.response === "string"
-                ? topHit.response
-                : topHit.response?.choices?.[0]?.message?.content || JSON.stringify(topHit.response, null, 2);
+            const responseText = topHit.response;
             const tokensSaved = Math.floor(responseText.length / 4);
             try {
                 const { reportSavings } = await import("../utils/reportSavings");
@@ -1628,7 +1673,7 @@ async function handleSmarterCache(args) {
                         hit: false,
                         error: e.message,
                         source: "cache-unavailable",
-                        hint: "Lemma Proxy no está corriendo. El LLM funcionará normalmente sin cache.",
+                        hint: "El cache local del brain falló. El LLM funcionará normalmente sin cache.",
                     }, null, 2),
                 }],
         };
@@ -2281,10 +2326,9 @@ async function handleSemanticDedupGuard(args) {
     const threshold = typeof args?.threshold === "number" ? args.threshold : 0.92;
     if (!query || !response)
         throw new Error("query and response are required");
-    const port = getProxyPort();
     try {
-        const searchRes = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(query)}&limit=3`);
-        const results = searchRes.data.results || [];
+        const brain = getBrain();
+        const results = brain.search(query, 3);
         const topHit = results[0];
         if (!topHit) {
             return {
@@ -2295,17 +2339,18 @@ async function handleSemanticDedupGuard(args) {
                         }, null, 2) }],
             };
         }
-        const sim = topHit.similarity || 0;
+        let sim = topHit.similarity || 0;
+        if (topHit.query.trim().toLowerCase() === query.trim().toLowerCase()) {
+            sim = 1.0;
+        }
         if (sim >= threshold) {
             return {
                 content: [{ type: "text", text: JSON.stringify({
                             verdict: "DUPLICATE_REJECTED",
                             reason: `Duplicado exacto detectado (${(sim * 100).toFixed(1)}% ≥ ${(threshold * 100).toFixed(0)}%). NO hagas store_memory — ya existe.`,
                             similarity: sim,
-                            existingQuery: typeof topHit.prompt === "string" ? topHit.prompt.substring(0, 200) : "N/A",
-                            existingResponse: (typeof topHit.response === "string"
-                                ? topHit.response
-                                : topHit.response?.choices?.[0]?.message?.content || "").substring(0, 300),
+                            existingQuery: typeof topHit.query === "string" ? topHit.query.substring(0, 200) : "N/A",
+                            existingResponse: (topHit.response || "").substring(0, 300),
                             tokensSaved: Math.floor(response.length / 4),
                         }, null, 2) }],
             };
@@ -2316,7 +2361,7 @@ async function handleSemanticDedupGuard(args) {
                             verdict: "SIMILAR_WARNING",
                             reason: `Contenido similar detectado (${(sim * 100).toFixed(1)}%). Decide si es distinto suficiente para guardar.`,
                             similarity: sim,
-                            existingQuery: typeof topHit.prompt === "string" ? topHit.prompt.substring(0, 200) : "N/A",
+                            existingQuery: typeof topHit.query === "string" ? topHit.query.substring(0, 200) : "N/A",
                             recommendation: "Si aporta info nueva → procede con store_memory. Si es redundante → descarta.",
                         }, null, 2) }],
             };
@@ -2334,7 +2379,7 @@ async function handleSemanticDedupGuard(args) {
         return {
             content: [{ type: "text", text: JSON.stringify({
                         verdict: "STORE_ALLOWED",
-                        reason: "No se pudo consultar The Brain (proxy no disponible). Procediendo con store.",
+                        reason: "El cache local del brain falló. Procediendo con store.",
                         error: e.message,
                     }, null, 2) }],
         };
@@ -3240,4 +3285,185 @@ async function handleRefactor(args) {
         return { content: [{ type: "text", text: `refactor failed: ${err.message}` }] };
     }
 }
+// ── Surgical Symbol Context ──────────────────────────────────────────
+async function handleGetSymbolSurgicalContext(args) {
+    const filePath = args?.filePath;
+    const symbolName = args?.symbolName;
+    if (!filePath || !symbolName)
+        throw new Error("filePath and symbolName are required");
+    const workspaceRoot = process.cwd();
+    try {
+        const res = getSymbolSurgicalContext(workspaceRoot, filePath, symbolName);
+        const lines = [];
+        lines.push(`# 🧬 Surgical Context: Symbol \`${symbolName}\` in \`${filePath}\``);
+        lines.push(`## Implementation`);
+        lines.push(`\`\`\`typescript\n${res.implementation}\n\`\`\``);
+        if (res.dependencies.length > 0) {
+            lines.push(`## Workspace Dependencies (Signatures ONLY)`);
+            for (const dep of res.dependencies) {
+                lines.push(`### \`${dep.name}\` (${dep.type}) declared in \`${dep.filePath}\``);
+                lines.push(`\`\`\`typescript\n${dep.signature}\n\`\`\``);
+            }
+        }
+        else {
+            lines.push(`*No local workspace dependencies detected for this symbol.*`);
+        }
+        const output = lines.join("\n\n");
+        const originalSize = fs.readFileSync(path.resolve(workspaceRoot, filePath), "utf8").length;
+        const totalRawSize = originalSize + res.dependencies.reduce((sum, dep) => {
+            try {
+                return sum + fs.readFileSync(path.resolve(workspaceRoot, dep.filePath), "utf8").length;
+            }
+            catch {
+                return sum;
+            }
+        }, 0);
+        reportSavings({
+            source: "contextSqueeze",
+            charsBefore: totalRawSize,
+            charsAfter: output.length,
+            toolName: "get_symbol_surgical_context",
+            filePath
+        });
+        return {
+            content: [{ type: "text", text: output }]
+        };
+    }
+    catch (err) {
+        logError("get_symbol_surgical_context", err);
+        return {
+            content: [{ type: "text", text: `Surgical context extraction failed: ${err.message}` }]
+        };
+    }
+}
+// ── Wormhole Squeeze ────────────────────────────────────────────────
+async function handleWormholeSqueeze(args) {
+    const text = args?.text;
+    if (!text)
+        throw new Error("text is required");
+    try {
+        const compressed = compressWormhole(text);
+        reportSavings({
+            source: "contextSqueeze",
+            charsBefore: text.length,
+            charsAfter: compressed.length,
+            toolName: "wormhole_squeeze"
+        });
+        return {
+            content: [{ type: "text", text: compressed }]
+        };
+    }
+    catch (err) {
+        logError("wormhole_squeeze", err);
+        return {
+            content: [{ type: "text", text: `Wormhole compression failed: ${err.message}` }]
+        };
+    }
+}
+// ── Executive ROI Report ──────────────────────────────────────────────
+async function handleGenerateExecutiveRoiReport(args) {
+    const teamSize = typeof args?.teamSize === "number" ? args.teamSize : 10;
+    const costPerDevHour = typeof args?.costPerDevHour === "number" ? args.costPerDevHour : 50;
+    const targetPath = args?.targetPath || "LEMMA_ROI_REPORT.md";
+    const workspaceRoot = process.cwd();
+    try {
+        const res = generateExecutiveReport(workspaceRoot, {
+            teamSize,
+            costPerDevHour,
+            targetPath
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: `Success: ROI Report generated at ${targetPath}.\n\nTotal Business Value Saved: $${res.metrics.totalBusinessValue.toFixed(2)} USD\nEstimated Dev Time Saved: ${res.metrics.devHoursSaved} Hours\nDirect API Cost Saved: $${res.metrics.totalCostSaved.toFixed(4)} USD`
+                }]
+        };
+    }
+    catch (err) {
+        logError("generate_executive_roi_report", err);
+        return {
+            content: [{ type: "text", text: `ROI Report generation failed: ${err.message}` }]
+        };
+    }
+}
+// ── Surgical AST Insert ──────────────────────────────────────────────
+async function handleSurgicalAstInsert(args) {
+    const filePath = args?.filePath;
+    const symbolName = args?.symbolName;
+    const anchorSymbol = args?.anchorSymbol;
+    const insertPosition = args?.insertPosition;
+    const codeToInsert = args?.codeToInsert;
+    if (!filePath || !codeToInsert)
+        throw new Error("filePath and codeToInsert are required");
+    const workspaceRoot = process.cwd();
+    try {
+        const resolvedPath = surgicalASTInsert(workspaceRoot, {
+            filePath,
+            symbolName,
+            anchorSymbol,
+            insertPosition,
+            codeToInsert
+        });
+        const newTextSize = fs.readFileSync(resolvedPath, "utf8").length;
+        const outputCharsSaved = Math.max(0, newTextSize - codeToInsert.length);
+        const tokensSaved = Math.floor(outputCharsSaved / 4);
+        reportSavings({
+            source: "contextSqueeze",
+            tokens: tokensSaved,
+            toolName: "surgical_ast_insert",
+            filePath
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: `Success: Surgically inserted code into ${filePath} using AST compiler.`
+                }]
+        };
+    }
+    catch (err) {
+        logError("surgical_ast_insert", err);
+        return {
+            content: [{ type: "text", text: `Surgical AST insertion failed: ${err.message}` }]
+        };
+    }
+}
+// ── Local Semantic Autofix ────────────────────────────────────────────
+async function handleLocalSemanticAutofix(args) {
+    const errorMessage = args?.errorMessage;
+    if (!errorMessage)
+        throw new Error("errorMessage is required");
+    try {
+        const brain = getBrain();
+        const results = brain.search(errorMessage, 3, 0.70);
+        const topHit = results[0];
+        if (topHit) {
+            const responseText = topHit.response;
+            const tokensSaved = Math.max(100, Math.floor(responseText.length / 4));
+            reportSavings({
+                source: "cache",
+                tokens: tokensSaved,
+                toolName: "local_semantic_autofix",
+                query: errorMessage.substring(0, 100)
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `🎯 Local Auto-Fix HIT (similarity: ${(topHit.similarity * 100).toFixed(1)}%)\n\nFound matching resolution in global memory. Cost: 0 tokens.\n\n---\n\n${responseText}`
+                    }]
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Brain MISS (No matching resolutions for this error in local memory).\n\nPlease proceed to ask the LLM for guidance. Once resolved, make sure to call store_memory with:\n- query: "[Error description/traceback]"\n- response: "[Exact code patch or steps used to fix]"\n\nThis will allow resolving this error instantly with 0 tokens next time!`
+                }]
+        };
+    }
+    catch (err) {
+        logError("local_semantic_autofix", err);
+        return {
+            content: [{ type: "text", text: `Local auto-fix failed: ${err.message}` }]
+        };
+    }
+}
 //# sourceMappingURL=tools.js.map