neuro-cli 4.1.2 → 4.2.0

package/dist/agents/base.js

@@ -117,7 +117,14 @@ export class BaseAgent {
             const streamCallbacks = {
                 onToken: (token) => callbacks?.onToken?.(token),
                 onThinking: (thinking) => callbacks?.onThinking?.(thinking),
-                onToolCall: (tc) => callbacks?.onToolCall?.(tc.function.name, JSON.parse(tc.function.arguments)),
+                onToolCall: (tc) => {
+                    let args = {};
+                    try {
+                        args = JSON.parse(tc.function.arguments);
+                    }
+                    catch { /* malformed LLM args */ }
+                    callbacks?.onToolCall?.(tc.function.name, args);
+                },
             };
             // Call LLM
             try {
@@ -183,9 +190,9 @@ export class BaseAgent {
                 break;
             }
         }
-        if (iteration > maxIter) {
+        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;
@@ -204,12 +211,17 @@ export class BaseAgent {
      * Quick single-turn query (no tool loop)
      */
     async query(prompt) {
-        const messages = [
-            { role: 'system', content: this.config.systemPrompt, timestamp: Date.now() },
-            { role: 'user', content: prompt, timestamp: Date.now() },
-        ];
-        const response = await this.client.quickChat(this.config.model || 'anthropic/claude-sonnet-4', messages);
-        return response.content;
+        try {
+            const messages = [
+                { role: 'system', content: this.config.systemPrompt, timestamp: Date.now() },
+                { role: 'user', content: prompt, timestamp: Date.now() },
+            ];
+            const response = await this.client.quickChat(this.config.model || 'anthropic/claude-sonnet-4', messages);
+            return response.content;
+        }
+        catch (error) {
+            return `Error: ${error instanceof Error ? error.message : String(error)}`;
+        }
     }
 }
 //# sourceMappingURL=base.js.map

package/dist/agents/orchestrator.js

@@ -59,7 +59,17 @@ Respond with a JSON plan in this exact format:
             { role: 'system', content: 'You are an expert task orchestrator. Always respond with valid JSON.', timestamp: Date.now() },
             { role: 'user', content: planPrompt, timestamp: Date.now() },
         ];
-        const response = await this.client.quickChat(this.config.model || 'anthropic/claude-sonnet-4', messages);
+        let response;
+        try {
+            response = await this.client.quickChat(this.config.model || 'anthropic/claude-sonnet-4', messages);
+        }
+        catch {
+            // API error during planning, fallback to direct approach
+            return {
+                reasoning: 'API error during planning, falling back to direct approach',
+                tasks: [{ agent: 'Coder', task, dependsOn: [] }],
+            };
+        }
         try {
             // Extract JSON from response
             const jsonMatch = response.content.match(/```json\n([\s\S]*?)\n```/) ||
@@ -117,7 +127,11 @@ Respond with a JSON plan in this exact format:
                 return t.dependsOn.every(dep => completedTasks.has(dep));
             });
             if (readyTasks.length === 0) {
-                // Deadlock or all tasks completed
+                // Deadlock detection - log unresolved tasks
+                const unresolved = plan.tasks.filter(t => !completedTasks.has(t.agent + ':' + t.task));
+                if (unresolved.length > 0) {
+                    callbacks?.onThinking?.(`⚠️ Deadlock detected. Unresolved tasks: ${unresolved.map(t => t.agent + ':' + t.task).join(', ')}`);
+                }
                 break;
             }
             // Execute ready tasks (could be parallelized in future)
@@ -146,15 +160,27 @@ Respond with a JSON plan in this exact format:
                         fullTask = `${fullTask}\n\n## Context from previous agents:\n${depResults}`;
                     }
                 }
