@link-assistant/hive-mind 1.21.1 → 1.21.3

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @link-assistant/hive-mind
 
+## 1.21.3
+
+### Patch Changes
+
+- 4426112: Fix error detection for `--tool agent` when JSON errors are pretty-printed (Issue #1258)
+  - Add fallback pattern matching for error events when NDJSON parsing fails
+  - Detect `"type": "error"` and `"type": "step_error"` patterns in raw output
+  - Detect critical error patterns like `AI_RetryError` and `UnhandledRejection`
+  - Extract error messages from output for better error reporting
+
+## 1.21.2
+
+### Patch Changes
+
+- 586b84d: Add retry mechanism for GitHub 500 errors during repository clone
+
+  This change adds intelligent retry logic with exponential backoff to handle transient GitHub server errors during repository cloning operations.
+
 ## 1.21.1
 
 ### Patch Changes

package/package.json

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

package/src/agent.lib.mjs

@@ -703,6 +703,51 @@ export const executeAgentCommand = async params => {
         outputError.match = streamingErrorMessage;
       }
 
+      // Issue #1258: Fallback pattern match for error detection
+      // When JSON parsing fails (e.g., multi-line pretty-printed JSON in logs),
+      // we need to detect error patterns in the raw output string
+      if (!outputError.detected && !streamingErrorDetected) {
+        // Check for error type patterns in raw output (handles pretty-printed JSON)
+        const errorTypePatterns = [
+          { pattern: '"type": "error"', type: 'AgentError' },
+          { pattern: '"type":"error"', type: 'AgentError' },
+          { pattern: '"type": "step_error"', type: 'AgentStepError' },
+          { pattern: '"type":"step_error"', type: 'AgentStepError' },
+        ];
+
+        for (const { pattern, type } of errorTypePatterns) {
+          if (fullOutput.includes(pattern)) {
+            outputError.detected = true;
+            outputError.type = type;
+            // Try to extract the error message from the output
+            const messageMatch = fullOutput.match(/"message":\s*"([^"]+)"/);
+            outputError.match = messageMatch ? messageMatch[1] : `Error event detected in output (fallback pattern match for ${pattern})`;
+            await log(`⚠️  Error event detected via fallback pattern match: ${outputError.match}`, { level: 'warning' });
+            break;
+          }
+        }
+
+        // Also check for known critical error patterns that indicate failure
+        if (!outputError.detected) {
+          const criticalErrorPatterns = [
+            { pattern: 'AI_RetryError:', extract: /AI_RetryError:\s*(.+?)(?:\n|$)/ },
+            { pattern: 'UnhandledRejection', extract: /"errorType":\s*"UnhandledRejection"/ },
+            { pattern: 'Failed after 3 attempts', extract: /Failed after \d+ attempts[^"]*/ },
+          ];
+
+          for (const { pattern, extract } of criticalErrorPatterns) {
+            if (fullOutput.includes(pattern)) {
+              outputError.detected = true;
+              outputError.type = 'CriticalError';
+              const match = fullOutput.match(extract);
+              outputError.match = match ? match[0] : `Critical error pattern detected: ${pattern}`;
+              await log(`⚠️  Critical error pattern detected via fallback: ${outputError.match}`, { level: 'warning' });
+              break;
+            }
+          }
+        }
+      }
+
       if (exitCode !== 0 || outputError.detected) {
         // Build JSON error structure for consistent error reporting
         const errorInfo = {

package/src/solve.repository.lib.mjs

@@ -884,56 +884,140 @@ Thank you!`;
   return { repoToClone, forkedRepo, upstreamRemote, prForkOwner: forkOwner };
 };
 
-// Clone repository and set up remotes
+// Classify git clone errors to determine if they are retryable
+export const classifyCloneError = errorOutput => {
+  const output = errorOutput.toLowerCase();
+
+  // Transient server errors (5xx) - typically retryable
+  if (output.includes('error: 500') || output.includes('internal server error') || output.includes('error: 502') || output.includes('error: 503') || output.includes('error: 504')) {
+    return { type: 'TRANSIENT', retryable: true, description: 'GitHub server error' };
+  }
+
+  // Network-related errors - typically retryable
+  if (output.includes('connection refused') || output.includes('connection timed out') || output.includes('connection reset') || output.includes('unable to connect') || output.includes('network is unreachable') || output.includes('ssl error')) {
+    return { type: 'NETWORK', retryable: true, description: 'Network connectivity issue' };
+  }
+
+  // Authentication/permission errors - not retryable
+  if (output.includes('error: 401') || output.includes('error: 403') || output.includes('authentication failed') || output.includes('permission denied')) {
+    return { type: 'PERMISSION', retryable: false, description: 'Authentication or permission error' };
+  }
+
+  // Repository not found - not retryable
+  if (output.includes('error: 404') || output.includes('not found') || output.includes('repository not found')) {
+    return { type: 'NOT_FOUND', retryable: false, description: 'Repository not found' };
+  }
+
+  // Rate limiting - retryable with backoff
+  if (output.includes('rate limit') || output.includes('too many requests') || output.includes('api rate limit exceeded')) {
+    return { type: 'RATE_LIMIT', retryable: true, description: 'Rate limit exceeded' };
+  }
+
+  // Default to retryable for unknown errors
+  return { type: 'UNKNOWN', retryable: true, description: 'Unknown error' };
+};
+
+// Clone repository and set up remotes with retry mechanism
 export const cloneRepository = async (repoToClone, tempDir, argv, owner, repo) => {
-  // Clone the repository (or fork) using gh tool with authentication
-  await log(`\n${formatAligned('📥', 'Cloning repository:', repoToClone)}`);
+  const maxRetries = 3;
+  const baseDelay = 2000; // Start with 2 seconds
 
-  // Use 2>&1 to capture all output and filter "Cloning into" message
-  const cloneResult = await $`gh repo clone ${repoToClone} ${tempDir} 2>&1`;
+  await log(`\n${formatAligned('📥', 'Cloning repository:', repoToClone)}`);
 
-  // Verify clone was successful
-  if (cloneResult.code !== 0) {
-    const errorOutput = (cloneResult.stderr || cloneResult.stdout || 'Unknown error').toString().trim();
-    await log('');
-    await log(`${formatAligned('❌', 'CLONE FAILED', '')}`, { level: 'error' });
-    await log('');
-    await log('  🔍 What happened:');
-    await log(`     Failed to clone repository ${repoToClone}`);
-    await log('');
-    await log('  📦 Error details:');
-    for (const line of errorOutput.split('\n')) {
-      if (line.trim()) await log(`     ${line}`);
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    if (attempt > 1) {
+      await log(`${formatAligned('⏳', 'Clone attempt:', `${attempt}/${maxRetries} (with retry logic)`)}`);
     }
-    await log('');
-    await log('  💡 Common causes:');
-    await log("     • Repository doesn't exist or is private");
-    await log('     • No GitHub authentication');
-    await log('     • Network connectivity issues');
-    if (argv.fork) {
-      await log('     • Fork not ready yet (try again in a moment)');
+
+    // Use 2>&1 to capture all output and filter "Cloning into" message
+    const cloneResult = await $`gh repo clone ${repoToClone} ${tempDir} 2>&1`;
+
+    // Verify clone was successful
+    if (cloneResult.code === 0) {
+      await log(`${formatAligned('✅', 'Cloned to:', tempDir)}`);
+
+      // Verify and fix remote configuration
+      const remoteCheckResult = await $({ cwd: tempDir })`git remote -v 2>&1`;
+      if (!remoteCheckResult.stdout || !remoteCheckResult.stdout.toString().includes('origin')) {
+        await log('   Setting up git remote...', { verbose: true });
+        // Add origin remote manually
+        await $({ cwd: tempDir })`git remote add origin https://github.com/${repoToClone}.git 2>&1`;
+      }
+      return; // Success - exit function
     }
-    await log('');
-    await log('  🔧 How to fix:');
-    await log('     1. Check authentication: gh auth status');
-    await log('     2. Login if needed: gh auth login');
-    await log(`     3. Verify access: gh repo view ${owner}/${repo}`);
-    if (argv.fork) {
-      await log(`     4. Check fork: gh repo view ${repoToClone}`);
+
+    // Clone failed - analyze error and determine if retry is appropriate
+    const errorOutput = (cloneResult.stderr || cloneResult.stdout || 'Unknown error').toString().trim();
+
+    const errorClassification = classifyCloneError(errorOutput);
+
+    if (!errorClassification.retryable || attempt === maxRetries) {
+      // Non-retryable error or max retries reached - fail with detailed error
+      await log('');
+      await log(`${formatAligned('❌', 'CLONE FAILED', '')}`, { level: 'error' });
+      await log('');
+      await log('  🔍 What happened:');
+      await log(`     Failed to clone repository ${repoToClone}`);
+
+      if (!errorClassification.retryable) {
+        await log(`     Error type: ${errorClassification.description} (not retryable)`);
+      } else {
+        await log(`     Error type: ${errorClassification.description} (max retries exceeded)`);
+      }
+      await log('');
+      await log('  📦 Error details:');
+      for (const line of errorOutput.split('\n')) {
+        if (line.trim()) await log(`     ${line}`);
+      }
+      await log('');
+      await log('  💡 Common causes:');
+      await log("     • Repository doesn't exist or is private");
+      await log('     • No GitHub authentication');
+      await log('     • Network connectivity issues');
+      if (errorClassification.type === 'TRANSIENT') {
+        await log('     • GitHub server issues (temporary)');
+      }
+      if (errorClassification.type === 'RATE_LIMIT') {
+        await log('     • API rate limiting exceeded');
+      }
+      if (argv.fork) {
+        await log('     • Fork not ready yet (try again in a moment)');
+      }
+      await log('');
+      await log('  🔧 How to fix:');
+      await log('     1. Check authentication: gh auth status');
+      await log('     2. Login if needed: gh auth login');
+      await log(`     3. Verify access: gh repo view ${owner}/${repo}`);
+      if (argv.fork) {
+        await log(`     4. Check fork: gh repo view ${repoToClone}`);
+      }
+      if (errorClassification.type === 'TRANSIENT') {
+        await log('     5. Wait a few minutes and retry (GitHub server issue)');
+        await log('     6. Check GitHub status: https://www.githubstatus.com');
+      }
+      if (errorClassification.type === 'RATE_LIMIT') {
+        await log('     5. Wait for rate limit to reset (check your quota)');
+        await log('     6. Use --token flag with different token if available');
+      }
+      await log('');
+      await safeExit(1, 'Repository setup failed');
     }
-    await log('');
-    await safeExit(1, 'Repository setup failed');
-  }
 
-  await log(`${formatAligned('✅', 'Cloned to:', tempDir)}`);
+    // Retryable error and we have attempts left
+    const delay = baseDelay * Math.pow(2, attempt - 1); // Exponential backoff
+    await log(`${formatAligned('⚠️', 'Clone failed:', errorClassification.description)}`);
+    await log(`${formatAligned('⏳', 'Retrying:', `Waiting ${delay / 1000}s before attempt ${attempt + 1}/${maxRetries}...`)}`);
+
+    if (errorClassification.type === 'RATE_LIMIT') {
+      await log('     💡 Tip: Rate limiting detected - using longer delay');
+    }
 
-  // Verify and fix remote configuration
-  const remoteCheckResult = await $({ cwd: tempDir })`git remote -v 2>&1`;
-  if (!remoteCheckResult.stdout || !remoteCheckResult.stdout.toString().includes('origin')) {
-    await log('   Setting up git remote...', { verbose: true });
-    // Add origin remote manually
-    await $({ cwd: tempDir })`git remote add origin https://github.com/${repoToClone}.git 2>&1`;
+    await new Promise(resolve => setTimeout(resolve, delay));
   }
+
+  // This should never be reached due to the loop logic above
+  await log(`${formatAligned('❌', 'UNEXPECTED ERROR:', 'Clone logic failed')}`);
+  await safeExit(1, 'Repository setup failed');
 };
 
 // Set up upstream remote and sync fork