@oss-autopilot/core 0.41.0

package/dist/core/ci-analysis.js

@@ -0,0 +1,163 @@
+/**
+ * CI Analysis - Classification and analysis of CI check runs and combined statuses.
+ * Extracted from PRMonitor to isolate CI-related logic (#263).
+ */
+/**
+ * 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 const FORK_LIMITATION_PATTERNS = [
+    /vercel/i,
+    /netlify/i,
+    /\bpreview\s*deploy/i,
+    /\bdeploy\s*preview/i,
+    /storybook/i,
+    /chromatic/i,
+    /percy/i,
+    /cloudflare pages/i,
+];
+/**
+ * Known CI check name patterns that indicate authorization gates (#81).
+ * These require maintainer approval and are not real failures.
+ */
+export const AUTH_GATE_PATTERNS = [/authoriz/i, /approval/i, /\bcla\b/i, /license\/cla/i];
+/**
+ * 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 const INFRASTRUCTURE_PATTERNS = [
+    /\binstall\s*(os\s*)?dep(endenc|s\b)/i,
+    /\bsetup\s+fail(ed|ure)?\b/i,
+    /\bservice\s*unavailable/i,
+    /\binfrastructure/i,
+];
+/**
+ * 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 function classifyCICheck(name, description, conclusion) {
+    // Infrastructure: cancelled or timed_out jobs are transient failures (#145)
+    if (conclusion === 'cancelled' || conclusion === 'timed_out')
+        return 'infrastructure';
+    const nameLower = name.toLowerCase();
+    // Check name first (more reliable than description)
+    if (AUTH_GATE_PATTERNS.some((p) => p.test(nameLower)))
+        return 'auth_gate';
+    if (FORK_LIMITATION_PATTERNS.some((p) => p.test(nameLower)))
+        return 'fork_limitation';
+    if (INFRASTRUCTURE_PATTERNS.some((p) => p.test(nameLower)))
+        return 'infrastructure';
+    // Fall through to description only if name was not classified
+    if (description) {
+        const descLower = description.toLowerCase();
+        if (AUTH_GATE_PATTERNS.some((p) => p.test(descLower)))
+            return 'auth_gate';
+        if (FORK_LIMITATION_PATTERNS.some((p) => p.test(descLower)))
+            return 'fork_limitation';
+        if (INFRASTRUCTURE_PATTERNS.some((p) => p.test(descLower)))
+            return 'infrastructure';
+    }
+    return 'actionable';
+}
+/**
+ * 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 function classifyFailingChecks(failingCheckNames, conclusions) {
+    return failingCheckNames.map((name) => {
+        const conclusion = conclusions?.get(name);
+        return {
+            name,
+            category: classifyCICheck(name, undefined, conclusion),
+            conclusion,
+        };
+    });
+}
+/**
+ * Analyze check runs (GitHub Actions, etc.) and categorize them.
+ * Returns flags for failing/pending/success and lists of failing check names + conclusions.
+ */
+export function analyzeCheckRuns(checkRuns) {
+    let hasFailingChecks = false;
+    let hasPendingChecks = false;
+    let hasSuccessfulChecks = false;
+    const failingCheckNames = [];
+    const failingCheckConclusions = new Map();
+    for (const check of checkRuns) {
+        if (check.conclusion === 'failure' || check.conclusion === 'cancelled' || check.conclusion === 'timed_out') {
+            hasFailingChecks = true;
+            failingCheckNames.push(check.name);
+            failingCheckConclusions.set(check.name, check.conclusion);
+        }
+        else if (check.conclusion === 'action_required') {
+            hasPendingChecks = true; // Maintainer approval gate, not a real failure
+        }
+        else if (check.status === 'in_progress' || check.status === 'queued') {
+            hasPendingChecks = true;
+        }
+        else if (check.conclusion === 'success') {
+            hasSuccessfulChecks = true;
+        }
+    }
+    return { hasFailingChecks, hasPendingChecks, hasSuccessfulChecks, failingCheckNames, failingCheckConclusions };
+}
+/**
+ * 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 function analyzeCombinedStatus(combinedStatus) {
+    // Filter out authorization-gate statuses (e.g., Vercel "Authorization required to deploy")
+    // These are permission gates, not real CI failures
+    const realStatuses = combinedStatus.statuses.filter((s) => {
+        const desc = (s.description || '').toLowerCase();
+        return !(s.state === 'failure' && (desc.includes('authorization required') || desc.includes('authorize')));
+    });
+    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;
+    const hasStatuses = combinedStatus.statuses.length > 0;
+    // Collect failing status names from combined status API
+    const failingStatusNames = [];
+    for (const s of realStatuses) {
+        if (s.state === 'failure' || s.state === 'error') {
+            failingStatusNames.push(s.context);
+        }
+    }
+    return { effectiveCombinedState, hasStatuses, failingStatusNames };
+}
+/**
+ * Merge check run analysis and combined status analysis into a final CIStatusResult.
+ * Priority: failing > pending > passing > unknown.
+ */
+export function mergeStatuses(checkRunAnalysis, combinedAnalysis, checkRunCount) {
+    const { hasFailingChecks, hasPendingChecks, hasSuccessfulChecks, failingCheckNames, failingCheckConclusions } = checkRunAnalysis;
+    const { effectiveCombinedState, hasStatuses, failingStatusNames } = combinedAnalysis;
+    // Merge failing names from both check runs and combined statuses
+    const allFailingNames = [...failingCheckNames, ...failingStatusNames];
+    // Safety net: If we have ANY failing checks, report as failing
+    if (hasFailingChecks || effectiveCombinedState === 'failure' || effectiveCombinedState === 'error') {
+        return { status: 'failing', failingCheckNames: allFailingNames, failingCheckConclusions };
+    }
+    if (hasPendingChecks || effectiveCombinedState === 'pending') {
+        return { status: 'pending', failingCheckNames: [], failingCheckConclusions: new Map() };
+    }
+    if (hasSuccessfulChecks || effectiveCombinedState === 'success') {
+        return { status: 'passing', failingCheckNames: [], failingCheckConclusions: new Map() };
+    }
+    // No checks found at all - this is common for repos without CI
+    if (!hasStatuses && checkRunCount === 0) {
+        return { status: 'unknown', failingCheckNames: [], failingCheckConclusions: new Map() };
+    }
+    return { status: 'unknown', failingCheckNames: [], failingCheckConclusions: new Map() };
+}

