@1930dev/opencode-usage 0.1.0

package/dist/cli.js

@@ -0,0 +1,922 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/core/src/types.ts
+function parseDuration(input) {
+  const m = /^(\d+)\s*(h|d|w)$/.exec(input.trim().toLowerCase());
+  if (!m)
+    throw new Error(`invalid duration: ${input} (use Nh, Nd or Nw)`);
+  const n = Number(m[1]);
+  const ms = { h: 3600000, d: 86400000, w: 604800000 }[m[2]];
+  return n * ms;
+}
+function startOfDayMs(now = Date.now()) {
+  const d = new Date(now);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+function startOfMonthMs(now = Date.now()) {
+  const d = new Date(now);
+  d.setDate(1);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+// packages/core/src/db.ts
+import { Database } from "bun:sqlite";
+
+// packages/core/src/config.ts
+import path from "path";
+function home() {
+  const h = process.env.HOME;
+  if (!h)
+    throw new Error("HOME is not set");
+  return h;
+}
+function dbPath() {
+  return process.env.OPENCODE_DB_PATH ?? path.join(home(), ".local/share/opencode/opencode.db");
+}
+function authPath() {
+  return process.env.OPENCODE_AUTH_PATH ?? path.join(home(), ".local/share/opencode/auth.json");
+}
+function cacheDir() {
+  return process.env.OPENCODE_USAGE_CACHE ?? path.join(home(), ".cache/opencode-usage");
+}
+function budgetsPath() {
+  return process.env.OPENCODE_USAGE_BUDGETS ?? path.join(home(), ".config/opencode-usage/budgets.json");
+}
+
+// packages/core/src/db.ts
+function openDb() {
+  const db = new Database(dbPath(), { readonly: true });
+  db.exec("PRAGMA query_only = true");
+  return db;
+}
+var COST = "CAST(json_extract(data,'$.cost') AS REAL)";
+var T_IN = "CAST(json_extract(data,'$.tokens.input') AS INTEGER)";
+var T_OUT = "CAST(json_extract(data,'$.tokens.output') AS INTEGER)";
+var T_REA = "CAST(json_extract(data,'$.tokens.reasoning') AS INTEGER)";
+var T_CR = "CAST(json_extract(data,'$.tokens.cache.read') AS INTEGER)";
+var T_CW = "CAST(json_extract(data,'$.tokens.cache.write') AS INTEGER)";
+var CREATED = "CAST(json_extract(data,'$.time.created') AS INTEGER)";
+var GROUPS = {
+  provider: "json_extract(data,'$.providerID')",
+  model: "json_extract(data,'$.providerID') || '/' || json_extract(data,'$.modelID')",
+  day: "strftime('%Y-%m-%d', (${" + CREATED + "})/1000, 'unixepoch')",
+  project: "json_extract(data,'$.path.cwd')",
+  agent: "json_extract(data,'$.agent')"
+};
+function usageSince(db, sinceMs, groupBy = "provider") {
+  const g = GROUPS[groupBy];
+  const rows = db.query(`SELECT ${g} AS grp,
+              COALESCE(json_extract(data,'$.providerID'),'?') AS provider,
+              COALESCE(json_extract(data,'$.modelID'),'?') AS model,
+              COUNT(*) AS messages,
+              COALESCE(SUM(${COST}),0) AS cost,
+              COALESCE(SUM(${T_IN}),0) AS tokensInput,
+              COALESCE(SUM(${T_OUT}),0) AS tokensOutput,
+              COALESCE(SUM(${T_REA}),0) AS tokensReasoning,
+              COALESCE(SUM(${T_CR}),0) AS tokensCacheRead,
+              COALESCE(SUM(${T_CW}),0) AS tokensCacheWrite
+       FROM message
+       WHERE json_extract(data,'$.role')='assistant'
+         AND ${CREATED} >= ?
+       GROUP BY grp
+       ORDER BY cost DESC`).all(sinceMs);
+  return rows.map((r) => ({
+    group: String(r.grp),
+    provider: String(r.provider),
+    model: String(r.model),
+    day: "",
+    project: "",
+    agent: "",
+    messages: Number(r.messages),
+    cost: Number(r.cost),
+    tokensInput: Number(r.tokensInput),
+    tokensOutput: Number(r.tokensOutput),
+    tokensReasoning: Number(r.tokensReasoning),
+    tokensCacheRead: Number(r.tokensCacheRead),
+    tokensCacheWrite: Number(r.tokensCacheWrite)
+  }));
+}
+function usageTotals(db, sinceMs) {
+  const r = db.query(`SELECT COUNT(*) AS messages,
+              COALESCE(SUM(${COST}),0) AS cost,
+              COALESCE(SUM(${T_IN}),0) AS tokensInput,
+              COALESCE(SUM(${T_OUT}),0) AS tokensOutput
+       FROM message
+       WHERE json_extract(data,'$.role')='assistant' AND ${CREATED} >= ?`).get(sinceMs);
+  return {
+    messages: Number(r?.messages ?? 0),
+    cost: Number(r?.cost ?? 0),
+    tokensInput: Number(r?.tokensInput ?? 0),
+    tokensOutput: Number(r?.tokensOutput ?? 0)
+  };
+}
+function localUsageByProvider(db, sinceMs) {
+  const rows = db.query(`SELECT COALESCE(json_extract(data,'$.providerID'),'?') AS provider,
+              COUNT(*) AS messages,
+              COALESCE(SUM(${COST}),0) AS cost,
+              COALESCE(SUM(${T_IN} + ${T_OUT}),0) AS tokens,
+              MAX(${CREATED}) AS lastUsedMs
+       FROM message
+       WHERE json_extract(data,'$.role')='assistant'
+         AND ${CREATED} >= ?
+       GROUP BY provider`).all(sinceMs);
+  const map = new Map;
+  for (const r of rows) {
+    map.set(String(r.provider), {
+      provider: String(r.provider),
+      messages: Number(r.messages),
+      cost: Number(r.cost),
+      tokens: Number(r.tokens),
+      lastUsedMs: Number(r.lastUsedMs)
+    });
+  }
+  return map;
+}
+function monthlyUsageByProvider(db, startOfMonthMs2) {
+  const rows = db.query(`SELECT COALESCE(json_extract(data,'$.providerID'),'?') AS provider,
+              COALESCE(SUM(CAST(json_extract(data,'$.cost') AS REAL)),0) AS cost
+       FROM message
+       WHERE json_extract(data,'$.role')='assistant'
+         AND CAST(json_extract(data,'$.time.created') AS INTEGER) >= ?
+       GROUP BY provider`).all(startOfMonthMs2);
+  const map = new Map;
+  for (const r of rows) {
+    map.set(String(r.provider), Number(r.cost));
+  }
+  return map;
+}
+// packages/core/src/providers.ts
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import path2 from "path";
+
+// packages/core/src/auth.ts
+import { readFile } from "fs/promises";
+async function readAuth() {
+  try {
+    return JSON.parse(await readFile(authPath(), "utf8"));
+  } catch (err) {
+    throw new Error(`cannot read opencode auth store: ${err.message}`);
+  }
+}
+function authSecret(entry) {
+  return entry.key ?? entry.access;
+}
+
+// packages/core/src/quota/shared.ts
+var BROWSER_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36";
+async function getJson(url, headers) {
+  const res = await fetch(url, { headers: { "User-Agent": BROWSER_UA, ...headers }, signal: AbortSignal.timeout(15000) });
+  if (!res.ok)
+    throw new Error(`HTTP ${res.status} from ${url}`);
+  return res.json();
+}
+
+// packages/core/src/quota/zen.ts
+async function fetchZen(key) {
+  try {
+    const data = await getJson("https://opencode.ai/zen/go/v1/usage", {
+      Authorization: `Bearer ${key}`
+    });
+    const u = data.usage;
+    const windows = [
+      { label: "5h", percentUsed: u.rolling.percent, resetsAt: u.rolling.resetsAt, status: u.rolling.status },
+      { label: "weekly", percentUsed: u.weekly.percent, resetsAt: u.weekly.resetsAt, status: u.weekly.status },
+      { label: "monthly", percentUsed: u.monthly.percent, resetsAt: u.monthly.resetsAt, status: u.monthly.status }
+    ];
+    const binding = windows.reduce((a, b) => b.percentUsed > a.percentUsed ? b : a);
+    return {
+      provider: "opencode-go",
+      ok: true,
+      windows,
+      budget: { percentUsed: binding.percentUsed, label: binding.label },
+      raw: data
+    };
+  } catch (err) {
+    return { provider: "opencode-go", ok: false, detail: err.message, windows: [] };
+  }
+}
+
+// packages/core/src/quota/openrouter.ts
+async function fetchOpenRouter(key) {
+  try {
+    const credits = await getJson("https://openrouter.ai/api/v1/credits", {
+      Authorization: `Bearer ${key}`
+    });
+    let keyInfo;
+    try {
+      keyInfo = (await getJson("https://openrouter.ai/api/v1/key", { Authorization: `Bearer ${key}` })).data;
+    } catch {
+      keyInfo = undefined;
+    }
+    const totalCredits = credits.data.total_credits;
+    const totalUsage = credits.data.total_usage;
+    const balance = totalCredits - totalUsage;
+    const pct = totalCredits > 0 ? totalUsage / totalCredits * 100 : 0;
+    return {
+      provider: "openrouter",
+      ok: true,
+      detail: `balance $${balance.toFixed(2)} of $${totalCredits.toFixed(2)}`,
+      windows: keyInfo ? [
+        { label: "daily", percentUsed: 0, detail: `$${keyInfo.usage_daily.toFixed(4)}` },
+        { label: "weekly", percentUsed: 0, detail: `$${keyInfo.usage_weekly.toFixed(4)}` },
+        { label: "monthly", percentUsed: 0, detail: `$${keyInfo.usage_monthly.toFixed(4)}` }
+      ] : [],
+      budget: totalCredits > 0 ? { percentUsed: pct, label: "credits" } : undefined,
+      raw: { credits: credits.data, key: keyInfo }
+    };
+  } catch (err) {
+    return { provider: "openrouter", ok: false, detail: err.message, windows: [] };
+  }
+}
+
+// packages/core/src/quota/copilot.ts
+function premiumBudget(s) {
+  if (s.unlimited && s.entitlement === 0)
+    return;
+  const remaining = s.remaining ?? s.quota_remaining;
+  if (remaining === undefined)
+    return;
+  const entitlement = s.entitlement;
+  if (entitlement <= 0)
+    return;
+  const used = (entitlement - remaining) / entitlement * 100;
+  return { percentUsed: used, label: "premium/mo" };
+}
+async function fetchCopilot(token) {
+  try {
+    const data = await getJson("https://api.github.com/copilot_internal/user", {
+      Authorization: `token ${token}`,
+      Accept: "application/json",
+      "Editor-Version": "vscode/1.96.2",
+      "Editor-Plugin-Version": "copilot-chat/0.26.7",
+      "X-Github-Api-Version": "2025-04-01"
+    });
+    const snaps = data.quota_snapshots ?? {};
+    const interesting = ["premium_interactions", "completions", "chat", "agent", "preview_features"];
+    const windows = Object.entries(snaps).filter(([id]) => interesting.includes(id)).map(([id, s]) => ({
+      label: id.replace(/_/g, " "),
+      percentUsed: s.unlimited && s.entitlement === 0 ? 0 : Math.round(100 - s.percent_remaining),
+      resetsAt: data.quota_reset_date,
+      detail: s.unlimited ? "unlimited" : `${s.quota_remaining} left of ${s.entitlement}`
+    }));
+    const budget = premiumBudget(snaps.premium_interactions) ?? premiumBudget(snaps.agent) ?? undefined;
+    return {
+      provider: "github-copilot",
+      ok: true,
+      detail: `plan ${data.copilot_plan}`,
+      windows,
+      budget,
+      raw: data
+    };
+  } catch (err) {
+    return { provider: "github-copilot", ok: false, detail: err.message, windows: [] };
+  }
+}
+
+// packages/core/src/quota/zai.ts
+function parseZai(data) {
+  if (data.success === false || data.code !== undefined && data.code !== 0) {
+    return { provider: "zai", ok: false, detail: data.msg ?? "quota endpoint error", windows: [] };
+  }
+  const limits = data.data?.limits ?? [];
+  const budget = limits.length > 0 ? { percentUsed: limits[0].percentage ?? 0, label: limits[0].name ?? limits[0].limitType ?? "limit" } : undefined;
+  return {
+    provider: "zai",
+    ok: true,
+    detail: data.data?.planName,
+    windows: limits.map((l) => ({
+      label: l.name ?? l.limitType ?? "limit",
+      percentUsed: l.percentage ?? 0,
+      resetsAt: l.nextResetTime ? new Date(l.nextResetTime).toISOString() : undefined
+    })),
+    budget,
+    raw: data
+  };
+}
+async function fetchZai(key) {
+  try {
+    const data = await getJson("https://api.z.ai/api/monitor/usage/quota/limit", {
+      Authorization: `Bearer ${key}`,
+      Accept: "application/json"
+    });
+    return parseZai(data);
+  } catch (err) {
+    return { provider: "zai", ok: false, detail: err.message, windows: [] };
+  }
+}
+
+// packages/core/src/providers.ts
+var TTL_MS = 15 * 60 * 1000;
+async function readCache() {
+  try {
+    const raw = JSON.parse(await readFile2(path2.join(cacheDir(), "quota.json"), "utf8"));
+    if (Date.now() - raw.fetchedAt > TTL_MS)
+      return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(quotas) {
+  await mkdir(cacheDir(), { recursive: true });
+  const file = { fetchedAt: Date.now(), quotas };
+  await writeFile(path2.join(cacheDir(), "quota.json"), JSON.stringify(file));
+}
+var FETCHERS = {
+  "opencode-go": fetchZen,
+  openrouter: fetchOpenRouter,
+  "github-copilot": fetchCopilot,
+  zai: fetchZai
+};
+async function providerStatuses(opts) {
+  const auth = await readAuth();
+  const providers = Object.keys(auth).sort();
+  let cached = {};
+  let quotaSource = "none";
+  if (opts.noNet) {
+    const c = await readCache();
+    if (c) {
+      cached = c.quotas;
+      quotaSource = "cache";
+    }
+  } else {
+    const c = await readCache();
+    const fresh = {};
+    const live = await Promise.all(providers.map(async (p) => {
+      const fetcher = FETCHERS[p];
+      const secret = authSecret(auth[p]);
+      if (!fetcher || !secret)
+        return null;
+      return fetcher(secret);
+    }));
+    for (const q of live) {
+      if (q)
+        fresh[q.provider] = q;
+    }
+    if (Object.keys(fresh).length > 0) {
+      await writeCache(fresh);
+      cached = fresh;
+      quotaSource = "live";
+    } else if (c) {
+      cached = c.quotas;
+      quotaSource = "cache";
+    }
+  }
+  return providers.map((p) => ({
+    provider: p,
+    auth: true,
+    quota: cached[p] ?? null,
+    quotaSource: cached[p] ? quotaSource : "none"
+  }));
+}
+// packages/core/src/report.ts
+function fmtTokens(n) {
+  if (n >= 1e9)
+    return `${(n / 1e9).toFixed(1)}B`;
+  if (n >= 1e6)
+    return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1000)
+    return `${(n / 1000).toFixed(1)}K`;
+  return String(n);
+}
+function fmtCost(n) {
+  return `$${n.toFixed(2)}`;
+}
+function fmtAgo(ms, now = Date.now()) {
+  const diff = now - ms;
+  const h = Math.floor(diff / 3600000);
+  if (h < 1)
+    return `${Math.max(1, Math.floor(diff / 60000))}m ago`;
+  if (h < 24)
+    return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
+function pad(s, n) {
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+function table(headers, rows) {
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+  const line = (cells) => cells.map((c, i) => pad(c, widths[i])).join("  ");
+  const head = line(headers);
+  const sep = widths.map((w) => "-".repeat(w)).join("  ");
+  const body = rows.map(line).join(`
+`);
+  return [head, sep, body].join(`
+`);
+}
+function usageTable(rows, totals, sinceLabel, groupBy, pct) {
+  const headers = [groupBy.toUpperCase(), "MSGS", "TOK IN", "TOK OUT", "EST COST"];
+  if (pct)
+    headers.push("% BUDGET");
+  const body = rows.slice(0, 30).map((r) => {
+    const row = [
+      r.group,
+      String(r.messages),
+      fmtTokens(r.tokensInput),
+      fmtTokens(r.tokensOutput),
+      fmtCost(r.cost)
+    ];
+    if (pct) {
+      const p = pct.get(r.provider);
+      if (p)
+        row.push(`${p.pct.toFixed(1)}%${p.label ? ` ${p.label}` : ""}`);
+      else
+        row.push("\u2014");
+    }
+    return row;
+  });
+  const t = table(headers, body);
+  const sourceNote = pct ? `
+[sources: ${[...pct.values()].map((p) => `${p.source}${p.label ? `(${p.label})` : ""}`).filter((v, i, a) => a.indexOf(v) === i).join(", ")}]` : "";
+  return `${t}
+
+TOTAL since ${sinceLabel}: ${totals.messages} msgs, ${fmtTokens(totals.tokensInput)} in / ${fmtTokens(totals.tokensOutput)} out, ${fmtCost(totals.cost)} est.${sourceNote}`;
+}
+function providersTable(statuses, local) {
+  const headers = ["PROVIDER", "QUOTA", "USAGE 7D (LOCAL)", "LAST USED"];
+  const rows = statuses.map((s) => {
+    const quota = s.quota ? s.quota.ok ? s.quota.windows.map((w) => w.detail ? `${w.label} ${w.detail}` : `${w.label} ${w.percentUsed}%`).join(", ") || s.quota.detail || "ok" : `unavailable (${s.quota.detail ?? "error"})` : "solo-local";
+    const loc = local.get(s.provider);
+    const usage = loc ? `${loc.messages} msgs, ${fmtCost(loc.cost)}` : "\u2014";
+    const last = loc ? fmtAgo(loc.lastUsedMs) : "never";
+    return [s.provider, quota, usage, last];
+  });
+  return table(headers, rows);
+}
+// packages/core/src/ranking/fetch.ts
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+var {$ } = globalThis.Bun;
+var TTL_MS2 = 24 * 60 * 60 * 1000;
+async function readCache2(file) {
+  try {
+    const raw = JSON.parse(await readFile3(path3.join(cacheDir(), file), "utf8"));
+    if (Date.now() - raw.fetchedAt > TTL_MS2)
+      return null;
+    return raw.data;
+  } catch {
+    return null;
+  }
+}
+async function writeCache2(file, data) {
+  await mkdir2(cacheDir(), { recursive: true });
+  await writeFile2(path3.join(cacheDir(), file), JSON.stringify({ fetchedAt: Date.now(), data }));
+}
+async function fetchModelsDev() {
+  const cached = await readCache2("models-dev.json");
+  if (cached)
+    return cached;
+  const res = await fetch("https://models.dev/api.json", { signal: AbortSignal.timeout(30000) });
+  if (!res.ok)
+    throw new Error(`models.dev fetch failed: HTTP ${res.status}`);
+  const data = await res.json();
+  const flat = {};
+  for (const provider of Object.values(data)) {
+    for (const [id, model] of Object.entries(provider.models)) {
+      flat[id] = model;
+    }
+  }
+  await writeCache2("models-dev.json", flat);
+  return flat;
+}
+async function aaApiKey() {
+  if (process.env.AA_API_KEY)
+    return process.env.AA_API_KEY;
+  const projectId = process.env.INFISICAL_PROJECT_ID;
+  if (!projectId)
+    return;
+  try {
+    const out = await $`infisical-secret get AA_API_KEY --projectId ${projectId} --env prod --plain --silent`.text();
+    return out.trim() || undefined;
+  } catch {
+    return;
+  }
+}
+async function fetchAA() {
+  const cached = await readCache2("aa.json");
+  if (cached)
+    return cached;
+  const key = await aaApiKey();
+  if (!key)
+    return [];
+  const res = await fetch("https://artificialanalysis.ai/api/v2/data/llms/models", {
+    headers: { "x-api-key": key },
+    signal: AbortSignal.timeout(30000)
+  });
+  if (!res.ok)
+    throw new Error(`AA fetch failed: HTTP ${res.status}`);
+  const data = await res.json();
+  await writeCache2("aa.json", data.data);
+  return data.data;
+}
+
+// packages/core/src/ranking/matcher.ts
+var ALIASES = {
+  "gpt-5": "gpt-5",
+  "gpt-5-codex": "gpt-5-codex",
+  "claude-opus-4-5": "claude-opus-5",
+  "claude-sonnet-4-5": "claude-sonnet-5",
+  "claude-sonnet-4": "claude-sonnet-4",
+  "claude-3-5-sonnet": "claude-35-sonnet",
+  "gemini-2-5-pro": "gemini-2-5-pro",
+  "gemini-2-5-flash": "gemini-2-5-flash",
+  "deepseek-v3": "deepseek-v3",
+  "deepseek-r1": "deepseek-r1",
+  "qwen-2-5-coder": "qwen2-5-coder",
+  "qwen-3": "qwen3",
+  "llama-3-1-405b": "llama-3-1-405b",
+  "llama-3-1-70b": "llama-3-1-70b",
+  "llama-3-1-8b": "llama-3-1-8b",
+  "minimax-m2-1": "minimax-m2-1",
+  "command-r-plus": "command-r-plus",
+  "command-r": "command-r"
+};
+function normalize(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").replace(/-(202[0-9]{5})$/, "");
+}
+function normalizeModelsDevId(id) {
+  const afterProvider = id.includes("/") ? id.split("/").pop() ?? id : id;
+  return normalize(afterProvider);
+}
+function buildMatcher(aaModels, modelsDev) {
+  const aaByNorm = new Map;
+  for (const m of aaModels) {
+    const key = normalize(m.slug ?? m.id ?? m.name);
+    if (!aaByNorm.has(key))
+      aaByNorm.set(key, m);
+    const alias = ALIASES[key];
+    if (alias && !aaByNorm.has(alias))
+      aaByNorm.set(alias, m);
+  }
+  for (const [alias, target] of Object.entries(ALIASES)) {
+    const m = aaModels.find((x) => normalize(x.slug ?? x.id ?? x.name) === target);
+    if (m)
+      aaByNorm.set(alias, m);
+  }
+  return (md) => {
+    const key = normalizeModelsDevId(md.id);
+    if (aaByNorm.has(key))
+      return aaByNorm.get(key);
+    const alias = ALIASES[key];
+    if (alias && aaByNorm.has(alias))
+      return aaByNorm.get(alias);
+    return;
+  };
+}
+
+// packages/core/src/ranking/metrics.ts
+function getIntelligenceIndex(model) {
+  return model.evaluations?.artificial_analysis_intelligence_index ?? undefined;
+}
+function blendedPrice(cost) {
+  const input = cost.input ?? 0;
+  const output = cost.output ?? 0;
+  return (3 * input + 1 * output) / 4;
+}
+function valueScore(intelligenceIndex, cost) {
+  if (intelligenceIndex === undefined || intelligenceIndex <= 0)
+    return;
+  const bp = blendedPrice(cost);
+  if (bp <= 0)
+    return;
+  return intelligenceIndex / bp;
+}
+
+// packages/core/src/top.ts
+async function buildTop(limit) {
+  const [modelsDev, aaModels] = await Promise.all([fetchModelsDev(), fetchAA()]);
+  const match = buildMatcher(aaModels, modelsDev);
+  const seen = new Set;
+  const rows = [];
+  for (const [id, md] of Object.entries(modelsDev)) {
+    if (!md.cost || md.cost.input === 0)
+      continue;
+    const modelId = id.includes("/") ? id.split("/").pop() : id;
+    const key = `${modelId}`;
+    if (seen.has(key))
+      continue;
+    const aa = match(md);
+    const ii = aa ? getIntelligenceIndex(aa) : undefined;
+    const coding = aa?.evaluations?.artificial_analysis_coding_index ?? undefined;
+    const bp = blendedPrice(md.cost);
+    const vs = valueScore(ii, md.cost);
+    seen.add(key);
+    rows.push({ model: modelId, name: md.name ?? modelId, intelligence: ii, codingIndex: coding, blended: bp, value: vs });
+  }
+  rows.sort((a, b) => (b.value ?? -1) - (a.value ?? -1));
+  return rows.slice(0, limit);
+}
+// packages/core/src/budget.ts
+import { readFile as readFile4 } from "fs/promises";
+async function readBudgets() {
+  try {
+    return JSON.parse(await readFile4(budgetsPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function pctFromLimit(provider, limit, usageTokens, usageRequests, isMonthly) {
+  if (limit.limit <= 0)
+    return;
+  const effectiveLimit = limit.metric.endsWith("/day") && limit.metric !== "neurons/day" ? limit.limit * 30 : limit.limit;
+  const metric = limit.metric.replace("/day", "").replace("/month", "");
+  switch (metric) {
+    case "tokens":
+      if (effectiveLimit > 0)
+        return usageTokens / effectiveLimit * 100;
+      return;
+    case "requests":
+      if (effectiveLimit > 0)
+        return usageRequests / effectiveLimit * 100;
+      return;
+    case "credits":
+    case "neurons":
+      return;
+    default:
+      return;
+  }
+}
+function resolvePct(provider, live, budgets, monthCost, usageTokens, usageRequests, limits) {
+  const liveQ = live.get(provider);
+  if (liveQ?.budget && liveQ.ok) {
+    return { pct: liveQ.budget.percentUsed, source: "live", label: liveQ.budget.label };
+  }
+  if (budgets[provider] !== undefined) {
+    const budget = budgets[provider];
+    if (budget <= 0)
+      return { pct: 0, source: "budgets" };
+    return { pct: monthCost / budget * 100, source: "budgets" };
+  }
+  const limit = limits.get(provider);
+  if (limit) {
+    const pct = pctFromLimit(provider, limit, usageTokens, usageRequests, true);
+    if (pct !== undefined) {
+      return { pct, source: "limits", label: `${limit.limit.toLocaleString()} ${limit.unit}/${limit.metric.split("/")[1]}` };
+    }
+  }
+  return { pct: 0, source: "none" };
+}
+// packages/core/src/limits.ts
+var PROVIDER_LIMITS = [
+  {
+    provider: "groq",
+    metric: "tokens/day",
+    limit: 200000,
+    unit: "tokens",
+    tier: "free",
+    source: "https://console.groq.com/docs/rate-limits",
+    note: "Also 30k tokens/minute. Paid tiers higher."
+  },
+  {
+    provider: "google",
+    metric: "requests/day",
+    limit: 1500,
+    unit: "requests",
+    tier: "free",
+    source: "https://ai.google.dev/gemini-api/docs/rate-limits",
+    note: "Free tier: 1500 RPM, 1500 RPD. Paid tiers higher."
+  },
+  {
+    provider: "cloudflare-workers-ai",
+    metric: "neurons/day",
+    limit: 1e5,
+    unit: "neurons",
+    tier: "free",
+    source: "https://developers.cloudflare.com/workers-ai/platform/limits/",
+    note: "100k neurons/day free. Workers AI paid plans higher."
+  },
+  {
+    provider: "nvidia",
+    metric: "credits/month",
+    limit: 1000,
+    unit: "credits",
+    tier: "free",
+    source: "https://build.nvidia.com/",
+    note: "NIM free tier ~1000 credits/month. Varies by model."
+  },
+  {
+    provider: "digitalocean",
+    metric: "tokens/day",
+    limit: 5000000,
+    unit: "tokens",
+    tier: "paid",
+    source: "https://docs.digitalocean.com/products/genai/",
+    note: "GenAI platform paid plans. Exact limits per model."
+  },
+  {
+    provider: "snowflake-cortex",
+    metric: "credits/month",
+    limit: 100,
+    unit: "credits",
+    tier: "paid",
+    source: "https://docs.snowflake.com/en/user-guide/snowflake-cortex",
+    note: "Cortex functions consume credits. Budget per warehouse."
+  },
+  {
+    provider: "cerebras",
+    metric: "tokens/day",
+    limit: 1e6,
+    unit: "tokens",
+    tier: "free",
+    source: "https://cerebras.ai/",
+    note: "Free tier estimate. Paid tiers much higher."
+  },
+  {
+    provider: "orcarouter",
+    metric: "tokens/day",
+    limit: 0,
+    unit: "tokens",
+    tier: "unknown",
+    source: "unknown",
+    note: "Proxy service. No public limits documented."
+  }
+];
+function limitsAsMap() {
+  const m = new Map;
+  for (const l of PROVIDER_LIMITS)
+    m.set(l.provider, l);
+  return m;
+}
+// packages/core/src/snapshot.ts
+async function withConnectedProviders(rows) {
+  let connected;
+  try {
+    connected = Object.keys(await readAuth());
+  } catch {
+    return rows;
+  }
+  const seen = new Set(rows.map((r) => r.provider));
+  const idle = connected.filter((provider) => !seen.has(provider)).sort().map((provider) => ({
+    group: provider,
+    provider,
+    model: "",
+    day: "",
+    project: "",
+    agent: "",
+    messages: 0,
+    cost: 0,
+    tokensInput: 0,
+    tokensOutput: 0,
+    tokensReasoning: 0,
+    tokensCacheRead: 0,
+    tokensCacheWrite: 0
+  }));
+  return [...rows, ...idle].sort((a, b) => b.cost - a.cost || b.messages - a.messages || a.provider.localeCompare(b.provider));
+}
+async function getUsageSnapshot(sinceMs, groupBy, includePct) {
+  const db = openDb();
+  try {
+    const rows = groupBy === "provider" ? await withConnectedProviders(usageSince(db, sinceMs, groupBy)) : usageSince(db, sinceMs, groupBy);
+    const totals = usageTotals(db, sinceMs);
+    let pct;
+    if (includePct) {
+      const budgets = await readBudgets();
+      const live = await providerStatuses({ noNet: false });
+      const liveMap = new Map;
+      for (const s of live) {
+        if (s.quota)
+          liveMap.set(s.provider, s.quota);
+      }
+      const monthCosts = monthlyUsageByProvider(db, startOfMonthMs());
+      const limits = limitsAsMap();
+      const pctMap = new Map;
+      for (const r of rows) {
+        const p = resolvePct(r.provider, liveMap, budgets, monthCosts.get(r.provider) ?? 0, r.tokensInput + r.tokensOutput, r.messages, limits);
+        if (p.pct > 0 || p.source !== "none")
+          pctMap.set(r.provider, p);
+      }
+      pct = pctMap;
+    }
+    return { rows, totals, pct: pct ? Object.fromEntries(pct) : undefined };
+  } finally {
+    db.close();
+  }
+}
+// packages/cli/src/cli.ts
+var USAGE = `opencode-usage \u2014 usage tracking and model ranking for opencode
+
+USAGE
+  opencode-usage usage  [--since 7d] [--by provider|model|day|project|agent] [--today] [--pct] [--json]
+  opencode-usage providers [--no-net] [--json]
+  opencode-usage top [--limit 20] [--json]
+
+OPTIONS
+  --json      machine-readable output
+  --no-net    skip live quota fetches (cache only)
+  --today     shortcut for --since with start of today
+  --since     lookback window: Nh, Nd or Nw (default 7d)
+  --pct       add % BUDGET column (requires --by provider)
+`;
+function fail(msg) {
+  console.error(`opencode-usage: ${msg}
+`);
+  process.exit(1);
+  throw new Error("unreachable");
+}
+function parseArgs(argv) {
+  const cmd = argv[0];
+  if (!cmd || cmd.startsWith("-"))
+    fail(`missing command
+
+${USAGE}`);
+  const flags = new Map;
+  for (let i = 1;i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--"))
+      fail(`unexpected argument: ${a}`);
+    const [key, val] = a.slice(2).split("=");
+    const name = `--${key}`;
+    if (val !== undefined)
+      flags.set(name, val);
+    else if (i + 1 < argv.length && !argv[i + 1].startsWith("--") && ["--since", "--by", "--limit"].includes(name)) {
+      flags.set(name, argv[++i]);
+    } else
+      flags.set(name, true);
+  }
+  return { cmd, flags };
+}
+async function cmdUsage(flags, json) {
+  const sinceMs = flags.has("--today") ? startOfDayMs() : flags.has("--since") ? (() => {
+    const v = flags.get("--since");
+    if (typeof v !== "string")
+      fail("--since needs a value like 7d");
+    return Date.now() - parseDuration(v);
+  })() : Date.now() - parseDuration("7d");
+  const groupBy = typeof flags.get("--by") === "string" ? flags.get("--by") : "provider";
+  if (!["provider", "model", "day", "project", "agent"].includes(groupBy))
+    fail(`invalid --by: ${groupBy}`);
+  const withPct = flags.has("--pct");
+  if (withPct && groupBy !== "provider")
+    fail("--pct only supported with --by provider");
+  const snapshot2 = await getUsageSnapshot(sinceMs, groupBy, withPct);
+  if (json) {
+    const out = {
+      since: new Date(sinceMs).toISOString(),
+      groupBy,
+      rows: snapshot2.rows,
+      totals: snapshot2.totals,
+      pct: snapshot2.pct
+    };
+    console.log(JSON.stringify(out, null, 2));
+  } else {
+    const label = flags.has("--today") ? "today" : flags.get("--since") ?? "7d";
+    console.log(usageTable(snapshot2.rows, snapshot2.totals, label, groupBy, snapshot2.pct ? new Map(Object.entries(snapshot2.pct)) : undefined));
+  }
+}
+async function cmdProviders(flags, json) {
+  const statuses = await providerStatuses({ noNet: flags.has("--no-net") });
+  const db2 = openDb();
+  try {
+    const local = localUsageByProvider(db2, Date.now() - parseDuration("7d"));
+    if (json) {
+      console.log(JSON.stringify({ statuses, local: Object.fromEntries(local) }, null, 2));
+    } else {
+      console.log(providersTable(statuses, local));
+    }
+  } finally {
+    db2.close();
+  }
+}
+async function cmdTop(flags, json) {
+  const limit = typeof flags.get("--limit") === "string" ? Number(flags.get("--limit")) : 20;
+  const rows = await buildTop(limit);
+  if (json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  const head = ["MODEL", "NAME", "IQ", "CODING", "$/M", "IQ/$"];
+  const widths = [28, 26, 5, 7, 8, 6];
+  const line = (cells) => cells.map((c, i) => c.length >= widths[i] ? c.slice(0, widths[i]) : c + " ".repeat(widths[i] - c.length)).join("  ");
+  console.log(line(head));
+  console.log(widths.map((w) => "-".repeat(w)).join("  "));
+  for (const r of rows) {
+    console.log(line([
+      r.model,
+      r.name,
+      r.intelligence !== undefined ? r.intelligence.toFixed(0) : "\u2014",
+      r.codingIndex !== undefined ? r.codingIndex.toFixed(0) : "\u2014",
+      fmtCost(r.blended).replace(".00", ""),
+      r.value !== undefined ? r.value.toFixed(1) : "\u2014"
+    ]));
+  }
+}
+if (import.meta.main) {
+  const { cmd, flags } = parseArgs(process.argv.slice(2));
+  const json = flags.has("--json");
+  try {
+    if (cmd === "usage")
+      await cmdUsage(flags, json);
+    else if (cmd === "providers")
+      await cmdProviders(flags, json);
+    else if (cmd === "top")
+      await cmdTop(flags, json);
+    else
+      fail(`unknown command: ${cmd}
+
+${USAGE}`);
+  } catch (err) {
+    fail(err.message);
+  }
+}