minovative-mind-cli 2.9.1 → 2.11.0

package/dist/services/orchestration/investigationAgent.js

@@ -135,56 +135,63 @@ export class InvestigationAgentRunner {
                     success = true;
                     break;
                 }
-                const functionResponses = [];
-                for (const call of functionCalls) {
-                    if (crashed || abortSignal.aborted)
-                        break;
+                let isFinished = false;
+                if (onTool) {
+                    for (const call of functionCalls) {
+                        onTool(formatToolCall(call.name, (call.args || {})));
+                    }
+                }
+                // Execute tool calls concurrently while preserving 1:1 Gemini response positional ordering
+                const functionResponses = await Promise.all(functionCalls.map(async (call) => {
+                    if (crashed || abortSignal.aborted) {
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { error: 'Operation aborted or agent stopped.' },
+                            },
+                        };
+                    }
                     this.pingHeartbeat();
-                    const args = call.args;
+                    const args = (call.args || {});
                     const logPrefix = `[${this.agentLabel}]`;
-                    if (onTool) {
-                        onTool(formatToolCall(call.name, args));
-                    }
                     if (call.name === 'finish_investigation') {
                         summary = args.summary || '';
                         const filesToRead = args.relevantFiles || [];
                         if (onProgress)
                             onProgress(`${logPrefix} Finished investigation (${filesToRead.length} files)`);
                         debugLog(`InvestigationAgent ${logPrefix}: Finished. Selected files: ${JSON.stringify(filesToRead)}`);
-                        for (const filePath of filesToRead) {
-                            if (!relevantFiles.has(filePath)) {
-                                // Check shared cache first
-                                if (this.readCache.has(filePath)) {
-                                    relevantFiles.set(filePath, this.readCache.get(filePath));
-                                }
-                                else {
-                                    const readResult = await readFile(this.workspaceRoot, filePath);
-                                    if (!readResult.error) {
-                                        const contentObj = { text: readResult.output, inlineData: readResult.inlineData };
-                                        relevantFiles.set(filePath, contentObj);
-                                        this.readCache.set(filePath, contentObj);
-                                    }
+                        await Promise.all(filesToRead.map(async (filePath) => {
+                            if (this.readCache.has(filePath)) {
+                                relevantFiles.set(filePath, this.readCache.get(filePath));
+                            }
+                            else {
+                                const readResult = await readFile(this.workspaceRoot, filePath);
+                                if (!readResult.error) {
+                                    const contentObj = { text: readResult.output, inlineData: readResult.inlineData };
+                                    relevantFiles.set(filePath, contentObj);
+                                    this.readCache.set(filePath, contentObj);
                                 }
                             }
-                        }
+                        }));
                         isFinished = true;
                         success = true;
-                        functionResponses.push({
-                            functionResponse: { name: call.name, response: { output: 'Investigation finished.' } },
-                        });
-                        break;
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { output: 'Investigation finished.' },
+                            },
+                        };
                     }
                     else if (call.name === 'select_files') {
                         const filesToRead = args.files || [];
                         if (onProgress)
                             onProgress(`${logPrefix} Selected ${filesToRead.length} files`);
-                        let output = '';
-                        for (const filePath of filesToRead) {
+                        const fileOutputs = await Promise.all(filesToRead.map(async (filePath) => {
                             // Check cache first
                             if (this.readCache.has(filePath)) {
                                 const cached = this.readCache.get(filePath);
                                 relevantFiles.set(filePath, cached);
-                                output += `\n--- File: ${filePath} ---\n${cached.text}\n`;
+                                return `\n--- File: ${filePath} ---\n${cached.text}\n`;
                             }
                             else {
                                 const readResult = await readFile(this.workspaceRoot, filePath);
@@ -192,99 +199,98 @@ export class InvestigationAgentRunner {
                                     const contentObj = { text: readResult.output, inlineData: readResult.inlineData };
                                     relevantFiles.set(filePath, contentObj);
                                     this.readCache.set(filePath, contentObj);
-                                    output += `\n--- File: ${filePath} ---\n${readResult.output}\n`;
+                                    return `\n--- File: ${filePath} ---\n${readResult.output}\n`;
                                 }
                                 else {
-                                    output += `\n--- File: ${filePath} ---\nError: ${readResult.error}\n`;
+                                    return `\n--- File: ${filePath} (Error: ${readResult.error}) ---\n`;
                                 }
                             }
-                        }
-                        functionResponses.push({
-                            functionResponse: { name: call.name, response: { output: output || 'No files read.' } },
-                        });
+                        }));
+                        const output = fileOutputs.join('');
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { output: output || 'No files selected.' },
+                            },
+                        };
                     }
                     else if (call.name === 'list_directory') {
                         if (onProgress)
-                            onProgress(`${logPrefix} Listing: ${args.dirPath}`);
-                        const listRes = await listDirectory(this.workspaceRoot, args.dirPath, args.maxDepth || 1);
-                        functionResponses.push({
+                            onProgress(`${logPrefix} Listing directory: ${args.dirPath || '.'}`);
+                        const listRes = await listDirectory(this.workspaceRoot, args.dirPath || '.', args.maxDepth);
+                        return {
                             functionResponse: {
                                 name: call.name,
-                                response: { output: listRes.output, ...(listRes.error ? { error: listRes.error } : {}) },
+                                response: {
+                                    output: listRes.output,
+                                    ...(listRes.error ? { error: listRes.error } : {}),
+                                },
                             },
-                        });
+                        };
                     }
                     else if (call.name === 'search_codebase') {
                         if (onProgress)
                             onProgress(`${logPrefix} Searching: "${args.pattern}"`);
-                        const grepRes = await grepSearch(this.workspaceRoot, args.pattern, args.fileGlob);
-                        functionResponses.push({
-                            functionResponse: { name: call.name, response: { output: grepRes.error ? grepRes.error : grepRes.output } },
-                        });
+                        const grepRes = await grepSearch(this.workspaceRoot, args.pattern || '', args.fileGlob, args.fixedStrings, args.dirPath);
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { output: grepRes.error ? grepRes.error : grepRes.output },
+                            },
+                        };
                     }
                     else if (call.name === 'read_file') {
-                        const filePath = args.filePath;
+                        const filePath = args.filePath || '';
+                        const startLine = args.startLine;
+                        const endLine = args.endLine;
+                        const targetElements = args.targetElements;
                         if (onProgress)
                             onProgress(`${logPrefix} Reading: ${filePath}`);
-                        // Check cache for full-file reads (no line range or target elements)
-                        if (!args.startLine && !args.endLine && !args.targetElements && this.readCache.has(filePath)) {
+                        // Check read cache only for full-file reads
+                        if (this.readCache.has(filePath) && !startLine && !endLine && (!targetElements || targetElements.length === 0)) {
                             const cached = this.readCache.get(filePath);
                             relevantFiles.set(filePath, cached);
-                            functionResponses.push({ functionResponse: { name: call.name, response: { output: cached.text } } });
+                            return {
+                                functionResponse: {
+                                    name: call.name,
+                                    response: { output: cached.text },
+                                },
+                            };
                         }
-                        else {
-                            const readRes = await readFile(this.workspaceRoot, filePath, args.startLine, args.endLine, args.targetElements);
-                            if (!readRes.error) {
-                                const contentObj = { text: readRes.output, inlineData: readRes.inlineData };
-                                relevantFiles.set(filePath, contentObj);
-                                // Only cache full-file reads (partial reads shouldn't overwrite full content)
-                                if (!args.startLine && !args.endLine && !args.targetElements) {
-                                    this.readCache.set(filePath, contentObj);
-                                }
-                            }
-                            functionResponses.push({
-                                functionResponse: { name: call.name, response: { output: readRes.error ? readRes.error : readRes.output } },
-                            });
-                        }
-                    }
-                    else if (call.name === 'perform_web_search') {
-                        if (onProgress)
-                            onProgress(`${logPrefix} Web search: "${args.query}"`);
-                        try {
-                            const { createWebSearchAgentSession } = await import('../ai.js');
-                            const webSession = createWebSearchAgentSession();
-                            const webResult = await webSession.sendMessage(`Please search the web for the following query and summarize your findings:\n"${args.query}"`, undefined, abortSignal, () => this.pingHeartbeat());
-                            const searchSummary = webResult.response.text()?.trim() || 'No relevant information found.';
-                            webSearchSummary += `\nQuery: ${args.query}\nFindings:\n${searchSummary}\n`;
-                            functionResponses.push({ functionResponse: { name: call.name, response: { output: searchSummary } } });
-                        }
-                        catch (e) {
-                            functionResponses.push({
-                                functionResponse: { name: call.name, response: { error: e.message || 'Failed to search the web' } },
-                            });
+                        const readRes = await readFile(this.workspaceRoot, filePath, startLine, endLine, targetElements);
+                        if (!readRes.error && !startLine && !endLine && (!targetElements || targetElements.length === 0)) {
+                            const contentObj = { text: readRes.output, inlineData: readRes.inlineData };
+                            relevantFiles.set(filePath, contentObj);
+                            this.readCache.set(filePath, contentObj);
                         }
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { output: readRes.error ? readRes.error : readRes.output },
+                            },
+                        };
                     }
                     else if (call.name === 'find_dependencies') {
                         if (onProgress)
                             onProgress(`${logPrefix} Tracing dependencies: ${args.filePath}`);
                         const depResult = await traceDependencies(this.workspaceRoot, args.filePath, args.direction, args.maxDepth);
-                        functionResponses.push({
+                        return {
                             functionResponse: {
                                 name: call.name,
                                 response: { output: depResult.error ? depResult.error : depResult.output },
                             },
-                        });
+                        };
                     }
                     else if (call.name === 'find_recent_changes') {
                         if (onProgress)
                             onProgress(`${logPrefix} Finding recent changes`);
                         const recentRes = await findRecentChanges(this.workspaceRoot, args.dirPath, args.minutes, args.maxDepth);
-                        functionResponses.push({
+                        return {
                             functionResponse: {
                                 name: call.name,
                                 response: { output: recentRes.error ? recentRes.error : recentRes.output },
                             },
-                        });
+                        };
                     }
                     else if (call.name === 'run_analysis_script') {
                         if (onProgress)
@@ -295,9 +301,20 @@ export class InvestigationAgentRunner {
                         const output = analysisResult.exitCode === 0
                             ? analysisResult.stdout || '(script produced no output)'
                             : `Script failed (exit ${analysisResult.exitCode}):\n${analysisResult.stderr}`;
-                        functionResponses.push({ functionResponse: { name: call.name, response: { output } } });
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { output },
+                            },
+                        };
                     }
