@leo000001/opencode-quota-sidebar 3.0.9 → 4.0.0

package/dist/history_usage.d.ts

@@ -0,0 +1,93 @@
+import type { AssistantMessage, Message } from '@opencode-ai/sdk';
+import { type HistoryPeriod, type PeriodRange, type SinceSpec } from './period.js';
+import { type UsageSummary } from './usage.js';
+import type { CacheCoverageMode, CachedSessionUsage, IncrementalCursor } from './types.js';
+export type HistoryDialogRow = {
+    label: string;
+    isCurrent: boolean;
+    usage: UsageSummary;
+};
+export type HistoryDialogData = {
+    period: HistoryPeriod;
+    since: string;
+    rows: HistoryDialogRow[];
+    total: UsageSummary;
+    warning?: string;
+};
+export type HistoryUsageRow = {
+    range: PeriodRange;
+    usage: UsageSummary;
+};
+export type HistoryUsageResult = {
+    period: HistoryPeriod;
+    since: SinceSpec;
+    rows: HistoryUsageRow[];
+    total: UsageSummary;
+    warning?: string;
+    persistenceHints?: HistoryPersistenceHint[];
+};
+type MessageEntry = {
+    info: Message;
+};
+export type HistoryPersistenceHint = {
+    sessionID: string;
+    dateKey: string;
+    lastMessageTime: number | undefined;
+    dirty: boolean;
+    ranges: UsageSummary[];
+    totalUsage: UsageSummary;
+    fullUsage: UsageSummary | undefined;
+    persist: boolean;
+    cursor: IncrementalCursor | undefined;
+    missing: boolean;
+    loadFailed: boolean;
+};
+export type LoadMessagesPageResult = {
+    status: 'ok';
+    entries: MessageEntry[];
+    nextBefore?: string;
+} | {
+    status: 'missing';
+} | {
+    status: 'error';
+};
+type SessionEntry = {
+    sessionID: string;
+    dateKey: string;
+    state: {
+        createdAt: number;
+        cursor?: IncrementalCursor;
+        dirty?: boolean;
+        usage?: CachedSessionUsage;
+    };
+};
+export type ComputeHistoryUsageDeps = {
+    /** All known sessions (from memory state + disk chunks). */
+    sessions: SessionEntry[];
+    /** Paged message loader — injected so both server and TUI can provide their own implementation. */
+    loadMessagesPage: (sessionID: string, before?: string) => Promise<LoadMessagesPageResult>;
+    /** Model pricing map for API-cost estimation. */
+    getModelCostMap: () => Promise<Record<string, unknown>>;
+    /** Calculate equivalent API cost for a single assistant message. */
+    calcApiCost: (message: AssistantMessage, modelCostMap: Record<string, unknown>) => number;
+    /** Classify cache coverage mode for a single assistant message. */
+    classifyCacheMode: (message: AssistantMessage, modelCostMap: Record<string, unknown>) => CacheCoverageMode;
+    /** Check whether a set of entries has at least one resolvable API-cost message. */
+    hasResolvableApiCostMessages: (entries: MessageEntry[], modelCostMap: Record<string, unknown>) => boolean;
+    /** Whether the cached usage for a session needs a full recompute. */
+    shouldTrackFullUsage: (cached: CachedSessionUsage | undefined, hasPricing: boolean) => boolean;
+    /** Whether cached usage needs recompute (for persistence decision). */
+    shouldRecomputeUsageCache: (cached: CachedSessionUsage, hasPricing: boolean, hasResolvableApiCostMessage: boolean) => boolean;
+    throwOnLoadFailure?: boolean;
+};
+/**
+ * Compute day/week/month history usage by paging through session messages.
+ *
+ * This is the shared core used by both the server-side `quota_summary` tool
+ * and the TUI-local `/qday /qweek /qmonth` popup.
+ *
+ * Callers inject their own `loadMessagesPage` implementation so the function
+ * does not depend on any specific runtime context.
+ */
+export declare function computeHistoryUsage(deps: ComputeHistoryUsageDeps, period: HistoryPeriod, rawSince: string): Promise<HistoryUsageResult>;
+export {};

