@nxuss/lemma 1.0.2 → 1.0.4

package/dist/esm/mcp/tools.js

@@ -136,6 +136,18 @@ const toolDefinitions = [
             required: ["filePath", "content"],
         },
     },
+    {
+        name: "create_workspace_file",
+        description: "Create a NEW file in the workspace. Fails immediately if the file already exists — use write_workspace_file or apply_workspace_patch to modify existing files. Creates parent directories automatically. Returns a minimal token-free ACK: no file content is echoed back, saving provider output tokens.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root for the new file" },
+                content: { type: "string", description: "The complete initial content for the new file" },
+            },
+            required: ["filePath", "content"],
+        },
+    },
     {
         name: "apply_workspace_patch",
         description: "Apply a smart search-and-replace patch to an existing file. Safe against duplicate matches.",
@@ -596,6 +608,172 @@ const toolDefinitions = [
             required: ["operation", "from", "to"],
         },
     },
+    {
+        name: "smart_file_slice",
+        description: "Read only the lines semánticamente relevantes around a search query in a file, avoiding sending the entire file context. Returns lines around the matches.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" },
+                query: { type: "string", description: "The term or pattern to look for" },
+                windowLines: { type: "number", description: "Number of lines of context around each match (default: 10)", default: 10 }
+            },
+            required: ["filePath", "query"]
+        }
+    },
+    {
+        name: "test_oracle",
+        description: "Execute unit tests locally and output ONLY the failing tests and compressed stack traces, keeping context clean.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "Test execution command (default: 'npm test')", default: "npm test" }
+            }
+        }
+    },
+    {
+        name: "schema_extract",
+        description: "Extract high-level schemas, Zod types, interfaces, or database models from a file using the TypeScript AST, removing all implementation code.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" }
+            },
+            required: ["filePath"]
+        }
+    },
+    {
+        name: "changelog_auto",
+        description: "Generate a clean, token-efficient changelog summary from git logs based on Conventional Commits.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: { type: "number", description: "Number of git commits to analyze (default: 30)", default: 30 }
+            }
+        }
+    },
+    {
+        name: "spec_to_stub",
+        description: "Parse a TypeScript interface/type definition from a file and output a template mock/stub object configuration using pure AST analysis.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" },
+                symbolName: { type: "string", description: "Name of the interface or type alias to stub" }
+            },
+            required: ["filePath", "symbolName"]
+        }
+    },
+    {
+        name: "env_snapshot",
+        description: "Capture environmental state like Node version, dependencies in package.json, and variables declared in .env files (hiding actual values/credentials).",
+        inputSchema: {
+            type: "object",
+            properties: {}
+        }
+    },
+    {
+        name: "migration_tracer",
+        description: "Inspect changes in database schemas (tables, columns) across local migrations (e.g. Prisma migration directories).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                migrationsPath: { type: "string", description: "Path to migrations folder relative to workspace root (default: 'prisma/migrations')", default: "prisma/migrations" }
+            }
+        }
+    },
+    {
+        name: "multi_file_patch",
+        description: "Apply search-and-replace patches to multiple workspace files in a single turn. Decreases round-trips for multi-file refactoring.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                patches: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            filePath: { type: "string", description: "Path relative to the project root" },
+                            searchContent: { type: "string", description: "The exact block of code to search for" },
+                            replaceContent: { type: "string", description: "The block of code to replace it with" }
+                        },
+                        required: ["filePath", "searchContent", "replaceContent"]
+                    },
+                    description: "List of file patches to apply"
+                },
+                dryRun: { type: "boolean", description: "If true, returns preview diffs without modifying files", default: false }
+            },
+            required: ["patches"]
+        }
+    },
+    {
+        name: "file_intent_index",
+        description: "Map and index files inside the workspace by domain intent (e.g., auth, billing, routes, config) to speed up navigation.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                dirPath: { type: "string", description: "Target directory relative to project root (default: '')", default: "" }
+            }
+        }
+    },
+    {
+        name: "cognitive_map",
+        description: "Access and interact with the Auto-Cognitive Mind Map of the workspace (persisted globally). Holds structured high-level system domains, patterns, decisions, and bugs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["build", "get", "query", "update", "file_context"], description: "Action to perform", default: "get" },
+                domain: { type: "string", description: "Target domain for 'query' or 'update'" },
+                filePath: { type: "string", description: "Target file path for 'file_context'" },
+                updates: {
+                    type: "object",
+                    properties: {
+                        patterns: { type: "array", items: { type: "string" } },
+                        knownBugs: { type: "array", items: { type: "string" } },
+                        decisions: { type: "array", items: { type: "string" } }
+                    },
+                    description: "Metadata to append/merge into the specified domain"
+                }
+            },
+            required: ["action"]
+        }
+    },
+    {
+        name: "semantic_grep",
+        description: "Search the codebase for conceptual terms using natural language and BM25 token relevance instead of exact substring matching.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Natural language concept to search (e.g., 'jwt timeout expiration')" },
+                dirPath: { type: "string", description: "Limit search to folder path (default: '')", default: "" },
+                limit: { type: "number", description: "Maximum file matches (default: 5)", default: 5 }
+            },
+            required: ["query"]
+        }
+    },
+    {
+        name: "imports_skeleton_resolver",
+        description: "Resolve all imported local files inside a file and print only their signatures (classes, functions, interfaces) in a consolidated view.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path to the target file relative to project root" }
+            },
+            required: ["filePath"]
+        }
+    },
+    {
+        name: "ast_flow_visualizer",
+        description: "Analyze a function's control flow statements (ifs, loops, try/catch) inside a file using AST compilation and output a visual flowchart in Mermaid syntax.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path to the target file relative to project root" },
+                functionName: { type: "string", description: "Name of the function or method to visualize" }
+            },
+            required: ["filePath", "functionName"]
+        }
+    }
 ];
 const toolHandlers = {
     scrub_privacy: handleScrubPrivacy,
@@ -605,6 +783,7 @@ const toolHandlers = {
     auto_heal: handleAutoHeal,
     read_workspace_file: handleReadWorkspaceFile,
     write_workspace_file: handleWriteWorkspaceFile,
+    create_workspace_file: handleCreateWorkspaceFile,
     apply_workspace_patch: handleApplyWorkspacePatch,
     run_workspace_command: handleRunWorkspaceCommand,
     list_workspace_dir: handleListWorkspaceDir,
@@ -641,6 +820,19 @@ const toolHandlers = {
     generate_pr_workflow: handleGeneratePRWorkflow,
     depgraph: handleDepgraph,
     refactor: handleRefactor,
+    smart_file_slice: handleSmartFileSlice,
+    test_oracle: handleTestOracle,
+    schema_extract: handleSchemaExtract,
+    changelog_auto: handleChangelogAuto,
+    spec_to_stub: handleSpecToStub,
+    env_snapshot: handleEnvSnapshot,
+    migration_tracer: handleMigrationTracer,
+    multi_file_patch: handleMultiFilePatch,
+    file_intent_index: handleFileIntentIndex,
+    cognitive_map: handleCognitiveMap,
+    semantic_grep: handleSemanticGrep,
+    imports_skeleton_resolver: handleImportsSkeletonResolver,
+    ast_flow_visualizer: handleAstFlowVisualizer,
 };
 export function setupToolsHandlers(server, onToolCall) {
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -845,6 +1037,31 @@ async function handleWriteWorkspaceFile(args) {
         return { content: [{ type: "text", text: `Error writing file: ${err.message}` }] };
     }
 }
+// ── Create Workspace File (zero-token ACK) ───────────────────────────
+async function handleCreateWorkspaceFile(args) {
+    const filePath = args?.filePath;
+    const content = args?.content;
+    if (!filePath || content === undefined)
+        throw new Error("filePath and content are required");
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, filePath);
+        if (fs.existsSync(resolved)) {
+            return { content: [{ type: "text", text: `Error: File already exists at ${filePath}. Use write_workspace_file or apply_workspace_patch to modify it.` }] };
+        }
+        const dir = path.dirname(resolved);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(resolved, content, "utf8");
+        // Minimal ACK — no content echoed back to save provider output tokens
+        return { content: [{ type: "text", text: `OK:created:${filePath}` }] };
+    }
+    catch (err) {
+        logError("create_workspace_file", err);
+        return { content: [{ type: "text", text: `Error creating file: ${err.message}` }] };
+    }
+}
 async function handleApplyWorkspacePatch(args) {
     const filePath = args?.filePath;
     const searchContent = args?.searchContent;
@@ -3466,4 +3683,762 @@ async function handleLocalSemanticAutofix(args) {
         };
     }
 }
