@gotza02/sequential-thinking 2026.1.28 → 2026.1.31

package/README.md

@@ -96,23 +96,10 @@ Reads a webpage and converts it to clean Markdown, removing ads and navigation.
 - `path` (string, optional): Root directory (defaults to `.`).
 
 #### `get_project_graph_summary`
-Returns high-level stats: total files and the top 5 most-referenced files. Use this to identify the "core" modules of the application.
+Get overview of project structure and most referenced files.
 
-#### `get_file_relationships`
-Zoom in on a specific file to see its context.
-
-**Inputs:**
-- `filePath` (string, required): Path to the file (e.g., `src/index.ts`).
-**Returns:**
-- `imports`: What this file needs.
-- `importedBy`: Who relies on this file.
-
-#### `search_code`
-Searches for a text pattern across all code files in the project. Useful for finding usage examples or specific logic.
-
-**Inputs:**
-- `pattern` (string, required): Text to search for.
-- `path` (string, optional): Root directory (defaults to `.`).
+#### `get_project_graph_visualization`
+Get a Mermaid Diagram string representing the project's dependency graph. You can render this string in a Markdown viewer that supports Mermaid.
 
 ### 🛠 System Operations
 
@@ -129,6 +116,26 @@ Creates or overwrites a file.
 - `path` (string, required): File path.
 - `content` (string, required): The full content to write.
 
+#### `edit_file`
+Replace a specific string in a file with a new string. Use this for surgical edits to avoid overwriting the whole file.
+
+**Inputs:**
+- `path` (string, required): File path.
+- `oldText` (string, required): The exact text segment to replace.
+- `newText` (string, required): The new text to insert.
+- `allowMultiple` (boolean, optional): Allow replacing multiple occurrences (default: false).
+
+#### `manage_notes`
+Manage long-term memory/notes. Use this to save important information, rules, or learnings that should persist across sessions.
+
+**Inputs:**
+- `action` (enum, required): 'add', 'list', 'search', 'update', 'delete'.
+- `title` (string): Title of the note.
+- `content` (string): Content of the note.
+- `tags` (array): Tags for categorization.
+- `searchQuery` (string): Query to search notes.
+- `noteId` (string): ID of the note.
+
 #### `shell_execute`
 Executes a shell command. Use for running tests (`npm test`), building (`npm run build`), or file operations (`ls`, `mkdir`).
 
@@ -222,6 +229,18 @@ npm run build
 npm test
 ```
 
+## Recent Updates (v2026.1.31)
+- **New Tools**:
+  - `manage_notes`: Long-term memory system to store and retrieve information across sessions.
+
+## Recent Updates (v2026.1.30)
+- **New Tools**:
+  - `get_project_graph_visualization`: Generate Mermaid diagrams of your project structure.
+
+## Recent Updates (v2026.1.29)
+- **New Tools**:
+  - `edit_file`: Surgically replace text in files without overwriting the entire content.
+
 ## Recent Updates (v2026.1.28)
 - **Robustness**:
   - Implemented **Atomic Writes** for `thoughts_history.json` to prevent file corruption.

package/dist/graph.js

@@ -186,4 +186,29 @@ export class ProjectKnowledgeGraph {
             }))
         };
     }
+    toMermaid() {
+        const lines = ['graph TD'];
+        const fileToId = new Map();
+        let idCounter = 0;
+        // Assign IDs
+        for (const [filePath, _] of this.nodes) {
+            const relative = path.relative(this.rootDir, filePath);
+            const id = `N${idCounter++}`;
+            fileToId.set(filePath, id);
+            // Escape quotes in label
+            const label = relative.replace(/"/g, "'");
+            lines.push(`  ${id}["${label}"]`);
+        }
+        // Add Edges
+        for (const [filePath, node] of this.nodes) {
+            const sourceId = fileToId.get(filePath);
+            for (const importPath of node.imports) {
+                const targetId = fileToId.get(importPath);
+                if (sourceId && targetId) {
+                    lines.push(`  ${sourceId} --> ${targetId}`);
+                }
+            }
+        }
+        return lines.join('\\n');
+    }
 }

package/dist/index.js

@@ -7,6 +7,7 @@ import * as fs from 'fs/promises';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { ProjectKnowledgeGraph } from './graph.js';
+import { NotesManager } from './notes.js';
 import * as path from 'path';
 import { JSDOM } from 'jsdom';
 import { Readability } from '@mozilla/readability';
@@ -50,6 +51,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');
 // --- Sequential Thinking Tool ---
 server.tool("sequentialthinking", `A detailed tool for dynamic and reflective problem-solving through thoughts.
 This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
