@oss-autopilot/core 0.54.0 → 0.56.0

package/dist/core/issue-eligibility.js

@@ -0,0 +1,126 @@
+/**
+ * Issue Eligibility — checks whether an individual issue is claimable:
+ * existing PR detection, claim-phrase scanning, user merge history,
+ * and requirement clarity analysis.
+ *
+ * Extracted from issue-vetting.ts (#621) to isolate eligibility logic.
+ */
+import { paginateAll } from './pagination.js';
+import { errorMessage } from './errors.js';
+import { warn } from './logger.js';
+const MODULE = 'issue-eligibility';
+/** Phrases that indicate someone has already claimed an issue. */
+const CLAIM_PHRASES = [
+    "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',
+];
+/**
+ * Check whether an open PR already exists for the given issue.
+ * Searches both the PR search index and the issue timeline for linked PRs.
+ */
+export async function checkNoExistingPR(octokit, owner, repo, issueNumber) {
+    try {
+        // Search for PRs that mention this issue
+        const { data } = await octokit.search.issuesAndPullRequests({
+            q: `repo:${owner}/${repo} is:pr ${issueNumber}`,
+            per_page: 5,
+        });
+        // Also check timeline for linked PRs
+        const timeline = await paginateAll((page) => 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).
+ */
+export async function checkUserMergedPRsInRepo(octokit, owner, repo) {
+    try {
+        // Use @me to search as the authenticated user
+        const { data } = await 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;
+    }
+}
+/**
+ * Check whether an issue has been claimed by another contributor
+ * by scanning recent comments for claim phrases.
+ */
+export async function checkNotClaimed(octokit, owner, repo, issueNumber, commentCount) {
+    if (commentCount === 0)
+        return { passed: true };
+    try {
+        // Paginate through all comments
+        const comments = await octokit.paginate(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);
+        for (const comment of recentComments) {
+            const body = (comment.body || '').toLowerCase();
+            if (CLAIM_PHRASES.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 };
+    }
+}
+/**
+ * Analyze whether an issue body has clear, actionable requirements.
+ * Returns true when at least two "clarity indicators" are present:
+ * numbered/bulleted steps, code blocks, expected-behavior keywords, length > 200.
+ */
+export function 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;
+}

package/dist/core/issue-vetting.d.ts

@@ -1,18 +1,14 @@
 /**
- * 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 { Octokit } from '@octokit/rest';
-import { ContributionGuidelines, ProjectHealth, type SearchPriority, type IssueCandidate } from './types.js';
+import { type SearchPriority, type IssueCandidate } from './types.js';
 import { getStateManager } from './state.js';
-/** Result of a vetting check that may be inconclusive due to API errors. */
-export interface CheckResult {
-    passed: boolean;
-    inconclusive?: boolean;
-    reason?: string;
-}
 export declare class IssueVetter {
     private octokit;
     private stateManager;
@@ -29,17 +25,6 @@ export declare class IssueVetter {
         allFailed: boolean;
         rateLimitHit: boolean;
     }>;
-    checkNoExistingPR(owner: string, repo: string, issueNumber: number): Promise<CheckResult>;
-    /**
-     * Check how many merged PRs the authenticated user has in a repo.
-     * Uses GitHub Search API. Returns 0 on error (non-fatal).
-     */
-    checkUserMergedPRsInRepo(owner: string, repo: string): Promise<number>;
-    checkNotClaimed(owner: string, repo: string, issueNumber: number, commentCount: number): Promise<CheckResult>;
-    checkProjectHealth(owner: string, repo: string): Promise<ProjectHealth>;
-    fetchContributionGuidelines(owner: string, repo: string): Promise<ContributionGuidelines | undefined>;
-    parseContributionGuidelines(content: string): ContributionGuidelines;
-    analyzeRequirements(body: string): boolean;
     /**
      * Get the repo score from state, or return null if not evaluated
      */

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,7 +4,7 @@
  * 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
@@ -15,9 +15,14 @@
 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.