@oss-autopilot/core 0.41.0

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

@@ -0,0 +1,73 @@
+/**
+ * GitHub Stats - Fetching merged/closed PR counts and repository star counts.
+ * Extracted from PRMonitor to isolate statistics-gathering API calls (#263).
+ */
+import { Octokit } from '@octokit/rest';
+import { ClosedPR, MergedPR } from './types.js';
+/**
+ * Fetch merged PR counts and latest merge dates per repository for the configured user.
+ * Also builds a monthly histogram of all merges for the contribution timeline.
+ */
+export declare function fetchUserMergedPRCounts(octokit: Octokit, githubUsername: string): Promise<{
+    repos: Map<string, {
+        count: number;
+        lastMergedAt: string;
+    }>;
+    monthlyCounts: Record<string, number>;
+    monthlyOpenedCounts: Record<string, number>;
+    dailyActivityCounts: Record<string, number>;
+}>;
+/**
+ * Fetch closed-without-merge PR counts per repository for the configured user.
+ * Used to populate closedWithoutMergeCount in repo scores for accurate merge rate.
+ */
+export declare function fetchUserClosedPRCounts(octokit: Octokit, githubUsername: string): Promise<{
+    repos: Map<string, number>;
+    monthlyCounts: Record<string, number>;
+    monthlyOpenedCounts: Record<string, number>;
+    dailyActivityCounts: Record<string, number>;
+}>;
+/**
+ * Fetch GitHub star counts for a list of repositories.
+ * Used to populate stargazersCount in repo scores for dashboard filtering by minStars.
+ * Fetches concurrently with per-repo error isolation (missing/private repos are skipped).
+ */
+export declare function fetchRepoStarCounts(octokit: Octokit, repos: string[]): Promise<Map<string, number>>;
+/**
+ * Shared helper: search for recent PRs and filter out own repos, excluded repos/orgs.
+ * Returns parsed search results that pass all filters.
+ */
+export declare function fetchRecentPRs<T>(octokit: Octokit, config: {
+    githubUsername: string;
+    excludeRepos: string[];
+    excludeOrgs?: string[];
+}, query: string, label: string, days: number, mapItem: (item: {
+    html_url: string;
+    title: string;
+    closed_at: string | null;
+    pull_request?: {
+        merged_at?: string | null;
+    };
+}, parsed: {
+    owner: string;
+    repo: string;
+    number: number;
+}) => T): Promise<T[]>;
+/**
+ * Fetch PRs closed without merge in the last N days.
+ * Returns lightweight ClosedPR objects for surfacing in the daily digest.
+ */
+export declare function fetchRecentlyClosedPRs(octokit: Octokit, config: {
+    githubUsername: string;
+    excludeRepos: string[];
+    excludeOrgs?: string[];
+}, days?: number): Promise<ClosedPR[]>;
+/**
+ * Fetch PRs merged in the last N days.
+ * Returns lightweight MergedPR objects for surfacing as wins in the dashboard.
+ */
+export declare function fetchRecentlyMergedPRs(octokit: Octokit, config: {
+    githubUsername: string;
+    excludeRepos: string[];
+    excludeOrgs?: string[];
+}, days?: number): Promise<MergedPR[]>;

package/dist/core/github-stats.js

