ai-usage-analyzer 0.3.2 → 0.5.0

package/src/markdown.js

@@ -3,43 +3,51 @@
 // copies cleanly into issues, PRs, Notion, etc.
 
 import {
-  perProject, perMonth, perWeek, perTool, perToolPerMonth, overall, topSessions, tokenBreakdown,
-  MONTH_NAMES,
-} from './aggregate.js';
-import { getToolBarChar, TOOLS } from './tools.js';
+    MONTH_NAMES,
+    overall,
+    perMonth,
+    perProject,
+    perTool,
+    perToolPerMonth,
+    perWeek,
+    tokenBreakdown,
+    topSessions,
+} from "./aggregate.js";
+import { getToolBarChar, TOOLS } from "./tools.js";
 
 // ---------------------------------------------------------------------------
 // Number formatting helpers (re-implemented locally to avoid TUI deps)
 // ---------------------------------------------------------------------------
 
 export function fmtInt(n) {
-  return Number(n || 0).toLocaleString('en-US');
+  return Number(n || 0).toLocaleString("en-US");
 }
 
 export function fmtCompact(n) {
   const a = Math.abs(n);
-  if (a >= 1e9) return (n / 1e9).toFixed(2) + 'B';
-  if (a >= 1e6) return (n / 1e6).toFixed(2) + 'M';
-  if (a >= 1e3) return (n / 1e3).toFixed(1) + 'K';
+  if (a >= 1e9) return (n / 1e9).toFixed(2) + "B";
+  if (a >= 1e6) return (n / 1e6).toFixed(2) + "M";
+  if (a >= 1e3) return (n / 1e3).toFixed(1) + "K";
   return String(n || 0);
 }
 
