minovative-mind-cli 1.0.5 → 1.1.0

package/dist/commands/chat.js

@@ -24,7 +24,7 @@ export default class DefaultCommand extends Command {
             idToken = await getAuthorizedIdToken();
         }
         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.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.`);
         await startAgentLoop(workspaceRoot, this.config.version);
     }
 }

package/dist/services/agent-tools.d.ts

@@ -24,13 +24,13 @@ export declare function modifyFile(workspaceRoot: string, filePath: string, edit
     replaceContent: string;
 }>): Promise<ToolResult>;
 export declare function listDirectory(workspaceRoot: string, dirPath: string, maxDepth?: number): Promise<ToolResult>;
-export declare function runCommand(workspaceRoot: string, command: string): Promise<ToolResult>;
+export declare function runCommand(workspaceRoot: string, command: string, abortSignal?: AbortSignal): Promise<ToolResult>;
 export declare function grepSearch(workspaceRoot: string, pattern: string, fileGlob?: string): Promise<ToolResult>;
 export declare function traceDependencies(workspaceRoot: string, filePath: string, direction?: string, maxDepth?: number): Promise<ToolResult>;
 export declare function findRecentChanges(workspaceRoot: string, dirPath?: string, minutes?: number, maxDepth?: number): Promise<ToolResult>;
-export declare function runDebugScript(workspaceRoot: string, language: string, code: string): Promise<ToolResult>;
+export declare function runDebugScript(workspaceRoot: string, language: string, code: string, abortSignal?: AbortSignal): Promise<ToolResult>;
 /**
  * Dispatches a function call from the model to the appropriate local tool.
  * Returns the tool result as a string to feed back to the model.
  */
-export declare function executeTool(workspaceRoot: string, toolName: string, args: Record<string, unknown>): Promise<ToolResult>;
+export declare function executeTool(workspaceRoot: string, toolName: string, args: Record<string, unknown>, abortSignal?: AbortSignal): Promise<ToolResult>;

package/dist/services/agent-tools.js

@@ -312,6 +312,15 @@ export async function readFile(workspaceRoot, filePath, startLine, endLine, targ
             }
             content = lines.slice(start - 1, end).join('\n');
         }
+        else {
+            const lines = content.split('\n');
+            if (lines.length > 1500) {
+                return {
+                    output: '',
+                    error: `File is too large (${lines.length} lines). You MUST use startLine/endLine or targetElements to read specific chunks instead of dumping the whole file.`,
+                };
+            }
+        }
         const attrLines = startLine || endLine ? ` lines="${startLine || 1}-${endLine || 'end'}"` : '';
         const attrTargets = targetElements && targetElements.length > 0 ? ` elements="${targetElements.join(',')}"` : '';
         const wrappedContent = `<workspace_file path="${filePath}"${attrLines}${attrTargets}>\n<content_data><![CDATA[\n${sanitizeForCDATA(content)}\n]]></content_data>\n</workspace_file>`;
@@ -506,12 +515,13 @@ export async function listDirectory(workspaceRoot, dirPath, maxDepth = 3) {
         };
     }
 }
-export async function runCommand(workspaceRoot, command) {
+export async function runCommand(workspaceRoot, command, abortSignal) {
     try {
         const { stdout, stderr } = await execAsync(command, {
             cwd: workspaceRoot,
             timeout: 60_000, // 60 second timeout
             maxBuffer: 1024 * 1024 * 2, // 2 MB buffer
+            signal: abortSignal,
         });
         let output = [stdout, stderr].filter(Boolean).join('\n');
         // Truncate command output to prevent memory blowout from massive build logs
@@ -655,7 +665,7 @@ export async function findRecentChanges(workspaceRoot, dirPath = '.', minutes =
     }
 }
 // ─── Tool Dispatcher ─────────────────────────────────────────────────
-export async function runDebugScript(workspaceRoot, language, code) {
+export async function runDebugScript(workspaceRoot, language, code, abortSignal) {
     const extMap = {
         node: '.js',
         'ts-node': '.ts',
@@ -693,7 +703,7 @@ export async function runDebugScript(workspaceRoot, language, code) {
                 return { output: '', error: `Unsupported language runtime: ${language}` };
         }
         try {
-            const { stdout, stderr } = await execAsync(cmd, { cwd: workspaceRoot, timeout: 15_000 });
+            const { stdout, stderr } = await execAsync(cmd, { cwd: workspaceRoot, timeout: 15_000, signal: abortSignal });
             const out = stdout.trim();
             const errOut = stderr.trim();
             let finalOutput = '';
@@ -739,7 +749,7 @@ export async function runDebugScript(workspaceRoot, language, code) {
  * Dispatches a function call from the model to the appropriate local tool.
  * Returns the tool result as a string to feed back to the model.
  */
-export async function executeTool(workspaceRoot, toolName, args) {
+export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
     switch (toolName) {
         case 'read_file':
             return readFile(workspaceRoot, args.filePath, args.startLine, args.endLine, args.targetElements);
@@ -754,9 +764,9 @@ export async function executeTool(workspaceRoot, toolName, args) {
         case 'list_directory':
             return listDirectory(workspaceRoot, args.dirPath, args.maxDepth ?? 3);
         case 'run_command':
-            return runCommand(workspaceRoot, args.command);
+            return runCommand(workspaceRoot, args.command, abortSignal);
         case 'run_debug_script':
-            return runDebugScript(workspaceRoot, args.language, args.code);
+            return runDebugScript(workspaceRoot, args.language, args.code, abortSignal);
         case 'grep_search':
             return grepSearch(workspaceRoot, args.pattern, args.fileGlob);
         case 'find_dependencies':

package/dist/services/agent.d.ts

@@ -1,21 +1,145 @@
+/**
+ * @fileoverview Core agent execution service.
+ *
+ * This file coordinates the central execution environment for Minovative Mind,
+ * an AI-powered developer CLI. It orchestrates:
+ *
+ * 1. **Interactive REPL Loop**: Collects multiline user input, supports slash-commands,
+ *    reverting changes, switching models, auto-commit, and clipboard paste injection.
+ * 2. **Context-Aware Investigation**: Gathers repo-wide context and compresses it using
+ *    low-cost, high-speed LLM summarization.
+ * 3. **Autonomous Tool Loop (processResponse)**: Allows the AI model to execute file-system,
+ *    shell-command, and search operations, feeding outcomes back in a recursive, multi-turn loop.
+ * 4. **Asynchronous Interrupt Handling (AsyncInputHandler)**: Intercepts keyboard events
+ *    on standard input to let users pause execution, queue live feedback, or abort generation.
+ * 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" or "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.
+ */
+/**
+ * Starts and orchestrates the primary interactive command-line interface (REPL) loop.
+ *
+ * This is the central control loop of the CLI application. It runs indefinitely until
+ * the user explicitly issues an exit directive (e.g., typing "exit", "quit", `/` command menu selections,
+ * or using keyboard breaks like Ctrl+C).
+ *
+ * ### Architectural Pipeline:
+ * 1. **User Input Collection**:
+ *    - Captures multiline text strings by checking for trailing backslash characters (`\`).
+ *    - Prevents visual terminal glitches during multi-line typing on varying themes.
+ *    - Automatically handles command menu redirection when users enter a forward slash (`/`).
+ *    - 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.
+ *
+ * 3. **Workspace Context Gathering & Intention Routing**:
+ *    - Leverages the Context Agent (`gatherContext`) to perform exploratory scans of the active repository.
+ *    - Identifies user intention to hot-swap system prompt strategies (`CHAT` for conversational assistance vs. `EXECUTE` for multi-turn modifications).
+ *    - Compresses gathered repo structures and file contents using high-speed Flash-Lite engines to respect context boundaries and budget costs.
+ *
+ * 4. **Model Execution & Self-Correction Feedback Loop**:
+ *    - Passes the target request to Gemini alongside compressed workspace injections.
+ *    - Recursively processes tool invocations via `processResponse`.
+ *    - Runs static validation checks (`verifyChangedFiles`) against mutated files to check for compiler/linter bugs.
+ *    - If files fail validation, enters a self-healing loop by submitting raw diagnostic errors directly back to the AI for remediation.
+ *
+ * @param workspaceRoot - The relative or absolute path representing the active workspace environment.
+ * @param version - The Semantic Version string of the active tool distribution.
  */
 export declare function startAgentLoop(workspaceRoot: string, version: string): Promise<void>;