@gotza02/sequential-thinking 2026.2.7 → 2026.2.10

package/dist/notes.js

@@ -1,9 +1,11 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { AsyncMutex } from './utils.js';
 export class NotesManager {
     filePath;
     notes = [];
     loaded = false;
+    mutex = new AsyncMutex();
     constructor(storagePath = 'project_notes.json') {
         this.filePath = path.resolve(storagePath);
     }
@@ -23,55 +25,75 @@ export class NotesManager {
     async save() {
         await fs.writeFile(this.filePath, JSON.stringify(this.notes, null, 2), 'utf-8');
     }
-    async addNote(title, content, tags = []) {
-        await this.load();
-        const note = {
-            id: Date.now().toString(36) + Math.random().toString(36).substring(2, 7),
-            title,
-            content,
-            tags,
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString()
-        };
-        this.notes.push(note);
-        await this.save();
-        return note;
+    async addNote(title, content, tags = [], priority = 'medium', expiresAt) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const note = {
+                id: Date.now().toString(36) + Math.random().toString(36).substring(2, 7),
+                title,
+                content,
+                tags,
+                priority,
+                expiresAt,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            this.notes.push(note);
+            await this.save();
+            return note;
+        });
     }
-    async listNotes(tag) {
-        await this.load();
-        if (tag) {
-            return this.notes.filter(n => n.tags.includes(tag));
-        }
-        return this.notes;
+    async listNotes(tag, includeExpired = false) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const now = new Date();
+            let activeNotes = this.notes;
+            if (!includeExpired) {
+                activeNotes = this.notes.filter(n => !n.expiresAt || new Date(n.expiresAt) > now);
+            }
+            if (tag) {
+                return activeNotes.filter(n => n.tags.includes(tag));
+            }
+            return activeNotes.sort((a, b) => {
+                const priorityMap = { 'critical': 4, 'high': 3, 'medium': 2, 'low': 1 };
+                return (priorityMap[b.priority] || 0) - (priorityMap[a.priority] || 0);
+            });
+        });
     }
     async searchNotes(query) {
-        await this.load();
-        const lowerQuery = query.toLowerCase();
-        return this.notes.filter(n => n.title.toLowerCase().includes(lowerQuery) ||
-            n.content.toLowerCase().includes(lowerQuery) ||
-            n.tags.some(t => t.toLowerCase().includes(lowerQuery)));
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const lowerQuery = query.toLowerCase();
+            return this.notes.filter(n => n.title.toLowerCase().includes(lowerQuery) ||
+                n.content.toLowerCase().includes(lowerQuery) ||
+                n.tags.some(t => t.toLowerCase().includes(lowerQuery)));
+        });
     }
     async deleteNote(id) {
-        await this.load();
-        const initialLength = this.notes.length;
-        this.notes = this.notes.filter(n => n.id !== id);
-        if (this.notes.length !== initialLength) {
-            await this.save();
-            return true;
-        }
-        return false;
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const initialLength = this.notes.length;
+            this.notes = this.notes.filter(n => n.id !== id);
+            if (this.notes.length !== initialLength) {
+                await this.save();
+                return true;
+            }
+            return false;
+        });
     }
     async updateNote(id, updates) {
-        await this.load();
-        const index = this.notes.findIndex(n => n.id === id);
-        if (index === -1)
-            return null;
-        this.notes[index] = {
-            ...this.notes[index],
-            ...updates,
-            updatedAt: new Date().toISOString()
-        };
-        await this.save();
-        return this.notes[index];
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const index = this.notes.findIndex(n => n.id === id);
+            if (index === -1)
+                return null;
+            this.notes[index] = {
+                ...this.notes[index],
+                ...updates,
+                updatedAt: new Date().toISOString()
+            };
+            await this.save();
+            return this.notes[index];
+        });
     }
 }

