@link-assistant/hive-mind 2.0.16 → 2.0.18

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 2.0.18
+
+### Patch Changes
+
+- 08c2f07: Clarify fork auto-recovery safety failures so terminal exits and failure comments explain the mismatched repository, expected upstream, safety-check result, and recovery options.
+
+## 2.0.17
+
+### Patch Changes
+
+- 1cec7b4: Allow bare indented LINO option/value links in .lenv configuration, matching parenthesized links.
+
 ## 2.0.16
 
 ### Patch Changes

package/package.json

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

package/src/lenv-reader.lib.mjs

@@ -39,10 +39,6 @@ const LinoParser = linoModule.Parser || linoModule.default?.Parser;
 
 const fs = await import('fs');
 
-function isCliOptionToken(value) {
-  return /^--[a-zA-Z0-9][a-zA-Z0-9=_.-]*$/.test(value) || /^-[a-zA-Z]$/.test(value);
-}
-
 function collectStringValues(value, result = []) {
   if (value && typeof value === 'object' && Array.isArray(value.values)) {
     if (value.id !== null && value.id !== undefined) {
@@ -57,25 +53,6 @@ function collectStringValues(value, result = []) {
   return result;
 }
 
-function validateNoBareSameLineOptions(content) {
-  let currentVar = 'configuration';
-
-  for (const line of content.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed === '(' || trimmed === ')') continue;
-
-    const topLevelMatch = !/^\s/.test(line) ? trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*):(?:\s*(.*))?$/) : null;
-    const valueText = topLevelMatch ? (topLevelMatch[2] || '').trim() : trimmed;
-    if (topLevelMatch) currentVar = topLevelMatch[1];
-    if (!valueText || valueText === '(' || valueText === ')' || valueText.startsWith('(')) continue;
-
-    const parts = valueText.split(/\s+/).filter(Boolean);
-    if (parts.length > 1 && isCliOptionToken(parts[0])) {
-      throw new Error(`Invalid LINO format in "${currentVar}": Multiple values on the same line are not supported.\n` + `Found: "${parts.join(' ')}"\n` + `Each value must be on its own line with proper indentation, or grouped explicitly as a parenthesized link.`);
-    }
-  }
-}
-
 /**
  * LenvReader - Reads and parses .lenv files using LINO notation
  */
