neuro-cli 4.1.3 → 4.3.0

package/dist/agents/base.js

@@ -192,7 +192,7 @@ export class BaseAgent {
         }
         if (iteration > maxIter && execution.status === 'running') {
             execution.status = 'completed';
-            execution.result = 'Max iterations reached';
+            execution.result = `Max iterations reached (${maxIter}). The task may not be fully completed. Consider using a higher effort level or switching to /orchestrate mode for complex tasks.`;
         }
         execution.endTime = Date.now();
         execution.iterations = iteration;

package/dist/config/config.js

@@ -19,7 +19,7 @@ export const DEFAULT_CONFIG = {
             temperature: 0.7,
             maxTokens: 4096,
             tools: ['read_file', 'search_files', 'list_directory'],
-            maxIterations: 3,
+            maxIterations: 10,
         },
         coder: {
             name: 'Coder',
@@ -29,7 +29,7 @@ export const DEFAULT_CONFIG = {
             temperature: 0.4,
             maxTokens: 16384,
             tools: ['read_file', 'write_file', 'edit_file', 'search_files', 'list_directory', 'run_command', 'apply_diff'],
-            maxIterations: 15,
+            maxIterations: 50,
         },
         reviewer: {
             name: 'Reviewer',
@@ -39,7 +39,7 @@ export const DEFAULT_CONFIG = {
             temperature: 0.3,
             maxTokens: 8192,
             tools: ['read_file', 'search_files', 'list_directory'],
-            maxIterations: 5,
+            maxIterations: 15,
         },
         researcher: {
             name: 'Researcher',
@@ -49,7 +49,7 @@ export const DEFAULT_CONFIG = {
             temperature: 0.5,
             maxTokens: 8192,
             tools: ['read_file', 'search_files', 'list_directory', 'web_search', 'web_fetch'],
-            maxIterations: 8,
+            maxIterations: 20,
         },
         tester: {
             name: 'Tester',
@@ -59,7 +59,7 @@ export const DEFAULT_CONFIG = {
             temperature: 0.3,
             maxTokens: 8192,
             tools: ['read_file', 'write_file', 'search_files', 'run_command', 'list_directory'],
-            maxIterations: 10,
+            maxIterations: 25,
         },
         debugger: {
             name: 'Debugger',
@@ -69,7 +69,7 @@ export const DEFAULT_CONFIG = {
             temperature: 0.2,
             maxTokens: 8192,
             tools: ['read_file', 'edit_file', 'search_files', 'run_command', 'list_directory', 'apply_diff'],
-            maxIterations: 12,
+            maxIterations: 20,
         },
         architect: {
             name: 'Architect',
@@ -79,7 +79,7 @@ export const DEFAULT_CONFIG = {
             temperature: 0.7,
             maxTokens: 8192,
             tools: ['read_file', 'search_files', 'list_directory'],
-            maxIterations: 5,
+            maxIterations: 15,
         },
         devops: {
             name: 'DevOps',
@@ -89,7 +89,7 @@ export const DEFAULT_CONFIG = {
             temperature: 0.3,
             maxTokens: 8192,
             tools: ['read_file', 'write_file', 'edit_file', 'run_command', 'search_files', 'list_directory'],
-            maxIterations: 10,
+            maxIterations: 25,
         },
     },
     tools: {
@@ -106,7 +106,7 @@ export const DEFAULT_CONFIG = {
         maxHistory: 100,
     },
     ui: {
-        theme: 'dracula',
+        theme: 'claude',
         showTokenCount: true,
         showCost: true,
         streaming: true,

package/dist/core/approval.d.ts

@@ -64,6 +64,10 @@ export declare class ApprovalSystem {
     requestBatchApproval(toolName: string, args: Record<string, unknown>, risk: 'low' | 'medium' | 'high', description?: string): Promise<ApprovalResult>;
     private processBatch;
     private isBlacklisted;
+    /**
+     * Format tool arguments as a compact one-liner for Claude Code-style display
+     */
+    private formatCompactArgs;
     private isWhitelisted;
     private getPattern;
     private getAlwaysKey;

package/dist/core/approval.js

@@ -171,27 +171,20 @@ export class ApprovalSystem {
     // --- Interactive Prompt ---
     async promptUser(toolName, args, risk, description) {
         const riskColors = { low: chalk.green, medium: chalk.yellow, high: chalk.red };
-        const riskIcons = { low: '🟢', medium: '🟡', high: '🔴' };
+        const riskLabels = { low: 'low', medium: 'med', high: 'high' };
+        // Claude Code style: compact, minimal approval prompt
         console.log();
-        console.log(`  ${riskIcons[risk]} ${riskColors[risk].bold(`Approval needed [${risk} risk]`)}`);
-        console.log(`  ${chalk.cyan('Tool:')} ${chalk.white.bold(toolName)}`);
-        if (description) {
-            console.log(`  ${chalk.cyan('Description:')} ${chalk.gray(description)}`);
+        console.log(`  ${chalk.dim('┌─')} ${chalk.bold(toolName)} ${riskColors[risk](`[${riskLabels[risk]}]`)}`);
+        // Show key argument on one line
+        const keyArg = this.formatCompactArgs(toolName, args);
+        if (keyArg) {
+            console.log(`  ${chalk.dim('│')} ${chalk.gray(keyArg)}`);
         }
-        const argEntries = Object.entries(args);
-        if (argEntries.length > 0) {
-            console.log(`  ${chalk.cyan('Arguments:')}`);
-            for (const [key, value] of argEntries.slice(0, 5)) {
-                const val = typeof value === 'string' && value.length > 80 ? value.slice(0, 80) + '...' : String(value);
-                console.log(`    ${chalk.gray(key)}: ${chalk.white(val)}`);
-            }
-            if (argEntries.length > 5) {
-                console.log(`    ${chalk.gray(`...and ${argEntries.length - 5} more`)}`);
-            }
+        if (description) {
+            console.log(`  ${chalk.dim('│')} ${chalk.gray(description.slice(0, 100))}`);
         }
-        console.log();
-        console.log(`  ${chalk.gray('y')} = Yes  ${chalk.gray('n')} = No  ${chalk.gray('a')} = Yes always (session)  ${chalk.gray('A')} = Yes always (persist)  ${chalk.gray('e')} = Edit args  ${chalk.gray('d')} = Show diff`);
-        const answer = await this.readline(`${riskIcons[risk]} Allow ${toolName}? [y/n/a/A/e/d]: `);
+        console.log(`  ${chalk.dim('└─')} ${chalk.gray('y')}yes ${chalk.gray('n')}no ${chalk.gray('a')}session ${chalk.gray('A')}always ${chalk.gray('e')}edit ${chalk.gray('d')}diff`);
+        const answer = await this.readline(`  ${riskColors[risk]('?')} Allow? `);
         const startTime = Date.now();
         switch (answer.toLowerCase().trim()) {
             case 'y':
@@ -277,19 +270,18 @@ export class ApprovalSystem {
             groups.get(item.toolName).push(item);
         }
         console.log();
-        console.log(chalk.bold.cyan(`  ━━━ Batch Approval (${batch.length} operations) ━━━`));
+        console.log(`  ${chalk.dim('┌─')} ${chalk.bold(`Batch (${batch.length} ops)`)}`);
         for (const [toolName, items] of groups) {
-            console.log(`  ${chalk.cyan(toolName)}: ${chalk.white(`${items.length} operations`)}`);
-            for (const item of items.slice(0, 3)) {
+            console.log(`  ${chalk.dim('│')} ${chalk.bold(toolName)} ${chalk.gray(`${items.length} ops`)}`);
+            for (const item of items.slice(0, 2)) {
                 const preview = item.args.path || item.args.command || item.description || '';
-                console.log(`    - ${chalk.gray(String(preview).slice(0, 60))}`);
+                console.log(`  ${chalk.dim('│')}   ${chalk.gray(String(preview).slice(0, 60))}`);
             }
-            if (items.length > 3)
-                console.log(`    ${chalk.gray(`...and ${items.length - 3} more`)}`);
+            if (items.length > 2)
+                console.log(`  ${chalk.dim('│')}   ${chalk.gray(`+${items.length - 2} more`)}`);
         }
-        console.log();
-        console.log(`  ${chalk.gray('y')} = Approve all  ${chalk.gray('n')} = Deny all  ${chalk.gray('r')} = Review each`);
-        const answer = await this.readline('  Batch approve? [y/n/r]: ');
+        console.log(`  ${chalk.dim('└─')} ${chalk.gray('y')}all ${chalk.gray('n')}none ${chalk.gray('r')}review`);
+        const answer = await this.readline(`  ${chalk.yellow('?')} Batch? `);
         switch (answer.toLowerCase().trim()) {
             case 'y':
             case 'yes':
@@ -314,6 +306,33 @@ export class ApprovalSystem {
     }
     // --- Helpers ---
     isBlacklisted(toolName) { return this.blacklist.has(toolName); }
+    /**
+     * Format tool arguments as a compact one-liner for Claude Code-style display
+     */
+    formatCompactArgs(toolName, args) {
+        switch (toolName) {
+            case 'read_file':
+            case 'edit_file':
+            case 'write_file':
+            case 'delete_file':
+            case 'apply_diff':
+                return String(args.path || '');
+            case 'run_command':
+                return String(args.command || '').slice(0, 80);
+            case 'search_files':
+                return `"${args.query || ''}" in ${args.path || '.'}`;
+            case 'list_directory':
+                return String(args.path || args.directory || '.');
+            case 'web_search':
+                return `"${args.query || ''}"`;
+            case 'web_fetch':
+                return String(args.url || '').slice(0, 60);
+            default: {
+                const entries = Object.entries(args).slice(0, 2);
+                return entries.map(([k, v]) => `${k}=${typeof v === 'string' ? v.slice(0, 40) : JSON.stringify(v)}`).join(' ');
+            }
+        }
+    }
     isWhitelisted(toolName) {
         if (this.whitelist.has(toolName))
             return true;
@@ -344,27 +363,36 @@ export class ApprovalSystem {
     readline(prompt) {
         // Pause the main readline to prevent it from also reading stdin input
         // This is the root cause of double character input (YY instead of Y)
-        const mainInputStream = this.mainRl?.input;
-        const wasMainPaused = mainInputStream?.isPaused?.();
-        if (this.mainRl && mainInputStream && mainInputStream.isPaused()) {
-            // Already paused, skip
-        }
-        else if (this.mainRl) {
-            this.mainRl.pause();
+        if (this.mainRl) {
+            const mainInputStream = this.mainRl?.input;
+            if (mainInputStream && !mainInputStream.isPaused()) {
+                this.mainRl.pause();
+            }
         }
         return new Promise((resolve) => {
-            // Reuse the main readline if available, otherwise create a temporary one
-            const rl = this.mainRl || this.rl || createInterface({ input: process.stdin, output: process.stdout });
-            if (!this.rl && !this.mainRl)
-                this.rl = rl;
-            rl.question(prompt, (answer) => {
-                // Resume the main readline after getting the answer
-                if (this.mainRl) {
-                    this.mainRl.resume();
-                    this.mainRl.prompt();
-                }
-                resolve(answer);
-            });
+            // Use the main readline's question method directly - it handles pause/resume internally
+            if (this.mainRl) {
+                this.mainRl.question(prompt, (answer) => {
+                    // Resume the main readline after getting the answer
+                    if (this.mainRl) {
+                        this.mainRl.resume();
+                        this.mainRl.prompt();
+                    }
+                    resolve(answer);
+                });
+            }
+            else if (this.rl) {
+                this.rl.question(prompt, (answer) => {
+                    resolve(answer);
+                });
+            }
+            else {
+                const tempRl = createInterface({ input: process.stdin, output: process.stdout });
+                this.rl = tempRl;
+                tempRl.question(prompt, (answer) => {
+                    resolve(answer);
+                });
+            }
         });
     }
     close() {

package/dist/core/diff-preview.js

@@ -65,10 +65,9 @@ export class DiffPreview {
      */
     static renderDiff(diff, contextLines = 3) {
         const { filePath, added, removed, lines } = diff;
+        // Claude Code style: clean diff header with +/-
         console.log();
-        console.log(`  ${chalk.bold.cyan('━━━ Diff Preview ━━━')}`);
-        console.log(`  ${chalk.white(filePath)} ${chalk.green(`+${added}`)} ${chalk.red(`-${removed}`)}`);
-        console.log(`  ${chalk.gray('─'.repeat(50))}`);
+        console.log(`  ${chalk.dim('───')} ${chalk.bold(filePath)} ${chalk.green(`+${added}`)} ${chalk.red(`-${removed}`)}`);
         let inChange = false;
         let contextCount = 0;
         for (const line of lines) {
@@ -86,43 +85,36 @@ export class DiffPreview {
                 case 'context':
                     contextCount++;
                     if (inChange) {
-                        // Show a few context lines after a change
                         if (contextCount <= contextLines) {
-                            console.log(`  ${chalk.gray(' ')} ${chalk.gray(line.content)}`);
+                            console.log(`  ${chalk.dim(' ')} ${chalk.dim(line.content)}`);
                         }
                         else {
                             inChange = false;
-                            console.log(`  ${chalk.gray('  ...')}`);
+                            console.log(`  ${chalk.dim('  ...')}`);
                         }
                     }
                     else if (contextCount <= 1) {
-                        // Show one context line before a change
-                        console.log(`  ${chalk.gray(' ')} ${chalk.gray(line.content)}`);
+                        console.log(`  ${chalk.dim(' ')} ${chalk.dim(line.content)}`);
                     }
                     break;
             }
         }
-        console.log(`  ${chalk.gray('─'.repeat(50))}`);
-        console.log(`  ${chalk.green(`+${added} additions`)}  ${chalk.red(`-${removed} deletions`)}`);
-        console.log();
+        console.log(`  ${chalk.dim(`${chalk.green(`+${added}`)} ${chalk.red(`-${removed}`)}`)}`);
     }
     /**
      * Render a compact summary of multiple diffs
      */
     static renderSummary(diffs) {
         console.log();
-        console.log(`  ${chalk.bold.cyan('━━━ Changes Summary ━━━')}`);
         for (const diff of diffs) {
             const statusLabel = diff.added > 0 && diff.removed === 0 ? chalk.green('created') :
                 diff.added === 0 && diff.removed > 0 ? chalk.red('deleted') :
                     chalk.yellow('modified');
-            console.log(`  ${statusLabel} ${diff.filePath.padEnd(40)} ${chalk.green(`+${diff.added}`)} ${chalk.red(`-${diff.removed}`)}`);
+            console.log(`  ${statusLabel} ${diff.filePath} ${chalk.green(`+${diff.added}`)} ${chalk.red(`-${diff.removed}`)}`);
         }
         const totalAdded = diffs.reduce((s, d) => s + d.added, 0);
         const totalRemoved = diffs.reduce((s, d) => s + d.removed, 0);
-        console.log(`  ${chalk.gray('─'.repeat(50))}`);
-        console.log(`  ${chalk.bold('Total:')} ${chalk.green(`+${totalAdded}`)} ${chalk.red(`-${totalRemoved}`)}`);
-        console.log();
+        console.log(`  ${chalk.dim(`${chalk.green(`+${totalAdded}`)} ${chalk.red(`-${totalRemoved}`)}`)}`);
     }
     /**
      * Ask user to confirm diff changes

package/dist/core/engine.d.ts

@@ -157,6 +157,10 @@ export declare class NeuroEngine {
      * Now delegates to ModelRouter for more sophisticated analysis
      */
     private assessComplexity;
+    /**
+     * Select the best agent for a given task category
+     */
+    private selectAgentForCategory;
     /**
      * Switch the active model
      */

package/dist/core/engine.js

@@ -537,7 +537,7 @@ Always consider the strengths of each agent when delegating:
             temperature: 0.7,
             maxTokens: 4096,
             tools: [],
-            maxIterations: 5,
+            maxIterations: 20,
         };
         this.orchestrator = new Orchestrator(orchestratorConfig, this.client, this.registry, process.cwd(), this.sessionManager.getCurrent()?.id || 'default');
         // Register all agents with orchestrator
@@ -622,7 +622,7 @@ Always consider the strengths of each agent when delegating:
         const cwd = process.cwd();
         // Built-in agents
         for (const [key, agentConfig] of Object.entries(this.config.agents)) {
-            const overrideConfig = { ...agentConfig, model: this.config.defaultModel };
+            const overrideConfig = { ...agentConfig };
             const agent = new BaseAgent(overrideConfig, this.client, this.registry, cwd, sessionId);
             this.agents.set(agentConfig.name, agent);
         }
@@ -750,9 +750,13 @@ Always consider the strengths of each agent when delegating:
         }
         else {
             const complexity = routeDecision?.complexity || this.assessComplexity(message);
+            const category = routeDecision?.category || this.modelRouter.getCategory(message);
             if (complexity === 'simple') {
-                const agent = this.agents.get('Coder');
+                // Route to the best agent based on task category
+                const targetAgentName = this.selectAgentForCategory(category);
+                const agent = this.agents.get(targetAgentName);
                 if (agent) {
+                    this.ui.info(`Using ${targetAgentName} agent (${category} task)`);
                     this.ui.startStreaming();
                     try {
                         result = await agent.run(message, callbacks);
@@ -762,16 +766,28 @@ Always consider the strengths of each agent when delegating:
                     }
                 }
                 else {
-                    // Fallback to orchestration instead of crashing
-                    this.ui.warning('Coder agent not initialized, using orchestration mode');
-                    const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
-                    result = {
-                        content: orchestrateResult.content,
-                        toolCallsMade: 0,
-                        iterations: orchestrateResult.execution.iterations,
-                        usage: orchestrateResult.totalUsage,
-                        execution: orchestrateResult.execution,
-                    };
+                    // Fallback to Coder
+                    const coderAgent = this.agents.get('Coder');
+                    if (coderAgent) {
+                        this.ui.startStreaming();
+                        try {
+                            result = await coderAgent.run(message, callbacks);
+                        }
+                        finally {
+                            this.ui.endStreaming();
+                        }
+                    }
+                    else {
+                        this.ui.warning('No agents initialized, using orchestration mode');
+                        const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
+                        result = {
+                            content: orchestrateResult.content,
+                            toolCallsMade: 0,
+                            iterations: orchestrateResult.execution.iterations,
+                            usage: orchestrateResult.totalUsage,
+                            execution: orchestrateResult.execution,
+                        };
+                    }
                 }
             }
             else {
@@ -905,6 +921,22 @@ Always consider the strengths of each agent when delegating:
         const decision = this.modelRouter.route(message);
         return decision.complexity;
     }
+    /**
+     * Select the best agent for a given task category
+     */
+    selectAgentForCategory(category) {
+        const categoryAgentMap = {
+            code: 'Coder',
+            reasoning: 'Architect',
+            creative: 'Coder',
+            analysis: 'Researcher',
+            conversation: 'Coder',
+            debugging: 'Debugger',
+            review: 'Reviewer',
+            refactoring: 'Coder',
+        };
+        return categoryAgentMap[category] || 'Coder';
+    }
     /**
      * Switch the active model
      */