minovative-mind-cli 1.0.3 → 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 createAndRunTest(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

@@ -222,8 +222,8 @@ export const toolDeclarations = [
         },
     },
     {
-        name: 'create_and_run_test',
-        description: 'Write a snippet of code (e.g. a unit test or debug script) to a temporary file, execute it using the specified runtime, and return the exact standard output and standard error logs. Use this to actively test and debug code during execution and verification loops.',
+        name: 'run_debug_script',
+        description: 'Write a debug script (using console.log, print, etc.) to a temporary file, execute it using the specified runtime, and return the exact standard output and standard error. Use this to actively debug the codebase, inspect variables, or solve problems during execution.',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
@@ -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>`;
@@ -437,7 +446,9 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
             }
             changeLogger.logChange(filePath, existing, 'modify');
             await atomicWriteFile(absPath, modified, 'utf-8');
-            return { output: `Successfully applied ${edits.length} edit(s) to "${filePath}".\\nStrategies used:\\n${strategies.join('\\n')}` };
+            return {
+                output: `Successfully applied ${edits.length} edit(s) to "${filePath}".\\nStrategies used:\\n${strategies.join('\\n')}`,
+            };
         }
         catch (err) {
             if (attempt === MAX_MODIFY_RETRIES) {
@@ -504,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
@@ -574,7 +586,7 @@ export async function grepSearch(workspaceRoot, pattern, fileGlob) {
 }
 export async function traceDependencies(workspaceRoot, filePath, direction, maxDepth) {
     try {
-        const dir = (direction === 'forward' || direction === 'reverse') ? direction : 'both';
+        const dir = direction === 'forward' || direction === 'reverse' ? direction : 'both';
         const depth = maxDepth && maxDepth > 0 ? Math.min(maxDepth, 5) : 3;
         const result = await findDependencies(workspaceRoot, filePath, dir, depth);
         const formatted = formatDependencyResult(result);
@@ -590,7 +602,7 @@ export async function findRecentChanges(workspaceRoot, dirPath = '.', minutes =
     try {
         const absPath = resolveAndValidatePath(workspaceRoot, dirPath);
         const { ignoredDirs, ignoredFiles } = await getIgnoredPaths(workspaceRoot);
-        const thresholdMs = Date.now() - (minutes * 60 * 1000);
+        const thresholdMs = Date.now() - minutes * 60 * 1000;
         const recentFiles = [];
         async function walk(currentPath, depth) {
             if (depth > maxDepth)
@@ -636,7 +648,7 @@ export async function findRecentChanges(workspaceRoot, dirPath = '.', minutes =
         // Sort by most recently modified first
         recentFiles.sort((a, b) => b.mtime - a.mtime);
         // Format output
-        const lines = recentFiles.map(f => {
+        const lines = recentFiles.map((f) => {
             const minsAgo = Math.max(0, Math.round((Date.now() - f.mtime) / 60000));
             return `- ${f.path} (${minsAgo} minutes ago)`;
         });
@@ -653,7 +665,7 @@ export async function findRecentChanges(workspaceRoot, dirPath = '.', minutes =
     }
 }
 // ─── Tool Dispatcher ─────────────────────────────────────────────────
-export async function createAndRunTest(workspaceRoot, language, code) {
+export async function runDebugScript(workspaceRoot, language, code, abortSignal) {
     const extMap = {
         node: '.js',
         'ts-node': '.ts',
@@ -691,7 +703,7 @@ export async function createAndRunTest(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 = '';
@@ -715,7 +727,10 @@ export async function createAndRunTest(workspaceRoot, language, code) {
         }
     }
     catch (err) {
-        return { output: '', error: `Failed to create or run test script: ${err instanceof Error ? err.message : String(err)}` };
+        return {
+            output: '',
+            error: `Failed to create or run test script: ${err instanceof Error ? err.message : String(err)}`,
+        };
     }
     finally {
         try {
@@ -734,7 +749,7 @@ export async function createAndRunTest(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);
@@ -749,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);
-        case 'create_and_run_test':
-            return createAndRunTest(workspaceRoot, args.language, args.code);
+            return runCommand(workspaceRoot, args.command, abortSignal);
+        case 'run_debug_script':
+            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>;