@mrxkun/mcfast-mcp 2.2.0 → 2.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Ultra-fast code editing with fuzzy patching, auto-rollback, and 5 unified tools.",
   "type": "module",
   "bin": {

package/src/index.js

@@ -23,6 +23,11 @@ import {
     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';
 
@@ -500,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}`);

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);
+}