package/dist/history_usage.js

@@ -0,0 +1,251 @@
+import { parseSince, periodRanges, } from './period.js';
+import { mapConcurrent } from './helpers.js';
+import { accumulateMessagesAcrossCompletedRanges, accumulateMessagesInCompletedRange, emptyUsageSummary, fromCachedSessionUsage, mergeCursorFromEntries, mergeUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
+// ── Constants ──────────────────────────────────────────────────────────────
+const RANGE_USAGE_CONCURRENCY = 5;
+// ── Core ───────────────────────────────────────────────────────────────────
+function filterRangeSessions(sessions, startAt, endAt) {
+    return sessions.filter((session) => {
+        if (session.state.createdAt > endAt)
+            return false;
+        if (session.state.dirty === true)
+            return true;
+        const lastMessageTime = session.state.cursor?.lastMessageTime;
+        if (typeof lastMessageTime === 'number' &&
+            Number.isFinite(lastMessageTime) &&
+            lastMessageTime < startAt) {
+            return false;
+        }
+        return true;
+    });
+}
+function pageLatestTimestamp(entries) {
+    let latest = Number.NEGATIVE_INFINITY;
+    for (const entry of entries) {
+        const info = entry.info;
+        const completed = info.time?.completed;
+        if (typeof completed === 'number' && Number.isFinite(completed)) {
+            if (completed > latest)
+                latest = completed;
+            continue;
+        }
+        const created = info.time?.created;
+        if (typeof created === 'number' && Number.isFinite(created)) {
+            if (created > latest)
+                latest = created;
+        }
+    }
+    return latest;
+}
+function rangeIndexForTimestamp(ranges, timestamp) {
+    let low = 0;
+    let high = ranges.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const range = ranges[mid];
+        if (timestamp < range.startAt) {
+            high = mid - 1;
+            continue;
+        }
+        if (timestamp >= range.endAt) {
+            low = mid + 1;
+            continue;
+        }
+        return mid;
+    }
+    return -1;
+}
+function canUseCurrentSessionCache(cached, session, ranges) {
+    if (!cached)
+        return undefined;
+    if (cached.billingVersion !== USAGE_BILLING_CACHE_VERSION)
+        return undefined;
+    if (session.state.dirty === true)
+        return undefined;
+    const lastMessageTime = session.state.cursor?.lastMessageTime;
+    if (typeof lastMessageTime !== 'number' ||
+        !Number.isFinite(lastMessageTime)) {
+        return undefined;
+    }
+    if (typeof session.state.createdAt !== 'number' ||
+        !Number.isFinite(session.state.createdAt)) {
+        return undefined;
+    }
+    const startIndex = rangeIndexForTimestamp(ranges, session.state.createdAt);
+    const endIndex = rangeIndexForTimestamp(ranges, lastMessageTime);
+    if (startIndex < 0 || endIndex < 0 || startIndex !== endIndex) {
+        return undefined;
+    }
+    return {
+        index: startIndex,
+        usage: fromCachedSessionUsage(cached, 1),
+        lastMessageTime,
+    };
+}
+/**
+ * Compute day/week/month history usage by paging through session messages.
+ *
+ * This is the shared core used by both the server-side `quota_summary` tool
+ * and the TUI-local `/qday /qweek /qmonth` popup.
+ *
+ * Callers inject their own `loadMessagesPage` implementation so the function
+ * does not depend on any specific runtime context.
+ */
+export async function computeHistoryUsage(deps, period, rawSince) {
+    const now = Date.now();
+    const since = parseSince(rawSince, now);
+    const ranges = periodRanges(period, since, now);
+    const total = emptyUsageSummary();
+    const rows = ranges.map((range) => ({
+        range,
+        usage: emptyUsageSummary(),
+    }));
+    if (ranges.length === 0) {
+        return { period, since, rows, total };
+    }
+    const startAt = ranges[0].startAt;
+    const endAt = ranges[ranges.length - 1].endAt;
+    const sessions = filterRangeSessions(deps.sessions, startAt, endAt);
+    const modelCostMap = await deps.getModelCostMap();
+    const hasPricing = Object.keys(modelCostMap).length > 0;
+    if (sessions.length > 0) {
+        const fetched = await mapConcurrent(sessions, RANGE_USAGE_CONCURRENCY, async (session) => {
+            const cachedHit = canUseCurrentSessionCache(session.state.usage, session, rows.map((row) => ({
+                startAt: row.range.startAt,
+                endAt: row.range.endAt,
+            })));
+            if (cachedHit) {
+                const rangeUsage = rows.map(() => emptyUsageSummary());
+                rangeUsage[cachedHit.index] = cachedHit.usage;
+                return {
+                    sessionID: session.sessionID,
+                    dateKey: session.dateKey,
+                    lastMessageTime: cachedHit.lastMessageTime,
+                    dirty: false,
+                    ranges: rangeUsage,
+                    totalUsage: cachedHit.usage,
+                    fullUsage: undefined,
+                    loadFailed: false,
+                    missing: false,
+                    persist: false,
+                    cursor: session.state.cursor,
+                };
+            }
+            const usageOptions = {
+                calcApiCost: (message) => deps.calcApiCost(message, modelCostMap),
+                classifyCacheMode: (message) => deps.classifyCacheMode(message, modelCostMap),
+            };
+            const rangeUsage = rows.map(() => emptyUsageSummary());
+            const totalUsage = emptyUsageSummary();
+            const trackFullUsage = deps.shouldTrackFullUsage(session.state.usage, hasPricing);
+            const fullUsage = trackFullUsage ? emptyUsageSummary() : undefined;
+            let cursor;
+            let hasResolvable = false;
+            let before;
+            while (true) {
+                const load = await deps.loadMessagesPage(session.sessionID, before);
+                if (load.status !== 'ok') {
+                    return {
+                        sessionID: session.sessionID,
+                        dateKey: session.dateKey,
+                        lastMessageTime: session.state.cursor?.lastMessageTime,
+                        dirty: session.state.dirty === true,
+                        ranges: rows.map(() => emptyUsageSummary()),
+                        totalUsage: emptyUsageSummary(),
+                        fullUsage: undefined,
+                        loadFailed: load.status === 'error',
+                        missing: load.status === 'missing',
+                        persist: false,
+                        cursor: undefined,
+                    };
+                }
+                const entries = load.entries;
+                if (entries.length === 0)
+                    break;
+                accumulateMessagesAcrossCompletedRanges(rangeUsage, entries, rows.map((row) => ({
+                    startAt: row.range.startAt,
+                    endAt: row.range.endAt,
+                })), usageOptions);
+                if (fullUsage) {
+                    accumulateMessagesInCompletedRange(fullUsage, entries, 0, Number.POSITIVE_INFINITY, usageOptions);
+                    cursor = mergeCursorFromEntries(cursor, entries);
+                }
+                if (!hasResolvable) {
+                    hasResolvable = deps.hasResolvableApiCostMessages(entries, modelCostMap);
+                }
+                // `session.messages(limit, before)` pages from newest to oldest.
+                // When we are only computing range usage (no full-session persistence),
+                // we can stop as soon as this page's newest timestamp is already older
+                // than the earliest requested range boundary.
+                if (!fullUsage) {
+                    const latestInPage = pageLatestTimestamp(entries);
+                    if (Number.isFinite(latestInPage) && latestInPage < startAt) {
+                        break;
+                    }
+                }
+                if (!load.nextBefore)
+                    break;
+                before = load.nextBefore;
+            }
+            for (const item of rangeUsage) {
+                if (item.assistantMessages > 0) {
+                    mergeUsage(totalUsage, item);
+                }
+            }
+            if (totalUsage.assistantMessages > 0) {
+                totalUsage.sessionCount = 1;
+            }
+            const shouldPersist = !!fullUsage &&
+                (!session.state.usage ||
+                    deps.shouldRecomputeUsageCache(session.state.usage, hasPricing, hasResolvable));
+            return {
+                sessionID: session.sessionID,
+                dateKey: session.dateKey,
+                lastMessageTime: cursor?.lastMessageTime,
+                dirty: session.state.dirty === true,
+                ranges: rangeUsage,
+                totalUsage,
+                fullUsage: shouldPersist ? fullUsage : undefined,
+                loadFailed: false,
+                missing: false,
+                persist: shouldPersist,
+                cursor,
+            };
+        });
+        const failedLoads = fetched.filter((item) => {
+            if (!item.loadFailed)
+                return false;
+            if (item.dirty)
+                return true;
+            const lastMessageTime = item.lastMessageTime;
+            if (typeof lastMessageTime === 'number' && lastMessageTime < startAt) {
+                return false;
+            }
+            return true;
+        });
+        if (failedLoads.length > 0 && deps.throwOnLoadFailure !== false) {
+            throw new Error(`history usage unavailable: failed to load ${failedLoads.length} session(s)`);
+        }
+        for (const item of fetched) {
+            for (let index = 0; index < rows.length; index++) {
+                if (item.ranges[index].assistantMessages > 0) {
+                    mergeUsage(rows[index].usage, item.ranges[index]);
+                }
+            }
+            if (item.totalUsage.assistantMessages > 0) {
+                mergeUsage(total, item.totalUsage);
+            }
+        }
+        return {
+            period,
+            since,
+            rows,
+            total,
+            warning: deps.throwOnLoadFailure === false && failedLoads.length > 0
+                ? `Skipped ${failedLoads.length} session(s) that could not be loaded.`
+                : undefined,
+            persistenceHints: fetched,
+        };
+    }
+    return { period, since, rows, total };
+}

