@mrxkun/mcfast-mcp 3.3.4 → 3.3.6

package/package.json

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

package/src/index.js

@@ -305,28 +305,53 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     };
 });
 
-// Helper for recursive file listing
-async function getFiles(dir, depth = 5, currentDepth = 0) {
-    if (currentDepth >= depth) return [];
+// Helper for recursive file listing (v4.0 optimized with fast-glob)
+async function getFiles(dir, depth = 5) {
+    const patterns = [];
 
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    let files = [];
+    for (let i = 1; i <= depth; i++) {
+        patterns.push('*'.repeat(i));
+    }
 
-    for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
+    const gitignorePath = path.join(dir, '.gitignore');
+    let gitignoreContent = null;
+    try {
+        gitignoreContent = await fs.readFile(gitignorePath, 'utf8');
+    } catch {
+        // .gitignore not found, continue without it
+    }
 
-        // Basic ignores
-        if (['node_modules', '.git', 'dist', 'build', '.next', 'coverage'].includes(entry.name)) continue;
-        if (entry.name.startsWith('.')) continue; // Ignore hidden files
+    const fastGlobOptions = {
+        cwd: dir,
+        onlyFiles: true,
+        onlyDirectories: false,
+        deep: depth,
+        ignore: [
+            'node_modules',
+            '.git',
+            'dist',
+            'build',
+            '.next',
+            'coverage',
+            '.cache',
+            '__pycache__',
+            '.venv',
+            'venv',
+            'node_modules/**',
+            '.git/**'
+        ],
+        absolute: false
+    };
 
-        if (entry.isDirectory()) {
-            const subFiles = await getFiles(fullPath, depth, currentDepth + 1);
-            files = files.concat(subFiles);
-        } else {
-            files.push(fullPath);
-        }
+    if (gitignoreContent) {
+        const ignorePatterns = gitignoreContent
+            .split('\n')
+            .map(l => l.trim())
+            .filter(l => l && !l.startsWith('#'));
+        fastGlobOptions.ignore.push(...ignorePatterns);
     }
-    return files;
+
+    return await fg(patterns, fastGlobOptions);
 }
 
 /**
@@ -877,96 +902,120 @@ async function reportAudit(params) {
     }
 }
 
-// Unified Search Implementation
+// Unified Search Implementation (v4.0 - Early Termination with Stream)
 async function handleSearchFilesystem({ query, path: searchPath = process.cwd(), include = "**/*", exclude = [], isRegex = false, caseSensitive = false }) {
     const start = Date.now();
+    const MAX_RESULTS = 100;
+    const results = [];
+    let strategy = 'unknown';
+
     try {
-        let results = [];
-        let strategy = 'node_fallback';
+        const { spawn } = await import('child_process');
+        const { promisify } = await import('util');
+        const sleep = promisify(setTimeout);
 
-        // 1. Try ripgrep (rg) if available - fastest
+        const escapedQuery = query.replace(/"/g, '\\"');
+        const caseFlag = caseSensitive ? '' : '-i';
+        const regexFlag = isRegex ? '-e' : '-F';
+
+        // Try ripgrep first with streaming and early termination
         try {
-            const flags = [
-                "--json",
-                caseSensitive ? "-s" : "-i",
-                isRegex ? "-e" : "-F"
-            ].join(" ");
-            // This is a simplified call; parsing JSON output from rg is best for structured data
-            // For now, we'll rely on a simpler text output for the LLM
-            const simpleFlags = [
-                "-n",
-                "--no-heading",
-                "--with-filename",
-                caseSensitive ? "-s" : "-i",
-                isRegex ? "-e" : "-F"
-            ].join(" ");
-
-            const command = `rg ${simpleFlags} "${query.replace(/"/g, '\\"')}" ${searchPath}`;
-            const { stdout } = await execAsync(command, { maxBuffer: 10 * 1024 * 1024 });
-            results = stdout.trim().split('\n').filter(Boolean);
             strategy = 'ripgrep';
+            const rgProcess = spawn('rg', [
+                '-n', '--no-heading', '--with-filename',
+                caseFlag, regexFlag,
+                escapedQuery,
+                searchPath
+            ], {
+                stdio: ['ignore', 'pipe', 'pipe']
+            });
+
+            const readline = (await import('readline')).createInterface({
+                input: rgProcess.stdout,
+                crlfDelay: Infinity
+            });
+
+            for await (const line of readline) {
+                if (results.length >= MAX_RESULTS) {
+                    rgProcess.kill();
+                    break;
+                }
+                results.push(line);
+            }
+
+            rgProcess.stderr.on('data', () => { });
+            await new Promise(resolve => rgProcess.on('close', resolve));
+
+            if (results.length > 0 || rgProcess.exitCode === 0) {
+                return formatSearchResults(query, strategy, results, start, MAX_RESULTS);
+            }
         } catch (rgErr) {
-            // 2. Try git grep if in a git repo
+            // Try git grep
             try {
-                const flags = [
-                    "-n",
-                    "-I",
-                    caseSensitive ? "" : "-i",
-                    isRegex ? "-E" : "-F"
-                ].filter(Boolean).join(" ");
-                const command = `git grep ${flags} "${query.replace(/"/g, '\\"')}" ${searchPath}`;
-                const { stdout } = await execAsync(command, { cwd: searchPath, maxBuffer: 10 * 1024 * 1024 });
-                results = stdout.trim().split('\n').filter(Boolean);
                 strategy = 'git_grep';
-            } catch (gitErr) {
-                // 3. Fallback to native grep
-                try {
-                    const flags = [
-                        "-r", "-n", "-I",
-                        caseSensitive ? "" : "-i",
-                        isRegex ? "-E" : "-F"
-                    ].filter(Boolean).join(" ");
-                    const exclusions = ["node_modules", ".git", ".next", "dist", "build"].map(d => `--exclude-dir=${d}`).join(" ");
-                    const command = `grep ${flags} ${exclusions} "${query.replace(/"/g, '\\"')}" ${searchPath}`;
-                    const { stdout } = await execAsync(command, { maxBuffer: 10 * 1024 * 1024 });
-                    results = stdout.trim().split('\n').filter(Boolean);
-                    strategy = 'native_grep';
-                } catch (grepErr) {
-                    // 4. Node.js fallback (slowest but guaranteed)
-                    // Only used if all system tools fail
-                    strategy = 'node_js_fallback';
-                    // ... (implement if needed, but grep usually exists)
+                const gitProcess = spawn('git', [
+                    'grep', '-n', '-I',
+                    caseFlag ? '' : '-i',
+                    regexFlag ? '-E' : '-F',
+                    escapedQuery
+                ], {
+                    cwd: searchPath,
+                    stdio: ['ignore', 'pipe', 'pipe']
+                });
+
+                const readline = (await import('readline')).createInterface({
+                    input: gitProcess.stdout,
+                    crlfDelay: Infinity
+                });
+
+                for await (const line of readline) {
+                    if (results.length >= MAX_RESULTS) {
+                        gitProcess.kill();
+                        break;
+                    }
+                    results.push(line);
                 }
-            }
-        }
 
-        let output = `⚡ search_filesystem (${strategy}) found ${results.length} results for "${query}"\n\n`;
-        if (results.length === 0) {
-            output += "No matches found.";
-        } else {
-            const limitedResults = results.slice(0, 100);
-            output += limitedResults.join('\n');
-            if (results.length > 100) output += `\n... and ${results.length - 100} more matches.`;
-        }
+                gitProcess.stderr.on('data', () => { });
+                await new Promise(resolve => gitProcess.on('close', resolve));
 
-        // Estimate tokens:
-        // - Search query (approx)
-        // - Result content length / 4
-        const estimatedOutputTokens = Math.ceil(output.length / 4);
+                return formatSearchResults(query, strategy, results, start, MAX_RESULTS);
+            } catch (gitErr) {
+                // Fallback to native grep
+                strategy = 'native_grep';
+                const grepProcess = spawn('grep', [
+                    '-r', '-n', '-I',
+                    caseFlag ? '' : '-i',
+                    regexFlag ? '-E' : '-F',
+                    '--exclude-dir=node_modules', '--exclude-dir=.git',
+                    '--exclude-dir=.next', '--exclude-dir=dist', '--exclude-dir=build',
+                    escapedQuery,
+                    searchPath
+                ], {
+                    stdio: ['ignore', 'pipe', 'pipe']
+                });
 
-        reportAudit({
-            tool: 'search_filesystem',
-            instruction: query,
-            strategy: strategy,
-            status: 'success',
-            latency_ms: Date.now() - start,
-            files_count: 0,
-            input_tokens: Math.ceil(query.length / 4), // Minimal input tokens for filesystem search
-            output_tokens: estimatedOutputTokens,
-            result_summary: JSON.stringify(results.slice(0, 100))
-        });
+                const readline = (await import('readline')).createInterface({
+                    input: grepProcess.stdout,
+                    crlfDelay: Infinity
+                });
 
-        return { content: [{ type: "text", text: output }] };
+                for await (const line of readline) {
+                    if (results.length >= MAX_RESULTS) {
+                        grepProcess.kill();
+                        break;
+                    }
+                    results.push(line);
+                }
+
+                grepProcess.stderr.on('data', () => { });
+                await new Promise(resolve => grepProcess.on('close', resolve));
+
+                return formatSearchResults(query, strategy, results, start, MAX_RESULTS);
+            }
+        }
+
+        return formatSearchResults(query, strategy, results, start, MAX_RESULTS);
 
     } catch (error) {
         reportAudit({
@@ -985,6 +1034,35 @@ async function handleSearchFilesystem({ query, path: searchPath = process.cwd(),
     }
 }
 
+function formatSearchResults(query, strategy, results, start, maxResults) {
+    let output = `⚡ search_filesystem (${strategy}) found ${results.length} results for "${query}"\n\n`;
+
+    if (results.length === 0) {
+        output += "No matches found.";
+    } else {
+        output += results.join('\n');
+        if (results.length >= maxResults) {
+            output += `\n... and more matches (early termination at ${maxResults}).`;
+        }
+    }
+
+    const estimatedOutputTokens = Math.ceil(output.length / 4);
+
+    reportAudit({
+        tool: 'search_filesystem',
+        instruction: query,
+        strategy,
+        status: 'success',
+        latency_ms: Date.now() - start,
+        files_count: 0,
+        input_tokens: Math.ceil(query.length / 4),
+        output_tokens: estimatedOutputTokens,
+        result_summary: JSON.stringify(results.slice(0, maxResults))
+    });
+
+    return { content: [{ type: "text", text: output }] };
+}
+
 // Native high-performance search
 async function handleWarpgrep({ query, include = ".", isRegex = false, caseSensitive = false }) {
     const start = Date.now();
@@ -1073,8 +1151,23 @@ async function handleSearchCode({ query, files, regex = false, caseSensitive = f
     try {
         const results = [];
         let totalInputChars = 0;
+        let lastYield = Date.now();
+        const YIELD_INTERVAL_MS = 10;
+        const YIELD_LINES = 1000;
+
+        const shouldYield = () => {
+            const now = Date.now();
+            if (now - lastYield > YIELD_INTERVAL_MS) {
+                lastYield = now;
+                return true;
+            }
+            return false;
+        };
+
+        const yieldEventLoop = async () => {
+            return new Promise(resolve => setImmediate(resolve));
+        };
 
-        // If regex mode, use original regex logic
         if (regex) {
             const flags = caseSensitive ? 'm' : 'im';
             const pattern = new RegExp(query, flags);
@@ -1084,47 +1177,44 @@ async function handleSearchCode({ query, files, regex = false, caseSensitive = f
                 totalInputChars += content.length;
 
                 const lines = content.split('\n');
-                lines.forEach((line, index) => {
-                    if (pattern.test(line)) {
+                for (let i = 0; i < lines.length; i++) {
+                    if (shouldYield()) await yieldEventLoop();
+
+                    if (pattern.test(lines[i])) {
                         pattern.lastIndex = 0;
-                        const startLine = Math.max(0, index - contextLines);
-                        const endLine = Math.min(lines.length - 1, index + contextLines);
+                        const startLine = Math.max(0, i - contextLines);
+                        const endLine = Math.min(lines.length - 1, i + contextLines);
 
                         const contextSnippet = lines
                             .slice(startLine, endLine + 1)
-                            .map((l, i) => ({
-                                lineNumber: startLine + i + 1,
+                            .map((l, idx) => ({
+                                lineNumber: startLine + idx + 1,
                                 content: l,
-                                isMatch: startLine + i === index
+                                isMatch: startLine + idx === i
                             }));
 
                         results.push({
                             file: filePath,
-                            lineNumber: index + 1,
-                            matchedLine: line.trim(),
+                            lineNumber: i + 1,
+                            matchedLine: lines[i].trim(),
                             context: contextSnippet,
                             matchType: 'regex'
                         });
                     }
-                });
+                }
             }
         } else {
-            // Semantic search with stop words filtering
             const queryLower = query.toLowerCase();
-
-            // Common English stop words to filter out
             const stopWords = new Set([
                 'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 'for', 'from', 'has', 'he',
                 'in', 'is', 'it', 'its', 'of', 'on', 'that', 'the', 'to', 'was', 'will', 'with',
                 'how', 'what', 'when', 'where', 'who', 'why', 'does', 'do', 'this', 'these', 'those'
             ]);
 
-            // Extract significant words (3+ chars, not stop words)
             const words = queryLower
                 .split(/\W+/)
                 .filter(w => w.length >= 3 && !stopWords.has(w));
 
-            // If no significant words, fall back to whole query
             const searchTerms = words.length > 0 ? words : [queryLower];
 
             for (const [filePath, content] of Object.entries(files)) {
@@ -1132,45 +1222,40 @@ async function handleSearchCode({ query, files, regex = false, caseSensitive = f
                 totalInputChars += content.length;
 
                 const lines = content.split('\n');
-                lines.forEach((line, index) => {
+                for (let i = 0; i < lines.length; i++) {
+                    if (shouldYield()) await yieldEventLoop();
+
                     const lineLower = caseSensitive ? line : line.toLowerCase();
                     const searchQuery = caseSensitive ? query : queryLower;
-
-                    // Check 1: Exact phrase match (highest priority)
                     const exactMatch = lineLower.includes(searchQuery);
-
-                    // Check 2: All significant words present (semantic match)
                     const allWordsMatch = searchTerms.every(term => lineLower.includes(term));
-
-                    // Check 3: At least half of significant words present (fuzzy match)
                     const matchCount = searchTerms.filter(term => lineLower.includes(term)).length;
                     const fuzzyMatch = matchCount >= Math.ceil(searchTerms.length / 2);
 
                     if (exactMatch || allWordsMatch || (searchTerms.length > 1 && fuzzyMatch)) {
-                        const startLine = Math.max(0, index - contextLines);
-                        const endLine = Math.min(lines.length - 1, index + contextLines);
+                        const startLine = Math.max(0, i - contextLines);
+                        const endLine = Math.min(lines.length - 1, i + contextLines);
 
                         const contextSnippet = lines
                             .slice(startLine, endLine + 1)
-                            .map((l, i) => ({
-                                lineNumber: startLine + i + 1,
+                            .map((l, idx) => ({
+                                lineNumber: startLine + idx + 1,
                                 content: l,
-                                isMatch: startLine + i === index
+                                isMatch: startLine + idx === i
                             }));
 
                         results.push({
                             file: filePath,
-                            lineNumber: index + 1,
+                            lineNumber: i + 1,
                             matchedLine: line.trim(),
                             context: contextSnippet,
                             matchType: exactMatch ? 'exact' : allWordsMatch ? 'semantic' : 'fuzzy',
                             matchScore: exactMatch ? 100 : allWordsMatch ? 80 : matchCount * 10
                         });
                     }
-                });
+                }
             }
 
-            // Sort results: by score (highest first), then by file
             results.sort((a, b) => {
                 if (a.matchScore !== b.matchScore) {
                     return b.matchScore - a.matchScore;
@@ -1226,18 +1311,16 @@ async function handleListFiles({ path: dirPath = process.cwd(), depth = 5 }) {
     const start = Date.now();
     try {
         const files = await getFiles(dirPath, depth);
-        // Return relative paths to save tokens
-        const relativeFiles = files.map(f => path.relative(dirPath, f));
 
-        const output = `📁 Files in ${dirPath}:\n\n${relativeFiles.join('\n')}`;
+        const output = `📁 Files in ${dirPath}:\n\n${files.join('\n')}`;
 
         reportAudit({
             tool: 'list_files_fast',
             instruction: dirPath,
             status: 'success',
             latency_ms: Date.now() - start,
-            files_count: relativeFiles.length,
-            result_summary: JSON.stringify(relativeFiles.slice(0, 500)),
+            files_count: files.length,
+            result_summary: JSON.stringify(files.slice(0, 500)),
             input_tokens: Math.ceil(dirPath.length / 4),
             output_tokens: Math.ceil(output.length / 4)
         });
@@ -1302,41 +1385,76 @@ async function handleEditFile({ path: filePath, content, instruction = "" }) {
 async function handleReadFile({ path: filePath, start_line, end_line }) {
     const start = Date.now();
     try {
-        // Resolve absolute path
         const absolutePath = path.resolve(filePath);
-
-        // Check if file exists and is a file
         const stats = await fs.stat(absolutePath);
+
         if (!stats.isFile()) {
             throw new Error(`Path is not a file: ${absolutePath}`);
         }
 
-        // Read file content
-        const content = await fs.readFile(absolutePath, 'utf8');
+        const STREAM_THRESHOLD = 1024 * 1024; // 1MB - files larger than this use streaming
+        const LINE_RANGE_THRESHOLD = 50000; // If requesting specific lines and file is large, stream
 
-        const lines = content.split('\n');
-        const totalLines = lines.length;
+        let startLine = start_line ? parseInt(start_line) : 1;
+        let endLine = end_line ? parseInt(end_line) : -1;
+        let outputContent;
+        let totalLines;
 
-        let outputContent = content;
-        let lineRangeInfo = `(Total ${totalLines} lines)`;
+        if ((stats.size > STREAM_THRESHOLD && (start_line || end_line)) || stats.size > 10 * 1024 * 1024) {
+            const { Readable } = await import('stream');
+            const { createInterface } = await import('readline');
 
-        let startLine = start_line ? parseInt(start_line) : 1;
-        let endLine = end_line ? parseInt(end_line) : totalLines;
+            let currentLine = 0;
+            const lines = [];
 
-        // Validate range
-        if (startLine < 1) startLine = 1;
-        if (endLine > totalLines) endLine = totalLines;
-        if (startLine > endLine) {
-            throw new Error(`Invalid line range: start_line (${startLine}) > end_line (${endLine})`);
-        }
+            const stream = (await import('fs')).createReadStream(absolutePath, { encoding: 'utf8' });
+            const rl = createInterface({ input: stream, crlfDelay: Infinity });
+
+            for await (const line of rl) {
+                currentLine++;
+                if (startLine && endLine) {
+                    if (currentLine >= startLine && currentLine <= endLine) {
+                        lines.push(line);
+                    }
+                    if (currentLine >= endLine) break;
+                } else if (startLine && currentLine >= startLine) {
+                    lines.push(line);
+                } else if (lines.length < 2000) {
+                    lines.push(line);
+                } else {
+                    break;
+                }
+            }
 
-        // Slice content if range specified
-        if (start_line || end_line) {
-            outputContent = lines.slice(startLine - 1, endLine).join('\n');
-            lineRangeInfo = `(Lines ${startLine}-${endLine} of ${totalLines})`;
-        } else if (totalLines > 2000) {
-            // Optional: warn if reading huge file without range?
-            // For now, we allow it but it might be truncated by the client/LLM window.
+            stream.destroy();
+            outputContent = lines.join('\n');
+            totalLines = currentLine;
+
+            if (startLine && endLine) {
+                lineRangeInfo = `(Lines ${startLine}-${endLine} of ${totalLines})`;
+            } else if (startLine) {
+                lineRangeInfo = `(Lines ${startLine}-${currentLine} of ${totalLines})`;
+            } else {
+                lineRangeInfo = `(Lines 1-${lines.length} of ${totalLines} - truncated)`;
+            }
+        } else {
+            const content = await fs.readFile(absolutePath, 'utf8');
+            const lines = content.split('\n');
+            totalLines = lines.length;
+
+            if (startLine < 1) startLine = 1;
+            if (endLine < 1 || endLine > totalLines) endLine = totalLines;
+            if (startLine > endLine) {
+                throw new Error(`Invalid line range: start_line (${startLine}) > end_line (${endLine})`);
+            }
+
+            if (start_line || end_line) {
+                outputContent = lines.slice(startLine - 1, endLine).join('\n');
+                lineRangeInfo = `(Lines ${startLine}-${endLine} of ${totalLines})`;
+            } else {
+                outputContent = content;
+                lineRangeInfo = `(Total ${totalLines} lines)`;
+            }
         }
 
         const output = `📄 File: ${filePath} ${lineRangeInfo}\n----------------------------------------\n${outputContent}`;

package/src/strategies/fuzzy-patch.js

@@ -1,6 +1,14 @@
 /**
- * Fuzzy Patch Strategy for mcfast v2.1+
- * Applies unified diffs with whitespace tolerance and semantic similarity
+ * Fuzzy Patch Strategy for mcfast v4.0+
+ *
+ * Performance Optimizations (v4.0):
+ * 1. Parse file into lines ONCE, not per hunk
+ * 2. Use Hash Maps for exact match before fuzzy search
+ * 3. Process all hunks in single pass with offset adjustment
+ * 4. Early termination when good match found
+ * 5. Space-optimized Levenshtein with early exit
+ *
+ * Complexity: O(Hunk * FileSize) → O(FileSize + Hunk * SearchWindow)
  */
 
 import {
@@ -10,26 +18,22 @@ import {
     isSemanticMatchingEnabled
 } from './semantic-similarity.js';
 
-/**
- * Calculate Levenshtein distance between two strings
- * Used for fuzzy matching to find best location for patch
- * Optimized with early termination and length-based shortcuts
- */
+// =============================================================================
+// OPTIMIZED LEVENSHTEIN (space-optimized with early termination)
+// =============================================================================
+
 function levenshteinDistance(str1, str2, maxDistance = Infinity) {
     const len1 = str1.length;
     const len2 = str2.length;
 
-    // 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++) {
@@ -39,15 +43,14 @@ function levenshteinDistance(str1, str2, maxDistance = Infinity) {
         for (let j = 1; j <= len2; j++) {
             const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
             const val = Math.min(
-                prevRow[j] + 1,      // deletion
-                currentRow[j - 1] + 1,      // insertion
-                prevRow[j - 1] + cost // substitution
+                prevRow[j] + 1,
+                currentRow[j - 1] + 1,
+                prevRow[j - 1] + cost
             );
             currentRow.push(val);
             minInRow = Math.min(minInRow, val);
         }
 
-        // Early termination: if minimum in row exceeds maxDistance, abort
         if (minInRow > maxDistance) {
             return maxDistance + 1;
         }
@@ -58,10 +61,6 @@ function levenshteinDistance(str1, str2, maxDistance = Infinity) {
     return prevRow[len2];
 }
 
-/**
- * Normalize whitespace for comparison
- * Converts tabs to spaces, trims lines, removes trailing whitespace
- */
 function normalizeWhitespace(text) {
     return text
         .split('\n')
@@ -70,25 +69,18 @@ function normalizeWhitespace(text) {
         .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);
+    return 1.0 - (levenshteinDistance(normalized1, normalized2) / maxLen);
 }
 
-/**
- * Parse unified diff format
- * Returns array of hunks with line numbers and changes
- */
+// =============================================================================
+// OPTIMIZED DIFF PARSING
+// =============================================================================
+
 export function parseDiff(diffText) {
     const hunks = [];
     const lines = diffText.split('\n');
@@ -97,7 +89,6 @@ export function parseDiff(diffText) {
     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);
 
@@ -112,7 +103,6 @@ export function parseDiff(diffText) {
                 };
             }
         } else if (currentHunk) {
-            // Parse diff lines
             if (line.startsWith('-')) {
                 currentHunk.lines.push({ type: 'remove', content: line.slice(1) });
             } else if (line.startsWith('+')) {
@@ -127,27 +117,66 @@ export function parseDiff(diffText) {
     return hunks;
 }
 
-/**
- * Find best match location for a pattern in target text
- * Returns { index, distance, confidence } or null if no good match
- */
+// =============================================================================
+// OPTIMIZED HASH-MAP BASED EXACT MATCH (v4.0 NEW)
+// =============================================================================
+
+function buildLineIndex(lines, windowSize = 3) {
+    const index = new Map();
+
+    for (let i = 0; i <= lines.length - windowSize; i++) {
+        const key = lines.slice(i, i + windowSize).join('|');
+        if (!index.has(key)) {
+            index.set(key, []);
+        }
+        index.get(key).push(i);
+    }
+
+    return index;
+}
+
+function findExactMatchHashMap(targetLines, fileLines, lineIndex, windowSize = 3) {
+    if (targetLines.length < windowSize) return null;
+
+    const targetKey = targetLines.slice(0, windowSize).join('|');
+    const candidates = lineIndex.get(targetKey);
+
+    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 };
+        }
+    }
+
+    return null;
+}
+
+// =============================================================================
+// OPTIMIZED FUZZY SEARCH (v4.0)
+// =============================================================================
+
 export function findBestMatch(targetLines, fileLines, startHint = 0) {
-    let bestMatch = null;
-    let bestScore = Infinity;
-    const maxIterations = 50000; // Increased from 10k to 50k
+    const maxIterations = 50000;
     let iterations = 0;
-
     const useSemanticMatching = isSemanticMatchingEnabled();
 
     if (useSemanticMatching) {
         console.error('[FUZZY] Semantic matching enabled');
     }
 
-    // optimization: pre-normalize lines to handle indentation/whitespace
     const normTargetLines = targetLines.map(l => normalizeWhitespace(l));
     const normFileLines = fileLines.map(l => normalizeWhitespace(l));
 
-    // Try exact match first at hint location
+    // OPTIMIZATION 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
@@ -157,27 +186,35 @@ export function findBestMatch(targetLines, fileLines, startHint = 0) {
         }
     }
 
-    // Fuzzy search with semantic similarity
-    for (let i = 0; i <= fileLines.length - targetLines.length; i++) {
+    // 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;
+    }
+
+    // OPTIMIZATION 3: Sampled fuzzy search with larger skip
+    let bestMatch = null;
+    let bestScore = Infinity;
+    const sampleStep = Math.max(1, Math.floor(fileLines.length / 5000)); // Skip positions for large files
+
+    for (let i = 0; i <= fileLines.length - targetLines.length; i += sampleStep) {
         iterations++;
         if (iterations > maxIterations) {
             console.error(`[FUZZY] Max iterations (${maxIterations}) reached`);
             break;
         }
 
-        // Optimization: Sampled check
-        // Check first, middle, and last line. If they are very different, skip block.
+        // 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;
             for (const idx of indices) {
-                // Use normalized lines for check
-                sampleDist += levenshteinDistance(normTargetLines[idx], normFileLines[i + idx], 20); // strict limit
-            }
-            // If average distance per sample line is high (> 10 chars), skip
-            if (sampleDist > indices.length * 10) {
-                continue;
+                sampleDist += levenshteinDistance(normTargetLines[idx], normFileLines[i + idx], 20);
             }
+            if (sampleDist > indices.length * 10) continue;
         }
 
         let totalDistance = 0;
@@ -185,46 +222,29 @@ export function findBestMatch(targetLines, fileLines, startHint = 0) {
         let contextMatchSum = 0;
 
         for (let j = 0; j < targetLines.length; j++) {
-            const targetLine = targetLines[j];
-            const fileLine = fileLines[i + j];
-
-            // Use NORMALIZED lines for distance to ignore indentation differences
             const nTarget = normTargetLines[j];
             const nFile = normFileLines[i + j];
 
-            // Levenshtein distance on normalized text
-            const distance = levenshteinDistance(nTarget, nFile);
-            totalDistance += distance;
-
-            // Token similarity (always available)
-            const tokSim = tokenSimilarity(targetLine, fileLine);
-            tokenSimilaritySum += tokSim;
-
-            // Context-aware matching (use surrounding lines)
-            const surroundingLines = [
-                fileLines[i + j - 1],
-                fileLines[i + j + 1]
-            ].filter(Boolean);
+            totalDistance += levenshteinDistance(nTarget, nFile);
+            tokenSimilaritySum += tokenSimilarity(targetLines[j], fileLines[i + j]);
 
-            const contextScore = contextAwareMatch(targetLine, fileLine, surroundingLines);
-            contextMatchSum += contextScore;
+            const surroundingLines = [fileLines[i + j - 1], fileLines[i + j + 1]].filter(Boolean);
+            contextMatchSum += contextAwareMatch(targetLines[j], fileLines[i + j], surroundingLines);
         }
 
         const avgTokenSim = tokenSimilaritySum / targetLines.length;
         const avgContextMatch = contextMatchSum / targetLines.length;
 
-        // Calculate confidence using enhanced scoring
         const confidence = calculateConfidence(null, {
             levenshteinDistance: totalDistance,
             maxDistance: targetLines.length * 100,
             tokenSimilarity: avgTokenSim,
-            structuralSimilarity: 0, // Would need AST parsing
+            structuralSimilarity: 0,
             lineNumberMatch: i === startHint,
             surroundingContextMatch: avgContextMatch
         });
 
-        // Prefer matches with higher confidence
-        const score = totalDistance * (1 - confidence * 0.5); // Confidence reduces effective distance
+        const score = totalDistance * (1 - confidence * 0.5);
 
         if (score < bestScore) {
             bestScore = score;
@@ -236,7 +256,6 @@ export function findBestMatch(targetLines, fileLines, startHint = 0) {
                 contextMatch: avgContextMatch
             };
 
-            // Early termination if we find a very good match
             if (confidence > 0.99) {
                 console.error(`[FUZZY] Early termination at ${confidence.toFixed(2)} confidence`);
                 break;
@@ -245,25 +264,22 @@ export function findBestMatch(targetLines, fileLines, startHint = 0) {
     }
 
     if (bestMatch) {
-        console.error(`[FUZZY] Best match: line ${bestMatch.index}, distance ${bestMatch.distance}, confidence ${bestMatch.confidence.toFixed(2)}, token_sim ${bestMatch.tokenSimilarity.toFixed(2)}`);
+        console.error(`[FUZZY] Best match: line ${bestMatch.index}, distance ${bestMatch.distance}, confidence ${bestMatch.confidence.toFixed(2)}`);
     }
 
     return bestMatch;
 }
 
-/**
- * Apply a single hunk to file content with fuzzy matching
- * Returns { success, content, confidence, message }
- */
+// =============================================================================
+// OPTIMIZED SINGLE-PASS MULTI-HUNK APPLICATION (v4.0 NEW)
+// =============================================================================
+
 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) {
@@ -275,20 +291,17 @@ export function applyHunk(fileContent, hunk, threshold = 0.8) {
         };
     }
 
-    // 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++;
         }
@@ -297,90 +310,95 @@ export function applyHunk(fileContent, hunk, threshold = 0.8) {
     return {
         success: true,
         content: newLines.join('\n'),
-        confidence: match.score,
-        message: `Applied at line ${match.lineNumber} (confidence: ${(match.score * 100).toFixed(1)}%)`
+        confidence: match.confidence,
+        message: `Applied at line ${match.index + 1} (confidence: ${(match.confidence * 100).toFixed(1)}%)`
     };
 }
 
 /**
- * Apply complete diff with fuzzy matching
- * Main entry point for fuzzy patching
+ * Apply complete diff with fuzzy matching - OPTIMIZED v4.0
+ *
+ * Key optimization: Parse file ONCE, apply all hunks with offset tracking
+ * instead of re-parsing for each hunk.
  */
 export function applyFuzzyPatch(fileContent, diffText, options = {}) {
-    // Input validation
     if (!fileContent || typeof fileContent !== 'string') {
-        return {
-            success: false,
-            content: fileContent || '',
-            message: 'Invalid file content provided'
-        };
+        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'
-        };
+        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'
-        };
+        return { success: false, content: fileContent, message: 'Threshold must be between 0 and 1' };
     }
 
     const hunks = parseDiff(diffText);
 
     if (hunks.length === 0) {
-        return {
-            success: false,
-            content: fileContent,
-            message: 'No valid hunks found in diff'
-        };
+        return { success: false, content: fileContent, message: 'No valid hunks found in diff' };
     }
 
-    let currentContent = fileContent;
+    // OPTIMIZATION: Parse file into lines ONCE at the start
+    let currentLines = fileContent.split('\n');
     const results = [];
 
     for (const hunk of hunks) {
-        const result = applyHunk(currentContent, hunk, threshold);
-        results.push(result);
+        // Extract context lines from hunk
+        const contextLines = hunk.lines
+            .filter(l => l.type === 'context' || l.type === 'remove')
+            .map(l => l.content);
+
+        // Find match in current (already modified) lines
+        const match = findBestMatch(currentLines, contextLines, 0);
 
-        if (!result.success) {
+        if (!match) {
             return {
                 success: false,
                 content: fileContent,
-                message: `Failed to apply hunk: ${result.message}`,
+                message: `Failed to apply hunk at line ${hunk.oldStart}: ${results[results.length - 1]?.message || 'match not found'}`,
                 partialResults: results
             };
         }
 
-        currentContent = result.content;
+        // Apply changes at matched location
+        let offset = match.index;
+
+        for (const diffLine of hunk.lines) {
+            if (diffLine.type === 'remove' || diffLine.type === 'context') {
+                if (diffLine.type === 'remove') {
+                    currentLines.splice(offset, 1);
+                } else {
+                    offset++;
+                }
+            } else if (diffLine.type === 'add') {
+                currentLines.splice(offset, 0, diffLine.content);
+                offset++;
+            }
+        }
+
+        results.push({
+            success: true,
+            confidence: match.confidence,
+            line: match.index + 1
+        });
     }
 
     const avgConfidence = results.reduce((sum, r) => sum + r.confidence, 0) / results.length;
 
     return {
         success: true,
-        content: currentContent,
+        content: currentLines.join('\n'),
         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/strategies/tree-sitter/languages.js

@@ -1,5 +1,9 @@
 /**
- * Tree-sitter Language Loader
+ * Tree-sitter Language Loader (v4.0+)
+ *
+ * Performance Optimization:
+ * - Cache Parser instances per language to avoid WASM re-initialization overhead
+ * - Reusing parsers significantly reduces latency for repeated operations
  */
 import path from 'path';
 import { createRequire } from 'module';
@@ -12,36 +16,31 @@ const require = createRequire(import.meta.url);
 const _Parser = require('web-tree-sitter');
 
 let Parser = _Parser;
-// If default export exists, use it
 if (Parser.default) {
     Parser = Parser.default;
 }
-// If Parser property exists and Parser itself isn't the constructor
 if (typeof Parser !== 'function' && Parser.Parser) {
     Parser = Parser.Parser;
 }
 
 let isInitialized = false;
 const languageCache = new Map();
+const parserCache = new Map();
 
-// Map internal language IDs to WASM filenames
 const WASM_MAP = {
     'go': 'tree-sitter-go.wasm',
     'rust': 'tree-sitter-rust.wasm',
     'java': 'tree-sitter-java.wasm',
     'javascript': 'tree-sitter-javascript.wasm',
-    'typescript': 'tree-sitter-javascript.wasm', // TS often uses JS or its own, using JS for now as fallback/compatible
+    'typescript': 'tree-sitter-javascript.wasm',
     'python': 'tree-sitter-python.wasm',
     'cpp': 'tree-sitter-cpp.wasm',
-    'c': 'tree-sitter-cpp.wasm', // C typically uses C++ parser or its own. Using CPP for now as it handles C.
+    'c': 'tree-sitter-cpp.wasm',
     'csharp': 'tree-sitter-c-sharp.wasm',
     'php': 'tree-sitter-php.wasm',
     'ruby': 'tree-sitter-ruby.wasm',
 };
 
-/**
- * Initialize web-tree-sitter
- */
 async function init() {
     if (isInitialized) return;
     try {
@@ -52,7 +51,6 @@ async function init() {
         isInitialized = true;
     } catch (e) {
         console.error('Failed to initialize web-tree-sitter:', e);
-        // Fallback: try without explicit path (may work if in same dir)
         try {
             await Parser.init();
             isInitialized = true;
@@ -62,10 +60,6 @@ async function init() {
     }
 }
 
-/**
- * Load language parser
- * @param {string} language - 'go', 'rust', 'java', etc.
- */
 export async function loadLanguage(language) {
     if (!isInitialized) await init();
 
@@ -78,12 +72,7 @@ export async function loadLanguage(language) {
         throw new Error(`Unsupported tree-sitter language: ${language}`);
     }
 
-    // Resolve path to wasm file
-    // Assuming this file is at packages/mcp-client/src/strategies/tree-sitter/languages.js
-    // and wasm files are at packages/mcp-client/src/strategies/tree-sitter/wasm/
     const wasmPath = path.resolve(__dirname, 'wasm', wasmFile);
-
-    // Resolve Language class
     let Language = Parser.Language;
     if (!Language && _Parser.Language) {
         Language = _Parser.Language;
@@ -94,20 +83,50 @@ export async function loadLanguage(language) {
         languageCache.set(language, lang);
         return lang;
     } catch (e) {
-        // Fallback for different environments where __dirname might behave differently
-        // Try relative path if absolute fails, or check common locations
         console.error(`Failed to load language ${language} from ${wasmPath}`, e);
         throw e;
     }
 }
 
+/**
+ * Get cached Parser instance for language (v4.0 optimization)
+ * Reuses Parser instances instead of creating new ones each time
+ */
 export async function getParser(language) {
+    if (!isInitialized) await init();
+
+    if (parserCache.has(language)) {
+        return parserCache.get(language);
+    }
+
     const lang = await loadLanguage(language);
     const parser = new Parser();
     parser.setLanguage(lang);
+    parserCache.set(language, parser);
     return parser;
 }
 
+/**
+ * Clear parser cache (useful for testing or memory management)
+ */
+export function clearParserCache() {
+    for (const parser of parserCache.values()) {
+        parser.delete?.();
+    }
+    parserCache.clear();
+}
+
+/**
+ * Get cache statistics
+ */
+export function getCacheStats() {
+    return {
+        languagesLoaded: languageCache.size,
+        parsersCached: parserCache.size,
+        supportedLanguages: Object.keys(WASM_MAP)
+    };
+}
+
 /**
  * Get compiled query for language
  */