-                }
+                    return {
+                        functionResponse: {
+                            name: call.name,
+                            response: { output: `Unknown tool: ${call.name}` },
+                        },
+                    };
+                }));
                 if (crashed || abortSignal.aborted || isFinished)
                     break;
                 // Feed tool results back to the model

package/dist/services/orchestration/investigationCache.d.ts

@@ -1,25 +1,100 @@
+export interface SemanticMetadata {
+    topics: string[];
+    components: string[];
+    intent: string;
+    reasoning?: string;
+}
 export interface InvestigationCacheEntry {
     promptHash: string;
+    normalizedPrompt: string;
+    topics?: string[];
+    components?: string[];
+    intent?: string;
+    semanticSignature?: string;
     relevantFiles: string[];
     summary: string;
     workspaceFingerprint: string;
     createdAt: number;
+    lastAccessedAt: number;
+    hitCount?: number;
 }
 export interface InvestigationCacheStore {
     entries: Record<string, InvestigationCacheEntry>;
+    totalHits?: number;
+    totalMisses?: number;
+}
+export interface LookupInvestigationOptions {
+    abortSignal?: AbortSignal;
+    allowSemanticFallback?: boolean;
+    semanticSession?: any;
+    onProgress?: (message: string) => void;
+    fuzzyThreshold?: number;
+    semanticThreshold?: number;
 }
