@oss-autopilot/core 0.41.0

package/dist/commands/daily.js

@@ -0,0 +1,433 @@
+/**
+ * Daily check command
+ * Fetches all open PRs fresh from GitHub (v2: no PR-level state tracking),
+ * generates a digest, and updates repo scores and analytics in local state.
+ *
+ * Domain logic lives in src/core/daily-logic.ts; this file is a thin
+ * orchestration layer that wires up the phases and handles I/O.
+ */
+import { getStateManager, PRMonitor, IssueConversationMonitor, getGitHubToken, CRITICAL_STATUSES, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, printDigest, } from '../core/index.js';
+import { outputJson, outputJsonError, deduplicateDigest, compactActionableIssues, compactRepoGroups, } from '../formatters/json.js';
+// Re-export domain functions so existing consumers (tests, dashboard, startup)
+// can continue importing from './daily.js' without changes.
+export { computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, printDigest, CRITICAL_STATUSES, } from '../core/index.js';
+export async function runDaily(options) {
+    // Token is guaranteed by the preAction hook in cli.ts for non-LOCAL_ONLY_COMMANDS.
+    const token = getGitHubToken();
+    try {
+        await runDailyInner(token, options);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (options.json) {
+            outputJsonError(`Daily check failed: ${msg}`);
+        }
+        else {
+            console.error(`[FATAL] Daily check failed: ${msg}`);
+            if (error instanceof Error && error.stack) {
+                console.error(error.stack);
+            }
+        }
+        process.exit(1);
+    }
+}
+// ---------------------------------------------------------------------------
+// Phase functions
+// ---------------------------------------------------------------------------
+/**
+ * Phase 1: Fetch all PR data from GitHub.
+ * Retrieves open PRs, merged/closed counts, recently closed/merged PRs, and
+ * issue conversation data — all in parallel where possible.
+ */
+async function fetchPRData(prMonitor, token) {
+    // Fetch all open PRs fresh from GitHub
+    const { prs, failures } = await prMonitor.fetchUserOpenPRs();
+    // Log any failures (but continue with successful checks)
+    if (failures.length > 0) {
+        console.error(`Warning: ${failures.length} PR fetch(es) failed`);
+    }
+    // Fetch merged PR counts, closed PR counts, recently closed PRs, recently merged PRs, and commented issues in parallel
+    // Recently closed/merged are non-critical (cosmetic sections), so isolate their failure
+    const issueMonitor = new IssueConversationMonitor(token);
+    const [mergedResult, closedResult, recentlyClosedPRs, recentlyMergedPRs, issueConversationResult] = await Promise.all([
+        prMonitor.fetchUserMergedPRCounts(),
+        prMonitor.fetchUserClosedPRCounts(),
+        prMonitor.fetchRecentlyClosedPRs().catch((err) => {
+            console.error(`Warning: Failed to fetch recently closed PRs: ${err instanceof Error ? err.message : err}`);
+            return [];
+        }),
+        prMonitor.fetchRecentlyMergedPRs().catch((err) => {
+            console.error(`Warning: Failed to fetch recently merged PRs: ${err instanceof Error ? err.message : err}`);
+            return [];
+        }),
+        issueMonitor.fetchCommentedIssues().catch((error) => {
+            const msg = error instanceof Error ? error.message : String(error);
+            if (msg.includes('No GitHub username configured')) {
+                console.error(`[DAILY] Issue conversation tracking requires setup: ${msg}`);
+            }
+            else {
+                console.error(`[DAILY] Issue conversation fetch failed: ${msg}`);
+            }
+            return {
+                issues: [],
+                failures: [{ issueUrl: 'N/A', error: `Issue conversation fetch failed: ${msg}` }],
+            };
+        }),
+    ]);
+    const commentedIssues = issueConversationResult.issues;
+    if (issueConversationResult.failures.length > 0) {
+        console.error(`[DAILY] ${issueConversationResult.failures.length} issue conversation check(s) failed`);
+    }
+    const { repos: mergedCounts, monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
+    const { repos: closedCounts, monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed, } = closedResult;
+    return {
+        prs,
+        failures,
+        mergedCounts,
+        closedCounts,
+        monthlyCounts,
+        monthlyClosedCounts,
+        openedFromMerged,
+        openedFromClosed,
+        recentlyClosedPRs,
+        recentlyMergedPRs,
+        commentedIssues,
+    };
+}
+/**
+ * Phase 2: Update repo scores in local state.
+ * Applies stale repo reset, updates merged/closed counts, computes and stores
+ * repo signals from open PR data, refreshes star counts, and syncs trusted projects.
+ */
+async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
+    const stateManager = getStateManager();
+    // Reset stale repos first (so excluded/removed repos get zeroed).
+    // Guard: if the API returned zero results but we have existing repos with merged PRs,
+    // skip the reset to avoid wiping scores due to transient API failures.
+    const existingReposWithMerges = Object.values(stateManager.getState().repoScores).filter((s) => s.mergedPRCount > 0);
+    if (mergedCounts.size === 0 && existingReposWithMerges.length > 0) {
+        console.error(`[DAILY] Skipping stale repo reset: API returned 0 merged PR results but state has ${existingReposWithMerges.length} repo(s) with merges. Possible API issue.`);
+    }
+    else {
+        for (const score of Object.values(stateManager.getState().repoScores)) {
+            if (!mergedCounts.has(score.repo)) {
+                stateManager.updateRepoScore(score.repo, { mergedPRCount: 0 });
+            }
+        }
+    }
+    // Update merged/closed counts with per-repo error isolation (matches signal/trust loops below)
+    let mergedCountFailures = 0;
+    for (const [repo, { count, lastMergedAt }] of mergedCounts) {
+        try {
+            stateManager.updateRepoScore(repo, { mergedPRCount: count, lastMergedAt: lastMergedAt || undefined });
+        }
+        catch (error) {
+            mergedCountFailures++;
+            console.error(`[DAILY] Failed to update merged count for ${repo}:`, error instanceof Error ? error.message : error);
+        }
+    }
+    if (mergedCountFailures === mergedCounts.size && mergedCounts.size > 0) {
+        console.error(`[DAILY_ALL_MERGED_COUNT_UPDATES_FAILED] All ${mergedCounts.size} merged count update(s) failed.`);
+    }
+    // Populate closedWithoutMergeCount in repo scores.
+    // Diagnostic: warn if API returned empty but we have known closed PRs (possible transient API failure).
+    // Unlike merged counts above, there is no stale-reset loop for closed counts, so no skip is needed.
+    const existingReposWithClosed = Object.values(stateManager.getState().repoScores).filter((s) => (s.closedWithoutMergeCount || 0) > 0);
+    if (closedCounts.size === 0 && existingReposWithClosed.length > 0) {
+        console.error(`[DAILY] Warning: API returned 0 closed PR results but state has ${existingReposWithClosed.length} repo(s) with closed PRs. Possible transient API issue.`);
+    }
+    let closedCountFailures = 0;
+    for (const [repo, count] of closedCounts) {
+        try {
+            stateManager.updateRepoScore(repo, { closedWithoutMergeCount: count });
+        }
+        catch (error) {
+            closedCountFailures++;
+            console.error(`[DAILY] Failed to update closed count for ${repo}:`, error instanceof Error ? error.message : error);
+        }
+    }
+    if (closedCountFailures === closedCounts.size && closedCounts.size > 0) {
+        console.error(`[DAILY_ALL_CLOSED_COUNT_UPDATES_FAILED] All ${closedCounts.size} closed count update(s) failed.`);
+    }
+    // Update repo signals from observed open PR data (responsiveness, active maintainers).
+    // Only repos with current open PRs get signal updates — repos with no open PRs
+    // preserve their existing signals to avoid degrading scores when PRs are merged.
+    // Per-repo try-catch: signal/trust syncing is secondary to the daily digest —
+    // a single corrupted repo score should not prevent updates to other repos.
+    const repoSignals = computeRepoSignals(prs);
+    let signalUpdateFailures = 0;
+    for (const [repo, signals] of repoSignals) {
+        try {
+            stateManager.updateRepoScore(repo, { signals });
+        }
+        catch (error) {
+            signalUpdateFailures++;
+            console.error(`[DAILY] Failed to update signals for ${repo}:`, error instanceof Error ? error.message : error);
+        }
+    }
+    if (signalUpdateFailures === repoSignals.size && repoSignals.size > 0) {
+        console.error(`[DAILY_ALL_SIGNAL_UPDATES_FAILED] All ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`);
+    }
+    // Fetch star counts for all scored repos (used by dashboard minStars filter, #216)
+    const allRepos = Object.keys(stateManager.getState().repoScores);
+    let starCounts;
+    try {
+        starCounts = await prMonitor.fetchRepoStarCounts(allRepos);
+    }
+    catch (error) {
+        console.error('[DAILY] Failed to fetch repo star counts:', error instanceof Error ? error.message : error);
+        console.error('[DAILY] Dashboard minStars filter will use cached star counts (or be skipped for repos without cached data).');
+        starCounts = new Map();
+    }
+    let starUpdateFailures = 0;
+    for (const [repo, stars] of starCounts) {
+        try {
+            stateManager.updateRepoScore(repo, { stargazersCount: stars });
+        }
+        catch (error) {
+            starUpdateFailures++;
+            console.error(`[DAILY] Failed to update star count for ${repo}:`, error instanceof Error ? error.message : error);
+        }
+    }
+    if (starUpdateFailures === starCounts.size && starCounts.size > 0) {
+        console.error(`[DAILY_ALL_STAR_COUNT_UPDATES_FAILED] All ${starCounts.size} star count update(s) failed.`);
+    }
+    // Auto-sync trustedProjects from repos with merged PRs
+    let trustSyncFailures = 0;
+    for (const [repo] of mergedCounts) {
+        try {
+            stateManager.addTrustedProject(repo);
+        }
+        catch (error) {
+            trustSyncFailures++;
+            console.error(`[DAILY] Failed to sync trusted project ${repo}:`, error instanceof Error ? error.message : error);
+        }
+    }
+    if (trustSyncFailures === mergedCounts.size && mergedCounts.size > 0) {
+        console.error(`[DAILY_ALL_TRUST_SYNCS_FAILED] All ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`);
+    }
+}
+/**
+ * Phase 3: Persist monthly chart analytics to state.
+ * Stores merged, closed, and combined opened counts per month.
+ * Each metric is isolated so partial failures don't produce inconsistent state.
+ */
+function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed) {
+    const stateManager = getStateManager();
+    // Store monthly chart data (non-critical — each metric isolated so partial failures don't leave inconsistent state)
+    try {
+        stateManager.setMonthlyMergedCounts(monthlyCounts);
+    }
+    catch (error) {
+        console.error('[DAILY] Failed to store monthly merged counts:', error instanceof Error ? error.message : error);
+    }
+    try {
+        stateManager.setMonthlyClosedCounts(monthlyClosedCounts);
+    }
+    catch (error) {
+        console.error('[DAILY] Failed to store monthly closed counts:', error instanceof Error ? error.message : error);
+    }
+    try {
+        // Build combined monthly opened counts from merged + closed + currently-open PRs
+        const combinedOpenedCounts = { ...openedFromMerged };
+        for (const [month, count] of Object.entries(openedFromClosed)) {
+            combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + count;
+        }
+        // Add currently-open PR creation dates
+        for (const pr of prs) {
+            if (pr.createdAt) {
+                const month = pr.createdAt.slice(0, 7);
+                combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + 1;
+            }
+        }
+        stateManager.setMonthlyOpenedCounts(combinedOpenedCounts);
+    }
+    catch (error) {
+        console.error('[DAILY] Failed to compute/store monthly opened counts:', error instanceof Error ? error.message : error);
+    }
+}
+/**
+ * Phase 4: Expire snoozes and partition PRs into active vs shelved buckets.
+ * Auto-unshelves PRs where maintainers have engaged, generates the digest,
+ * and persists state.
+ */
+function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
+    const stateManager = getStateManager();
+    // Expire any snoozes that have passed their expiresAt timestamp.
+    // Non-critical: corrupted snooze entries should not abort the daily check.
+    try {
+        const expiredSnoozes = stateManager.expireSnoozes();
+        if (expiredSnoozes.length > 0) {
+            console.error(`[DAILY] ${expiredSnoozes.length} snoozed PR(s) expired and will resurface:`);
+            for (const url of expiredSnoozes) {
+                console.error(`  - ${url}`);
+            }
+            stateManager.save();
+        }
+    }
+    catch (error) {
+        console.error('[DAILY] Failed to expire/persist snoozes:', error instanceof Error ? error.message : error);
+    }
+    // Partition PRs into active vs shelved, auto-unshelving when maintainers engage
+    const shelvedPRs = [];
+    const autoUnshelvedPRs = [];
+    const activePRs = [];
+    for (const pr of prs) {
+        if (stateManager.isPRShelved(pr.url)) {
+            if (CRITICAL_STATUSES.has(pr.status)) {
+                stateManager.unshelvePR(pr.url);
+                autoUnshelvedPRs.push(toShelvedPRRef(pr));
+                activePRs.push(pr);
+            }
+            else {
+                shelvedPRs.push(toShelvedPRRef(pr));
+            }
+        }
+        else if (pr.status === 'dormant') {
+            // Dormant PRs are auto-shelved (not persisted — they return when activity resumes)
+            shelvedPRs.push(toShelvedPRRef(pr));
+        }
+        else {
+            activePRs.push(pr);
+        }
+    }
+    // Generate digest from fresh data.
+    // Note: digest.openPRs contains ALL fetched PRs (including shelved).
+    // We override summary fields below to reflect active-only counts.
+    const digest = prMonitor.generateDigest(prs, recentlyClosedPRs, recentlyMergedPRs);
+    // Attach shelve info to digest
+    digest.shelvedPRs = shelvedPRs;
+    digest.autoUnshelvedPRs = autoUnshelvedPRs;
+    digest.summary.totalActivePRs = activePRs.length;
+    // Store digest in state so dashboard can render it
+    stateManager.setLastDigest(digest);
+    // Save state (updates lastRunAt, lastDigest, and any auto-unshelve changes)
+    stateManager.save();
+    return { activePRs, shelvedPRs, autoUnshelvedPRs, digest };
+}
+/**
+ * Phase 5: Build the structured output for the daily command.
+ * Assesses capacity, filters dismissed issues, computes actionable items,
+ * and assembles the action menu.
+ */
+function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures) {
+    const stateManager = getStateManager();
+    // Assess capacity from active PRs only (shelved PRs excluded)
+    const capacity = assessCapacity(activePRs, stateManager.getState().config.maxActivePRs, shelvedPRs.length);
+    // Filter dismissed issues: suppress if dismissed after last response, resurface + auto-undismiss if new activity
+    let hasAutoUndismissed = false;
+    const filteredCommentedIssues = commentedIssues.filter((issue) => {
+        const dismissedAt = stateManager.getIssueDismissedAt(issue.url);
+        if (!dismissedAt)
+            return true; // Not dismissed — include
+        if (issue.status === 'new_response') {
+            const responseTime = new Date(issue.lastResponseAt).getTime();
+            const dismissTime = new Date(dismissedAt).getTime();
+            if (isNaN(responseTime) || isNaN(dismissTime)) {
+                // Invalid timestamp — fail open (include issue to be safe)
+                console.error(`[DAILY] Invalid timestamp in dismiss check for ${issue.url}, including issue`);
+                stateManager.undismissIssue(issue.url);
+                hasAutoUndismissed = true;
+                return true;
+            }
+            if (responseTime > dismissTime) {
+                // New activity after dismiss — auto-undismiss and resurface
+                stateManager.undismissIssue(issue.url);
+                hasAutoUndismissed = true;
+                return true;
+            }
+        }
+        // Still dismissed (last response is at or before dismiss timestamp)
+        return false;
+    });
+    if (hasAutoUndismissed) {
+        stateManager.save();
+    }
+    const issueResponses = filteredCommentedIssues.filter((i) => i.status === 'new_response');
+    const summary = formatSummary(digest, capacity, issueResponses);
+    const snoozedUrls = new Set(Object.keys(stateManager.getState().config.snoozedPRs ?? {}).filter((url) => stateManager.isSnoozed(url)));
+    const actionableIssues = collectActionableIssues(activePRs, snoozedUrls);
+    digest.summary.totalNeedingAttention = actionableIssues.length;
+    const briefSummary = formatBriefSummary(digest, actionableIssues.length, issueResponses.length);
+    const actionMenu = computeActionMenu(actionableIssues, capacity, filteredCommentedIssues);
+    const repoGroups = groupPRsByRepo(activePRs);
+    return {
+        digest,
+        updates: [],
+        capacity,
+        summary,
+        briefSummary,
+        actionableIssues,
+        actionMenu,
+        commentedIssues: filteredCommentedIssues,
+        repoGroups,
+        failures,
+    };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Convert a full DailyCheckResult to the compact DailyOutput for JSON serialization (#287).
+ * Deduplicates PR objects: category arrays become PR URL references,
+ * full objects live only in digest.openPRs. Reduces JSON payload size ~60-70%.
+ */
+function toDailyOutput(result) {
+    return {
+        digest: deduplicateDigest(result.digest),
+        updates: result.updates,
+        capacity: result.capacity,
+        summary: result.summary,
+        briefSummary: result.briefSummary,
+        actionableIssues: compactActionableIssues(result.actionableIssues),
+        actionMenu: result.actionMenu,
+        commentedIssues: result.commentedIssues,
+        repoGroups: compactRepoGroups(result.repoGroups),
+        failures: result.failures,
+    };
+}
+/**
+ * Core daily check logic, extracted for reuse by the startup command.
+ * Fetches all open PRs, updates state, and returns structured output.
+ *
+ * Returns a deduplicated DailyOutput where category arrays contain PR URLs
+ * instead of full objects (#287). Full PR objects are in digest.openPRs only.
+ *
+ * Orchestrates five named phases:
+ *   1. fetchPRData        — fetch open PRs, merged/closed counts, issues
+ *   2. updateRepoScores   — update signals, star counts, trust in state
+ *   3. updateAnalytics    — store monthly chart data
+ *   4. partitionPRs       — expire snoozes, shelve/unshelve, generate digest
+ *   5. generateDigestOutput — capacity, dismiss filter, action menu assembly
+ */
+export async function executeDailyCheck(token) {
+    const result = await executeDailyCheckInternal(token);
+    return toDailyOutput(result);
+}
+/**
+ * Internal daily check returning full (non-deduplicated) result.
+ * Used by runDailyInner for text-mode output where full PR objects are needed.
+ */
+async function executeDailyCheckInternal(token) {
+    const prMonitor = new PRMonitor(token);
+    // Phase 1: Fetch all PR data from GitHub
+    const { prs, failures, mergedCounts, closedCounts, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed, recentlyClosedPRs, recentlyMergedPRs, commentedIssues, } = await fetchPRData(prMonitor, token);
+    // Phase 2: Update repo scores (signals, star counts, trust sync)
+    await updateRepoScores(prMonitor, prs, mergedCounts, closedCounts);
+    // Phase 3: Persist monthly analytics
+    updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
+    // Phase 4: Expire snoozes, partition PRs, generate and save digest
+    const { activePRs, shelvedPRs, digest } = partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs);
+    // Phase 5: Build structured output (capacity, dismiss filter, action menu)
+    return generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures);
+}
+async function runDailyInner(token, options) {
+    if (options.json) {
+        const result = await executeDailyCheck(token);
+        outputJson(result);
+    }
+    else {
+        const result = await executeDailyCheckInternal(token);
+        printDigest(result.digest, result.capacity, result.commentedIssues);
+    }
+}

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

