@mrxkun/mcfast-mcp 3.3.6 → 3.3.7

package/README.md

@@ -17,34 +17,48 @@ Standard AI agents often struggle with multi-file edits, broken syntax, and "hal
 1.  **🎯 Surgical Precision**: Uses real Abstract Syntax Trees (AST) to understand code structure. A "Rename" is scope-aware; it won't break unrelated variables.
 2.  **🛡️ Bulletproof Safety**: Every edit is automatically validated. If the AI generates a syntax error, mcfast detects it in milliseconds and **rolls back** the change instantly.
 3.  **⚡ Blazing Performance**: Powered by WASM, AST operations that take seconds in other tools are completed in **under 1ms** here.
-4.  **🌊 Multi-Language Native**: Full support for **Go, Rust, Java, JavaScript, and TypeScript**.
+4.  **🌊 Multi-Language Native**: Full support for **Go, Rust, Java, JavaScript, TypeScript, Python, C++, C#, PHP, and Ruby**.
 5.  **🔒 Local-First Privacy**: Your code structure is analyzed on *your* machine. No proprietary code is sent to the cloud for AST analysis.
 
 ---
 
-## 🚀 Key Features (v3.1 Beta)
+## 🚀 Key Features (v3.3)
 
 ### 1. **AST-Aware Refactoring**
 mcfast doesn't just "search and replace" text. It parses your code into a Tree-sitter AST to perform:
 - **Scope-Aware Rename**: Rename functions, variables, or classes safely across your entire project.
 - **Smart Symbol Search**: Find true references, ignoring comments and strings.
 
-### 2. **Advanced Fuzzy Patching**
+### 2. **Hybrid Fuzzy Patching** ⚡ NEW in v3.3
+Multi-layered matching strategy with intelligent fallback:
+1. **Exact Line Match** (Hash Map) - O(1) lookup for identical code blocks
+2. **Myers Diff Algorithm** - Shortest Edit Script in O((M+N)D) time
+3. **Levenshtein Distance** - For small single-line differences
+
+This hybrid approach significantly improves accuracy and reduces false matches for complex refactoring tasks.
+
+### 3. **Context-Aware Search** 🆕 NEW in v3.3
+Automatic junk directory exclusion powered by intelligent pattern matching:
+- Automatically filters `node_modules`, `.git`, `dist`, `build`, `.next`, `coverage`, `__pycache__`, and more
+- No manual configuration required
+- Respects `.gitignore` patterns automatically
+
+### 4. **Advanced Fuzzy Patching**
 Tired of "Line number mismatch" errors? mcfast uses a multi-layered matching strategy:
-- **Levenshtein Distance**: Measures text similarity.
+- **Levenshtein Distance**: Measures text similarity with early termination.
 - **Token Analysis**: Matches code based on logic even if whitespace or formatting differs.
 - **Structural Matching**: Validates that the patch "fits" the code structure.
 
-### 3. **Auto-Rollback (Auto-Healing)**
+### 5. **Auto-Rollback (Auto-Healing)**
 mcfast integrates language-specific linters to ensure your build stays green:
 - **JS/TS**: `node --check`
 - **Go**: `gofmt -e`
 - **Rust**: `rustc --parse-only`
-- **Java**: Structural verification.
+- **Python/PHP/Ruby**: Syntax validation.
 *If validation fails, mcfast automatically restores from a hidden backup.*
 
-### 4. **Organize Imports (Experimental)**
-Supports JS, TS, and Go. Automatically sorts and cleans up your import blocks using high-speed S-expression queries.
+### 6. **Organize Imports**
+Supports JS, TS, Go, Python, and more. Automatically sorts and cleans up your import blocks using high-speed S-expression queries.
 
 ---
 
@@ -55,6 +69,7 @@ Supports JS, TS, and Go. Automatically sorts and cleans up your import blocks us
 | **Simple Rename** | ~5,000ms | **0.5ms** | **10,000x** |
 | **Large File Parse** | ~800ms | **15ms** | **50x** |
 | **Multi-File Update** | ~15,000ms | **2,000ms** | **7x** |
+| **Fuzzy Patch** | ~2,000ms | **5-50ms** | **40-400x** |
 
 ---
 