package/dist/index.js

@@ -1,4 +1,4 @@
-import { renderMarkdownReport, resolveTitleView, renderSidebarTitle, renderToastMessage, } from './format.js';
+import { renderHistoryMarkdownReport, renderMarkdownReport, resolveTitleView, renderSidebarTitle, renderToastMessage, } from './format.js';
 import { createQuotaRuntime } from './quota.js';
 import { authFilePath, dateKeyFromTimestamp, deleteSessionFromDayChunk, evictOldSessions, loadConfig, loadState, normalizeTimestampMs, quotaConfigPaths, resolveOpencodeDataDir, saveState, stateFilePath, } from './storage.js';
 import { debug, swallow } from './helpers.js';
@@ -11,6 +11,7 @@ import { createPersistenceScheduler } from './persistence.js';
 import { createQuotaService } from './quota_service.js';
 import { createUsageService } from './usage_service.js';
 import { createTitleApplicator } from './title_apply.js';
+import { listCurrentProviderIDs } from './provider_catalog.js';
 const SHUTDOWN_HOOK_KEY = Symbol.for('opencode-quota-sidebar.shutdown-hook');
 const SHUTDOWN_CALLBACKS_KEY = Symbol.for('opencode-quota-sidebar.shutdown-callbacks');
 const SESSION_ACTIVE_GRACE_MS = 15_000;
