@mrxkun/mcfast-mcp 2.0.0 → 2.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "2.0.0",
-  "description": "Ultra-fast code editing with 5 unified tools and intelligent auto-detection.",
+  "version": "2.1.0",
+  "description": "Ultra-fast code editing with fuzzy patching, auto-rollback, and 5 unified tools.",
   "type": "module",
   "bin": {
     "mcfast-mcp": "src/index.js"

package/src/index.js

@@ -15,6 +15,9 @@ import { promisify } from "util";
 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 { safeEdit } from './utils/backup.js';
+import { formatError } from './utils/error-formatter.js';
 
 const execAsync = promisify(exec);
 
@@ -494,7 +497,63 @@ async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
 
     console.error(`${colors.cyan}[EDIT STRATEGY]${colors.reset} ${strategy}`);
 
-    // Strategy 1: Search/Replace (deterministic, fastest)
+    // Strategy 1: Fuzzy Patch (unified diff format)
+    if (strategy === 'fuzzy_patch') {
+        const diffText = code_edit || instruction;
+        const filePath = Object.keys(files)[0]; // Assume single file for now
+        const fileContent = files[filePath];
+
+        try {
+            // Apply fuzzy patch with backup/rollback
+            let patchResult;
+            const editResult = await safeEdit(filePath, async () => {
+                patchResult = applyFuzzyPatch(fileContent, diffText);
+
+                if (!patchResult.success) {
+                    throw new Error(patchResult.message);
+                }
+
+                // Write patched content
+                await fs.writeFile(filePath, patchResult.content, 'utf8');
+            });
+
+            if (!editResult.success) {
+                // Rollback occurred
+                return {
+                    content: [{
+                        type: "text",
+                        text: formatError('syntax_error', {
+                            filePath,
+                            error: editResult.error,
+                            backupPath: editResult.backupPath
+                        })
+                    }],
+                    isError: true
+                };
+            }
+
+            return {
+                content: [{
+                    type: "text",
+                    text: `✅ Fuzzy Patch Applied Successfully\n\n${patchResult.message}\nConfidence: ${(patchResult.confidence * 100).toFixed(1)}%\n\nBackup: ${editResult.backupPath}`
+                }]
+            };
+
+        } catch (error) {
+            return {
+                content: [{
+                    type: "text",
+                    text: formatError('fuzzy_match_failed', {
+                        filePath,
+                        error: error.message
+                    })
+                }],
+                isError: true
+            };
+        }
+    }
+
+    // Strategy 2: Search/Replace (deterministic, fastest)
     if (strategy === 'search_replace') {
         const extracted = extractSearchReplace(instruction);
         if (extracted) {
@@ -507,10 +566,8 @@ async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
         }
     }
 
-    // Strategy 2: Placeholder Merge (token-efficient)
+    // Strategy 3: Placeholder Merge (token-efficient)
     if (strategy === 'placeholder_merge' && code_edit) {
-        // Use edit_file logic for placeholder-based editing
-        // For now, we'll route to Mercury with a hint
         return await handleApplyFast({
             instruction: `${instruction}\n\nUSE PLACEHOLDER MERGE STRATEGY. Code snippet:\n${code_edit}`,
             files,
@@ -519,7 +576,7 @@ async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
         });
     }
 
-    // Strategy 3: Mercury Intelligent (most flexible, default)
+    // Strategy 4: Mercury Intelligent (most flexible, default)
     return await handleApplyFast({
         instruction,
         files,

package/src/strategies/edit-strategy.js

@@ -3,6 +3,8 @@
  * Determines the best editing strategy based on input parameters
  */
 
+import { isDiffBasedEdit } from './fuzzy-patch.js';
+
 /**
  * Detect if instruction is a simple search/replace
  */
@@ -62,19 +64,24 @@ export function hasPlaceholders(codeEdit) {
 
 /**
  * Determine the best edit strategy
- * @returns {'search_replace' | 'placeholder_merge' | 'mercury_intelligent'}
+ * @returns {'fuzzy_patch' | 'search_replace' | 'placeholder_merge' | 'mercury_intelligent'}
  */
 export function detectEditStrategy({ instruction, code_edit, files }) {
-    // Priority 1: Search/Replace (fastest, deterministic)
+    // Priority 1: Fuzzy Patch (unified diff format)
+    if (isDiffBasedEdit(instruction) || isDiffBasedEdit(code_edit || '')) {
+        return 'fuzzy_patch';
+    }
+
+    // Priority 2: Search/Replace (fastest, deterministic)
     if (isSearchReplace(instruction)) {
         return 'search_replace';
     }
 
-    // Priority 2: Placeholder Merge (token-efficient)
+    // Priority 3: Placeholder Merge (token-efficient)
     if (code_edit && hasPlaceholders(code_edit)) {
         return 'placeholder_merge';
     }
 
-    // Priority 3: Mercury Intelligent (most flexible)
+    // Priority 4: Mercury Intelligent (most flexible)
     return 'mercury_intelligent';
 }

package/src/strategies/fuzzy-patch.js

@@ -0,0 +1,235 @@
+/**
+ * Fuzzy Patching Engine for mcfast v2.1
+ * Applies code changes with tolerance for whitespace and minor formatting differences
+ */
+
+/**
+ * Calculate Levenshtein distance between two strings
+ * Used for fuzzy matching to find best location for patch
+ */
+function levenshteinDistance(str1, str2) {
+    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;
+
+    for (let i = 1; i <= len1; 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
+            );
+        }
+    }
+
+    return matrix[len1][len2];
+}
+
+/**
+ * Normalize whitespace for comparison
+ * Converts tabs to spaces, trims lines, removes trailing whitespace
+ */
+function normalizeWhitespace(text) {
+    return text
+        .split('\n')
+        .map(line => line.replace(/\t/g, '    ').trimEnd())
+        .join('\n')
+        .trim();
+}
+
+/**
+ * Calculate similarity score between two strings (0-1)
+ * 1.0 = identical, 0.0 = completely different
+ */
+function similarityScore(str1, str2) {
+    const normalized1 = normalizeWhitespace(str1);
+    const normalized2 = normalizeWhitespace(str2);
+
+    const maxLen = Math.max(normalized1.length, normalized2.length);
+    if (maxLen === 0) return 1.0;
+
+    const distance = levenshteinDistance(normalized1, normalized2);
+    return 1.0 - (distance / maxLen);
+}
+
+/**
+ * Parse unified diff format
+ * Returns array of hunks with line numbers and changes
+ */
+export function parseDiff(diffText) {
+    const hunks = [];
+    const lines = diffText.split('\n');
+    let currentHunk = null;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        // Parse hunk header: @@ -1,3 +1,4 @@
+        if (line.startsWith('@@')) {
+            if (currentHunk) hunks.push(currentHunk);
+
+            const match = line.match(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+            if (match) {
+                currentHunk = {
+                    oldStart: parseInt(match[1]),
+                    oldLines: parseInt(match[2] || '1'),
+                    newStart: parseInt(match[3]),
+                    newLines: parseInt(match[4] || '1'),
+                    lines: []
+                };
+            }
+        } else if (currentHunk) {
+            // Parse diff lines
+            if (line.startsWith('-')) {
+                currentHunk.lines.push({ type: 'remove', content: line.slice(1) });
+            } else if (line.startsWith('+')) {
+                currentHunk.lines.push({ type: 'add', content: line.slice(1) });
+            } else if (line.startsWith(' ')) {
+                currentHunk.lines.push({ type: 'context', content: line.slice(1) });
+            }
+        }
+    }
+
+    if (currentHunk) hunks.push(currentHunk);
+    return hunks;
+}
+
+/**
+ * Find best match location for a pattern in target text
+ * Returns { index, score, lineNumber } or null if no good match
+ */
+export function findBestMatch(targetLines, patternLines, threshold = 0.8) {
+    let bestMatch = null;
+    let bestScore = 0;
+
+    // Sliding window search
+    for (let i = 0; i <= targetLines.length - patternLines.length; i++) {
+        const window = targetLines.slice(i, i + patternLines.length);
+        const windowText = window.join('\n');
+        const patternText = patternLines.join('\n');
+
+        const score = similarityScore(windowText, patternText);
+
+        if (score > bestScore && score >= threshold) {
+            bestScore = score;
+            bestMatch = {
+                index: i,
+                score: score,
+                lineNumber: i + 1
+            };
+        }
+    }
+
+    return bestMatch;
+}
+
+/**
+ * Apply a single hunk to file content with fuzzy matching
+ * Returns { success, content, confidence, message }
+ */
+export function applyHunk(fileContent, hunk, threshold = 0.8) {
+    const lines = fileContent.split('\n');
+
+    // Extract context lines (lines that should match)
+    const contextLines = hunk.lines
+        .filter(l => l.type === 'context' || l.type === 'remove')
+        .map(l => l.content);
+
+    // Find best match location
+    const match = findBestMatch(lines, contextLines, threshold);
+
+    if (!match) {
+        return {
+            success: false,
+            content: fileContent,
+            confidence: 0,
+            message: `Could not find matching location (threshold: ${threshold})`
+        };
+    }
+
+    // Apply changes at matched location
+    const newLines = [...lines];
+    let offset = match.index;
+
+    for (const diffLine of hunk.lines) {
+        if (diffLine.type === 'remove' || diffLine.type === 'context') {
+            // Remove or skip context line
+            if (diffLine.type === 'remove') {
+                newLines.splice(offset, 1);
+            } else {
+                offset++;
+            }
+        } else if (diffLine.type === 'add') {
+            // Insert new line
+            newLines.splice(offset, 0, diffLine.content);
+            offset++;
+        }
+    }
+
+    return {
+        success: true,
+        content: newLines.join('\n'),
+        confidence: match.score,
+        message: `Applied at line ${match.lineNumber} (confidence: ${(match.score * 100).toFixed(1)}%)`
+    };
+}
+
+/**
+ * Apply complete diff with fuzzy matching
+ * Main entry point for fuzzy patching
+ */
+export function applyFuzzyPatch(fileContent, diffText, options = {}) {
+    const threshold = options.threshold || parseFloat(process.env.MCFAST_FUZZY_THRESHOLD || '0.8');
+    const hunks = parseDiff(diffText);
+
+    if (hunks.length === 0) {
+        return {
+            success: false,
+            content: fileContent,
+            message: 'No valid hunks found in diff'
+        };
+    }
+
+    let currentContent = fileContent;
+    const results = [];
+
+    for (const hunk of hunks) {
+        const result = applyHunk(currentContent, hunk, threshold);
+        results.push(result);
+
+        if (!result.success) {
+            return {
+                success: false,
+                content: fileContent,
+                message: `Failed to apply hunk: ${result.message}`,
+                partialResults: results
+            };
+        }
+
+        currentContent = result.content;
+    }
+
+    const avgConfidence = results.reduce((sum, r) => sum + r.confidence, 0) / results.length;
+
+    return {
+        success: true,
+        content: currentContent,
+        confidence: avgConfidence,
+        message: `Applied ${hunks.length} hunk(s) successfully`,
+        details: results
+    };
+}
+
+/**
+ * Detect if instruction is a diff-based edit
+ * Returns true if instruction contains unified diff markers
+ */
+export function isDiffBasedEdit(instruction) {
+    if (!instruction) return false;
+    // Check for unified diff hunk markers (@@)
+    return instruction.includes('@@');
+}

package/src/utils/backup.js

@@ -0,0 +1,202 @@
+/**
+ * Backup and Rollback Manager for mcfast v2.1
+ * Handles file backups before edits and auto-rollback on errors
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+const BACKUP_DIR = '.mcfast-backup';
+const MAX_BACKUPS = 5;
+
+/**
+ * Create backup of a file before editing
+ * Returns backup path
+ */
+export async function createBackup(filePath) {
+    const timestamp = Date.now();
+    const fileName = path.basename(filePath);
+    const backupPath = path.join(BACKUP_DIR, `${fileName}.${timestamp}`);
+
+    // Ensure backup directory exists
+    await fs.mkdir(BACKUP_DIR, { recursive: true });
+
+    // Copy file to backup
+    await fs.copyFile(filePath, backupPath);
+
+    // Cleanup old backups
+    await cleanupOldBackups(fileName);
+
+    return backupPath;
+}
+
+/**
+ * Restore file from backup
+ */
+export async function restoreFromBackup(filePath, backupPath) {
+    await fs.copyFile(backupPath, filePath);
+}
+
+/**
+ * Cleanup old backups, keeping only the most recent MAX_BACKUPS
+ */
+async function cleanupOldBackups(fileName) {
+    try {
+        const files = await fs.readdir(BACKUP_DIR);
+        const backups = files
+            .filter(f => f.startsWith(fileName + '.'))
+            .map(f => ({
+                name: f,
+                timestamp: parseInt(f.split('.').pop())
+            }))
+            .sort((a, b) => b.timestamp - a.timestamp);
+
+        // Remove old backups
+        for (let i = MAX_BACKUPS; i < backups.length; i++) {
+            await fs.unlink(path.join(BACKUP_DIR, backups[i].name));
+        }
+    } catch (err) {
+        // Ignore cleanup errors
+    }
+}
+
+/**
+ * Validate JavaScript/TypeScript syntax
+ * Returns { valid: boolean, error?: string }
+ */
+export async function validateJavaScript(filePath) {
+    try {
+        const { stderr } = await execAsync(`node --check "${filePath}"`, {
+            timeout: 5000
+        });
+
+        if (stderr && stderr.includes('SyntaxError')) {
+            return { valid: false, error: stderr };
+        }
+
+        return { valid: true };
+    } catch (error) {
+        return { valid: false, error: error.message };
+    }
+}
+
+/**
+ * Validate Python syntax
+ */
+export async function validatePython(filePath) {
+    try {
+        await execAsync(`python -m py_compile "${filePath}"`, {
+            timeout: 5000
+        });
+        return { valid: true };
+    } catch (error) {
+        return { valid: false, error: error.message };
+    }
+}
+
+/**
+ * Generic file validation (check for truncation, empty file)
+ */
+export async function validateGeneric(filePath, originalSize) {
+    try {
+        const stats = await fs.stat(filePath);
+
+        // Check if file was truncated
+        if (stats.size === 0 && originalSize > 0) {
+            return { valid: false, error: 'File was truncated to 0 bytes' };
+        }
+
+        // Check if file size changed dramatically (>90% reduction)
+        if (originalSize > 0 && stats.size < originalSize * 0.1) {
+            return { valid: false, error: 'File size reduced by >90%, possible corruption' };
+        }
+
+        return { valid: true };
+    } catch (error) {
+        return { valid: false, error: error.message };
+    }
+}
+
+/**
+ * Validate file based on extension
+ */
+export async function validateFile(filePath, originalSize) {
+    const ext = path.extname(filePath).toLowerCase();
+
+    // JavaScript/TypeScript
+    if (['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx'].includes(ext)) {
+        return await validateJavaScript(filePath);
+    }
+
+    // Python
+    if (['.py'].includes(ext)) {
+        return await validatePython(filePath);
+    }
+
+    // Generic validation for other files
+    return await validateGeneric(filePath, originalSize);
+}
+
+/**
+ * Safe edit with automatic rollback
+ * Returns { success, backupPath?, error? }
+ */
+export async function safeEdit(filePath, editFn) {
+    let backupPath = null;
+    let originalSize = 0;
+
+    try {
+        // Get original size
+        const stats = await fs.stat(filePath);
+        originalSize = stats.size;
+
+        // Create backup
+        backupPath = await createBackup(filePath);
+
+        // Apply edit
+        await editFn();
+
+        // Validate result
+        const validation = await validateFile(filePath, originalSize);
+
+        if (!validation.valid) {
+            // Rollback on validation failure
+            await restoreFromBackup(filePath, backupPath);
+            return {
+                success: false,
+                error: `Validation failed: ${validation.error}`,
+                rolledBack: true
+            };
+        }
+
+        return {
+            success: true,
+            backupPath
+        };
+
+    } catch (error) {
+        // Rollback on any error
+        if (backupPath) {
+            try {
+                await restoreFromBackup(filePath, backupPath);
+            } catch (rollbackError) {
+                // Rollback failed, critical error
+                return {
+                    success: false,
+                    error: error.message,
+                    rollbackError: rollbackError.message
+                };
+            }
+        }
+
+        return {
+            success: false,
+            error: error.message,
+            rolledBack: !!backupPath
+        };
+    }
+}

package/src/utils/error-formatter.js

@@ -0,0 +1,122 @@
+/**
+ * Error Formatter for mcfast v2.1
+ * Provides actionable error messages with context and suggestions
+ */
+
+/**
+ * Format error with context and suggestions
+ */
+export function formatError(errorType, context = {}) {
+    const formatters = {
+        'pattern_not_found': () => ({
+            title: '❌ Edit Failed: Pattern not found in target file',
+            suggestions: [
+                'The code may have changed since last read',
+                'Try using \'read\' tool to get current content',
+                'Use fuzzy mode for tolerance: { "fuzzy": true }'
+            ],
+            context: {
+                'Looking for': context.pattern ? `"${context.pattern.substring(0, 50)}..."` : 'N/A',
+                'In file': context.filePath || 'N/A',
+                'File size': context.fileSize ? `${context.fileSize} lines` : 'N/A'
+            }
+        }),
+
+        'syntax_error': () => ({
+            title: '❌ Syntax Error Detected (Auto-Rolled Back)',
+            suggestions: [
+                'The edit introduced a syntax error',
+                'File has been restored from backup',
+                'Review the instruction and try again'
+            ],
+            context: {
+                'File': context.filePath || 'N/A',
+                'Error': context.error || 'N/A',
+                'Backup': context.backupPath || 'N/A'
+            }
+        }),
+
+        'fuzzy_match_failed': () => ({
+            title: '❌ Fuzzy Patch Failed: No suitable match found',
+            suggestions: [
+                `Confidence threshold: ${context.threshold || 0.8} (adjust with MCFAST_FUZZY_THRESHOLD)`,
+                'The diff may be too different from current file state',
+                'Try using Mercury AI for complex changes'
+            ],
+            context: {
+                'File': context.filePath || 'N/A',
+                'Best match score': context.bestScore ? `${(context.bestScore * 100).toFixed(1)}%` : 'N/A'
+            }
+        }),
+
+        'file_not_found': () => ({
+            title: '❌ File Not Found',
+            suggestions: [
+                'Verify the file path is correct',
+                'Use \'list_files\' to browse available files',
+                'Check if file was moved or deleted'
+            ],
+            context: {
+                'Path': context.filePath || 'N/A'
+            }
+        }),
+
+        'permission_denied': () => ({
+            title: '❌ Permission Denied',
+            suggestions: [
+                'Check file permissions',
+                'Ensure you have write access to the file',
+                'Try running with appropriate permissions'
+            ],
+            context: {
+                'File': context.filePath || 'N/A'
+            }
+        }),
+
+        'generic': () => ({
+            title: '❌ Operation Failed',
+            suggestions: [
+                'Check the error message below for details',
+                'Verify your input parameters',
+                'Try again or use a different approach'
+            ],
+            context: {
+                'Error': context.error || 'Unknown error'
+            }
+        })
+    };
+
+    const formatter = formatters[errorType] || formatters['generic'];
+    const formatted = formatter();
+
+    // Build output
+    let output = `${formatted.title}\n\n`;
+
+    if (formatted.suggestions.length > 0) {
+        output += 'Suggestions:\n';
+        formatted.suggestions.forEach(s => {
+            output += `  • ${s}\n`;
+        });
+        output += '\n';
+    }
+
+    if (formatted.context && Object.keys(formatted.context).length > 0) {
+        output += 'Context:\n';
+        Object.entries(formatted.context).forEach(([key, value]) => {
+            output += `  ${key}: ${value}\n`;
+        });
+    }
+
+    return output;
+}
+
+/**
+ * Wrap error with formatting
+ */
+export function createFormattedError(errorType, context) {
+    const message = formatError(errorType, context);
+    const error = new Error(message);
+    error.formatted = true;
+    error.errorType = errorType;
+    return error;
+}