@mrxkun/mcfast-mcp 2.1.1 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "Ultra-fast code editing with fuzzy patching, auto-rollback, and 5 unified tools.",
   "type": "module",
   "bin": {
@@ -27,6 +27,10 @@
     "url": "git+https://github.com/ndpmmo/mcfast.git"
   },
   "dependencies": {
+    "@babel/generator": "^7.29.1",
+    "@babel/parser": "^7.29.0",
+    "@babel/traverse": "^7.29.0",
+    "@babel/types": "^7.29.0",
     "@modelcontextprotocol/sdk": "^0.6.0",
     "fast-glob": "^3.3.3",
     "ignore": "^7.0.5"

package/src/index.js

@@ -16,6 +16,13 @@ import fg from "fast-glob";
 import { detectEditStrategy, extractSearchReplace } from './strategies/edit-strategy.js';
 import { detectSearchStrategy } from './strategies/search-strategy.js';
 import { applyFuzzyPatch } from './strategies/fuzzy-patch.js';
+import {
+    detectRefactoringPattern,
+    parseCode,
+    renameIdentifier,
+    inlineVariable,
+    applyASTTransformation
+} from './strategies/ast-detector.js';
 import { safeEdit } from './utils/backup.js';
 import { formatError } from './utils/error-formatter.js';
 
@@ -565,7 +572,88 @@ async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
         }
     }
 