package/dist/notes.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { NotesManager } from './notes.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('NotesManager', () => {
+    let manager;
+    const testPath = 'test_notes.json';
+    let mockStore = '[]';
+    beforeEach(() => {
+        mockStore = '[]';
+        fs.readFile.mockImplementation(async () => mockStore);
+        fs.writeFile.mockImplementation(async (path, data) => {
+            mockStore = data;
+        });
+        manager = new NotesManager(testPath);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should add a note correctly', async () => {
+        const note = await manager.addNote("Test Title", "Test Content", ["tag1"]);
+        expect(note.title).toBe("Test Title");
+        expect(note.tags).toContain("tag1");
+        expect(JSON.parse(mockStore)).toHaveLength(1);
+    });
+    it('should list notes with sorting by priority', async () => {
+        await manager.addNote("Low Prio", "Content", [], "low");
+        await manager.addNote("High Prio", "Content", [], "high");
+        const notes = await manager.listNotes();
+        expect(notes[0].priority).toBe('high');
+        expect(notes[1].priority).toBe('low');
+    });
+    it('should filter notes by tag', async () => {
+        await manager.addNote("Note 1", "Content", ["react"]);
+        await manager.addNote("Note 2", "Content", ["vue"]);
+        const reactNotes = await manager.listNotes('react');
+        expect(reactNotes).toHaveLength(1);
+        expect(reactNotes[0].title).toBe("Note 1");
+    });
+    it('should search notes by query', async () => {
+        await manager.addNote("Deploy Script", "Run npm build", ["devops"]);
+        await manager.addNote("Meeting Notes", "Discuss API", ["meeting"]);
+        const results = await manager.searchNotes("build");
+        expect(results).toHaveLength(1);
+        expect(results[0].title).toBe("Deploy Script");
+    });
+    it('should update a note', async () => {
+        const note = await manager.addNote("Original", "Content");
+        const updated = await manager.updateNote(note.id, { title: "Updated" });
+        expect(updated?.title).toBe("Updated");
+        expect(updated?.content).toBe("Content"); // Should remain
+        const list = await manager.listNotes();
+        expect(list[0].title).toBe("Updated");
+    });
+    it('should delete a note', async () => {
+        const note = await manager.addNote("To Delete", "Content");
+        const success = await manager.deleteNote(note.id);
+        expect(success).toBe(true);
+        const list = await manager.listNotes();
+        expect(list).toHaveLength(0);
+    });
+    it('should hide expired notes by default', async () => {
+        // Expired yesterday
+        const yesterday = new Date();
+        yesterday.setDate(yesterday.getDate() - 1);
+        await manager.addNote("Expired", "Content", [], "medium", yesterday.toISOString());
+        await manager.addNote("Active", "Content");
+        const list = await manager.listNotes();
+        expect(list).toHaveLength(1);
+        expect(list[0].title).toBe("Active");
+        const all = await manager.listNotes(undefined, true);
+        expect(all).toHaveLength(2);
+    });
+});

package/dist/registration.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect, vi } from 'vitest';
+import { registerThinkingTools } from './tools/thinking.js';
+import { registerGraphTools } from './tools/graph.js';
+import { registerNoteTools } from './tools/notes.js';
+import { registerWebTools } from './tools/web.js';
+import { registerFileSystemTools } from './tools/filesystem.js';
+import { registerCodingTools } from './tools/coding.js';
+import { registerCodeDbTools } from './tools/codestore.js';
+describe('Tool Registration', () => {
+    it('should register all tools without duplicates', () => {
+        const registeredTools = new Set();
+        const mockServer = {
+            tool: (name, desc, schema, cb) => {
+                if (registeredTools.has(name)) {
+                    throw new Error(`Duplicate tool name: ${name}`);
+                }
+                registeredTools.add(name);
+            }
+        };
+        // Mock dependencies
+        const mockThinking = { processThought: vi.fn(), clearHistory: vi.fn(), archiveHistory: vi.fn() };
+        const mockGraph = { build: vi.fn(), getRelationships: vi.fn(), getSummary: vi.fn(), toMermaid: vi.fn() };
+        const mockNotes = {};
+        const mockCodeDb = {};
+        registerThinkingTools(mockServer, mockThinking);
+        registerGraphTools(mockServer, mockGraph);
+        registerNoteTools(mockServer, mockNotes);
+        registerWebTools(mockServer);
+        registerFileSystemTools(mockServer);
+        registerCodingTools(mockServer, mockGraph);
+        registerCodeDbTools(mockServer, mockCodeDb);
+        expect(registeredTools.has('sequentialthinking')).toBe(true);
+        expect(registeredTools.has('build_project_graph')).toBe(true);
+        expect(registeredTools.has('read_file')).toBe(true);
+        expect(registeredTools.has('web_search')).toBe(true);
+        // ... and so on
+        console.log('Registered tools:', Array.from(registeredTools).join(', '));
+    });
+});

