@link-assistant/hive-mind 1.69.3 → 1.69.4

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @link-assistant/hive-mind
 
+## 1.69.4
+
+### Patch Changes
+
+- 105172b: Fix auto-PR creation failure on fork-of-fork repositories. When `solve` runs against an issue in a repository that is itself a GitHub fork and the user has direct write access, `gh pr create` previously resolved the base repository to the upstream parent (because `gh repo clone` auto-adds an `upstream` remote for forks), producing a misleading "No commits between" error. The auto-PR command builder now always passes `--repo ${owner}/${repo}` so the PR is created against the explicit target. The fatal error block also detects the failure mode and prints a fork-aware diagnostic with the resolved remotes and a manual recovery command.
+- d89243f: Stabilize the version-info timing test that broke CI/CD by using the same 30 second reasonable bound as the broader version-info structure test. The version collector still runs commands in parallel, but individual commands can legally spend 5 seconds on a timeout and then another 5 seconds on a fallback, so the previous 10 second wall-clock assertion was too tight for GitHub-hosted runners.
+- db56b5a: Sync custom fork base branches proactively. When a user passes `--base-branch` in fork mode, the solver now copies the requested branch from `upstream` to the user's fork before creating the issue branch, and falls back to the same recovery if branch creation still trips on a missing `origin/<baseBranch>`. This prevents the `fatal: 'origin/<baseBranch>' is not a commit` failure that surfaced for issue #1772 when an existing fork pre-dated upstream's custom branch.
+
 ## 1.69.3
 
 ### Patch Changes

package/package.json

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

package/src/solve.auto-pr-fork-diagnostic.lib.mjs

@@ -0,0 +1,70 @@
+/**
+ * Fork-aware diagnostic for the auto-PR fatal error block.
+ *
+ * Issue #1774: when `gh pr create` fails with "No commits between" or
+ * "Head sha can't be blank", the most common cause is base-repo resolution
+ * picking the upstream parent of a fork (because `gh repo clone` auto-adds
+ * an `upstream` remote for forks). This helper inspects the local remotes
+ * and prints a self-explanatory diagnostic.
+ *
+ * Extracted from solve.auto-pr.lib.mjs to keep that file under the 1500-line
+ * CI cap.
+ */
+
+/**
+ * @param {object} params
+ * @param {string} params.errorMessage - prError.message from the auto-PR catch.
+ * @param {string} params.tempDir
+ * @param {string} params.owner
+ * @param {string} params.repo
+ * @param {string} params.defaultBranch
+ * @param {string} params.branchName
+ * @param {string|number} params.issueNumber
+ * @param {(msg: string, opts?: object) => Promise<void>} params.log
+ * @param {Function} params.$ - command-stream tagged function from solve.
+ * @param {Function} params.reportError
+ */
+export async function emitForkAwareDiagnostic({ errorMessage, tempDir, owner, repo, defaultBranch, branchName, issueNumber, log, $, reportError }) {
+  const errMsg = errorMessage || '';
+  if (!errMsg.includes('No commits between') && !errMsg.includes("Head sha can't be blank")) {
+    return;
+  }
+
+  try {
+    const remotesResult = await $({ cwd: tempDir, silent: true })`git remote -v`;
+    const remotesText = remotesResult.code === 0 ? remotesResult.stdout.toString().trim() : '';
+    const originLine = remotesText.split('\n').find(line => line.startsWith('origin\t') && line.includes('(fetch)'));
+    const upstreamLine = remotesText.split('\n').find(line => line.startsWith('upstream\t') && line.includes('(fetch)'));
+
+    await log('  🔬 Fork-aware diagnostic (Issue #1774):');
+    await log(`     Target repository:      ${owner}/${repo}`);
+    if (originLine) {
+      await log(`     origin remote:          ${originLine.replace(/^origin\t/, '').replace(/\s+\(fetch\)$/, '')}`);
+    }
+    if (upstreamLine) {
+      await log(`     upstream remote:        ${upstreamLine.replace(/^upstream\t/, '').replace(/\s+\(fetch\)$/, '')}`);
+      await log('');
+      await log('     `gh repo clone` automatically adds an `upstream` remote when the');
+      await log('     cloned repository is a fork. Without --repo, `gh pr create`');
+      await log('     resolves the base to that upstream parent instead of the fork');
+      await log('     where this branch was pushed, producing the misleading');
+      await log('     "No commits between" error. This version already pins --repo');
+      await log('     to the explicit target, so a fresh `solve` invocation should');
+      await log('     succeed. See docs/case-studies/issue-1774/README.md.');
+    } else {
+      await log('     (no `upstream` remote found locally)');
+    }
+    await log('');
+    await log('     Manual recovery command:');
+    await log(`     gh pr create --draft --base ${defaultBranch} --head ${branchName} --repo ${owner}/${repo}`);
+    await log('');
+  } catch (diagError) {
+    reportError(diagError, {
+      context: 'auto_pr_fork_diagnostic',
+      issueNumber,
+      operation: 'collect_fork_diagnostic',
+    });
+  }
+}
+
+export default { emitForkAwareDiagnostic };

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