@@ -137,7 +139,7 @@ You should:
 // --- New Tools ---
 // 1. web_search
 server.tool("web_search", "Search the web using Brave or Exa APIs (requires API keys in environment variables: BRAVE_API_KEY or EXA_API_KEY).", {
-    query: z.string().describe("The search query"),
+    query: z.string().min(1).describe("The search query"),
     provider: z.enum(['brave', 'exa', 'google']).optional().describe("Preferred search provider")
 }, async ({ query, provider }) => {
     try {
@@ -385,6 +387,18 @@ server.tool("search_code", "Search for a text pattern in project files (excludes
     path: z.string().optional().default('.').describe("Root directory to search")
 }, async ({ pattern, path: searchPath }) => {
     try {
+        const resolvedPath = path.resolve(searchPath || '.');
+        const stats = await fs.stat(resolvedPath);
+        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}"`
+                    }]
+            };
+        }
         async function searchDir(dir) {
             const results = [];
             const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -404,7 +418,7 @@ server.tool("search_code", "Search for a text pattern in project files (excludes
             }
             return results;
         }
-        const matches = await searchDir(path.resolve(searchPath || '.'));
+        const matches = await searchDir(resolvedPath);
         return {
             content: [{
                     type: "text",
@@ -445,6 +459,118 @@ server.tool("summarize_history", "Compress multiple thoughts into a single summa
         };
     }
 });
