@oss-autopilot/core 0.53.1 → 0.55.0

package/dist/core/issue-vetting.js

@@ -1,41 +1,20 @@
 /**
- * Issue Vetting — checks individual issues for claimability, existing PRs,
- * project health, contribution guidelines, and requirement clarity.
+ * Issue Vetting — orchestrates individual issue checks and computes
+ * recommendation + viability score.
  *
- * Extracted from issue-discovery.ts (#356) to isolate vetting logic.
+ * Delegates to focused modules (#621):
+ * - issue-eligibility.ts — PR existence, claim detection, requirements analysis
+ * - repo-health.ts       — project health, contribution guidelines
  */
-import { paginateAll } from './pagination.js';
-import { parseGitHubUrl, daysBetween, DEFAULT_CONCURRENCY } from './utils.js';
+import { parseGitHubUrl, DEFAULT_CONCURRENCY } from './utils.js';
 import { ValidationError, errorMessage, isRateLimitError } from './errors.js';
 import { warn } from './logger.js';
-import { getHttpCache, cachedRequest, cachedTimeBased } from './http-cache.js';
 import { calculateRepoQualityBonus, calculateViabilityScore } from './issue-scoring.js';
 import { repoBelongsToCategory } from './category-mapping.js';
+import { checkNoExistingPR, checkNotClaimed, checkUserMergedPRsInRepo, analyzeRequirements, } from './issue-eligibility.js';
+import { checkProjectHealth, fetchContributionGuidelines } from './repo-health.js';
 const MODULE = 'issue-vetting';
 const MAX_CONCURRENT_REQUESTS = DEFAULT_CONCURRENCY;
-// Cache for contribution guidelines (expires after 1 hour, max 100 entries)
-const guidelinesCache = new Map();
-const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
-/** TTL for cached project health results (4 hours). Health data (stars, commits, CI) changes slowly. */
-const HEALTH_CACHE_TTL_MS = 4 * 60 * 60 * 1000;
-const CACHE_MAX_SIZE = 100;
-function pruneCache() {
-    const now = Date.now();
-    // First, remove expired entries (older than CACHE_TTL_MS)
-    for (const [key, value] of guidelinesCache.entries()) {
-        if (now - value.fetchedAt > CACHE_TTL_MS) {
-            guidelinesCache.delete(key);
-        }
-    }
-    // Then, if still over size limit, remove oldest entries
-    if (guidelinesCache.size > CACHE_MAX_SIZE) {
-        const entries = Array.from(guidelinesCache.entries()).sort((a, b) => a[1].fetchedAt - b[1].fetchedAt);
-        const toRemove = entries.slice(0, guidelinesCache.size - CACHE_MAX_SIZE);
-        for (const [key] of toRemove) {
-            guidelinesCache.delete(key);
-        }
-    }
-}
 export class IssueVetter {
     octokit;
     stateManager;
@@ -60,18 +39,18 @@ export class IssueVetter {
             repo,
             issue_number: number,
         });
-        // Run all vetting checks in parallel
+        // Run all vetting checks in parallel — delegates to standalone functions
         const [existingPRCheck, claimCheck, projectHealth, contributionGuidelines, userMergedPRCount] = await Promise.all([
-            this.checkNoExistingPR(owner, repo, number),
-            this.checkNotClaimed(owner, repo, number, ghIssue.comments),
-            this.checkProjectHealth(owner, repo),
-            this.fetchContributionGuidelines(owner, repo),
-            this.checkUserMergedPRsInRepo(owner, repo),
+            checkNoExistingPR(this.octokit, owner, repo, number),
+            checkNotClaimed(this.octokit, owner, repo, number, ghIssue.comments),
+            checkProjectHealth(this.octokit, owner, repo),
+            fetchContributionGuidelines(this.octokit, owner, repo),
+            checkUserMergedPRsInRepo(this.octokit, owner, repo),
         ]);
         const noExistingPR = existingPRCheck.passed;
         const notClaimed = claimCheck.passed;
         // Analyze issue quality
-        const clearRequirements = this.analyzeRequirements(ghIssue.body || '');
+        const clearRequirements = analyzeRequirements(ghIssue.body || '');
         // When the health check itself failed (API error), use a neutral default:
         // don't penalize the repo as inactive, but don't credit it as active either.
         const projectActive = projectHealth.checkFailed ? true : projectHealth.isActive;
