minovative-mind-cli 1.4.1 → 1.4.3

package/dist/services/agent/slashCommands.js

@@ -0,0 +1,203 @@
+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';
+import { toggleDebugMode } from '../../utils/logger.js';
+import { changeLogger } from '../changeLogger.js';
+import { printLogo } from '../../utils/logo.js';
+import { readPaste } from '../../utils/paste.js';
+import { setApprovalMode, getApprovalMode } from '../agent-tools.js';
+import { ProxyChatSession } from '../ai.js';
+const execAsync = promisify(exec);
+/**
+ * Handles all slash command operations (/paste, /clear, /models, /debug, /auto-approve, /revert, /commit).
+ * Returns control state to the caller loop (such as whether to continue/skip, or if a text-override occurred).
+ */
+export async function handleSlashCommand(command, context) {
+    const { chat, inputHandler, workspaceRoot, version } = context;
+    const lowerCommand = command.toLowerCase();
+    if (lowerCommand === '/paste') {
+        p.log.info(pc.cyan('Paste mode activated. Paste your text below, then press Ctrl+D on an empty line to submit. (Ctrl+C to cancel)'));
+        try {
+            const content = await readPaste();
+            if (content === null) {
+                p.log.warn('Paste mode canceled.');
+                return { shouldContinue: true, isRawPasteMode: false };
+            }
+            if (!content) {
+                p.log.warn('Paste mode closed with no content.');
+                return { shouldContinue: true, isRawPasteMode: false };
+            }
+            p.log.step(pc.cyan(`Loaded ${content.length} characters from paste.`));
+            return { shouldContinue: false, userInputOverride: content, isRawPasteMode: false };
+        }
+        catch (err) {
+            p.log.error(`Paste failed: ${err instanceof Error ? err.message : String(err)}`);
+            return { shouldContinue: true, isRawPasteMode: false };
+        }
+    }
+    if (lowerCommand === '/clear') {
+        chat.clearHistory();
+        process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
+        printLogo();
+        p.intro(`${pc.bgCyan(pc.black(' Minovative Mind CLI '))} ${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 and "${pc.yellow('stop')}" to stop the ai generation. 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'));
+        return { shouldContinue: true };
+    }
+    if (lowerCommand === '/models') {
+        const currentModel = chat.getModel();
+        const selectedModel = await p['select']({
+            message: `Select AI Model (Current: ${pc.cyan(currentModel)})`,
+            initialValue: currentModel,
+            options: [
+                {
+                    value: 'gemini-3.1-pro-preview',
+                    label: 'Gemini 3.1 Pro',
+                    hint: 'The newest Pro model for complex logic',
+                },
+                {
+                    value: 'gemini-3.5-flash',
+                    label: 'Gemini 3.5 Flash',
+                    hint: 'Balanced performance',
+                },
+                {
+                    value: 'gemini-3.1-flash-lite',
+                    label: 'Gemini 3.1 Flash-Lite',
+                    hint: 'Ultra-fast and cost-effective',
+                },
+            ],
+        });
+        if (!p.isCancel(selectedModel)) {
+            chat.setModel(selectedModel);
+            p.log.success(`Model successfully switched to ${pc.cyan(selectedModel)}`);
+        }
+        return { shouldContinue: true };
+    }
+    if (lowerCommand === '/debug') {
+        const debugMode = toggleDebugMode();
+        if (debugMode) {
+            p.log.info('Debug mode enabled. Internal logs will now be shown.');
+        }
+        else {
+            p.log.info('Debug mode disabled.');
+        }
+        return { shouldContinue: true };
+    }
+    if (lowerCommand === '/auto-approve') {
+        if (getApprovalMode() === 'skip-all') {
+            setApprovalMode('ask');
+            p.log.success('Auto-approve disabled. You will be prompted before commands run.');
+        }
+        else {
+            setApprovalMode('skip-all');
+            p.log.success('Auto-approve enabled for all future commands in this session.');
+        }
+        return { shouldContinue: true };
+    }
+    if (lowerCommand === '/revert') {
+        const history = changeLogger.getHistory();
+        if (!history || history.length === 0) {
+            p.log.warn('No changes to revert.');
+            return { shouldContinue: true };
+        }
+        const lastChangeSet = history[history.length - 1];
+        const truncate = (str, max) => (str.length > max ? str.substring(0, max - 3) + '...' : str);
+        const revertMenu = await p['select']({
+            message: 'Revert Menu',
+            options: [
+                { value: 'revert_last', label: `Revert last change (${truncate(lastChangeSet.description, 50)})` },
+                { value: 'view_history', label: 'View history' },
+                { value: 'cancel', label: 'Cancel' },
+            ],
+        });
+        if (p.isCancel(revertMenu) || revertMenu === 'cancel') {
+            return { shouldContinue: true };
+        }
+        let targetTimestamp = lastChangeSet.timestamp;
+        if (revertMenu === 'view_history') {
+            const historyOptions = history
+                .slice()
+                .reverse()
+                .map((cs, i) => ({
+                value: cs.timestamp,
+                label: `[${i === 0 ? 'Latest' : `-${i}`}] ${truncate(cs.description, 50)} (${new Date(cs.timestamp).toLocaleTimeString()})`,
+                hint: `Reverts this and all ${i} changes after it`,
+            }));
+            const selectedHistory = await p['select']({
+                message: 'Select the point in history to revert back to:',
+                options: [...historyOptions, { value: -1, label: 'Cancel' }],
+            });
+            if (p.isCancel(selectedHistory) || selectedHistory === -1) {
+                return { shouldContinue: true };
+            }
+            targetTimestamp = selectedHistory;
+        }
+        const spinner = p.spinner();
+        spinner.start('Reverting selected changes...');
+        try {
+            const changesToRevert = changeLogger.popUntil(targetTimestamp);
+            const flatChanges = changesToRevert.flatMap((cs) => cs.changes);
+            for (const change of flatChanges) {
+                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 ${changesToRevert.length} changeset(s) successfully.`);
+        }
+        catch (err) {
+            spinner.stop('Revert failed.');
+            p.log.error(`Failed to revert: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return { shouldContinue: true };
+    }
+    if (lowerCommand === '/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.');
+                return { shouldContinue: true };
+            }
+            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>`;
+            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-3.1-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)}`);
+        }
+        return { shouldContinue: true };
+    }
+    return { shouldContinue: true };
+}

package/dist/services/agent/toolLoop.d.ts

@@ -0,0 +1,39 @@
+import { ProxyChatSession } from '../ai.js';
+import { AsyncInputHandler } from './inputHandler.js';
+import type { AgentState } from './types.js';
+/**
+ * Formats a tool execution call into a beautifully stylized console status line.
+ * Extracts context-specific arguments to display relevant parameters in real-time.
+ *
+ * @param name - The identifier of the tool being called (e.g. 'read_file').
+ * @param args - The dictionary of parameters supplied to the tool.
+ * @returns A fully colorized and formatted ANSI console string.
+ */
+export declare function formatToolCall(name: string, args: Record<string, unknown>): string;
+/**
+ * Coordinates and executes the recursive model-response tool-execution loop.
+ *
+ * ### Execution Mechanism:
+ * This function processes the initial response from the generative model. If the model determines
+ * it needs to execute tools (e.g. read_file, run_command, modify_file) to answer or fulfill the request:
+ *
+ * 1. **Analyze Tool Requirements**: Parses requested `functionCalls` from the LLM.
+ * 2. **Check for User Abortion**: Periodically examines the `AbortSignal` to stop execution if requested.
+ * 3. **Manage Safety Approvals**: For high-risk operations (like `run_command`), requests explicit confirmation from the user (or uses auto-approve configurations).
+ * 4. **Execute Operations**: Runs requested tool actions via `executeTool` in parallel or series as requested.
+ * 5. **Handle Interrupts**: Integrates background user inputs queued in `inputHandler` as new context prompts back into the active LLM context.
+ * 6. **Submit Loop Frame**: Feeds execution outcomes back to the Gemini session and recursively repeats this sequence until the LLM produces a final text answer without further tool requests.
+ *
+ * ### Limits & Recovery Guardrails:
+ * - **Turn-Limiting**: Capped at `MAX_TURNS` (100) to prevent infinite loops, API token drain, or excessive billing if the AI gets stuck in a repetitive loop.
+ * - **Empty-Response Healing**: If the API returns an empty text response with no tools, the system initiates up to `MAX_EMPTY_RETRIES` (3) system-driven wake-up prompts to re-engage the model.
+ *
+ * @param chat - The current active proxy chat session.
+ * @param result - The current result returned from sending a message to the model.
+ * @param workspaceRoot - The absolute/relative path to the workspace root.
+ * @param inputHandler - The input handler to check for queued interrupts.
+ * @param agentState - State tracker for whether the target agent configuration is CHAT or EXECUTE.
+ * @param abortSignal - Signal to detect when the operation has been cancelled.
+ * @returns A promise that resolves to the final text response.
+ */
+export declare function processResponse(chat: ProxyChatSession, result: any, workspaceRoot: string, inputHandler: AsyncInputHandler, agentState: AgentState, abortSignal: AbortSignal): Promise<string>;

package/dist/services/agent/toolLoop.js

@@ -0,0 +1,271 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { debugLog } from '../../utils/logger.js';
+import { executeTool } from '../agent-tools.js';
+import { getPlanExecutionConfig } from '../ai.js';
+import { routeIntent } from '../contextAgent.js';
+import { requestCommandApproval } from './commandApproval.js';
+// ─── Constants ───────────────────────────────────────────────────────
+/**
+ * Mapping of tool identifiers to user-friendly terminal emojis.
+ * Enhances the visual feedback during background tool execution turns.
+ */
+const TOOL_ICONS = {
+    read_file: '📖',
+    write_file: '✏️',
+    modify_file: '🔧',
+    list_directory: '📂',
+    run_command: '⚡',
+    grep_search: '🔍',
+    delete_file: '🗑️',
+    rename_file: '🚚',
+    find_dependencies: '🔗',
+    run_analysis_script: '🔬',
+};
+/**
+ * Human-readable translations for tool actions.
+ * Used for constructing clear, active-verb descriptive log headers in the CLI.
+ */
+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',
+    run_analysis_script: 'Analyzing code structure',
+};
+// ─── Helpers ─────────────────────────────────────────────────────────
+/**
+ * Formats a tool execution call into a beautifully stylized console status line.
+ * Extracts context-specific arguments to display relevant parameters in real-time.
+ *
+ * @param name - The identifier of the tool being called (e.g. 'read_file').
+ * @param args - The dictionary of parameters supplied to the tool.
+ * @returns A fully colorized and formatted ANSI console string.
+ */
+export function formatToolCall(name, args) {
+    const icon = TOOL_ICONS[name] ?? '🔧';
+    const label = TOOL_LABELS[name] ?? name;
+    const formatPath = (path) => pc.cyan(path);
+    const argsMap = {
+        read_file: () => {
+            if (args.startLine !== undefined || args.endLine !== undefined) {
+                const start = args.startLine ?? 1;
+                const end = args.endLine ?? 'end';
+                return pc.dim(` (Lines ${start}-${end})`) + `: ${formatPath(String(args.filePath))}`;
+            }
+            if (Array.isArray(args.targetElements) && args.targetElements.length > 0) {
+                return pc.dim(` (Elements: ${args.targetElements.join(', ')})`) + `: ${formatPath(String(args.filePath))}`;
+            }
+            return `: ${formatPath(String(args.filePath))}`;
+        },
+        write_file: () => `: ${formatPath(String(args.filePath))}`,
+        modify_file: () => `: ${formatPath(String(args.filePath))}`,
+        list_directory: () => `: ${formatPath(String(args.dirPath ?? '.'))}`,
+        run_command: () => `: ${pc.yellow(String(args.command))}`,
+        grep_search: () => `: ${pc.magenta(String(args.pattern))}`,
+        delete_file: () => `: ${pc.red(String(args.filePath))}`,
+        rename_file: () => `: ${formatPath(String(args.sourcePath))} -> ${formatPath(String(args.targetPath))}`,
+        find_dependencies: () => `: ${formatPath(String(args.filePath))}${args.direction ? ` (${args.direction})` : ''}`,
+        run_analysis_script: () => `: ${formatPath(String(args.targetFile ?? 'workspace'))}`,
+    };
+    const formatter = argsMap[name];
+    const details = formatter ? formatter() : '';
+    return `${icon} ${label}${details}`;
+}
+/**
+ * Coordinates and executes the recursive model-response tool-execution loop.
+ *
+ * ### Execution Mechanism:
+ * This function processes the initial response from the generative model. If the model determines
+ * it needs to execute tools (e.g. read_file, run_command, modify_file) to answer or fulfill the request:
+ *
+ * 1. **Analyze Tool Requirements**: Parses requested `functionCalls` from the LLM.
+ * 2. **Check for User Abortion**: Periodically examines the `AbortSignal` to stop execution if requested.
+ * 3. **Manage Safety Approvals**: For high-risk operations (like `run_command`), requests explicit confirmation from the user (or uses auto-approve configurations).
+ * 4. **Execute Operations**: Runs requested tool actions via `executeTool` in parallel or series as requested.
+ * 5. **Handle Interrupts**: Integrates background user inputs queued in `inputHandler` as new context prompts back into the active LLM context.
+ * 6. **Submit Loop Frame**: Feeds execution outcomes back to the Gemini session and recursively repeats this sequence until the LLM produces a final text answer without further tool requests.
+ *
+ * ### Limits & Recovery Guardrails:
+ * - **Turn-Limiting**: Capped at `MAX_TURNS` (100) to prevent infinite loops, API token drain, or excessive billing if the AI gets stuck in a repetitive loop.
+ * - **Empty-Response Healing**: If the API returns an empty text response with no tools, the system initiates up to `MAX_EMPTY_RETRIES` (3) system-driven wake-up prompts to re-engage the model.
+ *
+ * @param chat - The current active proxy chat session.
+ * @param result - The current result returned from sending a message to the model.
+ * @param workspaceRoot - The absolute/relative path to the workspace root.
+ * @param inputHandler - The input handler to check for queued interrupts.
+ * @param agentState - State tracker for whether the target agent configuration is CHAT or EXECUTE.
+ * @param abortSignal - Signal to detect when the operation has been cancelled.
+ * @returns A promise that resolves to the final text response.
+ */
+export async function processResponse(chat, result, workspaceRoot, inputHandler, agentState, abortSignal) {
+    let response = result.response;
+    // Upper limit on autonomous sequential tool executions to prevent out-of-control loops
+    let turnCount = 0;
+    const MAX_TURNS = 100;
+    // Recovery thresholds for handling unexpected empty API payloads
+    let emptyRetryCount = 0;
+    const MAX_EMPTY_RETRIES = 3;
+    // 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.`);
+            try {
+                p.log.info(pc.cyan(`Requesting final summary from AI based on gathered information...`));
+                const originalTools = chat.tools || [];
+                const originalInstruction = chat.systemInstruction || '';
+                // Temporarily clear tools to force a pure text response
+                chat.setAgentConfig(originalInstruction, []);
+                const finalFollowUp = await chat.sendMessage(`[SYSTEM INTERRUPTION] You have exceeded the maximum number of allowed tool operations (${MAX_TURNS} turns). You must now provide a final answer to the user based ONLY on the information you have gathered so far. Do NOT attempt to call any more tools, just answer the user directly.`, undefined, abortSignal);
+                // Restore tools
+                chat.setAgentConfig(originalInstruction, originalTools);
+                const finalOutput = finalFollowUp.response.text();
+                if (finalOutput && finalOutput.trim()) {
+                    return finalOutput;
+                }
+                return '';
+            }
+            catch (e) {
+                if (e.name === 'AbortError' || e.message?.includes('abort')) {
+                    p.log.warn(pc.yellow('Generation stopped by user.'));
+                    return '[Generation stopped by user]';
+                }
+                return '';
+            }
+        }
+        const functionCalls = response.functionCalls();
+        if (!functionCalls || functionCalls.length === 0) {
+            // No more tool calls — return the final text response
+            let finalOutput = response.text() ?? '';
+            if (!finalOutput.trim()) {
+                if (emptyRetryCount < MAX_EMPTY_RETRIES) {
+                    emptyRetryCount++;
+                    p.log.warn(pc.yellow(`AI returned an empty response. Attempting to recover (retry ${emptyRetryCount}/${MAX_EMPTY_RETRIES})...`));
+                    // System-driven injection to kickstart the LLM's conversation generation
+                    const wakeUpMessage = 'SYSTEM: You just returned a completely empty response with no tool calls. If you are stuck, please use your tools to explore the workspace, or explain what you are trying to do and ask the user for clarification. Do not return empty responses.';
+                    try {
+                        const retry = await chat.sendMessage(wakeUpMessage, undefined, abortSignal);
+                        response = retry.response;
+                        continue;
+                    }
+                    catch (e) {
+                        if (e.name === 'AbortError' || e.message?.includes('abort')) {
+                            p.log.warn(pc.yellow('Generation stopped by user during recovery.'));
+                            return '[Generation stopped by user]';
+                        }
+                        finalOutput = '[System Error: The AI returned an empty response and failed to recover.]';
+                    }
+                }
+                else {
+                    finalOutput =
+                        '[The AI repeatedly returned empty responses and could not recover. This usually means it hit an API filter/limit or is stuck. Try rewording your prompt.]';
+                }
+            }
+            return finalOutput;
+        }
+        // Process each tool call requested by the model (using helper to avoid nested loop warning)
+        const execRes = await executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal);
+        if (execRes.aborted) {
+            return '[Generation stopped by user]';
+        }
+        const toolResponses = execRes.toolResponses;
+        // Check if the user entered any feedback or interrupt commands during the tool execution cycle
+        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...`));
+            // Dynamically upgrade agent permissions/intent to EXECUTE mode if the interrupted instruction requires system modifications
+            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 and potential interruption text 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;
+        }
+        await inputHandler.waitForPrompt();
+        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;
+    }
+}
+async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal) {
+    const toolResponses = [];
+    for (const fc of functionCalls) {
+        await inputHandler.waitForPrompt();
+        if (abortSignal.aborted) {
+            p.log.warn(pc.yellow('Execution aborted by user.'));
+            return { toolResponses, aborted: true };
+        }
+        const toolName = fc.name;
+        const toolArgs = (fc.args ?? {});
+        // Log the ongoing tool action to the console
+        p.log.step(formatToolCall(toolName, toolArgs));
+        // If executing a CLI/shell command, wait for approval
+        if (toolName === 'run_command') {
+            await inputHandler.waitForPrompt();
+            inputHandler.stop(); // Temporarily release raw-mode during blocking interactive prompt
+            const approved = await requestCommandApproval(toolArgs.command);
+            inputHandler.start(); // Re-engage raw-mode for continuous background monitoring
+            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 underlying filesystem, shell or search tool logic
+        const toolResult = await executeTool(workspaceRoot, toolName, toolArgs, abortSignal);
+        await inputHandler.waitForPrompt();
+        if (toolResult.error) {
+            debugLog(`Raw Tool Error for ${toolName}: ${toolResult.error}`);
+            // Do not spam the user with expected chunking warnings
+            if (!toolResult.error.includes('File is too large')) {
+                // 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 } : {}),
+                },
+            },
+        });
+    }
+    return { toolResponses, aborted: false };
+}

package/dist/services/agent/types.d.ts

@@ -0,0 +1,17 @@
+import type { ProxyChatSession } from '../ai.js';
+import type { AsyncInputHandler } from './inputHandler.js';
+export interface AgentState {
+    targetAgent: 'CHAT' | 'EXECUTE';
+}
+export interface SlashCommandContext {
+    chat: ProxyChatSession;
+    inputHandler: AsyncInputHandler;
+    workspaceRoot: string;
+    version: string;
+    isRawPasteMode: boolean;
+}
+export interface SlashCommandResult {
+    shouldContinue: boolean;
+    userInputOverride?: string;
+    isRawPasteMode?: boolean;
+}

package/dist/services/agent/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/agent.d.ts

@@ -15,96 +15,7 @@
  * 5. **Self-Correction Pipeline**: Compares modified files against TS/Linter diagnostics,
  *    providing feedback on syntax or semantic failures back to the AI for self-healing.
  */
-import * as p from '@clack/prompts';
-/**
- * Asynchronous Input Handler (AsyncInputHandler)
- *
- * This class intercepts user keyboard input from standard input (stdin) while
- * background processes (e.g., Gemini model generations or long shell tool runs)
- * are executing. It provides seamless execution management by letting users:
- *
- * 1. **Pause execution** at any time by pressing a key.
- * 2. **Queue feedback** ("chained messages") without waiting for the entire run to finish.
- * 3. **Force abort** the current model or tool run by entering "stop".
- *
- * ### Raw Mode & Terminal States
- * In normal CLI execution, Node.js waits for a line feed (Enter) before emitting input.
- * To intercept immediate keystrokes, we put `process.stdin` into *raw mode*.
- * While in raw mode, we listen for direct data buffers.
- * To avoid visual conflicts with our logging output and Clack's CLI spinners,
- * we dynamically pause spinners, detach listeners, disable raw mode, open standard
- * interactive text-prompt forms, and resume raw mode and spinners upon completion.
- */
-export declare class AsyncInputHandler {
-    /** Queue of pending user feedback/instructions typed during active background execution */
-    private queue;
-    /** Guard flag preventing multiple simultaneous input prompt overlays */
-    private isPrompting;
-    /** Reference to the Clack CLI spinner which must be paused/restarted during prompts */
-    private spinner;
-    /** Stores the terminal's raw mode configuration state before handler activation */
-    private originalRawMode;
-    /** Indicates whether the input handler is currently inactive/stopped */
-    private stopped;
-    /** Reference to the AbortController controlling the active AI request to trigger cancellations */
-    private ac;
-    /**
-     * Registers the active AbortController for the current AI request.
-     * This is triggered when the user commands a process cancel (e.g., typing "stop").
-     *
-     * @param ac - The AbortController controlling the current generation.
-     */
-    setAbortController(ac: AbortController): void;
-    /**
-     * Determines if a user-prompt dialog is actively running.
-     * Useful for coordinating other console logging output to avoid UI overlap.
-     *
-     * @returns True if a text prompt is currently displayed, false otherwise.
-     */
-    isCurrentlyPrompting(): boolean;
-    /**
-     * Blocks and waits until any active prompting action is completed.
-     * Guarantees terminal stdout is clean before resuming logs.
-     */
-    waitForPrompt(): Promise<void>;
-    /**
-     * Core stdin event listener. Detects pressed keys, pauses background visual elements,
-     * handles exit interrupts, and opens a Clack text dialog for input.
-     *
-     * Handles recovery of the standard input stream and raw mode states even if
-     * errors occur during prompt initialization.
-     *
-     * @param chunk - The raw terminal buffer containing keypress data.
-     * @private
-     */
-    private onData;
-    /**
-     * Starts intercepting keystrokes and enables raw terminal processing.
-     * Saves the original raw mode configuration to ensure a clean restoration later.
-     *
-     * @param spinner - The current active Clack spinner UI reference, if any.
-     */
-    start(spinner?: ReturnType<typeof p.spinner>): void;
-    /**
-     * Disables raw mode, stops intercepting keystrokes, and restores
-     * the terminal stdin stream to its original raw/cooked state.
-     */
-    stop(): void;
-    /**
-     * Retrieves and flushes all user feedback messages accumulated during execution.
-     *
-     * @returns A concatenated string of all queued user messages separated by newlines,
-     *          or an empty string if nothing was queued.
-     */
-    getAndClear(): string;
-}
-/**
- * Starts the interactive agent chat loop.
- * Runs until the user types "exit", "quit", or presses Ctrl+C.
- *
- * @param workspaceRoot - The root directory of the workspace.
- * @param version - The active version of the CLI utility.
- */
+export { AsyncInputHandler } from './agent/inputHandler.js';
 /**
  * Starts and orchestrates the primary interactive command-line interface (REPL) loop.
  *
@@ -120,13 +31,7 @@ export declare class AsyncInputHandler {
  *    - Intercepts and filters OS clipboard paste buffers to allow inserting massive scripts cleanly.
  *
  * 2. **Slash Commands Processing**:
- *    - `/paste`: Interactively captures large copy-pasted blocks using EOF tracking.
- *    - `/clear`: Hard-clears active terminal histories and resets session state.
- *    - `/models`: Dynamic runtime model hot-swapping (e.g., swapping between Flash and Pro variants).
- *    - `/debug`: Toggles active runtime execution telemetry logging.
- *    - `/auto-approve`: Grants blanket terminal script permissions to bypass prompt approval blocks.
- *    - `/revert`: Pops the most recent change-set log and rolls back mutated files to original states.
- *    - `/commit`: Performs git diff staging, executes model summaries to write micro-commits, and executes local git commits.
+ *    - Delegated to `handleSlashCommand` within `src/services/agent/slashCommands.ts`.
  *
  * 3. **Workspace Context Gathering & Intention Routing**:
  *    - Leverages the Context Agent (`gatherContext`) to perform exploratory scans of the active repository.