package/dist/repro_dollar.js

@@ -0,0 +1,30 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerFileSystemTools } from './tools/filesystem.js';
+// Mock server
+const server = new McpServer({ name: "test", version: "1" });
+// Mock tool registration to capture the handler
+let editHandler;
+server.tool = (name, desc, schema, handler) => {
+    if (name === 'edit_file')
+        editHandler = handler;
+    return undefined;
+};
+registerFileSystemTools(server);
+async function test() {
+    console.log("Testing edit_file with dollar signs...");
+    const result = await editHandler({
+        path: 'test_dollar.txt',
+        oldText: 'OLD',
+        newText: '$100' // This usually becomes empty or weird if interpreted as regex replacement
+    });
+    const fs = await import('fs/promises');
+    const content = await fs.readFile('test_dollar.txt', 'utf-8');
+    console.log("File content:", content.trim());
+    if (content.trim() === 'Price: $100') {
+        console.log("PASS: $ preserved");
+    }
+    else {
+        console.log("FAIL: $ corrupted");
+    }
+}
+test();

package/dist/repro_dollar_simple.js

@@ -0,0 +1,22 @@
+async function test() {
+    console.log("Testing edit_file logic...");
+    // Simulate the logic in filesystem.ts
+    const content = "Price: OLD";
+    const oldText = "OLD";
+    const newText = "$&"; // Should be "$&" literally, but replace will make it "OLD"
+    // Logic from tool
+    // If allowMultiple is false, it passes string directly
+    const buggedResult = content.replace(oldText, newText);
+    console.log(`Original: "${content}"`);
+    console.log(`Old: "${oldText}"`);
+    console.log(`New: "${newText}"`);
+    console.log(`Result: "${buggedResult}"`);
+    if (buggedResult === "Price: OLD") {
+        console.log("FAIL: $& was interpreted as the matched string");
+    }
+    else if (buggedResult === "Price: $&") {
+        console.log("PASS: $& was preserved literally");
+    }
+}
+test();
+export {};

package/dist/repro_history.js

@@ -0,0 +1,41 @@
+import { SequentialThinkingServer } from './lib.js';
+import * as fs from 'fs/promises';
+async function test() {
+    const server = new SequentialThinkingServer('test_history_bug.json');
+    await server.clearHistory();
+    // Create thoughts: 1, 2, 3, 4
+    await server.processThought({ thought: "1", thoughtNumber: 1, totalThoughts: 4, nextThoughtNeeded: true });
+    await server.processThought({ thought: "2", thoughtNumber: 2, totalThoughts: 4, nextThoughtNeeded: true });
+    await server.processThought({ thought: "3", thoughtNumber: 3, totalThoughts: 4, nextThoughtNeeded: true });
+    // Thought 4 branches from 3
+    await server.processThought({
+        thought: "4",
+        thoughtNumber: 4,
+        totalThoughts: 4,
+        nextThoughtNeeded: false,
+        branchFromThought: 3,
+        branchId: "test"
+    });
+    // Verify initial state
+    // History: [1, 2, 3, 4(from 3)]
+    // Summarize 2-3
+    await server.archiveHistory(2, 3, "Summary of 2 and 3");
+    // Expected History: [1, Summary(2), 4(3)]
+    // Thought 4 should now contain "branchFromThought: 2" (pointing to summary)
+    // Or if it broke, it might still say 3 (which is itself!) or not be updated.
+    // Read file manually to check JSON content
+    const data = JSON.parse(await fs.readFile('test_history_bug.json', 'utf-8'));
+    const lastThought = data[data.length - 1];
+    console.log("Last Thought:", lastThought);
+    if (lastThought.branchFromThought === 3) {
+        console.log("FAIL: branchFromThought was NOT updated. It points to 3 (which is now itself).");
+    }
+    else if (lastThought.branchFromThought === 2) {
+        console.log("PASS: branchFromThought was updated to point to Summary.");
+    }
+    else {
+        console.log(`FAIL: branchFromThought is ${lastThought.branchFromThought} (Unknown state)`);
+    }
+    await fs.unlink('test_history_bug.json');
+}
+test();

