@link-assistant/hive-mind 1.35.4 → 1.35.6

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @link-assistant/hive-mind
 
+## 1.35.6
+
+### Patch Changes
+
+- 4b0beaf: Fix interactive mode PR comment output: use stdin for GitHub API calls to prevent shell quoting corruption, flush comment queue before tool result timeout to prevent stuck "Waiting for result..." comments, and guard against duplicate session started comments from late system.init events
+
+## 1.35.5
+
+### Patch Changes
+
+- 37481da: fix: improve PR creation failure error messaging and log upload fallback (Issue #1462)
+  - Consolidate triple error output into a single clear error message when PR creation fails
+  - Upload failure logs to the issue as fallback when PR is not available (--attach-logs)
+  - Capture and log `gh pr create` stdout/stderr in verbose mode for root cause diagnosis
+  - Add fallback GitHub user detection via `gh auth status` when `gh api user` fails
+  - Rename `github-issue-creator.lib.mjs` to `github-error-reporter.lib.mjs` for clarity
+
 ## 1.35.4
 
 ### Patch Changes

package/package.json

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

package/src/{github-issue-creator.lib.mjs → github-error-reporter.lib.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Automatic GitHub issue creation for error reporting
+ * GitHub error reporter - handles error reporting via GitHub issues and comments
  */
 
 import { createInterface } from 'readline';
@@ -52,7 +52,8 @@ const getCurrentGitHubUser = async () => {
   try {
     const result = await $`gh api user --jq .login`;
     if (result.exitCode === 0) {
-      return result.stdout.toString().trim();
+      const user = result.stdout.toString().trim();
+      if (user) return user;
     }
   } catch (error) {
     reportError(error, {
@@ -60,6 +61,18 @@ const getCurrentGitHubUser = async () => {
       operation: 'gh_api_user',
     });
   }
+  // Issue #1462: Fallback to gh auth status when gh api user fails
+  // This handles OAuth tokens (gho_****) that may lack the 'user' API scope
+  try {
+    const authResult = await $`gh auth status --hostname github.com 2>&1`;
+    const output = (authResult.stdout?.toString() || '') + (authResult.stderr?.toString() || '');
+    const userMatch = output.match(/Logged in to github\.com account (\S+)/i) || output.match(/Logged in to github\.com as (\S+)/i);
+    if (userMatch) {
+      return userMatch[1];
+    }
+  } catch {
+    // Silently ignore - will return null below
+  }
   return null;
 };
 

package/src/interactive-mode.lib.mjs

@@ -52,6 +52,13 @@ const CONFIG = {
 // See: https://github.com/link-assistant/hive-mind/issues/1324
 import { sanitizeUnicode } from './unicode-sanitization.lib.mjs';
 
+// Use child_process for stdin-based API calls to avoid shell quoting issues
+// with large/complex comment bodies containing backticks, quotes, etc.
+// See: https://github.com/link-assistant/hive-mind/issues/1458
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+
 /**
  * Truncate content in the middle, keeping start and end
  * This helps show context while reducing size for large outputs
@@ -237,7 +244,9 @@ const getToolIcon = toolName => {
  * @returns {Object} Handler object with event processing methods
  */
 export const createInteractiveHandler = options => {
-  const { owner, repo, prNumber, $, log, verbose = false } = options;
+  const { owner, repo, prNumber, log, verbose = false, execFile: execFileFn } = options;
+  // Use injected execFile for testability, or the real one by default
+  const runGhApi = execFileFn || execFileAsync;
 
   // State tracking for the handler
   const state = {
@@ -291,24 +300,35 @@ export const createInteractiveHandler = options => {
     }
 
     try {
-      // Post comment and capture the output to get the comment URL/ID
-      const result = await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${body}`;
+      // Post comment via gh api with stdin to avoid shell quoting issues
+      // with complex markdown bodies containing backticks, quotes, etc.
+      // See: https://github.com/link-assistant/hive-mind/issues/1458
+      const apiUrl = `repos/${owner}/${repo}/issues/${prNumber}/comments`;
+      const jsonPayload = JSON.stringify({ body });
+      const { stdout } = await runGhApi('gh', ['api', apiUrl, '-X', 'POST', '--input', '-'], {
+        input: jsonPayload,
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+      });
       state.lastCommentTime = Date.now();
 
-      // Extract comment ID from the result (gh outputs the comment URL)
-      // Format: https://github.com/owner/repo/pull/123#issuecomment-1234567890
-      // Note: command-stream returns stdout as a Buffer, so we need to call .toString()
-      const output = result.stdout?.toString() || result.toString() || '';
-      const match = output.match(/issuecomment-(\d+)/);
-      const commentId = match ? match[1] : null;
+      // Extract comment ID from the API response JSON
+      let commentId = null;
+      try {
+        const response = JSON.parse(stdout);
+        commentId = response.id ? String(response.id) : null;
+      } catch {
+        // Fallback: try to extract from URL pattern
+        const match = stdout.match(/issuecomment-(\d+)|"id":\s*(\d+)/);
+        commentId = match ? match[1] || match[2] : null;
+      }
 
       if (verbose) {
-        await log(`✅ Interactive mode: Comment posted${commentId ? ` (ID: ${commentId})` : ''}`, { verbose: true });
+        await log(`✅ Interactive mode: Comment posted${commentId ? ` (ID: ${commentId})` : ''} (body: ${body.length} chars)`, { verbose: true });
       }
       return commentId;
     } catch (error) {
       if (verbose) {
-        await log(`⚠️ Interactive mode: Failed to post comment: ${error.message}`, { verbose: true });
+        await log(`⚠️ Interactive mode: Failed to post comment: ${error.message} (body: ${body.length} chars)`, { verbose: true });
       }
       return null;
     }
@@ -330,14 +350,22 @@ export const createInteractiveHandler = options => {
     }
 
     try {
-      await $`gh api repos/${owner}/${repo}/issues/comments/${commentId} -X PATCH -f body=${body}`;
+      // Edit comment via gh api with stdin to avoid shell quoting issues
+      // with complex markdown bodies containing backticks, quotes, etc.
+      // See: https://github.com/link-assistant/hive-mind/issues/1458
+      const apiUrl = `repos/${owner}/${repo}/issues/comments/${commentId}`;
+      const jsonPayload = JSON.stringify({ body });
+      await runGhApi('gh', ['api', apiUrl, '-X', 'PATCH', '--input', '-'], {
+        input: jsonPayload,
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+      });
       if (verbose) {
-        await log(`✅ Interactive mode: Comment ${commentId} updated`, { verbose: true });
+        await log(`✅ Interactive mode: Comment ${commentId} updated (body: ${body.length} chars, payload: ${jsonPayload.length} chars)`, { verbose: true });
       }
       return true;
     } catch (error) {
       if (verbose) {
-        await log(`⚠️ Interactive mode: Failed to edit comment: ${error.message}`, { verbose: true });
+        await log(`⚠️ Interactive mode: Failed to edit comment ${commentId}: ${error.message} (body: ${body.length} chars)`, { verbose: true });
       }
       return false;
     }
@@ -398,6 +426,16 @@ export const createInteractiveHandler = options => {
    * @param {Object} data - Event data
    */
   const handleSystemInit = async data => {
+    // Guard against duplicate init events (e.g., when a late task_notification
+    // arrives after the result event and triggers a new conversation turn)
+    // See: https://github.com/link-assistant/hive-mind/issues/1458
+    if (state.sessionId) {
+      if (verbose) {
+        await log(`⚠️ Interactive mode: Ignoring duplicate system.init event (session already initialized: ${state.sessionId})`, { verbose: true });
+      }
+      return;
+    }
+
     state.sessionId = data.session_id;
     state.startTime = Date.now();
 
@@ -672,21 +710,44 @@ ${createRawJsonSection(data)}`;
       // If comment ID is not yet available (comment was queued), wait for it
       // But use a timeout to avoid blocking forever
       if (!commentId && commentIdPromise) {
-        if (verbose) {
-          await log(`⏳ Interactive mode: Waiting for tool use comment to be posted (tool: ${toolUseId})`, {
-            verbose: true,
-          });
+        // First, try to flush the queue — the tool_use comment may still be
+        // waiting for rate-limit clearance. Processing it here avoids the 30s
+        // timeout that previously caused many comments to stay stuck on
+        // "Waiting for result...".
+        // See: https://github.com/link-assistant/hive-mind/issues/1458
+        if (state.commentQueue.length > 0) {
+          if (verbose) {
+            await log(`🔄 Interactive mode: Flushing comment queue (${state.commentQueue.length} items) before waiting for tool use comment`, {
+              verbose: true,
+            });
+          }
+          // Temporarily reset isProcessing to allow processQueue to run
+          const wasProcessing = state.isProcessing;
+          state.isProcessing = false;
+          await processQueue();
+          state.isProcessing = wasProcessing;
         }
-        // Wait for the comment to be posted (with 30 second timeout)
-        const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(null), 30000));
-        commentId = await Promise.race([commentIdPromise, timeoutPromise]);
+
+        // Check again after queue flush
+        commentId = pendingCall.commentId;
 
         if (!commentId) {
           if (verbose) {
-            await log('⚠️ Interactive mode: Timeout waiting for tool use comment, posting result separately', {
+            await log(`⏳ Interactive mode: Waiting for tool use comment to be posted (tool: ${toolUseId})`, {
               verbose: true,
             });
           }
+          // Wait for the comment to be posted (with 30 second timeout)
+          const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(null), 30000));
+          commentId = await Promise.race([commentIdPromise, timeoutPromise]);
+
+          if (!commentId) {
+            if (verbose) {
+              await log('⚠️ Interactive mode: Timeout waiting for tool use comment, posting result separately', {
+                verbose: true,
+              });
+            }
+          }
         }
       }
 

package/src/solve.auto-pr.lib.mjs

@@ -1113,12 +1113,14 @@ ${prBody}`,
           }
 
           let output;
+          let prCreateStderr = '';
           let assigneeFailed = false;
 
           // Try to create PR with assignee first (if specified)
           try {
             const result = await execAsync(command, { encoding: 'utf8', cwd: tempDir, env: process.env });
             output = result.stdout;
+            prCreateStderr = result.stderr || '';
           } catch (firstError) {
             // Check if the error is specifically about assignee validation
             const errorMsg = firstError.message || '';
@@ -1146,6 +1148,7 @@ ${prBody}`,
               // Retry without assignee - if this fails, let the error propagate to outer catch
               const retryResult = await execAsync(command, { encoding: 'utf8', cwd: tempDir, env: process.env });
               output = retryResult.stdout;
+              prCreateStderr = retryResult.stderr || '';
             } else {
               // Not an assignee error, re-throw the original error
               throw firstError;
@@ -1168,6 +1171,14 @@ ${prBody}`,
             });
           });
 
+          // Log gh pr create output for debugging (Issue #1462)
+          if (argv.verbose) {
+            await log(`   gh pr create stdout: ${(output || '').trim() || '(empty)'}`, { verbose: true });
+            if (prCreateStderr) {
+              await log(`   gh pr create stderr: ${prCreateStderr.trim()}`, { verbose: true });
+            }
+          }
+
           // Extract PR URL from output - gh pr create outputs the URL to stdout
           prUrl = output.trim();
 
@@ -1214,22 +1225,11 @@ ${prBody}`,
                 }
               } else {
                 // PR does not exist - gh pr create must have failed silently
-                await log('');
-                await log(formatAligned('❌', 'FATAL ERROR:', 'PR creation failed'), { level: 'error' });
-                await log('');
-                await log('  🔍 What happened:');
-                await log('     The gh pr create command returned a URL, but the PR does not exist on GitHub.');
-                await log('');
-                await log('  🔧 How to fix:');
-                await log('     1. Check if PR exists manually:');
-                await log(`        gh pr list --repo ${owner}/${repo} --head ${branchName}`);
-                await log('     2. Try creating PR manually:');
-                await log(`        cd ${tempDir}`);
-                await log(`        gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}"`);
-                await log('     3. Check GitHub authentication:');
-                await log('        gh auth status');
-                await log('');
-                throw new Error('PR creation failed - PR does not exist on GitHub');
+                // Issue #1462: Include gh pr create stderr for root cause diagnosis
+                const verifyStderr = verifyResult.stderr ? verifyResult.stderr.toString().trim() : '';
+                const stderrInfo = prCreateStderr ? ` (gh pr create stderr: ${prCreateStderr.trim()})` : '';
+                const verifyInfo = verifyStderr ? ` (gh pr view stderr: ${verifyStderr})` : '';
+                throw new Error(`PR verification failed - gh pr create returned URL "${prUrl}" but PR #${localPrNumber} does not exist on GitHub${stderrInfo}${verifyInfo}`);
               }
               // Store PR info globally for error handlers
               global.createdPR = { number: localPrNumber, url: prUrl };
@@ -1374,73 +1374,22 @@ ${prBody}`,
             branchName,
             operation: 'create_pull_request',
           });
+          // Issue #1462: Don't log verbose error block here - let the outer catch
+          // handler produce a single consolidated error message to avoid triple error output.
+          // Extract clean error message and re-throw with context.
           const errorMsg = prCreateError.message || '';
-
-          // Clean up the error message - extract the meaningful part
           let cleanError = errorMsg;
           if (errorMsg.includes('pull request create failed:')) {
             cleanError = errorMsg.split('pull request create failed:')[1].trim();
           } else if (errorMsg.includes('Command failed:')) {
-            // Extract just the error part, not the full command
             const lines = errorMsg.split('\n');
             cleanError = lines[lines.length - 1] || errorMsg;
           }
 
-          // Check for specific error types
-          // Note: Assignee errors are now handled by automatic retry in the try block above
-          // This catch block only handles other types of PR creation failures
           if (errorMsg.includes('No commits between') || errorMsg.includes("Head sha can't be blank")) {
-            // Empty PR error
-            await log('');
-            await log(formatAligned('❌', 'PR CREATION FAILED', ''), { level: 'error' });
-            await log('');
-            await log('  🔍 What happened:');
-            await log('     Cannot create PR - no commits between branches.');
-            await log('');
-            await log('  📦 Error details:');
-            for (const line of cleanError.split('\n')) {
-              if (line.trim()) await log(`     ${line.trim()}`);
-            }
-            await log('');
-            await log('  💡 Possible causes:');
-            await log("     • The branch wasn't pushed properly");
-            await log("     • The commit wasn't created");
-            await log('     • GitHub sync issue');
-            await log('');
-            await log('  🔧 How to fix:');
-            await log('     1. Verify commit exists:');
-            await log(`        cd ${tempDir} && git log --format="%h %s" -5`);
-            await log('     2. Push again with tracking:');
-            await log(`        cd ${tempDir} && git push -u origin ${branchName}`);
-            await log('     3. Create PR manually:');
-            await log(`        cd ${tempDir} && gh pr create --draft`);
-            await log('');
-            await log(`  📂 Working directory: ${tempDir}`);
-            await log(`  🌿 Current branch: ${branchName}`);
-            await log('');
-            throw new Error('PR creation failed - no commits between branches');
+            throw new Error(`PR creation failed - no commits between branches: ${cleanError}`);
           } else {
-            // Generic PR creation error
-            await log('');
-            await log(formatAligned('❌', 'PR CREATION FAILED', ''), { level: 'error' });
-            await log('');
-            await log('  🔍 What happened:');
-            await log('     Failed to create pull request.');
-            await log('');
-            await log('  📦 Error details:');
-            for (const line of cleanError.split('\n')) {
-              if (line.trim()) await log(`     ${line.trim()}`);
-            }
-            await log('');
-            await log('  🔧 How to fix:');
-            await log('     1. Try creating PR manually:');
-            await log(`        cd ${tempDir} && gh pr create --draft`);
-            await log('     2. Check branch status:');
-            await log(`        cd ${tempDir} && git status`);
-            await log('     3. Verify GitHub authentication:');
-            await log('        gh auth status');
-            await log('');
-            throw new Error('PR creation failed');
+            throw new Error(`PR creation failed: ${cleanError}`);
           }
         }
       }
@@ -1452,23 +1401,22 @@ ${prBody}`,
       operation: 'handle_auto_pr',
     });
 
-    // CRITICAL: PR creation failure should stop the entire process
-    // We cannot continue without a PR when auto-PR creation is enabled
+    // Issue #1462: Single consolidated error message for PR creation failure.
+    // Previously this was the third of three error blocks, causing confusing output.
+    // Now this is the ONLY error block shown for PR creation failures.
     await log('');
     await log(formatAligned('❌', 'FATAL ERROR:', 'PR creation failed'), { level: 'error' });
     await log('');
-    await log('  🔍 What this means:');
-    await log('     The solve command cannot continue without a pull request.');
-    await log('     Auto-PR creation is enabled but failed to create the PR.');
-    await log('');
-    await log('  📦 Error details:');
+    await log('  🔍 What happened:');
     await log(`     ${prError.message}`);
     await log('');
+    await log('  💡 The solve command cannot continue without a pull request.');
+    await log('');
     await log('  🔧 How to fix:');
     await log('');
     await log('  Option 1: Retry without auto-PR creation');
     await log(`     ./solve.mjs "${issueUrl}" --no-auto-pull-request-creation`);
-    await log('     (Claude will create the PR during the session)');
+    await log('     (The AI agent will create the PR during the session)');
     await log('');
     await log('  Option 2: Create PR manually first');
     await log(`     cd ${tempDir}`);
@@ -1482,8 +1430,9 @@ ${prBody}`,
     await log('     gh pr create --draft  # Try manually to see detailed error');
     await log('');
 
-    // Re-throw the error to stop execution
-    throw new Error(`PR creation failed: ${prError.message}`);
+    // Re-throw the error to stop execution - use prError.message directly
+    // to avoid "PR creation failed: PR creation failed" redundancy (Issue #1462)
+    throw prError;
   }
 
   return { prUrl, prNumber: localPrNumber, claudeCommitHash };

package/src/solve.error-handlers.lib.mjs

@@ -8,8 +8,8 @@ import { safeExit } from './exit-handler.lib.mjs';
 // Import Sentry integration
 import { reportError } from './sentry.lib.mjs';
 
-// Import GitHub issue creator
-import { handleErrorWithIssueCreation } from './github-issue-creator.lib.mjs';
+// Import GitHub error reporter
+import { handleErrorWithIssueCreation } from './github-error-reporter.lib.mjs';
 
 /**
  * Handles log attachment and PR closing on failure
@@ -40,35 +40,45 @@ export const handleFailure = async options => {
   }
 
   // If --attach-logs is enabled, try to attach failure logs
-  if (shouldAttachLogs && getLogFile() && global.createdPR && global.createdPR.number) {
-    await log('\n📄 Attempting to attach failure logs...');
-    try {
-      const logUploadSuccess = await attachLogToGitHub({
-        logFile: getLogFile(),
-        targetType: 'pr',
-        targetNumber: global.createdPR.number,
-        owner: global.owner || owner,
-        repo: global.repo || repo,
-        $,
-        log,
-        sanitizeLogContent,
-        verbose: argv.verbose,
-        errorMessage: cleanErrorMessage(error),
-        // Issue #1225: Pass model and tool info for PR comments
-        requestedModel: argv.model,
-        tool: argv.tool || 'claude',
-      });
-      if (logUploadSuccess) {
-        await log('📎 Failure log attached to Pull Request');
+  if (shouldAttachLogs && getLogFile()) {
+    // Issue #1462: Upload logs to PR if available, otherwise fall back to the issue
+    const hasPR = global.createdPR && global.createdPR.number;
+    const hasIssue = global.issueNumber;
+    const targetType = hasPR ? 'pr' : hasIssue ? 'issue' : null;
+    const targetNumber = hasPR ? global.createdPR.number : hasIssue ? global.issueNumber : null;
+    const targetLabel = hasPR ? 'Pull Request' : 'Issue';
+
+    if (targetType && targetNumber) {
+      await log(`\n📄 Attempting to attach failure logs to ${targetLabel}...`);
+      try {
+        const logUploadSuccess = await attachLogToGitHub({
+          logFile: getLogFile(),
+          targetType,
+          targetNumber,
+          owner: global.owner || owner,
+          repo: global.repo || repo,
+          $,
+          log,
+          sanitizeLogContent,
+          verbose: argv.verbose,
+          errorMessage: cleanErrorMessage(error),
+          // Issue #1225: Pass model and tool info for PR comments
+          requestedModel: argv.model,
+          tool: argv.tool || 'claude',
+        });
+        if (logUploadSuccess) {
+          await log(`📎 Failure log attached to ${targetLabel}`);
+        }
+      } catch (attachError) {
+        reportError(attachError, {
+          context: 'attach_failure_log',
+          targetType,
+          targetNumber,
+          errorType,
+          operation: `attach_log_to_${targetType}`,
+        });
+        await log(`⚠️  Could not attach failure log to ${targetLabel}: ${attachError.message}`, { level: 'warning' });
       }
-    } catch (attachError) {
-      reportError(attachError, {
-        context: 'attach_failure_log',
-        prNumber: global.createdPR?.number,
-        errorType,
-        operation: 'attach_log_to_pr',
-      });
-      await log(`⚠️  Could not attach failure log: ${attachError.message}`, { level: 'warning' });
     }
   }
 

package/src/solve.mjs

@@ -496,6 +496,9 @@ if (isPrUrl) {
   issueNumber = urlNumber;
   await log(`📝 Issue mode: Working with issue #${issueNumber}`);
 }
+// Issue #1462: Store issueNumber in global so error handlers can upload logs to the issue
+// as a fallback when PR creation fails and global.createdPR is not available
+global.issueNumber = issueNumber;
 const workspaceInfo = argv.enableWorkspaces ? { owner, repo, issueNumber } : null;
 const { tempDir, workspaceTmpDir, needsClone } = await setupTempDirectory(argv, workspaceInfo);
 cleanupContext.tempDir = tempDir;
@@ -1076,19 +1079,25 @@ try {
       await log('');
     }
 
-    // If --attach-logs is enabled and we have a PR, attach failure logs before exiting
+    // If --attach-logs is enabled, attach failure logs before exiting
     // Note: sessionId is not required - logs should be uploaded even if agent failed before establishing a session
-    // This aligns with the pattern in handleFailure() in solve.error-handlers.lib.mjs
-    if (shouldAttachLogs && global.createdPR && global.createdPR.number) {
-      await log('\n📄 Attaching failure logs to Pull Request...');
+    // Issue #1462: Fall back to uploading logs to the issue if PR is not available
+    const hasPR = global.createdPR && global.createdPR.number;
+    const hasIssue = global.issueNumber;
+    const logTargetType = hasPR ? 'pr' : hasIssue ? 'issue' : null;
+    const logTargetNumber = hasPR ? global.createdPR.number : hasIssue ? global.issueNumber : null;
+    const logTargetLabel = hasPR ? 'Pull Request' : 'Issue';
+
+    if (shouldAttachLogs && logTargetType && logTargetNumber) {
+      await log(`\n📄 Attaching failure logs to ${logTargetLabel}...`);
       try {
         // Build Claude CLI resume command
         const tool = argv.tool || 'claude';
         const resumeCommand = sessionId && tool === 'claude' ? buildClaudeResumeCommand({ tempDir, sessionId, model: argv.model }) : null;
         const logUploadSuccess = await attachLogToGitHub({
           logFile: getLogFile(),
-          targetType: 'pr',
-          targetNumber: global.createdPR.number,
+          targetType: logTargetType,
+          targetNumber: logTargetNumber,
           owner,
           repo,
           $,
@@ -1110,7 +1119,7 @@ try {
         });
 
         if (logUploadSuccess) {
-          await log('  ✅ Failure logs uploaded successfully');
+          await log(`  ✅ Failure logs uploaded to ${logTargetLabel} successfully`);
         } else {
           await log('  ⚠️  Failed to upload logs', { verbose: true });
         }