-    // Strategy 2: Search/Replace (deterministic, fastest)
+    // Strategy 2: AST Refactor (symbol-aware operations)
+    if (strategy === 'ast_refactor') {
+        const filePath = Object.keys(files)[0];
+        const fileContent = files[filePath];
+        const pattern = detectRefactoringPattern(instruction);
+
+        if (!pattern) {
+            return {
+                content: [{
+                    type: "text",
+                    text: formatError('generic', {
+                        error: 'Could not detect refactoring pattern from instruction'
+                    })
+                }],
+                isError: true
+            };
+        }
+
+        try {
+            let transformResult;
+            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);
+                    });
+                } else if (pattern.type.startsWith('inline')) {
+                    transformResult = applyASTTransformation(fileContent, filePath, (ast) => {
+                        return inlineVariable(ast, pattern.oldName);
+                    });
+                } else {
+                    throw new Error(`Unsupported refactoring type: ${pattern.type}`);
+                }
+
+                if (!transformResult.success) {
+                    throw new Error(transformResult.message);
+                }
+
+                // Write transformed code
+                await fs.writeFile(filePath, transformResult.code, 'utf8');
+            });
+
+            if (!editResult.success) {
+                let errorType = 'generic';
+                if (editResult.error.includes('ENOENT')) errorType = 'file_not_found';
+                else if (editResult.error.includes('EACCES')) errorType = 'permission_denied';
+                else if (editResult.error.includes('Validation failed')) errorType = 'syntax_error';
+
+                return {
+                    content: [{
+                        type: "text",
+                        text: formatError(errorType, {
+                            filePath,
+                            error: editResult.error,
+                            backupPath: editResult.backupPath
+                        })
+                    }],
+                    isError: true
+                };
+            }
+
+            return {
+                content: [{
+                    type: "text",
+                    text: `✅ AST Refactor Applied Successfully\n\nOperation: ${pattern.type}\nChanges: ${transformResult.count || transformResult.replacements || 0} locations\n\nBackup: ${editResult.backupPath}`
+                }]
+            };
+
+        } catch (error) {
+            return {
+                content: [{
+                    type: "text",
+                    text: formatError('generic', {
+                        error: `AST refactor failed: ${error.message}`
+                    })
+                }],
+                isError: true
+            };
+        }
+    }
+
+    // Strategy 3: Search/Replace (deterministic, fastest)
     if (strategy === 'search_replace') {
         const extracted = extractSearchReplace(instruction);
         if (extracted) {

package/src/strategies/ast-detector.js

@@ -0,0 +1,288 @@
+/**
+ * AST-Aware Detection for mcfast v2.2
+ * Enables symbol-aware refactoring using Babel parser
+ */
+
+import parser from '@babel/parser';
+import _traverse from '@babel/traverse';
+import _generate from '@babel/generator';
+import * as t from '@babel/types';
+import path from 'path';
+
+// Handle default exports from Babel (CommonJS compatibility)
+const traverse = _traverse.default || _traverse;
+const generate = _generate.default || _generate;
+
+/**
+ * Parse code into AST based on file extension
+ */
+export function parseCode(code, filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const plugins = [];
+
+    // TypeScript support
+    if (['.ts', '.tsx', '.mts', '.cts'].includes(ext)) {
+        plugins.push('typescript');
+    }
+
+    // JSX support
+    if (['.jsx', '.tsx'].includes(ext)) {
+        plugins.push('jsx');
+    }
+
+    // Common plugins
+    plugins.push('decorators-legacy', 'classProperties', 'objectRestSpread');
+
+    try {
+        return parser.parse(code, {
+            sourceType: 'module',
+            plugins,
+            errorRecovery: true
+        });
+    } catch (error) {
+        // Fallback: try as script
+        try {
+            return parser.parse(code, {
+                sourceType: 'script',
+                plugins,
+                errorRecovery: true
+            });
+        } catch (fallbackError) {
+            throw new Error(`Failed to parse ${filePath}: ${error.message}`);
+        }
+    }
+}
+
+/**
+ * Detect refactoring patterns from instruction
+ */
+export function detectRefactoringPattern(instruction) {
+    const patterns = {
+        rename_variable: /rename\s+(?:variable|var|const|let)\s+["`']?(\w+)["`']?\s+to\s+["`']?(\w+)["`']?/i,
+        rename_function: /rename\s+(?:function|func)\s+["`']?(\w+)["`']?\s+to\s+["`']?(\w+)["`']?/i,
+        rename_class: /rename\s+class\s+["`']?(\w+)["`']?\s+to\s+["`']?(\w+)["`']?/i,
+        rename_any: /rename\s+["`']?(\w+)["`']?\s+to\s+["`']?(\w+)["`']?/i,
+        extract_function: /extract\s+(?:function|method)/i,
+        inline_variable: /inline\s+(?:variable|var|const|let)\s+["`']?(\w+)["`']?/i,
+        inline_function: /inline\s+(?:function|func)\s+["`']?(\w+)["`']?/i
+    };
+
+    for (const [type, pattern] of Object.entries(patterns)) {
+        const match = instruction.match(pattern);
+        if (match) {
+            return {
+                type,
+                oldName: match[1],
+                newName: match[2] || null
+            };
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Rename identifier in AST
+ */
+export function renameIdentifier(ast, oldName, newName, options = {}) {
+    const { scope = 'all' } = options;
+    const renamedLocations = [];
+
+    traverse(ast, {
+        Identifier(path) {
+            if (path.node.name === oldName) {
+                // Check if this is a binding (declaration) or reference
+                const binding = path.scope.getBinding(oldName);
+
+                if (scope === 'all' || (binding && path.isReferencedIdentifier())) {
+                    path.node.name = newName;
+                    renamedLocations.push({
+                        line: path.node.loc?.start.line,
+                        column: path.node.loc?.start.column,
+                        type: path.parent.type
+                    });
+                }
+            }
+        }
+    });
+
+    return {
+        success: true,
+        ast,
+        count: renamedLocations.length,
+        locations: renamedLocations
+    };
+}
+
+/**
+ * Find all usages of an identifier
+ */
+export function findIdentifierUsages(ast, name) {
+    const usages = [];
+
+    traverse(ast, {
+        Identifier(path) {
+            if (path.node.name === name) {
+                const binding = path.scope.getBinding(name);
+                usages.push({
+                    line: path.node.loc?.start.line,
+                    column: path.node.loc?.start.column,
+                    type: path.parent.type,
+                    isDeclaration: binding && path.isBindingIdentifier(),
+                    isReference: path.isReferencedIdentifier(),
+                    scope: path.scope.uid
+                });
+            }
+        }
+    });
+
+    return usages;
+}
+
+/**
+ * Extract function from selected code
+ */
+export function extractFunction(ast, startLine, endLine, functionName) {
+    let extractedStatements = [];
+    let insertionPoint = null;
+
+    traverse(ast, {
+        enter(path) {
+            const loc = path.node.loc;
+            if (!loc) return;
+
+            // Find statements within range
+            if (loc.start.line >= startLine && loc.end.line <= endLine) {
+                if (t.isStatement(path.node) && !path.findParent(p => extractedStatements.includes(p.node))) {
+                    extractedStatements.push(path.node);
+                    if (!insertionPoint) {
+                        insertionPoint = path.getStatementParent();
+                    }
+                }
+            }
+        }
+    });
+
+    if (extractedStatements.length === 0) {
+        return { success: false, message: 'No statements found in range' };
+    }
+
+    // Create new function
+    const newFunction = t.functionDeclaration(
+        t.identifier(functionName),
+        [],
+        t.blockStatement(extractedStatements)
+    );
+
+    // Replace extracted code with function call
+    const functionCall = t.expressionStatement(
+        t.callExpression(t.identifier(functionName), [])
+    );
+
+    return {
+        success: true,
+        newFunction,
+        functionCall,
+        insertionPoint
+    };
+}
+
+/**
+ * Inline variable (replace all usages with its value)
+ */
+export function inlineVariable(ast, variableName) {
+    let variableValue = null;
+    let declarationPath = null;
+    const replacements = [];
+
+    // Find variable declaration
+    traverse(ast, {
+        VariableDeclarator(path) {
+            if (path.node.id.name === variableName) {
+                variableValue = path.node.init;
+                declarationPath = path;
+            }
+        }
+    });
+
+    if (!variableValue) {
+        return { success: false, message: `Variable ${variableName} not found` };
+    }
+
+    // Replace all references
+    traverse(ast, {
+        Identifier(path) {
+            if (path.node.name === variableName && path.isReferencedIdentifier()) {
+                // Clone the value to avoid reference issues
+                const clonedValue = t.cloneNode(variableValue, true);
+                path.replaceWith(clonedValue);
+                replacements.push({
+                    line: path.node.loc?.start.line,
+                    column: path.node.loc?.start.column
+                });
+            }
+        }
+    });
+
+    // Remove declaration
+    if (declarationPath) {
+        const parent = declarationPath.parentPath;
+        if (parent.node.declarations.length === 1) {
+            parent.remove();
+        } else {
+            declarationPath.remove();
+        }
+    }
+
+    return {
+        success: true,
+        ast,
+        replacements: replacements.length,
+        locations: replacements
+    };
+}
+
+/**
+ * Apply AST transformation and generate code
+ */
+export function applyASTTransformation(code, filePath, transformation) {
+    try {
+        const ast = parseCode(code, filePath);
+        const result = transformation(ast);
+
+        if (!result.success) {
+            return result;
+        }
+
+        const output = generate(result.ast || ast, {
+            retainLines: true,
+            comments: true
+        });
+
+        return {
+            success: true,
+            code: output.code,
+            ...result
+        };
+    } catch (error) {
+        return {
+            success: false,
+            message: `AST transformation failed: ${error.message}`
+        };
+    }
+}
+
+/**
+ * Check if instruction requires AST-based refactoring
+ */
+export function requiresAST(instruction) {
+    const astPatterns = [
+        /rename\s+(?:variable|function|class|method)/i,
+        /extract\s+(?:function|method)/i,
+        /inline\s+(?:variable|function)/i,
+        /move\s+(?:function|class)/i,
+        /split\s+(?:function|class)/i
+    ];
+
+    return astPatterns.some(pattern => pattern.test(instruction));
+}

package/src/strategies/edit-strategy.js

@@ -4,6 +4,7 @@
  */
 
 import { isDiffBasedEdit } from './fuzzy-patch.js';
+import { requiresAST, detectRefactoringPattern } from './ast-detector.js';
 
 /**
  * Detect if instruction is a simple search/replace
@@ -64,7 +65,7 @@ export function hasPlaceholders(codeEdit) {
 
 /**
  * Determine the best edit strategy
- * @returns {'fuzzy_patch' | 'search_replace' | 'placeholder_merge' | 'mercury_intelligent'}
+ * @returns {'fuzzy_patch' | 'ast_refactor' | 'search_replace' | 'placeholder_merge' | 'mercury_intelligent'}
  */
 export function detectEditStrategy({ instruction, code_edit, files }) {
     // Priority 1: Fuzzy Patch (unified diff format)
@@ -72,16 +73,21 @@ export function detectEditStrategy({ instruction, code_edit, files }) {
         return 'fuzzy_patch';
     }
 
-    // Priority 2: Search/Replace (fastest, deterministic)
+    // Priority 2: AST Refactor (symbol-aware operations)
+    if (requiresAST(instruction)) {
+        return 'ast_refactor';
+    }
+
+    // Priority 3: Search/Replace (fastest, deterministic)
     if (isSearchReplace(instruction)) {
         return 'search_replace';
     }
 
-    // Priority 3: Placeholder Merge (token-efficient)
+    // Priority 4: Placeholder Merge (token-efficient)
     if (code_edit && hasPlaceholders(code_edit)) {
         return 'placeholder_merge';
     }
 
-    // Priority 4: Mercury Intelligent (most flexible)
+    // Priority 5: Mercury Intelligent (most flexible)
     return 'mercury_intelligent';
 }

package/src/strategies/fuzzy-patch.js

@@ -6,27 +6,49 @@
 /**
  * Calculate Levenshtein distance between two strings
  * Used for fuzzy matching to find best location for patch
+ * Optimized with early termination and length-based shortcuts
  */
-function levenshteinDistance(str1, str2) {
+function levenshteinDistance(str1, str2, maxDistance = Infinity) {
     const len1 = str1.length;
     const len2 = str2.length;
-    const matrix = Array(len1 + 1).fill(null).map(() => Array(len2 + 1).fill(0));
 
-    for (let i = 0; i <= len1; i++) matrix[i][0] = i;
-    for (let j = 0; j <= len2; j++) matrix[0][j] = j;
+    // Quick optimization: if length difference exceeds maxDistance, return early
+    if (Math.abs(len1 - len2) > maxDistance) {
+        return maxDistance + 1;
+    }
+
+    // Optimization: swap to ensure str1 is shorter (reduces memory)
+    if (len1 > len2) {
+        return levenshteinDistance(str2, str1, maxDistance);
+    }
+
+    // Use single array instead of matrix (space optimization)
+    let prevRow = Array(len2 + 1).fill(0).map((_, i) => i);
 
     for (let i = 1; i <= len1; i++) {
+        let currentRow = [i];
+        let minInRow = i;
+
         for (let j = 1; j <= len2; j++) {
             const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
-            matrix[i][j] = Math.min(
-                matrix[i - 1][j] + 1,      // deletion
-                matrix[i][j - 1] + 1,      // insertion
-                matrix[i - 1][j - 1] + cost // substitution
+            const val = Math.min(
+                prevRow[j] + 1,      // deletion
+                currentRow[j - 1] + 1,      // insertion
+                prevRow[j - 1] + cost // substitution
             );
+            currentRow.push(val);
+            minInRow = Math.min(minInRow, val);
         }
+
+        // Early termination: if minimum in row exceeds maxDistance, abort
+        if (minInRow > maxDistance) {
+            return maxDistance + 1;
+        }
+
+        prevRow = currentRow;
     }
 
-    return matrix[len1][len2];
+    return prevRow[len2];
 }
 
 /**
@@ -103,16 +125,40 @@ export function parseDiff(diffText) {
  * Returns { index, score, lineNumber } or null if no good match
  */
 export function findBestMatch(targetLines, patternLines, threshold = 0.8) {
+    // Input validation
+    if (!targetLines || !patternLines || patternLines.length === 0) {
+        return null;
+    }
+
+    if (targetLines.length < patternLines.length) {
+        return null;
+    }
+
+    // Performance limit: skip if pattern is too large (>500 lines)
+    if (patternLines.length > 500) {
+        return null;
+    }
+
     let bestMatch = null;
     let bestScore = 0;
+    const maxIterations = Math.min(targetLines.length - patternLines.length + 1, 10000);
 
-    // Sliding window search
-    for (let i = 0; i <= targetLines.length - patternLines.length; i++) {
+    // Sliding window search with iteration limit
+    for (let i = 0; i < maxIterations; i++) {
         const window = targetLines.slice(i, i + patternLines.length);
         const windowText = window.join('\n');
         const patternText = patternLines.join('\n');
 
-        const score = similarityScore(windowText, patternText);
+        // Calculate max acceptable distance based on threshold
+        const maxLen = Math.max(windowText.length, patternText.length);
+        const maxDistance = Math.ceil(maxLen * (1 - threshold));
+
+        const distance = levenshteinDistance(windowText, patternText, maxDistance);
+
+        // Skip if distance exceeds threshold
+        if (distance > maxDistance) continue;
+
+        const score = 1.0 - (distance / maxLen);
 
         if (score > bestScore && score >= threshold) {
             bestScore = score;
@@ -121,6 +167,11 @@ export function findBestMatch(targetLines, patternLines, threshold = 0.8) {
                 score: score,
                 lineNumber: i + 1
             };
+
+            // Early exit if perfect match found
+            if (score >= 0.99) {
+                break;
+            }
         }
     }
 
@@ -183,7 +234,34 @@ export function applyHunk(fileContent, hunk, threshold = 0.8) {
  * Main entry point for fuzzy patching
  */
 export function applyFuzzyPatch(fileContent, diffText, options = {}) {
+    // Input validation
+    if (!fileContent || typeof fileContent !== 'string') {
+        return {
+            success: false,
+            content: fileContent || '',
+            message: 'Invalid file content provided'
+        };
+    }
+
+    if (!diffText || typeof diffText !== 'string') {
+        return {
+            success: false,
+            content: fileContent,
+            message: 'Invalid diff text provided'
+        };
+    }
+
     const threshold = options.threshold || parseFloat(process.env.MCFAST_FUZZY_THRESHOLD || '0.8');
+
+    // Validate threshold range
+    if (threshold < 0 || threshold > 1) {
+        return {
+            success: false,
+            content: fileContent,
+            message: 'Threshold must be between 0 and 1'
+        };
+    }
+
     const hunks = parseDiff(diffText);
 
     if (hunks.length === 0) {

package/src/utils/backup.js

@@ -70,7 +70,9 @@ async function cleanupOldBackups(fileName) {
  */
 export async function validateJavaScript(filePath) {
     try {
-        const { stderr } = await execAsync(`node --check "${filePath}"`, {
+        // Escape file path for shell command
+        const escapedPath = filePath.replace(/"/g, '\\"');
+        const { stderr } = await execAsync(`node --check "${escapedPath}"`, {
             timeout: 5000
         });
 
@@ -89,7 +91,9 @@ export async function validateJavaScript(filePath) {
  */
 export async function validatePython(filePath) {
     try {
-        await execAsync(`python -m py_compile "${filePath}"`, {
+        // Escape file path for shell command
+        const escapedPath = filePath.replace(/"/g, '\\"');
+        await execAsync(`python -m py_compile "${escapedPath}"`, {
             timeout: 5000
         });
         return { valid: true };