@mrxkun/mcfast-mcp 2.2.4 → 3.0.1

package/README.md

@@ -41,6 +41,7 @@ Intelligently edits files with automatic strategy detection:
 - **Search/Replace**: Detects patterns like "Replace X with Y" → uses deterministic replacement
 - **Placeholder Merge**: Detects `// ... existing code ...` → uses token-efficient merging  
 - **Mercury AI**: Falls back to complex refactoring via Mercury Coder Cloud
+- **Tree-sitter WASM** (v3.0): **100x Faster** renaming for Go, Rust, Java, JS, TS.
 
 **Replaces:** `apply_fast`, `edit_file`, `apply_search_replace`
 
@@ -157,10 +158,16 @@ Automatically retries failed edits with adjusted strategy (max 3 attempts).
 
 ## Privacy & Security
 
-- **Zero Persistence**: Code processed in memory, discarded immediately
-- **Cloud Masking**: Your `MCFAST_TOKEN` never exposed in logs
-- **Open Source**: Audit the source at [github.com/ndpmmo/mcfast](https://github.com/ndpmmo/mcfast)
+- **Zero Persistence:** Code processed in memory, discarded immediately
+- **Cloud Masking:** Your `MCFAST_TOKEN` never exposed in logs
+- **Transient Code:** Client code available via NPM for easy installation
 
-## License
+## License & Usage
 
-MIT © [mrxkun](https://github.com/mrxkun)
+**mcfast is free to use.**
+
+- **NPM Package:** The client code is distributed on NPM.
+- **Service:** The Mercury Coder Cloud service is free via [mcfast.vercel.app](https://mcfast.vercel.app).
+- **Not Open Source:** mcfast is a proprietary tool. You are free to use it for personal or commercial projects, but the source code is not open source.
+
+Copyright © [mrxkun](https://github.com/mrxkun)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "2.2.4",
+  "version": "3.0.1",
   "description": "Ultra-fast code editing with fuzzy patching, auto-rollback, and 5 unified tools.",
   "type": "module",
   "bin": {
@@ -33,6 +33,11 @@
     "@babel/types": "^7.29.0",
     "@modelcontextprotocol/sdk": "^0.6.0",
     "fast-glob": "^3.3.3",
-    "ignore": "^7.0.5"
+    "ignore": "^7.0.5",
+    "tree-sitter-go": "^0.25.0",
+    "tree-sitter-java": "^0.23.5",
+    "tree-sitter-javascript": "^0.25.0",
+    "tree-sitter-rust": "^0.24.0",
+    "web-tree-sitter": "^0.26.5"
   }
-}
+}

package/src/index.js

@@ -28,6 +28,9 @@ import {
     batchRenameSymbol,
     updateImportPaths
 } from './strategies/multi-file-coordinator.js';
+import { detectLanguage, validateSyntax } from './strategies/syntax-validator.js';
+import { validate as validateTreeSitter } from './strategies/tree-sitter/index.js';
+import { renameSymbol as renameSymbolTreeSitter } from './strategies/tree-sitter/refactor.js';
 import { safeEdit } from './utils/backup.js';
 import { formatError } from './utils/error-formatter.js';
 
@@ -580,6 +583,21 @@ async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
                     throw new Error(patchResult.message);
                 }
 
+                // Syntax Validation (New for v2.3)
+                const language = detectLanguage(filePath);
+
+                // Try Tree-sitter validation first (Async, robust)
+                let validation = await validateTreeSitter(patchResult.content, filePath);
+
+                // Fallback to basic validation if Tree-sitter skipped (e.g. language not supported or failed)
+                if (!validation) {
+                    validation = validateSyntax(patchResult.content, language);
+                }
+
+                if (!validation.valid) {
+                    throw new Error(`Syntax Error in ${language} file: ${validation.error}`);
+                }
+
                 // Write patched content
                 await fs.writeFile(filePath, patchResult.content, 'utf8');
             });