+// ── Smart File Slice ────────────────────────────────────────────────
+async function handleSmartFileSlice(args) {
+    const filePath = args.filePath;
+    const query = args.query;
+    const windowLines = typeof args.windowLines === "number" ? args.windowLines : 10;
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, filePath);
+        const content = fs.readFileSync(resolved, "utf8");
+        const lines = content.split("\n");
+        const matchedIndices = [];
+        const lowerQuery = query.toLowerCase();
+        lines.forEach((line, index) => {
+            if (line.toLowerCase().includes(lowerQuery)) {
+                matchedIndices.push(index);
+            }
+        });
+        if (matchedIndices.length === 0) {
+            return { content: [{ type: "text", text: `No matches found in ${filePath} for "${query}"` }] };
+        }
+        // Merge overlapping windows
+        const windows = [];
+        matchedIndices.forEach((idx) => {
+            const start = Math.max(0, idx - windowLines);
+            const end = Math.min(lines.length - 1, idx + windowLines);
+            if (windows.length > 0 && windows[windows.length - 1].end >= start) {
+                windows[windows.length - 1].end = Math.max(windows[windows.length - 1].end, end);
+            }
+            else {
+                windows.push({ start, end });
+            }
+        });
+        let resultText = `Slicing ${filePath} around query "${query}":\n\n`;
+        windows.forEach((win, index) => {
+            if (index > 0)
+                resultText += "\n... [omitted] ...\n\n";
+            for (let i = win.start; i <= win.end; i++) {
+                resultText += `${i + 1}: ${lines[i]}\n`;
+            }
+        });
+        return { content: [{ type: "text", text: resultText }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error slicing file: ${e.message}` }] };
+    }
+}
+// ── Test Oracle ──────────────────────────────────────────────────────
+async function handleTestOracle(args) {
+    const command = args.command || "npm test";
+    const workspaceRoot = process.cwd();
+    // Run tests, check errors
+    try {
+        const out = execSync(command, { cwd: workspaceRoot, encoding: "utf8", timeout: 30000 });
+        return { content: [{ type: "text", text: `All tests passed!\n\nOutput:\n${out.substring(0, 1000)}` }] };
+    }
+    catch (e) {
+        const stdout = e.stdout || "";
+        const stderr = e.stderr || e.message || "";
+        // Attempt to parse only failures/stack traces
+        const failureLines = (stdout + "\n" + stderr)
+            .split("\n")
+            .filter((l) => l.includes("fail") || l.includes("Error") || l.includes("at ") || l.includes("✗") || l.includes("Stack"));
+        const summary = failureLines.slice(0, 80).join("\n") || `Test execution failed:\n${stdout.substring(0, 800)}\n${stderr.substring(0, 800)}`;
+        return { content: [{ type: "text", text: `Tests Failed. Compressed failures:\n\n${summary}` }] };
+    }
+}
+// ── Schema Extract ───────────────────────────────────────────────────
+async function handleSchemaExtract(args) {
+    const filePath = args.filePath;
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, filePath);
+        const content = fs.readFileSync(resolved, "utf8");
+        const sourceFile = ts.createSourceFile(resolved, content, ts.ScriptTarget.Latest, true);
+        const schemas = [];
+        function visit(node) {
+            if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node)) {
+                // Grab declarations without implementation details or method bodies
+                const printer = ts.createPrinter({ removeComments: true });
+                const printed = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+                schemas.push(printed);
+            }
+            else if (ts.isVariableStatement(node)) {
+                // Look for schema variables like Zod schemas: const userSchema = z.object(...)
+                for (const decl of node.declarationList.declarations) {
+                    if (decl.name && ts.isIdentifier(decl.name) && decl.name.text.toLowerCase().includes("schema")) {
+                        const printer = ts.createPrinter({ removeComments: true });
+                        const printed = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+                        schemas.push(printed);
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+        if (schemas.length === 0) {
+            // Fallback: search lines for Zod schema or interfaces
+            const lines = content.split("\n").filter(l => l.includes("interface ") || l.includes("type ") || l.includes("enum ") || l.includes("Schema ="));
+            return { content: [{ type: "text", text: `No high-level AST schema declarations found. High level declarations:\n\n${lines.join("\n")}` }] };
+        }
+        return { content: [{ type: "text", text: schemas.join("\n\n") }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Schema extraction failed: ${e.message}` }] };
+    }
+}
+// ── Changelog Auto ───────────────────────────────────────────────────
+async function handleChangelogAuto(args) {
+    const limit = typeof args.limit === "number" ? args.limit : 30;
+    const workspaceRoot = process.cwd();
+    try {
+        const log = execSync(`git log -n ${limit} --oneline`, { cwd: workspaceRoot, encoding: "utf8" });
+        const commits = log.split("\n").filter(Boolean);
+        const feats = [];
+        const fixes = [];
+        const chore = [];
+        const docs = [];
+        const refactors = [];
+        const others = [];
+        commits.forEach((c) => {
+            const message = c.substring(8); // Strip hash
+            if (message.startsWith("feat"))
+                feats.push(c);
+            else if (message.startsWith("fix"))
+                fixes.push(c);
+            else if (message.startsWith("chore"))
+                chore.push(c);
+            else if (message.startsWith("docs"))
+                docs.push(c);
+            else if (message.startsWith("refactor"))
+                refactors.push(c);
+            else
+                others.push(c);
+        });
+        let output = `## Git Changelog (Last ${limit} commits)\n\n`;
+        if (feats.length)
+            output += `### 🚀 Features\n${feats.map(x => `- ${x}`).join("\n")}\n\n`;
+        if (fixes.length)
+            output += `### 🐛 Bug Fixes\n${fixes.map(x => `- ${x}`).join("\n")}\n\n`;
+        if (refactors.length)
+            output += `### 🛠️ Refactoring\n${refactors.map(x => `- ${x}`).join("\n")}\n\n`;
+        if (docs.length)
+            output += `### 📝 Documentation\n${docs.map(x => `- ${x}`).join("\n")}\n\n`;
+        if (chore.length)
+            output += `### 🧰 Chores\n${chore.map(x => `- ${x}`).join("\n")}\n\n`;
+        if (others.length)
+            output += `### 📦 General\n${others.map(x => `- ${x}`).join("\n")}\n`;
+        return { content: [{ type: "text", text: output }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Changelog generation failed: ${e.message}` }] };
+    }
+}
+// ── Spec to Stub ─────────────────────────────────────────────────────
+async function handleSpecToStub(args) {
+    const filePath = args.filePath;
+    const symbolName = args.symbolName;
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, filePath);
+        const content = fs.readFileSync(resolved, "utf8");
+        const sourceFile = ts.createSourceFile(resolved, content, ts.ScriptTarget.Latest, true);
+        let stub = null;
+        function visit(node) {
+            if (ts.isInterfaceDeclaration(node) && node.name.text === symbolName) {
+                stub = {};
+                for (const member of node.members) {
+                    if (ts.isPropertySignature(member) && member.name) {
+                        const nameText = member.name.getText(sourceFile);
+                        const typeText = member.type ? member.type.getText(sourceFile) : "any";
+                        stub[nameText] = typeText === "number" ? 0 : typeText === "boolean" ? false : typeText === "string" ? '""' : "{}";
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+        if (!stub) {
+            return { content: [{ type: "text", text: `Symbol ${symbolName} not found in ${filePath} as a parseable Interface.` }] };
+        }
+        const mockStr = `const mock${symbolName}: ${symbolName} = ${JSON.stringify(stub, null, 2).replace(/"(0|false|""|{})"/g, "$1")};`;
+        return { content: [{ type: "text", text: mockStr }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Stub generation failed: ${e.message}` }] };
+    }
+}
+// ── Env Snapshot ─────────────────────────────────────────────────────
+async function handleEnvSnapshot(_args) {
+    const workspaceRoot = process.cwd();
+    try {
+        let nodeVersion = "unknown";
+        try {
+            nodeVersion = execSync("node -v", { encoding: "utf8" }).trim();
+        }
+        catch { }
+        let npmVersion = "unknown";
+        try {
+            npmVersion = execSync("npm -v", { encoding: "utf8" }).trim();
+        }
+        catch { }
+        const pkgPath = path.join(workspaceRoot, "package.json");
+        let deps = {};
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        }
+        // Read any .env files, extract only keys
+        const envKeys = [];
+        const envPath = path.join(workspaceRoot, ".env");
+        if (fs.existsSync(envPath)) {
+            const lines = fs.readFileSync(envPath, "utf8").split("\n");
+            lines.forEach((l) => {
+                const match = l.match(/^\s*([A-Za-z0-9_]+)\s*=/);
+                if (match)
+                    envKeys.push(match[1]);
+            });
+        }
+        const report = {
+            runtime: { node: nodeVersion, npm: npmVersion },
+            dependencies: deps,
+            envVariablesPresent: envKeys
+        };
+        return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Environment snapshot failed: ${e.message}` }] };
+    }
+}
+// ── Migration Tracer ─────────────────────────────────────────────────
+async function handleMigrationTracer(args) {
+    const migrationsPath = args.migrationsPath || "prisma/migrations";
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, migrationsPath);
+        if (!fs.existsSync(resolved)) {
+            return { content: [{ type: "text", text: `Migrations folder not found at ${migrationsPath}` }] };
+        }
+        const subdirs = fs.readdirSync(resolved, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name)
+            .sort();
+        if (subdirs.length === 0) {
+            return { content: [{ type: "text", text: `No migrations found in ${migrationsPath}` }] };
+        }
+        let summary = `Detected ${subdirs.length} migrations in ${migrationsPath}:\n\n`;
+        for (const dir of subdirs.slice(-5)) { // trace the last 5
+            summary += `Migration: ${dir}\n`;
+            const migrationSql = path.join(resolved, dir, "migration.sql");
+            if (fs.existsSync(migrationSql)) {
+                const sql = fs.readFileSync(migrationSql, "utf8");
+                // Extract create table or alter table statements
+                const actions = sql.split("\n")
+                    .map(l => l.trim())
+                    .filter(l => l.toLowerCase().startsWith("create table") || l.toLowerCase().startsWith("alter table") || l.toLowerCase().startsWith("drop table"));
+                summary += actions.map(act => `  - ${act}`).join("\n") + "\n";
+            }
+        }
+        return { content: [{ type: "text", text: summary }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Migration tracing failed: ${e.message}` }] };
+    }
+}
+// ── Multi File Patch ─────────────────────────────────────────────────
+async function handleMultiFilePatch(args) {
+    const patches = args.patches;
+    const dryRun = !!args.dryRun;
+    if (!patches || !Array.isArray(patches)) {
+        throw new Error("patches array is required");
+    }
+    const workspaceRoot = process.cwd();
+    const reports = [];
+    try {
+        for (const patch of patches) {
+            const { resolved } = safeResolvePath(workspaceRoot, patch.filePath);
+            if (!fs.existsSync(resolved)) {
+                reports.push(`❌ ${patch.filePath}: File does not exist`);
+                continue;
+            }
+            const content = fs.readFileSync(resolved, "utf8");
+            const idx = content.indexOf(patch.searchContent);
+            if (idx === -1) {
+                reports.push(`❌ ${patch.filePath}: Search content not found`);
+                continue;
+            }
+            if (content.indexOf(patch.searchContent, idx + 1) !== -1) {
+                reports.push(`❌ ${patch.filePath}: Multiple occurrences of search content`);
+                continue;
+            }
+            if (!dryRun) {
+                const updated = content.replace(patch.searchContent, patch.replaceContent);
+                fs.writeFileSync(resolved, updated, "utf8");
+                reports.push(`✅ ${patch.filePath}: Applied successfully`);
+            }
+            else {
+                reports.push(`🔍 ${patch.filePath}: Match found (dry-run mode)`);
+            }
+        }
+        return { content: [{ type: "text", text: reports.join("\n") }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Multi-patch failed: ${e.message}` }] };
+    }
+}
+// ── File Intent Index ────────────────────────────────────────────────
+async function handleFileIntentIndex(args) {
+    const dirPath = args.dirPath || "";
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, dirPath);
+        const files = listDirRecursive(resolved, dirPath, 1, 4);
+        const categories = {
+            config: [],
+            routing: [],
+            schemas: [],
+            mcp: [],
+            security: [],
+            subconscious: [],
+            others: []
+        };
+        files.forEach((f) => {
+            const lower = f.toLowerCase();
+            if (lower.includes("config") || lower.endsWith(".json") || lower.includes("tsconfig")) {
+                categories.config.push(f);
+            }
+            else if (lower.includes("route") || lower.includes("proxy") || lower.includes("controller")) {
+                categories.routing.push(f);
+            }
+            else if (lower.includes("schema") || lower.includes("type") || lower.includes("model")) {
+                categories.schemas.push(f);
+            }
+            else if (lower.includes("mcp") || lower.includes("tool")) {
+                categories.mcp.push(f);
+            }
+            else if (lower.includes("security") || lower.includes("scrub") || lower.includes("encrypt")) {
+                categories.security.push(f);
+            }
+            else if (lower.includes("subconscious") || lower.includes("brain") || lower.includes("memory")) {
+                categories.subconscious.push(f);
+            }
+            else {
+                categories.others.push(f);
+            }
+        });
+        let summary = `### Workspace File Intent Index:\n\n`;
+        for (const [cat, list] of Object.entries(categories)) {
+            if (list.length > 0) {
+                summary += `📁 **${cat.toUpperCase()}**\n${list.slice(0, 15).map(x => `  - ${x}`).join("\n")}\n\n`;
+            }
+        }
+        return { content: [{ type: "text", text: summary }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Intent indexing failed: ${e.message}` }] };
+    }
+}
+const COG_MAP_FILE = path.join(os.homedir(), ".lemma-cache", "cog_map.json");
+async function handleCognitiveMap(args) {
+    const action = args.action;
+    const domain = args.domain;
+    const filePath = args.filePath;
+    const updates = args.updates;
+    const workspaceRoot = process.cwd();
+    // Helper to load map
+    const loadMap = () => {
+        if (fs.existsSync(COG_MAP_FILE)) {
+            try {
+                return JSON.parse(fs.readFileSync(COG_MAP_FILE, "utf8"));
+            }
+            catch { }
+        }
+        return { workspace: path.basename(workspaceRoot), lastBuilt: new Date().toISOString(), nodes: {} };
+    };
+    // Helper to save map
+    const saveMap = (m) => {
+        const dir = path.dirname(COG_MAP_FILE);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(COG_MAP_FILE, JSON.stringify(m, null, 2), "utf8");
+    };
+    const map = loadMap();
+    switch (action) {
+        case "build": {
+            // Automatically scan the workspace recursively to populate the Cognitive Map
+            const files = listDirRecursive(workspaceRoot, "", 1, 3).filter(f => f.endsWith(".ts") || f.endsWith(".js"));
+            const nodes = {};
+            files.forEach((f) => {
+                // Group files by domain intent
+                let dom = "general";
+                if (f.includes("mcp"))
+                    dom = "mcp";
+                else if (f.includes("subconscious") || f.includes("brain"))
+                    dom = "memory";
+                else if (f.includes("security") || f.includes("scrubber"))
+                    dom = "security";
+                else if (f.includes("pr-review"))
+                    dom = "pr-review";
+                else if (f.includes("utils"))
+                    dom = "utils";
+                if (!nodes[dom]) {
+                    nodes[dom] = { domain: dom, files: [], patterns: [], knownBugs: [], decisions: [], symbols: [] };
+                }
+                nodes[dom].files.push(f);
+                // Simple AST parsing to retrieve export symbols
+                try {
+                    const fullPath = path.resolve(workspaceRoot, f);
+                    const src = fs.readFileSync(fullPath, "utf8");
+                    const sf = ts.createSourceFile(fullPath, src, ts.ScriptTarget.Latest, true);
+                    ts.forEachChild(sf, (node) => {
+                        if ((ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isFunctionDeclaration(node)) && node.name) {
+                            nodes[dom].symbols.push(node.name.text);
+                        }
+                    });
+                }
+                catch { }
+            });
+            // Preserve previously manually enriched patterns/knownBugs/decisions
+            for (const [dom, node] of Object.entries(nodes)) {
+                if (map.nodes[dom]) {
+                    node.patterns = [...new Set([...node.patterns, ...map.nodes[dom].patterns])];
+                    node.knownBugs = [...new Set([...node.knownBugs, ...map.nodes[dom].knownBugs])];
+                    node.decisions = [...new Set([...node.decisions, ...map.nodes[dom].decisions])];
+                }
+            }
+            map.nodes = nodes;
+            map.lastBuilt = new Date().toISOString();
+            saveMap(map);
+            return { content: [{ type: "text", text: `Cognitive Map successfully built with ${Object.keys(nodes).length} domains.` }] };
+        }
+        case "get": {
+            return { content: [{ type: "text", text: JSON.stringify(map, null, 2) }] };
+        }
+        case "query": {
+            if (!domain || !map.nodes[domain]) {
+                return { content: [{ type: "text", text: `Domain "${domain}" not found in Cognitive Map.` }] };
+            }
+            return { content: [{ type: "text", text: JSON.stringify(map.nodes[domain], null, 2) }] };
+        }
+        case "update": {
+            if (!domain)
+                throw new Error("domain is required for update action");
+            if (!map.nodes[domain]) {
+                map.nodes[domain] = { domain, files: [], patterns: [], knownBugs: [], decisions: [], symbols: [] };
+            }
+            const node = map.nodes[domain];
+            if (updates) {
+                if (Array.isArray(updates.patterns))
+                    node.patterns = [...new Set([...node.patterns, ...updates.patterns])];
+                if (Array.isArray(updates.knownBugs))
+                    node.knownBugs = [...new Set([...node.knownBugs, ...updates.knownBugs])];
+                if (Array.isArray(updates.decisions))
+                    node.decisions = [...new Set([...node.decisions, ...updates.decisions])];
+            }
+            saveMap(map);
+            return { content: [{ type: "text", text: `Cognitive Map domain "${domain}" updated successfully.` }] };
+        }
+        case "file_context": {
+            if (!filePath)
+                throw new Error("filePath is required for file_context action");
+            const norm = filePath.replace(/^\//, "");
+            let foundDomain = null;
+            for (const node of Object.values(map.nodes)) {
+                if (node.files.includes(norm)) {
+                    foundDomain = node;
+                    break;
+                }
+            }
+            if (!foundDomain) {
+                return { content: [{ type: "text", text: `No specific domain found for file "${filePath}".` }] };
+            }
+            return { content: [{ type: "text", text: JSON.stringify(foundDomain, null, 2) }] };
+        }
+        default:
+            throw new Error(`Unknown action: ${action}`);
+    }
+}
+// ── Semantic Grep ───────────────────────────────────────────────────
+async function handleSemanticGrep(args) {
+    const query = args.query;
+    const dirPath = args.dirPath || "";
+    const limit = typeof args.limit === "number" ? args.limit : 5;
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, dirPath);
+        const files = listDirRecursive(resolved, dirPath, 1, 4)
+            .filter(f => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".json") || f.endsWith(".md"));
+        const queryTokens = query.toLowerCase()
+            .replace(/([a-z])([A-Z])/g, '$1 $2')
+            .replace(/[_\-]/g, ' ')
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(t => t.length >= 2);
+        if (queryTokens.length === 0) {
+            return { content: [{ type: "text", text: "Query does not contain searchable tokens." }] };
+        }
+        const scoredFiles = [];
+        files.forEach((f) => {
+            try {
+                const fullPath = path.resolve(workspaceRoot, f);
+                const content = fs.readFileSync(fullPath, "utf8");
+                const lines = content.split("\n");
+                const fileLower = content.toLowerCase();
+                let tokenMatches = 0;
+                queryTokens.forEach(t => {
+                    if (fileLower.includes(t))
+                        tokenMatches++;
+                });
+                if (tokenMatches > 0) {
+                    const matchedLines = [];
+                    lines.forEach((line, idx) => {
+                        const lineLower = line.toLowerCase();
+                        const matchesQuery = queryTokens.some(t => lineLower.includes(t));
+                        if (matchesQuery && matchedLines.length < 3) {
+                            matchedLines.push(`  L${idx + 1}: ${line.trim()}`);
+                        }
+                    });
+                    // simple score calculation based on percentage match + file hits
+                    const score = tokenMatches / queryTokens.length;
+                    scoredFiles.push({ filePath: f, score, matchedLines });
+                }
+            }
+            catch { }
+        });
+        // Sort by score desc
+        scoredFiles.sort((a, b) => b.score - a.score);
+        const topMatches = scoredFiles.slice(0, limit);
+        if (topMatches.length === 0) {
+            return { content: [{ type: "text", text: `No relevant files found matching concept: "${query}"` }] };
+        }
+        let summary = `### Semantic Grep matches for "${query}":\n\n`;
+        topMatches.forEach((m, idx) => {
+            summary += `🎯 **[${idx + 1}] ${m.filePath}** (Relevance: ${(m.score * 100).toFixed(0)}%)\n`;
+            summary += m.matchedLines.join("\n") + "\n\n";
+        });
+        return { content: [{ type: "text", text: summary }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Semantic grep failed: ${e.message}` }] };
+    }
+}
+// ── Imports Skeleton Resolver ───────────────────────────────────────
+async function handleImportsSkeletonResolver(args) {
+    const filePath = args.filePath;
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, filePath);
+        const content = fs.readFileSync(resolved, "utf8");
+        const sourceFile = ts.createSourceFile(resolved, content, ts.ScriptTarget.Latest, true);
+        const importDeclarations = [];
+        ts.forEachChild(sourceFile, (node) => {
+            if (ts.isImportDeclaration(node)) {
+                importDeclarations.push(node);
+            }
+        });
+        if (importDeclarations.length === 0) {
+            return { content: [{ type: "text", text: `No import statements found in ${filePath}.` }] };
+        }
+        let output = `# Import reference signatures for \`${filePath}\`:\n\n`;
+        let foundImportsCount = 0;
+        for (const imp of importDeclarations) {
+            const moduleSpec = imp.moduleSpecifier.getText(sourceFile).replace(/['"]/g, "");
+            // Skip node_modules/external library imports
+            if (moduleSpec.startsWith(".") || moduleSpec.startsWith("/")) {
+                foundImportsCount++;
+                const targetPath = path.resolve(path.dirname(resolved), moduleSpec);
+                // Find matching file path with ts/js extensions
+                let matchPath = "";
+                const extensions = [".ts", ".tsx", ".d.ts", ".js", ".jsx"];
+                if (fs.existsSync(targetPath) && fs.statSync(targetPath).isFile()) {
+                    matchPath = targetPath;
+                }
+                else {
+                    for (const ext of extensions) {
+                        if (fs.existsSync(targetPath + ext)) {
+                            matchPath = targetPath + ext;
+                            break;
+                        }
+                    }
+                }
+                if (matchPath) {
+                    const relMatchPath = path.relative(workspaceRoot, matchPath);
+                    output += `## 📦 Signatures from: \`${relMatchPath}\` (imported via \`${moduleSpec}\`)\n`;
+                    try {
+                        const importContent = fs.readFileSync(matchPath, "utf8");
+                        const importSourceFile = ts.createSourceFile(matchPath, importContent, ts.ScriptTarget.Latest, true);
+                        const exportedSignatures = [];
+                        // Simple AST traverse to collect exported signatures
+                        ts.forEachChild(importSourceFile, (node) => {
+                            const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+                            const isExported = mods?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                            if (isExported) {
+                                if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node)) {
+                                    const printer = ts.createPrinter({ removeComments: true });
+                                    // Strip method body implementation code where applicable
+                                    const printed = printer.printNode(ts.EmitHint.Unspecified, node, importSourceFile);
+                                    exportedSignatures.push(printed);
+                                }
+                                else if (ts.isFunctionDeclaration(node)) {
+                                    // Print just the header/signature of the function
+                                    const printer = ts.createPrinter({ removeComments: true });
+                                    const printed = printer.printNode(ts.EmitHint.Unspecified, node, importSourceFile);
+                                    // Quick strip of function implementation body if present
+                                    const bodyIndex = printed.indexOf(" {");
+                                    if (bodyIndex !== -1) {
+                                        exportedSignatures.push(printed.substring(0, bodyIndex) + ";");
+                                    }
+                                    else {
+                                        exportedSignatures.push(printed);
+                                    }
+                                }
+                            }
+                        });
+                        if (exportedSignatures.length > 0) {
+                            output += "```typescript\n" + exportedSignatures.join("\n\n") + "\n```\n\n";
+                        }
+                        else {
+                            output += "*No public exported symbols found in this file.*\n\n";
+                        }
+                    }
+                    catch (e) {
+                        output += `*Failed to parse signatures: ${e.message}*\n\n`;
+                    }
+                }
+                else {
+                    output += `## 📦 Signatures from: \`${moduleSpec}\`\n*Local source file not found.*\n\n`;
+                }
+            }
+        }
+        if (foundImportsCount === 0) {
+            return { content: [{ type: "text", text: "No local imports detected." }] };
+        }
+        return { content: [{ type: "text", text: output }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Import resolution failed: ${e.message}` }] };
+    }
+}
+// ── AST Flow Visualizer ──────────────────────────────────────────────
+async function handleAstFlowVisualizer(args) {
+    const filePath = args.filePath;
+    const functionName = args.functionName;
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, filePath);
+        const content = fs.readFileSync(resolved, "utf8");
+        const sourceFile = ts.createSourceFile(resolved, content, ts.ScriptTarget.Latest, true);
+        let targetNode = null;
+        function findFunction(node) {
+            const nameText = (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) && node.name ? node.name.getText(sourceFile) : "";
+            if (nameText === functionName) {
+                targetNode = node;
+            }
+            else if (ts.isVariableDeclaration(node) && node.name && ts.isIdentifier(node.name) && node.name.text === functionName) {
+                if (node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+                    targetNode = node.initializer;
+                }
+            }
+            if (!targetNode) {
+                ts.forEachChild(node, findFunction);
+            }
+        }
+        findFunction(sourceFile);
+        if (!targetNode) {
+            return { content: [{ type: "text", text: `Function/Method "${functionName}" not found in file ${filePath}.` }] };
+        }
+        const bodyNode = targetNode.body;
+        if (!bodyNode) {
+            return { content: [{ type: "text", text: `Function "${functionName}" has no parseable implementation body.` }] };
+        }
+        // Traversal state
+        let mermaid = "flowchart TD\n";
+        let nodeId = 0;
+        function getNextId() {
+            return `node_${nodeId++}`;
+        }
+        function formatLabel(text) {
+            return text.trim()
+                .replace(/"/g, "'")
+                .replace(/[{}()]/g, "")
+                .substring(0, 55);
+        }
+        function traverse(n, parentId) {
+            if (ts.isIfStatement(n)) {
+                const condId = getNextId();
+                const condText = formatLabel(n.expression.getText(sourceFile));
+                mermaid += `  ${parentId} --> ${condId}{"if ${condText}"}\n`;
+                const thenId = getNextId();
+                mermaid += `  ${condId} -->|true| ${thenId}["then block"]\n`;
+                const lastThen = traverse(n.thenStatement, thenId);
+                const joinId = getNextId();
+                mermaid += `  ${joinId}(("join"))\n`;
+                mermaid += `  ${lastThen} --> ${joinId}\n`;
+                if (n.elseStatement) {
+                    const elseId = getNextId();
+                    mermaid += `  ${condId} -->|false| ${elseId}["else block"]\n`;
+                    const lastElse = traverse(n.elseStatement, elseId);
+                    mermaid += `  ${lastElse} --> ${joinId}\n`;
+                }
+                else {
+                    mermaid += `  ${condId} -->|false| ${joinId}\n`;
+                }
+                return joinId;
+            }
+            if (ts.isTryStatement(n)) {
+                const tryId = getNextId();
+                mermaid += `  ${parentId} --> ${tryId}["try block"]\n`;
+                const lastTry = traverse(n.tryBlock, tryId);
+                const joinId = getNextId();
+                mermaid += `  ${joinId}(("join"))\n`;
+                mermaid += `  ${lastTry} --> ${joinId}\n`;
+                if (n.catchClause) {
+                    const catchId = getNextId();
+                    mermaid += `  ${parentId} -.->|on error| ${catchId}["catch block"]\n`;
+                    const lastCatch = traverse(n.catchClause.block, catchId);
+                    mermaid += `  ${lastCatch} --> ${joinId}\n`;
+                }
+                return joinId;
+            }
+            if (ts.isForStatement(n) || ts.isForOfStatement(n) || ts.isForInStatement(n) || ts.isWhileStatement(n)) {
+                const loopId = getNextId();
+                const condText = ts.isWhileStatement(n)
+                    ? formatLabel(n.expression.getText(sourceFile))
+                    : "loop condition";
+                mermaid += `  ${parentId} --> ${loopId}{"loop: ${condText}"}\n`;
+                const bodyId = getNextId();
+                mermaid += `  ${loopId} -->|iterate| ${bodyId}["loop body"]\n`;
+                const lastBody = traverse(n.statement, bodyId);
+                mermaid += `  ${lastBody} --> ${loopId}\n`;
+                const endId = getNextId();
+                mermaid += `  ${loopId} -->|done| ${endId}(("end loop"))\n`;
+                return endId;
+            }
+            if (ts.isBlock(n)) {
+                let currentParent = parentId;
+                n.statements.forEach((stmt) => {
+                    currentParent = traverse(stmt, currentParent);
+                });
+                return currentParent;
+            }
+            const text = formatLabel(n.getText(sourceFile));
+            if (text.length > 0) {
+                const id = getNextId();
+                mermaid += `  ${parentId} --> ${id}["${text}"]\n`;
+                return id;
+            }
+            return parentId;
+        }
+        const startId = getNextId();
+        mermaid += `  ${startId}(("Start: ${functionName}"))\n`;
+        traverse(bodyNode, startId);
+        const wrappedMermaid = `\`\`\`mermaid\n${mermaid}\`\`\``;
+        return { content: [{ type: "text", text: `### Visual AST Flowchart for \`${functionName}\` inside \`${filePath}\`:\n\n${wrappedMermaid}` }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `AST flow visualization failed: ${e.message}` }] };
+    }
+}
 //# sourceMappingURL=tools.js.map