@gotza02/sequential-thinking 2026.2.7 → 2026.2.10

package/README.md

@@ -1,17 +1,18 @@
 # Sequential Thinking MCP Server (Extended Edition) 🧠✨
 
-**MCP Server ที่ยกระดับ AI ให้เป็นวิศวกรซอฟต์แวร์อัจฉริยะ ด้วยระบบ Deepest Thinking และการวิเคราะห์ Codebase เชิงลึก**
+**MCP Server ที่ยกระดับ AI ให้เป็นวิศวกรซอฟต์แวร์อัจฉริยะ ด้วยระบบ Deepest Thinking, การวิเคราะห์ Codebase เชิงลึก และฐานข้อมูลความรู้ (Code Database)**
 
-โปรเจกต์นี้คือส่วนขยายขั้นสูงของ Sequential Thinking ที่รวมเอาความสามารถในการวางแผนที่เป็นระบบ, การหาข้อมูลทั่วโลก (Web Search), การสร้างแผนผังความสัมพันธ์ของโค้ด (Dependency Graph) และการจัดการหน่วยความจำระยะยาวเข้าด้วยกัน เพื่อให้ AI สามารถทำงานที่ซับซ้อนได้อย่างอิสระและแม่นยำ
+โปรเจกต์นี้คือส่วนขยายขั้นสูงของ Sequential Thinking ที่รวมเอาความสามารถในการวางแผนที่เป็นระบบ, การหาข้อมูลทั่วโลก (Web Search), การสร้างแผนผังความสัมพันธ์ของโค้ด (Dependency Graph), การจัดการหน่วยความจำระยะยาว และ **ฐานข้อมูลความรู้โค้ด (Code Database)** เข้าด้วยกัน เพื่อให้ AI สามารถทำงานที่ซับซ้อนได้อย่างอิสระและแม่นยำ
 
 ---
 
 ## 🌟 จุดเด่นของเวอร์ชัน Extended
 
 1.  **Deepest Thinking Protocol**: บังคับให้ AI วิเคราะห์ปัญหาแบบเป็นลำดับขั้นตอน (Step-by-step) พร้อมการแตกกิ่งความคิด (Branching) และการทบทวนตัวเอง (Reflexion) เพื่อหาทางเลือกที่ดีที่สุด
-2.  **Codebase Intelligence**: ระบบ `ProjectKnowledgeGraph` ที่ใช้ TypeScript Compiler API จริงๆ ในการสแกนความสัมพันธ์ระหว่างไฟล์และ Exported Symbols
-3.  **Deep Coding Workflow**: เครื่องมือใหม่สำหรับการแก้ไขโค้ดที่ต้องผ่านการวิเคราะห์บริบท (Context Document) และการวางแผนที่ผ่านการตรวจสอบเหตุผลแล้วเท่านั้น
-4.  **Optimized Web Extraction**: ระบบอ่านเว็บที่ตัดโฆษณาและส่วนที่ไม่จำเป็นออก (Readability) แปลงเป็น Markdown เพื่อประหยัด Token และให้ข้อมูลที่สะอาดที่สุด
+2.  **Codebase Intelligence**: ระบบ `ProjectKnowledgeGraph` ที่ใช้ TypeScript Compiler API และ Regex (สำหรับ Python/Go) ในการสแกนความสัมพันธ์ระหว่างไฟล์และ Exported Symbols
+3.  **Code Database (CodeStore)**: ระบบจัดเก็บ Snippets และ Architectural Patterns ลงในไฟล์ JSON ถาวร ช่วยให้ AI "จดจำ" วิธีแก้ปัญหาและนำกลับมาใช้ใหม่ได้
+4.  **Deep Coding Workflow**: เครื่องมือใหม่สำหรับการแก้ไขโค้ดที่ต้องผ่านการวิเคราะห์บริบท (Context Document) และการวางแผนที่ผ่านการตรวจสอบเหตุผลแล้วเท่านั้น
+5.  **Smart Notes**: ระบบบันทึกที่มี **Priority Level** และ **Expiration Date** ช่วยจัดลำดับความสำคัญของงานได้ดียิ่งขึ้น
 
 ---
 
