minovative-mind-cli 2.9.1 → 2.11.0

package/dist/services/chatHistoryService.js

@@ -1,6 +1,35 @@
-import { readCache, writeCache } from '../utils/projectStorage.js';
+import { readCache, writeCache, getProjectStorageDir } from '../utils/projectStorage.js';
+import { estimateTokenCount } from '../utils/historyPrompt.js';
 /**
- * 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 function estimateContentTokens(content) {
+    if (!content || !content.parts || !Array.isArray(content.parts))
+        return 0;
+    let totalChars = 0;
+    for (const part of content.parts) {
+        if ('text' in part && typeof part.text === 'string') {
+            totalChars += part.text.length;
+        }
+        else if ('functionCall' in part && part.functionCall) {
+            totalChars += JSON.stringify(part.functionCall).length;
+        }
+        else if ('functionResponse' in part && part.functionResponse) {
+            totalChars += JSON.stringify(part.functionResponse).length;
+        }
+        else if ('inlineData' in part && part.inlineData) {
+            totalChars += 100; // Minimal estimate for media payload metadata
+        }
+    }
+    return estimateTokenCount(totalChars > 0 ? 'x'.repeat(totalChars) : '');
+}
+/**
+ * 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.
@@ -10,6 +39,10 @@ class ChatHistoryService {
     workspaceRoot = '';
     /** The maximum number of chat sessions allowed in the cache. Oldest sessions are discarded when this limit is exceeded. */
     MAX_SESSIONS = 250;
+    /** Default maximum entries allowed in active history before automatic archiving. */
+    DEFAULT_MAX_HISTORY_ENTRIES = 60;
+    /** Default maximum estimated tokens before pruning. */
+    DEFAULT_MAX_TOKENS = 64000;
     /**
      * Initializes the chat history service with the workspace root path.
      * This must be called before attempting to read, save, or delete sessions.
@@ -31,31 +64,226 @@ class ChatHistoryService {
         const sessions = readCache(this.workspaceRoot, 'chat_sessions.json');
         return sessions || [];
     }
+    /**
+     * Retrieves a single chat session by ID.
+     *
+     * @param id - The unique session identifier.
+     * @returns The session data, or null if not found.
+     */
+    getSession(id) {
+        if (!this.workspaceRoot || !id)
+            return null;
+        const sessions = this.getSessions();
+        return sessions.find((s) => s.id === id) || 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) {
+        if (!session || !session.history || !Array.isArray(session.history))
+            return 0;
+        return session.history.reduce((sum, content) => sum + estimateContentTokens(content), 0);
+    }
+    /**
+     * 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) {
+        if (!history || !Array.isArray(history))
+            return [];
+        return history.filter((content) => {
+            if (!content || !content.role || !Array.isArray(content.parts) || content.parts.length === 0) {
+                return false;
+            }
+            // Check if parts have actual non-empty content
+            return content.parts.some((p) => {
+                if ('text' in p && typeof p.text === 'string')
+                    return p.text.trim().length > 0;
+                if ('functionCall' in p && p.functionCall)
+                    return true;
+                if ('functionResponse' in p && p.functionResponse)
+                    return true;
+                if ('inlineData' in p && p.inlineData)
+                    return true;
+                return false;
+            });
+        });
+    }
+    /**
+     * 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.
+     */
+    async archiveSessionHistory(id, prunedEntries) {
+        if (!this.workspaceRoot || !id || prunedEntries.length === 0)
+            return;
+        const archiveFile = `archives/archived_history_${id}.json`;
+        const existingArchive = readCache(this.workspaceRoot, archiveFile) || [];
+        await writeCache(this.workspaceRoot, archiveFile, [...existingArchive, ...prunedEntries]);
+    }
+    /**
+     * Retrieves previously archived history entries for a given session.
+     *
+     * @param id - The session identifier.
+     * @returns Array of archived Content objects.
+     */
+    async getArchivedSessionHistory(id) {
+        if (!this.workspaceRoot || !id)
+            return [];
+        const archiveFile = `archives/archived_history_${id}.json`;
+        const archive = readCache(this.workspaceRoot, archiveFile);
+        return archive || [];
+    }
+    /**
+     * 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.
+     */
+    async pruneSessionHistory(session, options) {
+        const maxEntries = options?.maxEntries ?? this.DEFAULT_MAX_HISTORY_ENTRIES;
+        const maxTokens = options?.maxTokens ?? this.DEFAULT_MAX_TOKENS;
+        const minRecent = options?.minRecentEntries ?? 10;
+        const shouldArchive = options?.archivePruned ?? true;
+        const sanitized = this.sanitizeSessionHistory(session.history);
+        let history = [...sanitized];
+        let archivedCount = 0;
+        const toArchive = [];
+        // Phase 1: Entry count limit pruning (prune in pairs to preserve user/model turn parity)
+        if (history.length > maxEntries) {
+            const excess = history.length - maxEntries;
+            const trimCount = excess % 2 === 0 ? excess : excess + 1;
+            const pruned = history.slice(0, trimCount);
+            history = history.slice(trimCount);
+            toArchive.push(...pruned);
+            archivedCount += pruned.length;
+        }
+        // Phase 2: Token budget limit pruning
+        let currentTokens = history.reduce((sum, c) => sum + estimateContentTokens(c), 0);
+        while (currentTokens > maxTokens && history.length > minRecent) {
+            // Remove a pair of turns (user + assistant) from the oldest end
+            const prunePairCount = Math.min(2, history.length - minRecent);
+            if (prunePairCount <= 0)
+                break;
+            const pruned = history.slice(0, prunePairCount);
+            history = history.slice(prunePairCount);
+            toArchive.push(...pruned);
+            archivedCount += pruned.length;
+            currentTokens = history.reduce((sum, c) => sum + estimateContentTokens(c), 0);
+        }
+        if (shouldArchive && toArchive.length > 0) {
+            await this.archiveSessionHistory(session.id, toArchive);
+        }
+        const prunedSession = {
+            ...session,
+            history,
+        };
+        return { prunedSession, archivedCount };
+    }
     /**
      * 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.
      */