@@ -0,0 +1,45 @@
+/**
+ * Dashboard data fetching and aggregation.
+ * Handles GitHub API calls, PR grouping, stats computation, and monthly chart data.
+ * Separates data concerns from template generation and command orchestration.
+ */
+import type { DailyDigest, AgentState, CommentedIssue } from '../core/types.js';
+export interface DashboardFetchResult {
+    digest: DailyDigest;
+    commentedIssues: CommentedIssue[];
+}
+/**
+ * Fetch fresh dashboard data from GitHub.
+ * Returns the digest and commented issues, updating state as a side effect.
+ * Throws if the fetch fails entirely (caller should fall back to cached data).
+ */
+export declare function fetchDashboardData(token: string): Promise<DashboardFetchResult>;
+/**
+ * Compute PRs grouped by repository from a digest and state.
+ * Used for chart data in both JSON and HTML output.
+ */
+export declare function computePRsByRepo(digest: DailyDigest, state: Readonly<AgentState>): Record<string, {
+    active: number;
+    merged: number;
+    closed: number;
+}>;
+/**
+ * Compute the top repositories sorted by total PR count.
+ */
+export declare function computeTopRepos(prsByRepo: Record<string, {
+    active: number;
+    merged: number;
+    closed: number;
+}>, limit?: number): Array<[string, {
+    active: number;
+    merged: number;
+    closed: number;
+}]>;
+/**
+ * Extract monthly activity data from state.
+ */
+export declare function getMonthlyData(state: Readonly<AgentState>): {
+    monthlyMerged: Record<string, number>;
+    monthlyClosed: Record<string, number>;
+    monthlyOpened: Record<string, number>;
+};

