minovative-mind-cli 1.4.1 → 1.4.3

package/README.md

@@ -41,7 +41,7 @@ the build/performance metrics are green.
 **3. Verify and self-correct**
 
 - **Runs native builds & audits:** Automatically executes your actual build commands (`npm run build`, `cargo check`, etc.) and scans for performance flaws on modified files only.
-- **Autonomously debugs:** Reads the exact compiler output and fixes its own errors across up to 3 hands-free correction cycles.
+- **Autonomously debugs:** Reads the exact compiler output and fixes its own errors across up to 5 hands-free correction cycles.
 
 ---
 
@@ -54,6 +54,8 @@ the build/performance metrics are green.
 
 ## Quick Start
 
+**Prerequisite:** Ensure you have Node.js installed on your machine (v18.0.0 or higher).
+
 ```bash
 npm install -g minovative-mind-cli
 ```
@@ -102,8 +104,8 @@ Hot-swap during a session with `/models`:
 | `/models`       | Hot-swap the active model                             |
 | `/revert`       | Instantly undo all changes from the last turn         |
 | `/commit`       | Generate a conventional commit message from your diff |
-| `/auto-approve` | Skip confirmation prompts for commands                |
-| `/paste`        | Multi-line input mode                                 |
+| `/auto-approve` | Toggle skipping confirmation prompts for commands     |
+| `/paste`        | Multi-line input mode (cancel with Ctrl+C)            |
 | `/debug`        | Expose internal agent diagnostics                     |
 | `stop`          | Abort generation immediately                          |
 

package/dist/commands/login.d.ts

@@ -1,5 +1,20 @@
 import { Command } from '@oclif/core';
+/**
+ * @class LoginCommand
+ * @extends Command
+ * @description Command to authenticate the user with their Minovative Mind account.
+ * Initiates the GitHub Device Flow and exchanges credentials for a Firebase custom token.
+ */
 export default class LoginCommand extends Command {
+    /**
+     * Description of the login command shown in the CLI help documentation.
+     */
     static description: string;
+    /**
+     * Executes the login workflow. Displays the login prompt intro, executes the auth login logic,
+     * and handles UI feedback for successful/failed authorization attempts.
+     *
+     * @returns {Promise<void>}
+     */
     run(): Promise<void>;
 }

package/dist/commands/login.js

@@ -2,8 +2,23 @@ import { Command } from '@oclif/core';
 import { login } from '../services/auth.js';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
