minovative-mind-cli 2.9.1 → 2.11.0

package/dist/services/ai.js

@@ -5,7 +5,7 @@ import { getMetricCollector } from './metrics.js';
 import { getAuthorizedIdToken, checkByokSubscription } 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, HISTORY_SUMMARIZER_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.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, INVESTIGATION_SEMANTIC_SYSTEM_INSTRUCTION, HISTORY_SUMMARIZER_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
 import { workspaceRegistry } from './workspaceRegistry.js';
 import { loadCredentials } from '../utils/credentialStore.js';
 import { ProxyClient } from './proxyClient.js';
@@ -62,6 +62,14 @@ const MAX_HISTORY_ENTRIES = 500;
  * payload stays within sane memory bounds.
  */
 const MAX_PART_TEXT_LENGTH = 60_000;
+const HISTORICAL_TOOL_OUTPUT_THRESHOLD = 1500;
+const COLLAPSED_TOOL_OUTPUT_MARKER = '\n... [Historical tool output collapsed to save context]';
+function collapseHistoricalOutput(val, threshold = HISTORICAL_TOOL_OUTPUT_THRESHOLD) {
+    if (val.length <= threshold || val.includes('[Historical tool output collapsed')) {
+        return val;
+    }
+    return `${val.substring(0, threshold)}${COLLAPSED_TOOL_OUTPUT_MARKER}`;
+}
 function truncatePartText(text) {
     if (text.length <= MAX_PART_TEXT_LENGTH)
         return text;
@@ -117,6 +125,64 @@ export class ProxyChatSession {
         this.fullHistory.push(JSON.parse(JSON.stringify(userContent)));
         this.fullHistory.push(JSON.parse(JSON.stringify(modelContent)));
     }
+    /**
+     * Appends or merges the final conversational summary text into the active session history.
+     * Ensures that the final response produced by finish_task, PM reconciliation, or final turns
+     * is permanently preserved as a model text response in both working history and full transcript.
+     */
+    appendFinalSummary(text) {
+        if (!text || !text.trim())
+            return;
+        const clean = text.replace(/\[TASK_FINISHED\]/g, '').trim();
+        if (!clean)
+            return;
+        // 1. Ensure fullHistory has the model text response
+        if (this.fullHistory.length > 0) {
+            const lastFull = this.fullHistory[this.fullHistory.length - 1];
+            if (lastFull.role === 'model') {
+                const hasText = lastFull.parts?.some((p) => p.text && p.text.trim() === clean);
+                if (!hasText) {
+                    lastFull.parts = lastFull.parts || [];
+                    lastFull.parts.push({ text: clean });
+                }
+            }
+            else {
+                this.fullHistory.push({
+                    role: 'model',
+                    parts: [{ text: clean }],
+                });
+            }
+        }
+        else {
+            this.fullHistory.push({
+                role: 'model',
+                parts: [{ text: clean }],
+            });
+        }
+        // 2. Ensure working history has the model text response
+        if (this.history.length > 0) {
+            const lastHist = this.history[this.history.length - 1];
+            if (lastHist.role === 'model') {
+                const hasText = lastHist.parts?.some((p) => p.text && p.text.trim() === clean);
+                if (!hasText) {
+                    lastHist.parts = lastHist.parts || [];
+                    lastHist.parts.push({ text: clean });
+                }
+            }
+            else {
+                this.history.push({
+                    role: 'model',
+                    parts: [{ text: clean }],
+                });
+            }
+        }
+        else {
+            this.history.push({
+                role: 'model',
+                parts: [{ text: clean }],
+            });
+        }
+    }
     /**
      * Retrieves the most recent conversation history as a formatted string.
      * Useful for passing conversation context to stateless background agents.
@@ -164,6 +230,7 @@ export class ProxyChatSession {
      * conversational context while preventing OOM crashes.
      */
     async pruneHistory() {
+        this.pruneToolOutputHistory();
         if (this.history.length > MAX_HISTORY_ENTRIES) {
             const excess = this.history.length - MAX_HISTORY_ENTRIES;
             const trimCount = excess % 2 === 0 ? excess : excess + 1;
@@ -181,6 +248,46 @@ export class ProxyChatSession {
             }
         }
     }
+    /**
+     * Collapses oversized functionResponse outputs in historical turns (>1 turn old)
+     * while strictly maintaining Gemini functionCall and functionResponse pairing.
+     *
+     * Gemini requires every functionCall in a model turn to have a matching functionResponse
+     * in the immediately following user turn. Deleting parts or entries breaks this invariant and
+     * causes 400 Bad Request errors. This method mutates oversized response outputs in-place
+     * on older turns to drastically conserve context window tokens.
+     *
+     * @param threshold Maximum characters allowed for a historical tool response before collapsing (default: 1500).
+     * @param turnsToKeep Number of recent turns to preserve unpruned (default: 1).
+     */
+    pruneToolOutputHistory(threshold = HISTORICAL_TOOL_OUTPUT_THRESHOLD, turnsToKeep = 1) {
+        // 1 turn = 1 user Content + 1 model Content pair (2 entries)
+        const cutoffIndex = Math.max(0, this.history.length - turnsToKeep * 2);
+        if (cutoffIndex <= 0)
+            return;
+        for (let i = 0; i < cutoffIndex; i++) {
+            const entry = this.history[i];
+            if (entry && entry.role === 'user' && Array.isArray(entry.parts)) {
+                for (const part of entry.parts) {
+                    if (part && typeof part === 'object' && 'functionResponse' in part && part.functionResponse) {
+                        const funcResp = part.functionResponse;
+                        if (funcResp.response && typeof funcResp.response === 'object') {
+                            const respObj = funcResp.response;
+                            if (typeof respObj.output === 'string') {
+                                respObj.output = collapseHistoricalOutput(respObj.output, threshold);
+                            }
+                            if (typeof respObj.error === 'string') {
+                                respObj.error = collapseHistoricalOutput(respObj.error, threshold);
+                            }
+                            if (typeof respObj.result === 'string') {
+                                respObj.result = collapseHistoricalOutput(respObj.result, threshold);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     async sendMessage(message, additionalText, abortSignal, onChunk) {
         const idToken = await getAuthorizedIdToken();
         if (!idToken) {
@@ -345,7 +452,7 @@ export function getPlanModeConfig() {
     };
 }
 /**
- * Compresses a large string of text using gemini-3.5-flash-lite.
+ * Compresses a large string of text using Gemini Flash.
  * 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, force = false, abortSignal) {
@@ -357,7 +464,7 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
         const idToken = await getAuthorizedIdToken();
         if (!idToken)
             return text;
-        let model = GEMINI_MODELS.FLASH_LITE;
+        let model = GEMINI_MODELS.FLASH;
         const parts = [{ text }];
         if (inlineData) {
             parts.push({ inlineData });
@@ -397,7 +504,7 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
         if (abortSignal?.aborted || error?.name === 'AbortError' || error?.message?.includes('abort')) {
             return text;
         }
-        debugLog(`Failed to compress text using flash-lite: ${error}`);
+        debugLog(`Failed to compress text using flash: ${error}`);
         if (error?.status === 401 ||
             error?.status === 403 ||
             error?.message?.includes('API_KEY_INVALID') ||
@@ -568,25 +675,143 @@ export function createContextAgentSession() {
 export function createIntentRouterSession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, INTENT_ROUTER_SYSTEM_INSTRUCTION, [], // no tools
-    { temperature: 0, responseMimeType: 'application/json' });
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                context: {
+                    type: SchemaType.STRING,
+                    enum: ['SEARCH', 'SKIP'],
+                    description: 'Whether workspace context search is required',
+                },
+                agent: {
+                    type: SchemaType.STRING,
+                    enum: ['CHAT', 'EXECUTE'],
+                    description: 'Target agent to route the request to',
+                },
+            },
+            required: ['context', 'agent'],
+        },
+    });
 }
 // ─── Execution Complexity Router Service ──────────────────────────────
 export function createExecutionComplexitySession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, [], // no tools
-    { temperature: 0, responseMimeType: 'application/json' });
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                complexity: {
+                    type: SchemaType.STRING,
+                    enum: ['EASY', 'HARD'],
+                    description: 'Execution task complexity rating',
+                },
+            },
+            required: ['complexity'],
+        },
+    });
 }
 // ─── Investigation Complexity Router Service ─────────────────────────
 export function createInvestigationComplexitySession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, [], // no tools
-    { temperature: 0, responseMimeType: 'application/json' });
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                strategy: {
+                    type: SchemaType.STRING,
+                    enum: ['SINGLE', 'PARALLEL'],
+                    description: 'Investigation strategy (SINGLE or PARALLEL)',
+                },
+                domains: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'All identified investigation domains',
+                },
+                agentAssignments: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.OBJECT,
+                        properties: {
+                            agentLabel: {
+                                type: SchemaType.STRING,
+                                description: 'Label of the sub-agent',
+                            },
+                            domains: {
+                                type: SchemaType.ARRAY,
+                                items: {
+                                    type: SchemaType.STRING,
+                                },
+                                description: 'Domains assigned to this sub-agent',
+                            },
+                        },
+                        required: ['agentLabel', 'domains'],
+                    },
+                    description: 'Sub-agent domain group assignments',
+                },
+                reasoning: {
+                    type: SchemaType.STRING,
+                    description: 'Brief justification for the chosen strategy and grouping',
+                },
+            },
+            required: ['strategy', 'domains', 'agentAssignments', 'reasoning'],
+        },
+    });
+}
+// ─── Investigation Semantic Router Service ───────────────────────────
+export function createInvestigationSemanticSession() {
+    let model = getGlobalActiveModel();
+    if (model === 'auto' || model.includes('claude'))
+        model = GEMINI_MODELS.FLASH_LITE;
+    return new ProxyChatSession(model, INVESTIGATION_SEMANTIC_SYSTEM_INSTRUCTION, [], // no tools
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                topics: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'Technical topic or domain identifiers',
+                },
+                components: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'Target component, file, function, or endpoint names',
+                },
+                intent: {
+                    type: SchemaType.STRING,
+                    description: 'Primary intent category (e.g. bug_fix, feature_addition, explanation, refactoring)',
+                },
+                reasoning: {
+                    type: SchemaType.STRING,
+                    description: 'Brief justification for the extracted metadata',
+                },
+            },
+            required: ['topics', 'components', 'intent'],
+        },
+    });
 }
 // ─── Web Search Agent Service ───────────────────────────────────────────
 export function createWebSearchAgentSession() {
@@ -604,7 +829,7 @@ export function createWebSearchAgentSession() {
 export function createHistorySummarizerSession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, HISTORY_SUMMARIZER_SYSTEM_INSTRUCTION, [], {
         temperature: 0.2,
         maxOutputTokens: MAX_OUTPUT_TOKENS,

package/dist/services/chatHistoryService.d.ts

@@ -1,4 +1,17 @@
 import type { Content } from '@google/generative-ai';
+/**
+ * Options for configuring dynamic history pruning.
+ */
+export interface HistoryPruneOptions {
+    /** Maximum number of history entries (user + model contents) to keep in active memory. Defaults to 50. */
+    maxEntries?: number;
+    /** Maximum estimated tokens allowed for the active conversation history. Defaults to 64,000. */
+    maxTokens?: number;
+    /** Minimum number of recent entries to retain regardless of token limits. Defaults to 10 (5 full turns). */
+    minRecentEntries?: number;
+    /** Whether to automatically archive pruned entries to disk. Defaults to true. */
+    archivePruned?: boolean;
+}
 /**
  * Represents the structure of a saved chat session.
  * This data is persisted in the local workspace cache to allow users to resume
@@ -41,7 +54,16 @@ export interface ChatSessionData {
     modelUsageCounts?: Record<string, number>;
 }
 /**
- * Service responsible for managing the persistence, retrieval, and deletion of chat session histories.
+ * Estimates the token count for a Gemini Content object.
+ *
+ * @param content The Content object containing parts and role.
+ * @returns Estimated number of tokens.
+ */
+export declare function estimateContentTokens(content: Content): number;
+/**
+ * Service responsible for managing the persistence, retrieval, history pruning,
+ * and deletion of chat session histories.
+ *
  * It stores session metadata and message history in a local JSON cache (`chat_sessions.json`)
  * within the project's storage directory and enforces a maximum limit of 250 sessions to prevent
  * unbounded storage growth.
@@ -51,6 +73,10 @@ declare class ChatHistoryService {
     private workspaceRoot;
     /** The maximum number of chat sessions allowed in the cache. Oldest sessions are discarded when this limit is exceeded. */
     private readonly MAX_SESSIONS;
+    /** Default maximum entries allowed in active history before automatic archiving. */
+    private readonly DEFAULT_MAX_HISTORY_ENTRIES;
+    /** Default maximum estimated tokens before pruning. */
+    private readonly DEFAULT_MAX_TOKENS;
     /**
      * Initializes the chat history service with the workspace root path.
      * This must be called before attempting to read, save, or delete sessions.
@@ -65,15 +91,82 @@ declare class ChatHistoryService {
      * @returns An array of saved `ChatSessionData` objects, ordered as stored in the cache.
      */
     getSessions(): ChatSessionData[];
+    /**
+     * Retrieves a single chat session by ID.
+     *
+     * @param id - The unique session identifier.
+     * @returns The session data, or null if not found.
+     */
+    getSession(id: string): ChatSessionData | null;
+    /**
+     * Estimates the total token count of all messages within a given chat session.
+     *
+     * @param session The chat session to evaluate.
+     * @returns Total estimated tokens.
+     */
+    estimateSessionTokens(session: ChatSessionData): number;
+    /**
+     * Validates and cleans conversation turns by removing empty parts or invalid structures.
+     *
+     * @param history Array of Content objects.
+     * @returns Sanitized array of Content objects.
+     */
+    sanitizeSessionHistory(history: Content[]): Content[];
+    /**
+     * Appends pruned history items to the session's archive JSON file on disk.
+     *
+     * @param id - The session identifier.
+     * @param prunedEntries - Array of pruned Content objects.
+     */
+    archiveSessionHistory(id: string, prunedEntries: Content[]): Promise<void>;
+    /**
+     * Retrieves previously archived history entries for a given session.
+     *
+     * @param id - The session identifier.
+     * @returns Array of archived Content objects.
+     */
+    getArchivedSessionHistory(id: string): Promise<Content[]>;
+    /**
+     * Prunes a session's history to satisfy entry and token bounds while preserving
+     * recent conversational context and alternating turn integrity.
+     *
+     * @param session The session to prune.
+     * @param options History pruning configuration options.
+     * @returns An object containing the pruned session and count of archived entries.
+     */
+    pruneSessionHistory(session: ChatSessionData, options?: HistoryPruneOptions): Promise<{
+        prunedSession: ChatSessionData;
+        archivedCount: number;
+    }>;
     /**
      * Saves or updates a chat session in the local workspace cache.
      * If a session with the same ID already exists, it is updated in place. Otherwise, it is appended.
+     * Automatically executes history pruning and archiving if the session exceeds token/turn thresholds.
      * Enforces the maximum session limit of 250 by removing the oldest session if the limit is exceeded.
      *
      * @param session - The chat session data to be saved.
+     * @param pruneOptions - Optional pruning configuration overrides.
      * @returns A promise that resolves when the session has been successfully written to the cache.
      */
-    saveSession(session: ChatSessionData): Promise<void>;
+    saveSession(session: ChatSessionData, pruneOptions?: HistoryPruneOptions): Promise<void>;
+    /**
+     * Retrieves a chat session with its history constrained to a specific token budget.
+     *
+     * @param id - The unique session identifier.
+     * @param maxTokens - Maximum token budget for the returned history.
+     * @returns The session with budget-constrained history, or null if session not found.
+     */
+    getSessionWithTokenBudget(id: string, maxTokens: number): Promise<ChatSessionData | null>;
+    /**
+     * Prunes stale sessions based on age (in days) or total count limit.
+     *
+     * @param options Pruning options specifying maxAgeDays and maxTotalSessions.
+     * @returns Number of sessions pruned.
+     */
+    pruneOldSessions(options?: {
+        maxAgeDays?: number;
+        maxTotalSessions?: number;
+    }): Promise<number>;
     /**
      * Updates the user-friendly title of an existing chat session in the local workspace cache.
      * If the session with the matching ID exists, its title is updated and persisted to `chat_sessions.json`.