@link-assistant/hive-mind 2.1.8 → 2.1.9

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 2.1.9
+
+### Patch Changes
+
+- 5559c5e: Check all replacement repository branch tips before deleting a non-fork fork replacement, and report concrete branch-only commits when deletion is unsafe.
+
 ## 2.1.8
 
 ### Patch Changes

package/package.json

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

package/src/solve.pre-pr-failure-notifier.lib.mjs

@@ -1,5 +1,5 @@
 import { getTrackedToolCommentIds, postTrackedComment, SOLUTION_DRAFT_FAILED_MARKER } from './tool-comments.lib.mjs';
-import { extractForkReplacementBlockedDetails, isForkReplacementBlockedReason } from './solve.repository-recovery-message.lib.mjs';
+import { extractForkReplacementBlockedDetails, isForkReplacementBlockedReason, GITHUB_FORK_SUPPORT_URL } from './solve.repository-recovery-message.lib.mjs';
 import { FORK_DIVERGENCE_RESOLUTION_OPTION, buildForkDivergenceFailureActionSection } from './solve.branch-divergence.lib.mjs';
 
 export { FORK_DIVERGENCE_RESOLUTION_OPTION };
@@ -41,6 +41,7 @@ export function buildPrePullRequestFailureActionSection(reason = '') {
 - It could not prove whether the existing repository has unique commits, so it did not delete it automatically.
 
 ### What you can do
+- Recover the fork without deleting: if \`${repository}\` was a fork of \`${upstream}\` that GitHub detached (for example after a private/public visibility change), ask GitHub Support at ${GITHUB_FORK_SUPPORT_URL} ("Attach, detach or reroute forks") to re-attach it. Detachment from a visibility change is documented as permanent, so this is not guaranteed, and while detached the repository cannot open a cross-repository pull request to \`${upstream}\`.
 - Repository owner path: back up any needed work, then delete, rename, archive, or repair \`${repository}\` in GitHub and rerun the solver.
 - External-owner path: ask the repository owner or a Hive Mind administrator to clean it up and rerun the solver.
 - Use \`--allow-force-non-fork-repository-deletion\` only after confirming that deleting \`${repository}\` is acceptable and any unique commits can be lost.`;

package/src/solve.repository-recovery-message.lib.mjs

@@ -26,27 +26,47 @@ export function buildForkReplacementSafetyCheckDescription({ aheadBy = null, com
   return 'Hive Mind could not prove the repository has no unique commits.';
 }
 
-export function buildForkReplacementBlockedReason({ existingRepository, expectedUpstream, relationshipDescription, safetyCheckDescription } = {}) {
+// GitHub Support's self-service fork request workflow. See
+// https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/detaching-a-fork
+export const GITHUB_FORK_SUPPORT_URL = 'https://support.github.com/request/fork';
+
+/**
+ * Explain how to recover the GitHub fork relationship without deleting the
+ * existing repository. GitHub detaches a fork from its upstream network when the
+ * repository's visibility is toggled (for example private -> public), and that
+ * detachment is documented as permanent with no API/self-service reattachment.
+ * The only non-deletion path is a GitHub Support request. See issue #2019.
+ */
+export function buildDetachedForkRecoveryGuidance({ existingRepository, expectedUpstream } = {}) {
+  const repository = fallback(existingRepository, 'the existing repository');
+  const upstream = fallback(expectedUpstream, 'the expected upstream repository');
+
+  return `Recover the fork link WITHOUT deleting ${repository}: if ${repository} was once a GitHub fork of ${upstream} that got detached (for example after its visibility was switched to private and then back to public), the only path that keeps the repository is a GitHub Support request. Open ${GITHUB_FORK_SUPPORT_URL}, choose the "Attach, detach or reroute forks" flow, and ask to re-attach ${repository} to ${upstream}. GitHub documents visibility-change detachment as permanent, so reattachment is not guaranteed. While detached, ${repository} cannot open a cross-repository pull request to ${upstream}, so the solver needs either a reattached fork or a fresh fork to continue.`;
+}
+
+export function buildForkReplacementBlockedReason({ existingRepository, expectedUpstream, relationshipDescription, safetyCheckDescription, likelyDetachedFork = false } = {}) {
   const repository = fallback(existingRepository, 'the existing repository');
   const upstream = fallback(expectedUpstream, 'the expected upstream repository');
   const relationship = fallback(relationshipDescription, `${repository} is not a confirmed GitHub fork of ${upstream}.`);
   const safetyCheck = fallback(safetyCheckDescription, buildForkReplacementSafetyCheckDescription());
+  const detachedForkNote = likelyDetachedFork ? `\n- Likely cause: ${repository} shares history with ${upstream} but GitHub reports it as a non-fork, which matches a fork that was detached from its network (commonly after a private/public visibility change).` : '';
 
   return `${FORK_REPLACEMENT_BLOCKED_REASON_PREFIX}
 
 What happened:
 - Expected fork or replacement repository: ${repository}
 - Expected upstream: ${upstream}
-- Actual state: ${relationship}
+- Actual state: ${relationship}${detachedForkNote}
 - Safety check: ${safetyCheck}
 
 Why it stopped:
 Hive Mind did not delete ${repository} because the repository may contain commits that would be lost.
 
 Options:
-1. Back up any needed work in ${repository}, then delete, rename, archive, or repair that repository in GitHub and rerun the solver.
-2. If you do not control ${repository}, ask the repository owner or a Hive Mind administrator to clean it up and rerun the solver.
-3. Rerun with --allow-force-non-fork-repository-deletion only after confirming that deleting ${repository} is acceptable.`;
+1. ${buildDetachedForkRecoveryGuidance({ existingRepository: repository, expectedUpstream: upstream })}
+2. Back up any needed work in ${repository}, then delete, rename, archive, or repair that repository in GitHub and rerun the solver.
+3. If you do not control ${repository}, ask the repository owner or a Hive Mind administrator to clean it up and rerun the solver.
+4. Rerun with --allow-force-non-fork-repository-deletion only after confirming that deleting ${repository} is acceptable.`;
 }
 
 export function isForkReplacementBlockedReason(reason = '') {

package/src/solve.repository-safety.lib.mjs

@@ -0,0 +1,163 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { summarizeGitHubCompareFailure } from './solve.repository-recovery-message.lib.mjs';
+
+const resultText = result => `${result?.stderr?.toString?.() || ''}${result?.stdout?.toString?.() || ''}`.trim();
+const resultStdout = result => result?.stdout?.toString?.().trim() || '';
+const shortSha = sha => String(sha || '').slice(0, 12);
+
+const branchLabel = branch => {
+  const subject = branch.subject ? ` ${branch.subject}` : '';
+  return `${branch.ref} (${branch.uniqueCommitCount} commit(s), ${shortSha(branch.sha)}${subject})`;
+};
+
+export function buildReplacementBranchSafetyDescription({ uniqueBranches = [], branchCount = 0, failureOutput = '' } = {}) {
+  if (failureOutput) {
+    return `Local Git branch reachability check failed (${summarizeGitHubCompareFailure(failureOutput)}), so Hive Mind could not prove all replacement repository branches are preserved upstream.`;
+  }
+
+  if (uniqueBranches.length > 0) {
+    const examples = uniqueBranches.slice(0, 3).map(branchLabel).join('; ');
+    const remaining = uniqueBranches.length > 3 ? `; and ${uniqueBranches.length - 3} more` : '';
+    return `Local Git branch reachability found ${uniqueBranches.length} replacement branch tip(s) with commits not reachable from upstream branches or PR refs: ${examples}${remaining}.`;
+  }
+
+  return `Local Git branch reachability found all ${branchCount} replacement branch tip(s) reachable from upstream branches or PR refs.`;
+}
+
+async function runStep(commandPromise, failurePrefix) {
+  const result = await commandPromise;
+  if (result.code !== 0) {
+    return {
+      ok: false,
+      output: `${failurePrefix}: ${resultText(result) || `exit ${result.code}`}`,
+    };
+  }
+  return { ok: true, result };
+}
+
+const parseReplacementRefs = output =>
+  String(output || '')
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+    .map(line => {
+      const [ref, sha] = line.split(/\s+/, 2);
+      return { ref, sha };
+    })
+    .filter(item => item.ref && item.sha);
+
+/**
+ * Verify that deleting a non-fork replacement repository will not remove branch
+ * tips that are absent from the upstream repository. This is intentionally used
+ * only in the rare fork-replacement recovery path.
+ */
+export async function checkReplacementRepositoryBranchSafety({ $, owner, repo, existingRepository, tempRoot = os.tmpdir() }) {
+  const tempDir = await fs.mkdtemp(path.join(tempRoot, 'hive-mind-fork-replacement-'));
+
+  try {
+    const init = await runStep($({ cwd: tempDir })`git init -q 2>&1`, 'git init failed');
+    if (!init.ok) {
+      return {
+        safeToDelete: false,
+        branchCount: 0,
+        uniqueBranches: [],
+        safetyCheckDescription: buildReplacementBranchSafetyDescription({ failureOutput: init.output }),
+      };
+    }
+
+    const upstreamUrl = `https://github.com/${owner}/${repo}.git`;
+    const replacementUrl = `https://github.com/${existingRepository}.git`;
+
+    const upstreamFetch = await runStep($({ cwd: tempDir })`git fetch --filter=blob:none ${upstreamUrl} '+refs/heads/*:refs/remotes/upstream/*' '+refs/pull/*/head:refs/remotes/upstream-pr/*' 2>&1`, 'upstream fetch failed');
+    if (!upstreamFetch.ok) {
+      return {
+        safeToDelete: false,
+        branchCount: 0,
+        uniqueBranches: [],
+        safetyCheckDescription: buildReplacementBranchSafetyDescription({ failureOutput: upstreamFetch.output }),
+      };
+    }
+
+    const replacementFetch = await runStep($({ cwd: tempDir })`git fetch --filter=blob:none ${replacementUrl} '+refs/heads/*:refs/remotes/replacement/*' 2>&1`, 'replacement fetch failed');
+    if (!replacementFetch.ok) {
+      return {
+        safeToDelete: false,
+        branchCount: 0,
+        uniqueBranches: [],
+        safetyCheckDescription: buildReplacementBranchSafetyDescription({ failureOutput: replacementFetch.output }),
+      };
+    }
+
+    const refsResult = await runStep($({ cwd: tempDir })`git for-each-ref --format='%(refname:short) %(objectname)' refs/remotes/replacement 2>&1`, 'replacement ref listing failed');
+    if (!refsResult.ok) {
+      return {
+        safeToDelete: false,
+        branchCount: 0,
+        uniqueBranches: [],
+        safetyCheckDescription: buildReplacementBranchSafetyDescription({ failureOutput: refsResult.output }),
+      };
+    }
+
+    const replacementRefs = parseReplacementRefs(resultStdout(refsResult.result));
+    const uniqueBranches = [];
+
+    for (const { ref, sha } of replacementRefs) {
+      const countResult = await runStep($({ cwd: tempDir })`git rev-list --count ${ref} --not --remotes=upstream --remotes=upstream-pr 2>&1`, `unique commit count failed for ${ref}`);
+      if (!countResult.ok) {
+        return {
+          safeToDelete: false,
+          branchCount: replacementRefs.length,
+          uniqueBranches,
+          safetyCheckDescription: buildReplacementBranchSafetyDescription({ failureOutput: countResult.output }),
+        };
+      }
+
+      const uniqueCommitCount = Number.parseInt(resultStdout(countResult.result), 10);
+      if (!Number.isFinite(uniqueCommitCount)) {
+        return {
+          safeToDelete: false,
+          branchCount: replacementRefs.length,
+          uniqueBranches,
+          safetyCheckDescription: buildReplacementBranchSafetyDescription({ failureOutput: `invalid unique commit count for ${ref}: ${resultStdout(countResult.result)}` }),
+        };
+      }
+
+      if (uniqueCommitCount > 0) {
+        const subjectResult = await $({ cwd: tempDir })`git log -1 --format=%s ${ref} 2>&1`;
+        uniqueBranches.push({
+          ref: ref.replace(/^replacement\//, ''),
+          sha,
+          uniqueCommitCount,
+          subject: subjectResult.code === 0 ? resultStdout(subjectResult) : '',
+        });
+      }
+    }
+
+    const reachableBranchCount = replacementRefs.length - uniqueBranches.length;
+
+    return {
+      safeToDelete: uniqueBranches.length === 0,
+      branchCount: replacementRefs.length,
+      reachableBranchCount,
+      // At least one branch tip is fully reachable from upstream refs, so the
+      // replacement shares history with upstream. Combined with GitHub reporting
+      // it as a non-fork, that matches a fork detached from its network (see
+      // issue #2019), typically after a private/public visibility change.
+      likelyDetachedFork: replacementRefs.length > 0 && reachableBranchCount > 0,
+      uniqueBranches,
+      safetyCheckDescription: buildReplacementBranchSafetyDescription({ uniqueBranches, branchCount: replacementRefs.length }),
+    };
+  } catch (error) {
+    return {
+      safeToDelete: false,
+      branchCount: 0,
+      uniqueBranches: [],
+      safetyCheckDescription: buildReplacementBranchSafetyDescription({ failureOutput: error.message }),
+    };
+  } finally {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  }
+}

package/src/solve.repository.lib.mjs

@@ -30,6 +30,7 @@ const { log, formatAligned } = lib;
 // Import exit handler
 import { safeExit } from './exit-handler.lib.mjs';
 import { parseForkFullNameFromGhOutput } from './github-repository-names.lib.mjs';
+import { checkReplacementRepositoryBranchSafety } from './solve.repository-safety.lib.mjs';
 import { buildForkReplacementBlockedReason, buildForkReplacementSafetyCheckDescription } from './solve.repository-recovery-message.lib.mjs';
 
 // Import GitHub utilities for permission checks
@@ -525,34 +526,75 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
         const relationshipDescription = !forkValidation.isFork ? `${existingForkName} is not a GitHub fork of ${owner}/${repo}.` : `${existingForkName} is a GitHub fork of ${forkValidation.parent || 'unknown parent'}, not ${owner}/${repo}.`;
         await log(`${formatAligned('', '', detail)}`);
         await log(`${formatAligned('', '', `Fork parent: ${forkValidation.parent || 'N/A (not a fork)'}, source: ${forkValidation.source || 'N/A'}, expected: ${owner}/${repo}`)}`);
-        // Safety check: compare commits before deleting to avoid data loss
-        await log(`${formatAligned('🔍', 'Safety check:', 'Comparing commits against upstream...')}`);
+        // Safety check: compare commits before deleting to avoid data loss.
+        // GitHub compare only answers for fork-network refs, so a local Git
+        // fallback checks every replacement branch tip before deletion.
+        await log(`${formatAligned('🔍', 'Safety check:', 'Comparing default branch against upstream...')}`);
         let safeToDelete = false;
         let safetyCheckDescription = buildForkReplacementSafetyCheckDescription();
+        let shouldRunBranchReachabilityCheck = false;
+        let likelyDetachedFork = false;
         try {
           const cmp = await $`gh api repos/${owner}/${repo}/compare/${owner}:HEAD...${existingForkName.split('/')[0]}:HEAD --paginate --jq '.ahead_by' 2>&1`;
           const aheadBy = parseInt(cmp.stdout.toString().trim(), 10);
           if (cmp.code === 0 && aheadBy === 0) {
-            await log(`${formatAligned('✅', 'Safe to delete:', 'No additional commits in non-fork repository')}`);
-            safeToDelete = true;
+            await log(`${formatAligned('✅', 'Default branch:', 'No additional commits in replacement repository')}`);
+            shouldRunBranchReachabilityCheck = true;
           } else if (cmp.code === 0) {
             safetyCheckDescription = buildForkReplacementSafetyCheckDescription({ aheadBy });
-            const aheadDescription = Number.isFinite(aheadBy) ? `${aheadBy} commit(s)` : 'an unknown number of commit(s)';
-            await log(`${formatAligned('⚠️', 'UNSAFE:', `Repository has ${aheadDescription} ahead of upstream that would be lost`)}`, { level: 'warning' });
+            if (Number.isFinite(aheadBy)) {
+              await log(`${formatAligned('⚠️', 'UNSAFE:', `Default branch has ${aheadBy} commit(s) ahead of upstream that would be lost`)}`, { level: 'warning' });
+            } else {
+              await log(`${formatAligned('⚠️', 'Compare unclear:', 'GitHub compare did not return a numeric ahead_by value')}`, { level: 'warning' });
+              shouldRunBranchReachabilityCheck = true;
+            }
           } else {
             const compareOutput = (cmp.stderr?.toString() || '') + (cmp.stdout?.toString() || '');
             safetyCheckDescription = buildForkReplacementSafetyCheckDescription({ compareFailureOutput: compareOutput });
             await log(`${formatAligned('⚠️', 'Compare failed:', compareOutput.split('\n')[0])}`, { level: 'warning' });
+            shouldRunBranchReachabilityCheck = true;
           }
         } catch (e) {
           safetyCheckDescription = buildForkReplacementSafetyCheckDescription({ compareFailureOutput: e.message });
           await log(`${formatAligned('⚠️', 'Compare error:', e.message)}`, { level: 'warning' });
+          shouldRunBranchReachabilityCheck = true;
+        }
+
+        if (shouldRunBranchReachabilityCheck) {
+          await log(`${formatAligned('🔍', 'Safety check:', 'Checking all replacement branches against upstream refs...')}`);
+          const branchSafety = await checkReplacementRepositoryBranchSafety({
+            $,
+            owner,
+            repo,
+            existingRepository: existingForkName,
+          });
+          safetyCheckDescription = branchSafety.safetyCheckDescription;
+          likelyDetachedFork = Boolean(branchSafety.likelyDetachedFork);
+
+          if (likelyDetachedFork) {
+            await log(`${formatAligned('🔗', 'Detached fork:', `${existingForkName} shares history with ${owner}/${repo} but is not a GitHub fork — this matches a fork detached by a private/public visibility change`)}`);
+          }
+
+          if (branchSafety.safeToDelete) {
+            await log(`${formatAligned('✅', 'Safe to delete:', `All ${branchSafety.branchCount} replacement branch tip(s) are reachable from upstream`)}`);
+            safeToDelete = true;
+          } else if (branchSafety.uniqueBranches.length > 0) {
+            await log(`${formatAligned('⚠️', 'UNSAFE:', `${branchSafety.uniqueBranches.length} replacement branch tip(s) have commits not reachable from upstream`)}`, { level: 'warning' });
+            for (const branch of branchSafety.uniqueBranches.slice(0, 3)) {
+              await log(`${formatAligned('', '', `${branch.ref}: ${branch.uniqueCommitCount} commit(s), ${branch.sha.slice(0, 12)} ${branch.subject || ''}`)}`, { level: 'warning' });
+            }
+          } else {
+            await log(`${formatAligned('⚠️', 'Branch check failed:', safetyCheckDescription)}`, { level: 'warning' });
+          }
         }
         if (!safeToDelete) {
           if (argv.allowForceNonForkRepositoryDeletion) {
             // Force flag set — proceed with deletion despite the failed safety check.
             await log(`${formatAligned('⚠️', 'Force deletion ENABLED:', '--allow-force-non-fork-repository-deletion — proceeding despite potential data loss')}`, { level: 'warning' });
           } else {
+            if (likelyDetachedFork) {
+              await log(`  🔗 Recover without deletion: ask GitHub Support to re-attach ${existingForkName} to ${owner}/${repo} at https://support.github.com/request/fork ("Attach, detach or reroute forks")`);
+            }
             await log(`  💡 Manual fix required: back up work, then: gh repo delete ${existingForkName} --yes`);
             await log(`     Then run this command again to create a proper fork of ${owner}/${repo}`);
             await log(`  🔧 Or force deletion (DANGEROUS): solve ${argv.url || argv['issue-url'] || argv._[0] || '<issue-url>'} --allow-force-non-fork-repository-deletion`);
@@ -563,6 +605,7 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
                 expectedUpstream: `${owner}/${repo}`,
                 relationshipDescription,
                 safetyCheckDescription,
+                likelyDetachedFork,
               })
             );
           }