minovative-mind-cli 2.3.3 → 2.5.0

package/dist/services/ai.js

@@ -1,12 +1,14 @@
-import { GEMINI_MODELS, DEFAULT_MODEL, MAX_OUTPUT_TOKENS } from '../utils/config.js';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { GEMINI_MODELS, DEFAULT_MODEL, MAX_OUTPUT_TOKENS, isByokEnabled } from '../utils/config.js';
 import { getToolDeclarations } from './agent-tools.js';
-import { ProxyClient } from './proxyClient.js';
+import { getMetricCollector } from './metrics.js';
 import { getAuthorizedIdToken } from './auth.js';
 import { debugLog } from '../utils/logger.js';
 import { readCache, writeCache } from '../utils/projectStorage.js';
 import { GENERAL_CHAT_INSTRUCTION, PLAN_EXECUTION_INSTRUCTION, PLAN_MODE_INSTRUCTION, CONTEXT_SYSTEM_INSTRUCTION, INTENT_ROUTER_SYSTEM_INSTRUCTION, WEB_SEARCH_SYSTEM_INSTRUCTION, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
-import { getMetricCollector } from './metrics.js';
 import { workspaceRegistry } from './workspaceRegistry.js';
+import { loadCredentials } from '../utils/credentialStore.js';
+import { ProxyClient, accumulateTurnUsage } from './proxyClient.js';
 function getMultiWorkspaceBlock() {
     const summary = workspaceRegistry.buildPromptSummary();
     if (!summary)
@@ -206,13 +208,57 @@ export class ProxyChatSession {
         // Prune old history before sending to keep payload bounded
         await this.pruneHistory();
         const effectiveGenerationConfig = { ...this.generationConfig };
-        const result = await proxyClient.generateFunctionCallViaProxy(idToken, this.modelName, this.history, this.tools, undefined, // toolConfig
-        this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
-        abortSignal);
+        const byokEnabled = await isByokEnabled();
+        let result;
+        if (byokEnabled) {
+            const creds = await loadCredentials();
+            const genAI = new GoogleGenerativeAI(creds.geminiApiKey);
+            const model = genAI.getGenerativeModel({
+                model: this.modelName,
+                systemInstruction: this.systemInstruction,
+                tools: this.tools,
+            });
+            const chat = model.startChat({
+                history: this.history.slice(0, -1),
+                generationConfig: effectiveGenerationConfig,
+            });
+            const lastMessage = this.history[this.history.length - 1];
+            try {
+                const response = await chat.sendMessage(lastMessage.parts);
+                const responseObj = await response.response;
+                result = {
+                    functionCalls: responseObj.functionCalls(),
+                    parts: responseObj.candidates?.[0]?.content?.parts,
+                    usageMetadata: responseObj.usageMetadata,
+                };
+                if (responseObj.usageMetadata) {
+                    const collector = getMetricCollector();
+                    collector?.accumulateUsage(responseObj.usageMetadata);
+                }
+            }
+            catch (error) {
+                debugLog(`Failed to send message via BYOK: ${error}`);
+                const errorMessage = error?.message || '';
+                if (error?.status === 401 ||
+                    error?.status === 403 ||
+                    errorMessage.includes('API_KEY_INVALID') ||
+                    errorMessage.includes('quota') ||
+                    errorMessage.includes('PERMISSION_DENIED')) {
+                    throw new Error('AI_BYOK_ERROR: Your API key or quota is invalid. Please run /config-key to update your settings.');
+                }
+                throw error;
+            }
+        }
+        else {
+            result = await proxyClient.generateFunctionCallViaProxy(idToken, this.modelName, this.history, this.tools, undefined, // toolConfig
+            this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
+            abortSignal);
+        }
         this.latestUsageMetadata = result.usageMetadata;
         // Track token usage metrics
         if (result.usageMetadata) {
             const collector = getMetricCollector();
+            collector?.accumulateUsage(result.usageMetadata);
             if (collector) {
                 collector.recordTokenUsage(result.usageMetadata.promptTokens || 0, result.usageMetadata.candidatesTokens || 0, result.usageMetadata.cachedTokens || 0);
             }
@@ -306,9 +352,9 @@ export function getPlanModeConfig() {
  * Compresses a large string of text using gemini-3.5-flash-lite.
  * Used for shrinking context payloads to prevent OOM/choking.
  */
-export async function compressTextUsingFlashLite(text, instruction = "<directives>\nSummarize the following text concisely. Preserve the most critical technical details, function names, and architecture logic. Make sure it's understandable without the fluff.\n</directives>", inlineData) {
-    if (!text || (text.length < 1000 && !inlineData))
-        return text; // Don't compress tiny texts
+export async function compressTextUsingFlashLite(text, instruction = "<directives>\nSummarize the following text concisely. Preserve the most critical technical details, function names, and architecture logic. Make sure it's understandable without the fluff.\n</directives>", inlineData, force = false) {
+    if (!text || (!force && text.length < 1000 && !inlineData))
+        return text; // Don't compress tiny texts unless forced
     try {
         const idToken = await getAuthorizedIdToken();
         if (!idToken)
@@ -321,8 +367,38 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
             parts.push({ inlineData });
         }
         const contents = [{ role: 'user', parts }];
-        const result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
-        undefined, instruction, { temperature: 0.2 });
+        const byokEnabled = await isByokEnabled();
+        let result;
+        if (byokEnabled) {
+            try {
+                const creds = await loadCredentials();
+                const genAI = new GoogleGenerativeAI(creds.geminiApiKey);
+                const modelObj = genAI.getGenerativeModel({
+                    model,
+                    systemInstruction: instruction,
+                });
+                const response = await modelObj.generateContent({
+                    contents: [{ role: 'user', parts }],
+                    generationConfig: { temperature: 0.2 },
+                });
+                const responseObj = await response.response;
+                result = {
+                    parts: responseObj.candidates?.[0]?.content?.parts,
+                    usageMetadata: responseObj.usageMetadata,
+                };
+                if (responseObj.usageMetadata) {
+                    accumulateTurnUsage(responseObj.usageMetadata, model);
+                }
+            }
+            catch (error) {
+                console.error('BYOK Error:', error.message);
+                throw new Error(`BYOK AI Error: ${error.message}`);
+            }
+        }
+        else {
+            result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
+            undefined, instruction, { temperature: 0.2 });
+        }
         let textPart = '';
         if (result.parts) {
             // Use highly optimized local loop instead of array search to avoid callback allocation and naive database regex flags
@@ -338,6 +414,9 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
     }
     catch (error) {
         debugLog(`Failed to compress text using flash-lite: ${error}`);
+        if (error?.status === 401 || error?.status === 403 || error?.message?.includes('API_KEY_INVALID') || error?.message?.includes('quota')) {
+            throw new Error('AI_AUTH_ERROR: Your API key or quota is invalid. Please run /config-key or re-login.');
+        }
         return text; // fallback to raw text if compression fails
     }
 }
@@ -581,8 +660,38 @@ export async function generateChatTitle(firstMessage) {
         let model = getGlobalActiveModel();
         if (model === 'auto')
             model = GEMINI_MODELS.FLASH_LITE;
-        const result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
-        undefined, instruction, { temperature: 0.2 });
+        const byokEnabled = await isByokEnabled();
+        let result;
+        if (byokEnabled) {
+            try {
+                const creds = await loadCredentials();
+                const genAI = new GoogleGenerativeAI(creds.geminiApiKey);
+                const modelObj = genAI.getGenerativeModel({
+                    model,
+                    systemInstruction: instruction,
+                });
+                const response = await modelObj.generateContent({
+                    contents,
+                    generationConfig: { temperature: 0.2 },
+                });
+                const responseObj = await response.response;
+                result = {
+                    parts: responseObj.candidates?.[0]?.content?.parts,
+                    usageMetadata: responseObj.usageMetadata,
+                };
+                if (responseObj.usageMetadata) {
+                    accumulateTurnUsage(responseObj.usageMetadata, model);
+                }
+            }
+            catch (error) {
+                console.error('BYOK Error:', error.message);
+                throw new Error(`BYOK AI Error: ${error.message}`);
+            }
+        }
+        else {
+            result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
+            undefined, instruction, { temperature: 0.2 });
+        }
         let title = '';
         if (result.parts) {
             for (const p of result.parts) {
@@ -597,7 +706,15 @@ export async function generateChatTitle(firstMessage) {
         return title ? title : firstMessage.substring(0, maxLength);
     }
     catch (error) {
-        debugLog(`Failed to generate chat title: ${error}`);
+        debugLog(`Failed to generate chat title via BYOK: ${error}`);
+        const errorMessage = error?.message || '';
+        if (error?.status === 401 ||
+            error?.status === 403 ||
+            errorMessage.includes('API_KEY_INVALID') ||
+            errorMessage.includes('quota') ||
+            errorMessage.includes('PERMISSION_DENIED')) {
+            throw new Error('AI_BYOK_ERROR: Your API key or quota is invalid. Please run /config-key to update your settings.');
+        }
         return firstMessage.substring(0, maxLength);
     }
 }

package/dist/services/changeLogger.js

@@ -21,7 +21,7 @@ class ChangeLogger {
      * Maximum number of historical changesets retained in memory and on disk.
      * Older changesets are discarded on save once this limit is exceeded.
      */
-    MAX_HISTORY = 10;
+    MAX_HISTORY = 20;
     /**
      * Whether the change logger is currently enabled.
      */
@@ -66,7 +66,7 @@ class ChangeLogger {
         }
         writeCache(this.workspaceRoot, 'revert_state.json', {
             history: this.changeStack,
-            isEnabled: this.isEnabled
+            isEnabled: this.isEnabled,
         });
     }
     /**

package/dist/services/chatHistoryService.d.ts

@@ -80,6 +80,14 @@ declare class ChatHistoryService {
      * @returns A promise that resolves when the session and its associated archive have been deleted.
      */
     deleteSession(id: string): Promise<void>;
+    /**
+     * Deletes multiple chat sessions from the local workspace cache and removes their associated archived history files.
+     * If any session or its archived history file does not exist, the operation continues for the remaining sessions.
+     *
+     * @param ids - An array of unique identifiers of the chat sessions to delete.
+     * @returns A promise that resolves when the sessions and their associated archives have been deleted.
+     */
+    bulkDeleteSessions(ids: string[]): Promise<void>;
 }
 /**
  * Singleton instance of the `ChatHistoryService` exported for application-wide use.

package/dist/services/chatHistoryService.js

@@ -64,23 +64,36 @@ class ChatHistoryService {
      * @returns A promise that resolves when the session and its associated archive have been deleted.
      */
     async deleteSession(id) {
-        if (!this.workspaceRoot)
+        await this.bulkDeleteSessions([id]);
+    }
+    /**
+     * Deletes multiple chat sessions from the local workspace cache and removes their associated archived history files.
+     * If any session or its archived history file does not exist, the operation continues for the remaining sessions.
+     *
+     * @param ids - An array of unique identifiers of the chat sessions to delete.
+     * @returns A promise that resolves when the sessions and their associated archives have been deleted.
+     */
+    async bulkDeleteSessions(ids) {
+        if (!this.workspaceRoot || ids.length === 0)
             return;
         let sessions = this.getSessions();
-        sessions = sessions.filter((s) => s.id !== id);
+        const idSet = new Set(ids);
+        sessions = sessions.filter((s) => !idSet.has(s.id));
         await writeCache(this.workspaceRoot, 'chat_sessions.json', sessions);
-        // Also delete the archived history if it exists
+        // Also delete the archived histories if they exist
         const { promises: fs } = await import('node:fs');
         const path = await import('node:path');
         const { getProjectStorageDir } = await import('../utils/projectStorage.js');
-        try {
-            const storageDir = getProjectStorageDir(this.workspaceRoot);
-            const archivePath = path.join(storageDir, `archived_history_${id}.json`);
-            await fs.unlink(archivePath);
-        }
-        catch {
-            // Ignore error if file doesn't exist
-        }
+        const storageDir = getProjectStorageDir(this.workspaceRoot);
+        await Promise.all(ids.map(async (id) => {
+            try {
+                const archivePath = path.join(storageDir, `archived_history_${id}.json`);
+                await fs.unlink(archivePath);
+            }
+            catch {
+                // Ignore error if file doesn't exist
+            }
+        }));
     }
 }
 /**

package/dist/services/contextAgent.d.ts

@@ -7,6 +7,7 @@ export interface ContextAgentResult {
     }>;
     summary: string;
     webSearchSummary?: string;
+    fromMemoryBank?: boolean;
     isParallel?: boolean;
 }
 export interface IntentRoute {

package/dist/services/contextAgent.js

@@ -210,6 +210,57 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
         projectTree += `=== ${label} ===\\nProject Type: ${type}\\n${tree}\\n\\n`;
     }
     const projectType = primaryProjectType;
+    const { lookupInvestigation, saveInvestigation } = await import('./orchestration/investigationCache.js');
+    const cacheHit = await lookupInvestigation(workspaceRoot, userRequest);
+    if (cacheHit) {
+        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) {
+            const readResult = await executeTool(workspaceRoot, 'read_file', { filePath });
+            if (!readResult.error) {
+                cachedFiles.set(filePath, { text: readResult.output, inlineData: readResult.inlineData });
+            }
+        }
+        const MAX_TOTAL_FILES = 30;
+        try {
+            const { resolveAndValidateMultiWorkspacePath } = await import('../utils/pathSecurity.js');
+            const autoDiscovered = new Set();
+            for (const filePath of cacheHit.entry.relevantFiles) {
+                try {
+                    const resolved = resolveAndValidateMultiWorkspacePath(workspaceRoot, filePath);
+                    const graph = await buildDependencyGraph(resolved.workspaceRoot);
+                    const reverseDeps = graph.getImportedBy(resolved.relativePath);
+                    for (const dep of reverseDeps) {
+                        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 });
+                        }
+                    }
+                }
+                catch (e) { }
+            }
+        }
+        catch (e) { }
+        const { accumulateUsage } = await import('./metrics.js');
+        accumulateUsage({ cachedTokens: cacheHit.bytesSaved }); // Rough proxy for saved tokens
+        return {
+            contextResult: {
+                projectTree,
+                projectType,
+                summary: cacheHit.entry.summary,
+                relevantFiles: cachedFiles,
+                fromMemoryBank: true,
+            },
+            targetAgent,
+            chainedMessages: [],
+        };
+    }
     // ─── Parallel Investigation Gate ─────────────────────────────
     if (isSubAgentsEnabled()) {
         // Determine complexity and domain breakdown
@@ -231,9 +282,6 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     const relevantFiles = new Map();
     let summary = 'No relevant context found.';
     let isInvestigationFinished = false;
-    const visitedToolCalls = new Set();
-    let consecutiveDuplicates = 0;
-    const MAX_CONSECUTIVE_DUPLICATES = 3;
     let chainedMessages = [];
     let webSearchSummary = '';
     // Initial prompt
@@ -285,33 +333,6 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
             if (abortSignal.aborted)
                 break;
             const args = call.args;
-            // Deduplicate identical tool calls
-            const callSignature = `${call.name}:${JSON.stringify(args)}`;
-            if (call.name !== 'finish_investigation' && visitedToolCalls.has(callSignature)) {
-                consecutiveDuplicates++;
-                if (consecutiveDuplicates >= MAX_CONSECUTIVE_DUPLICATES) {
-                    // Force-finish: the model is stuck in a loop, finalize with whatever context we have
-                    const forceMsg = `Investigation auto-completed: the model repeated the same tool call ${MAX_CONSECUTIVE_DUPLICATES} times consecutively.`;
-                    debugLog(`[Context Agent] ${forceMsg}`);
-                    if (onProgress)
-                        onProgress(forceMsg);
-                    if (!summary || summary === 'No relevant context found.') {
-                        summary = 'Investigation was auto-completed due to repeated duplicate tool calls. Review the gathered files for context.';
-                    }
-                    isFinished = true;
-                    isInvestigationFinished = relevantFiles.size > 0;
-                    break;
-                }
-                functionResponses.push({
-                    functionResponse: {
-                        name: call.name,
-                        response: { error: `DUPLICATE CALL BLOCKED (attempt ${consecutiveDuplicates}/${MAX_CONSECUTIVE_DUPLICATES}): You already executed this exact tool call. Do NOT retry it. Use the results you already have and call finish_investigation now, or try a DIFFERENT tool call with different parameters.` }
-                    }
-                });
-                continue;
-            }
-            consecutiveDuplicates = 0;
-            visitedToolCalls.add(callSignature);
             let logMsg = `  [Context Agent] Executing ${call.name}`;
             if (call.name === 'finish_investigation') {
                 const filesToRead = args.relevantFiles || [];
@@ -369,7 +390,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 // 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 = 15;
+                const MAX_TOTAL_FILES = 30;
                 try {
                     const { resolveAndValidateMultiWorkspacePath } = await import('../utils/pathSecurity.js');
                     const autoDiscovered = new Set();
@@ -548,9 +569,13 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     if (collector) {
         collector.recordContextSelectedFiles(Array.from(relevantFiles.keys()));
         if (!isInvestigationFinished || relevantFiles.size === 0) {
-            collector.recordInvestigationFailure();
+            collector?.recordInvestigationFailure?.();
         }
     }
+    if (isInvestigationFinished && relevantFiles.size > 0) {
+        const { saveInvestigation } = await import('./orchestration/investigationCache.js');
+        await saveInvestigation(workspaceRoot, userRequest, Array.from(relevantFiles.keys()), summary);
+    }
     return {
         contextResult: { projectTree, projectType, relevantFiles, summary, webSearchSummary, isParallel: false },
         targetAgent,

package/dist/services/metrics.d.ts

@@ -2,6 +2,13 @@ export interface MetricCollector {
     startTimer(name: string): void;
     stopTimer(name: string): number;
     recordTokenUsage(input: number, output: number, cached?: number): void;
+    accumulateUsage(usage: any): void;
+    resetTurnAccumulator(): void;
+    getTurnTotals(): {
+        promptTokens: number;
+        outputTokens: number;
+        cachedTokens: number;
+    };
     recordCompressedContextSize(chars: number): void;
     recordContextSelectedFiles(files: string[]): void;
     recordFileModified(filePath: string): void;
@@ -9,10 +16,20 @@ export interface MetricCollector {
     recordSelfCorrection(): void;
     recordVerificationResult(passed: boolean): void;
     recordMatchTier(tier: 'exact' | 'normalized' | 'levenshtein' | 'none'): void;
-    recordInvestigationFailure(): void;
-    recordToolFailure(toolName: string): void;
-    recordModifyFailure(): void;
-    recordWriteFailure(): void;
+    recordCacheHit(cacheType?: 'investigation' | 'read'): void;
+    recordCacheMiss(cacheType?: 'investigation' | 'read'): void;
+    recordCachePerformance(cacheType: 'investigation' | 'read', durationMs: number): void;
+    recordWriteFailure?(): void;
+    recordModifyFailure?(): void;
+    recordToolFailure?(toolName?: string): void;
+    recordInvestigationFailure?(): void;
 }
 export declare function setMetricCollector(collector: MetricCollector | null): void;
 export declare function getMetricCollector(): MetricCollector | null;
+export declare function resetTurnAccumulator(): void;
+export declare function accumulateUsage(usage: any): void;
+export declare function getTurnTotals(): {
+    promptTokens: number;
+    outputTokens: number;
+    cachedTokens: number;
+};

package/dist/services/metrics.js

@@ -5,3 +5,21 @@ export function setMetricCollector(collector) {
 export function getMetricCollector() {
     return globalCollector;
 }
+let turnPromptTokens = 0;
+let turnOutputTokens = 0;
+let turnCachedTokens = 0;
+export function resetTurnAccumulator() {
+    turnPromptTokens = 0;
+    turnOutputTokens = 0;
+    turnCachedTokens = 0;
+}
+export function accumulateUsage(usage) {
+    if (!usage)
+        return;
+    turnPromptTokens += usage.promptTokens || 0;
+    turnOutputTokens += usage.candidatesTokens || 0;
+    turnCachedTokens += usage.cachedTokens || 0;
+}
+export function getTurnTotals() {
+    return { promptTokens: turnPromptTokens, outputTokens: turnOutputTokens, cachedTokens: turnCachedTokens };
+}

package/dist/services/orchestration/investigationAgent.js

@@ -113,9 +113,6 @@ export class InvestigationAgentRunner {
             }
             currentMessage += `\n\nStart investigating to find relevant files within your assigned domains.`;
             let isFinished = false;
-            const visitedToolCalls = new Set();
-            let consecutiveDuplicates = 0;
-            const MAX_CONSECUTIVE_DUPLICATES = 3;
             // Tool loop — mirrors the existing context agent loop in contextAgent.ts
             while (!crashed && !abortSignal.aborted && !isFinished) {
                 this.pingHeartbeat();
@@ -143,35 +140,6 @@ export class InvestigationAgentRunner {
                     this.pingHeartbeat();
                     const args = call.args;
                     const logPrefix = `[${this.agentLabel}]`;
-                    // Deduplicate identical tool calls
-                    const callSignature = `${call.name}:${JSON.stringify(args)}`;
-                    if (call.name !== 'finish_investigation' && visitedToolCalls.has(callSignature)) {
-                        consecutiveDuplicates++;
-                        if (consecutiveDuplicates >= MAX_CONSECUTIVE_DUPLICATES) {
-                            // Force-finish: the model is stuck in a loop
-                            const forceMsg = `Investigation auto-completed: the model repeated the same tool call ${MAX_CONSECUTIVE_DUPLICATES} times consecutively.`;
-                            debugLog(`InvestigationAgent [${this.agentLabel}]: ${forceMsg}`);
-                            if (onProgress)
-                                onProgress(`[${this.agentLabel}] ${forceMsg}`);
-                            if (!summary || summary === 'No relevant context found.') {
-                                summary = 'Investigation was auto-completed due to repeated duplicate tool calls. Review the gathered files for context.';
-                            }
-                            isFinished = true;
-                            success = relevantFiles.size > 0;
-                            break;
-                        }
-                        functionResponses.push({
-                            functionResponse: {
-                                name: call.name,
-                                response: {
-                                    error: `DUPLICATE CALL BLOCKED (attempt ${consecutiveDuplicates}/${MAX_CONSECUTIVE_DUPLICATES}): You already executed this exact tool call. Do NOT retry it. Use the results you already have and call finish_investigation now, or try a DIFFERENT tool call with different parameters.`,
-                                },
-                            },
-                        });
-                        continue;
-                    }
-                    consecutiveDuplicates = 0;
-                    visitedToolCalls.add(callSignature);
                     if (call.name === 'finish_investigation') {
                         summary = args.summary || '';
                         const filesToRead = args.relevantFiles || [];

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

@@ -0,0 +1,25 @@
+export interface InvestigationCacheEntry {
+    promptHash: string;
+    relevantFiles: string[];
+    summary: string;
+    workspaceFingerprint: string;
+    createdAt: number;
+}
+export interface InvestigationCacheStore {
+    entries: Record<string, InvestigationCacheEntry>;
+}
+export declare function normalizePrompt(prompt: string): string;
+export declare function hashPrompt(normalized: string): string;
+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>;
+export declare function invalidateFilesFromInvestigationCache(workspaceRoot: string, changedFiles: string[]): Promise<void>;
+export declare function getInvestigationCacheStats(workspaceRoot: string): {
+    entries: number;
+    sizeBytes: number;
+    hitCount: number;
+    missCount: number;
+};