@nxuss/lemma 0.7.1 → 0.7.2

package/dist/esm/mcp/tools.js

@@ -0,0 +1,979 @@
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import os from "os";
+import axios from "axios";
+import * as ts from "typescript";
+import { SemanticScrubber } from "../security/SemanticScrubber";
+import { ComplexityRouter } from "../proxy/ComplexityRouter";
+import { squeezeCode, squeezePrompt } from "../utils/ContextSqueezer";
+import { reportSavings } from "../utils/reportSavings";
+import { getProxyPort, safeResolvePath, logError, logWarn, estimateTokensFromResult } from "./utils";
+const toolDefinitions = [
+    {
+        name: "scrub_privacy",
+        description: "Mask sensitive data (PII, API Keys, Credentials) from a text block using Lemma's Privacy Firewall.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: { type: "string", description: "The raw text to scrub" },
+            },
+            required: ["text"],
+        },
+    },
+    {
+        name: "search_memory",
+        description: "Search Lemma's semantic memory (The Brain) before answering technical questions. Retrieves past solutions, fixes, and context from ALL your projects globally. If similarity > 50%, use this answer directly.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "The natural language query" },
+                limit: { type: "number", description: "Maximum results to return", default: 5 },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "store_memory",
+        description: "Persist a technical solution, bug fix, architecture decision, or key fact into Lemma's Brain.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "The natural language query key" },
+                response: { type: "string", description: "The complete technical content to memorize" },
+                provider: { type: "string", description: "Optional model provider name", default: "generic" },
+            },
+            required: ["query", "response"],
+        },
+    },
+    {
+        name: "get_routing_advice",
+        description: "Analyzes a prompt and suggests the best model based on Lemma's Complexity Router.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: { type: "string", description: "The prompt to analyze" },
+                intended_model: { type: "string", description: "The model you were planning to use (e.g., gpt-4o)" },
+            },
+            required: ["prompt"],
+        },
+    },
+    {
+        name: "auto_heal",
+        description: "Diagnose and auto-heal the latest local server crash registered in Lemma's context logs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                apply: { type: "boolean", description: "Whether to apply the generated code fix directly", default: false },
+            },
+        },
+    },
+    {
+        name: "read_workspace_file",
+        description: "Read a file inside the workspace. Automatically compresses comments/whitespace and scrubs API keys.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" },
+                compact: { type: "boolean", description: "Whether to compress comments and whitespace", default: true },
+            },
+            required: ["filePath"],
+        },
+    },
+    {
+        name: "write_workspace_file",
+        description: "Write full contents to a file inside the workspace. Creates parent directories automatically.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" },
+                content: { type: "string", description: "The complete content to write" },
+            },
+            required: ["filePath", "content"],
+        },
+    },
+    {
+        name: "apply_workspace_patch",
+        description: "Apply a smart search-and-replace patch to an existing file. Safe against duplicate matches.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" },
+                searchContent: { type: "string", description: "The exact search block to find" },
+                replaceContent: { type: "string", description: "The replacement block" },
+            },
+            required: ["filePath", "searchContent", "replaceContent"],
+        },
+    },
+    {
+        name: "run_workspace_command",
+        description: "Execute a bash command in the workspace root. Maximum execution timeout of 15 seconds.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "The bash command to run" },
+            },
+            required: ["command"],
+        },
+    },
+    {
+        name: "list_workspace_dir",
+        description: "List files and subdirectories recursively to navigate the repository structure.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                dirPath: { type: "string", description: "Directory relative to project root", default: "" },
+                maxDepth: { type: "number", description: "Maximum recursion depth", default: 3 },
+            },
+        },
+    },
+    {
+        name: "search_workspace",
+        description: "Perform a fast local text search (grep) across all files in the project workspace.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "The keyword or text pattern to search for" },
+                extension: { type: "string", description: "Optional file extension filter (e.g., 'ts', 'json')" },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "squeeze_prompt",
+        description: "Compress code blocks, comments, and boilerplate in any prompt. Saves up to 80% tokens.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: { type: "string", description: "The raw prompt containing code blocks to squeeze" },
+                query: { type: "string", description: "Optional user's primary query to preserve relevant parts", default: "" },
+            },
+            required: ["prompt"],
+        },
+    },
+    {
+        name: "get_project_onboarding",
+        description: "Fetch dynamic architectural and stack overview of the current project in markdown.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "get_ast_hologram",
+        description: "Generate a dense, token-efficient Holographic AST Map of the workspace using the TypeScript compiler. Returns structured JSON of all exported symbols with file paths and line numbers.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                dirPath: { type: "string", description: "Directory to scan relative to workspace root", default: "" },
+                extensions: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "File extensions to scan",
+                    default: ["ts", "tsx", "js", "jsx"],
+                },
+            },
+        },
+    },
+    {
+        name: "validate_patch_sandbox",
+        description: "Validate proposed code in isolated sandbox via tsc + syntax check before applying.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Target file path relative to workspace root" },
+                patchedContent: { type: "string", description: "The complete proposed file content after patch" },
+            },
+            required: ["filePath", "patchedContent"],
+        },
+    },
+    {
+        name: "query_hybrid_consensus",
+        description: "Search The Brain before reasoning. Brain HIT returns cached answer instantly. Brain MISS proceeds to cloud.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "The technical question or task description" },
+                context: { type: "string", description: "Optional extra context" },
+                threshold: { type: "number", description: "Similarity threshold (0.0-1.0, default: 0.80)", default: 0.80 },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "get_telepathic_hints",
+        description: "Surface relevant past solutions from The Brain based on the active file path.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                activeFile: { type: "string", description: "Path of the file being edited" },
+                limit: { type: "number", description: "Maximum hints (default: 5)", default: 5 },
+            },
+            required: ["activeFile"],
+        },
+    },
+];
+const toolHandlers = {
+    scrub_privacy: handleScrubPrivacy,
+    search_memory: handleSearchMemory,
+    store_memory: handleStoreMemory,
+    get_routing_advice: handleGetRoutingAdvice,
+    auto_heal: handleAutoHeal,
+    read_workspace_file: handleReadWorkspaceFile,
+    write_workspace_file: handleWriteWorkspaceFile,
+    apply_workspace_patch: handleApplyWorkspacePatch,
+    run_workspace_command: handleRunWorkspaceCommand,
+    list_workspace_dir: handleListWorkspaceDir,
+    search_workspace: handleSearchWorkspace,
+    squeeze_prompt: handleSqueezePrompt,
+    get_project_onboarding: handleGetProjectOnboarding,
+    get_ast_hologram: handleGetAstHologram,
+    validate_patch_sandbox: handleValidatePatchSandbox,
+    query_hybrid_consensus: handleQueryHybridConsensus,
+    get_telepathic_hints: handleGetTelepathicHints,
+};
+export function setupToolsHandlers(server, onToolCall) {
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: toolDefinitions,
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const startTime = Date.now();
+        const handler = toolHandlers[name];
+        if (!handler) {
+            const latency = Date.now() - startTime;
+            onToolCall?.({
+                tool: name,
+                args: args || {},
+                result: "ERROR",
+                latency,
+                error: "Unknown tool",
+            });
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        try {
+            const result = await handler((args || {}));
+            onToolCall?.({
+                tool: name,
+                args: args || {},
+                result: "OK",
+                latency: Date.now() - startTime,
+                tokensImpact: estimateTokensFromResult(result),
+            });
+            return result;
+        }
+        catch (error) {
+            onToolCall?.({
+                tool: name,
+                args: args || {},
+                result: "ERROR",
+                latency: Date.now() - startTime,
+                error: error.message?.substring(0, 100) || "Unknown error",
+            });
+            throw error;
+        }
+    });
+}
+// ── Tool Implementations ────────────────────────────────────────────
+async function handleScrubPrivacy(args) {
+    const text = args?.text;
+    if (!text)
+        throw new Error("Text is required");
+    const scrubber = new SemanticScrubber();
+    const { maskedPrompt } = scrubber.mask(text);
+    return { content: [{ type: "text", text: maskedPrompt }] };
+}
+async function handleSearchMemory(args) {
+    const query = args?.query;
+    const limit = args?.limit || 5;
+    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 || [];
+        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)}`;
+        })
+            .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?` }] };
+    }
+}
+async function handleStoreMemory(args) {
+    const query = args?.query;
+    const responseText = args?.response;
+    const provider = args?.provider || "generic";
+    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 tokensSaved = Math.max(100, Math.floor(responseText.length / 4));
+        reportSavings({
+            source: "cache",
+            tokens: tokensSaved,
+            toolName: "store_memory",
+            query: query.substring(0, 100),
+        });
+        return { content: [{ type: "text", text: `Success: ${response.data.message}` }] };
+    }
+    catch (e) {
+        logError("store_memory", e);
+        return { content: [{ type: "text", text: `Failed to store memory in Lemma: ${e.message}. Is Lemma Proxy running?` }] };
+    }
+}
+async function handleGetRoutingAdvice(args) {
+    const prompt = args?.prompt;
+    const intendedModel = args?.intended_model;
+    const router = new ComplexityRouter();
+    const decision = router.evaluate(prompt, intendedModel);
+    if (decision.complexity === "low" && intendedModel && decision.model !== intendedModel) {
+        const estimatedPromptTokens = Math.floor((prompt?.length || 0) / 4);
+        reportSavings({
+            source: "complexityRouting",
+            tokens: Math.floor(estimatedPromptTokens * 0.8),
+            toolName: "get_routing_advice",
+            query: prompt?.substring(0, 100),
+        });
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Lemma Routing Advice: Use ${decision.model}. Reason: Complexity is ${decision.complexity}.`,
+            },
+        ],
+    };
+}
+async function handleAutoHeal(args) {
+    const apply = !!args?.apply;
+    try {
+        const { performAutoHeal: heal } = await import("../cli/lemma-proxy");
+        const res = await heal(apply);
+        return { content: [{ type: "text", text: JSON.stringify(res, null, 2) }] };
+    }
+    catch (e) {
+        logError("auto_heal", e);
+        return { content: [{ type: "text", text: `Auto-heal failed: ${e.message}` }] };
+    }
+}
+async function handleReadWorkspaceFile(args) {
+    const filePath = args?.filePath;
+    const compact = args?.compact !== false;
+    if (!filePath)
+        throw new Error("filePath is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, filePath);
+        let content = fs.readFileSync(resolved, "utf8");
+        const originalSize = content.length;
+        if (compact) {
+            content = squeezeCode(content);
+            if (content.length < originalSize) {
+                reportSavings({
+                    source: "contextSqueeze",
+                    charsBefore: originalSize,
+                    charsAfter: content.length,
+                    toolName: "read_workspace_file",
+                    filePath,
+                });
+            }
+        }
+        try {
+            const scrubber = new SemanticScrubber();
+            const { maskedPrompt } = scrubber.mask(content);
+            content = maskedPrompt;
+        }
+        catch (err) {
+            logWarn("read_workspace_file", "SemanticScrubber failed, returning raw content");
+        }
+        return { content: [{ type: "text", text: content }] };
+    }
+    catch (err) {
+        logError("read_workspace_file", err);
+        return { content: [{ type: "text", text: `Error reading file: ${err.message}` }] };
+    }
+}
+async function handleWriteWorkspaceFile(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);
+        const dir = path.dirname(resolved);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(resolved, content, "utf8");
+        return { content: [{ type: "text", text: `Success: Written file to ${filePath}` }] };
+    }
+    catch (err) {
+        logError("write_workspace_file", err);
+        return { content: [{ type: "text", text: `Error writing file: ${err.message}` }] };
+    }
+}
+async function handleApplyWorkspacePatch(args) {
+    const filePath = args?.filePath;
+    const searchContent = args?.searchContent;
+    const replaceContent = args?.replaceContent;
+    if (!filePath || !searchContent || replaceContent === undefined) {
+        throw new Error("filePath, searchContent, and replaceContent are required");
+    }
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, filePath);
+        if (!fs.existsSync(resolved)) {
+            return { content: [{ type: "text", text: `Error: File ${filePath} does not exist.` }] };
+        }
+        const originalContent = fs.readFileSync(resolved, "utf8");
+        const index = originalContent.indexOf(searchContent);
+        if (index === -1) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: Target search content not found in file. Make sure the search content matches exactly, including indentation, tabs, spaces, and newlines.`,
+                    },
+                ],
+            };
+        }
+        if (originalContent.indexOf(searchContent, index + 1) !== -1) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: Multiple matches found for the search content. Please provide a larger search block with unique surrounding context lines to make it unambiguous.`,
+                    },
+                ],
+            };
+        }
+        const updatedContent = originalContent.replace(searchContent, replaceContent);
+        fs.writeFileSync(resolved, updatedContent, "utf8");
+        return { content: [{ type: "text", text: `Success: Patch successfully applied to ${filePath}` }] };
+    }
+    catch (err) {
+        logError("apply_workspace_patch", err);
+        return { content: [{ type: "text", text: `Error applying patch: ${err.message}` }] };
+    }
+}
+async function handleRunWorkspaceCommand(args) {
+    const command = args?.command;
+    if (!command)
+        throw new Error("command is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const output = execSync(command, {
+            cwd: workspaceRoot,
+            encoding: "utf8",
+            timeout: 15000,
+            env: { ...process.env },
+        });
+        return { content: [{ type: "text", text: `Command completed successfully.\n\nOutput:\n${output}` }] };
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Command failed with exit code ${err.status || "unknown"}.\n\nStdout:\n${err.stdout || ""}\n\nStderr:\n${err.stderr || err.message || ""}`,
+                },
+            ],
+        };
+    }
+}
+function listDirRecursive(currentDir, relativePath, depth, maxDepth) {
+    if (depth > maxDepth)
+        return [];
+    try {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        let result = [];
+        for (const entry of entries) {
+            if (["node_modules", ".git", "dist", "chroma_data", ".lemma"].includes(entry.name))
+                continue;
+            const rel = relativePath ? path.join(relativePath, entry.name) : entry.name;
+            const full = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                result.push(`${rel}/`);
+                result.push(...listDirRecursive(full, rel, depth + 1, maxDepth));
+            }
+            else {
+                result.push(rel);
+            }
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}
+async function handleListWorkspaceDir(args) {
+    const dirPath = args?.dirPath || "";
+    const maxDepth = args?.maxDepth || 3;
+    const workspaceRoot = process.cwd();
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, dirPath);
+        const list = listDirRecursive(resolved, dirPath, 1, maxDepth);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: list.length > 0 ? list.join("\n") : "(Directory is empty or inaccessible)",
+                },
+            ],
+        };
+    }
+    catch (err) {
+        logError("list_workspace_dir", err);
+        return { content: [{ type: "text", text: `Error listing directory: ${err.message}` }] };
+    }
+}
+function searchDirRecursive(currentDir, relativePath, query, extFilter) {
+    try {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        let result = [];
+        for (const entry of entries) {
+            if (["node_modules", ".git", "dist", "chroma_data", ".lemma"].includes(entry.name))
+                continue;
+            const rel = relativePath ? path.join(relativePath, entry.name) : entry.name;
+            const full = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                result.push(...searchDirRecursive(full, rel, query, extFilter));
+            }
+            else {
+                if (extFilter && !entry.name.endsWith(`.${extFilter}`))
+                    continue;
+                try {
+                    const content = fs.readFileSync(full, "utf8");
+                    if (content.toLowerCase().includes(query.toLowerCase())) {
+                        const lines = content.split("\n");
+                        lines.forEach((lineText, idx) => {
+                            if (lineText.toLowerCase().includes(query.toLowerCase())) {
+                                result.push({ filePath: rel, line: idx + 1, text: lineText.trim() });
+                            }
+                        });
+                    }
+                }
+                catch { }
+            }
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}
+async function handleSearchWorkspace(args) {
+    const query = args?.query;
+    const extension = args?.extension;
+    if (!query)
+        throw new Error("query is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const results = searchDirRecursive(workspaceRoot, "", query, extension);
+        if (results.length === 0) {
+            return { content: [{ type: "text", text: `No matches found in the workspace for "${query}".` }] };
+        }
+        let formatted = results.map((r) => `[${r.filePath}:${r.line}] ${r.text}`).join("\n");
+        try {
+            const scrubber = new SemanticScrubber();
+            const { maskedPrompt } = scrubber.mask(formatted);
+            formatted = maskedPrompt;
+        }
+        catch (err) {
+            logWarn("search_workspace", "SemanticScrubber failed, returning raw results");
+        }
+        return {
+            content: [{ type: "text", text: `Found ${results.length} matches:\n\n${formatted}` }],
+        };
+    }
+    catch (err) {
+        logError("search_workspace", err);
+        return { content: [{ type: "text", text: `Error searching workspace: ${err.message}` }] };
+    }
+}
+async function handleSqueezePrompt(args) {
+    const promptArg = args?.prompt;
+    const queryArg = args?.query || "";
+    if (!promptArg)
+        throw new Error("prompt is required");
+    try {
+        const result = squeezePrompt(promptArg, queryArg);
+        if (result.originalSize > result.squeezedSize) {
+            reportSavings({
+                source: "contextSqueeze",
+                charsBefore: result.originalSize,
+                charsAfter: result.squeezedSize,
+                toolName: "squeeze_prompt",
+                query: queryArg?.substring(0, 100),
+            });
+        }
+        return { content: [{ type: "text", text: result.squeezed }] };
+    }
+    catch (err) {
+        logError("squeeze_prompt", err);
+        return { content: [{ type: "text", text: `Error squeezing prompt: ${err.message}` }] };
+    }
+}
+async function handleGetProjectOnboarding(_args) {
+    try {
+        const port = getProxyPort();
+        const response = await axios.get(`http://localhost:${port}/api/project/onboarding`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: response.data.markdown || "# Onboarding mental model could not be generated.",
+                },
+            ],
+        };
+    }
+    catch (error) {
+        logError("get_project_onboarding", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to fetch codebase onboarding mental model: ${error.message}. Is Lemma proxy running?`,
+                },
+            ],
+        };
+    }
+}
+function extractSymbolsWithTsCompiler(filePath, relPath) {
+    try {
+        const src = fs.readFileSync(filePath, "utf8");
+        const sourceFile = ts.createSourceFile(filePath, src, ts.ScriptTarget.Latest, true);
+        const symbols = [];
+        function visit(node) {
+            const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+            const isExport = mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+            if (isExport || ts.isSourceFile(node.parent)) {
+                if (ts.isFunctionDeclaration(node) && node.name) {
+                    symbols.push({
+                        kind: "function",
+                        name: node.name.text,
+                        file: relPath,
+                        line: sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1,
+                    });
+                }
+                else if ((ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) &&
+                    node.name) {
+                    symbols.push({
+                        kind: ts.isClassDeclaration(node) ? "class" : "interface",
+                        name: node.name.text,
+                        file: relPath,
+                        line: sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1,
+                    });
+                }
+                else if (ts.isTypeAliasDeclaration(node) && node.name) {
+                    symbols.push({
+                        kind: "type",
+                        name: node.name.text,
+                        file: relPath,
+                        line: sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1,
+                    });
+                }
+                else if (ts.isEnumDeclaration(node) && node.name) {
+                    symbols.push({
+                        kind: "enum",
+                        name: node.name.text,
+                        file: relPath,
+                        line: sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1,
+                    });
+                }
+                else if (ts.isVariableStatement(node) &&
+                    isExport &&
+                    node.declarationList.declarations.length > 0) {
+                    for (const decl of node.declarationList.declarations) {
+                        if (ts.isIdentifier(decl.name)) {
+                            symbols.push({
+                                kind: "const",
+                                name: decl.name.text,
+                                file: relPath,
+                                line: sourceFile.getLineAndCharacterOfPosition(decl.getStart()).line + 1,
+                            });
+                        }
+                    }
+                }
+            }
+            // Handle `export { X, Y }` and `export { X as Y }`
+            if (ts.isExportDeclaration(node)) {
+                if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+                    for (const spec of node.exportClause.elements) {
+                        symbols.push({
+                            kind: "export",
+                            name: spec.name.text,
+                            file: relPath,
+                            line: sourceFile.getLineAndCharacterOfPosition(spec.getStart()).line + 1,
+                        });
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+        return symbols;
+    }
+    catch (err) {
+        logWarn("get_ast_hologram", `Could not parse ${relPath}: ${err}`);
+        return [];
+    }
+}
+function walkDirForHologram(dir, rel, extensions) {
+    let allSymbols = [];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (["node_modules", ".git", "dist", "chroma_data", ".lemma"].includes(entry.name))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            const relPath = rel ? path.join(rel, entry.name) : entry.name;
+            if (entry.isDirectory()) {
+                allSymbols = allSymbols.concat(walkDirForHologram(fullPath, relPath, extensions));
+            }
+            else {
+                const ext = entry.name.split(".").pop() || "";
+                if (extensions.includes(ext)) {
+                    allSymbols = allSymbols.concat(extractSymbolsWithTsCompiler(fullPath, relPath));
+                }
+            }
+        }
+    }
+    catch (err) {
+        logWarn("get_ast_hologram", `Error walking dir ${dir}: ${err}`);
+    }
+    return allSymbols;
+}
+async function handleGetAstHologram(args) {
+    const dirPath = args?.dirPath || "";
+    const extensions = args?.extensions || ["ts", "tsx", "js", "jsx"];
+    const workspaceRoot = process.cwd();
+    const { resolved } = safeResolvePath(workspaceRoot, dirPath);
+    const symbols = walkDirForHologram(resolved, dirPath, extensions);
+    const byFile = {};
+    symbols.forEach((s) => {
+        if (!byFile[s.file])
+            byFile[s.file] = [];
+        byFile[s.file].push({ kind: s.kind, name: s.name, line: s.line });
+    });
+    const hologram = {
+        workspace: path.basename(workspaceRoot),
+        scannedDir: dirPath || ".",
+        totalSymbols: symbols.length,
+        totalFiles: Object.keys(byFile).length,
+        map: byFile,
+    };
+    return { content: [{ type: "text", text: JSON.stringify(hologram, null, 2) }] };
+}
+// ── Validate Patch Sandbox ──────────────────────────────────────────
+async function handleValidatePatchSandbox(args) {
+    const filePath = args?.filePath;
+    const patchedContent = args?.patchedContent;
+    if (!filePath || patchedContent === undefined) {
+        throw new Error("filePath and patchedContent are required");
+    }
+    const workspaceRoot = process.cwd();
+    try {
+        safeResolvePath(workspaceRoot, filePath);
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Access denied: ${err.message}` }] };
+    }
+    const sandboxDir = path.join(os.tmpdir(), `lemma-sandbox-${Date.now()}`);
+    const sandboxFile = path.join(sandboxDir, path.basename(filePath));
+    try {
+        fs.mkdirSync(sandboxDir, { recursive: true });
+        fs.writeFileSync(sandboxFile, patchedContent, "utf8");
+        // Step 1: Try tsc --noEmit validation
+        const tsconfigPath = path.join(workspaceRoot, "tsconfig.json");
+        let tscResult = {
+            success: true,
+            output: "No TypeScript config found -- skipping tsc validation.",
+        };
+        if (fs.existsSync(tsconfigPath) && filePath.match(/\.tsx?$/)) {
+            try {
+                const sandboxWorkspace = path.join(sandboxDir, "workspace");
+                execSync(`cp -r ${workspaceRoot}/src ${sandboxWorkspace}/src 2>/dev/null || true`, {
+                    timeout: 5000,
+                });
+                const sandboxTargetFile = path.join(sandboxWorkspace, filePath);
+                fs.mkdirSync(path.dirname(sandboxTargetFile), { recursive: true });
+                fs.writeFileSync(sandboxTargetFile, patchedContent, "utf8");
+                const tscOut = execSync(`cd ${workspaceRoot} && npx tsc --noEmit --skipLibCheck --allowJs --esModuleInterop --strict false 2>&1 | head -40 || true`, { timeout: 20000, encoding: "utf8" });
+                const relevantErrors = tscOut
+                    .split("\n")
+                    .filter((l) => l.includes(path.basename(filePath)) || l.includes("error TS"));
+                tscResult = {
+                    success: relevantErrors.length === 0,
+                    output: relevantErrors.length > 0
+                        ? relevantErrors.join("\n")
+                        : "TypeScript check passed with no errors in target file.",
+                };
+            }
+            catch (e) {
+                tscResult = { success: false, output: e.stdout || e.message };
+            }
+        }
+        // Step 2: Quick bracket/brace balance check
+        const opens = (patchedContent.match(/[{[(]/g) || []).length;
+        const closes = (patchedContent.match(/[}\])]/g) || []).length;
+        const balanced = Math.abs(opens - closes) <= 2;
+        fs.rmSync(sandboxDir, { recursive: true, force: true });
+        const verdict = tscResult.success && balanced;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        verdict: verdict ? "SAFE TO APPLY" : "DO NOT APPLY -- Issues Found",
+                        syntaxBalanced: balanced ? "OK" : "Unbalanced brackets/braces detected",
+                        tscCheck: tscResult.output,
+                        recommendation: verdict
+                            ? "Patch looks valid. You can safely call apply_workspace_patch to apply it."
+                            : "Fix the reported issues before applying the patch to avoid breaking the codebase.",
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        try {
+            fs.rmSync(sandboxDir, { recursive: true, force: true });
+        }
+        catch { }
+        return { content: [{ type: "text", text: `Sandbox validation error: ${err.message}` }] };
+    }
+}
+// ── Hybrid Consensus ────────────────────────────────────────────────
+async function handleQueryHybridConsensus(args) {
+    const query = args?.query;
+    const context = args?.context || "";
+    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 topHit = results[0];
+        if (topHit && topHit.similarity >= threshold) {
+            const savedTokens = Math.floor((topHit.response?.choices?.[0]?.message?.content?.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);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Brain Cache HIT (similarity: ${(topHit.similarity * 100).toFixed(1)}% -- above ${(threshold * 100).toFixed(0)}% threshold)\n\nNo cloud LLM call needed. ~${savedTokens} tokens saved.\n\n---\n\n${responseText}`,
+                    },
+                ],
+            };
+        }
+        const missMsg = results.length > 0
+            ? `Brain Miss -- Best match was only ${(topHit.similarity * 100).toFixed(1)}% (below ${(threshold * 100).toFixed(0)}% threshold).`
+            : `Brain Miss -- No relevant memories found for this query.`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${missMsg}\n\nProceed with your cloud LLM call. Once you have the answer, call store_memory with:\n- query: "${query.substring(0, 100)}"\n- response: [your full answer]\n\nThis will cache it for future sessions and save tokens next time.`,
+                },
+            ],
+        };
+    }
+    catch (e) {
+        logError("query_hybrid_consensus", e);
+        return {
+            content: [
+                { type: "text", text: `Hybrid Consensus failed: ${e.message}. Is Lemma Proxy running?` },
+            ],
+        };
+    }
+}
+// ── Telepathic Hints ────────────────────────────────────────────────
+async function handleGetTelepathicHints(args) {
+    const activeFile = args?.activeFile;
+    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)
+        .split(path.sep)
+        .filter(Boolean)
+        .slice(-2)
+        .join(" ");
+    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 || [];
+        if (results.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Telepathic Hints for \`${activeFile}\`\n\nNo relevant memories found yet. As you use Lemma and store solutions, they will appear here automatically.`,
+                    },
+                ],
+            };
+        }
+        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);
+            hintsText += `### Hint ${i + 1} (${similarity}% match)\n`;
+            hintsText += `**Memory:** ${prompt}\n\n`;
+            hintsText += `${responseContent.substring(0, 400)}${responseContent.length > 400 ? "..." : ""}\n\n---\n\n`;
+        });
+        const estimatedTokensSaved = results.length * 150;
+        reportSavings({
+            source: "cache",
+            tokens: estimatedTokensSaved,
+            toolName: "get_telepathic_hints",
+            filePath: activeFile,
+        });
+        return { content: [{ type: "text", text: hintsText }] };
+    }
+    catch (e) {
+        logError("get_telepathic_hints", e);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Telepathic Hints failed: ${e.message}. Is Lemma Proxy running?`,
+                },
+            ],
+        };
+    }
+}
+//# sourceMappingURL=tools.js.map