snow-ai 0.2.18 → 0.2.19

package/dist/ui/components/ToolResultPreview.js

@@ -15,12 +15,15 @@ export default function ToolResultPreview({ toolName, result, maxLines = 5 }) {
         else if (toolName === 'filesystem-list') {
             return renderListPreview(data, maxLines);
         }
-        else if (toolName === 'filesystem-search') {
-            return renderSearchPreview(data, maxLines);
-        }
         else if (toolName === 'filesystem-create' || toolName === 'filesystem-write') {
             return renderCreatePreview(data);
         }
+        else if (toolName === 'filesystem-edit_search') {
+            return renderEditSearchPreview(data);
+        }
+        else if (toolName.startsWith('ace-')) {
+            return renderACEPreview(toolName, data, maxLines);
+        }
         else {
             // Generic preview for unknown tools
             return renderGenericPreview(data, maxLines);
@@ -66,29 +69,133 @@ function renderListPreview(data, maxLines) {
             files.length,
             " items)"))));
 }
-function renderSearchPreview(data, maxLines) {
-    if (!data.matches || data.matches.length === 0) {
-        return (React.createElement(Box, { marginLeft: 2 },
+function renderACEPreview(toolName, data, maxLines) {
+    // Handle ace-text-search results
+    if (toolName === 'ace-text-search' || toolName === 'ace_text_search') {
+        if (!data || data.length === 0) {
+            return (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "gray", dimColor: true }, "\u2514\u2500 No matches found")));
+        }
+        const results = Array.isArray(data) ? data : [];
+        const previewMatches = results.slice(0, maxLines);
+        const hasMore = results.length > maxLines;
+        return (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
+            previewMatches.map((match, idx) => (React.createElement(Text, { key: idx, color: "gray", dimColor: true },
+                idx === previewMatches.length - 1 && !hasMore ? '└─ ' : '├─ ',
+                match.filePath,
+                ":",
+                match.line,
+                " - ",
+                match.content.slice(0, 60),
+                match.content.length > 60 ? '...' : ''))),
+            hasMore && (React.createElement(Text, { color: "gray", dimColor: true },
+                "\u2514\u2500 ... (",
+                results.length - maxLines,
+                " more matches)"))));
+    }
+    // Handle ace-search-symbols results
+    if (toolName === 'ace-search-symbols' || toolName === 'ace_search_symbols') {
+        const symbols = data.symbols || [];
+        if (symbols.length === 0) {
+            return (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "gray", dimColor: true }, "\u2514\u2500 No symbols found")));
+        }
+        const previewSymbols = symbols.slice(0, maxLines);
+        const hasMore = symbols.length > maxLines;
+        return (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
+            previewSymbols.map((symbol, idx) => (React.createElement(Text, { key: idx, color: "gray", dimColor: true },
+                idx === previewSymbols.length - 1 && !hasMore ? '└─ ' : '├─ ',
+                symbol.type,
+                " ",
+                symbol.name,
+                " - ",
+                symbol.filePath,
+                ":",
+                symbol.line))),
+            hasMore && (React.createElement(Text, { color: "gray", dimColor: true },
+                "\u2514\u2500 ... (",
+                data.totalResults - maxLines,
+                " more symbols)"))));
+    }
+    // Handle ace-find-references results
+    if (toolName === 'ace-find-references' || toolName === 'ace_find_references') {
+        const references = Array.isArray(data) ? data : [];
+        if (references.length === 0) {
+            return (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "gray", dimColor: true }, "\u2514\u2500 No references found")));
+        }
+        const previewRefs = references.slice(0, maxLines);
+        const hasMore = references.length > maxLines;
+        return (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
+            previewRefs.map((ref, idx) => (React.createElement(Text, { key: idx, color: "gray", dimColor: true },
+                idx === previewRefs.length - 1 && !hasMore ? '└─ ' : '├─ ',
+                ref.referenceType,
+                " - ",
+                ref.filePath,
+                ":",
+                ref.line))),
+            hasMore && (React.createElement(Text, { color: "gray", dimColor: true },
+                "\u2514\u2500 ... (",
+                references.length - maxLines,
+                " more references)"))));
+    }
+    // Handle ace-find-definition result
+    if (toolName === 'ace-find-definition' || toolName === 'ace_find_definition') {
+        if (!data) {
+            return (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "gray", dimColor: true }, "\u2514\u2500 Definition not found")));
+        }
+        return (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
             React.createElement(Text, { color: "gray", dimColor: true },
-                "\u2514\u2500 No matches found (searched ",
-                data.searchedFiles,
-                " files)")));
+                "\u2514\u2500 ",
+                data.type,
+                " ",
+                data.name,
+                " - ",
+                data.filePath,
+                ":",
+                data.line)));
     }