@@ -45,6 +46,7 @@ export async function QuotaSidebarPlugin(input) {
         scheduleSave,
     });
     const getQuotaSnapshots = quotaService.getQuotaSnapshots;
+    const invalidateQuotaForProvider = quotaService.invalidateForProvider;
     const ensureSessionState = (sessionID, title, createdAt = Date.now(), parentID) => {
         const existing = state.sessions[sessionID];
         if (existing) {
@@ -117,7 +119,9 @@ export async function QuotaSidebarPlugin(input) {
     });
     const summarizeSessionUsageForDisplay = usageService.summarizeSessionUsageForDisplay;
     const summarizeForTool = usageService.summarizeForTool;
+    const summarizeHistoryForTool = usageService.summarizeHistoryUsage;
     const activeSessionUntil = new Map();
+    let lastTuiSessionID;
     const markSessionActive = (sessionID, now = Date.now()) => {
         activeSessionUntil.set(sessionID, now + SESSION_ACTIVE_GRACE_MS);
     };
@@ -219,6 +223,8 @@ export async function QuotaSidebarPlugin(input) {
         }
     }
     const showToast = async (period, message) => {
+        if (!input.client.tui?.showToast)
+            return;
         await input.client.tui
             .showToast({
             query: { directory: input.directory },
@@ -345,10 +351,16 @@ export async function QuotaSidebarPlugin(input) {
                 scheduleActiveTitleRefresh(session.parentID, 0);
             }
         },
-        onTuiActivity: async () => {
-            return;
+        onTuiActivity: async (sessionID) => {
+            const target = sessionID || lastTuiSessionID;
+            if (!target)
+                return;
+            lastTuiSessionID = target;
+            markSessionActive(target);
         },
         onTuiSessionSelect: async (sessionID) => {
+            lastTuiSessionID = sessionID;
+            markSessionActive(sessionID);
             scheduleActiveTitleRefresh(sessionID, 0);
         },
         onMessageRemoved: async (info) => {
@@ -360,16 +372,23 @@ export async function QuotaSidebarPlugin(input) {
             const now = Date.now();
             const completed = message.time.completed;
             if (typeof completed !== 'number' || !Number.isFinite(completed)) {
+                const created = message.time.created;
+                if (typeof created === 'number' &&
+                    Number.isFinite(created) &&
+                    created < now - SESSION_ACTIVE_GRACE_MS) {
+                    return;
+                }
                 markSessionActive(message.sessionID, now);
                 return;
             }
+            invalidateQuotaForProvider(message.providerID);
             const wasActive = isSessionActive(message.sessionID, now);
             if (!wasActive) {
                 return;
             }
             markSessionActive(message.sessionID, now);
             usageService.markSessionDirty(message.sessionID);
-            scheduleActiveTitleRefresh(message.sessionID);
+            scheduleActiveTitleRefresh(message.sessionID, 100);
             void maybeShowExpiryToast(message.sessionID);
         },
     });
@@ -399,9 +418,15 @@ export async function QuotaSidebarPlugin(input) {
             restoreSessionTitle: (sessionID) => titleApplicator.restoreSessionTitle(sessionID),
             showToast,
             summarizeForTool,
+            summarizeHistoryForTool,
+            listCurrentProviderIDs: () => listCurrentProviderIDs({
+                client: input.client,
+                directory: input.directory,
+            }),
             getQuotaSnapshots,
             renderMarkdownReport,
             renderToastMessage,
+            renderHistoryMarkdownReport,
             config: {
                 sidebar: config.sidebar,
                 sidebarEnabled: config.sidebar.enabled,

package/dist/period.d.ts

@@ -1 +1,29 @@
-export declare function periodStart(period: 'day' | 'week' | 'month'): number;
+export type HistoryPeriod = 'day' | 'week' | 'month';
+export type SincePrecision = 'month' | 'day';
+export type SinceSpec = {
+    raw: string;
+    precision: SincePrecision;
+    startAt: number;
+};
+export type PeriodRange = {
+    period: HistoryPeriod;
+    startAt: number;
+    endAt: number;
+    label: string;
+    shortLabel: string;
+    isCurrent: boolean;
+    isPartial: boolean;
+    index: number;
+};
+export declare function parseSince(raw: string, now?: number): {
+    raw: string;
+    precision: "month";
+    startAt: number;
+} | {
+    raw: string;
+    precision: "day";
+    startAt: number;
+};
+export declare function periodRanges(period: HistoryPeriod, since: SinceSpec, endAt?: number): PeriodRange[];
+export declare function periodStart(period: HistoryPeriod, now?: number): number;
+export declare function sinceFromLast(period: HistoryPeriod, last: number, now?: number): string;

package/dist/period.js

@@ -1,14 +1,192 @@
-export function periodStart(period) {
-    const now = new Date();
+const MONTH_NAMES = [
+    'Jan',
+    'Feb',
+    'Mar',
+    'Apr',
+    'May',
+    'Jun',
+    'Jul',
+    'Aug',
+    'Sep',
+    'Oct',
+    'Nov',
+    'Dec',
+];
+function pad2(value) {
+    return `${value}`.padStart(2, '0');
+}
+function startOfDay(timestamp) {
+    const date = new Date(timestamp);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+function startOfMonth(timestamp) {
+    const date = new Date(timestamp);
+    return new Date(date.getFullYear(), date.getMonth(), 1).getTime();
+}
+function startOfWeek(timestamp) {
+    const date = new Date(timestamp);
+    const day = date.getDay();
+    const shift = day === 0 ? 6 : day - 1;
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate() - shift).getTime();
+}
+function nextDayStart(timestamp) {
+    const date = new Date(timestamp);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1).getTime();
+}
+function nextWeekStart(timestamp) {
+    const weekStart = new Date(startOfWeek(timestamp));
+    return new Date(weekStart.getFullYear(), weekStart.getMonth(), weekStart.getDate() + 7).getTime();
+}
+function nextMonthStart(timestamp) {
+    const date = new Date(timestamp);
+    return new Date(date.getFullYear(), date.getMonth() + 1, 1).getTime();
+}
+function formatLocalDate(timestamp) {
+    const date = new Date(timestamp);
+    return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}
+function formatMonthInput(timestamp) {
+    const date = new Date(timestamp);
+    return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}`;
+}
+function formatMonthLabel(timestamp) {
+    const date = new Date(timestamp);
+    return `${MONTH_NAMES[date.getMonth()]} ${date.getFullYear()}`;
+}
+function formatMonthShortLabel(timestamp) {
+    const date = new Date(timestamp);
+    return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}`;
+}
+function formatDayShortLabel(timestamp) {
+    const date = new Date(timestamp);
+    return `${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}
+function periodBoundaryStart(period, timestamp) {
+    if (period === 'month')
+        return startOfMonth(timestamp);
+    if (period === 'week')
+        return startOfWeek(timestamp);
+    return startOfDay(timestamp);
+}
+function nextPeriodBoundary(period, timestamp) {
+    if (period === 'month')
+        return nextMonthStart(timestamp);
+    if (period === 'week')
+        return nextWeekStart(timestamp);
+    return nextDayStart(timestamp);
+}
+function periodRangeLabels(period, startAt, endAt) {
     if (period === 'month') {
-        return new Date(now.getFullYear(), now.getMonth(), 1).getTime();
+        return {
+            label: formatMonthLabel(startAt),
+            shortLabel: formatMonthShortLabel(startAt),
+        };
+    }
+    if (period === 'week') {
+        const endLabel = formatLocalDate(Math.max(startAt, endAt - 1));
+        const startLabel = formatLocalDate(startAt);
+        return {
+            label: `${startLabel} to ${endLabel}`,
+            shortLabel: `${startLabel}..${endLabel}`,
+        };
+    }
+    return {
+        label: formatLocalDate(startAt),
+        shortLabel: formatDayShortLabel(startAt),
+    };
+}
+export function parseSince(raw, now = Date.now()) {
+    const value = raw.trim();
+    const monthMatch = /^(\d{4})-(\d{2})$/.exec(value);
+    if (monthMatch) {
+        const year = Number(monthMatch[1]);
+        const month = Number(monthMatch[2]);
+        if (year < 100 || month < 1 || month > 12) {
+            throw new Error('`since` is not a valid calendar date');
+        }
+        const startAt = new Date(year, month - 1, 1).getTime();
+        if (Number.isNaN(startAt)) {
+            throw new Error('`since` is not a valid calendar date');
+        }
+        if (startAt > now) {
+            throw new Error('`since` cannot be in the future');
+        }
+        return { raw: value, precision: 'month', startAt };
+    }
+    const dayMatch = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+    if (dayMatch) {
+        const year = Number(dayMatch[1]);
+        const month = Number(dayMatch[2]);
+        const day = Number(dayMatch[3]);
+        if (year < 100) {
+            throw new Error('`since` is not a valid calendar date');
+        }
+        const startAt = new Date(year, month - 1, day).getTime();
+        const probe = new Date(startAt);
+        if (Number.isNaN(startAt) ||
+            probe.getFullYear() !== year ||
+            probe.getMonth() !== month - 1 ||
+            probe.getDate() !== day) {
+            throw new Error('`since` is not a valid calendar date');
+        }
+        if (startAt > now) {
+            throw new Error('`since` cannot be in the future');
+        }
+        return { raw: value, precision: 'day', startAt };
+    }
+    throw new Error('`since` must be `YYYY-MM` or `YYYY-MM-DD`');
+}
+export function periodRanges(period, since, endAt = Date.now()) {
+    if (since.startAt > endAt) {
+        throw new Error('`since` cannot be in the future');
+    }
+    const ranges = [];
+    let cursor = since.startAt;
+    let index = 0;
+    while (cursor < endAt) {
+        const boundaryStart = periodBoundaryStart(period, cursor);
+        const boundaryEnd = nextPeriodBoundary(period, cursor);
+        const rangeEnd = Math.min(boundaryEnd, endAt);
+        const isCurrent = rangeEnd === endAt && endAt !== periodBoundaryStart(period, endAt);
+        const isPartial = cursor !== boundaryStart || isCurrent;
+        const { label, shortLabel } = periodRangeLabels(period, cursor, rangeEnd);
+        ranges.push({
+            period,
+            startAt: cursor,
+            endAt: rangeEnd,
+            label,
+            shortLabel,
+            isCurrent,
+            isPartial,
+            index,
+        });
+        cursor = rangeEnd;
+        index += 1;
+    }
+    if (period === 'day' && ranges.length > 90) {
+        throw new Error('day history is limited to 90 days; choose a later `since` date');
+    }
+    return ranges;
+}
+export function periodStart(period, now = Date.now()) {
+    return periodBoundaryStart(period, now);
+}
+export function sinceFromLast(period, last, now = Date.now()) {
+    if (!Number.isInteger(last) || last < 1) {
+        throw new Error('`last` must be a positive integer');
+    }
+    const currentStart = periodBoundaryStart(period, now);
+    if (period === 'day') {
+        const date = new Date(currentStart);
+        const start = new Date(date.getFullYear(), date.getMonth(), date.getDate() - (last - 1)).getTime();
+        return formatLocalDate(start);
     }
     if (period === 'week') {
-        const day = now.getDay();
-        const shift = day === 0 ? 6 : day - 1;
-        const start = new Date(now.getFullYear(), now.getMonth(), now.getDate() - shift);
-        start.setHours(0, 0, 0, 0);
-        return start.getTime();
+        const date = new Date(currentStart);
+        const start = new Date(date.getFullYear(), date.getMonth(), date.getDate() - 7 * (last - 1)).getTime();
+        return formatLocalDate(start);
     }
-    return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+    const date = new Date(currentStart);
+    const start = new Date(date.getFullYear(), date.getMonth() - (last - 1), 1).getTime();
+    return formatMonthInput(start);
 }

package/dist/provider_catalog.d.ts

@@ -0,0 +1,8 @@
+import type { HistoryUsageResult } from './usage_service.js';
+import type { UsageSummary } from './usage.js';
+export declare function listCurrentProviderIDs(input: {
+    client: unknown;
+    directory: string;
+}): Promise<Set<string>>;
+export declare function filterUsageProvidersForDisplay(usage: UsageSummary, allowedProviderIDs: ReadonlySet<string>): UsageSummary;
+export declare function filterHistoryProvidersForDisplay(result: HistoryUsageResult, allowedProviderIDs: ReadonlySet<string>): HistoryUsageResult;