@@ -25,7 +26,9 @@
 | `GOOGLE_SEARCH_CX` | Google Custom Search Engine ID (CX) | ❌ (Optional) |
 | `THOUGHTS_STORAGE_PATH` | ไฟล์เก็บประวัติความคิดเพื่อใช้ต่อเนื่อง | `thoughts_history.json` |
 | `NOTES_STORAGE_PATH` | ไฟล์เก็บความจำระยะยาว (กฎโปรเจกต์, ความชอบ) | `project_notes.json` |
+| `CODE_DB_PATH` | ไฟล์เก็บฐานข้อมูลความรู้โค้ด (Snippets/Patterns) | `code_database.json` |
 | `THOUGHT_DELAY_MS` | เวลาหน่วงระหว่างคิด (เพื่อความสมจริงและการจัดการ Rate Limit) | `0` |
+| `LOG_LEVEL` | ระดับการแสดงผล Log (debug, info, warn, error) | `info` |
 
 ---
 
@@ -39,31 +42,24 @@
 ### 💻 2. Deep Coding & Codebase Context
 *   **`deep_code_analyze`**: 🌟 **(ใหม่)** สร้าง Codebase Context Document รวบรวมเนื้อหาไฟล์, Symbols และความสัมพันธ์ (Import/Export) เพื่อให้ AI "เรียนรู้" ก่อนแก้โค้ด
 *   **`deep_code_edit`**: 🌟 **(ใหม่)** แก้ไขโค้ดแบบ Surgical Edit โดยต้องระบุ `reasoning` (เหตุผลเชิงลึก) ที่ผ่านการคิดวิเคราะห์มาแล้ว
-*   **`build_project_graph`**: สแกนโปรเจกต์เพื่อสร้างแผนผังความสัมพันธ์ทั้งหมด
+*   **`build_project_graph`**: สแกนโปรเจกต์เพื่อสร้างแผนผังความสัมพันธ์ทั้งหมด (รองรับ TS, JS, PY, GO)
 *   **`get_file_relationships`**: ตรวจสอบว่าไฟล์เป้าหมายกระทบกับส่วนไหนของระบบบ้าง
 *   **`search_code`**: ค้นหา Code Pattern ทั้งโปรเจกต์แบบชาญฉลาด
 
-### 🌐 3. External Research
+### 📚 3. Knowledge & Memory (CodeStore)
+*   **`add_code_snippet`**: 🌟 **(ใหม่)** บันทึก Snippet โค้ดที่ใช้งานบ่อยลงฐานข้อมูล
+*   **`search_code_db`**: 🌟 **(ใหม่)** ค้นหาความรู้เดิมจากฐานข้อมูล (ช่วยลดเวลาในการเริ่มงานใหม่)
+*   **`learn_architecture_pattern`**: 🌟 **(ใหม่)** บันทึกรูปแบบโครงสร้างของระบบ
+*   **`manage_notes`**: (ปรับปรุงใหม่!) จัดการบันทึกพร้อมระบุ **Priority** และ **Expiration**
+
+### 🌐 4. External Research
 *   **`web_search`**: ค้นหาข้อมูลล่าสุดจากโลกภายนอก (Brave/Exa/Google)
 *   **`read_webpage`**: อ่านเนื้อหาเว็บแปลงเป็น Markdown ที่สะอาดและเข้าใจง่าย
 *   **`fetch`**: ดึงข้อมูล Raw จาก API ต่างๆ
 
-### 📁 4. System & Persistence
+### 📁 5. System & Persistence
 *   **`read_file` / `write_file` / `edit_file`**: จัดการไฟล์ในระบบ
-*   **`shell_execute`**: รันคำสั่ง Terminal (เช่น Build, Test, Deploy)
-*   **`manage_notes`**: จัดการหน่วยความจำระยะยาวข้ามเซสชัน
-
----
-
-## 🔄 The "Deep Coding" Workflow (ขั้นตอนการทำงานที่แนะนำ)
-
-เพื่อให้ AI ทำงานได้อย่างเทพที่สุด แนะนำให้ใช้ลำดับการทำงานดังนี้:
-
-1.  **Map the Codebase**: รัน `build_project_graph` เพื่อให้ AI เข้าใจโครงสร้างโปรเจกต์ทั้งหมด
-2.  **Deep Analysis**: ใช้ `deep_code_analyze` กับไฟล์ที่เกี่ยวข้อง เพื่อสร้างบริบทและความเข้าใจ symbols ที่ใช้งาน
-3.  **Strategic Planning**: ใช้ `sequentialthinking` เพื่อวางแผนแบบ Deepest Thinking (แตกกิ่งความคิด, ทดสอบสมมติฐาน)
-4.  **Precision Edit**: ลงมือแก้ไขด้วย `deep_code_edit` หรือ `edit_file` พร้อมระบุเหตุผลที่วิเคราะห์มาแล้ว
-5.  **Verify**: ใช้ `shell_execute` รันคำสั่ง Test หรือ Lint เพื่อตรวจสอบความถูกต้อง
+*   **`shell_execute`**: รันคำสั่ง Terminal (มีระบบป้องกันคำสั่งอันตราย เช่น `rm -rf /`)
 
 ---
 
