@mrxkun/mcfast-mcp 3.5.7 → 3.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "3.5.7",
+  "version": "3.5.8",
   "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. Optimized for AI code assistants with 80-98% latency reduction.",
   "type": "module",
   "bin": {

package/src/index.js

@@ -203,7 +203,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             // CORE TOOL 1: edit (consolidates apply_fast + edit_file + apply_search_replace)
             {
                 name: "edit",
-                description: "**PRIMARY TOOL FOR EDITING FILES** - Intelligent auto-switching strategies: (1) Search & Replace (Fastest) - use 'Replace X with Y', (2) Placeholder (Efficient) - use '// ... existing code ...' placeholders to save tokens, (3) Mercury AI (Intelligent) - for complex refactoring. Includes Auto-Rollback for syntax errors.",
+                description: "**PRIMARY TOOL FOR EDITING FILES** - Intelligent auto-switching strategies: (1) Search & Replace (Fastest) - use 'Replace X with Y'. (2) Placeholder (Efficient) - use '// ... existing code ...' placeholders to save tokens. (3) Mercury AI (Intelligent) - for complex refactoring. Includes Auto-Rollback for syntax errors.",
                 inputSchema: {
                     type: "object",
                     properties: {
@@ -283,7 +283,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     type: "object",
                     properties: {
                         path: { type: "string", description: "Root directory path (default: current dir)" },
-                        depth: { type: "number", description: "Max depth to traverse (default: 5)" }
+                        depth: { type: "number", description: "Max depth to traverse (default: 5)" },
+                        offset: { type: "number", description: "Number of files to skip (for pagination, default: 0)" },
+                        limit: { type: "number", description: "Max files to return (for pagination, default: 500)" }
                     }
                 }
             },
@@ -589,16 +591,140 @@ async function reportAudit(data) {
 }
 
 // ============================================
-// FILESYSTEM SEARCH HANDLER
+
+/**
+ * Handle regex-based filesystem search using grep
+ * Uses native grep for high-performance regex searching
+ */
+async function handleRegexSearch({ query, path: searchPath, caseSensitive = false }) {
+    const start = Date.now();
+
+    try {
+        const flags = [
+            "-r",        // Recursive
+            "-n",        // Line number
+            "-I",        // Ignore binary files
+            caseSensitive ? "" : "-i"  // Case sensitivity
+        ].filter(Boolean).join(" ");
+
+        // Exclude common noise directories
+        const excludes = [
+            "--exclude-dir=node_modules",
+            "--exclude-dir=.git",
+            "--exclude-dir=.next",
+            "--exclude-dir=dist",
+            "--exclude-dir=build",
+            "--exclude-dir=coverage",
+            "--exclude-dir=.cache"
+        ].join(" ");
+
+        const command = `grep ${flags} ${excludes} -E "${query.replace(/"/g, '\\"')}" "${searchPath}"`;
+
+        try {
+            const { stdout } = await execAsync(command, { maxBuffer: 10 * 1024 * 1024 }); // 10MB buffer
+            const results = stdout.trim().split('\n').filter(Boolean);
+
+            const latency = Date.now() - start;
+
+            let output = `🔍 Regex Search Results for "${query}"\n`;
+            output += `Path: ${searchPath}\n`;
+            output += `Matches: ${results.length} lines\n`;
+            output += `Latency: ${latency}ms\n\n`;
+
+            if (results.length === 0) {
+                output += "No matches found.";
+            } else {
+                // Parse grep output format: file:line:content
+                const parsedResults = results.map(line => {
+                    const match = line.match(/^([^:]+):(\d+):(.*)$/);
+                    if (match) {
+                        return { file: match[1], line: parseInt(match[2]), content: match[3] };
+                    }
+                    return null;
+                }).filter(Boolean);
+
+                // Group by file
+                const byFile = {};
+                parsedResults.forEach(r => {
+                    if (!byFile[r.file]) byFile[r.file] = [];
+                    byFile[r.file].push(r);
+                });
+
+                // Output grouped by file
+                Object.entries(byFile).slice(0, 20).forEach(([file, matches]) => {
+                    output += `${colors.yellow}${file}${colors.reset}\n`;
+                    matches.slice(0, 10).forEach(m => {
+                        output += `  ${colors.dim}${m.line}:${colors.reset} ${m.content}\n`;
+                    });
+                    if (matches.length > 10) {
+                        output += `  ${colors.dim}... and ${matches.length - 10} more matches${colors.reset}\n`;
+                    }
+                    output += "\n";
+                });
+
+                if (parsedResults.length > 200) {
+                    output += `${colors.dim}... and ${parsedResults.length - 200} more results${colors.reset}\n`;
+                }
+            }
+
+            reportAudit({
+                tool: 'search_regex',
+                instruction: `Regex search: ${query}`,
+                status: 'success',
+                latency_ms: latency,
+                files_count: 0,
+                result_summary: JSON.stringify(results.slice(0, 100)),
+                input_tokens: Math.ceil(query.length / 4),
+                output_tokens: Math.ceil(output.length / 4)
+            });
+
+            return { content: [{ type: "text", text: output }] };
+        } catch (execErr) {
+            if (execErr.code === 1) { // grep returns 1 when no matches found
+                const latency = Date.now() - start;
+                return {
+                    content: [{ type: "text", text: `🔍 Regex Search: No matches found for "${query}" in ${searchPath} (${latency}ms)` }]
+                };
+            }
+            throw execErr;
+        }
+    } catch (error) {
+        const latency = Date.now() - start;
+
+        reportAudit({
+            tool: 'search_regex',
+            instruction: `Regex search: ${query}`,
+            status: 'error',
+            latency_ms: latency,
+            error: error.message
+        });
+
+        return {
+            content: [{ type: "text", text: `❌ Regex search error: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+
 // ============================================
 
 /**
  * Handle filesystem search using fast-glob and pattern matching
  * Fast alternative to API-based search for local files
+ * Now supports regex search using grep
  */
 async function handleSearchFilesystem({ query, path: searchPath, isRegex = false, caseSensitive = false }) {
     const start = Date.now();
-    
+
+    // Default to current directory if no path specified
+    const cwd = searchPath || process.cwd();
+
+    // For regex searches, use grep instead of fast-glob
+    if (isRegex) {
+        return await handleRegexSearch({ query, path: cwd, caseSensitive });
+    }
+
+    // Original fast-glob based search for non-regex queries
     try {
         // Determine search pattern
         let pattern = query;
@@ -607,9 +733,6 @@ async function handleSearchFilesystem({ query, path: searchPath, isRegex = false
             pattern = `**/*${query}*`;
         }
         
-        // Default to current directory if no path specified
-        const cwd = searchPath || process.cwd();
-        
         // Use fast-glob to find files
         const files = await fg([pattern], {
             cwd,
@@ -1071,6 +1194,12 @@ async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
  * Auto-detects best strategy based on input
  */
 async function handleSearch({ query, files, path, mode = 'auto', regex = false, caseSensitive = false, contextLines = 2 }) {
+    // For regex mode without files, we need to do content-based regex search
+    // since fast-glob doesn't support full regex patterns
+    if (regex && !files && mode === 'auto') {
+        mode = 'filesystem'; // Will use grep-based search below
+    }
+
     const detectedMode = mode === 'auto' ? detectSearchStrategy({ query, files, path, mode }) : mode;
 
     console.error(`${colors.cyan}[SEARCH STRATEGY]${colors.reset} ${detectedMode}`);
@@ -1087,12 +1216,16 @@ async function handleSearch({ query, files, path, mode = 'auto', regex = false,
 
     // Strategy 3: LSP Definition
     if (detectedMode === 'definition') {
-        return await handleGetDefinition({ path: path, symbol: query });
+        // If no path provided, use current working directory
+        const searchPath = path || process.cwd();
+        return await handleGetDefinition({ path: searchPath, symbol: query });
     }
 
     // Strategy 4: LSP References
     if (detectedMode === 'references') {
-        return await handleFindReferences({ path: path, symbol: query });
+        // If no path provided, use current working directory
+        const searchPath = path || process.cwd();
+        return await handleFindReferences({ path: searchPath, symbol: query });
     }
 
     // Strategy 5: Filesystem search (fast grep-based)
@@ -1523,20 +1656,37 @@ async function handleSearchCode({ query, files, regex = false, caseSensitive = f
     }
 }
 
-async function handleListFiles({ path: dirPath = process.cwd(), depth = 5 }) {
+async function handleListFiles({ path: dirPath = process.cwd(), depth = 5, offset = 0, limit = 500 }) {
     const start = Date.now();
     try {
         const files = await getFiles(dirPath, depth);
 
-        const output = `📁 Files in ${dirPath}:\n\n${files.join('\n')}`;
+        // Apply pagination
+        const totalFiles = files.length;
+        const paginatedFiles = files.slice(offset, offset + limit);
+        const hasMore = offset + limit < totalFiles;
+
+        // Build output with pagination info
+        let output = `📁 Files in ${dirPath} (depth: ${depth}):\n`;
+        output += `Showing ${offset + 1}-${Math.min(offset + limit, totalFiles)} of ${totalFiles} files`;
+        if (hasMore) {
+            output += `. Use offset: ${offset + limit} to see more.`;
+        }
+        output += `\n\n${paginatedFiles.join('\n')}`;
+
+        // Check for large output and add helpful message
+        const outputLength = output.length;
+        if (outputLength > 50000) {
+            output += `\n\n💡 Tip: Output is large. Use depth parameter to limit depth (e.g., depth: 2 or 3) to limit the search scope.`;
+        }
 
         reportAudit({
             tool: 'list_files_fast',
             instruction: dirPath,
             status: 'success',
             latency_ms: Date.now() - start,
-            files_count: files.length,
-            result_summary: JSON.stringify(files.slice(0, 500)),
+            files_count: totalFiles,
+            result_summary: JSON.stringify(paginatedFiles.slice(0, 500)),
             input_tokens: Math.ceil(dirPath.length / 4),
             output_tokens: Math.ceil(output.length / 4)
         });
@@ -1546,6 +1696,12 @@ async function handleListFiles({ path: dirPath = process.cwd(), depth = 5 }) {
         };
 
     } catch (error) {
+        // Error recovery: suggest using depth parameter
+        let errorMessage = `❌ Error listing files: ${error.message}`;
+        if (error.message.includes('too many files') || error.message.includes('EMFILE') || error.message.includes('max')) {
+            errorMessage += `\n\n💡 Tip: Try reducing the depth (e.g., depth: 2 or 3) to limit the search scope.`;
+        }
+
         reportAudit({
             tool: 'list_files_fast',
             instruction: dirPath,
@@ -1554,7 +1710,7 @@ async function handleListFiles({ path: dirPath = process.cwd(), depth = 5 }) {
             latency_ms: Date.now() - start
         });
         return {
-            content: [{ type: "text", text: `❌ Error listing files: ${error.message}` }],
+            content: [{ type: "text", text: errorMessage }],
             isError: true
         };
     }
@@ -1843,14 +1999,22 @@ async function handleSearchCodeAI({ query, files, contextLines = 2 }) {
 async function handleGetDefinition({ path: filePath, symbol }) {
     if (!filePath || !symbol) throw new Error("Missing path or symbol");
 
-    // Check if path is a directory
     const absolutePath = path.resolve(filePath);
-    const stats = await fs.stat(absolutePath);
+
+    // Check if path is a directory - search across files in directory
+    let stats;
+    try {
+        stats = await fs.stat(absolutePath);
+    } catch (e) {
+        throw new Error(`Path does not exist: ${filePath}`);
+    }
+
     if (!stats.isFile()) {
-        throw new Error(`Path is not a file: ${filePath}`);
+        // It's a directory - search for symbol definition using grep
+        return await handleDefinitionInDirectory({ path: absolutePath, symbol });
     }
 
-    // Read file content first
+    // It's a file - use tree-sitter to find definition
     const content = await fs.readFile(filePath, 'utf8');
     const definitions = await findDefinition(content, filePath, symbol);
 
@@ -1867,16 +2031,88 @@ async function handleGetDefinition({ path: filePath, symbol }) {
     };
 }
 
+async function handleDefinitionInDirectory({ path: dirPath, symbol }) {
+    // Search for symbol definition in directory using grep
+    // Look for common definition patterns: const/let/var, function, class, interface, type, etc.
+    const patterns = [
+        `^\\s*(const|let|var)\\s+${symbol}\\s*=`,
+        `^\\s*function\\s+${symbol}\\s*\\(`,
+        `^\\s*class\\s+${symbol}\\s*[\\{\\s]`,
+        `^\\s*interface\\s+${symbol}\\s*[\\{\\s]`,
+        `^\\s*type\\s+${symbol}\\s*=`,
+        `^\\s*enum\\s+${symbol}\\s*[\\{\\s]`,
+        `^\\s*export\\s+(const|let|var|function|class|interface|type|enum)\\s+${symbol}`,
+        `^\\s*async\\s+function\\s+${symbol}\\s*\\(`,
+    ];
+
+    const results = [];
+    for (const pattern of patterns) {
+        const flags = "-rn";
+        const excludes = [
+            "--exclude-dir=node_modules",
+            "--exclude-dir=.git",
+            "--exclude-dir=dist",
+            "--exclude-dir=build"
+        ].join(" ");
+
+        try {
+            const { stdout } = await execAsync(
+                `grep ${flags} ${excludes} -E "${pattern}" "${dirPath}" 2>/dev/null`,
+                { maxBuffer: 5 * 1024 * 1024 }
+            );
+            if (stdout.trim()) {
+                const lines = stdout.trim().split('\n').filter(Boolean);
+                lines.forEach(line => {
+                    const match = line.match(/^([^:]+):(\d+):(.*)$/);
+                    if (match) {
+                        results.push({
+                            file: match[1],
+                            line: parseInt(match[2]),
+                            content: match[3].trim()
+                        });
+                    }
+                });
+            }
+        } catch (e) {
+            // Ignore grep errors - no matches
+        }
+    }
+
+    if (results.length === 0) {
+        return {
+            content: [{ type: "text", text: `No definition found for '${symbol}' in ${dirPath}` }]
+        };
+    }
+
+    const output = `Definition of '${symbol}' (${results.length} found):\n`;
+    const formatted = results.slice(0, 10).map(r =>
+        `${r.file}:${r.line}\n  ${r.content}`
+    ).join('\n');
+
+    return {
+        content: [{ type: "text", text: output + formatted + (results.length > 10 ? `\n... and ${results.length - 10} more` : '') }]
+    };
+}
+
 async function handleFindReferences({ path: filePath, symbol }) {
     if (!filePath || !symbol) throw new Error("Missing path or symbol");
 
-    // Check if path is a directory
     const absolutePath = path.resolve(filePath);
-    const stats = await fs.stat(absolutePath);
+
+    // Check if path is a directory - search across files in directory
+    let stats;
+    try {
+        stats = await fs.stat(absolutePath);
+    } catch (e) {
+        throw new Error(`Path does not exist: ${filePath}`);
+    }
+
     if (!stats.isFile()) {
-        throw new Error(`Path is not a file: ${filePath}`);
+        // It's a directory - search for references using grep
+        return await handleReferencesInDirectory({ path: absolutePath, symbol });
     }
 
+    // It's a file - use tree-sitter to find references
     const content = await fs.readFile(filePath, 'utf8');
     const references = await findReferences(content, filePath, symbol);
 
@@ -1896,6 +2132,81 @@ async function handleFindReferences({ path: filePath, symbol }) {
     };
 }
 
+async function handleReferencesInDirectory({ path: dirPath, symbol }) {
+    // Search for symbol references in directory using grep
+    const flags = "-rn";
+    const excludes = [
+        "--exclude-dir=node_modules",
+        "--exclude-dir=.git",
+        "--exclude-dir=dist",
+        "--exclude-dir=build"
+    ].join(" ");
+
+    try {
+        const { stdout } = await execAsync(
+            `grep ${flags} ${excludes} -E "\\b${symbol}\\b" "${dirPath}" 2>/dev/null`,
+            { maxBuffer: 10 * 1024 * 1024 }
+        );
+
+        if (!stdout.trim()) {
+            return {
+                content: [{ type: "text", text: `No references found for '${symbol}' in ${dirPath}` }]
+            };
+        }
+
+        const lines = stdout.trim().split('\n').filter(Boolean);
+        const results = lines.map(line => {
+            const match = line.match(/^([^:]+):(\d+):(.*)$/);
+            if (match) {
+                return {
+                    file: match[1],
+                    line: parseInt(match[2]),
+                    content: match[3].trim()
+                };
+            }
+            return null;
+        }).filter(Boolean);
+
+        if (results.length === 0) {
+            return {
+                content: [{ type: "text", text: `No references found for '${symbol}' in ${dirPath}` }]
+            };
+        }
+
+        let output = `References for '${symbol}' in ${dirPath} (${results.length} found):\n\n`;
+
+        // Group by file
+        const byFile = {};
+        results.forEach(r => {
+            if (!byFile[r.file]) byFile[r.file] = [];
+            byFile[r.file].push(r);
+        });
+
+        Object.entries(byFile).slice(0, 10).forEach(([file, matches]) => {
+            output += `${colors.yellow}${file}${colors.reset}\n`;
+            matches.slice(0, 5).forEach(m => {
+                output += `  ${colors.dim}${m.line}:${colors.reset} ${m.content}\n`;
+            });
+            if (matches.length > 5) {
+                output += `  ${colors.dim}... and ${matches.length - 5} more${colors.reset}\n`;
+            }
+            output += "\n";
+        });
+
+        if (results.length > 50) {
+            output += `${colors.dim}... and ${results.length - 50} more results${colors.reset}\n`;
+        }
+
+        return {
+            content: [{ type: "text", text: output }]
+        };
+    } catch (e) {
+        return {
+            content: [{ type: "text", text: `No references found for '${symbol}' in ${dirPath}` }]
+        };
+    }
+}
+
 /**
  * Start Server
  */

package/src/strategies/search-strategy.js

@@ -29,14 +29,19 @@ export function isSemanticQuery(query) {
 
 /**
  * Determine the best search strategy
- * @returns {'local' | 'ai' | 'filesystem'}
+ * @returns {'local' | 'ai' | 'filesystem' | 'definition' | 'references'}
  */
-export function detectSearchStrategy({ query, files, path, mode }) {
+export function detectSearchStrategy({ query, files, path, mode, regex = false }) {
     // If mode is explicitly set, use it
     if (mode && mode !== 'auto') {
         return mode;
     }
 
+    // For regex searches without files, use filesystem (grep-based)
+    if (regex && !files) {
+        return 'filesystem';
+    }
+
     // Priority 1: Local search (if files provided in context)
     if (files && Object.keys(files).length > 0) {
         return 'local';