snow-ai 0.3.28 → 0.3.29

package/dist/hooks/useConversation.js

@@ -515,8 +515,10 @@ export async function handleConversationWithTools(options) {
                         if (subAgentMessage.message.type === 'tool_calls') {
                             const toolCalls = subAgentMessage.message.tool_calls;
                             if (toolCalls && toolCalls.length > 0) {
-                                // Add tool call messages for each tool
-                                const toolMessages = toolCalls.map((toolCall) => {
+                                // Add tool call messages for each tool (only for time-consuming tools)
+                                const toolMessages = toolCalls
+                                    .filter((toolCall) => isToolNeedTwoStepDisplay(toolCall.function.name))
+                                    .map((toolCall) => {
                                     const toolDisplay = formatToolCallMessage(toolCall);
                                     let toolArgs;
                                     try {
@@ -543,16 +545,21 @@ export async function handleConversationWithTools(options) {
                                         },
                                         subAgentInternal: true, // Mark as internal sub-agent message
                                     };
-                                    // Save to session as 'assistant' role for API compatibility
-                                    const sessionMsg = {
-                                        role: 'assistant',
-                                        content: `⚇⚡ ${toolDisplay.toolName}`,
-                                        subAgentInternal: true,
-                                        tool_calls: [toolCall],
-                                    };
-                                    saveMessage(sessionMsg).catch(err => console.error('Failed to save sub-agent tool call:', err));
                                     return uiMsg;
                                 });
+                                // Save all tool calls to session (regardless of display type)
+                                const sessionMsg = {
+                                    role: 'assistant',
+                                    content: toolCalls
+                                        .map((tc) => {
+                                        const display = formatToolCallMessage(tc);
+                                        return `⚇⚡ ${display.toolName}`;
+                                    })
+                                        .join(', '),
+                                    subAgentInternal: true,
+                                    tool_calls: toolCalls,
+                                };
+                                saveMessage(sessionMsg).catch(err => console.error('Failed to save sub-agent tool call:', err));
                                 return [...prev, ...toolMessages];
                             }
                         }

package/dist/mcp/filesystem.d.ts

@@ -10,8 +10,19 @@ export declare class FilesystemMCPService {
      */
     private readonly prettierSupportedExtensions;
     constructor(basePath?: string);
+    /**
+     * Extract relevant symbol information for a specific line range
+     * This provides context that helps AI make more accurate modifications
+     * @param symbols - All symbols in the file
+     * @param startLine - Start line of the range
+     * @param endLine - End line of the range
+     * @param _totalLines - Total lines in the file (reserved for future use)
+     * @returns Formatted string with relevant symbol information
+     */
+    private extractRelevantSymbols;
     /**
      * Get the content of a file with optional line range
+     * Enhanced with symbol information for better AI context
      * @param filePath - Path to the file (relative to base path or absolute) or array of file paths or array of file config objects
      * @param startLine - Starting line number (1-indexed, inclusive, optional - defaults to 1). Used for single file or as default for array of strings
      * @param endLine - Ending line number (1-indexed, inclusive, optional - defaults to file end). Used for single file or as default for array of strings

package/dist/mcp/filesystem.js

@@ -11,6 +11,8 @@ import { calculateSimilarity, normalizeForDisplay, } from './utils/filesystem/si
 import { analyzeCodeStructure, findSmartContextBoundaries, } from './utils/filesystem/code-analysis.utils.js';
 import { findClosestMatches, generateDiffMessage, } from './utils/filesystem/match-finder.utils.js';
 import { parseEditBySearchParams, parseEditByLineParams, executeBatchOperation, } from './utils/filesystem/batch-operations.utils.js';
+// ACE Code Search utilities for symbol parsing
+import { parseFileSymbols } from './utils/aceCodeSearch/symbol.utils.js';
 const { resolve, dirname, isAbsolute } = path;
 const execAsync = promisify(exec);
 /**
@@ -52,8 +54,76 @@ export class FilesystemMCPService {
         });
         this.basePath = resolve(basePath);
     }
+    /**
+     * Extract relevant symbol information for a specific line range
+     * This provides context that helps AI make more accurate modifications
+     * @param symbols - All symbols in the file
+     * @param startLine - Start line of the range
+     * @param endLine - End line of the range
+     * @param _totalLines - Total lines in the file (reserved for future use)
+     * @returns Formatted string with relevant symbol information
+     */
+    extractRelevantSymbols(symbols, startLine, endLine, _totalLines) {
+        if (symbols.length === 0) {
+            return '';
+        }
+        // Categorize symbols
+        const imports = symbols.filter(s => s.type === 'import');
+        const exports = symbols.filter(s => s.type === 'export');
+        // Symbols within the requested range
+        const symbolsInRange = symbols.filter(s => s.line >= startLine && s.line <= endLine);
+        // Symbols defined before the range that might be referenced
+        const symbolsBeforeRange = symbols.filter(s => s.line < startLine);
+        // Build context information
+        const parts = [];
+        // Always include imports (crucial for understanding dependencies)
+        if (imports.length > 0) {
+            const importList = imports
+                .slice(0, 10) // Limit to avoid excessive tokens
+                .map(s => `  • ${s.name} (line ${s.line})`)
+                .join('\n');
+            parts.push(`📦 Imports:\n${importList}`);
+        }
+        // Symbols defined in the current range
+        if (symbolsInRange.length > 0) {
+            const rangeSymbols = symbolsInRange
+                .slice(0, 15)
+                .map(s => `  • ${s.type}: ${s.name} (line ${s.line})${s.signature ? ` - ${s.signature.slice(0, 60)}` : ''}`)
+                .join('\n');
+            parts.push(`🎯 Symbols in this range:\n${rangeSymbols}`);
+        }
+        // Key definitions before this range (that might be referenced)
+        if (symbolsBeforeRange.length > 0 && startLine > 1) {
+            const relevantBefore = symbolsBeforeRange
+                .filter(s => s.type === 'function' || s.type === 'class')
+                .slice(-5) // Last 5 before the range
+                .map(s => `  • ${s.type}: ${s.name} (line ${s.line})`)
+                .join('\n');
+            if (relevantBefore) {
+                parts.push(`⬆️ Key definitions above:\n${relevantBefore}`);
+            }
+        }
+        // Exports (important for understanding module interface)
+        if (exports.length > 0) {
+            const exportList = exports
+                .slice(0, 10)
+                .map(s => `  • ${s.name} (line ${s.line})`)
+                .join('\n');
+            parts.push(`📤 Exports:\n${exportList}`);
+        }
+        if (parts.length === 0) {
+            return '';
+        }
+        return ('\n\n' +
+            '='.repeat(60) +
+            '\n📚 SYMBOL INDEX & DEFINITIONS:\n' +
+            '='.repeat(60) +
+            '\n' +
+            parts.join('\n\n'));
+    }
     /**
      * Get the content of a file with optional line range
+     * Enhanced with symbol information for better AI context
      * @param filePath - Path to the file (relative to base path or absolute) or array of file paths or array of file config objects
      * @param startLine - Starting line number (1-indexed, inclusive, optional - defaults to 1). Used for single file or as default for array of strings
      * @param endLine - Ending line number (1-indexed, inclusive, optional - defaults to file end). Used for single file or as default for array of strings
@@ -127,7 +197,18 @@ export class FilesystemMCPService {
                             const lineNum = start + index;
                             return `${lineNum}→${line}`;
                         });
-                        const fileContent = `📄 ${file} (lines ${start}-${end}/${totalLines})\n${numberedLines.join('\n')}`;
+                        let fileContent = `📄 ${file} (lines ${start}-${end}/${totalLines})\n${numberedLines.join('\n')}`;
+                        // Parse and append symbol information
+                        try {
+                            const symbols = await parseFileSymbols(fullPath, content, this.basePath);
+                            const symbolInfo = this.extractRelevantSymbols(symbols, start, end, totalLines);
+                            if (symbolInfo) {
+                                fileContent += symbolInfo;
+                            }
+                        }
+                        catch {
+                            // Silently fail symbol parsing
+                        }
                         allContents.push(fileContent);
                         filesData.push({
                             path: file,
@@ -197,7 +278,19 @@ export class FilesystemMCPService {
                 const lineNum = start + index;
                 return `${lineNum}→${line}`;
             });
-            const partialContent = numberedLines.join('\n');
+            let partialContent = numberedLines.join('\n');
+            // Parse and append symbol information to provide better context for AI
+            try {
+                const symbols = await parseFileSymbols(fullPath, content, this.basePath);
+                const symbolInfo = this.extractRelevantSymbols(symbols, start, end, totalLines);
+                if (symbolInfo) {
+                    partialContent += symbolInfo;
+                }
+            }
+            catch (error) {
+                // Silently fail symbol parsing - don't block file reading
+                // This is optional context enhancement, not critical
+            }
             return {
                 content: partialContent,
                 startLine: start,

package/dist/mcp/utils/aceCodeSearch/language.utils.js

@@ -6,80 +6,399 @@
  */
 export const LANGUAGE_CONFIG = {
     typescript: {
-        extensions: ['.ts', '.tsx'],
+        extensions: ['.ts', '.tsx', '.mts', '.cts'],
         parser: 'typescript',
         symbolPatterns: {
-            function: /(?:export\s+)?(?:async\s+)?function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>/,
-            class: /(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/,
-            variable: /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=/,
-            import: /import\s+(?:{[^}]+}|\w+)\s+from\s+['"]([^'"]+)['"]/,
-            export: /export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type|enum)\s+(\w+)/,
+            function: /(?:export\s+)?(?:async\s+)?(?:function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>)|(?:@\w+\s+)*(?:public|private|protected|static)?\s*(?:async)?\s*(\w+)\s*[<(]/,
+            class: /(?:export\s+)?(?:abstract\s+)?(?:class|interface)\s+(\w+)|(?:export\s+)?type\s+(\w+)\s*=|(?:export\s+)?enum\s+(\w+)|(?:export\s+)?namespace\s+(\w+)/,
+            variable: /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*(?::|=)|(?:@\w+\s+)*(?:public|private|protected|readonly|static)?\s+(\w+)\s*[?:]/,
+            import: /import\s+(?:type\s+)?(?:{[^}]+}|\w+|\*\s+as\s+\w+)\s+from\s+['"]([^'"]+)['"]/,
+            export: /export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type|enum|namespace|abstract\s+class)\s+(\w+)/,
         },
     },
     javascript: {
-        extensions: ['.js', '.jsx', '.mjs', '.cjs'],
+        extensions: ['.js', '.jsx', '.mjs', '.cjs', '.es', '.es6'],
         parser: 'javascript',
         symbolPatterns: {
-            function: /(?:export\s+)?(?:async\s+)?function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>/,
+            function: /(?:export\s+)?(?:async\s+)?(?:function\s*\*?\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:function\s*\*?\s*)?(?:\([^)]*\)\s*=>|\([^)]*\)\s*\{))|(\w+)\s*\([^)]*\)\s*\{/,
             class: /(?:export\s+)?class\s+(\w+)/,
             variable: /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=/,
-            import: /import\s+(?:{[^}]+}|\w+)\s+from\s+['"]([^'"]+)['"]/,
+            import: /import\s+(?:{[^}]+}|\w+|\*\s+as\s+\w+)\s+from\s+['"]([^'"]+)['"]/,
             export: /export\s+(?:default\s+)?(?:class|function|const|let|var)\s+(\w+)/,
         },
     },
     python: {
-        extensions: ['.py', '.pyx', '.pyi'],
+        extensions: ['.py', '.pyx', '.pyi', '.pyw', '.pyz'],
         parser: 'python',
         symbolPatterns: {
-            function: /def\s+(\w+)\s*\(/,
-            class: /class\s+(\w+)\s*[(:]/,
-            variable: /(\w+)\s*=\s*[^=]/,
-            import: /(?:from\s+[\w.]+\s+)?import\s+([\w, ]+)/,
-            export: /^(\w+)\s*=\s*/, // Python doesn't have explicit exports
+            function: /(?:@\w+\s+)*(?:async\s+)?def\s+(\w+)\s*\(/,
+            class: /(?:@\w+\s+)*class\s+(\w+)\s*[(:]/,
+            variable: /^(?:[\t ]*)([\w_][\w\d_]*)\s*(?::.*)?=\s*(?![=\s])|^([\w_][\w\d_]*)\s*:\s*(?!.*=)/m,
+            import: /(?:from\s+([\w.]+)\s+import\s+[\w, *]+|import\s+([\w.]+(?:\s+as\s+\w+)?))/,
+            export: /^(?:__all__\s*=|def\s+(\w+)|class\s+(\w+))/, // Python exports via __all__ or top-level
         },
     },
     go: {
         extensions: ['.go'],
         parser: 'go',
         symbolPatterns: {
-            function: /func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/,
-            class: /type\s+(\w+)\s+struct/,
-            variable: /(?:var|const)\s+(\w+)\s+/,
-            import: /import\s+(?:"([^"]+)"|[(]([^)]+)[)])/,
-            export: /^(?:func|type|var|const)\s+([A-Z]\w+)/, // Go exports start with capital letter
+            function: /func\s+(?:\([^)]+\)\s+)?(\w+)\s*[<(]/,
+            class: /type\s+(\w+)\s+(?:struct|interface)/,
+            variable: /(?:var|const)\s+(\w+)\s+[\w\[\]*{]|(?:var|const)\s+\(\s*(\w+)/,
+            import: /import\s+(?:"([^"]+)"|_\s+"([^"]+)"|\w+\s+"([^"]+)")/,
+            export: /^(?:func|type|var|const)\s+([A-Z]\w+)|^type\s+([A-Z]\w+)\s+(?:struct|interface)/, // Go exports start with capital letter
         },
     },
     rust: {
         extensions: ['.rs'],
         parser: 'rust',
         symbolPatterns: {
-            function: /(?:pub\s+)?(?:async\s+)?fn\s+(\w+)\s*[<(]/,
-            class: /(?:pub\s+)?struct\s+(\w+)|(?:pub\s+)?enum\s+(\w+)|(?:pub\s+)?trait\s+(\w+)/,
-            variable: /(?:pub\s+)?(?:static|const)\s+(\w+)\s*:/,
-            import: /use\s+([^;]+);/,
-            export: /pub\s+(?:fn|struct|enum|trait|const|static)\s+(\w+)/,
+            function: /(?:pub(?:\s*\([^)]+\))?\s+)?(?:unsafe\s+)?(?:async\s+)?(?:const\s+)?(?:extern\s+(?:"[^"]+"\s+)?)?fn\s+(\w+)\s*[<(]/,
+            class: /(?:pub(?:\s*\([^)]+\))?\s+)?(?:struct|enum|trait|union|type)\s+(\w+)|impl(?:\s+<[^>]+>)?\s+(?:\w+::)*(\w+)/,
+            variable: /(?:pub(?:\s*\([^)]+\))?\s+)?(?:static|const|mut)?\s*(?:let\s+(?:mut\s+)?)?(\w+)\s*[:=]/,
+            import: /use\s+([^;]+);|extern\s+crate\s+(\w+);/,
+            export: /pub(?:\s*\([^)]+\))?\s+(?:fn|struct|enum|trait|const|static|type|mod|use)\s+(\w+)/,
         },
     },
     java: {
         extensions: ['.java'],
         parser: 'java',
         symbolPatterns: {
-            function: /(?:public|private|protected|static|\s)+[\w<>\[\]]+\s+(\w+)\s*\([^)]*\)\s*\{/,
-            class: /(?:public|private|protected)?\s*(?:abstract|final)?\s*class\s+(\w+)/,
-            variable: /(?:public|private|protected|static|final|\s)+[\w<>\[\]]+\s+(\w+)\s*[=;]/,
-            import: /import\s+([\w.]+);/,
-            export: /public\s+(?:class|interface|enum)\s+(\w+)/,
+            function: /(?:@\w+\s+)*(?:public|private|protected|static|final|synchronized|native|abstract|\s)+[\w<>\[\]]+\s+(\w+)\s*\([^)]*\)\s*(?:throws\s+[\w,\s]+)?\s*[{;]/,
+            class: /(?:@\w+\s+)*(?:public|private|protected)?\s*(?:abstract|final|static)?\s*(?:class|interface|enum|record|@interface)\s+(\w+)/,
+            variable: /(?:@\w+\s+)*(?:public|private|protected|static|final|transient|volatile|\s)+[\w<>\[\]]+\s+(\w+)\s*[=;]/,
+            import: /import\s+(?:static\s+)?([\w.*]+);/,
+            export: /public\s+(?:class|interface|enum|record|@interface)\s+(\w+)/,
         },
     },
     csharp: {
         extensions: ['.cs'],
         parser: 'csharp',
         symbolPatterns: {
-            function: /(?:public|private|protected|internal|static|\s)+[\w<>\[\]]+\s+(\w+)\s*\([^)]*\)\s*\{/,
-            class: /(?:public|private|protected|internal)?\s*(?:abstract|sealed|static)?\s*class\s+(\w+)/,
-            variable: /(?:public|private|protected|internal|static|readonly|\s)+[\w<>\[\]]+\s+(\w+)\s*[=;]/,
-            import: /using\s+([\w.]+);/,
-            export: /public\s+(?:class|interface|enum|struct)\s+(\w+)/,
+            function: /(?:\[[\w\s,()]+\]\s+)*(?:public|private|protected|internal|static|virtual|override|abstract|async|\s)+[\w<>\[\]?]+\s+(\w+)\s*[<(]/,
+            class: /(?:\[[\w\s,()]+\]\s+)*(?:public|private|protected|internal)?\s*(?:abstract|sealed|static|partial)?\s*(?:class|interface|struct|record|enum)\s+(\w+)/,
+            variable: /(?:\[[\w\s,()]+\]\s+)*(?:public|private|protected|internal|static|readonly|const|volatile|\s)+[\w<>\[\]?]+\s+(\w+)\s*[{=;]|(?:public|private|protected|internal)?\s*[\w<>\[\]?]+\s+(\w+)\s*\{\s*get/,
+            import: /using\s+(?:static\s+)?([\w.]+);/,
+            export: /public\s+(?:class|interface|enum|struct|record|delegate)\s+(\w+)/,
+        },
+    },
+    c: {
+        extensions: ['.c', '.h'],
+        parser: 'c',
+        symbolPatterns: {
+            function: /(?:static|extern|inline)?\s*[\w\s\*]+\s+(\w+)\s*\([^)]*\)\s*\{/,
+            class: /(?:struct|union|enum)\s+(\w+)\s*\{/,
+            variable: /(?:extern|static|const)?\s*[\w\s\*]+\s+(\w+)\s*[=;]/,
+            import: /#include\s+[<"]([^>"]+)[>"]/,
+            export: /^[\w\s\*]+\s+(\w+)\s*\([^)]*\)\s*;/, // Function declarations
+        },
+    },
+    cpp: {
+        extensions: ['.cpp', '.cc', '.cxx', '.hpp', '.hh', '.hxx', '.h++', '.c++'],
+        parser: 'cpp',
+        symbolPatterns: {
+            function: /(?:static|extern|inline|virtual|explicit|constexpr)?\s*[\w\s\*&:<>,]+\s+(\w+)\s*\([^)]*\)\s*(?:const)?\s*(?:override)?\s*\{/,
+            class: /(?:class|struct|union|enum\s+class|enum\s+struct)\s+(\w+)(?:\s*:\s*(?:public|private|protected)\s+[\w,\s<>]+)?\s*\{/,
+            variable: /(?:extern|static|const|constexpr|inline)?\s*[\w\s\*&:<>,]+\s+(\w+)\s*[=;]/,
+            import: /#include\s+[<"]([^>"]+)[>"]/,
+            export: /^[\w\s\*&:<>,]+\s+(\w+)\s*\([^)]*\)\s*;/,
+        },
+    },
+    php: {
+        extensions: ['.php', '.phtml', '.php3', '.php4', '.php5', '.phps'],
+        parser: 'php',
+        symbolPatterns: {
+            function: /(?:public|private|protected|static)?\s*function\s+(\w+)\s*\(/,
+            class: /(?:abstract|final)?\s*class\s+(\w+)(?:\s+extends\s+\w+)?(?:\s+implements\s+[\w,\s]+)?\s*\{/,
+            variable: /(?:public|private|protected|static)?\s*\$(\w+)\s*[=;]/,
+            import: /(?:require|require_once|include|include_once)\s*[('"]([^'"]+)['"]/,
+            export: /^(?:public\s+)?(?:function|class|interface|trait)\s+(\w+)/,
+        },
+    },
+    ruby: {
+        extensions: ['.rb', '.rake', '.gemspec', '.ru', '.rbw'],
+        parser: 'ruby',
+        symbolPatterns: {
+            function: /def\s+(?:self\.)?(\w+)/,
+            class: /class\s+(\w+)(?:\s+<\s+[\w:]+)?/,
+            variable: /(?:@|@@|\$)?(\w+)\s*=(?!=)/,
+            import: /require(?:_relative)?\s+['"]([^'"]+)['"]/,
+            export: /module_function\s+:(\w+)|^def\s+(\w+)/, // Ruby's module exports
+        },
+    },
+    swift: {
+        extensions: ['.swift'],
+        parser: 'swift',
+        symbolPatterns: {
+            function: /(?:public|private|internal|fileprivate|open)?\s*(?:static|class)?\s*func\s+(\w+)\s*[<(]/,
+            class: /(?:public|private|internal|fileprivate|open)?\s*(?:final)?\s*(?:class|struct|enum|protocol|actor)\s+(\w+)/,
+            variable: /(?:public|private|internal|fileprivate|open)?\s*(?:static|class)?\s*(?:let|var)\s+(\w+)\s*[:=]/,
+            import: /import\s+(?:class|struct|enum|protocol)?\s*([\w.]+)/,
+            export: /public\s+(?:func|class|struct|enum|protocol|var|let)\s+(\w+)/,
+        },
+    },
+    kotlin: {
+        extensions: ['.kt', '.kts'],
+        parser: 'kotlin',
+        symbolPatterns: {
+            function: /(?:public|private|protected|internal)?\s*(?:suspend|inline|infix|operator)?\s*fun\s+(\w+)\s*[<(]/,
+            class: /(?:public|private|protected|internal)?\s*(?:abstract|open|final|sealed|data|inline|value)?\s*(?:class|interface|object|enum\s+class)\s+(\w+)/,
+            variable: /(?:public|private|protected|internal)?\s*(?:const)?\s*(?:val|var)\s+(\w+)\s*[:=]/,
+            import: /import\s+([\w.]+)/,
+            export: /^(?:public\s+)?(?:fun|class|interface|object|val|var)\s+(\w+)/,
+        },
+    },
+    dart: {
+        extensions: ['.dart'],
+        parser: 'dart',
+        symbolPatterns: {
+            function: /(?:static|abstract|external)?\s*[\w<>?,\s]+\s+(\w+)\s*\([^)]*\)\s*(?:async|sync\*)?\s*\{/,
+            class: /(?:abstract)?\s*class\s+(\w+)(?:\s+extends\s+[\w<>]+)?(?:\s+with\s+[\w,\s<>]+)?(?:\s+implements\s+[\w,\s<>]+)?\s*\{/,
+            variable: /(?:static|final|const|late)?\s*(?:var|[\w<>?,\s]+)\s+(\w+)\s*[=;]/,
+            import: /import\s+['"]([^'"]+)['"]/,
+            export: /^(?:class|abstract\s+class|enum|mixin)\s+(\w+)/,
+        },
+    },
+    shell: {
+        extensions: ['.sh', '.bash', '.zsh', '.ksh', '.fish'],
+        parser: 'shell',
+        symbolPatterns: {
+            function: /(?:function\s+)?(\w+)\s*\(\s*\)\s*\{/,
+            class: /^$/, // Shell doesn't have classes
+            variable: /(?:export\s+)?(\w+)=/,
+            import: /(?:source|\.)\s+([^\s;]+)/,
+            export: /export\s+(?:function\s+)?(\w+)/,
+        },
+    },
+    scala: {
+        extensions: ['.scala', '.sc'],
+        parser: 'scala',
+        symbolPatterns: {
+            function: /def\s+(\w+)\s*[:\[(]/,
+            class: /(?:sealed|abstract|final|implicit)?\s*(?:class|trait|object|case\s+class|case\s+object)\s+(\w+)/,
+            variable: /(?:val|var|lazy\s+val)\s+(\w+)\s*[:=]/,
+            import: /import\s+([\w.{},\s=>]+)/,
+            export: /^(?:object|class|trait)\s+(\w+)/,
+        },
+    },
+    r: {
+        extensions: ['.r', '.R', '.rmd', '.Rmd'],
+        parser: 'r',
+        symbolPatterns: {
+            function: /(\w+)\s*<-\s*function\s*\(|^(\w+)\s*=\s*function\s*\(/,
+            class: /setClass\s*\(\s*['"](\w+)['"]/,
+            variable: /(\w+)\s*(?:<-|=)\s*(?!function)/,
+            import: /(?:library|require)\s*\(\s*['"]?(\w+)['"]?\s*\)/,
+            export: /^(\w+)\s*<-\s*function/, // R exports at top level
+        },
+    },
+    lua: {
+        extensions: ['.lua'],
+        parser: 'lua',
+        symbolPatterns: {
+            function: /(?:local\s+)?function\s+(?:[\w.]+[.:])?(\w+)\s*\(/,
+            class: /(\w+)\s*=\s*\{\s*\}|(\w+)\s*=\s*class\s*\(/,
+            variable: /(?:local\s+)?(\w+)\s*=/,
+            import: /require\s*\(?['"]([^'"]+)['"]\)?/,
+            export: /return\s+(\w+)|module\s*\(\s*['"]([^'"]+)['"]/,
+        },
+    },
+    perl: {
+        extensions: ['.pl', '.pm', '.t', '.pod'],
+        parser: 'perl',
+        symbolPatterns: {
+            function: /sub\s+(\w+)\s*\{/,
+            class: /package\s+([\w:]+)\s*;/,
+            variable: /(?:my|our|local)\s*[\$@%](\w+)\s*=/,
+            import: /(?:use|require)\s+([\w:]+)/,
+            export: /^sub\s+(\w+)|our\s+[\$@%](\w+)/,
+        },
+    },
+    objectivec: {
+        extensions: ['.m', '.mm', '.h'],
+        parser: 'objectivec',
+        symbolPatterns: {
+            function: /[-+]\s*\([^)]+\)\s*(\w+)(?::|;|\s*\{)/,
+            class: /@(?:interface|implementation|protocol)\s+(\w+)/,
+            variable: /@property\s+[^;]+\s+(\w+);|^[\w\s\*]+\s+(\w+)\s*[=;]/,
+            import: /#import\s+[<"]([^>"]+)[>"]/,
+            export: /@interface\s+(\w+)|@protocol\s+(\w+)/,
+        },
+    },
+    haskell: {
+        extensions: ['.hs', '.lhs'],
+        parser: 'haskell',
+        symbolPatterns: {
+            function: /^(\w+)\s*::/,
+            class: /(?:class|instance)\s+(\w+)/,
+            variable: /^(\w+)\s*=/,
+            import: /import\s+(?:qualified\s+)?([\w.]+)/,
+            export: /module\s+[\w.]+\s*\(([^)]+)\)/,
+        },
+    },
+    elixir: {
+        extensions: ['.ex', '.exs'],
+        parser: 'elixir',
+        symbolPatterns: {
+            function: /def(?:p|macro|macrop)?\s+(\w+)(?:\(|,|\s+do)/,
+            class: /defmodule\s+([\w.]+)\s+do/,
+            variable: /@(\w+)\s+|(\w+)\s*=\s*(?!fn)/,
+            import: /(?:import|alias|require|use)\s+([\w.]+)/,
+            export: /^def\s+(\w+)/,
+        },
+    },
+    clojure: {
+        extensions: ['.clj', '.cljs', '.cljc', '.edn'],
+        parser: 'clojure',
+        symbolPatterns: {
+            function: /\(defn-?\s+(\w+)/,
+            class: /\(defrecord\s+(\w+)|\(deftype\s+(\w+)|\(defprotocol\s+(\w+)/,
+            variable: /\(def\s+(\w+)/,
+            import: /\(:require\s+\[([^\]]+)\]/,
+            export: /\(defn-?\s+(\w+)/,
+        },
+    },
+    fsharp: {
+        extensions: ['.fs', '.fsx', '.fsi'],
+        parser: 'fsharp',
+        symbolPatterns: {
+            function: /let\s+(?:rec\s+)?(\w+)(?:\s+\w+)*\s*=/,
+            class: /type\s+(\w+)\s*(?:=|<|\()/,
+            variable: /let\s+(?:mutable\s+)?(\w+)\s*=/,
+            import: /open\s+([\w.]+)/,
+            export: /^(?:let|type)\s+(\w+)/,
+        },
+    },
+    vbnet: {
+        extensions: ['.vb', '.vbs'],
+        parser: 'vbnet',
+        symbolPatterns: {
+            function: /(?:Public|Private|Protected|Friend)?\s*(?:Shared)?\s*(?:Function|Sub)\s+(\w+)/i,
+            class: /(?:Public|Private|Protected|Friend)?\s*(?:MustInherit|NotInheritable)?\s*Class\s+(\w+)/i,
+            variable: /(?:Public|Private|Protected|Friend|Dim|Const)?\s*(\w+)\s+As\s+/i,
+            import: /Imports\s+([\w.]+)/i,
+            export: /Public\s+(?:Class|Module|Function|Sub)\s+(\w+)/i,
+        },
+    },
+    matlab: {
+        extensions: ['.m', '.mlx'],
+        parser: 'matlab',
+        symbolPatterns: {
+            function: /function\s+(?:\[[^\]]+\]\s*=\s*|[\w,\s]+\s*=\s*)?(\w+)\s*\(/,
+            class: /classdef\s+(\w+)/,
+            variable: /(\w+)\s*=\s*(?!function)/,
+            import: /import\s+([\w.*]+)/,
+            export: /^function\s+(?:\[[^\]]+\]\s*=\s*)?(\w+)/,
+        },
+    },
+    sql: {
+        extensions: ['.sql', '.ddl', '.dml'],
+        parser: 'sql',
+        symbolPatterns: {
+            function: /CREATE\s+(?:OR\s+REPLACE\s+)?(?:FUNCTION|PROCEDURE)\s+(\w+)/i,
+            class: /CREATE\s+(?:TABLE|VIEW)\s+(\w+)/i,
+            variable: /DECLARE\s+@?(\w+)/i,
+            import: /^$/, // SQL doesn't have imports
+            export: /^CREATE\s+(?:FUNCTION|PROCEDURE|VIEW)\s+(\w+)/i,
+        },
+    },
+    html: {
+        extensions: ['.html', '.htm', '.xhtml'],
+        parser: 'html',
+        symbolPatterns: {
+            function: /<script[^>]*>[\s\S]*?function\s+(\w+)/,
+            class: /class\s*=\s*["']([^"']+)["']/,
+            variable: /id\s*=\s*["']([^"']+)["']/,
+            import: /<(?:link|script)[^>]+(?:href|src)\s*=\s*["']([^"']+)["']/,
+            export: /<(?:div|section|article|header|footer)[^>]+id\s*=\s*["']([^"']+)["']/,
+        },
+    },
+    css: {
+        extensions: ['.css', '.scss', '.sass', '.less', '.styl'],
+        parser: 'css',
+        symbolPatterns: {
+            function: /@mixin\s+(\w+)|@function\s+(\w+)/,
+            class: /\.(\w+(?:-\w+)*)\s*\{/,
+            variable: /--(\w+(?:-\w+)*):|@(\w+):|(\$\w+):/,
+            import: /@import\s+(?:url\()?['"]([^'"]+)['"]/,
+            export: /@mixin\s+(\w+)|@function\s+(\w+)/,
+        },
+    },
+    vue: {
+        extensions: ['.vue'],
+        parser: 'vue',
+        symbolPatterns: {
+            function: /<script[^>]*>[\s\S]*?(?:export\s+default\s*\{[\s\S]*?)?(?:function|const|let|var)\s+(\w+)|methods\s*:\s*\{[\s\S]*?(\w+)\s*\(/,
+            class: /<template[^>]*>[\s\S]*?<(\w+)/,
+            variable: /<script[^>]*>[\s\S]*?(?:data\s*\(\s*\)\s*\{[\s\S]*?return\s*\{[\s\S]*?(\w+)|(?:const|let|var)\s+(\w+)\s*=)/,
+            import: /<script[^>]*>[\s\S]*?import\s+(?:{[^}]+}|\w+)\s+from\s+['"]([^'"]+)['"]/,
+            export: /<script[^>]*>[\s\S]*?export\s+default/,
+        },
+    },
+    svelte: {
+        extensions: ['.svelte'],
+        parser: 'svelte',
+        symbolPatterns: {
+            function: /<script[^>]*>[\s\S]*?(?:function|const|let|var)\s+(\w+)\s*[=(]/,
+            class: /<[\w-]+/,
+            variable: /<script[^>]*>[\s\S]*?(?:let|const|var)\s+(\w+)\s*=/,
+            import: /<script[^>]*>[\s\S]*?import\s+(?:{[^}]+}|\w+)\s+from\s+['"]([^'"]+)['"]/,
+            export: /<script[^>]*>[\s\S]*?export\s+(?:let|const|function)\s+(\w+)/,
+        },
+    },
+    xml: {
+        extensions: ['.xml', '.xsd', '.xsl', '.xslt', '.svg'],
+        parser: 'xml',
+        symbolPatterns: {
+            function: /<xsl:template[^>]+name\s*=\s*["']([^"']+)["']/,
+            class: /<(?:xsd:)?(?:complexType|simpleType)[^>]+name\s*=\s*["']([^"']+)["']/,
+            variable: /<(?:xsd:)?element[^>]+name\s*=\s*["']([^"']+)["']/,
+            import: /<(?:xsd:)?import[^>]+schemaLocation\s*=\s*["']([^"']+)["']/,
+            export: /<(?:xsd:)?element[^>]+name\s*=\s*["']([^"']+)["']/,
+        },
+    },
+    yaml: {
+        extensions: ['.yaml', '.yml'],
+        parser: 'yaml',
+        symbolPatterns: {
+            function: /^(\w+):\s*\|/m,
+            class: /^(\w+):$/m,
+            variable: /^(\w+):\s*[^|>]/m,
+            import: /^$/, // YAML doesn't have imports
+            export: /^(\w+):$/m,
+        },
+    },
+    json: {
+        extensions: ['.json', '.jsonc', '.json5'],
+        parser: 'json',
+        symbolPatterns: {
+            function: /^$/,
+            class: /^$/,
+            variable: /"(\w+)"\s*:/,
+            import: /^$/,
+            export: /^$/,
+        },
+    },
+    toml: {
+        extensions: ['.toml'],
+        parser: 'toml',
+        symbolPatterns: {
+            function: /^$/,
+            class: /^\[(\w+(?:\.\w+)*)\]/,
+            variable: /^(\w+)\s*=/,
+            import: /^$/,
+            export: /^\[(\w+(?:\.\w+)*)\]/,
+        },
+    },
+    markdown: {
+        extensions: ['.md', '.markdown', '.mdown', '.mkd'],
+        parser: 'markdown',
+        symbolPatterns: {
+            function: /```[\w]*\n[\s\S]*?function\s+(\w+)/,
+            class: /^#{1,6}\s+(.+)$/m,
+            variable: /\[([^\]]+)\]:/,
+            import: /\[([^\]]+)\]\(([^)]+)\)/,
+            export: /^#{1,6}\s+(.+)$/m,
         },
     },
 };

package/dist/ui/pages/SubAgentConfigScreen.js

@@ -88,6 +88,7 @@ const toolCategories = [
 export default function SubAgentConfigScreen({ onBack, onSave, inlineMode = false, agentId, }) {
     const [agentName, setAgentName] = useState('');
     const [description, setDescription] = useState('');
+    const [role, setRole] = useState('');
     const [selectedTools, setSelectedTools] = useState(new Set());
     const [currentField, setCurrentField] = useState('name');
     const [selectedCategoryIndex, setSelectedCategoryIndex] = useState(0);
@@ -105,6 +106,7 @@ export default function SubAgentConfigScreen({ onBack, onSave, inlineMode = fals
             if (agent) {
                 setAgentName(agent.name);
                 setDescription(agent.description);
+                setRole(agent.role || '');
                 setSelectedTools(new Set(agent.tools));
             }
         }
@@ -207,12 +209,13 @@ export default function SubAgentConfigScreen({ onBack, onSave, inlineMode = fals
                 updateSubAgent(agentId, {
                     name: agentName,
                     description: description,
+                    role: role || undefined,
                     tools: Array.from(selectedTools),
                 });
             }
             else {
                 // Create new agent
-                createSubAgent(agentName, description, Array.from(selectedTools));
+                createSubAgent(agentName, description, Array.from(selectedTools), role || undefined);
             }
             setShowSuccess(true);
             setTimeout(() => {
@@ -223,7 +226,15 @@ export default function SubAgentConfigScreen({ onBack, onSave, inlineMode = fals
         catch (error) {
             setSaveError(error instanceof Error ? error.message : 'Failed to save sub-agent');
         }
-    }, [agentName, description, selectedTools, onSave, isEditMode, agentId]);
+    }, [
+        agentName,
+        description,
+        role,
+        selectedTools,
+        onSave,
+        isEditMode,
+        agentId,
+    ]);
     useInput((rawInput, key) => {
         const input = stripFocusArtifacts(rawInput);
         // Ignore focus events completely
@@ -247,6 +258,10 @@ export default function SubAgentConfigScreen({ onBack, onSave, inlineMode = fals
                 setCurrentField('name');
                 return;
             }
+            else if (currentField === 'role') {
+                setCurrentField('description');
+                return;
+            }
             else if (currentField === 'tools') {
                 // Navigate within tools
                 if (selectedToolIndex > 0) {
@@ -258,8 +273,8 @@ export default function SubAgentConfigScreen({ onBack, onSave, inlineMode = fals
                     setSelectedToolIndex(prevCategory ? prevCategory.tools.length - 1 : 0);
                 }
                 else {
-                    // At top of tools, go to description
-                    setCurrentField('description');
+                    // At top of tools, go to role
+                    setCurrentField('role');
                 }
                 return;
             }
@@ -270,6 +285,10 @@ export default function SubAgentConfigScreen({ onBack, onSave, inlineMode = fals
                 return;
             }
             else if (currentField === 'description') {
+                setCurrentField('role');
+                return;
+            }
+            else if (currentField === 'role') {
                 setCurrentField('tools');
                 setSelectedCategoryIndex(0);
                 setSelectedToolIndex(0);
@@ -387,6 +406,10 @@ export default function SubAgentConfigScreen({ onBack, onSave, inlineMode = fals
                 React.createElement(Text, { bold: true, color: currentField === 'description' ? 'green' : 'white' }, "Description:"),
                 React.createElement(Box, { marginLeft: 2 },
                     React.createElement(TextInput, { value: description, onChange: value => setDescription(stripFocusArtifacts(value)), placeholder: "Enter agent description...", focus: currentField === 'description' }))),
+            React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { bold: true, color: currentField === 'role' ? 'green' : 'white' }, "Role (Optional):"),
+                React.createElement(Box, { marginLeft: 2 },
+                    React.createElement(TextInput, { value: role, onChange: value => setRole(stripFocusArtifacts(value)), placeholder: "Specify agent role to guide output and focus...", focus: currentField === 'role' }))),
             renderToolSelection(),
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { color: "gray", dimColor: true }, "\u2191\u2193: Navigate | \u2190\u2192: Switch category | Space: Toggle | A: Toggle all | Enter: Save | Esc: Back")))));

package/dist/utils/sessionConverter.js

@@ -18,27 +18,30 @@ export function convertSessionMessagesToUI(sessionMessages) {
         // Handle sub-agent internal tool call messages
         if (msg.subAgentInternal && msg.role === 'assistant' && msg.tool_calls) {
             for (const toolCall of msg.tool_calls) {
-                const toolDisplay = formatToolCallMessage(toolCall);
-                let toolArgs;
-                try {
-                    toolArgs = JSON.parse(toolCall.function.arguments);
-                }
-                catch (e) {
-                    toolArgs = {};
+                // 只有耗时工具才创建"进行中"消息
+                if (isToolNeedTwoStepDisplay(toolCall.function.name)) {
+                    const toolDisplay = formatToolCallMessage(toolCall);
+                    let toolArgs;
+                    try {
+                        toolArgs = JSON.parse(toolCall.function.arguments);
+                    }
+                    catch (e) {
+                        toolArgs = {};
+                    }
+                    uiMessages.push({
+                        role: 'subagent',
+                        content: `\x1b[38;2;184;122;206m⚇⚡ ${toolDisplay.toolName}\x1b[0m`,
+                        streaming: false,
+                        toolCall: {
+                            name: toolCall.function.name,
+                            arguments: toolArgs,
+                        },
+                        toolDisplay,
+                        toolCallId: toolCall.id,
+                        toolPending: false,
+                        subAgentInternal: true,
+                    });
                 }
-                uiMessages.push({
-                    role: 'subagent',
-                    content: `\x1b[38;2;184;122;206m⚇⚡ ${toolDisplay.toolName}\x1b[0m`,
-                    streaming: false,
-                    toolCall: {
-                        name: toolCall.function.name,
-                        arguments: toolArgs,
-                    },
-                    toolDisplay,
-                    toolCallId: toolCall.id,
-                    toolPending: false,
-                    subAgentInternal: true,
-                });
                 processedToolCalls.add(toolCall.id);
             }
             continue;

package/dist/utils/subAgentConfig.d.ts

@@ -2,6 +2,7 @@ export interface SubAgent {
     id: string;
     name: string;
     description: string;
+    role?: string;
     tools: string[];
     createdAt: string;
     updatedAt: string;
@@ -20,13 +21,14 @@ export declare function getSubAgent(id: string): SubAgent | null;
 /**
  * Create a new sub-agent
  */
-export declare function createSubAgent(name: string, description: string, tools: string[]): SubAgent;
+export declare function createSubAgent(name: string, description: string, tools: string[], role?: string): SubAgent;
 /**
  * Update an existing sub-agent
  */
 export declare function updateSubAgent(id: string, updates: {
     name?: string;
     description?: string;
+    role?: string;
     tools?: string[];
 }): SubAgent | null;
 /**

package/dist/utils/subAgentConfig.js

@@ -53,13 +53,14 @@ function saveSubAgents(agents) {
 /**
  * Create a new sub-agent
  */
-export function createSubAgent(name, description, tools) {
+export function createSubAgent(name, description, tools, role) {
     const agents = getSubAgents();
     const now = new Date().toISOString();
     const newAgent = {
         id: generateId(),
         name,
         description,
+        role,
         tools,
         createdAt: now,
         updatedAt: now,
@@ -85,6 +86,7 @@ export function updateSubAgent(id, updates) {
         id: existingAgent.id,
         name: updates.name ?? existingAgent.name,
         description: updates.description ?? existingAgent.description,
+        role: updates.role ?? existingAgent.role,
         tools: updates.tools ?? existingAgent.tools,
         createdAt: existingAgent.createdAt,
         updatedAt: new Date().toISOString(),

package/dist/utils/subAgentExecutor.js

@@ -50,10 +50,15 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
             };
         }
         // Build conversation history for sub-agent
+        // Append role to prompt if configured
+        let finalPrompt = prompt;
+        if (agent.role) {
+            finalPrompt = `${prompt}\n\n${agent.role}`;
+        }
         const messages = [
             {
                 role: 'user',
-                content: prompt,
+                content: finalPrompt,
             },
         ];
         // Stream sub-agent execution

package/dist/utils/vscodeConnection.d.ts

@@ -30,7 +30,14 @@ declare class VSCodeConnectionManager {
     private editorContext;
     private listeners;
     private currentWorkingDirectory;
+    private connectingPromise;
+    private connectionTimeout;
+    private readonly CONNECTION_TIMEOUT;
     start(): Promise<void>;
+    /**
+     * Clean up connection state and resources
+     */
+    private cleanupConnection;
     /**
      * Normalize path for cross-platform compatibility
      * - Converts Windows backslashes to forward slashes

package/dist/utils/vscodeConnection.js

@@ -89,15 +89,44 @@ class VSCodeConnectionManager {
             writable: true,
             value: process.cwd()
         });
+        // Connection state management
+        Object.defineProperty(this, "connectingPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "connectionTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "CONNECTION_TIMEOUT", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10000
+        }); // 10 seconds timeout for initial connection
     }
     async start() {
         // If already connected, just return success
         if (this.client?.readyState === WebSocket.OPEN) {
             return Promise.resolve();
         }
+        // If already connecting, return the existing promise to avoid duplicate connections
+        if (this.connectingPromise) {
+            return this.connectingPromise;
+        }
         // Try to find the correct port for this workspace
         const targetPort = this.findPortForWorkspace();
-        return new Promise((resolve, reject) => {
+        // Create a new connection promise and store it
+        this.connectingPromise = new Promise((resolve, reject) => {
+            // Set connection timeout
+            this.connectionTimeout = setTimeout(() => {
+                this.cleanupConnection();
+                reject(new Error('Connection timeout after 10 seconds'));
+            }, this.CONNECTION_TIMEOUT);
             const tryConnect = (port) => {
                 // Check both VSCode and JetBrains port ranges
                 if (port > this.VSCODE_MAX_PORT && port < this.JETBRAINS_BASE_PORT) {
@@ -106,6 +135,7 @@ class VSCodeConnectionManager {
                     return;
                 }
                 if (port > this.JETBRAINS_MAX_PORT) {
+                    this.cleanupConnection();
                     reject(new Error(`Failed to connect: no IDE server found on ports ${this.VSCODE_BASE_PORT}-${this.VSCODE_MAX_PORT} or ${this.JETBRAINS_BASE_PORT}-${this.JETBRAINS_MAX_PORT}`));
                     return;
                 }
@@ -115,6 +145,12 @@ class VSCodeConnectionManager {
                         // Reset reconnect attempts on successful connection
                         this.reconnectAttempts = 0;
                         this.port = port;
+                        // Clear connection state
+                        if (this.connectionTimeout) {
+                            clearTimeout(this.connectionTimeout);
+                            this.connectionTimeout = null;
+                        }
+                        this.connectingPromise = null;
                         resolve();
                     });
                     this.client.on('message', message => {
@@ -148,6 +184,34 @@ class VSCodeConnectionManager {
             };
             tryConnect(targetPort);
         });
+        // Return the promise and clean up state when it completes or fails
+        return this.connectingPromise.finally(() => {
+            this.connectingPromise = null;
+            if (this.connectionTimeout) {
+                clearTimeout(this.connectionTimeout);
+                this.connectionTimeout = null;
+            }
+        });
+    }
+    /**
+     * Clean up connection state and resources
+     */
+    cleanupConnection() {
+        this.connectingPromise = null;
+        if (this.connectionTimeout) {
+            clearTimeout(this.connectionTimeout);
+            this.connectionTimeout = null;
+        }
+        if (this.client) {
+            try {
+                this.client.removeAllListeners();
+                this.client.close();
+            }
+            catch (error) {
+                // Ignore errors during cleanup
+            }
+            this.client = null;
+        }
     }
     /**
      * Normalize path for cross-platform compatibility
@@ -228,8 +292,21 @@ class VSCodeConnectionManager {
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = null;
         }
+        // Clear connection timeout
+        if (this.connectionTimeout) {
+            clearTimeout(this.connectionTimeout);
+            this.connectionTimeout = null;
+        }
+        // Clear connecting promise
+        this.connectingPromise = null;
         if (this.client) {
-            this.client.close();
+            try {
+                this.client.removeAllListeners();
+                this.client.close();
+            }
+            catch (error) {
+                // Ignore errors during cleanup
+            }
             this.client = null;
         }
         this.reconnectAttempts = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.3.28",
+	"version": "0.3.29",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {