letmecode 0.1.0 → 0.1.2

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

@@ -0,0 +1,380 @@
+import fs from "node:fs";
+import { applyEdits, modify, parse } from "jsonc-parser";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
+import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
+import { asRecord } from "./limits.js";
+const VSCODE_OTEL_SETTINGS = {
+    "github.copilot.chat.otel.enabled": true,
+    "github.copilot.chat.otel.exporterType": "file",
+    "github.copilot.chat.otel.captureContent": false
+};
+const RATE_CARD = {
+    "gpt-5-mini": { input: 25, cachedInput: 2.5, output: 200 },
+    "gpt-5.3-codex": { input: 175, cachedInput: 17.5, output: 1400 },
+    "gpt-5.4": { input: 250, cachedInput: 25, output: 1500 },
+    "gpt-5.4-mini": { input: 75, cachedInput: 7.5, output: 450 },
+    "gpt-5.4-nano": { input: 20, cachedInput: 2, output: 125 },
+    "gpt-5.5": { input: 500, cachedInput: 50, output: 3000 },
+    "claude-haiku-4-5": { input: 100, cachedInput: 10, cacheWrite: 125, output: 500 },
+    "claude-sonnet-4-5": { input: 300, cachedInput: 30, cacheWrite: 375, output: 1500 },
+    "claude-sonnet-4-6": { input: 300, cachedInput: 30, cacheWrite: 375, output: 1500 },
+    "claude-opus-4-5": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-opus-4-6": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-opus-4-7": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-opus-4-8": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
+    "claude-fable-5": { input: 1000, cachedInput: 100, cacheWrite: 1250, output: 5000 },
+    "gemini-2.5-pro": { input: 125, cachedInput: 12.5, output: 1000 },
+    "gemini-3-flash": { input: 50, cachedInput: 5, output: 300 },
+    "gemini-3.1-pro": { input: 200, cachedInput: 20, output: 1200 },
+    "gemini-3.5-flash": { input: 150, cachedInput: 15, output: 900 },
+    "mai-code-1-flash": { input: 75, cachedInput: 7.5, output: 450 },
+    "raptor-mini": { input: 25, cachedInput: 2.5, output: 200 }
+};
+const LONG_CONTEXT_RATE_CARD = {
+    "gpt-5.4": { thresholdInputTokens: 272000, input: 500, cachedInput: 50, output: 2250 },
+    "gpt-5.5": { thresholdInputTokens: 272000, input: 1000, cachedInput: 100, output: 4500 },
+    "gemini-3.1-pro": { thresholdInputTokens: 200000, input: 400, cachedInput: 40, output: 1800 }
+};
+const NON_BILLABLE_MODEL_PREFIXES = ["copilot-nes", "copilot-suggestion"];
+export class CopilotUsageProvider extends UsageProviderBase {
+    constructor(options = {}) {
+        super("copilot", "Copilot");
+        this.root = path.resolve(options.root ?? os.homedir());
+    }
+    async getStats() {
+        const vscodeOtelFile = getCopilotOtelPath(this.root);
+        const byModel = new Map();
+        const byDay = createDailyUsageAggregates();
+        const warnings = [];
+        const parseTotals = {
+            linesRead: 0,
+            tokenEvents: 0,
+            malformedLines: 0
+        };
+        const vscodeOtelFileExists = await isReadableFile(vscodeOtelFile);
+        if (vscodeOtelFileExists) {
+            const fileStats = await parseCopilotJsonlFile(vscodeOtelFile, byModel, byDay);
+            parseTotals.linesRead += fileStats.linesRead;
+            parseTotals.tokenEvents += fileStats.tokenEvents;
+            parseTotals.malformedLines += fileStats.malformedLines;
+        }
+        else if (await isCopilotVsCodeLoggingEnabled(this.root, vscodeOtelFile)) {
+            warnings.push(`VS Code Copilot logging is enabled, but ${vscodeOtelFile} has not been created yet. Reload VS Code and send a Copilot Chat request.`);
+        }
+        if (parseTotals.malformedLines > 0) {
+            warnings.push(`Skipped ${parseTotals.malformedLines} malformed Copilot JSONL line(s).`);
+        }
+        const filesScanned = vscodeOtelFileExists ? 1 : 0;
+        if (filesScanned === 0) {
+            warnings.push(`No Copilot VS Code OTEL usage file found at ${vscodeOtelFile}.`);
+        }
+        else if (parseTotals.tokenEvents === 0) {
+            warnings.push("No Copilot token usage events found. For VS Code, run Start logging VS Code and reload VS Code.");
+        }
+        const modelUsage = [...byModel.entries()]
+            .map(([modelId, totals]) => ({ modelId, totals }))
+            .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+        const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
+        if (summaryTotals.cacheStatus === "unavailable") {
+            warnings.push("Copilot cache token attributes are unavailable for some events; cached/non-cached tokens and estimated credits are shown as unknown.");
+        }
+        return {
+            providerId: this.id,
+            providerLabel: this.label,
+            summary: {
+                filesScanned,
+                linesRead: parseTotals.linesRead,
+                tokenEvents: parseTotals.tokenEvents,
+                totals: summaryTotals,
+                distinctModels: modelUsage.map((row) => row.modelId),
+                distinctPlanTypes: [],
+                rootLabel: "~/.copilot/otel/vscode.jsonl",
+                rootPath: vscodeOtelFile
+            },
+            modelUsage,
+            dayUsage: buildDailyUsageRows(byDay),
+            primaryLimitWindows: [],
+            secondaryLimitWindows: [],
+            warnings
+        };
+    }
+}
+export async function configureCopilotVsCodeLogging(options = {}) {
+    const root = path.resolve(options.root ?? os.homedir());
+    const outfile = getCopilotOtelPath(root);
+    const settingsPath = options.settingsPath ?? (await getVsCodeSettingsPath(root));
+    const settingsText = await readTextFileOrEmpty(settingsPath);
+    const { text, changed } = updateJsoncSettings(settingsText, {
+        ...VSCODE_OTEL_SETTINGS,
+        "github.copilot.chat.otel.outfile": toVsCodeOutfilePath(outfile)
+    });
+    await fs.promises.mkdir(path.dirname(settingsPath), { recursive: true });
+    await fs.promises.mkdir(path.dirname(outfile), { recursive: true });
+    if (changed) {
+        await fs.promises.writeFile(settingsPath, text, "utf8");
+    }
+    return { settingsPath, outfile, changed };
+}
+function getCopilotOtelPath(root) {
+    return path.join(root, ".copilot", "otel", "vscode.jsonl");
+}
+function toVsCodeOutfilePath(filePath) {
+    return process.platform === "win32" ? filePath.replace(/\\/g, "/") : filePath;
+}
+async function getVsCodeSettingsPath(root) {
+    const userRoots = getVsCodeUserRoots(root);
+    for (const userRoot of userRoots) {
+        if (await isDirectory(userRoot)) {
+            return path.join(userRoot, "settings.json");
+        }
+    }
+    return path.join(userRoots[0], "settings.json");
+}
+function getVsCodeUserRoots(root) {
+    if (process.platform === "darwin") {
+        const applicationSupport = path.join(root, "Library", "Application Support");
+        return [
+            path.join(applicationSupport, "Code", "User"),
+            path.join(applicationSupport, "Code - Insiders", "User")
+        ];
+    }
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA ?? path.join(root, "AppData", "Roaming");
+        return [path.join(appData, "Code", "User"), path.join(appData, "Code - Insiders", "User")];
+    }
+    const configRoot = path.join(root, ".config");
+    return [path.join(configRoot, "Code", "User"), path.join(configRoot, "Code - Insiders", "User")];
+}
+async function parseCopilotJsonlFile(filePath, byModel, byDay) {
+    const stream = fs.createReadStream(filePath, { encoding: "utf8" });
+    const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    const parseTotals = {
+        linesRead: 0,
+        tokenEvents: 0,
+        malformedLines: 0
+    };
+    for await (const line of lineReader) {
+        parseTotals.linesRead += 1;
+        if (!line.trim()) {
+            continue;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(line);
+        }
+        catch {
+            parseTotals.malformedLines += 1;
+            continue;
+        }
+        const event = extractCopilotUsageEvent(payload);
+        if (event) {
+            parseTotals.tokenEvents += 1;
+            addModelUsage(byModel, event.modelId, event.totals);
+            addDailyUsage(byDay, event.timestampMs, event.modelId, undefined, event.totals);
+        }
+    }
+    return parseTotals;
+}
+function extractCopilotUsageEvent(payload) {
+    const record = asRecord(payload);
+    if (!record) {
+        return null;
+    }
+    const attributes = asRecord(record.attributes);
+    if (!attributes || !isCopilotChatSpan(attributes)) {
+        return null;
+    }
+    const usage = usageFromAttributes(attributes);
+    if (!usage) {
+        return null;
+    }
+    const modelId = stringAttribute(attributes, "gen_ai.response.model") ?? "unknown";
+    const timestampMs = hrTimeToMs(record.hrTime) ?? Number.NaN;
+    return {
+        timestampMs,
+        modelId,
+        totals: createUsageTotals(modelId, usage)
+    };
+}
+function usageFromAttributes(attributes) {
+    const inputTokens = numberAttribute(attributes, "gen_ai.usage.input_tokens") ?? 0;
+    const outputTokens = numberAttribute(attributes, "gen_ai.usage.output_tokens") ?? 0;
+    const reasoningOutputTokens = numberAttribute(attributes, "gen_ai.usage.reasoning.output_tokens");
+    const cachedInputTokens = numberAttribute(attributes, "gen_ai.usage.cache_read.input_tokens");
+    const cacheCreationInputTokens = numberAttribute(attributes, "gen_ai.usage.cache_creation.input_tokens");
+    if (inputTokens <= 0 && outputTokens <= 0 && (reasoningOutputTokens ?? 0) <= 0) {
+        return null;
+    }
+    return {
+        inputTokens,
+        cachedInputTokens,
+        cacheCreationInputTokens,
+        outputTokens,
+        reasoningOutputTokens
+    };
+}
+function isCopilotChatSpan(attributes) {
+    return stringAttribute(attributes, "gen_ai.operation.name") === "chat";
+}
+function createUsageTotals(modelId, usage) {
+    const hasCacheInfo = usage.cachedInputTokens !== undefined || usage.cacheCreationInputTokens !== undefined;
+    const hasKnownCreditPricing = isNonBillableModel(modelId) || (hasCacheInfo && rateForModel(modelId, usage.inputTokens) !== undefined);
+    const cachedInputTokens = hasCacheInfo ? Math.min(usage.cachedInputTokens ?? 0, usage.inputTokens) : 0;
+    return {
+        inputTokens: usage.inputTokens,
+        cachedInputTokens,
+        nonCachedInputTokens: hasCacheInfo ? Math.max(0, usage.inputTokens - cachedInputTokens) : 0,
+        outputTokens: usage.outputTokens,
+        reasoningOutputTokens: Math.min(usage.reasoningOutputTokens ?? 0, usage.outputTokens),
+        totalTokens: usage.inputTokens + usage.outputTokens,
+        estimatedCredits: creditsFor(modelId, usage),
+        eventCount: 1,
+        cacheStatus: hasCacheInfo ? "known" : "unavailable",
+        estimatedCreditsStatus: hasKnownCreditPricing ? "known" : "unavailable"
+    };
+}
+function creditsFor(modelId, usage) {
+    if (isNonBillableModel(modelId)) {
+        return 0;
+    }
+    const rate = rateForModel(modelId, usage.inputTokens);
+    if (!rate) {
+        return 0;
+    }
+    if (usage.cachedInputTokens === undefined && usage.cacheCreationInputTokens === undefined) {
+        return 0;
+    }
+    const cacheRead = Math.min(usage.cachedInputTokens ?? 0, usage.inputTokens);
+    const cacheWrite = Math.min(usage.cacheCreationInputTokens ?? 0, Math.max(0, usage.inputTokens - cacheRead));
+    const regularInput = Math.max(0, usage.inputTokens - cacheRead - cacheWrite);
+    return ((regularInput / 1000000) * rate.input +
+        (cacheRead / 1000000) * rate.cachedInput +
+        (cacheWrite / 1000000) * (rate.cacheWrite ?? rate.input) +
+        (usage.outputTokens / 1000000) * rate.output);
+}
+function rateForModel(modelId, inputTokens) {
+    const candidates = Object.keys(RATE_CARD).sort((left, right) => right.length - left.length);
+    const model = candidates.find((candidate) => modelId === candidate || modelId.startsWith(`${candidate}-`));
+    if (!model) {
+        return undefined;
+    }
+    const longContextRate = LONG_CONTEXT_RATE_CARD[model];
+    if (longContextRate && inputTokens > longContextRate.thresholdInputTokens) {
+        return longContextRate;
+    }
+    return RATE_CARD[model];
+}
+function isNonBillableModel(modelId) {
+    return NON_BILLABLE_MODEL_PREFIXES.some((prefix) => modelId === prefix || modelId.startsWith(`${prefix}-`));
+}
+function addModelUsage(byModel, modelId, deltaTotals) {
+    const resolvedModelId = modelId || "unknown";
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
+    addUsageTotals(totals, deltaTotals);
+    byModel.set(resolvedModelId, totals);
+}
+function numberAttribute(attributes, key) {
+    const value = attributes[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    return undefined;
+}
+function stringAttribute(attributes, key) {
+    const value = attributes[key];
+    if (typeof value === "string" && value) {
+        return value;
+    }
+    return undefined;
+}
+function hrTimeToMs(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const [seconds, nanoseconds] = value;
+    if (typeof seconds !== "number" ||
+        !Number.isFinite(seconds) ||
+        typeof nanoseconds !== "number" ||
+        !Number.isFinite(nanoseconds)) {
+        return undefined;
+    }
+    return seconds * 1000 + nanoseconds / 1000000;
+}
+async function isReadableFile(filePath) {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(filePath) {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function isCopilotVsCodeLoggingEnabled(root, outfile) {
+    const settings = await readJsonSettings(await getVsCodeSettingsPath(root));
+    const configuredOutfile = settings["github.copilot.chat.otel.outfile"];
+    return (settings["github.copilot.chat.otel.enabled"] === true &&
+        settings["github.copilot.chat.otel.exporterType"] === "file" &&
+        typeof configuredOutfile === "string" &&
+        normalizeComparablePath(configuredOutfile) === normalizeComparablePath(toVsCodeOutfilePath(outfile)));
+}
+function normalizeComparablePath(filePath) {
+    const normalized = path.resolve(filePath).replace(/\\/g, "/");
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+async function readJsonSettings(filePath) {
+    return parseJsoncSettings(await readTextFileOrEmpty(filePath));
+}
+async function readTextFileOrEmpty(filePath) {
+    try {
+        return await fs.promises.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function parseJsoncSettings(raw) {
+    if (!raw.trim()) {
+        return {};
+    }
+    const parsed = parse(raw);
+    return asRecord(parsed) ?? {};
+}
+function updateJsoncSettings(raw, values) {
+    let text = raw.trim() ? raw : "{\n}";
+    let changed = false;
+    for (const [key, value] of Object.entries(values)) {
+        if (parseJsoncSettings(text)[key] === value) {
+            continue;
+        }
+        const edits = modify(text, [key], value, {
+            formattingOptions: {
+                eol: "\n",
+                insertSpaces: true,
+                tabSize: 4
+            }
+        });
+        if (edits.length > 0) {
+            text = applyEdits(text, edits);
+            changed = true;
+        }
+    }
+    if (changed && !text.endsWith("\n")) {
+        text += "\n";
+    }
+    return { text, changed };
+}

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

@@ -0,0 +1,64 @@
+import { addUsageTotals } from "./contract.js";
+export function createDailyUsageAggregates() {
+    return new Map();
+}
+export function addDailyUsage(rows, eventTimeMs, modelId, planType, deltaTotals) {
+    const { dayKey, sortTimeMs } = resolveDayBucket(eventTimeMs);
+    const resolvedModelId = modelId || "unknown";
+    const existing = rows.get(dayKey);
+    if (!existing) {
+        const models = new Set();
+        models.add(resolvedModelId);
+        const planTypes = new Set();
+        if (planType) {
+            planTypes.add(planType);
+        }
+        rows.set(dayKey, {
+            dayKey,
+            sortTimeMs,
+            firstEventMs: Number.isFinite(eventTimeMs) ? eventTimeMs : null,
+            lastEventMs: Number.isFinite(eventTimeMs) ? eventTimeMs : null,
+            totals: { ...deltaTotals },
+            models,
+            planTypes
+        });
+        return;
+    }
+    addUsageTotals(existing.totals, deltaTotals);
+    existing.models.add(resolvedModelId);
+    if (planType) {
+        existing.planTypes.add(planType);
+    }
+    if (Number.isFinite(eventTimeMs)) {
+        existing.sortTimeMs = Math.max(existing.sortTimeMs, sortTimeMs);
+        existing.firstEventMs =
+            existing.firstEventMs === null ? eventTimeMs : Math.min(existing.firstEventMs, eventTimeMs);
+        existing.lastEventMs =
+            existing.lastEventMs === null ? eventTimeMs : Math.max(existing.lastEventMs, eventTimeMs);
+    }
+}
+export function buildDailyUsageRows(rows) {
+    return [...rows.values()]
+        .sort((left, right) => right.sortTimeMs - left.sortTimeMs || right.dayKey.localeCompare(left.dayKey))
+        .map((row) => ({
+        dayKey: row.dayKey,
+        firstEventUtcIso: row.firstEventMs === null ? null : formatIsoFromMilliseconds(row.firstEventMs),
+        lastEventUtcIso: row.lastEventMs === null ? null : formatIsoFromMilliseconds(row.lastEventMs),
+        distinctModels: [...row.models].sort(),
+        distinctPlanTypes: [...row.planTypes].sort(),
+        totals: { ...row.totals }
+    }));
+}
+function resolveDayBucket(eventTimeMs) {
+    if (!Number.isFinite(eventTimeMs)) {
+        return { dayKey: "unknown", sortTimeMs: Number.NEGATIVE_INFINITY };
+    }
+    const dayKey = new Date(eventTimeMs).toISOString().slice(0, 10);
+    return {
+        dayKey,
+        sortTimeMs: Date.parse(`${dayKey}T00:00:00.000Z`)
+    };
+}
+function formatIsoFromMilliseconds(milliseconds) {
+    return new Date(milliseconds).toISOString().replace(".000Z", "Z");
+}

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

@@ -1,6 +1,10 @@
+import { ClaudeUsageProvider } from "./claude.js";
 import { CodexUsageProvider } from "./codex.js";
+import { CopilotUsageProvider } from "./copilot.js";
 export function createProviders() {
-    return [new CodexUsageProvider()];
+    return [new CodexUsageProvider(), new ClaudeUsageProvider(), new CopilotUsageProvider()];
 }
+export { ClaudeUsageProvider } from "./claude.js";
 export { CodexUsageProvider } from "./codex.js";
+export { CopilotUsageProvider, configureCopilotVsCodeLogging } from "./copilot.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.2",
   "description": "Provider-based terminal usage dashboard for LetMeCode.",
   "author": "devforth.io",
   "license": "MIT",
@@ -26,6 +26,7 @@
   ],
   "dependencies": {
     "ink": "4.4.1",
+    "jsonc-parser": "^3.3.1",
     "react": "18.3.1"
   },
   "devDependencies": {