snow-ai 0.3.35 → 0.3.37

package/dist/mcp/aceCodeSearch.js

@@ -7,7 +7,7 @@ import { processManager } from '../utils/processManager.js';
 import { detectLanguage } from './utils/aceCodeSearch/language.utils.js';
 import { loadExclusionPatterns, shouldExcludeDirectory, readFileWithCache, } from './utils/aceCodeSearch/filesystem.utils.js';
 import { parseFileSymbols, getContext, } from './utils/aceCodeSearch/symbol.utils.js';
-import { isCommandAvailable, parseGrepOutput, globToRegex, } from './utils/aceCodeSearch/search.utils.js';
+import { isCommandAvailable, parseGrepOutput, } from './utils/aceCodeSearch/search.utils.js';
 export class ACECodeSearchService {
     constructor(basePath = process.cwd()) {
         Object.defineProperty(this, "basePath", {
@@ -196,10 +196,11 @@ export class ACECodeSearchService {
                 await fs.access(cachedPath);
             }
             catch {
-                // File no longer exists, remove from cache
+                // File no longer exists, remove from all caches
                 this.indexCache.delete(cachedPath);
                 this.fileModTimes.delete(cachedPath);
                 this.allIndexedFiles.delete(cachedPath);
+                this.fileContentCache.delete(cachedPath);
             }
         }
         this.lastIndexTime = now;
@@ -372,6 +373,10 @@ export class ACECodeSearchService {
      */
     async findReferences(symbolName, maxResults = 100) {
         const references = [];
+        // Load exclusion patterns
+        await this.loadExclusionPatterns();
+        // Escape special regex characters to prevent ReDoS
+        const escapedSymbol = symbolName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         const searchInDirectory = async (dirPath) => {
             try {
                 const entries = await fs.readdir(dirPath, { withFileTypes: true });
@@ -380,11 +385,8 @@ export class ACECodeSearchService {
                         break;
                     const fullPath = path.join(dirPath, entry.name);
                     if (entry.isDirectory()) {
-                        if (entry.name === 'node_modules' ||
-                            entry.name === '.git' ||
-                            entry.name === 'dist' ||
-                            entry.name === 'build' ||
-                            entry.name.startsWith('.')) {
+                        // Use configurable exclusion check
+                        if (shouldExcludeDirectory(entry.name, fullPath, this.basePath, this.customExcludes, this.regexCache)) {
                             continue;
                         }
                         await searchInDirectory(fullPath);
@@ -395,12 +397,14 @@ export class ACECodeSearchService {
                             try {
                                 const content = await fs.readFile(fullPath, 'utf-8');
                                 const lines = content.split('\n');
-                                // Search for symbol usage
+                                // Search for symbol usage with escaped symbol name
+                                const regex = new RegExp(`\\b${escapedSymbol}\\b`, 'g');
                                 for (let i = 0; i < lines.length; i++) {
                                     const line = lines[i];
                                     if (!line)
                                         continue;
-                                    const regex = new RegExp(`\\b${symbolName}\\b`, 'g');
+                                    // Reset regex for each line
+                                    regex.lastIndex = 0;
                                     let match;
                                     while ((match = regex.exec(line)) !== null) {
                                         if (references.length >= maxResults)
@@ -410,7 +414,7 @@ export class ACECodeSearchService {
                                         if (line.includes('import') && line.includes(symbolName)) {
                                             referenceType = 'import';
                                         }
-                                        else if (line.match(new RegExp(`(?:function|class|const|let|var)\\s+${symbolName}`))) {
+                                        else if (new RegExp(`(?:function|class|const|let|var)\\s+${escapedSymbol}`).test(line)) {
                                             referenceType = 'definition';
                                         }
                                         else if (line.includes(':') &&
@@ -491,19 +495,24 @@ export class ACECodeSearchService {
     /**
      * Strategy 1: Use git grep for fast searching in Git repositories
      */
-    async gitGrepSearch(pattern, fileGlob, maxResults = 100) {
+    async gitGrepSearch(pattern, fileGlob, maxResults = 100, isRegex = false) {
         return new Promise((resolve, reject) => {
-            const args = [
-                'grep',
-                '--untracked',
-                '-n',
-                '-E',
-                '--ignore-case',
-                pattern,
-            ];
+            const args = ['grep', '--untracked', '-n', '--ignore-case'];
+            // Use fixed-strings for literal search, extended regex for pattern search
+            if (isRegex) {
+                args.push('-E'); // Extended regex
+            }
+            else {
+                args.push('--fixed-strings'); // Literal string matching
+            }
+            args.push(pattern);
             if (fileGlob) {
-                // Expand glob patterns with braces (e.g., "source/**/*.{ts,tsx}" -> ["source/**/*.ts", "source/**/*.tsx"])
-                const expandedGlobs = this.expandGlobBraces(fileGlob);
+                // Normalize path separators for Windows compatibility
+                let gitGlob = fileGlob.replace(/\\/g, '/');
+                // Convert ** to * as git grep has limited ** support
+                gitGlob = gitGlob.replace(/\*\*/g, '*');
+                // Expand glob patterns with braces (e.g., "source/*.{ts,tsx}" -> ["source/*.ts", "source/*.tsx"])
+                const expandedGlobs = this.expandGlobBraces(gitGlob);
                 args.push('--', ...expandedGlobs);
             }
             const child = spawn('git', args, {
@@ -563,14 +572,22 @@ export class ACECodeSearchService {
                 // Ripgrep uses --glob for filtering
                 excludeDirs.forEach(dir => args.push('--glob', `!${dir}/`));
                 if (fileGlob) {
-                    args.push('--glob', fileGlob);
+                    // Normalize path separators for Windows compatibility
+                    const normalizedGlob = fileGlob.replace(/\\/g, '/');
+                    // Expand glob patterns with braces
+                    const expandedGlobs = this.expandGlobBraces(normalizedGlob);
+                    expandedGlobs.forEach(glob => args.push('--glob', glob));
                 }
             }
             else {
                 // System grep uses --exclude-dir
                 excludeDirs.forEach(dir => args.push(`--exclude-dir=${dir}`));
                 if (fileGlob) {
-                    args.push(`--include=${fileGlob}`);
+                    // Normalize path separators for Windows compatibility
+                    const normalizedGlob = fileGlob.replace(/\\/g, '/');
+                    // Expand glob patterns with braces
+                    const expandedGlobs = this.expandGlobBraces(normalizedGlob);
+                    expandedGlobs.forEach(glob => args.push(`--include=${glob}`));
                 }
                 args.push(pattern, '.');
             }
@@ -615,11 +632,35 @@ export class ACECodeSearchService {
             });
         });
     }
+    /**
+     * Convert a glob pattern to a RegExp that matches full paths
+     * Supports: *, **, ?, {a,b}, [abc]
+     */
+    globPatternToRegex(globPattern) {
+        // Normalize path separators
+        const normalizedGlob = globPattern.replace(/\\/g, '/');
+        // First, temporarily replace glob special patterns with placeholders
+        // to prevent them from being escaped
+        let regexStr = normalizedGlob
+            .replace(/\*\*/g, '\x00DOUBLESTAR\x00') // ** -> placeholder
+            .replace(/\*/g, '\x00STAR\x00') // * -> placeholder
+            .replace(/\?/g, '\x00QUESTION\x00'); // ? -> placeholder
+        // Now escape all special regex characters
+        regexStr = regexStr.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        // Replace placeholders with actual regex patterns
+        regexStr = regexStr
+            .replace(/\x00DOUBLESTAR\x00/g, '.*') // ** -> .* (match any path segments)
+            .replace(/\x00STAR\x00/g, '[^/]*') // * -> [^/]* (match within single segment)
+            .replace(/\x00QUESTION\x00/g, '.'); // ? -> . (match single character)
+        return new RegExp(regexStr, 'i');
+    }
     /**
      * Strategy 3: Pure JavaScript fallback search
      */
     async jsTextSearch(pattern, fileGlob, isRegex = false, maxResults = 100) {
         const results = [];
+        // Load exclusion patterns
+        await this.loadExclusionPatterns();
         // Compile search pattern
         let searchRegex;
         try {
@@ -635,8 +676,42 @@ export class ACECodeSearchService {
         catch (error) {
             throw new Error(`Invalid regex pattern: ${pattern}`);
         }
-        // Parse glob pattern if provided
-        const globRegex = fileGlob ? globToRegex(fileGlob) : null;
+        // Parse glob pattern if provided using improved glob parser
+        const globRegex = fileGlob ? this.globPatternToRegex(fileGlob) : null;
+        // Binary file extensions (using Set for O(1) lookup)
+        const binaryExts = new Set([
+            '.jpg',
+            '.jpeg',
+            '.png',
+            '.gif',
+            '.bmp',
+            '.ico',
+            '.svg',
+            '.pdf',
+            '.zip',
+            '.tar',
+            '.gz',
+            '.rar',
+            '.7z',
+            '.exe',
+            '.dll',
+            '.so',
+            '.dylib',
+            '.mp3',
+            '.mp4',
+            '.avi',
+            '.mov',
+            '.woff',
+            '.woff2',
+            '.ttf',
+            '.eot',
+            '.class',
+            '.jar',
+            '.war',
+            '.o',
+            '.a',
+            '.lib',
+        ]);
         // Search recursively
         const searchInDirectory = async (dirPath) => {
             if (results.length >= maxResults)
@@ -648,62 +723,26 @@ export class ACECodeSearchService {
                         break;
                     const fullPath = path.join(dirPath, entry.name);
                     if (entry.isDirectory()) {
-                        // Skip ignored directories
-                        if (entry.name === 'node_modules' ||
-                            entry.name === '.git' ||
-                            entry.name === 'dist' ||
-                            entry.name === 'build' ||
-                            entry.name === '__pycache__' ||
-                            entry.name === 'target' ||
-                            entry.name === '.next' ||
-                            entry.name === '.nuxt' ||
-                            entry.name === 'coverage' ||
-                            entry.name.startsWith('.')) {
+                        // Use configurable exclusion check
+                        if (shouldExcludeDirectory(entry.name, fullPath, this.basePath, this.customExcludes, this.regexCache)) {
                             continue;
                         }
                         await searchInDirectory(fullPath);
                     }
                     else if (entry.isFile()) {
                         // Filter by glob if specified
-                        if (globRegex && !globRegex.test(fullPath)) {
-                            continue;
+                        if (globRegex) {
+                            // Use relative path from basePath for glob matching
+                            const relativePath = path
+                                .relative(this.basePath, fullPath)
+                                .replace(/\\/g, '/');
+                            if (!globRegex.test(relativePath)) {
+                                continue;
+                            }
                         }
-                        // Skip binary files
+                        // Skip binary files (using Set for fast lookup)
                         const ext = path.extname(entry.name).toLowerCase();
-                        const binaryExts = [
-                            '.jpg',
-                            '.jpeg',
-                            '.png',
-                            '.gif',
-                            '.bmp',
-                            '.ico',
-                            '.svg',
-                            '.pdf',
-                            '.zip',
-                            '.tar',
-                            '.gz',
-                            '.rar',
-                            '.7z',
-                            '.exe',
-                            '.dll',
-                            '.so',
-                            '.dylib',
-                            '.mp3',
-                            '.mp4',
-                            '.avi',
-                            '.mov',
-                            '.woff',
-                            '.woff2',
-                            '.ttf',
-                            '.eot',
-                            '.class',
-                            '.jar',
-                            '.war',
-                            '.o',
-                            '.a',
-                            '.lib',
-                        ];
-                        if (binaryExts.includes(ext)) {
+                        if (binaryExts.has(ext)) {
                             continue;
                         }
                         try {
@@ -754,10 +793,8 @@ export class ACECodeSearchService {
             try {
                 const gitAvailable = await isCommandAvailable('git');
                 if (gitAvailable) {
-                    const results = await this.gitGrepSearch(pattern, fileGlob, maxResults);
-                    if (results.length > 0 || !isRegex) {
-                        // git grep doesn't support all regex features,
-                        // fall back if pattern is complex regex and no results
+                    const results = await this.gitGrepSearch(pattern, fileGlob, maxResults, isRegex);
+                    if (results.length > 0) {
                         return await this.sortResultsByRecency(results);
                     }
                 }
@@ -786,27 +823,32 @@ export class ACECodeSearchService {
     /**
      * Sort search results by file modification time (recent files first)
      * Files modified within last 24 hours are prioritized
+     * Uses parallel stat calls for better performance
      */
     async sortResultsByRecency(results) {
         if (results.length === 0)
             return results;
         const now = Date.now();
         const recentThreshold = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
-        // Get file modification times
+        // Get unique file paths
+        const uniqueFiles = Array.from(new Set(results.map(r => r.filePath)));
+        // Fetch file modification times in parallel using Promise.allSettled
+        const statResults = await Promise.allSettled(uniqueFiles.map(async (filePath) => {
+            const fullPath = path.resolve(this.basePath, filePath);
+            const stats = await fs.stat(fullPath);
+            return { filePath, mtimeMs: stats.mtimeMs };
+        }));
+        // Build map of file modification times
         const fileModTimes = new Map();
-        for (const result of results) {
-            if (fileModTimes.has(result.filePath))
-                continue;
-            try {
-                const fullPath = path.resolve(this.basePath, result.filePath);
-                const stats = await fs.stat(fullPath);
-                fileModTimes.set(result.filePath, stats.mtimeMs);
+        statResults.forEach((result, index) => {
+            if (result.status === 'fulfilled') {
+                fileModTimes.set(result.value.filePath, result.value.mtimeMs);
             }
-            catch {
+            else {
                 // If we can't get stats, treat as old file
-                fileModTimes.set(result.filePath, 0);
+                fileModTimes.set(uniqueFiles[index], 0);
             }
-        }
+        });
         // Sort results: recent files first, then by original order
         return results.sort((a, b) => {
             const aMtime = fileModTimes.get(a.filePath) || 0;
@@ -841,10 +883,10 @@ export class ACECodeSearchService {
     /**
      * Search with language-specific context (cross-reference search)
      */
-    async semanticSearch(query, searchType = 'all', language, maxResults = 50) {
+    async semanticSearch(query, searchType = 'all', language, symbolType, maxResults = 50) {
         const startTime = Date.now();
         // Get symbol search results
-        const symbolResults = await this.searchSymbols(query, undefined, language, maxResults);
+        const symbolResults = await this.searchSymbols(query, symbolType, language, maxResults);
         // Get reference results if needed
         let references = [];
         if (searchType === 'usage' || searchType === 'all') {
@@ -880,54 +922,6 @@ export class ACECodeSearchService {
 export const aceCodeSearchService = new ACECodeSearchService();
 // MCP Tool definitions for integration
 export const mcpTools = [
-    {
-        name: 'ace-search_symbols',
-        description: 'ACE Code Search: Intelligent symbol search across the codebase. Finds functions, classes, variables, and other code symbols with fuzzy matching. Supports multiple programming languages (TypeScript, JavaScript, Python, Go, Rust, Java, C#). Returns precise file locations with line numbers and context.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: 'Symbol name to search for (supports fuzzy matching, e.g., "gfc" can match "getFileContent")',
-                },
-                symbolType: {
-                    type: 'string',
-                    enum: [
-                        'function',
-                        'class',
-                        'method',
-                        'variable',
-                        'constant',
-                        'interface',
-                        'type',
-                        'enum',
-                        'import',
-                        'export',
-                    ],
-                    description: 'Filter by specific symbol type (optional)',
-                },
-                language: {
-                    type: 'string',
-                    enum: [
-                        'typescript',
-                        'javascript',
-                        'python',
-                        'go',
-                        'rust',
-                        'java',
-                        'csharp',
-                    ],
-                    description: 'Filter by programming language (optional)',
-                },
-                maxResults: {
-                    type: 'number',
-                    description: 'Maximum number of results to return (default: 100)',
-                    default: 100,
-                },
-            },
-            required: ['query'],
-        },
-    },
     {
         name: 'ace-find_definition',
         description: 'ACE Code Search: Find the definition of a symbol (Go to Definition). Locates where a function, class, or variable is defined in the codebase. Returns precise location with full signature and context.',
@@ -967,20 +961,36 @@ export const mcpTools = [
     },
     {
         name: 'ace-semantic_search',
-        description: 'ACE Code Search: Advanced semantic search with context understanding. Searches for symbols with intelligent filtering by search type (definition, usage, implementation, all). Combines symbol search with cross-reference analysis.',
+        description: 'ACE Code Search: 智能符号搜索与语义分析。支持多种搜索模式：(1) definition - 查找符号定义(函数/类/接口)；(2) usage - 查找符号引用位置；(3) implementation - 查找具体实现；(4) all - 综合搜索。支持模糊匹配、按语言和符号类型过滤。💡 提示：如果只需要查看单个文件的符号大纲，使用 ace-file_outline 更快。',
         inputSchema: {
             type: 'object',
             properties: {
                 query: {
                     type: 'string',
-                    description: 'Search query (symbol name or pattern)',
+                    description: '搜索查询 (符号名称或模式，支持模糊匹配如 "gfc" 匹配 "getFileContent")',
                 },
                 searchType: {
                     type: 'string',
                     enum: ['definition', 'usage', 'implementation', 'all'],
-                    description: 'Type of search: definition (find declarations), usage (find usages), implementation (find implementations), all (comprehensive search)',
+                    description: '搜索类型：definition (查找声明)、usage (查找使用)、implementation (查找实现)、all (全面搜索)',
                     default: 'all',
                 },
+                symbolType: {
+                    type: 'string',
+                    enum: [
+                        'function',
+                        'class',
+                        'method',
+                        'variable',
+                        'constant',
+                        'interface',
+                        'type',
+                        'enum',
+                        'import',
+                        'export',
+                    ],
+                    description: '可选：按符号类型筛选 (function, class, variable等)',
+                },
                 language: {
                     type: 'string',
                     enum: [
@@ -992,11 +1002,11 @@ export const mcpTools = [
                         'java',
                         'csharp',
                     ],
-                    description: 'Filter by programming language (optional)',
+                    description: '可选：按编程语言筛选',
                 },
                 maxResults: {
                     type: 'number',
-                    description: 'Maximum number of results to return (default: 50)',
+                    description: '最大返回结果数 (默认: 50)',
                     default: 50,
                 },
             },
@@ -1019,7 +1029,7 @@ export const mcpTools = [
     },
     {
         name: 'ace-text_search',
-        description: 'ACE Code Search: Fast text search across the entire codebase using Node.js built-in features (no external dependencies required). Search for exact patterns or regex across all files. Useful for finding strings, comments, TODOs, or any text patterns. Supports glob filtering.',
+        description: 'ACE Code Search: Literal text/regex pattern matching (grep-style search). Best for finding exact strings: TODOs, comments, log messages, error strings, string constants. NOT recommended for code understanding or exploring functionality - use semantic search tools for that. Use when you know the exact text pattern you are looking for.',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/mcp/codebaseSearch.d.ts

@@ -12,7 +12,7 @@ declare class CodebaseSearchService {
      */
     private cosineSimilarity;
     /**
-     * Search codebase using semantic similarity
+     * Search codebase using semantic similarity with retry logic
      */
     search(query: string, topN?: number): Promise<any>;
 }