+export interface LookupInvestigationResult {
+    entry: InvestigationCacheEntry;
+    bytesSaved: number;
+    matchTier: 'exact' | 'fuzzy' | 'semantic';
+    similarityScore?: number;
+}
+export declare const MAX_CACHE_SIZE_BYTES: number;
+export declare const DEFAULT_FUZZY_THRESHOLD = 0.85;
+export declare const DEFAULT_SEMANTIC_THRESHOLD = 0.7;
+/**
+ * Normalizes prompt by trimming, collapsing whitespace, and stripping common conversation prefixes.
+ */
 export declare function normalizePrompt(prompt: string): string;
+/**
+ * Computes SHA-256 hash of a normalized prompt string.
+ */
 export declare function hashPrompt(normalized: string): string;
+/**
+ * Generates a deterministic signature from topics, components, and intent.
+ */
+export declare function generateSemanticSignature(topics: string[], components: string[], intent?: string): string;
+/**
+ * Offline heuristic semantic metadata extractor.
+ */
+export declare function extractHeuristicSemanticMetadata(prompt: string, relevantFiles?: string[]): SemanticMetadata;
+/**
+ * Classifies prompt semantic intent and entity tags using AI or offline heuristic fallback.
+ */
+export declare function classifySemanticIntent(userPrompt: string, abortSignal?: AbortSignal, customSession?: any, timeoutMs?: number): Promise<SemanticMetadata | null>;
+/**
+ * Computes a SHA-256 fingerprint of the relevant files' mtime and sizes.
+ */
 export declare function generateWorkspaceFingerprint(workspaceRoot: string, relevantFiles: string[]): Promise<string>;