@@ -93,7 +89,7 @@ git clone https://github.com/gotza02/sequential-thinking.git && cd sequential-th
     ```bash
     npm run build
     ```
-4.  **Configuration**: เปิดไฟล์ตั้งค่า AI Client ของคุณ (เช่น `~/.gemini/settings.json`) แล้วเพิ่มการตั้งค่า MCP Server โดยอ้างอิง Path ไปยังโฟลเดอร์ที่ Build เสร็จแล้ว
+4.  **Configuration**: ตั้งค่า AI Client ตามตัวอย่างด้านล่าง
 
 ---
 
@@ -117,6 +113,7 @@ git clone https://github.com/gotza02/sequential-thinking.git && cd sequential-th
         "GOOGLE_SEARCH_CX": "YOUR_GOOGLE_SEARCH_ENGINE_ID",
         "THOUGHTS_STORAGE_PATH": "thoughts_history.json",
         "NOTES_STORAGE_PATH": "project_notes.json",
+        "CODE_DB_PATH": "code_database.json",
         "THOUGHT_DELAY_MS": "1000",
         "DISABLE_THOUGHT_LOGGING": "false"
       }
@@ -139,6 +136,7 @@ git clone https://github.com/gotza02/sequential-thinking.git && cd sequential-th
         "EXA_API_KEY": "YOUR_EXA_KEY",
         "GOOGLE_SEARCH_API_KEY": "YOUR_GOOGLE_API_KEY",
         "GOOGLE_SEARCH_CX": "YOUR_GOOGLE_SEARCH_ENGINE_ID",
+        "CODE_DB_PATH": "code_database.json",
         "THOUGHT_DELAY_MS": "1000"
       }
     }
@@ -150,6 +148,16 @@ git clone https://github.com/gotza02/sequential-thinking.git && cd sequential-th
 
 ---
 
+## 🛠️ ติดตั้งคำสั่งระบบ (System Instruction Setup)
+
+คุณสามารถติดตั้งคำสั่งระบบ **Ultimate Deep Engineer** ให้กับ Gemini และ Claude ได้โดยอัตโนมัติด้วย Script นี้:
+
+```bash
+chmod +x install-ultimate-engineer.sh && ./install-ultimate-engineer.sh
+```
+
+---
+
 ## 🤖 Recommended System Instruction (The Ultimate Deep Engineer)
 
 ให้ Copy ข้อความด้านล่างนี้ไปใส่ใน **System Prompt** ของ AI Agent เพื่อประสิทธิภาพสูงสุด:
@@ -164,6 +172,7 @@ You are a Senior AI Software Engineer equipped with the Sequential Thinking MCP
 - **Atomic Analysis:** Use `thoughtType: 'analysis'` to break every request into atomic requirements and constraints before proposing solutions.
 - **Mandatory Reflexion:** Use `thoughtType: 'reflexion'` frequently to critique your own logic, identify potential edge cases, and challenge your assumptions.
 - **Tree of Thoughts:** For critical architectural decisions, use branching to explore multiple paths (Conservative vs. Aggressive) and evaluate them using `thoughtType: 'evaluation'`.
+- **Loop Breaker:** If a bug persists after 2 attempts or reasoning loops, MUST create a new branch (`branchFromThought`) to change strategy completely.
 - **Verified Completion:** Only set `nextThoughtNeeded: false` when the solution is definitive, verified, and follows project standards.
 
 ## 🏗 CODEBASE INTELLIGENCE PROTOCOL
@@ -185,10 +194,11 @@ You are a Senior AI Software Engineer equipped with the Sequential Thinking MCP
 
 ## 📝 PERSISTENT MEMORY
 - **Long-term Knowledge:** Use `manage_notes` to save architectural decisions, user preferences, project conventions, and "lessons learned" that must persist across sessions.