package/dist/commands/dashboard-data.js

@@ -0,0 +1,132 @@
+/**
+ * Dashboard data fetching and aggregation.
+ * Handles GitHub API calls, PR grouping, stats computation, and monthly chart data.
+ * Separates data concerns from template generation and command orchestration.
+ */
+import { getStateManager, PRMonitor, IssueConversationMonitor } from '../core/index.js';
+import { toShelvedPRRef } from './daily.js';
+/**
+ * Fetch fresh dashboard data from GitHub.
+ * Returns the digest and commented issues, updating state as a side effect.
+ * Throws if the fetch fails entirely (caller should fall back to cached data).
+ */
+export async function fetchDashboardData(token) {
+    const stateManager = getStateManager();
+    const prMonitor = new PRMonitor(token);
+    const issueMonitor = new IssueConversationMonitor(token);
+    const [{ prs, failures }, recentlyClosedPRs, recentlyMergedPRs, mergedResult, closedResult, fetchedIssues] = await Promise.all([
+        prMonitor.fetchUserOpenPRs(),
+        prMonitor.fetchRecentlyClosedPRs().catch((err) => {
+            console.error(`Warning: Failed to fetch recently closed PRs: ${err instanceof Error ? err.message : err}`);
+            return [];
+        }),
+        prMonitor.fetchRecentlyMergedPRs().catch((err) => {
+            console.error(`Warning: Failed to fetch recently merged PRs: ${err instanceof Error ? err.message : err}`);
+            return [];
+        }),
+        prMonitor.fetchUserMergedPRCounts(),
+        prMonitor.fetchUserClosedPRCounts(),
+        issueMonitor.fetchCommentedIssues().catch((error) => {
+            const msg = error instanceof Error ? error.message : String(error);
+            if (msg.includes('No GitHub username configured')) {
+                console.error(`[DASHBOARD] Issue conversation tracking requires setup: ${msg}`);
+            }
+            else {
+                console.error(`[DASHBOARD] Issue conversation fetch failed: ${msg}`);
+            }
+            return {
+                issues: [],
+                failures: [{ issueUrl: 'N/A', error: `Issue conversation fetch failed: ${msg}` }],
+            };
+        }),
+    ]);
+    const commentedIssues = fetchedIssues.issues;
+    if (fetchedIssues.failures.length > 0) {
+        console.error(`[DASHBOARD] ${fetchedIssues.failures.length} issue conversation check(s) failed`);
+    }
+    if (failures.length > 0) {
+        console.error(`Warning: ${failures.length} PR fetch(es) failed`);
+    }
+    // Store monthly chart data (opened/merged/closed) so charts have data
+    const { monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
+    const { monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed } = closedResult;
+    try {
+        stateManager.setMonthlyMergedCounts(monthlyCounts);
+    }
+    catch (error) {
+        console.error('[DASHBOARD] Failed to store monthly merged counts:', error instanceof Error ? error.message : error);
+    }
+    try {
+        stateManager.setMonthlyClosedCounts(monthlyClosedCounts);
+    }
+    catch (error) {
+        console.error('[DASHBOARD] Failed to store monthly closed counts:', error instanceof Error ? error.message : error);
+    }
+    try {
+        const combinedOpenedCounts = { ...openedFromMerged };
+        for (const [month, count] of Object.entries(openedFromClosed)) {
+            combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + count;
+        }
+        for (const pr of prs) {
+            if (pr.createdAt) {
+                const month = pr.createdAt.slice(0, 7);
+                combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + 1;
+            }
+        }
+        stateManager.setMonthlyOpenedCounts(combinedOpenedCounts);
+    }
+    catch (error) {
+        console.error('[DASHBOARD] Failed to store monthly opened counts:', error instanceof Error ? error.message : error);
+    }
+    const digest = prMonitor.generateDigest(prs, recentlyClosedPRs, recentlyMergedPRs);
+    // Apply shelve partitioning for display (auto-unshelve only runs in daily check)
+    // Dormant PRs are treated as shelved for display purposes
+    const shelvedUrls = new Set(stateManager.getState().config.shelvedPRUrls || []);
+    const freshShelved = prs.filter((pr) => shelvedUrls.has(pr.url) || pr.status === 'dormant');
+    digest.shelvedPRs = freshShelved.map(toShelvedPRRef);
+    digest.autoUnshelvedPRs = [];
+    digest.summary.totalActivePRs = prs.length - freshShelved.length;
+    stateManager.setLastDigest(digest);
+    stateManager.save();
+    console.error(`Refreshed: ${prs.length} PRs fetched`);
+    return { digest, commentedIssues };
+}
+/**
+ * Compute PRs grouped by repository from a digest and state.
+ * Used for chart data in both JSON and HTML output.
+ */
+export function computePRsByRepo(digest, state) {
+    const prsByRepo = {};
+    // Count active PRs by repo from digest
+    for (const pr of digest.openPRs || []) {
+        if (!prsByRepo[pr.repo])
+            prsByRepo[pr.repo] = { active: 0, merged: 0, closed: 0 };
+        prsByRepo[pr.repo].active++;
+    }
+    // Add merged/closed counts from repo scores (historical data)
+    for (const [repo, score] of Object.entries(state.repoScores || {})) {
+        if (!prsByRepo[repo])
+            prsByRepo[repo] = { active: 0, merged: 0, closed: 0 };
+        prsByRepo[repo].merged = score.mergedPRCount;
+        prsByRepo[repo].closed = score.closedWithoutMergeCount;
+    }
+    return prsByRepo;
+}
+/**
+ * Compute the top repositories sorted by total PR count.
+ */
+export function computeTopRepos(prsByRepo, limit = 10) {
+    return Object.entries(prsByRepo)
+        .sort((a, b) => b[1].merged + b[1].active + b[1].closed - (a[1].merged + a[1].active + a[1].closed))
+        .slice(0, limit);
+}
+/**
+ * Extract monthly activity data from state.
+ */
+export function getMonthlyData(state) {
+    return {
+        monthlyMerged: state.monthlyMergedCounts || {},
+        monthlyClosed: state.monthlyClosedCounts || {},
+        monthlyOpened: state.monthlyOpenedCounts || {},
+    };
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Dashboard HTML template generation.
+ * Contains all HTML/CSS/JS template strings, escapeHtml(), and rendering helpers.
+ * Pure functions with no side effects — all data is passed in as arguments.
+ */
+import type { DailyDigest, AgentState, CommentedIssueWithResponse } from '../core/types.js';
+export interface DashboardStats {
+    activePRs: number;
+    shelvedPRs: number;
+    mergedPRs: number;
+    closedPRs: number;
+    mergeRate: string;
+}
+/**
+ * Escape HTML special characters to prevent XSS when interpolating
+ * user-controlled content (e.g. PR titles, comment bodies, author names) into HTML.
+ * Note: This escapes HTML entity characters only. It does not sanitize URL schemes
+ * (e.g., javascript:) — callers placing values in href attributes should validate
+ * the URL scheme if the source is untrusted. GitHub API URLs are trusted.
+ */
+export declare function escapeHtml(text: string): string;
+export declare function buildDashboardStats(digest: DailyDigest, state: Readonly<AgentState>): DashboardStats;
+export declare function generateDashboardHtml(stats: DashboardStats, monthlyMerged: Record<string, number>, monthlyClosed: Record<string, number>, monthlyOpened: Record<string, number>, digest: DailyDigest, state: Readonly<AgentState>, issueResponses?: CommentedIssueWithResponse[]): string;