@gotza02/sequential-thinking 2026.2.30 → 2026.2.32

package/dist/tools/filesystem.js

@@ -2,15 +2,114 @@ import { z } from "zod";
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { execAsync, validatePath } from "../utils.js";
+/**
+ * Default file extensions to search
+ * Covers common programming languages, config files, and text formats
+ */
+const DEFAULT_SEARCH_EXTENSIONS = [
+    // Programming languages
+    'ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs',
+    'py', 'pyw', 'pyi',
+    'java', 'kt', 'kts', 'scala',
+    'c', 'cpp', 'cc', 'cxx', 'h', 'hpp', 'hxx',
+    'cs', 'vb',
+    'go', 'rs',
+    'php', 'phtml',
+    'rb', 'gemspec',
+    'swift', 'm', 'mm',
+    'dart',
+    'lua', 'pl', 'pm',
+    'r', 'R',
+    'sh', 'bash', 'zsh', 'fish', 'ps1',
+    // Markup & Data
+    'html', 'htm', 'xhtml', 'xml', 'svg',
+    'css', 'scss', 'sass', 'less',
+    'json', 'yaml', 'yml', 'toml', 'ini', 'conf', 'cfg',
+    'md', 'markdown', 'rst', 'txt',
+    'vue', 'svelte', 'jsx',
+    // Config & Build
+    'gradle', 'pom', 'xml', // Java build
+    'cabal', // Haskell
+    'csproj', 'sln', // C#
+    'pro', // Lua
+    'gemfile', 'rake', // Ruby
+    'dockerfile', 'makefile', 'cmake',
+    'env', 'env.example',
+];
+/**
+ * Default directories to skip during search
+ */
+const DEFAULT_SKIP_DIRS = [
+    'node_modules',
+    '.git',
+    '.svn',
+    '.hg',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    '.nyc_output',
+    '.gemini',
+    '.next',
+    '.nuxt',
+    '.cache',
+    '.turbo',
+    '.parcel',
+    '.vscode',
+    '.idea',
+    'vendor',
+    'target',
+    'bin',
+    'obj',
+    '__pycache__',
+    'venv',
+    '.venv',
+    'virtualenv',
+    'node_modules_cache',
+    '.tsbuildinfo',
+    'tmp',
+    'temp',
+    '.tmp'
+];
+/**
+ * Binary file extensions to always skip
+ */
+const BINARY_EXTENSIONS = [
+    'png', 'jpg', 'jpeg', 'gif', 'bmp', 'ico', 'webp', 'svg',
+    'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx',
+    'zip', 'tar', 'gz', 'bz2', 'rar', '7z',
+    'exe', 'dll', 'so', 'dylib', 'lib', 'a',
+    'mp3', 'mp4', 'wav', 'ogg', 'flac',
+    'ttf', 'otf', 'woff', 'woff2', 'eot',
+    'class', 'jar', 'war', 'ear',
+    'pyc', 'pyo',
+    'node'
+];
 export function registerFileSystemTools(server) {
-    // 3. shell_execute
+    // =========================================================================
+    // SHELL EXECUTE
+    // =========================================================================
     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 = [new RegExp('rm\\s+-rf\\s+\\/'), /mkfs/, /dd\s+if=/];
+        // Dangerous command patterns to block
+        const dangerousPatterns = [
+            new RegExp('rm\\s+-rf?\\s+[\\/~]'), // rm -rf /, rm -rf ~
+            new RegExp('rm\\s+-rf?\\s+\\.'), // rm -rf .
+            /mkfs/, // Format filesystem
+            /dd\s+if=/, // dd direct disk write
+            /chmod\s+000\s+\//, // chmod 000 /
+            /chown\s+-R\s+root:/, // chown -R root:
+            new RegExp('.*>.*\\\\/dev\\\\/.*\\\\s+\\\\w'), // Redirect to device with write
+            /fdisk/, // Partition manipulation
+            /format/, // Windows format command
+        ];
         if (dangerousPatterns.some(p => p.test(command))) {
             return {
-                content: [{ type: "text", text: "Error: Dangerous command pattern detected. Execution blocked for safety." }],
+                content: [{
+                        type: "text",
+                        text: "Error: Dangerous command pattern detected. Execution blocked for safety."
+                    }],
                 isError: true
             };
         }
@@ -25,12 +124,17 @@ export function registerFileSystemTools(server) {
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: `Shell Error: ${error instanceof Error ? error.message : String(error)}` }],
+                content: [{
+                        type: "text",
+                        text: `Shell Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
                 isError: true
             };
         }
     });
-    // 4. read_file
+    // =========================================================================
+    // READ FILE
+    // =========================================================================
     server.tool("read_file", "Read the contents of a file.", {
         path: z.string().describe("Path to the file")
     }, async ({ path }) => {
@@ -43,64 +147,150 @@ export function registerFileSystemTools(server) {
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: `Read Error: ${error instanceof Error ? error.message : String(error)}` }],
+                content: [{
+                        type: "text",
+                        text: `Read Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
                 isError: true
             };
         }
     });
-    // 5. write_file
-    server.tool("write_file", "Write content to a file (overwrites existing).", {
+    // =========================================================================
+    // WRITE FILE
+    // =========================================================================
+    server.tool("write_file", "Write content to a file (overwrites existing). Use with caution.", {
         path: z.string().describe("Path to the file"),
         content: z.string().describe("Content to write")
     }, async ({ path, content }) => {
         try {
             const safePath = validatePath(path);
+            // Additional safety: don't overwrite system directories
+            const systemDirs = ['/etc', '/usr', '/bin', '/sbin', '/boot', '/lib', '/lib64'];
+            const isSystemPath = systemDirs.some(sysDir => safePath.startsWith(sysDir));
+            if (isSystemPath) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Cannot write to system directory: ${safePath}`
+                        }],
+                    isError: true
+                };
+            }
             await fs.writeFile(safePath, content, 'utf-8');
             return {
-                content: [{ type: "text", text: `Successfully wrote to ${safePath}` }]
+                content: [{
+                        type: "text",
+                        text: `Successfully wrote to ${safePath} (${content.length} bytes)`
+                    }]
             };
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: `Write Error: ${error instanceof Error ? error.message : String(error)}` }],
+                content: [{
+                        type: "text",
+                        text: `Write Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
                 isError: true
             };
         }
     });
-    // 10. search_code
-    server.tool("search_code", "Search for a text pattern in project files with advanced options (regex, case sensitivity).", {
+    // =========================================================================
+    // SEARCH CODE
+    // =========================================================================
+    server.tool("search_code", "Search for a text pattern in project files with advanced options (regex, case sensitivity, file filtering).", {
         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 }) => {
+        caseSensitive: z.boolean().optional().default(false).describe("Match case sensitive"),
+        extensions: z.string().optional().describe("Comma-separated file extensions to search (e.g., 'ts,js,py'). Default: common code files"),
+        excludeExtensions: z.string().optional().describe("Comma-separated extensions to exclude (e.g., 'md,txt')"),
+        skipDirs: z.string().optional().describe("Comma-separated directories to skip (e.g., 'dist,test')"),
+        allFiles: z.boolean().optional().default(false).describe("Search all text files (ignores extension filter)"),
+        contextLines: z.number().optional().describe("Number of context lines to show around matches"),
+        maxResults: z.number().optional().default(1000).describe("Maximum number of matches to return")
+    }, async ({ pattern, path: searchPath, useRegex, caseSensitive, extensions, excludeExtensions, skipDirs, allFiles, contextLines, maxResults }) => {
         try {
             const resolvedPath = validatePath(searchPath || '.');
             const stats = await fs.stat(resolvedPath);
             const results = [];
+            let matchCount = 0;
+            // Parse extensions
+            const includedExts = extensions
+                ? extensions.toLowerCase().split(',').map(e => e.trim().replace(/^\./, ''))
+                : DEFAULT_SEARCH_EXTENSIONS;
+            const excludedExts = excludeExtensions
+                ? excludeExtensions.toLowerCase().split(',').map(e => e.trim().replace(/^\./, ''))
+                : BINARY_EXTENSIONS;
+            const skipDirList = skipDirs
+                ? skipDirs.split(',').map(d => d.trim())
+                : DEFAULT_SKIP_DIRS;
+            const shouldSearchFile = (fileName) => {
+                const ext = fileName.includes('.') ? fileName.split('.').pop()?.toLowerCase() : '';
+                const baseName = fileName.split('/').pop() || '';
+                // Always skip binary extensions
+                if (ext && excludedExts.includes(ext)) {
+                    return false;
+                }
+                // Skip common binary/temp files by name
+                if (baseName.startsWith('.') || baseName.endsWith('~')) {
+                    return false;
+                }
+                if (allFiles) {
+                    // For all files, still skip known binary types
+                    return !BINARY_EXTENSIONS.includes(ext || '');
+                }
+                // Use extension filter
+                return ext ? includedExts.includes(ext) : false;
+            };
+            const shouldSkipDir = (dirName) => {
+                return skipDirList.includes(dirName);
+            };
             const searchFile = async (filePath) => {
+                if (matchCount >= maxResults)
+                    return;
                 try {
                     const content = await fs.readFile(filePath, 'utf-8');
+                    // Skip binary-like files (high proportion of non-printable chars)
+                    const nonPrintableRatio = (content.match(/[\x00-\x08\x0E-\x1F]/g) || []).length / content.length;
+                    if (nonPrintableRatio > 0.3) {
+                        return; // Likely binary file
+                    }
                     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, '\\$&');
+                        const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
                         regex = new RegExp(escaped, caseSensitive ? 'g' : 'gi');
                     }
                     lines.forEach((line, index) => {
+                        if (matchCount >= maxResults)
+                            return;
+                        regex.lastIndex = 0;
                         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()}`);
+                            matchCount++;
+                            const lineNum = index + 1;
+                            const trimmedLine = line.trim();
+                            if (contextLines && contextLines > 0) {
+                                // Include context lines
+                                const start = Math.max(0, index - contextLines);
+                                const end = Math.min(lines.length - 1, index + contextLines);
+                                let context = '';
+                                for (let i = start; i <= end; i++) {
+                                    const prefix = i === index ? '>' : ' ';
+                                    context += `${prefix} ${i + 1}: ${lines[i]}\n`;
+                                }
+                                results.push(`${filePath}:\n${context}`);
+                            }
+                            else {
+                                results.push(`${filePath}:${lineNum}: ${trimmedLine}`);
+                            }
                         }
                     });
                 }
                 catch (err) {
-                    // Ignore read errors (binary files etc)
+                    // Ignore read errors (binary files, permissions, etc.)
                 }
             };
             if (stats.isFile()) {
@@ -108,73 +298,202 @@ export function registerFileSystemTools(server) {
             }
             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);
+                    try {
+                        const entries = await fs.readdir(dir, { withFileTypes: true });
+                        for (const entry of entries) {
+                            if (matchCount >= maxResults)
+                                break;
+                            const fullPath = path.join(dir, entry.name);
+                            if (entry.isDirectory()) {
+                                if (shouldSkipDir(entry.name))
+                                    continue;
+                                await searchDir(fullPath);
+                            }
+                            else if (entry.isFile()) {
+                                if (shouldSearchFile(entry.name)) {
+                                    await searchFile(fullPath);
+                                }
+                            }
                         }
                     }
+                    catch (err) {
+                        // Skip directories we can't read
+                    }
                 };
                 await searchDir(resolvedPath);
             }
+            const responseText = results.length > 0
+                ? `Found ${Math.min(matchCount, maxResults)} match${matchCount > 1 ? 'es' : ''} for "${pattern}":\n\n${results.slice(0, maxResults).join('\n\n')}`
+                : `No matches found for "${pattern}"`;
             return {
                 content: [{
                         type: "text",
-                        text: results.length > 0 ? `Found matches for "${pattern}":\n${results.join('\n')}` : `No matches found for "${pattern}"`
+                        text: responseText
                     }]
             };
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: `Search Error: ${error instanceof Error ? error.message : String(error)}` }],
+                content: [{
+                        type: "text",
+                        text: `Search Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
                 isError: true
             };
         }
     });
-    // 13. edit_file
+    // =========================================================================
+    // 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)")
+        allowMultiple: z.boolean().optional().default(false).describe("Allow replacing multiple occurrences")
     }, async ({ path, oldText, newText, allowMultiple }) => {
         try {
             const safePath = validatePath(path);
+            // Additional safety: don't edit system files
+            const systemDirs = ['/etc', '/usr', '/bin', '/sbin', '/boot', '/lib', '/lib64'];
+            const isSystemPath = systemDirs.some(sysDir => safePath.startsWith(sysDir));
+            if (isSystemPath) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Cannot edit system directory file: ${safePath}`
+                        }],
+                    isError: true
+                };
+            }
             const content = await fs.readFile(safePath, 'utf-8');
             // Check occurrences
-            // Escape special regex characters in oldText to treat it as literal string
-            const escapeRegExp = (string) => string.replace(/[.*+?^${}()|[\\]/g, '\\$&');
+            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)." }],
+                    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'.` }],
+                    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'.\n\nTip: Include more surrounding context to make the match unique.`
+                        }],
                     isError: true
                 };
             }
             const newContent = content.replace(allowMultiple ? regex : oldText, () => newText);
             await fs.writeFile(safePath, newContent, 'utf-8');
             return {
-                content: [{ type: "text", text: `Successfully replaced ${allowMultiple ? matchCount : 1} occurrence(s) in ${safePath}` }]
+                content: [{
+                        type: "text",
+                        text: `Successfully replaced ${allowMultiple ? matchCount : 1} occurrence(s) in ${safePath}\n\nSize changed: ${content.length} → ${newContent.length} bytes`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Edit Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    // =========================================================================
+    // LIST DIRECTORY
+    // =========================================================================
+    server.tool("list_directory", "List files and directories in a given path.", {
+        path: z.string().optional().default('.').describe("Path to the directory"),
+        showHidden: z.boolean().optional().default(false).describe("Show hidden files/directories"),
+        includeStats: z.boolean().optional().default(false).describe("Include file statistics (size, mtime)")
+    }, async ({ path: dirPath, showHidden, includeStats }) => {
+        try {
+            const safePath = validatePath(dirPath || '.');
+            const stats = await fs.stat(safePath);
+            if (!stats.isDirectory()) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: ${safePath} is not a directory`
+                        }],
+                    isError: true
+                };
+            }
+            const entries = await fs.readdir(safePath, { withFileTypes: true });
+            let result = '';
+            for (const entry of entries) {
+                // Skip hidden files unless requested
+                if (!showHidden && entry.name.startsWith('.')) {
+                    continue;
+                }
+                const fullPath = path.join(safePath, entry.name);
+                const icon = entry.isDirectory() ? '📁 ' : entry.isSymbolicLink() ? '🔗 ' : '📄 ';
+                let line = `${icon}${entry.name}`;
+                if (includeStats) {
+                    try {
+                        const entryStats = await fs.stat(fullPath);
+                        const size = entryStats.size;
+                        const mtime = entryStats.mtime.toISOString();
+                        line += ` (${size} bytes, ${mtime})`;
+                    }
+                    catch {
+                        // Skip stats for files we can't read
+                    }
+                }
+                result += line + '\n';
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: result || `(empty directory)`
+                    }]
             };
         }
         catch (error) {
             return {
-                content: [{ type: "text", text: `Edit Error: ${error instanceof Error ? error.message : String(error)}` }],
+                content: [{
+                        type: "text",
+                        text: `List Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
                 isError: true
             };
         }
     });
+    // =========================================================================
+    // FILE EXISTS
+    // =========================================================================
+    server.tool("file_exists", "Check if a file or directory exists.", {
+        path: z.string().describe("Path to check")
+    }, async ({ path }) => {
+        try {
+            const safePath = validatePath(path);
+            await fs.access(safePath);
+            const stats = await fs.stat(safePath);
+            const type = stats.isDirectory() ? 'directory' :
+                stats.isFile() ? 'file' :
+                    stats.isSymbolicLink() ? 'symlink' : 'unknown';
+            return {
+                content: [{
+                        type: "text",
+                        text: `Exists: ${safePath} (${type})`
+                    }]
+            };
+        }
+        catch {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Does not exist: ${path}`
+                    }]
+            };
+        }
+    });
 }

package/dist/tools/thinking.js

@@ -66,7 +66,13 @@ If stuck in a loop:
 1. Do NOT continue linear thoughts
 2. Create a NEW BRANCH ('branchFromThought') from before the error
 3. State "Stuck detected, branching to explore Approach B"
-4. Change your assumptions completely`, {
+4. Change your assumptions completely
+
+THE RULE OF 3:
+If you have tried to fix the same problem 3 times and failed:
+1. STOP immediately.
+2. Do not attempt a 4th fix in the same chain.
+3. Branch back to the analysis phase before the first fix attempt.`, {
         thought: z.string().describe("Your current thinking step"),
         thoughtType: z.enum([
             'analysis', 'planning', 'execution', 'observation',

package/package.json

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