package/dist/repro_path.js

@@ -0,0 +1,17 @@
+import * as path from 'path';
+async function test() {
+    console.log("Testing path traversal vulnerability...");
+    const cwd = process.cwd();
+    const maliciousPath = '/etc/passwd'; // Or any file outside cwd
+    const resolved = path.resolve(maliciousPath);
+    console.log(`CWD: ${cwd}`);
+    console.log(`Input: ${maliciousPath}`);
+    console.log(`Resolved: ${resolved}`);
+    if (!resolved.startsWith(cwd)) {
+        console.log("FAIL: Path is outside CWD and would be allowed by current logic.");
+    }
+    else {
+        console.log("PASS: Path is inside CWD.");
+    }
+}
+test();

package/dist/repro_ts_req.js

@@ -0,0 +1,3 @@
+import { createRequire as _createRequire } from "module";
+const __require = _createRequire(import.meta.url);
+const fs = __require("fs");

package/dist/server.test.js

@@ -92,4 +92,36 @@ describe('SequentialThinkingServer', () => {
         const content = JSON.parse(result.content[0].text);
         expect(content.totalThoughts).toBe(6);
     });
+    it('should clear thought history', async () => {
+        await server.processThought({
+            thought: "To be forgotten",
+            thoughtNumber: 1,
+            totalThoughts: 1,
+            nextThoughtNeeded: false
+        });
+        await server.clearHistory();
+        // Since we can't easily peek into private state, we'll process a new thought
+        // and check if thoughtHistoryLength is 1 (meaning it started over or is just this one)
+        const result = await server.processThought({
+            thought: "Fresh start",
+            thoughtNumber: 1,
+            totalThoughts: 1,
+            nextThoughtNeeded: false
+        });
+        const content = JSON.parse(result.content[0].text);
+        expect(content.thoughtHistoryLength).toBe(1);
+    });
+    it('should summarize history correctly', async () => {
+        // Add 3 thoughts
+        await server.processThought({ thought: "T1", thoughtNumber: 1, totalThoughts: 3, nextThoughtNeeded: true });
+        await server.processThought({ thought: "T2", thoughtNumber: 2, totalThoughts: 3, nextThoughtNeeded: true });
+        await server.processThought({ thought: "T3", thoughtNumber: 3, totalThoughts: 3, nextThoughtNeeded: false });
+        const result = await server.archiveHistory(1, 2, "Summary of T1 and T2");
+        expect(result.newHistoryLength).toBe(2); // Summary + T3
+        expect(result.summaryInsertedAt).toBe(1);
+    });
+    it('should throw error when summarizing invalid range', async () => {
+        await server.processThought({ thought: "T1", thoughtNumber: 1, totalThoughts: 1, nextThoughtNeeded: false });
+        await expect(server.archiveHistory(1, 5, "Invalid")).rejects.toThrow();
+    });
 });

