snow-ai 0.2.12 → 0.2.13

package/dist/mcp/filesystem.js

@@ -1,7 +1,9 @@
 import { promises as fs } from 'fs';
 import * as path from 'path';
+import { execSync } from 'child_process';
 import { vscodeConnection } from '../utils/vscodeConnection.js';
 import { incrementalSnapshotManager } from '../utils/incrementalSnapshot.js';
+import { multiLanguageASTParser } from './multiLanguageASTParser.js';
 const { resolve, dirname, isAbsolute } = path;
 /**
  * Filesystem MCP Service
@@ -26,9 +28,9 @@ export class FilesystemMCPService {
             bracketBalance: {
                 curly: { open: 0, close: 0, balanced: true },
                 round: { open: 0, close: 0, balanced: true },
-                square: { open: 0, close: 0, balanced: true }
+                square: { open: 0, close: 0, balanced: true },
             },
-            indentationWarnings: []
+            indentationWarnings: [],
         };
         // Count brackets in the edited content
         const editedContent = editedLines.join('\n');
@@ -41,15 +43,18 @@ export class FilesystemMCPService {
         analysis.bracketBalance.curly.open = (cleanContent.match(/\{/g) || []).length;
         analysis.bracketBalance.curly.close = (cleanContent.match(/\}/g) || []).length;
         analysis.bracketBalance.curly.balanced =
-            analysis.bracketBalance.curly.open === analysis.bracketBalance.curly.close;
+            analysis.bracketBalance.curly.open ===
+                analysis.bracketBalance.curly.close;
         analysis.bracketBalance.round.open = (cleanContent.match(/\(/g) || []).length;
         analysis.bracketBalance.round.close = (cleanContent.match(/\)/g) || []).length;
         analysis.bracketBalance.round.balanced =
-            analysis.bracketBalance.round.open === analysis.bracketBalance.round.close;
+            analysis.bracketBalance.round.open ===
+                analysis.bracketBalance.round.close;
         analysis.bracketBalance.square.open = (cleanContent.match(/\[/g) || []).length;
         analysis.bracketBalance.square.close = (cleanContent.match(/\]/g) || []).length;
         analysis.bracketBalance.square.balanced =
-            analysis.bracketBalance.square.open === analysis.bracketBalance.square.close;
+            analysis.bracketBalance.square.open ===
+                analysis.bracketBalance.square.close;
         // HTML/JSX tag analysis (for .html, .jsx, .tsx, .vue files)
         const isMarkupFile = /\.(html|jsx|tsx|vue)$/i.test(filePath);
         if (isMarkupFile) {
@@ -82,7 +87,7 @@ export class FilesystemMCPService {
             analysis.htmlTags = {
                 unclosedTags,
                 unopenedTags,
-                balanced: unclosedTags.length === 0 && unopenedTags.length === 0
+                balanced: unclosedTags.length === 0 && unopenedTags.length === 0,
             };
         }
         // Check indentation consistency
@@ -123,14 +128,18 @@ 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(']');
+        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'
+                    : 'Edit starts with a closing bracket - ensure the opening bracket exists before this edit',
             };
         }
         return analysis;
@@ -214,7 +223,7 @@ export class FilesystemMCPService {
                     content: `Directory: ${filePath}\n\n${fileList}`,
                     startLine: 1,
                     endLine: lines.length,
-                    totalLines: lines.length
+                    totalLines: lines.length,
                 };
             }
             const content = await fs.readFile(fullPath, 'utf-8');
@@ -248,7 +257,7 @@ export class FilesystemMCPService {
                 content: partialContent,
                 startLine: start,
                 endLine: end,
-                totalLines
+                totalLines,
             };
         }
         catch (error) {
@@ -417,22 +426,26 @@ export class FilesystemMCPService {
             await incrementalSnapshotManager.backupFile(fullPath);
             // Extract the lines that will be replaced (for comparison)
             const replacedLines = lines.slice(startLine - 1, adjustedEndLine);
-            const replacedContent = replacedLines.map((line, idx) => {
+            const replacedContent = replacedLines
+                .map((line, idx) => {
                 const lineNum = startLine + idx;
                 const paddedNum = String(lineNum).padStart(String(adjustedEndLine).length, ' ');
                 return `${paddedNum}→${line}`;
-            }).join('\n');
+            })
+                .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)
             const oldContextLines = lines.slice(contextStart - 1, contextEnd);
-            const oldContent = oldContextLines.map((line, idx) => {
+            const oldContent = oldContextLines
+                .map((line, idx) => {
                 const lineNum = contextStart + idx;
                 const paddedNum = String(lineNum).padStart(String(contextEnd).length, ' ');
                 return `${paddedNum}→${line}`;
-            }).join('\n');
+            })
+                .join('\n');
             // Replace the specified lines
             const newContentLines = newContent.split('\n');
             const beforeLines = lines.slice(0, startLine - 1);
@@ -444,15 +457,49 @@ export class FilesystemMCPService {
             const newContextEnd = Math.min(newTotalLines, contextEnd + lineDifference);
             // Extract new content for context with line numbers
             const newContextLines = modifiedLines.slice(contextStart - 1, newContextEnd);
-            const newContextContent = newContextLines.map((line, idx) => {
+            const newContextContent = newContextLines
+                .map((line, idx) => {
                 const lineNum = contextStart + idx;
                 const paddedNum = String(lineNum).padStart(String(newContextEnd).length, ' ');
                 return `${paddedNum}→${line}`;
-            }).join('\n');
+            })
+                .join('\n');
             // Write the modified content back to file
             await fs.writeFile(fullPath, modifiedLines.join('\n'), 'utf-8');
-            // Analyze code structure of the edited content
-            const structureAnalysis = this.analyzeCodeStructure(modifiedLines.join('\n'), filePath, newContentLines);
+            // Format the file with Prettier after editing to ensure consistent code style
+            let finalLines = modifiedLines;
+            let finalTotalLines = newTotalLines;
+            let finalContextEnd = newContextEnd;
+            let finalContextContent = newContextContent;
+            try {
+                execSync(`npx prettier --write "${fullPath}"`, {
+                    stdio: 'pipe',
+                    encoding: 'utf-8',
+                });
+                // Re-read the file after formatting to get the formatted content
+                const formattedContent = await fs.readFile(fullPath, 'utf-8');
+                finalLines = formattedContent.split('\n');
+                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
+                const formattedContextLines = finalLines.slice(contextStart - 1, finalContextEnd);
+                finalContextContent = formattedContextLines
+                    .map((line, idx) => {
+                    const lineNum = contextStart + idx;
+                    const paddedNum = String(lineNum).padStart(String(finalContextEnd).length, ' ');
+                    return `${paddedNum}→${line}`;
+                })
+                    .join('\n');
+            }
+            catch (formatError) {
+                // If formatting fails, continue with the original content
+                // This ensures editing is not blocked by formatting issues
+                console.warn(`⚠️  Prettier formatting failed for ${filePath}, returning unformatted content:`, formatError instanceof Error ? formatError.message : 'Unknown error');
+            }
+            // 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
             let diagnostics = [];
             try {
@@ -467,15 +514,17 @@ export class FilesystemMCPService {
                 message: `✅ File edited successfully: ${filePath}\n` +
                     `   Replaced: lines ${startLine}-${adjustedEndLine} (${linesToModify} lines)\n` +
                     `   Result: ${newContentLines.length} new lines` +
-                    (smartBoundaries.extended ? `\n   📍 Context auto-extended to show complete code block (lines ${contextStart}-${newContextEnd})` : ''),
+                    (smartBoundaries.extended
+                        ? `\n   📍 Context auto-extended to show complete code block (lines ${contextStart}-${finalContextEnd})`
+                        : ''),
                 oldContent,
-                newContent: newContextContent,
+                newContent: finalContextContent,
                 replacedLines: replacedContent,
                 contextStartLine: contextStart,
-                contextEndLine: newContextEnd,
-                totalLines: newTotalLines,
+                contextEndLine: finalContextEnd,
+                totalLines: finalTotalLines,
                 linesModified: linesToModify,
-                structureAnalysis
+                structureAnalysis,
             };
             // Add diagnostics if any were found
             if (diagnostics.length > 0) {
@@ -501,15 +550,18 @@ export class FilesystemMCPService {
             const structureWarnings = [];
             // Check bracket balance
             if (!structureAnalysis.bracketBalance.curly.balanced) {
-                const diff = structureAnalysis.bracketBalance.curly.open - structureAnalysis.bracketBalance.curly.close;
+                const diff = structureAnalysis.bracketBalance.curly.open -
+                    structureAnalysis.bracketBalance.curly.close;
                 structureWarnings.push(`Curly brackets: ${diff > 0 ? `${diff} unclosed {` : `${Math.abs(diff)} extra }`}`);
             }
             if (!structureAnalysis.bracketBalance.round.balanced) {
-                const diff = structureAnalysis.bracketBalance.round.open - structureAnalysis.bracketBalance.round.close;
+                const diff = structureAnalysis.bracketBalance.round.open -
+                    structureAnalysis.bracketBalance.round.close;
                 structureWarnings.push(`Round brackets: ${diff > 0 ? `${diff} unclosed (` : `${Math.abs(diff)} extra )`}`);
             }
             if (!structureAnalysis.bracketBalance.square.balanced) {
-                const diff = structureAnalysis.bracketBalance.square.open - structureAnalysis.bracketBalance.square.close;
+                const diff = structureAnalysis.bracketBalance.square.open -
+                    structureAnalysis.bracketBalance.square.close;
                 structureWarnings.push(`Square brackets: ${diff > 0 ? `${diff} unclosed [` : `${Math.abs(diff)} extra ]`}`);
             }
             // Check HTML tags
@@ -526,7 +578,8 @@ export class FilesystemMCPService {
                 structureWarnings.push(...structureAnalysis.indentationWarnings.map(w => `Indentation: ${w}`));
             }
             // Add code block boundary warnings
-            if (structureAnalysis.codeBlockBoundary && structureAnalysis.codeBlockBoundary.suggestion) {
+            if (structureAnalysis.codeBlockBoundary &&
+                structureAnalysis.codeBlockBoundary.suggestion) {
                 structureWarnings.push(`Boundary: ${structureAnalysis.codeBlockBoundary.suggestion}`);
             }
             // Format structure warnings
@@ -552,13 +605,21 @@ export class FilesystemMCPService {
      * @param maxResults - Maximum number of results to return (default: 100)
      * @returns Search results with file paths, line numbers, and matched content
      */
