@mrxkun/mcfast-mcp 2.1.0 → 2.1.2

package/package.json

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

package/src/index.js

@@ -518,11 +518,23 @@ async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
             });
 
             if (!editResult.success) {
-                // Rollback occurred
+                // Determine error type based on result
+                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';
+                } else if (editResult.error.includes('Failed to apply hunk') || editResult.error.includes('Could not find matching location')) {
+                    errorType = 'fuzzy_match_failed';
+                }
+
                 return {
                     content: [{
                         type: "text",
-                        text: formatError('syntax_error', {
+                        text: formatError(errorType, {
                             filePath,
                             error: editResult.error,
                             backupPath: editResult.backupPath

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