+// 13. edit_file
+server.tool("edit_file", "Replace a specific string in a file with a new string. Use this for surgical edits to avoid overwriting the whole file.", {
+    path: z.string().describe("Path to the file"),
+    oldText: z.string().describe("The exact text segment to replace"),
+    newText: z.string().describe("The new text to insert"),
+    allowMultiple: z.boolean().optional().default(false).describe("Allow replacing multiple occurrences (default: false)")
+}, async ({ path, oldText, newText, allowMultiple }) => {
+    try {
+        const content = await fs.readFile(path, 'utf-8');
+        // Check occurrences
+        // Escape special regex characters in oldText to treat it as literal string
+        const escapeRegExp = (string) => string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(escapeRegExp(oldText), 'g');
+        const matchCount = (content.match(regex) || []).length;
+        if (matchCount === 0) {
+            return {
+                content: [{ type: "text", text: "Error: 'oldText' not found in the file. Please ensure exact matching (including whitespace/indentation)." }],
+                isError: true
+            };
+        }
+        if (matchCount > 1 && !allowMultiple) {
+            return {
+                content: [{ type: "text", text: `Error: Found ${matchCount} occurrences of 'oldText'. Set 'allowMultiple' to true if you intend to replace all, or provide more unique context in 'oldText'.` }],
+                isError: true
+            };
+        }
+        const newContent = content.replace(allowMultiple ? regex : oldText, newText);
+        await fs.writeFile(path, newContent, 'utf-8');
+        return {
+            content: [{ type: "text", text: `Successfully replaced ${allowMultiple ? matchCount : 1} occurrence(s) in ${path}` }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Edit Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+        };
+    }
+});
+// 14. get_project_graph_visualization
+server.tool("get_project_graph_visualization", "Get a Mermaid Diagram string representing the project's dependency graph. You can render this string in a Markdown viewer that supports Mermaid.", {}, async () => {
+    try {
+        const diagram = knowledgeGraph.toMermaid();
+        if (diagram.trim() === 'graph TD') {
+            return {
+                content: [{ type: "text", text: "Graph is empty. Please run 'build_project_graph' first." }],
+                isError: true
+            };
+        }
+        return {
+            content: [{ type: "text", text: diagram }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+        };
+    }
+});
+// 15. manage_notes
+server.tool("manage_notes", "Manage long-term memory/notes. Use this to save important information, rules, or learnings that should persist across sessions.", {
+    action: z.enum(['add', 'list', 'search', 'update', 'delete']).describe("Action to perform"),
+    title: z.string().optional().describe("Title of the note (for add/update)"),
+    content: z.string().optional().describe("Content of the note (for add/update)"),
+    tags: z.array(z.string()).optional().describe("Tags for categorization (for add/update)"),
+    searchQuery: z.string().optional().describe("Query to search notes (for search)"),
+    noteId: z.string().optional().describe("ID of the note (for update/delete)")
+}, async ({ action, title, content, tags, searchQuery, noteId }) => {
+    try {
+        switch (action) {
+            case 'add':
+                if (!title || !content) {
+                    return { content: [{ type: "text", text: "Error: 'title' and 'content' are required for add action." }], isError: true };
+                }
+                const newNote = await notesManager.addNote(title, content, tags);
+                return { content: [{ type: "text", text: `Note added successfully.\nID: ${newNote.id}` }] };
+            case 'list':
+                const notes = await notesManager.listNotes();
+                return { content: [{ type: "text", text: JSON.stringify(notes, null, 2) }] };
+            case 'search':
+                if (!searchQuery) {
+                    return { content: [{ type: "text", text: "Error: 'searchQuery' is required for search action." }], isError: true };
+                }
+                const searchResults = await notesManager.searchNotes(searchQuery);
+                return { content: [{ type: "text", text: searchResults.length > 0 ? JSON.stringify(searchResults, null, 2) : "No matching notes found." }] };
+            case 'update':
+                if (!noteId) {
+                    return { content: [{ type: "text", text: "Error: 'noteId' is required for update action." }], isError: true };
+                }
+                const updatedNote = await notesManager.updateNote(noteId, { title, content, tags });
+                if (!updatedNote) {
+                    return { content: [{ type: "text", text: `Error: Note with ID ${noteId} not found.` }], isError: true };
+                }
+                return { content: [{ type: "text", text: `Note updated successfully.` }] };
+            case 'delete':
+                if (!noteId) {
+                    return { content: [{ type: "text", text: "Error: 'noteId' is required for delete action." }], isError: true };
+                }
+                const deleted = await notesManager.deleteNote(noteId);
+                return { content: [{ type: "text", text: deleted ? "Note deleted successfully." : `Error: Note with ID ${noteId} not found.` }], isError: !deleted };
+            default:
+                return { content: [{ type: "text", text: `Error: Unknown action '${action}'` }], isError: true };
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Notes Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+        };
+    }
+});
 runServer().catch((error) => {
     console.error("Fatal error running server:", error);
     process.exit(1);

package/dist/notes.js

@@ -0,0 +1,77 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class NotesManager {
+    filePath;
+    notes = [];
+    loaded = false;
+    constructor(storagePath = 'project_notes.json') {
+        this.filePath = path.resolve(storagePath);
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        try {
+            const data = await fs.readFile(this.filePath, 'utf-8');
+            this.notes = JSON.parse(data);
+        }
+        catch (error) {
+            // If file doesn't exist, start with empty array
+            this.notes = [];
+        }
+        this.loaded = true;
+    }
+    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 listNotes(tag) {
+        await this.load();
+        if (tag) {
+            return this.notes.filter(n => n.tags.includes(tag));
+        }
+        return this.notes;
+    }
+    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)));
+    }
+    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;
+    }
+    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];
+    }
+}

package/dist/repro_search.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+async function searchCodeLogic(pattern, searchPath = '.') {
+    try {
+        const resolvedPath = path.resolve(searchPath);
+        const stat = await fs.stat(resolvedPath);
+        if (stat.isFile()) {
+            const content = await fs.readFile(resolvedPath, 'utf-8');
+            if (content.includes(pattern)) {
+                return {
+                    content: [{ type: "text", text: `Found "${pattern}" in:\n${resolvedPath}` }]
+                };
+            }
+            else {
+                return {
+                    content: [{ type: "text", text: `No matches found for "${pattern}"` }]
+                };
+            }
+        }
+        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 (new RegExp('\\.(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);
+                    }
+                }
+            }
+            return results;
+        }
+        const matches = await searchDir(resolvedPath);
+        const joinedMatches = matches.join('\n');
+        return {
+            content: [{
+                    type: "text",
+                    text: matches.length > 0 ? `Found "${pattern}" in:\n${joinedMatches}` : `No matches found for "${pattern}"`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Search Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+        };
+    }
+}
+describe('search_code tool', () => {
+    const testDir = path.join(__dirname, 'test_search_env');
+    beforeEach(async () => {
+        await fs.mkdir(testDir, { recursive: true });
+        await fs.writeFile(path.join(testDir, 'target.ts'), 'function myFunction() { return "found me"; }');
+        await fs.writeFile(path.join(testDir, 'other.ts'), 'const x = 10;');
+        await fs.mkdir(path.join(testDir, 'nested'), { recursive: true });
+        await fs.writeFile(path.join(testDir, 'nested', 'deep.ts'), 'export const secret = "found me too";');
+        await fs.mkdir(path.join(testDir, 'node_modules'), { recursive: true });
+        await fs.writeFile(path.join(testDir, 'node_modules', 'ignored.ts'), 'found me');
+    });
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true });
+    });
+    // ... (previous tests)
+    it('should handle single file path', async () => {
+        // This test will FAIL with current implementation (simulated here with the fix applied? No, I need to test failure first)
+        // Wait, I updated searchCodeLogic above with the FIX. 
+        // So this test checks if the FIX works.
+        const result = await searchCodeLogic('found me', path.join(testDir, 'target.ts'));
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain('target.ts');
+    });
+});

