letmecode 0.1.7 → 0.1.9

package/ink-app/dist/providers/claude.js

@@ -96,7 +96,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             const planType = typeof event.rateLimits?.plan_type === "string" ? event.rateLimits.plan_type : undefined;
             const safeEventTimeMs = Number.isFinite(event.timestampMs) ? event.timestampMs : 0;
             addDailyUsage(byDay, event.timestampMs, event.modelId, planType, event.totals);
-            applyRateLimits(windows, event.rateLimits, safeEventTimeMs, event.totals, planTypes);
+            applyRateLimits(windows, event.rateLimits, safeEventTimeMs, event.modelId, event.totals, planTypes);
         }
         parseTotals.tokenEvents = selectedEvents.length;
         if (parseTotals.malformedLines > 0) {
@@ -493,6 +493,12 @@ function describeUsageOutput(output) {
     }
     return output.trim() ? output : "<empty>";
 }
+function buildClaudeCommandEnvironment() {
+    return {
+        ...process.env,
+        TZ: "UTC"
+    };
+}
 async function buildLiveLimitWindows(options) {
     const [usageOutput, subscriptionType] = await Promise.all([
         readClaudeUsageCommandOutput(options.root, options.usageCommandKind, options.readUsageCommandOutput, options.traceLogger),
@@ -541,9 +547,10 @@ async function readClaudeAuthStatusOutput(root, usageCommandKind, override, trac
             return null;
         }
         try {
-            traceClaude(traceLogger, usageCommandKind, `Running auth status command with ${binaryPath}.`);
+            traceClaude(traceLogger, usageCommandKind, `Running auth status command with ${binaryPath} (TZ=UTC).`);
             const { stdout, stderr } = await execFileAsync(binaryPath, ["auth", "status"], {
                 encoding: "utf8",
+                env: buildClaudeCommandEnvironment(),
                 maxBuffer: 1024 * 1024,
                 timeout: 15000,
                 windowsHide: true
@@ -626,9 +633,10 @@ async function readClaudeUsageCommandOutput(root, usageCommandKind, override, tr
             return null;
         }
         try {
-            traceClaude(traceLogger, usageCommandKind, `Running /usage command with ${binaryPath}.`);
+            traceClaude(traceLogger, usageCommandKind, `Running /usage command with ${binaryPath} (TZ=UTC).`);
             const { stdout, stderr } = await execFileAsync(binaryPath, ["-p", "/usage"], {
                 encoding: "utf8",
+                env: buildClaudeCommandEnvironment(),
                 maxBuffer: 1024 * 1024,
                 timeout: 15000,
                 windowsHide: true
@@ -864,9 +872,19 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
         minUsedPercent: snapshot.usedPercent,
         maxUsedPercent: snapshot.usedPercent,
         totals,
+        modelUsage: buildModelUsageRowsForEvents(inWindowEvents),
         eventCount: totals.eventCount
     };
 }
+function buildModelUsageRowsForEvents(events) {
+    const byModel = new Map();
+    for (const event of events) {
+        addModelUsage(byModel, event.modelId, event.totals);
+    }
+    return [...byModel.entries()]
+        .map(([modelId, totals]) => ({ modelId, totals }))
+        .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+}
 function toUtcIso(value) {
     return new Date(value).toISOString().replace(".000Z", "Z");
 }

package/ink-app/dist/providers/codex.js

@@ -349,7 +349,7 @@ async function parseSessionFile(filePath, byModel, byDay, windows, planTypes, kn
         const rateLimits = asRecord(payload.rate_limits);
         const planType = typeof rateLimits?.plan_type === "string" ? rateLimits.plan_type : undefined;
         addDailyUsage(byDay, eventTimeMs, resolvedModelId, planType, deltaTotals);
-        applyRateLimits(windows, rateLimits, safeEventTimeMs, deltaTotals, planTypes);
+        applyRateLimits(windows, rateLimits, safeEventTimeMs, resolvedModelId, deltaTotals, planTypes);
     }
     return { linesRead, tokenEvents, malformedLines };
 }

package/ink-app/dist/providers/limits.js

@@ -8,31 +8,35 @@ export function numberOrZero(value) {
 export function asRecord(value) {
     return value && typeof value === "object" ? value : null;
 }
-export function applyRateLimits(windows, rateLimits, eventTimeMs, deltaTotals, planTypes) {
+export function applyRateLimits(windows, rateLimits, eventTimeMs, modelId, deltaTotals, planTypes) {
     if (!rateLimits) {
         return;
     }
     if (typeof rateLimits.plan_type === "string") {
         planTypes.add(rateLimits.plan_type);
     }
-    upsertWindow(windows, "primary", rateLimits, asRecord(rateLimits.primary), eventTimeMs, deltaTotals);
-    upsertWindow(windows, "secondary", rateLimits, asRecord(rateLimits.secondary), eventTimeMs, deltaTotals);
+    upsertWindow(windows, "primary", rateLimits, asRecord(rateLimits.primary), eventTimeMs, modelId, deltaTotals);
+    upsertWindow(windows, "secondary", rateLimits, asRecord(rateLimits.secondary), eventTimeMs, modelId, deltaTotals);
 }
 export function buildWindowLists(windows) {
-    const rows = collapseNearbyWindows([...windows.values()].map((window) => ({
-        scope: window.scope,
-        planType: window.planType,
-        limitId: window.limitId,
-        windowMinutes: window.windowMinutes,
-        startTimeUtcIso: formatIsoFromSeconds(window.minStartsAt),
-        endTimeUtcIso: formatIsoFromSeconds(window.maxResetsAt),
-        firstSeenUtcIso: formatIsoFromMilliseconds(window.firstSeenMs),
-        lastSeenUtcIso: formatIsoFromMilliseconds(window.lastSeenMs),
-        minUsedPercent: window.minUsedPercent,
-        maxUsedPercent: window.maxUsedPercent,
-        totals: computeWindowTotals(window.events),
-        eventCount: 0
-    })))
+    const rows = collapseNearbyWindows([...windows.values()].map((window) => {
+        const usage = computeWindowUsage(window.events);
+        return {
+            scope: window.scope,
+            planType: window.planType,
+            limitId: window.limitId,
+            windowMinutes: window.windowMinutes,
+            startTimeUtcIso: formatIsoFromSeconds(window.minStartsAt),
+            endTimeUtcIso: formatIsoFromSeconds(window.maxResetsAt),
+            firstSeenUtcIso: formatIsoFromMilliseconds(window.firstSeenMs),
+            lastSeenUtcIso: formatIsoFromMilliseconds(window.lastSeenMs),
+            minUsedPercent: window.minUsedPercent,
+            maxUsedPercent: window.maxUsedPercent,
+            totals: usage.totals,
+            modelUsage: usage.modelUsage,
+            eventCount: 0
+        };
+    }))
         .map((row) => ({
         ...row,
         eventCount: row.totals.eventCount
@@ -71,7 +75,11 @@ function collapseNearbyWindows(rows) {
         if (!existing) {
             collapsed.set(key, {
                 ...row,
-                totals: cloneUsageTotals(row.totals)
+                totals: cloneUsageTotals(row.totals),
+                modelUsage: row.modelUsage.map((entry) => ({
+                    modelId: entry.modelId,
+                    totals: cloneUsageTotals(entry.totals)
+                }))
             });
             continue;
         }
@@ -86,28 +94,34 @@ function collapseNearbyWindows(rows) {
         existing.minUsedPercent = Math.min(existing.minUsedPercent, row.minUsedPercent);
         existing.maxUsedPercent = Math.max(existing.maxUsedPercent, row.maxUsedPercent);
         addUsageTotals(existing.totals, row.totals);
+        existing.modelUsage = mergeModelUsageRows(existing.modelUsage, row.modelUsage);
         existing.eventCount = existing.totals.eventCount;
     }
     return [...collapsed.values()];
 }
-function computeWindowTotals(events) {
+function computeWindowUsage(events) {
     // Session files are not guaranteed to be parsed in timestamp order, so
     // saturation has to be applied after we sort the captured window events.
     const totals = createEmptyUsageTotals();
+    const byModel = new Map();
     let sawBelowCap = false;
     let isExhausted = false;
     for (const event of [...events].sort((left, right) => left.eventTimeMs - right.eventTimeMs)) {
         sawBelowCap || (sawBelowCap = event.usedPercent < 100);
         if (!isExhausted) {
             addUsageTotals(totals, event.totals);
+            addWindowModelUsage(byModel, event.modelId, event.totals);
             if (sawBelowCap && event.usedPercent >= 100) {
                 isExhausted = true;
             }
         }
     }
-    return totals;
+    return {
+        totals,
+        modelUsage: buildModelUsageRows(byModel)
+    };
 }
-function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, deltaTotals) {
+function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, modelId, deltaTotals) {
     if (!window) {
         return;
     }
@@ -132,7 +146,7 @@ function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, deltaTota
             lastSeenMs: eventTimeMs,
             minUsedPercent: usedPercent,
             maxUsedPercent: usedPercent,
-            events: [{ eventTimeMs, usedPercent, totals: cloneUsageTotals(deltaTotals) }]
+            events: [{ eventTimeMs, modelId, usedPercent, totals: cloneUsageTotals(deltaTotals) }]
         });
         return;
     }
@@ -142,5 +156,25 @@ function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, deltaTota
     existing.lastSeenMs = Math.max(existing.lastSeenMs, eventTimeMs);
     existing.minUsedPercent = Math.min(existing.minUsedPercent, usedPercent);
     existing.maxUsedPercent = Math.max(existing.maxUsedPercent, usedPercent);
-    existing.events.push({ eventTimeMs, usedPercent, totals: cloneUsageTotals(deltaTotals) });
+    existing.events.push({ eventTimeMs, modelId, usedPercent, totals: cloneUsageTotals(deltaTotals) });
+}
+function addWindowModelUsage(byModel, modelId, totals) {
+    const existing = byModel.get(modelId);
+    if (!existing) {
+        byModel.set(modelId, cloneUsageTotals(totals));
+        return;
+    }
+    addUsageTotals(existing, totals);
+}
+function buildModelUsageRows(byModel) {
+    return [...byModel.entries()]
+        .map(([modelId, totals]) => ({ modelId, totals }))
+        .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+}
+function mergeModelUsageRows(left, right) {
+    const byModel = new Map();
+    for (const row of [...left, ...right]) {
+        addWindowModelUsage(byModel, row.modelId, row.totals);
+    }
+    return buildModelUsageRows(byModel);
 }

package/ink-app/dist/reporting.js

@@ -37,25 +37,23 @@ function buildAnonymousUsageReport(stats, window, letmecodeVersion) {
         used_percents: resolveReportedUsedPercents(window),
         used_exhausted: window.maxUsedPercent >= 100,
         value_dollars: roundDollars(window.totals.estimatedCredits * CREDIT_TO_DOLLARS),
-        usage_raw: buildUsageRaw(stats.providerId, window),
+        usage_raw: buildUsageRaw(window.modelUsage),
         letmecode_version: letmecodeVersion
     };
 }
-function buildUsageRaw(providerId, window) {
-    const usageRaw = {
-        output: window.totals.outputTokens,
-        input_non_cache: window.totals.inputTokens,
-        input_cache_read: window.totals.cacheReadInputTokens
-    };
-    if (isAnthropicProvider(providerId)) {
-        usageRaw.input_cache_w5m = window.totals.cacheWrite5mInputTokens;
-        usageRaw.input_cache_w1h = window.totals.cacheWrite1hInputTokens;
+function buildUsageRaw(modelUsage) {
+    const usageRaw = {};
+    for (const row of modelUsage) {
+        usageRaw[row.modelId] = {
+            output: row.totals.outputTokens,
+            input_non_cache: row.totals.inputTokens,
+            input_cache_w5m: row.totals.cacheWrite5mInputTokens,
+            input_cache_w1h: row.totals.cacheWrite1hInputTokens,
+            input_cache_read: row.totals.cacheReadInputTokens
+        };
     }
     return usageRaw;
 }
-function isAnthropicProvider(providerId) {
-    return providerId === "claude" || providerId === "claude-vscode";
-}
 function resolveReportedUsedPercents(window) {
     if (window.minUsedPercent === window.maxUsedPercent) {
         return clampPercent(window.maxUsedPercent);

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "letmecode",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Provider-based terminal usage dashboard for LetMeCode.",
   "author": "devforth.io",
   "license": "MIT",
+  "packageManager": "pnpm@10.28.2",
   "type": "commonjs",
   "bin": {
     "letmecode": "./bin/letmecode.js"
@@ -20,6 +21,16 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true }); require('node:fs').rmSync('ink-app/dist', { recursive: true, force: true });\"",
+    "build": "npm run clean && tsc -p tsconfig.json && tsc -p ink-app/tsconfig.json",
+    "prepack": "npm run build",
+    "prestart": "npm run build",
+    "start": "node ./bin/letmecode.js",
+    "pretest": "npm run build",
+    "smoke": "node ./bin/letmecode.js",
+    "test": "node --test ink-app/test/*.test.mjs"
+  },
   "keywords": [
     "cli",
     "ink",
@@ -36,14 +47,5 @@
     "@types/node": "^24.0.7",
     "@types/react": "^18.3.24",
     "typescript": "^5.8.3"
-  },
-  "scripts": {
-    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true }); require('node:fs').rmSync('ink-app/dist', { recursive: true, force: true });\"",
-    "build": "npm run clean && tsc -p tsconfig.json && tsc -p ink-app/tsconfig.json",
-    "prestart": "npm run build",
-    "start": "node ./bin/letmecode.js",
-    "pretest": "npm run build",
-    "smoke": "node ./bin/letmecode.js",
-    "test": "node --test ink-app/test/*.test.mjs"
   }
-}
+}