@link-assistant/hive-mind 1.14.0 → 1.14.2

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @link-assistant/hive-mind
 
+## 1.14.2
+
+### Patch Changes
+
+- 69a34a6: fix: NDJSON stream buffering for Claude CLI output (Issue #1183)
+
+  Fixed issue where `total_cost_usd` and other critical fields were not being captured from Claude CLI sessions when the output JSON was split across multiple stdout chunks.
+
+  **Root Cause**: Claude CLI outputs NDJSON (newline-delimited JSON) format, but long JSON messages (like the `result` type containing `total_cost_usd`) can be split across multiple stdout buffer chunks. The code was splitting each chunk by newlines and parsing independently, causing partial JSON fragments to fail parsing.
+
+  **Solution**:
+  - Implemented line buffering to accumulate incomplete lines across chunks
+  - Lines are only parsed when they're complete (have a trailing newline)
+  - Added processing of any remaining buffer content after the stream ends
+
+  This ensures that even very long JSON output (e.g., result messages with extensive usage data) is properly parsed and cost tracking works correctly.
+
+  **Evidence from logs**: The broken session showed JSON truncated mid-word at `ephemeral_5m_input_tok` continuing on the next line with `ens":97252}}` - making both lines unparseable.
+
+## 1.14.1
+
+### Patch Changes
+
+- b139b00: fix: detect agent tool errors during streaming for reliable failure detection (Issue #1201)
+
+  Previously, agent tool errors (`"type": "error"`) could be missed when the post-hoc
+  detection function failed to parse NDJSON lines that were concatenated without newline
+  delimiters. Now errors are detected inline during stream processing, ensuring
+  `"type": "error"` events always trigger a failure exit regardless of output buffering.
+
 ## 1.14.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.14.0",
+  "version": "1.14.2",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/agent.lib.mjs

@@ -418,6 +418,10 @@ export const executeAgentCommand = async params => {
       let limitResetTime = null;
       let lastMessage = '';
       let fullOutput = ''; // Collect all output for pricing calculation and error detection
+      // Issue #1201: Track error events detected during streaming for reliable error detection
+      // Post-hoc detection on fullOutput can miss errors if NDJSON lines get concatenated without newlines
+      let streamingErrorDetected = false;
+      let streamingErrorMessage = null;
 
       for await (const chunk of execCommand.stream()) {
         if (chunk.type === 'stdout') {
@@ -437,6 +441,12 @@ export const executeAgentCommand = async params => {
                 sessionId = data.sessionID;
                 await log(`📌 Session ID: ${sessionId}`);
               }
+              // Issue #1201: Detect error events during streaming for reliable detection
+              if (data.type === 'error' || data.type === 'step_error') {
+                streamingErrorDetected = true;
+                streamingErrorMessage = data.message || data.error || line.substring(0, 100);
+                await log(`⚠️  Error event detected in stream: ${streamingErrorMessage}`, { level: 'warning' });
+              }
             } catch {
               // Not JSON - log as plain text
               await log(line);
@@ -463,6 +473,12 @@ export const executeAgentCommand = async params => {
                   sessionId = stderrData.sessionID;
                   await log(`📌 Session ID: ${sessionId}`);
                 }
+                // Issue #1201: Detect error events during streaming (stderr) for reliable detection
+                if (stderrData.type === 'error' || stderrData.type === 'step_error') {
+                  streamingErrorDetected = true;
+                  streamingErrorMessage = stderrData.message || stderrData.error || stderrLine.substring(0, 100);
+                  await log(`⚠️  Error event detected in stream: ${streamingErrorMessage}`, { level: 'warning' });
+                }
               } catch {
                 // Not JSON - log as plain text
                 await log(stderrLine);
@@ -496,7 +512,7 @@ export const executeAgentCommand = async params => {
 
             // Check for explicit error message types from agent
             if (msg.type === 'error' || msg.type === 'step_error') {
-              return { detected: true, type: 'AgentError', match: msg.message || line.substring(0, 100) };
+              return { detected: true, type: 'AgentError', match: msg.message || msg.error || line.substring(0, 100) };
             }
           } catch {
             // Not JSON - ignore for error detection
@@ -510,6 +526,15 @@ export const executeAgentCommand = async params => {
       // Only check for JSON error messages, not pattern matching in output
       const outputError = detectAgentErrors(fullOutput);
 
+      // Issue #1201: Use streaming detection as primary, post-hoc as fallback
+      // Streaming detection is more reliable because it parses each JSON line as it arrives,
+      // avoiding issues where NDJSON lines get concatenated without newline delimiters in fullOutput
+      if (!outputError.detected && streamingErrorDetected) {
+        outputError.detected = true;
+        outputError.type = 'AgentError';
+        outputError.match = streamingErrorMessage;
+      }
+
       if (exitCode !== 0 || outputError.detected) {
         // Build JSON error structure for consistent error reporting
         const errorInfo = {
@@ -545,7 +570,7 @@ export const executeAgentCommand = async params => {
             await log(line, { level: 'warning' });
           }
         } else if (outputError.detected) {
-          // Explicit JSON error message from agent
+          // Explicit JSON error message from agent (Issue #1201: includes streaming-detected errors)
           errorInfo.message = `Agent reported error: ${outputError.match}`;
           await log(`\n\n❌ ${errorInfo.message}`, { level: 'error' });
         } else {

package/src/claude.lib.mjs

@@ -944,57 +944,46 @@ export const executeClaudeCommand = async params => {
       await log(`\n${formatAligned('▶️', 'Streaming output:', '')}\n`);
       // Use command-stream's async iteration for real-time streaming
       let exitCode = 0;
+      // Issue #1183: Line buffer for NDJSON stream parsing - accumulate incomplete lines across chunks
+      // Long JSON messages (e.g., result with total_cost_usd) may be split across multiple stdout chunks
+      let stdoutLineBuffer = '';
       for await (const chunk of execCommand.stream()) {
         if (chunk.type === 'stdout') {
           const output = chunk.data.toString();
-          // Split output into individual lines for NDJSON parsing
-          // Claude CLI outputs NDJSON (newline-delimited JSON) format where each line is a separate JSON object
-          // This allows us to parse each event independently and extract structured data like session IDs,
-          // message counts, and error patterns. Attempting to parse the entire chunk as single JSON would fail
-          // since multiple JSON objects aren't valid JSON together.
-          const lines = output.split('\n');
+          // Append to buffer and split; keep last element (may be incomplete) for next chunk
+          stdoutLineBuffer += output;
+          const lines = stdoutLineBuffer.split('\n');
+          stdoutLineBuffer = lines.pop() || '';
+          // Parse each complete NDJSON line
           for (const line of lines) {
             if (!line.trim()) continue;
             try {
               const data = JSON.parse(line);
-              // Process event in interactive mode (posts PR comments in real-time)
+              // Process event in interactive mode
               if (interactiveHandler) {
                 try {
                   await interactiveHandler.processEvent(data);
                 } catch (interactiveError) {
-                  // Don't let interactive mode errors stop the main execution
                   await log(`⚠️ Interactive mode error: ${interactiveError.message}`, { verbose: true });
                 }
               }
-              // Output formatted JSON as in v0.3.2
               await log(JSON.stringify(data, null, 2));
-              // Capture session ID from the first message
+              // Capture session ID and rename log file
               if (!sessionId && data.session_id) {
                 sessionId = data.session_id;
                 await log(`📌 Session ID: ${sessionId}`);
-                // Try to rename log file to include session ID
                 let sessionLogFile;
                 try {
                   const currentLogFile = getLogFile();
-                  const logDir = path.dirname(currentLogFile);
-                  sessionLogFile = path.join(logDir, `${sessionId}.log`);
-                  // Use fs.promises to rename the file
+                  sessionLogFile = path.join(path.dirname(currentLogFile), `${sessionId}.log`);
                   await fs.rename(currentLogFile, sessionLogFile);
-                  // Update the global log file reference
                   setLogFile(sessionLogFile);
                   await log(`📁 Log renamed to: ${sessionLogFile}`);
                 } catch (renameError) {
-                  reportError(renameError, {
-                    context: 'rename_session_log',
-                    sessionId,
-                    sessionLogFile,
-                    operation: 'rename_log_file',
-                  });
-                  // If rename fails, keep original filename
+                  reportError(renameError, { context: 'rename_session_log', sessionId, sessionLogFile, operation: 'rename_log_file' });
                   await log(`⚠️ Could not rename log file: ${renameError.message}`, { verbose: true });
                 }
               }
-              // Track message and tool use counts
               if (data.type === 'message') {
                 messageCount++;
               } else if (data.type === 'tool_use') {
@@ -1110,6 +1099,19 @@ export const executeClaudeCommand = async params => {
         }
       }
 
+      // Issue #1183: Process remaining buffer content - extract cost from result type if present
+      if (stdoutLineBuffer.trim()) {
+        try {
+          const data = JSON.parse(stdoutLineBuffer);
+          await log(JSON.stringify(data, null, 2));
+          if (data.type === 'result' && data.subtype === 'success' && data.total_cost_usd != null) {
+            anthropicTotalCostUSD = data.total_cost_usd;
+          }
+        } catch {
+          if (!stdoutLineBuffer.includes('node:internal')) await log(stdoutLineBuffer, { stream: 'raw' });
+        }
+      }
+
       // Issue #1165: Check actual exit code from command result for more reliable detection
       // The .stream() method may not emit 'exit' chunks, but the command object still tracks the exit code
       // Exit code 127 is the standard Unix convention for "command not found"