neuro-cli 4.2.0 → 5.0.0

package/dist/core/engine.js

@@ -1,5 +1,5 @@
 // ============================================================
-// NeuroCLI - NeuroEngine v4.1.3
+// NeuroCLI - NeuroEngine v5.0 (Claude Code-style Agentic Loop)
 // The main engine that ties everything together
 // Now with: Sandbox, Plugin SDK, Enhanced MCP, Enhanced Approval,
 // Model Router, Prompt Cache, Undo/Redo, Output Styles,
@@ -483,7 +483,7 @@ export class NeuroEngine {
         this.gitWorktree = new GitWorktreeManager(process.cwd());
         // Auto-Updater
         this.updater = new AutoUpdater({
-            currentVersion: '4.1.3',
+            currentVersion: '5.0.0',
             autoCheck: true,
             autoUpdate: false,
         });
@@ -523,6 +523,7 @@ Key responsibilities:
 - Manage dependencies between sub-tasks
 - Synthesize results from multiple agents
 - Handle errors and re-plan if needed
+- IMPORTANT: Keep working until the ENTIRE task is COMPLETE
 
 Always consider the strengths of each agent when delegating:
 - Planner: For task decomposition and architecture decisions
@@ -537,7 +538,7 @@ Always consider the strengths of each agent when delegating:
             temperature: 0.7,
             maxTokens: 4096,
             tools: [],
-            maxIterations: 20,
+            maxIterations: 0, // 0 = no limit, run until done
         };
         this.orchestrator = new Orchestrator(orchestratorConfig, this.client, this.registry, process.cwd(), this.sessionManager.getCurrent()?.id || 'default');
         // Register all agents with orchestrator
@@ -634,7 +635,9 @@ Always consider the strengths of each agent when delegating:
         }
     }
     /**
-     * Process a user message
+     * Process a user message — Claude Code style
+     * Every task is sent to the best agent which runs until completion.
+     * No arbitrary early termination — the agent keeps working until done.
      */
     async processMessage(message, mode = 'auto', targetAgent) {
         // Check spending limit via spending monitor
@@ -687,7 +690,7 @@ Always consider the strengths of each agent when delegating:
         const skillAdditions = this.skillSystem.getSystemPromptAdditions();
         const styleAddition = this.styleManager.getSystemPromptAddition();
         const thinkingAddition = this.extendedThinking.getSystemPromptAddition();
-        // Build UI callbacks
+        // Build UI callbacks — Claude Code style
         const callbacks = {
             onThinking: (thinking) => this.ui.thinking(thinking),
             onToken: (token) => this.ui.streamingToken(token),
@@ -702,28 +705,32 @@ Always consider the strengths of each agent when delegating:
                     return;
                 }
                 this.ui.toolCall(name, args);
-                // Record in undo/redo for file modification tools
-                if (['write_file', 'edit_file', 'apply_diff', 'delete_file'].includes(name)) {
-                    // The undo/redo push will happen in the tool execution result handler
-                }
             },
             onToolResult: (name, result, isError) => this.ui.toolResult(name, result, isError),
             onApprovalNeeded: async (name, args, risk) => {
                 return this.handleApproval(name, args, risk);
             },
-            onIteration: (i, max) => {
-                this.ui.info(`Iteration ${i}/${max}`);
+            onIteration: (i, _max) => {
+                // Claude Code style: show iteration count without a ceiling
+                this.ui.agentActivity(this.config.defaultModel, 'working', `step ${i}`);
+            },
+            onCycleStart: (cycle, summary) => {
+                this.ui.agentActivity(this.config.defaultModel, 'working', `cycle ${cycle}: ${summary}`);
+            },
+            onTaskComplete: (reason) => {
+                this.ui.agentActivity(this.config.defaultModel, 'done', reason);
             },
         };
         let result;
         const activeModel = routeDecision?.model || this.config.defaultModel;
