letmecode 0.1.0 → 0.1.1

package/ink-app/dist/index.js

@@ -1,17 +1,45 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React, { useEffect, useState } from "react";
 import { Box, Text, useApp, useInput, render } from "ink";
 import { createProviders } from "./providers/index.js";
 const VERTICAL_TABS = [
-    { id: "limit-windows", label: "Limit windows" },
-    { id: "usage-by-model", label: "Usage by model" }
+    { id: "limit-windows", label: "Limits" },
+    { id: "summary", label: "Summary" },
+    { id: "usage-by-model", label: "by model" }
 ];
+const CODEX_CREDIT_COST_USD = 0.01;
+const LIMIT_WINDOW_COLUMNS = {
+    plan: 8,
+    window: 8,
+    used: 10,
+    date: 17,
+    value: 10
+};
+const MODEL_USAGE_COLUMNS = {
+    model: 17,
+    input: 12,
+    cached: 12,
+    nonCached: 12,
+    output: 11,
+    credits: 12,
+    value: 12
+};
 function App() {
     const { exit } = useApp();
     const providers = React.useState(() => createProviders())[0];
     const [providerStates, setProviderStates] = useState(providers.map((provider) => ({ provider, status: "loading" })));
     const [selectedProviderIndex, setSelectedProviderIndex] = useState(0);
     const [selectedVerticalTabIndex, setSelectedVerticalTabIndex] = useState(0);
+    const [selectedLimitRowIndex, setSelectedLimitRowIndex] = useState(0);
+    const [selectedModelRowIndex, setSelectedModelRowIndex] = useState(0);
+    const selectedProvider = providerStates[selectedProviderIndex];
+    const selectedVerticalTab = VERTICAL_TABS[selectedVerticalTabIndex];
+    const limitRows = getLimitRows(selectedProvider);
+    const modelRows = getModelRows(selectedProvider);
+    const activeLimitRowIndex = clampSelectionIndex(selectedLimitRowIndex, limitRows.length);
+    const activeModelRowIndex = clampSelectionIndex(selectedModelRowIndex, modelRows.length);
+    const selectedLimitRow = activeLimitRowIndex >= 0 ? limitRows[activeLimitRowIndex] : undefined;
+    const selectedModelRow = activeModelRowIndex >= 0 ? modelRows[activeModelRowIndex] : undefined;
     useEffect(() => {
         let cancelled = false;
         for (const provider of providers) {
@@ -44,6 +72,26 @@ function App() {
             exit();
             return;
         }
+        if ((key.ctrl || key.shift) && key.downArrow) {
+            if (selectedVerticalTab.id === "limit-windows") {
+                setSelectedLimitRowIndex(clampSelectionIndex(activeLimitRowIndex + 1, limitRows.length));
+                return;
+            }
+            if (selectedVerticalTab.id === "usage-by-model") {
+                setSelectedModelRowIndex(clampSelectionIndex(activeModelRowIndex + 1, modelRows.length));
+                return;
+            }
+        }
+        if ((key.ctrl || key.shift) && key.upArrow) {
+            if (selectedVerticalTab.id === "limit-windows") {
+                setSelectedLimitRowIndex(clampSelectionIndex(activeLimitRowIndex - 1, limitRows.length));
+                return;
+            }
+            if (selectedVerticalTab.id === "usage-by-model") {
+                setSelectedModelRowIndex(clampSelectionIndex(activeModelRowIndex - 1, modelRows.length));
+                return;
+            }
+        }
         if ((input === "\t" && !key.shift) || key.rightArrow) {
             setSelectedProviderIndex((current) => (current + 1) % providerStates.length);
             return;
@@ -60,9 +108,7 @@ function App() {
             setSelectedVerticalTabIndex((current) => (current - 1 + VERTICAL_TABS.length) % VERTICAL_TABS.length);
         }
     });
-    const selectedProvider = providerStates[selectedProviderIndex];
-    const selectedVerticalTab = VERTICAL_TABS[selectedVerticalTabIndex];
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "letmecode usage dashboard" }), _jsx(Text, { color: "gray", children: "tab/shift+tab or left/right to switch providers, j/k or up/down for details, q to quit" }), _jsx(Box, { marginTop: 1, children: providerStates.map((state, index) => (_jsx(ProviderTab, { label: state.provider.label, active: index === selectedProviderIndex, status: state.status }, state.provider.id))) }), _jsx(Box, { marginTop: 1, borderStyle: "round", paddingX: 1, paddingY: 0, flexDirection: "column", children: _jsx(SummarySection, { providerState: selectedProvider }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Box, { flexDirection: "column", width: 22, marginRight: 2, children: VERTICAL_TABS.map((tab, index) => (_jsx(VerticalTab, { label: tab.label, active: index === selectedVerticalTabIndex }, tab.id))) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: _jsx(ContentPanel, { providerState: selectedProvider, tabId: selectedVerticalTab.id }) })] }), selectedProvider.status === "ready" && selectedProvider.stats.warnings.length > 0 ? (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "Warnings" }), selectedProvider.stats.warnings.map((warning) => (_jsx(Text, { children: warning }, warning)))] })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "letmecode usage dashboard" }), _jsx(Text, { color: "gray", children: "tab/shift+tab or left/right to switch providers, j/k or up/down for details, ctrl+up/down or shift+up/down to select a row, q to quit" }), _jsx(Box, { marginTop: 1, children: providerStates.map((state, index) => (_jsx(ProviderTab, { label: state.provider.label, active: index === selectedProviderIndex, status: state.status }, state.provider.id))) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Box, { flexDirection: "column", width: 12, marginRight: 2, children: VERTICAL_TABS.map((tab, index) => (_jsx(VerticalTab, { label: tab.label, active: index === selectedVerticalTabIndex }, tab.id))) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: _jsx(ContentPanel, { providerState: selectedProvider, tabId: selectedVerticalTab.id, selectedLimitRowKey: selectedLimitRow ? getLimitRowKey(selectedLimitRow) : undefined, selectedModelId: selectedModelRow?.modelId }) })] }), _jsx(SelectionDetailsPanel, { providerState: selectedProvider, tabId: selectedVerticalTab.id, selectedLimitRow: selectedLimitRow, selectedModelRow: selectedModelRow }), selectedProvider.status === "ready" && selectedProvider.stats.warnings.length > 0 ? (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "Warnings" }), selectedProvider.stats.warnings.map((warning) => (_jsx(Text, { children: warning }, warning)))] })) : null] }));
 }
 function ProviderTab(props) {
     const statusColor = props.status === "error" ? "red" : props.status === "loading" ? "yellow" : "green";
@@ -72,15 +118,10 @@ function ProviderTab(props) {
 function VerticalTab(props) {
     return (_jsx(Text, { inverse: props.active, children: props.active ? ` ${props.label} ` : ` ${props.label}` }));
 }
-function SummarySection(props) {
-    if (props.providerState.status === "loading") {
-        return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: props.providerState.provider.label }), _jsx(Text, { color: "yellow", children: "Loading stats from local sessions..." })] }));
-    }
-    if (props.providerState.status === "error") {
-        return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: props.providerState.provider.label }), _jsxs(Text, { color: "red", children: ["Failed to load provider stats: ", props.providerState.errorMessage] })] }));
-    }
-    const { summary } = props.providerState.stats;
-    return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: props.providerState.stats.providerLabel }), _jsxs(Text, { children: ["root: ", summary.rootLabel, " (", summary.rootPath, ")"] }), _jsxs(Text, { children: ["files: ", formatInteger(summary.filesScanned), "  lines: ", formatInteger(summary.linesRead), "  token events: ", formatInteger(summary.tokenEvents)] }), _jsxs(Text, { children: ["input: ", formatInteger(summary.totals.inputTokens), "  cached: ", formatInteger(summary.totals.cachedInputTokens), "  non-cached: ", formatInteger(summary.totals.nonCachedInputTokens)] }), _jsxs(Text, { children: ["output: ", formatInteger(summary.totals.outputTokens), "  reasoning: ", formatInteger(summary.totals.reasoningOutputTokens), "  total: ", formatInteger(summary.totals.totalTokens)] }), _jsxs(Text, { children: ["estimated credits: ", formatCredits(summary.totals.estimatedCredits), "  models: ", summary.distinctModels.join(", ") || "none", "  plans: ", summary.distinctPlanTypes.join(", ") || "none"] })] }));
+function SummaryPanel(props) {
+    const { summary } = props.stats;
+    const inputPerOutput = formatInputPerOutput(summary.totals);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: props.stats.providerLabel }), _jsxs(Text, { children: ["root: ", summary.rootLabel, " (", summary.rootPath, ")"] }), _jsxs(Text, { children: ["files: ", formatInteger(summary.filesScanned), "  lines: ", formatInteger(summary.linesRead), "  token events: ", formatInteger(summary.tokenEvents)] }), _jsxs(Text, { children: ["input: ", formatInteger(summary.totals.inputTokens), "  cached: ", formatInteger(summary.totals.cachedInputTokens), "  non-cached: ", formatInteger(summary.totals.nonCachedInputTokens)] }), _jsxs(Text, { children: ["output: ", formatInteger(summary.totals.outputTokens), "  reasoning: ", formatInteger(summary.totals.reasoningOutputTokens), "  total: ", formatInteger(summary.totals.totalTokens)] }), _jsxs(Text, { children: ["estimated credits: ", formatCredits(summary.totals.estimatedCredits)] }), _jsxs(Text, { children: ["IpO: ", inputPerOutput.cached, ":", inputPerOutput.nonCached, ":", inputPerOutput.output] }), _jsxs(Text, { children: ["models: ", summary.distinctModels.join(", ") || "none"] }), _jsxs(Text, { children: ["plans: ", summary.distinctPlanTypes.join(", ") || "none"] })] }));
 }
 function ContentPanel(props) {
     if (props.providerState.status === "loading") {
@@ -90,21 +131,25 @@ function ContentPanel(props) {
         return _jsxs(Text, { color: "red", children: ["Provider error: ", props.providerState.errorMessage] });
     }
     if (props.tabId === "limit-windows") {
-        return _jsx(LimitWindowsPanel, { stats: props.providerState.stats });
+        return _jsx(LimitWindowsPanel, { stats: props.providerState.stats, selectedRowKey: props.selectedLimitRowKey });
     }
-    return _jsx(UsageByModelPanel, { stats: props.providerState.stats });
+    if (props.tabId === "summary") {
+        return _jsx(SummaryPanel, { stats: props.providerState.stats });
+    }
+    return _jsx(UsageByModelPanel, { stats: props.providerState.stats, selectedModelId: props.selectedModelId });
 }
 function LimitWindowsPanel(props) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Primary" }), _jsx(LimitWindowSection, { windows: props.stats.primaryLimitWindows }), _jsx(Box, { marginTop: 1 }), _jsx(Text, { bold: true, children: "Secondary" }), _jsx(LimitWindowSection, { windows: props.stats.secondaryLimitWindows })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Primary" }), _jsx(LimitWindowSection, { windows: props.stats.primaryLimitWindows, selectedRowKey: props.selectedRowKey }), _jsx(Box, { marginTop: 1 }), _jsx(Text, { bold: true, children: "Secondary" }), _jsx(LimitWindowSection, { windows: props.stats.secondaryLimitWindows, selectedRowKey: props.selectedRowKey })] }));
 }
 function LimitWindowSection(props) {
     if (props.windows.length === 0) {
         return _jsx(Text, { color: "gray", children: "No windows found." });
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "gray", children: "plan       limit      window    used          start                end                  events" }), props.windows.map((window) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "gray", children: [pad("plan", LIMIT_WINDOW_COLUMNS.plan), " ", pad("window", LIMIT_WINDOW_COLUMNS.window), " ", pad("used", LIMIT_WINDOW_COLUMNS.used), " ", pad("start", LIMIT_WINDOW_COLUMNS.date), " ", pad("end", LIMIT_WINDOW_COLUMNS.date), " value"] }), props.windows.map((window) => {
                 const windowLabel = formatWindowMinutes(window.windowMinutes);
                 const usedLabel = `${window.minUsedPercent}%->${window.maxUsedPercent}%`;
-                return (_jsxs(Text, { children: [pad(window.planType, 10), " ", pad(window.limitId, 10), " ", pad(windowLabel, 8), " ", pad(usedLabel, 12), " ", pad(shortIso(window.startTimeIso), 20), " ", pad(shortIso(window.endTimeIso), 20), " ", formatInteger(window.eventCount)] }, `${window.scope}-${window.planType}-${window.limitId}-${window.endTimeIso}`));
+                const isSelected = props.selectedRowKey === getLimitRowKey(window);
+                return (_jsxs(Text, { inverse: isSelected, color: isSelected ? "cyan" : undefined, children: [pad(window.planType, LIMIT_WINDOW_COLUMNS.plan), " ", pad(windowLabel, LIMIT_WINDOW_COLUMNS.window), " ", pad(usedLabel, LIMIT_WINDOW_COLUMNS.used), " ", pad(formatLocalDateTime(window.startTimeUtcIso), LIMIT_WINDOW_COLUMNS.date), " ", pad(formatLocalDateTime(window.endTimeUtcIso), LIMIT_WINDOW_COLUMNS.date), " ", pad(formatUsd(window.totals.estimatedCredits * CODEX_CREDIT_COST_USD), LIMIT_WINDOW_COLUMNS.value)] }, getLimitRowKey(window)));
             })] }));
 }
 function UsageByModelPanel(props) {
@@ -112,7 +157,28 @@ function UsageByModelPanel(props) {
         return _jsx(Text, { color: "gray", children: "No model usage found." });
     }
     const totals = props.stats.summary.totals;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "gray", children: "model            input        cached       non-cached   output       credits      events" }), props.stats.modelUsage.map((row) => (_jsxs(Text, { children: [pad(row.modelId, 16), " ", pad(formatInteger(row.totals.inputTokens), 12), " ", pad(formatInteger(row.totals.cachedInputTokens), 12), " ", pad(formatInteger(row.totals.nonCachedInputTokens), 12), " ", pad(formatInteger(row.totals.outputTokens), 12), " ", pad(formatCredits(row.totals.estimatedCredits), 12), " ", pad(formatInteger(row.totals.eventCount), 8)] }, row.modelId))), _jsxs(Text, { color: "cyan", children: [pad("TOTAL", 16), " ", pad(formatInteger(totals.inputTokens), 12), " ", pad(formatInteger(totals.cachedInputTokens), 12), " ", pad(formatInteger(totals.nonCachedInputTokens), 12), " ", pad(formatInteger(totals.outputTokens), 12), " ", pad(formatCredits(totals.estimatedCredits), 12), " ", pad(formatInteger(totals.eventCount), 8)] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "gray", children: [pad("model", MODEL_USAGE_COLUMNS.model), " ", pad("input", MODEL_USAGE_COLUMNS.input), " ", pad("cached", MODEL_USAGE_COLUMNS.cached), " ", pad("non-cached", MODEL_USAGE_COLUMNS.nonCached), " ", pad("output", MODEL_USAGE_COLUMNS.output), " ", pad("credits", MODEL_USAGE_COLUMNS.credits), " value"] }), props.stats.modelUsage.map((row) => {
+                const isSelected = props.selectedModelId === row.modelId;
+                return (_jsxs(Text, { inverse: isSelected, color: isSelected ? "cyan" : undefined, children: [pad(row.modelId, MODEL_USAGE_COLUMNS.model), " ", pad(formatInteger(row.totals.inputTokens), MODEL_USAGE_COLUMNS.input), " ", pad(formatInteger(row.totals.cachedInputTokens), MODEL_USAGE_COLUMNS.cached), " ", pad(formatInteger(row.totals.nonCachedInputTokens), MODEL_USAGE_COLUMNS.nonCached), " ", pad(formatInteger(row.totals.outputTokens), MODEL_USAGE_COLUMNS.output), " ", pad(formatCredits(row.totals.estimatedCredits), MODEL_USAGE_COLUMNS.credits), " ", pad(formatUsd(row.totals.estimatedCredits * CODEX_CREDIT_COST_USD), MODEL_USAGE_COLUMNS.value)] }, row.modelId));
+            }), _jsxs(Text, { color: "cyan", children: [pad("TOTAL", MODEL_USAGE_COLUMNS.model), " ", pad(formatInteger(totals.inputTokens), MODEL_USAGE_COLUMNS.input), " ", pad(formatInteger(totals.cachedInputTokens), MODEL_USAGE_COLUMNS.cached), " ", pad(formatInteger(totals.nonCachedInputTokens), MODEL_USAGE_COLUMNS.nonCached), " ", pad(formatInteger(totals.outputTokens), MODEL_USAGE_COLUMNS.output), " ", pad(formatCredits(totals.estimatedCredits), MODEL_USAGE_COLUMNS.credits), " ", pad(formatUsd(totals.estimatedCredits * CODEX_CREDIT_COST_USD), MODEL_USAGE_COLUMNS.value)] })] }));
+}
+function SelectionDetailsPanel(props) {
+    if (props.providerState.status !== "ready") {
+        return null;
+    }
+    if (props.tabId === "limit-windows" && props.selectedLimitRow) {
+        const row = props.selectedLimitRow;
+        return (_jsxs(Box, { marginTop: 1, borderStyle: "round", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Limit details" }), _jsxs(Text, { children: [row.scope, "  plan: ", row.planType, "  window: ", formatWindowMinutes(row.windowMinutes), "  used: ", row.minUsedPercent, "%", "->", row.maxUsedPercent, "%  limit: ", row.limitId] }), _jsxs(Text, { children: ["range: ", formatLocalDateTime(row.startTimeUtcIso), " ", "->", " ", formatLocalDateTime(row.endTimeUtcIso), "  events: ", formatInteger(row.eventCount)] }), _jsx(UsageTotalsDetails, { totals: row.totals })] }));
+    }
+    if (props.tabId === "usage-by-model" && props.selectedModelRow) {
+        return (_jsxs(Box, { marginTop: 1, borderStyle: "round", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Model details" }), _jsxs(Text, { children: ["model: ", props.selectedModelRow.modelId, "  events: ", formatInteger(props.selectedModelRow.totals.eventCount)] }), _jsx(UsageTotalsDetails, { totals: props.selectedModelRow.totals })] }));
+    }
+    return null;
+}
+function UsageTotalsDetails(props) {
+    const { totals } = props;
+    const inputPerOutput = formatInputPerOutput(totals);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Total credits burned: ", formatCredits(totals.estimatedCredits)] }), _jsxs(Text, { children: ["Credits Value (@ $0.01/credit): ", formatUsd(totals.estimatedCredits * CODEX_CREDIT_COST_USD)] }), _jsxs(Text, { children: ["IpO: ", inputPerOutput.cached, ":", inputPerOutput.nonCached, ":", inputPerOutput.output] })] }));
 }
 function formatInteger(value) {
     return Math.round(value).toLocaleString("en-US");
@@ -123,6 +189,14 @@ function formatCredits(value) {
         maximumFractionDigits: 2
     });
 }
+function formatUsd(value) {
+    return value.toLocaleString("en-US", {
+        currency: "USD",
+        style: "currency",
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 4
+    });
+}
 function formatWindowMinutes(value) {
     const hours = value / 60;
     if (hours >= 24) {
@@ -130,12 +204,53 @@ function formatWindowMinutes(value) {
     }
     return `${hours.toFixed(2)}h`;
 }
-function shortIso(value) {
-    return value.replace(".000Z", "Z").slice(0, 19) + "Z";
+function formatLocalDateTime(value) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        month: "short",
+        day: "2-digit",
+        year: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+        hourCycle: "h23"
+    }).formatToParts(new Date(value));
+    const lookup = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+    return `${lookup.day} ${lookup.month} ${lookup.year} ${lookup.hour}:${lookup.minute}`;
 }
 function pad(value, length) {
     return value.length >= length ? value.slice(0, length) : value.padEnd(length);
 }
+function formatInputPerOutput(totals) {
+    if (totals.outputTokens <= 0) {
+        return { cached: "0", nonCached: "0", output: "0" };
+    }
+    return {
+        cached: formatInteger(Math.round(totals.cachedInputTokens / totals.outputTokens)),
+        nonCached: formatInteger(Math.round(totals.nonCachedInputTokens / totals.outputTokens)),
+        output: "1"
+    };
+}
+function clampSelectionIndex(value, rowCount) {
+    if (rowCount === 0) {
+        return -1;
+    }
+    return Math.max(0, Math.min(value, rowCount - 1));
+}
+function getLimitRows(providerState) {
+    if (providerState.status !== "ready") {
+        return [];
+    }
+    return [...providerState.stats.primaryLimitWindows, ...providerState.stats.secondaryLimitWindows];
+}
+function getModelRows(providerState) {
+    if (providerState.status !== "ready") {
+        return [];
+    }
+    return providerState.stats.modelUsage;
+}
+function getLimitRowKey(row) {
+    return `${row.scope}-${row.planType}-${row.limitId}-${row.startTimeUtcIso}-${row.endTimeUtcIso}`;
+}
 export function main() {
     render(_jsx(App, {}));
 }

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

@@ -0,0 +1,225 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
+import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
+const RATE_CARD = {
+    "claude-opus-4-8": { input: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
+    "claude-opus-4-7": { input: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
+    "claude-opus-4-6": { input: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
+    "claude-opus-4-5": { input: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
+    "claude-opus-4-1": { input: 1500, cacheWrite5m: 1875, cacheWrite1h: 3000, cacheRead: 150, output: 7500 },
+    "claude-opus-4": { input: 1500, cacheWrite5m: 1875, cacheWrite1h: 3000, cacheRead: 150, output: 7500 },
+    "claude-sonnet-4-6": { input: 300, cacheWrite5m: 375, cacheWrite1h: 600, cacheRead: 30, output: 1500 },
+    "claude-sonnet-4-5": { input: 300, cacheWrite5m: 375, cacheWrite1h: 600, cacheRead: 30, output: 1500 },
+    "claude-sonnet-4": { input: 300, cacheWrite5m: 375, cacheWrite1h: 600, cacheRead: 30, output: 1500 },
+    "claude-haiku-4-5": { input: 100, cacheWrite5m: 125, cacheWrite1h: 200, cacheRead: 10, output: 500 },
+    "claude-haiku-3-5": { input: 80, cacheWrite5m: 100, cacheWrite1h: 160, cacheRead: 8, output: 400 }
+};
+export class ClaudeUsageProvider extends UsageProviderBase {
+    constructor(options = {}) {
+        super("claude", "Claude");
+        this.root = path.resolve(options.root ?? os.homedir());
+    }
+    async getStats() {
+        const sessionsRoot = path.join(this.root, ".claude", "projects");
+        const byModel = new Map();
+        const windows = createLimitWindowAggregates();
+        const planTypes = new Set();
+        const warnings = [];
+        const seenUsageEvents = new Set();
+        const parseTotals = {
+            filesScanned: 0,
+            linesRead: 0,
+            tokenEvents: 0,
+            malformedLines: 0
+        };
+        for await (const file of walkSessionFiles(sessionsRoot)) {
+            parseTotals.filesScanned += 1;
+            const fileStats = await parseSessionFile(file, byModel, windows, planTypes, seenUsageEvents);
+            parseTotals.linesRead += fileStats.linesRead;
+            parseTotals.tokenEvents += fileStats.tokenEvents;
+            parseTotals.malformedLines += fileStats.malformedLines;
+        }
+        if (parseTotals.malformedLines > 0) {
+            warnings.push(`Skipped ${parseTotals.malformedLines} malformed JSONL line(s).`);
+        }
+        const modelUsage = [...byModel.entries()]
+            .map(([modelId, totals]) => ({ modelId, totals }))
+            .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+        const unknownPricedModels = modelUsage
+            .map((row) => row.modelId)
+            .filter((modelId) => !resolveRate(modelId));
+        if (unknownPricedModels.length > 0) {
+            warnings.push(`No credit rate configured for: ${unknownPricedModels.join(", ")}.`);
+        }
+        if (parseTotals.filesScanned === 0) {
+            warnings.push(`No Claude session files found under ${sessionsRoot}.`);
+        }
+        const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
+        const [primaryLimitWindows, secondaryLimitWindows] = buildWindowLists(windows);
+        if (parseTotals.filesScanned > 0 &&
+            parseTotals.tokenEvents > 0 &&
+            primaryLimitWindows.length === 0 &&
+            secondaryLimitWindows.length === 0) {
+            warnings.push("Claude transcripts did not expose rate-limit windows in the local logs.");
+        }
+        return {
+            providerId: this.id,
+            providerLabel: this.label,
+            summary: {
+                filesScanned: parseTotals.filesScanned,
+                linesRead: parseTotals.linesRead,
+                tokenEvents: parseTotals.tokenEvents,
+                totals: summaryTotals,
+                distinctModels: modelUsage.map((row) => row.modelId),
+                distinctPlanTypes: [...planTypes].sort(),
+                rootLabel: "~/.claude/projects",
+                rootPath: sessionsRoot
+            },
+            modelUsage,
+            primaryLimitWindows,
+            secondaryLimitWindows,
+            warnings
+        };
+    }
+}
+function normalizeUsage(value) {
+    const usage = asRecord(value) ?? {};
+    const cacheCreation = asRecord(usage.cache_creation);
+    const cacheCreation5mInputTokens = numberOrZero(cacheCreation?.ephemeral_5m_input_tokens);
+    const cacheCreation1hInputTokens = numberOrZero(cacheCreation?.ephemeral_1h_input_tokens);
+    const cacheCreationInputTokens = Math.max(numberOrZero(usage.cache_creation_input_tokens), cacheCreation5mInputTokens + cacheCreation1hInputTokens);
+    return {
+        inputTokens: numberOrZero(usage.input_tokens),
+        cacheReadInputTokens: numberOrZero(usage.cache_read_input_tokens),
+        cacheCreationInputTokens,
+        cacheCreation5mInputTokens,
+        cacheCreation1hInputTokens,
+        outputTokens: numberOrZero(usage.output_tokens),
+        inferenceGeo: String(usage.inference_geo ?? "")
+    };
+}
+function resolveRate(modelId) {
+    const candidates = Object.keys(RATE_CARD).sort((left, right) => right.length - left.length);
+    for (const candidate of candidates) {
+        if (modelId === candidate || modelId.startsWith(`${candidate}-`)) {
+            return RATE_CARD[candidate];
+        }
+    }
+    return undefined;
+}
+function creditsFor(modelId, usage) {
+    const rate = resolveRate(modelId);
+    if (!rate) {
+        return 0;
+    }
+    const cacheWriteKnownTokens = usage.cacheCreation5mInputTokens + usage.cacheCreation1hInputTokens;
+    const cacheWriteFallbackTokens = Math.max(0, usage.cacheCreationInputTokens - cacheWriteKnownTokens);
+    const inferenceMultiplier = usage.inferenceGeo === "us" ? 1.1 : 1;
+    return (((usage.inputTokens / 1000000) * rate.input +
+        (usage.cacheReadInputTokens / 1000000) * rate.cacheRead +
+        (usage.cacheCreation5mInputTokens / 1000000) * rate.cacheWrite5m +
+        (usage.cacheCreation1hInputTokens / 1000000) * rate.cacheWrite1h +
+        (cacheWriteFallbackTokens / 1000000) * rate.cacheWrite5m +
+        (usage.outputTokens / 1000000) * rate.output) *
+        inferenceMultiplier);
+}
+function usageToTotals(modelId, usage) {
+    const nonCachedInputTokens = usage.inputTokens + usage.cacheCreationInputTokens;
+    const cachedInputTokens = usage.cacheReadInputTokens;
+    return {
+        inputTokens: nonCachedInputTokens + cachedInputTokens,
+        cachedInputTokens,
+        nonCachedInputTokens,
+        outputTokens: usage.outputTokens,
+        reasoningOutputTokens: 0,
+        totalTokens: nonCachedInputTokens + cachedInputTokens + usage.outputTokens,
+        estimatedCredits: creditsFor(modelId, usage),
+        eventCount: 1
+    };
+}
+function addModelUsage(byModel, modelId, deltaTotals) {
+    const resolvedModelId = modelId || "unknown";
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
+    addUsageTotals(totals, deltaTotals);
+    byModel.set(resolvedModelId, totals);
+}
+function isSessionFile(filePath) {
+    return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.claude${path.sep}projects${path.sep}`);
+}
+async function* walkSessionFiles(directory) {
+    let entries;
+    try {
+        entries = await fs.promises.readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            yield* walkSessionFiles(fullPath);
+        }
+        else if (entry.isFile() && isSessionFile(fullPath)) {
+            yield fullPath;
+        }
+    }
+}
+async function parseSessionFile(filePath, byModel, windows, planTypes, seenUsageEvents) {
+    const stream = fs.createReadStream(filePath, { encoding: "utf8" });
+    const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let linesRead = 0;
+    let tokenEvents = 0;
+    let malformedLines = 0;
+    for await (const line of lineReader) {
+        linesRead += 1;
+        if (!line.trim()) {
+            continue;
+        }
+        let payloadObject;
+        try {
+            payloadObject = JSON.parse(line);
+        }
+        catch {
+            malformedLines += 1;
+            continue;
+        }
+        if (payloadObject.type !== "assistant") {
+            continue;
+        }
+        const message = asRecord(payloadObject.message);
+        const usage = asRecord(message?.usage);
+        if (!usage) {
+            continue;
+        }
+        const usageKey = buildUsageEventKey(payloadObject, message);
+        if (usageKey && seenUsageEvents.has(usageKey)) {
+            continue;
+        }
+        if (usageKey) {
+            seenUsageEvents.add(usageKey);
+        }
+        const modelId = String(message?.model ?? "unknown");
+        const deltaTotals = usageToTotals(modelId, normalizeUsage(usage));
+        addModelUsage(byModel, modelId, deltaTotals);
+        tokenEvents += 1;
+        const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
+        const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
+        applyRateLimits(windows, extractRateLimits(payloadObject, message), safeEventTimeMs, deltaTotals, planTypes);
+    }
+    return { linesRead, tokenEvents, malformedLines };
+}
+function buildUsageEventKey(payloadObject, message) {
+    const sessionId = String(payloadObject.sessionId ?? "");
+    const requestId = typeof payloadObject.requestId === "string" ? payloadObject.requestId : "";
+    const messageId = typeof message?.id === "string" ? message.id : "";
+    if (!requestId && !messageId) {
+        return null;
+    }
+    return `${sessionId}|${requestId || messageId}`;
+}
+function extractRateLimits(payloadObject, message) {
+    return asRecord(payloadObject.rate_limits) ?? asRecord(message?.rate_limits);
+}

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

@@ -2,7 +2,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
-import { UsageProviderBase, createEmptyUsageTotals } from "./contract.js";
+import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
+import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
 const RATE_CARD = {
     "gpt-5.5": { input: 125, cachedInput: 12.5, output: 750 },
     "gpt-5.4": { input: 62.5, cachedInput: 6.25, output: 375 },
@@ -16,7 +17,7 @@ export class CodexUsageProvider extends UsageProviderBase {
     async getStats() {
         const sessionsRoot = path.join(this.root, ".codex", "sessions");
         const byModel = new Map();
-        const windows = new Map();
+        const windows = createLimitWindowAggregates();
         const planTypes = new Set();
         const warnings = [];
         const parseTotals = {
@@ -78,9 +79,6 @@ function createEmptyRawUsage() {
         totalTokens: 0
     };
 }
-function numberOrZero(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
 function normalizeRawUsage(value) {
     const usage = value && typeof value === "object" ? value : {};
     return {
@@ -124,104 +122,19 @@ function rawUsageToTotals(usage) {
         eventCount: 0
     };
 }
-function addUsageTotals(target, source) {
-    target.inputTokens += source.inputTokens;
-    target.cachedInputTokens += source.cachedInputTokens;
-    target.nonCachedInputTokens += source.nonCachedInputTokens;
-    target.outputTokens += source.outputTokens;
-    target.reasoningOutputTokens += source.reasoningOutputTokens;
-    target.totalTokens += source.totalTokens;
-    target.estimatedCredits += source.estimatedCredits;
-    target.eventCount += source.eventCount;
-}
-function addModelUsage(byModel, modelId, usage) {
+function createUsageTotalsForModel(modelId, usage) {
     const resolvedModelId = modelId || "unknown";
-    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
     const deltaTotals = rawUsageToTotals(usage);
     deltaTotals.estimatedCredits = creditsFor(resolvedModelId, usage);
     deltaTotals.eventCount = 1;
+    return deltaTotals;
+}
+function addModelUsage(byModel, modelId, deltaTotals) {
+    const resolvedModelId = modelId || "unknown";
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
     addUsageTotals(totals, deltaTotals);
     byModel.set(resolvedModelId, totals);
 }
-function sumUsageTotals(rows) {
-    const totals = createEmptyUsageTotals();
-    for (const row of rows) {
-        addUsageTotals(totals, row);
-    }
-    return totals;
-}
-function formatIsoFromSeconds(seconds) {
-    return new Date(seconds * 1000).toISOString().replace(".000Z", "Z");
-}
-function formatIsoFromMilliseconds(milliseconds) {
-    return new Date(milliseconds).toISOString().replace(".000Z", "Z");
-}
-function makeWindowKey(scope, rateLimits, window) {
-    return [
-        scope,
-        String(rateLimits.limit_id ?? "unknown"),
-        String(rateLimits.plan_type ?? "unknown"),
-        numberOrZero(window.window_minutes),
-        Math.round(numberOrZero(window.resets_at) / 60)
-    ].join("|");
-}
-function upsertWindow(windows, scope, rateLimits, window, eventTimeMs) {
-    if (!window) {
-        return;
-    }
-    const windowMinutes = numberOrZero(window.window_minutes);
-    const resetsAt = numberOrZero(window.resets_at);
-    if (!windowMinutes || !resetsAt) {
-        return;
-    }
-    const startsAt = resetsAt - windowMinutes * 60;
-    const usedPercent = numberOrZero(window.used_percent);
-    const key = makeWindowKey(scope, rateLimits, window);
-    const existing = windows.get(key);
-    if (!existing) {
-        windows.set(key, {
-            scope,
-            limitId: String(rateLimits.limit_id ?? "unknown"),
-            planType: String(rateLimits.plan_type ?? "unknown"),
-            windowMinutes,
-            minStartsAt: startsAt,
-            maxResetsAt: resetsAt,
-            firstSeenMs: eventTimeMs,
-            lastSeenMs: eventTimeMs,
-            minUsedPercent: usedPercent,
-            maxUsedPercent: usedPercent,
-            eventCount: 1
-        });
-        return;
-    }
-    existing.minStartsAt = Math.min(existing.minStartsAt, startsAt);
-    existing.maxResetsAt = Math.max(existing.maxResetsAt, resetsAt);
-    existing.firstSeenMs = Math.min(existing.firstSeenMs, eventTimeMs);
-    existing.lastSeenMs = Math.max(existing.lastSeenMs, eventTimeMs);
-    existing.minUsedPercent = Math.min(existing.minUsedPercent, usedPercent);
-    existing.maxUsedPercent = Math.max(existing.maxUsedPercent, usedPercent);
-    existing.eventCount += 1;
-}
-function buildWindowLists(windows) {
-    const rows = [...windows.values()]
-        .map((window) => ({
-        scope: window.scope,
-        planType: window.planType,
-        limitId: window.limitId,
-        windowMinutes: window.windowMinutes,
-        startTimeIso: formatIsoFromSeconds(window.minStartsAt),
-        endTimeIso: formatIsoFromSeconds(window.maxResetsAt),
-        firstSeenIso: formatIsoFromMilliseconds(window.firstSeenMs),
-        lastSeenIso: formatIsoFromMilliseconds(window.lastSeenMs),
-        minUsedPercent: window.minUsedPercent,
-        maxUsedPercent: window.maxUsedPercent,
-        eventCount: window.eventCount
-    }))
-        .sort((left, right) => right.endTimeIso.localeCompare(left.endTimeIso));
-    const primary = rows.filter((row) => row.scope === "primary").slice(0, 5);
-    const secondary = rows.filter((row) => row.scope === "secondary").slice(0, 5);
-    return [primary, secondary];
-}
 function isSessionFile(filePath) {
     return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.codex${path.sep}sessions${path.sep}`);
 }
@@ -279,23 +192,17 @@ async function parseSessionFile(filePath, byModel, windows, planTypes) {
             continue;
         }
         const info = payload.info;
-        const rateLimits = payload.rate_limits;
         const totalUsage = normalizeRawUsage(info?.total_token_usage);
         const lastUsage = info?.last_token_usage;
         const usage = lastUsage ? normalizeRawUsage(lastUsage) : previousTotal ? subtractRawUsage(totalUsage, previousTotal) : totalUsage;
         previousTotal = totalUsage;
+        const resolvedModelId = currentModel || "unknown";
+        const deltaTotals = createUsageTotalsForModel(resolvedModelId, usage);
         tokenEvents += 1;
-        addModelUsage(byModel, currentModel, usage);
-        if (typeof rateLimits?.plan_type === "string") {
-            planTypes.add(rateLimits.plan_type);
-        }
+        addModelUsage(byModel, resolvedModelId, deltaTotals);
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
         const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
-        upsertWindow(windows, "primary", rateLimits ?? {}, asRecord(rateLimits?.primary), safeEventTimeMs);
-        upsertWindow(windows, "secondary", rateLimits ?? {}, asRecord(rateLimits?.secondary), safeEventTimeMs);
+        applyRateLimits(windows, asRecord(payload.rate_limits), safeEventTimeMs, deltaTotals, planTypes);
     }
     return { linesRead, tokenEvents, malformedLines };
 }
-function asRecord(value) {
-    return value && typeof value === "object" ? value : null;
-}

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

@@ -16,3 +16,20 @@ export function createEmptyUsageTotals() {
         eventCount: 0
     };
 }
+export function addUsageTotals(target, source) {
+    target.inputTokens += source.inputTokens;
+    target.cachedInputTokens += source.cachedInputTokens;
+    target.nonCachedInputTokens += source.nonCachedInputTokens;
+    target.outputTokens += source.outputTokens;
+    target.reasoningOutputTokens += source.reasoningOutputTokens;
+    target.totalTokens += source.totalTokens;
+    target.estimatedCredits += source.estimatedCredits;
+    target.eventCount += source.eventCount;
+}
+export function sumUsageTotals(rows) {
+    const totals = createEmptyUsageTotals();
+    for (const row of rows) {
+        addUsageTotals(totals, row);
+    }
+    return totals;
+}

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

@@ -1,6 +1,8 @@
+import { ClaudeUsageProvider } from "./claude.js";
 import { CodexUsageProvider } from "./codex.js";
 export function createProviders() {
-    return [new CodexUsageProvider()];
+    return [new CodexUsageProvider(), new ClaudeUsageProvider()];
 }
+export { ClaudeUsageProvider } from "./claude.js";
 export { CodexUsageProvider } from "./codex.js";
 export { UsageProviderBase } from "./contract.js";

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

@@ -0,0 +1,146 @@
+import { addUsageTotals, createEmptyUsageTotals } from "./contract.js";
+export function createLimitWindowAggregates() {
+    return new Map();
+}
+export function numberOrZero(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+export function asRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}
+export function applyRateLimits(windows, rateLimits, eventTimeMs, 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);
+}
+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
+    })))
+        .map((row) => ({
+        ...row,
+        eventCount: row.totals.eventCount
+    }))
+        .sort((left, right) => right.endTimeUtcIso.localeCompare(left.endTimeUtcIso));
+    const primary = rows.filter((row) => row.scope === "primary").slice(0, 5);
+    const secondary = rows.filter((row) => row.scope === "secondary").slice(0, 5);
+    return [primary, secondary];
+}
+function formatIsoFromSeconds(seconds) {
+    return new Date(seconds * 1000).toISOString().replace(".000Z", "Z");
+}
+function formatIsoFromMilliseconds(milliseconds) {
+    return new Date(milliseconds).toISOString().replace(".000Z", "Z");
+}
+function makeWindowKey(scope, rateLimits, window) {
+    return [
+        scope,
+        String(rateLimits.limit_id ?? "unknown"),
+        String(rateLimits.plan_type ?? "unknown"),
+        numberOrZero(window.window_minutes),
+        numberOrZero(window.resets_at)
+    ].join("|");
+}
+function collapseNearbyWindows(rows) {
+    const collapsed = new Map();
+    for (const row of rows) {
+        const key = [
+            row.scope,
+            row.limitId,
+            row.planType,
+            row.windowMinutes,
+            Math.round(Date.parse(row.endTimeUtcIso) / 60000)
+        ].join("|");
+        const existing = collapsed.get(key);
+        if (!existing) {
+            collapsed.set(key, {
+                ...row,
+                totals: { ...row.totals }
+            });
+            continue;
+        }
+        existing.startTimeUtcIso =
+            existing.startTimeUtcIso < row.startTimeUtcIso ? existing.startTimeUtcIso : row.startTimeUtcIso;
+        existing.endTimeUtcIso =
+            existing.endTimeUtcIso > row.endTimeUtcIso ? existing.endTimeUtcIso : row.endTimeUtcIso;
+        existing.firstSeenUtcIso =
+            existing.firstSeenUtcIso < row.firstSeenUtcIso ? existing.firstSeenUtcIso : row.firstSeenUtcIso;
+        existing.lastSeenUtcIso =
+            existing.lastSeenUtcIso > row.lastSeenUtcIso ? existing.lastSeenUtcIso : row.lastSeenUtcIso;
+        existing.minUsedPercent = Math.min(existing.minUsedPercent, row.minUsedPercent);
+        existing.maxUsedPercent = Math.max(existing.maxUsedPercent, row.maxUsedPercent);
+        addUsageTotals(existing.totals, row.totals);
+        existing.eventCount = existing.totals.eventCount;
+    }
+    return [...collapsed.values()];
+}
+function computeWindowTotals(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();
+    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);
+            if (sawBelowCap && event.usedPercent >= 100) {
+                isExhausted = true;
+            }
+        }
+    }
+    return totals;
+}
+function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, deltaTotals) {
+    if (!window) {
+        return;
+    }
+    const windowMinutes = numberOrZero(window.window_minutes);
+    const resetsAt = numberOrZero(window.resets_at);
+    if (!windowMinutes || !resetsAt) {
+        return;
+    }
+    const startsAt = resetsAt - windowMinutes * 60;
+    const usedPercent = numberOrZero(window.used_percent);
+    const key = makeWindowKey(scope, rateLimits, window);
+    const existing = windows.get(key);
+    if (!existing) {
+        windows.set(key, {
+            scope,
+            limitId: String(rateLimits.limit_id ?? "unknown"),
+            planType: String(rateLimits.plan_type ?? "unknown"),
+            windowMinutes,
+            minStartsAt: startsAt,
+            maxResetsAt: resetsAt,
+            firstSeenMs: eventTimeMs,
+            lastSeenMs: eventTimeMs,
+            minUsedPercent: usedPercent,
+            maxUsedPercent: usedPercent,
+            events: [{ eventTimeMs, usedPercent, totals: { ...deltaTotals } }]
+        });
+        return;
+    }
+    existing.minStartsAt = Math.min(existing.minStartsAt, startsAt);
+    existing.maxResetsAt = Math.max(existing.maxResetsAt, resetsAt);
+    existing.firstSeenMs = Math.min(existing.firstSeenMs, eventTimeMs);
+    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: { ...deltaTotals } });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letmecode",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Provider-based terminal usage dashboard for LetMeCode.",
   "author": "devforth.io",
   "license": "MIT",