@link-assistant/hive-mind 1.46.0 → 1.46.2

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @link-assistant/hive-mind
 
+## 1.46.2
+
+### Patch Changes
+
+- 37daeb7: Auto-recover from non-fork repositories during fork validation (Issue #1518)
+  - When a repository exists but is NOT a proper GitHub fork (or has wrong parent), safely auto-recover by comparing commits against upstream first — only delete and re-fork if no additional commits would be lost
+  - Add verbose logging of fork commands for debugging non-fork creation scenarios
+  - Add post-creation fork validation to detect non-fork repos immediately after `gh repo fork`
+  - Report non-fork creation to Sentry for monitoring
+  - Add `--allow-force-non-fork-repository-deletion` flag to force deletion even when additional commits would be lost
+  - Add case study documenting the root cause analysis of konard/MixaByk1996-elements-app
+  - Document all previously undocumented solve options in CONFIGURATION.md (12 options including --allow-force-non-fork-repository-deletion)
+  - Add CI/CD test to verify documentation stays in sync with code options (prevents drift)
+
+## 1.46.1
+
+### Patch Changes
+
+- 84aacf7: fix: pass LINK_ASSISTANT_AGENT_VERBOSE env var to agent process for HTTP logging (#1521)
+
 ## 1.46.0
 
 ### Minor Changes

package/package.json

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

package/src/agent.lib.mjs

@@ -508,9 +508,22 @@ export const executeAgentCommand = async params => {
     try {
       // Pipe the prompt file to agent via stdin
       // Use agentArgs which includes --model and optionally --verbose
+
+      // Issue #1521: Build environment for agent process
+      // Pass LINK_ASSISTANT_AGENT_VERBOSE env var when --verbose is enabled
+      // This ensures Flag.LINK_ASSISTANT_AGENT_VERBOSE is true at module load time inside the agent,
+      // which is required for HTTP request/response logging to work.
+      // The --verbose CLI flag alone is not sufficient because the agent's Flag module
+      // reads the env var at initialization, before yargs middleware calls Flag.setVerbose().
+      const agentEnv = { ...process.env };
+      if (argv.verbose) {
+        agentEnv.LINK_ASSISTANT_AGENT_VERBOSE = 'true';
+      }
+
       execCommand = $({
         cwd: tempDir,
         mirror: false,
+        env: agentEnv,
       })`cat ${promptFile} | ${agentPath} ${agentArgs}`;
 
       await log(`${formatAligned('📋', 'Command details:', '')}`);

package/src/option-suggestions.lib.mjs

@@ -199,6 +199,7 @@ const KNOWN_OPTION_NAMES = [
   'only-prepare-command',
   'auto-merge-default-branch-to-pull-request-branch',
   'allow-fork-divergence-resolution-using-force-push-with-lease',
+  'allow-force-non-fork-repository-deletion',
   'allow-to-push-to-contributors-pull-requests-as-maintainer',
   'prefix-fork-name-with-owner-name',
   'auto-restart-max-iterations',

package/src/solve.config.lib.mjs

@@ -273,6 +273,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Allow automatic force-push (--force-with-lease) when fork diverges from upstream (DANGEROUS: can overwrite fork history)',
     default: false,
   },
+  'allow-force-non-fork-repository-deletion': {
+    type: 'boolean',
+    description: 'Allow deletion of non-fork repositories even when they contain additional commits that would be lost (DANGEROUS: data loss possible)',
+    default: false,
+  },
   'allow-to-push-to-contributors-pull-requests-as-maintainer': {
     type: 'boolean',
     description: 'When continuing a fork PR as a maintainer, attempt to push directly to the contributor\'s fork if "Allow edits by maintainers" is enabled. Requires --auto-fork to be enabled.',

package/src/solve.repository.lib.mjs

@@ -490,78 +490,77 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
 
       const forkValidation = await validateForkParent(existingForkName, `${owner}/${repo}`);
 
-      if (!forkValidation.isValid) {
+      if (forkValidation.isValid) {
+        // Fork is valid — use it
+        await log(`${formatAligned('✅', 'Fork parent validated:', `${forkValidation.parent}`)}`);
+        repoToClone = existingForkName;
+        forkedRepo = existingForkName;
+        upstreamRemote = `${owner}/${repo}`;
+      } else if (forkValidation.isNetworkError) {
         // Issue #1311: Handle network errors separately from fork mismatch errors
-        if (forkValidation.isNetworkError) {
-          await log('');
-          await log(`${formatAligned('❌', 'NETWORK ERROR DURING FORK VALIDATION', '')}`, { level: 'error' });
-          await log('');
-          await log('  🔍 What happened:');
-          await log(`     Failed to connect to GitHub API while validating fork.`);
-          await log(`     Error: ${forkValidation.error}`);
-          await log('');
-          await log('  💡 This is likely a temporary network issue. You can:');
-          await log('     1. Wait a moment and try again');
-          await log('     2. Check your internet connection');
-          await log('     3. Check GitHub status: https://www.githubstatus.com/');
-          await log('');
-          await log('     Or use --no-fork to skip fork validation if you have write access.');
-          await log('');
-          await safeExit(1, 'Network error during fork validation - please retry');
-        }
-
-        // Fork parent mismatch detected - this prevents issue #967
         await log('');
-        await log(`${formatAligned('❌', 'FORK PARENT MISMATCH DETECTED', '')}`, { level: 'error' });
+        await log(`${formatAligned('❌', 'NETWORK ERROR DURING FORK VALIDATION', '')}`, { level: 'error' });
         await log('');
         await log('  🔍 What happened:');
-        if (!forkValidation.isFork) {
-          await log(`     The repository ${existingForkName} is NOT a GitHub fork.`);
-          await log('     It may have been created by cloning and pushing instead of forking.');
-        } else {
-          await log(`     Your fork ${existingForkName} was created from an intermediate fork,`);
-          await log(`     not directly from the target repository ${owner}/${repo}.`);
-        }
-        await log('');
-        await log('  📦 Fork relationship:');
-        await log(`     • Your fork: ${existingForkName}`);
-        await log(`     • Fork parent: ${forkValidation.parent || 'N/A (not a fork)'}`);
-        await log(`     • Fork source (root): ${forkValidation.source || 'N/A'}`);
-        await log(`     • Expected parent: ${owner}/${repo}`);
-        await log('');
-        await log('  ⚠️  Why this is a problem:');
-        await log('     When a fork is created from an intermediate fork (a "fork of a fork"),');
-        await log('     any commits that exist in the intermediate fork but not in the target');
-        await log('     repository will be included in your pull requests. This can result in');
-        await log('     pull requests with hundreds or thousands of unexpected commits.');
+        await log(`     Failed to connect to GitHub API while validating fork.`);
+        await log(`     Error: ${forkValidation.error}`);
         await log('');
-        await log('  📖 Case study: See issue #967');
-        await log('     A fork created from veb86/zcadvelecAI (which had 1,678 extra commits)');
-        await log('     instead of zamtmn/zcad resulted in a PR with 1,681 commits');
-        await log('     instead of the expected 3 commits.');
+        await log('  💡 This is likely a temporary network issue. You can:');
+        await log('     1. Wait a moment and try again');
+        await log('     2. Check your internet connection');
+        await log('     3. Check GitHub status: https://www.githubstatus.com/');
         await log('');
-        await log('  💡 How to fix:');
+        await log('     Or use --no-fork to skip fork validation if you have write access.');
         await log('');
-        await log('     Option 1: Delete the problematic fork and create a fresh one');
-        await log(`        gh repo delete ${existingForkName}`);
-        await log(`        Then run this command again to create a proper fork of ${owner}/${repo}`);
-        await log('');
-        await log('     Option 2: Use --prefix-fork-name-with-owner-name to create a new fork');
-        await log(`        This creates a fork named ${currentUser}/${owner}-${repo} instead`);
-        await log(`        ./solve.mjs "${issueUrl || `https://github.com/${owner}/${repo}/issues/<number>`}" --prefix-fork-name-with-owner-name --fork`);
-        await log('');
-        await log('     Option 3: Work directly on the repository (if you have write access)');
-        await log(`        ./solve.mjs "${issueUrl || `https://github.com/${owner}/${repo}/issues/<number>`}" --no-fork`);
+        await safeExit(1, 'Network error during fork validation - please retry');
+      } else {
+        // Issue #1518: Auto-recovery — delete non-fork/mismatched repo and re-fork, but only if no commits would be lost
         await log('');
-
-        await safeExit(1, 'Fork parent mismatch - fork was created from intermediate fork');
+        await log(`${formatAligned('⚠️', 'FORK PARENT MISMATCH DETECTED', '')}`, { level: 'warning' });
+        const detail = !forkValidation.isFork ? `Repository ${existingForkName} is NOT a GitHub fork (see issue #1518)` : `Fork ${existingForkName} was created from ${forkValidation.parent} instead of ${owner}/${repo} (see issue #967)`;
+        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...')}`);
+        let safeToDelete = false;
+        try {
+          const cmp = await $`gh api repos/${owner}/${repo}/compare/${owner}:HEAD...${existingForkName.split('/')[0]}:HEAD --jq '.ahead_by' 2>&1`;
+          if (cmp.code === 0 && parseInt(cmp.stdout.toString().trim(), 10) === 0) {
+            await log(`${formatAligned('✅', 'Safe to delete:', 'No additional commits in non-fork repository')}`);
+            safeToDelete = true;
+          } else if (cmp.code === 0) {
+            await log(`${formatAligned('⚠️', 'UNSAFE:', `Repository has ${cmp.stdout.toString().trim()} commit(s) ahead of upstream that would be lost`)}`, { level: 'warning' });
+          } else {
+            await log(`${formatAligned('⚠️', 'Compare failed:', ((cmp.stderr?.toString() || '') + (cmp.stdout?.toString() || '')).split('\n')[0])}`, { level: 'warning' });
+          }
+        } catch (e) {
+          await log(`${formatAligned('⚠️', 'Compare error:', e.message)}`, { level: 'warning' });
+        }
+        if (!safeToDelete) {
+          if (argv.allowForceNonForkRepositoryDeletion) {
+            await log(`${formatAligned('⚠️', 'Force deletion ENABLED:', '--allow-force-non-fork-repository-deletion — proceeding despite potential data loss')}`, { level: 'warning' });
+            safeToDelete = true;
+          } else {
+            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`);
+            await safeExit(1, 'Auto-recovery skipped - repository may contain commits that would be lost');
+          }
+        }
+        await log(`${formatAligned('🔄', 'Auto-recovery:', 'Deleting non-fork repository and creating fresh fork...')}`);
+        const deleteResult = await $`gh repo delete ${existingForkName} --yes 2>&1`;
+        if (deleteResult.code !== 0) {
+          const delOut = (deleteResult.stderr?.toString() || '') + (deleteResult.stdout?.toString() || '');
+          await log(`${formatAligned('❌', 'Delete failed:', delOut.split('\n')[0])}`, { level: 'error' });
+          await log(`  💡 Manual fix: gh repo delete ${existingForkName} --yes, then re-run`);
+          await safeExit(1, 'Auto-recovery failed - could not delete problematic repository');
+        }
+        await log(`${formatAligned('✅', 'Deleted:', existingForkName)}`);
+        existingForkName = null; // Fall through to fork creation below
       }
+    }
 
-      await log(`${formatAligned('✅', 'Fork parent validated:', `${forkValidation.parent}`)}`);
-      repoToClone = existingForkName;
-      forkedRepo = existingForkName;
-      upstreamRemote = `${owner}/${repo}`;
-    } else {
+    if (!existingForkName) {
       // Need to create fork with retry logic for concurrent scenarios
       await log(`${formatAligned('🔄', 'Creating fork...', '')}`);
 
@@ -575,19 +574,18 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
       let actualForkName = `${currentUser}/${defaultForkName}`;
 
       for (let attempt = 1; attempt <= maxForkRetries; attempt++) {
-        // Try to create fork with optional custom name
         let forkResult;
+        // Issue #1518: Log the exact fork command for debugging non-fork creation scenarios
+        if (argv.verbose) await log(`${formatAligned('🔧', 'Fork command:', argv.prefixForkNameWithOwnerName ? `gh repo fork ${owner}/${repo} --fork-name ${owner}-${repo} --clone=false` : `gh repo fork ${owner}/${repo} --clone=false`)}`);
         if (argv.prefixForkNameWithOwnerName) {
-          // Use --fork-name flag to create fork with owner prefix
           forkResult = await $`gh repo fork ${owner}/${repo} --fork-name ${owner}-${repo} --clone=false 2>&1`;
         } else {
-          // Standard fork creation (no custom name)
           forkResult = await $`gh repo fork ${owner}/${repo} --clone=false 2>&1`;
         }
 
         // Always capture output to parse actual fork name
         const forkOutput = (forkResult.stderr ? forkResult.stderr.toString() : '') + (forkResult.stdout ? forkResult.stdout.toString() : '');
-
+        if (argv.verbose) await log(`${formatAligned('🔧', 'Fork output:', forkOutput.split('\n')[0] || '(empty)')}`); // Issue #1518
         // Parse actual fork name from output (e.g., "konard/netkeep80-jsonRVM already exists")
         // GitHub may create forks with modified names to avoid conflicts
         // Use regex that won't match domain names like "github.com/user" -> "com/user"
@@ -792,11 +790,20 @@ Thank you!`;
           await safeExit(1, 'Repository setup failed');
         }
 
-        // Wait a moment for fork to be fully ready
         if (forkCreated) {
+          // Wait a moment for fork to be fully ready
           await log(`${formatAligned('⏳', 'Waiting:', 'For fork to be fully ready...')}`);
           await new Promise(resolve => setTimeout(resolve, 3000));
         }
+        // Issue #1518: Validate fork parent after creation/discovery to detect non-fork repos early (covers concurrent worker scenarios too)
+        await log(`${formatAligned('🔍', 'Validating fork parent...', '')}`);
+        const pcv = await validateForkParent(actualForkName, `${owner}/${repo}`);
+        if (pcv.isValid) {
+          await log(`${formatAligned('✅', 'Fork parent validated:', `${pcv.parent}`)}`);
+        } else if (!pcv.isNetworkError) {
+          await log(`${formatAligned('⚠️', 'WARNING:', `Fork failed validation (possible gh CLI bug, see issue #1518): ${pcv.error}`)}`, { level: 'warning' });
+          reportError(new Error(`Fork created as non-fork: ${pcv.error}`), { context: 'fork_creation_validation', forkRepo: actualForkName, expectedUpstream: `${owner}/${repo}`, isFork: pcv.isFork, parent: pcv.parent, source: pcv.source });
+        }
       }
 
       repoToClone = actualForkName;