@nxuss/lemma 1.0.5 → 1.1.1

package/dist/cjs/mcp/tools.js

@@ -49,6 +49,17 @@ const ComplexityRouter_1 = require("../proxy/ComplexityRouter");
 const ContextSqueezer_1 = require("../utils/ContextSqueezer");
 const reportSavings_1 = require("../utils/reportSavings");
 const utils_1 = require("./utils");
+const FileFingerprint_1 = require("../utils/FileFingerprint");
+const GitBlameHeat_1 = require("../utils/GitBlameHeat");
+const TypeCoverage_1 = require("../utils/TypeCoverage");
+const ImportTreeContext_1 = require("../utils/ImportTreeContext");
+const TokenBudgetedReader_1 = require("../utils/TokenBudgetedReader");
+const BulkFileDigest_1 = require("../utils/BulkFileDigest");
+const AutoContextBundle_1 = require("../utils/AutoContextBundle");
+const RepeatGuard_1 = require("../utils/RepeatGuard");
+const ConversationCheckpoint_1 = require("../utils/ConversationCheckpoint");
+const TestAutofixInterceptor_1 = require("../utils/TestAutofixInterceptor");
+const PromptPatternCache_1 = require("../utils/PromptPatternCache");
 const PRReviewEngine_1 = require("../pr-review/PRReviewEngine");
 const ReviewStore_1 = require("../pr-review/ReviewStore");
 const reviewRunner_1 = require("../pr-review/reviewRunner");
@@ -82,6 +93,12 @@ const FREE_TOOLS = new Set([
     "token_budget", "squeeze_prompt", "turbosqueeze",
     // Utility — just enough to function
     "read_workspace_file", "scrub_privacy", "summarize_long_text",
+    // Phase 1 zero-cost analysis tools
+    "file_fingerprint", "git_blame_heat", "type_coverage_report", "import_tree_context",
+    // Phase 2 smart reading & dedup tools
+    "read_token_budgeted", "bulk_file_digest", "auto_context_bundle", "repeat_guard",
+    // Phase 3 session & automation tools
+    "conversation_checkpoint", "test_autofix_interceptor", "prompt_pattern_cache",
 ]);
 const PRO_GATE_MESSAGE = [
     "🔒 This tool requires Lemma Pro.",
@@ -812,6 +829,144 @@ const toolDefinitions = [
             },
             required: ["filePath", "functionName"]
         }