@@ -97,8 +74,6 @@ export class LenvReader {
     const result = {};
 
     try {
-      validateNoBareSameLineOptions(content);
-
       // Parse the entire content as LINO
       const parsed = this.parser.parse(content);
 

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

@@ -1,4 +1,5 @@
 import { getTrackedToolCommentIds, postTrackedComment, SOLUTION_DRAFT_FAILED_MARKER } from './tool-comments.lib.mjs';
+import { extractForkReplacementBlockedDetails, isForkReplacementBlockedReason } from './solve.repository-recovery-message.lib.mjs';
 
 export const FORK_DIVERGENCE_RESOLUTION_OPTION = '--allow-fork-divergence-resolution-using-force-push-with-lease';
 
@@ -29,6 +30,23 @@ export function buildPrePullRequestFailureActionSection(reason = '') {
   const normalizedReason = String(reason || '').toLowerCase();
   const isForkOrRecoveryFailure = normalizedReason.includes('fork') || normalizedReason.includes('auto-recovery') || normalizedReason.includes('repository setup');
 
+  if (isForkReplacementBlockedReason(reason)) {
+    const details = extractForkReplacementBlockedDetails(reason);
+    const repository = details.existingRepository || 'the existing repository';
+    const upstream = details.expectedUpstream || 'the expected upstream repository';
+
+    return `### What happened
+- Hive Mind found \`${repository}\` where it needed a GitHub fork of \`${upstream}\`.
+- It could not prove whether the existing repository has unique commits, so it did not delete it automatically.
+
+### What you can do
+- If you control \`${repository}\`, back up any needed work, then delete, rename, archive, or repair it in GitHub and rerun the solver.
+- If you do not control \`${repository}\`, 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.
+
+Administrator-only CLI details, if any, are printed in the solver terminal log rather than in this GitHub comment.`;
+  }
+
   if (isForkDivergenceFailure(reason)) {
     return `### What you can do
 - If the fork's default branch can be overwritten safely, rerun with \`${FORK_DIVERGENCE_RESOLUTION_OPTION}\` to allow a guarded force-with-lease sync.

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

@@ -0,0 +1,72 @@
+export const FORK_REPLACEMENT_BLOCKED_REASON_PREFIX = 'Repository setup halted - existing fork replacement could lose commits.';
+
+const fallback = (value, replacement) => {
+  const text = value === null || value === undefined ? '' : String(value).trim();
+  return text || replacement;
+};
+
+export function summarizeGitHubCompareFailure(output = '') {
+  const text = fallback(output, 'unknown compare error');
+  const status = text.match(/HTTP\s+(\d+)/i)?.[1] || text.match(/"status"\s*:\s*"?(\d+)"?/i)?.[1] || null;
+  const message = text.match(/"message"\s*:\s*"([^"]+)"/i)?.[1] || text.match(/gh:\s*([^\n(]+)/i)?.[1]?.trim() || null;
+
+  if (status && message) return `${status} ${message}`;
+  return message || status || text.split('\n')[0].slice(0, 160);
+}
+
+export function buildForkReplacementSafetyCheckDescription({ aheadBy = null, compareFailureOutput = '' } = {}) {
+  if (Number.isFinite(aheadBy) && aheadBy > 0) {
+    return `GitHub compare reported ${aheadBy} commit(s) ahead of upstream, so deleting the repository could lose commits.`;
+  }
+
+  if (compareFailureOutput) {
+    return `GitHub compare returned ${summarizeGitHubCompareFailure(compareFailureOutput)}, so Hive Mind could not prove the repository has no unique commits.`;
+  }
+
+  return 'Hive Mind could not prove the repository has no unique commits.';
+}
+
+export function buildForkReplacementBlockedReason({ existingRepository, expectedUpstream, relationshipDescription, safetyCheckDescription } = {}) {
+  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());
+
+  return `${FORK_REPLACEMENT_BLOCKED_REASON_PREFIX}
+
+What happened:
+- Expected fork or replacement repository: ${repository}
+- Expected upstream: ${upstream}
+- Actual state: ${relationship}
+- 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.`;
+}
+
+export function isForkReplacementBlockedReason(reason = '') {
+  const text = String(reason || '');
+  const normalized = text.toLowerCase();
+  return normalized.includes(FORK_REPLACEMENT_BLOCKED_REASON_PREFIX.toLowerCase()) || normalized.includes('auto-recovery skipped - repository may contain commits that would be lost');
+}
+
+const extractLineValue = (reason, label) => {
+  const pattern = new RegExp(`^- ${label}:\\s*(.+)$`, 'im');
+  return (
+    String(reason || '')
+      .match(pattern)?.[1]
+      ?.trim() || null
+  );
+};
+
+export function extractForkReplacementBlockedDetails(reason = '') {
+  return {
+    existingRepository: extractLineValue(reason, 'Expected fork or replacement repository'),
+    expectedUpstream: extractLineValue(reason, 'Expected upstream'),
+  };
+}

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 { buildForkReplacementBlockedReason, buildForkReplacementSafetyCheckDescription } from './solve.repository-recovery-message.lib.mjs';
 
 // Import GitHub utilities for permission checks
 const githubLib = await import('./github.lib.mjs');
@@ -521,22 +522,30 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
         await log('');
         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)`;
+        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...')}`);
         let safeToDelete = false;
+        let safetyCheckDescription = buildForkReplacementSafetyCheckDescription();
         try {
           const cmp = await $`gh api repos/${owner}/${repo}/compare/${owner}:HEAD...${existingForkName.split('/')[0]}:HEAD --paginate --jq '.ahead_by' 2>&1`;
-          if (cmp.code === 0 && parseInt(cmp.stdout.toString().trim(), 10) === 0) {
+          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;
           } 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' });
+            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' });
           } else {
-            await log(`${formatAligned('⚠️', 'Compare failed:', ((cmp.stderr?.toString() || '') + (cmp.stdout?.toString() || '')).split('\n')[0])}`, { level: 'warning' });
+            const compareOutput = (cmp.stderr?.toString() || '') + (cmp.stdout?.toString() || '');
+            safetyCheckDescription = buildForkReplacementSafetyCheckDescription({ compareFailureOutput: compareOutput });
+            await log(`${formatAligned('⚠️', 'Compare failed:', compareOutput.split('\n')[0])}`, { level: 'warning' });
           }
         } catch (e) {
+          safetyCheckDescription = buildForkReplacementSafetyCheckDescription({ compareFailureOutput: e.message });
           await log(`${formatAligned('⚠️', 'Compare error:', e.message)}`, { level: 'warning' });
         }
         if (!safeToDelete) {
@@ -547,7 +556,15 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
             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 safeExit(
+              1,
+              buildForkReplacementBlockedReason({
+                existingRepository: existingForkName,
+                expectedUpstream: `${owner}/${repo}`,
+                relationshipDescription,
+                safetyCheckDescription,
+              })
+            );
           }
         }
         await log(`${formatAligned('🔄', 'Auto-recovery:', 'Deleting non-fork repository and creating fresh fork...')}`);