minovative-mind-cli 2.6.3 → 2.6.4

package/dist/services/agent-tools.js

@@ -1413,12 +1413,23 @@ const currentTasksByAgent = new Map();
  * @returns A promise resolving to a {@link ToolResult}.
  */
 export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
+    // Normalize common LLM tool alias hallucinations to registered tool names
+    let normalizedToolName = toolName;
+    if (normalizedToolName === 'search' || normalizedToolName === 'web_search') {
+        normalizedToolName = (args.query || args.searchQuery || args.url) ? 'perform_web_search' : 'grep_search';
+    }
+    else if (normalizedToolName === 'grep' || normalizedToolName === 'search_codebase') {
+        normalizedToolName = 'grep_search';
+    }
+    else if (normalizedToolName === 'finish_investigation') {
+        normalizedToolName = 'finish_task';
+    }
     // ─── Multi-Workspace Path Resolution ─────────────────────────────
     // Intercept @alias/ prefixed paths and swap workspaceRoot + relative path
     // before dispatching to the underlying tool functions (which remain unchanged).
-    const { effectiveRoot, resolvedArgs } = resolveWorkspaceArgs(workspaceRoot, toolName, args);
+    const { effectiveRoot, resolvedArgs } = resolveWorkspaceArgs(workspaceRoot, normalizedToolName, args);
     let result;
