snow-ai 0.2.24 → 0.2.26

package/dist/mcp/filesystem.js

@@ -1,9 +1,13 @@
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { execSync } from 'child_process';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+// IDE connection supports both VSCode and JetBrains IDEs
 import { vscodeConnection } from '../utils/vscodeConnection.js';
 import { incrementalSnapshotManager } from '../utils/incrementalSnapshot.js';
+import { tryUnescapeFix, trimPairIfPossible, isOverEscaped, } from '../utils/escapeHandler.js';
 const { resolve, dirname, isAbsolute } = path;
+const execAsync = promisify(exec);
 /**
  * Filesystem MCP Service
  * Provides basic file operations: read, create, and delete files
@@ -43,6 +47,153 @@ export class FilesystemMCPService {
         });
         this.basePath = resolve(basePath);
     }
+    /**
+     * Calculate similarity between two strings using a smarter algorithm
+     * This normalizes whitespace first to avoid false negatives from spacing differences
+     * Returns a value between 0 (completely different) and 1 (identical)
+     */
+    calculateSimilarity(str1, str2, threshold = 0) {
+        // Normalize whitespace for comparison: collapse all whitespace to single spaces
+        const normalize = (s) => s.replace(/\s+/g, ' ').trim();
+        const norm1 = normalize(str1);
+        const norm2 = normalize(str2);
+        const len1 = norm1.length;
+        const len2 = norm2.length;
+        if (len1 === 0)
+            return len2 === 0 ? 1 : 0;
+        if (len2 === 0)
+            return 0;
+        // Quick length check - if lengths differ too much, similarity can't be above threshold
+        const maxLen = Math.max(len1, len2);
+        const minLen = Math.min(len1, len2);
+        const lengthRatio = minLen / maxLen;
+        if (threshold > 0 && lengthRatio < threshold) {
+            return lengthRatio; // Can't possibly meet threshold
+        }
+        // Use Levenshtein distance for better similarity calculation
+        const distance = this.levenshteinDistance(norm1, norm2, Math.ceil(maxLen * (1 - threshold)));
+        return 1 - distance / maxLen;
+    }
+    /**
+     * Calculate Levenshtein distance between two strings with early termination
+     * @param str1 First string
+     * @param str2 Second string
+     * @param maxDistance Maximum distance to compute (early exit if exceeded)
+     * @returns Levenshtein distance, or maxDistance+1 if exceeded
+     */
+    levenshteinDistance(str1, str2, maxDistance = Infinity) {
+        const len1 = str1.length;
+        const len2 = str2.length;
+        // Quick exit for identical strings
+        if (str1 === str2)
+            return 0;
+        // Quick exit if length difference already exceeds maxDistance
+        if (Math.abs(len1 - len2) > maxDistance) {
+            return maxDistance + 1;
+        }
+        // Use single-row algorithm to save memory (only need previous row)
+        let prevRow = Array.from({ length: len2 + 1 }, (_, i) => i);
+        for (let i = 1; i <= len1; i++) {
+            const currRow = [i];
+            let minInRow = i; // Track minimum value in current row
+            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
+                currRow[j - 1] + 1, // insertion
+                prevRow[j - 1] + cost // substitution
+                );
+                currRow[j] = val;
+                minInRow = Math.min(minInRow, val);
+            }
+            // Early termination: if minimum in this row exceeds maxDistance, we can stop
+            if (minInRow > maxDistance) {
+                return maxDistance + 1;
+            }
+            prevRow = currRow;
+        }
+        return prevRow[len2];
+    }
+    /**
+     * Find the closest matching candidates in the file content
+     * Returns top N candidates sorted by similarity
+     * Optimized with safe pre-filtering and early exit
+     */
+    findClosestMatches(searchContent, fileLines, topN = 3) {
+        const searchLines = searchContent.split('\n');
+        const candidates = [];
+        // Normalize whitespace for display only (makes preview more readable)
+        const normalizeForDisplay = (line) => line.replace(/\t/g, ' ').replace(/  +/g, ' ');
+        // Fast pre-filter: use first line as anchor (only for multi-line searches)
+        const searchFirstLine = searchLines[0]?.replace(/\s+/g, ' ').trim() || '';
+        const threshold = 0.5;
+        const usePreFilter = searchLines.length >= 5; // Only for 5+ line searches
+        const preFilterThreshold = 0.2; // Very conservative - only skip completely unrelated lines
+        // Try to find candidates by sliding window with optimizations
+        const maxCandidates = topN * 3; // Collect more candidates, then pick best
+        for (let i = 0; i <= fileLines.length - searchLines.length; i++) {
+            // Quick pre-filter: check first line similarity (only for multi-line)
+            if (usePreFilter) {
+                const firstLineCandidate = fileLines[i]?.replace(/\s+/g, ' ').trim() || '';
+                const firstLineSimilarity = this.calculateSimilarity(searchFirstLine, firstLineCandidate, preFilterThreshold);
+                // Skip only if first line is very different
+                if (firstLineSimilarity < preFilterThreshold) {
+                    continue;
+                }
+            }
+            // Full candidate check
+            const candidateLines = fileLines.slice(i, i + searchLines.length);
+            const candidateContent = candidateLines.join('\n');
+            const similarity = this.calculateSimilarity(searchContent, candidateContent, threshold);
+            // Only consider candidates with >50% similarity
+            if (similarity > threshold) {
+                candidates.push({
+                    startLine: i + 1,
+                    endLine: i + searchLines.length,
+                    similarity,
+                    preview: candidateLines
+                        .map((line, idx) => `${i + idx + 1}→${normalizeForDisplay(line)}`)
+                        .join('\n'),
+                });
+                // Early exit if we found a nearly perfect match
+                if (similarity >= 0.95) {
+                    break;
+                }
+                // Limit candidates to avoid excessive computation
+                if (candidates.length >= maxCandidates) {
+                    break;
+                }
+            }
+        }
+        // Sort by similarity descending and return top N
+        return candidates
+            .sort((a, b) => b.similarity - a.similarity)
+            .slice(0, topN);
+    }
+    /**
+     * Generate a helpful diff message showing differences between search and actual content
+     * Note: This is ONLY for display purposes. Tabs/spaces are normalized for better readability.
+     */
+    generateDiffMessage(searchContent, actualContent, maxLines = 10) {
+        const searchLines = searchContent.split('\n');
+        const actualLines = actualContent.split('\n');
+        const diffLines = [];
+        const maxLen = Math.max(searchLines.length, actualLines.length);
+        // Normalize whitespace for display only (makes diff more readable)
+        const normalizeForDisplay = (line) => line.replace(/\t/g, ' ').replace(/  +/g, ' ');
+        for (let i = 0; i < Math.min(maxLen, maxLines); i++) {
+            const searchLine = searchLines[i] || '';
+            const actualLine = actualLines[i] || '';
+            if (searchLine !== actualLine) {
+                diffLines.push(`Line ${i + 1}:`);
+                diffLines.push(`  Search: ${JSON.stringify(normalizeForDisplay(searchLine))}`);
+                diffLines.push(`  Actual: ${JSON.stringify(normalizeForDisplay(actualLine))}`);
+            }
+        }
+        if (maxLen > maxLines) {
+            diffLines.push(`... (${maxLen - maxLines} more lines)`);
+        }
+        return diffLines.join('\n');
+    }
     /**
      * Analyze code structure for balance and completeness
      * Helps AI identify bracket mismatches, unclosed tags, and boundary issues
@@ -149,23 +300,8 @@ export class FilesystemMCPService {
                 }
             }
         }
-        // Check if edit is at a code block boundary
-        const lastLine = editedLines[editedLines.length - 1]?.trim() || '';
-        const firstLine = editedLines[0]?.trim() || '';
-        const endsWithOpenBrace = lastLine.endsWith('{') ||
-            lastLine.endsWith('(') ||
-            lastLine.endsWith('[');
-        const startsWithCloseBrace = firstLine.startsWith('}') ||
-            firstLine.startsWith(')') ||
-            firstLine.startsWith(']');
-        if (endsWithOpenBrace || startsWithCloseBrace) {
-            analysis.codeBlockBoundary = {
-                isInCompleteBlock: false,
-                suggestion: endsWithOpenBrace
-                    ? 'Edit ends with an opening bracket - ensure the closing bracket is included in a subsequent edit or already exists in the file'
-                    : 'Edit starts with a closing bracket - ensure the opening bracket exists before this edit',
-            };
-        }
+        // Note: Boundary checking removed - AI should be free to edit partial code blocks
+        // The bracket balance check above is sufficient for detecting real issues
         return analysis;
     }
     /**
@@ -223,15 +359,85 @@ export class FilesystemMCPService {
         return { start: contextStart, end: contextEnd, extended };
     }
     /**
-     * Get the content of a file with specified line range
-     * @param filePath - Path to the file (relative to base path or absolute)
-     * @param startLine - Starting line number (1-indexed, inclusive)
-     * @param endLine - Ending line number (1-indexed, inclusive)
+     * Get the content of a file with optional line range
+     * @param filePath - Path to the file (relative to base path or absolute) or array of file paths
+     * @param startLine - Starting line number (1-indexed, inclusive, optional - defaults to 1)
+     * @param endLine - Ending line number (1-indexed, inclusive, optional - defaults to 500 or file end)
      * @returns Object containing the requested content with line numbers and metadata
      * @throws Error if file doesn't exist or cannot be read
      */
     async getFileContent(filePath, startLine, endLine) {
         try {
+            // Handle array of files
+            if (Array.isArray(filePath)) {
+                const filesData = [];
+                const allContents = [];
+                for (const file of filePath) {
+                    try {
+                        const fullPath = this.resolvePath(file);
+                        // For absolute paths, skip validation to allow access outside base path
+                        if (!isAbsolute(file)) {
+                            await this.validatePath(fullPath);
+                        }
+                        // Check if the path is a directory, if so, list its contents instead
+                        const stats = await fs.stat(fullPath);
+                        if (stats.isDirectory()) {
+                            const dirFiles = await this.listFiles(file);
+                            const fileList = dirFiles.join('\n');
+                            allContents.push(`📁 Directory: ${file}\n${fileList}`);
+                            filesData.push({
+                                path: file,
+                                startLine: 1,
+                                endLine: dirFiles.length,
+                                totalLines: dirFiles.length,
+                            });
+                            continue;
+                        }
+                        const content = await fs.readFile(fullPath, 'utf-8');
+                        const lines = content.split('\n');
+                        const totalLines = lines.length;
+                        // Default values and logic
+                        const actualStartLine = startLine ?? 1;
+                        const actualEndLine = endLine ?? totalLines;
+                        // Validate and adjust line numbers
+                        if (actualStartLine < 1) {
+                            throw new Error(`Start line must be greater than 0 for ${file}`);
+                        }
+                        if (actualEndLine < actualStartLine) {
+                            throw new Error(`End line must be greater than or equal to start line for ${file}`);
+                        }
+                        if (actualStartLine > totalLines) {
+                            throw new Error(`Start line ${actualStartLine} exceeds file length ${totalLines} for ${file}`);
+                        }
+                        const start = actualStartLine;
+                        const end = Math.min(totalLines, actualEndLine);
+                        // Extract specified lines
+                        const selectedLines = lines.slice(start - 1, end);
+                        const numberedLines = selectedLines.map((line, index) => {
+                            const lineNum = start + index;
+                            return `${lineNum}→${line}`;
+                        });
+                        const fileContent = `📄 ${file} (lines ${start}-${end}/${totalLines})\n${numberedLines.join('\n')}`;
+                        allContents.push(fileContent);
+                        filesData.push({
+                            path: file,
+                            startLine: start,
+                            endLine: end,
+                            totalLines,
+                        });
+                    }
+                    catch (error) {
+                        const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+                        allContents.push(`❌ ${file}: ${errorMsg}`);
+                    }
+                }
+                return {
+                    content: allContents.join('\n\n'),
+                    files: filesData,
+                    totalFiles: filePath.length,
+                };
+            }
+            // Original single file logic
             const fullPath = this.resolvePath(filePath);
             // For absolute paths, skip validation to allow access outside base path
             if (!isAbsolute(filePath)) {
@@ -254,29 +460,30 @@ export class FilesystemMCPService {
             // Parse lines
             const lines = content.split('\n');
             const totalLines = lines.length;
+            // Default values and logic:
+            // - No params: read entire file (1 to totalLines)
+            // - Only startLine: read from startLine to end of file
+            // - Both params: read from startLine to endLine
+            const actualStartLine = startLine ?? 1;
+            const actualEndLine = endLine ?? totalLines;
             // Validate and adjust line numbers
-            if (startLine < 1) {
+            if (actualStartLine < 1) {
                 throw new Error('Start line must be greater than 0');
             }
-            if (endLine < startLine) {
+            if (actualEndLine < actualStartLine) {
                 throw new Error('End line must be greater than or equal to start line');
             }
-            if (startLine > totalLines) {
-                throw new Error(`Start line ${startLine} exceeds file length ${totalLines}`);
+            if (actualStartLine > totalLines) {
+                throw new Error(`Start line ${actualStartLine} exceeds file length ${totalLines}`);
             }
-            const start = startLine;
-            const end = Math.min(totalLines, endLine);
+            const start = actualStartLine;
+            const end = Math.min(totalLines, actualEndLine);
             // Extract specified lines (convert to 0-indexed) and add line numbers
             const selectedLines = lines.slice(start - 1, end);
             // Format with line numbers (no padding to save tokens)
-            // Normalize whitespace: tabs → single space, multiple spaces → single space
             const numberedLines = selectedLines.map((line, index) => {
                 const lineNum = start + index;
-                // Normalize whitespace to reduce token usage
-                const normalizedLine = line
-                    .replace(/\t/g, ' ') // Convert tabs to single space
-                    .replace(/  +/g, ' '); // Compress multiple spaces to single space
-                return `${lineNum}→${normalizedLine}`;
+                return `${lineNum}→${line}`;
             });
             const partialContent = numberedLines.join('\n');
             return {
@@ -432,14 +639,14 @@ export class FilesystemMCPService {
     }
     /**
      * Edit a file by searching for exact content and replacing it
-     * This method is SAFER than line-based editing as it automatically handles code boundaries.
+     * This method uses SMART MATCHING to handle whitespace differences automatically.
      *
      * @param filePath - Path to the file to edit
-     * @param searchContent - Exact content to search for (must match precisely, including whitespace)
+     * @param searchContent - Content to search for (whitespace will be normalized automatically)
      * @param replaceContent - New content to replace the search content with
      * @param occurrence - Which occurrence to replace (1-indexed, default: 1, use -1 for all)
      * @param contextLines - Number of context lines to return before and after the edit (default: 8)
-     * @returns Object containing success message, before/after comparison, and diagnostics
+     * @returns Object containing success message, before/after comparison, and diagnostics from IDE (VSCode or JetBrains)
      * @throws Error if search content is not found or multiple matches exist
      */
     async editFileBySearch(filePath, searchContent, replaceContent, occurrence = 1, contextLines = 8) {
@@ -453,34 +660,129 @@ export class FilesystemMCPService {
             const content = await fs.readFile(fullPath, 'utf-8');
             const lines = content.split('\n');
             // Normalize line endings
-            const normalizedSearch = searchContent.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-            const normalizedContent = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-            // Apply whitespace normalization for matching (same as getFileContent output)
-            const normalizeWhitespace = (text) => text.replace(/\t/g, ' ').replace(/  +/g, ' ');
-            const normalizedSearchForMatch = normalizeWhitespace(normalizedSearch);
-            const normalizedContentForMatch = normalizeWhitespace(normalizedContent);
-            // Find all matches by comparing normalized versions line by line
-            // This avoids complex character position mapping
+            let normalizedSearch = searchContent
+                .replace(/\r\n/g, '\n')
+                .replace(/\r/g, '\n');
+            const normalizedContent = content
+                .replace(/\r\n/g, '\n')
+                .replace(/\r/g, '\n');
+            // Split into lines for matching
+            let searchLines = normalizedSearch.split('\n');
+            const contentLines = normalizedContent.split('\n');
+            // Find all matches using smart fuzzy matching (auto-handles whitespace)
             const matches = [];
-            const searchLines = normalizedSearchForMatch.split('\n');
-            const contentLines = normalizedContentForMatch.split('\n');
+            const threshold = 0.6; // Lowered to 60% to allow smaller partial edits (was 0.75)
+            // Fast pre-filter: use first line as anchor to skip unlikely positions
+            // Only apply pre-filter for multi-line searches to avoid missing valid matches
+            const searchFirstLine = searchLines[0]?.replace(/\s+/g, ' ').trim() || '';
+            const usePreFilter = searchLines.length >= 5; // Only pre-filter for 5+ line searches
+            const preFilterThreshold = 0.2; // Very low threshold - only skip completely unrelated lines
+            const maxMatches = 10; // Limit matches to avoid excessive computation
             for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
-                let isMatch = true;
-                for (let j = 0; j < searchLines.length; j++) {
-                    if (contentLines[i + j] !== searchLines[j]) {
-                        isMatch = false;
-                        break;
+                // Quick pre-filter: check first line similarity (only for multi-line searches)
+                if (usePreFilter) {
+                    const firstLineCandidate = contentLines[i]?.replace(/\s+/g, ' ').trim() || '';
+                    const firstLineSimilarity = this.calculateSimilarity(searchFirstLine, firstLineCandidate, preFilterThreshold);
+                    // Skip only if first line is very different (< 30% match)
+                    // This is safe because if first line differs this much, full match unlikely
+                    if (firstLineSimilarity < preFilterThreshold) {
+                        continue;
                     }
                 }
-                if (isMatch) {
-                    const startLine = i + 1; // Convert to 1-indexed
-                    const endLine = startLine + searchLines.length - 1;
-                    matches.push({ startLine, endLine });
+                // Full candidate check
+                const candidateLines = contentLines.slice(i, i + searchLines.length);
+                const candidateContent = candidateLines.join('\n');
+                const similarity = this.calculateSimilarity(normalizedSearch, candidateContent, threshold);
+                // Accept matches above threshold
+                if (similarity >= threshold) {
+                    matches.push({
+                        startLine: i + 1,
+                        endLine: i + searchLines.length,
+                        similarity,
+                    });
+                    // Early exit if we found a nearly perfect match
+                    if (similarity >= 0.95) {
+                        break;
+                    }
+                    // Limit matches to avoid excessive computation
+                    if (matches.length >= maxMatches) {
+                        break;
+                    }
                 }
             }
-            // Handle no matches
+            // Sort by similarity descending (best match first)
+            matches.sort((a, b) => b.similarity - a.similarity);
+            // Handle no matches: Try escape correction before giving up
             if (matches.length === 0) {
-                throw new Error(`Search content not found in file. Please verify the exact content including whitespace and indentation.`);
+                // Step 1: Try unescape correction (lightweight, no LLM)
+                const unescapeFix = tryUnescapeFix(normalizedContent, normalizedSearch, 1);
+                if (unescapeFix) {
+                    // Unescape succeeded! Re-run the matching with corrected content
+                    const correctedSearchLines = unescapeFix.correctedString.split('\n');
+                    for (let i = 0; i <= contentLines.length - correctedSearchLines.length; i++) {
+                        const candidateLines = contentLines.slice(i, i + correctedSearchLines.length);
+                        const candidateContent = candidateLines.join('\n');
+                        const similarity = this.calculateSimilarity(unescapeFix.correctedString, candidateContent);
+                        if (similarity >= threshold) {
+                            matches.push({
+                                startLine: i + 1,
+                                endLine: i + correctedSearchLines.length,
+                                similarity,
+                            });
+                        }
+                    }
+                    matches.sort((a, b) => b.similarity - a.similarity);
+                    // If unescape fix worked, also fix replaceContent if needed
+                    if (matches.length > 0) {
+                        const trimResult = trimPairIfPossible(unescapeFix.correctedString, replaceContent, normalizedContent, 1);
+                        // Update searchContent and replaceContent for the edit
+                        normalizedSearch = trimResult.target;
+                        replaceContent = trimResult.paired;
+                        // Also update searchLines for later use
+                        searchLines.splice(0, searchLines.length, ...normalizedSearch.split('\n'));
+                    }
+                }
+                // If still no matches after unescape, provide detailed error
+                if (matches.length === 0) {
+                    // Find closest matches for suggestions
+                    const closestMatches = this.findClosestMatches(normalizedSearch, normalizedContent.split('\n'), 3);
+                    let errorMessage = `❌ Search content not found in file: ${filePath}\n\n`;
+                    errorMessage += `🔍 Using smart fuzzy matching (threshold: 60%)\n`;
+                    if (isOverEscaped(searchContent)) {
+                        errorMessage += `⚠️  Detected over-escaped content, automatic fix attempted but failed\n`;
+                    }
+                    errorMessage += `\n`;
+                    if (closestMatches.length > 0) {
+                        errorMessage += `💡 Found ${closestMatches.length} similar location(s):\n\n`;
+                        closestMatches.forEach((candidate, idx) => {
+                            errorMessage += `${idx + 1}. Lines ${candidate.startLine}-${candidate.endLine} (${(candidate.similarity * 100).toFixed(0)}% match):\n`;
+                            errorMessage += `${candidate.preview}\n\n`;
+                        });
+                        // Show diff with the closest match
+                        const bestMatch = closestMatches[0];
+                        if (bestMatch) {
+                            const bestMatchLines = lines.slice(bestMatch.startLine - 1, bestMatch.endLine);
+                            const bestMatchContent = bestMatchLines.join('\n');
+                            const diffMsg = this.generateDiffMessage(normalizedSearch, bestMatchContent, 5);
+                            if (diffMsg) {
+                                errorMessage += `📊 Difference with closest match:\n${diffMsg}\n\n`;
+                            }
+                        }
+                        errorMessage += `💡 Suggestions:\n`;
+                        errorMessage += `  • Make sure you copied content from filesystem_read (without "123→")\n`;
+                        errorMessage += `  • Whitespace differences are automatically handled\n`;
+                        errorMessage += `  • Try copying a larger or smaller code block\n`;
+                        errorMessage += `  • If multiple filesystem_edit_search attempts fail, use terminal_execute to edit via command line (e.g. sed, printf)\n`;
+                        errorMessage += `⚠️  No similar content found in the file.\n\n`;
+                        errorMessage += `📝 What you searched for (first 5 lines, formatted):\n`;
+                        const normalizeForDisplay = (line) => line.replace(/\s+/g, ' ').trim();
+                        searchLines.slice(0, 5).forEach((line, idx) => {
+                            errorMessage += `${idx + 1}. ${JSON.stringify(normalizeForDisplay(line))}\n`;
+                        });
+                        errorMessage += `\n💡 Copy exact content from filesystem_read (without line numbers)\n`;
+                    }
+                    throw new Error(errorMessage);
+                }
             }
             // Handle occurrence selection
             let selectedMatch;
@@ -494,9 +796,7 @@ export class FilesystemMCPService {
                 }
             }
             else if (occurrence < 1 || occurrence > matches.length) {
-                throw new Error(`Invalid occurrence ${occurrence}. Found ${matches.length} match(es) at lines: ${matches
-                    .map(m => m.startLine)
-                    .join(', ')}`);
+                throw new Error(`Invalid occurrence ${occurrence}. Found ${matches.length} match(es) at lines: ${matches.map(m => m.startLine).join(', ')}`);
             }
             else {
                 selectedMatch = matches[occurrence - 1];
@@ -505,19 +805,21 @@ export class FilesystemMCPService {
             // Backup file before editing
             await incrementalSnapshotManager.backupFile(fullPath);
             // Perform the replacement by replacing the matched lines
-            const normalizedReplace = replaceContent.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            const normalizedReplace = replaceContent
+                .replace(/\r\n/g, '\n')
+                .replace(/\r/g, '\n');
             const beforeLines = lines.slice(0, startLine - 1);
             const afterLines = lines.slice(endLine);
             const replaceLines = normalizedReplace.split('\n');
             const modifiedLines = [...beforeLines, ...replaceLines, ...afterLines];
             const modifiedContent = modifiedLines.join('\n');
-            // Calculate replaced content for display
+            // Calculate replaced content for display (compress whitespace for readability)
+            const normalizeForDisplay = (line) => line.replace(/\s+/g, ' ');
             const replacedLines = lines.slice(startLine - 1, endLine);
             const replacedContent = replacedLines
                 .map((line, idx) => {
                 const lineNum = startLine + idx;
-                const normalizedLine = line.replace(/\t/g, ' ').replace(/  +/g, ' ');
-                return `${lineNum}→${normalizedLine}`;
+                return `${lineNum}→${normalizeForDisplay(line)}`;
             })
                 .join('\n');
             // Calculate context boundaries
@@ -525,18 +827,17 @@ export class FilesystemMCPService {
             const smartBoundaries = this.findSmartContextBoundaries(lines, startLine, endLine, contextLines);
             const contextStart = smartBoundaries.start;
             const contextEnd = smartBoundaries.end;
-            // Extract old content for context
+            // Extract old content for context (compress whitespace for readability)
             const oldContextLines = lines.slice(contextStart - 1, contextEnd);
             const oldContent = oldContextLines
                 .map((line, idx) => {
                 const lineNum = contextStart + idx;
-                const normalizedLine = line.replace(/\t/g, ' ').replace(/  +/g, ' ');
-                return `${lineNum}→${normalizedLine}`;
+                return `${lineNum}→${normalizeForDisplay(line)}`;
             })
                 .join('\n');
             // Write the modified content
             await fs.writeFile(fullPath, modifiedContent, 'utf-8');
-            // Format with Prettier if applicable
+            // Format with Prettier asynchronously (non-blocking)
             let finalContent = modifiedContent;
             let finalLines = modifiedLines;
             let finalTotalLines = modifiedLines.length;
@@ -546,8 +847,7 @@ export class FilesystemMCPService {
             const shouldFormat = this.prettierSupportedExtensions.includes(fileExtension);
             if (shouldFormat) {
                 try {
-                    execSync(`npx prettier --write "${fullPath}"`, {
-                        stdio: 'pipe',
+                    await execAsync(`npx prettier --write "${fullPath}"`, {
                         encoding: 'utf-8',
                     });
                     // Re-read the file after formatting
@@ -560,26 +860,29 @@ export class FilesystemMCPService {
                     // Continue with unformatted content
                 }
             }
-            // Extract new content for context
+            // Extract new content for context (compress whitespace for readability)
             const newContextLines = finalLines.slice(contextStart - 1, finalContextEnd);
             const newContextContent = newContextLines
                 .map((line, idx) => {
                 const lineNum = contextStart + idx;
-                const normalizedLine = line.replace(/\t/g, ' ').replace(/  +/g, ' ');
-                return `${lineNum}→${normalizedLine}`;
+                return `${lineNum}→${normalizeForDisplay(line)}`;
             })
                 .join('\n');
             // Analyze code structure
             const editedContentLines = replaceLines;
             const structureAnalysis = this.analyzeCodeStructure(finalContent, filePath, editedContentLines);
-            // Get diagnostics from VS Code
+            // Get diagnostics from IDE (VSCode or JetBrains) - non-blocking, fire-and-forget
             let diagnostics = [];
             try {
-                await new Promise(resolve => setTimeout(resolve, 500));
-                diagnostics = await vscodeConnection.requestDiagnostics(fullPath);
+                // Request diagnostics without blocking (with timeout protection)
+                const diagnosticsPromise = Promise.race([
+                    vscodeConnection.requestDiagnostics(fullPath),
+                    new Promise(resolve => setTimeout(() => resolve([]), 1000)), // 1s max wait
+                ]);
+                diagnostics = await diagnosticsPromise;
             }
             catch (error) {
-                // Ignore diagnostics errors
+                // Ignore diagnostics errors - this is optional functionality
             }
             // Build result
             const result = {
@@ -653,10 +956,7 @@ export class FilesystemMCPService {
             if (structureAnalysis.indentationWarnings.length > 0) {
                 structureWarnings.push(...structureAnalysis.indentationWarnings.map(w => `Indentation: ${w}`));
             }
-            if (structureAnalysis.codeBlockBoundary &&
-                structureAnalysis.codeBlockBoundary.suggestion) {
-                structureWarnings.push(`Boundary: ${structureAnalysis.codeBlockBoundary.suggestion}`);
-            }
+            // Note: Boundary warnings removed - partial edits are common and expected
             if (structureWarnings.length > 0) {
                 result.message += `\n\n🔍 Structure Analysis:\n`;
                 structureWarnings.forEach(warning => {
@@ -680,7 +980,7 @@ export class FilesystemMCPService {
      * @param endLine - Ending line number (1-indexed, inclusive) - get from filesystem_read output
      * @param newContent - New content to replace the specified lines (WITHOUT line numbers)
      * @param contextLines - Number of context lines to return before and after the edit (default: 8)
-     * @returns Object containing success message, precise before/after comparison, and diagnostics
+     * @returns Object containing success message, precise before/after comparison, and diagnostics from IDE (VSCode or JetBrains)
      * @throws Error if file editing fails
      */
     async editFile(filePath, startLine, endLine, newContent, contextLines = 8) {
@@ -710,25 +1010,25 @@ export class FilesystemMCPService {
             // Backup file before editing
             await incrementalSnapshotManager.backupFile(fullPath);
             // Extract the lines that will be replaced (for comparison)
+            // Compress whitespace for display readability
+            const normalizeForDisplay = (line) => line.replace(/\s+/g, ' ');
             const replacedLines = lines.slice(startLine - 1, adjustedEndLine);
             const replacedContent = replacedLines
                 .map((line, idx) => {
                 const lineNum = startLine + idx;
-                const normalizedLine = line.replace(/\t/g, ' ').replace(/  +/g, ' ');
-                return `${lineNum}→${normalizedLine}`;
+                return `${lineNum}→${normalizeForDisplay(line)}`;
             })
                 .join('\n');
             // Calculate context range using smart boundary detection
             const smartBoundaries = this.findSmartContextBoundaries(lines, startLine, adjustedEndLine, contextLines);
             const contextStart = smartBoundaries.start;
             const contextEnd = smartBoundaries.end;
-            // Extract old content for context (including the lines to be replaced)
+            // Extract old content for context (compress whitespace for readability)
             const oldContextLines = lines.slice(contextStart - 1, contextEnd);
             const oldContent = oldContextLines
                 .map((line, idx) => {
                 const lineNum = contextStart + idx;
-                const normalizedLine = line.replace(/\t/g, ' ').replace(/  +/g, ' ');
-                return `${lineNum}→${normalizedLine}`;
+                return `${lineNum}→${normalizeForDisplay(line)}`;
             })
                 .join('\n');
             // Replace the specified lines
@@ -740,13 +1040,12 @@ export class FilesystemMCPService {
             const newTotalLines = modifiedLines.length;
             const lineDifference = newContentLines.length - (adjustedEndLine - startLine + 1);
             const newContextEnd = Math.min(newTotalLines, contextEnd + lineDifference);
-            // Extract new content for context with line numbers
+            // Extract new content for context with line numbers (compress whitespace)
             const newContextLines = modifiedLines.slice(contextStart - 1, newContextEnd);
             const newContextContent = newContextLines
                 .map((line, idx) => {
                 const lineNum = contextStart + idx;
-                const normalizedLine = line.replace(/\t/g, ' ').replace(/  +/g, ' ');
-                return `${lineNum}→${normalizedLine}`;
+                return `${lineNum}→${normalizeForDisplay(line)}`;
             })
                 .join('\n');
             // Write the modified content back to file
@@ -761,8 +1060,7 @@ export class FilesystemMCPService {
             const shouldFormat = this.prettierSupportedExtensions.includes(fileExtension);
             if (shouldFormat) {
                 try {
-                    execSync(`npx prettier --write "${fullPath}"`, {
-                        stdio: 'pipe',
+                    await execAsync(`npx prettier --write "${fullPath}"`, {
                         encoding: 'utf-8',
                     });
                     // Re-read the file after formatting to get the formatted content
@@ -771,13 +1069,12 @@ export class FilesystemMCPService {
                     finalTotalLines = finalLines.length;
                     // Recalculate the context end line based on formatted content
                     finalContextEnd = Math.min(finalTotalLines, contextStart + (newContextEnd - contextStart));
-                    // Extract formatted content for context with line numbers
+                    // Extract formatted content for context (compress whitespace)
                     const formattedContextLines = finalLines.slice(contextStart - 1, finalContextEnd);
                     finalContextContent = formattedContextLines
                         .map((line, idx) => {
                         const lineNum = contextStart + idx;
-                        const normalizedLine = line.replace(/\t/g, ' ').replace(/  +/g, ' ');
-                        return `${lineNum}→${normalizedLine}`;
+                        return `${lineNum}→${normalizeForDisplay(line)}`;
                     })
                         .join('\n');
                 }
@@ -789,15 +1086,18 @@ export class FilesystemMCPService {
             // Analyze code structure of the edited content (using formatted content if available)
             const editedContentLines = finalLines.slice(startLine - 1, startLine - 1 + newContentLines.length);
             const structureAnalysis = this.analyzeCodeStructure(finalLines.join('\n'), filePath, editedContentLines);
-            // Try to get diagnostics from VS Code after editing
+            // Try to get diagnostics from IDE (VSCode or JetBrains) after editing (non-blocking)
             let diagnostics = [];
             try {
-                // Wait a bit for VS Code to process the file change
-                await new Promise(resolve => setTimeout(resolve, 500));
-                diagnostics = await vscodeConnection.requestDiagnostics(fullPath);
+                // Request diagnostics without blocking (with timeout protection)
+                const diagnosticsPromise = Promise.race([
+                    vscodeConnection.requestDiagnostics(fullPath),
+                    new Promise(resolve => setTimeout(() => resolve([]), 1000)), // 1s max wait
+                ]);
+                diagnostics = await diagnosticsPromise;
             }
             catch (error) {
-                // Ignore diagnostics errors, they are optional
+                // Ignore diagnostics errors - they are optional
             }
             const result = {
                 message: `✅ File edited successfully,Please check the edit results and pay attention to code boundary issues to avoid syntax errors caused by missing closed parts: ${filePath}\n` +
@@ -872,11 +1172,7 @@ export class FilesystemMCPService {
             if (structureAnalysis.indentationWarnings.length > 0) {
                 structureWarnings.push(...structureAnalysis.indentationWarnings.map(w => `Indentation: ${w}`));
             }
-            // Add code block boundary warnings
-            if (structureAnalysis.codeBlockBoundary &&
-                structureAnalysis.codeBlockBoundary.suggestion) {
-                structureWarnings.push(`Boundary: ${structureAnalysis.codeBlockBoundary.suggestion}`);
-            }
+            // Note: Boundary warnings removed - partial edits are common and expected
             // Format structure warnings
             if (structureWarnings.length > 0) {
                 result.message += `\n\n🔍 Structure Analysis:\n`;
@@ -921,28 +1217,39 @@ export class FilesystemMCPService {
 }
 // Export a default instance
 export const filesystemService = new FilesystemMCPService();
-// MCP Tool definitions for integration
 export const mcpTools = [
     {
         name: 'filesystem_read',
-        description: 'Read the content of a file within specified line range. The returned content includes line numbers (format: "lineNum→content") for precise editing. You MUST specify startLine and endLine. To read the entire file, use startLine=1 and a large endLine value (e.g., 500). IMPORTANT: When you need to edit a file, you MUST read it first to see the exact line numbers and current content. NOTE: If the path points to a directory, this tool will automatically list its contents instead of throwing an error.',
+        description: '📖 Read file content with line numbers. **SUPPORTS MULTIPLE FILES**: Pass either a single file path (string) or multiple file paths (array of strings) to read in one call. ⚠️ **IMPORTANT WORKFLOW**: (1) ALWAYS use ACE search tools FIRST (ace_text_search/ace_search_symbols/ace_file_outline) to locate the relevant code, (2) ONLY use filesystem_read when you know the approximate location and need precise line numbers for editing. **ANTI-PATTERN**: Reading files line-by-line from the top wastes tokens - use search instead! **USAGE**: Call without parameters to read entire file(s), or specify startLine/endLine for partial reads. Returns content with line numbers (format: "123→code") for precise editing. **MULTI-FILE EXAMPLE**: filePath=["src/component.ts", "src/utils.ts"] reads both files together.',
         inputSchema: {
             type: 'object',
             properties: {
                 filePath: {
-                    type: 'string',
-                    description: 'Path to the file to read (or directory to list)',
+                    oneOf: [
+                        {
+                            type: 'string',
+                            description: 'Path to a single file to read',
+                        },
+                        {
+                            type: 'array',
+                            items: {
+                                type: 'string',
+                            },
+                            description: 'Array of file paths to read in one call',
+                        },
+                    ],
+                    description: 'Path to the file(s) to read (single string or array of strings)',
                 },
                 startLine: {
                     type: 'number',
-                    description: 'Starting line number (1-indexed, inclusive). Must be >= 1.',
+                    description: 'Optional: Starting line number (1-indexed). Omit to read from line 1. Applied to all files.',
                 },
                 endLine: {
                     type: 'number',
-                    description: 'Ending line number (1-indexed, inclusive). Can exceed file length (will be capped automatically).',
+                    description: 'Optional: Ending line number (1-indexed). Omit to read to end of file. Applied to all files.',
                 },
             },
-            required: ['filePath', 'startLine', 'endLine'],
+            required: ['filePath'],
         },
     },
     {
@@ -982,17 +1289,17 @@ export const mcpTools = [
                     oneOf: [
                         {
                             type: 'string',
-                            description: 'Path to a single file to delete'
+                            description: 'Path to a single file to delete',
                         },
                         {
                             type: 'array',
                             items: {
-                                type: 'string'
+                                type: 'string',
                             },
-                            description: 'Array of file paths to delete'
-                        }
+                            description: 'Array of file paths to delete',
+                        },
                     ],
-                    description: 'Single file path or array of file paths to delete'
+                    description: 'Single file path or array of file paths to delete',
                 },
             },
             // Make both optional, but at least one is required (validated in code)
@@ -1014,7 +1321,7 @@ export const mcpTools = [
     },
     {
         name: 'filesystem_edit_search',
-        description: '🎯 **RECOMMENDED** for most edits: Search-and-replace editing with AUTOMATIC boundary detection. **WHY USE THIS**: (1) NO need to count line numbers - just copy the exact code you want to change, (2) SAFER - automatically handles code boundaries to prevent bracket/tag mismatches, (3) CLEARER intent - shows exactly what you\'re changing. **BEST FOR**: Modifying existing functions, fixing bugs, updating logic. **WORKFLOW**: (1) Read file with filesystem_read, (2) Copy exact code block to change (including whitespace!), (3) Provide the replacement. **HANDLES**: Multiple occurrences, whitespace normalization, structure validation. **TIP**: For new code additions, use filesystem_edit with line numbers instead.',
+        description: '🎯 **RECOMMENDED** for most edits: Search-and-replace with SMART FUZZY MATCHING that automatically handles whitespace differences. **WORKFLOW**: (1) Use ace_text_search/ace_search_symbols to locate code, (2) Use filesystem_read to view content, (3) Copy the code block you want to change (without line numbers), (4) Use THIS tool - whitespace will be normalized automatically. **WHY**: No line tracking, auto-handles spacing/tabs, finds best match. **BEST FOR**: Modifying functions, fixing bugs, updating logic.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -1024,20 +1331,20 @@ export const mcpTools = [
                 },
                 searchContent: {
                     type: 'string',
-                    description: '⚠️  EXACT content to find and replace. MUST match precisely including indentation and whitespace. Copy directly from filesystem_read output (WITHOUT line numbers like "123→").',
+                    description: 'Content to find and replace. Copy from filesystem_read output WITHOUT line numbers (e.g., "123→"). Whitespace differences are automatically handled - focus on getting the content right.',
                 },
                 replaceContent: {
                     type: 'string',
-                    description: 'New content to replace the search content. Should maintain consistent indentation with surrounding code.',
+                    description: 'New content to replace with. Indentation will be preserved automatically.',
                 },
                 occurrence: {
                     type: 'number',
-                    description: 'Which occurrence to replace if multiple matches found (1-indexed). Default: 1 (first match). Use -1 for all occurrences (not yet supported).',
+                    description: 'Which match to replace if multiple found (1-indexed). Default: 1 (best match first). Use -1 for all (not yet supported).',
                     default: 1,
                 },
                 contextLines: {
                     type: 'number',
-                    description: 'Number of context lines to show before/after edit (default: 8)',
+                    description: 'Context lines to show before/after (default: 8)',
                     default: 8,
                 },
             },
@@ -1046,7 +1353,7 @@ export const mcpTools = [
     },
     {
         name: 'filesystem_edit',
-        description: '🔧 Line-based editing for precise line range replacements. **WHEN TO USE**: (1) Adding completely new code sections, (2) Deleting specific line ranges, (3) When you need exact line-number control. **LIMITATIONS**: Requires manual line number tracking, higher risk of boundary errors. **RECOMMENDATION**: For most edits, use filesystem_edit_search instead - it\'s safer and easier. **BEST PRACTICES**: (1) Keep edits small (≤15 lines), (2) Always read file first to get exact line numbers, (3) Double-check boundaries for brackets/tags. **SMART FEATURES**: Auto-detects bracket/tag mismatches, indentation issues, context auto-extends to show complete code blocks.',
+        description: "🔧 Line-based editing for precise control. **WHEN TO USE**: (1) Adding completely new code sections, (2) Deleting specific line ranges, (3) When search-replace is not suitable. **WORKFLOW**: (1) Use ace_text_search/ace_file_outline to locate relevant area, (2) Use filesystem_read to get exact line numbers, (3) Use THIS tool with precise line ranges. **RECOMMENDATION**: For modifying existing code, use filesystem_edit_search instead - it's safer. **BEST PRACTICES**: Keep edits small (≤15 lines), double-check line numbers, verify bracket closure.",
         inputSchema: {
             type: 'object',
             properties: {