-function fmtCost(n) {
-  if (!n) return '—';
-  return '$' + Number(n).toFixed(2);
+function fmtCost(n, status) {
+  if (status === "unavailable") return "unavailable";
+  if (!n) return "—";
+  return (status === "estimated" || status === "partial" ? "~" : "") + "$" + Number(n).toFixed(2) + (status === "partial" ? " (partial)" : "");
 }
 
 function compactHome(p) {
-  if (!p) return '—';
-  const home = process.env.HOME || '';
-  return p.startsWith(home) ? '~' + p.slice(home.length) : p;
+  if (!p) return "—";
+  const home = process.env.HOME || "";
+  return p.startsWith(home) ? "~" + p.slice(home.length) : p;
 }
 
 function bar(value, max, width) {
-  if (!max || max <= 0) return '░'.repeat(width);
+  if (!max || max <= 0) return "░".repeat(width);
   const pct = Math.max(0, Math.min(1, value / max));
   const filled = Math.round(pct * width);
-  return '█'.repeat(filled) + '░'.repeat(width - filled);
+  return "█".repeat(filled) + "░".repeat(width - filled);
 }
 
 // Markdown has no color, so each tool's stacked-bar segment is shown with
@@ -47,17 +55,18 @@ function bar(value, max, width) {
 // src/tools.js alongside its color.
 function stackedBar(byTool, width) {
   const total = Object.values(byTool).reduce((a, b) => a + b, 0);
-  if (total <= 0 || width <= 0) return ' '.repeat(Math.max(0, width));
+  if (total <= 0 || width <= 0) return " ".repeat(Math.max(0, width));
   const entries = Object.entries(byTool)
     .filter(([, v]) => v > 0)
     .sort((a, b) => b[1] - a[1]);
-  let out = '';
+  let out = "";
   let x = 0;
   for (let i = 0; i < entries.length; i++) {
     const [tool, value] = entries[i];
-    const segW = i === entries.length - 1
-      ? width - x
-      : Math.round((value / total) * width);
+    const segW =
+      i === entries.length - 1
+        ? width - x
+        : Math.round((value / total) * width);
     if (segW <= 0) continue;
     out += getToolBarChar(tool).repeat(segW);
     x += segW;
@@ -65,28 +74,32 @@ function stackedBar(byTool, width) {
   return out;
 }
 
-function pct(x) { return (x * 100).toFixed(1) + '%'; }
+function pct(x) {
+  return (x * 100).toFixed(1) + "%";
+}
 
 function mdEscape(s) {
-  if (s == null) return '';
-  return String(s).replace(/\|/g, '\\|').replace(/\n/g, ' ');
+  if (s == null) return "";
+  return String(s).replace(/\|/g, "\\|").replace(/\n/g, " ");
 }
 
 function shortModel(m) {
-  if (!m) return '—';
-  if (typeof m === 'string' && m.trim().startsWith('{')) {
+  if (!m) return "—";
+  if (typeof m === "string" && m.trim().startsWith("{")) {
     try {
       const d = JSON.parse(m);
       const id = d.id || d.model || m;
       const prov = d.providerId || d.provider;
-      return id + (prov ? ` (${prov})` : '');
-    } catch { return m.slice(0, 30); }
+      return id + (prov ? ` (${prov})` : "");
+    } catch {
+      return m.slice(0, 30);
+    }
   }
   return m;
 }
 
 function today() {
-  return new Date().toISOString().split('T')[0];
+  return new Date().toISOString().split("T")[0];
 }
 
 // ---------------------------------------------------------------------------
@@ -94,8 +107,12 @@ function today() {
 // ---------------------------------------------------------------------------
 
 export function renderMarkdown({
-  records = [], detections = [], errors = [],
-  dateRange = [null, null], topN = 5, generatedAt = null,
+  records = [],
+  detections = [],
+  errors = [],
+  dateRange = [null, null],
+  topN = 5,
+  generatedAt = null,
 }) {
   const out = [];
   const tot = overall(records);
@@ -106,16 +123,17 @@ export function renderMarkdown({
   // Header --------------------------------------------------------------
   out.push(`# AI Token Usage Report`);
   out.push(``);
-  out.push(`> Generated by [\`ai-usage-analyzer\`](https://github.com/adetxt/ai-usage-analyzer) on ${generatedAt ? generatedAt.split('T')[0] : today()}`);
+  out.push(
+    `> Generated by [\`ai-usage-analyzer\`](https://github.com/adetxt/ai-usage-analyzer) on ${generatedAt ? generatedAt.split("T")[0] : today()}`,
+  );
   out.push(``);
 
   if (hasData) {
-    out.push(`**Range**: ${dateRange[0] ?? '—'} → ${dateRange[1] ?? '—'}  `);
+    out.push(`**Range**: ${dateRange[0] ?? "—"} → ${dateRange[1] ?? "—"}  `);
     out.push(`**Sessions**: ${fmtInt(records.length)}  `);
     out.push(`**Total tokens**: ${fmtCompact(tot.tokensTotal)}  `);
-    if (tot.cost > 0) {
-      out.push(`**Cost**: ${fmtCost(tot.cost)} (opencode only)  `);
-    }
+    out.push(`**Cost**: ${fmtCost(tot.cost, tot.costStatus)}  `);
+    if (tot.unknownModels.length) out.push(`**Unpriced models**: ${tot.unknownModels.map(mdEscape).join(", ")}  `);
   } else {
     out.push(`**No session data available** — only detection status below.`);
   }
@@ -127,13 +145,13 @@ export function renderMarkdown({
   out.push(`| Tool | Status | Path | Count | Tokens |`);
   out.push(`|---|---|---|---:|---|`);
   for (const d of detections) {
-    const status = d.status === 'present' ? '✅ present' : '❌ absent';
-    const path = d.path ? '`' + mdEscape(compactHome(d.path)) + '`' : '—';
-    const count = d.count ? fmtInt(d.count) : '—';
-    const tok = d.hasTokens
-      ? (d.count ? '✅' : '—')
-      : 'n/a';
-    out.push(`| ${mdEscape(d.name)} | ${status} | ${path} | ${count} | ${tok} |`);
+    const status = d.status === "present" ? "✅ present" : "❌ absent";
+    const path = d.path ? "`" + mdEscape(compactHome(d.path)) + "`" : "—";
+    const count = d.count ? fmtInt(d.count) : "—";
+    const tok = d.hasTokens ? (d.count ? "✅" : "—") : "n/a";
+    out.push(
+      `| ${mdEscape(d.name)} | ${status} | ${path} | ${count} | ${tok} |`,
+    );
   }
   out.push(``);
 
@@ -144,7 +162,7 @@ export function renderMarkdown({
       for (const e of errors) out.push(`- ${mdEscape(e)}`);
       out.push(``);
     }
-    return out.join('\n');
+    return out.join("\n");
   }
 
   // Overview ------------------------------------------------------------
@@ -155,20 +173,34 @@ export function renderMarkdown({
   out.push(`| Tool | Sessions | Total | Avg/sess | Cost |`);
   out.push(`|---|---:|---:|---:|---:|`);
   for (const t of tools) {
-    out.push(`| ${mdEscape(t.tool)} | ${fmtInt(t.n)} | ${fmtCompact(t.tokensTotal)} | ${fmtCompact(t.avg)} | ${fmtCost(t.cost)} |`);
+    out.push(
+      `| ${mdEscape(t.tool)} | ${fmtInt(t.n)} | ${fmtCompact(t.tokensTotal)} | ${fmtCompact(t.avg)} | ${fmtCost(t.cost, t.costStatus)} |`,
+    );
   }
-  out.push(`| **TOTAL** | **${fmtInt(records.length)}** | **${fmtCompact(tot.tokensTotal)}** | **${fmtCompact(tot.avg)}** | **${fmtCost(tot.cost)}** |`);
+  out.push(
+    `| **TOTAL** | **${fmtInt(records.length)}** | **${fmtCompact(tot.tokensTotal)}** | **${fmtCompact(tot.avg)}** | **${fmtCost(tot.cost, tot.costStatus)}** |`,
+  );
   out.push(``);
 
   out.push(`### Token Breakdown`);
   out.push(``);
   out.push(`| Type | Tokens | Share |`);
   out.push(`|---|---:|---:|`);
-  out.push(`| Input | ${fmtCompact(breakdown.input)} | ${pct(breakdown.ratios.input)} |`);
-  out.push(`| Output | ${fmtCompact(breakdown.output)} | ${pct(breakdown.ratios.output)} |`);
-  out.push(`| Cache Read | ${fmtCompact(breakdown.cacheRead)} | ${pct(breakdown.ratios.cacheRead)} |`);
-  out.push(`| Cache Write | ${fmtCompact(breakdown.cacheWrite)} | ${pct(breakdown.ratios.cacheWrite)} |`);
-  out.push(`| Reasoning | ${fmtCompact(breakdown.reasoning)} | ${pct(breakdown.ratios.reasoning)} |`);
+  out.push(
+    `| Input | ${fmtCompact(breakdown.input)} | ${pct(breakdown.ratios.input)} |`,
+  );
+  out.push(
+    `| Output | ${fmtCompact(breakdown.output)} | ${pct(breakdown.ratios.output)} |`,
+  );
+  out.push(
+    `| Cache Read | ${fmtCompact(breakdown.cacheRead)} | ${pct(breakdown.ratios.cacheRead)} |`,
+  );
+  out.push(
+    `| Cache Write | ${fmtCompact(breakdown.cacheWrite)} | ${pct(breakdown.ratios.cacheWrite)} |`,
+  );
+  out.push(
+    `| Reasoning | ${fmtCompact(breakdown.reasoning)} | ${pct(breakdown.ratios.reasoning)} |`,
+  );
   out.push(`| **Total** | **${fmtCompact(breakdown.total)}** | **100.0%** |`);
   out.push(``);
 
@@ -177,18 +209,25 @@ export function renderMarkdown({
   if (projects.length > 0) {
     out.push(`## Per Project`);
     out.push(``);
-    out.push(`| Project | Sessions | Input | Output | Cache | Total | Dist |`);
-    out.push(`|---|---:|---:|---:|---:|---:|---|`);
+    out.push(
+      `| Project | Sessions | By Tool | Input | Output | Cache | Total | Dist |`,
+    );
+    out.push(`|---|---:|---|---:|---:|---:|---:|---|`);
     for (const p of projects) {
       const cache = p.tokensCacheRead + p.tokensCacheWrite;
       const proj = compactHome(p.project);
-      out.push(`| \`${mdEscape(proj)}\` | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${stackedBar(p.byTool, 20)} |`);
+      const nByToolStr = Object.entries(p.nByTool)
+        .sort((a, b) => b[1] - a[1])
+        .map(([tool, count]) => `${tool}×${count}`)
+        .join(" ");
+      out.push(
+        `| \`${mdEscape(proj)}\` | ${fmtInt(p.n)} | ${mdEscape(nByToolStr)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${stackedBar(p.byTool, 20)} |`,
+      );
     }
     out.push(``);
-    const legend = TOOLS
-      .filter(t => t.hasTokens)
-      .map(t => `\`${t.barChar}\` ${t.label}`)
-      .join(' · ');
+    const legend = TOOLS.filter((t) => t.hasTokens)
+      .map((t) => `\`${t.barChar}\` ${t.label}`)
+      .join(" · ");
     out.push(`_Bar legend: ${legend} · \`·\` other_`);
     out.push(``);
   }
@@ -199,11 +238,15 @@ export function renderMarkdown({
     const max = toolRows[0].tokensTotal;
     out.push(`## Per Tool`);
     out.push(``);
-    out.push(`| Tool | Sessions | Input | Output | Cache | Total | Cost | Avg/sess | Dist |`);
+    out.push(
+      `| Tool | Sessions | Input | Output | Cache | Total | Cost | Avg/sess | Dist |`,
+    );
     out.push(`|---|---:|---:|---:|---:|---:|---:|---:|---|`);
     for (const p of toolRows) {
       const cache = p.tokensCacheRead + p.tokensCacheWrite;
-      out.push(`| ${mdEscape(p.tool)} | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${fmtCost(p.cost)} | ${fmtCompact(p.avg)} | ${bar(p.tokensTotal, max, 20)} |`);
+      out.push(
+        `| ${mdEscape(p.tool)} | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${fmtCost(p.cost, p.costStatus)} | ${fmtCompact(p.avg)} | ${bar(p.tokensTotal, max, 20)} |`,
+      );
     }
     out.push(``);
   }
@@ -214,14 +257,18 @@ export function renderMarkdown({
     const max = tpmRows[0].tokensTotal;
     out.push(`## Per Tool per Month`);
     out.push(``);
-    out.push(`| Tool | Month | Sessions | Input | Output | Cache | Total | Dist |`);
+    out.push(
+      `| Tool | Month | Sessions | Input | Output | Cache | Total | Dist |`,
+    );
     out.push(`|---|---|---:|---:|---:|---:|---:|---|`);
     for (const p of tpmRows) {
       const cache = p.tokensCacheRead + p.tokensCacheWrite;
       const yyyy = p.month.slice(0, 4);
       const mm = p.month.slice(5, 7);
       const label = `${MONTH_NAMES[mm] || mm} ${yyyy}`;
-      out.push(`| ${mdEscape(p.tool)} | ${label} | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${bar(p.tokensTotal, max, 18)} |`);
+      out.push(
+        `| ${mdEscape(p.tool)} | ${label} | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${bar(p.tokensTotal, max, 18)} |`,
+      );
     }
     out.push(``);
   }
@@ -237,7 +284,9 @@ export function renderMarkdown({
       const yyyy = m.month.slice(0, 4);
       const mm = m.month.slice(5, 7);
       const label = `${MONTH_NAMES[mm] || mm} ${yyyy}`;
-      out.push(`| ${label} | ${fmtInt(m.n)} | ${fmtCompact(m.tokensInput)} | ${fmtCompact(m.tokensOutput)} | ${fmtCompact(m.tokensTotal)} | ${stackedBar(m.byTool, 20)} |`);
+      out.push(
+        `| ${label} | ${fmtInt(m.n)} | ${fmtCompact(m.tokensInput)} | ${fmtCompact(m.tokensOutput)} | ${fmtCompact(m.tokensTotal)} | ${stackedBar(m.byTool, 20)} |`,
+      );
     }
     out.push(``);
   }
@@ -250,7 +299,9 @@ export function renderMarkdown({
     out.push(`| Week | Sessions | Input | Output | Total | Dist |`);
     out.push(`|---|---:|---:|---:|---:|---|`);
     for (const w of weeks) {
-      out.push(`| ${w.week} | ${fmtInt(w.n)} | ${fmtCompact(w.tokensInput)} | ${fmtCompact(w.tokensOutput)} | ${fmtCompact(w.tokensTotal)} | ${stackedBar(w.byTool, 18)} |`);
+      out.push(
+        `| ${w.week} | ${fmtInt(w.n)} | ${fmtCompact(w.tokensInput)} | ${fmtCompact(w.tokensOutput)} | ${fmtCompact(w.tokensTotal)} | ${stackedBar(w.byTool, 18)} |`,
+      );
     }
     out.push(``);
   }
@@ -264,7 +315,9 @@ export function renderMarkdown({
     out.push(`|---:|---:|---:|---:|---:|---|---|---|`);
     top.forEach((r, i) => {
       const proj = compactHome(r.project);
-      out.push(`| ${i + 1} | ${fmtCompact(r.tokensTotal)} | ${fmtCompact(r.tokensInput)} | ${fmtCompact(r.tokensOutput)} | ${r.cost ? '$' + r.cost.toFixed(4) : '—'} | ${mdEscape(shortModel(r.model))} | \`${mdEscape(proj)}\` | ${mdEscape(r.title || '—')} |`);
+      out.push(
+        `| ${i + 1} | ${fmtCompact(r.tokensTotal)} | ${fmtCompact(r.tokensInput)} | ${fmtCompact(r.tokensOutput)} | ${fmtCost(r.cost, r.costStatus)} | ${mdEscape(shortModel(r.model))} | \`${mdEscape(proj)}\` | ${mdEscape(r.title || "—")} |`,
+      );
     });
     out.push(``);
   }
@@ -272,16 +325,24 @@ export function renderMarkdown({
   // Notes ---------------------------------------------------------------
   out.push(`## Notes`);
   out.push(``);
+  out.push(`Costs marked ~ are API-equivalent estimates; partial totals exclude unpriced usage. Recorded costs come from local tool data and are not necessarily subscription charges.`);
+  out.push(``);
   out.push(`### Token Definitions`);
   out.push(``);
   out.push(`- **Input** — prompt tokens sent to the model`);
   out.push(`- **Output** — completion tokens generated by the model`);
-  out.push(`- **Cache Read** — prompt tokens served from the provider's cache (cheap)`);
-  out.push(`- **Cache Write** — prompt tokens cached for future use (OpenCode only)`);
+  out.push(
+    `- **Cache Read** — prompt tokens served from the provider's cache (cheap)`,
+  );
+  out.push(
+    `- **Cache Write** — prompt tokens cached for future use`,
+  );
   out.push(`- **Reasoning** — extended thinking / chain-of-thought tokens`);
   out.push(``);
 
-  const withTokens = detections.filter(d => d.hasTokens && d.status === 'present');
+  const withTokens = detections.filter(
+    (d) => d.hasTokens && d.status === "present",
+  );
   if (withTokens.length > 0) {
     out.push(`### Detected Tools With Token Data`);
     out.push(``);
@@ -291,7 +352,9 @@ export function renderMarkdown({
     out.push(``);
   }
 
-  const noTokens = detections.filter(d => !d.hasTokens && d.status === 'present');
+  const noTokens = detections.filter(
+    (d) => !d.hasTokens && d.status === "present",
+  );
   if (noTokens.length > 0) {
     out.push(`### Detected Tools Without Token Data`);
     out.push(``);
@@ -313,5 +376,5 @@ export function renderMarkdown({
     out.push(``);
   }
 
-  return out.join('\n');
+  return out.join("\n");
 }

package/src/pricing.js

@@ -0,0 +1,49 @@
+export const PRICING_VERSION = '2026-10-27';
+
+const PRICES = {
+  claude: [
+    [/^claude-opus-4-[5678](?:-\d{8})?$/, [5, 25, 0.5, 6.25]],
+    [/^claude-sonnet-4-6(?:-\d{8})?$/, [3, 15, 0.3, 3.75]],
+    [/^claude-sonnet-4-5(?:-\d{8})?$/, [3, 15, 0.3, 3.75], 200000],
+    [/^claude-sonnet-4(?:-\d{8})?$/, [3, 15, 0.3, 3.75], 200000],
+    [/^claude-haiku-4-5(?:-\d{8})?$/, [1, 5, 0.1, 1.25]],
+    [/^claude-3-5-haiku(?:-\d{8})?$/, [0.8, 4, 0.08, 1]],
+  ],
+  codex: [
+    [/^gpt-5-5(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [5, 30, 0.5, 0], 272000],
+    [/^gpt-5-4-mini(?:-\d{4}-\d{2}-\d{2})?$/, [0.75, 4.5, 0.075, 0]],
+    [/^gpt-5-4-nano(?:-\d{4}-\d{2}-\d{2})?$/, [0.2, 1.25, 0.02, 0]],
+    [/^gpt-5-4-pro(?:-\d{4}-\d{2}-\d{2})?$/, [30, 180, 0, 0], 272000],
+    [/^gpt-5-4(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [2.5, 15, 0.25, 0], 272000],
+    [/^gpt-5-[23](?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [1.75, 14, 0.175, 0]],
+    [/^gpt-5-1(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?$/, [1.25, 10, 0.125, 0]],
+    [/^gpt-5-1-codex-mini(?:-\d{4}-\d{2}-\d{2})?$/, [0.25, 2, 0.025, 0]],
+    [/^gpt-5-mini(?:-\d{4}-\d{2}-\d{2})?$/, [0.25, 2, 0.025, 0]],
+    [/^gpt-5-nano(?:-\d{4}-\d{2}-\d{2})?$/, [0.05, 0.4, 0.005, 0]],
+    [/^gpt-5(?:(?:-codex)?(?:-\d{4}-\d{2}-\d{2})?)$/, [1.25, 10, 0.125, 0]],
+  ],
+};
+
+export function estimateUsage(tool, events) {
+  let cost = 0;
+  let priced = 0;
+  const unknown = new Set();
+  for (const { model, usage, provider, aggregated, ambiguousModel } of events) {
+    const name = String(model || '').toLowerCase().replace(/[._ ]/g, '-').split('/').pop();
+    const price = (PRICES[tool] || []).find(([pattern]) => pattern.test(name));
+    if (!price || (tool === 'codex' && provider && provider.toLowerCase() !== 'openai')) { unknown.add(model || '(unknown model)'); continue; }
+    if (aggregated || ambiguousModel) { unknown.add(`${model || '(unknown model)'} (aggregate usage)`); continue; }
+    const [inputRate, outputRate, cacheRate, writeRate] = price[1];
+    const nonnegative = value => Number.isFinite(Number(value)) ? Math.max(0, Number(value)) : 0;
+    const rawInput = nonnegative(usage.input_tokens);
+    const cache = nonnegative(tool === 'codex' ? usage.cached_input_tokens : usage.cache_read_input_tokens);
+    const input = tool === 'codex' ? Math.max(0, rawInput - cache) : rawInput;
+    const output = nonnegative(usage.output_tokens);
+    const write = nonnegative(usage.cache_creation_input_tokens);
+    const prompt = rawInput + (tool === "claude" ? cache + write : 0);
+    const long = price[2] && prompt > price[2];
+    cost += (input * inputRate * (long ? 2 : 1) + output * outputRate * (long ? 1.5 : 1) + cache * cacheRate * (long ? 2 : 1) + write * writeRate * (long ? 2 : 1)) / 1000000;
+    priced++;
+  }
+  return { cost, costStatus: unknown.size ? (priced ? 'partial' : 'unavailable') : 'estimated', unknownModels: [...unknown] };
+}

package/src/quota.js

@@ -0,0 +1,194 @@
+import { readFile, open, rename, unlink, stat } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+function number(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function resetTime(value) {
+  const seconds = number(value);
+  if (seconds === null || seconds <= 0) return null;
+  const date = new Date(seconds * 1000);
+  return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+
+export function parseCodexQuota(data) {
+  const windows = [];
+  function add(rate, prefix = '') {
+    for (const w of [rate?.primary_window, rate?.secondary_window]) {
+      if (!w || number(w.used_percent) === null) continue;
+      const duration = number(w.limit_window_seconds);
+      const name = duration === 18000 ? 'Session' : duration === 604800 ? 'Weekly' : 'Limit';
+      windows.push({ label: prefix ? `${prefix} ${name}` : name, usedPercent: number(w.used_percent), resetAt: resetTime(w.reset_at) });
+    }
+  }
+  add(data.rate_limit);
+  for (const extra of data.additional_rate_limits || []) {
+    const name = extra.limit_name || extra.metered_feature || 'Additional';
+    add(extra.rate_limit, /spark/i.test(name) ? 'Codex Spark' : name);
+  }
+  const spend = data.spend_control?.individual_limit;
+  if (spend) {
+    const used = number(spend.used), limit = number(spend.limit);
+    const percent = number(spend.used_percent) ?? (limit > 0 && used !== null ? used / limit * 100 : null);
+    if (percent !== null) windows.push({ label: 'Monthly spend', usedPercent: percent, resetAt: resetTime(spend.reset_at) });
+  }
+  return { windows, plan: data.plan_type || null };
+}
+
+export function parseClaudeQuota(data) {
+  const windows = [];
+  for (const [field, label] of [['five_hour', 'Session'], ['seven_day', 'Weekly'], ['seven_day_oauth_apps', 'OAuth Apps'], ['seven_day_sonnet', 'Sonnet'], ['seven_day_opus', 'Opus']]) {
+    const w = data[field];
+    if (w && number(w.utilization) !== null) windows.push({ label, usedPercent: number(w.utilization), resetAt: w.resets_at || null });
+  }
+  for (const [fields, label] of [
+    [['seven_day_design', 'seven_day_claude_design', 'claude_design', 'design', 'seven_day_omelette', 'omelette', 'omelette_promotional'], 'Designs'],
+    [['seven_day_routines', 'seven_day_claude_routines', 'claude_routines', 'routines', 'routine', 'seven_day_cowork', 'cowork'], 'Daily Routines'],
+  ]) {
+    const w = fields.map(field => data[field]).find(Boolean);
+    if (w && number(w.utilization) !== null) windows.push({ label, usedPercent: number(w.utilization), resetAt: w.resets_at || null });
+  }
+  const extra = data.extra_usage;
+  const limit = number(extra?.monthly_limit), used = number(extra?.used_credits);
+  const percent = number(extra?.utilization) ?? (limit > 0 && used !== null ? used / limit * 100 : null);
+  if (extra?.is_enabled && percent !== null) windows.push({ label: 'Extra usage', usedPercent: percent, resetAt: null, used: used === null ? null : used / 100, limit: limit === null ? null : limit / 100, currency: extra.currency || 'USD' });
+  return { windows };
+}
+
+export async function fetchQuota(provider, credentials, fetcher = fetch, signal, versionReader) {
+  if (provider !== 'claude' && provider !== 'codex') throw new Error('Unsupported quota provider');
+  if (!credentials?.accessToken) throw new Error('No OAuth access token available');
+  const claude = provider === 'claude';
+  const headers = { Authorization: `Bearer ${credentials.accessToken}`, Accept: 'application/json' };
+  if (claude) {
+    headers['anthropic-beta'] = 'oauth-2025-04-20';
+    let version = '2.1.0';
+    try {
+      const reader = versionReader || (async () => (await execFileAsync('claude', ['--version'], { timeout: 1000, maxBuffer: 4096, signal })).stdout);
+      const output = await reader();
+      version = String(output).match(/\b\d+\.\d+\.\d+\b/)?.[0] || version;
+    } catch {}
+    signal?.throwIfAborted();
+    headers['User-Agent'] = `claude-code/${version}`;
+  } else if (credentials.accountId) {
+    headers['ChatGPT-Account-Id'] = credentials.accountId;
+  }
+  const response = await fetcher(claude ? 'https://api.anthropic.com/api/oauth/usage' : 'https://chatgpt.com/backend-api/wham/usage', { headers, signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(30000)]) : AbortSignal.timeout(30000) });
+  if (response.status === 401 || response.status === 403) {
+    throw new Error(claude ? 'Claude login is invalid or lacks access; run claude to log in again' : 'Codex login is invalid; run codex login');
+  }
+  if (!response.ok) throw new Error(`Quota request failed (HTTP ${response.status})`);
+  const data = await response.json();
+  const result = { provider, ...(claude ? parseClaudeQuota(data) : parseCodexQuota(data)) };
+  if (!claude && credentials.idToken && credentials.idToken.length < 65536) {
+    try {
+      const claims = JSON.parse(Buffer.from(credentials.idToken.split('.')[1], 'base64url').toString('utf8'));
+      if (typeof claims.email === 'string') result.email = claims.email;
+      if (!result.plan && typeof claims['https://api.openai.com/auth']?.chatgpt_plan_type === 'string') result.plan = claims['https://api.openai.com/auth'].chatgpt_plan_type;
+    } catch {}
+  }
+  return result;
+}
+
+export async function readCredentials(provider, env = process.env, options = {}) {
+  if (provider === 'codex') {
+    const file = join(env.CODEX_HOME || join(homedir(), '.codex'), 'auth.json');
+    const auth = JSON.parse(await readFile(file, 'utf8'));
+    if (auth.OPENAI_API_KEY) throw new Error('OAuth usage limits require codex login');
+    return { accessToken: auth.tokens?.access_token, refreshToken: auth.tokens?.refresh_token, idToken: auth.tokens?.id_token, accountId: auth.tokens?.account_id, lastRefresh: auth.last_refresh, authPath: file };
+  }
+  if (provider !== 'claude') throw new Error('Unsupported quota provider');
+  const token = env.TOKCAT_CLAUDE_OAUTH_TOKEN || env.CODEXBAR_CLAUDE_OAUTH_TOKEN;
+  if (token) return { accessToken: token };
+  let raw;
+  if ((options.platform || process.platform) === 'darwin') {
+    const getKeychain = options.getKeychain || (async () => (await execFileAsync('/usr/bin/security', ['find-generic-password', '-s', 'Claude Code-credentials', '-w'], { timeout: 5000, maxBuffer: 1024 * 1024, signal: options.signal })).stdout);
+    try { raw = await getKeychain(); }
+    catch (error) {
+      if (options.signal?.aborted) throw error;
+      if (error.killed || error.code === 'ETIMEDOUT') throw new Error('Claude Keychain access timed out; check the permission prompt');
+    }
+  }
+  if (!raw) {
+    const file = join(env.CLAUDE_HOME || join(homedir(), '.claude'), '.credentials.json');
+    raw = await readFile(file, 'utf8');
+  }
+  const oauth = JSON.parse(raw).claudeAiOauth || {};
+  if (oauth.expiresAt && oauth.expiresAt <= Date.now()) throw new Error('Claude token expired; run claude to refresh it');
+  if (oauth.scopes && !oauth.scopes.includes('user:profile')) throw new Error('Claude login lacks user:profile scope');
+  return { accessToken: oauth.accessToken };
+}
+
+export async function refreshCodexCredentials(path, fetcher = fetch, signal) {
+  const original = await readFile(path, 'utf8');
+  const auth = JSON.parse(original);
+  if (!auth.tokens?.refresh_token) throw new Error('Codex refresh token unavailable; run codex login');
+  const response = await fetcher('https://auth.openai.com/oauth/token', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+    body: JSON.stringify({ client_id: 'app_EMoamEEZ73f0CkXaXp7hrann', grant_type: 'refresh_token', refresh_token: auth.tokens.refresh_token, scope: 'openid profile email' }),
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(30000)]) : AbortSignal.timeout(30000),
+  });
+  if (!response.ok) throw new Error('Codex refresh failed; run codex login');
+  const tokens = await response.json();
+  if (!tokens.access_token) throw new Error('Codex refresh returned incomplete credentials; run codex login');
+  auth.tokens = { ...auth.tokens, access_token: tokens.access_token, refresh_token: tokens.refresh_token || auth.tokens.refresh_token, ...(tokens.id_token ? { id_token: tokens.id_token } : {}) };
+  auth.last_refresh = new Date().toISOString();
+  const temp = `${path}.${randomUUID()}.tmp`;
+  let handle;
+  try {
+    const mode = (await stat(path)).mode & 0o600;
+    handle = await open(temp, 'wx', mode || 0o600);
+    await handle.writeFile(JSON.stringify(auth, null, 2));
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    if (await readFile(path, 'utf8') !== original) throw new Error('Codex credentials changed during refresh; run codex login if needed');
+    await rename(temp, path);
+  } finally {
+    if (handle) await handle.close();
+    await unlink(temp).catch(() => {});
+  }
+  return { accessToken: auth.tokens.access_token, refreshToken: auth.tokens.refresh_token, idToken: auth.tokens.id_token, accountId: auth.tokens.account_id, lastRefresh: auth.last_refresh, authPath: path };
+}
+
+export async function collectQuotas(options = {}) {
+  const read = options.read || ((provider) => readCredentials(provider, process.env, { signal: options.signal }));
+  const refresh = options.refresh || ((path) => refreshCodexCredentials(path, fetch));
+  const request = options.fetch || ((provider, credentials) => fetchQuota(provider, credentials, fetch, options.signal));
+  return Promise.all(['claude', 'codex'].map(async (provider) => {
+    try {
+      let credentials = await read(provider);
+      options.signal?.throwIfAborted();
+      const refreshedAt = Date.parse(credentials.lastRefresh);
+      if (provider === 'codex' && (!Number.isFinite(refreshedAt) || Date.now() - refreshedAt > 8 * 86400000)) {
+        credentials = await refresh(credentials.authPath);
+      }
+      options.signal?.throwIfAborted();
+      return await request(provider, credentials);
+    } catch (error) {
+      const safe = /^(Claude token expired|Claude login lacks|Claude login is invalid|Codex login is invalid|Claude Keychain access|OAuth usage limits|Codex refresh|Codex credentials changed|No OAuth access token|Quota request failed)/;
+      const message = safe.test(error.message || '') ? error.message : 'Quota unavailable; check your login and network connection';
+      return { provider, windows: [], error: message };
+    }
+  }));
+}
+
+export function renderQuota(quotas) {
+  if (!quotas) return 'Loading quota information…';
+  return quotas.map(({ provider, windows, error, email, plan }) => {
+    const name = provider === 'claude' ? 'Claude' : 'Codex';
+    const lines = error ? [error] : windows.length ? windows.map((w) => `${w.label}: ${w.usedPercent}% used${w.used != null && w.limit != null ? ` · ${w.currency} ${w.used.toFixed(2)} / ${w.limit.toFixed(2)}` : ''}${w.resetAt ? ` · resets ${w.resetAt}` : ''}`) : ['No quota windows available'];
+    const identity = [email, plan].filter(Boolean).join(' · ');
+    return `${name}${identity ? ` (${identity})` : ''}\n${lines.map((line) => `  ${line}`).join('\n')}`;
+  }).join('\n\n').replace(/[\x00-\x09\x0b-\x1f\x7f-\x9f]/g, '');
+}