vibestats 1.0.0

package/dist/index.js

@@ -0,0 +1,1833 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { defineCommand, runMain } from "citty";
+
+// src/usage/loader.ts
+import { readFileSync, existsSync, readdirSync, statSync, realpathSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/pricing.ts
+var MODEL_PRICING = {
+  // Opus 4.5 (cheaper than Opus 4.1)
+  "claude-opus-4-5-20251101": {
+    input: 5,
+    output: 25,
+    cacheWrite: 6.25,
+    cacheRead: 0.5
+  },
+  // Sonnet 4.5
+  "claude-sonnet-4-5-20250929": {
+    input: 3,
+    output: 15,
+    cacheWrite: 3.75,
+    cacheRead: 0.3
+  },
+  // Opus 4.1 (MORE expensive than Opus 4.5)
+  "claude-opus-4-1-20250805": {
+    input: 15,
+    output: 75,
+    cacheWrite: 18.75,
+    cacheRead: 1.5
+  },
+  // Haiku 4.5
+  "claude-haiku-4-5-20251001": {
+    input: 1,
+    output: 5,
+    cacheWrite: 1.25,
+    cacheRead: 0.1
+  },
+  // Sonnet 3.5 (legacy - same as Sonnet 4.5)
+  "claude-3-5-sonnet-20241022": {
+    input: 3,
+    output: 15,
+    cacheWrite: 3.75,
+    cacheRead: 0.3
+  },
+  "claude-3-5-sonnet-20240620": {
+    input: 3,
+    output: 15,
+    cacheWrite: 3.75,
+    cacheRead: 0.3
+  },
+  // Haiku 3.5 (legacy - same as Haiku 4.5)
+  "claude-3-5-haiku-20241022": {
+    input: 1,
+    output: 5,
+    cacheWrite: 1.25,
+    cacheRead: 0.1
+  }
+};
+function getModelPricing(modelName) {
+  if (MODEL_PRICING[modelName]) {
+    return MODEL_PRICING[modelName];
+  }
+  if (modelName.includes("opus-4-5") || modelName.includes("opus-4.5")) {
+    return MODEL_PRICING["claude-opus-4-5-20251101"];
+  }
+  if (modelName.includes("opus-4-1") || modelName.includes("opus-4.1") || modelName.includes("opus-4")) {
+    return MODEL_PRICING["claude-opus-4-1-20250805"];
+  }
+  if (modelName.includes("sonnet-4-5") || modelName.includes("sonnet-4.5")) {
+    return MODEL_PRICING["claude-sonnet-4-5-20250929"];
+  }
+  if (modelName.includes("sonnet")) {
+    return MODEL_PRICING["claude-3-5-sonnet-20241022"];
+  }
+  if (modelName.includes("haiku-4-5") || modelName.includes("haiku-4.5")) {
+    return MODEL_PRICING["claude-haiku-4-5-20251001"];
+  }
+  if (modelName.includes("haiku")) {
+    return MODEL_PRICING["claude-3-5-haiku-20241022"];
+  }
+  return MODEL_PRICING["claude-sonnet-4-5-20250929"];
+}
+function getModelDisplayName(modelName) {
+  if (modelName.includes("opus-4-5") || modelName.includes("opus-4.5")) return "Opus 4.5";
+  if (modelName.includes("opus-4-1") || modelName.includes("opus-4.1")) return "Opus 4.1";
+  if (modelName.includes("opus")) return "Opus";
+  if (modelName.includes("sonnet-4-5") || modelName.includes("sonnet-4.5")) return "Sonnet 4.5";
+  if (modelName.includes("sonnet-3-5") || modelName.includes("sonnet-3.5")) return "Sonnet 3.5";
+  if (modelName.includes("sonnet")) return "Sonnet";
+  if (modelName.includes("haiku-4-5") || modelName.includes("haiku-4.5")) return "Haiku 4.5";
+  if (modelName.includes("haiku-3-5") || modelName.includes("haiku-3.5")) return "Haiku 3.5";
+  if (modelName.includes("haiku")) return "Haiku";
+  return modelName;
+}
+
+// src/codex-pricing.ts
+var CODEX_MODEL_PRICING = {
+  // GPT-5.2 (latest flagship)
+  // Cached input is ~10% of input price (prompt caching discount)
+  "gpt-5.2": {
+    input: 1.75,
+    output: 14,
+    cachedInput: 0.175
+  },
+  "gpt-5.2-codex": {
+    input: 1.75,
+    output: 14,
+    cachedInput: 0.175
+  },
+  // GPT-5.1 models
+  "gpt-5.1": {
+    input: 1.25,
+    output: 10,
+    cachedInput: 0.125
+  },
+  "gpt-5.1-codex": {
+    input: 1.25,
+    output: 10,
+    cachedInput: 0.125
+  },
+  "gpt-5.1-codex-max": {
+    input: 1.25,
+    output: 10,
+    cachedInput: 0.125
+  },
+  // GPT-5.1 Mini
+  "gpt-5.1-codex-mini": {
+    input: 0.25,
+    output: 2,
+    cachedInput: 0.025
+  },
+  // GPT-5 base models
+  "gpt-5": {
+    input: 1.25,
+    output: 10,
+    cachedInput: 0.125
+  },
+  "gpt-5-codex": {
+    input: 1.25,
+    output: 10,
+    cachedInput: 0.125
+  },
+  // GPT-5 Mini variants
+  "gpt-5-mini": {
+    input: 0.25,
+    output: 2,
+    cachedInput: 0.025
+  },
+  "gpt-5-codex-mini": {
+    input: 0.25,
+    output: 2,
+    cachedInput: 0.025
+  },
+  // GPT-5 Nano
+  "gpt-5-nano": {
+    input: 0.05,
+    output: 0.4,
+    cachedInput: 5e-3
+  },
+  // GPT-4o (fallback for older sessions)
+  "gpt-4o": {
+    input: 2.5,
+    output: 10,
+    cachedInput: 1.25
+  },
+  "gpt-4o-mini": {
+    input: 0.15,
+    output: 0.6,
+    cachedInput: 0.075
+  }
+};
+function getCodexModelPricing(modelName) {
+  if (CODEX_MODEL_PRICING[modelName]) {
+    return CODEX_MODEL_PRICING[modelName];
+  }
+  const normalized = modelName.toLowerCase();
+  if (normalized.includes("5.2")) {
+    return CODEX_MODEL_PRICING["gpt-5.2"];
+  }
+  if (normalized.includes("5.1") && normalized.includes("max")) {
+    return CODEX_MODEL_PRICING["gpt-5.1-codex-max"];
+  }
+  if (normalized.includes("5.1") && normalized.includes("mini")) {
+    return CODEX_MODEL_PRICING["gpt-5.1-codex-mini"];
+  }
+  if (normalized.includes("5.1")) {
+    return CODEX_MODEL_PRICING["gpt-5.1"];
+  }
+  if (normalized.includes("nano")) {
+    return CODEX_MODEL_PRICING["gpt-5-nano"];
+  }
+  if (normalized.includes("5") && normalized.includes("mini")) {
+    return CODEX_MODEL_PRICING["gpt-5-mini"];
+  }
+  if (normalized.includes("gpt-5") || normalized.includes("gpt5")) {
+    return CODEX_MODEL_PRICING["gpt-5"];
+  }
+  if (normalized.includes("4o-mini")) {
+    return CODEX_MODEL_PRICING["gpt-4o-mini"];
+  }
+  if (normalized.includes("4o")) {
+    return CODEX_MODEL_PRICING["gpt-4o"];
+  }
+  return CODEX_MODEL_PRICING["gpt-5"];
+}
+function getCodexModelDisplayName(modelName) {
+  const normalized = modelName.toLowerCase();
+  if (normalized.includes("5.2") && normalized.includes("pro")) return "GPT-5.2 Pro";
+  if (normalized.includes("5.2")) return "GPT-5.2";
+  if (normalized.includes("5.1") && normalized.includes("max")) return "GPT-5.1 Max";
+  if (normalized.includes("5.1") && normalized.includes("mini")) return "GPT-5.1 Mini";
+  if (normalized.includes("5.1") && normalized.includes("codex")) return "GPT-5.1 Codex";
+  if (normalized.includes("5.1")) return "GPT-5.1";
+  if (normalized.includes("nano")) return "GPT-5 Nano";
+  if (normalized.includes("5") && normalized.includes("mini")) return "GPT-5 Mini";
+  if (normalized.includes("5") && normalized.includes("codex")) return "GPT-5 Codex";
+  if (normalized.includes("gpt-5")) return "GPT-5";
+  if (normalized.includes("4o-mini")) return "GPT-4o Mini";
+  if (normalized.includes("4o")) return "GPT-4o";
+  return modelName;
+}
+function calculateCodexCost(modelName, inputTokens, outputTokens, cachedInputTokens) {
+  const pricing = getCodexModelPricing(modelName);
+  const regularInputTokens = inputTokens - cachedInputTokens;
+  const inputCost = regularInputTokens / 1e6 * pricing.input;
+  const cachedCost = cachedInputTokens / 1e6 * pricing.cachedInput;
+  const outputCost = outputTokens / 1e6 * pricing.output;
+  return inputCost + cachedCost + outputCost;
+}
+
+// src/usage/loader.ts
+function getClaudeDir() {
+  return process.env.CLAUDE_HOME || join(homedir(), ".claude");
+}
+function getCodexDir() {
+  return join(homedir(), ".codex");
+}
+function findJsonlFiles(dir, visited = /* @__PURE__ */ new Set(), depth = 0, result = []) {
+  if (!existsSync(dir)) return result;
+  if (depth > 10) return result;
+  let realPath;
+  try {
+    realPath = realpathSync(dir);
+  } catch {
+    realPath = dir;
+  }
+  if (visited.has(realPath)) return result;
+  visited.add(realPath);
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      try {
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          findJsonlFiles(fullPath, visited, depth + 1, result);
+        } else if (entry.endsWith(".jsonl")) {
+          result.push(fullPath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function parseClaudeJsonl() {
+  const entries = [];
+  const claudeDir = getClaudeDir();
+  const projectsDir = join(claudeDir, "projects");
+  if (!existsSync(projectsDir)) return entries;
+  const jsonlFiles = findJsonlFiles(projectsDir);
+  for (const filePath of jsonlFiles) {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const lines = content.split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const entry = JSON.parse(line);
+          if (entry.type !== "assistant" || !entry.message?.usage) continue;
+          const usage = entry.message.usage;
+          const model = entry.message.model || "unknown";
+          const timestamp = entry.timestamp;
+          if (!timestamp) continue;
+          const date = timestamp.split("T")[0];
+          const pricing = getModelPricing(model);
+          const inputTokens = usage.input_tokens || 0;
+          const outputTokens = usage.output_tokens || 0;
+          const cacheWriteTokens = usage.cache_creation_input_tokens || 0;
+          const cacheReadTokens = usage.cache_read_input_tokens || 0;
+          const cost = inputTokens * pricing.input / 1e6 + outputTokens * pricing.output / 1e6 + cacheWriteTokens * pricing.cacheWrite / 1e6 + cacheReadTokens * pricing.cacheRead / 1e6;
+          entries.push({
+            date,
+            model: getModelDisplayName(model),
+            inputTokens,
+            outputTokens,
+            cacheWriteTokens,
+            cacheReadTokens,
+            cost,
+            source: "claude"
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function parseCodexJsonl() {
+  const entries = [];
+  const codexDir = getCodexDir();
+  const sessionsDir = join(codexDir, "sessions");
+  if (!existsSync(sessionsDir)) return entries;
+  const jsonlFiles = findJsonlFiles(sessionsDir);
+  for (const filePath of jsonlFiles) {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const lines = content.split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const entry = JSON.parse(line);
+          if (entry.type !== "response" || !entry.response?.usage) continue;
+          const usage = entry.response.usage;
+          const model = entry.response.model || "unknown";
+          const timestamp = entry.timestamp;
+          if (!timestamp) continue;
+          const date = timestamp.split("T")[0];
+          const pricing = getCodexModelPricing(model);
+          const inputTokens = usage.input_tokens || 0;
+          const outputTokens = usage.output_tokens || 0;
+          const cachedInputTokens = usage.input_tokens_details?.cached_tokens || 0;
+          const cost = (inputTokens - cachedInputTokens) * pricing.input / 1e6 + outputTokens * pricing.output / 1e6 + cachedInputTokens * pricing.cachedInput / 1e6;
+          entries.push({
+            date,
+            model: getCodexModelDisplayName(model),
+            inputTokens,
+            outputTokens,
+            cacheWriteTokens: 0,
+            cacheReadTokens: cachedInputTokens,
+            cost,
+            source: "codex"
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function filterByDateRange(entries, since, until) {
+  return entries.filter((e) => {
+    if (since && e.date < since) return false;
+    if (until && e.date > until) return false;
+    return true;
+  });
+}
+function aggregateByDay(entries) {
+  const dayMap = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const existing = dayMap.get(e.date);
+    if (existing) {
+      existing.inputTokens += e.inputTokens;
+      existing.outputTokens += e.outputTokens;
+      existing.cacheWriteTokens += e.cacheWriteTokens;
+      existing.cacheReadTokens += e.cacheReadTokens;
+      existing.totalTokens += e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
+      existing.cost += e.cost;
+      existing.modelsSet.add(e.model);
+    } else {
+      dayMap.set(e.date, {
+        key: e.date,
+        inputTokens: e.inputTokens,
+        outputTokens: e.outputTokens,
+        cacheWriteTokens: e.cacheWriteTokens,
+        cacheReadTokens: e.cacheReadTokens,
+        totalTokens: e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens,
+        cost: e.cost,
+        modelsSet: /* @__PURE__ */ new Set([e.model])
+      });
+    }
+  }
+  return Array.from(dayMap.values()).map(({ modelsSet, ...row }) => ({
+    ...row,
+    models: Array.from(modelsSet).sort()
+  })).sort((a, b) => a.key.localeCompare(b.key));
+}
+function aggregateByMonth(entries) {
+  const monthMap = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const month = e.date.slice(0, 7);
+    const existing = monthMap.get(month);
+    if (existing) {
+      existing.inputTokens += e.inputTokens;
+      existing.outputTokens += e.outputTokens;
+      existing.cacheWriteTokens += e.cacheWriteTokens;
+      existing.cacheReadTokens += e.cacheReadTokens;
+      existing.totalTokens += e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
+      existing.cost += e.cost;
+      existing.modelsSet.add(e.model);
+    } else {
+      monthMap.set(month, {
+        key: month,
+        inputTokens: e.inputTokens,
+        outputTokens: e.outputTokens,
+        cacheWriteTokens: e.cacheWriteTokens,
+        cacheReadTokens: e.cacheReadTokens,
+        totalTokens: e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens,
+        cost: e.cost,
+        modelsSet: /* @__PURE__ */ new Set([e.model])
+      });
+    }
+  }
+  return Array.from(monthMap.values()).map(({ modelsSet, ...row }) => ({
+    ...row,
+    models: Array.from(modelsSet).sort()
+  })).sort((a, b) => a.key.localeCompare(b.key));
+}
+function aggregateByModel(entries) {
+  const modelMap = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const existing = modelMap.get(e.model);
+    if (existing) {
+      existing.inputTokens += e.inputTokens;
+      existing.outputTokens += e.outputTokens;
+      existing.cacheWriteTokens += e.cacheWriteTokens;
+      existing.cacheReadTokens += e.cacheReadTokens;
+      existing.totalTokens += e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
+      existing.cost += e.cost;
+    } else {
+      modelMap.set(e.model, {
+        key: e.model,
+        inputTokens: e.inputTokens,
+        outputTokens: e.outputTokens,
+        cacheWriteTokens: e.cacheWriteTokens,
+        cacheReadTokens: e.cacheReadTokens,
+        totalTokens: e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens,
+        cost: e.cost
+      });
+    }
+  }
+  return Array.from(modelMap.values()).sort((a, b) => b.totalTokens - a.totalTokens);
+}
+function computeTotals(rows) {
+  return rows.reduce(
+    (acc, row) => ({
+      inputTokens: acc.inputTokens + row.inputTokens,
+      outputTokens: acc.outputTokens + row.outputTokens,
+      cacheWriteTokens: acc.cacheWriteTokens + row.cacheWriteTokens,
+      cacheReadTokens: acc.cacheReadTokens + row.cacheReadTokens,
+      totalTokens: acc.totalTokens + row.totalTokens,
+      cost: acc.cost + row.cost
+    }),
+    { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0, totalTokens: 0, cost: 0 }
+  );
+}
+function computeModelBreakdown(entries) {
+  const modelMap = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const total = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
+    const existing = modelMap.get(e.model);
+    if (existing) {
+      existing.tokens += total;
+      existing.cost += e.cost;
+    } else {
+      modelMap.set(e.model, { tokens: total, cost: e.cost });
+    }
+  }
+  const totalTokens = Array.from(modelMap.values()).reduce((sum, m) => sum + m.tokens, 0);
+  return Array.from(modelMap.entries()).map(([model, data]) => ({
+    model,
+    tokens: data.tokens,
+    cost: data.cost,
+    percentage: totalTokens > 0 ? Math.round(data.tokens / totalTokens * 100) : 0
+  })).sort((a, b) => b.tokens - a.tokens);
+}
+function loadUsageStats(options) {
+  const { aggregation, since, until, codexOnly, combined } = options;
+  let entries = [];
+  if (!codexOnly) {
+    entries = entries.concat(parseClaudeJsonl());
+  }
+  if (codexOnly || combined) {
+    entries = entries.concat(parseCodexJsonl());
+  }
+  if (entries.length === 0) {
+    return null;
+  }
+  entries = filterByDateRange(entries, since, until);
+  if (entries.length === 0) {
+    return null;
+  }
+  const dates = entries.map((e) => e.date).sort();
+  const dateRange = {
+    start: dates[0],
+    end: dates[dates.length - 1]
+  };
+  let rows;
+  switch (aggregation) {
+    case "monthly":
+      rows = aggregateByMonth(entries);
+      break;
+    case "model":
+      rows = aggregateByModel(entries);
+      break;
+    case "total":
+      rows = [];
+      break;
+    case "daily":
+    default:
+      rows = aggregateByDay(entries);
+      break;
+  }
+  const totals = aggregation === "total" ? computeTotals(aggregateByDay(entries)) : computeTotals(rows);
+  const modelBreakdown = computeModelBreakdown(entries);
+  let source = "claude";
+  if (codexOnly) source = "codex";
+  else if (combined) source = "combined";
+  return {
+    rows,
+    totals,
+    source,
+    aggregation,
+    dateRange,
+    modelBreakdown
+  };
+}
+
+// src/usage/table.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  orange: "\x1B[38;5;208m",
+  amber: "\x1B[38;5;214m",
+  yellow: "\x1B[33m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var noColors = Object.fromEntries(
+  Object.keys(colors).map((k) => [k, ""])
+);
+function getColors(showColors) {
+  if (showColors === false) {
+    return noColors;
+  }
+  return colors;
+}
+function formatNumber(n) {
+  return n.toLocaleString("en-US");
+}
+function formatCost(n) {
+  if (n >= 1e3) return `$${(n / 1e3).toFixed(1)}K`;
+  if (n >= 1) return `$${n.toFixed(2)}`;
+  return `$${n.toFixed(4)}`;
+}
+function padLeft(str, width) {
+  return str.padStart(width);
+}
+function padRight(str, width) {
+  return str.padEnd(width);
+}
+function displayUsageTable(stats, options = {}) {
+  const c = getColors(options.showColors);
+  const { compact, hideCost } = options;
+  const termWidth = process.stdout.columns || 140;
+  const useCompact = compact || termWidth < 120;
+  console.log();
+  let title = "Claude Code Usage";
+  if (stats.source === "codex") title = "Codex CLI Usage";
+  else if (stats.source === "combined") title = "AI Coding Usage (Claude + Codex)";
+  const aggLabel = stats.aggregation === "daily" ? "Daily" : stats.aggregation === "monthly" ? "Monthly" : stats.aggregation === "model" ? "By Model" : "Total";
+  console.log(`${c.orange}${c.bold}${title} - ${aggLabel} Report${c.reset}`);
+  console.log(`${c.gray}Date range: ${stats.dateRange.start} to ${stats.dateRange.end}${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(Math.min(termWidth - 2, 120))}${c.reset}`);
+  console.log();
+  const headers = useCompact ? ["Date", "Input", "Output", "Total", ...hideCost ? [] : ["Cost"]] : ["Date", "", "Input", "Output", "Cache W", "Cache R", "Total", ...hideCost ? [] : ["Cost"]];
+  const widths = useCompact ? [12, 14, 12, 16, ...hideCost ? [] : [12]] : [12, 16, 14, 12, 14, 14, 16, ...hideCost ? [] : [12]];
+  const headerRow = headers.map((h, i) => padLeft(h, widths[i])).join(" ");
+  console.log(`${c.bold}${headerRow}${c.reset}`);
+  for (const row of stats.rows) {
+    const models = row.models || [];
+    const firstModel = models[0] || "";
+    const remainingModels = models.slice(1);
+    if (useCompact) {
+      const cols = [
+        padRight(row.key.slice(0, 12), widths[0]),
+        padLeft(formatNumber(row.inputTokens), widths[1]),
+        padLeft(formatNumber(row.outputTokens), widths[2]),
+        padLeft(formatNumber(row.totalTokens), widths[3]),
+        ...hideCost ? [] : [padLeft(formatCost(row.cost), widths[4])]
+      ];
+      console.log(cols.join(" "));
+    } else {
+      const modelDisplay = firstModel ? `- ${firstModel}` : "";
+      const cols = [
+        padRight(row.key.slice(0, 12), widths[0]),
+        padRight(modelDisplay.slice(0, 16), widths[1]),
+        padLeft(formatNumber(row.inputTokens), widths[2]),
+        padLeft(formatNumber(row.outputTokens), widths[3]),
+        padLeft(formatNumber(row.cacheWriteTokens), widths[4]),
+        padLeft(formatNumber(row.cacheReadTokens), widths[5]),
+        padLeft(`${c.orange}${formatNumber(row.totalTokens)}${c.reset}`, widths[6] + c.orange.length + c.reset.length),
+        ...hideCost ? [] : [padLeft(`${c.amber}${formatCost(row.cost)}${c.reset}`, widths[7] + c.amber.length + c.reset.length)]
+      ];
+      console.log(cols.join(" "));
+      for (const model of remainingModels) {
+        const modelLine = `${" ".repeat(widths[0])} ${c.gray}- ${model}${c.reset}`;
+        console.log(modelLine);
+      }
+    }
+  }
+  const totalWidth = widths.reduce((a, b) => a + b + 1, 0);
+  console.log(`${c.gray}${"\u2500".repeat(totalWidth)}${c.reset}`);
+  const totals = stats.totals;
+  if (useCompact) {
+    const totalCols = [
+      padRight("Total", widths[0]),
+      padLeft(formatNumber(totals.inputTokens), widths[1]),
+      padLeft(formatNumber(totals.outputTokens), widths[2]),
+      padLeft(formatNumber(totals.totalTokens), widths[3]),
+      ...hideCost ? [] : [padLeft(formatCost(totals.cost), widths[4])]
+    ];
+    console.log(`${c.bold}${c.amber}${totalCols.join(" ")}${c.reset}`);
+  } else {
+    const totalCols = [
+      padRight("Total", widths[0]),
+      padRight("", widths[1]),
+      padLeft(formatNumber(totals.inputTokens), widths[2]),
+      padLeft(formatNumber(totals.outputTokens), widths[3]),
+      padLeft(formatNumber(totals.cacheWriteTokens), widths[4]),
+      padLeft(formatNumber(totals.cacheReadTokens), widths[5]),
+      padLeft(formatNumber(totals.totalTokens), widths[6]),
+      ...hideCost ? [] : [padLeft(formatCost(totals.cost), widths[7])]
+    ];
+    console.log(`${c.bold}${c.amber}${totalCols.join(" ")}${c.reset}`);
+  }
+  console.log();
+}
+function displayTotalOnly(stats, options = {}) {
+  const c = getColors(options.showColors);
+  const { hideCost } = options;
+  console.log();
+  let title = "Claude Code Usage";
+  if (stats.source === "codex") title = "Codex CLI Usage";
+  else if (stats.source === "combined") title = "AI Coding Usage (Claude + Codex)";
+  console.log(`${c.orange}${c.bold}${title} - Summary${c.reset}`);
+  console.log(`${c.gray}Date range: ${stats.dateRange.start} to ${stats.dateRange.end}${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(50)}${c.reset}`);
+  console.log();
+  const t = stats.totals;
+  console.log(`  ${c.bold}Input Tokens:${c.reset}       ${c.amber}${formatNumber(t.inputTokens)}${c.reset}`);
+  console.log(`  ${c.bold}Output Tokens:${c.reset}      ${c.amber}${formatNumber(t.outputTokens)}${c.reset}`);
+  console.log(`  ${c.bold}Cache Write:${c.reset}        ${c.amber}${formatNumber(t.cacheWriteTokens)}${c.reset}`);
+  console.log(`  ${c.bold}Cache Read:${c.reset}         ${c.amber}${formatNumber(t.cacheReadTokens)}${c.reset}`);
+  console.log(`  ${c.gray}${"\u2500".repeat(30)}${c.reset}`);
+  console.log(`  ${c.bold}Total Tokens:${c.reset}       ${c.amber}${c.bold}${formatNumber(t.totalTokens)}${c.reset}`);
+  if (!hideCost) {
+    console.log(`  ${c.bold}Total Cost:${c.reset}         ${c.amber}${c.bold}${formatCost(t.cost)}${c.reset}`);
+  }
+  console.log();
+  if (stats.modelBreakdown.length > 0) {
+    console.log(`${c.bold}Model Breakdown${c.reset}`);
+    console.log(`${c.gray}${"\u2500".repeat(40)}${c.reset}`);
+    for (const m of stats.modelBreakdown) {
+      const filled = Math.max(0, Math.min(20, Math.round(m.percentage / 100 * 20)));
+      const empty = Math.max(0, 20 - filled);
+      const bar = `${c.amber}${"\u2588".repeat(filled)}${c.gray}${"\u2591".repeat(empty)}${c.reset}`;
+      const costStr = hideCost ? "" : ` ${c.gray}${formatCost(m.cost)}${c.reset}`;
+      console.log(`  ${m.model.padEnd(14)} ${bar} ${m.percentage}%${costStr}`);
+    }
+    console.log();
+  }
+}
+
+// src/claude-jsonl-loader.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function getClaudeDir2() {
+  return process.env.CLAUDE_HOME || join2(homedir2(), ".claude");
+}
+function claudeJsonlDataExists() {
+  const claudeDir = getClaudeDir2();
+  const projectsDir = join2(claudeDir, "projects");
+  return existsSync2(projectsDir);
+}
+function findJsonlFiles2(dir) {
+  const files = [];
+  if (!existsSync2(dir)) return files;
+  const entries = readdirSync2(dir);
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry);
+    try {
+      const stat = statSync2(fullPath);
+      if (stat.isDirectory()) {
+        files.push(...findJsonlFiles2(fullPath));
+      } else if (entry.endsWith(".jsonl")) {
+        files.push(fullPath);
+      }
+    } catch {
+    }
+  }
+  return files;
+}
+function loadClaudeStatsFromJsonl() {
+  const claudeDir = getClaudeDir2();
+  const projectsDir = join2(claudeDir, "projects");
+  if (!claudeJsonlDataExists()) {
+    return null;
+  }
+  const jsonlFiles = findJsonlFiles2(projectsDir);
+  if (jsonlFiles.length === 0) {
+    return null;
+  }
+  const modelUsage = {};
+  const dailyMap = /* @__PURE__ */ new Map();
+  const hourCounts = {};
+  let firstTimestamp = null;
+  let totalMessages = 0;
+  const messageIds = /* @__PURE__ */ new Set();
+  for (const filePath of jsonlFiles) {
+    try {
+      const content = readFileSync2(filePath, "utf-8");
+      const lines = content.split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const entry = JSON.parse(line);
+          if (entry.type !== "assistant") continue;
+          if (!entry.message?.usage) continue;
+          const usage = entry.message.usage;
+          const model = entry.message.model || "unknown";
+          const timestamp = entry.timestamp;
+          const messageId = entry.message.id;
+          if (!modelUsage[model]) {
+            modelUsage[model] = {
+              inputTokens: 0,
+              outputTokens: 0,
+              cacheReadInputTokens: 0,
+              cacheCreationInputTokens: 0
+            };
+          }
+          modelUsage[model].inputTokens += usage.input_tokens || 0;
+          modelUsage[model].outputTokens += usage.output_tokens || 0;
+          modelUsage[model].cacheReadInputTokens += usage.cache_read_input_tokens || 0;
+          modelUsage[model].cacheCreationInputTokens += usage.cache_creation_input_tokens || 0;
+          if (messageId) {
+            messageIds.add(messageId);
+          }
+          if (timestamp) {
+            const date = timestamp.split("T")[0];
+            const hour = new Date(timestamp).getHours().toString();
+            if (!dailyMap.has(date)) {
+              dailyMap.set(date, { messageCount: 0, sessionCount: 0, toolCallCount: 0 });
+            }
+            const daily = dailyMap.get(date);
+            daily.messageCount++;
+            hourCounts[hour] = (hourCounts[hour] || 0) + 1;
+          }
+          if (timestamp && (!firstTimestamp || timestamp < firstTimestamp)) {
+            firstTimestamp = timestamp;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  totalMessages = messageIds.size;
+  if (totalMessages === 0) {
+    return null;
+  }
+  const statsCacheModelUsage = {};
+  for (const [model, usage] of Object.entries(modelUsage)) {
+    statsCacheModelUsage[model] = {
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens,
+      cacheReadInputTokens: usage.cacheReadInputTokens,
+      cacheCreationInputTokens: usage.cacheCreationInputTokens,
+      webSearchRequests: 0,
+      costUSD: 0,
+      // Will be calculated by metrics.ts
+      contextWindow: 2e5
+    };
+  }
+  const dailyActivity = Array.from(dailyMap.entries()).map(([date, data]) => ({
+    date,
+    messageCount: data.messageCount,
+    sessionCount: 1,
+    // Each day counts as at least 1 session for activity
+    toolCallCount: data.toolCallCount
+  })).sort((a, b) => a.date.localeCompare(b.date));
+  const sessionsByDate = /* @__PURE__ */ new Map();
+  return {
+    version: 1,
+    lastComputedDate: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    dailyActivity,
+    dailyModelTokens: [],
+    // Not needed for wrapped stats
+    modelUsage: statsCacheModelUsage,
+    totalSessions: jsonlFiles.length,
+    totalMessages,
+    longestSession: {
+      sessionId: "",
+      duration: 0,
+      messageCount: 0,
+      timestamp: ""
+    },
+    firstSessionDate: firstTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    hourCounts
+  };
+}
+
+// src/codex-loader.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+function getCodexDir2() {
+  return process.env.CODEX_HOME || join3(homedir3(), ".codex");
+}
+function codexDataExists() {
+  const codexDir = getCodexDir2();
+  if (!existsSync3(codexDir)) return false;
+  const sessionsDir = join3(codexDir, "sessions");
+  const archivedDir = join3(codexDir, "archived_sessions");
+  return existsSync3(sessionsDir) || existsSync3(archivedDir);
+}
+function findJsonlFiles3(dir) {
+  const files = [];
+  if (!existsSync3(dir)) return files;
+  const entries = readdirSync3(dir);
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry);
+    const stat = statSync3(fullPath);
+    if (stat.isDirectory()) {
+      files.push(...findJsonlFiles3(fullPath));
+    } else if (entry.endsWith(".jsonl")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function parseSessionFile(filePath) {
+  try {
+    const content = readFileSync3(filePath, "utf-8");
+    const lines = content.trim().split("\n");
+    let sessionMeta = null;
+    let currentModel = "gpt-5";
+    const perModelUsage = {};
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "session_meta") {
+          sessionMeta = entry.payload;
+        } else if (entry.type === "turn_context") {
+          const payload = entry.payload;
+          if (payload.model) {
+            currentModel = payload.model;
+          }
+        } else if (entry.type === "event_msg") {
+          const payload = entry.payload;
+          if (payload.type === "token_count" && payload.info?.last_token_usage) {
+            const usage = payload.info.last_token_usage;
+            if (!perModelUsage[currentModel]) {
+              perModelUsage[currentModel] = {
+                input_tokens: 0,
+                cached_input_tokens: 0,
+                output_tokens: 0,
+                reasoning_output_tokens: 0,
+                total_tokens: 0
+              };
+            }
+            perModelUsage[currentModel].input_tokens += usage.input_tokens || 0;
+            perModelUsage[currentModel].cached_input_tokens += usage.cached_input_tokens || 0;
+            perModelUsage[currentModel].output_tokens += usage.output_tokens || 0;
+            perModelUsage[currentModel].reasoning_output_tokens += usage.reasoning_output_tokens || 0;
+            perModelUsage[currentModel].total_tokens += usage.total_tokens || 0;
+          }
+        }
+      } catch {
+      }
+    }
+    if (!sessionMeta) return null;
+    const summedUsage = {
+      input_tokens: 0,
+      cached_input_tokens: 0,
+      output_tokens: 0,
+      reasoning_output_tokens: 0,
+      total_tokens: 0
+    };
+    let primaryModel = "gpt-5";
+    let maxTokens = 0;
+    for (const [model, usage] of Object.entries(perModelUsage)) {
+      summedUsage.input_tokens += usage.input_tokens;
+      summedUsage.cached_input_tokens += usage.cached_input_tokens;
+      summedUsage.output_tokens += usage.output_tokens;
+      summedUsage.reasoning_output_tokens += usage.reasoning_output_tokens;
+      summedUsage.total_tokens += usage.total_tokens;
+      if (usage.total_tokens > maxTokens) {
+        maxTokens = usage.total_tokens;
+        primaryModel = model;
+      }
+    }
+    return {
+      id: sessionMeta.id,
+      timestamp: sessionMeta.timestamp,
+      cwd: sessionMeta.cwd,
+      model: primaryModel,
+      tokenUsage: summedUsage,
+      perModelUsage
+      // New: per-model token breakdown
+    };
+  } catch {
+    return null;
+  }
+}
+function loadCodexStats() {
+  const codexDir = getCodexDir2();
+  if (!codexDataExists()) {
+    return null;
+  }
+  const sessionsDir = join3(codexDir, "sessions");
+  const archivedDir = join3(codexDir, "archived_sessions");
+  const jsonlFiles = [
+    ...findJsonlFiles3(sessionsDir),
+    ...findJsonlFiles3(archivedDir)
+  ];
+  if (jsonlFiles.length === 0) {
+    return null;
+  }
+  const sessions = [];
+  for (const file of jsonlFiles) {
+    const session = parseSessionFile(file);
+    if (session) {
+      sessions.push(session);
+    }
+  }
+  if (sessions.length === 0) {
+    return null;
+  }
+  sessions.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  const modelUsage = {};
+  for (const session of sessions) {
+    if (session.perModelUsage) {
+      for (const [model, usage] of Object.entries(session.perModelUsage)) {
+        if (!modelUsage[model]) {
+          modelUsage[model] = {
+            inputTokens: 0,
+            outputTokens: 0,
+            cachedInputTokens: 0,
+            reasoningTokens: 0
+          };
+        }
+        modelUsage[model].inputTokens += usage.input_tokens;
+        modelUsage[model].outputTokens += usage.output_tokens;
+        modelUsage[model].cachedInputTokens += usage.cached_input_tokens;
+        modelUsage[model].reasoningTokens += usage.reasoning_output_tokens;
+      }
+    } else {
+      if (!modelUsage[session.model]) {
+        modelUsage[session.model] = {
+          inputTokens: 0,
+          outputTokens: 0,
+          cachedInputTokens: 0,
+          reasoningTokens: 0
+        };
+      }
+      modelUsage[session.model].inputTokens += session.tokenUsage.input_tokens;
+      modelUsage[session.model].outputTokens += session.tokenUsage.output_tokens;
+      modelUsage[session.model].cachedInputTokens += session.tokenUsage.cached_input_tokens;
+      modelUsage[session.model].reasoningTokens += session.tokenUsage.reasoning_output_tokens;
+    }
+  }
+  const dailyMap = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const date = session.timestamp.split("T")[0];
+    dailyMap.set(date, (dailyMap.get(date) || 0) + 1);
+  }
+  const dailyActivity = Array.from(dailyMap.entries()).map(([date, sessionCount]) => ({ date, sessionCount })).sort((a, b) => a.date.localeCompare(b.date));
+  const hourCounts = {};
+  for (const session of sessions) {
+    const hour = new Date(session.timestamp).getHours().toString();
+    hourCounts[hour] = (hourCounts[hour] || 0) + 1;
+  }
+  const totalMessages = sessions.length;
+  return {
+    sessions,
+    totalSessions: sessions.length,
+    totalMessages,
+    modelUsage,
+    dailyActivity,
+    hourCounts,
+    firstSessionDate: sessions[0].timestamp.split("T")[0]
+  };
+}
+
+// src/shared/data-loader.ts
+function loadData(options) {
+  const { codexOnly, combined } = options;
+  let claude = null;
+  let codex = null;
+  if (!codexOnly) {
+    if (claudeJsonlDataExists()) {
+      claude = loadClaudeStatsFromJsonl();
+    }
+  }
+  if (codexOnly || combined) {
+    if (codexDataExists()) {
+      codex = loadCodexStats();
+    }
+  }
+  let source = "claude";
+  if (codexOnly) source = "codex";
+  else if (combined) source = "combined";
+  return { claude, codex, source };
+}
+function validateData(data, options) {
+  if (!data.claude && !data.codex) {
+    if (options.codexOnly) {
+      console.error("Error: OpenAI Codex data not found at ~/.codex");
+      console.error("Make sure you have used the Codex CLI at least once.");
+    } else if (options.combined) {
+      console.error("Error: No usage data found");
+      console.error("Make sure you have used Claude Code or Codex CLI at least once.");
+    } else {
+      console.error("Error: Claude Code data not found at ~/.claude");
+      console.error("Make sure you have used Claude Code at least once.");
+    }
+    process.exit(1);
+  }
+}
+
+// src/metrics.ts
+function calculateModelCost(modelName, usage) {
+  const pricing = getModelPricing(modelName);
+  const inputCost = usage.inputTokens / 1e6 * pricing.input;
+  const outputCost = usage.outputTokens / 1e6 * pricing.output;
+  const cacheWriteCost = usage.cacheCreationInputTokens / 1e6 * pricing.cacheWrite;
+  const cacheReadCost = usage.cacheReadInputTokens / 1e6 * pricing.cacheRead;
+  return inputCost + outputCost + cacheWriteCost + cacheReadCost;
+}
+function calculateTotalTokens(modelUsage) {
+  let total = 0;
+  for (const usage of Object.values(modelUsage)) {
+    total += usage.inputTokens + usage.outputTokens + usage.cacheCreationInputTokens + usage.cacheReadInputTokens;
+  }
+  return total;
+}
+function calculateStreaks(dailyActivity) {
+  if (dailyActivity.length === 0) return { longest: 0, current: 0 };
+  const dates = dailyActivity.map((d) => d.date).sort();
+  const dateSet = new Set(dates);
+  let longest = 1;
+  let current = 1;
+  let tempStreak = 1;
+  for (let i = 1; i < dates.length; i++) {
+    const prevDate = new Date(dates[i - 1]);
+    const currDate = new Date(dates[i]);
+    const diffDays = Math.floor((currDate.getTime() - prevDate.getTime()) / (1e3 * 60 * 60 * 24));
+    if (diffDays === 1) {
+      tempStreak++;
+      longest = Math.max(longest, tempStreak);
+    } else if (diffDays > 1) {
+      tempStreak = 1;
+    }
+  }
+  const today = /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  let checkDate = today;
+  current = 0;
+  while (true) {
+    const dateStr = checkDate.toISOString().split("T")[0];
+    if (dateSet.has(dateStr)) {
+      current++;
+      checkDate = new Date(checkDate.getTime() - 24 * 60 * 60 * 1e3);
+    } else {
+      const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1e3);
+      if (checkDate.getTime() === today.getTime()) {
+        checkDate = yesterday;
+      } else {
+        break;
+      }
+    }
+  }
+  return { longest, current };
+}
+function findPeakHour(hourCounts) {
+  let peakHour = 0;
+  let maxCount = 0;
+  for (const [hour, count] of Object.entries(hourCounts)) {
+    if (count > maxCount) {
+      maxCount = count;
+      peakHour = parseInt(hour, 10);
+    }
+  }
+  return peakHour;
+}
+function findPeakDay(dailyActivity) {
+  const dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+  const dayCounts = new Array(7).fill(0);
+  for (const day of dailyActivity) {
+    const date = new Date(day.date);
+    const dayOfWeek = date.getDay();
+    dayCounts[dayOfWeek] += day.messageCount;
+  }
+  let peakDay = 0;
+  let maxCount = 0;
+  for (let i = 0; i < 7; i++) {
+    if (dayCounts[i] > maxCount) {
+      maxCount = dayCounts[i];
+      peakDay = i;
+    }
+  }
+  return dayNames[peakDay];
+}
+function findBusiestMonth(dailyActivity) {
+  const monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const monthCounts = {};
+  for (const day of dailyActivity) {
+    const date = new Date(day.date);
+    const monthKey = `${date.getFullYear()}-${monthNames[date.getMonth()]}`;
+    monthCounts[monthKey] = (monthCounts[monthKey] || 0) + day.messageCount;
+  }
+  let busiestMonth = "";
+  let maxCount = 0;
+  for (const [month, count] of Object.entries(monthCounts)) {
+    if (count > maxCount) {
+      maxCount = count;
+      busiestMonth = month;
+    }
+  }
+  return busiestMonth;
+}
+var EXCLUDED_MODELS = ["synthetic", "test", "internal"];
+function shouldExcludeModel(modelName) {
+  const lower = modelName.toLowerCase();
+  return EXCLUDED_MODELS.some((excluded) => lower.includes(excluded));
+}
+function getModelBreakdown(modelUsage) {
+  const totalTokens = calculateTotalTokens(modelUsage);
+  if (totalTokens === 0) return [];
+  const breakdown = [];
+  for (const [modelName, usage] of Object.entries(modelUsage)) {
+    if (shouldExcludeModel(modelName)) continue;
+    const modelTokens = usage.inputTokens + usage.outputTokens + usage.cacheCreationInputTokens + usage.cacheReadInputTokens;
+    breakdown.push({
+      model: getModelDisplayName(modelName),
+      percentage: Math.round(modelTokens / totalTokens * 100),
+      tokens: modelTokens
+    });
+  }
+  breakdown.sort((a, b) => b.tokens - a.tokens);
+  return breakdown.map(({ model, percentage }) => ({ model, percentage }));
+}
+function getFavoriteModel(modelUsage) {
+  let favoriteModel = "";
+  let maxTokens = 0;
+  for (const [modelName, usage] of Object.entries(modelUsage)) {
+    if (shouldExcludeModel(modelName)) continue;
+    const modelTokens = usage.inputTokens + usage.outputTokens + usage.cacheCreationInputTokens + usage.cacheReadInputTokens;
+    if (modelTokens > maxTokens) {
+      maxTokens = modelTokens;
+      favoriteModel = modelName;
+    }
+  }
+  return getModelDisplayName(favoriteModel);
+}
+function calculateWordsGenerated(modelUsage) {
+  let totalOutputTokens = 0;
+  for (const usage of Object.values(modelUsage)) {
+    totalOutputTokens += usage.outputTokens;
+  }
+  return Math.round(totalOutputTokens * 0.75);
+}
+function computeWrappedStats(cache) {
+  let totalCost = 0;
+  for (const [modelName, usage] of Object.entries(cache.modelUsage)) {
+    totalCost += calculateModelCost(modelName, usage);
+  }
+  const streaks = calculateStreaks(cache.dailyActivity);
+  const daysActive = cache.dailyActivity.length;
+  const peakHour = findPeakHour(cache.hourCounts);
+  const peakDay = findPeakDay(cache.dailyActivity);
+  const busiestMonth = findBusiestMonth(cache.dailyActivity);
+  const favoriteModel = getFavoriteModel(cache.modelUsage);
+  const modelBreakdown = getModelBreakdown(cache.modelUsage);
+  const totalTokens = calculateTotalTokens(cache.modelUsage);
+  const wordsGenerated = calculateWordsGenerated(cache.modelUsage);
+  return {
+    sessions: cache.totalSessions,
+    messages: cache.totalMessages,
+    totalTokens,
+    totalCost,
+    daysActive,
+    longestStreak: streaks.longest,
+    currentStreak: streaks.current,
+    peakHour,
+    peakDay,
+    busiestMonth,
+    favoriteModel,
+    modelBreakdown,
+    wordsGenerated,
+    firstSessionDate: cache.firstSessionDate,
+    source: "claude"
+  };
+}
+function computeCodexWrappedStats(cache) {
+  let totalCost = 0;
+  let totalTokens = 0;
+  let totalOutputTokens = 0;
+  for (const [modelName, usage] of Object.entries(cache.modelUsage)) {
+    totalCost += calculateCodexCost(
+      modelName,
+      usage.inputTokens,
+      usage.outputTokens,
+      usage.cachedInputTokens
+    );
+    totalTokens += usage.inputTokens + usage.outputTokens;
+    totalOutputTokens += usage.outputTokens + usage.reasoningTokens;
+  }
+  const streaks = calculateStreaks(cache.dailyActivity);
+  const daysActive = cache.dailyActivity.length;
+  const peakHour = findPeakHour(cache.hourCounts);
+  const dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+  const dayCounts = new Array(7).fill(0);
+  for (const day of cache.dailyActivity) {
+    const date = new Date(day.date);
+    const dayOfWeek = date.getDay();
+    dayCounts[dayOfWeek] += day.sessionCount;
+  }
+  let peakDayIdx = 0;
+  let maxDayCount = 0;
+  for (let i = 0; i < 7; i++) {
+    if (dayCounts[i] > maxDayCount) {
+      maxDayCount = dayCounts[i];
+      peakDayIdx = i;
+    }
+  }
+  const peakDay = dayNames[peakDayIdx];
+  const monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const monthCounts = {};
+  for (const day of cache.dailyActivity) {
+    const date = new Date(day.date);
+    const monthKey = `${date.getFullYear()}-${monthNames[date.getMonth()]}`;
+    monthCounts[monthKey] = (monthCounts[monthKey] || 0) + day.sessionCount;
+  }
+  let busiestMonth = "";
+  let maxMonthCount = 0;
+  for (const [month, count] of Object.entries(monthCounts)) {
+    if (count > maxMonthCount) {
+      maxMonthCount = count;
+      busiestMonth = month;
+    }
+  }
+  let favoriteModel = "";
+  let maxModelTokens = 0;
+  const breakdown = [];
+  for (const [modelName, usage] of Object.entries(cache.modelUsage)) {
+    const modelTokens = usage.inputTokens + usage.outputTokens;
+    breakdown.push({
+      model: getCodexModelDisplayName(modelName),
+      percentage: totalTokens > 0 ? Math.round(modelTokens / totalTokens * 100) : 0,
+      tokens: modelTokens
+    });
+    if (modelTokens > maxModelTokens) {
+      maxModelTokens = modelTokens;
+      favoriteModel = modelName;
+    }
+  }
+  breakdown.sort((a, b) => b.tokens - a.tokens);
+  const modelBreakdown = breakdown.map(({ model, percentage }) => ({ model, percentage }));
+  const wordsGenerated = Math.round(totalOutputTokens * 0.75);
+  return {
+    sessions: cache.totalSessions,
+    messages: cache.totalMessages,
+    totalTokens,
+    totalCost,
+    daysActive,
+    longestStreak: streaks.longest,
+    currentStreak: streaks.current,
+    peakHour,
+    peakDay,
+    busiestMonth,
+    favoriteModel: getCodexModelDisplayName(favoriteModel),
+    modelBreakdown,
+    wordsGenerated,
+    firstSessionDate: cache.firstSessionDate,
+    source: "codex"
+  };
+}
+function combineWrappedStats(claude, codex) {
+  if (!claude && !codex) {
+    throw new Error("No stats available from either source");
+  }
+  if (!claude) return { ...codex, source: "codex" };
+  if (!codex) return { ...claude, source: "claude" };
+  const allDates = /* @__PURE__ */ new Set();
+  const longestStreak = Math.max(claude.longestStreak, codex.longestStreak);
+  const currentStreak = Math.max(claude.currentStreak, codex.currentStreak);
+  const modelTokensMap = /* @__PURE__ */ new Map();
+  const totalCombinedTokens = claude.totalTokens + codex.totalTokens;
+  for (const mb of claude.modelBreakdown) {
+    const tokens = mb.percentage / 100 * claude.totalTokens;
+    modelTokensMap.set(mb.model, (modelTokensMap.get(mb.model) || 0) + tokens);
+  }
+  for (const mb of codex.modelBreakdown) {
+    const tokens = mb.percentage / 100 * codex.totalTokens;
+    modelTokensMap.set(mb.model, (modelTokensMap.get(mb.model) || 0) + tokens);
+  }
+  const combinedBreakdown = Array.from(modelTokensMap.entries()).map(([model, tokens]) => ({
+    model,
+    percentage: totalCombinedTokens > 0 ? Math.round(tokens / totalCombinedTokens * 100) : 0,
+    tokens
+  })).sort((a, b) => b.tokens - a.tokens).map(({ model, percentage }) => ({ model, percentage }));
+  const favoriteModel = combinedBreakdown[0]?.model || claude.favoriteModel;
+  const firstSessionDate = claude.firstSessionDate < codex.firstSessionDate ? claude.firstSessionDate : codex.firstSessionDate;
+  const peakHour = claude.sessions > codex.sessions ? claude.peakHour : codex.peakHour;
+  const peakDay = claude.sessions > codex.sessions ? claude.peakDay : codex.peakDay;
+  const busiestMonth = claude.sessions > codex.sessions ? claude.busiestMonth : codex.busiestMonth;
+  return {
+    sessions: claude.sessions + codex.sessions,
+    messages: claude.messages + codex.messages,
+    totalTokens: claude.totalTokens + codex.totalTokens,
+    totalCost: claude.totalCost + codex.totalCost,
+    daysActive: claude.daysActive + codex.daysActive,
+    // May overcount, but close enough
+    longestStreak,
+    currentStreak,
+    peakHour,
+    peakDay,
+    busiestMonth,
+    favoriteModel,
+    modelBreakdown: combinedBreakdown,
+    wordsGenerated: claude.wordsGenerated + codex.wordsGenerated,
+    firstSessionDate,
+    source: "combined"
+  };
+}
+
+// src/url-encoder.ts
+function formatCompactNumber(num) {
+  if (num >= 1e9) {
+    return `${(num / 1e9).toFixed(1)}B`;
+  }
+  if (num >= 1e6) {
+    return `${(num / 1e6).toFixed(1)}M`;
+  }
+  if (num >= 1e3) {
+    return `${(num / 1e3).toFixed(1)}K`;
+  }
+  return num.toString();
+}
+var dayToNumber = {
+  Sunday: 0,
+  Monday: 1,
+  Tuesday: 2,
+  Wednesday: 3,
+  Thursday: 4,
+  Friday: 5,
+  Saturday: 6
+};
+function encodeStatsToUrl(stats, baseUrl = "https://wrapped.wolfai.dev") {
+  const params = new URLSearchParams();
+  params.set("s", stats.sessions.toString());
+  params.set("t", formatCompactNumber(stats.totalTokens));
+  params.set("c", stats.totalCost.toFixed(2));
+  params.set("d", stats.daysActive.toString());
+  params.set("ls", stats.longestStreak.toString());
+  params.set("cs", stats.currentStreak.toString());
+  params.set("ph", stats.peakHour.toString());
+  params.set("pd", (dayToNumber[stats.peakDay] ?? 0).toString());
+  params.set("fm", getModelAbbrevFromDisplayName(stats.favoriteModel));
+  const mbParts = stats.modelBreakdown.slice(0, 3).map((m) => {
+    const abbr = getModelAbbrevFromDisplayName(m.model);
+    return `${abbr}:${m.percentage}`;
+  });
+  params.set("mb", mbParts.join(","));
+  if (stats.topTools && stats.topTools.length > 0) {
+    params.set("tt", stats.topTools.slice(0, 5).join(","));
+  }
+  if (stats.developerStyle) {
+    const styleMap = {
+      reader: "r",
+      writer: "w",
+      executor: "e",
+      balanced: "b"
+    };
+    params.set("st", styleMap[stats.developerStyle] || "b");
+  }
+  if (stats.topProject) {
+    params.set("tp", stats.topProject);
+  }
+  if (stats.projectCount) {
+    params.set("pc", stats.projectCount.toString());
+  }
+  params.set("wg", formatCompactNumber(stats.wordsGenerated));
+  const firstDate = new Date(stats.firstSessionDate);
+  params.set("fad", firstDate.toISOString().split("T")[0].replace(/-/g, ""));
+  if (stats.source && stats.source !== "claude") {
+    params.set("src", stats.source);
+  }
+  return `${baseUrl}?${params.toString()}`;
+}
+function getModelAbbrevFromDisplayName(displayName) {
+  const map = {
+    // Claude models
+    "Opus 4.5": "o45",
+    "Opus 4.1": "o41",
+    Opus: "opus",
+    "Sonnet 4.5": "s45",
+    "Sonnet 3.5": "s35",
+    Sonnet: "sonnet",
+    "Haiku 4.5": "h45",
+    "Haiku 3.5": "h35",
+    Haiku: "haiku",
+    // Codex/OpenAI models
+    "GPT-5.2": "g52",
+    "GPT-5.1 Max": "g51m",
+    "GPT-5.1 Mini": "g51n",
+    "GPT-5.1": "g51",
+    "GPT-5": "g5",
+    "GPT-5 Mini": "g5n",
+    "GPT-4o": "g4o",
+    "GPT-4o Mini": "g4om"
+  };
+  return map[displayName] || displayName.slice(0, 5).toLowerCase();
+}
+
+// src/display.ts
+var colors2 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  orange: "\x1B[38;5;208m",
+  amber: "\x1B[38;5;214m",
+  yellow: "\x1B[33m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var noColors2 = Object.fromEntries(
+  Object.keys(colors2).map((k) => [k, ""])
+);
+function getColors2(theme) {
+  if (theme?.enabled === false) {
+    return noColors2;
+  }
+  return colors2;
+}
+function displayWrappedStats(stats, url, options) {
+  const c = getColors2(options?.theme);
+  console.log();
+  let title = "\u2728 Claude Code Wrapped 2025 \u2728";
+  let sourceLabel = "";
+  if (stats.source === "codex") {
+    title = "\u2728 Codex CLI Wrapped 2025 \u2728";
+    sourceLabel = " (Codex)";
+  } else if (stats.source === "combined") {
+    title = "\u2728 AI Coding Wrapped 2025 \u2728";
+    sourceLabel = " (Claude + Codex)";
+  }
+  console.log(`${c.orange}${c.bold}\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557${c.reset}`);
+  console.log(`${c.orange}${c.bold}\u2551${c.reset}                                                            ${c.orange}${c.bold}\u2551${c.reset}`);
+  console.log(`${c.orange}${c.bold}\u2551${c.reset}             ${c.amber}${c.bold}${title}${c.reset}              ${c.orange}${c.bold}\u2551${c.reset}`);
+  console.log(`${c.orange}${c.bold}\u2551${c.reset}                                                            ${c.orange}${c.bold}\u2551${c.reset}`);
+  console.log(`${c.orange}${c.bold}\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D${c.reset}`);
+  console.log();
+  console.log(`${c.bold}\u{1F4CA} Your Year in Numbers${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(60)}${c.reset}`);
+  console.log();
+  const statsLine = [
+    `${c.amber}${c.bold}${stats.sessions}${c.reset} sessions`,
+    `${c.amber}${c.bold}${formatCompactNumber(stats.totalTokens)}${c.reset} tokens`,
+    ...options?.hideCost ? [] : [`${c.amber}${c.bold}$${stats.totalCost.toFixed(0)}${c.reset} spent`],
+    `${c.amber}${c.bold}${stats.daysActive}${c.reset} days active`
+  ];
+  console.log(`  ${statsLine.join("  \u2502  ")}`);
+  console.log();
+  console.log(`${c.bold}\u{1F525} Consistency${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(60)}${c.reset}`);
+  console.log(`  Longest streak: ${c.amber}${c.bold}${stats.longestStreak} days${c.reset}`);
+  console.log(`  Current streak: ${c.green}${stats.currentStreak} days${c.reset}`);
+  console.log();
+  console.log(`${c.bold}\u23F0 Your Coding Patterns${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(60)}${c.reset}`);
+  console.log(`  Peak hour: ${c.amber}${c.bold}${formatHour(stats.peakHour)}${c.reset}`);
+  console.log(`  Favorite day: ${c.amber}${c.bold}${stats.peakDay}${c.reset}`);
+  console.log(`  Busiest month: ${c.cyan}${stats.busiestMonth}${c.reset}`);
+  console.log();
+  console.log(`${c.bold}\u{1F916} Your AI Partners${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(60)}${c.reset}`);
+  console.log(`  Favorite model: ${c.amber}${c.bold}${stats.favoriteModel}${c.reset}`);
+  if (stats.modelBreakdown.length > 0) {
+    console.log(`  Model breakdown:`);
+    for (const { model, percentage } of stats.modelBreakdown) {
+      const filled = Math.max(0, Math.min(20, Math.round(percentage / 100 * 20)));
+      const empty = Math.max(0, 20 - filled);
+      const bar = `${c.amber}${"\u2588".repeat(filled)}${c.gray}${"\u2591".repeat(empty)}${c.reset}`;
+      console.log(`    ${model.padEnd(12)} ${bar} ${percentage}%`);
+    }
+  }
+  console.log();
+  console.log(`${c.bold}\u270D\uFE0F  Words Generated${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(60)}${c.reset}`);
+  console.log(`  ${c.amber}${c.bold}${formatCompactNumber(stats.wordsGenerated)}${c.reset} words of code, docs, and conversation`);
+  console.log(`  ${c.dim}(That's like ${Math.round(stats.wordsGenerated / 5e4)} novels!)${c.reset}`);
+  console.log();
+  console.log(`${c.bold}\u{1F517} Share Your Wrapped${c.reset}`);
+  console.log(`${c.gray}${"\u2500".repeat(60)}${c.reset}`);
+  if (options?.shortUrl) {
+    console.log(`  ${c.amber}${c.bold}${options.shortUrl}${c.reset}`);
+    console.log(`  ${c.dim}(Full URL: ${url})${c.reset}`);
+  } else {
+    console.log(`  ${c.cyan}${url}${c.reset}`);
+  }
+  console.log();
+  console.log(`${c.dim}Generated by vibestats (npx vibestats)${c.reset}`);
+  console.log();
+}
+function formatHour(hour) {
+  if (hour === 0) return "12am";
+  if (hour < 12) return `${hour}am`;
+  if (hour === 12) return "12pm";
+  return `${hour - 12}pm`;
+}
+
+// src/shortener.ts
+async function createShortlink(params, baseUrl) {
+  const queryString = params.includes("?") ? params.split("?")[1] : params;
+  try {
+    const apiUrl = new URL("/api/shorten", baseUrl);
+    const response = await fetch(apiUrl.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ params: queryString })
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    if (data.slug) {
+      return `${baseUrl}/s/${data.slug}`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/config.ts
+import { readFileSync as readFileSync4, existsSync as existsSync4, writeFileSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+var CONFIG_PATH = join4(homedir4(), ".vibestats.json");
+var DEFAULT_CONFIG = {
+  baseUrl: "https://wrapped.wolfai.dev",
+  outputFormat: "normal",
+  theme: {
+    enabled: true
+  },
+  hideCost: false
+};
+function loadConfig() {
+  if (!existsSync4(CONFIG_PATH)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const content = readFileSync4(CONFIG_PATH, "utf-8");
+    const userConfig = JSON.parse(content);
+    return mergeConfig(DEFAULT_CONFIG, userConfig);
+  } catch {
+    console.warn(`Warning: Could not parse config at ${CONFIG_PATH}`);
+    return DEFAULT_CONFIG;
+  }
+}
+function mergeConfig(defaults, user) {
+  return {
+    ...defaults,
+    ...user,
+    theme: {
+      ...defaults.theme,
+      ...user.theme
+    }
+  };
+}
+function initConfig() {
+  if (existsSync4(CONFIG_PATH)) {
+    console.log(`Config file already exists at ${CONFIG_PATH}`);
+    return;
+  }
+  const defaultConfig = {
+    baseUrl: "https://wrapped.wolfai.dev",
+    outputFormat: "normal",
+    theme: {
+      enabled: true
+    },
+    hideCost: false
+  };
+  writeFileSync(CONFIG_PATH, JSON.stringify(defaultConfig, null, 2) + "\n");
+  console.log(`Created config file at ${CONFIG_PATH}`);
+}
+function resolveOptions(cliArgs, config) {
+  let outputFormat = config.outputFormat || "normal";
+  if (cliArgs.json) outputFormat = "json";
+  if (cliArgs.quiet) outputFormat = "quiet";
+  return {
+    baseUrl: cliArgs.url || config.baseUrl || DEFAULT_CONFIG.baseUrl,
+    outputFormat,
+    theme: {
+      enabled: config.theme?.enabled ?? true
+    },
+    statsCachePath: config.statsCachePath,
+    hideCost: config.hideCost ?? false
+  };
+}
+
+// src/index.ts
+var main = defineCommand({
+  meta: {
+    name: "vibestats",
+    version: "1.0.0",
+    description: "AI coding stats - usage tracking and annual wrapped for Claude Code & Codex"
+  },
+  args: {
+    // Mode selection (wrapped is opt-in, usage is default)
+    wrapped: {
+      type: "boolean",
+      alias: "w",
+      description: "Show annual wrapped summary instead of usage stats",
+      default: false
+    },
+    // Data source
+    codex: {
+      type: "boolean",
+      description: "Show only OpenAI Codex CLI stats",
+      default: false
+    },
+    combined: {
+      type: "boolean",
+      description: "Show combined Claude Code + Codex stats",
+      default: false
+    },
+    // Output format
+    json: {
+      type: "boolean",
+      description: "Output raw JSON stats",
+      default: false
+    },
+    quiet: {
+      type: "boolean",
+      alias: "q",
+      description: "Only output the shareable URL (wrapped mode)",
+      default: false
+    },
+    // Usage-specific options
+    daily: {
+      type: "boolean",
+      alias: "d",
+      description: "Aggregate by day (default for usage)",
+      default: false
+    },
+    monthly: {
+      type: "boolean",
+      alias: "m",
+      description: "Show monthly aggregation",
+      default: false
+    },
+    model: {
+      type: "boolean",
+      description: "Aggregate by model",
+      default: false
+    },
+    total: {
+      type: "boolean",
+      alias: "t",
+      description: "Show only totals",
+      default: false
+    },
+    since: {
+      type: "string",
+      description: "Start date for filtering (YYYY-MM-DD)"
+    },
+    until: {
+      type: "string",
+      description: "End date for filtering (YYYY-MM-DD)"
+    },
+    compact: {
+      type: "boolean",
+      alias: "c",
+      description: "Use compact table format (hide cache columns)",
+      default: false
+    },
+    // Wrapped-specific options
+    url: {
+      type: "string",
+      description: "Custom base URL for the wrapped page"
+    },
+    "no-short": {
+      type: "boolean",
+      description: "Disable shortlink generation",
+      default: false
+    },
+    // Config management
+    init: {
+      type: "boolean",
+      description: "Create a default config file",
+      default: false
+    },
+    config: {
+      type: "boolean",
+      description: "Show current config location and values",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (args.init) {
+      initConfig();
+      return;
+    }
+    const config = loadConfig();
+    if (args.config) {
+      console.log(`Config file: ${CONFIG_PATH}`);
+      console.log(JSON.stringify(config, null, 2));
+      return;
+    }
+    if (args.wrapped) {
+      await runWrapped(args, config);
+    } else {
+      await runUsage(args, config);
+    }
+  }
+});
+async function runUsage(args, config) {
+  let aggregation = "daily";
+  if (args.monthly) aggregation = "monthly";
+  else if (args.model) aggregation = "model";
+  else if (args.total) aggregation = "total";
+  const stats = loadUsageStats({
+    aggregation,
+    since: args.since,
+    until: args.until,
+    codexOnly: args.codex,
+    combined: args.combined
+  });
+  if (!stats) {
+    if (args.codex) {
+      console.error("Error: OpenAI Codex data not found at ~/.codex");
+      console.error("Make sure you have used the Codex CLI at least once.");
+    } else if (args.combined) {
+      console.error("Error: No usage data found");
+      console.error("Make sure you have used Claude Code or Codex CLI at least once.");
+    } else {
+      console.error("Error: Claude Code data not found at ~/.claude");
+      console.error("Make sure you have used Claude Code at least once.");
+    }
+    process.exit(1);
+  }
+  if (args.json) {
+    console.log(JSON.stringify(stats, null, 2));
+  } else if (args.quiet) {
+    const t = stats.totals;
+    const costStr = config.hideCost ? "" : ` | $${t.cost.toFixed(2)}`;
+    console.log(`Total: ${formatNumber2(t.totalTokens)} tokens${costStr}`);
+  } else if (aggregation === "total") {
+    displayTotalOnly(stats, {
+      hideCost: config.hideCost,
+      showColors: config.theme?.enabled !== false
+    });
+  } else {
+    displayUsageTable(stats, {
+      compact: args.compact,
+      hideCost: config.hideCost,
+      showColors: config.theme?.enabled !== false
+    });
+  }
+}
+async function runWrapped(args, config) {
+  const options = resolveOptions(args, config);
+  const data = loadData({ codexOnly: args.codex, combined: args.combined });
+  validateData(data, { codexOnly: args.codex, combined: args.combined });
+  let claudeStats = null;
+  let codexStats = null;
+  if (data.claude) {
+    claudeStats = computeWrappedStats(data.claude);
+  }
+  if (data.codex) {
+    codexStats = computeCodexWrappedStats(data.codex);
+  }
+  let stats;
+  if (args.codex && codexStats) {
+    stats = codexStats;
+  } else if (args.combined) {
+    stats = combineWrappedStats(claudeStats, codexStats);
+  } else {
+    stats = claudeStats;
+  }
+  const url = encodeStatsToUrl(stats, options.baseUrl);
+  let shortUrl = null;
+  if (!args["no-short"]) {
+    shortUrl = await createShortlink(url, options.baseUrl);
+  }
+  if (options.outputFormat === "json") {
+    console.log(JSON.stringify({ ...stats, url, shortUrl }, null, 2));
+  } else if (options.outputFormat === "quiet") {
+    console.log(shortUrl || url);
+  } else {
+    displayWrappedStats(stats, url, {
+      theme: options.theme,
+      hideCost: options.hideCost,
+      shortUrl
+    });
+  }
+}
+function formatNumber2(n) {
+  if (n >= 1e9) return `${(n / 1e9).toFixed(1)}B`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toString();
+}
+runMain(main);