@@ -94,7 +109,7 @@ mcfast exposes a unified set of tools to your AI agent:
 *   **`edit`**: The primary tool. It decides whether to use `ast_refactor`, `fuzzy_patch`, or `search_replace` based on the task complexity.
 *   **`search`**: Fast grep-style search with in-memory AST indexing.
 *   **`read`**: Smart reader that returns code chunks with line numbers, optimized for token savings.
-*   **`list_files`**: High-performance globbing that respects `.gitignore`.
+*   **`list_files`**: High-performance globbing with `.gitignore` support and context-aware filtering.
 *   **`reapply`**: If an edit fails validation, the AI can use this to retry with a different strategy.
 
 ---
@@ -102,8 +117,7 @@ mcfast exposes a unified set of tools to your AI agent:
 ## 🔒 Privacy & Licensing
 
 - **Code Privacy**: mcfast is designed for corporate security. WASM parsing and fuzzy matching happen **locally**. We do not store or train on your code.
-- **Cloud Support**: Complex multi-file coordination used a high-performance edge service (Mercury Coder Cloud) to ensure accuracy, but code is never persisted.
+- **Cloud Support**: Complex multi-file coordination uses a high-performance edge service (Mercury Coder Cloud) to ensure accuracy, but code is never persisted.
 - **Usage**: Free for personal and commercial use. Proprietary license.
 
 Copyright © [mrxkun](https://github.com/mrxkun)
-

package/package.json

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

package/src/strategies/fuzzy-patch.js

@@ -8,6 +8,10 @@
  * 4. Early termination when good match found
  * 5. Space-optimized Levenshtein with early exit
  *
+ * Phase 3 - Advanced Algorithms:
+ * 1. HYBRID MATCHING: Exact Line Match (Hash Map) -> Myers Diff -> Levenshtein
+ * 2. CONTEXT-AWARE: Automatic junk directory exclusion
+ *
  * Complexity: O(Hunk * FileSize) → O(FileSize + Hunk * SearchWindow)
  */
 
@@ -18,6 +22,236 @@ import {
     isSemanticMatchingEnabled
 } from './semantic-similarity.js';
 
+// =============================================================================
+// PHASE 3: MYERS DIFF ALGORITHM (Shortest Edit Script)
+// =============================================================================
+
+/**
+ * Myers diff algorithm for computing shortest edit script
+ * O((M+N)D) time and O(D) space where D is edit distance
+ */
+function myersDiff(oldLines, newLines) {
+    const n = oldLines.length;
+    const m = newLines.length;
+    const max = n + m;
+
+    const v = new Map();
+    v.set(1, 0);
+
+    const trace = [];
+
+    for (let d = 0; d <= max; d++) {
+        trace.push(new Map([...v]));
+
+        for (let k = -d; k <= d; k += 2) {
+            let x;
+            if (k === -d || (k !== d && (v.get(k - 1) ?? -1) < (v.get(k + 1) ?? -1))) {
+                x = v.get(k + 1) ?? 0;
+            } else {
+                x = (v.get(k - 1) ?? 0) + 1;
+            }
+
+            let y = x - k;
+
+            while (x < n && y < m && oldLines[x] === newLines[y]) {
+                x++;
+                y++;
+            }
+
+            v.set(k, x);
+
+            if (x >= n && y >= m) {
+                return backtrack(trace, oldLines, newLines, n, m, d);
+            }
+        }
+    }
+
+    return null;
+}
+
+function backtrack(trace, oldLines, newLines, n, m, d) {
+    const changes = [];
+    let x = n;
+    let y = m;
+
+    for (let i = trace.length - 1; i >= 0; i--) {
+        const k = x - y;
+        const vPrev = trace[i];
+
+        let prevK;
+        if (k === -i || (k !== i && (vPrev.get(k - 1) ?? -1) < (vPrev.get(k + 1) ?? -1))) {
+            prevK = k + 1;
+        } else {
+            prevK = k - 1;
+        }
+
+        const prevX = vPrev.get(prevK) ?? 0;
+        const prevY = prevX - prevK;
+
+        while (x > prevX && y > prevY) {
+            x--;
+            y--;
+            changes.unshift({ type: 'equal', oldIdx: x, newIdx: y });
+        }
+
+        if (i > 0) {
+            if (x === prevX) {
+                y--;
+                changes.unshift({ type: 'insert', newIdx: y });
+            } else {
+                x--;
+                changes.unshift({ type: 'delete', oldIdx: x });
+            }
+        }
+    }
+
+    return changes;
+}
+
+// =============================================================================
+// PHASE 3: HYBRID MATCHING STRATEGY
+// =============================================================================
+
+/**
+ * Hybrid matching: Exact Line Match -> Myers Diff -> Levenshtein
+ * This is the core optimization from Phase 3 of the plan
+ */
+function hybridMatch(targetLines, fileLines, threshold = 0.8) {
+    // Step 1: Exact Line Match with Hash Map - O(1) lookup
+    const exactResult = exactLineMatch(targetLines, fileLines);
+    if (exactResult && exactResult.confidence >= threshold) {
+        console.error('[FUZZY] Step 1: Exact line match found');
+        return exactResult;
+    }
+
+    // Step 2: Myers Diff for block differences - O((M+N)D)
+    const myersResult = myersDiffMatch(targetLines, fileLines);
+    if (myersResult && myersResult.confidence >= threshold) {
+        console.error('[FUZZY] Step 2: Myers diff match found');
+        return myersResult;
+    }
+
+    // Step 3: Levenshtein for small single-line differences
+    const levResult = levenshteinMatch(targetLines, fileLines);
+    if (levResult) {
+        console.error('[FUZZY] Step 3: Levenshtein match found');
+        return levResult;
+    }
+
+    return null;
+}
+
+/**
+ * Exact Line Match using Hash Map - O(1) per lookup
+ */
+function exactLineMatch(targetLines, fileLines) {
+    if (targetLines.length === 0) return null;
+
+    const lineHash = new Map();
+    for (let i = 0; i < fileLines.length; i++) {
+        const hash = hashString(fileLines[i]);
+        if (!lineHash.has(hash)) {
+            lineHash.set(hash, []);
+        }
+        lineHash.get(hash).push(i);
+    }
+
+    const targetHash = hashString(targetLines[0]);
+    const candidates = lineHash.get(targetHash);
+
+    if (!candidates) return null;
+
+    for (const startPos of candidates) {
+        let match = true;
+        for (let j = 0; j < targetLines.length; j++) {
+            if (fileLines[startPos + j] !== targetLines[j]) {
+                match = false;
+                break;
+            }
+        }
+
+        if (match) {
+            return {
+                index: startPos,
+                distance: 0,
+                confidence: 1.0,
+                method: 'exact'
+            };
+        }
+    }
+
+    return null;
+}
+
+function hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return hash;
+}
+
+/**
+ * Myers Diff based matching
+ */
+function myersDiffMatch(targetLines, fileLines) {
+    const changes = myersDiff(targetLines, fileLines);
+    if (!changes) return null;
+
+    let equalCount = 0;
+    let totalCount = changes.length;
+
+    for (const change of changes) {
+        if (change.type === 'equal') equalCount++;
+    }
+
+    const confidence = totalCount > 0 ? equalCount / totalCount : 0;
+    const distance = totalCount - equalCount;
+
+    if (confidence >= 0.5) {
+        return {
+            index: changes.find(c => c.type === 'equal')?.oldIdx || 0,
+            distance,
+            confidence,
+            method: 'myers'
+        };
+    }
+
+    return null;
+}
+
+/**
+ * Levenshtein for small differences
+ */
+function levenshteinMatch(targetLines, fileLines, maxDistance = 10) {
+    if (targetLines.length > 20) return null;
+
+    const windowSize = Math.min(targetLines.length + maxDistance, fileLines.length);
+
+    for (let i = 0; i <= fileLines.length - targetLines.length; i++) {
+        const combinedTarget = targetLines.join('\n');
+        const combinedFile = fileLines.slice(i, i + targetLines.length).join('\n');
+
+        const distance = levenshteinDistance(combinedTarget, combinedFile, maxDistance);
+
+        if (distance <= maxDistance) {
+            const maxLen = Math.max(combinedTarget.length, combinedFile.length);
+            const confidence = maxLen > 0 ? 1 - (distance / maxLen) : 1;
+
+            return {
+                index: i,
+                distance,
+                confidence,
+                method: 'levenshtein'
+            };
+        }
+    }
+
+    return null;
+}
+
 // =============================================================================
 // OPTIMIZED LEVENSHTEIN (space-optimized with early termination)
 // =============================================================================
