neuro-cli 4.1.1 → 4.1.3

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,7 +190,7 @@ export class BaseAgent {
                 break;
             }
         }
-        if (iteration > maxIter) {
+        if (iteration > maxIter && execution.status === 'running') {
             execution.status = 'completed';
             execution.result = 'Max iterations reached';
         }
@@ -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/core/approval.d.ts

@@ -1,3 +1,4 @@
+import { Interface as ReadLineInterface } from 'readline';
 export type PermissionMode = 'manual' | 'auto' | 'plan' | 'yolo';
 export interface ApprovalResult {
     approved: boolean;
@@ -39,6 +40,7 @@ export declare class ApprovalSystem {
     private persistDecisions;
     private consecutiveAutoApproves;
     private rl;
+    private mainRl;
     private stats;
     private pendingBatch;
     private batchTimer;
@@ -65,6 +67,11 @@ export declare class ApprovalSystem {
     private isWhitelisted;
     private getPattern;
     private getAlwaysKey;
+    /**
+     * Set the main readline interface from index.ts
+     * This prevents creating a second readline on the same stdin
+     */
+    setMainReadline(rl: ReadLineInterface): void;
     private readline;
     close(): void;
     addAutoApprove(toolName: string): void;

package/dist/core/approval.js

@@ -23,6 +23,7 @@ export class ApprovalSystem {
     persistDecisions = true;
     consecutiveAutoApproves = 0;
     rl = null;
+    mainRl = null;
     stats = new Map();
     pendingBatch = [];
     batchTimer = null;
@@ -333,10 +334,38 @@ export class ApprovalSystem {
     getAlwaysKey(toolName, args) {
         return `${toolName}:${this.getPattern(args)}`;
     }
+    /**
+     * Set the main readline interface from index.ts
+     * This prevents creating a second readline on the same stdin
+     */
+    setMainReadline(rl) {
+        this.mainRl = rl;
+    }
     readline(prompt) {
-        if (!this.rl)
-            this.rl = createInterface({ input: process.stdin, output: process.stdout });
-        return new Promise((resolve) => { this.rl.question(prompt, (answer) => resolve(answer)); });
+        // 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();
+        }
+        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);
+            });
+        });
     }
     close() {
         if (this.rl) {

package/dist/core/diff-preview.js

@@ -3,6 +3,7 @@
 // Shows file changes before applying them
 // ============================================================
 import { readFileSync, existsSync } from 'fs';
+import { createInterface } from 'readline';
 import chalk from 'chalk';
 export class DiffPreview {
     /**
@@ -128,7 +129,7 @@ export class DiffPreview {
      */
     static async confirmDiff(diff) {
         DiffPreview.renderDiff(diff);
-        const rl = require('readline').createInterface({ input: process.stdin, output: process.stdout });
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
         return new Promise((resolve) => {
             rl.question(chalk.cyan('  Apply these changes? [y/n]: '), (answer) => {
                 rl.close();

package/dist/core/engine.js

@@ -1,5 +1,5 @@
 // ============================================================
-// NeuroCLI - NeuroEngine v4.1.1
+// 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.1',
+            currentVersion: '4.1.3',
             autoCheck: true,
             autoUpdate: false,
         });
@@ -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;
         }
@@ -750,11 +754,24 @@ Always consider the strengths of each agent when delegating:
                 const agent = this.agents.get('Coder');
                 if (agent) {
                     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 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,
+                    };
                 }
             }
             else {