@link-assistant/hive-mind 1.72.5 → 1.72.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.72.7
+
+### Patch Changes
+
+- 61e2935: Fix "Failed to add .gitkeep" abort during auto-PR creation when the target repository's `.gitignore` matches the seed placeholder (issue #1825). Placeholder staging now routes through `addPlaceholderFileToGit`, which detects the ignored path with `git check-ignore` and retries with `git add -f`. Because the placeholder is created by the solver to seed the initial commit and removed once the task completes, force-adding it is safe.
+
+## 1.72.6
+
+### Patch Changes
+
+- 57f15ec: Detect same-account human feedback in auto-restart comment monitoring only when the AI tool is idle, while still filtering hive-mind tool-generated comments by marker and tracked ID.
+
 ## 1.72.5
 
 ### Patch Changes

package/package.json

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

package/src/solve.auto-merge-helpers.lib.mjs

@@ -76,7 +76,7 @@ const formatRunLine = run => {
 // search scope for checkForExistingComment() stays in lock-step with the
 // markers actually embedded in tool-posted comments.
 const toolComments = await import('./tool-comments.lib.mjs');
-const { SESSION_ENDING_MARKERS } = toolComments;
+const { SESSION_ENDING_MARKERS, isToolGeneratedComment, isToolTrackedCommentId } = toolComments;
 
 /**
  * Issue #1323: Check if a comment with specific content already exists on the PR
@@ -168,14 +168,25 @@ export const checkForExistingComment = async (owner, repo, prNumber, commentSign
 
 /**
  * Check for new comments from non-bot users since last commit
+ *
+ * Same-account comments are only considered feedback when
+ * `trustAuthenticatedUserComments` is true. Keep the default false for callers
+ * that may run while an AI tool is still active: those tools can post through
+ * the authenticated GitHub account.
+ *
+ * @param {Function} commandRunner - Tagged-template command runner, injectable for tests
+ * @param {Object} options - Comment classification options
+ * @param {boolean} options.trustAuthenticatedUserComments - True only when the caller knows the AI tool is not running
  * @returns {Promise<{hasNewComments: boolean, comments: Array}>}
  */
-export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber, lastCheckTime, verbose = false) => {
+export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber, lastCheckTime, verbose = false, commandRunner = $, options = {}) => {
   try {
+    const { trustAuthenticatedUserComments = false } = options;
+
     // Get current GitHub user to identify which comments are from the bot/hive-mind
     let currentUser = null;
     try {
-      const userResult = await $`gh api user --jq .login`;
+      const userResult = await commandRunner`gh api user --jq .login`;
       if (userResult.code === 0) {
         currentUser = userResult.stdout.toString().trim();
       }
@@ -183,7 +194,12 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
       // If we can't get the current user, continue without filtering
     }
 
-    // Common bot usernames and patterns to filter out
+    // Common bot usernames and patterns to filter out.
+    // Issue #1821: In same-account operation, humans and AI tools can both
+    // post through the authenticated account. The safe default treats that
+    // account as tool-owned; auto-restart-until-mergeable opts in to trusting
+    // same-account comments only while no AI tool execution is active, and
+    // still filters tool-generated comments by tracked IDs and marker strings.
     // Note: Patterns use word boundaries or end-of-string to avoid false positives
     // (e.g., "claudeuser" should NOT match as a bot)
     const botPatterns = [
@@ -201,21 +217,21 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
 
     const isBot = login => {
       if (!login) return false;
-      // Check if it's the current user (the bot running hive-mind)
-      if (currentUser && login === currentUser) return true;
       // Check against known bot patterns
       return botPatterns.some(pattern => pattern.test(login));
     };
 
+    const isToolComment = comment => isToolTrackedCommentId(comment.id) || isToolGeneratedComment(comment.body);
+
     // Fetch PR conversation comments
-    const prCommentsResult = await $`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate`;
+    const prCommentsResult = await commandRunner`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate`;
     let prComments = [];
     if (prCommentsResult.code === 0 && prCommentsResult.stdout) {
       prComments = JSON.parse(prCommentsResult.stdout.toString() || '[]');
     }
 
     // Fetch PR review comments (inline code comments)
-    const prReviewCommentsResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate`;
+    const prReviewCommentsResult = await commandRunner`gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate`;
     let prReviewComments = [];
     if (prReviewCommentsResult.code === 0 && prReviewCommentsResult.stdout) {
       prReviewComments = JSON.parse(prReviewCommentsResult.stdout.toString() || '[]');
@@ -224,7 +240,7 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
     // Fetch issue comments if we have an issue number
     let issueComments = [];
     if (issueNumber && issueNumber !== prNumber) {
-      const issueCommentsResult = await $`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
+      const issueCommentsResult = await commandRunner`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
       if (issueCommentsResult.code === 0 && issueCommentsResult.stdout) {
         issueComments = JSON.parse(issueCommentsResult.stdout.toString() || '[]');
       }
@@ -233,14 +249,28 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
     // Combine all comments
     const allComments = [...prComments, ...prReviewComments, ...issueComments];
 
-    // Filter for new comments from non-bot users
+    // Filter for new comments from non-bot users. Automated hive-mind/tool
+    // comments are excluded by marker/ID, including comments posted by the
+    // authenticated user during the current or a previous process.
     const newNonBotComments = allComments.filter(comment => {
       const commentTime = new Date(comment.created_at);
       const isAfterLastCheck = commentTime > lastCheckTime;
-      const isFromNonBot = !isBot(comment.user?.login);
-
-      if (verbose && isAfterLastCheck && isFromNonBot) {
-        console.log(`[VERBOSE] New non-bot comment from ${comment.user?.login} at ${comment.created_at}`);
+      const login = comment.user?.login;
+      const isFromAuthenticatedUser = Boolean(currentUser && login === currentUser);
+      const isFromTool = isToolComment(comment);
+      const isFromAuthenticatedUserToolContext = isFromAuthenticatedUser && !trustAuthenticatedUserComments;
+      const isFromBot = isBot(login) || isFromAuthenticatedUserToolContext;
+      const isFromNonBot = !isFromBot && !isFromTool;
+
+      if (verbose && isAfterLastCheck && isFromTool) {
+        console.log(`[VERBOSE] Skipping tool-generated comment from ${login} at ${comment.created_at}`);
+      } else if (verbose && isAfterLastCheck && isFromAuthenticatedUserToolContext) {
+        console.log(`[VERBOSE] Skipping authenticated-user comment from ${login} at ${comment.created_at} because same-account feedback is not trusted in this context`);
+      } else if (verbose && isAfterLastCheck && isFromBot) {
+        console.log(`[VERBOSE] Skipping bot comment from ${login} at ${comment.created_at}`);
+      } else if (verbose && isAfterLastCheck && isFromNonBot) {
+        const sameAccountSuffix = currentUser && login === currentUser ? ' (authenticated user)' : '';
+        console.log(`[VERBOSE] New non-bot comment from ${login}${sameAccountSuffix} at ${comment.created_at}`);
       }
 
       return isAfterLastCheck && isFromNonBot;

package/src/solve.auto-merge.lib.mjs

@@ -206,8 +206,12 @@ export const watchUntilMergeable = async params => {
         // Keep the counter as-is (it reached the safety valve or wasn't needed).
       }
 
-      // Check for new comments from non-bot users
-      const { hasNewComments, comments } = await checkForNonBotComments(owner, repo, prNumber, issueNumber, lastCheckTime, argv.verbose);
+      // Check for new comments from non-bot users. At this point the AI tool
+      // is not executing, so same-account non-tool comments can be trusted as
+      // human feedback while known tool comments remain filtered by markers/IDs.
+      const { hasNewComments, comments } = await checkForNonBotComments(owner, repo, prNumber, issueNumber, lastCheckTime, argv.verbose, $, {
+        trustAuthenticatedUserComments: true,
+      });
 
       // Check for uncommitted changes using shared utility
       const hasUncommittedChanges = await checkForUncommittedChanges(tempDir, argv);

package/src/solve.auto-pr-placeholder.lib.mjs

@@ -0,0 +1,70 @@
+/**
+ * Placeholder-staging helper for auto PR creation.
+ *
+ * Extracted from solve.auto-pr.lib.mjs (issue #1825) to keep that module under
+ * the max-lines lint budget.
+ */
+
+/**
+ * Stage the temporary placeholder file (CLAUDE.md or .gitkeep) used to seed the
+ * initial auto-PR commit.
+ *
+ * The solver writes this placeholder deliberately to create the first commit so
+ * a draft PR can be opened, and removes it again once the task completes (see
+ * cleanupClaudeFile in solve.results.lib.mjs). When the target repository's
+ * .gitignore matches the placeholder — issue #1825: e.g. rumaster/tg-games
+ * ignores `.gitkeep` — a plain `git add <file>` exits non-zero with
+ * "The following paths are ignored by one of your .gitignore files", which
+ * previously aborted PR creation with a fatal "Failed to add .gitkeep".
+ *
+ * Because the placeholder belongs to us and is short-lived, we confirm the path
+ * is actually ignored with `git check-ignore` and then retry with
+ * `git add -f`. Force-adding only happens for the ignored-placeholder case;
+ * any other add failure is surfaced unchanged so genuine errors are not masked.
+ *
+ * @param {object} params
+ * @param {Function} params.$ - command-stream tagged-template runner.
+ * @param {string} params.tempDir - repository working directory.
+ * @param {string} params.fileName - placeholder file name (CLAUDE.md or .gitkeep).
+ * @param {Function} [params.log] - async logger.
+ * @param {Function} [params.formatAligned] - log line formatter.
+ * @param {boolean} [params.verbose] - emit verbose diagnostics.
+ * @returns {Promise<{code: number, forced: boolean, ignored: boolean, stderr: string}>}
+ */
+export async function addPlaceholderFileToGit({ $, tempDir, fileName, log, formatAligned, verbose = false }) {
+  // Run silently: `git add` is quiet on success and only emits the noisy
+  // "paths are ignored ... Use -f" hint on failure, which we capture in
+  // `stderr` and re-surface from the caller only when the failure is genuine.
+  const addResult = await $({ cwd: tempDir, silent: true })`git add ${fileName}`;
+  if (addResult.code === 0) {
+    return { code: 0, forced: false, ignored: false, stderr: '' };
+  }
+
+  const stderr = addResult.stderr ? addResult.stderr.toString() : '';
+
+  // Determine whether the add failed because the placeholder is git-ignored.
+  // `git check-ignore` exits 0 when the path matches a .gitignore rule.
+  const checkIgnore = await $({ cwd: tempDir, silent: true })`git check-ignore ${fileName}`;
+  const ignored = checkIgnore.code === 0;
+
+  if (!ignored) {
+    // The failure was not caused by .gitignore — surface the original error so
+    // genuine problems (permissions, corrupt index, ...) are not masked.
+    return { code: addResult.code, forced: false, ignored: false, stderr };
+  }
+
+  if (log && formatAligned) {
+    await log(formatAligned('ℹ️', `${fileName} is ignored:`, 'Force-adding placeholder (git add -f)'));
+  }
+  if (verbose && log) {
+    await log(`   ${fileName} matched a .gitignore rule; retrying with: git add -f ${fileName}`, { verbose: true });
+  }
+
+  const forcedResult = await $({ cwd: tempDir, silent: true })`git add -f ${fileName}`;
+  return {
+    code: forcedResult.code,
+    forced: true,
+    ignored: true,
+    stderr: forcedResult.stderr ? forcedResult.stderr.toString() : '',
+  };
+}

package/src/solve.auto-pr.lib.mjs

@@ -8,6 +8,7 @@ import { handleRejectedPushForAutoPr, synchronizeExistingIssueBranchBeforeAutoPr
 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.
+import { addPlaceholderFileToGit } from './solve.auto-pr-placeholder.lib.mjs'; // Issue #1825: force-adds the seed placeholder when the target repo gitignores it.
 
 export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNumber, owner, repo, defaultBranch, forkedRepo, isContinueMode, prNumber, log, formatAligned, $, reportError, path, fs }) {
   // Skip auto-PR creation if:
@@ -166,12 +167,13 @@ Proceed.
     // Add and commit the file
     await log(formatAligned('📦', 'Adding file:', 'To git staging'));
 
-    // Use explicit cwd option for better reliability
-    const addResult = await $({ cwd: tempDir })`git add ${fileName}`;
+    // Issue #1825: force-adds the placeholder when the target repo gitignores
+    // it (e.g. ignores `.gitkeep`), so PR creation is no longer aborted.
+    const addResult = await addPlaceholderFileToGit({ $, tempDir, fileName, log, formatAligned, verbose: argv.verbose });
 
     if (addResult.code !== 0) {
       await log(`❌ Failed to add ${fileName}`, { level: 'error' });
-      await log(`   Error: ${addResult.stderr ? addResult.stderr.toString() : 'Unknown error'}`, { level: 'error' });
+      await log(`   Error: ${addResult.stderr || 'Unknown error'}`, { level: 'error' });
       throw new Error(`Failed to add ${fileName}`);
     }
 
@@ -212,12 +214,12 @@ Proceed.
           await fs.writeFile(gitkeepPath, gitkeepContent);
           await log(formatAligned('✅', 'Created:', '.gitkeep file'));
 
-          // Try to add .gitkeep
-          const gitkeepAddResult = await $({ cwd: tempDir })`git add .gitkeep`;
+          // Try to add .gitkeep (force-added if it too is gitignored — issue #1825)
+          const gitkeepAddResult = await addPlaceholderFileToGit({ $, tempDir, fileName: '.gitkeep', log, formatAligned, verbose: argv.verbose });
 
           if (gitkeepAddResult.code !== 0) {
             await log('❌ Failed to add .gitkeep', { level: 'error' });
-            await log(`   Error: ${gitkeepAddResult.stderr ? gitkeepAddResult.stderr.toString() : 'Unknown error'}`, {
+            await log(`   Error: ${gitkeepAddResult.stderr || 'Unknown error'}`, {
               level: 'error',
             });
             throw new Error('Failed to add .gitkeep');