@@ -161,7 +395,43 @@ function findExactMatchHashMap(targetLines, fileLines, lineIndex, windowSize = 3
 }
 
 // =============================================================================
-// OPTIMIZED FUZZY SEARCH (v4.0)
+// PHASE 3: CONTEXT-AWARE SEARCH (Automatic junk directory exclusion)
+// =============================================================================
+
+const JUNK_DIR_PATTERNS = [
+    /node_modules\//,
+    /\.git\//,
+    /dist\//,
+    /build\//,
+    /\.next\//,
+    /coverage\//,
+    /\.cache\//,
+    /__pycache__\//,
+    /\.venv\//,
+    /venv\//,
+    /\.turbo\//,
+    /\.parcel-cache\//,
+    /target\/release\//,
+    /target\/debug\//,
+];
+
+export function isJunkPath(filePath) {
+    return JUNK_DIR_PATTERNS.some(pattern => pattern.test(filePath));
+}
+
+export function filterJunkPaths(paths) {
+    return paths.filter(p => !isJunkPath(p));
+}
+
+export function shouldSearchFile(filePath, includePatterns, excludePatterns) {
+    if (isJunkPath(filePath)) return false;
+    if (excludePatterns.some(p => new RegExp(p).test(filePath))) return false;
+    if (includePatterns.length > 0 && !includePatterns.some(p => new RegExp(p).test(filePath))) return false;
+    return true;
+}
+
+// =============================================================================
+// OPTIMIZED FUZZY SEARCH (v4.0) - Now with Hybrid Matching
 // =============================================================================
 
 export function findBestMatch(targetLines, fileLines, startHint = 0) {
@@ -173,32 +443,35 @@ export function findBestMatch(targetLines, fileLines, startHint = 0) {
         console.error('[FUZZY] Semantic matching enabled');
     }
 
-    const normTargetLines = targetLines.map(l => normalizeWhitespace(l));
-    const normFileLines = fileLines.map(l => normalizeWhitespace(l));
+    // PHASE 3: HYBRID MATCHING - Try all strategies in order
+    console.error('[FUZZY] Phase 3: Starting hybrid matching');
 
-    // OPTIMIZATION 1: Try exact match at hint location first
+    // Step 1: Try exact match at hint location first
     if (startHint >= 0 && startHint + targetLines.length <= fileLines.length) {
         const exactMatch = targetLines.every((line, i) =>
             fileLines[startHint + i] === line
         );
         if (exactMatch) {
+            console.error('[FUZZY] Hybrid: Exact match at hint location');
             return { index: startHint, distance: 0, confidence: 1.0 };
         }
     }
 
-    // OPTIMIZATION 2: Build hash index for faster exact lookups
-    const lineIndex = buildLineIndex(fileLines, Math.min(3, targetLines.length));
-    const exactResult = findExactMatchHashMap(targetLines, fileLines, lineIndex, Math.min(3, targetLines.length));
-
-    if (exactResult) {
-        console.error(`[FUZZY] Exact match found at line ${exactResult.index}`);
-        return exactResult;
+    // Step 2: Use hybrid matching (Exact -> Myers -> Levenshtein)
+    const hybridResult = hybridMatch(targetLines, fileLines, 0.8);
+    if (hybridResult) {
+        console.error(`[FUZZY] Hybrid: Found match using ${hybridResult.method} (confidence: ${hybridResult.confidence.toFixed(2)})`);
+        return hybridResult;
     }
 
-    // OPTIMIZATION 3: Sampled fuzzy search with larger skip
+    // Fallback: Sampled fuzzy search with larger skip
+    console.error('[FUZZY] Fallback: Sampled fuzzy search');
+    const normTargetLines = targetLines.map(l => normalizeWhitespace(l));
+    const normFileLines = fileLines.map(l => normalizeWhitespace(l));
+
     let bestMatch = null;
     let bestScore = Infinity;
-    const sampleStep = Math.max(1, Math.floor(fileLines.length / 5000)); // Skip positions for large files
+    const sampleStep = Math.max(1, Math.floor(fileLines.length / 5000));
 
     for (let i = 0; i <= fileLines.length - targetLines.length; i += sampleStep) {
         iterations++;
@@ -207,7 +480,6 @@ export function findBestMatch(targetLines, fileLines, startHint = 0) {
             break;
         }
 
-        // Sampled check for first, middle, last lines
         if (targetLines.length > 5) {
             const indices = [0, Math.floor(targetLines.length / 2), targetLines.length - 1];
             let sampleDist = 0;