package/dist/core/comment-utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared comment utility functions used by both PRMonitor and IssueConversationMonitor.
+ * Extracted to avoid circular dependencies between the two modules.
+ */
+/**
+ * Check if a comment author is a bot account.
+ * Matches the [bot] suffix convention and known bot usernames (case-insensitive).
+ */
+export declare function isBotAuthor(author: string): boolean;
+/**
+ * Detect acknowledgment comments that don't require a response.
+ * Returns true only when: no question mark, matches an acknowledgment keyword, and under 100 chars.
+ * Conservative -- missing a real acknowledgment (false negative) is safer than suppressing a substantive response (false positive).
+ */
+export declare function isAcknowledgmentComment(body: string): boolean;

package/dist/core/comment-utils.js

@@ -0,0 +1,52 @@
+/**
+ * Shared comment utility functions used by both PRMonitor and IssueConversationMonitor.
+ * Extracted to avoid circular dependencies between the two modules.
+ */
+// Bot accounts that don't follow the [bot] suffix convention
+const KNOWN_BOT_USERNAMES = new Set([
+    'allcontributors',
+    'changeset-bot',
+    'claassistant',
+    'codecov-commenter',
+    'greenkeeper',
+    'imgbot',
+    'netlify',
+    'renovate',
+    'snyk-bot',
+    'sonarcloud',
+    'stale',
+    'vercel',
+]);
+/**
+ * Check if a comment author is a bot account.
+ * Matches the [bot] suffix convention and known bot usernames (case-insensitive).
+ */
+export function isBotAuthor(author) {
+    return author.includes('[bot]') || KNOWN_BOT_USERNAMES.has(author.toLowerCase());
+}
+/**
+ * Detect acknowledgment comments that don't require a response.
+ * Returns true only when: no question mark, matches an acknowledgment keyword, and under 100 chars.
+ * Conservative -- missing a real acknowledgment (false negative) is safer than suppressing a substantive response (false positive).
+ */
+export function isAcknowledgmentComment(body) {
+    if (!body || body.length > 100)
+        return false;
+    if (body.includes('?'))
+        return false;
+    const lower = body.toLowerCase();
+    const ackKeywords = [
+        'thanks',
+        'thank you',
+        'lgtm',
+        'looks good',
+        'will review',
+        "we'll review",
+        "we'll get to this",
+        'noted',
+        'got it',
+        'will look',
+        'will check',
+    ];
+    return ackKeywords.some((kw) => lower.includes(kw));
+}

package/dist/core/concurrency.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Runs a worker pool that processes items with bounded concurrency.
+ * N workers consume from a shared index — simpler than Promise.race + splice.
+ */
+export declare function runWorkerPool<T>(items: T[], worker: (item: T) => Promise<void>, concurrency: number): Promise<void>;

package/dist/core/concurrency.js

@@ -0,0 +1,15 @@
+/**
+ * Runs a worker pool that processes items with bounded concurrency.
+ * N workers consume from a shared index — simpler than Promise.race + splice.
+ */
+export async function runWorkerPool(items, worker, concurrency) {
+    let index = 0;
+    const poolWorker = async () => {
+        while (index < items.length) {
+            const item = items[index++];
+            await worker(item);
+        }
+    };
+    const workerCount = Math.min(concurrency, items.length);
+    await Promise.all(Array.from({ length: workerCount }, () => poolWorker()));
+}