-    const previewMatches = data.matches.slice(0, maxLines);
-    const hasMore = data.matches.length > maxLines;
-    return (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
-        previewMatches.map((match, idx) => (React.createElement(Text, { key: idx, color: "gray", dimColor: true },
-            idx === previewMatches.length - 1 && !hasMore ? '└─ ' : '├─ ',
-            match.filePath,
-            ":",
-            match.lineNumber,
-            " - ",
-            match.lineContent.slice(0, 60),
-            match.lineContent.length > 60 ? '...' : ''))),
-        hasMore && (React.createElement(Text, { color: "gray", dimColor: true },
-            "\u2514\u2500 ... (",
-            data.totalMatches - maxLines,
-            " more matches)"))));
+    // Handle ace-file-outline result
+    if (toolName === 'ace-file-outline' || toolName === 'ace_file_outline') {
+        const symbols = Array.isArray(data) ? data : [];
+        if (symbols.length === 0) {
+            return (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "gray", dimColor: true }, "\u2514\u2500 No symbols in file")));
+        }
+        const previewSymbols = symbols.slice(0, maxLines);
+        const hasMore = symbols.length > maxLines;
+        return (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
+            previewSymbols.map((symbol, idx) => (React.createElement(Text, { key: idx, color: "gray", dimColor: true },
+                idx === previewSymbols.length - 1 && !hasMore ? '└─ ' : '├─ ',
+                symbol.type,
+                " ",
+                symbol.name,
+                " (line ",
+                symbol.line,
+                ")"))),
+            hasMore && (React.createElement(Text, { color: "gray", dimColor: true },
+                "\u2514\u2500 ... (",
+                symbols.length - maxLines,
+                " more symbols)"))));
+    }
+    // Handle ace-semantic-search result
+    if (toolName === 'ace-semantic-search' || toolName === 'ace_semantic_search') {
+        const totalResults = (data.symbols?.length || 0) + (data.references?.length || 0);
+        if (totalResults === 0) {
+            return (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "gray", dimColor: true }, "\u2514\u2500 No results found")));
+        }
+        return (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
+            React.createElement(Text, { color: "gray", dimColor: true },
+                "\u251C\u2500 Symbols: ",
+                data.symbols?.length || 0),
+            React.createElement(Text, { color: "gray", dimColor: true },
+                "\u2514\u2500 References: ",
+                data.references?.length || 0)));
+    }
+    // Generic ACE tool preview
+    return renderGenericPreview(data, maxLines);
 }
 function renderCreatePreview(data) {
     // Simple success message for create/write operations
@@ -97,6 +204,21 @@ function renderCreatePreview(data) {
             "\u2514\u2500 ",
             data.message || data)));
 }
