@mrxkun/mcfast-mcp 1.0.7 → 1.0.9

package/README.md

@@ -76,6 +76,27 @@ search: "localhost:3000"
 replace: "api.example.com"
 ```
 
+### `search_code` ⚡ (No API required)
+Fast local pattern-based search. Works offline without token.
+
+**Example:**
+```
+query: "fetchData"
+files: { "src/api.js": "<content>" }
+regex: false
+contextLines: 2
+```
+
+### `reapply`
+Smart retry for failed/incomplete edits. Auto-retries up to 3 times with enhanced context.
+
+**Example:**
+```
+instruction: "Add error handling to all fetch calls"
+files: { "src/api.js": "<content>" }
+errorContext: "Previous attempt missed the catch block"
+```
+
 ---
 
 ## 🧠 MCP Prompts
@@ -91,7 +112,7 @@ mcfast provides built-in strategies for AI agents (Claude Desktop, etc) to use t
 ## 🔒 Privacy & Security
 
 - **Zero Persistence:** Code is processed in-memory and discarded immediately
-- **Open Source Client:** Audit the source at [github.com/ndpmmo/mcfast](https://github.com/ndpmmo/mcfast). Current stable version: `1.0.7`.
+- **Open Source Client:** Audit the source at [github.com/ndpmmo/mcfast](https://github.com/ndpmmo/mcfast). Current stable version: `1.0.9`.
 - **Token Masking:** Your `MCFAST_TOKEN` is never logged
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Ultra-fast code editing via Mercury Coder Cloud API.",
   "type": "module",
   "bin": {

package/src/index.js

@@ -22,11 +22,12 @@ if (!TOKEN) {
 const server = new Server(
     {
         name: "mcfast",
-        version: "1.0.0",
+        version: "1.0.9",
     },
     {
         capabilities: {
             tools: {},
+            prompts: {},
         },
     }
 );
@@ -123,6 +124,34 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         depth: { type: "number", description: "Max depth to traverse (default: 5)." }
                     }
                 }
+            },
+            {
+                name: "search_code",
+                description: "Fast local code search using pattern matching. No API call required. Supports regex and literal search.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Search pattern (literal or regex)" },
+                        files: { type: "object", description: "Map of file paths to content to search within.", additionalProperties: { type: "string" } },
+                        regex: { type: "boolean", description: "Treat query as regex (default: false)" },
+                        contextLines: { type: "number", description: "Lines of context around matches (default: 2)" }
+                    },
+                    required: ["query", "files"]
+                }
+            },
+            {
+                name: "reapply",
+                description: "Smart retry for failed or incomplete edits. Analyzes error context and re-attempts with adjusted strategy. Max 3 retries.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        instruction: { type: "string", description: "Original instruction that failed" },
+                        files: { type: "object", description: "Current file contents", additionalProperties: { type: "string" } },
+                        errorContext: { type: "string", description: "Description of the error or incomplete result" },
+                        attempt: { type: "number", description: "Current attempt number (auto-incremented, starts at 1)" }
+                    },
+                    required: ["instruction", "files"]
+                }
             }
         ],
     };
@@ -249,11 +278,115 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return await handleEditFile(args);
     } else if (name === "list_files_fast") {
         return await handleListFiles(args);
+    } else if (name === "search_code") {
+        return await handleSearchCode(args);
+    } else if (name === "reapply") {
+        return await handleReapply(args);
     }
 
     throw new Error(`Tool not found: ${name}`);
 });
 
+// Smart retry handler
+async function handleReapply({ instruction, files, errorContext = "", attempt = 1 }) {
+    const MAX_ATTEMPTS = 3;
+
+    if (attempt > MAX_ATTEMPTS) {
+        return {
+            content: [{ type: "text", text: `❌ Max retry attempts (${MAX_ATTEMPTS}) reached. Manual intervention required.\n\nOriginal instruction: ${instruction}\nLast error: ${errorContext}` }],
+            isError: true
+        };
+    }
+
+    // Enhance instruction based on error context
+    let enhancedInstruction = instruction;
+    if (errorContext) {
+        enhancedInstruction = `Previous attempt failed with: "${errorContext}"\n\nPlease retry with extra care:\n${instruction}`;
+    }
+
+    try {
+        const result = await handleApplyFast({ instruction: enhancedInstruction, files, dryRun: false });
+        return {
+            content: [{
+                type: "text",
+                text: `✅ Reapply successful on attempt ${attempt}/${MAX_ATTEMPTS}\n\n${result.content[0].text}`
+            }]
+        };
+    } catch (error) {
+        // Recurse with incremented attempt
+        return handleReapply({
+            instruction,
+            files,
+            errorContext: error.message,
+            attempt: attempt + 1
+        });
+    }
+}
+
+// Local search implementation (no API required)
+async function handleSearchCode({ query, files, regex = false, contextLines = 2 }) {
+    try {
+        const results = [];
+        const pattern = regex ? new RegExp(query, 'gim') : null;
+
+        for (const [filePath, content] of Object.entries(files)) {
+            if (typeof content !== 'string') continue;
+
+            const lines = content.split('\n');
+            lines.forEach((line, index) => {
+                let isMatch = false;
+                if (regex && pattern) {
+                    isMatch = pattern.test(line);
+                    pattern.lastIndex = 0; // Reset for global regex
+                } else {
+                    isMatch = line.toLowerCase().includes(query.toLowerCase());
+                }
+
+                if (isMatch) {
+                    const startLine = Math.max(0, index - contextLines);
+                    const endLine = Math.min(lines.length - 1, index + contextLines);
+
+                    const contextSnippet = lines
+                        .slice(startLine, endLine + 1)
+                        .map((l, i) => ({
+                            lineNumber: startLine + i + 1,
+                            content: l,
+                            isMatch: startLine + i === index
+                        }));
+
+                    results.push({
+                        file: filePath,
+                        lineNumber: index + 1,
+                        matchedLine: line.trim(),
+                        context: contextSnippet
+                    });
+                }
+            });
+        }
+
+        let output = `🔍 Found ${results.length} matches for "${query}"\n\n`;
+        if (results.length === 0) {
+            output += "No matches found.";
+        } else {
+            results.slice(0, 50).forEach((result, i) => {
+                output += `📄 ${result.file}:${result.lineNumber}\n`;
+                result.context.forEach(ctx => {
+                    const prefix = ctx.isMatch ? "→ " : "  ";
+                    output += `${prefix}${ctx.lineNumber}: ${ctx.content}\n`;
+                });
+                if (i < Math.min(results.length, 50) - 1) output += "\n";
+            });
+        }
+
+        return { content: [{ type: "text", text: output }] };
+    } catch (error) {
+        return {
+            content: [{ type: "text", text: `❌ Search error: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+
 async function handleListFiles({ path: dirPath = process.cwd(), depth = 5 }) {
     try {
         const files = await getFiles(dirPath, depth);