agent-usage-report 0.1.0

package/dist/src/generator.js

@@ -0,0 +1,1417 @@
+import { existsSync, readdirSync } from "node:fs";
+import { readFile, readdir, writeFile } from "node:fs/promises";
+import { homedir, platform as osPlatform, release as osRelease } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MILLION = 1_000_000;
+const REPORT_SCHEMA_VERSION = 2;
+const DEFAULT_TIMEZONE = "America/Mexico_City";
+const DEFAULT_PROVIDER_ID = "codex";
+const DEFAULT_PROVIDER_LABEL = "Codex CLI";
+const DEFAULT_PROVIDER_SHORT_LABEL = "Codex";
+const CLAUDE_PROVIDER_ID = "claude";
+const CLAUDE_PROVIDER_LABEL = "Claude Code";
+const CLAUDE_PROVIDER_SHORT_LABEL = "Claude";
+const OPENCODE_PROVIDER_ID = "opencode";
+const OPENCODE_PROVIDER_LABEL = "Open Code";
+const OPENCODE_PROVIDER_SHORT_LABEL = "OpenCode";
+const PI_PROVIDER_ID = "pi";
+const PI_PROVIDER_LABEL = "Pi Coding Agent";
+const PI_PROVIDER_SHORT_LABEL = "Pi";
+const COMBINED_PROVIDER_ID = "all";
+const COMBINED_PROVIDER_LABEL = "All Providers";
+const COMBINED_PROVIDER_SHORT_LABEL = "All";
+const LEGACY_FALLBACK_MODEL = "gpt-5";
+const LITELLM_PRICING_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+const MODEL_ALIASES = {
+    "gpt-5-codex": "gpt-5",
+    "gpt-5.3-codex": "gpt-5.2-codex",
+};
+const MODEL_PREFIXES = [
+    "openai/",
+    "azure/",
+    "openrouter/openai/",
+    "chatgpt/",
+];
+const FREE_MODEL_PRICING = {
+    inputCostPerMToken: 0,
+    cachedInputCostPerMToken: 0,
+    outputCostPerMToken: 0,
+};
+const BUILTIN_MODEL_PRICING = {
+    "gpt-5": { inputCostPerMToken: 1.25, cachedInputCostPerMToken: 0.125, outputCostPerMToken: 10 },
+    "gpt-5.1-codex": { inputCostPerMToken: 1.25, cachedInputCostPerMToken: 0.125, outputCostPerMToken: 10 },
+    "gpt-5.1-codex-max": { inputCostPerMToken: 1.25, cachedInputCostPerMToken: 0.125, outputCostPerMToken: 10 },
+    "gpt-5.1-codex-mini": { inputCostPerMToken: 0.25, cachedInputCostPerMToken: 0.025, outputCostPerMToken: 2 },
+    "gpt-5.2": { inputCostPerMToken: 1.75, cachedInputCostPerMToken: 0.175, outputCostPerMToken: 14 },
+    "gpt-5.2-codex": { inputCostPerMToken: 1.75, cachedInputCostPerMToken: 0.175, outputCostPerMToken: 14 },
+    "gpt-5.3-codex": { inputCostPerMToken: 1.75, cachedInputCostPerMToken: 0.175, outputCostPerMToken: 14 },
+    "gpt-5.4": { inputCostPerMToken: 2.5, cachedInputCostPerMToken: 0.25, outputCostPerMToken: 15 },
+};
+const SCAN_OUTPUT_KEYS = [
+    "filesScanned",
+    "jsonlFilesScanned",
+    "jsonFilesScanned",
+    "parseErrors",
+    "nullInfoEventsSkipped",
+    "duplicateEventsSkipped",
+    "syntheticEventsSkipped",
+    "zeroTotalEventsSkipped",
+    "tokenEventsCounted",
+    "unsupportedLegacyFiles",
+    "activityOnlyDays",
+];
+function createEmptyUsageTotals() {
+    return {
+        input_tokens: 0,
+        cached_input_tokens: 0,
+        output_tokens: 0,
+        reasoning_output_tokens: 0,
+        total_tokens: 0,
+    };
+}
+function createEmptyDailyUsage() {
+    return {
+        ...createEmptyUsageTotals(),
+        events: 0,
+        model_usage: {},
+    };
+}
+function createEmptyScanStats() {
+    return {
+        filesScanned: 0,
+        jsonlFilesScanned: 0,
+        jsonFilesScanned: 0,
+        parseErrors: 0,
+        nullInfoEventsSkipped: 0,
+        duplicateEventsSkipped: 0,
+        syntheticEventsSkipped: 0,
+        zeroTotalEventsSkipped: 0,
+        tokenEventsCounted: 0,
+        unsupportedLegacyFiles: 0,
+        activityOnlyDays: 0,
+    };
+}
+function asNonEmptyString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed === "" ? null : trimmed;
+}
+function toNumber(value, fallback = 0) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function parseIsoTimestamp(value) {
+    if (!value)
+        return null;
+    const normalized = value.replace("Z", "+00:00");
+    const parsed = new Date(normalized);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function parseFlexibleTimestamp(value) {
+    if (typeof value === "string")
+        return parseIsoTimestamp(value);
+    if (typeof value === "number" && Number.isFinite(value)) {
+        const numeric = Math.abs(value) >= 1_000_000_000_000 ? value / 1000 : value;
+        const parsed = new Date(numeric * 1000);
+        return Number.isNaN(parsed.getTime()) ? null : parsed;
+    }
+    return null;
+}
+function dayKeyInTimezone(date, timeZone) {
+    return new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).format(date);
+}
+function addUsage(map, dayKey, usage, model, isFallbackModel = false) {
+    const entry = map.get(dayKey) ?? createEmptyDailyUsage();
+    entry.input_tokens += usage.input_tokens;
+    entry.cached_input_tokens += usage.cached_input_tokens;
+    entry.output_tokens += usage.output_tokens;
+    entry.reasoning_output_tokens += usage.reasoning_output_tokens;
+    entry.total_tokens += usage.total_tokens;
+    entry.events += 1;
+    if (model) {
+        const modelEntry = entry.model_usage[model] ??
+            {
+                ...createEmptyUsageTotals(),
+                events: 0,
+                is_fallback_model: false,
+            };
+        modelEntry.input_tokens += usage.input_tokens;
+        modelEntry.cached_input_tokens += usage.cached_input_tokens;
+        modelEntry.output_tokens += usage.output_tokens;
+        modelEntry.reasoning_output_tokens += usage.reasoning_output_tokens;
+        modelEntry.total_tokens += usage.total_tokens;
+        modelEntry.events += 1;
+        modelEntry.is_fallback_model = modelEntry.is_fallback_model || isFallbackModel;
+        entry.model_usage[model] = modelEntry;
+    }
+    map.set(dayKey, entry);
+}
+function normalizeCodexUsage(raw) {
+    const usage = typeof raw === "object" && raw !== null ? raw : {};
+    const input_tokens = Math.trunc(toNumber(usage.input_tokens));
+    const cached_input_tokens = Math.trunc(toNumber(usage.cached_input_tokens, toNumber(usage.cache_read_input_tokens)));
+    const output_tokens = Math.trunc(toNumber(usage.output_tokens));
+    const reasoning_output_tokens = Math.trunc(toNumber(usage.reasoning_output_tokens));
+    const total_tokens = Math.trunc(toNumber(usage.total_tokens));
+    return {
+        input_tokens,
+        cached_input_tokens,
+        output_tokens,
+        reasoning_output_tokens,
+        total_tokens: total_tokens > 0 ? total_tokens : input_tokens + output_tokens,
+    };
+}
+function normalizeClaudeUsage(raw) {
+    const usage = typeof raw === "object" && raw !== null ? raw : {};
+    const cacheRead = Math.trunc(toNumber(usage.cache_read_input_tokens));
+    const cacheCreation = Math.trunc(toNumber(usage.cache_creation_input_tokens));
+    const input_tokens = Math.trunc(toNumber(usage.input_tokens)) + cacheRead;
+    const output_tokens = Math.trunc(toNumber(usage.output_tokens)) + cacheCreation;
+    return {
+        input_tokens,
+        cached_input_tokens: cacheRead,
+        output_tokens,
+        reasoning_output_tokens: 0,
+        total_tokens: input_tokens + output_tokens,
+    };
+}
+function normalizePiUsage(raw) {
+    const usage = typeof raw === "object" && raw !== null ? raw : {};
+    const cacheRead = Math.trunc(toNumber(usage.cacheRead));
+    const cacheWrite = Math.trunc(toNumber(usage.cacheWrite));
+    const input_tokens = Math.trunc(toNumber(usage.input)) + cacheRead;
+    const output_tokens = Math.trunc(toNumber(usage.output)) + cacheWrite;
+    const total_tokens = Math.trunc(toNumber(usage.totalTokens));
+    return {
+        input_tokens,
+        cached_input_tokens: cacheRead,
+        output_tokens,
+        reasoning_output_tokens: 0,
+        total_tokens: total_tokens > 0 ? total_tokens : input_tokens + output_tokens,
+    };
+}
+function normalizeOpenCodeUsage(raw) {
+    const tokens = typeof raw === "object" && raw !== null ? raw : {};
+    const cache = typeof tokens.cache === "object" && tokens.cache !== null ? tokens.cache : {};
+    const cacheRead = Math.trunc(toNumber(cache.read));
+    const cacheWrite = Math.trunc(toNumber(cache.write));
+    const input_tokens = Math.trunc(toNumber(tokens.input)) + cacheRead;
+    const output_tokens = Math.trunc(toNumber(tokens.output)) + cacheWrite;
+    return {
+        input_tokens,
+        cached_input_tokens: cacheRead,
+        output_tokens,
+        reasoning_output_tokens: 0,
+        total_tokens: input_tokens + output_tokens,
+    };
+}
+function addUsageTotals(base, delta) {
+    return {
+        input_tokens: (base?.input_tokens ?? 0) + delta.input_tokens,
+        cached_input_tokens: (base?.cached_input_tokens ?? 0) + delta.cached_input_tokens,
+        output_tokens: (base?.output_tokens ?? 0) + delta.output_tokens,
+        reasoning_output_tokens: (base?.reasoning_output_tokens ?? 0) + delta.reasoning_output_tokens,
+        total_tokens: (base?.total_tokens ?? 0) + delta.total_tokens,
+    };
+}
+function subtractUsageTotals(current, previous) {
+    return {
+        input_tokens: Math.max(current.input_tokens - (previous?.input_tokens ?? 0), 0),
+        cached_input_tokens: Math.max(current.cached_input_tokens - (previous?.cached_input_tokens ?? 0), 0),
+        output_tokens: Math.max(current.output_tokens - (previous?.output_tokens ?? 0), 0),
+        reasoning_output_tokens: Math.max(current.reasoning_output_tokens - (previous?.reasoning_output_tokens ?? 0), 0),
+        total_tokens: Math.max(current.total_tokens - (previous?.total_tokens ?? 0), 0),
+    };
+}
+function didUsageTotalsRollback(current, previous) {
+    if (!previous)
+        return false;
+    return (current.input_tokens < previous.input_tokens ||
+        current.cached_input_tokens < previous.cached_input_tokens ||
+        current.output_tokens < previous.output_tokens ||
+        current.reasoning_output_tokens < previous.reasoning_output_tokens ||
+        current.total_tokens < previous.total_tokens);
+}
+function isSyntheticUsage(usage) {
+    return (usage.total_tokens > 0 &&
+        usage.input_tokens === 0 &&
+        usage.cached_input_tokens === 0 &&
+        usage.output_tokens === 0 &&
+        usage.reasoning_output_tokens === 0);
+}
+function modelLookupCandidates(model) {
+    const trimmed = model.trim();
+    const candidates = [trimmed];
+    if (!MODEL_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) {
+        for (const prefix of MODEL_PREFIXES)
+            candidates.push(`${prefix}${trimmed}`);
+    }
+    return candidates;
+}
+function hasNonZeroPricing(pricing) {
+    if (!pricing)
+        return false;
+    return ["input_cost_per_token", "output_cost_per_token", "cache_read_input_token_cost"].some((field) => Number(pricing[field] ?? 0) > 0);
+}
+function toPerMillion(value, fallback) {
+    const source = value ?? fallback ?? 0;
+    return Number(source) * MILLION;
+}
+function isOpenRouterFreeModel(model) {
+    const normalized = model.trim().toLowerCase();
+    return normalized === "openrouter/free" || (normalized.startsWith("openrouter/") && normalized.endsWith(":free"));
+}
+export async function fetchLiteLLMPricingDataset() {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 20_000);
+    try {
+        const response = await fetch(LITELLM_PRICING_URL, { signal: controller.signal });
+        if (!response.ok)
+            throw new Error(`Failed to fetch pricing: ${response.status}`);
+        const raw = await response.json();
+        if (!raw || typeof raw !== "object")
+            return {};
+        return raw;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export function resolveModelPricing(model, dataset) {
+    if (isOpenRouterFreeModel(model)) {
+        return {
+            requestedModel: model,
+            resolvedModel: model,
+            pricing: { ...FREE_MODEL_PRICING },
+            isMissing: false,
+            isAlias: false,
+            source: "free-route",
+        };
+    }
+    const ds = dataset ?? {};
+    for (const candidate of modelLookupCandidates(model)) {
+        const pricing = ds[candidate];
+        if (pricing && hasNonZeroPricing(pricing)) {
+            return {
+                requestedModel: model,
+                resolvedModel: candidate,
+                pricing: {
+                    inputCostPerMToken: toPerMillion(pricing.input_cost_per_token),
+                    cachedInputCostPerMToken: toPerMillion(pricing.cache_read_input_token_cost, pricing.input_cost_per_token),
+                    outputCostPerMToken: toPerMillion(pricing.output_cost_per_token),
+                },
+                isMissing: false,
+                isAlias: candidate !== model,
+                source: "litellm-live",
+            };
+        }
+    }
+    const alias = MODEL_ALIASES[model];
+    if (alias) {
+        for (const candidate of modelLookupCandidates(alias)) {
+            const pricing = ds[candidate];
+            if (pricing && hasNonZeroPricing(pricing)) {
+                return {
+                    requestedModel: model,
+                    resolvedModel: candidate,
+                    pricing: {
+                        inputCostPerMToken: toPerMillion(pricing.input_cost_per_token),
+                        cachedInputCostPerMToken: toPerMillion(pricing.cache_read_input_token_cost, pricing.input_cost_per_token),
+                        outputCostPerMToken: toPerMillion(pricing.output_cost_per_token),
+                    },
+                    isMissing: false,
+                    isAlias: true,
+                    source: "litellm-alias",
+                };
+            }
+        }
+    }
+    const builtin = BUILTIN_MODEL_PRICING[model] ?? (alias ? BUILTIN_MODEL_PRICING[alias] : undefined);
+    if (builtin) {
+        return {
+            requestedModel: model,
+            resolvedModel: alias ?? model,
+            pricing: { ...builtin },
+            isMissing: false,
+            isAlias: Boolean(alias),
+            source: "builtin-fallback",
+        };
+    }
+    return {
+        requestedModel: model,
+        resolvedModel: null,
+        pricing: { ...FREE_MODEL_PRICING },
+        isMissing: true,
+        isAlias: false,
+        source: "missing",
+    };
+}
+export function calculateCostBreakdown(usage, pricing) {
+    const cachedInput = Math.min(usage.cached_input_tokens, usage.input_tokens);
+    const nonCachedInput = Math.max(usage.input_tokens - cachedInput, 0);
+    const outputTokens = usage.output_tokens;
+    const inputUSD = (nonCachedInput / MILLION) * pricing.inputCostPerMToken;
+    const cachedInputUSD = (cachedInput / MILLION) * pricing.cachedInputCostPerMToken;
+    const outputUSD = (outputTokens / MILLION) * pricing.outputCostPerMToken;
+    return {
+        inputUSD,
+        cachedInputUSD,
+        outputUSD,
+        totalUSD: inputUSD + cachedInputUSD + outputUSD,
+    };
+}
+async function listFilesRecursive(root, suffix) {
+    const results = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (entry.isFile() && fullPath.endsWith(suffix)) {
+                results.push(fullPath);
+            }
+        }
+    }
+    await walk(root);
+    results.sort();
+    return results;
+}
+async function scanCodexProvider(codexHome, includeArchived, timeZone) {
+    const dailyUsage = new Map();
+    const displayValuesByDay = new Map();
+    const stats = createEmptyScanStats();
+    const roots = [join(codexHome, "sessions")];
+    if (includeArchived)
+        roots.push(join(codexHome, "archived_sessions"));
+    for (const root of roots) {
+        if (!existsSync(root))
+            continue;
+        const files = [
+            ...(await listFilesRecursive(root, ".jsonl")),
+            ...(await listFilesRecursive(root, ".json")),
+        ].sort();
+        for (const file of files) {
+            stats.filesScanned += 1;
+            if (file.endsWith(".jsonl")) {
+                stats.jsonlFilesScanned += 1;
+                await processCodexJsonlFile(file, dailyUsage, stats, timeZone);
+            }
+            else {
+                stats.jsonFilesScanned += 1;
+                await processLegacyJsonFile(file, stats);
+            }
+        }
+    }
+    return {
+        providerId: DEFAULT_PROVIDER_ID,
+        providerLabel: DEFAULT_PROVIDER_LABEL,
+        providerShortLabel: DEFAULT_PROVIDER_SHORT_LABEL,
+        sourceHome: codexHome,
+        dailyUsage,
+        displayValuesByDay,
+        stats,
+    };
+}
+async function processCodexJsonlFile(filePath, dailyUsage, stats, timeZone) {
+    const content = await readFile(filePath, "utf8");
+    let currentModel = null;
+    let currentModelIsFallback = false;
+    let previousTotals = null;
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line === "")
+            continue;
+        if (!line.includes('"type":"turn_context"') && !line.includes('"type":"event_msg"'))
+            continue;
+        if (!line.includes('"type":"token_count"') && !line.includes('"type":"turn_context"'))
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            stats.parseErrors += 1;
+            continue;
+        }
+        const recordType = record.type;
+        const payload = typeof record.payload === "object" && record.payload !== null ? record.payload : {};
+        const extractedModel = extractCodexModel(payload);
+        if (recordType === "turn_context") {
+            if (extractedModel) {
+                currentModel = extractedModel;
+                currentModelIsFallback = false;
+            }
+            continue;
+        }
+        if (recordType !== "event_msg" || payload.type !== "token_count")
+            continue;
+        const info = typeof payload.info === "object" && payload.info !== null ? payload.info : null;
+        if (!info) {
+            stats.nullInfoEventsSkipped += 1;
+            continue;
+        }
+        const lastUsage = normalizeCodexUsage(info.last_token_usage);
+        const totalUsage = normalizeCodexUsage(info.total_token_usage);
+        let rawUsage = null;
+        if (totalUsage.total_tokens > 0) {
+            rawUsage = didUsageTotalsRollback(totalUsage, previousTotals)
+                ? lastUsage
+                : subtractUsageTotals(totalUsage, previousTotals);
+            previousTotals = totalUsage;
+        }
+        else if (lastUsage.total_tokens > 0) {
+            rawUsage = lastUsage;
+            previousTotals = addUsageTotals(previousTotals, rawUsage);
+        }
+        if (!rawUsage || rawUsage.total_tokens <= 0) {
+            stats.zeroTotalEventsSkipped += 1;
+            continue;
+        }
+        if (isSyntheticUsage(rawUsage)) {
+            stats.syntheticEventsSkipped += 1;
+            continue;
+        }
+        const timestamp = parseFlexibleTimestamp(record.timestamp);
+        if (!timestamp) {
+            stats.parseErrors += 1;
+            continue;
+        }
+        let eventModel = extractedModel ?? currentModel;
+        let isFallbackModel = false;
+        if (extractedModel) {
+            currentModel = extractedModel;
+            currentModelIsFallback = false;
+        }
+        else if (eventModel == null) {
+            eventModel = LEGACY_FALLBACK_MODEL;
+            isFallbackModel = true;
+            currentModel = eventModel;
+            currentModelIsFallback = true;
+        }
+        else if (currentModelIsFallback) {
+            isFallbackModel = true;
+        }
+        addUsage(dailyUsage, dayKeyInTimezone(timestamp, timeZone), rawUsage, eventModel, isFallbackModel);
+        stats.tokenEventsCounted += 1;
+    }
+}
+function extractCodexModel(payload) {
+    const direct = asNonEmptyString(payload.model) ?? asNonEmptyString(payload.model_name);
+    if (direct)
+        return direct;
+    const info = typeof payload.info === "object" && payload.info !== null ? payload.info : null;
+    if (info) {
+        const infoModel = asNonEmptyString(info.model) ?? asNonEmptyString(info.model_name);
+        if (infoModel)
+            return infoModel;
+        const metadata = typeof info.metadata === "object" && info.metadata !== null ? info.metadata : null;
+        if (metadata) {
+            const metadataModel = asNonEmptyString(metadata.model);
+            if (metadataModel)
+                return metadataModel;
+        }
+    }
+    const metadata = typeof payload.metadata === "object" && payload.metadata !== null ? payload.metadata : null;
+    return metadata ? asNonEmptyString(metadata.model) : null;
+}
+async function processLegacyJsonFile(filePath, stats) {
+    const content = await readFile(filePath, "utf8");
+    try {
+        const parsed = JSON.parse(content);
+        if (typeof parsed !== "object" || parsed == null || (!("usage" in parsed) && !("token_usage" in parsed))) {
+            stats.unsupportedLegacyFiles += 1;
+        }
+    }
+    catch {
+        stats.parseErrors += 1;
+    }
+}
+function discoverClaudeWorkDirs() {
+    try {
+        return readdirSync(homedir(), { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && entry.name.startsWith(".claude-"))
+            .map((entry) => resolve(join(homedir(), entry.name)))
+            .filter((dir) => existsSync(join(dir, "projects")) ||
+            existsSync(join(dir, "stats-cache.json")) ||
+            existsSync(join(dir, "history.jsonl")));
+    }
+    catch {
+        return [];
+    }
+}
+function resolveClaudeConfigPaths(configuredPaths) {
+    const seen = new Set();
+    const resolvedPaths = [];
+    const raw = configuredPaths ?? process.env.CLAUDE_CONFIG_DIR ?? "";
+    const explicit = raw
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => resolve(part));
+    if (configuredPaths != null && configuredPaths.trim() !== "") {
+        for (const path of explicit) {
+            if (!seen.has(path)) {
+                seen.add(path);
+                resolvedPaths.push(path);
+            }
+        }
+        return resolvedPaths;
+    }
+    const xdg = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+    const defaults = [join(xdg, "claude"), join(homedir(), ".claude")];
+    for (const path of [...explicit, ...defaults, ...discoverClaudeWorkDirs()]) {
+        const resolvedPath = resolve(path);
+        if (!seen.has(resolvedPath)) {
+            seen.add(resolvedPath);
+            resolvedPaths.push(resolvedPath);
+        }
+    }
+    return resolvedPaths;
+}
+function getClaudeProjectDirs(configPaths) {
+    return configPaths
+        .map((base) => join(base, "projects"))
+        .filter((dir, index, array) => existsSync(dir) && array.indexOf(dir) === index);
+}
+function getClaudeStatsCacheFiles(configPaths) {
+    return configPaths
+        .map((base) => join(base, "stats-cache.json"))
+        .filter((file, index, array) => existsSync(file) && array.indexOf(file) === index);
+}
+function getClaudeHistoryFiles(configPaths) {
+    return configPaths
+        .map((base) => join(base, "history.jsonl"))
+        .filter((file, index, array) => existsSync(file) && array.indexOf(file) === index);
+}
+async function scanClaudeProvider(configPaths, timeZone) {
+    const dailyUsage = new Map();
+    const displayValuesByDay = new Map();
+    const stats = createEmptyScanStats();
+    const processedHashes = new Set();
+    for (const projectDir of getClaudeProjectDirs(configPaths)) {
+        for (const file of await listFilesRecursive(projectDir, ".jsonl")) {
+            stats.filesScanned += 1;
+            stats.jsonlFilesScanned += 1;
+            await processClaudeProjectFile(file, dailyUsage, stats, processedHashes, timeZone);
+        }
+    }
+    for (const file of getClaudeStatsCacheFiles(configPaths)) {
+        stats.filesScanned += 1;
+        stats.jsonFilesScanned += 1;
+        await processClaudeStatsCacheFile(file, dailyUsage, stats);
+    }
+    const coveredDates = new Set([...dailyUsage.keys()]);
+    for (const file of getClaudeHistoryFiles(configPaths)) {
+        stats.filesScanned += 1;
+        stats.jsonlFilesScanned += 1;
+        await processClaudeHistoryFile(file, displayValuesByDay, coveredDates, stats, timeZone);
+    }
+    return {
+        providerId: CLAUDE_PROVIDER_ID,
+        providerLabel: CLAUDE_PROVIDER_LABEL,
+        providerShortLabel: CLAUDE_PROVIDER_SHORT_LABEL,
+        sourceHome: configPaths[0] ?? null,
+        dailyUsage,
+        displayValuesByDay,
+        stats,
+    };
+}
+async function processClaudeProjectFile(filePath, dailyUsage, stats, processedHashes, timeZone) {
+    const content = await readFile(filePath, "utf8");
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line === "")
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            stats.parseErrors += 1;
+            continue;
+        }
+        const timestamp = parseFlexibleTimestamp(record.timestamp);
+        if (!timestamp || !record.message?.usage)
+            continue;
+        const uniqueHash = asNonEmptyString(record.message.id) && asNonEmptyString(record.requestId)
+            ? `${record.message.id}:${record.requestId}`
+            : null;
+        if (uniqueHash && processedHashes.has(uniqueHash)) {
+            stats.duplicateEventsSkipped += 1;
+            continue;
+        }
+        if (uniqueHash)
+            processedHashes.add(uniqueHash);
+        const usage = normalizeClaudeUsage(record.message.usage);
+        if (usage.total_tokens <= 0) {
+            stats.zeroTotalEventsSkipped += 1;
+            continue;
+        }
+        const model = asNonEmptyString(record.message.model);
+        addUsage(dailyUsage, dayKeyInTimezone(timestamp, timeZone), usage, model === "<synthetic>" ? null : model);
+        stats.tokenEventsCounted += 1;
+    }
+}
+function distributeTokenComponents(total, weights) {
+    const weightSum = weights.reduce((sum, value) => sum + value, 0);
+    if (total <= 0 || weightSum <= 0)
+        return weights.map(() => 0);
+    const exact = weights.map((weight) => (weight / weightSum) * total);
+    const allocated = exact.map((value) => Math.floor(value));
+    let remainder = total - allocated.reduce((sum, value) => sum + value, 0);
+    const order = exact
+        .map((value, index) => ({ index, fraction: value - allocated[index], weight: weights[index] }))
+        .sort((a, b) => (b.fraction - a.fraction) || (b.weight - a.weight));
+    for (const item of order) {
+        if (remainder <= 0)
+            break;
+        allocated[item.index] += 1;
+        remainder -= 1;
+    }
+    return allocated;
+}
+function createClaudeStatsCacheUsage(totalTokens, usage) {
+    if (totalTokens <= 0)
+        return createEmptyUsageTotals();
+    const [scaledInput, scaledOutput, scaledCacheRead, scaledCacheCreation] = distributeTokenComponents(totalTokens, [
+        Math.trunc(toNumber(usage?.inputTokens)),
+        Math.trunc(toNumber(usage?.outputTokens)),
+        Math.trunc(toNumber(usage?.cacheReadInputTokens)),
+        Math.trunc(toNumber(usage?.cacheCreationInputTokens)),
+    ]);
+    if (scaledInput === 0 && scaledOutput === 0 && scaledCacheRead === 0 && scaledCacheCreation === 0) {
+        return {
+            input_tokens: totalTokens,
+            cached_input_tokens: 0,
+            output_tokens: 0,
+            reasoning_output_tokens: 0,
+            total_tokens: totalTokens,
+        };
+    }
+    return {
+        input_tokens: scaledInput + scaledCacheRead,
+        cached_input_tokens: scaledCacheRead,
+        output_tokens: scaledOutput + scaledCacheCreation,
+        reasoning_output_tokens: 0,
+        total_tokens: totalTokens,
+    };
+}
+async function processClaudeStatsCacheFile(filePath, dailyUsage, stats) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(filePath, "utf8"));
+    }
+    catch {
+        stats.parseErrors += 1;
+        return;
+    }
+    const rows = Array.isArray(parsed.dailyModelTokens) ? parsed.dailyModelTokens : [];
+    const modelUsageMap = typeof parsed.modelUsage === "object" && parsed.modelUsage != null
+        ? parsed.modelUsage
+        : {};
+    for (const row of rows) {
+        if (typeof row !== "object" || row == null)
+            continue;
+        const date = asNonEmptyString(row.date);
+        if (!date || dailyUsage.has(date))
+            continue;
+        const tokensByModel = typeof row.tokensByModel === "object" &&
+            row.tokensByModel != null
+            ? row.tokensByModel
+            : {};
+        for (const [rawModelName, totalTokensRaw] of Object.entries(tokensByModel)) {
+            const totalTokens = Math.trunc(toNumber(totalTokensRaw));
+            if (totalTokens <= 0)
+                continue;
+            const usage = createClaudeStatsCacheUsage(totalTokens, typeof modelUsageMap[rawModelName] === "object" && modelUsageMap[rawModelName] != null
+                ? modelUsageMap[rawModelName]
+                : undefined);
+            addUsage(dailyUsage, date, usage, rawModelName);
+        }
+    }
+}
+async function processClaudeHistoryFile(filePath, displayValuesByDay, coveredDates, stats, timeZone) {
+    const content = await readFile(filePath, "utf8");
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line === "")
+            continue;
+        try {
+            const record = JSON.parse(line);
+            const timestamp = parseFlexibleTimestamp(record.timestamp);
+            if (!timestamp)
+                continue;
+            const dayKey = dayKeyInTimezone(timestamp, timeZone);
+            if (coveredDates.has(dayKey))
+                continue;
+            displayValuesByDay.set(dayKey, (displayValuesByDay.get(dayKey) ?? 0) + 1);
+        }
+        catch {
+            stats.parseErrors += 1;
+        }
+    }
+}
+function resolveOpenCodeBaseDir(configuredPath) {
+    const candidates = [];
+    if (configuredPath)
+        candidates.push(resolve(configuredPath));
+    if (process.env.OPENCODE_DATA_DIR?.trim())
+        candidates.push(resolve(process.env.OPENCODE_DATA_DIR.trim()));
+    candidates.push(resolve(join(homedir(), ".local", "share", "opencode")));
+    for (const candidate of candidates) {
+        if (!existsSync(candidate))
+            continue;
+        if (existsSync(join(candidate, "opencode.db")) || existsSync(join(candidate, "storage", "message"))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function scanOpenCodeProvider(baseDir, timeZone) {
+    const dailyUsage = new Map();
+    const displayValuesByDay = new Map();
+    const stats = createEmptyScanStats();
+    const dedupeIds = new Set();
+    const databasePath = join(baseDir, "opencode.db");
+    if (existsSync(databasePath)) {
+        stats.filesScanned += 1;
+        await processOpenCodeDatabase(databasePath, dailyUsage, stats, dedupeIds, timeZone);
+    }
+    else {
+        for (const file of await listFilesRecursive(join(baseDir, "storage", "message"), ".json")) {
+            stats.filesScanned += 1;
+            stats.jsonFilesScanned += 1;
+            await processOpenCodeLegacyFile(file, dailyUsage, stats, dedupeIds, timeZone);
+        }
+    }
+    return {
+        providerId: OPENCODE_PROVIDER_ID,
+        providerLabel: OPENCODE_PROVIDER_LABEL,
+        providerShortLabel: OPENCODE_PROVIDER_SHORT_LABEL,
+        sourceHome: baseDir,
+        dailyUsage,
+        displayValuesByDay,
+        stats,
+    };
+}
+function addOpenCodeMessage(message, dailyUsage, stats, dedupeIds, timeZone, fallbackId) {
+    const messageId = asNonEmptyString(message.id) ?? fallbackId ?? null;
+    if (messageId && dedupeIds.has(messageId)) {
+        stats.duplicateEventsSkipped += 1;
+        return;
+    }
+    if (messageId)
+        dedupeIds.add(messageId);
+    const usage = normalizeOpenCodeUsage(message.tokens);
+    if (usage.total_tokens <= 0) {
+        stats.zeroTotalEventsSkipped += 1;
+        return;
+    }
+    const timestamp = parseFlexibleTimestamp(message.time?.created);
+    if (!timestamp) {
+        stats.parseErrors += 1;
+        return;
+    }
+    addUsage(dailyUsage, dayKeyInTimezone(timestamp, timeZone), usage, asNonEmptyString(message.modelID));
+    stats.tokenEventsCounted += 1;
+}
+async function processOpenCodeLegacyFile(filePath, dailyUsage, stats, dedupeIds, timeZone) {
+    try {
+        const message = JSON.parse(await readFile(filePath, "utf8"));
+        addOpenCodeMessage(message, dailyUsage, stats, dedupeIds, timeZone);
+    }
+    catch {
+        stats.parseErrors += 1;
+    }
+}
+async function processOpenCodeDatabase(databasePath, dailyUsage, stats, dedupeIds, timeZone) {
+    const { DatabaseSync } = await import("node:sqlite");
+    const db = new DatabaseSync(databasePath, { readOnly: true });
+    try {
+        const rows = db.prepare("SELECT id, data FROM message ORDER BY time_created ASC").iterate();
+        for (const row of rows) {
+            try {
+                const message = JSON.parse(row.data);
+                addOpenCodeMessage(message, dailyUsage, stats, dedupeIds, timeZone, row.id);
+            }
+            catch {
+                stats.parseErrors += 1;
+            }
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+function resolvePiSessionsDir(configuredPath) {
+    const candidates = [];
+    if (configuredPath)
+        candidates.push(resolve(configuredPath));
+    if (process.env.PI_CODING_AGENT_DIR?.trim())
+        candidates.push(resolve(process.env.PI_CODING_AGENT_DIR.trim()));
+    candidates.push(resolve(join(homedir(), ".pi", "agent")));
+    for (const candidate of candidates) {
+        if (candidate.endsWith("/sessions") && existsSync(candidate))
+            return candidate;
+        const sessionsDir = join(candidate, "sessions");
+        if (existsSync(sessionsDir))
+            return sessionsDir;
+    }
+    return null;
+}
+async function scanPiProvider(sessionsDir, timeZone) {
+    const dailyUsage = new Map();
+    const displayValuesByDay = new Map();
+    const stats = createEmptyScanStats();
+    for (const file of await listFilesRecursive(sessionsDir, ".jsonl")) {
+        stats.filesScanned += 1;
+        stats.jsonlFilesScanned += 1;
+        await processPiJsonlFile(file, dailyUsage, stats, timeZone);
+    }
+    return {
+        providerId: PI_PROVIDER_ID,
+        providerLabel: PI_PROVIDER_LABEL,
+        providerShortLabel: PI_PROVIDER_SHORT_LABEL,
+        sourceHome: resolve(dirname(sessionsDir)),
+        dailyUsage,
+        displayValuesByDay,
+        stats,
+    };
+}
+async function processPiJsonlFile(filePath, dailyUsage, stats, timeZone) {
+    const content = await readFile(filePath, "utf8");
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line === "")
+            continue;
+        if (!line.includes('"role":"assistant"') && !line.includes('"role": "assistant"'))
+            continue;
+        if (!line.includes('"usage"'))
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            stats.parseErrors += 1;
+            continue;
+        }
+        if (record.type != null && record.type !== "message")
+            continue;
+        if (record.message?.role !== "assistant" || !record.message.usage)
+            continue;
+        const usage = normalizePiUsage(record.message.usage);
+        if (usage.total_tokens <= 0) {
+            stats.zeroTotalEventsSkipped += 1;
+            continue;
+        }
+        const timestamp = parseFlexibleTimestamp(record.timestamp) ?? parseFlexibleTimestamp(record.message.timestamp);
+        if (!timestamp) {
+            stats.parseErrors += 1;
+            continue;
+        }
+        addUsage(dailyUsage, dayKeyInTimezone(timestamp, timeZone), usage, asNonEmptyString(record.message.model));
+        stats.tokenEventsCounted += 1;
+    }
+}
+export function providerScanHasUsage(scan) {
+    for (const usage of scan.dailyUsage.values()) {
+        if (usage.total_tokens > 0)
+            return true;
+    }
+    for (const value of scan.displayValuesByDay.values()) {
+        if (value > 0)
+            return true;
+    }
+    return false;
+}
+export function buildMonthlyRollups(reportDays) {
+    const months = new Map();
+    for (const day of reportDays) {
+        if ((day.totalTokens || 0) <= 0 && (day.costUSD || 0) <= 0)
+            continue;
+        const monthKey = day.date.slice(0, 7);
+        let month = months.get(monthKey);
+        if (!month) {
+            month = {
+                row: {
+                    month: monthKey,
+                    inputTokens: 0,
+                    cachedInputTokens: 0,
+                    outputTokens: 0,
+                    reasoningTokens: 0,
+                    totalTokens: 0,
+                    events: 0,
+                    activeDays: 0,
+                    costBreakdownUSD: { inputUSD: 0, cachedInputUSD: 0, outputUSD: 0, totalUSD: 0 },
+                    costUSD: 0,
+                    modelTotals: {},
+                    modelBreakdown: [],
+                },
+                modelBreakdownIndex: new Map(),
+            };
+            months.set(monthKey, month);
+        }
+        month.row.inputTokens += day.inputTokens;
+        month.row.cachedInputTokens += day.cachedInputTokens;
+        month.row.outputTokens += day.outputTokens;
+        month.row.reasoningTokens += day.reasoningTokens;
+        month.row.totalTokens += day.totalTokens;
+        month.row.events += day.events;
+        if (day.totalTokens > 0)
+            month.row.activeDays += 1;
+        month.row.costBreakdownUSD.inputUSD += day.costBreakdownUSD.inputUSD;
+        month.row.costBreakdownUSD.cachedInputUSD += day.costBreakdownUSD.cachedInputUSD;
+        month.row.costBreakdownUSD.outputUSD += day.costBreakdownUSD.outputUSD;
+        month.row.costBreakdownUSD.totalUSD += day.costBreakdownUSD.totalUSD;
+        month.row.costUSD += day.costUSD;
+        for (const modelEntry of day.modelBreakdown) {
+            const name = String(modelEntry.name);
+            const existing = month.modelBreakdownIndex.get(name) ?? {
+                name,
+                inputTokens: 0,
+                cachedInputTokens: 0,
+                outputTokens: 0,
+                reasoningTokens: 0,
+                totalTokens: 0,
+                events: 0,
+                isFallbackModel: false,
+                isMissingPricing: false,
+                isAliasPricing: false,
+                resolvedPricingModel: asNonEmptyString(modelEntry.resolvedPricingModel) ?? null,
+                pricingSource: asNonEmptyString(modelEntry.pricingSource) ?? null,
+                pricingPerMToken: modelEntry.pricingPerMToken ?? null,
+                costBreakdownUSD: { inputUSD: 0, cachedInputUSD: 0, outputUSD: 0, totalUSD: 0 },
+                costUSD: 0,
+            };
+            existing.inputTokens += Number(modelEntry.inputTokens ?? 0);
+            existing.cachedInputTokens += Number(modelEntry.cachedInputTokens ?? 0);
+            existing.outputTokens += Number(modelEntry.outputTokens ?? 0);
+            existing.reasoningTokens += Number(modelEntry.reasoningTokens ?? 0);
+            existing.totalTokens += Number(modelEntry.totalTokens ?? 0);
+            existing.events += Number(modelEntry.events ?? 0);
+            existing.isFallbackModel = existing.isFallbackModel || Boolean(modelEntry.isFallbackModel);
+            existing.isMissingPricing = existing.isMissingPricing || Boolean(modelEntry.isMissingPricing);
+            existing.isAliasPricing = existing.isAliasPricing || Boolean(modelEntry.isAliasPricing);
+            existing.costBreakdownUSD.inputUSD += Number(modelEntry.costBreakdownUSD?.inputUSD ?? 0);
+            existing.costBreakdownUSD.cachedInputUSD += Number(modelEntry.costBreakdownUSD?.cachedInputUSD ?? 0);
+            existing.costBreakdownUSD.outputUSD += Number(modelEntry.costBreakdownUSD?.outputUSD ?? 0);
+            existing.costBreakdownUSD.totalUSD += Number(modelEntry.costBreakdownUSD?.totalUSD ?? 0);
+            existing.costUSD += Number(modelEntry.costUSD ?? 0);
+            month.modelBreakdownIndex.set(name, existing);
+        }
+    }
+    const rows = [...months.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([, month]) => {
+        const breakdown = [...month.modelBreakdownIndex.values()].sort((a, b) => Number(b.totalTokens) - Number(a.totalTokens));
+        month.row.modelBreakdown = breakdown;
+        month.row.modelTotals = Object.fromEntries(breakdown.map((entry) => [String(entry.name), Number(entry.totalTokens)]));
+        return month.row;
+    });
+    return rows;
+}
+function serializeScanStats(stats) {
+    return { ...stats };
+}
+function buildCombinedScanStats(providerReports) {
+    const combined = createEmptyScanStats();
+    for (const report of providerReports) {
+        for (const key of SCAN_OUTPUT_KEYS)
+            combined[key] += Number(report.scan[key] ?? 0);
+    }
+    return combined;
+}
+function buildProviderReport(scan, pricingDataset, pricingSourceKind, pricingSourceLabel) {
+    const allDays = [...new Set([...scan.dailyUsage.keys(), ...scan.displayValuesByDay.keys()])].sort();
+    const days = [];
+    const missingPricingModels = new Set();
+    const costTotalsUSD = { inputUSD: 0, cachedInputUSD: 0, outputUSD: 0, totalUSD: 0 };
+    for (const dayKey of allDays) {
+        const usage = scan.dailyUsage.get(dayKey) ?? createEmptyDailyUsage();
+        const modelBreakdown = Object.entries(usage.model_usage)
+            .sort(([, left], [, right]) => right.total_tokens - left.total_tokens)
+            .map(([name, modelUsage]) => {
+            const resolved = resolveModelPricing(name, pricingDataset);
+            const costBreakdownUSD = calculateCostBreakdown(modelUsage, resolved.pricing);
+            if (resolved.isMissing)
+                missingPricingModels.add(name);
+            return {
+                name,
+                inputTokens: modelUsage.input_tokens,
+                cachedInputTokens: modelUsage.cached_input_tokens,
+                outputTokens: modelUsage.output_tokens,
+                reasoningTokens: modelUsage.reasoning_output_tokens,
+                totalTokens: modelUsage.total_tokens,
+                events: modelUsage.events,
+                isFallbackModel: modelUsage.is_fallback_model,
+                isMissingPricing: resolved.isMissing,
+                isAliasPricing: resolved.isAlias,
+                resolvedPricingModel: resolved.resolvedModel,
+                pricingSource: resolved.source,
+                pricingPerMToken: resolved.pricing,
+                costBreakdownUSD,
+                costUSD: costBreakdownUSD.totalUSD,
+            };
+        });
+        const costBreakdownUSD = modelBreakdown.reduce((acc, entry) => ({
+            inputUSD: acc.inputUSD + Number(entry.costBreakdownUSD.inputUSD),
+            cachedInputUSD: acc.cachedInputUSD + Number(entry.costBreakdownUSD.cachedInputUSD),
+            outputUSD: acc.outputUSD + Number(entry.costBreakdownUSD.outputUSD),
+            totalUSD: acc.totalUSD + Number(entry.costBreakdownUSD.totalUSD),
+        }), { inputUSD: 0, cachedInputUSD: 0, outputUSD: 0, totalUSD: 0 });
+        costTotalsUSD.inputUSD += costBreakdownUSD.inputUSD;
+        costTotalsUSD.cachedInputUSD += costBreakdownUSD.cachedInputUSD;
+        costTotalsUSD.outputUSD += costBreakdownUSD.outputUSD;
+        costTotalsUSD.totalUSD += costBreakdownUSD.totalUSD;
+        days.push({
+            date: dayKey,
+            inputTokens: usage.input_tokens,
+            cachedInputTokens: usage.cached_input_tokens,
+            outputTokens: usage.output_tokens,
+            reasoningTokens: usage.reasoning_output_tokens,
+            totalTokens: usage.total_tokens,
+            events: usage.events,
+            costBreakdownUSD,
+            costUSD: costBreakdownUSD.totalUSD,
+            modelTotals: Object.fromEntries(modelBreakdown.map((entry) => [entry.name, Number(entry.totalTokens)])),
+            modelBreakdown,
+            displayValue: scan.displayValuesByDay.get(dayKey) ?? 0,
+        });
+    }
+    const scanStats = serializeScanStats(scan.stats);
+    scanStats.activityOnlyDays = [...scan.displayValuesByDay.keys()].filter((dayKey) => !scan.dailyUsage.has(dayKey)).length;
+    return {
+        providerId: scan.providerId,
+        providerLabel: scan.providerLabel,
+        providerShortLabel: scan.providerShortLabel,
+        sourceHome: scan.sourceHome,
+        days,
+        monthly: buildMonthlyRollups(days),
+        pricing: {
+            source: pricingSourceKind,
+            sourceLabel: pricingSourceLabel,
+            url: LITELLM_PRICING_URL,
+            missingModels: [...missingPricingModels].sort(),
+        },
+        costTotalsUSD,
+        scan: scanStats,
+    };
+}
+export function buildCombinedReport(providerReports) {
+    const combinedByDay = new Map();
+    const missingModels = new Set();
+    const costTotalsUSD = { inputUSD: 0, cachedInputUSD: 0, outputUSD: 0, totalUSD: 0 };
+    const pricingSources = new Set();
+    const pricingLabels = new Set();
+    const pricingUrls = new Set();
+    for (const report of providerReports) {
+        pricingSources.add(report.pricing.source);
+        pricingLabels.add(report.pricing.sourceLabel);
+        pricingUrls.add(report.pricing.url);
+        for (const model of report.pricing.missingModels)
+            missingModels.add(model);
+        costTotalsUSD.inputUSD += report.costTotalsUSD.inputUSD;
+        costTotalsUSD.cachedInputUSD += report.costTotalsUSD.cachedInputUSD;
+        costTotalsUSD.outputUSD += report.costTotalsUSD.outputUSD;
+        costTotalsUSD.totalUSD += report.costTotalsUSD.totalUSD;
+        for (const day of report.days) {
+            const existing = combinedByDay.get(day.date) ??
+                {
+                    date: day.date,
+                    inputTokens: 0,
+                    cachedInputTokens: 0,
+                    outputTokens: 0,
+                    reasoningTokens: 0,
+                    totalTokens: 0,
+                    events: 0,
+                    costBreakdownUSD: { inputUSD: 0, cachedInputUSD: 0, outputUSD: 0, totalUSD: 0 },
+                    costUSD: 0,
+                    modelTotals: {},
+                    modelBreakdown: [],
+                    displayValue: 0,
+                };
+            existing.inputTokens += day.inputTokens;
+            existing.cachedInputTokens += day.cachedInputTokens;
+            existing.outputTokens += day.outputTokens;
+            existing.reasoningTokens += day.reasoningTokens;
+            existing.totalTokens += day.totalTokens;
+            existing.events += day.events;
+            existing.displayValue += day.displayValue;
+            existing.costBreakdownUSD.inputUSD += day.costBreakdownUSD.inputUSD;
+            existing.costBreakdownUSD.cachedInputUSD += day.costBreakdownUSD.cachedInputUSD;
+            existing.costBreakdownUSD.outputUSD += day.costBreakdownUSD.outputUSD;
+            existing.costBreakdownUSD.totalUSD += day.costBreakdownUSD.totalUSD;
+            existing.costUSD += day.costUSD;
+            const modelIndex = new Map(existing.modelBreakdown.map((entry) => [String(entry.name), entry]));
+            for (const modelEntry of day.modelBreakdown) {
+                const name = String(modelEntry.name);
+                const merged = modelIndex.get(name) ?? {
+                    name,
+                    inputTokens: 0,
+                    cachedInputTokens: 0,
+                    outputTokens: 0,
+                    reasoningTokens: 0,
+                    totalTokens: 0,
+                    events: 0,
+                    isFallbackModel: false,
+                    isMissingPricing: false,
+                    isAliasPricing: false,
+                    resolvedPricingModel: modelEntry.resolvedPricingModel ?? null,
+                    pricingSource: modelEntry.pricingSource ?? null,
+                    pricingPerMToken: modelEntry.pricingPerMToken ?? null,
+                    costBreakdownUSD: { inputUSD: 0, cachedInputUSD: 0, outputUSD: 0, totalUSD: 0 },
+                    costUSD: 0,
+                };
+                merged.inputTokens = Number(merged.inputTokens) + Number(modelEntry.inputTokens ?? 0);
+                merged.cachedInputTokens = Number(merged.cachedInputTokens) + Number(modelEntry.cachedInputTokens ?? 0);
+                merged.outputTokens = Number(merged.outputTokens) + Number(modelEntry.outputTokens ?? 0);
+                merged.reasoningTokens = Number(merged.reasoningTokens) + Number(modelEntry.reasoningTokens ?? 0);
+                merged.totalTokens = Number(merged.totalTokens) + Number(modelEntry.totalTokens ?? 0);
+                merged.events = Number(merged.events) + Number(modelEntry.events ?? 0);
+                merged.isFallbackModel = Boolean(merged.isFallbackModel) || Boolean(modelEntry.isFallbackModel);
+                merged.isMissingPricing = Boolean(merged.isMissingPricing) || Boolean(modelEntry.isMissingPricing);
+                merged.isAliasPricing = Boolean(merged.isAliasPricing) || Boolean(modelEntry.isAliasPricing);
+                merged.costBreakdownUSD.inputUSD += Number(modelEntry.costBreakdownUSD.inputUSD);
+                merged.costBreakdownUSD.cachedInputUSD += Number(modelEntry.costBreakdownUSD.cachedInputUSD);
+                merged.costBreakdownUSD.outputUSD += Number(modelEntry.costBreakdownUSD.outputUSD);
+                merged.costBreakdownUSD.totalUSD += Number(modelEntry.costBreakdownUSD.totalUSD);
+                merged.costUSD = Number(merged.costUSD) + Number(modelEntry.costUSD ?? 0);
+                if (merged.resolvedPricingModel == null)
+                    merged.resolvedPricingModel = modelEntry.resolvedPricingModel ?? null;
+                if (merged.pricingSource == null)
+                    merged.pricingSource = modelEntry.pricingSource ?? null;
+                if (merged.pricingPerMToken == null)
+                    merged.pricingPerMToken = modelEntry.pricingPerMToken ?? null;
+                modelIndex.set(name, merged);
+            }
+            existing.modelBreakdown = [...modelIndex.values()].sort((a, b) => Number(b.totalTokens) - Number(a.totalTokens));
+            existing.modelTotals = Object.fromEntries(existing.modelBreakdown.map((entry) => [String(entry.name), Number(entry.totalTokens)]));
+            combinedByDay.set(day.date, existing);
+        }
+    }
+    const days = [...combinedByDay.values()].sort((a, b) => a.date.localeCompare(b.date));
+    return {
+        providerId: COMBINED_PROVIDER_ID,
+        providerLabel: COMBINED_PROVIDER_LABEL,
+        providerShortLabel: COMBINED_PROVIDER_SHORT_LABEL,
+        sourceHome: null,
+        days,
+        monthly: buildMonthlyRollups(days),
+        pricing: {
+            source: pricingSources.size === 1 ? [...pricingSources][0] : "mixed",
+            sourceLabel: pricingLabels.size === 1 ? [...pricingLabels][0] : "Mixed provider pricing",
+            url: pricingUrls.size === 1 ? [...pricingUrls][0] : LITELLM_PRICING_URL,
+            missingModels: [...missingModels].sort(),
+        },
+        costTotalsUSD,
+        scan: buildCombinedScanStats(providerReports),
+    };
+}
+export async function buildReportPayload(providerScans, timeZone) {
+    let pricingDataset = null;
+    let pricingSourceKind = "builtin-fallback";
+    let pricingSourceLabel = "Built-in fallback pricing";
+    try {
+        pricingDataset = await fetchLiteLLMPricingDataset();
+        pricingSourceKind = "litellm-live";
+        pricingSourceLabel = "LiteLLM live pricing";
+    }
+    catch {
+        pricingDataset = null;
+    }
+    const providerReports = providerScans.map((scan) => buildProviderReport(scan, pricingDataset, pricingSourceKind, pricingSourceLabel));
+    const combined = buildCombinedReport(providerReports);
+    const providers = Object.fromEntries(providerReports.map((report) => [report.providerId, report]));
+    const providerOrder = providerReports.map((report) => report.providerId);
+    const defaultProvider = providerOrder[0] ?? DEFAULT_PROVIDER_ID;
+    const defaultProviderReport = providers[defaultProvider] ?? combined;
+    const now = new Date();
+    return {
+        schemaVersion: REPORT_SCHEMA_VERSION,
+        kind: "agent-usage-report",
+        timezone: timeZone,
+        generatedAt: now.toISOString(),
+        generatedAtDisplay: new Intl.DateTimeFormat("en-CA", {
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            timeZone,
+            timeZoneName: "short",
+        }).format(now).replace(",", ""),
+        generatedLocalDate: dayKeyInTimezone(now, timeZone),
+        platform: `${osPlatform()} ${osRelease()} · Node ${process.version.replace(/^v/, "")}`,
+        defaultProvider,
+        providerOrder,
+        providerOptions: providerReports.map((report) => ({
+            id: report.providerId,
+            label: report.providerLabel,
+            shortLabel: report.providerShortLabel,
+        })),
+        providers,
+        combined,
+        capabilities: {
+            multiProvider: providerReports.length > 1,
+            providerControls: providerReports.length > 1,
+        },
+        sourceHome: defaultProviderReport.sourceHome,
+        codexHome: providers[DEFAULT_PROVIDER_ID]?.sourceHome ?? null,
+        days: defaultProviderReport.days,
+        monthly: defaultProviderReport.monthly,
+        pricing: defaultProviderReport.pricing,
+        costTotalsUSD: defaultProviderReport.costTotalsUSD,
+        scan: defaultProviderReport.scan,
+    };
+}
+async function loadTemplate() {
+    return readFile(join(__dirname, "template.html"), "utf8");
+}
+export async function writeOutput(report, outputHtml, outputJson) {
+    await writeFile(outputJson, JSON.stringify(report, null, 2), "utf8");
+    const template = await loadTemplate();
+    await writeFile(outputHtml, template.replace("__DATA__", JSON.stringify(report)), "utf8");
+}
+export function parseCliArgs(argv) {
+    const args = {
+        codexHome: join(homedir(), ".codex"),
+        claudeConfigDir: null,
+        opencodeDir: null,
+        piAgentDir: null,
+        timezone: DEFAULT_TIMEZONE,
+        outputHtml: "agent-usage-report.html",
+        outputJson: "agent-usage-data.json",
+        skipArchived: false,
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        const next = argv[index + 1];
+        switch (arg) {
+            case "--codex-home":
+                if (!next)
+                    throw new Error("Missing value for --codex-home");
+                args.codexHome = next;
+                index += 1;
+                break;
+            case "--claude-config-dir":
+                if (!next)
+                    throw new Error("Missing value for --claude-config-dir");
+                args.claudeConfigDir = next;
+                index += 1;
+                break;
+            case "--opencode-dir":
+                if (!next)
+                    throw new Error("Missing value for --opencode-dir");
+                args.opencodeDir = next;
+                index += 1;
+                break;
+            case "--pi-agent-dir":
+                if (!next)
+                    throw new Error("Missing value for --pi-agent-dir");
+                args.piAgentDir = next;
+                index += 1;
+                break;
+            case "--timezone":
+                if (!next)
+                    throw new Error("Missing value for --timezone");
+                args.timezone = next;
+                index += 1;
+                break;
+            case "--output-html":
+                if (!next)
+                    throw new Error("Missing value for --output-html");
+                args.outputHtml = next;
+                index += 1;
+                break;
+            case "--output-json":
+                if (!next)
+                    throw new Error("Missing value for --output-json");
+                args.outputJson = next;
+                index += 1;
+                break;
+            case "--skip-archived":
+                args.skipArchived = true;
+                break;
+            case "-h":
+            case "--help":
+                printHelp();
+                process.exit(0);
+            default:
+                throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    return args;
+}
+function printHelp() {
+    console.log(`usage: agent-usage-report [options]
+
+Options:
+  --codex-home <path>          Path to the Codex home directory
+  --claude-config-dir <paths>  Claude config dir or comma-separated dirs
+  --opencode-dir <path>        OpenCode data directory
+  --pi-agent-dir <path>        Pi Coding Agent dir or sessions dir
+  --timezone <iana-tz>         Day bucketing timezone
+  --output-html <path>         HTML output path
+  --output-json <path>         JSON output path
+  --skip-archived              Skip ~/.codex/archived_sessions
+  -h, --help                   Show this help text`);
+}
+export async function generateReport(args) {
+    const codexHome = resolve(args.codexHome);
+    if (!existsSync(codexHome))
+        throw new Error(`Configured usage source does not exist: ${codexHome}`);
+    const claudeConfigPaths = resolveClaudeConfigPaths(args.claudeConfigDir);
+    const openCodeBaseDir = resolveOpenCodeBaseDir(args.opencodeDir);
+    const piSessionsDir = resolvePiSessionsDir(args.piAgentDir);
+    const providerScans = [];
+    providerScans.push(await scanCodexProvider(codexHome, !args.skipArchived, args.timezone));
+    if (getClaudeProjectDirs(claudeConfigPaths).length > 0 ||
+        getClaudeStatsCacheFiles(claudeConfigPaths).length > 0 ||
+        getClaudeHistoryFiles(claudeConfigPaths).length > 0) {
+        const claudeScan = await scanClaudeProvider(claudeConfigPaths, args.timezone);
+        if (providerScanHasUsage(claudeScan))
+            providerScans.push(claudeScan);
+    }
+    if (openCodeBaseDir) {
+        const openCodeScan = await scanOpenCodeProvider(openCodeBaseDir, args.timezone);
+        if (providerScanHasUsage(openCodeScan))
+            providerScans.push(openCodeScan);
+    }
+    if (piSessionsDir) {
+        const piScan = await scanPiProvider(piSessionsDir, args.timezone);
+        if (providerScanHasUsage(piScan))
+            providerScans.push(piScan);
+    }
+    return buildReportPayload(providerScans, args.timezone);
+}
+export async function main(argv = process.argv.slice(2)) {
+    const args = parseCliArgs(argv);
+    const report = await generateReport(args);
+    const outputHtml = resolve(args.outputHtml);
+    const outputJson = resolve(args.outputJson);
+    await writeOutput(report, outputHtml, outputJson);
+    const combined = report.combined;
+    const primaryScan = report.providers[DEFAULT_PROVIDER_ID]?.scan ?? createEmptyScanStats();
+    console.log(`Scanned ${primaryScan.filesScanned} local usage files from ${resolve(args.codexHome)}`);
+    console.log(`Counted ${primaryScan.tokenEventsCounted} token events across ${combined.days.length} days`);
+    console.log(`Total tokens in extracted dataset: ${combined.days.reduce((sum, day) => sum + day.totalTokens, 0).toLocaleString("en-US")}`);
+    console.log(`HTML report: ${outputHtml}`);
+    console.log(`JSON data: ${outputJson}`);
+}
+//# sourceMappingURL=generator.js.map