@link-assistant/hive-mind 0.39.0

package/src/github-linking.lib.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+/**
+ * GitHub Issue Linking Detection Library
+ *
+ * This module provides utilities to detect GitHub's reserved keywords for linking
+ * pull requests to issues according to GitHub's official documentation:
+ * https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue
+ *
+ * Valid linking keywords (case-insensitive):
+ * - close, closes, closed
+ * - fix, fixes, fixed
+ * - resolve, resolves, resolved
+ *
+ * Valid formats:
+ * - KEYWORD #ISSUE-NUMBER
+ * - KEYWORD OWNER/REPO#ISSUE-NUMBER
+ * - KEYWORD https://github.com/OWNER/REPO/issues/ISSUE-NUMBER
+ */
+
+/**
+ * Get all valid GitHub linking keywords
+ * @returns {string[]} Array of valid linking keywords
+ */
+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;
+  }
+
+  const keywords = getGitHubLinkingKeywords();
+  const issueNumStr = issueNumber.toString();
+
+  // Build regex patterns for each valid format:
+  // 1. KEYWORD #123
+  // 2. KEYWORD owner/repo#123
+  // 3. KEYWORD https://github.com/owner/repo/issues/123
+
+  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'
+    );
+
+    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'
+      );
+
+      if (pattern2.test(prBody)) {
+        return true;
+      }
+    }
+
+    // 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'
+      );
+
+      if (pattern3.test(prBody)) {
+        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;
+}
+
+/**
+ * Extract issue number from PR body using GitHub linking keywords
+ * This is used to find which issue a PR is linked to
+ *
+ * @param {string} prBody - The pull request body text
+ * @returns {string|null} The issue number if found, null otherwise
+ */
+export function extractLinkedIssueNumber(prBody) {
+  if (!prBody) {
+    return null;
+  }
+
+  const keywords = getGitHubLinkingKeywords();
+
+  for (const keyword of keywords) {
+    // Try to match: KEYWORD #123
+    const pattern1 = new RegExp(
+      `\\b${keyword}\\s+#(\\d+)\\b`,
+      'i'
+    );
+    const match1 = prBody.match(pattern1);
+    if (match1) {
+      return match1[1];
+    }
+
+    // Try to match: KEYWORD owner/repo#123
+    const pattern2 = new RegExp(
+      `\\b${keyword}\\s+[^/\\s]+/[^/\\s]+#(\\d+)\\b`,
+      'i'
+    );
+    const match2 = prBody.match(pattern2);
+    if (match2) {
+      return match2[1];
+    }
+
+    // Try to match: KEYWORD https://github.com/owner/repo/issues/123
+    const pattern3 = new RegExp(
+      `\\b${keyword}\\s+https://github\\.com/[^/]+/[^/]+/issues/(\\d+)\\b`,
+      'i'
+    );
+    const match3 = prBody.match(pattern3);
+    if (match3) {
+      return match3[1];
+    }
+  }
+
+  return null;
+}

