snow-ai 0.3.35 → 0.3.37

package/dist/mcp/codebaseSearch.js

@@ -1,6 +1,9 @@
 import { CodebaseDatabase } from '../utils/codebaseDatabase.js';
 import { createEmbedding } from '../api/embedding.js';
 import { logger } from '../utils/logger.js';
+import { codebaseReviewAgent } from '../agents/codebaseReviewAgent.js';
+import { codebaseSearchEvents } from '../utils/codebaseSearchEvents.js';
+import { loadCodebaseConfig } from '../utils/codebaseConfig.js';
 import path from 'node:path';
 import fs from 'node:fs';
 /**
@@ -61,9 +64,12 @@ class CodebaseSearchService {
         return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
     }
     /**
-     * Search codebase using semantic similarity
+     * Search codebase using semantic similarity with retry logic
      */
     async search(query, topN = 10) {
+        // Load codebase config
+        const config = loadCodebaseConfig();
+        const enableAgentReview = config.enableAgentReview;
         // Check if codebase index is available
         const { available, reason } = this.isCodebaseIndexAvailable();
         if (!available) {
@@ -73,38 +79,160 @@ class CodebaseSearchService {
                 totalResults: 0,
             };
         }
+        const MAX_SEARCH_RETRIES = 3;
+        const MIN_RESULTS_THRESHOLD = Math.ceil(topN * 0.5); // 50% of topN
         try {
             const projectRoot = process.cwd();
             const db = new CodebaseDatabase(projectRoot);
             db.initialize();
             const totalChunks = db.getTotalChunks();
-            // Generate embedding for query
-            logger.info(`Generating embedding for query: "${query}"`);
-            const queryEmbedding = await createEmbedding(query);
-            // Search similar chunks
-            logger.info(`Searching top ${topN} similar chunks from ${totalChunks} total chunks`);
-            const results = db.searchSimilar(queryEmbedding, topN);
-            // Format results with similarity scores and full content (no truncation)
-            const formattedResults = results.map((chunk, index) => {
-                const score = this.cosineSimilarity(queryEmbedding, chunk.embedding);
-                const scorePercent = (score * 100).toFixed(2);
-                return {
-                    rank: index + 1,
-                    filePath: chunk.filePath,
-                    startLine: chunk.startLine,
-                    endLine: chunk.endLine,
-                    content: chunk.content, // Full content, no truncation
-                    similarityScore: scorePercent,
-                    location: `${chunk.filePath}:${chunk.startLine}-${chunk.endLine}`,
+            let lastResults = null;
+            let searchAttempt = 0;
+            let currentTopN = topN;
+            // Retry loop: if results are too few, increase search range and retry
+            while (searchAttempt < MAX_SEARCH_RETRIES) {
+                searchAttempt++;
+                // Emit search event (only if agent review is enabled)
+                if (enableAgentReview) {
+                    codebaseSearchEvents.emitSearchEvent({
+                        type: searchAttempt === 1 ? 'search-start' : 'search-retry',
+                        attempt: searchAttempt,
+                        maxAttempts: MAX_SEARCH_RETRIES,
+                        currentTopN,
+                        message: `Searching top ${currentTopN} code chunks...`,
+                        query,
+                    });
+                }
+                // Generate embedding for query
+                logger.info(`Search attempt ${searchAttempt}/${MAX_SEARCH_RETRIES}: Searching top ${currentTopN} chunks for query: "${query}"`);
+                const queryEmbedding = await createEmbedding(query);
+                // Search similar chunks
+                const results = db.searchSimilar(queryEmbedding, currentTopN);
+                // Format results with similarity scores and full content
+                const formattedResults = results.map((chunk, index) => {
+                    const score = this.cosineSimilarity(queryEmbedding, chunk.embedding);
+                    const scorePercent = (score * 100).toFixed(2);
+                    return {
+                        rank: index + 1,
+                        filePath: chunk.filePath,
+                        startLine: chunk.startLine,
+                        endLine: chunk.endLine,
+                        content: chunk.content,
+                        similarityScore: scorePercent,
+                        location: `${chunk.filePath}:${chunk.startLine}-${chunk.endLine}`,
+                    };
+                });
+                // Use review agent to filter irrelevant results (if enabled)
+                let finalResults;
+                let reviewFailed = false;
+                let removedCount = 0;
+                let suggestions = [];
+                if (enableAgentReview) {
+                    // Emit reviewing event
+                    codebaseSearchEvents.emitSearchEvent({
+                        type: 'search-retry',
+                        attempt: searchAttempt,
+                        maxAttempts: MAX_SEARCH_RETRIES,
+                        currentTopN,
+                        message: `Reviewing ${formattedResults.length} results with AI...`,
+                        query,
+                    });
+                    logger.info(`Reviewing ${formattedResults.length} search results (attempt ${searchAttempt})`);
+                    const reviewResult = await codebaseReviewAgent.reviewResults(query, formattedResults);
+                    finalResults = reviewResult.filteredResults;
+                    reviewFailed = reviewResult.reviewFailed || false;
+                    removedCount = reviewResult.removedCount;
+                    suggestions = reviewResult.suggestions || [];
+                }
+                else {
+                    // Skip agent review, use all formatted results
+                    finalResults = formattedResults;
+                    reviewFailed = false;
+                    removedCount = 0;
+                    suggestions = [];
+                    // When agent review is disabled, we don't need to retry
+                    // Just return results immediately
+                    logger.info(`Agent review disabled, returning all ${finalResults.length} search results`);
+                }
+                // Store current results as last results
+                lastResults = {
+                    query,
+                    totalChunks,
+                    originalResultsCount: formattedResults.length,
+                    resultsCount: finalResults.length,
+                    removedCount,
+                    reviewFailed,
+                    results: finalResults,
+                    suggestions,
+                    searchAttempts: searchAttempt,
                 };
+                // If agent review is disabled, return immediately (no need to retry)
+                if (!enableAgentReview) {
+                    // Emit search complete event
+                    codebaseSearchEvents.emitSearchEvent({
+                        type: 'search-complete',
+                        attempt: searchAttempt,
+                        maxAttempts: MAX_SEARCH_RETRIES,
+                        currentTopN,
+                        message: `Found ${finalResults.length} results`,
+                        query,
+                    });
+                    db.close();
+                    return lastResults;
+                }
+                // If review failed, return immediately (no point retrying)
+                if (reviewFailed) {
+                    logger.info('Review failed, returning all results without retry');
+                    // Emit search complete event
+                    codebaseSearchEvents.emitSearchEvent({
+                        type: 'search-complete',
+                        attempt: searchAttempt,
+                        maxAttempts: MAX_SEARCH_RETRIES,
+                        currentTopN,
+                        message: 'Review failed, returning all results',
+                        query,
+                    });
+                    db.close();
+                    return lastResults;
+                }
+                // Check if we have enough results
+                if (finalResults.length >= MIN_RESULTS_THRESHOLD) {
+                    logger.info(`Found ${finalResults.length} results (>= ${MIN_RESULTS_THRESHOLD} threshold), search complete`);
+                    // Emit search complete event
+                    codebaseSearchEvents.emitSearchEvent({
+                        type: 'search-complete',
+                        attempt: searchAttempt,
+                        maxAttempts: MAX_SEARCH_RETRIES,
+                        currentTopN,
+                        message: `Found ${finalResults.length} relevant results`,
+                        query,
+                    });
+                    db.close();
+                    return lastResults;
+                }
+                // Too few results, need to retry with more candidates
+                if (searchAttempt < MAX_SEARCH_RETRIES) {
+                    const removedPercentage = ((removedCount / formattedResults.length) *
+                        100).toFixed(1);
+                    logger.warn(`Only ${finalResults.length} results after filtering (${removedPercentage}% removed, threshold: ${MIN_RESULTS_THRESHOLD}). Retrying with more candidates...`);
+                    // Increase search range for next attempt (double it)
+                    currentTopN = Math.min(currentTopN * 2, totalChunks);
+                    continue;
+                }
+                // Last attempt exhausted
+                logger.warn(`Search attempt ${searchAttempt} complete. Only ${finalResults.length} results found (threshold: ${MIN_RESULTS_THRESHOLD}). Returning last results.`);
+            }
+            // Emit search complete event before closing
+            codebaseSearchEvents.emitSearchEvent({
+                type: 'search-complete',
+                attempt: searchAttempt,
+                maxAttempts: MAX_SEARCH_RETRIES,
+                currentTopN,
+                message: `Completed with ${lastResults?.resultsCount || 0} results`,
+                query,
             });
             db.close();
-            return {
-                query,
-                totalChunks,
-                resultsCount: formattedResults.length,
-                results: formattedResults,
-            };
+            return lastResults;
         }
         catch (error) {
             logger.error('Codebase search failed:', error);
@@ -120,11 +248,12 @@ export const codebaseSearchService = new CodebaseSearchService();
 export const mcpTools = [
     {
         name: 'codebase-search',
-        description: '🔍 Semantic search across the codebase using embeddings. ' +
-            'Finds code snippets similar to your query based on meaning, not just keywords. ' +
-            'Returns full code content with similarity scores and file locations. ' +
-            'NOTE: Only available when codebase indexing is enabled and the index has been built. ' +
-            'If the index is not available, the tool will return an error message with instructions.',
+        description: '**Important:When you need to search for code, this is the highest priority tool. You need to use this Codebase tool first.**' +
+            '* Semantic search across the codebase using embeddings. ' +
+            '* Finds code snippets similar to your query based on meaning, not just keywords. ' +
+            '* Returns full code content with similarity scores and file locations. ' +
+            '* NOTE: Only available when codebase indexing is enabled and the index has been built. ' +
+            '* If the index is not available, the tool will return an error message with instructions.',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/mcp/filesystem.d.ts

@@ -64,19 +64,13 @@ export declare class FilesystemMCPService {
      */
     createFile(filePath: string, content: string, createDirectories?: boolean): Promise<string>;
     /**
-     * Delete one or multiple files
-     * @param filePaths - Single file path or array of file paths to delete
-     * @returns Success message with details
-     * @throws Error if file deletion fails
-     */
-    deleteFile(filePaths: string | string[]): Promise<string>;
-    /**
-     * List files in a directory
+     * List files in a directory (internal use for read tool)
      * @param dirPath - Directory path relative to base path or absolute path
      * @returns Array of file names
      * @throws Error if directory cannot be read
+     * @private
      */
-    listFiles(dirPath?: string): Promise<string[]>;
+    private listFiles;
     /**
      * Check if a file or directory exists
      * @param filePath - Path to check
@@ -199,8 +193,6 @@ export declare const mcpTools: ({
             };
             content?: undefined;
             createDirectories?: undefined;
-            filePaths?: undefined;
-            dirPath?: undefined;
             searchContent?: undefined;
             replaceContent?: undefined;
             occurrence?: undefined;
@@ -231,8 +223,6 @@ export declare const mcpTools: ({
             };
             startLine?: undefined;
             endLine?: undefined;
-            filePaths?: undefined;
-            dirPath?: undefined;
             searchContent?: undefined;
             replaceContent?: undefined;
             occurrence?: undefined;
@@ -241,69 +231,6 @@ export declare const mcpTools: ({
         };
         required: string[];
     };
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            filePath: {
-                type: string;
-                description: string;
-                oneOf?: undefined;
-            };
-            filePaths: {
-                oneOf: ({
-                    type: string;
-                    description: string;
-                    items?: undefined;
-                } | {
-                    type: string;
-                    items: {
-                        type: string;
-                    };
-                    description: string;
-                })[];
-                description: string;
-            };
-            startLine?: undefined;
-            endLine?: undefined;
-            content?: undefined;
-            createDirectories?: undefined;
-            dirPath?: undefined;
-            searchContent?: undefined;
-            replaceContent?: undefined;
-            occurrence?: undefined;
-            contextLines?: undefined;
-            newContent?: undefined;
-        };
-        required?: undefined;
-    };
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            dirPath: {
-                type: string;
-                description: string;
-                default: string;
-            };
-            filePath?: undefined;
-            startLine?: undefined;
-            endLine?: undefined;
-            content?: undefined;
-            createDirectories?: undefined;
-            filePaths?: undefined;
-            searchContent?: undefined;
-            replaceContent?: undefined;
-            occurrence?: undefined;
-            contextLines?: undefined;
-            newContent?: undefined;
-        };
-        required?: undefined;
-    };
 } | {
     name: string;
     description: string;
@@ -374,8 +301,6 @@ export declare const mcpTools: ({
             endLine?: undefined;
             content?: undefined;
             createDirectories?: undefined;
-            filePaths?: undefined;
-            dirPath?: undefined;
             newContent?: undefined;
         };
         required: string[];
@@ -447,8 +372,6 @@ export declare const mcpTools: ({
             };
             content?: undefined;
             createDirectories?: undefined;
-            filePaths?: undefined;
-            dirPath?: undefined;
             searchContent?: undefined;
             replaceContent?: undefined;
             occurrence?: undefined;

package/dist/mcp/filesystem.js

@@ -382,52 +382,11 @@ export class FilesystemMCPService {
         }
     }
     /**
-     * Delete one or multiple files
-     * @param filePaths - Single file path or array of file paths to delete
-     * @returns Success message with details
-     * @throws Error if file deletion fails
-     */
-    async deleteFile(filePaths) {
-        try {
-            const paths = Array.isArray(filePaths) ? filePaths : [filePaths];
-            const results = [];
-            const errors = [];
-            for (const filePath of paths) {
-                try {
-                    const fullPath = this.resolvePath(filePath);
-                    await this.validatePath(fullPath);
-                    const stats = await fs.stat(fullPath);
-                    if (!stats.isFile()) {
-                        throw new Error(`Path is not a file: ${filePath}`);
-                    }
-                    // Backup file before deletion
-                    await incrementalSnapshotManager.backupFile(fullPath);
-                    await fs.unlink(fullPath);
-                    results.push(`✅ ${filePath}`);
-                }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-                    errors.push(`❌ ${filePath}: ${errorMsg}`);
-                }
-            }
-            const summary = [];
-            if (results.length > 0) {
-                summary.push(`Successfully deleted ${results.length} file(s):\n${results.join('\n')}`);
-            }
-            if (errors.length > 0) {
-                summary.push(`Failed to delete ${errors.length} file(s):\n${errors.join('\n')}`);
-            }
-            return summary.join('\n\n');
-        }
-        catch (error) {
-            throw new Error(`Failed to delete files: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    /**
-     * List files in a directory
+     * List files in a directory (internal use for read tool)
      * @param dirPath - Directory path relative to base path or absolute path
      * @returns Array of file names
      * @throws Error if directory cannot be read
+     * @private
      */
     async listFiles(dirPath = '.') {
         try {
@@ -1113,7 +1072,7 @@ export const filesystemService = new FilesystemMCPService();
 export const mcpTools = [
     {
         name: 'filesystem-read',
-        description: 'Read file content with line numbers. **SUPPORTS MULTIPLE FILES WITH FLEXIBLE LINE RANGES**: Pass either (1) a single file path (string), (2) array of file paths (strings) with unified startLine/endLine, or (3) array of file config objects with per-file line ranges. ⚠️ **IMPORTANT WORKFLOW**: (1) ALWAYS use ACE search tools FIRST (ace-text_search/ace-search_symbols/ace-file_outline) to locate the relevant code, (2) ONLY use filesystem-read when you know the approximate location and need precise line numbers for editing. **ANTI-PATTERN**: Reading files line-by-line from the top wastes tokens - use search instead! **USAGE**: Call without parameters to read entire file(s), or specify startLine/endLine for partial reads. Returns content with line numbers (format: "123→code") for precise editing. **EXAMPLES**: (A) Unified: filePath=["a.ts", "b.ts"], startLine=1, endLine=50 reads lines 1-50 from both. (B) Per-file: filePath=[{path:"a.ts", startLine:1, endLine:30}, {path:"b.ts", startLine:100, endLine:150}] reads different ranges from each file.',
+        description: 'Read file content with line numbers. **Read only when the actual file or folder path is found or provided by the user, do not make random guesses.** **SUPPORTS MULTIPLE FILES WITH FLEXIBLE LINE RANGES**: Pass either (1) a single file path (string), (2) array of file paths (strings) with unified startLine/endLine, or (3) array of file config objects with per-file line ranges. **INTEGRATED DIRECTORY LISTING**: When filePath is a directory, automatically lists its contents instead of throwing error. ⚠️ **IMPORTANT WORKFLOW**: (1) ALWAYS use ACE search tools FIRST (ace-text_search/ace-search_symbols/ace-file_outline) to locate the relevant code, (2) ONLY use filesystem-read when you know the approximate location and need precise line numbers for editing. **ANTI-PATTERN**: Reading files line-by-line from the top wastes tokens - use search instead! **USAGE**: Call without parameters to read entire file(s), or specify startLine/endLine for partial reads. Returns content with line numbers (format: "123→code") for precise editing. **EXAMPLES**: (A) Unified: filePath=["a.ts", "b.ts"], startLine=1, endLine=500 reads lines 1-500 from both. (B) Per-file: filePath=[{path:"a.ts", startLine:1, endLine:300}, {path:"b.ts", startLine:100, endLine:550}] reads different ranges from each file. (C) Directory: filePath="./src" returns list of files in src/.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -1121,7 +1080,7 @@ export const mcpTools = [
                     oneOf: [
                         {
                             type: 'string',
-                            description: 'Path to a single file to read',
+                            description: 'Path to a single file to read or directory to list',
                         },
                         {
                             type: 'array',
@@ -1153,7 +1112,7 @@ export const mcpTools = [
                             description: 'Array of file config objects with per-file line ranges. Each file can have its own startLine/endLine.',
                         },
                     ],
-                    description: 'Path to the file(s) to read: string, array of strings, or array of {path, startLine?, endLine?} objects',
+                    description: 'Path to the file(s) to read or directory to list: string, array of strings, or array of {path, startLine?, endLine?} objects',
                 },
                 startLine: {
                     type: 'number',
@@ -1190,53 +1149,9 @@ export const mcpTools = [
             required: ['filePath', 'content'],
         },
     },
-    {
-        name: 'filesystem-delete',
-        description: 'Delete one or multiple files. Supports both single file and batch deletion.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                filePath: {
-                    type: 'string',
-                    description: 'Path to a single file to delete (deprecated: use filePaths for single or multiple files)',
-                },
-                filePaths: {
-                    oneOf: [
-                        {
-                            type: 'string',
-                            description: 'Path to a single file to delete',
-                        },
-                        {
-                            type: 'array',
-                            items: {
-                                type: 'string',
-                            },
-                            description: 'Array of file paths to delete',
-                        },
-                    ],
-                    description: 'Single file path or array of file paths to delete',
-                },
-            },
-            // Make both optional, but at least one is required (validated in code)
-        },
-    },
-    {
-        name: 'filesystem-list',
-        description: 'List files in a directory',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                dirPath: {
-                    type: 'string',
-                    description: 'Directory path to list files from',
-                    default: '.',
-                },
-            },
-        },
-    },
     {
         name: 'filesystem-edit_search',
-        description: '**RECOMMENDED** for most edits: Search-and-replace with SMART FUZZY MATCHING. **SUPPORTS BATCH EDITING**: Pass (1) single file with search/replace, (2) array of file paths with unified search/replace, or (3) array of {path, searchContent, replaceContent, occurrence?} for per-file edits. **WORKFLOW**: (1) Use ace-text_search/ace-search_symbols to locate code, (2) Use filesystem-read to view content, (3) Copy code blocks (without line numbers), (4) Use THIS tool. **WHY**: No line tracking, auto-handles spacing/tabs, finds best match. **BATCH EXAMPLE**: filePath=[{path:"a.ts", searchContent:"old1", replaceContent:"new1"}, {path:"b.ts", searchContent:"old2", replaceContent:"new2"}] **It is very important to use the filesystem-read tool to determine the code boundaries of the area that need to be modified first to avoid syntactic errors**',
+        description: 'RECOMMENDED for most edits: Search-and-replace with SMART FUZZY MATCHING. SUPPORTS BATCH EDITING: Pass (1) single file with search/replace, (2) array of file paths with unified search/replace, or (3) array of {path, searchContent, replaceContent, occurrence?} for per-file edits. CRITICAL WORKFLOW FOR CODE SAFETY: (1) Use ace-text_search/ace-search_symbols to locate code, (2) MUST use filesystem-read to identify COMPLETE code boundaries (entire function body with all braces, complete markup tags with opening/closing pairs, full code blocks), (3) Copy the COMPLETE code block (without line numbers), (4) Verify boundaries are intact (matching braces/brackets/tags), (5) Use THIS tool. WHY: No line tracking, auto-handles spacing/tabs, finds best match. COMMON ERRORS TO AVOID: Modifying only part of a function (missing closing brace), incomplete markup tags (HTML/Vue/JSX), partial code blocks. Always include complete syntactic units. BATCH EXAMPLE: filePath=[{path:"a.ts", searchContent:"old1", replaceContent:"new1"}, {path:"b.ts", searchContent:"old2", replaceContent:"new2"}]',
         inputSchema: {
             type: 'object',
             properties: {
@@ -1306,7 +1221,7 @@ export const mcpTools = [
     },
     {
         name: 'filesystem-edit',
-        description: 'Line-based editing for precise control. **SUPPORTS BATCH EDITING**: Pass (1) single file with line range, (2) array of file paths with unified line range, or (3) array of {path, startLine, endLine, newContent} for per-file edits. **WHEN TO USE**: (1) Adding new code sections, (2) Deleting specific line ranges, (3) When search-replace not suitable. **WORKFLOW**: (1) Use ace-text_search/ace-file_outline to locate area, (2) Use filesystem-read to get line numbers, (3) Use THIS tool. **RECOMMENDATION**: For modifying existing code, use filesystem-edit_search - safer. **BATCH EXAMPLE**: filePath=[{path:"a.ts", startLine:10, endLine:20, newContent:"..."}, {path:"b.ts", startLine:50, endLine:60, newContent:"..."}] **It is very important to use the filesystem-read tool to determine the code boundaries of the area that need to be modified first to avoid syntactic errors**',
+        description: 'Line-based editing for precise control. SUPPORTS BATCH EDITING: Pass (1) single file with line range, (2) array of file paths with unified line range, or (3) array of {path, startLine, endLine, newContent} for per-file edits. WHEN TO USE: (1) Adding new code sections, (2) Deleting specific line ranges, (3) When search-replace not suitable. CRITICAL WORKFLOW FOR CODE SAFETY: (1) Use ace-text_search/ace-file_outline to locate area, (2) MUST use filesystem-read to identify COMPLETE code boundaries - for functions: include opening line to closing brace; for markup tags (HTML/Vue/JSX): include opening tag to closing tag; for code blocks: include all braces/brackets, (3) Verify line range covers the ENTIRE syntactic unit (check indentation levels, matching pairs), (4) Use THIS tool with exact startLine/endLine. RECOMMENDATION: For modifying existing code, use filesystem-edit_search - safer and no line tracking needed. COMMON ERRORS TO AVOID: Line range stops mid-function (missing closing brace), partial markup tags, incomplete code blocks. Always verify boundaries with filesystem-read first. BATCH EXAMPLE: filePath=[{path:"a.ts", startLine:10, endLine:20, newContent:"..."}, {path:"b.ts", startLine:50, endLine:60, newContent:"..."}]',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/mcp/subagent.d.ts

@@ -1,11 +1,12 @@
 import type { SubAgentMessage } from '../utils/subAgentExecutor.js';
 import type { ToolCall } from '../utils/toolExecutor.js';
+import type { ConfirmationResult } from '../ui/components/ToolConfirmation.js';
 export interface SubAgentToolExecutionOptions {
     agentId: string;
     prompt: string;
     onMessage?: (message: SubAgentMessage) => void;
     abortSignal?: AbortSignal;
-    requestToolConfirmation?: (toolCall: ToolCall, batchToolNames?: string, allTools?: ToolCall[]) => Promise<string>;
+    requestToolConfirmation?: (toolCall: ToolCall, batchToolNames?: string, allTools?: ToolCall[]) => Promise<ConfirmationResult>;
     isToolAutoApproved?: (toolName: string) => boolean;
     yoloMode?: boolean;
     addToAlwaysApproved?: (toolName: string) => void;

package/dist/mcp/subagent.js

@@ -1,5 +1,5 @@
 import { executeSubAgent } from '../utils/subAgentExecutor.js';
-import { getSubAgents } from '../utils/subAgentConfig.js';
+import { getUserSubAgents } from '../utils/subAgentConfig.js';
 /**
  * Sub-Agent MCP Service
  * Provides tools for executing sub-agents with their own specialized system prompts and tool access
@@ -32,14 +32,62 @@ export class SubAgentService {
         return {
             success: true,
             result: result.result,
+            usage: result.usage,
         };
     }
     /**
      * Get all available sub-agents as MCP tools
      */
     getTools() {
-        const subAgents = getSubAgents();
-        return subAgents.map(agent => ({
+        // Get only user-configured agents (built-in agents are hardcoded below)
+        const userAgents = getUserSubAgents();
+        // Built-in agents (hardcoded, always available)
+        const tools = [
+            {
+                name: 'agent_explore',
+                description: 'Explore Agent: Specialized for quickly exploring and understanding codebases. Excels at searching code, finding definitions, analyzing code structure and dependencies. Read-only operations, will not modify files or execute commands.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        prompt: {
+                            type: 'string',
+                            description: 'CRITICAL: Provide COMPLETE context from main session. Sub-agent has NO access to main conversation history. Include: (1) Full task description with business requirements, (2) Known file locations and code paths, (3) Relevant code snippets or patterns already discovered, (4) Any constraints or important context. Example: "Explore authentication implementation. Main flow uses OAuth in src/auth/oauth.ts, need to find all related error handling. User mentioned JWT tokens are validated in middleware."',
+                        },
+                    },
+                    required: ['prompt'],
+                },
+            },
+            {
+                name: 'agent_plan',
+                description: 'Plan Agent: Specialized for planning complex tasks. Analyzes requirements, explores code, identifies relevant files, and creates detailed implementation plans. Read-only operations, outputs structured implementation proposals.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        prompt: {
+                            type: 'string',
+                            description: 'CRITICAL: Provide COMPLETE context from main session. Sub-agent has NO access to main conversation history. Include: (1) Full requirement details and business objectives, (2) Current architecture/file structure understanding, (3) Known dependencies and constraints, (4) Files/modules already identified that need changes, (5) User preferences or specific implementation approaches mentioned. Example: "Plan caching implementation. Current API uses Express in src/server.ts, data layer in src/models/. Need Redis caching, user wants minimal changes to existing controllers in src/controllers/."',
+                        },
+                    },
+                    required: ['prompt'],
+                },
+            },
+            {
+                name: 'agent_general',
+                description: 'General Purpose Agent: General-purpose multi-step task execution agent. Has full tool access for searching, modifying files, and executing commands. Best for complex tasks requiring actual operations.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        prompt: {
+                            type: 'string',
+                            description: 'CRITICAL: Provide COMPLETE context from main session. Sub-agent has NO access to main conversation history. Include: (1) Full task description with step-by-step requirements, (2) Exact file paths and locations to modify, (3) Code patterns/snippets to follow or replicate, (4) Dependencies between files/changes, (5) Testing/verification requirements, (6) Any business logic or constraints discovered in main session. Example: "Update error handling across API. Files: src/api/users.ts, src/api/posts.ts, src/api/comments.ts. Replace old pattern try-catch with new ErrorHandler class from src/utils/errorHandler.ts. Must preserve existing error codes. Run npm test after changes."',
+                        },
+                    },
+                    required: ['prompt'],
+                },
+            },
+        ];
+        // Add user-configured agents (avoid duplicates with built-in)
+        tools.push(...userAgents.map(agent => ({
             name: agent.id,
             description: `${agent.name}: ${agent.description}`,
             inputSchema: {
@@ -47,12 +95,13 @@ export class SubAgentService {
                 properties: {
                     prompt: {
                         type: 'string',
-                        description: 'The task prompt to send to the sub-agent',
+                        description: 'CRITICAL: Provide COMPLETE context from main session. Sub-agent has NO access to main conversation history. Include all relevant: (1) Task requirements and objectives, (2) Known file locations and code structure, (3) Business logic and constraints, (4) Code patterns or examples, (5) Dependencies and relationships. Be specific and comprehensive - sub-agent cannot ask for clarification from main session.',
                     },
                 },
                 required: ['prompt'],
             },
-        }));
+        })));
+        return tools;
     }
 }
 // Export a default instance