@gotza02/sequential-thinking 2026.1.27 → 2026.1.31

package/README.md

@@ -52,6 +52,14 @@ The core engine for structured problem-solving. It forces a step-by-step analysi
 #### `clear_thought_history`
 Clears the stored thinking history. Use this to start fresh or free up context.
 
+#### `summarize_history`
+Compresses multiple thoughts into a single summary thought. This is essential for long reasoning chains to save token context while preserving the core insights.
+
+**Inputs:**
+- `startIndex` (integer): Start of the range to summarize.
+- `endIndex` (integer): End of the range to summarize.
+- `summary` (string): The summary text that replaces the range.
+
 ### 🌐 External Knowledge
 
 #### `web_search`
@@ -82,29 +90,16 @@ Reads a webpage and converts it to clean Markdown, removing ads and navigation.
 ### 🏗 Codebase Intelligence
 
 #### `build_project_graph`
-**RUN THIS FIRST** when entering a new project. It scans the directory and builds a map of file dependencies using TypeScript AST analysis.
+**RUN THIS FIRST** when entering a new project. It scans the directory and builds a map of file dependencies using TypeScript AST analysis. Now also extracts **exported symbols** (Functions, Classes, Variables) to provide deeper structural insight.
 
 **Inputs:**
 - `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_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.
+Get overview of project structure and most referenced files.
 
-#### `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
 