-    async saveSession(session) {
+    async saveSession(session, pruneOptions) {
         if (!this.workspaceRoot)
             return;
+        // Prune history if necessary
+        const { prunedSession } = await this.pruneSessionHistory(session, pruneOptions);
         const sessions = this.getSessions();
-        const index = sessions.findIndex((s) => s.id === session.id);
+        const index = sessions.findIndex((s) => s.id === prunedSession.id);
         if (index >= 0) {
-            sessions[index] = session;
+            sessions[index] = prunedSession;
         }
         else {
-            sessions.push(session);
+            sessions.push(prunedSession);
         }
-        // Keep history bounded
+        // Keep session list bounded to MAX_SESSIONS
         if (sessions.length > this.MAX_SESSIONS) {
-            sessions.shift(); // Remove oldest
+            const removed = sessions.shift(); // Remove oldest
+            if (removed?.id) {
+                // Clean up archived history of evicted session to avoid orphan files
+                try {
+                    const { promises: fs } = await import('node:fs');
+                    const path = await import('node:path');
+                    const storageDir = getProjectStorageDir(this.workspaceRoot);
+                    const archivePath = path.join(storageDir, 'archives', `archived_history_${removed.id}.json`);
+                    await fs.unlink(archivePath);
+                }
+                catch {
+                    // Ignore if archive did not exist
+                }
+            }
         }
         await writeCache(this.workspaceRoot, 'chat_sessions.json', sessions);
     }
+    /**
+     * 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.
+     */
+    async getSessionWithTokenBudget(id, maxTokens) {
+        const session = this.getSession(id);
+        if (!session)
+            return null;
+        const { prunedSession } = await this.pruneSessionHistory(session, {
+            maxTokens,
+            archivePruned: false, // Reading with budget does not mutate the persistent archive
+        });
+        return prunedSession;
+    }
+    /**
+     * 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.
+     */
+    async pruneOldSessions(options) {
+        if (!this.workspaceRoot)
+            return 0;
+        const sessions = this.getSessions();
+        if (sessions.length === 0)
+            return 0;
+        const maxAgeMs = (options?.maxAgeDays ?? 90) * 24 * 60 * 60 * 1000;
+        const maxTotal = options?.maxTotalSessions ?? this.MAX_SESSIONS;
+        const now = Date.now();
+        const idsToDelete = [];
+        const retainedSessions = [];
+        for (const session of sessions) {
+            const age = now - session.timestamp;
+            if (age > maxAgeMs) {
+                idsToDelete.push(session.id);
+            }
+            else {
+                retainedSessions.push(session);
+            }
+        }
+        // If still over maxTotal, remove oldest
+        while (retainedSessions.length > maxTotal) {
+            const oldest = retainedSessions.shift();
+            if (oldest)
+                idsToDelete.push(oldest.id);
+        }
+        if (idsToDelete.length > 0) {
+            await this.bulkDeleteSessions(idsToDelete);
+        }
+        return idsToDelete.length;
+    }
     /**
      * 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`.
@@ -102,7 +330,6 @@ class ChatHistoryService {
         // 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');
         const storageDir = getProjectStorageDir(this.workspaceRoot);
         await Promise.all(ids.map(async (id) => {
             try {