@mrxkun/mcfast-mcp 2.1.2 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "2.1.2",
+  "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';
 }