@oss-autopilot/core 0.46.2 → 0.47.1

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 CommentedIssue } from '../core/types.js';
+import { type DailyDigest, type AgentState, type MergedPR, type StoredMergedPR, 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>): DashboardStats;
+export declare function buildDashboardStats(digest: DailyDigest, state: Readonly<AgentState>, storedMergedCount?: 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.
@@ -31,6 +31,7 @@ export declare function updateMonthlyAnalytics(prs: Array<{
 export interface DashboardFetchResult {
     digest: DailyDigest;
     commentedIssues: CommentedIssue[];
+    allMergedPRs: MergedPR[];
 }
 /**
  * Fetch fresh dashboard data from GitHub.
@@ -38,6 +39,11 @@ export interface DashboardFetchResult {
  * Throws if the fetch fails entirely (caller should fall back to cached data).
  */
 export declare function fetchDashboardData(token: string): Promise<DashboardFetchResult>;
+/**
+ * Convert StoredMergedPR[] to MergedPR[] by deriving repo and number from URL.
+ * Skips entries with unparseable URLs.
+ */
+export declare function storedToMergedPRs(stored: StoredMergedPR[]): MergedPR[];
 /**
  * Compute PRs grouped by repository from a digest and state.
  * Used for chart data in the dashboard API.

package/dist/commands/dashboard-data.js

@@ -3,14 +3,15 @@
  * 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 { getStateManager, PRMonitor, IssueConversationMonitor } from '../core/index.js';
+import { getStateManager, PRMonitor, IssueConversationMonitor, getOctokit } from '../core/index.js';
 import { errorMessage, isRateLimitOrAuthError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
-import { emptyPRCountsResult } from '../core/github-stats.js';
+import { emptyPRCountsResult, fetchMergedPRsSince } 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) {
+export function buildDashboardStats(digest, state, storedMergedCount) {
     const summary = digest.summary || {
         totalActivePRs: 0,
         totalMergedAllTime: 0,
@@ -18,10 +19,15 @@ export function buildDashboardStats(digest, state) {
         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)
+    const mergedPRs = storedMergedCount !== undefined
+        ? Math.max(storedMergedCount, summary.totalMergedAllTime)
+        : summary.totalMergedAllTime;
     return {
         activePRs: summary.totalActivePRs,
         shelvedPRs: (digest.shelvedPRs || []).length,
-        mergedPRs: summary.totalMergedAllTime,
+        mergedPRs,
         closedPRs: Object.values(state.repoScores || {}).reduce((sum, s) => sum + (isBelowMinStars(s.stargazersCount, minStars) ? 0 : s.closedWithoutMergeCount || 0), 0),
         mergeRate: `${(summary.mergeRate ?? 0).toFixed(1)}%`,
     };
@@ -92,9 +98,13 @@ export async function fetchDashboardData(token) {
     const stateManager = getStateManager();
     const prMonitor = new PRMonitor(token);
     const issueMonitor = new IssueConversationMonitor(token);
+    const octokit = getOctokit(token);
+    const config = stateManager.getState().config;
     // Build star filter from cached repoScores (#576)
     const starFilter = buildStarFilter(stateManager.getState());
-    const [{ prs, failures }, recentlyClosedPRs, recentlyMergedPRs, mergedResult, closedResult, fetchedIssues] = await Promise.all([
+    // Get watermark for incremental merged PR fetch
+    const watermark = stateManager.getMergedPRWatermark();
+    const [{ prs, failures }, recentlyClosedPRs, recentlyMergedPRs, mergedResult, closedResult, fetchedIssues, newMergedPRs,] = await Promise.all([
         prMonitor.fetchUserOpenPRs(),
         prMonitor.fetchRecentlyClosedPRs().catch((err) => {
             if (isRateLimitOrAuthError(err))
@@ -135,6 +145,12 @@ export async function fetchDashboardData(token) {
                 failures: [{ issueUrl: 'N/A', error: `Issue conversation fetch failed: ${msg}` }],
             };
         }),
+        fetchMergedPRsSince(octokit, config, watermark).catch((err) => {
+            if (isRateLimitOrAuthError(err))
+                throw err;
+            warn(MODULE, `Failed to fetch merged PRs for storage: ${errorMessage(err)}`);
+            return [];
+        }),
     ]);
     const commentedIssues = fetchedIssues.issues;
     if (fetchedIssues.failures.length > 0) {
@@ -143,6 +159,15 @@ export async function fetchDashboardData(token) {
     if (failures.length > 0) {
         warn(MODULE, `${failures.length} PR fetch(es) failed`);
     }
+    // Store new merged PRs incrementally (dedupes by URL)
+    try {
+        stateManager.addMergedPRs(newMergedPRs);
+    }
+    catch (error) {
+        warn(MODULE, `Failed to store merged PRs: ${errorMessage(error)}`);
+    }
+    // Convert stored merged PRs to full MergedPR type (derive repo/number from URL)
+    const allMergedPRs = storedToMergedPRs(stateManager.getMergedPRs());
     // Store monthly chart data (opened/merged/closed) so charts have data
     const { monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
     const { monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed } = closedResult;
@@ -163,7 +188,33 @@ 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 };
+    return { digest, commentedIssues, allMergedPRs };
+}
+/**
+ * Convert StoredMergedPR[] to MergedPR[] by deriving repo and number from URL.
+ * Skips entries with unparseable URLs.
+ */
+export function storedToMergedPRs(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,
+            mergedAt: pr.mergedAt,
+        });
+    }
+    if (skipped > 0) {
+        warn(MODULE, `Skipped ${skipped} stored merged PR(s) with unparseable URLs`);
+    }
+    return results;
 }
 /**
  * Compute PRs grouped by repository from a digest and state.

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, } from './dashboard-data.js';
+import { fetchDashboardData, computePRsByRepo, computeTopRepos, getMonthlyData, buildDashboardStats, storedToMergedPRs, } from './dashboard-data.js';
 import { openInBrowser } from './startup.js';
 import { writeDashboardServerInfo, removeDashboardServerInfo } from './dashboard-process.js';
 import { RateLimiter } from './rate-limiter.js';
@@ -70,11 +70,13 @@ function applyStatusOverrides(prs, state) {
 /**
  * Build the JSON payload that the SPA expects from GET /api/data.
  */
