@link-assistant/hive-mind 1.24.3 → 1.24.5

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @link-assistant/hive-mind
 
+## 1.24.5
+
+### Patch Changes
+
+- 17317bb: fix: prevent false positive error detection for JSON-structured stderr warnings (Issue #1337)
+
+  Claude Code SDK can emit structured JSON log messages to stderr with format `{"level":"warn","message":"..."}`. When these messages contained error-related keywords like "failed", the detection logic incorrectly flagged them as errors.
+
+  Added JSON parsing for stderr messages starting with `{`. If the parsed JSON has a `level` field that is not `"error"` or `"fatal"`, the message is treated as a warning (non-error), preserving existing emoji-prefix detection as a fallback.
+
+  Also enables `ANTHROPIC_LOG=debug` when running with `--verbose` flag, allowing users to see detailed API request information as suggested by the BashTool pre-flight warning.
+
+## 1.24.4
+
+### Patch Changes
+
+- 40282f3: fix: escape '...' ellipsis in MarkdownV2 and retry on UNKNOWN merge state (Issue #1339)
+
+  Two root causes fixed:
+  1. **MarkdownV2 escaping**: In `formatProgressMessage()`, literal '...' was appended in PR titles, error messages, and overflow lines. Telegram's MarkdownV2 requires '.' to be escaped as '\.' - unescaped periods caused 400 Bad Request errors on every message update during CI wait.
+  2. **UNKNOWN merge state**: GitHub computes PR mergeability asynchronously, so initial queries may return `mergeStateStatus: 'UNKNOWN'`. The old code immediately skipped PRs in this state. Fixed by adding retry logic to `checkPRMergeable()` that retries up to 3 times with 5-second delays before giving up.
+
 ## 1.24.3
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -724,6 +724,48 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
     throw new Error(`Failed to read session file: ${readError.message}`);
   }
 };
