@leo000001/opencode-quota-sidebar 3.0.10 → 4.0.2

package/dist/tools.d.ts

@@ -1,6 +1,8 @@
 import * as z from 'zod';
 import type { QuotaSnapshot } from './types.js';
 import type { UsageSummary } from './usage.js';
+import type { HistoryPeriod } from './period.js';
+import type { HistoryUsageResult } from './usage_service.js';
 type ToolContext = {
     sessionID: string;
 };
@@ -19,6 +21,8 @@ export declare function createQuotaSidebarTools(deps: {
     restoreSessionTitle?: (sessionID: string) => Promise<boolean>;
     showToast: (period: 'session' | 'day' | 'week' | 'month' | 'toggle', message: string) => Promise<void>;
     summarizeForTool: (period: 'session' | 'day' | 'week' | 'month', sessionID: string, includeChildren: boolean) => Promise<UsageSummary>;
+    summarizeHistoryForTool: (period: HistoryPeriod, since: string) => Promise<HistoryUsageResult>;
+    listCurrentProviderIDs?: () => Promise<Set<string>>;
     getQuotaSnapshots: (providerIDs: string[], options?: {
         allowDefault?: boolean;
     }) => Promise<QuotaSnapshot[]>;
@@ -29,6 +33,9 @@ export declare function createQuotaSidebarTools(deps: {
         showCost?: boolean;
         width?: number;
     }) => string;
+    renderHistoryMarkdownReport: (result: HistoryUsageResult, quotas: QuotaSnapshot[], options?: {
+        showCost?: boolean;
+    }) => string;
     config: {
         sidebar: {
             showCost: boolean;
@@ -42,16 +49,20 @@ export declare function createQuotaSidebarTools(deps: {
         description: string;
         args: {
             period: z.ZodOptional<z.ZodEnum<{
-                day: "day";
-                week: "week";
                 month: "month";
+                day: "day";
                 session: "session";
+                week: "week";
             }>>;
+            since: z.ZodOptional<z.ZodString>;
+            last: z.ZodOptional<z.ZodNumber>;
             toast: z.ZodOptional<z.ZodBoolean>;
             includeChildren: z.ZodOptional<z.ZodBoolean>;
         };
         execute: (args: {
-            period?: "day" | "week" | "month" | "session" | undefined;
+            period?: "month" | "day" | "session" | "week" | undefined;
+            since?: string | undefined;
+            last?: number | undefined;
             toast?: boolean | undefined;
             includeChildren?: boolean | undefined;
         }, context: ToolContext) => Promise<string>;

package/dist/tools.js

@@ -1,4 +1,6 @@
 import * as z from 'zod';
+import { sinceFromLast } from './period.js';
+import { filterHistoryProvidersForDisplay, filterUsageProvidersForDisplay, } from './provider_catalog.js';
 function tool(input) {
     return input;
 }
@@ -16,6 +18,16 @@ export function createQuotaSidebarTools(deps) {
             description: 'Show usage and quota summary for session/day/week/month. Returns the full markdown report with totals, highlights, provider table, and subscription quota so callers can present the report directly to the user.',
             args: {
                 period: z.enum(['session', 'day', 'week', 'month']).optional(),
+                since: z
+                    .string()
+                    .optional()
+                    .describe('Historical start date: `YYYY-MM` or `YYYY-MM-DD`.'),
+                last: z
+                    .number()
+                    .int()
+                    .positive()
+                    .optional()
+                    .describe('Relative history length. Examples: `period=day,last=7`, `period=week,last=8`, `period=month,last=6`.'),
                 toast: z.boolean().optional(),
                 includeChildren: z
                     .boolean()
@@ -23,11 +35,51 @@ export function createQuotaSidebarTools(deps) {
                     .describe('For period=session, include descendant subagent sessions in usage aggregation.'),
             },
             execute: async (args, context) => {
-                const period = args.period || 'session';
+                const period = args.period || (args.since || args.last ? 'month' : 'session');
+                const since = args.since?.trim();
+                const last = args.last;
+                if (since && last !== undefined) {
+                    throw new Error('`since` and `last` cannot be used together');
+                }
+                if (period === 'session' && since) {
+                    throw new Error('`since` is not supported when `period=session`');
+                }
+                if (period === 'session' && last !== undefined) {
+                    throw new Error('`last` is not supported when `period=session`');
+                }
+                const resolvedSince = since ||
+                    (period !== 'session' && last !== undefined
+                        ? sinceFromLast(period, last)
+                        : undefined);
+                const allowedProviderIDs = await deps
+                    .listCurrentProviderIDs?.()
+                    .catch(() => new Set());
+                if (period !== 'session' && resolvedSince) {
+                    const historyRaw = await deps.summarizeHistoryForTool(period, resolvedSince);
+                    const history = allowedProviderIDs
+                        ? filterHistoryProvidersForDisplay(historyRaw, allowedProviderIDs)
+                        : historyRaw;
+                    const quotas = await deps.getQuotaSnapshots([], {
+                        allowDefault: true,
+                    });
+                    const markdown = deps.renderHistoryMarkdownReport(history, quotas, {
+                        showCost: deps.config.sidebar.showCost,
+                    });
+                    if (args.toast === true) {
+                        await deps.showToast(period, deps.renderToastMessage(period, history.total, quotas, {
+                            showCost: deps.config.sidebar.showCost,
+                            width: Math.max(44, deps.config.sidebar.width + 18),
+                        }));
+                    }
+                    return markdown;
+                }
                 const includeChildren = period === 'session'
                     ? (args.includeChildren ?? deps.config.sidebar.includeChildren)
                     : false;
-                const usage = await deps.summarizeForTool(period, context.sessionID, includeChildren);
+                const usageRaw = await deps.summarizeForTool(period, context.sessionID, includeChildren);
+                const usage = allowedProviderIDs
+                    ? filterUsageProvidersForDisplay(usageRaw, allowedProviderIDs)
+                    : usageRaw;
                 // For quota_summary, always show all subscription quota balances,
                 // regardless of which providers were used in the session.
                 const quotas = await deps.getQuotaSnapshots([], { allowDefault: true });

package/dist/tui.tsx

@@ -25,7 +25,11 @@ import {
 } from './storage.js'
 import { looksDecorated, normalizeBaseTitle } from './title.js'
 import type { QuotaSidebarConfig } from './types.js'
-import { fromCachedSessionUsage, summarizeMessages } from './usage.js'
+import {
+  fromCachedSessionUsage,
+  mergeUsage,
+  summarizeMessages,
+} from './usage.js'
 
 const id = 'leo.quota-sidebar'
 const INTERNAL_CONTEXT_PLUGIN_ID = 'internal:sidebar-context'
@@ -89,11 +93,18 @@ async function loadSidebarPanel(
 
   const liveUsage = summarizeMessages(liveEntries, 0, 1)
   const cachedUsage = session?.sidebarPanel?.usage || session?.usage
-  const usage = cachedUsage
+  const persistedUsage = cachedUsage
     ? fromCachedSessionUsage(cachedUsage)
-    : liveUsage.assistantMessages > 0
+    : undefined
+  const usage =
+    liveUsage.assistantMessages > 0 &&
+    (!persistedUsage ||
+      liveUsage.assistantMessages > persistedUsage.assistantMessages ||
+      (liveUsage.assistantMessages === persistedUsage.assistantMessages &&
+        liveUsage.total >= persistedUsage.total))
       ? liveUsage
-      : undefined
+      : persistedUsage ||
+        (liveUsage.assistantMessages > 0 ? liveUsage : undefined)
   const compactTitle = resolveCompactTitle(sessionID, session?.lastAppliedTitle)
 
   if (!enabled) {
@@ -154,8 +165,8 @@ function useSidebarPanelData(api: TuiPluginApi, sessionID: () => string) {
   }
 
   const scheduleRefresh = () => {
-    queueRefresh(300)
-    queueRefresh(1_000)
+    queueRefresh(150)
+    queueRefresh(600)
   }
 
   // Bulk session sync populates messages asynchronously without emitting the

package/dist/tui_helpers.js

@@ -1,5 +1,6 @@
 import { fitLine, renderSidebarQuotaLineGroups } from './format.js';
 import { collapseQuotaSnapshots } from './quota_render.js';
+import { isSupportedQuotaSnapshot, isSupportedQuotaTitleLabel, } from './supported_quota.js';
 const VISIBLE_QUOTA_STATUSES = new Set([
     'ok',
     'error',
@@ -70,7 +71,7 @@ function fallbackQuotaTone(detail) {
     if (/\bB-/.test(safe))
         return 'error';
     const percents = [
-        ...safe.matchAll(/\b(?:\d+[hdw]|[DWM]|S7d|O7d|OA7d|Co7d)(\d{1,3})\b/gi),
+        ...safe.matchAll(/\b(?:\d+[hdw]|[DWM]|S7d|O7d|OA7d|Co7d|Sk5h|SkW)(\d{1,3})\b/gi),
     ]
         .map((match) => Number(match[1]))
         .filter((value) => Number.isFinite(value));
@@ -107,7 +108,7 @@ export function renderSidebarQuotaGroups(quotas, config) {
     });
 }
 export function sidebarPanelQuotaSnapshots(panel) {
-    return panel?.panelQuotas || panel?.quotas || [];
+    return (panel?.panelQuotas || panel?.quotas || []).filter((quota) => isSupportedQuotaSnapshot(quota));
 }
 export function fallbackQuotaGroupsFromTitle(title, width) {
     const parts = (title || '')
@@ -120,18 +121,22 @@ export function fallbackQuotaGroupsFromTitle(title, width) {
     if (quotaParts.length === 0)
         return [];
     const contentWidth = quotaParts.length > 1 ? Math.max(1, width - 2) : width;
-    return quotaParts.map((part, index) => {
+    const groups = [];
+    for (const [index, part] of quotaParts.entries()) {
         const line = fitLine(part, contentWidth);
         const parsed = parseQuotaLineParts([line]);
-        return {
+        if (!isSupportedQuotaTitleLabel(parsed.shortLabel))
+            continue;
+        groups.push({
             providerID: `fallback:${index}`,
             status: 'ok',
             tone: fallbackQuotaTone(parsed.detail),
             shortLabel: parsed.shortLabel,
             detail: parsed.detail,
             continuationLines: parsed.continuationLines,
-        };
-    });
+        });
+    }
+    return groups;
 }
 export function quotaGroupsUseBullets(groups) {
     return groups.length > 1;

package/dist/types.d.ts

@@ -12,6 +12,12 @@ export type QuotaWindow = {
     usedPercent?: number;
     resetAt?: string;
 };
+export type QuotaStaleReasonKind = 'timeout' | 'network' | 'http_5xx' | 'http_transient' | 'invalid_response' | 'unknown';
+export type QuotaStaleMeta = {
+    staleAt: number;
+    staleReason: string;
+    staleReasonKind: QuotaStaleReasonKind;
+};
 export type QuotaSnapshot = {
     providerID: string;
     /** Adapter ID that produced this snapshot (e.g. openai, rightcode). */
@@ -35,6 +41,8 @@ export type QuotaSnapshot = {
     note?: string;
     /** Multi-window quota (e.g. OpenAI short-term + weekly). */
     windows?: QuotaWindow[];
+    /** Last successful snapshot reused during a transient quota fetch failure. */
+    stale?: QuotaStaleMeta;
 };
 export type QuotaProviderConfig = {
     enabled?: boolean;

package/dist/usage.d.ts

@@ -46,12 +46,30 @@ export type UsageOptions = {
 export declare function getCacheCoverageMetrics(usage: Pick<UsageSummary, 'input' | 'cacheRead' | 'cacheWrite' | 'assistantMessages' | 'cacheBuckets'>): CacheCoverageMetrics;
 export declare function getProviderCacheCoverageMetrics(usage: Pick<ProviderUsage, 'input' | 'cacheRead' | 'cacheWrite' | 'assistantMessages' | 'cacheBuckets'>): CacheCoverageMetrics;
 export declare function emptyUsageSummary(): UsageSummary;
+export declare function accumulateMessagesInCompletedRange(target: UsageSummary, entries: Array<{
+    info: Message;
+}>, startAt?: number, endAt?: number, options?: UsageOptions): UsageSummary;
 export declare function summarizeMessages(entries: Array<{
     info: Message;
 }>, startAt?: number, sessionCount?: number, options?: UsageOptions): UsageSummary;
 export declare function summarizeMessagesInCompletedRange(entries: Array<{
     info: Message;
 }>, startAt: number, endAt: number, sessionCount?: number, options?: UsageOptions): UsageSummary;
+export declare function summarizeMessagesAcrossCompletedRanges(entries: Array<{
+    info: Message;
+}>, ranges: Array<{
+    startAt: number;
+    endAt: number;
+}>, options?: UsageOptions): UsageSummary[];
+export declare function accumulateMessagesAcrossCompletedRanges(summaries: UsageSummary[], entries: Array<{
+    info: Message;
+}>, ranges: Array<{
+    startAt: number;
+    endAt: number;
+}>, options?: UsageOptions): Set<number>;
+export declare function mergeCursorFromEntries(cursor: IncrementalCursor | undefined, entries: Array<{
+    info: Message;
+}>): IncrementalCursor | undefined;
 /**
  * P1: Incremental usage aggregation.
  * Only processes messages newer than the cursor. Returns updated cursor.

package/dist/usage.js

@@ -235,27 +235,111 @@ function isCompletedAssistantInRange(message, startAt = 0, endAt = Number.POSITI
     const completed = completedTimeOf(message);
     if (completed === undefined)
         return false;
-    return completed >= startAt && completed <= endAt;
+    return completed >= startAt && completed < endAt;
 }
-export function summarizeMessages(entries, startAt = 0, sessionCount = 1, options) {
-    const summary = emptyUsageSummary();
-    summary.sessionCount = sessionCount;
+export function accumulateMessagesInCompletedRange(target, entries, startAt = 0, endAt = Number.POSITIVE_INFINITY, options) {
     for (const entry of entries) {
-        if (!isCompletedAssistantInRange(entry.info, startAt))
+        if (!isCompletedAssistantInRange(entry.info, startAt, endAt))
             continue;
-        addMessageUsage(summary, entry.info, options);
+        addMessageUsage(target, entry.info, options);
     }
+    return target;
+}
+export function summarizeMessages(entries, startAt = 0, sessionCount = 1, options) {
+    const summary = emptyUsageSummary();
+    summary.sessionCount = sessionCount;
+    accumulateMessagesInCompletedRange(summary, entries, startAt, Infinity, options);
     return summary;
 }
 export function summarizeMessagesInCompletedRange(entries, startAt, endAt, sessionCount = 1, options) {
     const summary = emptyUsageSummary();
     summary.sessionCount = sessionCount;
+    accumulateMessagesInCompletedRange(summary, entries, startAt, endAt, options);
+    return summary;
+}
+function rangeIndexForCompletedAt(ranges, completedAt) {
+    let low = 0;
+    let high = ranges.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const range = ranges[mid];
+        if (completedAt < range.startAt) {
+            high = mid - 1;
+            continue;
+        }
+        if (completedAt >= range.endAt) {
+            low = mid + 1;
+            continue;
+        }
+        return mid;
+    }
+    return -1;
+}
+export function summarizeMessagesAcrossCompletedRanges(entries, ranges, options) {
+    const summaries = ranges.map(() => emptyUsageSummary());
+    accumulateMessagesAcrossCompletedRanges(summaries, entries, ranges, options);
+    return summaries;
+}
+export function accumulateMessagesAcrossCompletedRanges(summaries, entries, ranges, options) {
+    const touched = new Set();
+    if (ranges.length === 0)
+        return touched;
     for (const entry of entries) {
-        if (!isCompletedAssistantInRange(entry.info, startAt, endAt))
+        if (!isAssistant(entry.info))
+            continue;
+        const completed = completedTimeOf(entry.info);
+        if (completed === undefined)
             continue;
-        addMessageUsage(summary, entry.info, options);
+        const index = rangeIndexForCompletedAt(ranges, completed);
+        if (index < 0)
+            continue;
+        addMessageUsage(summaries[index], entry.info, options);
+        touched.add(index);
     }
-    return summary;
+    for (const index of touched) {
+        summaries[index].sessionCount = 1;
+    }
+    return touched;
+}
+export function mergeCursorFromEntries(cursor, entries) {
+    let bestTime = typeof cursor?.lastMessageTime === 'number' &&
+        Number.isFinite(cursor.lastMessageTime)
+        ? cursor.lastMessageTime
+        : Number.NEGATIVE_INFINITY;
+    let bestID = cursor?.lastMessageId || '';
+    const idsAtBestTime = new Set(Array.isArray(cursor?.lastMessageIdsAtTime)
+        ? cursor.lastMessageIdsAtTime
+        : cursor?.lastMessageId && Number.isFinite(bestTime)
+            ? [cursor.lastMessageId]
+            : []);
+    for (const entry of entries) {
+        const msg = entry.info;
+        if (!isAssistant(msg))
+            continue;
+        const completed = completedTimeOf(msg);
+        if (completed === undefined)
+            continue;
+        if (completed > bestTime) {
+            bestTime = completed;
+            bestID = msg.id;
+            idsAtBestTime.clear();
+            idsAtBestTime.add(msg.id);
+            continue;
+        }
+        if (completed !== bestTime)
+            continue;
+        idsAtBestTime.add(msg.id);
+        if (msg.id.localeCompare(bestID) > 0) {
+            bestID = msg.id;
+        }
+    }
+    if (!Number.isFinite(bestTime) || !bestID)
+        return undefined;
+    return {
+        lastMessageId: bestID,
+        lastMessageTime: bestTime,
+        lastMessageIdsAtTime: Array.from(idsAtBestTime).sort(),
+    };
 }
 /**
  * P1: Incremental usage aggregation.

package/dist/usage_service.d.ts

@@ -1,5 +1,8 @@
 import type { PluginInput } from '@opencode-ai/plugin';
+import { type HistoryPeriod } from './period.js';
 import { type UsageSummary } from './usage.js';
+export type { HistoryUsageRow, HistoryUsageResult } from './history_usage.js';
+import type { HistoryUsageResult } from './history_usage.js';
 import type { QuotaSidebarConfig, QuotaSidebarState } from './types.js';
 type DescendantsResolver = {
     listDescendantSessionIDs: (sessionID: string, opts: {
@@ -24,8 +27,8 @@ export declare function createUsageService(deps: {
 }): {
     summarizeSessionUsageForDisplay: (sessionID: string, includeChildren: boolean) => Promise<UsageSummary>;
     summarizeForTool: (period: "session" | "day" | "week" | "month", sessionID: string, includeChildren: boolean) => Promise<UsageSummary>;
+    summarizeHistoryUsage: (period: HistoryPeriod, rawSince: string) => Promise<HistoryUsageResult>;
     markSessionDirty: (sessionID: string) => void;
     markForceRescan: (sessionID: string) => void;
     forgetSession: (sessionID: string) => void;
 };
-export {};