@link-assistant/hive-mind 2.7.3 → 2.8.0

package/src/fix.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+
+/**
+ * `/fix` command (issue #1733).
+ *
+ * Currently implements `--ci-cd`: automatically generate a CI/CD remediation
+ * issue for a target repository and (optionally) hand it off to
+ * `/solve --development-log --deep-analysis --auto-merge`.
+ *
+ *   fix.mjs <github-repository-url> --ci-cd [solve options...]
+ *
+ * Every option `/fix` does not consume itself (e.g. --tool, --model, --think)
+ * is forwarded to `/solve`.
+ */
+
+import path from 'path';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { CI_CD_ISSUE_LABELS, CI_CD_ISSUE_TYPE, buildCiCdIssueBody, buildCiCdIssueTitle, buildSolveArgs, partitionFixArgs, summarizeRunFailures } from './fix.ci-cd.lib.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function printHelp() {
+  console.log(`Usage: fix.mjs <github-repository-url> --ci-cd [options]
+
+Automatically generate a CI/CD remediation issue for a repository and hand it
+off to /solve --development-log --deep-analysis --auto-merge.
+
+Options:
+  --ci-cd            Generate a CI/CD remediation issue (required mode)
+  --dry-run          Print the issue that would be created without creating it
+  --no-solve         Create the issue but do not start /solve on it
+  --version          Show version number
+  --help, -h         Show help
+
+All other options (e.g. --tool, --model, --think) are forwarded to /solve.
+
+Examples:
+  fix.mjs https://github.com/owner/repo --ci-cd
+  fix.mjs https://github.com/owner/repo --ci-cd --tool codex --model gpt-5.5
+  fix.mjs owner/repo --ci-cd --think max --no-solve`);
+}
+
+function runCommand(command, args, options = {}) {
+  return new Promise(resolve => {
+    const child = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+      ...options,
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', data => {
+      stdout += data.toString();
+    });
+    child.stderr.on('data', data => {
+      stderr += data.toString();
+    });
+    child.on('error', error => {
+      resolve({ code: 1, stdout, stderr: stderr || error.message });
+    });
+    child.on('close', code => {
+      resolve({ code, stdout, stderr });
+    });
+  });
+}
+
+async function commandOutput(command, args) {
+  const result = await runCommand(command, args);
+  if (result.code !== 0) {
+    const output = `${result.stderr || ''}${result.stdout || ''}`.trim();
+    throw new Error(output || `${command} exited with code ${result.code}`);
+  }
+  return result.stdout.trim();
+}
+
+async function detectLanguages(repository) {
+  try {
+    const json = await commandOutput('gh', ['api', `repos/${repository.fullName}/languages`]);
+    return JSON.parse(json);
+  } catch (error) {
+    console.warn(`⚠️  Could not detect languages: ${error.message}`);
+    return {};
+  }
+}
+
+async function getDefaultBranch(repository) {
+  try {
+    return await commandOutput('gh', ['api', `repos/${repository.fullName}`, '--jq', '.default_branch']);
+  } catch (error) {
+    console.warn(`⚠️  Could not determine default branch: ${error.message}`);
+    return null;
+  }
+}
+
+async function getLatestCommit(repository, branch) {
+  if (!branch) return null;
+  try {
+    const json = await commandOutput('gh', ['api', `repos/${repository.fullName}/commits/${branch}`, '--jq', '{sha: .sha, message: .commit.message, url: .html_url}']);
+    return JSON.parse(json);
+  } catch (error) {
+    console.warn(`⚠️  Could not fetch latest commit: ${error.message}`);
+    return null;
+  }
+}
+
+const RUNS_JQ = '[.workflow_runs[] | {name: .name, status: .status, conclusion: .conclusion, html_url: .html_url, head_sha: .head_sha}]';
+
+async function getRunsForCommit(repository, sha) {
+  if (!sha) return [];
+  try {
+    const json = await commandOutput('gh', ['api', `repos/${repository.fullName}/actions/runs?head_sha=${sha}&per_page=100`, '--jq', RUNS_JQ]);
+    const parsed = JSON.parse(json);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (error) {
+    console.warn(`⚠️  Could not fetch CI/CD runs: ${error.message}`);
+    return [];
+  }
+}
+
+async function getRecentBranchRuns(repository, branch) {
+  if (!branch) return [];
+  try {
+    const json = await commandOutput('gh', ['api', `repos/${repository.fullName}/actions/runs?branch=${encodeURIComponent(branch)}&per_page=20`, '--jq', RUNS_JQ]);
+    const parsed = JSON.parse(json);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (error) {
+    console.warn(`⚠️  Could not fetch recent CI/CD runs for branch ${branch}: ${error.message}`);
+    return [];
+  }
+}
+
+function resolveSolveCommand() {
+  return path.join(__dirname, 'solve.mjs');
+}
+
+async function main() {
+  const rawArgs = process.argv.slice(2);
+
+  if (rawArgs.includes('--version')) {
+    const { getVersion } = await import('./version.lib.mjs');
+    try {
+      console.log(await getVersion());
+    } catch {
+      console.error('Error: Unable to determine version');
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (rawArgs.length === 0 || rawArgs.includes('--help') || rawArgs.includes('-h')) {
+    printHelp();
+    process.exit(rawArgs.length === 0 ? 1 : 0);
+  }
+
+  const parsed = partitionFixArgs(rawArgs);
+
+  if (!parsed.ciCd) {
+    console.error('❌ /fix currently supports only --ci-cd mode. Pass --ci-cd to continue.');
+    process.exit(1);
+  }
+
+  if (!parsed.repository) {
+    console.error('❌ Missing or invalid GitHub repository URL. Provide it as the first argument, e.g. fix.mjs https://github.com/owner/repo --ci-cd');
+    process.exit(1);
+  }
+
+  const repository = parsed.repository;
+  console.log(`🔧 /fix --ci-cd for ${repository.fullName}`);
+
+  const [languages, defaultBranch] = await Promise.all([detectLanguages(repository), getDefaultBranch(repository)]);
+  const commit = await getLatestCommit(repository, defaultBranch);
+  let runs = await getRunsForCommit(repository, commit?.sha);
+  let runsSource = 'commit';
+
+  // Release/tag commits frequently produce no runs of their own. Fall back to
+  // the most recent runs on the default branch so the issue stays actionable.
+  if (runs.length === 0) {
+    const branchRuns = await getRecentBranchRuns(repository, defaultBranch);
+    if (branchRuns.length > 0) {
+      runs = branchRuns;
+      runsSource = 'branch';
+    }
+  }
+
+  const { total, failing } = summarizeRunFailures(runs);
+  console.log(`   Default branch: ${defaultBranch || 'unknown'}`);
+  console.log(`   Latest commit:  ${commit?.sha ? commit.sha.slice(0, 7) : 'unknown'}`);
+  console.log(`   CI/CD runs:     ${total} (${failing} not passing)${runsSource === 'branch' ? ' [recent branch runs]' : ''}`);
+
+  const title = buildCiCdIssueTitle();
+  const body = buildCiCdIssueBody({ repository, defaultBranch, commit, runs, languages, runsSource });
+
+  if (parsed.dryRun) {
+    console.log('\n--- DRY RUN: issue that would be created ---\n');
+    console.log(`Title: ${title}\n`);
+    console.log(body);
+    return;
+  }
+
+  console.log('\n📝 Creating remediation issue...');
+  const { createTaskIssue } = await import('./task.issue-creation.lib.mjs');
+  const issue = await createTaskIssue({
+    repository,
+    title,
+    body,
+    // The Bug type is what makes /solve --deep-analysis emit the root-cause
+    // instructions this body omits (issue #1733).
+    issueType: CI_CD_ISSUE_TYPE,
+    labels: [...CI_CD_ISSUE_LABELS],
+    run: runCommand,
+    log: message => console.log(message),
+  });
+  console.log(`✅ Created issue: ${issue.url}`);
+
+  if (!parsed.runSolve) {
+    console.log('ℹ️  --no-solve set; skipping /solve. Run it manually with:');
+    console.log(`   solve ${buildSolveArgs({ issueUrl: issue.url, passthrough: parsed.passthrough }).join(' ')}`);
+    return;
+  }
+
+  const solveArgs = buildSolveArgs({ issueUrl: issue.url, passthrough: parsed.passthrough });
+  const solveCommand = resolveSolveCommand();
+  console.log(`\n🚀 Starting /solve: solve ${solveArgs.join(' ')}`);
+
+  await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [solveCommand, ...solveArgs], {
+      stdio: 'inherit',
+      env: process.env,
+    });
+    child.on('error', reject);
+    child.on('close', code => {
+      if (code === 0) resolve();
+      else reject(new Error(`solve exited with code ${code}`));
+    });
+  });
+}
+
+main().catch(error => {
+  console.error(`❌ ${error.message}`);
+  process.exit(1);
+});

package/src/github-merge-ci-wait.lib.mjs

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+/**
+ * GitHub Merge CI Wait Loops
+ *
+ * The long-running CI polling loops used by the /merge command.
+ * Split from github-merge.lib.mjs to maintain file size limits.
+ *
+ * Every wait here is cancellable: the poll delay is slept in short steps via
+ * `cancellableSleep`, so pressing the Cancel button takes effect within ~100ms
+ * instead of after a full poll interval.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2072
+ */
+
+import { checkPRCIStatus, getActiveBranchRuns } from './github-merge.lib.mjs';
+import { cancellableSleep } from './interruptible-sleep.lib.mjs';
+
+/**
+ * Wait for CI/CD to complete with polling
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} prNumber - Pull request number
+ * @param {Object} options - Wait options
+ * @param {number} options.timeout - Maximum wait time in ms (default: 30 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, status: string, error: string|null}>}
+ */
+export async function waitForCI(owner, repo, prNumber, options = {}, verbose = false) {
+  const {
+    timeout = 30 * 60 * 1000,
+    pollInterval = 30 * 1000,
+    onStatusUpdate = null,
+    // Issue #1269: Add timeout for callback to prevent infinite blocking
+    callbackTimeout = 60 * 1000, // 1 minute max for callback
+    isCancelled = null, // Issue #1407: Support early exit when cancellation is requested
+  } = options;
+
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeout) {
+    // Issue #1407: Check for cancellation before each poll to allow early exit
+    if (isCancelled?.()) return { success: false, status: 'cancelled', error: 'Operation was cancelled' };
+
+    let ciStatus;
+    try {
+      ciStatus = await checkPRCIStatus(owner, repo, prNumber, verbose);
+    } catch (error) {
+      // Issue #1269: Log and continue on CI check errors instead of crashing
+      console.error(`[ERROR] /merge: Error checking CI status for PR #${prNumber}: ${error.message}`);
+      verbose && console.error(`[VERBOSE] /merge: CI check error details:`, error);
+      // Wait and retry
+      await cancellableSleep(pollInterval, isCancelled);
+      continue;
+    }
+
+    if (onStatusUpdate) {
+      // Issue #1269: Wrap callback with timeout to prevent infinite blocking; #1346: capture and clear timeout handle to prevent dangling timer
+      try {
+        let callbackTimeoutId;
+        await Promise.race([
+          onStatusUpdate(ciStatus),
+          new Promise((_, reject) => {
+            callbackTimeoutId = setTimeout(() => reject(new Error(`Callback timeout after ${callbackTimeout}ms`)), callbackTimeout);
+          }),
+        ]).finally(() => clearTimeout(callbackTimeoutId));
+      } catch (callbackError) {
+        // Issue #1269: Log callback errors but continue processing
+        console.error(`[ERROR] /merge: Status update callback failed for PR #${prNumber}: ${callbackError.message}`);
+        verbose && console.error(`[VERBOSE] /merge: Callback error details:`, callbackError);
+        // Continue processing even if callback fails - don't let UI issues block merging
+      }
+    }
+
+    if (ciStatus.status === 'success') {
+      return { success: true, status: 'success', error: null };
+    }
+
+    if (ciStatus.status === 'failure') {
+      return { success: false, status: 'failure', error: 'CI checks failed' };
+    }
+
+    if (ciStatus.status === 'terminal_github_entity_error') {
+      return {
+        success: false,
+        status: 'terminal_github_entity_error',
+        error: ciStatus.error || 'GitHub repository, pull request, issue, or branch is no longer accessible',
+      };
+    }
+
+    if (ciStatus.status === 'pending') {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: Waiting for CI... (${Math.round((Date.now() - startTime) / 1000)}s elapsed)`);
+      }
+      await cancellableSleep(pollInterval, isCancelled);
+      continue;
+    }
+
+    // Unknown status - wait and retry
+    await cancellableSleep(pollInterval, isCancelled);
+  }
+
+  return { success: false, status: 'timeout', error: 'CI check timeout exceeded' };
+}
+
+/**
+ * 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, isCancelled = 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) {
+    if (isCancelled?.()) return { success: false, waitedForRuns: totalWaitedRuns > 0, completedRuns: totalWaitedRuns, error: 'Operation was cancelled' };
+    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 cancellableSleep(pollInterval, isCancelled);
+      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 cancellableSleep(pollInterval, isCancelled);
+  }
+
+  // Issue #2072: a cancel landing as the timeout expires must still report 'cancelled'
+  // rather than falling through to the extra API round-trip below.
+  if (isCancelled?.()) return { success: false, waitedForRuns: totalWaitedRuns > 0, completedRuns: totalWaitedRuns, error: 'Operation was cancelled' };
+
+  // Timeout reached
+  // Issue #1722: if the final check throws, do NOT silently report "ready".
+  // Treat it the same as still-active (force a timeout failure), so /merge
+  // waits/retries instead of merging on top of a still-running CI run.
+  let finalCheck;
+  try {
+    finalCheck = await getActiveBranchRuns(owner, repo, branch, verbose);
+  } catch (error) {
+    return {
+      success: false,
+      waitedForRuns: true,
+      completedRuns: totalWaitedRuns,
+      error: `Timeout reached and final CI check failed on ${branch}: ${error.message}`,
+    };
+  }
+  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,
+  };
+}
+
+export default {
+  waitForCI,
+  waitForBranchCI,
+};

package/src/github-merge-ci.lib.mjs

@@ -12,6 +12,7 @@ import { getWorkflowRunsForSha } from './github-merge.lib.mjs';
 import { promisify } from 'util';
 import { exec as execCallback } from 'child_process';
 import { ghWithRateLimitRetry } from './github-rate-limit.lib.mjs';
+import { cancellableSleep } from './interruptible-sleep.lib.mjs';
 
 const execRaw = promisify(execCallback);
 // Issue #1726: every gh call must be rate-limit safe.
@@ -54,7 +55,7 @@ export async function waitForCommitCI(owner, repo, sha, options = {}, verbose =
       runs = await getWorkflowRunsForSha(owner, repo, sha, verbose);
     } catch (error) {
       console.error(`[ERROR] /merge: Error checking commit CI: ${error.message}`);
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      await cancellableSleep(pollInterval, isCancelled);
       continue;
     }
 
@@ -71,7 +72,7 @@ export async function waitForCommitCI(owner, repo, sha, options = {}, verbose =
       if (verbose) {
         console.log(`[VERBOSE] /merge: No CI runs yet for commit ${sha.substring(0, 7)} (attempt ${noRunsIterations}/${MAX_NO_RUNS_ITERATIONS}). Waiting...`);
       }
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      await cancellableSleep(pollInterval, isCancelled);
       continue;
     }
 
@@ -134,7 +135,13 @@ export async function waitForCommitCI(owner, repo, sha, options = {}, verbose =
       console.log(`[VERBOSE] /merge: Waiting for ${inProgressRuns.length} CI run(s) to complete... (${elapsedSec}s elapsed)`);
     }
 
-    await new Promise(resolve => setTimeout(resolve, pollInterval));
+    await cancellableSleep(pollInterval, isCancelled);
+  }
+
+  // Issue #2072: a cancel that lands while the timeout is expiring must still report
+  // 'cancelled' rather than falling through to an extra API round-trip below.
+  if (isCancelled?.()) {
+    return { success: false, status: 'cancelled', runs: [], failedRuns: [], error: 'Operation was cancelled' };
   }
 
   // Timeout reached

package/src/github-merge-repo-actions.lib.mjs

@@ -13,6 +13,7 @@ import { promisify } from 'util';
 import { exec as execCallback } from 'child_process';
 import { githubLimits } from './config.lib.mjs';
 import { ghWithRateLimitRetry } from './github-rate-limit.lib.mjs';
+import { cancellableSleep } from './interruptible-sleep.lib.mjs';
 const execRaw = promisify(execCallback);
 // Issue #1722: raise exec maxBuffer above Node's 1 MB default for paginated gh
 // API responses (workflow runs can easily exceed that on busy repos).
@@ -70,15 +71,21 @@ export async function getAllActiveRepoRuns(owner, repo, verbose = false) {
  * @param {string} owner - Repository owner
  * @param {string} repo - Repository name
  * @param {Object} options - Wait options (timeout, pollInterval, onStatusUpdate)
+ * @param {Function} [options.isCancelled] - Issue #2072: polled during the poll delay so a
+ *   cancel (or SIGINT/SIGTERM) aborts the wait instead of sleeping out a full 5-minute interval
  * @param {boolean} verbose - Whether to log verbose output
  * @returns {Promise<{success: boolean, waitedForRuns: boolean, timedOut: boolean, remainingRuns: Array}>}
  */
 export async function waitForAllRepoActions(owner, repo, options = {}, verbose = false) {
-  const { timeout = 45 * 60 * 1000, pollInterval = 5 * 60 * 1000, onStatusUpdate = null } = options;
+  const { timeout = 45 * 60 * 1000, pollInterval = 5 * 60 * 1000, onStatusUpdate = null, isCancelled = null } = options;
   const startTime = Date.now();
   let peakRunCount = 0;
 
   while (Date.now() - startTime < timeout) {
+    // Issue #2072: no stage of the merge flow may hold up a cancel.
+    if (isCancelled?.()) {
+      return { success: false, waitedForRuns: peakRunCount > 0, timedOut: false, cancelled: true, remainingRuns: [] };
+    }
     let active;
     try {
       active = await getAllActiveRepoRuns(owner, repo, verbose);
@@ -86,7 +93,7 @@ export async function waitForAllRepoActions(owner, repo, options = {}, verbose =
       // Issue #1722: do not silently treat fetch errors as "no active runs".
       // Log and retry on the next poll instead.
       console.error(`[ERROR] repo-actions: Error checking repo CI: ${error.message}`);
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      await cancellableSleep(pollInterval, isCancelled);
       continue;
     }
     if (onStatusUpdate) {
@@ -100,7 +107,11 @@ export async function waitForAllRepoActions(owner, repo, options = {}, verbose =
       return { success: true, waitedForRuns: peakRunCount > 0, timedOut: false, remainingRuns: [] };
     }
     peakRunCount = Math.max(peakRunCount, active.count);
-    await new Promise(resolve => setTimeout(resolve, pollInterval));
+    await cancellableSleep(pollInterval, isCancelled);
+  }
+  // Issue #2072: a cancel landing as the timeout expires must not trigger another API round-trip.
+  if (isCancelled?.()) {
+    return { success: false, waitedForRuns: peakRunCount > 0, timedOut: false, cancelled: true, remainingRuns: [] };
   }
   // Issue #1722: if the timeout-final check throws, surface that as an error
   // rather than reporting "no remaining runs".