@mrxkun/mcfast-mcp 2.1.2 → 2.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "2.1.2",
+  "version": "2.2.1",
   "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,18 @@ 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 {
+    detectCrossFileEdit,
+    batchRenameSymbol,
+    updateImportPaths
+} from './strategies/multi-file-coordinator.js';
 import { safeEdit } from './utils/backup.js';
 import { formatError } from './utils/error-formatter.js';
 
@@ -493,6 +505,61 @@ async function handleReapply({ instruction, files, errorContext = "", attempt =
  * Auto-detects best strategy based on input
  */
 async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
+    // Check for multi-file edits first
+    const multiFileEdit = detectCrossFileEdit(instruction, files);
+
+    if (multiFileEdit && Object.keys(files).length > 1) {
+        console.error(`${colors.cyan}[MULTI-FILE EDIT]${colors.reset} ${multiFileEdit.type} - ${multiFileEdit.reason}`);
+
+        try {
+            let result;
+
+            if (multiFileEdit.type === 'symbol_rename') {
+                result = await batchRenameSymbol(files, multiFileEdit.symbol, multiFileEdit.newSymbol);
+            } else if (multiFileEdit.type === 'dependency') {
+                // Extract old and new paths from instruction
+                const pathMatch = instruction.match(/from\s+['"]([^'"]+)['"]\s+to\s+['"]([^'"]+)['"]/i);
+                if (pathMatch) {
+                    result = await updateImportPaths(files, pathMatch[1], pathMatch[2]);
+                } else {
+                    throw new Error('Could not extract import paths from instruction');
+                }
+            } else {
+                throw new Error(`Unsupported multi-file edit type: ${multiFileEdit.type}`);
+            }
+
+            if (!result.success) {
+                return {
+                    content: [{
+                        type: "text",
+                        text: formatError('generic', {
+                            error: result.message || result.error
+                        })
+                    }],
+                    isError: true
+                };
+            }
+
+            return {
+                content: [{
+                    type: "text",
+                    text: `✅ Multi-File Edit Successful\n\nType: ${multiFileEdit.type}\nFiles Modified: ${result.files.length}\n\nBackups created for all files.`
+                }]
+            };
+
+        } catch (error) {
+            return {
+                content: [{
+                    type: "text",
+                    text: formatError('generic', {
+                        error: `Multi-file edit failed: ${error.message}`
+                    })
+                }],
+                isError: true
+            };
+        }
+    }
+
     const strategy = detectEditStrategy({ instruction, code_edit, files });
 
     console.error(`${colors.cyan}[EDIT STRATEGY]${colors.reset} ${strategy}`);
@@ -565,7 +632,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/multi-file-coordinator.js

@@ -0,0 +1,298 @@
+/**
+ * Multi-File Coordination for mcfast v2.2
+ * Enables cross-file edits with atomic rollback
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { parseCode, renameIdentifier, findIdentifierUsages } from './ast-detector.js';
+import { createBackup, restoreFromBackup, validateFile } from '../utils/backup.js';
+import _generate from '@babel/generator';
+
+// Handle default export from Babel (CommonJS compatibility)
+const generate = _generate.default || _generate;
+
+/**
+ * Detect if edit requires multiple files
+ */
+export function detectCrossFileEdit(instruction, files) {
+    const fileKeys = Object.keys(files);
+
+    // Pattern 1: Explicit multi-file mention
+    if (/in\s+all\s+files|across\s+files|in\s+every|everywhere/i.test(instruction)) {
+        return {
+            type: 'broadcast',
+            files: fileKeys,
+            reason: 'Explicit multi-file instruction'
+        };
+    }
+
+    // Pattern 2: Import/Export changes
+    if (/change\s+import|update\s+import|fix\s+import|update\s+export/i.test(instruction)) {
+        return {
+            type: 'dependency',
+            files: fileKeys,
+            reason: 'Import/export modification'
+        };
+    }
+
+    // Pattern 3: Symbol rename (check if symbol exists in multiple files)
+    const renameMatch = instruction.match(/rename\s+(?:variable|function|class|const|let)?\s*["`']?(\w+)["`']?\s+to\s+["`']?(\w+)["`']?/i);
+    if (renameMatch && fileKeys.length > 1) {
+        const [, oldName, newName] = renameMatch;
+        const filesWithSymbol = findFilesUsingSymbol(files, oldName);
+
+        if (filesWithSymbol.length > 1) {
+            return {
+                type: 'symbol_rename',
+                symbol: oldName,
+                newSymbol: newName,
+                files: filesWithSymbol,
+                reason: `Symbol "${oldName}" found in ${filesWithSymbol.length} files`
+            };
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Find files that use a specific symbol
+ */
+export function findFilesUsingSymbol(files, symbolName) {
+    const filesWithSymbol = [];
+
+    for (const [filePath, content] of Object.entries(files)) {
+        // Quick text search first (performance optimization)
+        if (!content.includes(symbolName)) continue;
+
+        try {
+            const ast = parseCode(content, filePath);
+            const usages = findIdentifierUsages(ast, symbolName);
+
+            if (usages.length > 0) {
+                filesWithSymbol.push({
+                    path: filePath,
+                    usageCount: usages.length,
+                    usages
+                });
+            }
+        } catch (error) {
+            // If AST parsing fails, fall back to text search
+            const regex = new RegExp(`\\b${symbolName}\\b`, 'g');
+            const matches = content.match(regex);
+            if (matches && matches.length > 0) {
+                filesWithSymbol.push({
+                    path: filePath,
+                    usageCount: matches.length,
+                    usages: [],
+                    parseError: error.message
+                });
+            }
+        }
+    }
+
+    return filesWithSymbol.map(f => f.path);
+}
+
+/**
+ * Find files that import from a specific file
+ */
+export function findDependentFiles(files, targetFile) {
+    const dependents = [];
+    const targetBasename = path.basename(targetFile, path.extname(targetFile));
+
+    for (const [filePath, content] of Object.entries(files)) {
+        if (filePath === targetFile) continue;
+
+        // Check for imports from target file
+        const importPatterns = [
+            new RegExp(`from\\s+['"](\\.\\/|\\.\\.\\/)*${targetBasename}['"]`, 'g'),
+            new RegExp(`require\\(['"](\\.\\/|\\.\\.\\/)*${targetBasename}['"]\\)`, 'g'),
+            new RegExp(`import\\(['"](\\.\\/|\\.\\.\\/)*${targetBasename}['"]\\)`, 'g')
+        ];
+
+        const hasImport = importPatterns.some(pattern => pattern.test(content));
+        if (hasImport) {
+            dependents.push(filePath);
+        }
+    }
+
+    return dependents;
+}
+
+/**
+ * Atomic multi-file edit with rollback
+ */
+export async function safeMultiFileEdit(fileEdits) {
+    const backups = new Map();
+    const completed = [];
+    const results = [];
+
+    try {
+        // Phase 1: Backup all files
+        console.error(`[MULTI-FILE] Backing up ${fileEdits.length} files...`);
+        for (const { filePath } of fileEdits) {
+            const backupPath = await createBackup(filePath);
+            backups.set(filePath, backupPath);
+        }
+
+        // Phase 2: Apply all edits
+        console.error(`[MULTI-FILE] Applying edits...`);
+        for (const { filePath, editFn } of fileEdits) {
+            try {
+                const result = await editFn();
+                completed.push(filePath);
+                results.push({ filePath, success: true, result });
+            } catch (error) {
+                throw new Error(`Edit failed for ${filePath}: ${error.message}`);
+            }
+        }
+
+        // Phase 3: Validate all files
+        console.error(`[MULTI-FILE] Validating ${completed.length} files...`);
+        for (const filePath of completed) {
+            const validation = await validateFile(filePath);
+            if (!validation.valid) {
+                throw new Error(`Validation failed for ${filePath}: ${validation.error}`);
+            }
+        }
+
+        console.error(`[MULTI-FILE] ✅ All ${completed.length} files edited successfully`);
+
+        return {
+            success: true,
+            files: completed,
+            results,
+            backups: Array.from(backups.entries())
+        };
+
+    } catch (error) {
+        // Rollback ALL files
+        console.error(`[MULTI-FILE] ❌ Error: ${error.message}`);
+        console.error(`[MULTI-FILE] Rolling back ${backups.size} files...`);
+
+        for (const [filePath, backupPath] of backups) {
+            try {
+                await restoreFromBackup(filePath, backupPath);
+            } catch (restoreError) {
+                console.error(`[MULTI-FILE] Failed to restore ${filePath}: ${restoreError.message}`);
+            }
+        }
+
+        return {
+            success: false,
+            error: error.message,
+            rolledBack: Array.from(backups.keys())
+        };
+    }
+}
+
+/**
+ * Batch rename symbol across multiple files
+ */
+export async function batchRenameSymbol(files, oldName, newName) {
+    const fileEdits = [];
+
+    for (const [filePath, content] of Object.entries(files)) {
+        // Skip if symbol not in file
+        if (!content.includes(oldName)) continue;
+
+        fileEdits.push({
+            filePath,
+            editFn: async () => {
+                const ast = parseCode(content, filePath);
+                const result = renameIdentifier(ast, oldName, newName);
+
+                if (!result.success) {
+                    throw new Error(result.message);
+                }
+
+                const output = generate(result.ast, {
+                    retainLines: true,
+                    comments: true
+                });
+
+                await fs.writeFile(filePath, output.code, 'utf8');
+
+                return {
+                    count: result.count,
+                    locations: result.locations
+                };
+            }
+        });
+    }
+
+    if (fileEdits.length === 0) {
+        return {
+            success: false,
+            message: `Symbol "${oldName}" not found in any files`
+        };
+    }
+
+    return await safeMultiFileEdit(fileEdits);
+}
+
+/**
+ * Update import paths across multiple files
+ */
+export async function updateImportPaths(files, oldPath, newPath) {
+    const fileEdits = [];
+    const oldBasename = path.basename(oldPath, path.extname(oldPath));
+    const newBasename = path.basename(newPath, path.extname(newPath));
+
+    for (const [filePath, content] of Object.entries(files)) {
+        const hasImport = content.includes(oldBasename);
+        if (!hasImport) continue;
+
+        fileEdits.push({
+            filePath,
+            editFn: async () => {
+                // Replace import paths
+                let newContent = content;
+
+                // Handle various import formats
+                const patterns = [
+                    {
+                        regex: new RegExp(`from\\s+(['"])(\\.\\/|\\.\\.\\/)*${oldBasename}\\1`, 'g'),
+                        replace: (match, quote, prefix) => `from ${quote}${prefix || './'}${newBasename}${quote}`
+                    },
+                    {
+                        regex: new RegExp(`require\\((['"])(\\.\\/|\\.\\.\\/)*${oldBasename}\\1\\)`, 'g'),
+                        replace: (match, quote, prefix) => `require(${quote}${prefix || './'}${newBasename}${quote})`
+                    },
+                    {
+                        regex: new RegExp(`import\\((['"])(\\.\\/|\\.\\.\\/)*${oldBasename}\\1\\)`, 'g'),
+                        replace: (match, quote, prefix) => `import(${quote}${prefix || './'}${newBasename}${quote})`
+                    }
+                ];
+
+                let changeCount = 0;
+                for (const { regex, replace } of patterns) {
+                    const matches = newContent.match(regex);
+                    if (matches) {
+                        changeCount += matches.length;
+                        newContent = newContent.replace(regex, replace);
+                    }
+                }
+
+                if (changeCount === 0) {
+                    throw new Error('No import statements found to update');
+                }
+
+                await fs.writeFile(filePath, newContent, 'utf8');
+
+                return { changeCount };
+            }
+        });
+    }
+
+    if (fileEdits.length === 0) {
+        return {
+            success: false,
+            message: `No files import from "${oldPath}"`
+        };
+    }
+
+    return await safeMultiFileEdit(fileEdits);
+}