package/dist/verify_edit.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// Replicating the logic from src/index.ts for testing
+async function editFileLogic(path, oldText, newText, allowMultiple = false) {
+    try {
+        const content = await fs.readFile(path, 'utf-8');
+        const escapeRegExp = (string) => string.replace(/[.*+?^${}()|[\\]/g, '\\$&');
+        const regex = new RegExp(escapeRegExp(oldText), 'g');
+        const matchCount = (content.match(regex) || []).length;
+        if (matchCount === 0) {
+            return { error: "Error: 'oldText' not found" };
+        }
+        if (matchCount > 1 && !allowMultiple) {
+            return { error: `Error: Found ${matchCount} occurrences` };
+        }
+        const newContent = content.replace(allowMultiple ? regex : oldText, newText);
+        await fs.writeFile(path, newContent, 'utf-8');
+        return { success: true };
+    }
+    catch (error) {
+        return { error: String(error) };
+    }
+}
+describe('edit_file logic', () => {
+    const testFile = path.join(__dirname, 'test_edit.txt');
+    beforeEach(async () => {
+        await fs.writeFile(testFile, 'Line 1\nTarget\nLine 3\nTarget again');
+    });
+    afterEach(async () => {
+        try {
+            await fs.unlink(testFile);
+        }
+        catch { }
+    });
+    it('should replace single occurrence', async () => {
+        await fs.writeFile(testFile, 'Line 1\nUnique\nLine 3');
+        const result = await editFileLogic(testFile, 'Unique', 'Replaced');
+        expect(result.error).toBeUndefined();
+        const content = await fs.readFile(testFile, 'utf-8');
+        expect(content).toContain('Line 1\nReplaced\nLine 3');
+    });
+    it('should fail if text not found', async () => {
+        const result = await editFileLogic(testFile, 'Missing', 'New');
+        expect(result.error).toContain("not found");
+    });
+    it('should fail if multiple found and allowMultiple=false', async () => {
+        const result = await editFileLogic(testFile, 'Target', 'New');
+        expect(result.error).toContain("Found 2 occurrences");
+    });
+    it('should replace multiple if allowMultiple=true', async () => {
+        const result = await editFileLogic(testFile, 'Target', 'New', true);
+        expect(result.error).toBeUndefined();
+        const content = await fs.readFile(testFile, 'utf-8');
+        expect(content).toBe('Line 1\nNew\nLine 3\nNew again');
+    });
+    it('should handle special regex characters in text', async () => {
+        await fs.writeFile(testFile, 'func(a, b) { return a+b; }');
+        const oldText = 'func(a, b) { return a+b; }';
+        const newText = 'replacement';
+        const result = await editFileLogic(testFile, oldText, newText);
+        expect(result.error).toBeUndefined();
+        const content = await fs.readFile(testFile, 'utf-8');
+        expect(content).toBe('replacement');
+    });
+});

package/dist/verify_notes.test.js

@@ -0,0 +1,36 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { NotesManager } from './notes.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+describe('Notes Manager', () => {
+    const testFile = path.join(__dirname, 'test_notes.json');
+    let manager;
+    beforeEach(async () => {
+        manager = new NotesManager(testFile);
+    });
+    afterEach(async () => {
+        try {
+            await fs.unlink(testFile);
+        }
+        catch { }
+    });
+    it('should add and list notes', async () => {
+        await manager.addNote("My Note", "Content", ["tag1"]);
+        const notes = await manager.listNotes();
+        expect(notes.length).toBe(1);
+        expect(notes[0].title).toBe("My Note");
+    });
+    it('should search notes', async () => {
+        await manager.addNote("React Tips", "Use hooks", ["react"]);
+        await manager.addNote("Vue Tips", "Use composition", ["vue"]);
+        const results = await manager.searchNotes("hooks");
+        expect(results.length).toBe(1);
+        expect(results[0].title).toBe("React Tips");
+    });
+    it('should delete note', async () => {
+        const note = await manager.addNote("To Delete", "...");
+        await manager.deleteNote(note.id);
+        const notes = await manager.listNotes();
+        expect(notes.length).toBe(0);
+    });
+});