+/**
+ * @class LoginCommand
+ * @extends Command
+ * @description Command to authenticate the user with their Minovative Mind account.
+ * Initiates the GitHub Device Flow and exchanges credentials for a Firebase custom token.
+ */
 export default class LoginCommand extends Command {
+    /**
+     * Description of the login command shown in the CLI help documentation.
+     */
     static description = 'Sign in to your Minovative Mind account using GitHub';
+    /**
+     * Executes the login workflow. Displays the login prompt intro, executes the auth login logic,
+     * and handles UI feedback for successful/failed authorization attempts.
+     *
+     * @returns {Promise<void>}
+     */
     async run() {
         p.intro(`${pc.bgCyan(pc.black(' Minovative Mind '))} - Login`);
         const success = await login();

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

@@ -0,0 +1,16 @@
+export declare function isCommandDestructive(command: string): boolean;
+export declare function isCommandSafe(command: string): boolean;
+/**
+ * Executes an interactive approval prompt via `@clack/prompts`.
+ *
+ * Supports pattern-based approvals and three user approval models:
+ * 1. **Ask**: Prompts the user for every shell execution command (except implicitly safe ones).
+ * 2. **Skip-Once**: Automatically grants permission to the current command, then resets.
+ * 3. **Skip-All / Auto-Approve**: Grants permission to all future terminal commands.
+ *
+ * Destructive commands will ALWAYS prompt the user, regardless of mode.
+ *
+ * @param command - The terminal string requested for execution.
+ * @returns A promise resolving to `true` if approved, or `false` if denied/cancelled.
+ */
+export declare function requestCommandApproval(command: string): Promise<boolean>;

package/dist/services/agent/commandApproval.js

@@ -0,0 +1,128 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { consumeSkipOnce, getApprovalMode, setApprovalMode } from '../agent-tools.js';
+export function isCommandDestructive(command) {
+    const destructivePatterns = [
+        // Unix deletion (catches rm -r, rm -rf, rm -fr, rm --recursive, rm --force, anywhere in args)
+        /\brm\s+.*?(?:-[a-zA-Z]*[rfR]|--(?:recursive|force))\b/i,
+        /\bmv\s+.*\/dev\/null\b/i, // Move to void
+        // Windows deletion (catches rd /s, del /f /s)
+        /\b(?:rd|rmdir)\s+.*\/[sq]\b/i,
+        /\bdel\s+.*\/[fs]\b/i,
+        // Remote script execution (catches curl/wget piped to any shell or runtime)
+        /\b(?:curl|wget)\b.*?\|\s*(?:sh|bash|zsh|dash|python|node|ruby|perl)\b/i,
+        // Git overwriting (catches hard resets, clean -f, force pushes, hard branch deletes)
+        /\bgit\s+(?:reset|clean)\s+.*(?:--hard|-f|--force)\b/i,
+        /\bgit\s+push\s+.*(?:-f|--force)\b/i,
+        /\bgit\s+branch\s+.*-D\b/i,
+        // DB & Cluster Drops (catches truncates, deletes, drop db/table, docker volume/system prunes, kubectl wipes)
+        /\b(?:drop|truncate|delete)\s+(?:database|table|schema)\b/i,
+        /\bdocker\s+system\s+prune\b/i,
+        /\bdocker\s+volume\s+(?:rm|prune)\b/i,
+        /\bkubectl\s+delete\s+(?:namespace|all|--all)\b/i,
+        // Disk & System destruction (format, fdisk, dd, overwriting block devices, shutdown, fork bombs)
+        /\b(?:mkfs|fdisk|parted|mkswap)\b/i,
+        /\bformat\s+[A-Z]:/i,
+        /\bdd\s+.*(?:if=|of=)\b/i,
+        />\s*\/dev\/(?:sda|disk|hda|nvme)\b/i,
+        /\b(?:shutdown|reboot|halt|poweroff)\b/i,
+        /:\(\)\{\s*:\|:&\s*\};:/, // Fork bomb
+        // User data/config erasure
+        /\bcrontab\s+-r\b/i,
+        /\bhistory\s+-c\b/i,
+        // Massive permission shifts (chmod 777, recursive chowns)
+        /\bchmod\s+(?:-[R\w]*\s+)?777\b/i,
+        /\bchown\s+-[R\w]*\b/i,
+    ];
+    return destructivePatterns.some((pattern) => pattern.test(command));
+}
+export function isCommandSafe(command) {
+    // Do not auto-approve chained, redirected, or sudo commands
+    if (/[;&|>]/.test(command) || /\bsudo\b/.test(command)) {
+        return false;
+    }
+    const safePatterns = [
+        /^\s*ls\b/i,
+        /^\s*pwd\b/i,
+        /^\s*whoami\b/i,
+        /^\s*cat\b/i,
+        /^\s*echo\b/i,
+        /^\s*grep\b/i,
+        /^\s*find\b/i,
+        /^\s*npm\s+(install|i|ci|run\b)/i,
+        /^\s*yarn\s+(install|add|build|lint|test|run\b)/i,
+        /^\s*pnpm\s+(install|i|add|build|lint|test|run\b)/i,
+        /^\s*bun\s+(install|i|add|run\b)/i,
+        /^\s*cargo\s+(build|check|add|test|run\b)/i,
+        /^\s*go\s+(mod|get|build|test|run\b)/i,
+        /^\s*pip\s+(install|list|show)\b/i,
+        /^\s*uv\s+(add|pip|sync|run\b)/i,
+        /^\s*rustc\b/i,
+        /^\s*git\s+(status|log|diff|show|branch)\b/i,
+        /^\s*(node|python|ruby|java|go|rustc)\s+(--version|-v)\b/i,
+        /^\s*tsc\b/i,
+        /^\s*eslint\b/i,
+        /^\s*prettier\b/i,
+    ];
+    return safePatterns.some((pattern) => pattern.test(command));
+}
+/**
+ * Executes an interactive approval prompt via `@clack/prompts`.
+ *
+ * Supports pattern-based approvals and three user approval models:
+ * 1. **Ask**: Prompts the user for every shell execution command (except implicitly safe ones).
+ * 2. **Skip-Once**: Automatically grants permission to the current command, then resets.
+ * 3. **Skip-All / Auto-Approve**: Grants permission to all future terminal commands.
+ *
+ * Destructive commands will ALWAYS prompt the user, regardless of mode.
+ *
+ * @param command - The terminal string requested for execution.
+ * @returns A promise resolving to `true` if approved, or `false` if denied/cancelled.
+ */
+export async function requestCommandApproval(command) {
+    const mode = getApprovalMode();
+    const isDestructive = isCommandDestructive(command);
+    const isSafe = isCommandSafe(command);
+    // Force prompt for destructive commands
+    if (isDestructive) {
+        p.log.warn(`${pc.bgRed(pc.white(' WARNING '))} Destructive command detected. Explicit approval required.`);
+    }
+    else {
+        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;
+        }
+        if (isSafe) {
+            p.log.info(`${pc.dim('Auto-approved (safe command):')} ${pc.yellow(command)}`);
+            return true;
+        }
+    }
+    // mode === 'ask' or isDestructive
+    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;
+}

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

@@ -0,0 +1,83 @@
+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;
+}

