snow-ai 0.2.25 → 0.2.26

package/dist/mcp/filesystem.js

@@ -2,8 +2,10 @@ import { promises as fs } from 'fs';
 import * as path from 'path';
 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);
 /**
@@ -50,7 +52,7 @@ export class FilesystemMCPService {
      * This normalizes whitespace first to avoid false negatives from spacing differences
      * Returns a value between 0 (completely different) and 1 (identical)
      */
-    calculateSimilarity(str1, str2) {
+    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);
@@ -61,52 +63,89 @@ export class FilesystemMCPService {
             return len2 === 0 ? 1 : 0;
         if (len2 === 0)
             return 0;
-        // Use Levenshtein distance for better similarity calculation
+        // Quick length check - if lengths differ too much, similarity can't be above threshold
         const maxLen = Math.max(len1, len2);
-        const distance = this.levenshteinDistance(norm1, norm2);
+        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
+     * 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) {
+    levenshteinDistance(str1, str2, maxDistance = Infinity) {
         const len1 = str1.length;
         const len2 = str2.length;
-        // Create distance matrix
-        const matrix = [];
-        for (let i = 0; i <= len1; i++) {
-            matrix[i] = [i];
-        }
-        for (let j = 0; j <= len2; j++) {
-            matrix[0][j] = j;
+        // 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;
         }
-        // Fill matrix
+        // 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;
-                matrix[i][j] = Math.min(matrix[i - 1][j] + 1, // deletion
-                matrix[i][j - 1] + 1, // insertion
-                matrix[i - 1][j - 1] + cost);
+                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 matrix[len1][len2];
+        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, ' ');
-        // Try to find candidates by sliding window
+        // 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);
+            const similarity = this.calculateSimilarity(searchContent, candidateContent, threshold);
             // Only consider candidates with >50% similarity
-            if (similarity > 0.5) {
+            if (similarity > threshold) {
                 candidates.push({
                     startLine: i + 1,
                     endLine: i + searchLines.length,
@@ -115,6 +154,14 @@ export class FilesystemMCPService {
                         .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
@@ -253,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;
     }
     /**
@@ -328,7 +360,7 @@ export class FilesystemMCPService {
     }
     /**
      * Get the content of a file with optional line range
-     * @param filePath - Path to the file (relative to base path or absolute)
+     * @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
@@ -336,6 +368,76 @@ export class FilesystemMCPService {
      */
     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)) {
@@ -544,7 +646,7 @@ export class FilesystemMCPService {
      * @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) {
@@ -558,22 +660,39 @@ export class FilesystemMCPService {
             const content = await fs.readFile(fullPath, 'utf-8');
             const lines = content.split('\n');
             // Normalize line endings
-            const normalizedSearch = searchContent
+            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
-            const searchLines = normalizedSearch.split('\n');
+            let searchLines = normalizedSearch.split('\n');
             const contentLines = normalizedContent.split('\n');
             // Find all matches using smart fuzzy matching (auto-handles whitespace)
             const matches = [];
-            const threshold = 0.75; // Lower threshold for better tolerance
+            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++) {
+                // 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;
+                    }
+                }
+                // Full candidate check
                 const candidateLines = contentLines.slice(i, i + searchLines.length);
                 const candidateContent = candidateLines.join('\n');
-                const similarity = this.calculateSimilarity(normalizedSearch, candidateContent);
+                const similarity = this.calculateSimilarity(normalizedSearch, candidateContent, threshold);
                 // Accept matches above threshold
                 if (similarity >= threshold) {
                     matches.push({
@@ -581,47 +700,89 @@ export class FilesystemMCPService {
                         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;
+                    }
                 }
             }
             // Sort by similarity descending (best match first)
             matches.sort((a, b) => b.similarity - a.similarity);
-            // Handle no matches with enhanced error message
+            // Handle no matches: Try escape correction before giving up
             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: 75%)\n\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`;
+                // 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,
+                            });
                         }
                     }
-                    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`;
+                    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'));
+                    }
                 }
-                else {
-                    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`;
+                // 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);
                 }
-                throw new Error(errorMessage);
             }
             // Handle occurrence selection
             let selectedMatch;
@@ -710,14 +871,18 @@ export class FilesystemMCPService {
             // 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 = {
@@ -791,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 => {
@@ -818,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) {
@@ -924,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` +
@@ -1007,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`;
@@ -1056,47 +1217,36 @@ export class FilesystemMCPService {
 }
 // Export a default instance
 export const filesystemService = new FilesystemMCPService();
-/**
- * MCP Tool definitions for integration
- *
- * 🎯 **RECOMMENDED WORKFLOW FOR AI AGENTS**:
- *
- * 1️⃣ **SEARCH FIRST** (DON'T skip this!):
- *    - Use ace_text_search() to find code patterns/strings
- *    - Use ace_search_symbols() to find functions/classes by name
- *    - Use ace_file_outline() to understand file structure
- *
- * 2️⃣ **READ STRATEGICALLY** (Only after search):
- *    - Use filesystem_read() WITHOUT line numbers to read entire file
- *    - OR use filesystem_read(filePath, startLine, endLine) to read specific range
- *    - ⚠️ AVOID reading files line-by-line from top - wastes tokens!
- *
- * 3️⃣ **EDIT SAFELY**:
- *    - PREFER filesystem_edit_search() for modifying existing code (no line counting!)
- *    - Use filesystem_edit() only for adding new code or when search-replace doesn't fit
- *
- * 📊 **TOKEN EFFICIENCY**:
- *    - ❌ BAD: Read file top-to-bottom, repeat reading, blind scanning
- *    - ✅ GOOD: Search → Targeted read → Edit with context
- */
 export const mcpTools = [
     {
         name: 'filesystem_read',
-        description: '📖 Read file content with line numbers. ⚠️ **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, or specify startLine/endLine for partial reads. Returns content with line numbers (format: "123→code") for precise editing.',
+        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: 'Optional: Starting line number (1-indexed). Omit to read from line 1.',
+                    description: 'Optional: Starting line number (1-indexed). Omit to read from line 1. Applied to all files.',
                 },
                 endLine: {
                     type: 'number',
-                    description: 'Optional: Ending line number (1-indexed). Omit to read to end of file.',
+                    description: 'Optional: Ending line number (1-indexed). Omit to read to end of file. Applied to all files.',
                 },
             },
             required: ['filePath'],

package/dist/mcp/ideDiagnostics.d.ts

@@ -0,0 +1,36 @@
+import { type Diagnostic } from '../utils/vscodeConnection.js';
+/**
+ * IDE Diagnostics MCP Service
+ * Provides access to diagnostics (errors, warnings, hints) from connected IDE
+ * Supports both VSCode and JetBrains IDEs
+ */
+export declare class IdeDiagnosticsMCPService {
+    /**
+     * Get diagnostics for a specific file from the connected IDE
+     * @param filePath - Absolute path to the file to get diagnostics for
+     * @returns Promise that resolves with array of diagnostics
+     */
+    getDiagnostics(filePath: string): Promise<Diagnostic[]>;
+    /**
+     * Format diagnostics into human-readable text
+     * @param diagnostics - Array of diagnostics to format
+     * @param filePath - Path to the file (for display)
+     * @returns Formatted string
+     */
+    formatDiagnostics(diagnostics: Diagnostic[], filePath: string): string;
+}
+export declare const ideDiagnosticsService: IdeDiagnosticsMCPService;
+export declare const mcpTools: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            filePath: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+}[];