@oss-autopilot/core 0.53.1 → 0.55.0

package/dist/core/ci-analysis.js

@@ -2,6 +2,12 @@
  * CI Analysis - Classification and analysis of CI check runs and combined statuses.
  * Extracted from PRMonitor to isolate CI-related logic (#263).
  */
+import { getHttpStatusCode, errorMessage } from './errors.js';
+import { debug, warn } from './logger.js';
+/** Return a fresh unknown CI status (avoids shared mutable state between callers). */
+function unknownCIStatus() {
+    return { status: 'unknown', failingCheckNames: [], failingCheckConclusions: new Map() };
+}
 /**
  * Known CI check name patterns that indicate fork limitations rather than real failures (#81).
  * These are deployment/preview services that require repo-level secrets unavailable in forks.
@@ -15,6 +21,7 @@ const FORK_LIMITATION_PATTERNS = [
     /chromatic/i,
     /percy/i,
     /cloudflare pages/i,
+    /\binternal\b/i,
 ];
 /**
  * Known CI check name patterns that indicate authorization gates (#81).
@@ -30,6 +37,7 @@ const INFRASTRUCTURE_PATTERNS = [
     /\bsetup\s+fail(ed|ure)?\b/i,
     /\bservice\s*unavailable/i,
     /\binfrastructure/i,
+    /\bblacksmith\b/i,
 ];
 /**
  * Classify a failing CI check as actionable, fork_limitation, auth_gate, or infrastructure (#81, #145).
@@ -117,15 +125,23 @@ export function analyzeCombinedStatus(combinedStatus) {
     const hasRealFailure = realStatuses.some((s) => s.state === 'failure' || s.state === 'error');
     const hasRealPending = realStatuses.some((s) => s.state === 'pending');
     const hasRealSuccess = realStatuses.some((s) => s.state === 'success');
-    const effectiveCombinedState = hasRealFailure
-        ? 'failure'
-        : hasRealPending
-            ? 'pending'
-            : hasRealSuccess
-                ? 'success'
-                : realStatuses.length === 0
-                    ? 'success' // All statuses were auth gates; don't inherit original failure
-                    : combinedStatus.state;
+    let effectiveCombinedState;
+    if (hasRealFailure) {
+        effectiveCombinedState = 'failure';
+    }
+    else if (hasRealPending) {
+        effectiveCombinedState = 'pending';
+    }
+    else if (hasRealSuccess) {
+        effectiveCombinedState = 'success';
+    }
+    else if (realStatuses.length === 0) {
+        // All statuses were auth gates; don't inherit original failure
+        effectiveCombinedState = 'success';
+    }
+    else {
+        effectiveCombinedState = combinedStatus.state;
+    }
     const hasStatuses = combinedStatus.statuses.length > 0;
     // Collect failing status names from combined status API
     const failingStatusNames = [];
@@ -155,9 +171,72 @@ export function mergeStatuses(checkRunAnalysis, combinedAnalysis, checkRunCount)
     if (hasSuccessfulChecks || effectiveCombinedState === 'success') {
         return { status: 'passing', failingCheckNames: [], failingCheckConclusions: new Map() };
     }
-    // No checks found at all - this is common for repos without CI
+    // No checks found at all — common for repos without CI
     if (!hasStatuses && checkRunCount === 0) {
-        return { status: 'unknown', failingCheckNames: [], failingCheckConclusions: new Map() };
+        return unknownCIStatus();
+    }
+    return unknownCIStatus();
+}
+/**
+ * Get CI status for a commit SHA by querying both the combined status API and check runs API.
+ * Returns the merged status and names of any failing checks for diagnostics.
+ */
+export async function getCIStatus(octokit, owner, repo, sha) {
+    if (!sha)
+        return unknownCIStatus();
+    try {
+        // Fetch both combined status and check runs in parallel
+        const [statusResponse, checksResponse] = await Promise.all([
+            octokit.repos.getCombinedStatusForRef({ owner, repo, ref: sha }),
+            // 404 is expected for repos without check runs configured; log other errors for debugging
+            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()];
+        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)`);
+        }
+        else {
+            warn('pr-monitor', `Failed to check CI for ${owner}/${repo}@${sha.slice(0, 7)}: ${errorMessage(error)}`);
+        }
+        return unknownCIStatus();
     }
-    return { status: 'unknown', failingCheckNames: [], failingCheckConclusions: new Map() };
 }

package/dist/core/daily-logic.js

@@ -52,43 +52,34 @@ export function applyStatusOverrides(prs, state) {
     if (!overrides || Object.keys(overrides).length === 0)
         return prs;
     const stateManager = getStateManager();
-    // Snapshot keys before iteration — clearStatusOverride mutates the same object
-    const overrideUrls = new Set(Object.keys(overrides));
-    let didAutoClear = false;
-    const result = prs.map((pr) => {
-        try {
-            const override = stateManager.getStatusOverride(pr.url, pr.updatedAt);
-            if (!override) {
-                if (overrideUrls.has(pr.url))
-                    didAutoClear = true;
-                return pr;
-            }
-            if (!VALID_OVERRIDE_STATUSES.has(override.status)) {
-                warn('daily-logic', `Invalid override status "${override.status}" for ${pr.url} — ignoring`);
-                return pr;
+    // Wrap in batch: getStatusOverride may auto-clear stale overrides via clearStatusOverride,
+    // which now auto-saves. Batching produces a single disk write for all auto-clears.
+    let result = [];
+    stateManager.batch(() => {
+        result = prs.map((pr) => {
+            try {
+                const override = stateManager.getStatusOverride(pr.url, pr.updatedAt);
+                if (!override) {
+                    return pr;
+                }
+                if (!VALID_OVERRIDE_STATUSES.has(override.status)) {
+                    warn('daily-logic', `Invalid override status "${override.status}" for ${pr.url} — ignoring`);
+                    return pr;
+                }
+                if (override.status === pr.status)
+                    return pr;
+                // Clear the contradictory reason field and set an appropriate default
+                if (override.status === 'waiting_on_maintainer') {
+                    return { ...pr, status: override.status, actionReason: undefined, waitReason: 'pending_review' };
+                }
+                return { ...pr, status: override.status, waitReason: undefined, actionReason: 'needs_response' };
             }
-            if (override.status === pr.status)
+            catch (err) {
+                warn('daily-logic', `Failed to apply status override for ${pr.url}: ${errorMessage(err)}`);
                 return pr;
-            // Clear the contradictory reason field and set an appropriate default
-            if (override.status === 'waiting_on_maintainer') {
-                return { ...pr, status: override.status, actionReason: undefined, waitReason: 'pending_review' };
             }
-            return { ...pr, status: override.status, waitReason: undefined, actionReason: 'needs_response' };
-        }
-        catch (err) {
-            warn('daily-logic', `Failed to apply status override for ${pr.url}: ${errorMessage(err)}`);
-            return pr;
-        }
+        });
     });
-    // Persist any auto-cleared overrides so they don't resurrect on restart
-    if (didAutoClear) {
-        try {
-            stateManager.save();
-        }
-        catch (err) {
-            warn('daily-logic', `Failed to persist auto-cleared overrides — they may reappear on restart: ${errorMessage(err)}`);
-        }
-    }
     return result;
 }
 // ---------------------------------------------------------------------------

package/dist/core/display-utils.js

@@ -84,13 +84,33 @@ const WAIT_DISPLAY = {
             return 'CI checks are failing but no action is needed from you';
         },
     },
+    stale_ci_failure: {
+        label: '[Stale CI Failure]',
+        description: (pr) => `CI failing for ${pr.daysSinceActivity}+ days — likely pre-existing or non-actionable`,
+    },
 };
+/** Convert a bracketed display label like "[CI Failing]" to a plain lowercase string like "ci failing". */
+function labelToPlainText(reason) {
+    const label = ACTION_DISPLAY[reason]?.label;
+    if (!label)
+        return reason;
+    return label.replace(/[[\]]/g, '').toLowerCase();
+}
 /** Compute display label and description for a FetchedPR (#79). */
 export function computeDisplayLabel(pr) {
     if (pr.status === 'needs_addressing' && pr.actionReason) {
         const entry = ACTION_DISPLAY[pr.actionReason];
-        if (entry)
-            return { displayLabel: entry.label, displayDescription: entry.description(pr) };
+        if (entry) {
+            let displayDescription = entry.description(pr);
+            // Append secondary action reasons when multiple issues exist (#675)
+            if (pr.actionReasons && pr.actionReasons.length > 1) {
+                const secondary = pr.actionReasons.filter((r) => r !== pr.actionReason).map(labelToPlainText);
+                if (secondary.length > 0) {
+                    displayDescription += ` (also: ${secondary.join(', ')})`;
+                }
+            }
+            return { displayLabel: entry.label, displayDescription };
+        }
     }
     if (pr.status === 'waiting_on_maintainer' && pr.waitReason) {
         const entry = WAIT_DISPLAY[pr.waitReason];

package/dist/core/github-stats.d.ts

@@ -1,5 +1,5 @@
 /**
- * GitHub Stats - Fetching merged/closed PR counts and repository star counts.
+ * GitHub Stats - Fetching merged/closed PR counts with star-based filtering.
  * Extracted from PRMonitor to isolate statistics-gathering API calls (#263).
  */
 import { Octokit } from '@octokit/rest';

package/dist/core/github-stats.js

@@ -1,5 +1,5 @@
 /**
- * GitHub Stats - Fetching merged/closed PR counts and repository star counts.
+ * GitHub Stats - Fetching merged/closed PR counts with star-based filtering.
  * Extracted from PRMonitor to isolate statistics-gathering API calls (#263).
  */
 import { extractOwnerRepo, parseGitHubUrl, isOwnRepo } from './utils.js';

package/dist/core/index.d.ts

@@ -4,7 +4,8 @@
  */
 export { StateManager, getStateManager, resetStateManager, type Stats } from './state.js';
 export { PRMonitor, type PRCheckFailure, type FetchPRsResult, computeDisplayLabel, classifyCICheck, classifyFailingChecks, } from './pr-monitor.js';
-export { IssueDiscovery, type IssueCandidate, type SearchPriority, isDocOnlyIssue, applyPerRepoCap, DOC_ONLY_LABELS, } from './issue-discovery.js';
+export { IssueDiscovery } from './issue-discovery.js';
+export { isDocOnlyIssue, applyPerRepoCap, DOC_ONLY_LABELS } from './issue-filtering.js';
 export { IssueConversationMonitor } from './issue-conversation.js';
 export { isBotAuthor, isAcknowledgmentComment } from './comment-utils.js';
 export { getOctokit, checkRateLimit, type RateLimitInfo } from './github.js';

package/dist/core/index.js

@@ -4,7 +4,8 @@
  */
 export { StateManager, getStateManager, resetStateManager } from './state.js';
 export { PRMonitor, computeDisplayLabel, classifyCICheck, classifyFailingChecks, } from './pr-monitor.js';
-export { IssueDiscovery, isDocOnlyIssue, applyPerRepoCap, DOC_ONLY_LABELS, } from './issue-discovery.js';
+export { IssueDiscovery } from './issue-discovery.js';
+export { isDocOnlyIssue, applyPerRepoCap, DOC_ONLY_LABELS } from './issue-filtering.js';
 export { IssueConversationMonitor } from './issue-conversation.js';
 export { isBotAuthor, isAcknowledgmentComment } from './comment-utils.js';
 export { getOctokit, checkRateLimit } from './github.js';

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

@@ -1,17 +1,15 @@
 /**
  * Issue Discovery — orchestrates multi-phase issue search across GitHub.
  *
- * Delegates filtering, scoring, and vetting to focused modules (#356):
- * - issue-filtering.ts — spam detection, doc-only filtering, per-repo caps
- * - issue-scoring.ts  — viability scores, repo quality bonuses
- * - issue-vetting.ts  — individual issue checks (PRs, claims, health, guidelines)
+ * Delegates filtering, scoring, vetting, and search infrastructure to focused modules (#356, #621):
+ * - issue-filtering.ts  — spam detection, doc-only filtering, per-repo caps
+ * - issue-scoring.ts   — viability scores, repo quality bonuses
+ * - issue-vetting.ts   — vetting orchestration, recommendation + viability scoring
+ * - issue-eligibility.ts — PR existence, claim detection, requirements analysis
+ * - repo-health.ts     — project health checks, contribution guidelines
+ * - search-phases.ts   — search helpers, caching, batched repo search
  */
 import { type IssueCandidate } from './types.js';
-import { type ViabilityScoreParams } from './issue-scoring.js';
-export { isDocOnlyIssue, applyPerRepoCap, isLabelFarming, hasTemplatedTitle, detectLabelFarmingRepos, DOC_ONLY_LABELS, BEGINNER_LABELS, type GitHubSearchItem, } from './issue-filtering.js';
-export { calculateRepoQualityBonus, calculateViabilityScore, type ViabilityScoreParams } from './issue-scoring.js';
-export { type CheckResult } from './issue-vetting.js';
-export type { SearchPriority, IssueCandidate } from './types.js';
 export declare class IssueDiscovery {
     private octokit;
     private stateManager;
@@ -20,12 +18,6 @@ export declare class IssueDiscovery {
     /** Set after searchIssues() runs if rate limits affected the search (low pre-flight quota or mid-search rate limit hits). */
     rateLimitWarning: string | null;
     constructor(githubToken: string);
-    /**
-     * Wrap octokit.search.issuesAndPullRequests with time-based caching.
-     * Repeated identical queries within SEARCH_CACHE_TTL_MS return cached results
-     * without consuming GitHub API rate limit points.
-     */
-    private cachedSearch;
     /**
      * Fetch the authenticated user's starred repositories from GitHub.
      * Updates the state manager with the list and timestamp.
@@ -35,11 +27,6 @@ export declare class IssueDiscovery {
      * Get starred repos, fetching from GitHub if cache is stale
      */
     getStarredReposWithRefresh(): Promise<string[]>;
-    /**
-     * Shared pipeline for Phases 2 and 3: spam-filter, repo-exclusion, vetting, and star-count filter.
-     * Extracts the common logic so each phase only needs to supply search results and context.
-     */
-    private filterVetAndScore;
     /**
      * Search for issues matching our criteria.
      * Searches in priority order: merged-PR repos first (no label filter), then starred repos,
@@ -51,34 +38,10 @@ export declare class IssueDiscovery {
         labels?: string[];
         maxResults?: number;
     }): Promise<IssueCandidate[]>;
-    /**
-     * Search for issues within specific repos using batched queries.
-     *
-     * To avoid GitHub's secondary rate limit (30 requests/minute), we batch
-     * multiple repos into a single search query using OR syntax:
-     *   repo:owner1/repo1 OR repo:owner2/repo2 OR repo:owner3/repo3
-     *
-     * This reduces API calls from N (one per repo) to ceil(N/BATCH_SIZE).
-     */
-    private searchInRepos;
-    /**
-     * Split repos into batches of the specified size.
-     */
-    private batchRepos;
     /**
      * Vet a specific issue (delegates to IssueVetter).
      */
     vetIssue(issueUrl: string): Promise<IssueCandidate>;
-    /**
-     * Analyze issue requirements for clarity (delegates to IssueVetter).
-     * Kept on class for backward compatibility.
-     */
-    analyzeRequirements(body: string): boolean;
-    /**
-     * Calculate viability score for an issue (delegates to issue-scoring module).
-     * Kept on class for backward compatibility with tests that call instance.calculateViabilityScore().
-     */
-    calculateViabilityScore(params: ViabilityScoreParams): number;
     /**
      * Save search results to ~/.oss-autopilot/found-issues.md
      * Results are sorted by viability score (highest first)