minovative-mind-cli 2.10.0 → 2.11.2

package/dist/services/contextAgent.js

@@ -9,7 +9,48 @@ import { debugLog } from '../utils/logger.js';
 import { buildDependencyGraph } from '../utils/dependencyTracer.js';
 import { runEphemeralScript } from '../utils/analysisRunner.js';
 import { getMetricCollector } from './metrics.js';
+import { estimateTokenCount, pruneTextToTokenBudget } from '../utils/historyPrompt.js';
 const metrics = getMetricCollector();
+/** Token budget constants for context optimization */
+const MAX_TREE_TOKENS = 12000;
+const MAX_CHAT_HISTORY_ROUTER_TOKENS = 3000;
+const MAX_CHAT_HISTORY_INVESTIGATION_TOKENS = 4500;
+const MAX_SINGLE_FILE_TOKENS = 25000;
+const MAX_TOTAL_FILE_TOKENS = 150000;
+const MAX_TOTAL_FILES = 30;
+const MAX_TOOL_OUTPUT_TOKENS = 10000;
+/**
+ * Bounds individual file content to ensure it does not exceed the single-file token budget.
+ *
+ * @param filePath The file path.
+ * @param content Raw file text.
+ * @returns Budget-constrained file text.
+ */
+function boundFileContent(filePath, content) {
+    const tokens = estimateTokenCount(content);
+    if (tokens <= MAX_SINGLE_FILE_TOKENS) {
+        return content;
+    }
+    debugLog(`Truncating large file context for ${filePath}: ${tokens} tokens -> capped at ${MAX_SINGLE_FILE_TOKENS}`);
+    return pruneTextToTokenBudget(content, MAX_SINGLE_FILE_TOKENS, {
+        truncationMarker: `\n\n... [File content truncated by Context Agent: ${tokens} estimated tokens exceeded the ${MAX_SINGLE_FILE_TOKENS} token limit. Use read_file with line ranges if specific sections are needed.] ...\n\n`,
+    });
+}
+/**
+ * Bounds tool output text to prevent massive outputs from blowing the context window during investigation turns.
+ *
+ * @param output Raw tool output string.
+ * @returns Budget-constrained tool output.
+ */
+function boundToolOutput(output) {
+    const tokens = estimateTokenCount(output);
+    if (tokens <= MAX_TOOL_OUTPUT_TOKENS) {
+        return output;
+    }
+    return pruneTextToTokenBudget(output, MAX_TOOL_OUTPUT_TOKENS, {
+        truncationMarker: `\n\n... [Tool output truncated: exceeded ${MAX_TOOL_OUTPUT_TOKENS} tokens limit] ...\n`,
+    });
+}
 async function detectProjectType(workspaceRoot) {
     const types = [];
     const fileExists = async (fileName) => {
@@ -149,7 +190,8 @@ export async function routeIntent(userRequest, chatHistory = '', abortSignal) {
         const session = createIntentRouterSession();
         let prompt = `User Request: "${userRequest}"`;
         if (chatHistory) {
-            prompt = `Previous Conversation Context:\n${chatHistory}\n\n${prompt}`;
+            const prunedHistory = pruneTextToTokenBudget(chatHistory, MAX_CHAT_HISTORY_ROUTER_TOKENS, { fromStart: true });
+            prompt = `Previous Conversation Context:\n${prunedHistory}\n\n${prompt}`;
         }
         const result = await session.sendMessage(prompt, undefined, abortSignal);
         const text = result.response.text()?.trim() || '{}';
@@ -183,7 +225,8 @@ export async function evaluateExecutionComplexity(userRequest, investigationSumm
 Investigation Summary: ${investigationSummary || 'None (0 files needed)'}
 Number of Relevant Files: ${numRelevantFiles}`;
         if (chatHistory) {
-            prompt = `Previous Conversation Context:\n${chatHistory}\n\n${prompt}`;
+            const prunedHistory = pruneTextToTokenBudget(chatHistory, MAX_CHAT_HISTORY_ROUTER_TOKENS, { fromStart: true });
+            prompt = `Previous Conversation Context:\n${prunedHistory}\n\n${prompt}`;
         }
         const result = await session.sendMessage(prompt, undefined, abortSignal);
         const text = result.response.text()?.trim() || '{}';
@@ -235,8 +278,11 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
         const label = alias ? `@${alias} (${root})` : `Primary Workspace (${root})`;
         const treeResult = await executeTool(root, 'list_directory', { dirPath: '.', maxDepth: 10 });
         let tree = treeResult.output;
-        if (tree.length > 30000) {
-            tree = tree.substring(0, 30000) + '\n... (Project tree truncated due to size)';
+        const treeTokens = estimateTokenCount(tree);
+        if (treeTokens > MAX_TREE_TOKENS) {
+            tree = pruneTextToTokenBudget(tree, MAX_TREE_TOKENS, {
+                truncationMarker: '\n... (Project tree truncated to fit token budget)\n',
+            });
         }
         const type = await detectProjectType(root);
         if (!alias) {
@@ -275,20 +321,27 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
         if (onProgress)
             onProgress(`⚡ Memory Bank HIT — loaded ${cacheHit.entry.relevantFiles.length} files from cache`);
         const cachedFiles = new Map();
-        for (const filePath of cacheHit.entry.relevantFiles) {
-            if (abortSignal.aborted) {
-                const err = new Error('Operation aborted');
-                err.name = 'AbortError';
-                throw err;
-            }
+        let cumulativeFileTokens = 0;
+        const readResults = await Promise.all(cacheHit.entry.relevantFiles.map(async (filePath) => {
+            if (abortSignal.aborted)
+                return { filePath, error: 'aborted' };
             const readResult = await executeTool(workspaceRoot, 'read_file', { filePath });
-            if (!readResult.error) {
-                cachedFiles.set(filePath, { text: readResult.output, inlineData: readResult.inlineData });
+            return { filePath, readResult };
+        }));
+        for (const item of readResults) {
+            if (item.readResult && !item.readResult.error) {
+                const boundedText = boundFileContent(item.filePath, item.readResult.output);
+                const tokens = estimateTokenCount(boundedText);
+                if (cumulativeFileTokens + tokens <= MAX_TOTAL_FILE_TOKENS) {
+                    cachedFiles.set(item.filePath, { text: boundedText, inlineData: item.readResult.inlineData });
+                    cumulativeFileTokens += tokens;
+                }
             }
         }
         const MAX_TOTAL_FILES = 30;
         try {
             const { resolveAndValidateMultiWorkspacePath } = await import('../utils/pathSecurity.js');
+            const depsToRead = [];
             const autoDiscovered = new Set();
             for (const filePath of cacheHit.entry.relevantFiles) {
                 if (abortSignal.aborted)
@@ -298,21 +351,34 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                     const graph = await buildDependencyGraph(resolved.workspaceRoot);
                     const reverseDeps = graph.getImportedBy(resolved.relativePath);
                     for (const dep of reverseDeps) {
-                        if (abortSignal.aborted)
-                            break;
                         if (cachedFiles.has(dep) || autoDiscovered.has(dep))
                             continue;
                         if (cachedFiles.size + autoDiscovered.size >= MAX_TOTAL_FILES)
                             break;
                         autoDiscovered.add(dep);
-                        const depReadRes = await executeTool(resolved.workspaceRoot, 'read_file', { filePath: dep });
-                        if (!depReadRes.error) {
-                            cachedFiles.set(dep, { text: depReadRes.output, inlineData: depReadRes.inlineData });
-                        }
+                        depsToRead.push({ dep, resolvedWorkspace: resolved.workspaceRoot });
                     }
                 }
                 catch (e) { }
             }
+            if (depsToRead.length > 0) {
+                const depResults = await Promise.all(depsToRead.map(async ({ dep, resolvedWorkspace }) => {
+                    if (abortSignal.aborted)
+                        return { dep, error: 'aborted' };
+                    const depReadRes = await executeTool(resolvedWorkspace, 'read_file', { filePath: dep });
+                    return { dep, depReadRes };
+                }));
+                for (const item of depResults) {
+                    if (item.depReadRes && !item.depReadRes.error) {
+                        const boundedText = boundFileContent(item.dep, item.depReadRes.output);
+                        const tokens = estimateTokenCount(boundedText);
+                        if (cumulativeFileTokens + tokens <= MAX_TOTAL_FILE_TOKENS) {
+                            cachedFiles.set(item.dep, { text: boundedText, inlineData: item.depReadRes.inlineData });
+                            cumulativeFileTokens += tokens;
+                        }
+                    }
+                }
+            }
         }
         catch (e) { }
         const { accumulateUsage } = await import('./metrics.js');
@@ -352,10 +418,12 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     let isInvestigationFinished = false;
     let chainedMessages = [];
     let webSearchSummary = '';
-    // Initial prompt
+    let cumulativeFileTokens = 0;
+    // Initial prompt with history budget management
     let currentMessage = `User Request: "${userRequest}"\n\nProject Type: ${projectType}\n\nProject Structure:\n${projectTree}`;
     if (chatHistory) {
-        currentMessage = `Previous Conversation Context:\n${chatHistory}\n\n` + currentMessage;
+        const prunedHistory = pruneTextToTokenBudget(chatHistory, MAX_CHAT_HISTORY_INVESTIGATION_TOKENS, { fromStart: true });
+        currentMessage = `Previous Conversation Context:\n${prunedHistory}\n\n` + currentMessage;
     }
     currentMessage += `\n\nStart investigating to find relevant files.`;
     const MAX_TURNS = Infinity;
@@ -403,11 +471,11 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
             break;
         }
         let isFinished = false;
-        const functionResponses = [];
+        // Log progress for all requested tool calls in this turn
         for (const call of functionCalls) {
             if (abortSignal.aborted)
                 break;
-            const args = call.args;
+            const args = (call.args || {});
             let logMsg = `  [Context Agent] Executing ${call.name}`;
             if (call.name === 'finish_investigation') {
                 const filesToRead = args.relevantFiles || [];
@@ -434,69 +502,84 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 logMsg = `  [Context Agent] Looking for recently modified files`;
             }
             else if (call.name === 'run_analysis_script') {
-                const target = args.targetFile ? ` for: ${args.targetFile}` : '';
-                logMsg = `  [Context Agent] Running analysis script${target}`;
-            }
-            const cleanMsg = logMsg.trim().replace(/^\[Context Agent\] /, '');
-            if (onToolCall) {
-                onToolCall(cleanMsg, 'Context Agent');
+                logMsg = `  [Context Agent] Running analysis script (${args.language})`;
             }
-            else if (onProgress) {
-                onProgress(cleanMsg);
+            if (onProgress) {
+                onProgress(logMsg.trim());
             }
             else {
                 console.log(pc.dim(logMsg));
             }
+        }
+        // Execute tool calls concurrently while preserving 1:1 Gemini response positional ordering
+        const functionResponses = await Promise.all(functionCalls.map(async (call) => {
+            if (abortSignal.aborted) {
+                return {
+                    functionResponse: {
+                        name: call.name,
+                        response: { error: 'Operation aborted.' },
+                    },
+                };
+            }
+            const args = (call.args || {});
             if (call.name === 'finish_investigation') {
+                isInvestigationFinished = true;
+                isFinished = true;
                 summary = args.summary || '';
                 const filesToRead = args.relevantFiles || [];
-                debugLog(`Context Agent finished. Selected files: ${JSON.stringify(filesToRead)}`);
-                for (const filePath of filesToRead) {
-                    if (!relevantFiles.has(filePath)) {
-                        const readResult = await executeTool(workspaceRoot, 'read_file', { filePath });
-                        if (!readResult.error) {
-                            relevantFiles.set(filePath, { text: readResult.output, inlineData: readResult.inlineData });
-                        }
+                const uniqueFilesToRead = filesToRead.filter((fp) => !relevantFiles.has(fp));
+                const readResults = await Promise.all(uniqueFilesToRead.map(async (filePath) => {
+                    const readResult = await executeTool(workspaceRoot, 'read_file', { filePath });
+                    return { filePath, readResult };
+                }));
+                for (const { filePath, readResult } of readResults) {
+                    if (cumulativeFileTokens >= MAX_TOTAL_FILE_TOKENS)
+                        break;
+                    if (!readResult.error) {
+                        const boundedText = boundFileContent(filePath, readResult.output);
+                        relevantFiles.set(filePath, { text: boundedText, inlineData: readResult.inlineData });
+                        cumulativeFileTokens += estimateTokenCount(boundedText);
                     }
                 }
-                isFinished = true;
-                isInvestigationFinished = true;
-                // ── Auto-trace reverse dependencies ──
-                // When the Context Agent finalizes its investigation, we automatically
-                // discover files that DEPEND ON the selected files. This ensures the
-                // Execution Agent won't break imports when modifying/deleting/renaming.
-                const MAX_TOTAL_FILES = 30;
+                // Auto-trace reverse dependencies for all selected files to include active importers
                 try {
+                    const { buildDependencyGraph } = await import('../utils/dependencyTracer.js');
                     const { resolveAndValidateMultiWorkspacePath } = await import('../utils/pathSecurity.js');
                     const autoDiscovered = new Set();
-                    for (const filePath of filesToRead) {
+                    await Promise.all(filesToRead.map(async (filePath) => {
                         try {
                             const resolved = resolveAndValidateMultiWorkspacePath(workspaceRoot, filePath);
                             const graph = await buildDependencyGraph(resolved.workspaceRoot);
                             const reverseDeps = graph.getImportedBy(resolved.relativePath);
                             for (const dep of reverseDeps) {
                                 const aliasedDep = resolved.alias ? `@${resolved.alias}/${dep}` : dep;
-                                if (!filesToRead.includes(aliasedDep) && !autoDiscovered.has(aliasedDep)) {
+                                if (!filesToRead.includes(aliasedDep)) {
                                     autoDiscovered.add(aliasedDep);
                                 }
                             }
                         }
-                        catch (e) {
+                        catch {
                             // Ignore path resolution errors for trace dependencies
                         }
-                    }
-                    // Merge auto-discovered dependents, respecting the file cap
+                    }));
+                    // Merge auto-discovered dependents, respecting both file count and token budget caps
                     const remaining = MAX_TOTAL_FILES - relevantFiles.size;
+                    const depsToRead = Array.from(autoDiscovered)
+                        .filter((dep) => !relevantFiles.has(dep))
+                        .slice(0, Math.max(0, remaining));
+                    const depReadResults = await Promise.all(depsToRead.map(async (dep) => {
+                        const readResult = await executeTool(workspaceRoot, 'read_file', { filePath: dep });
+                        return { dep, readResult };
+                    }));
                     let added = 0;
-                    for (const dep of autoDiscovered) {
-                        if (added >= remaining)
+                    for (const { dep, readResult } of depReadResults) {
+                        if (relevantFiles.size >= MAX_TOTAL_FILES || cumulativeFileTokens >= MAX_TOTAL_FILE_TOKENS)
                             break;
-                        if (!relevantFiles.has(dep)) {
-                            const readResult = await executeTool(workspaceRoot, 'read_file', { filePath: dep });
-                            if (!readResult.error) {
-                                relevantFiles.set(dep, { text: readResult.output, inlineData: readResult.inlineData });
-                                added++;
-                            }
+                        if (!readResult.error) {
+                            const boundedText = boundFileContent(dep, readResult.output);
+                            relevantFiles.set(dep, { text: boundedText, inlineData: readResult.inlineData });
+                            cumulativeFileTokens += estimateTokenCount(boundedText);
+                            added++;
                         }
                     }
                     if (added > 0) {
@@ -510,46 +593,50 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 catch {
                     // Dependency tracing is best-effort — don't block investigation
                 }
-                functionResponses.push({
+                return {
                     functionResponse: {
                         name: call.name,
                         response: { output: 'Investigation finished.' },
                     },
-                });
-                break;
+                };
             }
             else if (call.name === 'list_directory') {
                 const listRes = await executeTool(workspaceRoot, 'list_directory', args);
-                functionResponses.push({
+                const output = boundToolOutput(listRes.output);
+                return {
                     functionResponse: {
                         name: call.name,
                         response: {
-                            output: listRes.output,
+                            output,
                             ...(listRes.error ? { error: listRes.error } : {}),
                         },
                     },
-                });
+                };
             }
             else if (call.name === 'search_codebase') {
                 const grepRes = await executeTool(workspaceRoot, 'grep_search', { ...args, workspace: 'all' });
-                functionResponses.push({
+                const output = boundToolOutput(grepRes.error ? grepRes.error : grepRes.output);
+                return {
                     functionResponse: {
                         name: call.name,
-                        response: { output: grepRes.error ? grepRes.error : grepRes.output },
+                        response: { output },
                     },
-                });
+                };
             }
             else if (call.name === 'read_file') {
                 const readRes = await executeTool(workspaceRoot, 'read_file', args);
                 if (!readRes.error) {
-                    relevantFiles.set(args.filePath, { text: readRes.output, inlineData: readRes.inlineData });
+                    const boundedText = boundFileContent(args.filePath, readRes.output);
+                    relevantFiles.set(args.filePath, { text: boundedText, inlineData: readRes.inlineData });
+                    cumulativeFileTokens += estimateTokenCount(boundedText);
                 }
-                functionResponses.push({
+                const output = boundToolOutput(readRes.error ? readRes.error : readRes.output);
+                return {
                     functionResponse: {
                         name: call.name,
-                        response: { output: readRes.error ? readRes.error : readRes.output },
+                        response: { output },
                     },
-                });
+                };
             }
             else if (call.name === 'perform_web_search') {
                 try {
@@ -564,56 +651,64 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                             console.log(pc.dim(`  [Web Search] ${webMsg}`));
                     }
                     const searchSummary = webResult.response.text()?.trim() || 'No relevant information found.';
-                    webSearchSummary += `\nQuery: ${args.query}\nFindings:\n${searchSummary}\n`;
-                    functionResponses.push({
+                    const boundedSummary = boundToolOutput(searchSummary);
+                    webSearchSummary += `\nQuery: ${args.query}\nFindings:\n${boundedSummary}\n`;
+                    return {
                         functionResponse: {
                             name: call.name,
-                            response: { output: searchSummary },
+                            response: { output: boundedSummary },
                         },
-                    });
+                    };
                 }
                 catch (e) {
-                    functionResponses.push({
+                    return {
                         functionResponse: {
                             name: call.name,
                             response: { error: e.message || 'Failed to search the web' },
                         },
-                    });
+                    };
                 }
             }
             else if (call.name === 'find_dependencies') {
                 const depResult = await executeTool(workspaceRoot, 'find_dependencies', args);
-                functionResponses.push({
+                const output = boundToolOutput(depResult.error ? depResult.error : depResult.output);
+                return {
                     functionResponse: {
                         name: call.name,
-                        response: { output: depResult.error ? depResult.error : depResult.output },
+                        response: { output },
                     },
-                });
+                };
             }
             else if (call.name === 'find_recent_changes') {
                 const recentRes = await executeTool(workspaceRoot, 'find_recent_changes', args);
-                functionResponses.push({
+                const output = boundToolOutput(recentRes.error ? recentRes.error : recentRes.output);
+                return {
                     functionResponse: {
                         name: call.name,
-                        response: { output: recentRes.error ? recentRes.error : recentRes.output },
+                        response: { output },
                     },
-                });
+                };
             }
             else if (call.name === 'run_analysis_script') {
-                const analysisResult = await runEphemeralScript(workspaceRoot, args.language, args.code, {
-                    abortSignal,
-                });
-                const output = analysisResult.exitCode === 0
+                const analysisResult = await runEphemeralScript(workspaceRoot, args.language, args.code, { abortSignal });
+                const rawOutput = analysisResult.exitCode === 0
                     ? analysisResult.stdout || '(script produced no output)'
                     : `Script failed (exit ${analysisResult.exitCode}):\n${analysisResult.stderr}`;
-                functionResponses.push({
+                const output = boundToolOutput(rawOutput);
+                return {
                     functionResponse: {
                         name: call.name,
                         response: { output },
                     },
-                });
+                };
             }
-        }
+            return {
+                functionResponse: {
+                    name: call.name,
+                    response: { output: `Unknown tool: ${call.name}` },
+                },
+            };
+        }));
         if (isFinished) {
             break;
         }