package/dist/stress.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SequentialThinkingServer } from './lib.js';
+import { ProjectKnowledgeGraph } from './graph.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// Mock fs for graph test
+vi.mock('fs/promises', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        readdir: vi.fn(),
+        readFile: vi.fn(),
+        writeFile: vi.fn(),
+        rename: vi.fn(),
+        unlink: vi.fn()
+    };
+});
+// Mock existsSync and readFileSync from 'fs' (non-promise) for SequentialThinkingServer
+vi.mock('fs', async () => {
+    return {
+        existsSync: () => false,
+        readFileSync: () => '[]',
+        unlinkSync: () => { }
+    };
+});
+describe('Stress Testing', () => {
+    it('should handle 1000 sequential thoughts', async () => {
+        // We use a real instance but mocked fs
+        const server = new SequentialThinkingServer('stress_thoughts.json');
+        const startTime = Date.now();
+        for (let i = 1; i <= 1000; i++) {
+            await server.processThought({
+                thought: `Thought ${i}`,
+                thoughtNumber: i,
+                totalThoughts: 1000,
+                nextThoughtNeeded: i < 1000
+            });
+        }
+        const duration = Date.now() - startTime;
+        console.log(`Processed 1000 thoughts in ${duration}ms`);
+        expect(duration).toBeLessThan(10000); // Should be fast enough (< 10s)
+    });
+    it('should handle large graph construction', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        // Mock 1000 files
+        const files = Array.from({ length: 1000 }, (_, i) => `file${i}.ts`);
+        // Mock readdir to return these files (recursively? no, just flat for stress test)
+        // logic in getAllFiles is recursive. We need to mock it to return all at once or handle recursion.
+        // Actually, ProjectKnowledgeGraph.getAllFiles calls readdir.
+        // Let's mock readdir to return files for root, and then nothing for subdirs.
+        fs.readdir.mockImplementation(async (dir) => {
+            if (dir === path.resolve('.')) {
+                return files.map(f => ({
+                    name: f,
+                    isDirectory: () => false
+                }));
+            }
+            return [];
+        });
+        fs.readFile.mockResolvedValue("import { x } from './file0';");
+        const startTime = Date.now();
+        const result = await graph.build('.');
+        const duration = Date.now() - startTime;
+        console.log(`Built graph of ${result.totalFiles} files in ${duration}ms`);
+        expect(result.totalFiles).toBe(1000);
+        expect(duration).toBeLessThan(5000);
+    });
+});

package/dist/system_test.js

@@ -0,0 +1,51 @@
+import { NotesManager } from './notes.js';
+import { CodeDatabase } from './codestore.js';
+import * as fs from 'fs/promises';
+async function testSystem() {
+    console.log("🚀 Starting System Logic Test...\n");
+    // --- 1. Testing Notes Manager (Priority & Expiration) ---
+    console.log("--- Testing Notes Manager ---");
+    const notes = new NotesManager('test_notes.json');
+    // Clean up previous test
+    try {
+        await fs.unlink('test_notes.json');
+    }
+    catch { }
+    console.log("1. Adding CRITICAL note (expires tomorrow)...");
+    await notes.addNote("Urgent Security Fix", "Fix the login bug", ["bug"], "critical", new Date(Date.now() + 86400000).toISOString());
+    console.log("2. Adding LOW priority note...");
+    await notes.addNote("Refactor UI", "Make it pretty eventually", ["ui"], "low");
+    console.log("3. Listing notes (Expect Critical first)...");
+    const list = await notes.listNotes();
+    list.forEach(n => console.log(`- [${n.priority.toUpperCase()}] ${n.title}`));
+    // --- 2. Testing Code Database ---
+    console.log("\n--- Testing Code Database ---");
+    const codeDb = new CodeDatabase('test_code_db.json');
+    try {
+        await fs.unlink('test_code_db.json');
+    }
+    catch { }
+    console.log("1. Adding Code Snippet...");
+    await codeDb.addSnippet({
+        title: "Deepest Thinking Prompt",
+        language: "markdown",
+        code: "You must use sequentialthinking...",
+        description: "Standard prompt for deep agents",
+        tags: ["prompt", "ai"]
+    });
+    console.log("2. Searching for 'Deepest'...");
+    const results = await codeDb.searchSnippets("Deepest");
+    console.log(`Found ${results.length} result(s):`);
+    results.forEach(r => console.log(`- ${r.title} (${r.language})`));
+    console.log("\n✅ Test Complete!");
+    // Cleanup
+    try {
+        await fs.unlink('test_notes.json');
+    }
+    catch { }
+    try {
+        await fs.unlink('test_code_db.json');
+    }
+    catch { }
+}
+testSystem();

package/dist/test_ts_req.js

