@mrxkun/mcfast-mcp 1.0.2

package/README.md

@@ -0,0 +1,106 @@
+# @mrxkun/mcfast-mcp
+
+**Ultra-fast code editing for AI agents** powered by [Mercury Coder](https://inceptionlabs.ai) Cloud.
+
+Transform any MCP-enabled AI (Claude Code, Cursor, Windsurf, OpenCode) into a **Priority Coder** with intelligent multi-file editing capabilities.
+
+---
+
+## 🚀 Quick Start
+
+### 1. Get Your Token
+Visit [mcfast.vercel.app](https://mcfast.vercel.app) to sign up and get your free `MCFAST_TOKEN`.
+
+### 2. Install & Configure
+
+**Claude Code / Claude Desktop:**
+```json
+{
+  "mcpServers": {
+    "mcfast": {
+      "command": "npx",
+      "args": ["-y", "@mrxkun/mcfast-mcp"],
+      "env": {
+        "MCFAST_TOKEN": "mcfast_..."
+      }
+    }
+  }
+}
+```
+
+**Cursor / Windsurf:**
+1. Settings → Features → MCP → Add New Server
+2. Name: `mcfast`
+3. Command: `npx -y @mrxkun/mcfast-mcp`
+4. Environment: `MCFAST_TOKEN=mcfast_...`
+
+**VS Code / OpenCode:**
+```json
+{
+  "mcp.servers": {
+    "mcfast": {
+      "command": "npx",
+      "args": ["-y", "@mrxkun/mcfast-mcp"],
+      "env": { "MCFAST_TOKEN": "mcfast_..." }
+    }
+  }
+}
+```
+
+---
+
+## 🛠️ Available Tools
+
+### `apply_fast`
+Apply intelligent code edits to multiple files simultaneously.
+
+**Example:**
+```
+instruction: "Add error handling to all fetch calls"
+files: { "src/api.js": "<content>", "src/utils.js": "<content>" }
+dryRun: false
+```
+
+**Features:**
+- Automatic strategy selection (SEARCH_REPLACE, MULTI_EDIT, FULL_REWRITE)
+- Deterministic diff generation
+- Syntax-aware transformations
+
+### `apply_search_replace`
+Fast targeted replacements for simple edits.
+
+**Example:**
+```
+files: { "src/config.js": "<content>" }
+search: "localhost:3000"
+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`.
+- **Token Masking:** Your `MCFAST_TOKEN` is never logged
+
+---
+
+## 💎 Priority Coder Mode
+
+Upgrade to **Priority Coder** by adding your own Mercury API key in the [dashboard settings](https://mcfast.vercel.app):
+- Dedicated bandwidth (no shared rate limits)
+- Higher throughput for large codebases
+- Direct access to Mercury Coder infrastructure
+
+---
+
+## 📚 Documentation
+
+- [Dashboard](https://mcfast.vercel.app)
+- [GitHub Repository](https://github.com/ndpmmo/mcfast)
+- [Mercury Coder Docs](https://inceptionlabs.ai)
+
+## 📜 License
+
+MIT © [mrxkun](https://github.com/mrxkun)

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@mrxkun/mcfast-mcp",
+  "version": "1.0.2",
+  "description": "Ultra-fast code editing via Mercury Coder Cloud API.",
+  "type": "module",
+  "bin": {
+    "mcfast-mcp": "src/index.js"
+  },
+  "main": "src/index.js",
+  "files": [
+    "src/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "cursor",
+    "mercury",
+    "fast-apply"
+  ],
+  "author": "mrxkun",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ndpmmo/mcfast.git"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.6.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+/**
+ * mcfast MCP Client v1.0.0
+ * Proxies code edit requests to mcfast Cloud (Vercel)
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+const API_URL = "https://mcfast.vercel.app/api/v1";
+const TOKEN = process.env.MCFAST_TOKEN;
+
+if (!TOKEN) {
+    console.error("❌ Error: MCFAST_TOKEN is missing. Get one at https://mcfast.vercel.app");
+    process.exit(1);
+}
+
+const server = new Server(
+    {
+        name: "mcfast",
+        version: "1.0.0",
+    },
+    {
+        capabilities: {
+            tools: {},
+        },
+    }
+);
+
+/**
+ * MCP Tool Definition: apply_fast
+ */
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "apply_fast",
+                description: "Apply complex multi-file code edits intelligently using Mercury Coder Cloud. Suitable for refactoring, bug fixes, and feature implementation across multiple files.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        instruction: {
+                            type: "string",
+                            description: "The natural language instruction describing what changes to make.",
+                        },
+                        files: {
+                            type: "object",
+                            description: "A dictionary where keys are file paths and values are CURRENT file contents. Provide context for files you want to edit.",
+                            additionalProperties: { type: "string" }
+                        },
+                        dryRun: {
+                            type: "boolean",
+                            description: "If true, returns the diff but does not apply changes (for preview). Default: false.",
+                        },
+                    },
+                    required: ["instruction", "files"],
+                },
+            },
+            {
+                name: "apply_search_replace",
+                description: "Apply targeted search/replace edits. Faster and cheaper for simple replacements.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "object",
+                            description: "Map of file paths to content.",
+                            additionalProperties: { type: "string" }
+                        },
+                        search: { type: "string", description: "Exact string to search for." },
+                        replace: { type: "string", description: "String to replace with." }
+                    },
+                    required: ["files", "search", "replace"]
+                }
+            }
+        ],
+    };
+});
+
+/**
+ * Tool Execution Handler
+ */
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    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
+        });
+    }
+
+    throw new Error(`Tool not found: ${name}`);
+});
+
+async function handleApplyFast({ instruction, files, dryRun }) {
+    try {
+        const response = await fetch(`${API_URL}/apply`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${TOKEN}`,
+            },
+            body: JSON.stringify({ instruction, files, dryRun }),
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            return {
+                content: [{ type: "text", text: `Cloud Error (${response.status}): ${errorText}` }],
+                isError: true,
+            };
+        }
+
+        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`;
+
+        if (data.diffs && Object.keys(data.diffs).length > 0) {
+            for (const [path, diff] of Object.entries(data.diffs)) {
+                output += `📄 ${path}:\n${diff}\n\n`;
+            }
+        } else {
+            output += "No changes detected or files were identical.";
+        }
+
+        return {
+            content: [{ type: "text", text: output }],
+        };
+
+    } catch (error) {
+        return {
+            content: [{ type: "text", text: `Client Connection Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+
+/**
+ * Start Server
+ */
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("mcfast MCP v1.0.0 running on stdio");