+function renderEditSearchPreview(data) {
+    // For edit_search, show only key metadata, exclude searchContent and replaceContent
+    return (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
+        data.message && (React.createElement(Text, { color: "gray", dimColor: true },
+            "\u251C\u2500 ",
+            data.message)),
+        data.matchLocation && (React.createElement(Text, { color: "gray", dimColor: true },
+            "\u251C\u2500 Match: lines ",
+            data.matchLocation.startLine,
+            "-",
+            data.matchLocation.endLine)),
+        data.totalLines && (React.createElement(Text, { color: "gray", dimColor: true },
+            "\u2514\u2500 Total lines: ",
+            data.totalLines))));
+}
 function renderGenericPreview(data, maxLines) {
     // For unknown tool types, show first few properties
     const entries = Object.entries(data).slice(0, maxLines);

package/dist/ui/pages/ChatScreen.js

@@ -493,7 +493,12 @@ export default function ChatScreen({}) {
                                     message.toolCall.name === 'filesystem-edit' &&
                                     message.toolCall.arguments.oldContent &&
                                     message.toolCall.arguments.newContent && (React.createElement(Box, { marginTop: 1 },
-                                    React.createElement(DiffViewer, { oldContent: message.toolCall.arguments.oldContent, newContent: message.toolCall.arguments.newContent, filename: message.toolCall.arguments.filename, completeOldContent: message.toolCall.arguments.completeOldContent, completeNewContent: message.toolCall.arguments.completeNewContent }))),
+                                    React.createElement(DiffViewer, { oldContent: message.toolCall.arguments.oldContent, newContent: message.toolCall.arguments.newContent, filename: message.toolCall.arguments.filename, completeOldContent: message.toolCall.arguments.completeOldContent, completeNewContent: message.toolCall.arguments.completeNewContent, startLineNumber: message.toolCall.arguments.contextStartLine }))),
+                                message.toolCall &&
+                                    message.toolCall.name === 'filesystem-edit_search' &&
+                                    message.toolCall.arguments.oldContent &&
+                                    message.toolCall.arguments.newContent && (React.createElement(Box, { marginTop: 1 },
+                                    React.createElement(DiffViewer, { oldContent: message.toolCall.arguments.oldContent, newContent: message.toolCall.arguments.newContent, filename: message.toolCall.arguments.filename, completeOldContent: message.toolCall.arguments.completeOldContent, completeNewContent: message.toolCall.arguments.completeNewContent, startLineNumber: message.toolCall.arguments.contextStartLine }))),
                                 message.toolCall &&
                                     message.toolCall.name === 'terminal-execute' &&
                                     message.toolCall.arguments.command && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },

package/dist/utils/mcpToolsManager.js

@@ -5,6 +5,7 @@ import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { getMCPConfig } from './apiConfig.js';
 import { mcpTools as filesystemTools } from '../mcp/filesystem.js';
 import { mcpTools as terminalTools } from '../mcp/bash.js';
+import { mcpTools as aceCodeSearchTools } from '../mcp/aceCodeSearch.js';
 import { TodoService } from '../mcp/todo.js';
 import { sessionManager } from './sessionManager.js';
 import { logger } from './logger.js';
@@ -130,6 +131,28 @@ async function refreshToolsCache() {
             },
         });
     }
