@mrxkun/mcfast-mcp 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Ultra-fast code editing via Mercury Coder Cloud API.",
   "type": "module",
   "bin": {
@@ -27,6 +27,8 @@
     "url": "git+https://github.com/ndpmmo/mcfast.git"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^0.6.0"
+    "@modelcontextprotocol/sdk": "^0.6.0",
+    "fast-glob": "^3.3.3",
+    "ignore": "^7.0.5"
   }
 }

package/src/index.js

@@ -12,6 +12,7 @@ import fs from "fs/promises";
 import path from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
+import fg from "fast-glob";
 
 const execAsync = promisify(exec);
 
@@ -26,7 +27,7 @@ if (!TOKEN) {
 const server = new Server(
     {
         name: "mcfast",
-        version: "1.2.0",
+        version: "1.3.0",
     },
     {
         capabilities: {
@@ -130,13 +131,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 }
             },
             {
-                name: "warpgrep_codebase_search",
-                description: "High-performance codebase search using native grep. Searches the entire local project directory. Fast and reliable for finding symbol definitions or usages without passing file contents.",
+                name: "search_filesystem",
+                description: "Deep, high-performance filesystem search using ripgrep -> git grep -> grep fallback. Best for finding code when you don't know the file location.",
                 inputSchema: {
                     type: "object",
                     properties: {
                         query: { type: "string", description: "Search pattern (literal or regex)" },
-                        include: { type: "string", description: "Glob pattern for files to include (e.g. *.ts)" },
+                        path: { type: "string", description: "Directory to search in (default: current cwd)" },
+                        include: { type: "string", description: "Glob pattern to include (e.g. **/*.ts)" },
+                        exclude: { type: "array", items: { type: "string" }, description: "Patterns to exclude" },
                         isRegex: { type: "boolean", description: "Treat query as regex (default: false)" },
                         caseSensitive: { type: "boolean", description: "Case sensitive search (default: false)" }
                     },
@@ -285,8 +288,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
     if (name === "apply_fast") {
         return await handleApplyFast({ ...args, toolName: 'apply_fast' });
-    } else if (name === "warpgrep_codebase_search") {
-        return await handleWarpgrep(args);
+    } else if (name === "search_filesystem") {
+        return await handleSearchFilesystem(args);
     } else if (name === "apply_search_replace") {
         return await handleApplyFast({
             instruction: `Replace checking for exact match:\nSEARCH:\n${args.search}\n\nREPLACE WITH:\n${args.replace}`,
@@ -362,6 +365,104 @@ async function reportAudit(params) {
     }
 }
 
+// Unified Search Implementation
+async function handleSearchFilesystem({ query, path: searchPath = process.cwd(), include = "**/*", exclude = [], isRegex = false, caseSensitive = false }) {
+    const start = Date.now();
+    try {
+        let results = [];
+        let strategy = 'node_fallback';
+
+        // 1. Try ripgrep (rg) if available - fastest
+        try {
+            const flags = [
+                "--json",
+                caseSensitive ? "-s" : "-i",
+                isRegex ? "-e" : "-F"
+            ].join(" ");
+            // This is a simplified call; parsing JSON output from rg is best for structured data
+            // For now, we'll rely on a simpler text output for the LLM
+            const simpleFlags = [
+                "-n",
+                "--no-heading",
+                "--with-filename",
+                caseSensitive ? "-s" : "-i",
+                isRegex ? "-e" : "-F"
+            ].join(" ");
+
+            const command = `rg ${simpleFlags} "${query.replace(/"/g, '\\"')}" ${searchPath}`;
+            const { stdout } = await execAsync(command, { maxBuffer: 10 * 1024 * 1024 });
+            results = stdout.trim().split('\n').filter(Boolean);
+            strategy = 'ripgrep';
+        } catch (rgErr) {
+            // 2. Try git grep if in a git repo
+            try {
+                const flags = [
+                    "-n",
+                    "-I",
+                    caseSensitive ? "" : "-i",
+                    isRegex ? "-E" : "-F"
+                ].filter(Boolean).join(" ");
+                const command = `git grep ${flags} "${query.replace(/"/g, '\\"')}" ${searchPath}`;
+                const { stdout } = await execAsync(command, { cwd: searchPath, maxBuffer: 10 * 1024 * 1024 });
+                results = stdout.trim().split('\n').filter(Boolean);
+                strategy = 'git_grep';
+            } catch (gitErr) {
+                // 3. Fallback to native grep
+                try {
+                    const flags = [
+                        "-r", "-n", "-I",
+                        caseSensitive ? "" : "-i",
+                        isRegex ? "-E" : "-F"
+                    ].filter(Boolean).join(" ");
+                    const exclusions = ["node_modules", ".git", ".next", "dist", "build"].map(d => `--exclude-dir=${d}`).join(" ");
+                    const command = `grep ${flags} ${exclusions} "${query.replace(/"/g, '\\"')}" ${searchPath}`;
+                    const { stdout } = await execAsync(command, { maxBuffer: 10 * 1024 * 1024 });
+                    results = stdout.trim().split('\n').filter(Boolean);
+                    strategy = 'native_grep';
+                } catch (grepErr) {
+                    // 4. Node.js fallback (slowest but guaranteed)
+                    // Only used if all system tools fail
+                    strategy = 'node_js_fallback';
+                    // ... (implement if needed, but grep usually exists)
+                }
+            }
+        }
+
+        let output = `⚡ search_filesystem (${strategy}) found ${results.length} results for "${query}"\n\n`;
+        if (results.length === 0) {
+            output += "No matches found.";
+        } else {
+            const limitedResults = results.slice(0, 100);
+            output += limitedResults.join('\n');
+            if (results.length > 100) output += `\n... and ${results.length - 100} more matches.`;
+        }
+
+        reportAudit({
+            tool: 'search_filesystem',
+            instruction: query,
+            strategy: strategy,
+            status: 'success',
+            latency_ms: Date.now() - start,
+            files_count: 0
+        });
+
+        return { content: [{ type: "text", text: output }] };
+
+    } catch (error) {
+        reportAudit({
+            tool: 'search_filesystem',
+            instruction: query,
+            status: 'error',
+            error_message: error.message,
+            latency_ms: Date.now() - start
+        });
+        return {
+            content: [{ type: "text", text: `❌ search_filesystem error: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+
 // Native high-performance search
 async function handleWarpgrep({ query, include = ".", isRegex = false, caseSensitive = false }) {
     const start = Date.now();