@link-assistant/hive-mind 1.35.12 → 1.36.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @link-assistant/hive-mind
 
+## 1.36.1
+
+### Patch Changes
+
+- 74bf211: fix false positive 'Ready to merge' by adding workflow run grace period (Issue #1480)
+
+## 1.36.0
+
+### Minor Changes
+
+- 3adbf2b: feat: add --auto-report-issue and --disable-report-issue flags for non-interactive error reporting (Issue #1484)
+  - Add `--auto-report-issue` flag that automatically creates a GitHub issue on failure without prompting.
+    The auto-reported issue includes error details, logs, and case study analysis instructions in the body.
+    Issue is labeled as `bug`.
+  - Add `--disable-report-issue` flag that completely disables error issue creation (no prompt, no auto-creation).
+    Takes precedence over `--auto-report-issue` if both are specified.
+  - Default behavior (neither flag) preserves the existing interactive y/n prompt.
+  - Both flags are automatically available as passthrough options in hive and TELEGRAM_HIVE_OVERRIDES.
+
 ## 1.35.12
 
 ### Patch Changes

package/package.json

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

package/src/github-error-reporter.lib.mjs

@@ -149,7 +149,7 @@ export const formatLogForIssue = async (logContent, logFilePath) => {
  * @returns {Promise<string|null>} Issue URL or null on failure
  */
 export const createIssueForError = async options => {
-  const { error, errorType, logFile, context = {} } = options;
+  const { error, errorType, logFile, context = {}, autoReport = false } = options;
 
   try {
     const currentUser = await getCurrentGitHubUser();
@@ -159,7 +159,20 @@ export const createIssueForError = async options => {
     }
 
     const errorMessage = cleanErrorMessage(error);
-    const shouldCreateIssue = await promptUserForIssueCreation(errorMessage);
+
+    let shouldCreateIssue;
+    if (autoReport) {
+      // Auto-report mode: skip prompt, automatically create issue
+      console.log('\n❌ An error occurred:');
+      console.log(`   ${errorMessage}`);
+      if (isSentryEnabled()) {
+        console.log('\n✅ Error reported to Sentry successfully');
+      }
+      console.log('\nℹ️  --auto-report-issue enabled: automatically creating GitHub issue...');
+      shouldCreateIssue = true;
+    } else {
+      shouldCreateIssue = await promptUserForIssueCreation(errorMessage);
+    }
 
     if (!shouldCreateIssue) {
       await log('ℹ️  Issue creation cancelled by user');
@@ -199,6 +212,20 @@ export const createIssueForError = async options => {
       }
     }
 
+    if (autoReport) {
+      issueBody += '### Instructions\n\n';
+      issueBody += 'We need to download all logs and data related about the issue to this repository, ';
+      issueBody += 'make sure we compile that data to `./docs/case-studies/issue-{id}` folder, ';
+      issueBody += 'and use it to do deep case study analysis (also make sure to search online for additional facts and data), ';
+      issueBody += 'in which we will reconstruct timeline/sequence of events, find root causes of the problem, ';
+      issueBody += 'and propose possible solutions (including known existing components/libraries, ';
+      issueBody += 'that solve similar problem or can help in solutions).\n\n';
+      issueBody += 'If there is not enough data to find actual root cause, add debug output and verbose mode if not present, ';
+      issueBody += 'that will allow us to find root cause on next iteration.\n\n';
+      issueBody += 'If issue related to any other repository/project, where we can report issues on GitHub, please do so. ';
+      issueBody += 'Each issue must contain reproducible examples, workarounds and suggestions for fix the issue in code.\n\n';
+    }
+
     issueBody += '---\n';
     issueBody += `*This issue was automatically created by @${currentUser} using hive-mind error reporting*\n`;
 
@@ -239,7 +266,24 @@ export const createIssueForError = async options => {
  * @returns {Promise<string|null>} Issue URL if created, null otherwise
  */
 export const handleErrorWithIssueCreation = async options => {
-  const { error, errorType, logFile, context = {}, skipPrompt = false } = options;
+  const { error, errorType, logFile, context = {}, skipPrompt = false, autoReport = false, disableReport = false } = options;
+
+  // --disable-report-issue takes highest precedence
+  if (disableReport) {
+    await log('ℹ️  Issue reporting disabled via --disable-report-issue.');
+    return null;
+  }
+
+  // --auto-report-issue: create issue automatically without prompting
+  if (autoReport) {
+    return await createIssueForError({
+      error,
+      errorType,
+      logFile: logFile || (await getAbsoluteLogPath()),
+      context,
+      autoReport: true,
+    });
+  }
 
   if (skipPrompt) {
     return null;

package/src/github-merge.lib.mjs

@@ -1286,6 +1286,170 @@ export async function getActiveRepoWorkflows(owner, repo, verbose = false) {
   }
 }
 
+/**
+ * Get the committed date of a specific commit from GitHub API
+ * Issue #1480: Used to determine how recently a commit was pushed, to distinguish between
+ * "CI not yet registered in API" (race condition) and "CI definitively not triggered"
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {string} sha - Commit SHA
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{date: Date|null, ageSeconds: number|null}>}
+ */
+export async function getCommitDate(owner, repo, sha, verbose = false) {
+  try {
+    const { stdout } = await exec(`gh api repos/${owner}/${repo}/commits/${sha} --jq '.commit.committer.date'`);
+    const dateStr = stdout.trim();
+    if (!dateStr) {
+      return { date: null, ageSeconds: null };
+    }
+    const commitDate = new Date(dateStr);
+    const ageSeconds = Math.floor((Date.now() - commitDate.getTime()) / 1000);
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Commit ${sha.substring(0, 7)} date: ${dateStr} (${ageSeconds}s ago)`);
+    }
+    return { date: commitDate, ageSeconds };
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error fetching commit date for ${sha}: ${error.message}`);
+    }
+    return { date: null, ageSeconds: null };
+  }
+}
+
+/**
+ * Check if any previous commits in a PR had workflow runs triggered.
+ * Issue #1480: If earlier commits in the same PR triggered CI, we should expect CI
+ * for the HEAD commit too (unless conditions changed). This provides an additional
+ * signal that CI should be expected and avoids false "CI not triggered" conclusions.
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} prNumber - Pull request number
+ * @param {string} headSha - Current HEAD SHA (to exclude from check)
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{hadPreviousCI: boolean, previousCommitsWithCI: number, totalPreviousCommits: number}>}
+ */
+export async function checkPreviousPRCommitsHadCI(owner, repo, prNumber, headSha, verbose = false) {
+  try {
+    // Get all commits in the PR
+    const { stdout: commitsJson } = await exec(`gh api "repos/${owner}/${repo}/pulls/${prNumber}/commits?per_page=100" --jq '[.[].sha]'`);
+    const allShas = JSON.parse(commitsJson.trim() || '[]');
+
+    // Exclude the current HEAD SHA
+    const previousShas = allShas.filter(sha => sha !== headSha);
+
+    if (previousShas.length === 0) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: PR #${prNumber} has no previous commits to check for CI history`);
+      }
+      return { hadPreviousCI: false, previousCommitsWithCI: 0, totalPreviousCommits: 0 };
+    }
+
+    // Check the most recent previous commits (limit to last 3 to avoid excessive API calls)
+    const commitsToCheck = previousShas.slice(-3);
+    let commitsWithCI = 0;
+
+    for (const sha of commitsToCheck) {
+      try {
+        const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${sha}&per_page=1" --jq '.total_count'`);
+        const count = parseInt(stdout.trim(), 10);
+        if (count > 0) {
+          commitsWithCI++;
+        }
+      } catch {
+        // Skip errors for individual commits
+      }
+    }
+
+    const hadPreviousCI = commitsWithCI > 0;
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: PR #${prNumber} previous CI history: ${commitsWithCI}/${commitsToCheck.length} checked commits had workflow runs (total PR commits: ${allShas.length})`);
+    }
+
+    return { hadPreviousCI, previousCommitsWithCI: commitsWithCI, totalPreviousCommits: previousShas.length };
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error checking previous PR commits CI history: ${error.message}`);
+    }
+    return { hadPreviousCI: false, previousCommitsWithCI: 0, totalPreviousCommits: 0 };
+  }
+}
+
+/**
+ * Check if any workflow files in the repository have PR-related triggers
+ * Issue #1480: Used as additional signal to determine if CI should run on PRs.
+ * Parses .github/workflows/*.yml files from the repository content API.
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{hasPRTriggers: boolean, hasWorkflowFiles: boolean, workflows: Array<{name: string, triggers: string[]}>}>}
+ */
+export async function checkWorkflowsHavePRTriggers(owner, repo, verbose = false) {
+  try {
+    // List workflow files in .github/workflows/
+    const { stdout: listJson } = await exec(`gh api "repos/${owner}/${repo}/contents/.github/workflows" --jq '[.[] | select(.name | test("\\\\.(yml|yaml)$")) | {name: .name, download_url: .download_url, path: .path}]' 2>/dev/null`);
+    const files = JSON.parse(listJson.trim() || '[]');
+
+    if (files.length === 0) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: No workflow files found in ${owner}/${repo}/.github/workflows/ — no CI/CD will execute`);
+      }
+      // Issue #1480: hasWorkflowFiles=false is a strong signal that no CI/CD is configured at the file level
+      return { hasPRTriggers: false, hasWorkflowFiles: false, workflows: [] };
+    }
+
+    const prTriggerPatterns = [/\bon:\s*\n\s+pull_request/m, /\bon:\s*\[.*pull_request.*\]/m, /\bon:\s*pull_request\b/m, /\bpull_request_target\b/m];
+
+    // Also check for push triggers (push to PR branches triggers CI)
+    const pushTriggerPatterns = [/\bon:\s*\n\s+push/m, /\bon:\s*\[.*push.*\]/m, /\bon:\s*push\b/m];
+
+    const results = [];
+
+    for (const file of files) {
+      try {
+        // Fetch file content (use raw content from the API)
+        const { stdout: contentJson } = await exec(`gh api "repos/${owner}/${repo}/contents/${file.path}" --jq '.content'`);
+        const content = Buffer.from(contentJson.trim().replace(/"/g, ''), 'base64').toString('utf-8');
+
+        const triggers = [];
+        if (prTriggerPatterns.some(p => p.test(content))) {
+          triggers.push('pull_request');
+        }
+        if (pushTriggerPatterns.some(p => p.test(content))) {
+          triggers.push('push');
+        }
+
+        if (triggers.length > 0) {
+          results.push({ name: file.name, triggers });
+        }
+
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: Workflow ${file.name}: triggers=[${triggers.join(', ')}]`);
+        }
+      } catch (fileError) {
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: Error reading workflow file ${file.name}: ${fileError.message}`);
+        }
+      }
+    }
+
+    const hasPRTriggers = results.length > 0;
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: ${results.length}/${files.length} workflow files have PR/push triggers`);
+    }
+
+    return { hasPRTriggers, hasWorkflowFiles: true, workflows: results };
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error checking workflow PR triggers: ${error.message}`);
+    }
+    // On error, assume workflows might have PR triggers (safer: avoids false positives)
+    return { hasPRTriggers: true, hasWorkflowFiles: true, workflows: [] };
+  }
+}
+
 // Issue #1341: Re-export post-merge CI functions from separate module
 import { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha } from './github-merge-ci.lib.mjs';
 export { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha };
@@ -1323,6 +1487,10 @@ export default {
   checkBranchCIHealth,
   getMergeCommitSha,
   getActiveRepoWorkflows,
+  // Issue #1480: Commit date, workflow PR triggers, and previous commit CI history for race condition detection
+  getCommitDate,
+  checkPreviousPRCommitsHadCI,
+  checkWorkflowsHavePRTriggers,
   // Issue #1413: Use issue timeline to find genuinely linked PRs (avoids false positives from text search)
   getLinkedPRsFromTimeline,
 };

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

@@ -33,7 +33,7 @@ const { reportError } = sentryLib;
 
 // Import GitHub merge functions
 const githubMergeLib = await import('./github-merge.lib.mjs');
-const { checkPRMergeable, checkMergePermissions, mergePullRequest, waitForCI, checkForBillingLimitError, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDetailedCIStatus, rerunWorkflowRun, getWorkflowRunsForSha, getActiveRepoWorkflows } = githubMergeLib;
+const { checkPRMergeable, checkMergePermissions, mergePullRequest, waitForCI, checkForBillingLimitError, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDetailedCIStatus, rerunWorkflowRun, getWorkflowRunsForSha, getActiveRepoWorkflows, getCommitDate, checkPreviousPRCommitsHadCI, checkWorkflowsHavePRTriggers } = githubMergeLib;
 
 // Import GitHub functions for log attachment
 const githubLib = await import('./github.lib.mjs');
@@ -255,14 +255,86 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
             details: workflowRuns.map(r => r.name),
           });
         } else {
-          // No workflow runs for this SHA — CI was definitively NOT triggered
-          // Issue #1442: This is the root cause of the infinite loop. Fork PRs needing
-          // maintainer approval, paths-ignore filtering, workflow conditions not matching,
-          // etc. all result in zero workflow runs. No need for timeout — exit immediately.
-          if (verbose) {
-            console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks and no workflow runs for SHA ${ciStatus.sha.substring(0, 7)} — CI was not triggered (fork PR, paths-ignore, workflow conditions, etc.)`);
+          // No workflow runs for this SHA — but this could be a race condition!
+          // Issue #1480: GitHub Actions workflow runs take 30-120 seconds to appear in the
+          // API after a push. The previous fix (issue #1442) assumed 0 workflow runs meant
+          // "CI definitively NOT triggered", but this caused false positive "Ready to merge"
+          // when checked too soon after a push.
+          //
+          // Multi-layer defense (Issue #1480 enhanced):
+          // Layer 1: Grace period — check commit age
+          // Layer 2: Workflow file parsing — check .github/workflows for PR triggers
+          // Layer 3: Previous commit CI history — check if earlier PR commits had CI runs
+          const WORKFLOW_RUN_GRACE_PERIOD_SECONDS = 120; // 2 minutes — generous to cover slow GitHub API registration
+          const commitInfo = await getCommitDate(owner, repo, ciStatus.sha, verbose);
+
+          // Issue #1480: Parse workflow files for PR triggers (used in both grace period and post-grace checks)
+          const prTriggers = await checkWorkflowsHavePRTriggers(owner, repo, verbose);
+
+          // Issue #1480: If .github/workflows folder doesn't exist or has no workflow files,
+          // that's a definitive signal — no CI/CD will execute, skip grace period entirely
+          if (!prTriggers.hasWorkflowFiles) {
+            if (verbose) {
+              console.log(`[VERBOSE] /merge: PR #${prNumber} repo has no workflow files in .github/workflows/ — CI definitively not configured at file level`);
+            }
+            return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
+          }
+
+          if (commitInfo.ageSeconds !== null && commitInfo.ageSeconds < WORKFLOW_RUN_GRACE_PERIOD_SECONDS) {
+            // Commit is recent — workflow runs may not have appeared in the API yet
+            if (verbose) {
+              console.log(`[VERBOSE] /merge: PR #${prNumber} has no workflow runs for SHA ${ciStatus.sha.substring(0, 7)}, but commit is only ${commitInfo.ageSeconds}s old (grace period: ${WORKFLOW_RUN_GRACE_PERIOD_SECONDS}s) — treating as potential race condition`);
+            }
+
+            if (prTriggers.hasPRTriggers) {
+              // Workflows have PR/push triggers AND commit is recent — almost certainly a race condition
+              if (verbose) {
+                console.log(`[VERBOSE] /merge: Workflow files confirm PR/push triggers exist (${prTriggers.workflows.map(w => w.name).join(', ')}) — waiting for workflow runs to appear`);
+              }
+              blockers.push({
+                type: 'ci_pending',
+                message: `CI/CD workflow runs have not appeared yet — commit is ${commitInfo.ageSeconds}s old, waiting for GitHub to register workflow runs (grace period: ${WORKFLOW_RUN_GRACE_PERIOD_SECONDS}s)`,
+                details: prTriggers.workflows.map(w => w.name),
+              });
+            } else {
+              // No PR triggers found in workflow files — but commit is still recent, be safe and wait
+              if (verbose) {
+                console.log(`[VERBOSE] /merge: No PR/push triggers found in workflow files, but commit is only ${commitInfo.ageSeconds}s old — waiting to be safe`);
+              }
+              blockers.push({
+                type: 'ci_pending',
+                message: `CI/CD workflow runs have not appeared yet — commit is ${commitInfo.ageSeconds}s old, waiting for GitHub to register workflow runs (grace period: ${WORKFLOW_RUN_GRACE_PERIOD_SECONDS}s)`,
+                details: [],
+              });
+            }
+          } else {
+            // Commit is old enough (grace period elapsed) — but check additional signals before concluding
+            // Issue #1480: Layer 3 — Check if previous commits in this PR had CI runs.
+            // If earlier commits had CI, the HEAD commit should also have CI unless conditions changed.
+            const previousCI = await checkPreviousPRCommitsHadCI(owner, repo, prNumber, ciStatus.sha, verbose);
+
+            if (previousCI.hadPreviousCI && prTriggers.hasPRTriggers) {
+              // Previous commits had CI AND workflow files have PR triggers — something is wrong,
+              // this could be a GitHub API glitch or delayed registration beyond the grace period.
+              // Wait one more cycle to be safe.
+              if (verbose) {
+                console.log(`[VERBOSE] /merge: PR #${prNumber} previous commits had CI (${previousCI.previousCommitsWithCI}/${previousCI.totalPreviousCommits}) and workflows have PR triggers, but HEAD has no runs — waiting as safety measure`);
+              }
+              blockers.push({
+                type: 'ci_pending',
+                message: `CI/CD workflow runs missing for HEAD — previous PR commits had CI (${previousCI.previousCommitsWithCI} of ${previousCI.totalPreviousCommits}), workflows have PR triggers, possible API delay`,
+                details: prTriggers.workflows.map(w => w.name),
+              });
+            } else {
+              // CI was definitively NOT triggered
+              // Issue #1442: Fork PRs needing maintainer approval, paths-ignore filtering,
+              // workflow conditions not matching, etc. all result in zero workflow runs.
+              if (verbose) {
+                console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks and no workflow runs for SHA ${ciStatus.sha.substring(0, 7)} (commit age: ${commitInfo.ageSeconds ?? 'unknown'}s, grace period: ${WORKFLOW_RUN_GRACE_PERIOD_SECONDS}s elapsed, previous CI: ${previousCI.hadPreviousCI}, PR triggers: ${prTriggers.hasPRTriggers}) — CI was not triggered`);
+              }
+              return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
+            }
           }
-          return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
         }
       } else {
         // Repo has NO workflows — this is truly "no CI configured"

package/src/solve.config.lib.mjs

@@ -369,6 +369,16 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Automatically initialize empty repositories by creating a simple README.md file. Only works when you have write access to the repository. This allows branch creation and pull request workflows to proceed on repositories that have no commits.',
     default: false,
   },
+  'auto-report-issue': {
+    type: 'boolean',
+    description: 'Automatically create a GitHub issue on failure without prompting (non-interactive mode). The issue includes error details, logs, and case study analysis instructions. Sets issue type and label to bug.',
+    default: false,
+  },
+  'disable-report-issue': {
+    type: 'boolean',
+    description: 'Disable error issue creation entirely (no prompt, no automatic creation). Overrides --auto-report-issue if both are specified.',
+    default: false,
+  },
   'attach-solution-summary': {
     type: 'boolean',
     description: 'Attach the AI solution summary (from the result field) as a comment to the PR/issue after completion. The summary is extracted from the AI tool JSON output and posted under a "Solution summary" header.',

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

@@ -30,6 +30,8 @@ export const handleFailure = async options => {
         errorType,
       },
       skipPrompt: !process.stdin.isTTY || argv.noIssueCreation,
+      autoReport: argv.autoReportIssue,
+      disableReport: argv.disableReportIssue,
     });
   } catch (issueError) {
     reportError(issueError, {