package/src/github.batch.lib.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+// GitHub batch operations using GraphQL
+
+// Check if use is already defined (when imported from solve.mjs)
+// If not, fetch it (when running standalone)
+if (typeof globalThis.use === 'undefined') {
+  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+}
+
+// Import dependencies
+import { log, cleanErrorMessage } from './lib.mjs';
+import { githubLimits, timeouts } from './config.lib.mjs';
+
+/**
+ * Batch fetch pull request information for multiple issues using GraphQL
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {Array<number>} issueNumbers - Array of issue numbers to check
+ * @returns {Promise<Object>} Object mapping issue numbers to their linked PRs
+ */
+export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers) {
+  try {
+    if (!issueNumbers || issueNumbers.length === 0) {
+      return {};
+    }
+
+    await log(`   🔍 Batch checking PRs for ${issueNumbers.length} issues using GraphQL...`, { verbose: true });
+
+    // GraphQL has complexity limits, so batch in groups of 50
+    const BATCH_SIZE = 50;
+    const results = {};
+
+    for (let i = 0; i < issueNumbers.length; i += BATCH_SIZE) {
+      const batch = issueNumbers.slice(i, i + BATCH_SIZE);
+
+      // Build GraphQL query for this batch
+      const query = `
+        query GetPullRequestsForIssues {
+          repository(owner: "${owner}", name: "${repo}") {
+            ${batch.map(num => `
+            issue${num}: issue(number: ${num}) {
+              number
+              title
+              state
+              timelineItems(first: 100, itemTypes: [CROSS_REFERENCED_EVENT]) {
+                nodes {
+                  ... on CrossReferencedEvent {
+                    source {
+                      ... on PullRequest {
+                        number
+                        title
+                        state
+                        isDraft
+                        url
+                      }
+                    }
+                  }
+                }
+              }
+            }`).join('\n')}
+          }
+        }
+      `;
+
+      try {
+        // Add small delay between batches to respect rate limits
+        if (i > 0) {
+          await log('   ⏰ Waiting 2 seconds before next batch...', { verbose: true });
+          await new Promise(resolve => setTimeout(resolve, timeouts.githubRepoDelay));
+        }
+
+        // Execute GraphQL query
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        const { stdout } = await execAsync(`gh api graphql -f query='${query}'`, {
+          encoding: 'utf8',
+          maxBuffer: githubLimits.bufferMaxSize,
+          env: process.env
+        });
+
+        const data = JSON.parse(stdout);
+
+        // Process results for this batch
+        for (const issueNum of batch) {
+          const issueData = data.data?.repository?.[`issue${issueNum}`];
+          if (issueData) {
+            const linkedPRs = [];
+
+            // Extract linked PRs from timeline items
+            for (const item of issueData.timelineItems?.nodes || []) {
+              if (item?.source && item.source.state === 'OPEN' && !item.source.isDraft) {
+                linkedPRs.push({
+                  number: item.source.number,
+                  title: item.source.title,
+                  state: item.source.state,
+                  url: item.source.url
+                });
+              }
+            }
+
+            results[issueNum] = {
+              title: issueData.title,
+              state: issueData.state,
+              openPRCount: linkedPRs.length,
+              linkedPRs: linkedPRs
+            };
+          } else {
+            // Issue not found or error
+            results[issueNum] = {
+              openPRCount: 0,
+              linkedPRs: [],
+              error: 'Issue not found'
+            };
+          }
+        }
+
+        await log(`   ✅ Batch ${Math.floor(i / BATCH_SIZE) + 1}/${Math.ceil(issueNumbers.length / BATCH_SIZE)} processed (${batch.length} issues)`, { verbose: true });
+
+      } catch (batchError) {
+        await log(`   ⚠️  GraphQL batch query failed: ${cleanErrorMessage(batchError)}`, { level: 'warning' });
+
+        // Fall back to individual REST API calls for this batch
+        await log('   🔄 Falling back to REST API for batch...', { verbose: true });
+
+        for (const issueNum of batch) {
+          try {
+            const { exec } = await import('child_process');
+            const { promisify } = await import('util');
+            const execAsync = promisify(exec);
+            const cmd = `gh api repos/${owner}/${repo}/issues/${issueNum}/timeline --jq '[.[] | select(.event == "cross-referenced" and .source.issue.pull_request != null and .source.issue.state == "open")] | length'`;
+
+            const { stdout } = await execAsync(cmd, { encoding: 'utf8', env: process.env });
+            const openPrCount = parseInt(stdout.trim()) || 0;
+
+            results[issueNum] = {
+              openPRCount: openPrCount,
+              linkedPRs: [] // REST API doesn't give us PR details easily
+            };
+          } catch (restError) {
+            results[issueNum] = {
+              openPRCount: 0,
+              linkedPRs: [],
+              error: cleanErrorMessage(restError)
+            };
+          }
+        }
+      }
+    }
+
+    // Log summary
+    const totalIssues = issueNumbers.length;
+    const issuesWithPRs = Object.values(results).filter(r => r.openPRCount > 0).length;
+    await log(`   📊 Batch PR check complete: ${issuesWithPRs}/${totalIssues} issues have open PRs`, { verbose: true });
+
+    return results;
+
+  } catch (error) {
+    await log(`   ❌ Batch PR check failed: ${cleanErrorMessage(error)}`, { level: 'error' });
+    return {};
+  }
+}
+
+/**
+ * Batch check if repositories are archived using GraphQL
+ * This is more efficient than checking each repository individually
+ * @param {Array<{owner: string, name: string}>} repositories - Array of repository objects with owner and name
+ * @returns {Promise<Object>} Object mapping "owner/repo" to isArchived boolean
+ */
+export async function batchCheckArchivedRepositories(repositories) {
+  try {
+    if (!repositories || repositories.length === 0) {
+      return {};
+    }
+
+    await log(`   🔍 Batch checking archived status for ${repositories.length} repositories...`, { verbose: true });
+
+    // GraphQL has complexity limits, so batch in groups of 50
+    const BATCH_SIZE = 50;
+    const results = {};
+
+    for (let i = 0; i < repositories.length; i += BATCH_SIZE) {
+      const batch = repositories.slice(i, i + BATCH_SIZE);
+
+      // Build GraphQL query for this batch
+      const queryFields = batch.map((repo, index) => `
+        repo${index}: repository(owner: "${repo.owner}", name: "${repo.name}") {
+          nameWithOwner
+          isArchived
+        }`).join('\n');
+
+      const query = `
+        query CheckArchivedStatus {
+          ${queryFields}
+        }
+      `;
+
+      try {
+        // Add small delay between batches to respect rate limits
+        if (i > 0) {
+          await log('   ⏰ Waiting 2 seconds before next batch...', { verbose: true });
+          await new Promise(resolve => setTimeout(resolve, timeouts.githubRepoDelay));
+        }
+
+        // Execute GraphQL query
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        const { stdout } = await execAsync(`gh api graphql -f query='${query}'`, {
+          encoding: 'utf8',
+          maxBuffer: githubLimits.bufferMaxSize,
+          env: process.env
+        });
+
+        const data = JSON.parse(stdout);
+
+        // Process results for this batch
+        batch.forEach((repo, index) => {
+          const repoData = data.data?.[`repo${index}`];
+          if (repoData) {
+            const repoKey = `${repo.owner}/${repo.name}`;
+            results[repoKey] = repoData.isArchived;
+          }
+        });
+
+        await log(`   ✅ Batch ${Math.floor(i / BATCH_SIZE) + 1}/${Math.ceil(repositories.length / BATCH_SIZE)} processed (${batch.length} repositories)`, { verbose: true });
+
+      } catch (batchError) {
+        await log(`   ⚠️  GraphQL batch query failed: ${cleanErrorMessage(batchError)}`, { level: 'warning' });
+
+        // Fall back to individual REST API calls for this batch
+        await log('   🔄 Falling back to REST API for batch...', { verbose: true });
+
+        for (const repo of batch) {
+          try {
+            const { exec } = await import('child_process');
+            const { promisify } = await import('util');
+            const execAsync = promisify(exec);
+            const cmd = `gh api repos/${repo.owner}/${repo.name} --jq .archived`;
+
+            const { stdout } = await execAsync(cmd, { encoding: 'utf8', env: process.env });
+            const isArchived = stdout.trim() === 'true';
+
+            const repoKey = `${repo.owner}/${repo.name}`;
+            results[repoKey] = isArchived;
+          } catch {
+            // If we can't check, assume it's not archived (safer to include than exclude)
+            const repoKey = `${repo.owner}/${repo.name}`;
+            results[repoKey] = false;
+            await log(`   ⚠️  Could not check ${repoKey}, assuming not archived`, { verbose: true });
+          }
+        }
+      }
+    }
+
+    // Log summary
+    const archivedCount = Object.values(results).filter(isArchived => isArchived).length;
+    await log(`   📊 Batch archived check complete: ${archivedCount}/${repositories.length} repositories are archived`, { verbose: true });
+
+    return results;
+
+  } catch (error) {
+    await log(`   ❌ Batch archived check failed: ${cleanErrorMessage(error)}`, { level: 'error' });
+    return {};
+  }
+}
+
+// Export all functions as default object too
+export default {
+  batchCheckPullRequestsForIssues,
+  batchCheckArchivedRepositories
+};

