@nxuss/lemma 0.8.1 → 0.9.0

package/dist/esm/mcp/tools.js

@@ -325,6 +325,84 @@ const toolDefinitions = [
             properties: {},
         },
     },
+    {
+        name: "entropy_score",
+        description: "Calcula la entropía matemática (complejidad) de uno o más archivos usando el TypeScript Compiler API. Sin LLM. Sin tokens. Devuelve: cyclomatic complexity, nesting depth, ratio de 'any', tamaño de funciones, y un score compuesto 0-100 (0=limpio, 100=caos puro). Usa esto para identificar qué archivos necesitan refactor ANTES de tocarlos.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Archivo o directorio a analizar (relativo al workspace root)" },
+                topN: { type: "number", description: "Solo reportar los N archivos más caóticos (default: 10)", default: 10 },
+            },
+        },
+    },
+    {
+        name: "coupling_radar",
+        description: "Construye un grafo de acoplamiento entre módulos analizando imports/exports con el TypeScript Compiler. Sin LLM. Sin tokens. Detecta: ciclos de dependencia, módulos 'dios' (importados por todo), islas muertas (nadie los importa), y fan-in/fan-out por módulo. Esencial antes de refactors grandes.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                dirPath: { type: "string", description: "Directorio a analizar (relativo al workspace root)", default: "src" },
+                minFanIn: { type: "number", description: "Reportar solo módulos importados por al menos N archivos", default: 3 },
+            },
+        },
+    },
+    {
+        name: "pattern_fossil",
+        description: "Detecta código zombie: patrones que ya fueron reemplazados en la mayoría del codebase pero siguen vivos en archivos viejos. Sin LLM. Sin tokens. Detecta: callbacks vs async/await, var vs let/const, require() vs import, any vs generics. Devuelve porcentaje de adopción del patrón nuevo vs. los fósiles que quedan.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                dirPath: { type: "string", description: "Directorio a escanear (default: src)", default: "src" },
+            },
+        },
+    },
+    {
+        name: "git_heatmap_risk",
+        description: "Analiza el historial de git para identificar zonas de alto riesgo. Sin LLM. Sin tokens. Calcula: churn rate (frecuencia de cambios), co-edición oculta (archivos que siempre cambian juntos = acoplamiento implícito), y un risk score compuesto por archivo. Detecta los archivos que estadísticamente tienen más probabilidad de tener un bug.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                days: { type: "number", description: "Ventana de días de historial a analizar (default: 30)", default: 30 },
+                topN: { type: "number", description: "Top N archivos más riesgosos a reportar (default: 10)", default: 10 },
+            },
+        },
+    },
+    {
+        name: "precrime_static",
+        description: "MINORITY REPORT para tu código. Combina entropy_score + coupling_radar + git_heatmap_risk en un predictor de riesgo compuesto. Sin LLM. Sin tokens. Devuelve un ranking de archivos y funciones con mayor probabilidad de causar un bug, con justificación matemática de cada factor. Úsalo antes de un deploy o un PR review.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                dirPath: { type: "string", description: "Directorio a analizar (default: src)", default: "src" },
+                days: { type: "number", description: "Ventana de días de historial git (default: 30)", default: 30 },
+                topN: { type: "number", description: "Top N archivos a reportar (default: 10)", default: 10 },
+            },
+        },
+    },
+    {
+        name: "semantic_dedup_guard",
+        description: "Firewall anti-redundancia para The Brain. Antes de hacer store_memory, pasa el contenido por aquí. Consulta ChromaDB localmente sin gastar tokens. Si hay un hit >= 92% → rechaza el store y devuelve el duplicado. Si 75-91% → advierte y muestra el similar. Mantiene The Brain denso y limpio.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "El query/prompt que ibas a almacenar" },
+                response: { type: "string", description: "La respuesta que ibas a almacenar" },
+                threshold: { type: "number", description: "Threshold de duplicado exacto (default: 0.92)", default: 0.92 },
+            },
+            required: ["query", "response"],
+        },
+    },
+    {
+        name: "dead_export_necromancer",
+        description: "Resucita el código muerto. Usa el TypeScript Compiler para mapear TODOS los exports del workspace y los cruza contra TODOS los imports. Lo que se exporta pero nadie importa = código zombie que está inflando tu contexto y desperdiciando tokens. Sin LLM. Sin tokens. Devuelve lista de exports muertos con estimación de tokens desperdiciados.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                dirPath: { type: "string", description: "Directorio a analizar (default: src)", default: "src" },
+            },
+        },
+    },
 ];
 const toolHandlers = {
     scrub_privacy: handleScrubPrivacy,
@@ -352,6 +430,13 @@ const toolHandlers = {
     compress_context: handleCompressContext,
     smarter_cache: handleSmarterCache,
     token_budget: handleTokenBudget,
+    entropy_score: handleEntropyScore,
+    coupling_radar: handleCouplingRadar,
+    pattern_fossil: handlePatternFossil,
+    git_heatmap_risk: handleGitHeatmapRisk,
+    precrime_static: handlePrecrimeStatic,
+    semantic_dedup_guard: handleSemanticDedupGuard,
+    dead_export_necromancer: handleDeadExportNecromancer,
 };
 export function setupToolsHandlers(server, onToolCall) {
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -1451,4 +1536,787 @@ async function handleTokenBudget(_args) {
             }],
     };
 }