-                const result = await agent.run(fullTask, {
-                    onToken: (token) => callbacks?.onToken?.(token),
-                    onToolCall: (name, args) => callbacks?.onToolCall?.(name, args),
-                    onToolResult: (name, result, isError) => callbacks?.onToolResult?.(name, result, isError),
-                    onApprovalNeeded: async (name, args, risk) => {
-                        return callbacks?.onApprovalNeeded?.(name, args, risk) ?? true;
-                    },
-                    onThinking: (thinking) => callbacks?.onThinking?.(thinking),
-                });
+                let result;
+                try {
+                    result = await agent.run(fullTask, {
+                        onToken: (token) => callbacks?.onToken?.(token),
+                        onToolCall: (name, args) => callbacks?.onToolCall?.(name, args),
+                        onToolResult: (name, result, isError) => callbacks?.onToolResult?.(name, result, isError),
+                        onApprovalNeeded: async (name, args, risk) => {
+                            return callbacks?.onApprovalNeeded?.(name, args, risk) ?? true;
+                        },
+                        onThinking: (thinking) => callbacks?.onThinking?.(thinking),
+                    });
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    result = {
+                        content: `Agent ${subTask.agent} failed: ${errMsg}`,
+                        toolCallsMade: 0, iterations: 0,
+                        usage: { inputTokens: 0, outputTokens: 0, cost: 0 },
+                        execution: { agentName: subTask.agent, task: subTask.task, startTime: Date.now(), iterations: 0, tokensUsed: 0, status: 'failed' },
+                    };
+                }
                 agentResults.set(subTask.agent + ':' + subTask.task, result);
                 totalUsage.inputTokens += result.usage.inputTokens;
                 totalUsage.outputTokens += result.usage.outputTokens;

package/dist/api/openrouter.js

@@ -173,13 +173,26 @@ export class OpenRouterClient {
                 const { done, value } = await reader.read();
                 if (done)
                     break;
-                const chunk = decoder.decode(value, { stream: true });
-                parser.feed(chunk);
+                try {
+                    const chunk = decoder.decode(value, { stream: true });
+                    parser.feed(chunk);
+                }
+                catch {
+                    // Skip malformed SSE chunks
+                }
             }
         }
         catch (error) {
             callbacks.onError?.(error);
-            throw error;
+            // Return partial result instead of crashing the agent
+            const content = fullContent.join('');
+            const toolCallList = Array.from(toolCalls.values());
+            const cost = calculateCost(modelId, inputTokens, outputTokens);
+            const usage = { inputTokens, outputTokens, cost };
+            this.totalUsage.inputTokens += inputTokens;
+            this.totalUsage.outputTokens += outputTokens;
+            this.totalUsage.cost += cost;
+            return { content, toolCalls: toolCallList, usage };
         }
         const content = fullContent.join('');
         const toolCallList = Array.from(toolCalls.values());
@@ -195,7 +208,13 @@ export class OpenRouterClient {
      * Handle non-streaming response
      */
     async handleNonStreamingResponse(response, modelId) {
-        const data = await response.json();
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch {
+            throw new Error('Invalid JSON response from OpenRouter API');
+        }
         const content = data.choices?.[0]?.message?.content || '';
         const toolCalls = data.choices?.[0]?.message?.tool_calls || [];
         const inputTokens = data.usage?.prompt_tokens || 0;

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: {

package/dist/core/approval.js

@@ -344,27 +344,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/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

@@ -1,5 +1,5 @@
 // ============================================================
-// NeuroCLI - NeuroEngine v4.1.2
+// NeuroCLI - NeuroEngine v4.1.3
 // 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.2',
+            currentVersion: '4.1.3',
             autoCheck: true,
             autoUpdate: false,
         });
@@ -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);
         }
@@ -729,8 +729,12 @@ Always consider the strengths of each agent when delegating:
                 agent.configModel = this.config.defaultModel;
             }
             this.ui.startStreaming();
-            result = await agent.run(message, callbacks);
-            this.ui.endStreaming();
+            try {
+                result = await agent.run(message, callbacks);
+            }
+            finally {
+                this.ui.endStreaming();
+            }
             // Restore original model
             agent.configModel = originalModel;
         }
@@ -746,15 +750,44 @@ 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();
-                    result = await agent.run(message, callbacks);
-                    this.ui.endStreaming();
+                    try {
+                        result = await agent.run(message, callbacks);
+                    }
+                    finally {
+                        this.ui.endStreaming();
+                    }
                 }
                 else {
-                    throw new Error('Coder agent not initialized');
+                    // 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 {
@@ -888,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
      */

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: 1,
+        maxSteps: 5,
     },
     moderate: {
         patterns: [
@@ -83,7 +83,7 @@ const COMPLEXITY_SIGNALS = {
             /\b(refactor|clean|simplify|optimize|restructure)\b/i,
         ],
         lengthThreshold: 300,
-        maxSteps: 3,
+        maxSteps: 15,
     },
     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: 6,
+        maxSteps: 30,
     },
 };
 // ---------------------------------------------------------------------------