@@ -0,0 +1,46 @@
+import { ProjectKnowledgeGraph } from './graph.js';
+import * as fs from 'fs/promises';
+async function test() {
+    const tempFile = 'temp_req.ts';
+    await fs.writeFile(tempFile, 'import fs = require("fs");\nexport = fs;');
+    try {
+        const graph = new ProjectKnowledgeGraph();
+        await graph.build(process.cwd());
+        const rel = graph.getRelationships(tempFile);
+        console.log("Imports:", rel?.imports);
+        // Note: 'fs' is a built-in, so it might not be in 'imports' array unless resolved to a file.
+        // But ProjectKnowledgeGraph parser ADDS it to 'imports' list initially.
+        // finalizeFileNodes only keeps it if it resolves to a node OR if we assume internal logic keeps it?
+        // Wait, 'finalizeFileNodes' logic:
+        // for (const importPath of imports) {
+        //     resolved = resolvePath(...)
+        //     if (resolved && nodes.has(resolved)) { imports.push(resolved) }
+        // }
+        // It FILTERS out imports that don't resolve to files in the project!
+        // So 'fs' will be DROPPED.
+        // This makes verifying the PARSER hard via 'getRelationships'.
+        // However, 'symbols' are kept.
+        // 'import fs = require...' creates a symbol 'fs'?
+        // The parser only pushes to 'imports' or 'symbols'.
+        // Let's create a local file 'my_dep.ts' and import THAT.
+        await fs.writeFile('my_dep.ts', 'export const x = 1;');
+        await fs.writeFile(tempFile, 'import dep = require("./my_dep");');
+        await graph.build(process.cwd());
+        const rel2 = graph.getRelationships(tempFile);
+        console.log("Imports 2:", rel2?.imports);
+        if (rel2?.imports.some(i => i.includes('my_dep'))) {
+            console.log("PASS: Found 'my_dep' import");
+        }
+        else {
+            console.log("FAIL: 'my_dep' import missing");
+        }
+    }
+    finally {
+        await fs.unlink(tempFile);
+        try {
+            await fs.unlink('my_dep.ts');
+        }
+        catch { }
+    }
+}
+test();

package/dist/tools/codestore.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export function registerCodeDbTools(server, db) {
+    // 16. add_code_snippet
+    server.tool("add_code_snippet", "Add a useful code snippet or implementation pattern to the persistent Code Database.", {
+        title: z.string().describe("Title of the snippet"),
+        code: z.string().describe("The actual code"),
+        language: z.string().describe("Programming language"),
+        description: z.string().describe("What this code does and why it is useful"),
+        tags: z.array(z.string()).optional().default([]).describe("Tags for categorization")
+    }, async (args) => {
+        const snippet = await db.addSnippet(args);
+        return {
+            content: [{ type: "text", text: `Snippet saved with ID: ${snippet.id}` }]
+        };
+    });
+    // 17. search_code_db
+    server.tool("search_code_db", "Search the Code Database for existing snippets, patterns, or architectural knowledge.", {
+        query: z.string().describe("Search query")
+    }, async ({ query }) => {
+        const results = await db.searchSnippets(query);
+        const patterns = await db.listAllPatterns();
+        let output = `--- CODE DATABASE RESULTS ---\n\n`;
+        if (results.length > 0) {
+            output += `SNIPPETS FOUND:\n`;
+            results.forEach(s => {
+                output += `ID: ${s.id} | ${s.title} (${s.language})\nDesc: ${s.description}\nCode:\n\`\`\`\n${s.code}\n\`\`\`\n\n`;
+            });
+        }
+        const matchedPatterns = Object.entries(patterns).filter(([k, v]) => k.toLowerCase().includes(query.toLowerCase()) || v.toLowerCase().includes(query.toLowerCase()));
+        if (matchedPatterns.length > 0) {
+            output += `PATTERNS FOUND:\n`;
+            matchedPatterns.forEach(([name, desc]) => {
+                output += `- ${name}: ${desc}\n`;
+            });
+        }
+        if (results.length === 0 && matchedPatterns.length === 0) {
+            output += "No results found in the Code Database.";
+        }
+        return { content: [{ type: "text", text: output }] };
+    });
+    // 18. learn_architecture_pattern
+    server.tool("learn_architecture_pattern", "Store a high-level architectural or logic pattern in the Code DB (e.g., 'auth-flow', 'error-handling-strategy').", {
+        name: z.string().describe("Name of the pattern"),
+        description: z.string().describe("Detailed description of the pattern and how it applies to this project")
+    }, async ({ name, description }) => {
+        await db.learnPattern(name, description);
+        return {
+            content: [{ type: "text", text: `Pattern '${name}' learned and stored.` }]
+        };
+    });
+}