package/src/github.graphql.lib.mjs

@@ -0,0 +1,258 @@
+/**
+ * GraphQL API utilities for GitHub issue fetching
+ * This module provides functions to fetch issues using GitHub's GraphQL API
+ */
+
+/**
+ * Fetch issues from a single repository with pagination support for >100 issues
+ * @param {string} owner - Repository owner
+ * @param {string} repoName - Repository name
+ * @param {Function} log - Logging function
+ * @param {Function} cleanErrorMessage - Error message cleaner
+ * @param {number} issueLimit - Maximum number of issues to fetch per query (default 100)
+ * @returns {Promise<Array>} Array of issues
+ */
+async function fetchRepositoryIssuesWithPagination(owner, repoName, log, cleanErrorMessage, issueLimit = 100) {
+  const { exec } = await import('child_process');
+  const { promisify } = await import('util');
+  const execAsync = promisify(exec);
+  const allIssues = [];
+  let hasNextPage = true;
+  let cursor = null;
+  let pageNum = 0;
+
+  try {
+    while (hasNextPage) {
+      pageNum++;
+
+      // Build query with cursor for pagination
+      const graphqlQuery = `
+        query($owner: String!, $repo: String!, $issueLimit: Int!, $cursor: String) {
+          repository(owner: $owner, name: $repo) {
+            issues(states: OPEN, first: $issueLimit, after: $cursor) {
+              totalCount
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+              nodes {
+                number
+                title
+                url
+                createdAt
+              }
+            }
+          }
+        }
+      `;
+
+      // Execute GraphQL query
+      const escapedQuery = graphqlQuery.replace(/'/g, '\'\\\'\'');
+      let graphqlCmd = `gh api graphql -f query='${escapedQuery}' -f owner='${owner}' -f repo='${repoName}' -F issueLimit=${issueLimit}`;
+
+      if (cursor) {
+        graphqlCmd += ` -f cursor='${cursor}'`;
+      }
+
+      await log(`      📄 Fetching issues page ${pageNum} from ${owner}/${repoName}...`, { verbose: true });
+
+      // Add delay for rate limiting
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      const { stdout } = await execAsync(graphqlCmd, { encoding: 'utf8', env: process.env });
+      const data = JSON.parse(stdout);
+      const issuesData = data.data.repository.issues;
+
+      // Add issues to collection
+      allIssues.push(...issuesData.nodes);
+
+      // Check if there are more pages
+      hasNextPage = issuesData.pageInfo.hasNextPage;
+      cursor = issuesData.pageInfo.endCursor;
+
+      await log(`      ✅ Fetched ${issuesData.nodes.length} issues (total so far: ${allIssues.length}/${issuesData.totalCount})`, { verbose: true });
+    }
+
+    return allIssues;
+
+  } catch (error) {
+    await log(`      ❌ Failed to fetch issues from ${owner}/${repoName}: ${cleanErrorMessage(error)}`, { verbose: true });
+    // Return what we have so far
+    return allIssues;
+  }
+}
+
+/**
+ * Try to fetch issues using GraphQL API with full pagination support
+ * This approach uses cursor-based pagination to handle unlimited repositories and issues
+ * @param {string} owner - Organization or user name
+ * @param {string} scope - 'organization' or 'user'
+ * @param {Function} log - Logging function
+ * @param {Function} cleanErrorMessage - Error message cleaner
+ * @param {number} repoLimit - Maximum number of repos to fetch per query (default 100)
+ * @param {number} issueLimit - Maximum number of issues to fetch per repo query (default 100)
+ * @returns {Promise<{success: boolean, issues: Array, repoCount: number}>}
+ */
+export async function tryFetchIssuesWithGraphQL(owner, scope, log, cleanErrorMessage, repoLimit = 100, issueLimit = 100) {
+  const { exec } = await import('child_process');
+  const { promisify } = await import('util');
+  const execAsync = promisify(exec);
+
+  try {
+    await log('   🧪 Attempting GraphQL approach with pagination support...', { verbose: true });
+
+    const isOrg = scope === 'organization';
+    const allRepos = [];
+    let hasNextRepoPage = true;
+    let repoCursor = null;
+    let repoPageNum = 0;
+
+    // Fetch all repositories with pagination
+    while (hasNextRepoPage) {
+      repoPageNum++;
+
+      // Build GraphQL query to fetch repos
+      const graphqlQuery = isOrg ? `
+        query($owner: String!, $repoLimit: Int!, $cursor: String) {
+          organization(login: $owner) {
+            repositories(first: $repoLimit, orderBy: {field: UPDATED_AT, direction: DESC}, after: $cursor) {
+              totalCount
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+              nodes {
+                name
+                owner {
+                  login
+                }
+                isArchived
+                issues(states: OPEN, first: 1) {
+                  totalCount
+                }
+              }
+            }
+          }
+        }
+      ` : `
+        query($owner: String!, $repoLimit: Int!, $cursor: String) {
+          user(login: $owner) {
+            repositories(first: $repoLimit, orderBy: {field: UPDATED_AT, direction: DESC}, after: $cursor) {
+              totalCount
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+              nodes {
+                name
+                owner {
+                  login
+                }
+                isArchived
+                issues(states: OPEN, first: 1) {
+                  totalCount
+                }
+              }
+            }
+          }
+        }
+      `;
+
+      // Execute GraphQL query
+      const escapedQuery = graphqlQuery.replace(/'/g, '\'\\\'\'');
+      let graphqlCmd = `gh api graphql -f query='${escapedQuery}' -f owner='${owner}' -F repoLimit=${repoLimit}`;
+
+      if (repoCursor) {
+        graphqlCmd += ` -f cursor='${repoCursor}'`;
+      }
+
+      await log(`   📄 Fetching repositories page ${repoPageNum} for ${owner}...`, { verbose: true });
+
+      // Add delay for rate limiting
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      const { stdout } = await execAsync(graphqlCmd, { encoding: 'utf8', env: process.env });
+      const data = JSON.parse(stdout);
+      const repos = isOrg ? data.data.organization.repositories : data.data.user.repositories;
+
+      // Add repos to collection
+      allRepos.push(...repos.nodes);
+
+      // Check if there are more pages
+      hasNextRepoPage = repos.pageInfo.hasNextPage;
+      repoCursor = repos.pageInfo.endCursor;
+
+      const totalRepos = repos.totalCount;
+      await log(`   ✅ Fetched ${repos.nodes.length} repositories (total so far: ${allRepos.length}/${totalRepos})`, { verbose: true });
+    }
+
+    await log(`   📊 Fetched all ${allRepos.length} repositories`, { verbose: true });
+
+    // Filter out archived repositories AND repositories not owned by the target user/org
+    const ownedRepos = allRepos.filter(repo => repo.owner.login === owner);
+    const unownedCount = allRepos.length - ownedRepos.length;
+
+    if (unownedCount > 0) {
+      await log(`   ⏭️  Skipping ${unownedCount} repository(ies) not owned by ${owner}`);
+    }
+
+    const nonArchivedRepos = ownedRepos.filter(repo => !repo.isArchived);
+    const archivedCount = ownedRepos.length - nonArchivedRepos.length;
+
+    if (archivedCount > 0) {
+      await log(`   ⏭️  Skipping ${archivedCount} archived repository(ies)`);
+    }
+
+    await log(`   ✅ Processing ${nonArchivedRepos.length} non-archived repositories owned by ${owner}`);
+
+    // Now fetch issues from each repository
+    // For repositories with >100 issues, use pagination
+    const allIssues = [];
+    let reposWithIssues = 0;
+
+    for (const repo of nonArchivedRepos) {
+      const issueCount = repo.issues.totalCount;
+
+      // Skip repos with no issues
+      if (issueCount === 0) {
+        continue;
+      }
+
+      await log(`   🔍 Fetching ${issueCount} issue(s) from ${repo.owner.login}/${repo.name}...`, { verbose: true });
+
+      // Fetch all issues from this repository with pagination
+      const repoIssues = await fetchRepositoryIssuesWithPagination(
+        repo.owner.login,
+        repo.name,
+        log,
+        cleanErrorMessage,
+        issueLimit
+      );
+
+      // Add repository information to each issue
+      for (const issue of repoIssues) {
+        allIssues.push({
+          ...issue,
+          repository: {
+            name: repo.name,
+            owner: repo.owner
+          }
+        });
+      }
+
+      if (repoIssues.length > 0) {
+        reposWithIssues++;
+        await log(`   ✅ Collected ${repoIssues.length} issue(s) from ${repo.owner.login}/${repo.name}`, { verbose: true });
+      }
+    }
+
+    await log(`   ✅ GraphQL pagination complete: ${nonArchivedRepos.length} non-archived repos, ${allIssues.length} issues from ${reposWithIssues} repos with issues`, { verbose: true });
+
+    return { success: true, issues: allIssues, repoCount: nonArchivedRepos.length };
+
+  } catch (error) {
+    await log(`   ❌ GraphQL approach failed: ${cleanErrorMessage(error)}`, { verbose: true });
+    await log('   💡 Falling back to gh api --paginate approach...', { verbose: true });
+    return { success: false, issues: [], repoCount: 0 };
+  }
+}