@mrxkun/mcfast-mcp 1.0.2 → 1.0.4

package/README.md

@@ -81,7 +81,7 @@ replace: "api.example.com"
 ## 🔒 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.2`.
+- **Open Source Client:** Audit the source at [github.com/ndpmmo/mcfast](https://github.com/ndpmmo/mcfast). Current stable version: `1.0.4`.
 - **Token Masking:** Your `MCFAST_TOKEN` is never logged
 
 ---

package/package.json

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

package/src/index.js

@@ -8,6 +8,8 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import fs from "fs/promises";
+import path from "path";
 
 const API_URL = "https://mcfast.vercel.app/api/v1";
 const TOKEN = process.env.MCFAST_TOKEN;
@@ -74,6 +76,42 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     required: ["files", "search", "replace"]
                 }
+            },
+            {
+                name: "search_code_ai",
+                description: "Intelligently search for code patterns across multiple files. Returns matches with surrounding context.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "Search query (supports natural language or literal strings)"
+                        },
+                        files: {
+                            type: "object",
+                            description: "Map of file paths to content to search within.",
+                            additionalProperties: { type: "string" }
+                        },
+                        contextLines: {
+                            type: "number",
+                            description: "Number of lines to show before/after each match (default: 2)"
+                        }
+                    },
+                    required: ["query", "files"]
+                }
+            },
+            {
+                name: "edit_file",
+                description: "Edit a local file by providing the target path and the new code content. This tool writes directly to the filesystem.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Absolute or relative path to the file." },
+                        content: { type: "string", description: "The full new content of the file." },
+                        instruction: { type: "string", description: "Briefly what you changed (for logging)." }
+                    },
+                    required: ["path", "content"]
+                }
             }
         ],
     };
@@ -88,18 +126,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     if (name === "apply_fast") {
         return await handleApplyFast(args);
     } else if (name === "apply_search_replace") {
-        // Placeholder: You could implement a dedicated endpoint for this later to save tokens
-        // For now, we route it to apply_fast with a synthesized instruction
         return await handleApplyFast({
             instruction: `Replace checking for exact match:\nSEARCH:\n${args.search}\n\nREPLACE WITH:\n${args.replace}`,
             files: args.files,
-            dryRun: false
+            dryRun: args.dryRun || false
         });
+    } else if (name === "search_code_ai") {
+        return await handleSearchCodeAI(args);
+    } else if (name === "edit_file") {
+        return await handleEditFile(args);
     }
 
     throw new Error(`Tool not found: ${name}`);
 });
 
+async function handleEditFile({ path: filePath, content, instruction = "" }) {
+    try {
+        await fs.writeFile(filePath, content, 'utf8');
+        return {
+            content: [{ type: "text", text: `✅ File saved successfully: ${filePath}` }]
+        };
+    } catch (error) {
+        return {
+            content: [{ type: "text", text: `❌ Failed to write file: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+
 async function handleApplyFast({ instruction, files, dryRun }) {
     try {
         const response = await fetch(`${API_URL}/apply`, {
@@ -121,8 +175,26 @@ async function handleApplyFast({ instruction, files, dryRun }) {
 
         const data = await response.json();
 
-        // Format the result nicely for the AI Agent consuming this tool
-        let output = `✅ Edit Applied Successfully via ${data.strategy} (${data.latency_ms}ms)\n\n`;
+        // AUTOMATIC FILE WRITING LOGIC
+        const writtenFiles = [];
+        if (!dryRun && data.files) {
+            for (const [filePath, content] of Object.entries(data.files)) {
+                try {
+                    await fs.writeFile(filePath, content, 'utf8');
+                    writtenFiles.push(filePath);
+                } catch (writeErr) {
+                    console.error(`Failed to write ${filePath}:`, writeErr);
+                }
+            }
+        }
+
+        // Format the result nicely
+        let output = `✅ Edit Processed via ${data.strategy} (${data.latency_ms}ms)\n`;
+        if (writtenFiles.length > 0) {
+            output += `💾 Automatically saved ${writtenFiles.length} files to disk.\n\n`;
+        } else if (dryRun) {
+            output += `🔍 DRY RUN: No files were modified on disk.\n\n`;
+        }
 
         if (data.diffs && Object.keys(data.diffs).length > 0) {
             for (const [path, diff] of Object.entries(data.diffs)) {
@@ -144,6 +216,55 @@ async function handleApplyFast({ instruction, files, dryRun }) {
     }
 }
 
+async function handleSearchCodeAI({ query, files, contextLines = 2 }) {
+    try {
+        const response = await fetch(`${API_URL}/search-ai`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${TOKEN}`,
+            },
+            body: JSON.stringify({ query, files, contextLines }),
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            return {
+                content: [{ type: "text", text: `Search Error (${response.status}): ${errorText}` }],
+                isError: true,
+            };
+        }
+
+        const data = await response.json();
+
+        // Format results nicely
+        let output = `🔍 Found ${data.totalMatches} matches for "${query}"\\n\\n`;
+
+        if (data.results.length === 0) {
+            output += "No matches found.";
+        } else {
+            data.results.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 < data.results.length - 1) output += "\\n";
+            });
+        }
+
+        return {
+            content: [{ type: "text", text: output }],
+        };
+
+    } catch (error) {
+        return {
+            content: [{ type: "text", text: `Search Connection Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+
 /**
  * Start Server
  */