@link-assistant/hive-mind 1.69.3 → 1.69.5

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.config.lib.mjs

@@ -572,8 +572,23 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: "Working language passed to the AI tool (Claude/Codex/etc). Used as the tool's preferred language for translations and prompts. Defaults to --language.",
     choices: ['en', 'ru', 'zh', 'hi'],
   },
+  'prompt-language': {
+    type: 'string',
+    description: 'Deprecated alias for --work-language.',
+    choices: ['en', 'ru', 'zh', 'hi'],
+    hidden: true,
+  },
+  'auto-language': {
+    type: 'boolean',
+    description: 'Experimental and disabled by default. Automatically detect the target issue or pull request language and set the AI work language to English or Russian when one language has more than 51% of all words. Explicit --work-language or --prompt-language takes precedence.',
+    default: false,
+  },
 };
 
+function hasRawOption(rawArgs, optionName) {
+  return rawArgs.some(arg => arg === optionName || arg.startsWith(`${optionName}=`));
+}
+
 // Function to create yargs configuration - avoids duplication
 export const createYargsConfig = yargsInstance => {
   let config = yargsInstance
@@ -749,6 +764,12 @@ export const parseArguments = async (yargs = getLinoYargsFactory(), hideBinFn =
     if (argv.disableIssueAutoCreationOnError) {
       argv.disableReportIssue = true;
     }
+    const workLanguageExplicit = hasRawOption(rawArgs, '--work-language');
+    const promptLanguageExplicit = hasRawOption(rawArgs, '--prompt-language');
+    if (argv.promptLanguage && !workLanguageExplicit) {
+      argv.workLanguage = argv.promptLanguage;
+    }
+    argv._workLanguageExplicit = workLanguageExplicit || promptLanguageExplicit;
   }
 
   // --finalize normalization

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

@@ -84,16 +84,6 @@ try {
 }
 global.verboseMode = argv.verbose;
 
-// Initialize i18n based on --language / --ui-language / --work-language
-// (or detected system locale). --language sets both tracks by default;
-// --ui-language and --work-language can override each track independently.
-const { initI18n } = await import('./i18n.lib.mjs');
-await initI18n({
-  language: argv.language,
-  uiLanguage: argv.uiLanguage,
-  workLanguage: argv.workLanguage,
-});
-
 setupVerboseLogInterceptor(); // Issue #1466: capture [VERBOSE] output in log files
 setupStdioLogInterceptor(); // Issue #1549: capture ALL terminal output in log file
 
@@ -180,6 +170,18 @@ if (isIssueUrl) {
 }
 cleanupContext.owner = owner;
 cleanupContext.repo = repo;
+if (argv.autoLanguage) {
+  const { applyAutoLanguageToArgv } = await import('./auto-language.lib.mjs');
+  await applyAutoLanguageToArgv({ argv, githubLib, owner, repo, number: urlNumber, isIssueUrl, isPrUrl, log });
+}
+// Initialize i18n based on --language / --ui-language / --work-language
+// (or detected system locale). --auto-language may set only the work track.
+const { initI18n } = await import('./i18n.lib.mjs');
+await initI18n({
+  language: argv.language,
+  uiLanguage: argv.uiLanguage,
+  workLanguage: argv.workLanguage,
+});
 // Setup unhandled error handlers to ensure log path is always shown
 const errorHandlerOptions = {
   log,
@@ -576,7 +578,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) {