@@ -121,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`).
 
@@ -214,6 +229,29 @@ 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.
+  - Added **Internal Locking** to handle concurrent save requests gracefully.
+  - Added **API Retry Logic** with exponential backoff for all search and web tools (handles HTTP 429/5xx).
+  - Improved HTTP requests with browser-like headers (User-Agent) to reduce blocking.
+- **New Tools**:
+  - `summarize_history`: Archive and condense long reasoning chains.
+- **Graph Enhancements**:
+  - Added **Symbol Extraction**: The project graph now tracks exported functions, classes, and variables.
+
 ## Recent Updates (v2026.1.27)
 - **New Tools**:
   - `read_webpage`: Convert webpages to Markdown for efficient reading.

package/dist/graph.js

@@ -14,7 +14,8 @@ export class ProjectKnowledgeGraph {
             this.nodes.set(file, {
                 path: file,
                 imports: [],
-                importedBy: []
+                importedBy: [],
+                symbols: []
             });
         }
         // Step 2: Parse imports and build edges
@@ -49,8 +50,29 @@ export class ProjectKnowledgeGraph {
             const content = await fs.readFile(filePath, 'utf-8');
             const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
             const imports = [];
+            const symbols = [];
             const visit = (node) => {
-                // 1. Static imports: import ... from '...'
+                // --- Symbols (Exports) ---
+                if (ts.isFunctionDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`function:${node.name.text}`);
+                }
+                else if (ts.isClassDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`class:${node.name.text}`);
+                }
+                else if (ts.isVariableStatement(node)) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported) {
+                        node.declarationList.declarations.forEach(d => {
+                            if (ts.isIdentifier(d.name))
+                                symbols.push(`var:${d.name.text}`);
+                        });
+                    }
+                }
+                // --- Imports ---
                 if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
                     if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
                         imports.push(node.moduleSpecifier.text);
@@ -78,6 +100,7 @@ export class ProjectKnowledgeGraph {
             const currentNode = this.nodes.get(filePath);
             if (!currentNode)
                 return;
+            currentNode.symbols = symbols;
             for (const importPath of imports) {
                 let resolvedPath = null;
                 if (importPath.startsWith('.')) {
@@ -146,7 +169,8 @@ export class ProjectKnowledgeGraph {
         return {
             path: node.path,
             imports: node.imports.map(p => path.relative(this.rootDir, p)),
-            importedBy: node.importedBy.map(p => path.relative(this.rootDir, p))
+            importedBy: node.importedBy.map(p => path.relative(this.rootDir, p)),
+            symbols: node.symbols
         };
     }
     getSummary() {
@@ -162,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,17 +7,51 @@ 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';
 import TurndownService from 'turndown';
 const execAsync = promisify(exec);
+const DEFAULT_HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+    'Accept-Language': 'en-US,en;q=0.9',
+};
+async function fetchWithRetry(url, options = {}, retries = 3, backoff = 1000) {
+    const fetchOptions = {
+        ...options,
+        headers: { ...DEFAULT_HEADERS, ...options.headers }
+    };
+    try {
+        const response = await fetch(url, fetchOptions);
+        if (response.status === 429 && retries > 0) {
+            const retryAfter = response.headers.get('Retry-After');
+            const waitTime = retryAfter ? parseInt(retryAfter) * 1000 : backoff;
+            await new Promise(resolve => setTimeout(resolve, waitTime));
+            return fetchWithRetry(url, options, retries - 1, backoff * 2);
+        }
+        if (!response.ok && retries > 0 && response.status >= 500) {
+            await new Promise(resolve => setTimeout(resolve, backoff));
+            return fetchWithRetry(url, options, retries - 1, backoff * 2);
+        }
+        return response;
+    }
+    catch (error) {
+        if (retries > 0) {
+            await new Promise(resolve => setTimeout(resolve, backoff));
+            return fetchWithRetry(url, options, retries - 1, backoff * 2);
+        }
+        throw error;
+    }
+}
 const server = new McpServer({
     name: "sequential-thinking-server",
     version: "2026.1.18",
 });
 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.
@@ -105,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 {
@@ -124,7 +158,7 @@ server.tool("web_search", "Search the web using Brave or Exa APIs (requires API
         if (selectedProvider === 'brave') {
             if (!process.env.BRAVE_API_KEY)
                 throw new Error("BRAVE_API_KEY not found");
-            const response = await fetch(`https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=5`, {
+            const response = await fetchWithRetry(`https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=5`, {
                 headers: { 'X-Subscription-Token': process.env.BRAVE_API_KEY }
             });
             if (!response.ok)
@@ -135,7 +169,7 @@ server.tool("web_search", "Search the web using Brave or Exa APIs (requires API
         if (selectedProvider === 'exa') {
             if (!process.env.EXA_API_KEY)
                 throw new Error("EXA_API_KEY not found");
-            const response = await fetch('https://api.exa.ai/search', {
+            const response = await fetchWithRetry('https://api.exa.ai/search', {
                 method: 'POST',
                 headers: {
                     'x-api-key': process.env.EXA_API_KEY,
@@ -153,7 +187,7 @@ server.tool("web_search", "Search the web using Brave or Exa APIs (requires API
                 throw new Error("GOOGLE_SEARCH_API_KEY not found");
             if (!process.env.GOOGLE_SEARCH_CX)
                 throw new Error("GOOGLE_SEARCH_CX (Search Engine ID) not found");
-            const response = await fetch(`https://www.googleapis.com/customsearch/v1?key=${process.env.GOOGLE_SEARCH_API_KEY}&cx=${process.env.GOOGLE_SEARCH_CX}&q=${encodeURIComponent(query)}&num=5`);
+            const response = await fetchWithRetry(`https://www.googleapis.com/customsearch/v1?key=${process.env.GOOGLE_SEARCH_API_KEY}&cx=${process.env.GOOGLE_SEARCH_CX}&q=${encodeURIComponent(query)}&num=5`);
             if (!response.ok)
                 throw new Error(`Google API error: ${response.statusText}`);
             const data = await response.json();
@@ -182,7 +216,7 @@ server.tool("fetch", "Perform an HTTP request to a specific URL.", {
     body: z.string().optional().describe("Request body (for POST/PUT)")
 }, async ({ url, method, headers, body }) => {
     try {
-        const response = await fetch(url, {
+        const response = await fetchWithRetry(url, {
             method,
             headers: headers || {},
             body: body
@@ -324,7 +358,7 @@ server.tool("read_webpage", "Read a webpage and convert it to clean Markdown (re
     url: z.string().url().describe("The URL to read")
 }, async ({ url }) => {
     try {
-        const response = await fetch(url);
+        const response = await fetchWithRetry(url);
         const html = await response.text();
         const doc = new JSDOM(html, { url });
         const reader = new Readability(doc.window.document);
@@ -353,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 });
@@ -372,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",
@@ -394,6 +440,137 @@ server.tool("clear_thought_history", "Clear the sequential thinking history.", {
         content: [{ type: "text", text: "Thought history cleared." }]
     };
 });
+// 12. summarize_history
+server.tool("summarize_history", "Compress multiple thoughts into a single summary thought to save space/context.", {
+    startIndex: z.number().int().min(1).describe("The starting thought number to summarize"),
+    endIndex: z.number().int().min(1).describe("The ending thought number to summarize"),
+    summary: z.string().describe("The summary text that replaces the range")
+}, async ({ startIndex, endIndex, summary }) => {
+    try {
+        const result = await thinkingServer.archiveHistory(startIndex, endIndex, summary);
+        return {
+            content: [{ type: "text", text: `Successfully summarized thoughts ${startIndex}-${endIndex}. New history length: ${result.newHistoryLength}` }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Archive Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+        };
+    }
+});
+// 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/lib.js

@@ -8,6 +8,7 @@ export class SequentialThinkingServer {
     disableThoughtLogging;
     storagePath;
     delayMs;
+    isSaving = false;
     constructor(storagePath = 'thoughts_history.json', delayMs = 0) {
         this.disableThoughtLogging = (process.env.DISABLE_THOUGHT_LOGGING || "").toLowerCase() === "true";
         this.storagePath = path.resolve(storagePath);
@@ -31,18 +32,64 @@ export class SequentialThinkingServer {
         }
     }
     async saveHistory() {
+        if (this.isSaving) {
+            // Simple retry if already saving
+            setTimeout(() => this.saveHistory(), 100);
+            return;
+        }
+        this.isSaving = true;
         try {
-            await fs.writeFile(this.storagePath, JSON.stringify(this.thoughtHistory, null, 2), 'utf-8');
+            // Atomic write: write to tmp then rename
+            const tmpPath = `${this.storagePath}.tmp`;
+            await fs.writeFile(tmpPath, JSON.stringify(this.thoughtHistory, null, 2), 'utf-8');
+            await fs.rename(tmpPath, this.storagePath);
         }
         catch (error) {
             console.error(`Error saving history to ${this.storagePath}:`, error);
         }
+        finally {
+            this.isSaving = false;
+        }
     }
     async clearHistory() {
         this.thoughtHistory = [];
         this.branches = {};
         await this.saveHistory();
     }
+    async archiveHistory(startIndex, endIndex, summary) {
+        if (startIndex < 1 || endIndex > this.thoughtHistory.length || startIndex > endIndex) {
+            throw new Error(`Invalid range: ${startIndex} to ${endIndex}. History length is ${this.thoughtHistory.length}.`);
+        }
+        const summaryThought = {
+            thought: `SUMMARY [${startIndex}-${endIndex}]: ${summary}`,
+            thoughtNumber: startIndex,
+            totalThoughts: this.thoughtHistory[this.thoughtHistory.length - 1].totalThoughts - (endIndex - startIndex),
+            nextThoughtNeeded: true,
+            thoughtType: 'analysis'
+        };
+        // Remove the range and insert summary
+        const removedCount = endIndex - startIndex + 1;
+        this.thoughtHistory.splice(startIndex - 1, removedCount, summaryThought);
+        // Renumber subsequent thoughts
+        for (let i = startIndex; i < this.thoughtHistory.length; i++) {
+            this.thoughtHistory[i].thoughtNumber -= (removedCount - 1);
+        }
+        // Rebuild branches (simplification: clear and let it rebuild if needed, or just clear)
+        this.branches = {};
+        this.thoughtHistory.forEach(t => {
+            if (t.branchFromThought && t.branchId) {
+                const branchKey = `${t.branchFromThought}-${t.branchId}`;
+                if (!this.branches[branchKey])
+                    this.branches[branchKey] = [];
+                this.branches[branchKey].push(t);
+            }
+        });
+        await this.saveHistory();
+        return {
+            newHistoryLength: this.thoughtHistory.length,
+            summaryInsertedAt: startIndex
+        };
+    }
     addToMemory(input) {
         if (input.thoughtNumber > input.totalThoughts) {
             input.totalThoughts = input.thoughtNumber;

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.27",
+  "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"