-    async searchCode(query, dirPath = '.', fileExtensions = [], caseSensitive = false, maxResults = 100) {
+    async searchCode(query, dirPath = '.', fileExtensions = [], caseSensitive = false, maxResults = 100, searchMode = 'text') {
         const matches = [];
         let searchedFiles = 0;
         const fullDirPath = this.resolvePath(dirPath);
-        // Convert query to regex for flexible matching
+        // Prepare search regex based on mode
         const flags = caseSensitive ? 'g' : 'gi';
-        const searchRegex = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), flags);
+        let searchRegex = null;
+        if (searchMode === 'text') {
+            // Escape special regex characters for literal text search
+            searchRegex = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), flags);
+        }
+        else if (searchMode === 'regex') {
+            // Use query as-is for regex search
+            searchRegex = new RegExp(query, flags);
+        }
         // Recursively search files
         const searchInDirectory = async (currentPath) => {
             try {
@@ -571,7 +632,11 @@ export class FilesystemMCPService {
                     // Skip common directories that should be ignored
                     if (entry.isDirectory()) {
                         const dirName = entry.name;
-                        if (dirName === 'node_modules' || dirName === '.git' || dirName === 'dist' || dirName === 'build' || dirName.startsWith('.')) {
+                        if (dirName === 'node_modules' ||
+                            dirName === '.git' ||
+                            dirName === 'dist' ||
+                            dirName === 'build' ||
+                            dirName.startsWith('.')) {
                             continue;
                         }
                         await searchInDirectory(fullPath);
@@ -587,23 +652,56 @@ export class FilesystemMCPService {
                         searchedFiles++;
                         try {
                             const content = await fs.readFile(fullPath, 'utf-8');
-                            const lines = content.split('\n');
-                            lines.forEach((line, index) => {
-                                if (matches.length >= maxResults) {
-                                    return;
+                            // AST search mode - supports multiple languages via tree-sitter
+                            if (searchMode === 'ast') {
+                                // Check if file is supported for AST parsing
+                                if (multiLanguageASTParser.isSupported(fullPath)) {
+                                    try {
+                                        const astResults = multiLanguageASTParser.searchAST(content, fullPath, query, caseSensitive);
+                                        for (const result of astResults) {
+                                            if (matches.length >= maxResults) {
+                                                break;
+                                            }
+                                            const lineContent = content.split('\n')[result.startPosition.line - 1] ||
+                                                '';
+                                            matches.push({
+                                                filePath: path.relative(this.basePath, fullPath),
+                                                lineNumber: result.startPosition.line,
+                                                lineContent: lineContent.trim(),
+                                                column: result.startPosition.column,
+                                                matchedText: result.name,
+                                                nodeType: result.type,
+                                                nodeName: result.name,
+                                                language: result.language,
+                                            });
+                                        }
+                                    }
+                                    catch (error) {
+                                        // Skip files with AST parsing errors
+                                    }
                                 }
-                                // Reset regex for each line
-                                searchRegex.lastIndex = 0;
-                                const match = searchRegex.exec(line);
-                                if (match) {
-                                    matches.push({
-                                        filePath: path.relative(this.basePath, fullPath),
-                                        lineNumber: index + 1,
-                                        lineContent: line.trim(),
-                                        column: match.index + 1
-                                    });
-                                }
-                            });
+                            }
+                            else if (searchRegex) {
+                                // Text or Regex search mode
+                                const lines = content.split('\n');
+                                lines.forEach((line, index) => {
+                                    if (matches.length >= maxResults) {
+                                        return;
+                                    }
+                                    // Reset regex for each line
+                                    searchRegex.lastIndex = 0;
+                                    const match = searchRegex.exec(line);
+                                    if (match) {
+                                        matches.push({
+                                            filePath: path.relative(this.basePath, fullPath),
+                                            lineNumber: index + 1,
+                                            lineContent: line.trim(),
+                                            column: match.index + 1,
+                                            matchedText: match[0],
+                                        });
+                                    }
+                                });
+                            }
                         }
                         catch (error) {
                             // Skip files that cannot be read (binary files, permission issues, etc.)
@@ -620,7 +718,7 @@ export class FilesystemMCPService {
             query,
             totalMatches: matches.length,
             matches,
-            searchedFiles
+            searchedFiles,
         };
     }
     /**
@@ -663,19 +761,19 @@ export const mcpTools = [
             properties: {
                 filePath: {
                     type: 'string',
-                    description: 'Path to the file to read (or directory to list)'
+                    description: 'Path to the file to read (or directory to list)',
                 },
                 startLine: {
                     type: 'number',
-                    description: 'Starting line number (1-indexed, inclusive). Must be >= 1.'
+                    description: 'Starting line number (1-indexed, inclusive). Must be >= 1.',
                 },
                 endLine: {
                     type: 'number',
-                    description: 'Ending line number (1-indexed, inclusive). Can exceed file length (will be capped automatically).'
-                }
+                    description: 'Ending line number (1-indexed, inclusive). Can exceed file length (will be capped automatically).',
+                },
             },
-            required: ['filePath', 'startLine', 'endLine']
-        }
+            required: ['filePath', 'startLine', 'endLine'],
+        },
     },
     {
         name: 'filesystem_create',
@@ -685,20 +783,20 @@ export const mcpTools = [
             properties: {
                 filePath: {
                     type: 'string',
-                    description: 'Path where the file should be created'
+                    description: 'Path where the file should be created',
                 },
                 content: {
                     type: 'string',
-                    description: 'Content to write to the file'
+                    description: 'Content to write to the file',
                 },
                 createDirectories: {
                     type: 'boolean',
-                    description: 'Whether to create parent directories if they don\'t exist',
-                    default: true
-                }
+                    description: "Whether to create parent directories if they don't exist",
+                    default: true,
+                },
             },
-            required: ['filePath', 'content']
-        }
+            required: ['filePath', 'content'],
+        },
     },
     {
         name: 'filesystem_delete',
@@ -708,11 +806,11 @@ export const mcpTools = [
             properties: {
                 filePath: {
                     type: 'string',
-                    description: 'Path to the file to delete'
-                }
+                    description: 'Path to the file to delete',
+                },
             },
-            required: ['filePath']
-        }
+            required: ['filePath'],
+        },
     },
     {
         name: 'filesystem_list',
@@ -723,10 +821,10 @@ export const mcpTools = [
                 dirPath: {
                     type: 'string',
                     description: 'Directory path to list files from',
-                    default: '.'
-                }
-            }
-        }
+                    default: '.',
+                },
+            },
+        },
     },
     {
         name: 'filesystem_edit',
@@ -736,64 +834,70 @@ export const mcpTools = [
             properties: {
                 filePath: {
                     type: 'string',
-                    description: 'Path to the file to edit (absolute or relative)'
+                    description: 'Path to the file to edit (absolute or relative)',
                 },
                 startLine: {
                     type: 'number',
-                    description: '⚠️  CRITICAL: Starting line number (1-indexed, inclusive). MUST match exact line number from filesystem_read output. Double-check this value!'
+                    description: '⚠️  CRITICAL: Starting line number (1-indexed, inclusive). MUST match exact line number from filesystem_read output. Double-check this value!',
                 },
                 endLine: {
                     type: 'number',
-                    description: '⚠️  CRITICAL: Ending line number (1-indexed, inclusive). MUST match exact line number from filesystem_read output. 💡 TIP: Keep edits small (≤15 lines recommended) for better accuracy.'
+                    description: '⚠️  CRITICAL: Ending line number (1-indexed, inclusive). MUST match exact line number from filesystem_read output. 💡 TIP: Keep edits small (≤15 lines recommended) for better accuracy.',
                 },
                 newContent: {
                     type: 'string',
-                    description: 'New content to replace specified lines. ⚠️  Do NOT include line numbers. ⚠️  Ensure proper indentation and bracket closure. Keep changes MINIMAL and FOCUSED.'
+                    description: 'New content to replace specified lines. ⚠️  Do NOT include line numbers. ⚠️  Ensure proper indentation and bracket closure. Keep changes MINIMAL and FOCUSED.',
                 },
                 contextLines: {
                     type: 'number',
                     description: 'Number of context lines to show before/after edit for verification (default: 8)',
-                    default: 8
-                }
+                    default: 8,
+                },
             },
-            required: ['filePath', 'startLine', 'endLine', 'newContent']
-        }
+            required: ['filePath', 'startLine', 'endLine', 'newContent'],
+        },
     },
     {
         name: 'filesystem_search',
-        description: 'Search for code keywords across files in a directory. Useful for finding function definitions, variable usages, or any code patterns. Similar to VS Code\'s global search feature.',
+        description: "Search for code keywords across files in a directory. Useful for finding function definitions, variable usages, or any code patterns. Similar to VS Code's global search feature.",
         inputSchema: {
             type: 'object',
             properties: {
                 query: {
                     type: 'string',
-                    description: 'The keyword or text to search for (e.g., function name, variable name, or any code pattern)'
+                    description: 'The keyword or text to search for (e.g., function name, variable name, or any code pattern)',
                 },
                 dirPath: {
                     type: 'string',
                     description: 'Directory to search in (relative to base path or absolute). Defaults to current directory.',
-                    default: '.'
+                    default: '.',
                 },
                 fileExtensions: {
                     type: 'array',
                     items: {
-                        type: 'string'
+                        type: 'string',
                     },
                     description: 'Array of file extensions to search (e.g., [".ts", ".tsx", ".js"]). If empty, searches all text files.',
-                    default: []
+                    default: [],
                 },
                 caseSensitive: {
                     type: 'boolean',
                     description: 'Whether the search should be case-sensitive',
-                    default: false
+                    default: false,
                 },
                 maxResults: {
                     type: 'number',
                     description: 'Maximum number of results to return',
-                    default: 100
-                }
+                    default: 100,
+                },
+                searchMode: {
+                    type: 'string',
+                    enum: ['text', 'regex', 'ast'],
+                    description: 'Search mode: "text" for literal text search (default), "regex" for regular expression search, "ast" for AST-based semantic search (supports function/class/variable names)',
+                    default: 'text',
+                },
             },
-            required: ['query']
-        }
-    }
+            required: ['query'],
+        },
+    },
 ];

package/dist/mcp/multiLanguageASTParser.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Supported programming languages for AST parsing
+ */
+export type SupportedLanguage = 'javascript' | 'typescript' | 'tsx' | 'python' | 'java' | 'go' | 'cpp' | 'c' | 'csharp' | 'rust' | 'ruby' | 'php';
+/**
+ * AST node result with metadata
+ */
+export interface ASTNodeResult {
+    name: string;
+    type: string;
+    startPosition: {
+        line: number;
+        column: number;
+    };
+    endPosition: {
+        line: number;
+        column: number;
+    };
+    text: string;
+    language: SupportedLanguage;
+}
+/**
+ * Multi-language AST parser using tree-sitter
+ * Supports JavaScript, TypeScript, Python, Java, Go, C/C++, C#, Rust, Ruby, PHP
+ */
+export declare class MultiLanguageASTParser {
+    private parsers;
+    private languageConfigs;
+    constructor();
+    /**
+     * Initialize language configurations
+     */
+    private initializeLanguageConfigs;
+    /**
+     * Initialize parsers for all supported languages
+     */
+    private initializeParsers;
+    /**
+     * Detect language from file extension
+     */
+    detectLanguage(filePath: string): SupportedLanguage | null;
+    /**
+     * Parse source code and search for nodes matching the query
+     */
+    searchAST(sourceCode: string, filePath: string, query: string, caseSensitive?: boolean): ASTNodeResult[];
+    /**
+     * Extract the name/identifier from an AST node based on language
+     */
+    private extractNodeName;
+    /**
+     * Recursively find the first identifier node
+     */
+    private findIdentifier;
+    /**
+     * Get supported file extensions
+     */
+    getSupportedExtensions(): string[];
+    /**
+     * Check if a file is supported for AST parsing
+     */
+    isSupported(filePath: string): boolean;
+    /**
+     * Get node types for a specific language
+     */
+    getNodeTypes(language: SupportedLanguage): string[];
+}
+export declare const multiLanguageASTParser: MultiLanguageASTParser;