@oss-autopilot/core 0.47.2 → 0.48.0

package/dist/commands/dashboard-data.d.ts

@@ -3,7 +3,7 @@
  * Handles GitHub API calls, PR grouping, stats computation, and monthly chart data.
  * Consumed by the dashboard HTTP server (dashboard-server.ts) for the SPA API.
  */
-import { type DailyDigest, type AgentState, type MergedPR, type StoredMergedPR, type CommentedIssue } from '../core/types.js';
+import { type DailyDigest, type AgentState, type ClosedPR, type MergedPR, type StoredMergedPR, type StoredClosedPR, type CommentedIssue } from '../core/types.js';
 export interface DashboardStats {
     activePRs: number;
     shelvedPRs: number;
@@ -11,7 +11,7 @@ export interface DashboardStats {
     closedPRs: number;
     mergeRate: string;
 }
-export declare function buildDashboardStats(digest: DailyDigest, state: Readonly<AgentState>, storedMergedCount?: number): DashboardStats;
+export declare function buildDashboardStats(digest: DailyDigest, state: Readonly<AgentState>, storedMergedCount?: number, storedClosedCount?: number): DashboardStats;
 /**
  * Merge fresh API counts into existing stored counts.
  * Months present in the fresh data are updated; months only in the existing data are preserved.
@@ -32,6 +32,7 @@ export interface DashboardFetchResult {
     digest: DailyDigest;
     commentedIssues: CommentedIssue[];
     allMergedPRs: MergedPR[];
+    allClosedPRs: ClosedPR[];
 }
 /**
  * Fetch fresh dashboard data from GitHub.
@@ -44,6 +45,11 @@ export declare function fetchDashboardData(token: string): Promise<DashboardFetc
  * Skips entries with unparseable URLs.
  */
 export declare function storedToMergedPRs(stored: StoredMergedPR[]): MergedPR[];
+/**
+ * Convert StoredClosedPR[] to ClosedPR[] by deriving repo and number from URL.
+ * Skips entries with unparseable URLs.
+ */
+export declare function storedToClosedPRs(stored: StoredClosedPR[]): ClosedPR[];
 /**
  * Compute PRs grouped by repository from a digest and state.
  * Used for chart data in the dashboard API.

package/dist/commands/dashboard-data.js

@@ -6,12 +6,12 @@
 import { getStateManager, PRMonitor, IssueConversationMonitor, getOctokit } from '../core/index.js';
 import { errorMessage, isRateLimitOrAuthError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
-import { emptyPRCountsResult, fetchMergedPRsSince } from '../core/github-stats.js';
+import { emptyPRCountsResult, fetchMergedPRsSince, fetchClosedPRsSince } from '../core/github-stats.js';
 import { parseGitHubUrl } from '../core/utils.js';
 import { isBelowMinStars, } from '../core/types.js';
 import { toShelvedPRRef, buildStarFilter } from './daily.js';
 const MODULE = 'dashboard-data';
-export function buildDashboardStats(digest, state, storedMergedCount) {
+export function buildDashboardStats(digest, state, storedMergedCount, storedClosedCount) {
     const summary = digest.summary || {
         totalActivePRs: 0,
         totalMergedAllTime: 0,
@@ -19,16 +19,19 @@ export function buildDashboardStats(digest, state, storedMergedCount) {
         totalNeedingAttention: 0,
     };
     const minStars = state.config.minStars ?? 50;
-    // Use the higher of stored merged PR count and repoScores-derived count to avoid regressions
-    // when stored list hasn't caught up yet (first fetch caps at 300)
+    // Merged: use the higher of stored count vs repoScores aggregate to avoid regressions
+    // when the stored list hasn't caught up yet (initial fetch caps at 300 PRs)
     const mergedPRs = storedMergedCount !== undefined
         ? Math.max(storedMergedCount, summary.totalMergedAllTime)
         : summary.totalMergedAllTime;
+    // Closed: same anti-regression strategy — use the higher of stored count vs repoScores aggregate
+    const aggregateClosedCount = Object.values(state.repoScores || {}).reduce((sum, s) => sum + (isBelowMinStars(s.stargazersCount, minStars) ? 0 : s.closedWithoutMergeCount || 0), 0);
+    const closedPRs = storedClosedCount !== undefined ? Math.max(storedClosedCount, aggregateClosedCount) : aggregateClosedCount;
     return {
         activePRs: summary.totalActivePRs,
         shelvedPRs: (digest.shelvedPRs || []).length,
         mergedPRs,
-        closedPRs: Object.values(state.repoScores || {}).reduce((sum, s) => sum + (isBelowMinStars(s.stargazersCount, minStars) ? 0 : s.closedWithoutMergeCount || 0), 0),
+        closedPRs,
         mergeRate: `${(summary.mergeRate ?? 0).toFixed(1)}%`,
     };
 }
@@ -102,9 +105,10 @@ export async function fetchDashboardData(token) {
     const config = stateManager.getState().config;
     // Build star filter from cached repoScores (#576)
     const starFilter = buildStarFilter(stateManager.getState());
-    // Get watermark for incremental merged PR fetch
+    // Get watermarks for incremental PR fetch
     const watermark = stateManager.getMergedPRWatermark();
-    const [{ prs, failures }, recentlyClosedPRs, recentlyMergedPRs, mergedResult, closedResult, fetchedIssues, newMergedPRs,] = await Promise.all([
+    const closedWatermark = stateManager.getClosedPRWatermark();
+    const [{ prs, failures }, recentlyClosedPRs, recentlyMergedPRs, mergedResult, closedResult, fetchedIssues, newMergedPRs, newClosedPRs,] = await Promise.all([
         prMonitor.fetchUserOpenPRs(),
         prMonitor.fetchRecentlyClosedPRs().catch((err) => {
             if (isRateLimitOrAuthError(err))
@@ -151,6 +155,12 @@ export async function fetchDashboardData(token) {
             warn(MODULE, `Failed to fetch merged PRs for storage: ${errorMessage(err)}`);
             return [];
         }),
+        fetchClosedPRsSince(octokit, config, closedWatermark).catch((err) => {
+            if (isRateLimitOrAuthError(err))
+                throw err;
+            warn(MODULE, `Failed to fetch closed PRs for storage: ${errorMessage(err)}`);
+            return [];
+        }),
     ]);
     const commentedIssues = fetchedIssues.issues;
     if (fetchedIssues.failures.length > 0) {
@@ -166,8 +176,16 @@ export async function fetchDashboardData(token) {
     catch (error) {
         warn(MODULE, `Failed to store merged PRs: ${errorMessage(error)}`);
     }
-    // Convert stored merged PRs to full MergedPR type (derive repo/number from URL)
+    // Store new closed PRs incrementally (dedupes by URL)
+    try {
+        stateManager.addClosedPRs(newClosedPRs);
+    }
+    catch (error) {
+        warn(MODULE, `Failed to store closed PRs: ${errorMessage(error)}`);
+    }
+    // Convert stored PRs to full types (derive repo/number from URL)
     const allMergedPRs = storedToMergedPRs(stateManager.getMergedPRs());
+    const allClosedPRs = storedToClosedPRs(stateManager.getClosedPRs());
     // Store monthly chart data (opened/merged/closed) so charts have data
     const { monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
     const { monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed } = closedResult;
@@ -188,7 +206,7 @@ export async function fetchDashboardData(token) {
         warn(MODULE, `Failed to save dashboard digest to state: ${errorMessage(error)}`);
     }
     warn(MODULE, `Refreshed: ${prs.length} PRs fetched`);
-    return { digest, commentedIssues, allMergedPRs };
+    return { digest, commentedIssues, allMergedPRs, allClosedPRs };
 }
 /**
  * Convert StoredMergedPR[] to MergedPR[] by deriving repo and number from URL.
@@ -216,6 +234,32 @@ export function storedToMergedPRs(stored) {
     }
     return results;
 }
+/**
+ * Convert StoredClosedPR[] to ClosedPR[] by deriving repo and number from URL.
+ * Skips entries with unparseable URLs.
+ */
+export function storedToClosedPRs(stored) {
+    const results = [];
+    let skipped = 0;
+    for (const pr of stored) {
+        const parsed = parseGitHubUrl(pr.url);
+        if (!parsed) {
+            skipped++;
+            continue;
+        }
+        results.push({
+            url: pr.url,
+            repo: `${parsed.owner}/${parsed.repo}`,
+            number: parsed.number,
+            title: pr.title,
+            closedAt: pr.closedAt,
+        });
+    }
+    if (skipped > 0) {
+        warn(MODULE, `Skipped ${skipped} stored closed PR(s) with unparseable URLs`);
+    }
+    return results;
+}
 /**
  * Compute PRs grouped by repository from a digest and state.
  * Used for chart data in the dashboard API.

package/dist/commands/dashboard-lifecycle.js

@@ -102,7 +102,7 @@ export async function launchDashboardServer(options) {
         if (info) {
             // PID file appeared — verify the server is responding
             if (await isDashboardServerRunning(info.port)) {
-                return { url: `http://localhost:${info.port}`, port: info.port, alreadyRunning: false };
+                return { url: `http://oss.localhost:${info.port}`, port: info.port, alreadyRunning: false };
             }
         }
     }

package/dist/commands/dashboard-process.js

@@ -85,7 +85,7 @@ export async function findRunningDashboardServer() {
     }
     // Process exists — verify it's actually our server via HTTP probe
     if (await isDashboardServerRunning(info.port)) {
-        return { port: info.port, url: `http://localhost:${info.port}` };
+        return { port: info.port, url: `http://oss.localhost:${info.port}` };
     }
     // Process exists but not responding on expected port — stale
     removeDashboardServerInfo();

package/dist/commands/dashboard-server.js

@@ -12,7 +12,7 @@ import { getStateManager, getGitHubToken, getCLIVersion } from '../core/index.js
 import { errorMessage, ValidationError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
 import { validateUrl, validateGitHubUrl, PR_URL_PATTERN } from './validation.js';
-import { fetchDashboardData, computePRsByRepo, computeTopRepos, getMonthlyData, buildDashboardStats, storedToMergedPRs, } from './dashboard-data.js';
+import { fetchDashboardData, computePRsByRepo, computeTopRepos, getMonthlyData, buildDashboardStats, storedToMergedPRs, storedToClosedPRs, } from './dashboard-data.js';
 import { openInBrowser } from './startup.js';
 import { writeDashboardServerInfo, removeDashboardServerInfo } from './dashboard-process.js';
 import { RateLimiter } from './rate-limiter.js';
@@ -71,19 +71,20 @@ function applyStatusOverrides(prs, state) {
 /**
  * Build the JSON payload that the SPA expects from GET /api/data.
  */
-function buildDashboardJson(digest, state, commentedIssues, allMergedPRs) {
+function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClosedPRs) {
     const prsByRepo = computePRsByRepo(digest, state);
     const topRepos = computeTopRepos(prsByRepo);
     const { monthlyMerged, monthlyOpened, monthlyClosed } = getMonthlyData(state);
-    // Derive allMergedPRs from state if not provided (e.g. initial load from cached state)
+    // Derive from state if not provided (e.g. initial load from cached state)
     const mergedPRs = allMergedPRs ?? storedToMergedPRs(getStateManager().getMergedPRs());
-    // Filter out merged PRs from repos below the minStars threshold
+    const closedPRs = allClosedPRs ?? storedToClosedPRs(getStateManager().getClosedPRs());
+    // Filter out PRs from repos below the minStars threshold
     const minStars = state.config.minStars ?? 50;
-    const filteredMergedPRs = mergedPRs.filter((pr) => {
-        const repoScore = (state.repoScores || {})[pr.repo];
-        return !isBelowMinStars(repoScore?.stargazersCount, minStars);
-    });
-    const stats = buildDashboardStats(digest, state, filteredMergedPRs.length);
+    const repoScores = state.repoScores || {};
+    const isAboveMinStars = (pr) => !isBelowMinStars(repoScores[pr.repo]?.stargazersCount, minStars);
+    const filteredMergedPRs = mergedPRs.filter(isAboveMinStars);
+    const filteredClosedPRs = closedPRs.filter(isAboveMinStars);
+    const stats = buildDashboardStats(digest, state, filteredMergedPRs.length, filteredClosedPRs.length);
     const issueResponses = commentedIssues.filter((i) => i.status === 'new_response');
     return {
         stats,
@@ -100,6 +101,7 @@ function buildDashboardJson(digest, state, commentedIssues, allMergedPRs) {
         commentedIssues,
         issueResponses,
         allMergedPRs: filteredMergedPRs,
+        allClosedPRs: filteredClosedPRs,
     };
 }
 /**
@@ -339,7 +341,7 @@ export async function startDashboardServer(options) {
             const result = await fetchDashboardData(currentToken);
             cachedDigest = result.digest;
             cachedCommentedIssues = result.commentedIssues;
-            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs);
+            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs, result.allClosedPRs);
             sendJson(res, 200, cachedJsonData);
         }
         catch (error) {
@@ -442,8 +444,8 @@ export async function startDashboardServer(options) {
         startedAt: new Date().toISOString(),
         version: getCLIVersion(),
     });
-    const serverUrl = `http://localhost:${actualPort}`;
-    warn(MODULE, `Dashboard server running at ${serverUrl} (also: http://oss.localhost:${actualPort})`);
+    const serverUrl = `http://oss.localhost:${actualPort}`;
+    warn(MODULE, `Dashboard server running at ${serverUrl} (also: http://localhost:${actualPort})`);
     // ── Background refresh ─────────────────────────────────────────────────
     // Port is bound and PID file written — now fetch fresh data from GitHub
     // so subsequent /api/data requests get live data instead of cached state.
@@ -452,7 +454,7 @@ export async function startDashboardServer(options) {
             .then((result) => {
             cachedDigest = result.digest;
             cachedCommentedIssues = result.commentedIssues;
-            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs);
+            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs, result.allClosedPRs);
             warn(MODULE, 'Background data refresh complete');
         })
             .catch((error) => {

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

@@ -3,7 +3,7 @@
  * Extracted from PRMonitor to isolate statistics-gathering API calls (#263).
  */
 import { Octokit } from '@octokit/rest';
-import { ClosedPR, MergedPR, StoredMergedPR, type StarFilter } from './types.js';
+import { ClosedPR, MergedPR, StoredMergedPR, StoredClosedPR, type StarFilter } from './types.js';
 /** TTL for cached PR count results (24 hours — these stats change slowly). */
 export declare const PR_COUNTS_CACHE_TTL_MS: number;
 /** Return type shared by both merged and closed PR count functions. */
@@ -50,3 +50,12 @@ export declare function fetchRecentlyMergedPRs(octokit: Octokit, config: {
 export declare function fetchMergedPRsSince(octokit: Octokit, config: {
     githubUsername: string;
 }, since?: string): Promise<StoredMergedPR[]>;
+/**
+ * Fetch closed-without-merge PRs since a watermark date for incremental storage.
+ * If no watermark is provided (first-ever fetch), fetches all closed PRs (up to pagination cap).
+ * Returns StoredClosedPR[] (minimal: url, title, closedAt) for state persistence.
+ * Uses `is:unmerged` to exclude merged PRs (which are also "closed" in GitHub's model).
+ */
+export declare function fetchClosedPRsSince(octokit: Octokit, config: {
+    githubUsername: string;
+}, since?: string): Promise<StoredClosedPR[]>;

package/dist/core/github-stats.js

@@ -287,3 +287,61 @@ export async function fetchMergedPRsSince(octokit, config, since) {
     debug(MODULE, `Fetched ${results.length} merged PRs${since ? ' (incremental)' : ' (initial)'}`);
     return results;
 }
+/**
+ * Fetch closed-without-merge PRs since a watermark date for incremental storage.
+ * If no watermark is provided (first-ever fetch), fetches all closed PRs (up to pagination cap).
+ * Returns StoredClosedPR[] (minimal: url, title, closedAt) for state persistence.
+ * Uses `is:unmerged` to exclude merged PRs (which are also "closed" in GitHub's model).
+ */
+export async function fetchClosedPRsSince(octokit, config, since) {
+    if (!config.githubUsername) {
+        warn(MODULE, 'Skipping closed PRs fetch: no githubUsername configured.');
+        return [];
+    }
+    const dateFilter = since ? ` closed:>${since}` : '';
+    const q = `is:pr is:closed is:unmerged author:${config.githubUsername} -user:${config.githubUsername}${dateFilter}`;
+    debug(MODULE, `Fetching closed PRs${since ? ` since ${since}` : ' (all time)'}...`);
+    const results = [];
+    let page = 1;
+    let fetched = 0;
+    let totalCount;
+    while (true) {
+        const { data } = await octokit.search.issuesAndPullRequests({
+            q,
+            sort: 'updated',
+            order: 'desc',
+            per_page: 100,
+            page,
+        });
+        totalCount = data.total_count;
+        for (const item of data.items) {
+            const parsed = parseGitHubUrl(item.html_url);
+            if (!parsed) {
+                warn(MODULE, `Skipping closed PR with unparseable URL: ${item.html_url}`);
+                continue;
+            }
+            if (isOwnRepo(parsed.owner, config.githubUsername))
+                continue;
+            const closedAt = item.closed_at || '';
+            if (!closedAt) {
+                warn(MODULE, `Skipping closed PR with no close date: ${item.html_url}`);
+                continue;
+            }
+            results.push({
+                url: item.html_url,
+                title: item.title,
+                closedAt,
+            });
+        }
+        fetched += data.items.length;
+        if (fetched >= totalCount || fetched >= 1000 || data.items.length === 0 || page >= MAX_PAGINATION_PAGES) {
+            break;
+        }
+        page++;
+    }
+    if (fetched < totalCount && page >= MAX_PAGINATION_PAGES) {
+        warn(MODULE, `Pagination capped at ${MAX_PAGINATION_PAGES} pages: fetched ${fetched} of ${totalCount} closed PRs. Oldest PRs may be missing.`);
+    }
+    debug(MODULE, `Fetched ${results.length} closed PRs${since ? ' (incremental)' : ' (initial)'}`);
+    return results;
+}

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 } from './types.js';
+import { AgentState, TrackedIssue, RepoScore, RepoScoreUpdate, StateEvent, StateEventType, DailyDigest, LocalRepoCache, SnoozeInfo, 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),
@@ -129,6 +129,22 @@ export declare class StateManager {
      * @returns ISO date string of the most recent merge, or undefined if no stored PRs.
      */
     getMergedPRWatermark(): string | undefined;
+    /**
+     * Get all stored closed PRs.
+     * @returns Array of stored closed PRs, sorted by closedAt desc.
+     */
+    getClosedPRs(): StoredClosedPR[];
+    /**
+     * Add new closed PRs to the stored list. Deduplicates by URL and sorts by closedAt desc.
+     * @param prs - New closed PRs to add.
+     */
+    addClosedPRs(prs: StoredClosedPR[]): void;
+    /**
+     * Get the most recent closedAt timestamp from stored closed PRs.
+     * Used as the watermark for incremental fetching.
+     * @returns ISO date string of the most recent close, or undefined if no stored PRs.
+     */
+    getClosedPRWatermark(): string | undefined;
     /**
      * Store cached local repo scan results (#84).
      * @param cache - The scan results, paths scanned, and timestamp.

package/dist/core/state.js

@@ -576,10 +576,44 @@ export class StateManager {
         if (!prs || prs.length === 0)
             return undefined;
         // List is sorted desc by mergedAt, so first element is most recent
-        const watermark = prs[0].mergedAt;
-        if (!watermark)
+        return prs[0].mergedAt || undefined;
+    }
+    /**
+     * Get all stored closed PRs.
+     * @returns Array of stored closed PRs, sorted by closedAt desc.
+     */
+    getClosedPRs() {
+        return this.state.closedPRs ?? [];
+    }
+    /**
+     * Add new closed PRs to the stored list. Deduplicates by URL and sorts by closedAt desc.
+     * @param prs - New closed PRs to add.
+     */
+    addClosedPRs(prs) {
+        if (prs.length === 0)
+            return;
+        if (!this.state.closedPRs) {
+            this.state.closedPRs = [];
+        }
+        const existingUrls = new Set(this.state.closedPRs.map((pr) => pr.url));
+        const newPRs = prs.filter((pr) => !existingUrls.has(pr.url));
+        if (newPRs.length === 0)
+            return;
+        this.state.closedPRs.push(...newPRs);
+        this.state.closedPRs.sort((a, b) => b.closedAt.localeCompare(a.closedAt));
+        debug(MODULE, `Added ${newPRs.length} closed PRs (total: ${this.state.closedPRs.length})`);
+    }
+    /**
+     * Get the most recent closedAt timestamp from stored closed PRs.
+     * Used as the watermark for incremental fetching.
+     * @returns ISO date string of the most recent close, or undefined if no stored PRs.
+     */
+    getClosedPRWatermark() {
+        const prs = this.state.closedPRs;
+        if (!prs || prs.length === 0)
             return undefined;
-        return watermark;
+        // List is sorted desc by closedAt, so first element is most recent
+        return prs[0].closedAt || undefined;
     }
     /**
      * Store cached local repo scan results (#84).

package/dist/core/types.d.ts

@@ -298,7 +298,7 @@ export interface StateEvent {
     /** Event-specific payload (e.g., `{ repo: "owner/repo", number: 42 }` for PR events). */
     data: Record<string, unknown>;
 }
-/** Minimal record of a PR that was closed without being merged, used in the daily digest. */
+/** Minimal record of a PR that was closed without being merged, used in the daily digest and dashboard detail view. */
 export interface ClosedPR {
     url: string;
     repo: string;
@@ -313,7 +313,13 @@ export interface StoredMergedPR {
     title: string;
     mergedAt: string;
 }
-/** Minimal record of a PR that was merged, used in the daily digest. */
+/** Minimal closed PR data persisted in state.json. Repo/number derived from URL at display time. */
+export interface StoredClosedPR {
+    url: string;
+    title: string;
+    closedAt: string;
+}
+/** Minimal record of a PR that was merged, used in the daily digest and dashboard detail view. */
 export interface MergedPR {
     url: string;
     repo: string;
@@ -391,6 +397,8 @@ export interface AgentState {
     localRepoCache?: LocalRepoCache;
     /** All merged PRs stored incrementally. Source of truth for the merged PR detail view. */
     mergedPRs?: StoredMergedPR[];
+    /** All closed PRs stored incrementally. Source of truth for the closed PR detail view. */
+    closedPRs?: StoredClosedPR[];
     activeIssues: TrackedIssue[];
 }
 /** Cached results from scanning the filesystem for local git clones (#84). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-autopilot/core",
-  "version": "0.47.2",
+  "version": "0.48.0",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {