@link-assistant/hive-mind 1.23.8 → 1.23.9

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.23.9
+
+### Patch Changes
+
+- 4456760: Fix merge queue to wait for target branch CI before merging (Issue #1307). The merge queue now checks for active CI runs on the target branch (main) before processing the first PR in the queue. This prevents cancelled workflows, incomplete releases, and failed post-merge checks when multiple PRs are merged in quick succession.
+
 ## 1.23.8
 
 ### Patch Changes

package/package.json

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

package/src/config.lib.mjs

@@ -409,6 +409,7 @@ export const version = {
 // Merge queue configurations
 // See: https://github.com/link-assistant/hive-mind/issues/1143
 // See: https://github.com/link-assistant/hive-mind/issues/1269
+// See: https://github.com/link-assistant/hive-mind/issues/1307
 export const mergeQueue = {
   // Maximum PRs to process in one merge session
   // Default: 10 PRs per session
@@ -426,6 +427,18 @@ export const mergeQueue = {
   // Issue #1269: gh pr merge requires explicit method when running non-interactively
   // Default: 'merge' - creates a merge commit
   mergeMethod: getenv('HIVE_MIND_MERGE_QUEUE_MERGE_METHOD', 'merge'),
+  // Issue #1307: Wait for main branch CI to complete before processing merge queue
+  // When enabled, the merge queue will wait for any active CI runs on the target branch
+  // (usually main) to complete before merging the first PR.
+  // Default: true - ensures all post-merge CI workflows complete before next merge
+  waitForTargetBranchCI: getenv('HIVE_MIND_MERGE_QUEUE_WAIT_FOR_TARGET_CI', 'true').toLowerCase() === 'true',
+  // Issue #1307: Timeout for waiting on target branch CI (in milliseconds)
+  // If active runs don't complete within this time, proceed with merge anyway
+  // Default: 45 minutes (2700000ms)
+  targetBranchCITimeoutMs: parseIntWithDefault('HIVE_MIND_MERGE_QUEUE_TARGET_CI_TIMEOUT_MS', 45 * 60 * 1000),
+  // Issue #1307: Polling interval for checking target branch CI status (in milliseconds)
+  // Default: 30 seconds (30000ms) - more frequent than PR CI polling since we're blocking
+  targetBranchCIPollIntervalMs: parseIntWithDefault('HIVE_MIND_MERGE_QUEUE_TARGET_CI_POLL_INTERVAL_MS', 30 * 1000),
 };
 
 // Helper function to validate configuration values

package/src/github-merge.lib.mjs

@@ -636,6 +636,160 @@ export function parseRepositoryUrl(url) {
   };
 }
 
+/**
+ * Get active workflow runs on a specific branch
+ * Issue #1307: Used to check if there are any in-progress or queued runs on the target branch
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {string} branch - Branch name (default: main)
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{runs: Array<Object>, hasActiveRuns: boolean, count: number}>}
+ */
+export async function getActiveBranchRuns(owner, repo, branch = 'main', verbose = false) {
+  try {
+    // Query for in_progress and queued runs on the specified branch
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?branch=${branch}&per_page=10" --jq '[.workflow_runs[] | select(.status=="in_progress" or .status=="queued")] | map({id: .id, name: .name, status: .status, created_at: .created_at, html_url: .html_url})'`);
+
+    const runs = JSON.parse(stdout.trim() || '[]');
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Found ${runs.length} active runs on ${owner}/${repo} branch ${branch}`);
+      for (const run of runs) {
+        console.log(`[VERBOSE] /merge:   - Run #${run.id}: ${run.name} (${run.status})`);
+      }
+    }
+
+    return {
+      runs,
+      hasActiveRuns: runs.length > 0,
+      count: runs.length,
+    };
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error checking active runs on ${branch}: ${error.message}`);
+    }
+    return {
+      runs: [],
+      hasActiveRuns: false,
+      count: 0,
+    };
+  }
+}
+
+/**
+ * Wait for all active workflow runs on a branch to complete
+ * Issue #1307: Ensures all CI runs on target branch are complete before merging
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {string} branch - Branch name (default: main)
+ * @param {Object} options - Wait options
+ * @param {number} options.timeout - Maximum wait time in ms (default: 45 minutes)
+ * @param {number} options.pollInterval - Polling interval in ms (default: 30 seconds)
+ * @param {Function} options.onStatusUpdate - Callback for status updates
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{success: boolean, waitedForRuns: boolean, completedRuns: number, error: string|null}>}
+ */
+export async function waitForBranchCI(owner, repo, branch = 'main', options = {}, verbose = false) {
+  const { timeout = 45 * 60 * 1000, pollInterval = 30 * 1000, onStatusUpdate = null } = options;
+
+  const startTime = Date.now();
+  let totalWaitedRuns = 0;
+
+  if (verbose) {
+    console.log(`[VERBOSE] /merge: Checking for active CI runs on ${owner}/${repo} branch ${branch}...`);
+  }
+
+  while (Date.now() - startTime < timeout) {
+    let activeRuns;
+    try {
+      activeRuns = await getActiveBranchRuns(owner, repo, branch, verbose);
+    } catch (error) {
+      // Log and continue on errors
+      console.error(`[ERROR] /merge: Error checking branch CI: ${error.message}`);
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      continue;
+    }
+
+    if (onStatusUpdate) {
+      try {
+        await onStatusUpdate({
+          hasActiveRuns: activeRuns.hasActiveRuns,
+          count: activeRuns.count,
+          runs: activeRuns.runs,
+          elapsedMs: Date.now() - startTime,
+        });
+      } catch (callbackError) {
+        // Log callback errors but continue
+        console.error(`[ERROR] /merge: Status update callback failed: ${callbackError.message}`);
+      }
+    }
+
+    if (!activeRuns.hasActiveRuns) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: No active CI runs on ${branch} branch. Ready to proceed.`);
+      }
+      return {
+        success: true,
+        waitedForRuns: totalWaitedRuns > 0,
+        completedRuns: totalWaitedRuns,
+        error: null,
+      };
+    }
+
+    totalWaitedRuns = Math.max(totalWaitedRuns, activeRuns.count);
+
+    if (verbose) {
+      const elapsedSec = Math.round((Date.now() - startTime) / 1000);
+      console.log(`[VERBOSE] /merge: Waiting for ${activeRuns.count} active runs on ${branch}... (${elapsedSec}s elapsed)`);
+    }
+
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+  }
+
+  // Timeout reached
+  const finalCheck = await getActiveBranchRuns(owner, repo, branch, verbose);
+  if (finalCheck.hasActiveRuns) {
+    return {
+      success: false,
+      waitedForRuns: true,
+      completedRuns: totalWaitedRuns - finalCheck.count,
+      error: `Timeout waiting for ${finalCheck.count} CI runs on ${branch} branch`,
+    };
+  }
+
+  return {
+    success: true,
+    waitedForRuns: totalWaitedRuns > 0,
+    completedRuns: totalWaitedRuns,
+    error: null,
+  };
+}
+
+/**
+ * Get the default branch for a repository
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<string>} Default branch name (e.g., 'main' or 'master')
+ */
+export async function getDefaultBranch(owner, repo, verbose = false) {
+  try {
+    const { stdout } = await exec(`gh api repos/${owner}/${repo} --jq '.default_branch'`);
+    const branch = stdout.trim();
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Default branch for ${owner}/${repo}: ${branch}`);
+    }
+
+    return branch || 'main';
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error getting default branch, falling back to 'main': ${error.message}`);
+    }
+    return 'main';
+  }
+}
+
 export default {
   READY_LABEL,
   checkReadyLabelExists,
@@ -651,4 +805,8 @@ export default {
   mergePullRequest,
   waitForCI,
   parseRepositoryUrl,
+  // Issue #1307: New exports for target branch CI waiting
+  getActiveBranchRuns,
+  waitForBranchCI,
+  getDefaultBranch,
 };

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

@@ -16,7 +16,7 @@
  * @see https://github.com/link-assistant/hive-mind/issues/1143
  */
 
-import { getAllReadyPRs, checkPRCIStatus, checkPRMergeable, mergePullRequest, waitForCI, ensureReadyLabel } from './github-merge.lib.mjs';
+import { getAllReadyPRs, checkPRCIStatus, checkPRMergeable, mergePullRequest, waitForCI, ensureReadyLabel, waitForBranchCI, getDefaultBranch } from './github-merge.lib.mjs';
 import { mergeQueue as mergeQueueConfig } from './config.lib.mjs';
 import { getProgressBar } from './limits.lib.mjs';
 
@@ -74,6 +74,11 @@ export const MERGE_QUEUE_CONFIG = {
   // Merge method: 'merge', 'squash', or 'rebase' (Issue #1269)
   // gh pr merge requires explicit method when running non-interactively
   MERGE_METHOD: mergeQueueConfig.mergeMethod,
+
+  // Issue #1307: Wait for target branch CI before first merge
+  WAIT_FOR_TARGET_BRANCH_CI: mergeQueueConfig.waitForTargetBranchCI,
+  TARGET_BRANCH_CI_TIMEOUT_MS: mergeQueueConfig.targetBranchCITimeoutMs,
+  TARGET_BRANCH_CI_POLL_INTERVAL_MS: mergeQueueConfig.targetBranchCIPollIntervalMs,
 };
 
 /**
@@ -229,6 +234,12 @@ export class MergeQueueProcessor {
     this.isCancelled = false;
 
     try {
+      // Issue #1307: Wait for any active CI runs on the target branch before processing
+      // This prevents merging while post-merge CI from previous merges is still running
+      if (MERGE_QUEUE_CONFIG.WAIT_FOR_TARGET_BRANCH_CI) {
+        await this.waitForTargetBranchCI();
+      }
+
       // Process each PR sequentially
       for (this.currentIndex = 0; this.currentIndex < this.items.length; this.currentIndex++) {
         if (this.isCancelled) {
@@ -383,6 +394,54 @@ export class MergeQueueProcessor {
     this.log('Cancellation requested');
   }
 
+  /**
+   * Wait for any active CI runs on the target branch to complete
+   * Issue #1307: Prevents merging while post-merge CI from previous merges is still running
+   * @returns {Promise<void>}
+   */
+  async waitForTargetBranchCI() {
+    // Track if we're waiting for CI (for progress updates)
+    this.waitingForTargetBranchCI = true;
+    this.targetBranchCIStatus = null;
+
+    try {
+      // Get the default branch (usually 'main' or 'master')
+      const targetBranch = await getDefaultBranch(this.owner, this.repo, this.verbose);
+      this.log(`Checking for active CI runs on ${targetBranch} branch before processing queue...`);
+
+      const waitResult = await waitForBranchCI(
+        this.owner,
+        this.repo,
+        targetBranch,
+        {
+          timeout: MERGE_QUEUE_CONFIG.TARGET_BRANCH_CI_TIMEOUT_MS,
+          pollInterval: MERGE_QUEUE_CONFIG.TARGET_BRANCH_CI_POLL_INTERVAL_MS,
+          onStatusUpdate: async status => {
+            this.targetBranchCIStatus = status;
+
+            // Report progress while waiting
+            if (this.onProgress) {
+              await this.onProgress(this.getProgressUpdate());
+            }
+          },
+        },
+        this.verbose
+      );
+
+      if (!waitResult.success) {
+        // Log warning but don't fail - proceed with merge anyway
+        console.warn(`[WARN] /merge-queue: ${waitResult.error}. Proceeding with merge anyway.`);
+      } else if (waitResult.waitedForRuns) {
+        this.log(`Waited for ${waitResult.completedRuns} CI runs to complete on ${targetBranch} branch`);
+      } else {
+        this.log(`No active CI runs on ${targetBranch} branch. Ready to proceed.`);
+      }
+    } finally {
+      this.waitingForTargetBranchCI = false;
+      this.targetBranchCIStatus = null;
+    }
+  }
+
   /**
    * Get current progress update
    */
@@ -456,8 +515,18 @@ export class MergeQueueProcessor {
     message += `⏭️ Skipped: ${update.stats.skipped}  `;
     message += `⏳ Pending: ${update.stats.total - update.progress.processed}\n\n`;
 
+    // Issue #1307: Show waiting status for target branch CI
+    if (this.waitingForTargetBranchCI && this.targetBranchCIStatus) {
+      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`;
+    } else if (this.waitingForTargetBranchCI) {
+      message += `⏱️ Checking for active CI runs on target branch\\.\\.\\.\n\n`;
+    }
+
     // Current item being processed
-    if (update.current) {
+    if (update.current && !this.waitingForTargetBranchCI) {
       const statusEmoji = update.currentStatus === MergeItemStatus.WAITING_CI ? '⏱️' : '🔄';
       message += `${statusEmoji} ${update.current}\n\n`;
     }