@oss-autopilot/core 0.41.0

package/dist/commands/startup.js

@@ -0,0 +1,197 @@
+/**
+ * Startup command
+ * Combines all pre-flight checks into a single CLI invocation:
+ * auth check, setup check, daily fetch, dashboard generation, version detection, issue list detection.
+ *
+ * Replaces the ~100-line inline bash script in commands/oss.md with a single
+ * `node cli.bundle.cjs startup --json` call, reducing UI noise in Claude Code.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execFile } from 'child_process';
+import { getStateManager, getGitHubToken } from '../core/index.js';
+import { outputJson, outputJsonError } from '../formatters/json.js';
+import { executeDailyCheck } from './daily.js';
+import { writeDashboardFromState } from './dashboard.js';
+function getVersion() {
+    try {
+        const pkgPath = path.join(path.dirname(process.argv[1]), '..', 'package.json');
+        return JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version;
+    }
+    catch (error) {
+        console.error('[STARTUP] Failed to detect CLI version:', error instanceof Error ? error.message : error);
+        return '0.0.0';
+    }
+}
+/**
+ * Parse issueListPath from a config file's YAML frontmatter.
+ * Returns the path string or undefined if not found.
+ */
+export function parseIssueListPathFromConfig(configContent) {
+    const match = configContent.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return undefined;
+    const frontmatter = match[1];
+    const pathMatch = frontmatter.match(/issueListPath:\s*["']?([^"'\n]+)["']?/);
+    return pathMatch ? pathMatch[1].trim() : undefined;
+}
+/**
+ * Count available and completed items in an issue list file.
+ * Available: list items (- [) NOT struck through or marked Done.
+ * Completed: list items that ARE struck through or marked Done.
+ */
+export function countIssueListItems(content) {
+    let availableCount = 0;
+    let completedCount = 0;
+    const lines = content.split('\n');
+    for (const line of lines) {
+        // Match list items: "- [" or "- ~~[" (strikethrough completed items)
+        if (/^\s*- (?:~~)?\[/.test(line)) {
+            if (/~~|\*\*Done\*\*/.test(line)) {
+                completedCount++;
+            }
+            else {
+                availableCount++;
+            }
+        }
+    }
+    return { availableCount, completedCount };
+}
+/**
+ * Detect an issue list file from config or known paths.
+ * Returns IssueListInfo or undefined if no list found.
+ */
+export function detectIssueList() {
+    let issueListPath = '';
+    let source = 'auto-detected';
+    // 1. Check config file for configured path
+    const configPath = '.claude/oss-autopilot/config.md';
+    if (fs.existsSync(configPath)) {
+        try {
+            const configContent = fs.readFileSync(configPath, 'utf-8');
+            const configuredPath = parseIssueListPathFromConfig(configContent);
+            if (configuredPath && fs.existsSync(configuredPath)) {
+                issueListPath = configuredPath;
+                source = 'configured';
+            }
+        }
+        catch (error) {
+            console.error('[STARTUP] Failed to read config:', error instanceof Error ? error.message : error);
+        }
+    }
+    // 2. Probe known paths
+    if (!issueListPath) {
+        const probes = ['open-source/potential-issue-list.md', 'oss/issue-list.md', 'issues.md'];
+        for (const probe of probes) {
+            if (fs.existsSync(probe)) {
+                issueListPath = probe;
+                source = 'auto-detected';
+                break;
+            }
+        }
+    }
+    if (!issueListPath)
+        return undefined;
+    // 3. Count available/completed items
+    try {
+        const content = fs.readFileSync(issueListPath, 'utf-8');
+        const { availableCount, completedCount } = countIssueListItems(content);
+        return { path: issueListPath, source, availableCount, completedCount };
+    }
+    catch (error) {
+        console.error(`[STARTUP] Failed to read issue list at ${issueListPath}:`, error instanceof Error ? error.message : error);
+        return { path: issueListPath, source, availableCount: 0, completedCount: 0 };
+    }
+}
+function openInBrowser(filePath) {
+    const isWindows = process.platform === 'win32';
+    const openCmd = process.platform === 'darwin' ? 'open' : isWindows ? 'cmd' : 'xdg-open';
+    const args = isWindows ? ['/c', 'start', '', filePath] : [filePath];
+    execFile(openCmd, args, (error) => {
+        if (error) {
+            console.error(`[STARTUP] Failed to open dashboard in browser: ${error.message}`);
+        }
+    });
+}
+export async function runStartup(options) {
+    const version = getVersion();
+    const stateManager = getStateManager();
+    // 1. Check setup
+    if (!stateManager.isSetupComplete()) {
+        if (options.json) {
+            outputJson({ version, setupComplete: false });
+        }
+        else {
+            console.log('Setup incomplete. Run /setup-oss first.');
+        }
+        return;
+    }
+    // 2. Check auth
+    const token = getGitHubToken();
+    if (!token) {
+        if (options.json) {
+            outputJson({
+                version,
+                setupComplete: true,
+                authError: 'GitHub authentication required. Install GitHub CLI (https://cli.github.com/) and run "gh auth login", or set GITHUB_TOKEN.',
+            });
+        }
+        else {
+            console.error('Error: GitHub authentication required.');
+        }
+        return;
+    }
+    // 3. Run daily check
+    try {
+        const daily = await executeDailyCheck(token);
+        // 4. Generate dashboard from state (just saved by daily)
+        // Skip opening on first run (0 PRs) — the welcome flow handles onboarding
+        let dashboardPath;
+        let dashboardOpened = false;
+        try {
+            dashboardPath = writeDashboardFromState();
+            if (daily.digest.summary.totalActivePRs > 0) {
+                openInBrowser(dashboardPath);
+                dashboardOpened = true;
+            }
+        }
+        catch (error) {
+            console.error('[STARTUP] Dashboard generation failed:', error instanceof Error ? error.message : error);
+        }
+        // Append dashboard status to brief summary (only startup opens the browser, not daily)
+        if (dashboardOpened) {
+            daily.briefSummary += ' | Dashboard opened in browser';
+        }
+        // 5. Detect issue list
+        const issueList = detectIssueList();
+        // 6. Output
+        if (options.json) {
+            outputJson({
+                version,
+                setupComplete: true,
+                daily,
+                dashboardPath,
+                issueList,
+            });
+        }
+        else {
+            console.log(`OSS Autopilot v${version}`);
+            console.log(daily.briefSummary);
+            if (dashboardPath)
+                console.log(`Dashboard: ${dashboardPath}`);
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (options.json) {
+            outputJsonError(`Daily check failed: ${msg}`);
+        }
+        else {
+            console.error(`[FATAL] Daily check failed: ${msg}`);
+            if (error instanceof Error && error.stack) {
+                console.error(error.stack);
+            }
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Status command
+ * Shows current status and stats
+ */
+interface StatusOptions {
+    json?: boolean;
+    offline?: boolean;
+}
+export declare function runStatus(options: StatusOptions): Promise<void>;
+export {};

package/dist/commands/status.js

@@ -0,0 +1,43 @@
+/**
+ * Status command
+ * Shows current status and stats
+ */
+import { getStateManager } from '../core/index.js';
+import { outputJson } from '../formatters/json.js';
+export async function runStatus(options) {
+    const stateManager = getStateManager();
+    const stats = stateManager.getStats();
+    const state = stateManager.getState();
+    // Status always reads from local state (no API calls), so offline mode
+    // simply adds metadata about cache freshness.
+    const lastUpdated = state.lastDigestAt || state.lastRunAt;
+    if (options.json) {
+        // Extract only the stats we want to output (exclude totalTracked)
+        const { totalTracked: _totalTracked, ...outputStats } = stats;
+        const output = {
+            stats: outputStats,
+            lastRunAt: state.lastRunAt,
+        };
+        if (options.offline) {
+            output.offline = true;
+            output.lastUpdated = lastUpdated;
+        }
+        outputJson(output);
+    }
+    else {
+        // Simple console output
+        console.log('\n📊 OSS Status\n');
+        console.log(`Merged PRs: ${stats.mergedPRs}`);
+        console.log(`Closed PRs: ${stats.closedPRs}`);
+        console.log(`Merge Rate: ${stats.mergeRate}`);
+        console.log(`Needs Response: ${stats.needsResponse}`);
+        if (options.offline) {
+            console.log(`\nLast Updated: ${lastUpdated || 'Never'}`);
+            console.log('(Offline mode: showing cached data)');
+        }
+        else {
+            console.log(`\nLast Run: ${state.lastRunAt || 'Never'}`);
+        }
+        console.log('\nRun with --json for structured output');
+    }
+}

package/dist/commands/track.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Track/Untrack commands
+ * In v2, PRs are fetched fresh from GitHub on each `daily` run.
+ * These commands are preserved for backward compatibility.
+ */
+interface TrackOptions {
+    prUrl: string;
+    json?: boolean;
+}
+interface UntrackOptions {
+    prUrl: string;
+    json?: boolean;
+}
+export declare function runTrack(options: TrackOptions): Promise<void>;
+export declare function runUntrack(options: UntrackOptions): Promise<void>;
+export {};

package/dist/commands/track.js

@@ -0,0 +1,59 @@
+/**
+ * Track/Untrack commands
+ * In v2, PRs are fetched fresh from GitHub on each `daily` run.
+ * These commands are preserved for backward compatibility.
+ */
+import { getOctokit, getGitHubToken } from '../core/index.js';
+import { outputJson, outputJsonError } from '../formatters/json.js';
+import { validateUrl, PR_URL_PATTERN, validateGitHubUrl } from './validation.js';
+import { parseGitHubUrl } from '../core/utils.js';
+export async function runTrack(options) {
+    validateUrl(options.prUrl);
+    validateGitHubUrl(options.prUrl, PR_URL_PATTERN, 'PR', options.json);
+    // Token is guaranteed by the preAction hook in cli.ts for non-LOCAL_ONLY_COMMANDS.
+    const token = getGitHubToken();
+    const octokit = getOctokit(token);
+    const parsed = parseGitHubUrl(options.prUrl);
+    if (!parsed || parsed.type !== 'pull') {
+        if (options.json) {
+            outputJsonError(`Invalid PR URL: ${options.prUrl}`);
+        }
+        else {
+            console.error(`Error: Invalid PR URL: ${options.prUrl}`);
+        }
+        process.exit(1);
+    }
+    const { owner, repo, number } = parsed;
+    if (!options.json) {
+        console.log(`\n📌 Fetching PR: ${options.prUrl}\n`);
+    }
+    const { data: ghPR } = await octokit.pulls.get({ owner, repo, pull_number: number });
+    const pr = {
+        repo: `${owner}/${repo}`,
+        number,
+        title: ghPR.title,
+        url: options.prUrl,
+    };
+    if (options.json) {
+        outputJson({ pr });
+    }
+    else {
+        console.log(`PR: ${pr.repo}#${pr.number} - ${pr.title}`);
+        console.log('Note: In v2, PRs are tracked automatically via the daily run.');
+    }
+}
+export async function runUntrack(options) {
+    validateUrl(options.prUrl);
+    validateGitHubUrl(options.prUrl, PR_URL_PATTERN, 'PR', options.json);
+    if (options.json) {
+        outputJson({
+            removed: false,
+            url: options.prUrl,
+            message: 'In v2, PRs are fetched fresh on each daily run — there is no local tracking list to remove from.',
+        });
+    }
+    else {
+        console.log('Note: In v2, PRs are fetched fresh on each daily run — there is no local tracking list to remove from.');
+        console.log('Use `shelve` to temporarily hide a PR from the daily summary.');
+    }
+}

package/dist/commands/validation.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared validation patterns and helpers for CLI commands.
+ */
+/** Matches GitHub PR URLs: https://github.com/owner/repo/pull/123 */
+export declare const PR_URL_PATTERN: RegExp;
+/** Matches GitHub issue URLs: https://github.com/owner/repo/issues/123 */
+export declare const ISSUE_URL_PATTERN: RegExp;
+/**
+ * Validate a GitHub URL against a pattern. Exits with error if invalid.
+ */
+export declare function validateGitHubUrl(url: string, pattern: RegExp, entityType: 'PR' | 'issue', json?: boolean): void;
+/**
+ * Validate that a URL does not exceed the maximum allowed length.
+ * Returns the URL if valid, throws if too long.
+ */
+export declare function validateUrl(url: string): string;
+/**
+ * Validate that a PR/issue number is a positive integer within bounds.
+ * Returns the number if valid, throws if invalid.
+ */
+export declare function validatePRNumber(num: number): number;
+/**
+ * Validate that a message string does not exceed the maximum allowed length.
+ * Returns the message if valid, throws if too long.
+ */
+export declare function validateMessage(message: string): string;
+/**
+ * Validate that a repository identifier matches the "owner/repo" format.
+ * Returns the identifier if valid, throws if invalid.
+ */
+export declare function validateRepoIdentifier(repo: string): string;
+/**
+ * Validate a GitHub username against GitHub's username rules.
+ * Throws a ValidationError if the username is invalid.
+ *
+ * Rules:
+ * - Must not be empty
+ * - Maximum 39 characters
+ * - Only alphanumeric characters and hyphens
+ * - Cannot start or end with a hyphen
+ * - Cannot contain consecutive hyphens
+ */
+export declare function validateGitHubUsername(username: string): string;

package/dist/commands/validation.js

@@ -0,0 +1,112 @@
+/**
+ * Shared validation patterns and helpers for CLI commands.
+ */
+import { ValidationError } from '../core/errors.js';
+import { outputJsonError } from '../formatters/json.js';
+/** Matches GitHub PR URLs: https://github.com/owner/repo/pull/123 */
+export const PR_URL_PATTERN = /^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+$/;
+/** Matches GitHub issue URLs: https://github.com/owner/repo/issues/123 */
+export const ISSUE_URL_PATTERN = /^https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/\d+$/;
+/** Maximum allowed URL length */
+const MAX_URL_LENGTH = 2048;
+/** Maximum allowed PR/issue number */
+const MAX_PR_NUMBER = 999999;
+/** Maximum allowed message string length */
+const MAX_MESSAGE_LENGTH = 1000;
+/** Pattern for valid GitHub repository identifiers */
+const REPO_PATTERN = /^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/;
+/**
+ * Validate a GitHub URL against a pattern. Exits with error if invalid.
+ */
+export function validateGitHubUrl(url, pattern, entityType, json) {
+    if (pattern.test(url))
+        return;
+    const example = entityType === 'PR' ? 'https://github.com/owner/repo/pull/123' : 'https://github.com/owner/repo/issues/123';
+    const msg = `Invalid ${entityType} URL: ${url}. Expected format: ${example}`;
+    if (json) {
+        outputJsonError(msg);
+    }
+    else {
+        console.error(`Error: ${msg}`);
+    }
+    process.exit(1);
+}
+/**
+ * Validate that a URL does not exceed the maximum allowed length.
+ * Returns the URL if valid, throws if too long.
+ */
+export function validateUrl(url) {
+    if (url.length > MAX_URL_LENGTH) {
+        throw new Error(`URL exceeds maximum length of ${MAX_URL_LENGTH} characters`);
+    }
+    return url;
+}
+/**
+ * Validate that a PR/issue number is a positive integer within bounds.
+ * Returns the number if valid, throws if invalid.
+ */
+export function validatePRNumber(num) {
+    if (!Number.isInteger(num) || num < 1 || num > MAX_PR_NUMBER) {
+        throw new Error(`PR number must be a positive integer up to ${MAX_PR_NUMBER}`);
+    }
+    return num;
+}
+/**
+ * Validate that a message string does not exceed the maximum allowed length.
+ * Returns the message if valid, throws if too long.
+ */
+export function validateMessage(message) {
+    if (message.length > MAX_MESSAGE_LENGTH) {
+        throw new Error(`Message exceeds maximum length of ${MAX_MESSAGE_LENGTH} characters`);
+    }
+    return message;
+}
+/**
+ * Validate that a repository identifier matches the "owner/repo" format.
+ * Returns the identifier if valid, throws if invalid.
+ */
+export function validateRepoIdentifier(repo) {
+    if (!REPO_PATTERN.test(repo)) {
+        throw new Error(`Invalid repository format: "${repo}". Expected "owner/repo".`);
+    }
+    return repo;
+}
+/** Maximum allowed GitHub username length */
+const MAX_USERNAME_LENGTH = 39;
+/** Pattern for valid GitHub username characters (alphanumeric and hyphens) */
+const USERNAME_CHARS_PATTERN = /^[a-zA-Z0-9-]+$/;
+/** Pattern for consecutive hyphens */
+const CONSECUTIVE_HYPHENS_PATTERN = /--/;
+/**
+ * Validate a GitHub username against GitHub's username rules.
+ * Throws a ValidationError if the username is invalid.
+ *
+ * Rules:
+ * - Must not be empty
+ * - Maximum 39 characters
+ * - Only alphanumeric characters and hyphens
+ * - Cannot start or end with a hyphen
+ * - Cannot contain consecutive hyphens
+ */
+export function validateGitHubUsername(username) {
+    if (!username || username.trim().length === 0) {
+        throw new ValidationError('GitHub username cannot be empty.');
+    }
+    const trimmed = username.trim();
+    if (trimmed.length > MAX_USERNAME_LENGTH) {
+        throw new ValidationError(`GitHub username must be at most ${MAX_USERNAME_LENGTH} characters (got ${trimmed.length}).`);
+    }
+    if (!USERNAME_CHARS_PATTERN.test(trimmed)) {
+        throw new ValidationError('GitHub username can only contain alphanumeric characters and hyphens.');
+    }
+    if (trimmed.startsWith('-')) {
+        throw new ValidationError('GitHub username cannot start with a hyphen.');
+    }
+    if (trimmed.endsWith('-')) {
+        throw new ValidationError('GitHub username cannot end with a hyphen.');
+    }
+    if (CONSECUTIVE_HYPHENS_PATTERN.test(trimmed)) {
+        throw new ValidationError('GitHub username cannot contain consecutive hyphens.');
+    }
+    return trimmed;
+}

package/dist/commands/vet.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Vet command
+ * Vets a specific issue before working on it
+ */
+interface VetOptions {
+    issueUrl: string;
+    json?: boolean;
+}
+export declare function runVet(options: VetOptions): Promise<void>;
+export {};

package/dist/commands/vet.js

@@ -0,0 +1,36 @@
+/**
+ * Vet command
+ * Vets a specific issue before working on it
+ */
+import { IssueDiscovery, getGitHubToken } from '../core/index.js';
+import { outputJson } from '../formatters/json.js';
+import { validateUrl } from './validation.js';
+export async function runVet(options) {
+    validateUrl(options.issueUrl);
+    // Token is guaranteed by the preAction hook in cli.ts for non-LOCAL_ONLY_COMMANDS.
+    const token = getGitHubToken();
+    const discovery = new IssueDiscovery(token);
+    if (!options.json) {
+        console.log(`\n🔍 Vetting issue: ${options.issueUrl}\n`);
+    }
+    const candidate = await discovery.vetIssue(options.issueUrl);
+    if (options.json) {
+        outputJson({
+            issue: {
+                repo: candidate.issue.repo,
+                number: candidate.issue.number,
+                title: candidate.issue.title,
+                url: candidate.issue.url,
+                labels: candidate.issue.labels,
+            },
+            recommendation: candidate.recommendation,
+            reasonsToApprove: candidate.reasonsToApprove,
+            reasonsToSkip: candidate.reasonsToSkip,
+            projectHealth: candidate.projectHealth,
+            vettingResult: candidate.vettingResult,
+        });
+    }
+    else {
+        console.log(discovery.formatCandidate(candidate));
+    }
+}

package/dist/core/checklist-analysis.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Checklist Analysis - PR body checklist detection and conditional item filtering.
+ * Extracted from PRMonitor to isolate checklist-related logic (#263).
+ */
+import { FetchedPR } from './types.js';
+export declare function isConditionalChecklistItem(line: string): boolean;
+/**
+ * Analyze PR body for incomplete checklists (unchecked markdown checkboxes).
+ * Looks for patterns like "- [ ]" (unchecked) vs "- [x]" (checked).
+ * Only flags if there ARE checkboxes and some are unchecked.
+ * Conditional items (containing "if applicable", "(if ...)", etc.) are
+ * excluded from the incomplete count (#152).
+ */
+export declare function analyzeChecklist(body: string): {
+    hasIncompleteChecklist: boolean;
+    checklistStats?: FetchedPR['checklistStats'];
+};

package/dist/core/checklist-analysis.js

@@ -0,0 +1,39 @@
+/**
+ * Checklist Analysis - PR body checklist detection and conditional item filtering.
+ * Extracted from PRMonitor to isolate checklist-related logic (#263).
+ */
+/**
+ * Detect conditional checklist items that are intentionally left unchecked (#152).
+ * Matches patterns like "(if the PR is ...)", "if applicable", "N/A", "optional", etc.
+ * Conservative — only skips items with clear conditional language.
+ */
+const CONDITIONAL_CHECKLIST_PATTERN = /\(if\s|\bif applicable\b|\bif needed\b|\bif relevant\b|\bonly if\b|\bwhen applicable\b|\(optional\)|- \[ \]\s*optional\b|\bn\/a\b|\bnot applicable\b|\bif required\b|\bif necessary\b/;
+export function isConditionalChecklistItem(line) {
+    return CONDITIONAL_CHECKLIST_PATTERN.test(line.toLowerCase());
+}
+/**
+ * Analyze PR body for incomplete checklists (unchecked markdown checkboxes).
+ * Looks for patterns like "- [ ]" (unchecked) vs "- [x]" (checked).
+ * Only flags if there ARE checkboxes and some are unchecked.
+ * Conditional items (containing "if applicable", "(if ...)", etc.) are
+ * excluded from the incomplete count (#152).
+ */
+export function analyzeChecklist(body) {
+    if (!body)
+        return { hasIncompleteChecklist: false };
+    const checkedPattern = /- \[x\]/gi;
+    const uncheckedLinePattern = /^.*- \[ \].*$/gm;
+    const checkedMatches = body.match(checkedPattern) || [];
+    const uncheckedLines = body.match(uncheckedLinePattern) || [];
+    const checked = checkedMatches.length;
+    const total = checked + uncheckedLines.length;
+    // No checkboxes at all - not a checklist PR
+    if (total === 0)
+        return { hasIncompleteChecklist: false };
+    // Filter out conditional checklist items that are intentionally unchecked
+    const nonConditionalUnchecked = uncheckedLines.filter((line) => !isConditionalChecklistItem(line));
+    return {
+        hasIncompleteChecklist: nonConditionalUnchecked.length > 0,
+        checklistStats: { checked, total },
+    };
+}

package/dist/core/ci-analysis.d.ts

@@ -0,0 +1,78 @@
+/**
+ * CI Analysis - Classification and analysis of CI check runs and combined statuses.
+ * Extracted from PRMonitor to isolate CI-related logic (#263).
+ */
+import { CIFailureCategory, ClassifiedCheck, CIStatusResult } from './types.js';
+/**
+ * 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.
+ */
+export declare const FORK_LIMITATION_PATTERNS: RegExp[];
+/**
+ * Known CI check name patterns that indicate authorization gates (#81).
+ * These require maintainer approval and are not real failures.
+ */
+export declare const AUTH_GATE_PATTERNS: RegExp[];
+/**
+ * Known CI check name patterns that indicate infrastructure/transient failures (#145).
+ * These are runner issues, dependency install problems, or service outages — not code failures.
+ */
+export declare const INFRASTRUCTURE_PATTERNS: RegExp[];
+/**
+ * Classify a failing CI check as actionable, fork_limitation, auth_gate, or infrastructure (#81, #145).
+ * Default is 'actionable' — only known patterns get reclassified.
+ * When conclusion is provided (cancelled, timed_out), the check is classified as infrastructure.
+ */
+export declare function classifyCICheck(name: string, description?: string, conclusion?: string): CIFailureCategory;
+/**
+ * Classify all failing checks and return both the flat names array and classified array (#81, #145).
+ * Accepts optional conclusion data to detect infrastructure failures.
+ */
+export declare function classifyFailingChecks(failingCheckNames: string[], conclusions?: Map<string, string>): ClassifiedCheck[];
+/**
+ * Analyze check runs (GitHub Actions, etc.) and categorize them.
+ * Returns flags for failing/pending/success and lists of failing check names + conclusions.
+ */
+export declare function analyzeCheckRuns(checkRuns: Array<{
+    name: string;
+    conclusion: string | null;
+    status: string;
+}>): {
+    hasFailingChecks: boolean;
+    hasPendingChecks: boolean;
+    hasSuccessfulChecks: boolean;
+    failingCheckNames: string[];
+    failingCheckConclusions: Map<string, string>;
+};
+/** Result shape from analyzeCheckRuns, used by mergeStatuses. */
+export interface CheckRunAnalysis {
+    hasFailingChecks: boolean;
+    hasPendingChecks: boolean;
+    hasSuccessfulChecks: boolean;
+    failingCheckNames: string[];
+    failingCheckConclusions: Map<string, string>;
+}
+/** Result shape from analyzeCombinedStatus, used by mergeStatuses. */
+export interface CombinedStatusAnalysis {
+    effectiveCombinedState: string;
+    hasStatuses: boolean;
+    failingStatusNames: string[];
+}
+/**
+ * Analyze combined status API results (Travis, CircleCI, etc.).
+ * Filters out authorization-gate statuses and determines the effective combined state.
+ * Returns failing status context names in the result (does not mutate caller arrays).
+ */
+export declare function analyzeCombinedStatus(combinedStatus: {
+    state: string;
+    statuses: Array<{
+        state: string;
+        context: string;
+        description: string | null;
+    }>;
+}): CombinedStatusAnalysis;
+/**
+ * Merge check run analysis and combined status analysis into a final CIStatusResult.
+ * Priority: failing > pending > passing > unknown.
+ */
+export declare function mergeStatuses(checkRunAnalysis: CheckRunAnalysis, combinedAnalysis: CombinedStatusAnalysis, checkRunCount: number): CIStatusResult;