@@ -5,6 +5,7 @@
 
 import { closingIssueNumbersContain, parseClosingIssueNumbers } from './pr-issue-linking.lib.mjs';
 import { buildPushRejectionExplanation, getRemoteBranchDivergenceSnapshot, synchronizeExistingIssueBranchBeforeAutoPrCreation } from './solve.branch-divergence.lib.mjs';
+import { emitForkAwareDiagnostic } from './solve.auto-pr-fork-diagnostic.lib.mjs';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller. Issue #1756: execGhWithRetry retries on transient 5xx (504) too.
 
@@ -1112,13 +1113,15 @@ ${prBody}`,
           // Build command with optional assignee and handle forks
           // Note: targetBranch is already defined above
           // IMPORTANT: Use --title-file instead of --title to avoid shell parsing issues with special characters
+          // --repo is always passed (Issue #1774) so a fork-of-fork target
+          // does not silently switch to the upstream parent via `gh repo clone`'s
+          // auto-added `upstream` remote.
           let command;
           if (argv.fork && forkedRepo) {
-            // For forks, specify the full head reference
             const forkUser = forkedRepo.split('/')[0];
             command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${forkUser}:${branchName} --repo ${owner}/${repo}`;
           } else {
-            command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${branchName}`;
+            command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${branchName} --repo ${owner}/${repo}`;
           }
           // Only add assignee if user has permissions
           if (currentUser && canAssign) {
@@ -1157,12 +1160,12 @@ ${prBody}`,
               });
               await log('     Retrying PR creation without assignee...');
 
-              // Rebuild command without --assignee flag
+              // Rebuild command without --assignee flag (Issue #1774: --repo always pinned)
               if (argv.fork && forkedRepo) {
                 const forkUser = forkedRepo.split('/')[0];
                 command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${forkUser}:${branchName} --repo ${owner}/${repo}`;
               } else {
-                command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${branchName}`;
+                command = `cd "${tempDir}" && gh pr create --draft --title "$(cat '${prTitleFile}')" --body-file "${prBodyFile}" --base ${targetBranch} --head ${branchName} --repo ${owner}/${repo}`;
               }
 
               if (argv.verbose) {
@@ -1460,6 +1463,10 @@ ${prBody}`,
     await log('  🔍 What happened:');
     await log(`     ${prError.message}`);
     await log('');
+
+    // Issue #1774: fork-base resolution failure diagnostic.
+    await emitForkAwareDiagnostic({ errorMessage: prError.message, tempDir, owner, repo, defaultBranch, branchName, issueNumber, log, $, reportError });
+
     await log('  💡 The solve command cannot continue without a pull request.');
     await log('');
     await log('  🔧 How to fix:');
@@ -1470,14 +1477,14 @@ ${prBody}`,
     await log('');
     await log('  Option 2: Create PR manually first');
     await log(`     cd ${tempDir}`);
-    await log(`     gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}"`);
+    await log(`     gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}" --repo ${owner}/${repo}`);
     await log(`     Then use: ./solve.mjs "${issueUrl}" --continue`);
     await log('');
     await log('  Option 3: Debug the issue');
     await log(`     cd ${tempDir}`);
     await log('     git status');
     await log('     git log --oneline -5');
-    await log('     gh pr create --draft  # Try manually to see detailed error');
+    await log(`     gh pr create --draft --repo ${owner}/${repo}  # Try manually to see detailed error`);
     await log('');
 
     // Re-throw the error to stop execution - use prError.message directly

package/src/solve.branch.lib.mjs

@@ -205,6 +205,105 @@ export function validateBranchInArgs(args) {
   return null;
 }
 