@@ -655,9 +673,29 @@ async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
             const editResult = await safeEdit(filePath, async () => {
                 // Apply AST transformation based on pattern type
                 if (pattern.type.startsWith('rename')) {
-                    transformResult = applyASTTransformation(fileContent, filePath, (ast) => {
-                        return renameIdentifier(ast, pattern.oldName, pattern.newName);
-                    });
+                    // Start of v3.0: Use Tree-sitter for supported languages
+                    const language = detectLanguage(filePath);
+                    if (['go', 'rust', 'java', 'javascript', 'typescript'].includes(language)) {
+                        console.error(`${colors.cyan}[TREE-SITTER]${colors.reset} Using WASM rename for ${language}`);
+                        try {
+                            const newCode = await renameSymbolTreeSitter(fileContent, filePath, pattern.oldName, pattern.newName);
+                            transformResult = { success: true, code: newCode, count: 1 };
+                        } catch (e) {
+                            if (['javascript', 'typescript'].includes(language)) {
+                                console.error(`${colors.yellow}[FALLBACK]${colors.reset} Tree-sitter failed, trying Babel: ${e.message}`);
+                                transformResult = applyASTTransformation(fileContent, filePath, (ast) => {
+                                    return renameIdentifier(ast, pattern.oldName, pattern.newName);
+                                });
+                            } else {
+                                throw e;
+                            }
+                        }
+                    } else {
+                        // Legacy Babel path
+                        transformResult = applyASTTransformation(fileContent, filePath, (ast) => {
+                            return renameIdentifier(ast, pattern.oldName, pattern.newName);
+                        });
+                    }
                 } else if (pattern.type.startsWith('inline')) {
                     transformResult = applyASTTransformation(fileContent, filePath, (ast) => {
                         return inlineVariable(ast, pattern.oldName);

package/src/strategies/syntax-validator.js

@@ -0,0 +1,168 @@
+/**
+ * Syntax Validator & Language Detector for mcfast v2.3
+ * Provides basic syntax checking for non-JS languages to prevent broken edits
+ */
+
+import path from 'path';
+
+/**
+ * Detect language from file extension
+ */
+export function detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+
+    const map = {
+        '.js': 'javascript',
+        '.jsx': 'javascript',
+        '.ts': 'typescript',
+        '.tsx': 'typescript',
+        '.go': 'go',
+        '.rs': 'rust',
+        '.java': 'java',
+        '.py': 'python',
+        '.c': 'c',
+        '.cpp': 'cpp',
+        '.h': 'c',
+        '.hpp': 'cpp'
+    };
+
+    return map[ext] || 'unknown';
+}
+
+/**
+ * Validate syntax based on language
+ * Returns { valid: boolean, error: string | null }
+ */
+export function validateSyntax(code, language) {
+    // Skip unknown languages
+    if (!['go', 'rust', 'java'].includes(language)) {
+        return { valid: true, error: null };
+    }
+
+    // common checks
+    const braceCheck = checkBalancedBraces(code);
+    if (!braceCheck.valid) {
+        return braceCheck;
+    }
+
+    // Language specific checks
+    switch (language) {
+        case 'go':
+            return validateGo(code);
+        case 'rust':
+            return validateRust(code);
+        case 'java':
+            return validateJava(code);
+        default:
+            return { valid: true, error: null };
+    }
+}
+
+/**
+ * Check for balanced braces {}, [], ()
+ */
+function checkBalancedBraces(code) {
+    const stack = [];
+    const pairs = { '}': '{', ']': '[', ')': '(' };
+
+    // Simple state machine to ignore strings and comments
+    let inString = false;
+    let stringChar = '';
+    let inLineComment = false;
+    let inBlockComment = false;
+
+    for (let i = 0; i < code.length; i++) {
+        const char = code[i];
+        const nextChar = code[i + 1];
+
+        // Handle comments
+        if (!inString && !inLineComment && !inBlockComment) {
+            if (char === '/' && nextChar === '/') {
+                inLineComment = true;
+                i++;
+                continue;
+            }
+            if (char === '/' && nextChar === '*') {
+                inBlockComment = true;
+                i++;
+                continue;
+            }
+        }
+
+        if (inLineComment) {
+            if (char === '\n') inLineComment = false;
+            continue;
+        }
+
+        if (inBlockComment) {
+            if (char === '*' && nextChar === '/') {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+
+        // Handle strings
+        if (!inLineComment && !inBlockComment) {
+            if (char === '"' || char === "'" || (char === '`')) {
+                if (!inString) {
+                    inString = true;
+                    stringChar = char;
+                } else if (char === stringChar && code[i - 1] !== '\\') {
+                    inString = false;
+                }
+                continue;
+            }
+        }
+
+        if (inString) continue;
+
+        // Check braces
+        if (['{', '[', '('].includes(char)) {
+            stack.push(char);
+        } else if (['}', ']', ')'].includes(char)) {
+            const last = stack.pop();
+            if (last !== pairs[char]) {
+                return {
+                    valid: false,
+                    error: `Unbalanced brace '${char}' at index ${i}. Expected closing for '${last || 'none'}'`
+                };
+            }
+        }
+    }
+
+    if (stack.length > 0) {
+        return {
+            valid: false,
+            error: `Unclosed brace '${stack[stack.length - 1]}'`
+        };
+    }
+
+    return { valid: true, error: null };
+}
+
+function validateGo(code) {
+    // Basic Go checks
+    // If it has 'func main()', it MUST have 'package main'
+    if (code.includes('func main()')) {
+        const hasPackageMain = /^\s*package\s+main\b/m.test(code);
+        if (!hasPackageMain) {
+            return { valid: false, error: 'Go files with main function must have package main' };
+        }
+    }
+    return { valid: true, error: null };
+}
+
+function validateRust(code) {
+    // Basic Rust checks
+    // Check for obvious missing semicolons in simple statements (heuristic)
+    // This is hard to do reliably with regex, so we stick to structural integrity (braces) which is already done
+    return { valid: true, error: null };
+}
+
+function validateJava(code) {
+    // Basic Java checks
+    // Check if class matches filename is too hard without filename context passed down often
+    // We stick to structural integrity
+    return { valid: true, error: null };
+}

package/src/strategies/tree-sitter/index.js

@@ -0,0 +1,86 @@
+/**
+ * Tree-sitter Strategy Entry Point
+ */
+import { getParser } from './languages.js';
+import { detectLanguage } from '../syntax-validator.js'; // Reuse existing detection
+
+/**
+ * Parse code and return AST
+ */
+export async function parse(code, filePath) {
+    const language = detectLanguage(filePath);
+    if (!['go', 'rust', 'java', 'javascript', 'typescript'].includes(language)) {
+        return null;
+    }
+
+    try {
+        const parser = await getParser(language);
+        return parser.parse(code);
+    } catch (e) {
+        console.warn(`Tree-sitter parse failed for ${filePath}:`, e);
+        return null;
+    }
+}
+
+/**
+ * Validate syntax using Tree-sitter
+ * Returns { valid: boolean, error: string | null }
+ */
+export async function validate(code, filePath) {
+    const tree = await parse(code, filePath);
+    if (!tree) {
+        // Fallback or skip
+        return null;
+    }
+
+    // Check for errors in the tree
+    // Tree-sitter produces ERROR nodes for syntax errors
+    let hasError = false;
+    let errorNode = null;
+
+    // Simple traversal to find error node
+    // We can't use simple recursion easily on the tree object depending on binding version,
+    // but typically rootNode.hasError() is available.
+
+    // Check root node
+    // In web-tree-sitter, hasError is a property, not a function
+    const rootHasError = typeof tree.rootNode.hasError === 'function'
+        ? tree.rootNode.hasError()
+        : tree.rootNode.hasError;
+
+    if (rootHasError) {
+        hasError = true;
+        // Find the first error node for details
+        errorNode = findErrorNode(tree.rootNode);
+    }
+
+    if (hasError) {
+        const { startPosition, endPosition } = errorNode || tree.rootNode;
+        return {
+            valid: false,
+            error: `Syntax error at line ${startPosition.row + 1}, column ${startPosition.column}`
+        };
+    }
+
+    return { valid: true, error: null };
+}
+
+function findErrorNode(node) {
+    if (node.type === 'ERROR' || node.type === 'MISSING') {
+        return node;
+    }
+
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        const childHasError = typeof child.hasError === 'function'
+            ? child.hasError()
+            : child.hasError;
+
+        if (childHasError) {
+            // Recurse into the child that actually has the error
+            return findErrorNode(child) || child;
+        }
+    }
+
+    return null;
+}

package/src/strategies/tree-sitter/languages.js

@@ -0,0 +1,103 @@
+/**
+ * Tree-sitter Language Loader
+ */
+import path from 'path';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const require = createRequire(import.meta.url);
+const _Parser = require('web-tree-sitter');
+
+let Parser = _Parser;
+// If default export exists, use it
+if (Parser.default) {
+    Parser = Parser.default;
+}
+// If Parser property exists and Parser itself isn't the constructor
+if (typeof Parser !== 'function' && Parser.Parser) {
+    Parser = Parser.Parser;
+}
+
+let isInitialized = false;
+const languageCache = new Map();
+
+// Map internal language IDs to WASM filenames
+const WASM_MAP = {
+    'go': 'tree-sitter-go.wasm',
+    'rust': 'tree-sitter-rust.wasm',
+    'java': 'tree-sitter-java.wasm',
+    'javascript': 'tree-sitter-javascript.wasm',
+    'typescript': 'tree-sitter-javascript.wasm', // TS often uses JS or its own, using JS for now as fallback/compatible
+};
+
+/**
+ * Initialize web-tree-sitter
+ */
+async function init() {
+    if (isInitialized) return;
+    try {
+        const wasmPath = path.resolve(__dirname, 'wasm', 'web-tree-sitter.wasm');
+        await Parser.init({
+            locateFile: () => wasmPath,
+        });
+        isInitialized = true;
+    } catch (e) {
+        console.error('Failed to initialize web-tree-sitter:', e);
+        // Fallback: try without explicit path (may work if in same dir)
+        try {
+            await Parser.init();
+            isInitialized = true;
+        } catch (e2) {
+            throw new Error(`Failed to initialize web-tree-sitter: ${e.message}`);
+        }
+    }
+}
+
+/**
+ * Load language parser
+ * @param {string} language - 'go', 'rust', 'java', etc.
+ */
+export async function loadLanguage(language) {
+    if (!isInitialized) await init();
+
+    if (languageCache.has(language)) {
+        return languageCache.get(language);
+    }
+
+    const wasmFile = WASM_MAP[language];
+    if (!wasmFile) {
+        throw new Error(`Unsupported tree-sitter language: ${language}`);
+    }
+
+    // Resolve path to wasm file
+    // Assuming this file is at packages/mcp-client/src/strategies/tree-sitter/languages.js
+    // and wasm files are at packages/mcp-client/src/strategies/tree-sitter/wasm/
+    const wasmPath = path.resolve(__dirname, 'wasm', wasmFile);
+
+    // Resolve Language class
+    let Language = Parser.Language;
+    if (!Language && _Parser.Language) {
+        Language = _Parser.Language;
+    }
+
+    try {
+        const lang = await Language.load(wasmPath);
+        languageCache.set(language, lang);
+        return lang;
+    } catch (e) {
+        // Fallback for different environments where __dirname might behave differently
+        // Try relative path if absolute fails, or check common locations
+        console.error(`Failed to load language ${language} from ${wasmPath}`, e);
+        throw e;
+    }
+}
+
+export async function getParser(language) {
+    const lang = await loadLanguage(language);
+    const parser = new Parser();
+    parser.setLanguage(lang);
+    return parser;
+}

package/src/strategies/tree-sitter/queries.js

@@ -0,0 +1,69 @@
+/**
+ * Tree-sitter Queries
+ */
+
+export const QUERIES = {
+    go: {
+        definitions: `
+            (function_declaration name: (identifier) @name) @function
+            (method_declaration name: (field_identifier) @name) @method
+            (type_declaration (type_spec name: (type_identifier) @name)) @class
+        `,
+        references: `
+            (identifier) @ref
+            (type_identifier) @ref
+            (field_identifier) @ref
+        `
+    },
+    rust: {
+        definitions: `
+            (function_item name: (identifier) @name) @function
+            (impl_item type: (type_identifier) @name) @impl
+            (struct_item name: (type_identifier) @name) @struct
+            (enum_item name: (type_identifier) @name) @enum
+        `,
+        references: `
+            (identifier) @ref
+            (type_identifier) @ref
+            (field_identifier) @ref
+        `
+    },
+    java: {
+        definitions: `
+            (method_declaration name: (identifier) @name) @method
+            (class_declaration name: (identifier) @name) @class
+            (interface_declaration name: (identifier) @name) @interface
+        `,
+        references: `
+            (identifier) @ref
+            (type_identifier) @ref
+        `
+    },
+    javascript: {
+        definitions: `
+            (function_declaration name: (identifier) @name) @function
+            (class_declaration name: (identifier) @name) @class
+            (method_definition key: (property_identifier) @name) @method
+            (variable_declarator name: (identifier) @name init: (arrow_function)) @arrow_function
+        `,
+        references: `
+            (identifier) @ref
+            (property_identifier) @ref
+            (shorthand_property_identifier_pattern) @ref
+        `
+    },
+    typescript: {
+        definitions: `
+            (function_declaration name: (identifier) @name) @function
+            (class_declaration name: (type_identifier) @name) @class
+            (method_definition key: (property_identifier) @name) @method
+            (interface_declaration name: (type_identifier) @name) @interface
+        `,
+        references: `
+            (identifier) @ref
+            (type_identifier) @ref
+            (property_identifier) @ref
+            (shorthand_property_identifier_pattern) @ref
+        `
+    }
+};

package/src/strategies/tree-sitter/refactor.js

@@ -0,0 +1,107 @@
+/**
+ * Tree-sitter Refactoring Logic
+ */
+import { parse } from './index.js';
+import { getParser, loadLanguage } from './languages.js';
+import { QUERIES } from './queries.js';
+import { detectLanguage } from '../syntax-validator.js';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const _Parser = require('web-tree-sitter');
+// Get the Query constructor from the module if available, or try Parser.Query
+const Query = _Parser.Query || (_Parser.default && _Parser.default.Query) || (_Parser.Parser && _Parser.Parser.Query);
+
+/**
+ * Rename a symbol in the code using Tree-sitter
+ * @param {string} code - The source code
+ * @param {string} filePath - File path for language detection
+ * @param {string} oldName - The identifier to rename
+ * @param {string} newName - The new name
+ * @returns {Promise<string>} - The modified code
+ */
+export async function renameSymbol(code, filePath, oldName, newName) {
+    const language = detectLanguage(filePath);
+    if (!QUERIES[language]) {
+        throw new Error(`Refactoring not supported for ${language}`);
+    }
+
+    const tree = await parse(code, filePath);
+    if (!tree) {
+        throw new Error('Failed to parse code');
+    }
+
+    const langObj = await loadLanguage(language);
+
+    let query;
+    try {
+        if (typeof langObj.query === 'function') {
+            query = langObj.query(QUERIES[language].references);
+        } else if (Query) {
+            query = new Query(langObj, QUERIES[language].references);
+        } else {
+            throw new Error('Query constructor not found');
+        }
+    } catch (e) {
+        throw new Error(`Failed to create query: ${e.message}`);
+    }
+
+    // Find all occurrences of the identifier
+    const captures = query.captures(tree.rootNode);
+    const matches = captures.filter(c => c.node.text === oldName);
+
+    if (matches.length === 0) {
+        return code;
+    }
+
+    // TODO: Advanced scope analysis
+    // For now, we'll implement a "smart text replace" that respects the AST
+    // This avoids replacing substrings in string literals or comments, 
+    // which simple regex replace would do incorrectly.
+
+    // Process edits in reverse order to preserve indices
+    let result = code;
+    // Sort matches by start index descending
+    matches.sort((a, b) => b.node.startIndex - a.node.startIndex);
+
+    // Filter duplicates (some nodes might be captured multiple times if queries overlap)
+    const uniqueMatches = [];
+    let lastIndex = -1;
+
+    for (const match of matches) {
+        if (match.node.startIndex !== lastIndex) {
+            uniqueMatches.push(match);
+            lastIndex = match.node.startIndex;
+        }
+    }
+
+    for (const match of uniqueMatches) {
+        const { startIndex, endIndex } = match.node;
+        result = result.substring(0, startIndex) + newName + result.substring(endIndex);
+    }
+
+    return result;
+}
+
+/**
+ * Find all references of a symbol
+ */
+export async function findReferences(code, filePath, symbolName) {
+    const language = detectLanguage(filePath);
+    if (!QUERIES[language]) return [];
+
+    const tree = await parse(code, filePath);
+    if (!tree) return [];
+
+    const langObj = await loadLanguage(language);
+    const query = langObj.query(QUERIES[language].references);
+
+    const captures = query.captures(tree.rootNode);
+    return captures
+        .filter(c => c.node.text === symbolName)
+        .map(c => ({
+            line: c.node.startPosition.row + 1,
+            column: c.node.startPosition.column,
+            text: c.node.text
+        }));
+}