@@ -0,0 +1,272 @@
+/**
+ * GitHub Stats - Fetching merged/closed PR counts and repository star counts.
+ * Extracted from PRMonitor to isolate statistics-gathering API calls (#263).
+ */
+import { extractOwnerRepo, parseGitHubUrl } from './utils.js';
+import { ValidationError } from './errors.js';
+import { debug, warn } from './logger.js';
+const MODULE = 'github-stats';
+/**
+ * Fetch merged PR counts and latest merge dates per repository for the configured user.
+ * Also builds a monthly histogram of all merges for the contribution timeline.
+ */
+export async function fetchUserMergedPRCounts(octokit, githubUsername) {
+    if (!githubUsername) {
+        return { repos: new Map(), monthlyCounts: {}, monthlyOpenedCounts: {}, dailyActivityCounts: {} };
+    }
+    debug(MODULE, `Fetching merged PR counts for @${githubUsername}...`);
+    const repos = new Map();
+    const monthlyCounts = {};
+    const monthlyOpenedCounts = {};
+    const dailyActivityCounts = {};
+    let page = 1;
+    let fetched = 0;
+    while (true) {
+        const { data } = await octokit.search.issuesAndPullRequests({
+            q: `is:pr is:merged author:${githubUsername}`,
+            sort: 'updated',
+            order: 'desc',
+            per_page: 100,
+            page,
+        });
+        for (const item of data.items) {
+            const parsed = extractOwnerRepo(item.html_url);
+            if (!parsed) {
+                warn(MODULE, `Skipping merged PR with unparseable URL: ${item.html_url}`);
+                continue;
+            }
+            const { owner } = parsed;
+            const repo = `${owner}/${parsed.repo}`;
+            // Skip own repos (PRs to your own repos aren't OSS contributions)
+            if (owner.toLowerCase() === githubUsername.toLowerCase())
+                continue;
+            // Note: excludeRepos/excludeOrgs are intentionally NOT filtered here.
+            // Those filters control issue discovery/search, not historical statistics.
+            // A merged PR is a merged PR regardless of current tracking preferences.
+            const mergedAt = item.pull_request?.merged_at || item.closed_at || '';
+            // Per-repo tracking
+            const existing = repos.get(repo);
+            if (existing) {
+                existing.count += 1;
+                if (mergedAt && mergedAt > existing.lastMergedAt) {
+                    existing.lastMergedAt = mergedAt;
+                }
+            }
+            else {
+                repos.set(repo, { count: 1, lastMergedAt: mergedAt });
+            }
+            // Monthly histogram (every PR counted individually)
+            if (mergedAt) {
+                const month = mergedAt.slice(0, 7); // "YYYY-MM"
+                monthlyCounts[month] = (monthlyCounts[month] || 0) + 1;
+            }
+            // Track when this PR was opened (for monthly opened histogram)
+            if (item.created_at) {
+                const openedMonth = item.created_at.slice(0, 7); // "YYYY-MM"
+                monthlyOpenedCounts[openedMonth] = (monthlyOpenedCounts[openedMonth] || 0) + 1;
+                // Daily activity: PR opened
+                const openedDay = item.created_at.slice(0, 10);
+                if (openedDay.length === 10)
+                    dailyActivityCounts[openedDay] = (dailyActivityCounts[openedDay] || 0) + 1;
+            }
+            // Daily activity: PR merged
+            if (mergedAt) {
+                const mergedDay = mergedAt.slice(0, 10);
+                if (mergedDay.length === 10)
+                    dailyActivityCounts[mergedDay] = (dailyActivityCounts[mergedDay] || 0) + 1;
+            }
+        }
+        fetched += data.items.length;
+        // Stop if we've fetched all results or hit the API limit (1000)
+        if (fetched >= data.total_count || fetched >= 1000 || data.items.length === 0) {
+            break;
+        }
+        page++;
+    }
+    debug(MODULE, `Found ${fetched} merged PRs across ${repos.size} repos`);
+    return { repos, monthlyCounts, monthlyOpenedCounts, dailyActivityCounts };
+}
+/**
+ * Fetch closed-without-merge PR counts per repository for the configured user.
+ * Used to populate closedWithoutMergeCount in repo scores for accurate merge rate.
+ */
+export async function fetchUserClosedPRCounts(octokit, githubUsername) {
+    if (!githubUsername) {
+        return { repos: new Map(), monthlyCounts: {}, monthlyOpenedCounts: {}, dailyActivityCounts: {} };
+    }
+    debug(MODULE, `Fetching closed PR counts for @${githubUsername}...`);
+    const repos = new Map();
+    const monthlyCounts = {};
+    const monthlyOpenedCounts = {};
+    const dailyActivityCounts = {};
+    let page = 1;
+    let fetched = 0;
+    while (true) {
+        const { data } = await octokit.search.issuesAndPullRequests({
+            q: `is:pr is:closed is:unmerged author:${githubUsername}`,
+            sort: 'updated',
+            order: 'desc',
+            per_page: 100,
+            page,
+        });
+        for (const item of data.items) {
+            const parsed = extractOwnerRepo(item.html_url);
+            if (!parsed) {
+                warn(MODULE, `Skipping closed PR with unparseable URL: ${item.html_url}`);
+                continue;
+            }
+            const { owner } = parsed;
+            const repo = `${owner}/${parsed.repo}`;
+            // Skip own repos
+            if (owner.toLowerCase() === githubUsername.toLowerCase())
+                continue;
+            // Note: excludeRepos/excludeOrgs are intentionally NOT filtered here.
+            // Those filters control issue discovery/search, not historical statistics.
+            // A closed PR is a closed PR regardless of current tracking preferences.
+            repos.set(repo, (repos.get(repo) || 0) + 1);
+            // Track when this PR was closed (for monthly closed histogram)
+            if (item.closed_at) {
+                const closedMonth = item.closed_at.slice(0, 7); // "YYYY-MM"
+                monthlyCounts[closedMonth] = (monthlyCounts[closedMonth] || 0) + 1;
+                // Daily activity: PR closed
+                const closedDay = item.closed_at.slice(0, 10);
+                if (closedDay.length === 10)
+                    dailyActivityCounts[closedDay] = (dailyActivityCounts[closedDay] || 0) + 1;
+            }
+            // Track when this PR was opened (for monthly opened histogram)
+            if (item.created_at) {
+                const openedMonth = item.created_at.slice(0, 7); // "YYYY-MM"
+                monthlyOpenedCounts[openedMonth] = (monthlyOpenedCounts[openedMonth] || 0) + 1;
+                // Daily activity: PR opened
+                const openedDay = item.created_at.slice(0, 10);
+                if (openedDay.length === 10)
+                    dailyActivityCounts[openedDay] = (dailyActivityCounts[openedDay] || 0) + 1;
+            }
+        }
+        fetched += data.items.length;
+        if (fetched >= data.total_count || fetched >= 1000 || data.items.length === 0) {
+            break;
+        }
+        page++;
+    }
+    debug(MODULE, `Found ${fetched} closed (unmerged) PRs across ${repos.size} repos`);
+    return { repos, monthlyCounts, monthlyOpenedCounts, dailyActivityCounts };
+}
+/**
+ * Fetch GitHub star counts for a list of repositories.
+ * Used to populate stargazersCount in repo scores for dashboard filtering by minStars.
+ * Fetches concurrently with per-repo error isolation (missing/private repos are skipped).
+ */
+export async function fetchRepoStarCounts(octokit, repos) {
+    if (repos.length === 0)
+        return new Map();
+    debug(MODULE, `Fetching star counts for ${repos.length} repos...`);
+    const results = new Map();
+    // Fetch in parallel chunks to avoid overwhelming the API
+    const chunkSize = 10;
+    for (let i = 0; i < repos.length; i += chunkSize) {
+        const chunk = repos.slice(i, i + chunkSize);
+        const settled = await Promise.allSettled(chunk.map(async (repo) => {
+            const parts = repo.split('/');
+            if (parts.length !== 2 || !parts[0] || !parts[1]) {
+                throw new ValidationError(`Malformed repo identifier: "${repo}"`);
+            }
+            const [owner, name] = parts;
+            const { data } = await octokit.repos.get({ owner, repo: name });
+            return { repo, stars: data.stargazers_count };
+        }));
+        let chunkFailures = 0;
+        for (let j = 0; j < settled.length; j++) {
+            const result = settled[j];
+            if (result.status === 'fulfilled') {
+                results.set(result.value.repo, result.value.stars);
+            }
+            else {
+                chunkFailures++;
+                warn(MODULE, `Failed to fetch stars for ${chunk[j]}: ${result.reason instanceof Error ? result.reason.message : result.reason}`);
+            }
+        }
+        // If entire chunk failed, likely a systemic issue (rate limit, auth, outage) — abort remaining
+        if (chunkFailures === chunk.length && chunk.length > 0) {
+            const remaining = repos.length - i - chunkSize;
+            if (remaining > 0) {
+                warn(MODULE, `Entire chunk failed, aborting remaining ${remaining} repos`);
+            }
+            break;
+        }
+    }
+    debug(MODULE, `Fetched star counts for ${results.size}/${repos.length} repos`);
+    return results;
+}
+/**
+ * Shared helper: search for recent PRs and filter out own repos, excluded repos/orgs.
+ * Returns parsed search results that pass all filters.
+ */
+export async function fetchRecentPRs(octokit, config, query, label, days, mapItem) {
+    if (!config.githubUsername) {
+        warn(MODULE, `Skipping recently ${label} PRs fetch: no githubUsername configured. Run /setup-oss to configure.`);
+        return [];
+    }
+    const sinceDate = new Date();
+    sinceDate.setDate(sinceDate.getDate() - days);
+    const since = sinceDate.toISOString().split('T')[0]; // YYYY-MM-DD
+    debug(MODULE, `Fetching recently ${label} PRs for @${config.githubUsername} (since ${since})...`);
+    const { data } = await octokit.search.issuesAndPullRequests({
+        q: query.replace('{username}', config.githubUsername).replace('{since}', since),
+        sort: 'updated',
+        order: 'desc',
+        per_page: 100,
+    });
+    const results = [];
+    for (const item of data.items) {
+        const parsed = parseGitHubUrl(item.html_url);
+        if (!parsed) {
+            warn(MODULE, `Could not parse GitHub URL from API response: ${item.html_url}`);
+            continue;
+        }
+        const repo = `${parsed.owner}/${parsed.repo}`;
+        // Skip own repos
+        if (parsed.owner.toLowerCase() === config.githubUsername.toLowerCase())
+            continue;
+        // Skip excluded repos and orgs
+        if (config.excludeRepos.includes(repo))
+            continue;
+        if (config.excludeOrgs?.some((org) => parsed.owner.toLowerCase() === org.toLowerCase()))
+            continue;
+        results.push(mapItem(item, { owner: parsed.owner, repo, number: parsed.number }));
+    }
+    debug(MODULE, `Found ${results.length} recently ${label} PRs`);
+    return results;
+}
+/**
+ * Fetch PRs closed without merge in the last N days.
+ * Returns lightweight ClosedPR objects for surfacing in the daily digest.
+ */
+export async function fetchRecentlyClosedPRs(octokit, config, days = 7) {
+    return fetchRecentPRs(octokit, config, 'is:pr is:closed is:unmerged author:{username} closed:>={since}', 'closed', days, (item, { repo, number }) => ({
+        url: item.html_url,
+        repo,
+        number,
+        title: item.title,
+        closedAt: item.closed_at || '',
+    }));
+}
+/**
+ * Fetch PRs merged in the last N days.
+ * Returns lightweight MergedPR objects for surfacing as wins in the dashboard.
+ */
+export async function fetchRecentlyMergedPRs(octokit, config, days = 7) {
+    return fetchRecentPRs(octokit, config, 'is:pr is:merged author:{username} merged:>={since}', 'merged', days, (item, { repo, number }) => {
+        const mergedAt = item.pull_request?.merged_at;
+        if (!mergedAt) {
+            warn(MODULE, `merged_at missing for merged PR ${item.html_url}${item.closed_at ? ', falling back to closed_at' : ', no date available'}`);
+        }
+        return {
+            url: item.html_url,
+            repo,
+            number,
+            title: item.title,
+            mergedAt: mergedAt || item.closed_at || '',
+        };
+    });
+}