package/dist/verify_viz.test.js

@@ -0,0 +1,25 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ProjectKnowledgeGraph } from './graph.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+describe('Graph Visualization', () => {
+    const testDir = path.join(__dirname, 'test_viz_env');
+    const graph = new ProjectKnowledgeGraph();
+    beforeEach(async () => {
+        await fs.mkdir(testDir, { recursive: true });
+        await fs.writeFile(path.join(testDir, 'a.ts'), 'import { b } from "./b";');
+        await fs.writeFile(path.join(testDir, 'b.ts'), 'export const b = 1;');
+    });
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true });
+    });
+    it('should generate mermaid diagram', async () => {
+        await graph.build(testDir);
+        const mermaid = graph.toMermaid();
+        console.log("Generated Mermaid:", mermaid);
+        expect(mermaid).toContain('graph TD');
+        expect(mermaid).toMatch(/N\d+\["a\.ts"\]/);
+        expect(mermaid).toMatch(/N\d+\["b\.ts"\]/);
+        expect(mermaid).toContain('-->');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "2026.1.28",
+  "version": "2026.1.31",
   "publishConfig": {
     "access": "public"
   },
@@ -22,7 +22,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc && shx chmod +x dist/*.js",
+    "build": "tsc",
+    "start": "node dist/index.js",
     "prepare": "npm run build",
     "watch": "tsc --watch",
     "test": "vitest run --coverage"

package/dist/verify_new_tools.test.js

@@ -1,67 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { SequentialThinkingServer } from './lib';
-// Mock dependencies for read_webpage if needed, 
-// but for now let's test the logic we can control.
-describe('New Tools Verification', () => {
-    const testDir = path.resolve('test_sandbox');
-    beforeEach(async () => {
-        await fs.mkdir(testDir, { recursive: true });
-    });
-    afterEach(async () => {
-        await fs.rm(testDir, { recursive: true, force: true });
-    });
-    it('search_code should find patterns and ignore node_modules', async () => {
-        // Setup files
-        await fs.writeFile(path.join(testDir, 'target.ts'), 'const x = "FIND_ME";');
-        await fs.writeFile(path.join(testDir, 'other.ts'), 'const y = "nope";');
-        const modulesDir = path.join(testDir, 'node_modules');
-        await fs.mkdir(modulesDir);
-        await fs.writeFile(path.join(modulesDir, 'ignored.ts'), 'const z = "FIND_ME";');
-        // Logic from search_code (replicated here for unit testing the logic itself, 
-        // effectively testing the implementation I wrote in index.ts)
-        async function searchDir(dir, pattern) {
-            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, pattern));
-                }
-                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);
-                    }
-                }
-            }
-            return results;
-        }
-        const results = await searchDir(testDir, 'FIND_ME');
-        expect(results).toHaveLength(1);
-        expect(results[0]).toContain('target.ts');
-        expect(results[0]).not.toContain('node_modules');
-    });
-    it('SequentialThinkingServer should clear history', async () => {
-        const historyFile = path.join(testDir, 'test_history.json');
-        const server = new SequentialThinkingServer(historyFile);
-        // Add a thought
-        await server.processThought({
-            thought: "Test thought",
-            thoughtNumber: 1,
-            totalThoughts: 1,
-            nextThoughtNeeded: false
-        });
-        // Verify it was written
-        const contentBefore = JSON.parse(await fs.readFile(historyFile, 'utf-8'));
-        expect(contentBefore).toHaveLength(1);
-        // Clear history
-        await server.clearHistory();
-        // Verify it is empty
-        const contentAfter = JSON.parse(await fs.readFile(historyFile, 'utf-8'));
-        expect(contentAfter).toHaveLength(0);
-    });
-});