package/dist/core/daily-logic.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Domain logic extracted from src/commands/daily.ts.
+ *
+ * Pure or near-pure functions that operate on FetchedPR data:
+ *   - computeRepoSignals / groupPRsByRepo — per-repo aggregations
+ *   - assessCapacity — capacity assessment against active PRs
+ *   - collectActionableIssues — ordered list of issues needing attention
+ *   - computeActionMenu — pre-computed action menu for orchestration
+ *   - toShelvedPRRef — lightweight projection for digest display
+ *   - formatActionHint — human-readable maintainer action hint label
+ *   - formatBriefSummary / formatSummary / printDigest — rendering
+ */
+import type { FetchedPR, FetchedPRStatus, DailyDigest, ShelvedPRRef, MaintainerActionHint, ComputedRepoSignals, RepoGroup, CommentedIssue, CommentedIssueWithResponse } from './types.js';
+import type { CapacityAssessment, ActionableIssue, ActionMenu } from '../formatters/json.js';
+/**
+ * Statuses indicating maintainer engagement or action needed from the contributor.
+ * Used both for auto-unshelving shelved PRs and for counting critical issues in capacity assessment.
+ */
+export declare const CRITICAL_STATUSES: ReadonlySet<FetchedPRStatus>;
+/** Statuses indicating active maintainer engagement (reviews, feedback, merges). */
+export declare const ACTIVE_MAINTAINER_STATUSES: ReadonlySet<FetchedPRStatus>;
+/** Statuses indicating staleness — maintainer comments during these statuses don't count as responsive. */
+export declare const STALE_STATUSES: ReadonlySet<FetchedPRStatus>;
+/**
+ * Map a full FetchedPR to a lightweight ShelvedPRRef for digest output.
+ * Only the fields needed for display are retained, reducing JSON payload size.
+ */
+export declare function toShelvedPRRef(pr: FetchedPR): ShelvedPRRef;
+/**
+ * Group PRs by repository (#80).
+ * Ensures one agent per repo during parallel dispatch, preventing branch checkout conflicts.
+ */
+export declare function groupPRsByRepo(prs: FetchedPR[]): RepoGroup[];
+/**
+ * Compute per-repo maintainer signals from observed open PR data.
+ * - isResponsive: true if any PR in the repo has a maintainer comment and status
+ *   is not in STALE_STATUSES
+ * - hasActiveMaintainers: true if any PR in the repo has a status in ACTIVE_MAINTAINER_STATUSES
+ */
+export declare function computeRepoSignals(prs: FetchedPR[]): Map<string, ComputedRepoSignals>;
+/**
+ * Assess whether user has capacity for new issues.
+ * Only active (non-shelved) PRs count against the limit.
+ */
+export declare function assessCapacity(activePRs: FetchedPR[], maxActivePRs: number, shelvedPRCount: number): CapacityAssessment;
+/**
+ * Collect all actionable issues across PRs for the action-first flow.
+ * Order: Needs response -> Needs changes -> CI failing -> Merge conflicts -> Incomplete checklist
+ *
+ * Note: Recently closed PRs are informational only and excluded from this list.
+ * They are available separately in digest.recentlyClosedPRs (#156).
+ */
+export declare function collectActionableIssues(prs: FetchedPR[], snoozedUrls?: Set<string>): ActionableIssue[];
+/**
+ * Format a maintainer action hint as a human-readable label
+ */
+export declare function formatActionHint(hint: MaintainerActionHint): string;
+/**
+ * Compute the action menu from PR data and capacity.
+ * The orchestration layer can insert issue-list options (e.g., "Pick from list")
+ * using the context flags.
+ */
+export declare function computeActionMenu(actionableIssues: ActionableIssue[], capacity: CapacityAssessment, commentedIssues?: CommentedIssue[]): ActionMenu;
+/**
+ * Format a brief one-liner summary for the action-first flow
+ */
+export declare function formatBriefSummary(digest: DailyDigest, issueCount: number, issueResponseCount?: number): string;
+/**
+ * Format summary as markdown (used in JSON output for Claude to display verbatim)
+ */
+export declare function formatSummary(digest: DailyDigest, capacity: CapacityAssessment, issueResponses?: CommentedIssueWithResponse[]): string;
+/**
+ * Print digest to console (simple text output).
+ * Unified renderer: uses the same section ordering as formatSummary
+ * but outputs plain text with console.log instead of markdown links.
+ */
+export declare function printDigest(digest: DailyDigest, capacity: CapacityAssessment, commentedIssues?: CommentedIssue[]): void;