tokentrack 1.0.0

package/dist/chunk-KQYHDGZP.js

@@ -0,0 +1,1002 @@
+// src/server.ts
+import { serve } from "@hono/node-server";
+import { Hono as Hono2 } from "hono";
+
+// src/api/routes.ts
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+
+// src/data/providers/claude-code.ts
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { glob } from "glob";
+import { existsSync as existsSync2 } from "fs";
+
+// src/data/pricing.ts
+var PRICING_TABLE = {
+  // Anthropic — current gen (keys use both . and - for matching)
+  "claude-opus-4-6": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5, provider: "anthropic" },
+  "claude-opus-4.6": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5, provider: "anthropic" },
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3, provider: "anthropic" },
+  "claude-sonnet-4.6": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3, provider: "anthropic" },
+  "claude-opus-4-5": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5, provider: "anthropic" },
+  "claude-opus-4.5": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5, provider: "anthropic" },
+  "claude-sonnet-4-5": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3, provider: "anthropic" },
+  "claude-sonnet-4.5": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3, provider: "anthropic" },
+  "claude-haiku-4-5": { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1, provider: "anthropic" },
+  "claude-haiku-4.5": { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1, provider: "anthropic" },
+  // Legacy gen
+  "claude-opus-4-1": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5, provider: "anthropic" },
+  "claude-opus-4.1": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5, provider: "anthropic" },
+  "claude-opus-4": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5, provider: "anthropic" },
+  "claude-sonnet-4": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3, provider: "anthropic" },
+  "claude-sonnet-3-5": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3, provider: "anthropic" },
+  "claude-sonnet-3.5": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3, provider: "anthropic" },
+  "claude-haiku-3-5": { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08, provider: "anthropic" },
+  "claude-haiku-3.5": { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08, provider: "anthropic" },
+  "claude-haiku-3": { input: 0.25, output: 1.25, cacheWrite: 0.3, cacheRead: 0.025, provider: "anthropic" },
+  // OpenAI
+  "gpt-5.4": { input: 2.5, output: 15, cachedInput: 1.25, provider: "openai" },
+  "gpt-5.4-mini": { input: 0.4, output: 1.6, cachedInput: 0.1, provider: "openai" },
+  "gpt-5.4-nano": { input: 0.1, output: 0.4, cachedInput: 0.025, provider: "openai" },
+  "gpt-5.4-pro": { input: 30, output: 180, cachedInput: 15, provider: "openai" },
+  "gpt-5.3-codex": { input: 1.25, output: 10, cachedInput: 0.625, provider: "openai" },
+  "gpt-5.3": { input: 1.75, output: 14, cachedInput: 0.875, provider: "openai" },
+  "gpt-5.2-codex": { input: 1.25, output: 10, cachedInput: 0.625, provider: "openai" },
+  "gpt-5.1-codex-max": { input: 1.25, output: 10, cachedInput: 0.625, provider: "openai" },
+  "gpt-5-codex": { input: 1.25, output: 10, cachedInput: 0.625, provider: "openai" },
+  "gpt-4.1": { input: 2, output: 8, cachedInput: 0.5, provider: "openai" },
+  "gpt-4.1-mini": { input: 0.4, output: 1.6, cachedInput: 0.1, provider: "openai" },
+  "gpt-4.1-nano": { input: 0.1, output: 0.4, cachedInput: 0.025, provider: "openai" },
+  "gpt-4o": { input: 2.5, output: 10, cachedInput: 1.25, provider: "openai" },
+  "gpt-4o-mini": { input: 0.15, output: 0.6, cachedInput: 0.075, provider: "openai" },
+  "o3": { input: 10, output: 40, cachedInput: 2.5, provider: "openai" },
+  "o3-mini": { input: 1.1, output: 4.4, cachedInput: 0.275, provider: "openai" },
+  "o4-mini": { input: 1.1, output: 4.4, cachedInput: 0.275, provider: "openai" },
+  // Google
+  "gemini-3-pro": { input: 1.25, output: 10, provider: "google" },
+  "gemini-2.5-pro": { input: 1.25, output: 10, provider: "google" },
+  "gemini-2.5-flash": { input: 0.15, output: 0.6, provider: "google" },
+  "gemini-2.0-flash": { input: 0.1, output: 0.4, provider: "google" }
+};
+var FALLBACKS = {
+  anthropic: "claude-sonnet-4.6",
+  openai: "gpt-5.3-codex",
+  google: "gemini-3-pro"
+};
+function detectProvider(model) {
+  const lower = model.toLowerCase();
+  if (lower.includes("claude") || lower.includes("sonnet") || lower.includes("opus") || lower.includes("haiku")) return "anthropic";
+  if (lower.includes("gpt") || lower.includes("o3") || lower.includes("o4") || lower.includes("codex")) return "openai";
+  if (lower.includes("gemini")) return "google";
+  return "anthropic";
+}
+function normalizeToPricingKey(model) {
+  let name = model.toLowerCase().trim();
+  name = name.replace(/^anthropic[./]/, "");
+  name = name.replace(/^\[.*?\]\s*/, "");
+  name = name.replace(/-\d{8}$/, "");
+  name = name.replace(/-[a-f0-9]{6,}$/, "");
+  return name;
+}
+function findPricing(modelName) {
+  const key = normalizeToPricingKey(modelName);
+  if (PRICING_TABLE[key]) return PRICING_TABLE[key];
+  const keys = Object.keys(PRICING_TABLE).sort((a, b) => b.length - a.length);
+  for (const k of keys) {
+    if (key.startsWith(k) || key.includes(k)) return PRICING_TABLE[k];
+  }
+  const provider = detectProvider(modelName);
+  return PRICING_TABLE[FALLBACKS[provider]];
+}
+function calculateCost(model, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens, speed) {
+  const pricing = findPricing(model);
+  let multiplier = 1;
+  if (speed === "fast" && model.toLowerCase().includes("opus-4.6")) {
+    multiplier = 6;
+  }
+  let cost = 0;
+  cost += inputTokens * pricing.input * multiplier / 1e6;
+  cost += outputTokens * pricing.output * multiplier / 1e6;
+  if (pricing.cacheWrite) {
+    cost += cacheWriteTokens * pricing.cacheWrite * multiplier / 1e6;
+  }
+  if (pricing.cacheRead) {
+    cost += cacheReadTokens * pricing.cacheRead * multiplier / 1e6;
+  }
+  if (pricing.cachedInput && !pricing.cacheRead) {
+    cost += cacheReadTokens * pricing.cachedInput * multiplier / 1e6;
+  }
+  return Math.round(cost * 1e6) / 1e6;
+}
+function normalizeModelDisplay(raw) {
+  if (!raw) return "unknown";
+  let name = raw;
+  let prefix = "";
+  const prefixMatch = name.match(/^(\[.*?\]\s*)/);
+  if (prefixMatch) {
+    prefix = prefixMatch[1];
+    name = name.slice(prefix.length);
+  }
+  name = name.replace(/^anthropic[./]/, "");
+  name = name.replace(/^claude-/, "");
+  name = name.replace(/-\d{8}$/, "");
+  return prefix + name;
+}
+function getPricingTable() {
+  return { ...PRICING_TABLE };
+}
+
+// src/data/litellm-pricing.ts
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
+var LITELLM_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+var CACHE_DIR = join(homedir(), ".tokentrack");
+var CACHE_PATH = join(CACHE_DIR, "litellm-pricing.json");
+var CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var cachedPricing = null;
+function isCacheFresh() {
+  try {
+    if (!existsSync(CACHE_PATH)) return false;
+    const stat = statSync(CACHE_PATH);
+    return Date.now() - stat.mtimeMs < CACHE_MAX_AGE_MS;
+  } catch {
+    return false;
+  }
+}
+function readCache() {
+  try {
+    if (!existsSync(CACHE_PATH)) return null;
+    const data = JSON.parse(readFileSync(CACHE_PATH, "utf-8"));
+    return parseRawPricing(data);
+  } catch {
+    return null;
+  }
+}
+function writeCache(data) {
+  try {
+    if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
+    writeFileSync(CACHE_PATH, JSON.stringify(data), "utf-8");
+  } catch {
+  }
+}
+function parseRawPricing(data) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, val] of Object.entries(data)) {
+    if (val && typeof val === "object" && typeof val.input_cost_per_token === "number") {
+      map.set(key, {
+        input_cost_per_token: val.input_cost_per_token,
+        output_cost_per_token: val.output_cost_per_token || 0,
+        cache_read_input_token_cost: val.cache_read_input_token_cost,
+        cache_creation_input_token_cost: val.cache_creation_input_token_cost
+      });
+    }
+  }
+  return map;
+}
+async function loadLiteLLMPricing() {
+  if (cachedPricing) return cachedPricing;
+  if (isCacheFresh()) {
+    const cached = readCache();
+    if (cached) {
+      cachedPricing = cached;
+      return cached;
+    }
+  }
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const res = await fetch(LITELLM_URL, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (res.ok) {
+      const data = await res.json();
+      writeCache(data);
+      cachedPricing = parseRawPricing(data);
+      return cachedPricing;
+    }
+  } catch {
+  }
+  const stale = readCache();
+  if (stale) {
+    cachedPricing = stale;
+    return stale;
+  }
+  cachedPricing = /* @__PURE__ */ new Map();
+  return cachedPricing;
+}
+function findLiteLLMPricing(model, pricing) {
+  if (pricing.has(model)) return pricing.get(model);
+  const stripped = model.replace(/-\d{8}$/, "");
+  if (pricing.has(stripped)) return pricing.get(stripped);
+  if (!stripped.startsWith("claude-") && (stripped.includes("sonnet") || stripped.includes("opus") || stripped.includes("haiku"))) {
+    const withPrefix = "claude-" + stripped;
+    if (pricing.has(withPrefix)) return pricing.get(withPrefix);
+  }
+  const aliases = {
+    "claude-opus-4-6": "claude-opus-4-6-20260227",
+    "claude-sonnet-4-6": "claude-sonnet-4-6-20260220",
+    "claude-haiku-4-5": "claude-haiku-4-5-20251001"
+  };
+  for (const [alias, full] of Object.entries(aliases)) {
+    if (stripped === alias && pricing.has(full)) return pricing.get(full);
+  }
+  for (const [key, val] of pricing) {
+    if (key.startsWith(stripped) || stripped.startsWith(key)) return val;
+  }
+  return null;
+}
+function calculateCostWithLiteLLM(model, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens, pricing) {
+  const p = findLiteLLMPricing(model, pricing);
+  if (!p) return 0;
+  let cost = inputTokens * p.input_cost_per_token + outputTokens * p.output_cost_per_token;
+  if (cacheWriteTokens > 0 && p.cache_creation_input_token_cost) {
+    cost += cacheWriteTokens * p.cache_creation_input_token_cost;
+  }
+  if (cacheReadTokens > 0) {
+    const readRate = p.cache_read_input_token_cost ?? p.input_cost_per_token * 0.5;
+    cost += cacheReadTokens * readRate;
+  }
+  return Math.round(cost * 1e6) / 1e6;
+}
+async function updatePricingCache() {
+  try {
+    const res = await fetch(LITELLM_URL);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const data = await res.json();
+    writeCache(data);
+    const parsed = parseRawPricing(data);
+    cachedPricing = parsed;
+    return parsed.size;
+  } catch (e) {
+    throw new Error(`Failed to update: ${e.message}`);
+  }
+}
+
+// src/data/providers/claude-code.ts
+function getDataDirectories() {
+  const dirs = [];
+  const envDir = process.env.CLAUDE_CONFIG_DIR;
+  if (envDir) {
+    for (const d of envDir.split(",")) {
+      const p = join2(d.trim(), "projects");
+      if (existsSync2(p)) dirs.push(p);
+    }
+  }
+  const xdg = process.env.XDG_CONFIG_HOME || join2(homedir2(), ".config");
+  const xdgPath = join2(xdg, "claude", "projects");
+  if (existsSync2(xdgPath)) dirs.push(xdgPath);
+  const dotClaude = join2(homedir2(), ".claude", "projects");
+  if (existsSync2(dotClaude)) dirs.push(dotClaude);
+  return [...new Set(dirs)];
+}
+async function findJsonlFiles() {
+  const dirs = getDataDirectories();
+  const files = [];
+  for (const dir of dirs) {
+    const found = await glob("**/*.jsonl", {
+      cwd: dir,
+      absolute: true,
+      ignore: ["**/skill-injections.jsonl"]
+    });
+    files.push(...found);
+  }
+  return [...new Set(files)];
+}
+function extractProjectName(filePath) {
+  const projectsIdx = filePath.indexOf("/projects/");
+  if (projectsIdx === -1) return "unknown";
+  const afterProjects = filePath.substring(projectsIdx + "/projects/".length);
+  const projectDir = afterProjects.split("/")[0];
+  const segments = projectDir.split("-").filter(Boolean);
+  return segments[segments.length - 1] || projectDir;
+}
+async function parseFile(filePath, project, litellm) {
+  const records = [];
+  const rl = createInterface({
+    input: createReadStream(filePath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    try {
+      const raw = JSON.parse(line);
+      if (raw.type !== "assistant") continue;
+      if (!raw.message?.usage) continue;
+      const usage = raw.message.usage;
+      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;
+      if (inputTokens + outputTokens === 0) continue;
+      const model = raw.message.model || "unknown";
+      const speed = usage.speed || "standard";
+      let costUSD;
+      if (raw.costUSD != null) {
+        costUSD = raw.costUSD;
+      } else if (litellm && litellm.size > 0) {
+        costUSD = calculateCostWithLiteLLM(model, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens, litellm);
+      } else {
+        costUSD = calculateCost(model, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens, speed);
+      }
+      records.push({
+        id: `cc-${raw.uuid || raw.message.id || ""}`,
+        provider: "claude-code",
+        timestamp: new Date(raw.timestamp),
+        model,
+        modelDisplay: normalizeModelDisplay(model),
+        project,
+        sessionId: raw.sessionId || "unknown",
+        inputTokens,
+        outputTokens,
+        cacheWriteTokens,
+        cacheReadTokens,
+        totalTokens: inputTokens + outputTokens + cacheWriteTokens + cacheReadTokens,
+        costUSD,
+        isEstimated: false,
+        speed,
+        messageId: raw.message.id || raw.uuid || ""
+      });
+    } catch {
+    }
+  }
+  return records;
+}
+async function parseClaudeCode() {
+  const files = await findJsonlFiles();
+  const litellm = await loadLiteLLMPricing();
+  const fileEntries = files.map((f) => ({
+    path: f,
+    project: extractProjectName(f)
+  }));
+  const results = await Promise.all(
+    fileEntries.map((f) => parseFile(f.path, f.project, litellm))
+  );
+  const byMessageId = /* @__PURE__ */ new Map();
+  for (const records of results) {
+    for (const r of records) {
+      const key = r.messageId || `${r.timestamp.getTime()}-${r.sessionId}-${r.model}`;
+      const existing = byMessageId.get(key);
+      if (!existing || r.outputTokens > 0 && r.outputTokens < existing.outputTokens) {
+        byMessageId.set(key, r);
+      }
+    }
+  }
+  const allRecords = Array.from(byMessageId.values());
+  allRecords.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+  return allRecords;
+}
+async function detectClaudeCode() {
+  const dirs = getDataDirectories();
+  let count = 0;
+  for (const dir of dirs) {
+    const found = await glob("**/*.jsonl", {
+      cwd: dir,
+      absolute: true,
+      ignore: ["**/skill-injections.jsonl"]
+    });
+    count += found.length;
+  }
+  return {
+    id: "claude-code",
+    name: "Claude Code",
+    color: "#d97757",
+    dataPath: dirs,
+    entryCount: count,
+    isAvailable: count > 0
+  };
+}
+
+// src/data/providers/codex.ts
+import { createReadStream as createReadStream2 } from "fs";
+import { createInterface as createInterface2 } from "readline";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+import { glob as glob2 } from "glob";
+import { existsSync as existsSync3 } from "fs";
+function getCodexSessionsDir() {
+  const dirs = [];
+  const envDir = process.env.CODEX_HOME;
+  if (envDir) {
+    const sessionsPath = join3(envDir, "sessions");
+    if (existsSync3(sessionsPath)) dirs.push(sessionsPath);
+  }
+  const defaultPath = join3(homedir3(), ".codex", "sessions");
+  if (existsSync3(defaultPath)) dirs.push(defaultPath);
+  return [...new Set(dirs)];
+}
+async function findCodexFiles() {
+  const dirs = getCodexSessionsDir();
+  const files = [];
+  for (const dir of dirs) {
+    const found = await glob2("**/*.jsonl", { cwd: dir, absolute: true });
+    files.push(...found);
+  }
+  return [...new Set(files)];
+}
+async function parseCodexFile(filePath, litellm) {
+  const records = [];
+  const sessionId = filePath.split("/").pop()?.replace(".jsonl", "") || "unknown";
+  const rl = createInterface2({
+    input: createReadStream2(filePath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  let cwd = "";
+  let detectedModel = "gpt-5.3-codex";
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    try {
+      const raw = JSON.parse(line);
+      if (raw.type === "session_meta" && raw.payload) {
+        cwd = raw.payload.cwd || cwd;
+      }
+      const eventModel = raw.payload?.model || raw.model;
+      if (eventModel && typeof eventModel === "string" && eventModel.startsWith("gpt")) {
+        detectedModel = eventModel;
+      }
+      if (raw.type === "event_msg" && raw.payload?.type === "token_count" && raw.payload.info?.last_token_usage) {
+        const last = raw.payload.info.last_token_usage;
+        const totalInput = last.input_tokens || 0;
+        const cachedInput = last.cached_input_tokens || 0;
+        const outputTokens = last.output_tokens || 0;
+        const freshInput = Math.max(totalInput - cachedInput, 0);
+        if (freshInput + outputTokens + cachedInput === 0) continue;
+        const model = detectedModel;
+        let costUSD;
+        if (litellm.size > 0) {
+          costUSD = calculateCostWithLiteLLM(model, freshInput, outputTokens, 0, cachedInput, litellm);
+        } else {
+          costUSD = calculateCost(model, freshInput, outputTokens, 0, cachedInput);
+        }
+        const projectName = cwd ? cwd.split("/").pop() || "codex" : "codex";
+        records.push({
+          id: `cx-${sessionId}-${records.length}`,
+          provider: "codex",
+          timestamp: new Date(raw.timestamp || Date.now()),
+          model,
+          modelDisplay: normalizeModelDisplay(model),
+          project: projectName,
+          sessionId,
+          inputTokens: freshInput,
+          outputTokens,
+          cacheWriteTokens: 0,
+          cacheReadTokens: cachedInput,
+          totalTokens: freshInput + outputTokens + cachedInput,
+          costUSD,
+          isEstimated: false,
+          speed: "standard",
+          messageId: `cx-${sessionId}-${records.length}`
+        });
+      }
+    } catch {
+    }
+  }
+  return records;
+}
+async function parseCodex() {
+  const files = await findCodexFiles();
+  const litellm = await loadLiteLLMPricing();
+  const allRecords = [];
+  const results = await Promise.all(files.map((f) => parseCodexFile(f, litellm)));
+  for (const records of results) {
+    allRecords.push(...records);
+  }
+  allRecords.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+  return allRecords;
+}
+async function detectCodex() {
+  const dirs = getCodexSessionsDir();
+  let count = 0;
+  for (const dir of dirs) {
+    const found = await glob2("**/*.jsonl", { cwd: dir, absolute: true });
+    count += found.length;
+  }
+  return {
+    id: "codex",
+    name: "Codex",
+    color: "#10a37f",
+    dataPath: dirs,
+    entryCount: count,
+    isAvailable: count > 0
+  };
+}
+
+// src/data/providers/antigravity.ts
+import { homedir as homedir4, platform } from "os";
+import { join as join4 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { glob as glob3 } from "glob";
+function getAntigravityDir() {
+  const dirs = [];
+  if (platform() === "darwin") {
+    const macPath = join4(homedir4(), "Library", "Application Support", "Antigravity");
+    if (existsSync4(macPath)) dirs.push(macPath);
+  }
+  const linuxPath = join4(homedir4(), ".config", "Antigravity");
+  if (existsSync4(linuxPath)) dirs.push(linuxPath);
+  return [...new Set(dirs)];
+}
+async function parseAntigravity() {
+  const dirs = getAntigravityDir();
+  const records = [];
+  for (const dir of dirs) {
+    const memoryFiles = await glob3("**/memory/**/*.json", { cwd: dir, absolute: true });
+    const logFiles = await glob3("**/logs/**/*.json", { cwd: dir, absolute: true });
+    const allFiles = [...memoryFiles, ...logFiles];
+    for (const file of allFiles) {
+      try {
+        const content = readFileSync2(file, "utf-8");
+        const data = JSON.parse(content);
+        if (data.messages && Array.isArray(data.messages)) {
+          for (const msg of data.messages) {
+            if (!msg.content) continue;
+            const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+            const estimatedTokens = Math.ceil(text.length / 4);
+            const isAssistant = msg.role === "assistant";
+            const model = data.model || "gemini-3-pro";
+            const inputTokens = isAssistant ? 0 : estimatedTokens;
+            const outputTokens = isAssistant ? estimatedTokens : 0;
+            records.push({
+              id: `ag-${file.split("/").pop()}-${records.length}`,
+              provider: "antigravity",
+              timestamp: new Date(msg.timestamp || data.timestamp || Date.now()),
+              model,
+              modelDisplay: normalizeModelDisplay(model),
+              project: data.workspace || data.project || "antigravity",
+              sessionId: data.sessionId || file.split("/").pop()?.replace(".json", "") || "unknown",
+              inputTokens,
+              outputTokens,
+              cacheWriteTokens: 0,
+              cacheReadTokens: 0,
+              totalTokens: estimatedTokens,
+              costUSD: calculateCost(model, inputTokens, outputTokens, 0, 0),
+              isEstimated: true,
+              speed: "standard",
+              messageId: `ag-${records.length}`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  records.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+  return records;
+}
+async function detectAntigravity() {
+  const dirs = getAntigravityDir();
+  let hasData = false;
+  for (const dir of dirs) {
+    const files = await glob3("**/*.json", { cwd: dir, absolute: true });
+    if (files.length > 0) {
+      hasData = true;
+      break;
+    }
+  }
+  return {
+    id: "antigravity",
+    name: "Antigravity",
+    color: "#4285f4",
+    dataPath: dirs,
+    entryCount: 0,
+    // estimated
+    isAvailable: hasData
+  };
+}
+
+// src/data/providers/registry.ts
+async function detectProviders() {
+  const results = await Promise.all([
+    detectClaudeCode(),
+    detectCodex(),
+    detectAntigravity()
+  ]);
+  return results;
+}
+async function loadAllRecords(providers) {
+  const targets = providers || ["claude-code", "codex", "antigravity"];
+  const loaders = [];
+  if (targets.includes("claude-code")) loaders.push(parseClaudeCode());
+  if (targets.includes("codex")) loaders.push(parseCodex());
+  if (targets.includes("antigravity")) loaders.push(parseAntigravity());
+  const results = await Promise.all(loaders);
+  const all = results.flat();
+  all.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+  return all;
+}
+
+// src/data/cache.ts
+var cachedRecords = null;
+var cachedProviderInfo = null;
+async function getRecords(forceRefresh = false) {
+  if (!forceRefresh && cachedRecords) {
+    return cachedRecords;
+  }
+  cachedRecords = await loadAllRecords();
+  return cachedRecords;
+}
+async function getProviderInfo() {
+  if (cachedProviderInfo) return cachedProviderInfo;
+  cachedProviderInfo = await detectProviders();
+  return cachedProviderInfo;
+}
+
+// src/data/aggregator.ts
+import { format, startOfWeek, startOfMonth } from "date-fns";
+function applyFilters(records, filters) {
+  return records.filter((r) => {
+    if (filters.from && r.timestamp < filters.from) return false;
+    if (filters.to && r.timestamp > filters.to) return false;
+    if (filters.project && r.project !== filters.project) return false;
+    if (filters.model && normalizeModelDisplay(r.model) !== filters.model) return false;
+    if (filters.provider && r.provider !== filters.provider) return false;
+    return true;
+  });
+}
+function bucketKey(date, granularity) {
+  if (granularity === "day") return format(date, "yyyy-MM-dd");
+  if (granularity === "week") return format(startOfWeek(date, { weekStartsOn: 1 }), "yyyy-MM-dd");
+  return format(startOfMonth(date), "yyyy-MM");
+}
+function aggregateByTime(records, granularity) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const key = bucketKey(r.timestamp, granularity);
+    let bucket = buckets.get(key);
+    if (!bucket) {
+      bucket = { date: key, inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, totalCost: 0, models: [], providers: [] };
+      buckets.set(key, bucket);
+    }
+    bucket.inputTokens += r.inputTokens;
+    bucket.outputTokens += r.outputTokens;
+    bucket.cacheCreationTokens += r.cacheWriteTokens;
+    bucket.cacheReadTokens += r.cacheReadTokens;
+    bucket.totalCost += r.costUSD;
+    const mn = normalizeModelDisplay(r.model);
+    if (!bucket.models.includes(mn)) bucket.models.push(mn);
+    if (!bucket.providers.includes(r.provider)) bucket.providers.push(r.provider);
+  }
+  return Array.from(buckets.values()).sort((a, b) => a.date.localeCompare(b.date));
+}
+function aggregateByProject(records) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    let p = map.get(r.project);
+    if (!p) {
+      p = { sessions: /* @__PURE__ */ new Set(), input: 0, output: 0, cache: 0, cost: 0, lastActivity: r.timestamp, models: /* @__PURE__ */ new Set(), providers: /* @__PURE__ */ new Set() };
+      map.set(r.project, p);
+    }
+    p.sessions.add(r.sessionId);
+    p.input += r.inputTokens;
+    p.output += r.outputTokens;
+    p.cache += r.cacheWriteTokens + r.cacheReadTokens;
+    p.cost += r.costUSD;
+    if (r.timestamp > p.lastActivity) p.lastActivity = r.timestamp;
+    p.models.add(normalizeModelDisplay(r.model));
+    p.providers.add(r.provider);
+  }
+  return Array.from(map.entries()).map(([project, p]) => ({
+    project,
+    sessions: p.sessions.size,
+    inputTokens: p.input,
+    outputTokens: p.output,
+    cacheTokens: p.cache,
+    totalCost: p.cost,
+    lastActivity: format(p.lastActivity, "yyyy-MM-dd"),
+    models: Array.from(p.models),
+    providers: Array.from(p.providers)
+  })).sort((a, b) => b.totalCost - a.totalCost);
+}
+function aggregateByModel(records) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const mn = normalizeModelDisplay(r.model);
+    let m = map.get(mn);
+    if (!m) {
+      m = { input: 0, output: 0, cache: 0, cost: 0, sessions: /* @__PURE__ */ new Set(), provider: r.provider };
+      map.set(mn, m);
+    }
+    m.input += r.inputTokens;
+    m.output += r.outputTokens;
+    m.cache += r.cacheWriteTokens + r.cacheReadTokens;
+    m.cost += r.costUSD;
+    m.sessions.add(r.sessionId);
+  }
+  return Array.from(map.entries()).map(([model, m]) => ({
+    model,
+    inputTokens: m.input,
+    outputTokens: m.output,
+    cacheTokens: m.cache,
+    totalCost: m.cost,
+    sessions: m.sessions.size,
+    provider: m.provider
+  })).sort((a, b) => b.totalCost - a.totalCost);
+}
+var PROVIDER_META = {
+  "claude-code": { name: "Claude Code", color: "#d97757" },
+  "codex": { name: "Codex", color: "#10a37f" },
+  "antigravity": { name: "Antigravity", color: "#4285f4" }
+};
+function aggregateByProvider(records) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    let p = map.get(r.provider);
+    if (!p) {
+      p = { records: 0, sessions: /* @__PURE__ */ new Set(), projects: /* @__PURE__ */ new Set(), input: 0, output: 0, cache: 0, cost: 0 };
+      map.set(r.provider, p);
+    }
+    p.records++;
+    p.sessions.add(r.sessionId);
+    p.projects.add(r.project);
+    p.input += r.inputTokens;
+    p.output += r.outputTokens;
+    p.cache += r.cacheWriteTokens + r.cacheReadTokens;
+    p.cost += r.costUSD;
+  }
+  return Array.from(map.entries()).map(([provider, p]) => ({
+    provider,
+    ...PROVIDER_META[provider],
+    records: p.records,
+    sessions: p.sessions.size,
+    projects: p.projects.size,
+    inputTokens: p.input,
+    outputTokens: p.output,
+    cacheTokens: p.cache,
+    totalCost: p.cost
+  })).sort((a, b) => b.totalCost - a.totalCost);
+}
+function getSummary(records) {
+  const totalInput = records.reduce((s, r) => s + r.inputTokens, 0);
+  const totalOutput = records.reduce((s, r) => s + r.outputTokens, 0);
+  const totalCache = records.reduce((s, r) => s + r.cacheWriteTokens + r.cacheReadTokens, 0);
+  const totalCost = records.reduce((s, r) => s + r.costUSD, 0);
+  const sessions = new Set(records.map((r) => r.sessionId)).size;
+  const projects = new Set(records.map((r) => r.project)).size;
+  const providers = [...new Set(records.map((r) => r.provider))];
+  const dates = records.map((r) => r.timestamp.getTime());
+  const dateRange = dates.length > 0 ? { from: format(new Date(Math.min(...dates)), "yyyy-MM-dd"), to: format(new Date(Math.max(...dates)), "yyyy-MM-dd") } : { from: "", to: "" };
+  return {
+    totalTokens: totalInput + totalOutput + totalCache,
+    totalInputTokens: totalInput,
+    totalOutputTokens: totalOutput,
+    totalCacheTokens: totalCache,
+    totalCost,
+    totalSessions: sessions,
+    totalProjects: projects,
+    providers,
+    dateRange
+  };
+}
+function aggregateSessions(records, limit = 50, offset = 0) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    let s = map.get(r.sessionId);
+    if (!s) {
+      s = { project: r.project, timestamp: r.timestamp, models: /* @__PURE__ */ new Set(), input: 0, output: 0, cost: 0, count: 0, provider: r.provider, isEstimated: r.isEstimated };
+      map.set(r.sessionId, s);
+    }
+    s.models.add(normalizeModelDisplay(r.model));
+    s.input += r.inputTokens;
+    s.output += r.outputTokens;
+    s.cost += r.costUSD;
+    s.count++;
+    if (r.timestamp < s.timestamp) s.timestamp = r.timestamp;
+  }
+  return Array.from(map.entries()).map(([sessionId, s]) => ({
+    sessionId,
+    project: s.project,
+    timestamp: format(s.timestamp, "yyyy-MM-dd'T'HH:mm:ss"),
+    model: Array.from(s.models).join(", "),
+    inputTokens: s.input,
+    outputTokens: s.output,
+    cost: s.cost,
+    messageCount: s.count,
+    provider: s.provider,
+    isEstimated: s.isEstimated
+  })).sort((a, b) => b.timestamp.localeCompare(a.timestamp)).slice(offset, offset + limit);
+}
+
+// src/api/routes.ts
+import { format as format2 } from "date-fns";
+var api = new Hono();
+api.use("*", cors());
+function parseFilters(query) {
+  return {
+    from: query.from ? new Date(query.from) : void 0,
+    to: query.to ? /* @__PURE__ */ new Date(query.to + "T23:59:59") : void 0,
+    project: query.project || void 0,
+    model: query.model || void 0,
+    provider: query.provider || void 0
+  };
+}
+api.get("/api/providers", async (c) => {
+  const info = await getProviderInfo();
+  return c.json(info);
+});
+api.get("/api/pricing", async (c) => {
+  return c.json(getPricingTable());
+});
+api.get("/api/summary", async (c) => {
+  const records = await getRecords();
+  const filters = parseFilters(c.req.query());
+  const filtered = applyFilters(records, filters);
+  const summary = getSummary(filtered);
+  const providerBreakdown = aggregateByProvider(filtered);
+  return c.json({ ...summary, providerBreakdown });
+});
+api.get("/api/daily", async (c) => {
+  const records = await getRecords();
+  const filters = parseFilters(c.req.query());
+  const filtered = applyFilters(records, filters);
+  return c.json(aggregateByTime(filtered, "day"));
+});
+api.get("/api/weekly", async (c) => {
+  const records = await getRecords();
+  const filters = parseFilters(c.req.query());
+  const filtered = applyFilters(records, filters);
+  return c.json(aggregateByTime(filtered, "week"));
+});
+api.get("/api/monthly", async (c) => {
+  const records = await getRecords();
+  const filters = parseFilters(c.req.query());
+  const filtered = applyFilters(records, filters);
+  return c.json(aggregateByTime(filtered, "month"));
+});
+api.get("/api/projects", async (c) => {
+  const records = await getRecords();
+  const filters = parseFilters(c.req.query());
+  const filtered = applyFilters(records, filters);
+  return c.json(aggregateByProject(filtered));
+});
+api.get("/api/models", async (c) => {
+  const records = await getRecords();
+  const filters = parseFilters(c.req.query());
+  const filtered = applyFilters(records, filters);
+  return c.json(aggregateByModel(filtered));
+});
+api.get("/api/sessions", async (c) => {
+  const records = await getRecords();
+  const filters = parseFilters(c.req.query());
+  const filtered = applyFilters(records, filters);
+  const limit = parseInt(c.req.query("limit") || "50");
+  const offset = parseInt(c.req.query("offset") || "0");
+  return c.json(aggregateSessions(filtered, limit, offset));
+});
+api.get("/api/sessions/:id", async (c) => {
+  const id = c.req.param("id");
+  const records = await getRecords();
+  const sessionRecords = records.filter((r) => r.sessionId === id);
+  return c.json({
+    sessionId: id,
+    messages: sessionRecords.map((r) => ({
+      timestamp: format2(r.timestamp, "yyyy-MM-dd'T'HH:mm:ss"),
+      model: normalizeModelDisplay(r.model),
+      inputTokens: r.inputTokens,
+      outputTokens: r.outputTokens,
+      cacheCreationTokens: r.cacheWriteTokens,
+      cacheReadTokens: r.cacheReadTokens,
+      cost: r.costUSD,
+      provider: r.provider,
+      isEstimated: r.isEstimated
+    }))
+  });
+});
+api.get("/api/heatmap", async (c) => {
+  const records = await getRecords();
+  const filters = parseFilters(c.req.query());
+  const filtered = applyFilters(records, filters);
+  return c.json(aggregateByTime(filtered, "day"));
+});
+api.get("/api/filters", async (c) => {
+  const records = await getRecords();
+  const projects = [...new Set(records.map((r) => r.project))].sort();
+  const models = [...new Set(records.map((r) => normalizeModelDisplay(r.model)))].sort();
+  const providers = [...new Set(records.map((r) => r.provider))].sort();
+  return c.json({ projects, models, providers });
+});
+api.get("/api/export", async (c) => {
+  const records = await getRecords();
+  const filters = parseFilters(c.req.query());
+  const filtered = applyFilters(records, filters);
+  const fmt = c.req.query("format") || "json";
+  if (fmt === "csv") {
+    const header = "timestamp,session_id,project,provider,model,input_tokens,output_tokens,cache_write_tokens,cache_read_tokens,cost_usd,is_estimated";
+    const rows = filtered.map(
+      (r) => `${format2(r.timestamp, "yyyy-MM-dd'T'HH:mm:ss")},${r.sessionId},${r.project},${r.provider},${normalizeModelDisplay(r.model)},${r.inputTokens},${r.outputTokens},${r.cacheWriteTokens},${r.cacheReadTokens},${r.costUSD.toFixed(6)},${r.isEstimated}`
+    );
+    const csv = "\uFEFF" + header + "\n" + rows.join("\n");
+    c.header("Content-Type", "text/csv; charset=utf-8");
+    c.header("Content-Disposition", 'attachment; filename="tokentrack-export.csv"');
+    return c.body(csv);
+  }
+  return c.json(filtered.map((r) => ({
+    timestamp: format2(r.timestamp, "yyyy-MM-dd'T'HH:mm:ss"),
+    sessionId: r.sessionId,
+    project: r.project,
+    provider: r.provider,
+    model: normalizeModelDisplay(r.model),
+    inputTokens: r.inputTokens,
+    outputTokens: r.outputTokens,
+    cacheWriteTokens: r.cacheWriteTokens,
+    cacheReadTokens: r.cacheReadTokens,
+    costUSD: r.costUSD,
+    isEstimated: r.isEstimated
+  })));
+});
+
+// src/server.ts
+import { fileURLToPath } from "url";
+import { dirname, join as join5 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function createServer(port) {
+  const app = new Hono2();
+  app.route("/", api);
+  const candidates = [
+    join5(__dirname, "..", "dist", "web"),
+    // from src/ -> dist/web/ (dev via tsx)
+    join5(__dirname, "web")
+    // dist/web/ (production)
+  ];
+  const webDir = candidates.find((d) => existsSync5(join5(d, "index.html"))) || candidates[0];
+  app.get("/*", async (c) => {
+    const urlPath = new URL(c.req.url).pathname;
+    const filePath = join5(webDir, urlPath === "/" ? "index.html" : urlPath);
+    if (existsSync5(filePath)) {
+      const content = readFileSync3(filePath);
+      const ext = filePath.split(".").pop() || "";
+      const mimeTypes = {
+        html: "text/html",
+        js: "application/javascript",
+        css: "text/css",
+        json: "application/json",
+        png: "image/png",
+        svg: "image/svg+xml",
+        ico: "image/x-icon"
+      };
+      return new Response(content, {
+        headers: { "Content-Type": mimeTypes[ext] || "application/octet-stream" }
+      });
+    }
+    const indexPath = join5(webDir, "index.html");
+    if (existsSync5(indexPath)) {
+      return new Response(readFileSync3(indexPath), {
+        headers: { "Content-Type": "text/html" }
+      });
+    }
+    return c.text("Not found", 404);
+  });
+  return new Promise((resolve) => {
+    const tryPort = (p) => {
+      const server = serve({ fetch: app.fetch, port: p });
+      server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          console.log(`  Port ${p} in use, trying ${p + 1}...`);
+          tryPort(p + 1);
+        } else {
+          throw err;
+        }
+      });
+      server.on("listening", () => {
+        resolve({ port: p });
+      });
+    };
+    tryPort(port);
+  });
+}
+
+export {
+  getPricingTable,
+  loadLiteLLMPricing,
+  findLiteLLMPricing,
+  updatePricingCache,
+  getRecords,
+  getProviderInfo,
+  applyFilters,
+  aggregateByProject,
+  aggregateByProvider,
+  getSummary,
+  createServer
+};