package/dist/core/github.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared GitHub API client with rate limiting and throttling
+ */
+import { Octokit } from '@octokit/rest';
+/** Rate limit info returned by {@link checkRateLimit}. */
+export interface RateLimitInfo {
+    /** Remaining search API requests in current window. */
+    remaining: number;
+    /** Total search API request limit per window. */
+    limit: number;
+    /** ISO timestamp when the rate limit window resets. */
+    resetAt: string;
+}
+export declare function getOctokit(token: string): Octokit;
+/**
+ * Check the GitHub Search API rate limit quota.
+ * Returns the remaining requests, total limit, and reset time for the search endpoint.
+ */
+export declare function checkRateLimit(token: string): Promise<RateLimitInfo>;

package/dist/core/github.js

@@ -0,0 +1,60 @@
+/**
+ * Shared GitHub API client with rate limiting and throttling
+ */
+import { Octokit } from '@octokit/rest';
+import { throttling } from '@octokit/plugin-throttling';
+import { warn } from './logger.js';
+const MODULE = 'github';
+const ThrottledOctokit = Octokit.plugin(throttling);
+let _octokit = null;
+let _currentToken = null;
+/** Format a Date as HH:MM:SS for log messages. */
+function formatResetTime(date) {
+    return date.toLocaleTimeString('en-US', { hour12: false });
+}
+export function getOctokit(token) {
+    // Return cached instance only if token matches
+    if (_octokit && _currentToken === token)
+        return _octokit;
+    _octokit = new ThrottledOctokit({
+        auth: token,
+        throttle: {
+            onRateLimit: (retryAfter, options, octokit, retryCount) => {
+                const opts = options;
+                const resetAt = new Date(Date.now() + retryAfter * 1000);
+                if (retryCount < 2) {
+                    warn(MODULE, `Rate limit hit (retry ${retryCount + 1}/2, waiting ${retryAfter}s, resets at ${formatResetTime(resetAt)}) — ${opts.method} ${opts.url}`);
+                    return true;
+                }
+                warn(MODULE, `Rate limit exceeded, not retrying — ${opts.method} ${opts.url} (resets at ${formatResetTime(resetAt)})`);
+                return false;
+            },
+            onSecondaryRateLimit: (retryAfter, options, octokit, retryCount) => {
+                const opts = options;
+                const resetAt = new Date(Date.now() + retryAfter * 1000);
+                if (retryCount < 1) {
+                    warn(MODULE, `Secondary rate limit hit (retry ${retryCount + 1}/1, waiting ${retryAfter}s, resets at ${formatResetTime(resetAt)}) — ${opts.method} ${opts.url}`);
+                    return true;
+                }
+                warn(MODULE, `Secondary rate limit exceeded, not retrying — ${opts.method} ${opts.url} (resets at ${formatResetTime(resetAt)})`);
+                return false;
+            },
+        },
+    });
+    _currentToken = token;
+    return _octokit;
+}
+/**
+ * Check the GitHub Search API rate limit quota.
+ * Returns the remaining requests, total limit, and reset time for the search endpoint.
+ */
+export async function checkRateLimit(token) {
+    const octokit = getOctokit(token);
+    const { data } = await octokit.rateLimit.get();
+    const search = data.resources.search;
+    return {
+        remaining: search.remaining,
+        limit: search.limit,
+        resetAt: new Date(search.reset * 1000).toISOString(),
+    };
+}