+        // === Claude Code-style routing: always send to the best agent and let it run until done ===
         if (mode === 'direct' && targetAgent) {
+            // Direct mode: use specified agent
             const agent = this.agents.get(targetAgent);
             if (!agent) {
                 this.ui.error(`Agent not found: ${targetAgent}`);
                 return { content: '', usage: { inputTokens: 0, outputTokens: 0, cost: 0 } };
             }
-            // Override agent model if defaultModel differs from agent's model
             const originalModel = agent.configModel;
             if (this.config.defaultModel !== originalModel) {
                 agent.configModel = this.config.defaultModel;
@@ -735,10 +742,10 @@ Always consider the strengths of each agent when delegating:
             finally {
                 this.ui.endStreaming();
             }
-            // Restore original model
             agent.configModel = originalModel;
         }
         else if (mode === 'agent') {
+            // Orchestration mode: multi-agent with re-planning
             const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
             result = {
                 content: orchestrateResult.content,
@@ -749,58 +756,52 @@ Always consider the strengths of each agent when delegating:
             };
         }
         else {
-            const complexity = routeDecision?.complexity || this.assessComplexity(message);
+            // Auto mode — Claude Code style: route to best agent, let it run until done
             const category = routeDecision?.category || this.modelRouter.getCategory(message);
-            if (complexity === 'simple') {
-                // 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)`);
+            const targetAgentName = this.selectAgentForCategory(category);
+            const agent = this.agents.get(targetAgentName);
+            if (agent) {
+                // Override agent model with routed model if different
+                const originalModel = agent.configModel;
+                if (activeModel !== originalModel) {
+                    agent.configModel = activeModel;
+                }
+                this.ui.info(`Using ${targetAgentName} agent (${category} task) — will run until complete`);
+                this.ui.startStreaming();
+                try {
+                    result = await agent.run(message, callbacks);
+                }
+                finally {
+                    this.ui.endStreaming();
+                }
+                // Restore original model
+                agent.configModel = originalModel;
+            }
+            else {
+                // Fallback: try Coder, then orchestrator
+                const coderAgent = this.agents.get('Coder');
+                if (coderAgent) {
+                    this.ui.info(`Using Coder agent — will run until complete`);
                     this.ui.startStreaming();
                     try {
-                        result = await agent.run(message, callbacks);
+                        result = await coderAgent.run(message, callbacks);
                     }
                     finally {
                         this.ui.endStreaming();
                     }
                 }
                 else {
-                    // 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,
-                        };
-                    }
+                    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 {
-                this.ui.thinking('Analyzing task complexity... Using multi-agent orchestration');
-                const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
-                result = {
-                    content: orchestrateResult.content,
-                    toolCallsMade: 0,
-                    iterations: orchestrateResult.execution.iterations,
-                    usage: orchestrateResult.totalUsage,
-                    execution: orchestrateResult.execution,
-                };
-            }
         }
         // Parse extended thinking blocks from response
         const thinkingResult = this.extendedThinking.parseResponse(result.content);
@@ -914,8 +915,9 @@ Always consider the strengths of each agent when delegating:
         return result.approved;
     }
     /**
-     * Assess task complexity to decide execution mode
-     * Now delegates to ModelRouter for more sophisticated analysis
+     * Assess task complexity — delegates to ModelRouter
+     * Note: complexity no longer determines execution mode (all tasks run until complete)
+     * but is still used for model selection
      */
     assessComplexity(message) {
         const decision = this.modelRouter.route(message);

package/dist/core/model-router.js

@@ -72,7 +72,7 @@ const COMPLEXITY_SIGNALS = {
             /\b(hello|hi|thanks|yes|no|ok|sure|done|correct|right|please)\b/i,
         ],
         lengthThreshold: 80,
-        maxSteps: 5,
+        maxSteps: 0, // 0 = no limit (Claude Code style)
     },
     moderate: {
         patterns: [
@@ -83,7 +83,7 @@ const COMPLEXITY_SIGNALS = {
             /\b(refactor|clean|simplify|optimize|restructure)\b/i,
         ],
         lengthThreshold: 300,
-        maxSteps: 15,
+        maxSteps: 0, // 0 = no limit (Claude Code style)
     },
     complex: {
         patterns: [
@@ -97,7 +97,7 @@ const COMPLEXITY_SIGNALS = {
             /\b(security\s+(audit|review|hardening)|performance\s+(optim|tuning|profiling)|scalab(ility|le))\b/i,
         ],
         lengthThreshold: 500,
-        maxSteps: 30,
+        maxSteps: 0, // 0 = no limit (Claude Code style)
     },
 };
 // ---------------------------------------------------------------------------

package/dist/core/types.d.ts

@@ -78,7 +78,7 @@ export interface NeuroConfig {
         maxHistory: number;
     };
     ui: {
-        theme: 'dark' | 'light' | 'dracula' | 'nord';
+        theme: 'claude' | 'dark' | 'light' | 'dracula' | 'nord';
         showTokenCount: boolean;
         showCost: boolean;
         streaming: boolean;

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // ============================================================
 // NeuroCLI - Advanced AI Terminal Coding Assistant
-// Main Entry Point - v4.1.3 with robust error handling
+// Main Entry Point - v5.0 (Claude Code-style Agentic Loop)
 // ============================================================
 import { Command } from 'commander';
 import { createInterface } from 'readline';
@@ -16,7 +16,7 @@ import { HeadlessMode } from './core/headless.js';
 import { ShellCompletionGenerator } from './core/shell-completion.js';
 import chalk from 'chalk';
 import { AutoUpdater } from './core/updater.js';
-const VERSION = '4.2.0';
+const VERSION = '5.0.0';
 // ---- Global Error Handlers (prevent crashes) ----
 process.on('unhandledRejection', (reason) => {
     console.error(chalk.red('\n⚠️ Unhandled promise rejection:'), reason);
@@ -420,6 +420,7 @@ async function startInteractive(options) {
     const updater = new AutoUpdater({ currentVersion: VERSION });
     const updateCheck = updater.checkOnStartup(); // Fire and forget — don't block startup
     // Print banner
+    engine.ui.setVersion(VERSION);
     engine.ui.banner();
     const theme = engine.ui.theme;
     const permMode = engine.approval.getMode();
@@ -444,7 +445,7 @@ async function startInteractive(options) {
     const rl = createInterface({
         input: process.stdin,
         output: process.stdout,
-        prompt: chalk.cyan('❯ '),
+        prompt: chalk.hex('#d97706')('> '),
         historySize: 100,
         completer: completionEngine.complete,
     });
@@ -532,7 +533,7 @@ async function startInteractive(options) {
                             engine.ui.success(`Theme: ${args[0]}`);
                         }
                         else {
-                            console.log('Available themes: dracula, dark, nord, light');
+                            console.log('Available themes: claude, dracula, dark, nord, light');
                         }
                         break;
                     case 'resume':