+function isMissingOriginBaseRefError(errorOutput, baseBranch) {
+  return errorOutput.includes(`origin/${baseBranch}`) && (errorOutput.includes('is not a commit') || errorOutput.includes('not a valid object name') || errorOutput.includes('unknown revision'));
+}
+
+async function hasUpstreamRemote(tempDir, $) {
+  const result = await $({ cwd: tempDir })`git remote get-url upstream 2>/dev/null`;
+  return result.code === 0;
+}
+
+async function originHasBaseBranch(tempDir, baseBranch, $) {
+  const result = await $({ cwd: tempDir })`git show-ref --verify --quiet refs/remotes/origin/${baseBranch}`;
+  return result.code === 0;
+}
+
+/**
+ * Ensure the requested base branch exists on the fork (origin) by syncing it from upstream.
+ * Returns true if origin/<baseBranch> exists at the end of the call (was already there or was synced).
+ * Returns false if syncing was attempted and failed (caller should propagate the original error).
+ *
+ * Design note (issue #1772 follow-up): when working in fork mode against a public upstream, the user
+ * expects their fork to mirror the upstream branch they want to base work on. Before relying on
+ * git's create-from-origin path, we proactively copy the upstream branch into the fork so that the
+ * branch creation, the later PR comparison, and any ahead/behind checks all see a consistent state.
+ */
+async function ensureBaseBranchInFork({ baseBranch, tempDir, log, formatAligned, $, reason = 'proactive' }) {
+  if (!(await hasUpstreamRemote(tempDir, $))) {
+    return false;
+  }
+
+  if (reason === 'proactive') {
+    await log(`${formatAligned('🔄', 'Syncing base branch:', `ensuring origin/${baseBranch} matches upstream`)}`);
+  } else {
+    await log(`${formatAligned('🔄', 'Base branch not in fork:', `checking upstream/${baseBranch}`)}`);
+  }
+
+  const fetchResult = await $({ cwd: tempDir })`git fetch upstream`;
+  if (fetchResult.code !== 0) {
+    await log(`${formatAligned('⚠️', 'Warning:', 'Failed to fetch upstream base branch')}`, { level: 'warning' });
+    return false;
+  }
+
+  const upstreamRefResult = await $({ cwd: tempDir })`git show-ref --verify --quiet refs/remotes/upstream/${baseBranch}`;
+  if (upstreamRefResult.code !== 0) {
+    await log(`${formatAligned('⚠️', 'Warning:', `Base branch not found in upstream/${baseBranch}`)}`, { level: 'warning' });
+    return false;
+  }
+
+  await log(`${formatAligned('✅', 'Base branch found:', `upstream/${baseBranch}`)}`);
+  const checkoutBaseResult = await $({ cwd: tempDir })`git checkout -B ${baseBranch} upstream/${baseBranch}`;
+  if (checkoutBaseResult.code !== 0) {
+    await log(`${formatAligned('⚠️', 'Warning:', `Failed to prepare local ${baseBranch}`)}`, { level: 'warning' });
+    return false;
+  }
+
+  await log(`${formatAligned('🔄', 'Pushing to fork:', `${baseBranch} branch`)}`);
+  const pushBaseResult = await $({ cwd: tempDir })`git push origin ${baseBranch} 2>&1`;
+  if (pushBaseResult.code !== 0) {
+    const pushError = (pushBaseResult.stderr || pushBaseResult.stdout || 'Unknown error').toString().trim();
+    await log(`${formatAligned('⚠️', 'Warning:', `Failed to push ${baseBranch} to fork`)}`, { level: 'warning' });
+    if (pushError) await log(`${formatAligned('', 'Push error:', pushError)}`, { level: 'warning' });
+    return false;
+  }
+
+  await log(`${formatAligned('✅', 'Fork updated:', `Custom base branch ${baseBranch} pushed to fork`)}`);
+  return true;
+}
+
+async function proactivelySyncBaseBranchToFork({ baseBranch, defaultBranch, tempDir, log, formatAligned, $ }) {
+  // Default branch is already synced by setupUpstreamAndSync; skip to avoid redundant work.
+  if (baseBranch === defaultBranch) {
+    return;
+  }
+
+  if (!(await hasUpstreamRemote(tempDir, $))) {
+    return;
+  }
+
+  if (await originHasBaseBranch(tempDir, baseBranch, $)) {
+    return;
+  }
+
+  await ensureBaseBranchInFork({ baseBranch, tempDir, log, formatAligned, $, reason: 'proactive' });
+}
+
+async function retryBranchCreationFromUpstreamBase({ checkoutResult, branchName, baseBranch, tempDir, log, formatAligned, $ }) {
+  const errorOutput = `${checkoutResult.stderr || ''}${checkoutResult.stdout || ''}`;
+  if (!isMissingOriginBaseRefError(errorOutput, baseBranch)) {
+    return checkoutResult;
+  }
+
+  const synced = await ensureBaseBranchInFork({ baseBranch, tempDir, log, formatAligned, $, reason: 'reactive' });
+  if (!synced) {
+    return checkoutResult;
+  }
+
+  await log(`${formatAligned('🌿', 'Retrying branch:', `${branchName} from ${baseBranch}`)}`);
+  return await $({ cwd: tempDir })`git checkout -b ${branchName} ${baseBranch}`;
+}
+
 export async function createOrCheckoutBranch({ isContinueMode, prBranch, issueNumber, tempDir, defaultBranch, argv, log, formatAligned, $, crypto, owner, repo, prNumber }) {
   // Create a branch for the issue or checkout existing PR branch
   let branchName;
@@ -234,10 +333,33 @@ export async function createOrCheckoutBranch({ isContinueMode, prBranch, issueNu
 
     await log(`\n${formatAligned('🌿', 'Creating branch:', `${branchName} from ${baseBranch} (${branchSource})`)}`);
 
+    // Issue #1772: when a custom base branch is requested in fork mode, proactively copy it from
+    // upstream to the fork before branch creation. The fork's `gh repo fork` snapshot may pre-date
+    // upstream's custom branches, so we cannot assume origin already has the requested base.
+    if (argv.baseBranch) {
+      await proactivelySyncBaseBranchToFork({
+        baseBranch,
+        defaultBranch,
+        tempDir,
+        log,
+        formatAligned,
+        $,
+      });
+    }
+
     // IMPORTANT: Don't use 2>&1 here as it can interfere with exit codes
     // Git checkout -b outputs to stderr but that's normal
     // Create branch from the specified base branch (origin/baseBranch)
     checkoutResult = await $({ cwd: tempDir })`git checkout -b ${branchName} origin/${baseBranch}`;
+    checkoutResult = await retryBranchCreationFromUpstreamBase({
+      checkoutResult,
+      branchName,
+      baseBranch,
+      tempDir,
+      log,
+      formatAligned,
+      $,
+    });
   }
 
   if (checkoutResult.code !== 0) {

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

@@ -175,7 +175,10 @@ export const createUnhandledRejectionHandler = options => {
 /**
  * Handles the case where no PR is available when one is required
  */
-export const handleNoPrAvailableError = async ({ isContinueMode, tempDir, issueNumber, issueUrl, log, formatAligned }) => {
+export const handleNoPrAvailableError = async ({ isContinueMode, tempDir, issueNumber, issueUrl, owner, repo, log, formatAligned }) => {
+  // Issue #1774: when an explicit target repo is known, surface --repo in the
+  // recovery hint so users do not hit the same fork-base resolution trap.
+  const repoFlag = owner && repo ? ` --repo ${owner}/${repo}` : '';
   await log('');
   await log(formatAligned('❌', 'FATAL ERROR:', 'No pull request available'), { level: 'error' });
   await log('');
@@ -199,7 +202,7 @@ export const handleNoPrAvailableError = async ({ isContinueMode, tempDir, issueN
   await log('');
   await log('  Option 1: Create PR manually and use --continue');
   await log(`     cd ${tempDir}`);
-  await log(`     gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}"`);
+  await log(`     gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}"${repoFlag}`);
   await log('     # Then use the PR URL with solve.mjs');
   await log('');
   await log('  Option 2: Start fresh without continue mode');

package/src/solve.mjs

@@ -576,7 +576,7 @@ try {
   // CRITICAL: Validate that we have a PR number when required
   // This prevents continuing without a PR when one was supposed to be created
   if ((isContinueMode || argv.autoPullRequestCreation) && !prNumber) {
-    await handleNoPrAvailableError({ isContinueMode, tempDir, issueNumber, issueUrl, log, formatAligned });
+    await handleNoPrAvailableError({ isContinueMode, tempDir, issueNumber, issueUrl, owner, repo, log, formatAligned });
   }
 
   if (isContinueMode) {