minovative-mind-cli 1.0.0

package/dist/services/agent.d.ts

@@ -0,0 +1,21 @@
+import * as p from '@clack/prompts';
+export declare class AsyncInputHandler {
+    private queue;
+    private isPrompting;
+    private spinner;
+    private originalRawMode;
+    private stopped;
+    private ac;
+    setAbortController(ac: AbortController): void;
+    isCurrentlyPrompting(): boolean;
+    waitForPrompt(): Promise<void>;
+    private onData;
+    start(spinner?: ReturnType<typeof p.spinner>): void;
+    stop(): void;
+    getAndClear(): string;
+}
+/**
+ * Starts the interactive agent chat loop.
+ * Runs until the user types "exit", "quit", or presses Ctrl+C.
+ */
+export declare function startAgentLoop(workspaceRoot: string, version: string): Promise<void>;

package/dist/services/agent.js

@@ -0,0 +1,648 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+export class AsyncInputHandler {
+    queue = [];
+    isPrompting = false;
+    spinner = null;
+    originalRawMode = false;
+    stopped = true;
+    ac = null;
+    setAbortController(ac) {
+        this.ac = ac;
+    }
+    isCurrentlyPrompting() {
+        return this.isPrompting;
+    }
+    async waitForPrompt() {
+        while (this.isPrompting) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    onData = async (chunk) => {
+        try {
+            if (this.isPrompting)
+                return;
+            const char = chunk.toString();
+            if (char === '\u0003') {
+                process.exit(0);
+            }
+            if (char.charCodeAt(0) < 32 || char === '\u007f')
+                return;
+            this.isPrompting = true;
+            process.stdin.removeListener('data', this.onData);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+            if (this.spinner) {
+                this.spinner.stop('Paused to receive input');
+            }
+            const userInput = await p.text({
+                message: 'Add chained message:',
+                placeholder: '(Leave blank and press Enter to cancel)',
+                initialValue: char,
+            });
+            if (!p.isCancel(userInput) && userInput.trim()) {
+                const text = userInput.trim();
+                if (text.toLowerCase() === 'stop' || text.toLowerCase() === 'stop!') {
+                    if (this.ac) {
+                        this.ac.abort();
+                        p.log.warn(pc.yellow(`Generation aborted by user.`));
+                    }
+                }
+                else {
+                    this.queue.push(text);
+                    p.log.info(pc.cyan(`📥 Queued message: "${text}"`));
+                }
+            }
+            if (this.spinner) {
+                this.spinner.start('Resuming execution...');
+            }
+        }
+        catch (err) {
+            // Ignore
+        }
+        finally {
+            if (!this.stopped) {
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(true);
+                }
+                setTimeout(() => {
+                    if (!this.stopped) {
+                        process.stdin.on('data', this.onData);
+                    }
+                    this.isPrompting = false;
+                }, 50);
+            }
+            else {
+                this.isPrompting = false;
+            }
+        }
+    };
+    start(spinner) {
+        this.stopped = false;
+        if (spinner) {
+            this.spinner = spinner;
+        }
+        if (process.stdin.isTTY) {
+            this.originalRawMode = process.stdin.isRaw;
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.on('data', this.onData);
+    }
+    stop() {
+        this.stopped = true;
+        process.stdin.removeListener('data', this.onData);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(this.originalRawMode);
+        }
+        this.spinner = null;
+    }
+    getAndClear() {
+        if (this.queue.length === 0)
+            return '';
+        const messages = this.queue.join('\n');
+        this.queue = [];
+        return messages;
+    }
+}
+import { consumeSkipOnce, executeTool, getApprovalMode, setApprovalMode } from './agent-tools.js';
+import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, ProxyChatSession } from './ai.js';
+import { changeLogger } from './changeLogger.js';
+import { gatherContext, routeIntent } from './contextAgent.js';
+import { verifyChangedFiles } from './verificationService.js';
+import { buildContextInjection } from '../utils/contextPrompts.js';
+import { debugLog, toggleDebugMode } from '../utils/logger.js';
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+marked.use(markedTerminal());
+// ─── Constants ───────────────────────────────────────────────────────
+const TOOL_ICONS = {
+    read_file: '📖',
+    write_file: '✏️',
+    modify_file: '🔧',
+    list_directory: '📂',
+    run_command: '⚡',
+    grep_search: '🔍',
+    delete_file: '🗑️',
+    rename_file: '🚚',
+    find_dependencies: '🔗',
+};
+const TOOL_LABELS = {
+    read_file: 'Reading file',
+    write_file: 'Writing file',
+    modify_file: 'Modifying file',
+    list_directory: 'Listing directory',
+    run_command: 'Running command',
+    grep_search: 'Searching code',
+    delete_file: 'Deleting file',
+    rename_file: 'Moving file',
+    find_dependencies: 'Tracing dependencies',
+};
+// ─── Helpers ─────────────────────────────────────────────────────────
+function formatToolCall(name, args) {
+    const icon = TOOL_ICONS[name] ?? '🔧';
+    const label = TOOL_LABELS[name] ?? name;
+    switch (name) {
+        case 'read_file':
+            return `${icon} ${label}: ${pc.cyan(String(args.filePath))}`;
+        case 'write_file':
+            return `${icon} ${label}: ${pc.cyan(String(args.filePath))}`;
+        case 'modify_file':
+            return `${icon} ${label}: ${pc.cyan(String(args.filePath))}`;
+        case 'list_directory':
+            return `${icon} ${label}: ${pc.cyan(String(args.dirPath ?? '.'))}`;
+        case 'run_command':
+            return `${icon} ${label}: ${pc.yellow(String(args.command))}`;
+        case 'grep_search':
+            return `${icon} ${label}: ${pc.magenta(String(args.pattern))}`;
+        case 'delete_file':
+            return `${icon} ${label}: ${pc.red(String(args.filePath))}`;
+        case 'rename_file':
+            return `${icon} ${label}: ${pc.cyan(String(args.sourcePath))} -> ${pc.cyan(String(args.targetPath))}`;
+        case 'find_dependencies':
+            return `${icon} ${label}: ${pc.cyan(String(args.filePath))}${args.direction ? ` (${args.direction})` : ''}`;
+        default:
+            return `${icon} ${label}`;
+    }
+}
+/**
+ * Prompts the user to approve a shell command, respecting the current
+ * approval mode (ask / skip-once / skip-all).
+ *
+ * Returns `true` if the command should run, `false` to deny.
+ */
+async function requestCommandApproval(command) {
+    const mode = getApprovalMode();
+    if (mode === 'skip-all') {
+        p.log.info(`${pc.dim('Auto-approved (skip-all):')} ${pc.yellow(command)}`);
+        return true;
+    }
+    if (mode === 'skip-once') {
+        p.log.info(`${pc.dim('Auto-approved (skip-once):')} ${pc.yellow(command)}`);
+        consumeSkipOnce();
+        return true;
+    }
+    // mode === 'ask'
+    const result = await p.select({
+        message: `Approve command: ${pc.yellow(command)}`,
+        options: [
+            { value: 'approve', label: 'Yes, run this command' },
+            { value: 'skip-once', label: 'Yes, and skip approval for the next command too' },
+            {
+                value: 'skip-all',
+                label: 'Yes, auto-approve all future commands (Note: this lasts until you restart the CLI)',
+            },
+            { value: 'deny', label: 'No, deny this command' },
+        ],
+    });
+    if (p.isCancel(result) || result === 'deny') {
+        return false;
+    }
+    if (result === 'skip-once') {
+        setApprovalMode('skip-once');
+    }
+    else if (result === 'skip-all') {
+        setApprovalMode('skip-all');
+    }
+    return true;
+}
+// ─── Agent Loop ──────────────────────────────────────────────────────
+/**
+ * Processes a single model response that may contain tool calls.
+ * Handles the full tool-call loop: execute → feed results → repeat
+ * until the model produces a final text response.
+ */
+async function processResponse(chat, result, workspaceRoot, inputHandler, agentState, abortSignal) {
+    let response = result.response;
+    let turnCount = 0;
+    const MAX_TURNS = 25;
+    // Loop while the model keeps requesting tool calls
+    while (true) {
+        turnCount++;
+        if (turnCount > MAX_TURNS) {
+            p.log.error(`${pc.red('System Error:')} Agent exceeded maximum autonomous turns (${MAX_TURNS}). Force stopping to prevent infinite loop.`);
+            return 'I have exceeded the maximum allowed number of autonomous actions (25 turns) and was force-stopped by the system to prevent an infinite loop. Please adjust your request or guide me on what went wrong.';
+        }
+        const functionCalls = response.functionCalls();
+        if (!functionCalls || functionCalls.length === 0) {
+            // No more tool calls — return the final text response
+            return response.text() ?? '';
+        }
+        // Process each tool call
+        const toolResponses = [];
+        for (const fc of functionCalls) {
+            const toolName = fc.name;
+            const toolArgs = (fc.args ?? {});
+            // Display what the agent is doing
+            p.log.step(formatToolCall(toolName, toolArgs));
+            // For run_command, request user approval
+            if (toolName === 'run_command') {
+                await inputHandler.waitForPrompt();
+                inputHandler.stop();
+                const approved = await requestCommandApproval(toolArgs.command);
+                inputHandler.start();
+                if (!approved) {
+                    toolResponses.push({
+                        functionResponse: {
+                            name: toolName,
+                            response: {
+                                output: '',
+                                error: 'Command was denied by the user. Do not retry this command. Ask the user how they would like to proceed.',
+                            },
+                        },
+                    });
+                    continue;
+                }
+            }
+            // Execute the tool
+            const toolResult = await executeTool(workspaceRoot, toolName, toolArgs);
+            if (toolResult.error) {
+                debugLog(`Raw Tool Error for ${toolName}: ${toolResult.error}`);
+                // Truncate the error message for the terminal UI to prevent console clutter
+                // (e.g. hiding the large file previews sent to the AI)
+                const displayError = toolResult.error.split('\n')[0].substring(0, 100);
+                p.log.warn(`${pc.red('Tool error:')} [${displayError}]`);
+            }
+            toolResponses.push({
+                functionResponse: {
+                    name: toolName,
+                    response: {
+                        output: toolResult.output,
+                        ...(toolResult.error ? { error: toolResult.error } : {}),
+                    },
+                },
+            });
+        }
+        await inputHandler.waitForPrompt();
+        const queuedMsg = inputHandler.getAndClear();
+        let additionalText = undefined;
+        if (queuedMsg) {
+            additionalText = `[USER INTERRUPTION] The user sent the following message during your execution:\n"${queuedMsg}"\n\nPlease incorporate this feedback into your ongoing work. Address the user's message, but DO NOT lose track of your original overall plan or focus. After addressing this interruption, continue with your broader objective.`;
+            p.log.info(pc.cyan(`Sending queued message to AI...`));
+            const newIntent = await routeIntent(queuedMsg);
+            if (agentState.targetAgent === 'CHAT') {
+                if (newIntent.targetAgent === 'EXECUTE' || newIntent.needsContext) {
+                    agentState.targetAgent = 'EXECUTE';
+                    const config = getPlanExecutionConfig();
+                    chat.setAgentConfig(config.systemInstruction, config.tools);
+                    p.log.info(pc.yellow(`Upgraded session intent to EXECUTE based on chained message.`));
+                }
+            }
+        }
+        // Feed tool results back to the model
+        let followUp;
+        try {
+            followUp = await chat.sendMessage(toolResponses, additionalText, abortSignal);
+        }
+        catch (e) {
+            if (e.name === 'AbortError' || e.message?.includes('abort')) {
+                p.log.warn(pc.yellow('Generation stopped by user.'));
+                return '[Generation stopped by user]';
+            }
+            throw e;
+        }
+        const grounding = followUp.response.groundingMetadata?.();
+        if (grounding?.webSearchQueries && grounding.webSearchQueries.length > 0) {
+            p.log.info(`${pc.blue('🌐')} ${pc.dim('Google Search Queries:')} ${grounding.webSearchQueries.map((q) => pc.cyan(`"${q}"`)).join(', ')}`);
+        }
+        response = followUp.response;
+    }
+}
+/**
+ * Starts the interactive agent chat loop.
+ * Runs until the user types "exit", "quit", or presses Ctrl+C.
+ */
+export async function startAgentLoop(workspaceRoot, version) {
+    const chat = createSharedChatSession();
+    const inputHandler = new AsyncInputHandler();
+    // Intercept terminal paste events to prevent accidental early-submission of multi-line pastes
+    const originalEmit = process.stdin.emit.bind(process.stdin);
+    process.stdin.emit = function (event, ...args) {
+        if (event === 'data' && Buffer.isBuffer(args[0])) {
+            let chunk = args[0].toString();
+            // If a single data chunk is longer than 2 characters and contains a newline, it is a paste event.
+            // (Normal typing sends 1 character per data event. Enter key sends exactly 1 character).
+            if (chunk.length > 2 && (chunk.includes('\n') || chunk.includes('\r'))) {
+                chunk = chunk.replace(/\r?\n/g, ' ');
+                args[0] = Buffer.from(chunk);
+            }
+        }
+        return originalEmit(event, ...args);
+    };
+    console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
+    while (true) {
+        inputHandler.stop();
+        let lines = [];
+        let isMultiLine = false;
+        let canceledGlobal = false;
+        while (true) {
+            const userInputRaw = await p.text({
+                message: isMultiLine ? '  ' : '❯',
+                placeholder: isMultiLine ? '' : 'Use "\\" for new lines',
+            });
+            if (p.isCancel(userInputRaw)) {
+                if (isMultiLine) {
+                    p.log.warn(pc.yellow('Multi-line input canceled.'));
+                    lines = [];
+                    isMultiLine = false;
+                    continue;
+                }
+                else {
+                    canceledGlobal = true;
+                    break;
+                }
+            }
+            let line = (userInputRaw || '');
+            if (line.trimEnd().endsWith('\\')) {
+                const cleanLine = line.trimEnd().slice(0, -1);
+                lines.push(cleanLine);
+                isMultiLine = true;
+                // Clack's text prompt dims the submitted value, which can be completely invisible on some terminal themes.
+                // We explicitly log the line here so the user can see what they are typing in multiline mode.
+                p.log.step(pc.cyan(cleanLine));
+            }
+            else {
+                lines.push(line);
+                if (isMultiLine) {
+                    p.log.step(pc.cyan(line));
+                }
+                break;
+            }
+        }
+        if (canceledGlobal) {
+            p.outro(pc.green('Goodbye! Happy coding. 🚀'));
+            return;
+        }
+        let userInput = lines.join('\n').trim();
+        if (!userInput) {
+            continue;
+        }
+        if (userInput === '/') {
+            const commandMenu = await p.select({
+                message: 'Command Menu',
+                options: [
+                    { value: '/models', label: '/models', hint: 'Change the active AI model' },
+                    { value: '/clear', label: '/clear', hint: 'Clear chat session history' },
+                    { value: '/debug', label: '/debug', hint: 'Toggle internal debug logs' },
+                    { value: '/auto-approve', label: '/auto-approve', hint: 'Approve all future terminal commands' },
+                    { value: '/commit', label: '/commit', hint: 'Auto-commit changes with AI message' },
+                    { value: '/revert', label: '/revert', hint: 'Undo last change' },
+                    { value: 'exit', label: 'exit', hint: 'Close the CLI' },
+                    { value: 'cancel', label: 'cancel', hint: 'Return to chat' },
+                ],
+            });
+            if (p.isCancel(commandMenu) || commandMenu === 'cancel') {
+                continue;
+            }
+            userInput = commandMenu;
+        }
+        if (userInput.toLowerCase() === 'exit' || userInput.toLowerCase() === 'quit') {
+            p.outro(pc.green('Goodbye! Happy coding. 🚀'));
+            return;
+        }
+        if (userInput.length === 0) {
+            continue;
+        }
+        // Handle special commands
+        if (userInput.toLowerCase() === '/clear') {
+            chat.clearHistory();
+            process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
+            p.intro(`${pc.bgCyan(pc.black(' Minovative Mind '))} ${pc.dim('v' + version)}`);
+            p.log.info(`${pc.dim('Workspace:')} ${pc.cyan(workspaceRoot)}`);
+            p.log.info(`${pc.dim('Commands:')} Type ${pc.yellow('/')} to open the command menu. Type ${pc.yellow('exit')} to leave.`);
+            p.log.success('Chat history cleared.');
+            console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
+            continue;
+        }
+        if (userInput.toLowerCase() === '/models') {
+            const selectedModel = await p.select({
+                message: 'Select AI Model',
+                options: [
+                    { value: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro', hint: 'Best for complex coding & large context' },
+                    { value: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash', hint: 'Balanced performance' },
+                    // {value: 'claude-opus-4-6', label: 'Claude Opus 4.6', hint: 'Anthropic: Highly capable, complex reasoning'},
+                    // {value: 'claude-sonnet-4-6', label: 'Claude Sonnet 4.6', hint: 'Anthropic: Fast and highly intelligent'},
+                ],
+            });
+            if (!p.isCancel(selectedModel)) {
+                chat.setModel(selectedModel);
+                p.log.success(`Model successfully switched to ${pc.cyan(selectedModel)}`);
+            }
+            continue;
+        }
+        if (userInput.toLowerCase() === '/debug') {
+            const isEnabled = toggleDebugMode();
+            if (isEnabled) {
+                p.log.success('Debug mode enabled. Internal logs will now be shown.');
+            }
+            else {
+                p.log.success('Debug mode disabled.');
+            }
+            continue;
+        }
+        if (userInput.toLowerCase() === '/auto-approve') {
+            setApprovalMode('skip-all');
+            p.log.success('Auto-approve enabled for all future commands in this session.');
+            continue;
+        }
+        if (userInput.toLowerCase() === '/revert') {
+            const lastChangeSet = changeLogger.popLastChangeSet();
+            if (!lastChangeSet) {
+                p.log.warn('No changes to revert.');
+                continue;
+            }
+            const spinner = p.spinner();
+            spinner.start('Reverting last changes...');
+            try {
+                for (const change of lastChangeSet.changes) {
+                    const absPath = path.resolve(workspaceRoot, change.filePath);
+                    if (change.action === 'create') {
+                        await fs.rm(absPath, { force: true });
+                    }
+                    else if (change.originalContent !== null) {
+                        await fs.writeFile(absPath, change.originalContent, 'utf-8');
+                    }
+                }
+                spinner.stop('Reverted successfully.');
+                p.log.success(`Reverted changes for: ${lastChangeSet.description}`);
+            }
+            catch (err) {
+                spinner.stop('Revert failed.');
+                p.log.error(`Failed to revert: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            continue;
+        }
+        if (userInput.toLowerCase() === '/commit') {
+            const commitSpinner = p.spinner();
+            commitSpinner.start('Staging changes and analyzing diff...');
+            try {
+                await execAsync('git add .', { cwd: workspaceRoot });
+                const { stdout: diffOut } = await execAsync('git diff --cached', { cwd: workspaceRoot });
+                if (!diffOut || diffOut.trim().length === 0) {
+                    commitSpinner.stop('No changes to commit.');
+                    p.log.warn('Git working tree is clean.');
+                    continue;
+                }
+                commitSpinner.message('Generating commit message...');
+                const prompt = `Generate a concise, standard git commit message for the following diff. Only return the commit message text.
+
+<diff>
+${diffOut}
+</diff>`;
+                // Use flash-lite for extreme speed and low cost for this simple task
+                const commitSystemPrompt = 'You are an expert developer. Output only the git commit message, no markdown formatting, no explanations. Follow Conventional Commits format (feat:, fix:, chore:, refactor:, etc.) for the first line, keeping it under 70 characters and using the imperative mood. Then, add a blank line followed by a more descriptive bulleted list explaining the "what" and "why" of the changes based on the diff.';
+                const commitAgent = new ProxyChatSession('gemini-2.5-flash-lite', commitSystemPrompt, [], {});
+                const commitResult = await commitAgent.sendMessage(prompt);
+                const commitMsg = commitResult.response.text().trim();
+                commitSpinner.message('Committing...');
+                const tmpMsgPath = path.join(workspaceRoot, '.gemini-commit-msg.tmp');
+                await fs.writeFile(tmpMsgPath, commitMsg, 'utf-8');
+                try {
+                    await execAsync(`git commit -F .gemini-commit-msg.tmp`, { cwd: workspaceRoot });
+                }
+                finally {
+                    await fs.rm(tmpMsgPath, { force: true });
+                }
+                commitSpinner.stop('Committed successfully.');
+                p.log.success(`Committed with message:\n\n${pc.dim(commitMsg)}`);
+            }
+            catch (err) {
+                commitSpinner.stop('Commit failed.');
+                p.log.error(`Failed to commit: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            continue;
+        }
+        const spinner = p.spinner();
+        const ac = new AbortController();
+        inputHandler.setAbortController(ac);
+        try {
+            inputHandler.start(spinner);
+            changeLogger.startChangeSet(userInput);
+            let finalInput = userInput;
+            spinner.start('🔍 Investigating workspace...');
+            const chatHistory = chat.getRecentHistory(3);
+            const gatherRes = await gatherContext(workspaceRoot, userInput, chatHistory, inputHandler, ac.signal, (msg) => {
+                if (!inputHandler.isCurrentlyPrompting()) {
+                    spinner.message(`🔍 Investigating workspace... ${pc.dim(msg)}`);
+                }
+            });
+            let latestUsage = undefined;
+            // Also grab any messages queued exactly between gatherContext ending and here
+            const leftoverMsg = inputHandler.getAndClear();
+            if (leftoverMsg) {
+                gatherRes.chainedMessages.push(leftoverMsg);
+            }
+            let effectiveTargetAgent = gatherRes.targetAgent;
+            if (gatherRes.chainedMessages.length > 0) {
+                const chainedContent = gatherRes.chainedMessages.join('\n');
+                const newIntent = await routeIntent(chainedContent);
+                if (gatherRes.contextResult !== null) {
+                    // Was SEARCH: Can change to EXECUTE or CHAT based on chained message
+                    effectiveTargetAgent = newIntent.targetAgent;
+                }
+                else {
+                    // Was NOT SEARCH
+                    if (gatherRes.targetAgent === 'EXECUTE') {
+                        // Executing cannot downgrade to CHAT
+                        effectiveTargetAgent = 'EXECUTE';
+                    }
+                    else {
+                        // Was CHAT: Can change to SEARCH or EXECUTE. Both are treated as EXECUTE to grant tools.
+                        if (newIntent.targetAgent === 'EXECUTE' || newIntent.needsContext) {
+                            effectiveTargetAgent = 'EXECUTE';
+                        }
+                    }
+                }
+                finalInput += `\n\n[USER FOLLOW-UP INSTRUCTIONS SENT DURING INVESTIGATION]:\n${chainedContent}\n\nPlease incorporate these instructions into your work. Address them appropriately, but ensure you do not lose track of the original request's primary objective.`;
+            }
+            // Hot-swap the agent configuration based on intent
+            debugLog(`Intent Router output: original targetAgent = ${gatherRes.targetAgent}, effective = ${effectiveTargetAgent}`);
+            const config = effectiveTargetAgent === 'CHAT' ? getGeneralChatConfig() : getPlanExecutionConfig();
+            let dynamicSystemInstruction = config.systemInstruction;
+            if (gatherRes.contextResult) {
+                const contextInjection = buildContextInjection(gatherRes.contextResult);
+                debugLog(`Context injection size: ${contextInjection.length} chars`);
+                dynamicSystemInstruction += '\n\n' + contextInjection;
+            }
+            chat.setAgentConfig(dynamicSystemInstruction, config.tools);
+            if (!inputHandler.isCurrentlyPrompting()) {
+                spinner.message('Thinking...');
+            }
+            let result;
+            try {
+                result = await chat.sendMessage(finalInput, undefined, ac.signal);
+            }
+            catch (e) {
+                if (e.name === 'AbortError' || e.message?.includes('abort')) {
+                    p.log.warn(pc.yellow('Generation aborted by user.'));
+                    spinner.stop('');
+                    continue;
+                }
+                throw e;
+            }
+            latestUsage = result.response.usageMetadata?.();
+            const grounding = result.response.groundingMetadata?.();
+            if (grounding?.webSearchQueries && grounding.webSearchQueries.length > 0) {
+                p.log.info(`${pc.blue('🌐')} ${pc.dim('Google Search Queries:')} ${grounding.webSearchQueries.map((q) => pc.cyan(`"${q}"`)).join(', ')}`);
+            }
+            spinner.stop('');
+            let finalText = '';
+            const MAX_CORRECTIONS = 3;
+            let correctionAttempts = 0;
+            const calls = result.response.functionCalls();
+            debugLog(`Initial functionCalls: ${calls && calls.length > 0 ? JSON.stringify(calls) : 'None'}`);
+            let agentState = { targetAgent: effectiveTargetAgent };
+            while (correctionAttempts <= MAX_CORRECTIONS) {
+                if (finalText === '[Generation stopped by user]')
+                    break;
+                finalText = await processResponse(chat, result, workspaceRoot, inputHandler, agentState, ac.signal);
+                debugLog(`processResponse returned finalText (length ${finalText.length}): "${finalText.substring(0, 50)}..."`);
+                const currentChanges = changeLogger.getCurrentChangeSet()?.changes || [];
+                const changedFiles = currentChanges
+                    .filter((c) => c.action === 'create' || c.action === 'modify')
+                    .map((c) => c.filePath);
+                if (changedFiles.length === 0)
+                    break;
+                p.log.step('Verifying modified files...');
+                const verificationErrors = await verifyChangedFiles(workspaceRoot, changedFiles);
+                if (!verificationErrors) {
+                    p.log.success('Verification passed.');
+                    break;
+                }
+                correctionAttempts++;
+                if (correctionAttempts > MAX_CORRECTIONS) {
+                    p.log.warn('Max self-correction attempts reached. Leaving remaining errors for manual review.');
+                    break;
+                }
+                p.log.warn(`${pc.yellow('Verification failed. Auto-correcting errors')} (Attempt ${correctionAttempts}/${MAX_CORRECTIONS})...`);
+                // Optionally show a snippet of the error to the user so they aren't left in the dark
+                const displayError = verificationErrors.split('\n').slice(0, 5).join('\n');
+                console.log(pc.dim(`  ${displayError.replace(/\n/g, '\n  ')}\n  ...`));
+                debugLog(`Verification failed on attempt ${correctionAttempts}/${MAX_CORRECTIONS}. Errors:\n${verificationErrors}`);
+                const correctionPrompt = `AUTOMATED SYSTEM CHECK: Your previous changes resulted in the following errors:\n\n${verificationErrors}\n\nPlease analyze these errors and use your file modification tools to fix them.`;
+                spinner.start('Thinking (Correction)...');
+                result = await chat.sendMessage(correctionPrompt);
+                spinner.stop('');
+            }
+            changeLogger.commitChangeSet();
+            if (finalText) {
+                console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim(`(${chat.getModel()})`)}\n`);
+                console.log(marked.parse(finalText));
+            }
+            if (latestUsage && latestUsage.remainingBalance !== undefined) {
+                p.log.info(`${pc.dim('Credits Remaining:')} ${pc.cyan(latestUsage.remainingBalance.toLocaleString())}`);
+            }
+        }
+        catch (err) {
+            spinner.stop('');
+            const message = err instanceof Error ? err.message : String(err);
+            p.log.error(`${pc.red('Error:')} ${message}`);
+        }
+    }
+}