@@ -285,249 +264,6 @@ export class IssueVetter {
         }
         return { candidates: candidates.slice(0, maxResults), allFailed, rateLimitHit: rateLimitFailures > 0 };
     }
-    async checkNoExistingPR(owner, repo, issueNumber) {
-        try {
-            // Search for PRs that mention this issue
-            const { data } = await this.octokit.search.issuesAndPullRequests({
-                q: `repo:${owner}/${repo} is:pr ${issueNumber}`,
-                per_page: 5,
-            });
-            // Also check timeline for linked PRs
-            const timeline = await paginateAll((page) => this.octokit.issues.listEventsForTimeline({
-                owner,
-                repo,
-                issue_number: issueNumber,
-                per_page: 100,
-                page,
-            }));
-            const linkedPRs = timeline.filter((event) => {
-                const e = event;
-                return e.event === 'cross-referenced' && e.source?.issue?.pull_request;
-            });
-            return { passed: data.total_count === 0 && linkedPRs.length === 0 };
-        }
-        catch (error) {
-            const errMsg = errorMessage(error);
-            warn(MODULE, `Failed to check for existing PRs on ${owner}/${repo}#${issueNumber}: ${errMsg}. Assuming no existing PR.`);
-            return { passed: true, inconclusive: true, reason: errMsg };
-        }
-    }
-    /**
-     * Check how many merged PRs the authenticated user has in a repo.
-     * Uses GitHub Search API. Returns 0 on error (non-fatal).
-     */
-    async checkUserMergedPRsInRepo(owner, repo) {
-        try {
-            // Use @me to search as the authenticated user
-            const { data } = await this.octokit.search.issuesAndPullRequests({
-                q: `repo:${owner}/${repo} is:pr is:merged author:@me`,
-                per_page: 1, // We only need total_count
-            });
-            return data.total_count;
-        }
-        catch (error) {
-            const errMsg = errorMessage(error);
-            warn(MODULE, `Could not check merged PRs in ${owner}/${repo}: ${errMsg}. Defaulting to 0.`);
-            return 0;
-        }
-    }
-    async checkNotClaimed(owner, repo, issueNumber, commentCount) {
-        if (commentCount === 0)
-            return { passed: true };
-        try {
-            // Paginate through all comments (up to 100)
-            const comments = await this.octokit.paginate(this.octokit.issues.listComments, {
-                owner,
-                repo,
-                issue_number: issueNumber,
-                per_page: 100,
-            }, (response) => response.data);
-            // Limit to last 100 comments to avoid excessive processing
-            const recentComments = comments.slice(-100);
-            // Look for claiming phrases
-            const claimPhrases = [
-                "i'm working on this",
-                'i am working on this',
-                "i'll take this",
-                'i will take this',
-                'working on it',
-                "i'd like to work on",
-                'i would like to work on',
-                'can i work on',
-                'may i work on',
-                'assigned to me',
-                "i'm on it",
-                "i'll submit a pr",
-                'i will submit a pr',
-                'working on a fix',
-                'working on a pr',
-            ];
-            for (const comment of recentComments) {
-                const body = (comment.body || '').toLowerCase();
-                if (claimPhrases.some((phrase) => body.includes(phrase))) {
-                    return { passed: false };
-                }
-            }
-            return { passed: true };
-        }
-        catch (error) {
-            const errMsg = errorMessage(error);
-            warn(MODULE, `Failed to check claim status on ${owner}/${repo}#${issueNumber}: ${errMsg}. Assuming not claimed.`);
-            return { passed: true, inconclusive: true, reason: errMsg };
-        }
-    }
-    async checkProjectHealth(owner, repo) {
-        const cache = getHttpCache();
-        const healthCacheKey = `health:${owner}/${repo}`;
-        try {
-            return await cachedTimeBased(cache, healthCacheKey, HEALTH_CACHE_TTL_MS, async () => {
-                // Get repo info (with ETag caching — repo metadata changes infrequently)
-                const url = `/repos/${owner}/${repo}`;
-                const repoData = await cachedRequest(cache, url, (headers) => this.octokit.repos.get({ owner, repo, headers }));
-                // Get recent commits
-                const { data: commits } = await this.octokit.repos.listCommits({
-                    owner,
-                    repo,
-                    per_page: 1,
-                });
-                const lastCommit = commits[0];
-                const lastCommitAt = lastCommit?.commit?.author?.date || repoData.pushed_at;
-                const daysSinceLastCommit = daysBetween(new Date(lastCommitAt));
-                // Check CI status (simplified - just check if workflows exist)
-                let ciStatus = 'unknown';
-                try {
-                    const { data: workflows } = await this.octokit.actions.listRepoWorkflows({
-                        owner,
-                        repo,
-                        per_page: 1,
-                    });
-                    if (workflows.total_count > 0) {
-                        ciStatus = 'passing'; // Assume passing if workflows exist
-                    }
-                }
-                catch (error) {
-                    const errMsg = errorMessage(error);
-                    warn(MODULE, `Failed to check CI status for ${owner}/${repo}: ${errMsg}. Defaulting to unknown.`);
-                }
-                return {
-                    repo: `${owner}/${repo}`,
-                    lastCommitAt,
-                    daysSinceLastCommit,
-                    openIssuesCount: repoData.open_issues_count,
-                    avgIssueResponseDays: 0, // Would need more API calls to calculate
-                    ciStatus,
-                    isActive: daysSinceLastCommit < 30,
-                    stargazersCount: repoData.stargazers_count,
-                    forksCount: repoData.forks_count,
-                };
-            });
-        }
-        catch (error) {
-            const errMsg = errorMessage(error);
-            warn(MODULE, `Error checking project health for ${owner}/${repo}: ${errMsg}`);
-            return {
-                repo: `${owner}/${repo}`,
-                lastCommitAt: '',
-                daysSinceLastCommit: 999,
-                openIssuesCount: 0,
-                avgIssueResponseDays: 0,
-                ciStatus: 'unknown',
-                isActive: false,
-                checkFailed: true,
-                failureReason: errMsg,
-            };
-        }
-    }
-    async fetchContributionGuidelines(owner, repo) {
-        const cacheKey = `${owner}/${repo}`;
-        // Check cache first
-        const cached = guidelinesCache.get(cacheKey);
-        if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
-            return cached.guidelines;
-        }
-        const filesToCheck = ['CONTRIBUTING.md', '.github/CONTRIBUTING.md', 'docs/CONTRIBUTING.md', 'contributing.md'];
-        // Probe all paths in parallel — take the first success in priority order
-        const results = await Promise.allSettled(filesToCheck.map((file) => this.octokit.repos.getContent({ owner, repo, path: file }).then(({ data }) => {
-            if ('content' in data) {
-                return Buffer.from(data.content, 'base64').toString('utf-8');
-            }
-            return null;
-        })));
-        for (let i = 0; i < results.length; i++) {
-            const result = results[i];
-            if (result.status === 'fulfilled' && result.value) {
-                const guidelines = this.parseContributionGuidelines(result.value);
-                guidelinesCache.set(cacheKey, { guidelines, fetchedAt: Date.now() });
-                pruneCache();
-                return guidelines;
-            }
-            if (result.status === 'rejected') {
-                const msg = result.reason instanceof Error ? result.reason.message : String(result.reason);
-                if (!msg.includes('404') && !msg.includes('Not Found')) {
-                    warn(MODULE, `Unexpected error fetching ${filesToCheck[i]} from ${owner}/${repo}: ${msg}`);
-                }
-            }
-        }
-        // Cache the negative result too and prune if needed
-        guidelinesCache.set(cacheKey, { guidelines: undefined, fetchedAt: Date.now() });
-        pruneCache();
-        return undefined;
-    }
-    parseContributionGuidelines(content) {
-        const guidelines = {
-            rawContent: content,
-        };
-        const lowerContent = content.toLowerCase();
-        // Detect branch naming conventions
-        if (lowerContent.includes('branch')) {
-            const branchMatch = content.match(/branch[^\n]*(?:named?|format|convention)[^\n]*[`"]([^`"]+)[`"]/i);
-            if (branchMatch) {
-                guidelines.branchNamingConvention = branchMatch[1];
-            }
-        }
-        // Detect commit message format
-        if (lowerContent.includes('conventional commit')) {
-            guidelines.commitMessageFormat = 'conventional commits';
-        }
-        else if (lowerContent.includes('commit message')) {
-            const commitMatch = content.match(/commit message[^\n]*[`"]([^`"]+)[`"]/i);
-            if (commitMatch) {
-                guidelines.commitMessageFormat = commitMatch[1];
-            }
-        }
-        // Detect test framework
-        if (lowerContent.includes('jest'))
-            guidelines.testFramework = 'Jest';
-        else if (lowerContent.includes('rspec'))
-            guidelines.testFramework = 'RSpec';
-        else if (lowerContent.includes('pytest'))
-            guidelines.testFramework = 'pytest';
-        else if (lowerContent.includes('mocha'))
-            guidelines.testFramework = 'Mocha';
-        // Detect linter
-        if (lowerContent.includes('eslint'))
-            guidelines.linter = 'ESLint';
-        else if (lowerContent.includes('rubocop'))
-            guidelines.linter = 'RuboCop';
-        else if (lowerContent.includes('prettier'))
-            guidelines.formatter = 'Prettier';
-        // Detect CLA requirement
-        if (lowerContent.includes('cla') || lowerContent.includes('contributor license agreement')) {
-            guidelines.claRequired = true;
-        }
-        return guidelines;
-    }
-    analyzeRequirements(body) {
-        if (!body || body.length < 50)
-            return false;
-        // Check for clear structure
-        const hasSteps = /\d\.|[-*]\s/.test(body);
-        const hasCodeBlock = /```/.test(body);
-        const hasExpectedBehavior = /expect|should|must|want/i.test(body);
-        // Must have at least two indicators of clarity
-        const indicators = [hasSteps, hasCodeBlock, hasExpectedBehavior, body.length > 200];
-        return indicators.filter(Boolean).length >= 2;
-    }
     /**
      * Get the repo score from state, or return null if not evaluated
      */

package/dist/core/pr-monitor.d.ts

@@ -4,20 +4,25 @@
  * Score methods still write to state.
  *
  * Decomposed into focused modules (#263):
- * - ci-analysis.ts: CI check classification and analysis
+ * - ci-analysis.ts: CI status fetching, check classification and analysis
  * - review-analysis.ts: Review decision and comment detection
  * - checklist-analysis.ts: PR body checklist analysis
  * - maintainer-analysis.ts: Maintainer action hint extraction
  * - display-utils.ts: Display label computation
- * - github-stats.ts: Merged/closed PR counts and star fetching
+ * - github-stats.ts: Merged/closed PR counts and star-based filtering
  * - status-determination.ts: PR status classification logic
  */
 import { FetchedPR, DailyDigest, ClosedPR, MergedPR, StarFilter } from './types.js';
 import { type PRCountsResult } from './github-stats.js';
 export { computeDisplayLabel } from './display-utils.js';
-export { classifyCICheck, classifyFailingChecks } from './ci-analysis.js';
+export { classifyCICheck, classifyFailingChecks, getCIStatus } from './ci-analysis.js';
 export { isConditionalChecklistItem } from './checklist-analysis.js';
 export { determineStatus } from './status-determination.js';
+/**
+ * Check if a PR has a merge conflict based on GitHub's mergeable flag and mergeable_state.
+ * Returns true when mergeable is explicitly false or the mergeable_state is 'dirty'.
+ */
+export declare function hasMergeConflict(mergeable: boolean | null, mergeableState: string | null): boolean;
 export interface PRCheckFailure {
     prUrl: string;
     error: string;
@@ -44,16 +49,6 @@ export declare class PRMonitor {
      * Centralizes PR construction and display label computation (#79).
      */
     private buildFetchedPR;
-    /**
-     * Check if PR has merge conflict
-     */
-    private hasMergeConflict;
-    /**
-     * Get CI status from combined status API and check runs.
-     * Returns status and names of failing checks for diagnostics.
-     * Delegates analysis to ci-analysis module.
-     */
-    private getCIStatus;
     /**
      * Fetch merged PR counts and latest merge dates per repository for the configured user.
      * Delegates to github-stats module.
@@ -68,10 +63,13 @@ export declare class PRMonitor {
      */
     fetchUserClosedPRCounts(starFilter?: StarFilter): Promise<PRCountsResult<number>>;
     /**
-     * Fetch GitHub star counts for a list of repositories.
-     * Delegates to github-stats module.
+     * Fetch metadata (star count and primary language) for a list of repositories.
+     * Both fields come from the same `repos.get()` call — zero additional API cost.
      */
-    fetchRepoStarCounts(repos: string[]): Promise<Map<string, number>>;
+    fetchRepoMetadata(repos: string[]): Promise<Map<string, {
+        stars: number;
+        language: string | null;
+    }>>;
     /**
      * Fetch PRs closed without merge in the last N days.
      * Delegates to github-stats module.

package/dist/core/pr-monitor.js

@@ -4,12 +4,12 @@
  * Score methods still write to state.
  *
  * Decomposed into focused modules (#263):
- * - ci-analysis.ts: CI check classification and analysis
+ * - ci-analysis.ts: CI status fetching, check classification and analysis
  * - review-analysis.ts: Review decision and comment detection
  * - checklist-analysis.ts: PR body checklist analysis
  * - maintainer-analysis.ts: Maintainer action hint extraction
  * - display-utils.ts: Display label computation
- * - github-stats.ts: Merged/closed PR counts and star fetching
+ * - github-stats.ts: Merged/closed PR counts and star-based filtering
  * - status-determination.ts: PR status classification logic
  */
 import { getOctokit } from './github.js';
@@ -21,8 +21,7 @@ import { ConfigurationError, ValidationError, errorMessage, getHttpStatusCode }
 import { paginateAll } from './pagination.js';
 import { debug, warn, timed } from './logger.js';
 import { getHttpCache, cachedRequest } from './http-cache.js';
-// Extracted modules
-import { classifyFailingChecks, analyzeCheckRuns, analyzeCombinedStatus, mergeStatuses } from './ci-analysis.js';
+import { classifyFailingChecks, getCIStatus } from './ci-analysis.js';
 import { determineReviewDecision, getLatestChangesRequestedDate, checkUnrespondedComments, } from './review-analysis.js';
 import { analyzeChecklist } from './checklist-analysis.js';
 import { extractMaintainerActionHints } from './maintainer-analysis.js';
@@ -30,9 +29,16 @@ import { computeDisplayLabel } from './display-utils.js';
 import { fetchUserMergedPRCounts as fetchUserMergedPRCountsImpl, fetchUserClosedPRCounts as fetchUserClosedPRCountsImpl, fetchRecentlyClosedPRs as fetchRecentlyClosedPRsImpl, fetchRecentlyMergedPRs as fetchRecentlyMergedPRsImpl, } from './github-stats.js';
 // Re-export so existing consumers can still import from pr-monitor
 export { computeDisplayLabel } from './display-utils.js';
-export { classifyCICheck, classifyFailingChecks } from './ci-analysis.js';
+export { classifyCICheck, classifyFailingChecks, getCIStatus } from './ci-analysis.js';
 export { isConditionalChecklistItem } from './checklist-analysis.js';
 export { determineStatus } from './status-determination.js';
+/**
+ * Check if a PR has a merge conflict based on GitHub's mergeable flag and mergeable_state.
+ * Returns true when mergeable is explicitly false or the mergeable_state is 'dirty'.
+ */
+export function hasMergeConflict(mergeable, mergeableState) {
+    return mergeable === false || mergeableState === 'dirty';
+}
 const MODULE = 'pr-monitor';
 const MAX_CONCURRENT_REQUESTS = DEFAULT_CONCURRENCY;
 export class PRMonitor {
@@ -167,14 +173,14 @@ export class PRMonitor {
         // Determine review decision (delegated to review-analysis module)
         const reviewDecision = determineReviewDecision(reviews);
         // Check for merge conflict
-        const hasMergeConflict = this.hasMergeConflict(ghPR.mergeable, ghPR.mergeable_state);
+        const mergeConflict = hasMergeConflict(ghPR.mergeable, ghPR.mergeable_state);
         // Check if there's an unresponded maintainer comment (delegated to review-analysis module)
         const { hasUnrespondedComment, lastMaintainerComment } = checkUnrespondedComments(comments, reviews, reviewComments, config.githubUsername);
         // Fetch CI status and (conditionally) latest commit date in parallel
         // We need the commit date when hasUnrespondedComment is true (to distinguish
         // "needs_response" from "waiting_on_maintainer") OR when reviewDecision is "changes_requested"
         // (to detect needs_changes: review requested changes but no new commits pushed)
-        const ciPromise = this.getCIStatus(owner, repo, ghPR.head.sha);
+        const ciPromise = getCIStatus(this.octokit, owner, repo, ghPR.head.sha);
         const needCommitDate = hasUnrespondedComment || reviewDecision === 'changes_requested';
         const commitInfoPromise = needCommitDate
             ? this.octokit.repos
@@ -220,9 +226,9 @@ export class PRMonitor {
         const classifiedChecks = classifyFailingChecks(failingCheckNames, failingCheckConclusions);
         // Determine status
         const hasActionableCIFailure = ciStatus === 'failing' && classifiedChecks.some((c) => c.category === 'actionable');
-        const { status, actionReason, waitReason, stalenessTier } = determineStatus({
+        const { status, actionReason, waitReason, stalenessTier, actionReasons } = determineStatus({
             ciStatus,
-            hasMergeConflict,
+            hasMergeConflict: mergeConflict,
             hasUnrespondedComment,
             hasIncompleteChecklist,
             reviewDecision,
@@ -246,13 +252,14 @@ export class PRMonitor {
             actionReason,
             waitReason,
             stalenessTier,
+            actionReasons,
             createdAt: ghPR.created_at,
             updatedAt: ghPR.updated_at,
             daysSinceActivity,
             ciStatus,
             failingCheckNames,
             classifiedChecks,
-            hasMergeConflict,
+            hasMergeConflict: mergeConflict,
             reviewDecision,
             hasUnrespondedComment,
             lastMaintainerComment,
@@ -278,78 +285,6 @@ export class PRMonitor {
         pr.displayDescription = displayDescription;
         return pr;
     }
-    /**
-     * Check if PR has merge conflict
-     */
-    hasMergeConflict(mergeable, mergeableState) {
-        return mergeable === false || mergeableState === 'dirty';
-    }
-    /**
-     * Get CI status from combined status API and check runs.
-     * Returns status and names of failing checks for diagnostics.
-     * Delegates analysis to ci-analysis module.
-     */
-    async getCIStatus(owner, repo, sha) {
-        if (!sha)
-            return { status: 'unknown', failingCheckNames: [], failingCheckConclusions: new Map() };
-        try {
-            // Fetch both combined status and check runs in parallel
-            const [statusResponse, checksResponse] = await Promise.all([
-                this.octokit.repos.getCombinedStatusForRef({ owner, repo, ref: sha }),
-                // 404 is expected for repos without check runs configured; log other errors for debugging
-                this.octokit.checks.listForRef({ owner, repo, ref: sha }).catch((err) => {
-                    const status = getHttpStatusCode(err);
-                    // Rate limit errors must propagate — matches listReviewComments pattern (#481)
-                    if (status === 429)
-                        throw err;
-                    if (status === 403) {
-                        const msg = errorMessage(err).toLowerCase();
-                        if (msg.includes('rate limit') || msg.includes('abuse detection'))
-                            throw err;
-                    }
-                    if (status === 404) {
-                        debug('pr-monitor', `Check runs 404 for ${owner}/${repo}@${sha.slice(0, 7)} (no checks configured)`);
-                    }
-                    else {
-                        warn('pr-monitor', `Non-404 error fetching check runs for ${owner}/${repo}@${sha.slice(0, 7)}: ${status ?? err}`);
-                    }
-                    return null;
-                }),
-            ]);
-            const combinedStatus = statusResponse.data;
-            const allCheckRuns = checksResponse?.data?.check_runs || [];
-            // Deduplicate check runs by name, keeping only the most recent run per unique name.
-            // GitHub returns all historical runs (including re-runs), so without deduplication
-            // a superseded failure will incorrectly flag the PR as failing even after a re-run passes.
-            const latestCheckRunsByName = new Map();
-            for (const check of allCheckRuns) {
-                const existing = latestCheckRunsByName.get(check.name);
-                if (!existing || new Date(check.started_at ?? 0) > new Date(existing.started_at ?? 0)) {
-                    latestCheckRunsByName.set(check.name, check);
-                }
-            }
-            const checkRuns = [...latestCheckRunsByName.values()];
-            // Delegate analysis to ci-analysis module
-            const checkRunAnalysis = analyzeCheckRuns(checkRuns);
-            const combinedAnalysis = analyzeCombinedStatus(combinedStatus);
-            return mergeStatuses(checkRunAnalysis, combinedAnalysis, checkRuns.length);
-        }
-        catch (error) {
-            const statusCode = getHttpStatusCode(error);
-            if (statusCode === 401 || statusCode === 403 || statusCode === 429) {
-                throw error;
-            }
-            else if (statusCode === 404) {
-                // Repo might not have CI configured, this is normal
-                debug('pr-monitor', `CI check 404 for ${owner}/${repo} (no CI configured)`);
-                return { status: 'unknown', failingCheckNames: [], failingCheckConclusions: new Map() };
-            }
-            else {
-                warn('pr-monitor', `Failed to check CI for ${owner}/${repo}@${sha.slice(0, 7)}: ${errorMessage(error)}`);
-            }
-            return { status: 'unknown', failingCheckNames: [], failingCheckConclusions: new Map() };
-        }
-    }
     /**
      * Fetch merged PR counts and latest merge dates per repository for the configured user.
      * Delegates to github-stats module.
@@ -367,13 +302,13 @@ export class PRMonitor {
         return fetchUserClosedPRCountsImpl(this.octokit, config.githubUsername, starFilter);
     }
     /**
-     * Fetch GitHub star counts for a list of repositories.
-     * Delegates to github-stats module.
+     * Fetch metadata (star count and primary language) for a list of repositories.
+     * Both fields come from the same `repos.get()` call — zero additional API cost.
      */
-    async fetchRepoStarCounts(repos) {
+    async fetchRepoMetadata(repos) {
         if (repos.length === 0)
             return new Map();
-        debug(MODULE, `Fetching star counts for ${repos.length} repos...`);
+        debug(MODULE, `Fetching repo metadata for ${repos.length} repos...`);
         const results = new Map();
         const cache = getHttpCache();
         // Deduplicate repos to avoid fetching the same repo twice
@@ -394,17 +329,18 @@ export class PRMonitor {
                     repo: name,
                     headers,
                 }));
-                return { repo, stars: data.stargazers_count };
+                const metadata = { stars: data.stargazers_count, language: data.language ?? null };
+                return { repo, metadata };
             }));
             let chunkFailures = 0;
             for (let j = 0; j < settled.length; j++) {
                 const result = settled[j];
                 if (result.status === 'fulfilled') {
-                    results.set(result.value.repo, result.value.stars);
+                    results.set(result.value.repo, result.value.metadata);
                 }
                 else {
                     chunkFailures++;
-                    warn(MODULE, `Failed to fetch stars for ${chunk[j]}: ${errorMessage(result.reason)}`);
+                    warn(MODULE, `Failed to fetch metadata for ${chunk[j]}: ${errorMessage(result.reason)}`);
                 }
             }
             // If entire chunk failed, likely a systemic issue (rate limit, auth, outage) — abort remaining
@@ -416,7 +352,7 @@ export class PRMonitor {
                 break;
             }
         }
-        debug(MODULE, `Fetched star counts for ${results.size}/${repos.length} repos`);
+        debug(MODULE, `Fetched repo metadata for ${results.size}/${repos.length} repos`);
         return results;
     }
     /**

package/dist/core/repo-health.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Repo Health — project health checks and contribution guidelines fetching.
+ *
+ * Extracted from issue-vetting.ts (#621) to isolate repo-level checks
+ * from issue-level eligibility logic.
+ */
+import { Octokit } from '@octokit/rest';
+import { type ContributionGuidelines, type ProjectHealth } from './types.js';
+/**
+ * Check the health of a GitHub project: recent commits, CI status, star/fork counts.
+ * Results are cached for HEALTH_CACHE_TTL_MS (4 hours).
+ */
+export declare function checkProjectHealth(octokit: Octokit, owner: string, repo: string): Promise<ProjectHealth>;
+/**
+ * Fetch and parse CONTRIBUTING.md (or variants) from a GitHub repo.
+ * Probes multiple paths in parallel: CONTRIBUTING.md, .github/CONTRIBUTING.md,
+ * docs/CONTRIBUTING.md, contributing.md. Results are cached for CACHE_TTL_MS.
+ */
+export declare function fetchContributionGuidelines(octokit: Octokit, owner: string, repo: string): Promise<ContributionGuidelines | undefined>;
+/**
+ * Parse the raw content of a CONTRIBUTING.md file to extract structured guidelines:
+ * branch naming, commit format, test framework, linter, formatter, CLA requirement.
+ */
+export declare function parseContributionGuidelines(content: string): ContributionGuidelines;