@leo000001/opencode-quota-sidebar 1.0.2 → 1.2.0

package/dist/usage.js

@@ -13,6 +13,20 @@ export function emptyUsageSummary() {
         providers: {},
     };
 }
+function emptyProviderUsage(providerID) {
+    return {
+        providerID,
+        input: 0,
+        output: 0,
+        reasoning: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        total: 0,
+        cost: 0,
+        apiCost: 0,
+        assistantMessages: 0,
+    };
+}
 function isAssistant(message) {
     return message.role === 'assistant';
 }
@@ -44,18 +58,7 @@ function addMessageUsage(target, message, options) {
     target.cost += cost;
     target.apiCost += apiCost;
     const provider = target.providers[message.providerID] ||
-        {
-            providerID: message.providerID,
-            input: 0,
-            output: 0,
-            reasoning: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            total: 0,
-            cost: 0,
-            apiCost: 0,
-            assistantMessages: 0,
-        };
+        emptyProviderUsage(message.providerID);
     provider.input += message.tokens.input;
     provider.output += output;
     provider.cacheRead += message.tokens.cache.read;
@@ -72,7 +75,9 @@ export function summarizeMessages(entries, startAt = 0, sessionCount = 1, option
     for (const entry of entries) {
         if (!isAssistant(entry.info))
             continue;
-        if (!entry.info.time.completed)
+        if (typeof entry.info.time.completed !== 'number')
+            continue;
+        if (!Number.isFinite(entry.info.time.completed))
             continue;
         if (entry.info.time.created < startAt)
             continue;
@@ -87,7 +92,11 @@ export function summarizeMessages(entries, startAt = 0, sessionCount = 1, option
  */
 export function summarizeMessagesIncremental(entries, existingUsage, cursor, forceRescan, options) {
     // If no cursor or force rescan, do full scan
-    if (forceRescan || !cursor?.lastMessageId || !existingUsage) {
+    if (forceRescan ||
+        !cursor?.lastMessageId ||
+        typeof cursor.lastMessageTime !== 'number' ||
+        !Number.isFinite(cursor.lastMessageTime) ||
+        !existingUsage) {
         const usage = summarizeMessages(entries, 0, 1, options);
         const lastMsg = findLastCompletedAssistant(entries);
         return {
@@ -95,31 +104,102 @@ export function summarizeMessagesIncremental(entries, existingUsage, cursor, for
             cursor: {
                 lastMessageId: lastMsg?.id,
                 lastMessageTime: lastMsg?.time.completed ?? undefined,
+                lastMessageIdsAtTime: lastMsg?.time.completed === undefined
+                    ? undefined
+                    : collectCompletedAssistantIdsAt(entries, lastMsg.time.completed),
             },
         };
     }
-    // Incremental: start from existing usage, only process new messages
+    // Incremental: start from existing usage, only process new messages.
+    // Order-independent: use completed-time cursor (with id tie-breaker).
     const summary = fromCachedSessionUsage(existingUsage, 1);
+    const cursorTime = cursor.lastMessageTime;
+    const cursorID = cursor.lastMessageId;
+    const cursorIDsAtTime = Array.isArray(cursor.lastMessageIdsAtTime)
+        ? new Set(cursor.lastMessageIdsAtTime)
+        : undefined;
+    // If the cursor doesn't record ids-at-time, and we see other messages with the
+    // same completed timestamp but "earlier" ids, the id tie-breaker can miss
+    // newly-arrived messages. Force a full rescan once to initialize ids-at-time.
+    if (!cursorIDsAtTime) {
+        for (const entry of entries) {
+            const msg = entry.info;
+            if (!isAssistant(msg))
+                continue;
+            if (typeof msg.time.completed !== 'number')
+                continue;
+            if (!Number.isFinite(msg.time.completed))
+                continue;
+            if (msg.id === cursorID)
+                continue;
+            if (msg.time.completed === cursorTime &&
+                msg.id.localeCompare(cursorID) < 0) {
+                const usage = summarizeMessages(entries, 0, 1, options);
+                const lastMsg = findLastCompletedAssistant(entries);
+                return {
+                    usage,
+                    cursor: {
+                        lastMessageId: lastMsg?.id,
+                        lastMessageTime: lastMsg?.time.completed ?? undefined,
+                        lastMessageIdsAtTime: lastMsg?.time.completed === undefined
+                            ? undefined
+                            : collectCompletedAssistantIdsAt(entries, lastMsg.time.completed),
+                    },
+                };
+            }
+        }
+    }
+    const isAfterCursor = (message) => {
+        const completed = message.time.completed;
+        if (typeof completed !== 'number' || !Number.isFinite(completed))
+            return false;
+        if (completed > cursorTime)
+            return true;
+        if (completed < cursorTime)
+            return false;
+        if (cursorIDsAtTime) {
+            return !cursorIDsAtTime.has(message.id);
+        }
+        // Same timestamp: best-effort tie-breaker.
+        return message.id.localeCompare(cursorID) > 0;
+    };
+    const newerThan = (left, right) => {
+        if (left.time !== right.time)
+            return left.time > right.time;
+        return left.id.localeCompare(right.id) > 0;
+    };
     let foundCursor = false;
-    let newCursor = { ...cursor };
+    let nextCursor = { ...cursor };
     for (const entry of entries) {
-        if (!isAssistant(entry.info))
+        const msg = entry.info;
+        if (!isAssistant(msg))
             continue;
-        if (!entry.info.time.completed)
+        if (typeof msg.time.completed !== 'number')
             continue;
-        // Skip messages we've already processed
-        if (!foundCursor) {
-            if (entry.info.id === cursor.lastMessageId) {
-                foundCursor = true;
-            }
+        if (!Number.isFinite(msg.time.completed))
             continue;
-        }
-        // Process new message
-        addMessageUsage(summary, entry.info, options);
-        newCursor = {
-            lastMessageId: entry.info.id,
-            lastMessageTime: entry.info.time.completed ?? undefined,
+        if (msg.id === cursorID)
+            foundCursor = true;
+        if (!isAfterCursor(msg))
+            continue;
+        addMessageUsage(summary, msg, options);
+        const candidate = { id: msg.id, time: msg.time.completed };
+        const current = {
+            id: nextCursor.lastMessageId || cursorID,
+            time: nextCursor.lastMessageTime ?? cursorTime,
         };
+        if (newerThan(candidate, current)) {
+            nextCursor = {
+                lastMessageId: msg.id,
+                lastMessageTime: msg.time.completed,
+                lastMessageIdsAtTime: [msg.id],
+            };
+        }
+        else if (nextCursor.lastMessageTime === msg.time.completed) {
+            const ids = new Set(nextCursor.lastMessageIdsAtTime || []);
+            ids.add(msg.id);
+            nextCursor.lastMessageIdsAtTime = Array.from(ids).sort();
+        }
     }
     // If we never found the cursor message, the history may have been modified.
     // Fall back to full rescan.
@@ -131,18 +211,50 @@ export function summarizeMessagesIncremental(entries, existingUsage, cursor, for
             cursor: {
                 lastMessageId: lastMsg?.id,
                 lastMessageTime: lastMsg?.time.completed ?? undefined,
+                lastMessageIdsAtTime: lastMsg?.time.completed === undefined
+                    ? undefined
+                    : collectCompletedAssistantIdsAt(entries, lastMsg.time.completed),
             },
         };
     }
-    return { usage: summary, cursor: newCursor };
+    return { usage: summary, cursor: nextCursor };
+}
+function collectCompletedAssistantIdsAt(entries, completedTime) {
+    const ids = [];
+    for (const entry of entries) {
+        const msg = entry.info;
+        if (!isAssistant(msg))
+            continue;
+        if (typeof msg.time.completed !== 'number')
+            continue;
+        if (!Number.isFinite(msg.time.completed))
+            continue;
+        if (msg.time.completed !== completedTime)
+            continue;
+        ids.push(msg.id);
+    }
+    return Array.from(new Set(ids)).sort();
 }
 function findLastCompletedAssistant(entries) {
-    for (let i = entries.length - 1; i >= 0; i--) {
-        const msg = entries[i].info;
-        if (isAssistant(msg) && msg.time.completed)
-            return msg;
+    let best;
+    let bestTime = -Infinity;
+    let bestID = '';
+    for (const entry of entries) {
+        const msg = entry.info;
+        if (!isAssistant(msg))
+            continue;
+        if (typeof msg.time.completed !== 'number')
+            continue;
+        if (!Number.isFinite(msg.time.completed))
+            continue;
+        const t = msg.time.completed;
+        if (t > bestTime || (t === bestTime && msg.id.localeCompare(bestID) > 0)) {
+            best = msg;
+            bestTime = t;
+            bestID = msg.id;
+        }
     }
-    return undefined;
+    return best;
 }
 export function mergeUsage(target, source) {
     target.input += source.input;
@@ -156,18 +268,7 @@ export function mergeUsage(target, source) {
     target.sessionCount += source.sessionCount;
     for (const provider of Object.values(source.providers)) {
         const existing = target.providers[provider.providerID] ||
-            {
-                providerID: provider.providerID,
-                input: 0,
-                output: 0,
-                reasoning: 0,
-                cacheRead: 0,
-                cacheWrite: 0,
-                total: 0,
-                cost: 0,
-                apiCost: 0,
-                assistantMessages: 0,
-            };
+            emptyProviderUsage(provider.providerID);
         existing.input += provider.input;
         existing.output += provider.output;
         existing.cacheRead += provider.cacheRead;

package/dist/usage_service.d.ts

@@ -0,0 +1,31 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import { type UsageSummary } from './usage.js';
+import type { QuotaSidebarConfig, QuotaSidebarState } from './types.js';
+type DescendantsResolver = {
+    listDescendantSessionIDs: (sessionID: string, opts: {
+        maxDepth: number;
+        maxSessions: number;
+        concurrency: number;
+    }) => Promise<string[]>;
+};
+type Persistence = {
+    markDirty: (dateKey: string | undefined) => void;
+    scheduleSave: () => void;
+    flushSave: () => Promise<void>;
+};
+export declare function createUsageService(deps: {
+    state: QuotaSidebarState;
+    config: QuotaSidebarConfig;
+    statePath: string;
+    client: PluginInput['client'];
+    directory: string;
+    persistence: Persistence;
+    descendantsResolver: DescendantsResolver;
+}): {
+    summarizeSessionUsageForDisplay: (sessionID: string, includeChildren: boolean) => Promise<UsageSummary>;
+    summarizeForTool: (period: "session" | "day" | "week" | "month", sessionID: string, includeChildren: boolean) => Promise<UsageSummary>;
+    markSessionDirty: (sessionID: string) => void;
+    markForceRescan: (sessionID: string) => void;
+    forgetSession: (sessionID: string) => void;
+};
+export {};