-    switch (toolName) {
+    switch (normalizedToolName) {
         case 'perform_web_search': {
             const { createWebSearchAgentSession } = await import('./ai.js');
             const webSession = createWebSearchAgentSession();

package/dist/services/agent.d.ts

@@ -112,24 +112,14 @@ export declare function executeSingleTurn(workspaceRoot: string, userInput: stri
 } | void>;
 /**
  * Raw chat history entry count threshold to trigger chat history summarization.
- * 12 entries = 6 conversational user/model turns.
- */
-export declare const HISTORY_SUMMARIZATION_THRESHOLD = 12;
-/**
- * Checks and summarizes older chat history entries if the active session's history
- * exceeds HISTORY_SUMMARIZATION_THRESHOLD entries.
- *
- * Preserves the most recent 4 entries (2 turns) intact for conversational continuity,
- * replacing all preceding turns with a single summarized pair in the chat history.
- *
- * @param chat - The active ProxyChatSession instance.
- * @returns True if history was summarized and updated; false otherwise.
+ * 50 entries = 25 conversational user/model turns.
  */
+export declare const HISTORY_SUMMARIZATION_THRESHOLD = 50;
 /**
  * Summarizes older chat history entries if the active session's history
  * exceeds {@link HISTORY_SUMMARIZATION_THRESHOLD} entries.
  *
- * Preserves the most recent 4 entries (2 turns) intact for conversational continuity,
+ * Preserves the most recent 20 entries (10 turns) intact for conversational continuity,
  * replacing all preceding turns with a single summarized pair in the chat history.
  *
  * @param chat - The active ProxyChatSession instance.

package/dist/services/agent.js

@@ -152,7 +152,7 @@ export async function startAgentLoop(workspaceRoot, version) {
     process.stdout.write('\n\n\n\x1b[3A');
     console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
     while (true) {
-        if (chat.getRawHistory().length === 0 && chatSessionState.title !== '') {
+        if (chat.getFullHistory().length === 0 && chatSessionState.title !== '') {
             chatSessionState.id = crypto.randomUUID();
             chatSessionState.title = '';
             chatSessionState.totalTokens = 0;
@@ -466,19 +466,47 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 const orchestrator = new Orchestrator(workspaceRoot, chatSessionState.id, inputHandler);
                 const handledByOrchestrator = await orchestrator.runOrchestration(finalInput, dynamicSystemInstruction, ac.signal);
                 if (typeof handledByOrchestrator === 'string') {
-                    // The orchestrator successfully decomposed and ran the task.
-                    // Inject the task context into the main proxy chat session so the agent remembers what happened
-                    // and so the history state gets saved properly on disk.
-                    chat.getRawHistory().push({
-                        role: 'user',
-                        parts: [{ text: userInput }],
-                    });
-                    chat.getRawHistory().push({
-                        role: 'model',
-                        parts: [{ text: handledByOrchestrator }],
-                    });
-                    // Print the summary text just like single-agent mode
-                    if (handledByOrchestrator !== '[Generation stopped.]') {
+                    const isStopped = handledByOrchestrator.includes('Generation stopped') ||
+                        handledByOrchestrator.includes('[Generation stopped');
+                    if (isStopped) {
+                        const currentChanges = changeLogger.getCurrentChangeSet()?.changes || [];
+                        const modifiedFiles = currentChanges
+                            .filter((c) => c.action === 'modify' || c.action === 'create' || c.action === 'delete')
+                            .map((c) => `${c.action}: ${path.relative(workspaceRoot, c.filePath)}`);
+                        let summaryMsg = '';
+                        if (modifiedFiles.length > 0) {
+                            summaryMsg = `Generation was stopped by the user before completion. Partial code changes made before stopping:\n- ${modifiedFiles.join('\n- ')}`;
+                            p.log.warn(pc.yellow('\n⚠️  Generation stopped by user before completion.'));
+                            p.log.info(pc.cyan('Partial code changes created/modified before stopping:'));
+                            modifiedFiles.forEach((file) => p.log.message(`  ${pc.dim('•')} ${file}`));
+                        }
+                        else {
+                            summaryMsg = 'Generation was stopped by the user before completion. No code files were modified before stopping.';
+                            p.log.warn(pc.yellow('\n⚠️  Generation stopped by user before completion (no files were modified).'));
+                        }
+                        chat.addTurn({
+                            role: 'user',
+                            parts: [{ text: `[USER INTERRUPT] User issued a "stop" command during execution: "${userInput}"` }],
+                        }, {
+                            role: 'model',
+                            parts: [
+                                {
+                                    text: `[GENERATION INTERRUPTED BY USER] I acknowledge that generation was manually stopped by the user before task completion.\n${summaryMsg}`,
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        // Inject the task context into the main proxy chat session so the agent remembers what happened
+                        // and so the full history state gets saved properly on disk.
+                        chat.addTurn({
+                            role: 'user',
+                            parts: [{ text: userInput }],
+                        }, {
+                            role: 'model',
+                            parts: [{ text: handledByOrchestrator }],
+                        });
+                        // Print the summary text just like single-agent mode
                         console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim(`(Orchestrator)`)}\n`);
                         const cleanText = handledByOrchestrator.replace(/\n([ \t]*\n){2,}/g, '\n\n');
                         console.log(marked.parse(cleanText));
@@ -519,7 +547,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     changeLogger.markComplete();
                     changeLogger.commitChangeSet();
                     // Auto-save chat history for the orchestrator turn
-                    const history = chat.getRawHistory();
+                    const history = chat.getFullHistory();
                     if (history.length > 0) {
                         if (!chatSessionState.title) {
                             chatSessionState.title = 'Generating title...';
@@ -628,8 +656,38 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             const turnEndTime = Date.now();
             const turnDuration = ((turnEndTime - turnStartTime) / 1000).toFixed(1);
             p.log.info(`${pc.dim('Generated in')} ${pc.cyan(turnDuration + 's')}`);
-            // If we reach this point without throwing or breaking early, and the generation wasn't stopped, the turn finished completely.
-            if (finalText !== '[Generation stopped.]') {
+            // Check if generation was stopped by user
+            const isStopped = finalText.includes('Generation stopped') ||
+                finalText.includes('[Generation stopped');
+            if (isStopped) {
+                const currentChanges = changeLogger.getCurrentChangeSet()?.changes || [];
+                const modifiedFiles = currentChanges
+                    .filter((c) => c.action === 'modify' || c.action === 'create' || c.action === 'delete')
+                    .map((c) => `${c.action}: ${path.relative(workspaceRoot, c.filePath)}`);
+                let summaryMsg = '';
+                if (modifiedFiles.length > 0) {
+                    summaryMsg = `Generation was stopped by the user before completion. Partial code changes made before stopping:\n- ${modifiedFiles.join('\n- ')}`;
+                    p.log.warn(pc.yellow('\n⚠️  Generation stopped by user before completion.'));
+                    p.log.info(pc.cyan('Partial code changes created/modified before stopping:'));
+                    modifiedFiles.forEach((file) => p.log.message(`  ${pc.dim('•')} ${file}`));
+                }
+                else {
+                    summaryMsg = 'Generation was stopped by the user before completion. No code files were modified before stopping.';
+                    p.log.warn(pc.yellow('\n⚠️  Generation stopped by user before completion (no files were modified).'));
+                }
+                chat.addTurn({
+                    role: 'user',
+                    parts: [{ text: `[USER INTERRUPT] User issued a "stop" command during execution: "${userInput}"` }],
+                }, {
+                    role: 'model',
+                    parts: [
+                        {
+                            text: `[GENERATION INTERRUPTED BY USER] I acknowledge that generation was manually stopped by the user before task completion.\n${summaryMsg}`,
+                        },
+                    ],
+                });
+            }
+            else {
                 changeLogger.markComplete();
             }
             if (usage) {
@@ -647,7 +705,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 chatSessionState.totalCreditsUsed += usage.creditsUsed || 0;
             }
             // Auto-save chat history
-            const history = chat.getRawHistory();
+            const history = chat.getFullHistory();
             if (history.length > 0) {
                 if (!chatSessionState.title) {
                     chatSessionState.title = 'Generating title...';
@@ -884,24 +942,14 @@ async function compressContextFiles(workspaceRoot, contextResult) {
 }
 /**
  * Raw chat history entry count threshold to trigger chat history summarization.
- * 12 entries = 6 conversational user/model turns.
- */
-export const HISTORY_SUMMARIZATION_THRESHOLD = 12;
-/**
- * Checks and summarizes older chat history entries if the active session's history
- * exceeds HISTORY_SUMMARIZATION_THRESHOLD entries.
- *
- * Preserves the most recent 4 entries (2 turns) intact for conversational continuity,
- * replacing all preceding turns with a single summarized pair in the chat history.
- *
- * @param chat - The active ProxyChatSession instance.
- * @returns True if history was summarized and updated; false otherwise.
+ * 50 entries = 25 conversational user/model turns.
  */
+export const HISTORY_SUMMARIZATION_THRESHOLD = 50;
 /**
  * Summarizes older chat history entries if the active session's history
  * exceeds {@link HISTORY_SUMMARIZATION_THRESHOLD} entries.
  *
- * Preserves the most recent 4 entries (2 turns) intact for conversational continuity,
+ * Preserves the most recent 20 entries (10 turns) intact for conversational continuity,
  * replacing all preceding turns with a single summarized pair in the chat history.
  *
  * @param chat - The active ProxyChatSession instance.
@@ -913,8 +961,8 @@ export async function summarizeHistoryIfNeeded(chat) {
         return false;
     }
     try {
-        // Keep the most recent 4 entries (2 full user/model turns) intact
-        const recentCount = 4;
+        // Keep the most recent 20 entries (10 full user/model turns) intact
+        const recentCount = 20;
         const olderHistory = history.slice(0, history.length - recentCount);
         const recentHistory = history.slice(history.length - recentCount);
         debugLog(`Summarizing ${olderHistory.length} older chat history entries...`);
@@ -930,7 +978,7 @@ export async function summarizeHistoryIfNeeded(chat) {
                     parts: [{ text: 'Understood. I have reviewed and absorbed the summary of our preceding conversation.' }],
                 },
             ];
-            chat.loadRawHistory([...summaryContent, ...recentHistory]);
+            chat.loadCompressedHistory([...summaryContent, ...recentHistory]);
             debugLog(`Chat history compressed successfully from ${history.length} to ${summaryContent.length + recentHistory.length} entries.`);
             return true;
         }

package/dist/services/ai.d.ts

@@ -5,6 +5,7 @@ export declare function setGlobalActiveModel(model: string): void;
 export declare function getGlobalActiveModel(): string;
 export declare class ProxyChatSession {
     private history;
+    private fullHistory;
     private modelName;
     private systemInstruction;
     private tools;
@@ -17,7 +18,10 @@ export declare class ProxyChatSession {
     getModel(): string;
     clearHistory(): void;
     getRawHistory(): Content[];
+    getFullHistory(): Content[];
     loadRawHistory(history: Content[]): void;
+    loadCompressedHistory(history: Content[]): void;
+    addTurn(userContent: Content, modelContent: Content): void;
     /**
      * Retrieves the most recent conversation history as a formatted string.
      * Useful for passing conversation context to stateless background agents.

package/dist/services/ai.js

@@ -69,6 +69,7 @@ function truncatePartText(text) {
 }
 export class ProxyChatSession {
     history = [];
+    fullHistory = [];
     modelName;
     systemInstruction;
     tools;
@@ -95,25 +96,37 @@ export class ProxyChatSession {
     }
     clearHistory() {
         this.history = [];
+        this.fullHistory = [];
     }
     getRawHistory() {
         return this.history;
     }
+    getFullHistory() {
+        return this.fullHistory;
+    }
     loadRawHistory(history) {
+        this.history = [...history];
+        this.fullHistory = JSON.parse(JSON.stringify(history));
+    }
+    loadCompressedHistory(history) {
         this.history = history;
     }
+    addTurn(userContent, modelContent) {
+        this.history.push(userContent);
+        this.history.push(modelContent);
+        this.fullHistory.push(JSON.parse(JSON.stringify(userContent)));
+        this.fullHistory.push(JSON.parse(JSON.stringify(modelContent)));
+    }
     /**
      * Retrieves the most recent conversation history as a formatted string.
      * Useful for passing conversation context to stateless background agents.
      * @param turns Number of back-and-forth turns (user + model pair = 1 turn) to retrieve.
      */
     getRecentHistory(turns = 2) {
-        if (this.history.length === 0)
+        if (this.fullHistory.length === 0 && this.history.length === 0)
             return '';
-        // History is an array of Content { role: 'user' | 'model', parts: Part[] }
-        // A single turn is generally 2 items (user, then model). Sometimes tools are interspersed.
-        // We'll just grab the last N * 2 items.
-        const recentItems = this.history.slice(-(turns * 2));
+        const sourceHistory = this.fullHistory.length > 0 ? this.fullHistory : this.history;
+        const recentItems = sourceHistory.slice(-(turns * 2));
         let formattedHistory = '';
         for (const item of recentItems) {
             const role = item.role === 'user' ? 'User' : 'Assistant';
@@ -134,6 +147,10 @@ export class ProxyChatSession {
             this.history.pop();
             this.history.pop();
         }
+        if (this.fullHistory.length >= 2) {
+            this.fullHistory.pop();
+            this.fullHistory.pop();
+        }
     }
     sessionId;
     workspaceRoot;
@@ -148,12 +165,15 @@ export class ProxyChatSession {
      */
     async pruneHistory() {
         if (this.history.length > MAX_HISTORY_ENTRIES) {
-            // Always keep pairs aligned (user/model), so trim from the front
             const excess = this.history.length - MAX_HISTORY_ENTRIES;
-            // Round up to the nearest even number to keep user/model pairs intact
             const trimCount = excess % 2 === 0 ? excess : excess + 1;
-            const pruned = this.history.slice(0, trimCount);
             this.history = this.history.slice(trimCount);
+        }
+        if (this.fullHistory.length > MAX_HISTORY_ENTRIES) {
+            const excess = this.fullHistory.length - MAX_HISTORY_ENTRIES;
+            const trimCount = excess % 2 === 0 ? excess : excess + 1;
+            const pruned = this.fullHistory.slice(0, trimCount);
+            this.fullHistory = this.fullHistory.slice(trimCount);
             if (this.sessionId && this.workspaceRoot) {
                 const archiveFile = `archives/archived_history_${this.sessionId}.json`;
                 const existingArchive = readCache(this.workspaceRoot, archiveFile) || [];
@@ -199,10 +219,12 @@ export class ProxyChatSession {
         if (additionalText) {
             newParts.push({ text: truncatePartText(additionalText) });
         }
-        this.history.push({
+        const userEntry = {
             role: 'user',
             parts: newParts,
-        });
+        };
+        this.history.push(userEntry);
+        this.fullHistory.push(JSON.parse(JSON.stringify(userEntry)));
         // Prune old history before sending to keep payload bounded
         await this.pruneHistory();
         const effectiveGenerationConfig = { ...this.generationConfig };
@@ -286,10 +308,12 @@ export class ProxyChatSession {
             });
         }
         if (modelParts.length > 0) {
-            this.history.push({
+            const modelEntry = {
                 role: 'model',
                 parts: modelParts,
-            });
+            };
+            this.history.push(modelEntry);
+            this.fullHistory.push(JSON.parse(JSON.stringify(modelEntry)));
             // We must prune again if we just pushed new history
             await this.pruneHistory();
         }

package/oclif.manifest.json

@@ -65,5 +65,5 @@
       ]
     }
   },
-  "version": "2.6.3"
+  "version": "2.6.4"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minovative-mind-cli",
   "description": "An automated AI agent powered by Vertex AI that helps you write software",
-  "version": "2.6.3",
+  "version": "2.6.4",
   "author": "Daniel Ward",
   "bin": {
     "minovative-mind-cli": "bin/run.js"