@link-assistant/hive-mind 2.0.17 → 2.0.19

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 2.0.19
+
+### Patch Changes
+
+- 8061979: Preserve per-command isolation overrides for queued Telegram solve commands.
+
+## 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.0.17",
+  "version": "2.0.19",
   "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,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...')}`);

package/src/telegram-solve-queue.lib.mjs

@@ -58,6 +58,8 @@ class SolveQueueItem {
     this.requester = options.requester;
     this.infoBlock = options.infoBlock;
     this.tool = options.tool || 'claude';
+    // Issue #1983: preserve per-command isolation through queued execution.
+    this.perCommandIsolation = options.perCommandIsolation || null;
     // Issue #1688: keep parsed URL context (owner/repo/number/type) so completion
     //   notifications can look up linked PRs for issue URLs.
     this.urlContext = options.urlContext || null;