@link-assistant/hive-mind 1.69.0 → 1.69.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.69.2
+
+### Patch Changes
+
+- 0ff36b4: Count open draft pull requests when `/hive --skip-issues-with-prs` checks linked solution drafts, preventing duplicate work while an existing PR is still in progress.
+
+## 1.69.1
+
+### Patch Changes
+
+- 2911597: Fix feedback comment counting to run local git timestamp checks in the prepared repository directory, avoiding misleading `not a git repository` diagnostics in detached solve sessions.
+
 ## 1.69.0
 
 ### Minor Changes

package/package.json

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

package/src/github-linking.lib.mjs

@@ -26,66 +26,71 @@ export function getGitHubLinkingKeywords() {
   return ['close', 'closes', 'closed', 'fix', 'fixes', 'fixed', 'resolve', 'resolves', 'resolved'];
 }
 
-/**
- * Check if PR body contains a valid GitHub linking keyword for the given issue
- *
- * @param {string} prBody - The pull request body text
- * @param {string|number} issueNumber - The issue number to check for
- * @param {string} [owner] - Repository owner (for cross-repo references)
- * @param {string} [repo] - Repository name (for cross-repo references)
- * @returns {boolean} True if a valid linking keyword is found
- */
-export function hasGitHubLinkingKeyword(prBody, issueNumber, owner = null, repo = null) {
-  if (!prBody || !issueNumber) {
-    return false;
-  }
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 
-  const keywords = getGitHubLinkingKeywords();
-  const issueNumStr = issueNumber.toString();
+function buildClosingReferencePatterns(keyword, issueNumber, owner = null, repo = null) {
+  const issueNumStr = escapeRegExp(issueNumber);
+  const separator = String.raw`(?:\s+|\s*:\s*)`;
+  const prefix = String.raw`\b${keyword}${separator}`;
+  const references = [String.raw`#${issueNumStr}\b`];
 
-  // Build regex patterns for each valid format:
-  // 1. KEYWORD #123
-  // 2. KEYWORD owner/repo#123
-  // 3. KEYWORD https://github.com/owner/repo/issues/123
+  if (owner && repo) {
+    references.push(`${escapeRegExp(owner)}/${escapeRegExp(repo)}#${issueNumStr}\\b`);
+    references.push(`https://github\\.com/${escapeRegExp(owner)}/${escapeRegExp(repo)}/issues/${issueNumStr}\\b`);
+  }
 
-  for (const keyword of keywords) {
-    // Pattern 1: KEYWORD #123
-    // Must have word boundary before keyword and # immediately before number
-    const pattern1 = new RegExp(`\\b${keyword}\\s+#${issueNumStr}\\b`, 'i');
+  references.push(String.raw`[\w.-]+/[\w.-]+#${issueNumStr}\b`);
+  references.push(`https://github\\.com/[^/\\s]+/[^/\\s]+/issues/${issueNumStr}\\b`);
 
-    if (pattern1.test(prBody)) {
-      return true;
-    }
-
-    // Pattern 2: KEYWORD owner/repo#123 (for cross-repo or fork references)
-    if (owner && repo) {
-      const pattern2 = new RegExp(`\\b${keyword}\\s+${owner}/${repo}#${issueNumStr}\\b`, 'i');
+  return references.map(reference => new RegExp(`${prefix}${reference}`, 'i'));
+}
 
-      if (pattern2.test(prBody)) {
-        return true;
-      }
-    }
+/**
+ * Check whether text contains a GitHub closing keyword for a specific issue.
+ *
+ * This is the shared parser used by solve and hive code paths so they agree on
+ * which PR body/title references are real closing links.
+ *
+ * @param {string} text - Pull request body or title text
+ * @param {string|number} issueNumber - Issue number to check for
+ * @param {string} [owner] - Repository owner for exact owner/repo references
+ * @param {string} [repo] - Repository name for exact owner/repo references
+ * @returns {boolean} True if a valid closing reference is found
+ */
+export function prClosesIssue(text, issueNumber, owner = null, repo = null) {
+  if (!text || typeof text !== 'string' || issueNumber === null || issueNumber === undefined || String(issueNumber).trim() === '') {
+    return false;
+  }
 
-    // Pattern 3: KEYWORD https://github.com/owner/repo/issues/123
-    if (owner && repo) {
-      const pattern3 = new RegExp(`\\b${keyword}\\s+https://github\\.com/${owner}/${repo}/issues/${issueNumStr}\\b`, 'i');
+  const issueNumStr = String(issueNumber).trim();
 
-      if (pattern3.test(prBody)) {
+  for (const keyword of getGitHubLinkingKeywords()) {
+    const patterns = buildClosingReferencePatterns(keyword, issueNumStr, owner, repo);
+    for (const pattern of patterns) {
+      if (pattern.test(text)) {
         return true;
       }
     }
-
-    // Pattern 4: Also check for any URL format (generic)
-    const pattern4 = new RegExp(`\\b${keyword}\\s+https://github\\.com/[^/]+/[^/]+/issues/${issueNumStr}\\b`, 'i');
-
-    if (pattern4.test(prBody)) {
-      return true;
-    }
   }
 
   return false;
 }
 
+/**
+ * Check if PR body contains a valid GitHub linking keyword for the given issue
+ *
+ * @param {string} prBody - The pull request body text
+ * @param {string|number} issueNumber - The issue number to check for
+ * @param {string} [owner] - Repository owner (for cross-repo references)
+ * @param {string} [repo] - Repository name (for cross-repo references)
+ * @returns {boolean} True if a valid linking keyword is found
+ */
+export function hasGitHubLinkingKeyword(prBody, issueNumber, owner = null, repo = null) {
+  return prClosesIssue(prBody, issueNumber, owner, repo);
+}
+
 /**
  * Extract issue number from PR body using GitHub linking keywords
  * This is used to find which issue a PR is linked to

package/src/github.batch.lib.mjs

@@ -10,53 +10,46 @@ if (typeof globalThis.use === 'undefined') {
 // Import dependencies
 import { log, cleanErrorMessage } from './lib.mjs';
 import { githubLimits, timeouts } from './config.lib.mjs';
+import { prClosesIssue } from './github-linking.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. execGhWithRetry adds transient-network retry (#1756).
+export { prClosesIssue };
+
 /**
- * Check if a PR body/title indicates it fixes/closes/resolves a specific issue number
- * GitHub auto-closes issues when PR body contains keywords like "fixes #123", "closes #123", "resolves #123"
- * See: https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue
- * @param {string} text - PR body or title text
- * @param {number} issueNumber - Issue number to check for
- * @returns {boolean} True if the text contains a closing keyword for this issue
+ * Extract open pull requests that are linked to an issue with closing keywords.
+ * Draft pull requests are still open in-progress solution drafts, so they must
+ * count for /hive --skip-issues-with-prs.
+ * @param {Object} issueData - GraphQL issue node with timelineItems
+ * @param {number} issueNum - Issue number to check
+ * @param {Function} logger - Async logger, defaults to shared log helper
+ * @returns {Promise<Array<Object>>} Linked open PRs that close the issue
  */
-export function prClosesIssue(text, issueNumber) {
-  if (!text || typeof text !== 'string') {
-    return false;
-  }
-
-  // GitHub closing keywords (case-insensitive)
-  // Supports: fix, fixes, fixed, close, closes, closed, resolve, resolves, resolved
-  // Also supports variations with repository prefix like "fixes owner/repo#123"
-  const closingKeywords = ['fix', 'fixes', 'fixed', 'close', 'closes', 'closed', 'resolve', 'resolves', 'resolved'];
-
-  // Build regex pattern that matches any of the keywords followed by #N or repo#N
-  // Examples matched:
-  //   - "fixes #123"
-  //   - "Closes #123"
-  //   - "RESOLVED #123"
-  //   - "fixes owner/repo#123"
-  //   - "fix: #123" (common commit style)
-  const issueNum = issueNumber.toString();
-
-  for (const keyword of closingKeywords) {
-    // Pattern: keyword + optional colon/space + optional repo prefix + # + issue number
-    // Must be followed by word boundary (not part of larger number)
-    const patterns = [
-      // Standard format: "fixes #123"
-      new RegExp(`\\b${keyword}\\s*:?\\s*#${issueNum}\\b`, 'i'),
-      // With repo prefix: "fixes owner/repo#123"
-      new RegExp(`\\b${keyword}\\s*:?\\s*[\\w.-]+/[\\w.-]+#${issueNum}\\b`, 'i'),
-    ];
-
-    for (const pattern of patterns) {
-      if (pattern.test(text)) {
-        return true;
+export async function extractLinkedPullRequestsForIssue(issueData, issueNum, logger = log) {
+  const linkedPRs = [];
+
+  for (const item of issueData.timelineItems?.nodes || []) {
+    if (item?.source && item.source.state === 'OPEN') {
+      // Check if PR actually closes this issue (has "fixes #N", "closes #N", or "resolves #N")
+      const prBody = item.source.body || '';
+      const prTitle = item.source.title || '';
+      const closesThisIssue = prClosesIssue(prBody, issueNum) || prClosesIssue(prTitle, issueNum);
+
+      if (closesThisIssue) {
+        linkedPRs.push({
+          number: item.source.number,
+          title: item.source.title,
+          state: item.source.state,
+          isDraft: Boolean(item.source.isDraft),
+          url: item.source.url,
+        });
+      } else {
+        // Log that we're skipping a PR that only mentions the issue
+        await logger(`      ℹ️  PR #${item.source.number} mentions issue #${issueNum} but doesn't close it (no fixes/closes/resolves keyword)`, { verbose: true });
       }
     }
   }
 
-  return false;
+  return linkedPRs;
 }
 
 /**
@@ -140,31 +133,11 @@ export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers)
         for (const issueNum of batch) {
           const issueData = data.data?.repository?.[`issue${issueNum}`];
           if (issueData) {
-            const linkedPRs = [];
-
-            // Extract linked PRs from timeline items
+            // Extract linked PRs from timeline items, including draft PRs.
             // Issue #1094: Only count PRs that explicitly fix/close/resolve this issue
             // This prevents false positives from PRs that only mention issues without solving them
-            for (const item of issueData.timelineItems?.nodes || []) {
-              if (item?.source && item.source.state === 'OPEN' && !item.source.isDraft) {
-                // Check if PR actually closes this issue (has "fixes #N", "closes #N", or "resolves #N")
-                const prBody = item.source.body || '';
-                const prTitle = item.source.title || '';
-                const closesThisIssue = prClosesIssue(prBody, issueNum) || prClosesIssue(prTitle, issueNum);
-
-                if (closesThisIssue) {
-                  linkedPRs.push({
-                    number: item.source.number,
-                    title: item.source.title,
-                    state: item.source.state,
-                    url: item.source.url,
-                  });
-                } else {
-                  // Log that we're skipping a PR that only mentions the issue
-                  await log(`      ℹ️  PR #${item.source.number} mentions issue #${issueNum} but doesn't close it (no fixes/closes/resolves keyword)`, { verbose: true });
-                }
-              }
-            }
+            // Issue #1760: Draft PRs are still active solution drafts and must block duplicate work
+            const linkedPRs = await extractLinkedPullRequestsForIssue(issueData, issueNum);
 
             results[issueNum] = {
               title: issueData.title,
@@ -337,6 +310,7 @@ export async function batchCheckArchivedRepositories(repositories) {
 // Export all functions as default object too
 export default {
   prClosesIssue,
+  extractLinkedPullRequestsForIssue,
   batchCheckPullRequestsForIssues,
   batchCheckArchivedRepositories,
 };

package/src/solve.feedback.lib.mjs

@@ -8,7 +8,7 @@ import { reportError } from './sentry.lib.mjs';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
 export const detectAndCountFeedback = async params => {
-  const { prNumber, branchName, owner, repo, issueNumber, isContinueMode, argv, mergeStateStatus, prState, workStartTime, log, formatAligned, cleanErrorMessage, $ } = params;
+  const { prNumber, branchName, owner, repo, issueNumber, isContinueMode, argv, mergeStateStatus, prState, workStartTime, log, formatAligned, cleanErrorMessage, $, repositoryPath = null } = params;
 
   let newPrComments = 0;
   let newPrReviewComments = 0;
@@ -53,14 +53,18 @@ export const detectAndCountFeedback = async params => {
       if (argv.verbose) {
         await log(`   PR #${prNumber} on branch: ${branchName}`, { verbose: true });
         await log(`   Owner/Repo: ${owner}/${repo}`, { verbose: true });
+        if (repositoryPath) {
+          await log(`   Repository path: ${repositoryPath}`, { verbose: true });
+        }
       }
 
       // Get the last commit timestamp from the PR branch
       let lastCommitTime = null;
-      let lastCommitResult = await $`git log -1 --format="%aI" origin/${branchName}`;
+      const git$ = repositoryPath ? $({ cwd: repositoryPath }) : $;
+      let lastCommitResult = await git$`git log -1 --format="%aI" origin/${branchName}`;
       if (lastCommitResult.code !== 0) {
         // Fallback to local branch if remote doesn't exist
-        lastCommitResult = await $`git log -1 --format="%aI" ${branchName}`;
+        lastCommitResult = await git$`git log -1 --format="%aI" ${branchName}`;
       }
 
       if (lastCommitResult.code === 0) {

package/src/solve.mjs

@@ -623,6 +623,7 @@ try {
     log,
     formatAligned,
     cleanErrorMessage,
+    tempDir,
     $,
   });
 

package/src/solve.preparation.lib.mjs

@@ -8,7 +8,7 @@ import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-l
 const feedback = await import('./solve.feedback.lib.mjs');
 const { detectAndCountFeedback } = feedback;
 
-export async function prepareFeedbackAndTimestamps({ prNumber, branchName: _branchName, owner, repo, issueNumber, isContinueMode: _isContinueMode, mergeStateStatus: _mergeStateStatus, prState: _prState, argv: _argv, log, formatAligned, cleanErrorMessage: _cleanErrorMessage, $ }) {
+export async function prepareFeedbackAndTimestamps({ tempDir = null, prNumber, branchName: _branchName, owner, repo, issueNumber, isContinueMode: _isContinueMode, mergeStateStatus: _mergeStateStatus, prState: _prState, argv: _argv, log, formatAligned, cleanErrorMessage: _cleanErrorMessage, $ }) {
   // Count new comments and detect feedback
   let { feedbackLines } = await detectAndCountFeedback({
     prNumber,
@@ -25,6 +25,7 @@ export async function prepareFeedbackAndTimestamps({ prNumber, branchName: _bran
     formatAligned,
     cleanErrorMessage: _cleanErrorMessage,
     $,
+    repositoryPath: tempDir,
   });
 
   // Get timestamps from GitHub servers before executing the command

package/src/solve.watch.lib.mjs

@@ -209,6 +209,7 @@ export const watchForFeedback = async params => {
         formatAligned,
         cleanErrorMessage,
         $,
+        repositoryPath: tempDir,
       });
 
       // Check if there's any feedback or if it's the first iteration in temporary mode