+- **Code Database:** Use `add_code_snippet` to store reusable patterns and `search_code_db` to retrieve them.
 - **Session Continuity:** Your thought history is saved. If you restart, review the history to maintain context.
 ```
 
 ---
 
 ## License
-MIT - พัฒนาโดย @gotza02
+MIT - พัฒนาโดย @gotza02/sequential-thinking

package/dist/codestore.js

@@ -0,0 +1,69 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { AsyncMutex } from './utils.js';
+export class CodeDatabase {
+    filePath;
+    db = { snippets: [], patterns: {} };
+    loaded = false;
+    mutex = new AsyncMutex();
+    constructor(storagePath = 'code_database.json') {
+        this.filePath = path.resolve(storagePath);
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        try {
+            const data = await fs.readFile(this.filePath, 'utf-8');
+            this.db = JSON.parse(data);
+        }
+        catch (error) {
+            this.db = { snippets: [], patterns: {} };
+        }
+        this.loaded = true;
+    }
+    async save() {
+        await fs.writeFile(this.filePath, JSON.stringify(this.db, null, 2), 'utf-8');
+    }
+    async addSnippet(snippet) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const newSnippet = {
+                ...snippet,
+                id: Math.random().toString(36).substring(2, 9),
+                updatedAt: new Date().toISOString()
+            };
+            this.db.snippets.push(newSnippet);
+            await this.save();
+            return newSnippet;
+        });
+    }
+    async searchSnippets(query) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const q = query.toLowerCase();
+            return this.db.snippets.filter(s => s.title.toLowerCase().includes(q) ||
+                s.description.toLowerCase().includes(q) ||
+                s.tags.some(t => t.toLowerCase().includes(q)) ||
+                s.code.toLowerCase().includes(q));
+        });
+    }
+    async learnPattern(name, description) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            this.db.patterns[name] = description;
+            await this.save();
+        });
+    }
+    async getPattern(name) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            return this.db.patterns[name] || null;
+        });
+    }
+    async listAllPatterns() {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            return this.db.patterns;
+        });
+    }
+}

package/dist/codestore.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { CodeDatabase } from './codestore.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('CodeDatabase', () => {
+    let db;
+    const testPath = 'test_code_db.json';
+    let mockStore = '{"snippets": [], "patterns": {}}';
+    beforeEach(() => {
+        mockStore = '{"snippets": [], "patterns": {}}';
+        fs.readFile.mockImplementation(async () => mockStore);
+        fs.writeFile.mockImplementation(async (path, data) => {
+            mockStore = data;
+        });
+        db = new CodeDatabase(testPath);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should add a code snippet', async () => {
+        const snippet = await db.addSnippet({
+            title: "Quick Sort",
+            language: "typescript",
+            code: "function sort() {}",
+            description: "A sorting algorithm",
+            tags: ["algo"]
+        });
+        expect(snippet.id).toBeDefined();
+        expect(snippet.title).toBe("Quick Sort");
+        const stored = JSON.parse(mockStore);
+        expect(stored.snippets).toHaveLength(1);
+    });
+    it('should search snippets', async () => {
+        await db.addSnippet({
+            title: "React Hook",
+            language: "ts",
+            code: "const useX = () => {}",
+            description: "Custom hook",
+            tags: ["react"]
+        });
+        await db.addSnippet({
+            title: "Python Script",
+            language: "py",
+            code: "print('hello')",
+            description: "Hello world",
+            tags: ["python"]
+        });
+        const results = await db.searchSnippets("hook");
+        expect(results).toHaveLength(1);
+        expect(results[0].title).toBe("React Hook");
+    });
+    it('should learn and retrieve patterns', async () => {
+        await db.learnPattern("Repository Pattern", "Separate data access from business logic.");
+        const pattern = await db.getPattern("Repository Pattern");
+        expect(pattern).toContain("Separate data access");
+        const all = await db.listAllPatterns();
+        expect(all["Repository Pattern"]).toBeDefined();
+    });
+});

package/dist/filesystem.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
+import { validatePath } from './utils.js';
+import * as path from 'path';
+describe('FileSystem Security', () => {
+    // Mock process.cwd to be a known fixed path
+    const mockCwd = '/app/project';
+    // We need to spy on process.cwd and path.resolve behavior if we want to be strict,
+    // but validatePath uses path.resolve(requestedPath).
+    // Let's just mock path.resolve to behave as expected, or trust the real path module 
+    // but ensure we set up the cwd check correctly.
+    // The easiest way is to mock process.cwd().
+    const originalCwd = process.cwd;
+    beforeEach(() => {
+        vi.spyOn(process, 'cwd').mockReturnValue(mockCwd);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should allow paths within the project root', () => {
+        const p = validatePath('src/index.ts');
+        expect(p).toBe(path.resolve(mockCwd, 'src/index.ts'));
+    });
+    it('should allow explicit ./ paths', () => {
+        const p = validatePath('./package.json');
+        expect(p).toBe(path.resolve(mockCwd, 'package.json'));
+    });
+    it('should block traversal to parent directory', () => {
+        expect(() => {
+            validatePath('../outside.txt');
+        }).toThrow(/Access denied/);
+    });
+    it('should block multiple level traversal', () => {
+        expect(() => {
+            validatePath('src/../../etc/passwd');
+        }).toThrow(/Access denied/);
+    });
+    it('should block absolute paths outside root', () => {
+        // path.resolve('/etc/passwd') returns '/etc/passwd' on linux-like
+        // path.resolve('C:/Windows') on windows...
+        // We rely on path.resolve behavior.
+        // If system is linux-like:
+        if (path.sep === '/') {
+            expect(() => {
+                validatePath('/etc/passwd');
+            }).toThrow(/Access denied/);
+        }
+    });
+});

package/dist/graph.js

@@ -103,6 +103,14 @@ export class ProjectKnowledgeGraph {
                         }
                     }
                 }
+                // 4. Import Equals: import x = require('...')
+                else if (ts.isImportEqualsDeclaration(node)) {
+                    if (ts.isExternalModuleReference(node.moduleReference)) {
+                        if (ts.isStringLiteral(node.moduleReference.expression)) {
+                            imports.push(node.moduleReference.expression.text);
+                        }
+                    }
+                }
                 ts.forEachChild(node, visit);
             };
             visit(sourceFile);
@@ -121,13 +129,13 @@ export class ProjectKnowledgeGraph {
             // Basic Regex for generic symbols and imports
             if (ext === '.py') {
                 // Python: import x, from x import y, def func, class Cls
-                const importMatches = content.matchAll(/^(?:import|from)\s+([a-zA-Z0-9_.]+)/gm);
+                const importMatches = content.matchAll(/^\s*(?:import|from)\s+([a-zA-Z0-9_.]+)/gm);
                 for (const match of importMatches)
                     imports.push(match[1]);
-                const funcMatches = content.matchAll(/^def\s+([a-zA-Z0-9_]+)/gm);
+                const funcMatches = content.matchAll(/^\s*def\s+([a-zA-Z0-9_]+)/gm);
                 for (const match of funcMatches)
                     symbols.push(`def:${match[1]}`);
-                const classMatches = content.matchAll(/^class\s+([a-zA-Z0-9_]+)/gm);
+                const classMatches = content.matchAll(/^\s*class\s+([a-zA-Z0-9_]+)/gm);
                 for (const match of classMatches)
                     symbols.push(`class:${match[1]}`);
             }
@@ -136,7 +144,7 @@ export class ProjectKnowledgeGraph {
                 const importMatches = content.matchAll(/import\s+"([^"]+)"/g);
                 for (const match of importMatches)
                     imports.push(match[1]);
-                const funcMatches = content.matchAll(/^func\s+([a-zA-Z0-9_]+)/gm);
+                const funcMatches = content.matchAll(/^\s*func\s+([a-zA-Z0-9_]+)/gm);
                 for (const match of funcMatches)
                     symbols.push(`func:${match[1]}`);
             }
@@ -176,7 +184,7 @@ export class ProjectKnowledgeGraph {
             return absolutePath;
         }
         // 2. Try appending extensions
-        const extensions = ['.ts', '.js', '.tsx', '.jsx', '.json', '/index.ts', '/index.js'];
+        const extensions = ['.ts', '.js', '.tsx', '.jsx', '.json', '.py', '.go', '.rs', '.java', '.c', '.cpp', '.h', '/index.ts', '/index.js'];
         for (const ext of extensions) {
             const p = absolutePath + ext;
             if (this.nodes.has(p)) {

package/dist/graph.test.js

@@ -76,4 +76,57 @@ describe('ProjectKnowledgeGraph', () => {
         const relationships = graph.getRelationships('/app/index.js');
         expect(relationships?.imports).toContain('Button.jsx');
     });
+    it('should handle circular dependencies', async () => {
+        const contentA = `import { b } from './b'; export const a = 1;`;
+        const contentB = `import { a } from './a'; export const b = 2;`;
+        fs.readdir.mockResolvedValue([
+            { name: 'a.ts', isDirectory: () => false },
+            { name: 'b.ts', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.endsWith('a.ts'))
+                return contentA;
+            if (filePath.endsWith('b.ts'))
+                return contentB;
+            return '';
+        });
+        await graph.build('/app');
+        const relA = graph.getRelationships('/app/a.ts');
+        const relB = graph.getRelationships('/app/b.ts');
+        expect(relA?.imports).toContain('b.ts');
+        expect(relA?.importedBy).toContain('b.ts');
+        expect(relB?.imports).toContain('a.ts');
+        expect(relB?.importedBy).toContain('a.ts');
+    });
+    it('should gracefully handle missing imports', async () => {
+        const contentA = `import { ghost } from './ghost';`;
+        fs.readdir.mockResolvedValue([
+            { name: 'a.ts', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.endsWith('a.ts'))
+                return contentA;
+            return '';
+        });
+        await graph.build('/app');
+        const relA = graph.getRelationships('/app/a.ts');
+        // ghost.ts doesn't exist, so imports should be empty (filtered out)
+        expect(relA?.imports).toHaveLength(0);
+    });
+    it('should ignore directory traversal attempts outside root', async () => {
+        // If we pretend root is /app, and we try to import ../outside
+        const contentA = `import { secret } from '../secret';`;
+        fs.readdir.mockResolvedValue([
+            { name: 'a.ts', isDirectory: () => false }
+        ]);
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.endsWith('a.ts'))
+                return contentA;
+            return '';
+        });
+        await graph.build('/app');
+        const relA = graph.getRelationships('/app/a.ts');
+        // Should be empty because '../secret' is not in the scanned file list (nodes)
+        expect(relA?.imports).toHaveLength(0);
+    });
 });

package/dist/index.js

@@ -4,12 +4,14 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { SequentialThinkingServer } from './lib.js';
 import { ProjectKnowledgeGraph } from './graph.js';
 import { NotesManager } from './notes.js';
+import { CodeDatabase } from './codestore.js';
 import { registerThinkingTools } from './tools/thinking.js';
 import { registerWebTools } from './tools/web.js';
 import { registerFileSystemTools } from './tools/filesystem.js';
 import { registerGraphTools } from './tools/graph.js';
 import { registerNoteTools } from './tools/notes.js';
 import { registerCodingTools } from './tools/coding.js';
+import { registerCodeDbTools } from './tools/codestore.js';
 const server = new McpServer({
     name: "sequential-thinking-server",
     version: "2026.2.6",
@@ -17,6 +19,7 @@ const server = new McpServer({
 const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json', parseInt(process.env.THOUGHT_DELAY_MS || '0', 10));
 const knowledgeGraph = new ProjectKnowledgeGraph();
 const notesManager = new NotesManager(process.env.NOTES_STORAGE_PATH || 'project_notes.json');
+const codeDb = new CodeDatabase(process.env.CODE_DB_PATH || 'code_database.json');
 // Register tools
 registerThinkingTools(server, thinkingServer);
 registerWebTools(server);
@@ -24,6 +27,7 @@ registerFileSystemTools(server);
 registerGraphTools(server, knowledgeGraph);
 registerNoteTools(server, notesManager);
 registerCodingTools(server, knowledgeGraph);
+registerCodeDbTools(server, codeDb);
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/integration.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// We need to import the register functions to get the callbacks, 
+// but we can just use the classes directly for this integration logic test.
+// Actually, testing the *interaction* via the tool layer is better.
+import { registerThinkingTools } from './tools/thinking.js';
+import { registerGraphTools } from './tools/graph.js';
+import { registerNoteTools } from './tools/notes.js';
+describe('Integration Workflow', () => {
+    let toolCallbacks = {};
+    const mockServer = {
+        tool: (name, desc, schema, cb) => {
+            toolCallbacks[name] = cb;
+        }
+    };
+    // Mocks
+    const mockThinking = { processThought: vi.fn(), clearHistory: vi.fn() };
+    const mockGraph = { build: vi.fn(), getRelationships: vi.fn() };
+    const mockNotes = { addNote: vi.fn() };
+    beforeEach(() => {
+        toolCallbacks = {};
+        registerThinkingTools(mockServer, mockThinking);
+        registerGraphTools(mockServer, mockGraph);
+        registerNoteTools(mockServer, mockNotes);
+        vi.clearAllMocks();
+    });
+    it('should support a full analysis workflow', async () => {
+        // Step 1: Start Thinking
+        mockThinking.processThought.mockResolvedValue({
+            content: [{ type: "text", text: "Thought processed" }]
+        });
+        await toolCallbacks['sequentialthinking']({
+            thought: "Analyze architecture",
+            thoughtNumber: 1,
+            totalThoughts: 5,
+            nextThoughtNeeded: true,
+            thoughtType: 'analysis'
+        });
+        expect(mockThinking.processThought).toHaveBeenCalledWith(expect.objectContaining({
+            thought: "Analyze architecture"
+        }));
+        // Step 2: Build Graph
+        mockGraph.build.mockResolvedValue({ nodeCount: 10, totalFiles: 20 });
+        await toolCallbacks['build_project_graph']({ path: '.' });
+        expect(mockGraph.build).toHaveBeenCalled();
+        // Step 3: Get Relationships
+        mockGraph.getRelationships.mockReturnValue({ imports: ['utils.ts'] });
+        const relResult = await toolCallbacks['get_file_relationships']({ filePath: 'src/index.ts' });
+        expect(JSON.parse(relResult.content[0].text).imports).toContain('utils.ts');
+        // Step 4: Add Note
+        mockNotes.addNote.mockResolvedValue({ id: '123', title: 'Arch Note' });
+        await toolCallbacks['manage_notes']({
+            action: 'add',
+            title: 'Architecture Review',
+            content: 'Found circular deps'
+        });
+        expect(mockNotes.addNote).toHaveBeenCalledWith('Architecture Review', 'Found circular deps', undefined, undefined, undefined);
+    });
+});

package/dist/lib.js

@@ -9,6 +9,7 @@ export class SequentialThinkingServer {
     storagePath;
     delayMs;
     isSaving = false;
+    hasPendingSave = false;
     constructor(storagePath = 'thoughts_history.json', delayMs = 0) {
         this.disableThoughtLogging = (process.env.DISABLE_THOUGHT_LOGGING || "").toLowerCase() === "true";
         this.storagePath = path.resolve(storagePath);
@@ -33,8 +34,7 @@ export class SequentialThinkingServer {
     }
     async saveHistory() {
         if (this.isSaving) {
-            // Simple retry if already saving
-            setTimeout(() => this.saveHistory(), 100);
+            this.hasPendingSave = true;
             return;
         }
         this.isSaving = true;
@@ -49,6 +49,10 @@ export class SequentialThinkingServer {
         }
         finally {
             this.isSaving = false;
+            if (this.hasPendingSave) {
+                this.hasPendingSave = false;
+                this.saveHistory();
+            }
         }
     }
     async clearHistory() {
@@ -70,9 +74,30 @@ export class SequentialThinkingServer {
         // Remove the range and insert summary
         const removedCount = endIndex - startIndex + 1;
         this.thoughtHistory.splice(startIndex - 1, removedCount, summaryThought);
-        // Renumber subsequent thoughts
+        // Renumber subsequent thoughts and update references
+        const shiftAmount = removedCount - 1;
         for (let i = startIndex; i < this.thoughtHistory.length; i++) {
-            this.thoughtHistory[i].thoughtNumber -= (removedCount - 1);
+            const t = this.thoughtHistory[i];
+            // Update own number
+            t.thoughtNumber -= shiftAmount;
+            // Update references (branchFromThought)
+            if (t.branchFromThought) {
+                if (t.branchFromThought > endIndex) {
+                    t.branchFromThought -= shiftAmount;
+                }
+                else if (t.branchFromThought >= startIndex) {
+                    t.branchFromThought = startIndex; // Point to summary
+                }
+            }
+            // Update references (revisesThought)
+            if (t.revisesThought) {
+                if (t.revisesThought > endIndex) {
+                    t.revisesThought -= shiftAmount;
+                }
+                else if (t.revisesThought >= startIndex) {
+                    t.revisesThought = startIndex; // Point to summary
+                }
+            }
         }
         // Rebuild branches (simplification: clear and let it rebuild if needed, or just clear)
         this.branches = {};