+    },
+    {
+        name: "file_fingerprint",
+        description: "Compute SHA256 fingerprint of a file. Returns 'unchanged' if hash matches cache, avoiding full re-reads. Saves 60-70% tokens on repeated file access.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" },
+                forceRefresh: { type: "boolean", description: "Force re-read even if hash matches", default: false }
+            },
+            required: ["filePath"]
+        }
+    },
+    {
+        name: "git_blame_heat",
+        description: "Analyze git blame history to identify high-risk lines and authors. Zero LLM cost. Returns risk scores per line, hotspots, and top contributors by risk.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" }
+            },
+            required: ["filePath"]
+        }
+    },
+    {
+        name: "type_coverage_report",
+        description: "Analyze TypeScript type coverage of a file using AST. Returns declaration count, typed vs untyped ratio, any-usage count, and a safety score 0-100. Zero LLM cost.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" }
+            },
+            required: ["filePath"]
+        }
+    },
+    {
+        name: "import_tree_context",
+        description: "Build a bidirectional import graph for a file. Shows what it imports, what imports it, and external dependencies. Zero LLM cost. Essential before refactors.",
+        inputSchema: {
+            type: "tool",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" },
+                depth: { type: "number", description: "Traversal depth (default: 2)", default: 2 }
+            },
+            required: ["filePath"]
+        }
+    },
+    {
+        name: "read_token_budgeted",
+        description: "Read a file with a hard token budget. Returns only the most relevant sections up to maxTokens. Saves 70-90% vs full reads.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" },
+                query: { type: "string", description: "Search query to determine relevance", default: "" },
+                maxTokens: { type: "number", description: "Maximum tokens to return (default: 2000)", default: 2000 }
+            },
+            required: ["filePath"]
+        }
+    },
+    {
+        name: "bulk_file_digest",
+        description: "Read multiple files in one call and return a compressed digest. Saves 80% round-trips vs reading files individually.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePaths: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of file paths relative to the project root"
+                },
+                query: { type: "string", description: "Search query for relevance ranking", default: "" },
+                maxTotalTokens: { type: "number", description: "Total token budget for all files (default: 4000)", default: 4000 }
+            },
+            required: ["filePaths"]
+        }
+    },
+    {
+        name: "auto_context_bundle",
+        description: "Get everything about a file in one call: compressed content, import graph, schema types, and telepathic hints from The Brain. Replaces 4-5 separate tool calls.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path relative to the project root" }
+            },
+            required: ["filePath"]
+        }
+    },
+    {
+        name: "repeat_guard",
+        description: "Check if a draft output is repetitive compared to recent responses. Returns similarity score and suggestion. Prevents duplicate explanations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                draftOutput: { type: "string", description: "The draft output to check for repetition" },
+                threshold: { type: "number", description: "Similarity threshold 0-1 (default: 0.75)", default: 0.75 }
+            },
+            required: ["draftOutput"]
+        }
+    },
+    {
+        name: "conversation_checkpoint",
+        description: "Save or load session state. Prevents re-explaining context across turns. Save current progress or load last checkpoint.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["save", "load", "summary"], description: "Action to perform", default: "load" },
+                filesModified: { type: "array", items: { type: "string" }, description: "Files modified in this session" },
+                decisionsMade: { type: "array", items: { type: "string" }, description: "Decisions made" },
+                bugsResolved: { type: "array", items: { type: "string" }, description: "Bugs resolved" },
+                tasksPending: { type: "array", items: { type: "string" }, description: "Pending tasks" }
+            },
+            required: ["action"]
+        }
+    },
+    {
+        name: "test_autofix_interceptor",
+        description: "Run tests and auto-search The Brain for fixes to failures. Returns failure list with suggested fixes from past sessions. Saves 4-5 turns of debugging.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "Test command (default: 'npm test')", default: "npm test" }
+            }
+        }
+    },
+    {
+        name: "prompt_pattern_cache",
+        description: "Find or store optimized prompt templates. Reuses past prompt patterns to save 20-30% tokens on repetitive operations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["find", "store", "stats"], description: "Action to perform", default: "find" },
+                query: { type: "string", description: "The prompt/query to search or store" },
+                template: { type: "string", description: "The optimized template to store (for 'store' action)" },
+                tokensSaved: { type: "number", description: "Estimated tokens saved by this template", default: 0 }
+            },
+            required: ["action"]
+        }
     }
 ];
 const toolHandlers = {
@@ -872,6 +1027,17 @@ const toolHandlers = {
     semantic_grep: handleSemanticGrep,
     imports_skeleton_resolver: handleImportsSkeletonResolver,
     ast_flow_visualizer: handleAstFlowVisualizer,
+    file_fingerprint: handleFileFingerprint,
+    git_blame_heat: handleGitBlameHeat,
+    type_coverage_report: handleTypeCoverageReport,
+    import_tree_context: handleImportTreeContext,
+    read_token_budgeted: handleReadTokenBudgeted,
+    bulk_file_digest: handleBulkFileDigest,
+    auto_context_bundle: handleAutoContextBundle,
+    repeat_guard: handleRepeatGuard,
+    conversation_checkpoint: handleConversationCheckpoint,
+    test_autofix_interceptor: handleTestAutofixInterceptor,
+    prompt_pattern_cache: handlePromptPatternCache,
 };
 function setupToolsHandlers(server, onToolCall) {
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
@@ -4480,4 +4646,335 @@ async function handleAstFlowVisualizer(args) {
         return { content: [{ type: "text", text: `AST flow visualization failed: ${e.message}` }] };
     }
 }
+// ── File Fingerprint ──────────────────────────────────────────────────
+async function handleFileFingerprint(args) {
+    const filePath = args.filePath;
+    const forceRefresh = !!args.forceRefresh;
+    if (!filePath)
+        throw new Error("filePath is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const result = (0, FileFingerprint_1.computeFingerprint)(filePath, workspaceRoot, forceRefresh);
+        if (result.status === "unchanged") {
+            return { content: [{ type: "text", text: `UNCHANGED: ${filePath} (hash: ${result.hash}, ${result.lines} lines)` }] };
+        }
+        if (result.status === "new") {
+            return { content: [{ type: "text", text: `NEW: ${filePath} (hash: ${result.hash}, ${result.lines} lines)` }] };
+        }
+        (0, reportSavings_1.reportSavings)({ source: "cache", charsBefore: (result.content || "").length, charsAfter: 0, toolName: "file_fingerprint", filePath });
+        return { content: [{ type: "text", text: `CHANGED: ${filePath} (hash: ${result.hash}, ${result.lines} lines)\n\n${result.content}` }] };
+    }
+    catch (e) {
+        (0, utils_1.logError)("file_fingerprint", e);
+        return { content: [{ type: "text", text: `Fingerprint failed: ${e.message}` }] };
+    }
+}
+// ── Git Blame Heat ────────────────────────────────────────────────────
+async function handleGitBlameHeat(args) {
+    const filePath = args.filePath;
+    if (!filePath)
+        throw new Error("filePath is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const result = (0, GitBlameHeat_1.analyzeBlameHeat)(filePath, workspaceRoot);
+        const lines = [
+            `# Git Blame Heat: ${result.file}`,
+            `**Total lines:** ${result.totalLines} | **Risk Score:** ${result.riskScore}/100`,
+            "",
+        ];
+        if (result.topAuthors.length > 0) {
+            lines.push("## Top Authors by Risk");
+            for (const a of result.topAuthors) {
+                lines.push(`- **${a.author}**: ${a.lines} lines, risk ${a.risk}`);
+            }
+            lines.push("");
+        }
+        if (result.hotspots.length > 0) {
+            lines.push("## Hotspots (risk > 50)");
+            for (const h of result.hotspots.slice(0, 10)) {
+                lines.push(`- L${h.line}: risk=${h.riskScore.toFixed(1)}, author=${h.author}, age=${h.age}d, changes=${h.changeCount}`);
+            }
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    catch (e) {
+        (0, utils_1.logError)("git_blame_heat", e);
+        return { content: [{ type: "text", text: `Git blame heat failed: ${e.message}` }] };
+    }
+}
+// ── Type Coverage Report ──────────────────────────────────────────────
+async function handleTypeCoverageReport(args) {
+    const filePath = args.filePath;
+    if (!filePath)
+        throw new Error("filePath is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const result = (0, TypeCoverage_1.analyzeTypeCoverage)(filePath, workspaceRoot);
+        const lines = [
+            `# Type Coverage: ${result.file}`,
+            `**Score:** ${result.score}/100 | **Coverage:** ${result.coveragePercent}%`,
+            `**Declarations:** ${result.typedDeclarations}/${result.totalDeclarations} typed | **any count:** ${result.anyCount}`,
+            "",
+        ];
+        if (result.missingTypes.length > 0) {
+            lines.push("## Missing Types (first 10)");
+            for (const m of result.missingTypes.slice(0, 10)) {
+                lines.push(`- L${m.line}: \`${m.code}\``);
+            }
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    catch (e) {
+        (0, utils_1.logError)("type_coverage_report", e);
+        return { content: [{ type: "text", text: `Type coverage analysis failed: ${e.message}` }] };
+    }
+}
+// ── Import Tree Context ───────────────────────────────────────────────
+async function handleImportTreeContext(args) {
+    const filePath = args.filePath;
+    const depth = args.depth || 2;
+    if (!filePath)
+        throw new Error("filePath is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const result = (0, ImportTreeContext_1.buildImportTree)(filePath, workspaceRoot, depth);
+        return { content: [{ type: "text", text: result.summary }] };
+    }
+    catch (e) {
+        (0, utils_1.logError)("import_tree_context", e);
+        return { content: [{ type: "text", text: `Import tree failed: ${e.message}` }] };
+    }
+}
+// ── Token Budgeted Reader ─────────────────────────────────────────────
+async function handleReadTokenBudgeted(args) {
+    const filePath = args.filePath;
+    const query = args.query || '';
+    const maxTokens = args.maxTokens || 2000;
+    if (!filePath)
+        throw new Error("filePath is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const result = (0, TokenBudgetedReader_1.readTokenBudgeted)(filePath, workspaceRoot, query, maxTokens);
+        if (!result.truncated) {
+            return { content: [{ type: "text", text: `FULL READ: ${result.filePath} (${result.tokensUsed} tokens)\n\n${result.content}` }] };
+        }
+        const sections = result.relevantSections.map(s => `L${s.start}-L${s.end} (${s.reason})`).join(', ');
+        return { content: [{ type: "text", text: `BUDGETED READ: ${result.filePath} (${result.tokensUsed}/${result.tokensBudget} tokens, ${result.relevantSections.length} sections)\nSections: ${sections}\n\n${result.content}` }] };
+    }
+    catch (e) {
+        (0, utils_1.logError)("read_token_budgeted", e);
+        return { content: [{ type: "text", text: `Token budgeted read failed: ${e.message}` }] };
+    }
+}
+// ── Bulk File Digest ──────────────────────────────────────────────────
+async function handleBulkFileDigest(args) {
+    const filePaths = args.filePaths;
+    const query = args.query || '';
+    const maxTotalTokens = args.maxTotalTokens || 4000;
+    if (!filePaths || filePaths.length === 0)
+        throw new Error("filePaths array is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const result = (0, BulkFileDigest_1.bulkFileDigest)(filePaths, workspaceRoot, query, maxTotalTokens);
+        const lines = [`# Bulk Digest: ${result.files.length} files (${result.totalTokens} tokens)\n`];
+        for (const f of result.files) {
+            const flag = f.truncated ? ' [TRUNCATED]' : '';
+            lines.push(`## ${f.path} (${f.tokenCount} tokens)${flag}\n${f.summary}\n`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    catch (e) {
+        (0, utils_1.logError)("bulk_file_digest", e);
+        return { content: [{ type: "text", text: `Bulk digest failed: ${e.message}` }] };
+    }
+}
+// ── Auto Context Bundle ───────────────────────────────────────────────
+async function handleAutoContextBundle(args) {
+    const filePath = args.filePath;
+    if (!filePath)
+        throw new Error("filePath is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const result = (0, AutoContextBundle_1.autoContextBundle)(filePath, workspaceRoot);
+        const lines = [
+            `# Auto Context: ${result.filePath}`,
+            `**Hash:** ${result.fingerprint} | **Tokens:** ~${result.tokenEstimate}`,
+            "",
+        ];
+        if (result.imports.length > 0) {
+            const localImps = result.imports.filter(i => i.isLocal);
+            const extImps = result.imports.filter(i => !i.isLocal);
+            if (localImps.length > 0)
+                lines.push(`**Local imports:** ${localImps.map(i => `${i.symbols.join(', ')} from ${i.source}`).join('; ')}`);
+            if (extImps.length > 0)
+                lines.push(`**External:** ${extImps.map(i => i.source.split('/')[0]).join(', ')}`);
+            lines.push("");
+        }
+        if (result.importedBy.length > 0) {
+            lines.push(`**Imported by:** ${result.importedBy.join(', ')}`);
+            lines.push("");
+        }
+        if (result.schemaTypes) {
+            lines.push(`## Types\n\`\`\`typescript\n${result.schemaTypes}\n\`\`\`\n`);
+        }
+        if (result.telepathicHints.length > 0) {
+            lines.push("## Relevant Brain Memories");
+            for (const h of result.telepathicHints) {
+                lines.push(`- **${h.query}:** ${h.response.slice(0, 200)}`);
+            }
+            lines.push("");
+        }
+        lines.push(`## Content\n${result.content}`);
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    catch (e) {
+        (0, utils_1.logError)("auto_context_bundle", e);
+        return { content: [{ type: "text", text: `Auto context bundle failed: ${e.message}` }] };
+    }
+}
+// ── Repeat Guard ──────────────────────────────────────────────────────
+async function handleRepeatGuard(args) {
+    const draftOutput = args.draftOutput;
+    const threshold = args.threshold || 0.75;
+    if (!draftOutput)
+        throw new Error("draftOutput is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const result = (0, RepeatGuard_1.checkRepeat)(draftOutput, workspaceRoot, threshold);
+        (0, RepeatGuard_1.recordOutput)(draftOutput, workspaceRoot);
+        const icon = result.isRepeat ? '⚠️' : '✅';
+        const lines = [
+            `${icon} Repeat Guard`,
+            `**Similarity:** ${Math.round(result.similarity * 100)}% | **Threshold:** ${Math.round(threshold * 100)}%`,
+            `**Verdict:** ${result.isRepeat ? 'REPETITIVE' : 'OK'}`,
+            `**Note:** ${result.suggestion}`,
+        ];
+        if (result.previousOutput) {
+            lines.push(`\n**Previous output preview:** ${result.previousOutput}`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    catch (e) {
+        (0, utils_1.logError)("repeat_guard", e);
+        return { content: [{ type: "text", text: `Repeat guard failed: ${e.message}` }] };
+    }
+}
+// ── Conversation Checkpoint ───────────────────────────────────────────
+async function handleConversationCheckpoint(args) {
+    const action = args.action || 'load';
+    const workspaceRoot = process.cwd();
+    try {
+        if (action === 'load') {
+            const cp = (0, ConversationCheckpoint_1.loadLatestCheckpoint)(workspaceRoot);
+            if (!cp) {
+                return { content: [{ type: "text", text: 'No checkpoint found. Starting fresh session.' }] };
+            }
+            const age = Math.floor((Date.now() - cp.timestamp) / 60000);
+            const lines = [
+                `# Session Checkpoint (${age}min ago)`,
+                `**Summary:** ${cp.summary}`,
+                `**Files modified:** ${cp.filesModified.length}`,
+                `**Decisions:** ${cp.decisionsMade.length}`,
+                `**Bugs resolved:** ${cp.bugsResolved.length}`,
+                `**Pending tasks:** ${cp.tasksPending.length}`,
+                `**Token estimate:** ~${cp.tokenEstimate}`,
+            ];
+            if (cp.tasksPending.length > 0) {
+                lines.push('\n## Pending Tasks');
+                for (const t of cp.tasksPending)
+                    lines.push(`- ${t}`);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        if (action === 'save') {
+            const filesModified = args.filesModified || [];
+            const decisionsMade = args.decisionsMade || [];
+            const bugsResolved = args.bugsResolved || [];
+            const tasksPending = args.tasksPending || [];
+            const summary = (0, ConversationCheckpoint_1.buildCheckpointSummary)(filesModified, decisionsMade, bugsResolved, tasksPending);
+            const cp = (0, ConversationCheckpoint_1.saveCheckpoint)({ projectPath: workspaceRoot, filesModified, decisionsMade, bugsResolved, tasksPending, summary }, workspaceRoot);
+            return { content: [{ type: "text", text: `Checkpoint saved (${cp.tokenEstimate} tokens estimated).` }] };
+        }
+        if (action === 'summary') {
+            const cp = (0, ConversationCheckpoint_1.loadLatestCheckpoint)(workspaceRoot);
+            return { content: [{ type: "text", text: cp ? cp.summary : 'No checkpoint available.' }] };
+        }
+        return { content: [{ type: "text", text: `Unknown action: ${action}. Use 'save', 'load', or 'summary'.` }] };
+    }
+    catch (e) {
+        (0, utils_1.logError)("conversation_checkpoint", e);
+        return { content: [{ type: "text", text: `Checkpoint failed: ${e.message}` }] };
+    }
+}
+// ── Test Autofix Interceptor ──────────────────────────────────────────
+async function handleTestAutofixInterceptor(args) {
+    const command = args.command || 'npm test';
+    const workspaceRoot = process.cwd();
+    try {
+        const result = (0, TestAutofixInterceptor_1.runTestAutofix)(command, workspaceRoot);
+        const lines = [
+            `# Test Results: ${result.passed}/${result.totalTests} passed, ${result.failed} failed`,
+        ];
+        if (result.failures.length > 0) {
+            lines.push(`\n## ${result.failures.length} Failure(s) (${result.autoFixAvailable} with brain fix)\n`);
+            for (const f of result.failures) {
+                lines.push(`### ${f.testName}${f.file ? ` (${f.file})` : ''}`);
+                lines.push(`\`\`\`\n${f.error.slice(0, 300)}\n\`\`\``);
+                if (f.brainHit && f.suggestedFix) {
+                    lines.push(`**Suggested fix (from Brain):** ${f.suggestedFix.slice(0, 400)}`);
+                }
+                else {
+                    lines.push('**Brain:** No matching fix found.');
+                }
+                lines.push('');
+            }
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    catch (e) {
+        (0, utils_1.logError)("test_autofix_interceptor", e);
+        return { content: [{ type: "text", text: `Test autofix failed: ${e.message}` }] };
+    }
+}
+// ── Prompt Pattern Cache ──────────────────────────────────────────────
+async function handlePromptPatternCache(args) {
+    const action = args.action || 'find';
+    const query = args.query || '';
+    const template = args.template || '';
+    const tokensSaved = args.tokensSaved || 0;
+    const workspaceRoot = process.cwd();
+    try {
+        if (action === 'find') {
+            if (!query)
+                throw new Error("query is required for 'find'");
+            const pattern = (0, PromptPatternCache_1.findPattern)(query, workspaceRoot);
+            if (pattern) {
+                return { content: [{ type: "text", text: `Pattern found (hit #${pattern.hitCount}):\n\n**Keywords:** ${pattern.keywords.join(', ')}\n**Template:**\n${pattern.template}\n\n**Avg tokens saved:** ${pattern.avgTokensSaved}` }] };
+            }
+            return { content: [{ type: "text", text: 'No matching pattern found. Consider storing one with action "store".' }] };
+        }
+        if (action === 'store') {
+            if (!query || !template)
+                throw new Error("query and template are required for 'store'");
+            const pattern = (0, PromptPatternCache_1.storePattern)(query, template, tokensSaved, workspaceRoot);
+            return { content: [{ type: "text", text: `Pattern stored (id: ${pattern.id}). Keywords: ${pattern.keywords.join(', ')}` }] };
+        }
+        if (action === 'stats') {
+            const stats = (0, PromptPatternCache_1.getPatternStats)(workspaceRoot);
+            const lines = [`# Prompt Pattern Cache: ${stats.totalPatterns} patterns\n`];
+            if (stats.topPatterns.length > 0) {
+                lines.push('## Top Patterns');
+                for (const p of stats.topPatterns) {
+                    lines.push(`- **${p.id}**: hits=${p.hitCount}, saved=${p.avgTokensSaved}tok, kw=[${p.keywords.slice(0, 5).join(', ')}]`);
+                }
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        return { content: [{ type: "text", text: `Unknown action: ${action}. Use 'find', 'store', or 'stats'.` }] };
+    }
+    catch (e) {
+        (0, utils_1.logError)("prompt_pattern_cache", e);
+        return { content: [{ type: "text", text: `Prompt pattern cache failed: ${e.message}` }] };
+    }
+}
 //# sourceMappingURL=tools.js.map