+/**
+ * Determines whether a stderr message line should be treated as an error.
+ *
+ * Excludes:
+ * - Emoji-prefixed warnings (Issue #477): lines starting with ⚠️ or ⚠
+ * - JSON-structured log messages with non-error level (Issue #1337):
+ *   e.g. {"level":"warn","message":"...failed..."} — the word "failed" is in
+ *   the message text but the level is "warn", so it is NOT an error.
+ *   Only JSON lines with level "error" or "fatal" are treated as real errors.
+ *
+ * @param {string} message - A single trimmed stderr line
+ * @returns {boolean} true if the line should count as an error
+ */
+export const isStderrError = message => {
+  const trimmed = message.trim();
+  if (!trimmed) return false;
+
+  // Detection 1: Emoji-prefixed warnings (Issue #477)
+  let isWarning = trimmed.startsWith('⚠️') || trimmed.startsWith('⚠');
+
+  // Detection 2: JSON-structured log messages (Issue #1337)
+  if (!isWarning && trimmed.startsWith('{')) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed.level === 'string') {
+        const level = parsed.level.toLowerCase();
+        // Only "error" and "fatal" levels are real errors.
+        if (level !== 'error' && level !== 'fatal') {
+          isWarning = true;
+        }
+      }
+    } catch {
+      // Not valid JSON — fall through to keyword matching
+    }
+  }
+
+  if (!isWarning && (trimmed.includes('Error:') || trimmed.includes('error') || trimmed.includes('failed') || trimmed.includes('not found'))) {
+    return true;
+  }
+  return false;
+};
+
 export const executeClaudeCommand = async params => {
   const {
     tempDir,
@@ -847,10 +889,17 @@ export const executeClaudeCommand = async params => {
       // Pass model for model-specific max output tokens (Issue #1221)
       // Pass thinkLevel and maxBudget for Opus 4.6 effort level conversion (Issue #1238)
       const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: mappedModel, thinkLevel, maxBudget });
+      // Issue #1337: Enable ANTHROPIC_LOG=debug in --verbose mode to diagnose slow API requests.
+      // The BashTool pre-flight check suggests "Run with ANTHROPIC_LOG=debug to check for failed or slow API requests."
+      // When --verbose is enabled, we propagate ANTHROPIC_LOG=debug so users can see detailed API request info.
+      if (argv.verbose) {
+        claudeEnv.ANTHROPIC_LOG = 'debug';
+      }
       const modelMaxOutputTokens = getMaxOutputTokensForModel(mappedModel);
       if (argv.verbose) await log(`📊 CLAUDE_CODE_MAX_OUTPUT_TOKENS: ${modelMaxOutputTokens}`, { verbose: true });
       if (argv.verbose) await log(`📊 MCP_TIMEOUT: ${claudeCode.mcpTimeout}ms (server startup)`, { verbose: true });
       if (argv.verbose) await log(`📊 MCP_TOOL_TIMEOUT: ${claudeCode.mcpToolTimeout}ms (tool execution)`, { verbose: true });
+      if (argv.verbose) await log(`📊 ANTHROPIC_LOG: debug (verbose mode)`, { verbose: true });
       if (resolvedThinkingBudget !== undefined) await log(`📊 MAX_THINKING_TOKENS: ${resolvedThinkingBudget}`, { verbose: true });
       if (claudeEnv.CLAUDE_CODE_EFFORT_LEVEL) await log(`📊 CLAUDE_CODE_EFFORT_LEVEL: ${claudeEnv.CLAUDE_CODE_EFFORT_LEVEL}`, { verbose: true });
       if (!isNewVersion && thinkLevel) await log(`📊 Thinking level (via keywords): ${thinkLevel}`, { verbose: true });
@@ -1065,16 +1114,9 @@ export const executeClaudeCommand = async params => {
           // Log stderr immediately
           if (errorOutput) {
             await log(errorOutput, { stream: 'stderr' });
-            // Track stderr errors for failure detection
-            const trimmed = errorOutput.trim();
-            // Exclude warnings (messages starting with ⚠️) from being treated as errors
-            // Example: "⚠️  [BashTool] Pre-flight check is taking longer than expected. Run with ANTHROPIC_LOG=debug to check for failed or slow API requests."
-            // Even though this contains the word "failed", it's a warning, not an error
-            const isWarning = trimmed.startsWith('⚠️') || trimmed.startsWith('⚠');
-            // Issue #1165: Also detect "command not found" errors (e.g., "/bin/sh: 1: claude: not found")
-            // These indicate the Claude CLI is not installed or not in PATH
-            if (trimmed && !isWarning && (trimmed.includes('Error:') || trimmed.includes('error') || trimmed.includes('failed') || trimmed.includes('not found'))) {
-              stderrErrors.push(trimmed);
+            // Track stderr errors for failure detection using shared helper (Issue #477, #1165, #1337)
+            if (isStderrError(errorOutput)) {
+              stderrErrors.push(errorOutput.trim());
             }
           }
         } else if (chunk.type === 'exit') {

package/src/github-merge.lib.mjs

@@ -400,6 +400,11 @@ export async function checkPRCIStatus(owner, repo, prNumber, verbose = false) {
 
 /**
  * Check if PR is mergeable
+ *
+ * Issue #1339: GitHub computes mergeability asynchronously. The first request may return
+ * mergeable: null and mergeStateStatus: 'UNKNOWN' while the computation is in progress.
+ * We retry up to 3 times with a 5-second delay between attempts to handle this case.
+ *
  * @param {string} owner - Repository owner
  * @param {string} repo - Repository name
  * @param {number} prNumber - Pull request number
@@ -407,46 +412,73 @@ export async function checkPRCIStatus(owner, repo, prNumber, verbose = false) {
  * @returns {Promise<{mergeable: boolean, reason: string|null}>}
  */
 export async function checkPRMergeable(owner, repo, prNumber, verbose = false) {
-  try {
-    const { stdout } = await exec(`gh pr view ${prNumber} --repo ${owner}/${repo} --json mergeable,mergeStateStatus`);
-    const pr = JSON.parse(stdout.trim());
-
-    const mergeable = pr.mergeable === 'MERGEABLE';
-    let reason = null;
-
-    if (!mergeable) {
-      switch (pr.mergeStateStatus) {
-        case 'BLOCKED':
-          reason = 'PR is blocked (possibly by branch protection rules)';
-          break;
-        case 'BEHIND':
-          reason = 'PR branch is behind the base branch';
-          break;
-        case 'DIRTY':
-          reason = 'PR has merge conflicts';
-          break;
-        case 'UNSTABLE':
-          reason = 'PR has failing required status checks';
-          break;
-        case 'DRAFT':
-          reason = 'PR is a draft';
-          break;
-        default:
-          reason = `Merge state: ${pr.mergeStateStatus || 'unknown'}`;
+  // Issue #1339: GitHub computes mergeability asynchronously. When mergeStateStatus is
+  // 'UNKNOWN', it means GitHub hasn't calculated the merge state yet. Retry a few times.
+  const MAX_UNKNOWN_RETRIES = 3;
+  const UNKNOWN_RETRY_DELAY_MS = 5000;
+
+  for (let attempt = 0; attempt < MAX_UNKNOWN_RETRIES; attempt++) {
+    try {
+      const { stdout } = await exec(`gh pr view ${prNumber} --repo ${owner}/${repo} --json mergeable,mergeStateStatus`);
+      const pr = JSON.parse(stdout.trim());
+
+      // Issue #1339: If mergeStateStatus is 'UNKNOWN', GitHub is still computing.
+      // Wait and retry instead of immediately skipping the PR.
+      if (pr.mergeStateStatus === 'UNKNOWN' || pr.mergeable === null) {
+        if (attempt < MAX_UNKNOWN_RETRIES - 1) {
+          if (verbose) {
+            console.log(`[VERBOSE] /merge: PR #${prNumber} mergeability is UNKNOWN (attempt ${attempt + 1}/${MAX_UNKNOWN_RETRIES}), retrying in ${UNKNOWN_RETRY_DELAY_MS / 1000}s...`);
+          }
+          await new Promise(resolve => setTimeout(resolve, UNKNOWN_RETRY_DELAY_MS));
+          continue;
+        }
+        // All retries exhausted, still UNKNOWN - treat as not mergeable
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: PR #${prNumber} mergeability still UNKNOWN after ${MAX_UNKNOWN_RETRIES} attempts`);
+        }
+        return { mergeable: false, reason: `Merge state: UNKNOWN (GitHub could not compute mergeability after ${MAX_UNKNOWN_RETRIES} attempts)` };
       }
-    }
 
-    if (verbose) {
-      console.log(`[VERBOSE] /merge: PR #${prNumber} mergeable: ${mergeable}, state: ${pr.mergeStateStatus}`);
-    }
+      const mergeable = pr.mergeable === 'MERGEABLE';
+      let reason = null;
+
+      if (!mergeable) {
+        switch (pr.mergeStateStatus) {
+          case 'BLOCKED':
+            reason = 'PR is blocked (possibly by branch protection rules)';
+            break;
+          case 'BEHIND':
+            reason = 'PR branch is behind the base branch';
+            break;
+          case 'DIRTY':
+            reason = 'PR has merge conflicts';
+            break;
+          case 'UNSTABLE':
+            reason = 'PR has failing required status checks';
+            break;
+          case 'DRAFT':
+            reason = 'PR is a draft';
+            break;
+          default:
+            reason = `Merge state: ${pr.mergeStateStatus || 'unknown'}`;
+        }
+      }
 
-    return { mergeable, reason };
-  } catch (error) {
-    if (verbose) {
-      console.log(`[VERBOSE] /merge: Error checking mergeability: ${error.message}`);
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: PR #${prNumber} mergeable: ${mergeable}, state: ${pr.mergeStateStatus}`);
+      }
+
+      return { mergeable, reason };
+    } catch (error) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: Error checking mergeability: ${error.message}`);
+      }
+      return { mergeable: false, reason: error.message };
     }
-    return { mergeable: false, reason: error.message };
   }
+
+  // Should not reach here, but return safe default
+  return { mergeable: false, reason: 'Merge state: UNKNOWN' };
 }
 
 /**

package/src/telegram-merge-queue.lib.mjs

@@ -520,7 +520,7 @@ export class MergeQueueProcessor {
       const elapsedSec = Math.round(this.targetBranchCIStatus.elapsedMs / 1000);
       const elapsedMin = Math.floor(elapsedSec / 60);
       const elapsedSecRemainder = elapsedSec % 60;
-      message += `⏱️ Waiting for ${this.targetBranchCIStatus.count} CI run\\(s\\) on target branch to complete \\(${elapsedMin}m ${elapsedSecRemainder}s\\)\\.\\.\\.\\n\\n`;
+      message += `⏱️ Waiting for ${this.targetBranchCIStatus.count} CI run\\(s\\) on target branch to complete \\(${elapsedMin}m ${elapsedSecRemainder}s\\)\\.\\.\\.\n\n`;
     } else if (this.waitingForTargetBranchCI) {
       message += `⏱️ Checking for active CI runs on target branch\\.\\.\\.\n\n`;
     }
@@ -528,7 +528,8 @@ export class MergeQueueProcessor {
     // Current item being processed
     if (update.current && !this.waitingForTargetBranchCI) {
       const statusEmoji = update.currentStatus === MergeItemStatus.WAITING_CI ? '⏱️' : '🔄';
-      message += `${statusEmoji} ${update.current}\n\n`;
+      // Issue #1339: escape the current item description for MarkdownV2
+      message += `${statusEmoji} ${this.escapeMarkdown(update.current)}\n\n`;
     }
 
     // Show errors/failures/skips inline so user gets immediate feedback (Issue #1269, #1294)
@@ -538,10 +539,12 @@ export class MergeQueueProcessor {
       message += `⚠️ *Issues:*\n`;
       for (const item of problemItems.slice(0, 5)) {
         const statusEmoji = item.status === MergeItemStatus.FAILED ? '❌' : '⏭️';
-        message += `  ${statusEmoji} \\#${item.prNumber}: ${this.escapeMarkdown(item.error.substring(0, 50))}${item.error.length > 50 ? '...' : ''}\n`;
+        // Issue #1339: escape the ellipsis '...' for MarkdownV2 (periods are reserved)
+        message += `  ${statusEmoji} \\#${item.prNumber}: ${this.escapeMarkdown(item.error.substring(0, 50))}${item.error.length > 50 ? '\\.\\.\\.' : ''}\n`;
       }
       if (problemItems.length > 5) {
-        message += `  _...and ${problemItems.length - 5} more issues_\n`;
+        // Issue #1339: escape the ellipsis '...' for MarkdownV2
+        message += `  _\\.\\.\\.and ${problemItems.length - 5} more issues_\n`;
       }
       message += '\n';
     }
@@ -549,11 +552,13 @@ export class MergeQueueProcessor {
     // PRs list with emojis
     message += `*Queue:*\n`;
     for (const item of update.items.slice(0, 10)) {
-      message += `${item.emoji} \\#${item.prNumber}: ${this.escapeMarkdown(item.title.substring(0, 35))}${item.title.length > 35 ? '...' : ''}\n`;
+      // Issue #1339: escape the ellipsis '...' for MarkdownV2 (periods are reserved)
+      message += `${item.emoji} \\#${item.prNumber}: ${this.escapeMarkdown(item.title.substring(0, 35))}${item.title.length > 35 ? '\\.\\.\\.' : ''}\n`;
     }
 
     if (update.items.length > 10) {
-      message += `_...and ${update.items.length - 10} more_\n`;
+      // Issue #1339: escape the ellipsis '...' for MarkdownV2
+      message += `_\\.\\.\\.and ${update.items.length - 10} more_\n`;
     }
 
     return message;