@oss-autopilot/core 0.50.0 → 0.51.1

package/dist/core/pr-monitor.js

@@ -10,10 +10,12 @@
  * - maintainer-analysis.ts: Maintainer action hint extraction
  * - display-utils.ts: Display label computation
  * - github-stats.ts: Merged/closed PR counts and star fetching
+ * - status-determination.ts: PR status classification logic
  */
 import { getOctokit } from './github.js';
 import { getStateManager } from './state.js';
 import { daysBetween, parseGitHubUrl, extractOwnerRepo, isOwnRepo, DEFAULT_CONCURRENCY } from './utils.js';
+import { determineStatus } from './status-determination.js';
 import { runWorkerPool } from './concurrency.js';
 import { ConfigurationError, ValidationError, errorMessage, getHttpStatusCode } from './errors.js';
 import { paginateAll } from './pagination.js';
@@ -30,6 +32,7 @@ import { fetchUserMergedPRCounts as fetchUserMergedPRCountsImpl, fetchUserClosed
 export { computeDisplayLabel } from './display-utils.js';
 export { classifyCICheck, classifyFailingChecks } from './ci-analysis.js';
 export { isConditionalChecklistItem } from './checklist-analysis.js';
+export { determineStatus } from './status-determination.js';
 const MODULE = 'pr-monitor';
 const MAX_CONCURRENT_REQUESTS = DEFAULT_CONCURRENCY;
 export class PRMonitor {
@@ -217,7 +220,7 @@ 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 } = this.determineStatus({
+        const { status, actionReason, waitReason, stalenessTier } = determineStatus({
             ciStatus,
             hasMergeConflict,
             hasUnrespondedComment,
@@ -275,115 +278,6 @@ export class PRMonitor {
         pr.displayDescription = displayDescription;
         return pr;
     }
-    /**
-     * Determine the overall status of a PR
-     */
-    determineStatus(input) {
-        const { ciStatus, hasMergeConflict, hasUnrespondedComment, hasIncompleteChecklist, reviewDecision, daysSinceActivity, dormantThreshold, approachingThreshold, latestCommitDate: rawCommitDate, latestCommitAuthor, contributorUsername, lastMaintainerCommentDate, latestChangesRequestedDate, hasActionableCIFailure = true, } = input;
-        // Compute staleness tier (independent of status)
-        let stalenessTier = 'active';
-        if (daysSinceActivity >= dormantThreshold)
-            stalenessTier = 'dormant';
-        else if (daysSinceActivity >= approachingThreshold)
-            stalenessTier = 'approaching_dormant';
-        // Only count the latest commit if it was authored by the contributor or a
-        // CI bot (#547, #568). Non-contributor commits (maintainer merge commits,
-        // GitHub suggestion commits) should not mask unaddressed feedback.
-        const latestCommitDate = rawCommitDate && this.isContributorCommit(latestCommitAuthor, contributorUsername) ? rawCommitDate : undefined;
-        // Priority order: needs_addressing (response/changes/ci/conflict/checklist) > waiting_on_maintainer (review/merge/addressed/ci_blocked)
-        if (hasUnrespondedComment) {
-            // If the contributor pushed a commit after the maintainer's comment,
-            // the changes have been addressed — waiting for maintainer re-review.
-            // Require a minimum 2-minute gap to avoid false positives from race
-            // conditions (pushing while review is being submitted) (#547).
-            if (latestCommitDate &&
-                lastMaintainerCommentDate &&
-                this.isCommitAfterComment(latestCommitDate, lastMaintainerCommentDate)) {
-                // Safety net (#431): if a CHANGES_REQUESTED review was submitted after
-                // the commit, the maintainer still expects changes — don't mask it
-                if (latestChangesRequestedDate && latestCommitDate < latestChangesRequestedDate) {
-                    return { status: 'needs_addressing', actionReason: 'needs_response', stalenessTier };
-                }
-                if (ciStatus === 'failing' && hasActionableCIFailure)
-                    return { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier };
-                // Non-actionable CI failures (infrastructure, fork, auth) don't block changes_addressed —
-                // the contributor can't fix them, so the relevant status is "waiting for re-review" (#502)
-                return { status: 'waiting_on_maintainer', waitReason: 'changes_addressed', stalenessTier };
-            }
-            return { status: 'needs_addressing', actionReason: 'needs_response', stalenessTier };
-        }
-        // Review requested changes but no unresponded comment.
-        // If the latest commit is before the review, the contributor hasn't addressed it yet.
-        if (reviewDecision === 'changes_requested' && latestChangesRequestedDate) {
-            if (!latestCommitDate || latestCommitDate < latestChangesRequestedDate) {
-                return { status: 'needs_addressing', actionReason: 'needs_changes', stalenessTier };
-            }
-            // Commit is after review — changes have been addressed
-            if (ciStatus === 'failing' && hasActionableCIFailure)
-                return { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier };
-            // Non-actionable CI failures don't block changes_addressed (#502)
-            return { status: 'waiting_on_maintainer', waitReason: 'changes_addressed', stalenessTier };
-        }
-        if (ciStatus === 'failing') {
-            return hasActionableCIFailure
-                ? { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier }
-                : { status: 'waiting_on_maintainer', waitReason: 'ci_blocked', stalenessTier };
-        }
-        if (hasMergeConflict) {
-            return { status: 'needs_addressing', actionReason: 'merge_conflict', stalenessTier };
-        }
-        if (hasIncompleteChecklist) {
-            return { status: 'needs_addressing', actionReason: 'incomplete_checklist', stalenessTier };
-        }
-        // Approved and CI passing/unknown = waiting on maintainer to merge
-        if (reviewDecision === 'approved' && (ciStatus === 'passing' || ciStatus === 'unknown')) {
-            return { status: 'waiting_on_maintainer', waitReason: 'pending_merge', stalenessTier };
-        }
-        // Default: no actionable issues found. Covers pending CI, no reviews yet, etc.
-        return { status: 'waiting_on_maintainer', waitReason: 'pending_review', stalenessTier };
-    }
-    /**
-     * CI-fix bots that push commits as a direct result of the contributor's push (#568).
-     * Their commits represent contributor work and should count as addressing feedback.
-     * This is intentionally an allowlist — not all `[bot]` accounts are CI-fix bots
-     * (e.g. dependabot[bot] and renovate[bot] open their own PRs).
-     * Values must be lowercase — lookup uses .toLowerCase() for case-insensitive matching.
-     */
-    static CI_FIX_BOTS = new Set([
-        'autofix-ci[bot]',
-        'prettier-ci[bot]',
-        'pre-commit-ci[bot]',
-    ]);
-    /**
-     * Check whether the HEAD commit was authored by the contributor (#547).
-     * Returns true when the author matches, when the author is a known CI-fix
-     * bot (#568), or when author info is unavailable (graceful degradation).
-     */
-    isContributorCommit(commitAuthor, contributorUsername) {
-        if (!commitAuthor || !contributorUsername)
-            return true; // degrade gracefully
-        const author = commitAuthor.toLowerCase();
-        if (PRMonitor.CI_FIX_BOTS.has(author))
-            return true; // CI-fix bots act on behalf of the contributor (#568)
-        return author === contributorUsername.toLowerCase();
-    }
-    /** Minimum gap (ms) between maintainer comment and contributor commit for
-     *  the commit to count as "addressing" the feedback (#547). Prevents false
-     *  positives from race conditions, clock skew, and in-flight pushes. */
-    static MIN_RESPONSE_GAP_MS = 2 * 60 * 1000; // 2 minutes
-    /**
-     * Check whether the contributor's commit is meaningfully after the maintainer's
-     * comment — i.e. the commit timestamp is at least MIN_RESPONSE_GAP_MS later (#547).
-     */
-    isCommitAfterComment(commitDate, commentDate) {
-        const commitMs = new Date(commitDate).getTime();
-        const commentMs = new Date(commentDate).getTime();
-        if (Number.isNaN(commitMs) || Number.isNaN(commentMs)) {
-            // Fall back to simple string comparison (pre-#547 behavior)
-            return commitDate > commentDate;
-        }
-        return commitMs - commentMs >= PRMonitor.MIN_RESPONSE_GAP_MS;
-    }
     /**
      * Check if PR has merge conflict
      */

package/dist/core/state.d.ts

@@ -2,7 +2,7 @@
  * State management for the OSS Contribution Agent
  * Persists state to a JSON file in ~/.oss-autopilot/
  */
-import { AgentState, TrackedIssue, RepoScore, RepoScoreUpdate, StateEvent, StateEventType, DailyDigest, LocalRepoCache, SnoozeInfo, StatusOverride, FetchedPRStatus, StoredMergedPR, StoredClosedPR } from './types.js';
+import { AgentState, TrackedIssue, RepoScore, RepoScoreUpdate, StateEvent, StateEventType, DailyDigest, LocalRepoCache, StatusOverride, FetchedPRStatus, StoredMergedPR, StoredClosedPR } from './types.js';
 /**
  * Acquire an advisory file lock using exclusive-create (`wx` flag).
  * If the lock file already exists but is stale (older than LOCK_TIMEOUT_MS or corrupt),
@@ -31,6 +31,7 @@ export declare function atomicWriteFileSync(filePath: string, data: string, mode
 export declare class StateManager {
     private state;
     private readonly inMemoryOnly;
+    private lastLoadedMtimeMs;
     /**
      * Create a new StateManager instance.
      * @param inMemoryOnly - When true, state is held only in memory and never read from or
@@ -92,6 +93,12 @@ export declare class StateManager {
      *   use the StateManager methods to make changes.
      */
     getState(): Readonly<AgentState>;
+    /**
+     * Re-read state from disk if the file has been modified since the last load/save.
+     * Uses mtime comparison (single statSync call) to avoid unnecessary JSON parsing.
+     * Returns true if state was reloaded, false if unchanged or in-memory mode.
+     */
+    reloadIfChanged(): boolean;
     /**
      * Store the latest daily digest for dashboard rendering.
      * @param digest - The freshly generated digest from the current daily run.
@@ -240,57 +247,25 @@ export declare class StateManager {
      */
     isPRShelved(url: string): boolean;
     /**
-     * Dismiss an issue or PR by URL. Dismissed URLs are excluded from `new_response` notifications
+     * Dismiss an issue by URL. Dismissed issues are excluded from `new_response` notifications
      * until new activity occurs after the dismiss timestamp.
-     * @param url - The full GitHub issue or PR URL.
-     * @param timestamp - ISO timestamp of when the issue/PR was dismissed.
+     * @param url - The full GitHub issue URL.
+     * @param timestamp - ISO timestamp of when the issue was dismissed.
      * @returns true if newly dismissed, false if already dismissed.
      */
     dismissIssue(url: string, timestamp: string): boolean;
     /**
-     * Undismiss an issue or PR by URL.
-     * @param url - The full GitHub issue or PR URL.
+     * Undismiss an issue by URL.
+     * @param url - The full GitHub issue URL.
      * @returns true if found and removed, false if not dismissed.
      */
     undismissIssue(url: string): boolean;
     /**
-     * Get the timestamp when an issue or PR was dismissed.
-     * @param url - The full GitHub issue or PR URL.
+     * Get the timestamp when an issue was dismissed.
+     * @param url - The full GitHub issue URL.
      * @returns The ISO dismiss timestamp, or undefined if not dismissed.
      */
     getIssueDismissedAt(url: string): string | undefined;
-    /**
-     * Snooze a PR's CI failure for a given number of days.
-     * Snoozed PRs are excluded from actionable CI failure lists until the snooze expires.
-     * @param url - The full GitHub PR URL.
-     * @param reason - Why the CI failure is being snoozed (e.g., "upstream infrastructure issue").
-     * @param durationDays - Number of days to snooze. Default 7.
-     * @returns true if newly snoozed, false if already snoozed.
-     */
-    snoozePR(url: string, reason: string, durationDays: number): boolean;
-    /**
-     * Unsnooze a PR by URL.
-     * @param url - The full GitHub PR URL.
-     * @returns true if found and removed, false if not snoozed.
-     */
-    unsnoozePR(url: string): boolean;
-    /**
-     * Check if a PR is currently snoozed (not expired).
-     * @param url - The full GitHub PR URL.
-     * @returns true if the PR is snoozed and the snooze has not expired.
-     */
-    isSnoozed(url: string): boolean;
-    /**
-     * Get snooze metadata for a PR.
-     * @param url - The full GitHub PR URL.
-     * @returns The snooze metadata, or undefined if not snoozed.
-     */
-    getSnoozeInfo(url: string): SnoozeInfo | undefined;
-    /**
-     * Expire all snoozes that are past their `expiresAt` timestamp.
-     * @returns Array of PR URLs whose snoozes were expired.
-     */
-    expireSnoozes(): string[];
     /**
      * Set a manual status override for a PR.
      * @param url - The full GitHub PR URL.

package/dist/core/state.js

@@ -6,7 +6,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { INITIAL_STATE, isBelowMinStars, } from './types.js';
 import { getStatePath, getBackupDir, getDataDir } from './utils.js';
-import { ValidationError, errorMessage } from './errors.js';
+import { errorMessage } from './errors.js';
 import { debug, warn } from './logger.js';
 const MODULE = 'state';
 // Current state version
@@ -169,6 +169,7 @@ function migrateV1ToV2(rawState) {
 export class StateManager {
     state;
     inMemoryOnly;
+    lastLoadedMtimeMs = 0;
     /**
      * Create a new StateManager instance.
      * @param inMemoryOnly - When true, state is held only in memory and never read from or
@@ -196,7 +197,6 @@ export class StateManager {
                 trustedProjects: [],
                 shelvedPRUrls: [],
                 dismissedIssues: {},
-                snoozedPRs: {},
             },
             events: [],
             lastRunAt: new Date().toISOString(),
@@ -342,6 +342,41 @@ export class StateManager {
                     atomicWriteFileSync(statePath, JSON.stringify(state, null, 2), 0o600);
                     debug(MODULE, 'Migrated state saved');
                 }
+                // Strip legacy fields from persisted state (snoozedPRs and PR dismiss
+                // entries were removed in the three-state PR model simplification)
+                try {
+                    let needsCleanupSave = false;
+                    const rawConfig = state.config;
+                    if (rawConfig.snoozedPRs) {
+                        delete rawConfig.snoozedPRs;
+                        needsCleanupSave = true;
+                    }
+                    // Strip PR URLs from dismissedIssues (PR dismiss removed)
+                    if (state.config.dismissedIssues) {
+                        const PR_URL_RE = /\/pull\/\d+$/;
+                        for (const url of Object.keys(state.config.dismissedIssues)) {
+                            if (PR_URL_RE.test(url)) {
+                                delete state.config.dismissedIssues[url];
+                                needsCleanupSave = true;
+                            }
+                        }
+                    }
+                    if (needsCleanupSave) {
+                        atomicWriteFileSync(statePath, JSON.stringify(state, null, 2), 0o600);
+                        warn(MODULE, 'Cleaned up removed features (snoozedPRs, dismissed PR URLs) from persisted state');
+                    }
+                }
+                catch (cleanupError) {
+                    warn(MODULE, `Failed to clean up removed features from state: ${errorMessage(cleanupError)}`);
+                    // Continue with loaded state — cleanup will be retried on next load
+                }
+                // Record file mtime so reloadIfChanged() can detect external writes
+                try {
+                    this.lastLoadedMtimeMs = fs.statSync(getStatePath()).mtimeMs;
+                }
+                catch (error) {
+                    debug(MODULE, `Could not read state file mtime (reload detection will always trigger): ${errorMessage(error)}`);
+                }
                 // Log appropriate message based on version
                 const repoCount = Object.keys(state.repoScores).length;
                 debug(MODULE, `Loaded state v${state.version}: ${repoCount} repo scores tracked`);
@@ -472,6 +507,8 @@ export class StateManager {
             }
             // Atomic write: write to temp file then rename to prevent corruption on crash
             atomicWriteFileSync(statePath, JSON.stringify(this.state, null, 2), 0o600);
+            // Update mtime so own writes don't trigger reloadIfChanged()
+            this.lastLoadedMtimeMs = fs.statSync(statePath).mtimeMs;
             debug(MODULE, 'State saved successfully');
         }
         finally {
@@ -508,6 +545,40 @@ export class StateManager {
     getState() {
         return this.state;
     }
+    /**
+     * Re-read state from disk if the file has been modified since the last load/save.
+     * Uses mtime comparison (single statSync call) to avoid unnecessary JSON parsing.
+     * Returns true if state was reloaded, false if unchanged or in-memory mode.
+     */
+    reloadIfChanged() {
+        if (this.inMemoryOnly)
+            return false;
+        try {
+            const statePath = getStatePath();
+            const currentMtimeMs = fs.statSync(statePath).mtimeMs;
+            if (currentMtimeMs === this.lastLoadedMtimeMs)
+                return false;
+            this.state = this.load();
+            // load() only records lastLoadedMtimeMs on the happy path. Ensure it is
+            // always current after reload (covers backup-restore and fresh-state paths)
+            // to prevent repeated unnecessary reloads on every request.
+            try {
+                this.lastLoadedMtimeMs = fs.statSync(statePath).mtimeMs;
+            }
+            catch {
+                // If file was just loaded, stat should not fail. If it does,
+                // next reloadIfChanged() will simply trigger another reload.
+            }
+            return true;
+        }
+        catch (error) {
+            // statSync failure (file deleted) is benign — keep current in-memory state.
+            // load() failure should not happen (load() handles its own recovery),
+            // but if it does, keeping current state is the safest option.
+            warn(MODULE, `Failed to reload state from disk: ${errorMessage(error)}`);
+            return false;
+        }
+    }
     /**
      * Store the latest daily digest for dashboard rendering.
      * @param digest - The freshly generated digest from the current daily run.
@@ -803,10 +874,10 @@ export class StateManager {
     }
     // === Dismiss / Undismiss Issues ===
     /**
-     * Dismiss an issue or PR by URL. Dismissed URLs are excluded from `new_response` notifications
+     * Dismiss an issue by URL. Dismissed issues are excluded from `new_response` notifications
      * until new activity occurs after the dismiss timestamp.
-     * @param url - The full GitHub issue or PR URL.
-     * @param timestamp - ISO timestamp of when the issue/PR was dismissed.
+     * @param url - The full GitHub issue URL.
+     * @param timestamp - ISO timestamp of when the issue was dismissed.
      * @returns true if newly dismissed, false if already dismissed.
      */
     dismissIssue(url, timestamp) {
@@ -820,8 +891,8 @@ export class StateManager {
         return true;
     }
     /**
-     * Undismiss an issue or PR by URL.
-     * @param url - The full GitHub issue or PR URL.
+     * Undismiss an issue by URL.
+     * @param url - The full GitHub issue URL.
      * @returns true if found and removed, false if not dismissed.
      */
     undismissIssue(url) {
@@ -832,97 +903,13 @@ export class StateManager {
         return true;
     }
     /**
-     * Get the timestamp when an issue or PR was dismissed.
-     * @param url - The full GitHub issue or PR URL.
+     * Get the timestamp when an issue was dismissed.
+     * @param url - The full GitHub issue URL.
      * @returns The ISO dismiss timestamp, or undefined if not dismissed.
      */
     getIssueDismissedAt(url) {
         return this.state.config.dismissedIssues?.[url];
     }
-    // === Snooze / Unsnooze CI Failures ===
-    /**
-     * Snooze a PR's CI failure for a given number of days.
-     * Snoozed PRs are excluded from actionable CI failure lists until the snooze expires.
-     * @param url - The full GitHub PR URL.
-     * @param reason - Why the CI failure is being snoozed (e.g., "upstream infrastructure issue").
-     * @param durationDays - Number of days to snooze. Default 7.
-     * @returns true if newly snoozed, false if already snoozed.
-     */
-    snoozePR(url, reason, durationDays) {
-        if (!Number.isFinite(durationDays) || durationDays <= 0) {
-            throw new ValidationError(`Invalid snooze duration: ${durationDays}. Must be a positive finite number.`);
-        }
-        if (!this.state.config.snoozedPRs) {
-            this.state.config.snoozedPRs = {};
-        }
-        if (url in this.state.config.snoozedPRs) {
-            return false;
-        }
-        const now = new Date();
-        const expiresAt = new Date(now.getTime() + durationDays * 24 * 60 * 60 * 1000);
-        this.state.config.snoozedPRs[url] = {
-            reason,
-            snoozedAt: now.toISOString(),
-            expiresAt: expiresAt.toISOString(),
-        };
-        return true;
-    }
-    /**
-     * Unsnooze a PR by URL.
-     * @param url - The full GitHub PR URL.
-     * @returns true if found and removed, false if not snoozed.
-     */
-    unsnoozePR(url) {
-        if (!this.state.config.snoozedPRs || !(url in this.state.config.snoozedPRs)) {
-            return false;
-        }
-        delete this.state.config.snoozedPRs[url];
-        return true;
-    }
-    /**
-     * Check if a PR is currently snoozed (not expired).
-     * @param url - The full GitHub PR URL.
-     * @returns true if the PR is snoozed and the snooze has not expired.
-     */
-    isSnoozed(url) {
-        const info = this.getSnoozeInfo(url);
-        if (!info)
-            return false;
-        const expiresAtMs = new Date(info.expiresAt).getTime();
-        if (isNaN(expiresAtMs)) {
-            warn(MODULE, `Invalid expiresAt for snoozed PR ${url}: "${info.expiresAt}". Treating as not snoozed.`);
-            return false;
-        }
-        return expiresAtMs > Date.now();
-    }
-    /**
-     * Get snooze metadata for a PR.
-     * @param url - The full GitHub PR URL.
-     * @returns The snooze metadata, or undefined if not snoozed.
-     */
-    getSnoozeInfo(url) {
-        return this.state.config.snoozedPRs?.[url];
-    }
-    /**
-     * Expire all snoozes that are past their `expiresAt` timestamp.
-     * @returns Array of PR URLs whose snoozes were expired.
-     */
-    expireSnoozes() {
-        if (!this.state.config.snoozedPRs)
-            return [];
-        const expired = [];
-        const now = Date.now();
-        for (const [url, info] of Object.entries(this.state.config.snoozedPRs)) {
-            const expiresAtMs = new Date(info.expiresAt).getTime();
-            if (isNaN(expiresAtMs) || expiresAtMs <= now) {
-                expired.push(url);
-            }
-        }
-        for (const url of expired) {
-            delete this.state.config.snoozedPRs[url];
-        }
-        return expired;
-    }
     // === Status Overrides ===
     /**
      * Set a manual status override for a PR.

package/dist/core/status-determination.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Status determination logic for PRs — extracted from PRMonitor (#263).
+ *
+ * Computes the top-level status (needs_addressing vs waiting_on_maintainer),
+ * granular action/wait reasons, and staleness tier for a single PR based on
+ * its CI, review, merge-conflict, and timeline signals.
+ */
+import type { DetermineStatusInput, DetermineStatusResult } from './types.js';
+/**
+ * CI-fix bots that push commits as a direct result of the contributor's push (#568).
+ * Their commits represent contributor work and should count as addressing feedback.
+ * This is intentionally an allowlist — not all `[bot]` accounts are CI-fix bots
+ * (e.g. dependabot[bot] and renovate[bot] open their own PRs).
+ * Values must be lowercase — lookup uses .toLowerCase() for case-insensitive matching.
+ */
+export declare const CI_FIX_BOTS: ReadonlySet<string>;
+/** Minimum gap (ms) between maintainer comment and contributor commit for
+ *  the commit to count as "addressing" the feedback (#547). Prevents false
+ *  positives from race conditions, clock skew, and in-flight pushes. */
+export declare const MIN_RESPONSE_GAP_MS: number;
+/**
+ * Check whether the HEAD commit was authored by the contributor (#547).
+ * Returns true when the author matches, when the author is a known CI-fix
+ * bot (#568), or when author info is unavailable (graceful degradation).
+ */
+export declare function isContributorCommit(commitAuthor?: string, contributorUsername?: string): boolean;
+/**
+ * Check whether the contributor's commit is meaningfully after the maintainer's
+ * comment — i.e. the commit timestamp is at least MIN_RESPONSE_GAP_MS later (#547).
+ */
+export declare function isCommitAfterComment(commitDate: string, commentDate: string): boolean;
+/**
+ * Determine the overall status of a PR based on its signals.
+ */
+export declare function determineStatus(input: DetermineStatusInput): DetermineStatusResult;

package/dist/core/status-determination.js

@@ -0,0 +1,112 @@
+/**
+ * Status determination logic for PRs — extracted from PRMonitor (#263).
+ *
+ * Computes the top-level status (needs_addressing vs waiting_on_maintainer),
+ * granular action/wait reasons, and staleness tier for a single PR based on
+ * its CI, review, merge-conflict, and timeline signals.
+ */
+/**
+ * CI-fix bots that push commits as a direct result of the contributor's push (#568).
+ * Their commits represent contributor work and should count as addressing feedback.
+ * This is intentionally an allowlist — not all `[bot]` accounts are CI-fix bots
+ * (e.g. dependabot[bot] and renovate[bot] open their own PRs).
+ * Values must be lowercase — lookup uses .toLowerCase() for case-insensitive matching.
+ */
+export const CI_FIX_BOTS = new Set(['autofix-ci[bot]', 'prettier-ci[bot]', 'pre-commit-ci[bot]']);
+/** Minimum gap (ms) between maintainer comment and contributor commit for
+ *  the commit to count as "addressing" the feedback (#547). Prevents false
+ *  positives from race conditions, clock skew, and in-flight pushes. */
+export const MIN_RESPONSE_GAP_MS = 2 * 60 * 1000; // 2 minutes
+/**
+ * Check whether the HEAD commit was authored by the contributor (#547).
+ * Returns true when the author matches, when the author is a known CI-fix
+ * bot (#568), or when author info is unavailable (graceful degradation).
+ */
+export function isContributorCommit(commitAuthor, contributorUsername) {
+    if (!commitAuthor || !contributorUsername)
+        return true; // degrade gracefully
+    const author = commitAuthor.toLowerCase();
+    if (CI_FIX_BOTS.has(author))
+        return true; // CI-fix bots act on behalf of the contributor (#568)
+    return author === contributorUsername.toLowerCase();
+}
+/**
+ * Check whether the contributor's commit is meaningfully after the maintainer's
+ * comment — i.e. the commit timestamp is at least MIN_RESPONSE_GAP_MS later (#547).
+ */
+export function isCommitAfterComment(commitDate, commentDate) {
+    const commitMs = new Date(commitDate).getTime();
+    const commentMs = new Date(commentDate).getTime();
+    if (Number.isNaN(commitMs) || Number.isNaN(commentMs)) {
+        // Fall back to simple string comparison (pre-#547 behavior)
+        return commitDate > commentDate;
+    }
+    return commitMs - commentMs >= MIN_RESPONSE_GAP_MS;
+}
+/**
+ * Determine the overall status of a PR based on its signals.
+ */
+export function determineStatus(input) {
+    const { ciStatus, hasMergeConflict, hasUnrespondedComment, hasIncompleteChecklist, reviewDecision, daysSinceActivity, dormantThreshold, approachingThreshold, latestCommitDate: rawCommitDate, latestCommitAuthor, contributorUsername, lastMaintainerCommentDate, latestChangesRequestedDate, hasActionableCIFailure = true, } = input;
+    // Compute staleness tier (independent of status)
+    let stalenessTier = 'active';
+    if (daysSinceActivity >= dormantThreshold)
+        stalenessTier = 'dormant';
+    else if (daysSinceActivity >= approachingThreshold)
+        stalenessTier = 'approaching_dormant';
+    // Only count the latest commit if it was authored by the contributor or a
+    // CI bot (#547, #568). Non-contributor commits (maintainer merge commits,
+    // GitHub suggestion commits) should not mask unaddressed feedback.
+    const latestCommitDate = rawCommitDate && isContributorCommit(latestCommitAuthor, contributorUsername) ? rawCommitDate : undefined;
+    // Priority order: needs_addressing (response/changes/ci/conflict/checklist) > waiting_on_maintainer (review/merge/addressed/ci_blocked)
+    if (hasUnrespondedComment) {
+        // If the contributor pushed a commit after the maintainer's comment,
+        // the changes have been addressed — waiting for maintainer re-review.
+        // Require a minimum 2-minute gap to avoid false positives from race
+        // conditions (pushing while review is being submitted) (#547).
+        if (latestCommitDate &&
+            lastMaintainerCommentDate &&
+            isCommitAfterComment(latestCommitDate, lastMaintainerCommentDate)) {
+            // Safety net (#431): if a CHANGES_REQUESTED review was submitted after
+            // the commit, the maintainer still expects changes — don't mask it
+            if (latestChangesRequestedDate && latestCommitDate < latestChangesRequestedDate) {
+                return { status: 'needs_addressing', actionReason: 'needs_response', stalenessTier };
+            }
+            if (ciStatus === 'failing' && hasActionableCIFailure)
+                return { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier };
+            // Non-actionable CI failures (infrastructure, fork, auth) don't block changes_addressed —
+            // the contributor can't fix them, so the relevant status is "waiting for re-review" (#502)
+            return { status: 'waiting_on_maintainer', waitReason: 'changes_addressed', stalenessTier };
+        }
+        return { status: 'needs_addressing', actionReason: 'needs_response', stalenessTier };
+    }
+    // Review requested changes but no unresponded comment.
+    // If the latest commit is before the review, the contributor hasn't addressed it yet.
+    if (reviewDecision === 'changes_requested' && latestChangesRequestedDate) {
+        if (!latestCommitDate || latestCommitDate < latestChangesRequestedDate) {
+            return { status: 'needs_addressing', actionReason: 'needs_changes', stalenessTier };
+        }
+        // Commit is after review — changes have been addressed
+        if (ciStatus === 'failing' && hasActionableCIFailure)
+            return { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier };
+        // Non-actionable CI failures don't block changes_addressed (#502)
+        return { status: 'waiting_on_maintainer', waitReason: 'changes_addressed', stalenessTier };
+    }
+    if (ciStatus === 'failing') {
+        return hasActionableCIFailure
+            ? { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier }
+            : { status: 'waiting_on_maintainer', waitReason: 'ci_blocked', stalenessTier };
+    }
+    if (hasMergeConflict) {
+        return { status: 'needs_addressing', actionReason: 'merge_conflict', stalenessTier };
+    }
+    if (hasIncompleteChecklist) {
+        return { status: 'needs_addressing', actionReason: 'incomplete_checklist', stalenessTier };
+    }
+    // Approved and CI passing/unknown = waiting on maintainer to merge
+    if (reviewDecision === 'approved' && (ciStatus === 'passing' || ciStatus === 'unknown')) {
+        return { status: 'waiting_on_maintainer', waitReason: 'pending_merge', stalenessTier };
+    }
+    // Default: no actionable issues found. Covers pending CI, no reviews yet, etc.
+    return { status: 'waiting_on_maintainer', waitReason: 'pending_review', stalenessTier };
+}