tokenleak 0.1.0

package/tokenleak.js

@@ -0,0 +1,2382 @@
+#!/usr/bin/env bun
+// @bun
+var __require = import.meta.require;
+
+// node_modules/citty/dist/_chunks/libs/scule.mjs
+var NUMBER_CHAR_RE = /\d/;
+var STR_SPLITTERS = [
+  "-",
+  "_",
+  "/",
+  "."
+];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char))
+    return;
+  return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+  const splitters = separators ?? STR_SPLITTERS;
+  const parts = [];
+  if (!str || typeof str !== "string")
+    return parts;
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of str) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = undefined;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff.at(-1);
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function upperFirst(str) {
+  return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+  return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function pascalCase(str, opts) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
+}
+function camelCase(str, opts) {
+  return lowerFirst(pascalCase(str || "", opts));
+}
+function kebabCase(str, joiner) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+}
+
+// node_modules/citty/dist/index.mjs
+import { parseArgs as parseArgs$1 } from "util";
+function toArray(val) {
+  if (Array.isArray(val))
+    return val;
+  return val === undefined ? [] : [val];
+}
+function formatLineColumns(lines, linePrefix = "") {
+  const maxLength = [];
+  for (const line of lines)
+    for (const [i, element] of line.entries())
+      maxLength[i] = Math.max(maxLength[i] || 0, element.length);
+  return lines.map((l) => l.map((c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLength[i])).join("  ")).join(`
+`);
+}
+function resolveValue(input) {
+  return typeof input === "function" ? input() : input;
+}
+var CLIError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "CLIError";
+    this.code = code;
+  }
+};
+function parseRawArgs(args = [], opts = {}) {
+  const booleans = new Set(opts.boolean || []);
+  const strings = new Set(opts.string || []);
+  const aliasMap = opts.alias || {};
+  const defaults = opts.default || {};
+  const aliasToMain = /* @__PURE__ */ new Map;
+  const mainToAliases = /* @__PURE__ */ new Map;
+  for (const [key, value] of Object.entries(aliasMap)) {
+    const targets = value;
+    for (const target of targets) {
+      aliasToMain.set(key, target);
+      if (!mainToAliases.has(target))
+        mainToAliases.set(target, []);
+      mainToAliases.get(target).push(key);
+      aliasToMain.set(target, key);
+      if (!mainToAliases.has(key))
+        mainToAliases.set(key, []);
+      mainToAliases.get(key).push(target);
+    }
+  }
+  const options = {};
+  function getType(name) {
+    if (booleans.has(name))
+      return "boolean";
+    const aliases = mainToAliases.get(name) || [];
+    for (const alias of aliases)
+      if (booleans.has(alias))
+        return "boolean";
+    return "string";
+  }
+  const allOptions = new Set([
+    ...booleans,
+    ...strings,
+    ...Object.keys(aliasMap),
+    ...Object.values(aliasMap).flat(),
+    ...Object.keys(defaults)
+  ]);
+  for (const name of allOptions)
+    if (!options[name])
+      options[name] = {
+        type: getType(name),
+        default: defaults[name]
+      };
+  for (const [alias, main] of aliasToMain.entries())
+    if (alias.length === 1 && options[main] && !options[main].short)
+      options[main].short = alias;
+  const processedArgs = [];
+  const negatedFlags = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      processedArgs.push(...args.slice(i));
+      break;
+    }
+    if (arg.startsWith("--no-")) {
+      const flagName = arg.slice(5);
+      negatedFlags[flagName] = true;
+      continue;
+    }
+    processedArgs.push(arg);
+  }
+  let parsed;
+  try {
+    parsed = parseArgs$1({
+      args: processedArgs,
+      options: Object.keys(options).length > 0 ? options : undefined,
+      allowPositionals: true,
+      strict: false
+    });
+  } catch {
+    parsed = {
+      values: {},
+      positionals: processedArgs
+    };
+  }
+  const out = { _: [] };
+  out._ = parsed.positionals;
+  for (const [key, value] of Object.entries(parsed.values))
+    out[key] = value;
+  for (const [name] of Object.entries(negatedFlags)) {
+    out[name] = false;
+    const mainName = aliasToMain.get(name);
+    if (mainName)
+      out[mainName] = false;
+    const aliases = mainToAliases.get(name);
+    if (aliases)
+      for (const alias of aliases)
+        out[alias] = false;
+  }
+  for (const [alias, main] of aliasToMain.entries()) {
+    if (out[alias] !== undefined && out[main] === undefined)
+      out[main] = out[alias];
+    if (out[main] !== undefined && out[alias] === undefined)
+      out[alias] = out[main];
+  }
+  return out;
+}
+var noColor = /* @__PURE__ */ (() => {
+  const env = globalThis.process?.env ?? {};
+  return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
+})();
+var _c = (c, r = 39) => (t) => noColor ? t : `\x1B[${c}m${t}\x1B[${r}m`;
+var bold = /* @__PURE__ */ _c(1, 22);
+var cyan = /* @__PURE__ */ _c(36);
+var gray = /* @__PURE__ */ _c(90);
+var underline = /* @__PURE__ */ _c(4, 24);
+function parseArgs(rawArgs, argsDef) {
+  const parseOptions = {
+    boolean: [],
+    string: [],
+    alias: {},
+    default: {}
+  };
+  const args = resolveArgs(argsDef);
+  for (const arg of args) {
+    if (arg.type === "positional")
+      continue;
+    if (arg.type === "string" || arg.type === "enum")
+      parseOptions.string.push(arg.name);
+    else if (arg.type === "boolean")
+      parseOptions.boolean.push(arg.name);
+    if (arg.default !== undefined)
+      parseOptions.default[arg.name] = arg.default;
+    if (arg.alias)
+      parseOptions.alias[arg.name] = arg.alias;
+    const camelName = camelCase(arg.name);
+    const kebabName = kebabCase(arg.name);
+    if (camelName !== arg.name || kebabName !== arg.name) {
+      const existingAliases = toArray(parseOptions.alias[arg.name] || []);
+      if (camelName !== arg.name && !existingAliases.includes(camelName))
+        existingAliases.push(camelName);
+      if (kebabName !== arg.name && !existingAliases.includes(kebabName))
+        existingAliases.push(kebabName);
+      if (existingAliases.length > 0)
+        parseOptions.alias[arg.name] = existingAliases;
+    }
+  }
+  const parsed = parseRawArgs(rawArgs, parseOptions);
+  const [...positionalArguments] = parsed._;
+  const parsedArgsProxy = new Proxy(parsed, { get(target, prop) {
+    return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+  } });
+  for (const [, arg] of args.entries())
+    if (arg.type === "positional") {
+      const nextPositionalArgument = positionalArguments.shift();
+      if (nextPositionalArgument !== undefined)
+        parsedArgsProxy[arg.name] = nextPositionalArgument;
+      else if (arg.default === undefined && arg.required !== false)
+        throw new CLIError(`Missing required positional argument: ${arg.name.toUpperCase()}`, "EARG");
+      else
+        parsedArgsProxy[arg.name] = arg.default;
+    } else if (arg.type === "enum") {
+      const argument = parsedArgsProxy[arg.name];
+      const options = arg.options || [];
+      if (argument !== undefined && options.length > 0 && !options.includes(argument))
+        throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o) => cyan(o)).join(", ")}.`, "EARG");
+    } else if (arg.required && parsedArgsProxy[arg.name] === undefined)
+      throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+  return parsedArgsProxy;
+}
+function resolveArgs(argsDef) {
+  const args = [];
+  for (const [name, argDef] of Object.entries(argsDef || {}))
+    args.push({
+      ...argDef,
+      name,
+      alias: toArray(argDef.alias)
+    });
+  return args;
+}
+function defineCommand(def) {
+  return def;
+}
+async function runCommand(cmd, opts) {
+  const cmdArgs = await resolveValue(cmd.args || {});
+  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+  const context = {
+    rawArgs: opts.rawArgs,
+    args: parsedArgs,
+    data: opts.data,
+    cmd
+  };
+  if (typeof cmd.setup === "function")
+    await cmd.setup(context);
+  let result;
+  try {
+    const subCommands = await resolveValue(cmd.subCommands);
+    if (subCommands && Object.keys(subCommands).length > 0) {
+      const subCommandArgIndex = opts.rawArgs.findIndex((arg) => !arg.startsWith("-"));
+      const subCommandName = opts.rawArgs[subCommandArgIndex];
+      if (subCommandName) {
+        if (!subCommands[subCommandName])
+          throw new CLIError(`Unknown command ${cyan(subCommandName)}`, "E_UNKNOWN_COMMAND");
+        const subCommand = await resolveValue(subCommands[subCommandName]);
+        if (subCommand)
+          await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+      } else if (!cmd.run)
+        throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+    }
+    if (typeof cmd.run === "function")
+      result = await cmd.run(context);
+  } finally {
+    if (typeof cmd.cleanup === "function")
+      await cmd.cleanup(context);
+  }
+  return { result };
+}
+async function resolveSubCommand(cmd, rawArgs, parent) {
+  const subCommands = await resolveValue(cmd.subCommands);
+  if (subCommands && Object.keys(subCommands).length > 0) {
+    const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
+    const subCommandName = rawArgs[subCommandArgIndex];
+    const subCommand = await resolveValue(subCommands[subCommandName]);
+    if (subCommand)
+      return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
+  }
+  return [cmd, parent];
+}
+async function showUsage(cmd, parent) {
+  try {
+    console.log(await renderUsage(cmd, parent) + `
+`);
+  } catch (error) {
+    console.error(error);
+  }
+}
+var negativePrefixRe = /^no[-A-Z]/;
+async function renderUsage(cmd, parent) {
+  const cmdMeta = await resolveValue(cmd.meta || {});
+  const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
+  const parentMeta = await resolveValue(parent?.meta || {});
+  const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
+  const argLines = [];
+  const posLines = [];
+  const commandsLines = [];
+  const usageLine = [];
+  for (const arg of cmdArgs)
+    if (arg.type === "positional") {
+      const name = arg.name.toUpperCase();
+      const isRequired = arg.required !== false && arg.default === undefined;
+      const defaultHint = arg.default ? `="${arg.default}"` : "";
+      posLines.push([
+        cyan(name + defaultHint),
+        arg.description || "",
+        arg.valueHint ? `<${arg.valueHint}>` : ""
+      ]);
+      usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
+    } else {
+      const isRequired = arg.required === true && arg.default === undefined;
+      const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "") + (arg.type === "enum" && arg.options ? `=<${arg.options.join("|")}>` : "");
+      argLines.push([cyan(argStr + (isRequired ? " (required)" : "")), arg.description || ""]);
+      if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
+        const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
+        argLines.push([cyan(negativeArgStr + (isRequired ? " (required)" : "")), arg.negativeDescription || ""]);
+      }
+      if (isRequired)
+        usageLine.push(argStr);
+    }
+  if (cmd.subCommands) {
+    const commandNames = [];
+    const subCommands = await resolveValue(cmd.subCommands);
+    for (const [name, sub] of Object.entries(subCommands)) {
+      const meta = await resolveValue((await resolveValue(sub))?.meta);
+      if (meta?.hidden)
+        continue;
+      commandsLines.push([cyan(name), meta?.description || ""]);
+      commandNames.push(name);
+    }
+    usageLine.push(commandNames.join("|"));
+  }
+  const usageLines = [];
+  const version = cmdMeta.version || parentMeta.version;
+  usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
+  const hasOptions = argLines.length > 0 || posLines.length > 0;
+  usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
+  if (posLines.length > 0) {
+    usageLines.push(underline(bold("ARGUMENTS")), "");
+    usageLines.push(formatLineColumns(posLines, "  "));
+    usageLines.push("");
+  }
+  if (argLines.length > 0) {
+    usageLines.push(underline(bold("OPTIONS")), "");
+    usageLines.push(formatLineColumns(argLines, "  "));
+    usageLines.push("");
+  }
+  if (commandsLines.length > 0) {
+    usageLines.push(underline(bold("COMMANDS")), "");
+    usageLines.push(formatLineColumns(commandsLines, "  "));
+    usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
+  }
+  return usageLines.filter((l) => typeof l === "string").join(`
+`);
+}
+async function runMain(cmd, opts = {}) {
+  const rawArgs = opts.rawArgs || process.argv.slice(2);
+  const showUsage$1 = opts.showUsage || showUsage;
+  try {
+    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      process.exit(0);
+    } else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
+      const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
+      if (!meta?.version)
+        throw new CLIError("No version specified", "E_NO_VERSION");
+      console.log(meta.version);
+    } else
+      await runCommand(cmd, { rawArgs });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      console.error(error.message);
+    } else
+      console.error(error, `
+`);
+    process.exit(1);
+  }
+}
+
+// packages/cli/src/cli.ts
+import { writeFileSync } from "fs";
+
+// packages/core/dist/constants.js
+var DEFAULT_DAYS = 90;
+var DEFAULT_CONCURRENCY = 3;
+var MAX_JSONL_RECORD_BYTES = 10 * 1024 * 1024;
+var SCHEMA_VERSION = 1;
+// packages/core/dist/aggregation/streaks.js
+function calculateStreaks(daily) {
+  if (daily.length === 0) {
+    return { current: 0, longest: 0 };
+  }
+  const sorted = [...daily].sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+  const ONE_DAY_MS = 86400000;
+  let longest = 1;
+  let currentRun = 1;
+  for (let i = 1;i < sorted.length; i++) {
+    const prev = new Date(sorted[i - 1].date).getTime();
+    const curr = new Date(sorted[i].date).getTime();
+    const diff = curr - prev;
+    if (diff === ONE_DAY_MS) {
+      currentRun++;
+    } else {
+      currentRun = 1;
+    }
+    if (currentRun > longest) {
+      longest = currentRun;
+    }
+  }
+  let current = 1;
+  for (let i = sorted.length - 1;i > 0; i--) {
+    const curr = new Date(sorted[i].date).getTime();
+    const prev = new Date(sorted[i - 1].date).getTime();
+    if (curr - prev === ONE_DAY_MS) {
+      current++;
+    } else {
+      break;
+    }
+  }
+  return { current, longest };
+}
+// packages/core/dist/aggregation/rolling-window.js
+function rollingWindow(daily, days, referenceDate) {
+  if (daily.length === 0 || days <= 0) {
+    return { tokens: 0, cost: 0 };
+  }
+  const refTime = new Date(referenceDate).getTime();
+  const ONE_DAY_MS = 86400000;
+  const windowStart = refTime - (days - 1) * ONE_DAY_MS;
+  let tokens = 0;
+  let cost = 0;
+  for (const entry of daily) {
+    const entryTime = new Date(entry.date).getTime();
+    if (entryTime >= windowStart && entryTime <= refTime) {
+      tokens += entry.totalTokens;
+      cost += entry.cost;
+    }
+  }
+  return { tokens, cost };
+}
+// packages/core/dist/aggregation/peaks.js
+function findPeakDay(daily) {
+  if (daily.length === 0) {
+    return null;
+  }
+  let peak = null;
+  for (const entry of daily) {
+    if (peak === null || entry.totalTokens > peak.tokens || entry.totalTokens === peak.tokens && entry.date > peak.date) {
+      peak = { date: entry.date, tokens: entry.totalTokens };
+    }
+  }
+  return peak;
+}
+// packages/core/dist/aggregation/day-of-week.js
+var DAY_LABELS = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+function dayOfWeekBreakdown(daily) {
+  const buckets = DAY_LABELS.map((label, i) => ({
+    day: i,
+    label,
+    tokens: 0,
+    cost: 0,
+    count: 0
+  }));
+  for (const entry of daily) {
+    const dayIndex = new Date(entry.date + "T00:00:00").getUTCDay();
+    const bucket = buckets[dayIndex];
+    bucket.tokens += entry.totalTokens;
+    bucket.cost += entry.cost;
+    bucket.count += 1;
+  }
+  return buckets;
+}
+// packages/core/dist/aggregation/cache-rate.js
+function cacheHitRate(daily) {
+  let totalCacheRead = 0;
+  let totalInput = 0;
+  for (const entry of daily) {
+    totalCacheRead += entry.cacheReadTokens;
+    totalInput += entry.inputTokens;
+  }
+  const denominator = totalInput + totalCacheRead;
+  if (denominator === 0) {
+    return 0;
+  }
+  return totalCacheRead / denominator;
+}
+// packages/core/dist/aggregation/averages.js
+function calculateAverages(daily, totalDays) {
+  if (totalDays <= 0 || daily.length === 0) {
+    return { tokens: 0, cost: 0 };
+  }
+  let totalTokens = 0;
+  let totalCost = 0;
+  for (const entry of daily) {
+    totalTokens += entry.totalTokens;
+    totalCost += entry.cost;
+  }
+  return {
+    tokens: totalTokens / totalDays,
+    cost: totalCost / totalDays
+  };
+}
+// packages/core/dist/aggregation/top-models.js
+var DEFAULT_LIMIT = 10;
+function topModels(daily, limit = DEFAULT_LIMIT) {
+  const modelMap = new Map;
+  for (const entry of daily) {
+    for (const m of entry.models) {
+      const existing = modelMap.get(m.model);
+      if (existing) {
+        existing.tokens += m.totalTokens;
+        existing.cost += m.cost;
+      } else {
+        modelMap.set(m.model, { tokens: m.totalTokens, cost: m.cost });
+      }
+    }
+  }
+  let grandTotal = 0;
+  for (const v of modelMap.values()) {
+    grandTotal += v.tokens;
+  }
+  const entries = [];
+  for (const [model, { tokens, cost }] of modelMap) {
+    entries.push({
+      model,
+      tokens,
+      cost,
+      percentage: grandTotal > 0 ? tokens / grandTotal : 0
+    });
+  }
+  entries.sort((a, b) => b.tokens - a.tokens);
+  return entries.slice(0, limit);
+}
+// packages/core/dist/aggregation/aggregate.js
+function aggregate(daily, referenceDate) {
+  const streaks = calculateStreaks(daily);
+  const rolling30 = rollingWindow(daily, 30, referenceDate);
+  const rolling7 = rollingWindow(daily, 7, referenceDate);
+  const peak = findPeakDay(daily);
+  const dow = dayOfWeekBreakdown(daily);
+  const cache = cacheHitRate(daily);
+  const models = topModels(daily);
+  let totalTokens = 0;
+  let totalCost = 0;
+  for (const entry of daily) {
+    totalTokens += entry.totalTokens;
+    totalCost += entry.cost;
+  }
+  const activeDays = daily.length;
+  let totalDays = 0;
+  if (daily.length > 0) {
+    const sorted = [...daily].sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+    const first = new Date(sorted[0].date).getTime();
+    const last = new Date(sorted[sorted.length - 1].date).getTime();
+    const ONE_DAY_MS = 86400000;
+    totalDays = Math.round((last - first) / ONE_DAY_MS) + 1;
+  }
+  const averages = calculateAverages(daily, totalDays);
+  return {
+    currentStreak: streaks.current,
+    longestStreak: streaks.longest,
+    rolling30dTokens: rolling30.tokens,
+    rolling30dCost: rolling30.cost,
+    rolling7dTokens: rolling7.tokens,
+    rolling7dCost: rolling7.cost,
+    peakDay: peak,
+    averageDailyTokens: averages.tokens,
+    averageDailyCost: averages.cost,
+    cacheHitRate: cache,
+    totalTokens,
+    totalCost,
+    totalDays,
+    activeDays,
+    dayOfWeek: dow,
+    topModels: models
+  };
+}
+// packages/core/dist/aggregation/merge.js
+function mergeProviderData(providers) {
+  const dateMap = new Map;
+  for (const provider of providers) {
+    for (const entry of provider.daily) {
+      const existing = dateMap.get(entry.date);
+      if (existing) {
+        existing.inputTokens += entry.inputTokens;
+        existing.outputTokens += entry.outputTokens;
+        existing.cacheReadTokens += entry.cacheReadTokens;
+        existing.cacheWriteTokens += entry.cacheWriteTokens;
+        existing.totalTokens += entry.totalTokens;
+        existing.cost += entry.cost;
+        existing.models = [...existing.models, ...entry.models];
+      } else {
+        dateMap.set(entry.date, {
+          date: entry.date,
+          inputTokens: entry.inputTokens,
+          outputTokens: entry.outputTokens,
+          cacheReadTokens: entry.cacheReadTokens,
+          cacheWriteTokens: entry.cacheWriteTokens,
+          totalTokens: entry.totalTokens,
+          cost: entry.cost,
+          models: [...entry.models]
+        });
+      }
+    }
+  }
+  return [...dateMap.values()].sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+}
+// packages/core/dist/aggregation/compare.js
+function computeDeltas(statsA, statsB) {
+  return {
+    tokens: statsB.totalTokens - statsA.totalTokens,
+    cost: statsB.totalCost - statsA.totalCost,
+    streak: statsB.currentStreak - statsA.currentStreak,
+    activeDays: statsB.activeDays - statsA.activeDays,
+    averageDailyTokens: statsB.averageDailyTokens - statsA.averageDailyTokens,
+    cacheHitRate: statsB.cacheHitRate - statsA.cacheHitRate
+  };
+}
+function buildCompareOutput(periodA, periodB) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    generated: new Date().toISOString(),
+    periodA,
+    periodB,
+    deltas: computeDeltas(periodA.stats, periodB.stats)
+  };
+}
+function parseCompareRange(rangeStr) {
+  const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+  const parts = rangeStr.split("..");
+  if (parts.length !== 2)
+    return null;
+  const [since, until] = parts;
+  if (!DATE_PATTERN.test(since) || !DATE_PATTERN.test(until))
+    return null;
+  if (since > until)
+    return null;
+  return { since, until };
+}
+function computePreviousPeriod(current) {
+  const ONE_DAY_MS = 86400000;
+  const sinceMs = new Date(current.since).getTime();
+  const untilMs = new Date(current.until).getTime();
+  const periodDays = Math.round((untilMs - sinceMs) / ONE_DAY_MS);
+  const prevUntil = new Date(sinceMs - ONE_DAY_MS);
+  const prevSince = new Date(prevUntil.getTime() - periodDays * ONE_DAY_MS);
+  return {
+    since: prevSince.toISOString().slice(0, 10),
+    until: prevUntil.toISOString().slice(0, 10)
+  };
+}
+// packages/core/dist/index.js
+var VERSION = "0.1.0";
+
+// packages/registry/dist/models/normalizer.js
+var DATE_SUFFIX_PATTERN = /-\d{8}$/;
+function normalizeModelName(model) {
+  return model.replace(DATE_SUFFIX_PATTERN, "");
+}
+// packages/registry/dist/models/pricing.js
+var TOKENS_PER_MILLION = 1e6;
+var MODEL_PRICING = {
+  "claude-3-haiku": {
+    input: 0.25,
+    output: 1.25,
+    cacheRead: 0.03,
+    cacheWrite: 0.3
+  },
+  "claude-3-sonnet": {
+    input: 3,
+    output: 15,
+    cacheRead: 0.3,
+    cacheWrite: 3.75
+  },
+  "claude-3-opus": {
+    input: 15,
+    output: 75,
+    cacheRead: 1.5,
+    cacheWrite: 18.75
+  },
+  "claude-3.5-haiku": {
+    input: 0.8,
+    output: 4,
+    cacheRead: 0.08,
+    cacheWrite: 1
+  },
+  "claude-3.5-sonnet": {
+    input: 3,
+    output: 15,
+    cacheRead: 0.3,
+    cacheWrite: 3.75
+  },
+  "claude-sonnet-4": {
+    input: 3,
+    output: 15,
+    cacheRead: 0.3,
+    cacheWrite: 3.75
+  },
+  "claude-opus-4": {
+    input: 15,
+    output: 75,
+    cacheRead: 1.5,
+    cacheWrite: 18.75
+  },
+  "gpt-4o": {
+    input: 2.5,
+    output: 10,
+    cacheRead: 1.25,
+    cacheWrite: 2.5
+  },
+  "gpt-4o-mini": {
+    input: 0.15,
+    output: 0.6,
+    cacheRead: 0.075,
+    cacheWrite: 0.15
+  },
+  o1: {
+    input: 15,
+    output: 60,
+    cacheRead: 7.5,
+    cacheWrite: 15
+  },
+  "o1-mini": {
+    input: 3,
+    output: 12,
+    cacheRead: 1.5,
+    cacheWrite: 3
+  },
+  o3: {
+    input: 10,
+    output: 40,
+    cacheRead: 5,
+    cacheWrite: 10
+  },
+  "o3-mini": {
+    input: 1.1,
+    output: 4.4,
+    cacheRead: 0.55,
+    cacheWrite: 1.1
+  },
+  "o4-mini": {
+    input: 1.1,
+    output: 4.4,
+    cacheRead: 0.55,
+    cacheWrite: 1.1
+  }
+};
+function getModelPricing(model) {
+  return MODEL_PRICING[model];
+}
+// packages/registry/dist/models/cost.js
+function estimateCost(model, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens) {
+  const normalized = normalizeModelName(model);
+  const pricing = getModelPricing(normalized);
+  if (!pricing) {
+    return 0;
+  }
+  const inputCost = inputTokens / TOKENS_PER_MILLION * pricing.input;
+  const outputCost = outputTokens / TOKENS_PER_MILLION * pricing.output;
+  const cacheReadCost = cacheReadTokens / TOKENS_PER_MILLION * pricing.cacheRead;
+  const cacheWriteCost = cacheWriteTokens / TOKENS_PER_MILLION * pricing.cacheWrite;
+  return inputCost + outputCost + cacheReadCost + cacheWriteCost;
+}
+// packages/registry/dist/registry.js
+class ProviderRegistry {
+  providers = new Map;
+  register(provider) {
+    if (this.providers.has(provider.name)) {
+      throw new Error(`Provider "${provider.name}" is already registered`);
+    }
+    this.providers.set(provider.name, provider);
+  }
+  getAll() {
+    return [...this.providers.values()];
+  }
+  async getAvailable() {
+    const results = await Promise.all(this.getAll().map(async (p) => ({
+      provider: p,
+      available: await p.isAvailable()
+    })));
+    return results.filter((r) => r.available).map((r) => r.provider);
+  }
+  async loadAll(range, concurrency = DEFAULT_CONCURRENCY) {
+    const available = await this.getAvailable();
+    const results = [];
+    const queue = [...available];
+    const runNext = async () => {
+      while (queue.length > 0) {
+        const provider = queue.shift();
+        try {
+          const data = await provider.load(range);
+          results.push({ provider: provider.name, data, error: null });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          results.push({ provider: provider.name, data: null, error: message });
+        }
+      }
+    };
+    const workers = Array.from({ length: Math.min(concurrency, available.length) }, () => runNext());
+    await Promise.all(workers);
+    return results;
+  }
+}
+// packages/registry/dist/parsers/jsonl-splitter.js
+function getMaxRecordBytes() {
+  const envValue = process.env["TOKENLEAK_MAX_JSONL_RECORD_BYTES"];
+  if (envValue !== undefined && envValue !== "") {
+    const parsed = Number(envValue);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      throw new Error(`Invalid TOKENLEAK_MAX_JSONL_RECORD_BYTES value: "${envValue}". Must be a positive number.`);
+    }
+    return parsed;
+  }
+  return MAX_JSONL_RECORD_BYTES;
+}
+async function* splitJsonlRecords(filePath) {
+  const maxBytes = getMaxRecordBytes();
+  const file = Bun.file(filePath);
+  const text = await file.text();
+  const lines = text.split(`
+`);
+  let lineNumber = 0;
+  for (const line of lines) {
+    lineNumber++;
+    if (line.trim() === "") {
+      continue;
+    }
+    const byteLength = new TextEncoder().encode(line).byteLength;
+    if (byteLength > maxBytes) {
+      throw new Error(`Oversized JSONL record in ${filePath} at line ${lineNumber}: ${byteLength} bytes exceeds limit of ${maxBytes} bytes`);
+    }
+    try {
+      yield JSON.parse(line);
+    } catch {
+      throw new Error(`Malformed JSON in ${filePath} at line ${lineNumber}: unable to parse`);
+    }
+  }
+}
+// packages/registry/dist/providers/claude-code.js
+import { existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_BASE_DIR = join(homedir(), ".claude", "projects");
+var CLAUDE_CODE_COLORS = {
+  primary: "#ff6b35",
+  secondary: "#ffa366",
+  gradient: ["#ff6b35", "#ffa366"]
+};
+function collectJsonlFiles(dir) {
+  const results = [];
+  if (!existsSync(dir)) {
+    return results;
+  }
+  const entries = readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      results.push(...collectJsonlFiles(fullPath));
+    } else if (entry.endsWith(".jsonl")) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function extractUsage(record) {
+  if (typeof record !== "object" || record === null) {
+    return null;
+  }
+  const rec = record;
+  if (rec["type"] !== "assistant") {
+    return null;
+  }
+  const timestamp = rec["timestamp"];
+  if (typeof timestamp !== "string") {
+    return null;
+  }
+  const message = rec["message"];
+  if (typeof message !== "object" || message === null) {
+    return null;
+  }
+  const msg = message;
+  const usage = msg["usage"];
+  if (typeof usage !== "object" || usage === null) {
+    return null;
+  }
+  const model = msg["model"];
+  if (typeof model !== "string") {
+    return null;
+  }
+  const u = usage;
+  const inputTokens = typeof u["input_tokens"] === "number" ? u["input_tokens"] : 0;
+  const outputTokens = typeof u["output_tokens"] === "number" ? u["output_tokens"] : 0;
+  const cacheReadTokens = typeof u["cache_read_input_tokens"] === "number" ? u["cache_read_input_tokens"] : 0;
+  const cacheWriteTokens = typeof u["cache_creation_input_tokens"] === "number" ? u["cache_creation_input_tokens"] : 0;
+  const date = timestamp.slice(0, 10);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+    return null;
+  }
+  return {
+    date,
+    model,
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens
+  };
+}
+function isInRange(date, range) {
+  return date >= range.since && date <= range.until;
+}
+function buildDailyUsage(records) {
+  const byDate = new Map;
+  for (const rec of records) {
+    const normalizedModel = normalizeModelName(rec.model);
+    const cost = estimateCost(rec.model, rec.inputTokens, rec.outputTokens, rec.cacheReadTokens, rec.cacheWriteTokens);
+    let dateModels = byDate.get(rec.date);
+    if (!dateModels) {
+      dateModels = new Map;
+      byDate.set(rec.date, dateModels);
+    }
+    let mb = dateModels.get(normalizedModel);
+    if (!mb) {
+      mb = {
+        model: normalizedModel,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        cost: 0
+      };
+      dateModels.set(normalizedModel, mb);
+    }
+    mb.inputTokens += rec.inputTokens;
+    mb.outputTokens += rec.outputTokens;
+    mb.cacheReadTokens += rec.cacheReadTokens;
+    mb.cacheWriteTokens += rec.cacheWriteTokens;
+    mb.totalTokens += rec.inputTokens + rec.outputTokens;
+    mb.cost += cost;
+  }
+  const daily = [];
+  for (const [date, dateModels] of byDate) {
+    const models = [...dateModels.values()];
+    const inputTokens = models.reduce((sum, m) => sum + m.inputTokens, 0);
+    const outputTokens = models.reduce((sum, m) => sum + m.outputTokens, 0);
+    const cacheReadTokens = models.reduce((sum, m) => sum + m.cacheReadTokens, 0);
+    const cacheWriteTokens = models.reduce((sum, m) => sum + m.cacheWriteTokens, 0);
+    const totalTokens = models.reduce((sum, m) => sum + m.totalTokens, 0);
+    const cost = models.reduce((sum, m) => sum + m.cost, 0);
+    daily.push({
+      date,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      totalTokens,
+      cost,
+      models
+    });
+  }
+  daily.sort((a, b) => a.date.localeCompare(b.date));
+  return daily;
+}
+
+class ClaudeCodeProvider {
+  name = "claude-code";
+  displayName = "Claude Code";
+  colors = CLAUDE_CODE_COLORS;
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? DEFAULT_BASE_DIR;
+  }
+  async isAvailable() {
+    try {
+      return existsSync(this.baseDir);
+    } catch {
+      return false;
+    }
+  }
+  async load(range) {
+    const files = collectJsonlFiles(this.baseDir);
+    const allRecords = [];
+    for (const file of files) {
+      for await (const record of splitJsonlRecords(file)) {
+        const usage = extractUsage(record);
+        if (usage !== null && isInRange(usage.date, range)) {
+          allRecords.push(usage);
+        }
+      }
+    }
+    const daily = buildDailyUsage(allRecords);
+    const totalTokens = daily.reduce((sum, d) => sum + d.totalTokens, 0);
+    const totalCost = daily.reduce((sum, d) => sum + d.cost, 0);
+    return {
+      provider: this.name,
+      displayName: this.displayName,
+      daily,
+      totalTokens,
+      totalCost,
+      colors: this.colors
+    };
+  }
+}
+// packages/registry/dist/providers/codex.js
+import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var CODEX_COLORS = {
+  primary: "#10a37f",
+  secondary: "#4ade80",
+  gradient: ["#10a37f", "#4ade80"]
+};
+var DEFAULT_SESSIONS_DIR = join2(homedir2(), ".codex", "sessions");
+function parseResponseEvent(record) {
+  if (typeof record !== "object" || record === null || !("type" in record)) {
+    return null;
+  }
+  const obj = record;
+  if (obj["type"] !== "response") {
+    return null;
+  }
+  if (typeof obj["timestamp"] !== "string" || typeof obj["model"] !== "string" || typeof obj["usage"] !== "object" || obj["usage"] === null) {
+    return null;
+  }
+  const usage = obj["usage"];
+  if (typeof usage["input_tokens"] !== "number" || typeof usage["output_tokens"] !== "number" || typeof usage["total_tokens"] !== "number") {
+    return null;
+  }
+  return {
+    type: "response",
+    timestamp: obj["timestamp"],
+    model: obj["model"],
+    usage: {
+      input_tokens: usage["input_tokens"],
+      output_tokens: usage["output_tokens"],
+      total_tokens: usage["total_tokens"]
+    }
+  };
+}
+var DASHED_DATE_SUFFIX = /-(\d{4})-(\d{2})-(\d{2})$/;
+function compactModelDateSuffix(model) {
+  return model.replace(DASHED_DATE_SUFFIX, "-$1$2$3");
+}
+function extractDate(timestamp) {
+  const match = /^(\d{4}-\d{2}-\d{2})/.exec(timestamp);
+  return match ? match[1] : null;
+}
+function isInRange2(date, range) {
+  return date >= range.since && date <= range.until;
+}
+
+class CodexProvider {
+  name = "codex";
+  displayName = "Codex";
+  colors = CODEX_COLORS;
+  sessionsDir;
+  constructor(baseDir) {
+    this.sessionsDir = baseDir ?? DEFAULT_SESSIONS_DIR;
+  }
+  async isAvailable() {
+    try {
+      return existsSync2(this.sessionsDir);
+    } catch {
+      return false;
+    }
+  }
+  async load(range) {
+    const dailyMap = new Map;
+    let files;
+    try {
+      files = readdirSync2(this.sessionsDir).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      files = [];
+    }
+    for (const file of files) {
+      const filePath = join2(this.sessionsDir, file);
+      for await (const record of splitJsonlRecords(filePath)) {
+        const event = parseResponseEvent(record);
+        if (!event) {
+          continue;
+        }
+        const date = extractDate(event.timestamp);
+        if (!date || !isInRange2(date, range)) {
+          continue;
+        }
+        const normalizedModel = normalizeModelName(compactModelDateSuffix(event.model));
+        const inputTokens = event.usage.input_tokens;
+        const outputTokens = event.usage.output_tokens;
+        const cacheReadTokens = 0;
+        const cacheWriteTokens = 0;
+        const cost = estimateCost(normalizedModel, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens);
+        if (!dailyMap.has(date)) {
+          dailyMap.set(date, new Map);
+        }
+        const modelMap = dailyMap.get(date);
+        if (!modelMap.has(normalizedModel)) {
+          modelMap.set(normalizedModel, {
+            model: normalizedModel,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0,
+            totalTokens: 0,
+            cost: 0
+          });
+        }
+        const breakdown = modelMap.get(normalizedModel);
+        breakdown.inputTokens += inputTokens;
+        breakdown.outputTokens += outputTokens;
+        breakdown.totalTokens += inputTokens + outputTokens;
+        breakdown.cost += cost;
+      }
+    }
+    const daily = [...dailyMap.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([date, modelMap]) => {
+      const models = [...modelMap.values()];
+      const inputTokens = models.reduce((s, m) => s + m.inputTokens, 0);
+      const outputTokens = models.reduce((s, m) => s + m.outputTokens, 0);
+      const cacheReadTokens = models.reduce((s, m) => s + m.cacheReadTokens, 0);
+      const cacheWriteTokens = models.reduce((s, m) => s + m.cacheWriteTokens, 0);
+      const totalTokens2 = models.reduce((s, m) => s + m.totalTokens, 0);
+      const cost = models.reduce((s, m) => s + m.cost, 0);
+      return {
+        date,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        totalTokens: totalTokens2,
+        cost,
+        models
+      };
+    });
+    const totalTokens = daily.reduce((s, d) => s + d.totalTokens, 0);
+    const totalCost = daily.reduce((s, d) => s + d.cost, 0);
+    return {
+      provider: this.name,
+      displayName: this.displayName,
+      daily,
+      totalTokens,
+      totalCost,
+      colors: this.colors
+    };
+  }
+}
+// packages/registry/dist/providers/open-code.js
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { Database } from "bun:sqlite";
+var PROVIDER_NAME = "open-code";
+var DISPLAY_NAME = "Open Code";
+var COLORS = {
+  primary: "#6366f1",
+  secondary: "#a78bfa",
+  gradient: ["#6366f1", "#a78bfa"]
+};
+function extractDate2(createdAt) {
+  if (typeof createdAt === "number") {
+    return new Date(createdAt * 1000).toISOString().slice(0, 10);
+  }
+  const asNum = Number(createdAt);
+  if (!Number.isNaN(asNum) && String(asNum) === String(createdAt).trim()) {
+    return new Date(asNum * 1000).toISOString().slice(0, 10);
+  }
+  return new Date(createdAt).toISOString().slice(0, 10);
+}
+function isWithinRange(date, range) {
+  return date >= range.since && date <= range.until;
+}
+function buildProviderData(records) {
+  const byDate = new Map;
+  for (const record of records) {
+    let dateMap = byDate.get(record.date);
+    if (!dateMap) {
+      dateMap = new Map;
+      byDate.set(record.date, dateMap);
+    }
+    const normalized = normalizeModelName(record.model);
+    const existing = dateMap.get(normalized);
+    if (existing) {
+      existing.inputTokens += record.inputTokens;
+      existing.outputTokens += record.outputTokens;
+    } else {
+      dateMap.set(normalized, {
+        inputTokens: record.inputTokens,
+        outputTokens: record.outputTokens
+      });
+    }
+  }
+  let totalTokens = 0;
+  let totalCost = 0;
+  const daily = [...byDate.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([date, modelMap]) => {
+    const models = [];
+    let dayInput = 0;
+    let dayOutput = 0;
+    let dayCost = 0;
+    for (const [model, usage] of modelMap) {
+      const cost = estimateCost(model, usage.inputTokens, usage.outputTokens, 0, 0);
+      const modelTotal = usage.inputTokens + usage.outputTokens;
+      models.push({
+        model,
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: modelTotal,
+        cost
+      });
+      dayInput += usage.inputTokens;
+      dayOutput += usage.outputTokens;
+      dayCost += cost;
+    }
+    const dayTotal = dayInput + dayOutput;
+    totalTokens += dayTotal;
+    totalCost += dayCost;
+    return {
+      date,
+      inputTokens: dayInput,
+      outputTokens: dayOutput,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      totalTokens: dayTotal,
+      cost: dayCost,
+      models
+    };
+  });
+  return {
+    provider: PROVIDER_NAME,
+    displayName: DISPLAY_NAME,
+    daily,
+    totalTokens,
+    totalCost,
+    colors: COLORS
+  };
+}
+function loadFromSqlite(dbPath, range) {
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    const rows = db.query("SELECT model, input_tokens, output_tokens, created_at FROM messages WHERE role = 'assistant'").all();
+    const records = [];
+    for (const row of rows) {
+      const date = extractDate2(row.created_at);
+      if (isWithinRange(date, range)) {
+        records.push({
+          date,
+          model: row.model,
+          inputTokens: row.input_tokens,
+          outputTokens: row.output_tokens
+        });
+      }
+    }
+    return records;
+  } finally {
+    db.close();
+  }
+}
+function loadFromJson(sessionsDir, range) {
+  const files = readdirSync3(sessionsDir).filter((f) => f.endsWith(".json"));
+  const records = [];
+  for (const file of files) {
+    const content = readFileSync(join3(sessionsDir, file), "utf-8");
+    const session = JSON.parse(content);
+    if (!Array.isArray(session.messages)) {
+      continue;
+    }
+    for (const msg of session.messages) {
+      if (msg.role !== "assistant" || !msg.usage) {
+        continue;
+      }
+      const date = extractDate2(msg.created_at);
+      if (isWithinRange(date, range)) {
+        records.push({
+          date,
+          model: msg.model,
+          inputTokens: msg.usage.input_tokens,
+          outputTokens: msg.usage.output_tokens
+        });
+      }
+    }
+  }
+  return records;
+}
+
+class OpenCodeProvider {
+  name = PROVIDER_NAME;
+  displayName = DISPLAY_NAME;
+  colors = COLORS;
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? join3(homedir3(), ".opencode");
+  }
+  async isAvailable() {
+    try {
+      if (!existsSync3(this.baseDir)) {
+        return false;
+      }
+      const hasDb = existsSync3(join3(this.baseDir, "sessions.db"));
+      const hasSessionsDir = existsSync3(join3(this.baseDir, "sessions"));
+      return hasDb || hasSessionsDir;
+    } catch {
+      return false;
+    }
+  }
+  async load(range) {
+    const dbPath = join3(this.baseDir, "sessions.db");
+    const sessionsDir = join3(this.baseDir, "sessions");
+    let records;
+    if (existsSync3(dbPath)) {
+      records = loadFromSqlite(dbPath, range);
+    } else if (existsSync3(sessionsDir)) {
+      records = loadFromJson(sessionsDir, range);
+    } else {
+      records = [];
+    }
+    return buildProviderData(records);
+  }
+}
+// packages/renderers/dist/json/json-renderer.js
+class JsonRenderer {
+  format = "json";
+  async render(output, _options) {
+    return JSON.stringify(output, null, 2);
+  }
+}
+// packages/renderers/dist/svg/theme.js
+var DARK_THEME = {
+  background: "#0d1117",
+  foreground: "#e6edf3",
+  muted: "#7d8590",
+  border: "#30363d",
+  cardBackground: "#161b22",
+  heatmap: ["#161b22", "#0e4429", "#006d32", "#26a641", "#39d353"],
+  accent: "#58a6ff",
+  accentSecondary: "#bc8cff",
+  barFill: "#58a6ff",
+  barBackground: "#21262d"
+};
+var LIGHT_THEME = {
+  background: "#ffffff",
+  foreground: "#1f2328",
+  muted: "#656d76",
+  border: "#d0d7de",
+  cardBackground: "#f6f8fa",
+  heatmap: ["#ebedf0", "#9be9a8", "#40c463", "#30a14e", "#216e39"],
+  accent: "#0969da",
+  accentSecondary: "#8250df",
+  barFill: "#0969da",
+  barBackground: "#eaeef2"
+};
+function getTheme(mode) {
+  return mode === "dark" ? DARK_THEME : LIGHT_THEME;
+}
+
+// packages/renderers/dist/svg/layout.js
+var PADDING = 24;
+var CELL_SIZE = 12;
+var CELL_GAP = 3;
+var HEADER_HEIGHT = 60;
+var MONTH_LABEL_HEIGHT = 20;
+var DAY_LABEL_WIDTH = 32;
+var HEATMAP_ROWS = 7;
+var SECTION_GAP = 28;
+var STAT_ROW_HEIGHT = 28;
+var BAR_HEIGHT = 20;
+var BAR_GAP = 8;
+var BAR_LABEL_WIDTH = 120;
+var FONT_SIZE_TITLE = 20;
+var FONT_SIZE_SUBTITLE = 14;
+var FONT_SIZE_BODY = 12;
+var FONT_SIZE_SMALL = 10;
+var FONT_FAMILY = "-apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif";
+
+// packages/renderers/dist/svg/utils.js
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function rect(x, y, w, h, fill, rx) {
+  const rxAttr = rx !== undefined ? ` rx="${rx}"` : "";
+  return `<rect x="${x}" y="${y}" width="${w}" height="${h}" fill="${escapeXml(fill)}"${rxAttr}/>`;
+}
+function text(x, y, content, attrs) {
+  const attrStr = attrs ? Object.entries(attrs).map(([k, v]) => ` ${k}="${typeof v === "string" ? escapeXml(v) : v}"`).join("") : "";
+  return `<text x="${x}" y="${y}"${attrStr}>${escapeXml(content)}</text>`;
+}
+function group(children, transform) {
+  const transformAttr = transform ? ` transform="${escapeXml(transform)}"` : "";
+  return `<g${transformAttr}>${children.join("")}</g>`;
+}
+function formatNumber(n) {
+  if (n >= 1e6) {
+    return `${(n / 1e6).toFixed(1)}M`;
+  }
+  if (n >= 1000) {
+    return `${(n / 1000).toFixed(1)}K`;
+  }
+  return n.toFixed(0);
+}
+function formatCost(cost) {
+  if (cost >= 100) {
+    return `$${cost.toFixed(0)}`;
+  }
+  if (cost >= 1) {
+    return `$${cost.toFixed(2)}`;
+  }
+  return `$${cost.toFixed(4)}`;
+}
+function formatPercent(rate) {
+  return `${(rate * 100).toFixed(1)}%`;
+}
+
+// packages/renderers/dist/svg/heatmap.js
+var DAY_LABELS2 = ["", "Mon", "", "Wed", "", "Fri", ""];
+var MONTH_NAMES = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function getLevel(tokens, quantiles) {
+  if (tokens <= 0)
+    return 0;
+  if (tokens <= quantiles[0])
+    return 1;
+  if (tokens <= quantiles[1])
+    return 2;
+  if (tokens <= quantiles[2])
+    return 3;
+  return 4;
+}
+function computeQuantiles(values) {
+  const nonZero = values.filter((v) => v > 0).sort((a, b) => a - b);
+  if (nonZero.length === 0)
+    return [0, 0, 0];
+  const q = (p) => {
+    const idx = Math.floor(p * (nonZero.length - 1));
+    return nonZero[idx] ?? 0;
+  };
+  return [q(0.25), q(0.5), q(0.75)];
+}
+function renderHeatmap(daily, theme, options = {}) {
+  const tokenMap = new Map;
+  for (const d of daily) {
+    const existing = tokenMap.get(d.date) ?? 0;
+    tokenMap.set(d.date, existing + d.totalTokens);
+  }
+  const dates = daily.map((d) => d.date).sort();
+  const endStr = options.endDate ?? dates[dates.length - 1] ?? new Date().toISOString().slice(0, 10);
+  const startStr = options.startDate ?? dates[0] ?? endStr;
+  const end = new Date(endStr);
+  const start = new Date(startStr);
+  const startDay = start.getDay();
+  start.setDate(start.getDate() - startDay);
+  const cells = [];
+  const allTokens = Array.from(tokenMap.values());
+  const quantiles = computeQuantiles(allTokens);
+  const current = new Date(start);
+  let col = 0;
+  const monthLabels = [];
+  let lastMonth = -1;
+  while (current <= end) {
+    const row = current.getDay();
+    const dateStr = current.toISOString().slice(0, 10);
+    const tokens = tokenMap.get(dateStr) ?? 0;
+    const level = getLevel(tokens, quantiles);
+    const x = DAY_LABEL_WIDTH + col * (CELL_SIZE + CELL_GAP);
+    const y = MONTH_LABEL_HEIGHT + row * (CELL_SIZE + CELL_GAP);
+    const title = `${dateStr}: ${tokens.toLocaleString()} tokens`;
+    cells.push(`<rect x="${x}" y="${y}" width="${CELL_SIZE}" height="${CELL_SIZE}" fill="${escapeXml(theme.heatmap[level])}" rx="2"><title>${escapeXml(title)}</title></rect>`);
+    const month = current.getMonth();
+    if (month !== lastMonth && row === 0) {
+      lastMonth = month;
+      monthLabels.push(text(x, MONTH_LABEL_HEIGHT - 6, MONTH_NAMES[month] ?? "", {
+        fill: theme.muted,
+        "font-size": FONT_SIZE_SMALL,
+        "font-family": FONT_FAMILY
+      }));
+    }
+    if (row === 6) {
+      col++;
+    }
+    current.setDate(current.getDate() + 1);
+  }
+  const dayLabels = DAY_LABELS2.map((label, i) => {
+    if (!label)
+      return "";
+    const y = MONTH_LABEL_HEIGHT + i * (CELL_SIZE + CELL_GAP) + CELL_SIZE - 1;
+    return text(0, y, label, {
+      fill: theme.muted,
+      "font-size": FONT_SIZE_SMALL,
+      "font-family": FONT_FAMILY
+    });
+  });
+  const totalCols = col + 1;
+  const width = DAY_LABEL_WIDTH + totalCols * (CELL_SIZE + CELL_GAP);
+  const height = MONTH_LABEL_HEIGHT + HEATMAP_ROWS * (CELL_SIZE + CELL_GAP);
+  const svg = group([...monthLabels, ...dayLabels, ...cells]);
+  return { svg, width, height };
+}
+
+// packages/renderers/dist/svg/stats-panel.js
+function buildStatItems(stats) {
+  return [
+    { label: "Current Streak", value: `${stats.currentStreak} days` },
+    { label: "Longest Streak", value: `${stats.longestStreak} days` },
+    { label: "Total Tokens", value: formatNumber(stats.totalTokens) },
+    { label: "Total Cost", value: formatCost(stats.totalCost) },
+    { label: "30-Day Tokens", value: formatNumber(stats.rolling30dTokens) },
+    { label: "30-Day Cost", value: formatCost(stats.rolling30dCost) },
+    { label: "Avg Daily Tokens", value: formatNumber(stats.averageDailyTokens) },
+    { label: "Cache Hit Rate", value: formatPercent(stats.cacheHitRate) },
+    { label: "Active Days", value: `${stats.activeDays} / ${stats.totalDays}` }
+  ];
+}
+function renderStatsPanel(stats, theme) {
+  const items = buildStatItems(stats);
+  const width = 280;
+  const children = [];
+  for (let i = 0;i < items.length; i++) {
+    const item = items[i];
+    if (!item)
+      continue;
+    const y = i * STAT_ROW_HEIGHT + STAT_ROW_HEIGHT;
+    children.push(text(0, y, item.label, {
+      fill: theme.muted,
+      "font-size": FONT_SIZE_SMALL,
+      "font-family": FONT_FAMILY
+    }));
+    children.push(text(width - 8, y, item.value, {
+      fill: theme.foreground,
+      "font-size": FONT_SIZE_BODY,
+      "font-family": FONT_FAMILY,
+      "text-anchor": "end"
+    }));
+  }
+  const height = items.length * STAT_ROW_HEIGHT + STAT_ROW_HEIGHT;
+  return { svg: group(children), width, height };
+}
+
+// packages/renderers/dist/svg/insights-panel.js
+var DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function buildInsights(stats, providers) {
+  const items = [];
+  if (stats.peakDay) {
+    items.push({
+      label: "Peak Day",
+      value: `${stats.peakDay.date} (${formatNumber(stats.peakDay.tokens)} tokens)`
+    });
+  }
+  if (stats.dayOfWeek.length > 0) {
+    const sorted = [...stats.dayOfWeek].sort((a, b) => b.tokens - a.tokens);
+    const top = sorted[0];
+    if (top) {
+      items.push({
+        label: "Most Active Day",
+        value: DAY_NAMES[top.day] ?? top.label
+      });
+    }
+  }
+  if (stats.topModels.length > 0) {
+    const top = stats.topModels[0];
+    if (top) {
+      items.push({
+        label: "Top Model",
+        value: `${top.model} (${top.percentage.toFixed(1)}%)`
+      });
+    }
+  }
+  if (providers.length > 0) {
+    const sorted = [...providers].sort((a, b) => b.totalTokens - a.totalTokens);
+    const top = sorted[0];
+    if (top) {
+      items.push({
+        label: "Top Provider",
+        value: `${top.displayName} (${formatNumber(top.totalTokens)} tokens)`
+      });
+    }
+  }
+  return items;
+}
+function renderInsightsPanel(stats, providers, theme) {
+  const items = buildInsights(stats, providers);
+  const width = 360;
+  const children = [];
+  for (let i = 0;i < items.length; i++) {
+    const item = items[i];
+    if (!item)
+      continue;
+    const y = i * STAT_ROW_HEIGHT + STAT_ROW_HEIGHT;
+    children.push(text(0, y, item.label, {
+      fill: theme.muted,
+      "font-size": FONT_SIZE_SMALL,
+      "font-family": FONT_FAMILY
+    }));
+    children.push(text(width - 8, y, item.value, {
+      fill: theme.foreground,
+      "font-size": FONT_SIZE_BODY,
+      "font-family": FONT_FAMILY,
+      "text-anchor": "end"
+    }));
+  }
+  const height = Math.max(items.length * STAT_ROW_HEIGHT + STAT_ROW_HEIGHT, STAT_ROW_HEIGHT);
+  return { svg: group(children), width, height };
+}
+
+// packages/renderers/dist/svg/day-of-week-chart.js
+function renderDayOfWeekChart(dayOfWeek, theme) {
+  const chartWidth = 300;
+  const barAreaWidth = chartWidth - BAR_LABEL_WIDTH;
+  const maxTokens = Math.max(...dayOfWeek.map((d) => d.tokens), 1);
+  const children = [];
+  for (let i = 0;i < dayOfWeek.length; i++) {
+    const entry = dayOfWeek[i];
+    if (!entry)
+      continue;
+    const y = i * (BAR_HEIGHT + BAR_GAP);
+    const barWidth = Math.max(entry.tokens / maxTokens * barAreaWidth, 0);
+    children.push(text(0, y + BAR_HEIGHT - 4, entry.label, {
+      fill: theme.muted,
+      "font-size": FONT_SIZE_SMALL,
+      "font-family": FONT_FAMILY
+    }));
+    children.push(rect(BAR_LABEL_WIDTH, y, barAreaWidth, BAR_HEIGHT, theme.barBackground, 3));
+    if (barWidth > 0) {
+      children.push(rect(BAR_LABEL_WIDTH, y, barWidth, BAR_HEIGHT, theme.barFill, 3));
+    }
+    children.push(text(BAR_LABEL_WIDTH + barAreaWidth + 8, y + BAR_HEIGHT - 4, formatNumber(entry.tokens), {
+      fill: theme.foreground,
+      "font-size": FONT_SIZE_SMALL,
+      "font-family": FONT_FAMILY
+    }));
+  }
+  const height = dayOfWeek.length * (BAR_HEIGHT + BAR_GAP);
+  const width = chartWidth + 60;
+  return { svg: group(children), width, height };
+}
+
+// packages/renderers/dist/svg/model-chart.js
+function renderModelChart(topModels2, theme) {
+  const chartWidth = 360;
+  const barAreaWidth = chartWidth - BAR_LABEL_WIDTH;
+  const maxTokens = Math.max(...topModels2.map((m) => m.tokens), 1);
+  const children = [];
+  for (let i = 0;i < topModels2.length; i++) {
+    const entry = topModels2[i];
+    if (!entry)
+      continue;
+    const y = i * (BAR_HEIGHT + BAR_GAP);
+    const barWidth = Math.max(entry.tokens / maxTokens * barAreaWidth, 0);
+    const label = entry.model.length > 18 ? entry.model.slice(0, 17) + "\u2026" : entry.model;
+    children.push(text(0, y + BAR_HEIGHT - 4, label, {
+      fill: theme.muted,
+      "font-size": FONT_SIZE_SMALL,
+      "font-family": FONT_FAMILY
+    }));
+    children.push(rect(BAR_LABEL_WIDTH, y, barAreaWidth, BAR_HEIGHT, theme.barBackground, 3));
+    if (barWidth > 0) {
+      children.push(rect(BAR_LABEL_WIDTH, y, barWidth, BAR_HEIGHT, theme.accentSecondary, 3));
+    }
+    const valueStr = `${formatNumber(entry.tokens)} (${entry.percentage.toFixed(1)}%)`;
+    children.push(text(BAR_LABEL_WIDTH + barAreaWidth + 8, y + BAR_HEIGHT - 4, valueStr, {
+      fill: theme.foreground,
+      "font-size": FONT_SIZE_SMALL,
+      "font-family": FONT_FAMILY
+    }));
+  }
+  const height = Math.max(topModels2.length * (BAR_HEIGHT + BAR_GAP), BAR_HEIGHT);
+  const width = chartWidth + 100;
+  return { svg: group(children), width, height };
+}
+
+// packages/renderers/dist/svg/svg-renderer.js
+class SvgRenderer {
+  format = "svg";
+  async render(output, options) {
+    const theme = getTheme(options.theme);
+    const contentWidth = options.width - PADDING * 2;
+    let y = PADDING;
+    const sections = [];
+    sections.push(group([
+      text(PADDING, y + FONT_SIZE_TITLE + 4, "Tokenleak", {
+        fill: theme.foreground,
+        "font-size": FONT_SIZE_TITLE,
+        "font-family": FONT_FAMILY,
+        "font-weight": "bold"
+      }),
+      text(PADDING, y + FONT_SIZE_TITLE + 4 + 20, `${output.dateRange.since} \u2014 ${output.dateRange.until}`, {
+        fill: theme.muted,
+        "font-size": FONT_SIZE_SUBTITLE,
+        "font-family": FONT_FAMILY
+      })
+    ]));
+    y += HEADER_HEIGHT + SECTION_GAP;
+    if (output.providers.length > 0) {
+      const providerNames = output.providers.map((p) => p.displayName).join(" \xB7 ");
+      sections.push(text(PADDING, y, providerNames, {
+        fill: theme.accent,
+        "font-size": FONT_SIZE_SUBTITLE,
+        "font-family": FONT_FAMILY
+      }));
+      y += SECTION_GAP;
+    }
+    const allDaily = output.providers.flatMap((p) => p.daily);
+    if (allDaily.length > 0) {
+      sections.push(text(PADDING, y, "Activity", {
+        fill: theme.foreground,
+        "font-size": FONT_SIZE_SUBTITLE,
+        "font-family": FONT_FAMILY,
+        "font-weight": "bold"
+      }));
+      y += 16;
+      const heatmap = renderHeatmap(allDaily, theme, {
+        startDate: output.dateRange.since,
+        endDate: output.dateRange.until
+      });
+      sections.push(group([heatmap.svg], `translate(${PADDING}, ${y})`));
+      y += heatmap.height + SECTION_GAP;
+    }
+    sections.push(text(PADDING, y, "Statistics", {
+      fill: theme.foreground,
+      "font-size": FONT_SIZE_SUBTITLE,
+      "font-family": FONT_FAMILY,
+      "font-weight": "bold"
+    }));
+    y += 16;
+    const stats = renderStatsPanel(output.aggregated, theme);
+    sections.push(group([stats.svg], `translate(${PADDING}, ${y})`));
+    y += stats.height + SECTION_GAP;
+    if (output.aggregated.dayOfWeek.length > 0) {
+      sections.push(text(PADDING, y, "Day of Week", {
+        fill: theme.foreground,
+        "font-size": FONT_SIZE_SUBTITLE,
+        "font-family": FONT_FAMILY,
+        "font-weight": "bold"
+      }));
+      y += 16;
+      const dowChart = renderDayOfWeekChart(output.aggregated.dayOfWeek, theme);
+      sections.push(group([dowChart.svg], `translate(${PADDING}, ${y})`));
+      y += dowChart.height + SECTION_GAP;
+    }
+    if (output.aggregated.topModels.length > 0) {
+      sections.push(text(PADDING, y, "Top Models", {
+        fill: theme.foreground,
+        "font-size": FONT_SIZE_SUBTITLE,
+        "font-family": FONT_FAMILY,
+        "font-weight": "bold"
+      }));
+      y += 16;
+      const modelChart = renderModelChart(output.aggregated.topModels, theme);
+      sections.push(group([modelChart.svg], `translate(${PADDING}, ${y})`));
+      y += modelChart.height + SECTION_GAP;
+    }
+    if (options.showInsights) {
+      sections.push(text(PADDING, y, "Insights", {
+        fill: theme.foreground,
+        "font-size": FONT_SIZE_SUBTITLE,
+        "font-family": FONT_FAMILY,
+        "font-weight": "bold"
+      }));
+      y += 16;
+      const insights = renderInsightsPanel(output.aggregated, output.providers, theme);
+      sections.push(group([insights.svg], `translate(${PADDING}, ${y})`));
+      y += insights.height + SECTION_GAP;
+    }
+    const totalHeight = y + PADDING;
+    const svgContent = [
+      `<svg xmlns="http://www.w3.org/2000/svg" width="${options.width}" height="${totalHeight}" viewBox="0 0 ${options.width} ${totalHeight}">`,
+      rect(0, 0, options.width, totalHeight, theme.background, 8),
+      ...sections,
+      "</svg>"
+    ].join(`
+`);
+    return svgContent;
+  }
+}
+// packages/renderers/dist/png/png-renderer.js
+import sharp from "sharp";
+
+class PngRenderer {
+  format = "png";
+  svgRenderer = new SvgRenderer;
+  async render(output, options) {
+    const svgString = await this.svgRenderer.render(output, options);
+    const pngBuffer = await sharp(Buffer.from(svgString)).png().toBuffer();
+    return pngBuffer;
+  }
+}
+// packages/renderers/dist/terminal/ansi.js
+var ESC = "\x1B[";
+var CODES = {
+  green: `${ESC}32m`,
+  yellow: `${ESC}33m`,
+  red: `${ESC}31m`,
+  cyan: `${ESC}36m`,
+  bold: `${ESC}1m`,
+  dim: `${ESC}2m`,
+  reset: `${ESC}0m`
+};
+// packages/cli/src/config.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+var CONFIG_FILENAME = ".tokenleakrc";
+function loadConfig() {
+  try {
+    const configPath = join4(homedir4(), CONFIG_FILENAME);
+    const raw = readFileSync2(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+// packages/cli/src/env.ts
+var VALID_FORMATS = new Set(["json", "svg", "png", "terminal"]);
+var VALID_THEMES = new Set(["dark", "light"]);
+function loadEnvOverrides() {
+  const overrides = {};
+  const format = process.env["TOKENLEAK_FORMAT"];
+  if (format && VALID_FORMATS.has(format)) {
+    overrides.format = format;
+  }
+  const theme = process.env["TOKENLEAK_THEME"];
+  if (theme && VALID_THEMES.has(theme)) {
+    overrides.theme = theme;
+  }
+  const days = process.env["TOKENLEAK_DAYS"];
+  if (days !== undefined && days !== "") {
+    const parsed = Number(days);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      overrides.days = parsed;
+    }
+  }
+  return overrides;
+}
+
+// packages/cli/src/errors.ts
+class TokenleakError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TokenleakError";
+  }
+}
+function handleError(error) {
+  if (error instanceof TokenleakError) {
+    process.stderr.write(`Error: ${error.message}
+`);
+  } else if (error instanceof Error) {
+    process.stderr.write(`Error: ${error.message}
+`);
+  } else {
+    process.stderr.write(`Error: ${String(error)}
+`);
+  }
+  process.exit(1);
+}
+
+// packages/cli/src/sharing/clipboard.ts
+var PLATFORM_COMMANDS = {
+  darwin: ["pbcopy"],
+  linux: ["xclip", "-selection", "clipboard"],
+  win32: ["clip"]
+};
+function getClipboardCommand(platform = process.platform) {
+  const command = PLATFORM_COMMANDS[platform];
+  if (!command) {
+    throw new Error(`Clipboard is not supported on platform "${platform}". Supported: macOS, Linux, Windows.`);
+  }
+  return command;
+}
+async function copyToClipboard(content, platform = process.platform) {
+  const [cmd, ...args] = getClipboardCommand(platform);
+  const proc = Bun.spawn([cmd, ...args], {
+    stdin: "pipe",
+    stdout: "ignore",
+    stderr: "pipe"
+  });
+  proc.stdin.write(content);
+  proc.stdin.end();
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Clipboard command "${cmd}" failed with exit code ${exitCode}: ${stderr.trim()}`);
+  }
+}
+// packages/cli/src/sharing/open.ts
+var PLATFORM_COMMANDS2 = {
+  darwin: "open",
+  linux: "xdg-open",
+  win32: "start"
+};
+function getOpenCommand(platform = process.platform) {
+  const command = PLATFORM_COMMANDS2[platform];
+  if (!command) {
+    throw new Error(`Opening files is not supported on platform "${platform}". Supported: macOS, Linux, Windows.`);
+  }
+  return command;
+}
+async function openFile(filePath, platform = process.platform) {
+  const cmd = getOpenCommand(platform);
+  const spawnArgs = platform === "win32" ? ["cmd", "/c", "start", "", filePath] : [cmd, filePath];
+  const proc = Bun.spawn(spawnArgs, {
+    stdout: "ignore",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Failed to open "${filePath}" with "${cmd}": exit code ${exitCode}: ${stderr.trim()}`);
+  }
+}
+// packages/cli/src/sharing/gist.ts
+async function isGhAvailable() {
+  try {
+    const proc = Bun.spawn(["gh", "auth", "status"], {
+      stdout: "ignore",
+      stderr: "ignore"
+    });
+    const exitCode = await proc.exited;
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function uploadToGist(content, filename, description) {
+  const available = await isGhAvailable();
+  if (!available) {
+    throw new Error("GitHub CLI (gh) is not installed or not authenticated. " + "Install it from https://cli.github.com and run `gh auth login`.");
+  }
+  const { join: join5 } = await import("path");
+  const { tmpdir } = await import("os");
+  const { writeFileSync, unlinkSync } = await import("fs");
+  const tmpPath = join5(tmpdir(), `tokenleak-gist-${Date.now()}-${filename}`);
+  writeFileSync(tmpPath, content, "utf-8");
+  try {
+    const proc = Bun.spawn(["gh", "gist", "create", tmpPath, "--desc", description, "--public"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    const stdout = (await new Response(proc.stdout).text()).trim();
+    const stderr = (await new Response(proc.stderr).text()).trim();
+    if (exitCode !== 0) {
+      throw new Error(`Failed to create gist: ${stderr || "unknown error"} (exit code ${exitCode})`);
+    }
+    if (!stdout.startsWith("http")) {
+      throw new Error(`Unexpected gh output: ${stdout}`);
+    }
+    return stdout;
+  } finally {
+    try {
+      unlinkSync(tmpPath);
+    } catch {}
+  }
+}
+// packages/cli/src/cli.ts
+var FORMAT_VALUES = ["json", "svg", "png", "terminal"];
+var THEME_VALUES = ["dark", "light"];
+function inferFormatFromPath(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "json":
+      return "json";
+    case "svg":
+      return "svg";
+    case "png":
+      return "png";
+    default:
+      return null;
+  }
+}
+function computeDateRange(args) {
+  const until = args.until ?? new Date().toISOString().slice(0, 10);
+  let since;
+  if (args.since) {
+    since = args.since;
+  } else {
+    const daysBack = args.days ?? DEFAULT_DAYS;
+    const d = new Date(until);
+    d.setDate(d.getDate() - daysBack);
+    since = d.toISOString().slice(0, 10);
+  }
+  return { since, until };
+}
+function resolveConfig(cliArgs) {
+  const fileConfig = loadConfig();
+  const envConfig = loadEnvOverrides();
+  const merged = {
+    format: "terminal",
+    theme: "dark",
+    days: DEFAULT_DAYS,
+    output: null,
+    width: 80,
+    noColor: false,
+    noInsights: false,
+    clipboard: false,
+    open: false
+  };
+  if (fileConfig.format && FORMAT_VALUES.includes(fileConfig.format)) {
+    merged.format = fileConfig.format;
+  }
+  if (fileConfig.theme && THEME_VALUES.includes(fileConfig.theme)) {
+    merged.theme = fileConfig.theme;
+  }
+  if (fileConfig.days !== undefined)
+    merged.days = fileConfig.days;
+  if (fileConfig.width !== undefined)
+    merged.width = fileConfig.width;
+  if (fileConfig.noColor !== undefined)
+    merged.noColor = fileConfig.noColor;
+  if (fileConfig.noInsights !== undefined)
+    merged.noInsights = fileConfig.noInsights;
+  if (envConfig.format)
+    merged.format = envConfig.format;
+  if (envConfig.theme)
+    merged.theme = envConfig.theme;
+  if (envConfig.days !== undefined)
+    merged.days = envConfig.days;
+  const result = { ...merged };
+  if (cliArgs["format"] !== undefined) {
+    result.format = cliArgs["format"];
+  }
+  if (cliArgs["theme"] !== undefined) {
+    result.theme = cliArgs["theme"];
+  }
+  if (cliArgs["since"] !== undefined) {
+    result.since = cliArgs["since"];
+  }
+  if (cliArgs["until"] !== undefined) {
+    result.until = cliArgs["until"];
+  }
+  if (cliArgs["days"] !== undefined) {
+    result.days = cliArgs["days"];
+  }
+  if (cliArgs["output"] !== undefined) {
+    const outputPath = cliArgs["output"];
+    result.output = outputPath;
+    if (cliArgs["format"] === undefined) {
+      const inferred = inferFormatFromPath(outputPath);
+      if (inferred) {
+        result.format = inferred;
+      }
+    }
+  }
+  if (cliArgs["width"] !== undefined) {
+    result.width = cliArgs["width"];
+  }
+  if (cliArgs["noColor"] !== undefined) {
+    result.noColor = cliArgs["noColor"];
+  }
+  if (cliArgs["noInsights"] !== undefined) {
+    result.noInsights = cliArgs["noInsights"];
+  }
+  if (cliArgs["compare"] !== undefined) {
+    result.compare = cliArgs["compare"];
+  }
+  if (cliArgs["provider"] !== undefined) {
+    result.provider = cliArgs["provider"];
+  }
+  if (cliArgs["clipboard"] !== undefined) {
+    result.clipboard = cliArgs["clipboard"];
+  }
+  if (cliArgs["open"] !== undefined) {
+    result.open = cliArgs["open"];
+  }
+  if (cliArgs["upload"] !== undefined) {
+    result.upload = cliArgs["upload"];
+  }
+  return result;
+}
+function getRenderer(format) {
+  switch (format) {
+    case "json":
+      return new JsonRenderer;
+    default:
+      throw new TokenleakError(`Format "${format}" is not yet supported. Available formats: json`);
+  }
+}
+async function loadAndAggregate(range, providers) {
+  const results = await Promise.all(providers.map(async (p) => {
+    try {
+      return await p.load(range);
+    } catch {
+      return null;
+    }
+  }));
+  const data = results.filter((r) => r !== null);
+  const merged = data.length > 0 ? mergeProviderData(data) : [];
+  const stats = aggregate(merged, range.until);
+  return { data, stats };
+}
+async function runCompare(compareStr, currentRange, _registry, available) {
+  let previousRange;
+  if (compareStr === "auto" || compareStr === "true" || compareStr === "") {
+    previousRange = computePreviousPeriod(currentRange);
+  } else {
+    const parsed = parseCompareRange(compareStr);
+    if (!parsed) {
+      throw new TokenleakError(`Invalid --compare format: "${compareStr}". Use YYYY-MM-DD..YYYY-MM-DD or "auto".`);
+    }
+    previousRange = parsed;
+  }
+  const [currentResult, previousResult] = await Promise.all([
+    loadAndAggregate(currentRange, available),
+    loadAndAggregate(previousRange, available)
+  ]);
+  return buildCompareOutput({ range: currentRange, stats: currentResult.stats }, { range: previousRange, stats: previousResult.stats });
+}
+async function run(cliArgs) {
+  const config = resolveConfig(cliArgs);
+  const dateRange = computeDateRange({
+    since: config.since,
+    until: config.until,
+    days: config.days
+  });
+  const registry = new ProviderRegistry;
+  registry.register(new ClaudeCodeProvider);
+  registry.register(new CodexProvider);
+  registry.register(new OpenCodeProvider);
+  let available = await registry.getAvailable();
+  if (config.provider) {
+    const requested = new Set(config.provider.split(",").map((s) => s.trim().toLowerCase()));
+    available = available.filter((p) => requested.has(p.name.toLowerCase()) || requested.has(p.displayName.toLowerCase()));
+  }
+  if (available.length === 0) {
+    throw new TokenleakError("No provider data found");
+  }
+  if (config.compare) {
+    const compareOutput = await runCompare(config.compare, dateRange, registry, available);
+    const rendered2 = JSON.stringify(compareOutput, null, 2);
+    if (config.output) {
+      writeFileSync(config.output, rendered2);
+    } else {
+      process.stdout.write(rendered2 + `
+`);
+    }
+    return;
+  }
+  const results = await Promise.all(available.map(async (p) => {
+    try {
+      return await p.load(dateRange);
+    } catch {
+      return null;
+    }
+  }));
+  const providerDataList = results.filter((r) => r !== null);
+  if (providerDataList.length === 0) {
+    throw new TokenleakError("No provider data found");
+  }
+  const mergedDaily = mergeProviderData(providerDataList);
+  const stats = aggregate(mergedDaily, dateRange.until);
+  const output = {
+    schemaVersion: SCHEMA_VERSION,
+    generated: new Date().toISOString(),
+    dateRange,
+    providers: providerDataList,
+    aggregated: stats
+  };
+  const renderer = getRenderer(config.format);
+  const renderOptions = {
+    format: config.format,
+    theme: config.theme,
+    width: config.width,
+    showInsights: !config.noInsights,
+    noColor: config.noColor,
+    output: config.output
+  };
+  const rendered = await renderer.render(output, renderOptions);
+  if (config.output) {
+    const data = typeof rendered === "string" ? rendered : Buffer.from(rendered);
+    writeFileSync(config.output, data);
+  } else {
+    const text2 = typeof rendered === "string" ? rendered : rendered.toString("utf-8");
+    process.stdout.write(text2 + `
+`);
+  }
+  if (config.clipboard) {
+    const text2 = typeof rendered === "string" ? rendered : rendered.toString("utf-8");
+    await copyToClipboard(text2);
+    process.stderr.write(`Copied output to clipboard.
+`);
+  }
+  if (config.open) {
+    if (!config.output) {
+      throw new TokenleakError("--open requires --output to specify a file path");
+    }
+    await openFile(config.output);
+    process.stderr.write(`Opened ${config.output} in default application.
+`);
+  }
+  if (config.upload === "gist") {
+    const text2 = typeof rendered === "string" ? rendered : rendered.toString("utf-8");
+    const ext = config.format === "json" ? "json" : config.format === "svg" ? "svg" : "txt";
+    const filename = `tokenleak.${ext}`;
+    const description = `Tokenleak report (${dateRange.since} to ${dateRange.until})`;
+    const url = await uploadToGist(text2, filename, description);
+    process.stderr.write(`Uploaded to gist: ${url}
+`);
+  } else if (config.upload !== undefined) {
+    throw new TokenleakError(`Unknown upload target "${config.upload}". Supported: gist`);
+  }
+}
+var main = defineCommand({
+  meta: {
+    name: "tokenleak",
+    version: VERSION,
+    description: "Visualise your AI coding-assistant token usage across providers"
+  },
+  args: {
+    format: {
+      type: "string",
+      alias: "f",
+      description: "Output format: json, svg, png, terminal"
+    },
+    theme: {
+      type: "string",
+      alias: "t",
+      description: "Color theme: dark, light"
+    },
+    since: {
+      type: "string",
+      alias: "s",
+      description: "Start date (YYYY-MM-DD)"
+    },
+    until: {
+      type: "string",
+      alias: "u",
+      description: "End date (YYYY-MM-DD), defaults to today"
+    },
+    days: {
+      type: "string",
+      alias: "d",
+      description: `Number of days to look back (default: ${DEFAULT_DAYS}, overridden by --since)`
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "Output file path"
+    },
+    width: {
+      type: "string",
+      alias: "w",
+      description: "Terminal width (default: 80)"
+    },
+    noColor: {
+      type: "boolean",
+      description: "Disable ANSI colors",
+      default: false
+    },
+    noInsights: {
+      type: "boolean",
+      description: "Hide insights panel",
+      default: false
+    },
+    compare: {
+      type: "string",
+      description: "Compare two date ranges (YYYY-MM-DD..YYYY-MM-DD)"
+    },
+    provider: {
+      type: "string",
+      alias: "p",
+      description: "Filter to specific provider(s), comma-separated"
+    },
+    clipboard: {
+      type: "boolean",
+      description: "Copy output to clipboard after rendering",
+      default: false
+    },
+    open: {
+      type: "boolean",
+      description: "Open output file in default application (requires --output)",
+      default: false
+    },
+    upload: {
+      type: "string",
+      description: "Upload output to a service (supported: gist)"
+    }
+  },
+  async run({ args }) {
+    try {
+      const cliArgs = {};
+      if (args.format !== undefined)
+        cliArgs["format"] = args.format;
+      if (args.theme !== undefined)
+        cliArgs["theme"] = args.theme;
+      if (args.since !== undefined)
+        cliArgs["since"] = args.since;
+      if (args.until !== undefined)
+        cliArgs["until"] = args.until;
+      if (args.days !== undefined)
+        cliArgs["days"] = Number(args.days);
+      if (args.output !== undefined)
+        cliArgs["output"] = args.output;
+      if (args.width !== undefined)
+        cliArgs["width"] = Number(args.width);
+      if (args.noColor)
+        cliArgs["noColor"] = true;
+      if (args.noInsights)
+        cliArgs["noInsights"] = true;
+      if (args.compare !== undefined)
+        cliArgs["compare"] = args.compare;
+      if (args.provider !== undefined)
+        cliArgs["provider"] = args.provider;
+      if (args.clipboard)
+        cliArgs["clipboard"] = true;
+      if (args.open)
+        cliArgs["open"] = true;
+      if (args.upload !== undefined)
+        cliArgs["upload"] = args.upload;
+      await run(cliArgs);
+    } catch (error) {
+      handleError(error);
+    }
+  }
+});
+var isDirectExecution = typeof Bun !== "undefined" ? Bun.main === import.meta.path : process.argv[1] !== undefined && import.meta.url.endsWith(process.argv[1].replace(/\\/g, "/"));
+if (isDirectExecution) {
+  runMain(main);
+}
+export {
+  run,
+  resolveConfig,
+  inferFormatFromPath,
+  computeDateRange
+};