-export declare function lookupInvestigation(workspaceRoot: string, userPrompt: string): Promise<{
-    entry: InvestigationCacheEntry;
-    bytesSaved: number;
-} | null>;
-export declare function saveInvestigation(workspaceRoot: string, userPrompt: string, relevantFiles: string[], summary: string): Promise<void>;
+/**
+ * Enforces LRU eviction to keep cache store below MAX_CACHE_SIZE_BYTES (5MB).
+ */
+export declare function pruneCacheStore(store: InvestigationCacheStore): void;
+/**
+ * Looks up cached investigation results using a 2-Tier matching pipeline:
+ * - Tier 1A: Exact hash match
+ * - Tier 1B: Local fuzzy Levenshtein & token similarity match
+ * - Tier 2: AI semantic topic & component classification match
+ * All candidates validate the workspace fingerprint before returning.
+ */
+export declare function lookupInvestigation(workspaceRoot: string, userPrompt: string, options?: LookupInvestigationOptions): Promise<LookupInvestigationResult | null>;
+/**
+ * Saves investigation context with semantic tagging, workspace fingerprint, and LRU pruning.
+ */
+export declare function saveInvestigation(workspaceRoot: string, userPrompt: string, relevantFiles: string[], summary: string, semanticMetadata?: Partial<SemanticMetadata>, abortSignal?: AbortSignal): Promise<void>;
+/**
+ * Invalidates cache entries that reference any changed files.
+ */
 export declare function invalidateFilesFromInvestigationCache(workspaceRoot: string, changedFiles: string[]): Promise<void>;
+/**
+ * Clears all entries in the investigation cache.
+ */
+export declare function clearInvestigationCache(workspaceRoot: string): void;
+/**
+ * Returns cache statistics for inspection and telemetry.
+ */
 export declare function getInvestigationCacheStats(workspaceRoot: string): {
     entries: number;
     sizeBytes: number;
     hitCount: number;
     missCount: number;
+    topicsCount: number;
 };