+    // Add built-in ACE Code Search tools (always available)
+    const aceServiceTools = aceCodeSearchTools.map(tool => ({
+        name: tool.name.replace('ace_', ''),
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+    }));
+    servicesInfo.push({
+        serviceName: 'ace',
+        tools: aceServiceTools,
+        isBuiltIn: true,
+        connected: true,
+    });
+    for (const tool of aceCodeSearchTools) {
+        allTools.push({
+            type: 'function',
+            function: {
+                name: `ace-${tool.name.replace('ace_', '')}`,
+                description: tool.description,
+                parameters: tool.inputSchema,
+            },
+        });
+    }
     // Add user-configured MCP server tools (probe for availability but don't maintain connections)
     try {
         const mcpConfig = getMCPConfig();
@@ -413,6 +436,10 @@ export async function executeMCPTool(toolName, args) {
         serviceName = 'terminal';
         actualToolName = toolName.substring('terminal-'.length);
     }
+    else if (toolName.startsWith('ace-')) {
+        serviceName = 'ace';
+        actualToolName = toolName.substring('ace-'.length);
+    }
     else {
         // Check configured MCP services
         try {
@@ -460,15 +487,8 @@ export async function executeMCPTool(toolName, args) {
                 return await filesystemService.getFileInfo(args.filePath);
             case 'edit':
                 return await filesystemService.editFile(args.filePath, args.startLine, args.endLine, args.newContent, args.contextLines);
-            case 'search': {
-                // 兼容性处理:如果 searchMode 不存在或无效,默认使用 'text'
-                const validSearchModes = ['text', 'regex'];
-                let searchMode = 'text';
-                if (args.searchMode && validSearchModes.includes(args.searchMode)) {
-                    searchMode = args.searchMode;
-                }
-                return await filesystemService.searchCode(args.query, args.dirPath, args.fileExtensions, args.caseSensitive, args.maxResults, searchMode);
-            }
+            case 'edit_search':
+                return await filesystemService.editFileBySearch(args.filePath, args.searchContent, args.replaceContent, args.occurrence, args.contextLines);
             default:
                 throw new Error(`Unknown filesystem tool: ${actualToolName}`);
         }
@@ -483,6 +503,31 @@ export async function executeMCPTool(toolName, args) {
                 throw new Error(`Unknown terminal tool: ${actualToolName}`);
         }
     }
+    else if (serviceName === 'ace') {
+        // Handle built-in ACE Code Search tools (no connection needed)
+        const { aceCodeSearchService } = await import('../mcp/aceCodeSearch.js');
+        switch (actualToolName) {
+            case 'search_symbols':
+                return await aceCodeSearchService.searchSymbols(args.query, args.symbolType, args.language, args.maxResults);
+            case 'find_definition':
+                return await aceCodeSearchService.findDefinition(args.symbolName, args.contextFile);
+            case 'find_references':
+                return await aceCodeSearchService.findReferences(args.symbolName, args.maxResults);
+            case 'semantic_search':
+                return await aceCodeSearchService.semanticSearch(args.query, args.searchType, args.language, args.maxResults);
+            case 'file_outline':
+                return await aceCodeSearchService.getFileOutline(args.filePath);
+            case 'text_search':
+                return await aceCodeSearchService.textSearch(args.pattern, args.fileGlob, args.isRegex, args.maxResults);
+            case 'index_stats':
+                return aceCodeSearchService.getIndexStats();
+            case 'clear_cache':
+                aceCodeSearchService.clearCache();
+                return { message: 'ACE Code Search cache cleared successfully' };
+            default:
+                throw new Error(`Unknown ACE tool: ${actualToolName}`);
+        }
+    }
     else {
         // Handle user-configured MCP service tools - connect only when needed
         const mcpConfig = getMCPConfig();

package/dist/utils/sessionConverter.js

@@ -41,9 +41,9 @@ export function convertSessionMessagesToUI(sessionMessages) {
                 // Get the tool result for this tool call
                 const toolResult = toolResultsMap.get(toolCall.id);
                 const isError = toolResult?.startsWith('Error:') || false;
-                // For filesystem-edit, try to extract diff data from result
+                // For filesystem-edit and filesystem-edit_search, try to extract diff data from result
                 let editDiffData;
-                if (toolCall.function.name === 'filesystem-edit' &&
+                if ((toolCall.function.name === 'filesystem-edit' || toolCall.function.name === 'filesystem-edit_search') &&
                     toolResult &&
                     !isError) {
                     try {
@@ -53,10 +53,16 @@ export function convertSessionMessagesToUI(sessionMessages) {
                                 oldContent: resultData.oldContent,
                                 newContent: resultData.newContent,
                                 filename: toolArgs.filePath,
+                                completeOldContent: resultData.completeOldContent,
+                                completeNewContent: resultData.completeNewContent,
+                                contextStartLine: resultData.contextStartLine
                             };
                             // Merge diff data into toolArgs for DiffViewer
                             toolArgs.oldContent = resultData.oldContent;
                             toolArgs.newContent = resultData.newContent;
+                            toolArgs.completeOldContent = resultData.completeOldContent;
+                            toolArgs.completeNewContent = resultData.completeNewContent;
+                            toolArgs.contextStartLine = resultData.contextStartLine;
                         }
                     }
                     catch (e) {

package/package.json

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