package/dist/core/http-cache.d.ts

@@ -0,0 +1,97 @@
+/**
+ * HTTP caching with ETags for GitHub API responses.
+ *
+ * Stores ETags and response bodies for cacheable GET endpoints in
+ * `~/.oss-autopilot/cache/`. On subsequent requests, sends `If-None-Match`
+ * headers — 304 responses don't count against GitHub rate limits.
+ *
+ * Also provides in-flight request deduplication so that concurrent calls
+ * for the same endpoint (e.g., star counts for two PRs in the same repo)
+ * share a single HTTP round-trip.
+ */
+/** Shape of a single cache entry on disk. */
+export interface CacheEntry {
+    etag: string;
+    url: string;
+    body: unknown;
+    cachedAt: string;
+}
+/**
+ * File-based HTTP cache backed by `~/.oss-autopilot/cache/`.
+ *
+ * Each cache entry is stored as a separate JSON file keyed by the SHA-256
+ * hash of the request URL. This avoids filesystem issues with URL-based
+ * filenames and keeps lookup O(1).
+ */
+export declare class HttpCache {
+    private readonly cacheDir;
+    /** In-flight request deduplication map: URL -> Promise<response>. */
+    private readonly inflightRequests;
+    constructor(cacheDir?: string);
+    /** Derive a filesystem-safe cache key from a URL. */
+    private keyFor;
+    /** Full path to the cache file for a given URL. */
+    private pathFor;
+    /**
+     * Look up a cached response. Returns `null` if no cache entry exists.
+     */
+    get(url: string): CacheEntry | null;
+    /**
+     * Store a response with its ETag.
+     */
+    set(url: string, etag: string, body: unknown): void;
+    /**
+     * Check whether a URL has an in-flight request.
+     */
+    hasInflight(url: string): boolean;
+    /**
+     * Get the in-flight promise for a URL (for deduplication).
+     */
+    getInflight(url: string): Promise<unknown> | undefined;
+    /**
+     * Register an in-flight request for deduplication.
+     * Returns a cleanup function to call when the request completes.
+     */
+    setInflight(url: string, promise: Promise<unknown>): () => void;
+    /**
+     * Remove stale entries older than `maxAgeMs` from the cache directory.
+     * Intended to be called periodically (e.g., once per daily run).
+     */
+    evictStale(maxAgeMs?: number): number;
+    /**
+     * Remove all entries from the cache.
+     */
+    clear(): void;
+    /**
+     * Return the number of entries currently in the cache.
+     */
+    size(): number;
+}
+/**
+ * Get (or create) the shared HttpCache singleton.
+ * The singleton is lazily initialized on first access.
+ */
+export declare function getHttpCache(): HttpCache;
+/** Reset the singleton (for tests). */
+export declare function resetHttpCache(): void;
+/**
+ * Wraps an Octokit `repos.get`-style call with ETag caching and request
+ * deduplication.
+ *
+ * Usage:
+ * ```ts
+ * const data = await cachedRequest(cache, octokit, '/repos/owner/repo', () =>
+ *   octokit.repos.get({ owner, repo: name }),
+ * );
+ * ```
+ *
+ * 1. If an identical request is already in-flight, returns the existing promise
+ *    (request deduplication).
+ * 2. If a cached ETag exists, sends `If-None-Match`. On 304, returns the
+ *    cached body without consuming a rate-limit point.
+ * 3. On a fresh 200, caches the ETag + body for next time.
+ */
+export declare function cachedRequest<T>(cache: HttpCache, url: string, fetcher: (headers: Record<string, string>) => Promise<{
+    data: T;
+    headers?: Record<string, string>;
+}>): Promise<T>;