package/dist/services/agent/inputHandler.js

@@ -0,0 +1,208 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+/**
+ * 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 class AsyncInputHandler {
+    /** Queue of pending user feedback/instructions typed during active background execution */
+    queue = [];
+    /** Guard flag preventing multiple simultaneous input prompt overlays */
+    isPrompting = false;
+    /** Reference to the Clack CLI spinner which must be paused/restarted during prompts */
+    spinner = null;
+    /** Stores the terminal's raw mode configuration state before handler activation */
+    originalRawMode = false;
+    /** Indicates whether the input handler is currently inactive/stopped */
+    stopped = true;
+    /** Reference to the AbortController controlling the active AI request to trigger cancellations */
+    ac = null;
+    /**
+     * 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) {
+        this.ac = ac;
+    }
+    /**
+     * 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() {
+        return this.isPrompting;
+    }
+    /**
+     * Blocks and waits until any active prompting action is completed.
+     * Guarantees terminal stdout is clean before resuming logs.
+     */
+    async waitForPrompt() {
+        while (this.isPrompting) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    /**
+     * 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
+     */
+    onData = async (chunk) => {
+        try {
+            if (this.isPrompting)
+                return;
+            const char = chunk.toString();
+            // Handle Ctrl+C (End of Text ASCII 0x03) immediately
+            if (char === '\u0003') {
+                process.exit(0);
+            }
+            // Ignore standard non-printable control keys, escape sequences, etc.
+            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);
+            }
+            // Hide the background spinner before prompt output to avoid corrupting terminal lines
+            if (this.spinner) {
+                this.spinner.stop();
+            }
+            p.log.step(pc.cyan('Paused to receive input'));
+            // Capture the user feedback. The character typed to trigger this event is passed
+            // as the initial value of the prompt to avoid losing the first keystroke.
+            const userInput = await p.text({
+                message: 'Add chained message:',
+                placeholder: '(Leave blank and press Enter to cancel)',
+                initialValue: char,
+            });
+            let wasAborted = false;
+            if (!p.isCancel(userInput) && userInput.trim()) {
+                const text = userInput.trim();
+                if (text.toLowerCase() === 'stop') {
+                    if (this.ac) {
+                        this.ac.abort();
+                        p.log.warn(pc.yellow(`Generation aborted by user.`));
+                        wasAborted = true;
+                    }
+                }
+                else {
+                    this.queue.push(text);
+                    p.log.info(pc.cyan(`📥 Queued message: "${text}"`));
+                }
+            }
+            if (this.spinner && !wasAborted) {
+                const resumeMsg = this.spinner._lastMessage || 'Resuming execution...';
+                this.spinner.start(resumeMsg);
+            }
+        }
+        catch (err) {
+            // Absorb and suppress errors safely during raw stream intercepts
+        }
+        finally {
+            if (!this.stopped) {
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(true);
+                }
+                process.stdin.resume();
+                // Small delay before reattaching listener to avoid capturing duplicate keypress frames
+                setTimeout(() => {
+                    if (!this.stopped) {
+                        process.stdin.on('data', this.onData);
+                    }
+                    this.isPrompting = false;
+                }, 50);
+            }
+            else {
+                this.isPrompting = false;
+            }
+        }
+    };
+    /**
+     * 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) {
+        this.stopped = false;
+        if (spinner) {
+            this.spinner = spinner;
+            // Monkey-patch to track the latest message for un-pausing
+            if (!spinner._isPatched) {
+                ;
+                spinner._isPatched = true;
+                spinner._lastMessage = 'Executing...';
+                const originalMessage = spinner.message.bind(spinner);
+                spinner.message = (msg) => {
+                    if (msg) {
+                        ;
+                        spinner._lastMessage = msg;
+                    }
+                    originalMessage(msg);
+                };
+                const originalStart = spinner.start.bind(spinner);
+                spinner.start = (msg) => {
+                    if (msg) {
+                        ;
+                        spinner._lastMessage = msg;
+                    }
+                    originalStart(msg);
+                };
+            }
+        }
+        if (process.stdin.isTTY) {
+            this.originalRawMode = process.stdin.isRaw;
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.on('data', this.onData);
+    }
+    /**
+     * Disables raw mode, stops intercepting keystrokes, and restores
+     * the terminal stdin stream to its original raw/cooked state.
+     */
+    stop() {
+        this.stopped = true;
+        process.stdin.removeListener('data', this.onData);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(this.originalRawMode);
+        }
+        this.spinner = null;
+    }
+    /**
+     * 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() {
+        if (this.queue.length === 0)
+            return '';
+        const messages = this.queue.join('\n');
+        this.queue = [];
+        return messages;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { SlashCommandContext, SlashCommandResult } from './types.js';
+/**
+ * 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 declare function handleSlashCommand(command: string, context: SlashCommandContext): Promise<SlashCommandResult>;