@gotza02/sequential-thinking 2026.2.17 → 2026.2.19

package/README.md

@@ -4,7 +4,7 @@ Advanced MCP Server enabling AI to act as a Software Engineer with Deep Thinking
 
 ## ✨ Key Features
 - **Deep Thinking:** Step-by-step reasoning with auto-correction (Loop Breaker).
-- **Code Intelligence:** Dependency graph mapping (`build_project_graph`) & surgical code editing.
+- **Code Intelligence:** Dependency graph mapping (`build_project_graph`) with **Incremental Caching** & surgical code editing.
 - **Memory:** Long-term project notes, reusable code database, and thought history.
 - **Research:** Integrated Web search (Brave/Exa) & webpage reading.
 - **REST API:** Built-in HTTP server wrapper for easy integration with web tools and external services.
@@ -62,7 +62,7 @@ Add this to your MCP settings (`~/.gemini/settings.json` or `claude_desktop_conf
 
 ## 🛠️ Tools Summary
 - **Thinking:** `sequentialthinking`, `summarize_history`, `clear_thought_history`
-- **Code:** `build_project_graph`, `deep_code_analyze`, `deep_code_edit`, `search_code`
+- **Code:** `build_project_graph`, `deep_code_analyze`, `deep_code_edit`, `search_code` (Regex/Line Numbers)
 - **Memory:** `add_code_snippet`, `search_code_db`, `manage_notes`
 - **Web:** `web_search`, `read_webpage`, `fetch`
 - **System:** `read_file`, `write_file`, `edit_file`, `shell_execute`

package/dist/filesystem.test.js

@@ -113,22 +113,40 @@ describe('FileSystem Tools', () => {
         });
     });
     describe('search_code', () => {
-        it('should find pattern in single file', async () => {
+        it('should find pattern in single file with line number', async () => {
             registerFileSystemTools(mockServer);
             const handler = registeredTools['search_code'];
             fs.stat.mockResolvedValue({ isFile: () => true });
-            fs.readFile.mockResolvedValue('const x = "target";');
+            fs.readFile.mockResolvedValue('line1\nconst x = "target";\nline3');
             const result = await handler({ pattern: 'target', path: 'file.ts' });
-            expect(result.content[0].text).toContain('Found "target" in');
-            expect(result.content[0].text).toContain('file.ts');
+            expect(result.content[0].text).toContain('Found matches for "target"');
+            expect(result.content[0].text).toContain('file.ts:2: const x = "target";');
+        });
+        it('should use regex when requested', async () => {
+            registerFileSystemTools(mockServer);
+            const handler = registeredTools['search_code'];
+            fs.stat.mockResolvedValue({ isFile: () => true });
+            fs.readFile.mockResolvedValue('const x = 123;');
+            const result = await handler({ pattern: '\\d+', path: 'file.ts', useRegex: true });
+            expect(result.content[0].text).toContain('Found matches');
+            expect(result.content[0].text).toContain('file.ts:1: const x = 123;');
+        });
+        it('should handle case sensitivity', async () => {
+            registerFileSystemTools(mockServer);
+            const handler = registeredTools['search_code'];
+            fs.stat.mockResolvedValue({ isFile: () => true });
+            fs.readFile.mockResolvedValue('TARGET');
+            // Case sensitive search for lowercase 'target' should fail
+            const result = await handler({ pattern: 'target', path: 'file.ts', caseSensitive: true });
+            expect(result.content[0].text).toContain('No matches found');
+            // Case insensitive (default) should pass
+            const result2 = await handler({ pattern: 'target', path: 'file.ts', caseSensitive: false });
+            expect(result2.content[0].text).toContain('Found matches');
         });
         it('should recursively search directory ignoring node_modules', async () => {
             registerFileSystemTools(mockServer);
             const handler = registeredTools['search_code'];
-            // Mock file system structure
-            // Root -> [src (dir), node_modules (dir), root.ts (file)]
-            // src -> [deep.ts (file)]
-            fs.stat.mockResolvedValue({ isFile: () => false }); // Root is dir
+            fs.stat.mockResolvedValue({ isFile: () => false });
             fs.readdir.mockImplementation(async (dirPath) => {
                 if (dirPath.endsWith('src')) {
                     return [{ name: 'deep.ts', isDirectory: () => false }];
@@ -136,7 +154,6 @@ describe('FileSystem Tools', () => {
                 if (dirPath.endsWith('node_modules')) {
                     return [{ name: 'lib.ts', isDirectory: () => false }];
                 }
-                // Root
                 return [
                     { name: 'src', isDirectory: () => true },
                     { name: 'node_modules', isDirectory: () => true },
@@ -148,13 +165,11 @@ describe('FileSystem Tools', () => {
                     return 'no match';
                 if (filePath.includes('deep.ts'))
                     return 'const a = "target";';
-                if (filePath.includes('lib.ts'))
-                    return 'const a = "target";'; // Should be ignored
                 return '';
             });
             const result = await handler({ pattern: 'target', path: '.' });
-            expect(result.content[0].text).toContain('deep.ts');
-            expect(result.content[0].text).not.toContain('lib.ts'); // Should ignore node_modules
+            expect(result.content[0].text).toContain('deep.ts:1: const a = "target";');
+            expect(result.content[0].text).not.toContain('lib.ts');
         });
     });
     // Keeping original security tests if needed, or merging them.

package/dist/graph.js

@@ -4,16 +4,20 @@ import ts from 'typescript';
 export class ProjectKnowledgeGraph {
     nodes = new Map();
     rootDir = '';
+    cache = { version: '1.0', files: {} };
+    cachePath = '';
     constructor() { }
     async build(rootDir) {
         try {
             this.rootDir = path.resolve(rootDir);
+            this.cachePath = path.join(this.rootDir, '.gemini_graph_cache.json');
             // Check if rootDir exists and is a directory
             const stats = await fs.stat(this.rootDir);
             if (!stats.isDirectory()) {
                 throw new Error(`Path '${rootDir}' is not a directory.`);
             }
             this.nodes.clear();
+            await this.loadCache();
             const files = await this.getAllFiles(this.rootDir);
             // Step 1: Initialize nodes
             for (const file of files) {
@@ -24,15 +28,56 @@ export class ProjectKnowledgeGraph {
                     symbols: []
                 });
             }
-            // Step 2: Parse imports and build edges in parallel with concurrency limit
+            // Step 2: Identify files to parse vs cache hits
+            const filesToParse = [];
+            const extractionMap = new Map();
+            for (const file of files) {
+                try {
+                    const stats = await fs.stat(file);
+                    const cached = this.cache.files[file];
+                    if (cached && cached.mtime === stats.mtimeMs) {
+                        extractionMap.set(file, { imports: cached.imports, symbols: cached.symbols });
+                    }
+                    else {
+                        filesToParse.push(file);
+                    }
+                }
+                catch (e) {
+                    filesToParse.push(file);
+                }
+            }
+            // Step 3: Parse new/modified files concurrently
             const CONCURRENCY_LIMIT = 20;
-            for (let i = 0; i < files.length; i += CONCURRENCY_LIMIT) {
-                const chunk = files.slice(i, i + CONCURRENCY_LIMIT);
-                await Promise.all(chunk.map(file => this.parseFile(file)));
+            for (let i = 0; i < filesToParse.length; i += CONCURRENCY_LIMIT) {
+                const chunk = filesToParse.slice(i, i + CONCURRENCY_LIMIT);
+                await Promise.all(chunk.map(async (file) => {
+                    const data = await this.parseFile(file);
+                    extractionMap.set(file, data);
+                    // Update cache
+                    const stats = await fs.stat(file);
+                    this.cache.files[file] = {
+                        mtime: stats.mtimeMs,
+                        imports: data.imports,
+                        symbols: data.symbols
+                    };
+                }));
+            }
+            // Prune deleted files from cache
+            for (const cachedFile of Object.keys(this.cache.files)) {
+                if (!this.nodes.has(cachedFile)) {
+                    delete this.cache.files[cachedFile];
+                }
+            }
+            await this.saveCache();
+            // Step 4: Link Graph (Resolve imports and build importedBy)
+            for (const [filePath, data] of extractionMap.entries()) {
+                await this.linkFileNodes(filePath, data.imports, data.symbols);
             }
             return {
                 nodeCount: this.nodes.size,
-                totalFiles: files.length
+                totalFiles: files.length,
+                cachedFiles: files.length - filesToParse.length,
+                parsedFiles: filesToParse.length
             };
         }
         catch (error) {
@@ -40,6 +85,27 @@ export class ProjectKnowledgeGraph {
             throw error;
         }
     }
+    async loadCache() {
+        try {
+            const content = await fs.readFile(this.cachePath, 'utf-8');
+            const data = JSON.parse(content);
+            if (data.version === '1.0') {
+                this.cache = data;
+            }
+        }
+        catch (e) {
+            // Ignore cache errors (start fresh)
+            this.cache = { version: '1.0', files: {} };
+        }
+    }
+    async saveCache() {
+        try {
+            await fs.writeFile(this.cachePath, JSON.stringify(this.cache, null, 2), 'utf-8');
+        }
+        catch (e) {
+            console.error('Failed to save graph cache:', e);
+        }
+    }
     async getAllFiles(dir) {
         try {
             const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -58,6 +124,9 @@ export class ProjectKnowledgeGraph {
                 }
                 else {
                     if (/\.(ts|js|tsx|jsx|json|py|go|rs|java|c|cpp|h)$/.test(entry.name)) {
+                        // Ignore cache file itself
+                        if (entry.name === '.gemini_graph_cache.json')
+                            continue;
                         files.push(res);
                     }
                 }
@@ -72,10 +141,10 @@ export class ProjectKnowledgeGraph {
     async parseFile(filePath) {
         const ext = path.extname(filePath);
         if (['.ts', '.js', '.tsx', '.jsx'].includes(ext)) {
-            await this.parseTypeScript(filePath);
+            return await this.parseTypeScript(filePath);
         }
         else {
-            await this.parseGeneric(filePath);
+            return await this.parseGeneric(filePath);
         }
     }
     async parseTypeScript(filePath) {
@@ -138,10 +207,11 @@ export class ProjectKnowledgeGraph {
                 ts.forEachChild(node, visit);
             };
             visit(sourceFile);
-            await this.finalizeFileNodes(filePath, imports, symbols);
+            return { imports, symbols };
         }
         catch (error) {
             console.error(`Error parsing TypeScript file ${filePath}:`, error);
+            return { imports: [], symbols: [] };
         }
     }
     async parseGeneric(filePath) {
@@ -176,14 +246,14 @@ export class ProjectKnowledgeGraph {
             else if (ext === '.go') {
                 // 1. Go Imports
                 // Single line: import "fmt"
-                const singleImportMatches = content.matchAll(/import\s+"([^"]+)"/g);
+                const singleImportMatches = content.matchAll(/import\s+\"([^\"]+)\"/g);
                 for (const match of singleImportMatches)
                     imports.push(match[1]);
                 // Block: import ( "fmt"; "os" )
                 const blockImportMatches = content.matchAll(/import\s+\(([\s\S]*?)\)/g);
                 for (const match of blockImportMatches) {
                     const block = match[1];
-                    const innerMatches = block.matchAll(/"([^"]+)"/g);
+                    const innerMatches = block.matchAll(/"([^\"]+)"/g);
                     for (const im of innerMatches)
                         imports.push(im[1]);
                 }
@@ -197,18 +267,19 @@ export class ProjectKnowledgeGraph {
                 for (const match of typeMatches)
                     symbols.push(`type:${match[1]}`);
             }
-            await this.finalizeFileNodes(filePath, imports, symbols);
+            return { imports, symbols };
         }
         catch (error) {
             console.error(`Error parsing generic file ${filePath}:`, error);
+            return { imports: [], symbols: [] };
         }
     }
-    async finalizeFileNodes(filePath, imports, symbols) {
+    async linkFileNodes(filePath, rawImports, symbols) {
         const currentNode = this.nodes.get(filePath);
         if (!currentNode)
             return;
         currentNode.symbols = symbols;
-        for (const importPath of imports) {
+        for (const importPath of rawImports) {
             let resolvedPath = null;
             if (importPath.startsWith('.')) {
                 resolvedPath = await this.resolvePath(path.dirname(filePath), importPath);
@@ -225,9 +296,12 @@ export class ProjectKnowledgeGraph {
                 }
             }
             else {
-                // If we can't resolve to a local file, keep the original import string as an external dependency
-                if (!currentNode.imports.includes(importPath)) {
-                    currentNode.imports.push(importPath);
+                // If we can't resolve to a local file, keep the original import string ONLY if it looks like an external package
+                // Ignore relative paths that failed to resolve (broken links)
+                if (!importPath.startsWith('.') && !path.isAbsolute(importPath)) {
+                    if (!currentNode.imports.includes(importPath)) {
+                        currentNode.imports.push(importPath);
+                    }
                 }
             }
         }

package/dist/graph.test.js

@@ -7,6 +7,12 @@ describe('ProjectKnowledgeGraph', () => {
     beforeEach(() => {
         graph = new ProjectKnowledgeGraph();
         vi.resetAllMocks();
+        // Default mocks for stat and writeFile
+        fs.stat.mockResolvedValue({
+            isDirectory: () => true,
+            mtimeMs: 1000
+        });
+        fs.writeFile.mockResolvedValue(undefined);
     });
     it('should ignore imports in comments', async () => {
         const mockFiles = ['/app/index.ts', '/app/utils.ts', '/app/oldUtils.ts'];
@@ -22,6 +28,8 @@ describe('ProjectKnowledgeGraph', () => {
             { name: 'oldUtils.ts', isDirectory: () => false }
         ]);
         fs.readFile.mockImplementation(async (path) => {
+            if (path.includes('graph_cache.json'))
+                return '{}'; // Mock empty cache
             if (path.includes('index.ts'))
                 return mockContentIndex;
             return '';
@@ -50,6 +58,8 @@ describe('ProjectKnowledgeGraph', () => {
             { name: 'lib.ts', isDirectory: () => false }
         ]);
         fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.includes('graph_cache.json'))
+                return '{}';
             if (filePath.endsWith('index.ts'))
                 return mockContentIndex;
             return '';
@@ -68,6 +78,8 @@ describe('ProjectKnowledgeGraph', () => {
             { name: 'Button.jsx', isDirectory: () => false }
         ]);
         fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.includes('graph_cache.json'))
+                return '{}';
             if (filePath.endsWith('index.js'))
                 return mockContentIndex;
             return '';
@@ -84,6 +96,8 @@ describe('ProjectKnowledgeGraph', () => {
             { name: 'b.ts', isDirectory: () => false }
         ]);
         fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.includes('graph_cache.json'))
+                return '{}';
             if (filePath.endsWith('a.ts'))
                 return contentA;
             if (filePath.endsWith('b.ts'))
@@ -104,6 +118,8 @@ describe('ProjectKnowledgeGraph', () => {
             { name: 'a.ts', isDirectory: () => false }
         ]);
         fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.includes('graph_cache.json'))
+                return '{}';
             if (filePath.endsWith('a.ts'))
                 return contentA;
             return '';
@@ -120,6 +136,8 @@ describe('ProjectKnowledgeGraph', () => {
             { name: 'a.ts', isDirectory: () => false }
         ]);
         fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.includes('graph_cache.json'))
+                return '{}';
             if (filePath.endsWith('a.ts'))
                 return contentA;
             return '';

package/dist/tools/filesystem.js

@@ -7,7 +7,7 @@ export function registerFileSystemTools(server) {
     server.tool("shell_execute", "Execute a shell command. SECURITY WARNING: Use this ONLY for safe, non-destructive commands. Avoid 'rm -rf /', format, or destructive operations.", {
         command: z.string().describe("The bash command to execute")
     }, async ({ command }) => {
-        const dangerousPatterns = [/rm\s+-rf\s+\//, /mkfs/, /dd\s+if=/];
+        const dangerousPatterns = [new RegExp('rm\\s+-rf\\s+\\/'), /mkfs/, /dd\s+if=/];
         if (dangerousPatterns.some(p => p.test(command))) {
             return {
                 content: [{ type: "text", text: "Error: Dangerous command pattern detected. Execution blocked for safety." }],
@@ -68,47 +68,65 @@ export function registerFileSystemTools(server) {
         }
     });
     // 10. search_code
-    server.tool("search_code", "Search for a text pattern in project files (excludes node_modules, etc.).", {
-        pattern: z.string().describe("The text to search for"),
-        path: z.string().optional().default('.').describe("Root directory to search")
-    }, async ({ pattern, path: searchPath }) => {
+    server.tool("search_code", "Search for a text pattern in project files with advanced options (regex, case sensitivity).", {
+        pattern: z.string().describe("The text or regex pattern to search for"),
+        path: z.string().optional().default('.').describe("Root directory to search"),
+        useRegex: z.boolean().optional().default(false).describe("Treat pattern as a regular expression"),
+        caseSensitive: z.boolean().optional().default(false).describe("Match case sensitive (default: false)")
+    }, async ({ pattern, path: searchPath, useRegex, caseSensitive }) => {
         try {
             const resolvedPath = validatePath(searchPath || '.');
             const stats = await fs.stat(resolvedPath);
+            const results = [];
+            const searchFile = async (filePath) => {
+                try {
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const lines = content.split('\n');
+                    let regex;
+                    if (useRegex) {
+                        regex = new RegExp(pattern, caseSensitive ? 'g' : 'gi');
+                    }
+                    else {
+                        // Escape regex special chars if not using regex
+                        const escaped = pattern.replace(/[.*+?^${}()|[\\]/g, '\\$&');
+                        regex = new RegExp(escaped, caseSensitive ? 'g' : 'gi');
+                    }
+                    lines.forEach((line, index) => {
+                        if (regex.test(line)) {
+                            // Reset lastIndex if global (not strictly needed for test() but good practice)
+                            regex.lastIndex = 0;
+                            results.push(`${filePath}:${index + 1}: ${line.trim()}`);
+                        }
+                    });
+                }
+                catch (err) {
+                    // Ignore read errors (binary files etc)
+                }
+            };
             if (stats.isFile()) {
-                const content = await fs.readFile(resolvedPath, 'utf-8');
-                const matches = content.includes(pattern) ? [resolvedPath] : [];
-                return {
-                    content: [{
-                            type: "text",
-                            text: matches.length > 0 ? `Found "${pattern}" in:\n${matches.join('\n')}` : `No matches found for "${pattern}"`
-                        }]
-                };
+                await searchFile(resolvedPath);
             }
-            async function searchDir(dir) {
-                const results = [];
-                const entries = await fs.readdir(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    const fullPath = path.join(dir, entry.name);
-                    if (entry.isDirectory()) {
-                        if (['node_modules', '.git', 'dist', 'coverage', '.gemini'].includes(entry.name))
-                            continue;
-                        results.push(...await searchDir(fullPath));
-                    }
-                    else if (/\.(ts|js|json|md|txt|html|css|py|java|c|cpp|h|rs|go)$/.test(entry.name)) {
-                        const content = await fs.readFile(fullPath, 'utf-8');
-                        if (content.includes(pattern)) {
-                            results.push(fullPath);
+            else {
+                const searchDir = async (dir) => {
+                    const entries = await fs.readdir(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const fullPath = path.join(dir, entry.name);
+                        if (entry.isDirectory()) {
+                            if (['node_modules', '.git', 'dist', 'coverage', '.gemini'].includes(entry.name))
+                                continue;
+                            await searchDir(fullPath);
+                        }
+                        else if (/\.(ts|js|json|md|txt|html|css|py|java|c|cpp|h|rs|go|sh|yaml|yml)$/.test(entry.name)) {
+                            await searchFile(fullPath);
                         }
                     }
-                }
-                return results;
+                };
+                await searchDir(resolvedPath);
             }
-            const matches = await searchDir(resolvedPath);
             return {
                 content: [{
                         type: "text",
-                        text: matches.length > 0 ? `Found "${pattern}" in:\n${matches.join('\n')}` : `No matches found for "${pattern}"`
+                        text: results.length > 0 ? `Found matches for "${pattern}":\n${results.join('\n')}` : `No matches found for "${pattern}"`
                     }]
             };
         }

package/dist/verify_cache.test.js

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { ProjectKnowledgeGraph } from './graph.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+describe('Graph Caching Verification', () => {
+    it('should use cache on second run', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const root = process.cwd();
+        // Cleanup existing cache
+        const cachePath = path.join(root, '.gemini_graph_cache.json');
+        try {
+            await fs.unlink(cachePath);
+        }
+        catch (e) { }
+        console.log('--- Run 1 (Fresh) ---');
+        const res1 = await graph.build(root);
+        console.log('Result 1:', res1);
+        expect(res1.parsedFiles).toBeGreaterThan(0);
+        expect(res1.cachedFiles).toBe(0);
+        console.log('--- Run 2 (Cached) ---');
+        const res2 = await graph.build(root);
+        console.log('Result 2:', res2);
+        expect(res2.parsedFiles).toBe(0);
+        expect(res2.cachedFiles).toBeGreaterThan(0);
+        expect(res2.nodeCount).toBe(res1.nodeCount);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "2026.2.17",
+  "version": "2026.2.19",
   "publishConfig": {
     "access": "public"
   },