-function buildDashboardJson(digest, state, commentedIssues) {
+function buildDashboardJson(digest, state, commentedIssues, allMergedPRs) {
     const prsByRepo = computePRsByRepo(digest, state);
     const topRepos = computeTopRepos(prsByRepo);
     const { monthlyMerged, monthlyOpened, monthlyClosed } = getMonthlyData(state);
-    const stats = buildDashboardStats(digest, state);
+    // Derive allMergedPRs from state if not provided (e.g. initial load from cached state)
+    const mergedPRs = allMergedPRs ?? storedToMergedPRs(getStateManager().getMergedPRs());
+    const stats = buildDashboardStats(digest, state, mergedPRs.length);
     const issueResponses = commentedIssues.filter((i) => i.status === 'new_response');
     return {
         stats,
@@ -90,6 +92,7 @@ function buildDashboardJson(digest, state, commentedIssues) {
         autoUnshelvedPRs: digest.autoUnshelvedPRs || [],
         commentedIssues,
         issueResponses,
+        allMergedPRs: mergedPRs,
     };
 }
 /**
@@ -139,7 +142,7 @@ function isValidOrigin(req, port) {
     const origin = req.headers['origin'];
     if (!origin)
         return true; // No Origin header = same-origin request (non-browser or same-page)
-    const allowed = [`http://localhost:${port}`, `http://127.0.0.1:${port}`];
+    const allowed = [`http://localhost:${port}`, `http://127.0.0.1:${port}`, `http://oss.localhost:${port}`];
     return allowed.includes(origin);
 }
 /**
@@ -329,7 +332,7 @@ export async function startDashboardServer(options) {
             const result = await fetchDashboardData(currentToken);
             cachedDigest = result.digest;
             cachedCommentedIssues = result.commentedIssues;
-            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues);
+            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs);
             sendJson(res, 200, cachedJsonData);
         }
         catch (error) {
@@ -433,7 +436,7 @@ export async function startDashboardServer(options) {
         version: getCLIVersion(),
     });
     const serverUrl = `http://localhost:${actualPort}`;
-    warn(MODULE, `Dashboard server running at ${serverUrl}`);
+    warn(MODULE, `Dashboard server running at ${serverUrl} (also: http://oss.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.
@@ -442,7 +445,7 @@ export async function startDashboardServer(options) {
             .then((result) => {
             cachedDigest = result.digest;
             cachedCommentedIssues = result.commentedIssues;
-            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues);
+            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs);
             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, type StarFilter } from './types.js';
+import { ClosedPR, MergedPR, StoredMergedPR, 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. */
@@ -42,3 +42,11 @@ export declare function fetchRecentlyClosedPRs(octokit: Octokit, config: {
 export declare function fetchRecentlyMergedPRs(octokit: Octokit, config: {
     githubUsername: string;
 }, days?: number): Promise<MergedPR[]>;
+/**
+ * Fetch merged PRs since a watermark date for incremental storage.
+ * If no watermark is provided (first-ever fetch), fetches all merged PRs (up to pagination cap).
+ * Returns StoredMergedPR[] (minimal: url, title, mergedAt) for state persistence.
+ */
+export declare function fetchMergedPRsSince(octokit: Octokit, config: {
+    githubUsername: string;
+}, since?: string): Promise<StoredMergedPR[]>;

package/dist/core/github-stats.js

@@ -235,3 +235,55 @@ export async function fetchRecentlyMergedPRs(octokit, config, days = 7) {
         };
     });
 }
+/**
+ * Fetch merged PRs since a watermark date for incremental storage.
+ * If no watermark is provided (first-ever fetch), fetches all merged PRs (up to pagination cap).
+ * Returns StoredMergedPR[] (minimal: url, title, mergedAt) for state persistence.
+ */
+export async function fetchMergedPRsSince(octokit, config, since) {
+    if (!config.githubUsername) {
+        warn(MODULE, 'Skipping merged PRs fetch: no githubUsername configured.');
+        return [];
+    }
+    const dateFilter = since ? ` merged:>${since}` : '';
+    const q = `is:pr is:merged author:${config.githubUsername} -user:${config.githubUsername}${dateFilter}`;
+    debug(MODULE, `Fetching merged PRs${since ? ` since ${since}` : ' (all time)'}...`);
+    const results = [];
+    let page = 1;
+    let fetched = 0;
+    while (true) {
+        const { data } = await octokit.search.issuesAndPullRequests({
+            q,
+            sort: 'updated',
+            order: 'desc',
+            per_page: 100,
+            page,
+        });
+        for (const item of data.items) {
+            const parsed = parseGitHubUrl(item.html_url);
+            if (!parsed) {
+                warn(MODULE, `Skipping merged PR with unparseable URL: ${item.html_url}`);
+                continue;
+            }
+            if (isOwnRepo(parsed.owner, config.githubUsername))
+                continue;
+            const mergedAt = item.pull_request?.merged_at || item.closed_at || '';
+            if (!mergedAt) {
+                warn(MODULE, `Skipping merged PR with no merge date: ${item.html_url}`);
+                continue;
+            }
+            results.push({
+                url: item.html_url,
+                title: item.title,
+                mergedAt,
+            });
+        }
+        fetched += data.items.length;
+        if (fetched >= data.total_count || fetched >= 1000 || data.items.length === 0 || page >= MAX_PAGINATION_PAGES) {
+            break;
+        }
+        page++;
+    }
+    debug(MODULE, `Fetched ${results.length} merged 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 } from './types.js';
+import { AgentState, TrackedIssue, RepoScore, RepoScoreUpdate, StateEvent, StateEventType, DailyDigest, LocalRepoCache, SnoozeInfo, StatusOverride, FetchedPRStatus, StoredMergedPR } 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),
@@ -113,6 +113,22 @@ export declare class StateManager {
      */
     setMonthlyOpenedCounts(counts: Record<string, number>): void;
     setDailyActivityCounts(counts: Record<string, number>): void;
+    /**
+     * Get all stored merged PRs.
+     * @returns Array of stored merged PRs, sorted by mergedAt desc.
+     */
+    getMergedPRs(): StoredMergedPR[];
+    /**
+     * Add new merged PRs to the stored list. Deduplicates by URL and sorts by mergedAt desc.
+     * @param prs - New merged PRs to add.
+     */
+    addMergedPRs(prs: StoredMergedPR[]): void;
+    /**
+     * Get the most recent mergedAt timestamp from stored merged PRs.
+     * Used as the watermark for incremental fetching.
+     * @returns ISO date string of the most recent merge, or undefined if no stored PRs.
+     */
+    getMergedPRWatermark(): string | undefined;
     /**
      * Store cached local repo scan results (#84).
      * @param cache - The scan results, paths scanned, and timestamp.

package/dist/core/state.js

@@ -419,6 +419,10 @@ export class StateManager {
         if (s.events === undefined) {
             s.events = [];
         }
+        // Migrate older states that don't have mergedPRs
+        if (s.mergedPRs === undefined) {
+            s.mergedPRs = [];
+        }
         // Base requirements for all versions
         const hasBaseFields = typeof s.version === 'number' &&
             typeof s.repoScores === 'object' &&
@@ -536,6 +540,47 @@ export class StateManager {
     setDailyActivityCounts(counts) {
         this.state.dailyActivityCounts = counts;
     }
+    // === Merged PR Storage ===
+    /**
+     * Get all stored merged PRs.
+     * @returns Array of stored merged PRs, sorted by mergedAt desc.
+     */
+    getMergedPRs() {
+        return this.state.mergedPRs ?? [];
+    }
+    /**
+     * Add new merged PRs to the stored list. Deduplicates by URL and sorts by mergedAt desc.
+     * @param prs - New merged PRs to add.
+     */
+    addMergedPRs(prs) {
+        if (prs.length === 0)
+            return;
+        if (!this.state.mergedPRs) {
+            this.state.mergedPRs = [];
+        }
+        const existingUrls = new Set(this.state.mergedPRs.map((pr) => pr.url));
+        const newPRs = prs.filter((pr) => !existingUrls.has(pr.url));
+        if (newPRs.length === 0)
+            return;
+        this.state.mergedPRs.push(...newPRs);
+        this.state.mergedPRs.sort((a, b) => b.mergedAt.localeCompare(a.mergedAt));
+        debug(MODULE, `Added ${newPRs.length} merged PRs (total: ${this.state.mergedPRs.length})`);
+    }
+    /**
+     * Get the most recent mergedAt timestamp from stored merged PRs.
+     * Used as the watermark for incremental fetching.
+     * @returns ISO date string of the most recent merge, or undefined if no stored PRs.
+     */
+    getMergedPRWatermark() {
+        const prs = this.state.mergedPRs;
+        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 undefined;
+        return watermark;
+    }
     /**
      * Store cached local repo scan results (#84).
      * @param cache - The scan results, paths scanned, and timestamp.

package/dist/core/types.d.ts

@@ -307,6 +307,12 @@ export interface ClosedPR {
     closedAt: string;
     closedBy?: string;
 }
+/** Minimal merged PR data persisted in state.json. Repo/number derived from URL at display time. */
+export interface StoredMergedPR {
+    url: string;
+    title: string;
+    mergedAt: string;
+}
 /** Minimal record of a PR that was merged, used in the daily digest. */
 export interface MergedPR {
     url: string;
@@ -383,6 +389,8 @@ export interface AgentState {
     dailyActivityCounts?: Record<string, number>;
     /** Cached local repo scan results (#84). Avoids re-scanning the filesystem every session. */
     localRepoCache?: LocalRepoCache;
+    /** All merged PRs stored incrementally. Source of truth for the merged PR detail view. */
+    mergedPRs?: StoredMergedPR[];
     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.46.2",
+  "version": "0.47.1",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {