sidekick-shared 0.24.5 → 0.26.0

package/dist/usage/usageReports.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Daily, weekly, monthly, and per-session usage rows bucketed from usage
+ * events by the time of each event, so a session that crosses midnight is
+ * split across the days it actually ran in. Browser-safe: no Node imports.
+ *
+ * @module usage/usageReports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.weekKey = weekKey;
+exports.usageBucketKey = usageBucketKey;
+exports.bucketUsage = bucketUsage;
+exports.summarizeUsageRows = summarizeUsageRows;
+const costProvenance_1 = require("../aggregation/costProvenance");
+const formatting_1 = require("../formatting");
+function dayParts(ms, utc) {
+    const date = new Date(ms);
+    return utc
+        ? {
+            year: date.getUTCFullYear(),
+            month: date.getUTCMonth(),
+            day: date.getUTCDate(),
+            weekday: date.getUTCDay(),
+        }
+        : {
+            year: date.getFullYear(),
+            month: date.getMonth(),
+            day: date.getDate(),
+            weekday: date.getDay(),
+        };
+}
+function pad(value) {
+    return String(value).padStart(2, '0');
+}
+/** The `YYYY-MM-DD` key of the week containing `ms`, starting on `weekStartsOn`. */
+function weekKey(ms, options = {}) {
+    const utc = options.utc ?? false;
+    const start = options.weekStartsOn ?? 1;
+    const parts = dayParts(ms, utc);
+    const offset = (parts.weekday - start + 7) % 7;
+    if (utc) {
+        return new Date(Date.UTC(parts.year, parts.month, parts.day - offset))
+            .toISOString()
+            .slice(0, 10);
+    }
+    return (0, formatting_1.formatLocalDateKey)(new Date(parts.year, parts.month, parts.day - offset));
+}
+/** The time key for one event at the requested granularity. */
+function usageBucketKey(event, options) {
+    const utc = options.utc ?? false;
+    switch (options.granularity) {
+        case 'session':
+            return event.sessionId;
+        case 'week':
+            return weekKey(event.timestamp, { utc, weekStartsOn: options.weekStartsOn });
+        case 'month': {
+            const parts = dayParts(event.timestamp, utc);
+            return `${parts.year}-${pad(parts.month + 1)}`;
+        }
+        case 'day':
+        default:
+            return utc
+                ? new Date(event.timestamp).toISOString().slice(0, 10)
+                : (0, formatting_1.formatLocalDateKey)(event.timestamp);
+    }
+}
+function emptyTokens() {
+    return { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0 };
+}
+function addTokens(target, source) {
+    target.inputTokens += source.inputTokens;
+    target.outputTokens += source.outputTokens;
+    target.cacheWriteTokens += source.cacheWriteTokens;
+    target.cacheReadTokens += source.cacheReadTokens;
+}
+/**
+ * Group usage events into rows. Rows are sorted by key (sessions by first
+ * event), then provider, project, and model, so tables read oldest first.
+ */
+function bucketUsage(events, options) {
+    const groupBy = new Set(options.groupBy ?? ['provider']);
+    const isSession = options.granularity === 'session';
+    const byProvider = isSession || groupBy.has('provider');
+    const byProject = isSession || groupBy.has('project');
+    const byModel = groupBy.has('model');
+    const buckets = new Map();
+    for (const event of events) {
+        const key = usageBucketKey(event, options);
+        const provider = byProvider ? event.provider : null;
+        const project = byProject ? event.project : null;
+        const model = byModel ? event.model : null;
+        const id = [key, provider ?? '', project ?? '', model ?? ''].join('|');
+        let acc = buckets.get(id);
+        if (!acc) {
+            acc = {
+                row: {
+                    key,
+                    granularity: options.granularity,
+                    provider,
+                    project,
+                    model,
+                    sessionId: isSession ? event.sessionId : null,
+                    models: [],
+                    calls: 0,
+                    sessions: 0,
+                    tokens: emptyTokens(),
+                    totalTokens: 0,
+                    costUsd: 0,
+                    costProvenance: 'none',
+                    unpricedCalls: 0,
+                    firstTimestamp: event.timestamp,
+                    lastTimestamp: event.timestamp,
+                },
+                sessionIds: new Set(),
+                modelTokens: new Map(),
+                reportedCalls: 0,
+                estimatedCalls: 0,
+            };
+            buckets.set(id, acc);
+        }
+        const { row } = acc;
+        row.calls += 1;
+        addTokens(row.tokens, event.tokens);
+        row.totalTokens += event.tokens.totalTokens;
+        row.firstTimestamp = Math.min(row.firstTimestamp, event.timestamp);
+        row.lastTimestamp = Math.max(row.lastTimestamp, event.timestamp);
+        acc.sessionIds.add(event.sessionId);
+        acc.modelTokens.set(event.model, (acc.modelTokens.get(event.model) ?? 0) + event.tokens.totalTokens);
+        if (event.costUsd !== null) {
+            row.costUsd += event.costUsd;
+            if (event.costProvenance === 'provider-reported')
+                acc.reportedCalls += 1;
+            else
+                acc.estimatedCalls += 1;
+        }
+        else {
+            row.unpricedCalls += 1;
+        }
+    }
+    const rows = [];
+    for (const acc of buckets.values()) {
+        acc.row.sessions = acc.sessionIds.size;
+        acc.row.models = [...acc.modelTokens.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([model]) => model);
+        acc.row.costProvenance = (0, costProvenance_1.classifyCostProvenance)({
+            reportedCalls: acc.reportedCalls,
+            estimatedCalls: acc.estimatedCalls,
+            unpricedCalls: acc.row.unpricedCalls,
+        });
+        rows.push(acc.row);
+    }
+    return rows.sort((a, b) => (isSession ? a.firstTimestamp - b.firstTimestamp : a.key.localeCompare(b.key)) ||
+        (a.provider ?? '').localeCompare(b.provider ?? '') ||
+        (a.project ?? '').localeCompare(b.project ?? '') ||
+        (a.model ?? '').localeCompare(b.model ?? ''));
+}
+/**
+ * Sum rows that do not overlap (for example every row of one `bucketUsage`
+ * call). Pass the events too when rows are not per-session, so distinct
+ * sessions are counted once instead of once per row they appear in.
+ */
+function summarizeUsageRows(rows, events) {
+    const totals = {
+        calls: 0,
+        sessions: 0,
+        tokens: emptyTokens(),
+        totalTokens: 0,
+        costUsd: 0,
+        costProvenance: 'none',
+        unpricedCalls: 0,
+    };
+    let reportedCalls = 0;
+    let estimatedCalls = 0;
+    const sessionIds = new Set();
+    for (const row of rows) {
+        totals.calls += row.calls;
+        addTokens(totals.tokens, row.tokens);
+        totals.totalTokens += row.totalTokens;
+        totals.costUsd += row.costUsd;
+        totals.unpricedCalls += row.unpricedCalls;
+        const priced = row.calls - row.unpricedCalls;
+        if (row.costProvenance === 'reported')
+            reportedCalls += priced;
+        else if (row.costProvenance === 'estimated')
+            estimatedCalls += priced;
+        else if (row.costProvenance === 'mixed') {
+            reportedCalls += 1;
+            estimatedCalls += 1;
+        }
+        if (row.sessionId)
+            sessionIds.add(row.sessionId);
+    }
+    if (events) {
+        for (const event of events)
+            sessionIds.add(event.sessionId);
+        totals.sessions = sessionIds.size;
+    }
+    else {
+        totals.sessions = sessionIds.size || rows.reduce((sum, row) => sum + row.sessions, 0);
+    }
+    totals.costProvenance = (0, costProvenance_1.classifyCostProvenance)({
+        reportedCalls,
+        estimatedCalls,
+        unpricedCalls: totals.unpricedCalls,
+    });
+    return totals;
+}

package/dist/watchers/factory.d.ts

@@ -9,6 +9,12 @@ export interface CreateWatcherOptions {
     sessionId?: string;
     callbacks: SessionWatcherCallbacks;
 }
+/**
+ * Resolve the session a command should act on: an exact or unique-prefix
+ * match of `sessionId` among the workspace's sessions, or the most recent
+ * session when no id is given. Throws with the available ids on a miss.
+ */
+export declare function resolveSessionPath(provider: SessionProviderBase, workspacePath: string, sessionId?: string): string;
 export declare function createWatcher(options: CreateWatcherOptions): {
     watcher: SessionWatcher;
     sessionPath: string;

package/dist/watchers/factory.js

@@ -36,6 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSessionPath = resolveSessionPath;
 exports.createWatcher = createWatcher;
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -48,37 +49,41 @@ function getOpenCodeDataDir() {
         return path.join(xdg, 'opencode');
     return path.join(os.homedir(), '.local', 'share', 'opencode');
 }
-function createWatcher(options) {
-    const { provider, workspacePath, sessionId, callbacks } = options;
+/**
+ * Resolve the session a command should act on: an exact or unique-prefix
+ * match of `sessionId` among the workspace's sessions, or the most recent
+ * session when no id is given. Throws with the available ids on a miss.
+ */
+function resolveSessionPath(provider, workspacePath, sessionId) {
     const sessions = provider.findAllSessions(workspacePath);
     if (sessions.length === 0) {
         throw new Error(`No sessions found for ${provider.displayName} in ${workspacePath}`);
     }
-    let sessionPath;
-    if (sessionId) {
-        const matches = sessions.map((sessionPath) => ({
-            sessionPath,
-            id: provider.getSessionId(sessionPath),
-        }));
-        const exact = matches.filter((candidate) => candidate.id === sessionId);
-        const candidates = exact.length > 0 ? exact : matches.filter((candidate) => candidate.id.startsWith(sessionId));
-        if (candidates.length === 0) {
-            throw new Error(`Session ${sessionId} not found. Available: ${sessions
-                .slice(0, 5)
-                .map((s) => path.basename(s))
-                .join(', ')}`);
-        }
-        if (candidates.length > 1) {
-            throw new Error(`Session ${sessionId} is ambiguous. Matches: ${candidates
-                .slice(0, 5)
-                .map((candidate) => candidate.id)
-                .join(', ')}`);
-        }
-        sessionPath = candidates[0].sessionPath;
+    if (!sessionId)
+        return sessions[0]; // most recent
+    const matches = sessions.map((sessionPath) => ({
+        sessionPath,
+        id: provider.getSessionId(sessionPath),
+    }));
+    const exact = matches.filter((candidate) => candidate.id === sessionId);
+    const candidates = exact.length > 0 ? exact : matches.filter((candidate) => candidate.id.startsWith(sessionId));
+    if (candidates.length === 0) {
+        throw new Error(`Session ${sessionId} not found. Available: ${sessions
+            .slice(0, 5)
+            .map((s) => path.basename(s))
+            .join(', ')}`);
     }
-    else {
-        sessionPath = sessions[0]; // most recent
+    if (candidates.length > 1) {
+        throw new Error(`Session ${sessionId} is ambiguous. Matches: ${candidates
+            .slice(0, 5)
+            .map((candidate) => candidate.id)
+            .join(', ')}`);
     }
+    return candidates[0].sessionPath;
+}
+function createWatcher(options) {
+    const { provider, workspacePath, sessionId, callbacks } = options;
+    const sessionPath = resolveSessionPath(provider, workspacePath, sessionId);
     const watcher = createWatcherForProvider(provider, sessionPath, callbacks);
     return { watcher, sessionPath };
 }

package/dist/zaiQuotaApi.d.ts

@@ -29,5 +29,7 @@ export interface ZaiQuotaResolveOptions extends ZaiQuotaApiOptions {
 export declare function readZaiCredentials(options?: ReadZaiCredentialsOptions): ZaiCredentials | null;
 export declare function quotaStateFromZaiQuotaLimitPayload(payload: unknown, capturedAt?: string): QuotaState;
 export declare function fetchZaiQuotaFromApi(options?: ZaiQuotaApiOptions): Promise<QuotaState>;
+/** Stamp a z.ai quota sample with its runtime provider, projections, and window labels. */
+export declare function enrichZaiQuota(state: QuotaState): ProviderQuotaState<'zai'>;
 export declare function resolveZaiQuota(options?: ZaiQuotaResolveOptions): Promise<ProviderQuotaState<'zai'>>;
 export {};

package/dist/zaiQuotaApi.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readZaiCredentials = readZaiCredentials;
 exports.quotaStateFromZaiQuotaLimitPayload = quotaStateFromZaiQuotaLimitPayload;
 exports.fetchZaiQuotaFromApi = fetchZaiQuotaFromApi;
+exports.enrichZaiQuota = enrichZaiQuota;
 exports.resolveZaiQuota = resolveZaiQuota;
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
@@ -245,6 +246,7 @@ async function fetchZaiQuotaFromApi(options = {}) {
         clearTimeout(timeout);
     }
 }
+/** Stamp a z.ai quota sample with its runtime provider, projections, and window labels. */
 function enrichZaiQuota(state) {
     const withProjections = (0, quota_1.withQuotaProjections)(state);
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sidekick-shared",
-  "version": "0.24.5",
+  "version": "0.26.0",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "keywords": [
     "claude-code",
@@ -35,42 +35,62 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
       "default": "./dist/index.js"
     },
     "./browser": {
       "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js",
+      "require": "./dist/browser.js",
       "default": "./dist/browser.js"
     },
     "./node": {
       "types": "./dist/node.d.ts",
+      "import": "./dist/node.js",
+      "require": "./dist/node.js",
       "default": "./dist/node.js"
     },
     "./schemas": {
       "types": "./dist/schemas/index.d.ts",
+      "import": "./dist/schemas/index.js",
+      "require": "./dist/schemas/index.js",
       "default": "./dist/schemas/index.js"
     },
     "./phrases": {
       "types": "./dist/phrases.d.ts",
+      "import": "./dist/phrases.js",
+      "require": "./dist/phrases.js",
       "default": "./dist/phrases.js"
     },
     "./modelContext": {
       "types": "./dist/modelContext.d.ts",
+      "import": "./dist/modelContext.js",
+      "require": "./dist/modelContext.js",
       "default": "./dist/modelContext.js"
     },
     "./modelInfo": {
       "types": "./dist/modelInfo.d.ts",
+      "import": "./dist/modelInfo.js",
+      "require": "./dist/modelInfo.js",
       "default": "./dist/modelInfo.js"
     },
     "./formatting": {
       "types": "./dist/formatting.d.ts",
+      "import": "./dist/formatting.js",
+      "require": "./dist/formatting.js",
       "default": "./dist/formatting.js"
     },
     "./statusline": {
       "types": "./dist/statusline/index.d.ts",
+      "import": "./dist/statusline/index.js",
+      "require": "./dist/statusline/index.js",
       "default": "./dist/statusline/index.js"
     },
     "./dist/*": {
       "types": "./dist/*.d.ts",
+      "import": "./dist/*.js",
+      "require": "./dist/*.js",
       "default": "./dist/*.js"
     },
     "./package.json": "./package.json"
@@ -131,6 +151,7 @@
     "prettier": "3.8.4",
     "typescript": "^5.7.0",
     "typescript-eslint": "^8.0.0",
+    "vite": "^8.1.0",
     "vitest": "^4.1.9"
   },
   "license": "MIT",