@mrxkun/mcfast-mcp 3.3.5 → 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.5",
+  "version": "3.3.7",
   "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}`;