+function computeCyclomaticComplexity(node) {
+    let count = 1; // base
+    function walk(n) {
+        switch (n.kind) {
+            case ts.SyntaxKind.IfStatement:
+            case ts.SyntaxKind.WhileStatement:
+            case ts.SyntaxKind.ForStatement:
+            case ts.SyntaxKind.ForInStatement:
+            case ts.SyntaxKind.ForOfStatement:
+            case ts.SyntaxKind.CaseClause:
+            case ts.SyntaxKind.CatchClause:
+            case ts.SyntaxKind.ConditionalExpression:
+                count++;
+                break;
+            case ts.SyntaxKind.BinaryExpression: {
+                const bin = n;
+                if (bin.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+                    bin.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
+                    bin.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken)
+                    count++;
+                break;
+            }
+        }
+        ts.forEachChild(n, walk);
+    }
+    walk(node);
+    return count;
+}
+function computeMaxNesting(node, depth = 0) {
+    const nestingNodes = new Set([
+        ts.SyntaxKind.IfStatement, ts.SyntaxKind.WhileStatement,
+        ts.SyntaxKind.ForStatement, ts.SyntaxKind.ForInStatement,
+        ts.SyntaxKind.ForOfStatement, ts.SyntaxKind.SwitchStatement,
+        ts.SyntaxKind.TryStatement, ts.SyntaxKind.Block,
+    ]);
+    const isNesting = nestingNodes.has(node.kind);
+    const currentDepth = isNesting ? depth + 1 : depth;
+    let max = currentDepth;
+    ts.forEachChild(node, child => {
+        max = Math.max(max, computeMaxNesting(child, currentDepth));
+    });
+    return max;
+}
+function analyzeFileEntropy(filePath, relPath) {
+    try {
+        const src = fs.readFileSync(filePath, "utf8");
+        const sourceFile = ts.createSourceFile(filePath, src, ts.ScriptTarget.Latest, true);
+        const lines = src.split("\n");
+        // Count 'any' tokens
+        const anyCount = (src.match(/:\s*any\b/g) || []).length;
+        const typeAnnotations = (src.match(/:\s*\w+/g) || []).length;
+        const anyRatio = typeAnnotations > 0 ? anyCount / typeAnnotations : 0;
+        const functions = [];
+        function visitFunctions(node) {
+            const isFn = ts.isFunctionDeclaration(node) ||
+                ts.isMethodDeclaration(node) ||
+                ts.isArrowFunction(node) ||
+                ts.isFunctionExpression(node);
+            if (isFn) {
+                const nameNode = node.name;
+                const name = nameNode ? nameNode.getText(sourceFile) : "<anonymous>";
+                const start = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line;
+                const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line;
+                const fnLines = end - start + 1;
+                const cc = computeCyclomaticComplexity(node);
+                const depth = computeMaxNesting(node);
+                functions.push({ name, lines: fnLines, cyclomaticComplexity: cc, nestingDepth: depth });
+            }
+            ts.forEachChild(node, visitFunctions);
+        }
+        visitFunctions(sourceFile);
+        const avgCC = functions.length > 0
+            ? functions.reduce((s, f) => s + f.cyclomaticComplexity, 0) / functions.length
+            : 1;
+        const maxDepth = functions.length > 0
+            ? Math.max(...functions.map(f => f.nestingDepth))
+            : 0;
+        const avgLines = functions.length > 0
+            ? functions.reduce((s, f) => s + f.lines, 0) / functions.length
+            : lines.length;
+        // Entropy score: weighted composite 0-100
+        const ccScore = Math.min(100, (avgCC / 15) * 40); // 40% weight
+        const nestScore = Math.min(100, (maxDepth / 8) * 20); // 20% weight
+        const anyScore = Math.min(100, anyRatio * 100) * 0.20; // 20% weight
+        const sizeScore = Math.min(100, (avgLines / 80) * 100) * 0.20; // 20% weight
+        const entropyScore = Math.round(ccScore + nestScore + anyScore + sizeScore);
+        const verdict = entropyScore >= 80 ? "🔥 PELIGRO — Refactor urgente" :
+            entropyScore >= 60 ? "⚠️  ALTO — Revisar antes de tocar" :
+                entropyScore >= 40 ? "🟡 MEDIO — Manejable" :
+                    "✅ LIMPIO — Bajo riesgo";
+        return {
+            file: relPath,
+            entropyScore,
+            cyclomaticComplexity: Math.round(avgCC * 10) / 10,
+            maxNestingDepth: maxDepth,
+            anyRatio: Math.round(anyRatio * 1000) / 10,
+            avgFunctionLines: Math.round(avgLines),
+            functionCount: functions.length,
+            functions: functions.sort((a, b) => b.cyclomaticComplexity - a.cyclomaticComplexity).slice(0, 5),
+            verdict,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function handleEntropyScore(args) {
+    const filePath = args?.filePath || "";
+    const topN = args?.topN || 10;
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, filePath);
+        const isFile = fs.statSync(resolved).isFile();
+        const filesToAnalyze = [];
+        if (isFile) {
+            filesToAnalyze.push({ abs: resolved, rel: filePath });
+        }
+        else {
+            function walkForTs(dir, rel) {
+                try {
+                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                    for (const e of entries) {
+                        if (["node_modules", ".git", "dist", "chroma_data", ".lemma"].includes(e.name))
+                            continue;
+                        const abs = path.join(dir, e.name);
+                        const relPath2 = rel ? path.join(rel, e.name) : e.name;
+                        if (e.isDirectory())
+                            walkForTs(abs, relPath2);
+                        else if (e.name.match(/\.(ts|tsx)$/) && !e.name.endsWith(".d.ts")) {
+                            filesToAnalyze.push({ abs, rel: relPath2 });
+                        }
+                    }
+                }
+                catch { }
+            }
+            walkForTs(resolved, filePath);
+        }
+        const results = filesToAnalyze
+            .map(f => analyzeFileEntropy(f.abs, f.rel))
+            .filter((r) => r !== null)
+            .sort((a, b) => b.entropyScore - a.entropyScore)
+            .slice(0, topN);
+        const avgEntropy = results.length > 0
+            ? Math.round(results.reduce((s, r) => s + r.entropyScore, 0) / results.length)
+            : 0;
+        const summary = [
+            `# 🧮 Entropy Score Report`,
+            `Archivos analizados: ${filesToAnalyze.length} | Top ${topN} mostrados | Entropía promedio: ${avgEntropy}/100`,
+            ``,
+            ...results.map((r, i) => `## ${i + 1}. ${r.file} — Score: ${r.entropyScore}/100 ${r.verdict}\n` +
+                `   CC: ${r.cyclomaticComplexity} | Nesting: ${r.maxNestingDepth} | Any ratio: ${r.anyRatio}% | Avg fn: ${r.avgFunctionLines} líneas | Fns: ${r.functionCount}\n` +
+                (r.functions.length > 0
+                    ? `   Top funciones caóticas: ${r.functions.slice(0, 3).map(f => `${f.name}(CC:${f.cyclomaticComplexity})`).join(", ")}`
+                    : "")),
+        ].join("\n");
+        return { content: [{ type: "text", text: summary }] };
+    }
+    catch (err) {
+        logError("entropy_score", err);
+        return { content: [{ type: "text", text: `Entropy score failed: ${err.message}` }] };
+    }
+}
+function extractImports(filePath, relPath, workspaceRoot) {
+    try {
+        const src = fs.readFileSync(filePath, "utf8");
+        const sourceFile = ts.createSourceFile(filePath, src, ts.ScriptTarget.Latest, true);
+        const imports = [];
+        ts.forEachChild(sourceFile, node => {
+            if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+                const spec = node.moduleSpecifier.text;
+                if (spec.startsWith(".")) {
+                    // Resolve relative import to normalized path
+                    const dir = path.dirname(filePath);
+                    let resolved = path.resolve(dir, spec);
+                    // Try to find the actual file with extension
+                    for (const ext of [".ts", ".tsx", "/index.ts", "/index.tsx"]) {
+                        if (fs.existsSync(resolved + ext)) {
+                            resolved = resolved + ext;
+                            break;
+                        }
+                    }
+                    const rel = path.relative(workspaceRoot, resolved).replace(/\\/g, "/");
+                    imports.push(rel);
+                }
+            }
+        });
+        return imports;
+    }
+    catch {
+        return [];
+    }
+}
+async function handleCouplingRadar(args) {
+    const dirPath = args?.dirPath || "src";
+    const minFanIn = args?.minFanIn || 3;
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, dirPath);
+        const allFiles = [];
+        function walkForTs2(dir, rel) {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const e of entries) {
+                    if (["node_modules", ".git", "dist", "chroma_data", ".lemma"].includes(e.name))
+                        continue;
+                    const abs = path.join(dir, e.name);
+                    const relPath2 = rel ? path.join(rel, e.name).replace(/\\/g, "/") : e.name;
+                    if (e.isDirectory())
+                        walkForTs2(abs, relPath2);
+                    else if (e.name.match(/\.(ts|tsx)$/) && !e.name.endsWith(".d.ts")) {
+                        allFiles.push({ abs, rel: relPath2 });
+                    }
+                }
+            }
+            catch { }
+        }
+        walkForTs2(resolved, dirPath);
+        // Build adjacency map
+        const moduleMap = new Map();
+        for (const f of allFiles) {
+            moduleMap.set(f.rel, { file: f.rel, imports: [], importedBy: [], fanIn: 0, fanOut: 0 });
+        }
+        for (const f of allFiles) {
+            const imports = extractImports(f.abs, f.rel, workspaceRoot);
+            const node = moduleMap.get(f.rel);
+            for (const imp of imports) {
+                if (moduleMap.has(imp)) {
+                    node.imports.push(imp);
+                    moduleMap.get(imp).importedBy.push(f.rel);
+                }
+            }
+        }
+        // Compute fan-in / fan-out
+        for (const node of moduleMap.values()) {
+            node.fanIn = node.importedBy.length;
+            node.fanOut = node.imports.length;
+        }
+        // Detect cycles using DFS
+        const cycles = [];
+        const visited = new Set();
+        const stack = new Set();
+        function dfs(file, currentPath) {
+            if (stack.has(file)) {
+                const cycleStart = currentPath.indexOf(file);
+                if (cycleStart >= 0)
+                    cycles.push(currentPath.slice(cycleStart).concat(file));
+                return;
+            }
+            if (visited.has(file))
+                return;
+            visited.add(file);
+            stack.add(file);
+            const node = moduleMap.get(file);
+            if (node) {
+                for (const imp of node.imports)
+                    dfs(imp, [...currentPath, file]);
+            }
+            stack.delete(file);
+        }
+        for (const f of allFiles)
+            dfs(f.rel, []);
+        // High fan-in (god modules)
+        const godModules = [...moduleMap.values()]
+            .filter(n => n.fanIn >= minFanIn)
+            .sort((a, b) => b.fanIn - a.fanIn)
+            .slice(0, 10);
+        // Dead islands (no fan-in, not an index/entry)
+        const deadIslands = [...moduleMap.values()]
+            .filter(n => n.fanIn === 0 && n.fanOut === 0 && !n.file.includes("index"))
+            .slice(0, 10);
+        const report = [
+            `# 🕸️ Coupling Radar`,
+            `Módulos analizados: ${moduleMap.size}`,
+            ``,
+            `## 🔄 Ciclos de dependencia detectados: ${cycles.length}`,
+            cycles.slice(0, 5).map(c => `  ⚡ ${c.join(" → ")}`).join("\n") || "  Ninguno detectado ✅",
+            ``,
+            `## 👁️ Módulos DIOS (fan-in >= ${minFanIn}):`,
+            godModules.map(n => `  🌐 ${n.file}\n     fan-in: ${n.fanIn} importadores | fan-out: ${n.fanOut} dependencias`).join("\n") || "  Ninguno",
+            ``,
+            `## 👻 Islas muertas (sin importadores y sin dependencias):`,
+            deadIslands.map(n => `  💀 ${n.file}`).join("\n") || "  Ninguno ✅",
+            ``,
+            `## 📊 Top acoplados (mayor fan-in + fan-out):`,
+            [...moduleMap.values()]
+                .sort((a, b) => (b.fanIn + b.fanOut) - (a.fanIn + a.fanOut))
+                .slice(0, 8)
+                .map(n => `  ${n.file} → in:${n.fanIn} out:${n.fanOut}`)
+                .join("\n"),
+        ].join("\n");
+        return { content: [{ type: "text", text: report }] };
+    }
+    catch (err) {
+        logError("coupling_radar", err);
+        return { content: [{ type: "text", text: `Coupling radar failed: ${err.message}` }] };
+    }
+}
+const FOSSIL_PATTERNS = [
+    {
+        name: "async/await vs callbacks",
+        modernPattern: /async\s+function|\basync\s*\(|await\s+/g,
+        fossilPattern: /\.then\s*\(|\.catch\s*\(|callback\s*\(/g,
+        modernLabel: "async/await",
+        fossilLabel: "callbacks/.then",
+    },
+    {
+        name: "const/let vs var",
+        modernPattern: /\b(const|let)\s+\w+/g,
+        fossilPattern: /\bvar\s+\w+/g,
+        modernLabel: "const/let",
+        fossilLabel: "var",
+    },
+    {
+        name: "ESM import vs CommonJS require",
+        modernPattern: /^import\s+/gm,
+        fossilPattern: /\brequire\s*\(/g,
+        modernLabel: "ESM import",
+        fossilLabel: "require()",
+    },
+    {
+        name: "Typed generics vs any",
+        modernPattern: /<[A-Z]\w*>/g,
+        fossilPattern: /:\s*any\b/g,
+        modernLabel: "generics/types",
+        fossilLabel: ": any",
+    },
+    {
+        name: "Template literals vs concatenation",
+        modernPattern: /`[^`]*\$\{/g,
+        fossilPattern: /["']\s*\+\s*\w+\s*\+\s*["']/g,
+        modernLabel: "template literals",
+        fossilLabel: "string concatenation",
+    },
+];
+async function handlePatternFossil(args) {
+    const dirPath = args?.dirPath || "src";
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, dirPath);
+        const allFiles = [];
+        function walkForSource(dir, rel) {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const e of entries) {
+                    if (["node_modules", ".git", "dist", "chroma_data", ".lemma"].includes(e.name))
+                        continue;
+                    const abs = path.join(dir, e.name);
+                    const relPath2 = rel ? path.join(rel, e.name) : e.name;
+                    if (e.isDirectory())
+                        walkForSource(abs, relPath2);
+                    else if (e.name.match(/\.(ts|tsx|js|jsx)$/) && !e.name.endsWith(".d.ts")) {
+                        allFiles.push({ abs, rel: relPath2 });
+                    }
+                }
+            }
+            catch { }
+        }
+        walkForSource(resolved, dirPath);
+        const results = [];
+        for (const fp of FOSSIL_PATTERNS) {
+            let totalModern = 0;
+            let totalFossil = 0;
+            const fossilFiles = [];
+            for (const f of allFiles) {
+                try {
+                    const src = fs.readFileSync(f.abs, "utf8");
+                    const modernMatches = (src.match(fp.modernPattern) || []).length;
+                    const fossilMatches = (src.match(fp.fossilPattern) || []).length;
+                    totalModern += modernMatches;
+                    if (fossilMatches > 0) {
+                        totalFossil += fossilMatches;
+                        fossilFiles.push(`${f.rel} (${fossilMatches}x)`);
+                    }
+                }
+                catch { }
+            }
+            const total = totalModern + totalFossil;
+            const adoptionPercent = total > 0 ? Math.round((totalModern / total) * 100) : 100;
+            if (totalFossil > 0) {
+                results.push({
+                    pattern: fp.name,
+                    modernCount: totalModern,
+                    fossilCount: totalFossil,
+                    adoptionPercent,
+                    fossilFiles: fossilFiles.slice(0, 5),
+                });
+            }
+        }
+        if (results.length === 0) {
+            return { content: [{ type: "text", text: "✅ No se detectaron fósiles de código. Codebase moderno y consistente." }] };
+        }
+        const report = [
+            `# 👻 Pattern Fossil Detector`,
+            `Archivos escaneados: ${allFiles.length}`,
+            ``,
+            ...results.map(r => [
+                `## ${r.adoptionPercent < 70 ? "🦕" : "⚠️"} ${r.pattern}`,
+                `Adopción moderna: **${r.adoptionPercent}%** | Modern: ${r.modernCount} | Fósil: ${r.fossilCount}`,
+                `Archivos con código fósil:`,
+                r.fossilFiles.map(f => `  - ${f}`).join("\n"),
+            ].join("\n")),
+        ].join("\n\n");
+        return { content: [{ type: "text", text: report }] };
+    }
+    catch (err) {
+        logError("pattern_fossil", err);
+        return { content: [{ type: "text", text: `Pattern fossil failed: ${err.message}` }] };
+    }
+}
+// ─── git_heatmap_risk ─────────────────────────────────────────────────────────
+async function handleGitHeatmapRisk(args) {
+    const days = args?.days || 30;
+    const topN = args?.topN || 10;
+    const workspaceRoot = process.cwd();
+    try {
+        const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().split("T")[0];
+        // Get commit log with changed files
+        let gitLog = "";
+        try {
+            gitLog = execSync(`git log --since="${since}" --name-only --pretty=format:"COMMIT:%H" --diff-filter=M`, { cwd: workspaceRoot, encoding: "utf8", timeout: 10000 });
+        }
+        catch {
+            return { content: [{ type: "text", text: "⚠️ Git no disponible o repositorio sin historial suficiente." }] };
+        }
+        // Parse commit groups
+        const commitGroups = [];
+        let currentGroup = [];
+        for (const line of gitLog.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("COMMIT:")) {
+                if (currentGroup.length > 0)
+                    commitGroups.push(currentGroup);
+                currentGroup = [];
+            }
+            else if (trimmed && !trimmed.startsWith("COMMIT:")) {
+                currentGroup.push(trimmed);
+            }
+        }
+        if (currentGroup.length > 0)
+            commitGroups.push(currentGroup);
+        // Churn rate per file
+        const fileChurn = new Map();
+        for (const group of commitGroups) {
+            for (const file of group) {
+                fileChurn.set(file, (fileChurn.get(file) || 0) + 1);
+            }
+        }
+        // Co-change pairs (files changed together)
+        const coChange = new Map();
+        for (const group of commitGroups) {
+            if (group.length < 2)
+                continue;
+            for (let i = 0; i < group.length; i++) {
+                for (let j = i + 1; j < group.length; j++) {
+                    const key = [group[i], group[j]].sort().join(" <-> ");
+                    coChange.set(key, (coChange.get(key) || 0) + 1);
+                }
+            }
+        }
+        // Build risk scores
+        const maxChurn = Math.max(...fileChurn.values(), 1);
+        const riskScores = [...fileChurn.entries()]
+            .map(([file, churn]) => ({
+            file,
+            churn,
+            churnScore: Math.round((churn / maxChurn) * 100),
+            riskScore: Math.round((churn / maxChurn) * 100),
+        }))
+            .sort((a, b) => b.riskScore - a.riskScore)
+            .slice(0, topN);
+        // Top co-change pairs
+        const topCoChange = [...coChange.entries()]
+            .filter(([, count]) => count >= 2)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5);
+        const report = [
+            `# 🔥 Git Heatmap Risk`,
+            `Período: últimos ${days} días | Commits analizados: ${commitGroups.length} | Archivos rastreados: ${fileChurn.size}`,
+            ``,
+            `## 🌡️ Top ${topN} archivos con mayor churn (más cambian = más riesgo):`,
+            riskScores.map((r, i) => `  ${i + 1}. ${r.file}\n     Cambios: ${r.churn}x | Risk score: ${r.riskScore}/100 ${r.riskScore >= 70 ? "🔥" : r.riskScore >= 40 ? "⚠️" : "🟢"}`).join("\n"),
+            ``,
+            `## 🔗 Acoplamiento oculto (siempre cambian juntos):`,
+            topCoChange.length > 0
+                ? topCoChange.map(([pair, count]) => `  ⚡ ${pair}\n     Co-editados ${count} veces — posible acoplamiento implícito`).join("\n")
+                : "  Ningún patrón de co-edición significativo detectado.",
+        ].join("\n");
+        return { content: [{ type: "text", text: report }] };
+    }
+    catch (err) {
+        logError("git_heatmap_risk", err);
+        return { content: [{ type: "text", text: `Git heatmap failed: ${err.message}` }] };
+    }
+}
+// ─── precrime_static ──────────────────────────────────────────────────────────
+async function handlePrecrimeStatic(args) {
+    const dirPath = args?.dirPath || "src";
+    const days = args?.days || 30;
+    const topN = args?.topN || 10;
+    const workspaceRoot = process.cwd();
+    try {
+        // 1. Run entropy analysis
+        const { resolved } = safeResolvePath(workspaceRoot, dirPath);
+        const allFiles = [];
+        function walkTs(dir, rel) {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const e of entries) {
+                    if (["node_modules", ".git", "dist", "chroma_data", ".lemma"].includes(e.name))
+                        continue;
+                    const abs = path.join(dir, e.name);
+                    const relPath2 = rel ? path.join(rel, e.name).replace(/\\/g, "/") : e.name;
+                    if (e.isDirectory())
+                        walkTs(abs, relPath2);
+                    else if (e.name.match(/\.(ts|tsx)$/) && !e.name.endsWith(".d.ts")) {
+                        allFiles.push({ abs, rel: relPath2 });
+                    }
+                }
+            }
+            catch { }
+        }
+        walkTs(resolved, dirPath);
+        const entropyResults = allFiles
+            .map(f => analyzeFileEntropy(f.abs, f.rel))
+            .filter((r) => r !== null);
+        const entropyMap = new Map(entropyResults.map(r => [r.file, r.entropyScore]));
+        // 2. Git churn
+        const churnMap = new Map();
+        try {
+            const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().split("T")[0];
+            const gitLog = execSync(`git log --since="${since}" --name-only --pretty=format:"COMMIT:%H" --diff-filter=M`, { cwd: workspaceRoot, encoding: "utf8", timeout: 10000 });
+            for (const line of gitLog.split("\n")) {
+                const t = line.trim();
+                if (t && !t.startsWith("COMMIT:")) {
+                    churnMap.set(t, (churnMap.get(t) || 0) + 1);
+                }
+            }
+        }
+        catch { }
+        const maxChurn = Math.max(...churnMap.values(), 1);
+        // 3. Coupling fan-in
+        const fanInMap = new Map();
+        for (const f of allFiles) {
+            const imports = extractImports(f.abs, f.rel, workspaceRoot);
+            for (const imp of imports) {
+                fanInMap.set(imp, (fanInMap.get(imp) || 0) + 1);
+            }
+        }
+        const maxFanIn = Math.max(...fanInMap.values(), 1);
+        const precrimeResults = allFiles.map(f => {
+            const entropy = entropyMap.get(f.rel) || 0;
+            const churn = churnMap.get(f.rel) || 0;
+            const fanIn = fanInMap.get(f.rel) || 0;
+            const churnScore = Math.round((churn / maxChurn) * 100);
+            const couplingScore = Math.round((fanIn / maxFanIn) * 100);
+            // Weighted: entropy 40%, churn 40%, coupling 20%
+            const precrimeScore = Math.round(entropy * 0.4 + churnScore * 0.4 + couplingScore * 0.2);
+            const entropyResult = entropyResults.find(r => r.file === f.rel);
+            const topRiskyFunctions = entropyResult?.functions
+                .filter(fn => fn.cyclomaticComplexity >= 5)
+                .slice(0, 3)
+                .map(fn => `${fn.name}(CC:${fn.cyclomaticComplexity}, ${fn.lines}L)`) || [];
+            const verdict = precrimeScore >= 75 ? "🚨 ARRESTO PREVENTIVO — Alto riesgo de bug" :
+                precrimeScore >= 50 ? "⚠️  SOSPECHOSO — Revisar antes de merge" :
+                    precrimeScore >= 25 ? "🟡 VIGILANCIA — Bajo radar" :
+                        "✅ LIMPIO";
+            return { file: f.rel, precrimeScore, entropyScore: entropy, churnScore, couplingScore, verdict, topRiskyFunctions };
+        });
+        const topThreats = precrimeResults
+            .sort((a, b) => b.precrimeScore - a.precrimeScore)
+            .slice(0, topN);
+        const report = [
+            `# 🔮 PreCrime Static — Minority Report para tu Código`,
+            `Archivos bajo análisis: ${allFiles.length} | Período git: ${days}d | Factores: Entropía 40% + Churn 40% + Acoplamiento 20%`,
+            ``,
+            `## 🚨 Predicciones de riesgo:`,
+            ``,
+            ...topThreats.map((r, i) => [
+                `### ${i + 1}. ${r.file}`,
+                `**PreCrime Score: ${r.precrimeScore}/100** — ${r.verdict}`,
+                `| Factor | Score |`,
+                `|--------|-------|`,
+                `| 🧮 Entropía (40%) | ${r.entropyScore}/100 |`,
+                `| 🔥 Churn git (40%) | ${r.churnScore}/100 |`,
+                `| 🕸️ Acoplamiento (20%) | ${r.couplingScore}/100 |`,
+                r.topRiskyFunctions.length > 0
+                    ? `\n**Funciones sospechosas:** ${r.topRiskyFunctions.join(", ")}`
+                    : "",
+            ].join("\n")),
+        ].join("\n");
+        return { content: [{ type: "text", text: report }] };
+    }
+    catch (err) {
+        logError("precrime_static", err);
+        return { content: [{ type: "text", text: `PreCrime static failed: ${err.message}` }] };
+    }
+}
+// ─── semantic_dedup_guard ─────────────────────────────────────────────────────
+async function handleSemanticDedupGuard(args) {
+    const query = args?.query;
+    const response = args?.response;
+    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 topHit = results[0];
+        if (!topHit) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            verdict: "STORE_ALLOWED",
+                            reason: "The Brain está vacío para esta query. Procede con store_memory.",
+                            similarity: 0,
+                        }, null, 2) }],
+            };
+        }
+        const sim = topHit.similarity || 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),
+                            tokensSaved: Math.floor(response.length / 4),
+                        }, null, 2) }],
+            };
+        }
+        if (sim >= 0.75) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            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",
+                            recommendation: "Si aporta info nueva → procede con store_memory. Si es redundante → descarta.",
+                        }, null, 2) }],
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify({
+                        verdict: "STORE_ALLOWED",
+                        reason: `Contenido único (${(sim * 100).toFixed(1)}% de similitud con lo más cercano). Procede con store_memory.`,
+                        similarity: sim,
+                    }, null, 2) }],
+        };
+    }
+    catch (e) {
+        logError("semantic_dedup_guard", e);
+        return {
+            content: [{ type: "text", text: JSON.stringify({
+                        verdict: "STORE_ALLOWED",
+                        reason: "No se pudo consultar The Brain (proxy no disponible). Procediendo con store.",
+                        error: e.message,
+                    }, null, 2) }],
+        };
+    }
+}
+// ─── dead_export_necromancer ──────────────────────────────────────────────────
+async function handleDeadExportNecromancer(args) {
+    const dirPath = args?.dirPath || "src";
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, dirPath);
+        const allFiles = [];
+        function walkForNecro(dir, rel) {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const e of entries) {
+                    if (["node_modules", ".git", "dist", "chroma_data", ".lemma"].includes(e.name))
+                        continue;
+                    const abs = path.join(dir, e.name);
+                    const relPath2 = rel ? path.join(rel, e.name).replace(/\\/g, "/") : e.name;
+                    if (e.isDirectory())
+                        walkForNecro(abs, relPath2);
+                    else if (e.name.match(/\.(ts|tsx)$/) && !e.name.endsWith(".d.ts")) {
+                        allFiles.push({ abs, rel: relPath2 });
+                    }
+                }
+            }
+            catch { }
+        }
+        walkForNecro(resolved, dirPath);
+        const allExports = [];
+        for (const f of allFiles) {
+            try {
+                const src = fs.readFileSync(f.abs, "utf8");
+                const sourceFile = ts.createSourceFile(f.abs, src, ts.ScriptTarget.Latest, true);
+                function visitExports(node) {
+                    const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+                    const isExported = mods?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported) {
+                        const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+                        if (ts.isFunctionDeclaration(node) && node.name) {
+                            allExports.push({ file: f.rel, name: node.name.text, line, kind: "function" });
+                        }
+                        else if (ts.isClassDeclaration(node) && node.name) {
+                            allExports.push({ file: f.rel, name: node.name.text, line, kind: "class" });
+                        }
+                        else if (ts.isInterfaceDeclaration(node) && node.name) {
+                            allExports.push({ file: f.rel, name: node.name.text, line, kind: "interface" });
+                        }
+                        else if (ts.isTypeAliasDeclaration(node) && node.name) {
+                            allExports.push({ file: f.rel, name: node.name.text, line, kind: "type" });
+                        }
+                        else if (ts.isVariableStatement(node)) {
+                            for (const decl of node.declarationList.declarations) {
+                                if (ts.isIdentifier(decl.name)) {
+                                    allExports.push({ file: f.rel, name: decl.name.text, line, kind: "const" });
+                                }
+                            }
+                        }
+                    }
+                    ts.forEachChild(node, visitExports);
+                }
+                visitExports(sourceFile);
+            }
+            catch { }
+        }
+        // Collect all imported names across the workspace
+        const importedNames = new Set();
+        for (const f of allFiles) {
+            try {
+                const src = fs.readFileSync(f.abs, "utf8");
+                const sourceFile = ts.createSourceFile(f.abs, src, ts.ScriptTarget.Latest, true);
+                ts.forEachChild(sourceFile, node => {
+                    if (ts.isImportDeclaration(node) && node.importClause) {
+                        const clause = node.importClause;
+                        if (clause.name)
+                            importedNames.add(clause.name.text); // default import
+                        if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+                            for (const spec of clause.namedBindings.elements) {
+                                importedNames.add(spec.name.text);
+                            }
+                        }
+                    }
+                });
+            }
+            catch { }
+        }
+        // Find dead exports
+        const deadExports = allExports.filter(e => !importedNames.has(e.name));
+        // Estimate tokens wasted (approximate: name + type annotation + function body avg ~50 tokens per export)
+        const estimatedWastedTokens = deadExports.length * 50;
+        if (deadExports.length === 0) {
+            return {
+                content: [{ type: "text", text: "✅ No se encontraron exports muertos. Cada export tiene al menos un importador." }],
+            };
+        }
+        // Group by file
+        const byFile = new Map();
+        for (const e of deadExports) {
+            if (!byFile.has(e.file))
+                byFile.set(e.file, []);
+            byFile.get(e.file).push(e);
+        }
+        const report = [
+            `# 💀 Dead Export Necromancer`,
+            `Exports totales: ${allExports.length} | Exports muertos: ${deadExports.length} | ~${estimatedWastedTokens} tokens desperdiciados en contexto`,
+            ``,
+            `## 🪦 Código zombie por archivo:`,
+            [...byFile.entries()]
+                .sort((a, b) => b[1].length - a[1].length)
+                .map(([file, exports]) => `### ${file} (${exports.length} exports muertos)\n` +
+                exports.map(e => `  💀 \`${e.name}\` [${e.kind}] — línea ${e.line}`).join("\n"))
+                .join("\n\n"),
+            ``,
+            `## 💡 Recomendación:`,
+            `Eliminar estos ${deadExports.length} exports muertos liberaría ~${estimatedWastedTokens} tokens de contexto por sesión.`,
+            `Verifica que no sean parte de la API pública del paquete antes de eliminar.`,
+        ].join("\n");
+        return { content: [{ type: "text", text: report }] };
+    }
+    catch (err) {
+        logError("dead_export_necromancer", err);
+        return { content: [{ type: "text", text: `Dead export necromancer failed: ${err.message}` }] };
+    }
+}
 //# sourceMappingURL=tools.js.map