ai-token-usage-lite 0.1.0

package/src/aggregate.js

@@ -0,0 +1,100 @@
+function aggregateEvents(events) {
+  const cleanEvents = events.filter(Boolean).map(sanitizeEvent);
+  const summary = emptyTotals();
+  const sourceMap = new Map();
+  const modelMap = new Map();
+  const dayMap = new Map();
+  const projectMap = new Map();
+
+  for (const event of cleanEvents) {
+    addTotals(summary, event);
+    addToMap(sourceMap, event.source, { source: event.source }, event);
+    addToMap(modelMap, `${event.source}:${event.model}`, {
+      source: event.source,
+      model: event.model,
+    }, event);
+    addToMap(dayMap, dayKey(event.timestamp), { day: dayKey(event.timestamp) }, event);
+    if (event.projectRef) {
+      addToMap(projectMap, `${event.source}:${event.projectRef}`, {
+        source: event.source,
+        projectRef: event.projectRef,
+      }, event);
+    }
+  }
+
+  return {
+    generatedAt: new Date().toISOString(),
+    summary,
+    bySource: sortRows(sourceMap),
+    byModel: sortRows(modelMap),
+    byDay: Array.from(dayMap.values()).sort((a, b) => a.day.localeCompare(b.day)),
+    byProject: sortRows(projectMap),
+  };
+}
+
+function sanitizeEvent(event) {
+  return {
+    source: String(event.source || "unknown"),
+    model: String(event.model || "unknown"),
+    timestamp: normalizeTimestamp(event.timestamp),
+    projectRef: event.projectRef || null,
+    inputTokens: number(event.inputTokens),
+    outputTokens: number(event.outputTokens),
+    cachedInputTokens: number(event.cachedInputTokens),
+    cacheCreationInputTokens: number(event.cacheCreationInputTokens),
+    reasoningOutputTokens: number(event.reasoningOutputTokens),
+    totalTokens: number(event.totalTokens),
+    exact: event.exact !== false,
+  };
+}
+
+function addToMap(map, key, base, event) {
+  if (!map.has(key)) map.set(key, { ...base, ...emptyTotals() });
+  addTotals(map.get(key), event);
+}
+
+function addTotals(target, event) {
+  target.inputTokens += number(event.inputTokens);
+  target.outputTokens += number(event.outputTokens);
+  target.cachedInputTokens += number(event.cachedInputTokens);
+  target.cacheCreationInputTokens += number(event.cacheCreationInputTokens);
+  target.reasoningOutputTokens += number(event.reasoningOutputTokens);
+  target.totalTokens += number(event.totalTokens);
+  target.conversationCount += 1;
+}
+
+function emptyTotals() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cachedInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    reasoningOutputTokens: 0,
+    totalTokens: 0,
+    conversationCount: 0,
+  };
+}
+
+function dayKey(timestamp) {
+  return normalizeTimestamp(timestamp).slice(0, 10);
+}
+
+function normalizeTimestamp(value) {
+  const date = value ? new Date(value) : new Date();
+  if (Number.isNaN(date.getTime())) return new Date().toISOString();
+  return date.toISOString();
+}
+
+function sortRows(map) {
+  return Array.from(map.values()).sort((a, b) => b.totalTokens - a.totalTokens);
+}
+
+function number(value) {
+  return Number.isFinite(Number(value)) && Number(value) > 0 ? Math.round(Number(value)) : 0;
+}
+
+module.exports = {
+  aggregateEvents,
+  sanitizeEvent,
+  emptyTotals,
+};

package/src/cli.js

@@ -0,0 +1,115 @@
+const { syncUsage } = require("./sync");
+const { getStatus } = require("./status");
+const { getDoctorReport } = require("./doctor");
+const { exportUsage } = require("./export");
+const { serve } = require("./server");
+
+async function run(argv) {
+  const { command, rest } = parseCommand(argv);
+  if (!command || command === "serve") {
+    const opts = parseArgs(rest);
+    await syncUsage(opts);
+    await serve(opts);
+    return;
+  }
+  if (command === "sync") {
+    const result = await syncUsage(parseArgs(rest));
+    process.stdout.write(formatSyncResult(result));
+    return;
+  }
+  if (command === "status") {
+    const opts = parseArgs(rest);
+    const status = await getStatus(opts);
+    writeStructured(status, opts);
+    return;
+  }
+  if (command === "doctor") {
+    const opts = parseArgs(rest);
+    const report = await getDoctorReport(opts);
+    writeStructured(report, opts);
+    process.exitCode = report.ok ? 0 : 1;
+    return;
+  }
+  if (command === "export") {
+    await exportUsage(parseArgs(rest));
+    return;
+  }
+  if (command === "--help" || command === "-h" || command === "help") {
+    printHelp();
+    return;
+  }
+  throw new Error(`Unknown command: ${command}`);
+}
+
+function parseCommand(argv) {
+  const args = Array.isArray(argv) ? argv : [];
+  return { command: args[0], rest: args.slice(1) };
+}
+
+function parseArgs(argv) {
+  const opts = {
+    home: null,
+    dataDir: null,
+    port: 7680,
+    json: false,
+    format: "json",
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--home") opts.home = argv[++i];
+    else if (arg === "--data-dir") opts.dataDir = argv[++i];
+    else if (arg === "--port") opts.port = Number(argv[++i]);
+    else if (arg === "--json") opts.json = true;
+    else if (arg === "--format") opts.format = argv[++i] || "json";
+  }
+  return opts;
+}
+
+function writeStructured(value, opts) {
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${humanize(value)}\n`);
+}
+
+function humanize(value) {
+  if (!value || typeof value !== "object") return String(value);
+  if (value.providers) {
+    const lines = ["Provider status:"];
+    for (const [name, provider] of Object.entries(value.providers)) {
+      const state = provider.installed ? "installed" : "missing";
+      const details = provider.detail ? ` - ${provider.detail}` : "";
+      lines.push(`  ${name}: ${state}${details}`);
+    }
+    return lines.join("\n");
+  }
+  return JSON.stringify(value, null, 2);
+}
+
+function formatSyncResult(result) {
+  const total = result && result.data ? result.data.summary.totalTokens : 0;
+  const sources = result && result.data ? result.data.bySource.length : 0;
+  return `Synced ${total.toLocaleString()} tokens across ${sources} sources.\nData: ${result.outputPath}\n`;
+}
+
+function printHelp() {
+  process.stdout.write(
+    [
+      "ai-token-usage-lite",
+      "",
+      "Usage:",
+      "  ai-token-usage-lite serve [--port 7680] [--home <path>]",
+      "  ai-token-usage-lite sync [--home <path>]",
+      "  ai-token-usage-lite status [--json] [--home <path>]",
+      "  ai-token-usage-lite doctor [--json] [--home <path>]",
+      "  ai-token-usage-lite export --format json|csv [--home <path>]",
+      "",
+    ].join("\n"),
+  );
+}
+
+module.exports = {
+  run,
+  parseArgs,
+};

package/src/doctor.js

@@ -0,0 +1,30 @@
+const { getStatus } = require("./status");
+
+async function getDoctorReport(options = {}) {
+  const status = await getStatus(options);
+  const checks = [
+    {
+      id: "runtime.node",
+      ok: Number(process.versions.node.split(".")[0]) >= 20,
+      detail: `node ${process.version}`,
+    },
+    {
+      id: "provider.claude",
+      ok: status.providers.claude.installed,
+      detail: status.providers.claude.detail,
+    },
+    {
+      id: "provider.codex",
+      ok: status.providers.codex.installed,
+      detail: status.providers.codex.detail,
+    },
+  ];
+  return {
+    generatedAt: new Date().toISOString(),
+    ok: checks.every((check) => check.ok || check.optional),
+    checks,
+    status,
+  };
+}
+
+module.exports = { getDoctorReport };

package/src/export.js

@@ -0,0 +1,32 @@
+const { resolvePaths } = require("./paths");
+const { readJson } = require("./fs-utils");
+
+async function exportUsage(options = {}) {
+  const paths = resolvePaths(options);
+  const data = await readJson(paths.usagePath);
+  if (!data) throw new Error(`No usage data found. Run sync first: ${paths.usagePath}`);
+  if (options.format === "csv") {
+    process.stdout.write(toCsv(data));
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+
+function toCsv(data) {
+  const rows = [
+    ["group", "source", "model", "day", "projectRef", "totalTokens", "inputTokens", "outputTokens", "cachedInputTokens", "conversationCount"],
+  ];
+  for (const row of data.bySource || []) rows.push(["source", row.source, "", "", "", row.totalTokens, row.inputTokens, row.outputTokens, row.cachedInputTokens, row.conversationCount]);
+  for (const row of data.byModel || []) rows.push(["model", row.source, row.model, "", "", row.totalTokens, row.inputTokens, row.outputTokens, row.cachedInputTokens, row.conversationCount]);
+  for (const row of data.byDay || []) rows.push(["day", "", "", row.day, "", row.totalTokens, row.inputTokens, row.outputTokens, row.cachedInputTokens, row.conversationCount]);
+  for (const row of data.byProject || []) rows.push(["project", row.source, "", "", row.projectRef, row.totalTokens, row.inputTokens, row.outputTokens, row.cachedInputTokens, row.conversationCount]);
+  return rows.map((row) => row.map(csvCell).join(",")).join("\n") + "\n";
+}
+
+function csvCell(value) {
+  const text = String(value ?? "");
+  if (!/[",\n]/.test(text)) return text;
+  return `"${text.replace(/"/g, '""')}"`;
+}
+
+module.exports = { exportUsage, toCsv };

package/src/fs-utils.js

@@ -0,0 +1,65 @@
+const fs = require("node:fs/promises");
+const fssync = require("node:fs");
+const path = require("node:path");
+
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+async function writeJson(filePath, value) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+async function readJson(filePath) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function walk(dir, predicate = () => true) {
+  const out = [];
+  async function visit(current) {
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) await visit(full);
+      else if (entry.isFile() && predicate(full)) out.push(full);
+    }
+  }
+  await visit(dir);
+  return out;
+}
+
+function existsSync(filePath) {
+  try {
+    return fssync.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  ensureDir,
+  writeJson,
+  readJson,
+  exists,
+  existsSync,
+  walk,
+};

package/src/paths.js

@@ -0,0 +1,16 @@
+const os = require("node:os");
+const path = require("node:path");
+
+function resolvePaths(options = {}) {
+  const home = options.home || process.env.HOME || os.homedir();
+  const dataDir = options.dataDir || path.join(home, ".ai-token-usage-lite");
+  return {
+    home,
+    dataDir,
+    usagePath: path.join(dataDir, "usage.json"),
+    claudeProjectsDir: path.join(home, ".claude", "projects"),
+    codexSessionsDir: path.join(process.env.CODEX_HOME || path.join(home, ".codex"), "sessions"),
+  };
+}
+
+module.exports = { resolvePaths };

package/src/providers/claude.js

@@ -0,0 +1,69 @@
+const fs = require("node:fs/promises");
+const { walk } = require("../fs-utils");
+
+async function scanClaude(paths) {
+  const files = await walk(paths.claudeProjectsDir, (p) => p.endsWith(".jsonl"));
+  const events = [];
+  for (const file of files) {
+    const text = await fs.readFile(file, "utf8").catch(() => "");
+    for (const line of text.split(/\r?\n/)) {
+      const event = parseClaudeLine(line, file);
+      if (event) events.push(event);
+    }
+  }
+  return {
+    provider: "claude",
+    files: files.length,
+    events,
+  };
+}
+
+function parseClaudeLine(line, filePath) {
+  if (!line || !line.trim()) return null;
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (obj.type !== "assistant" || !obj.message) return null;
+  const usage = obj.message.usage;
+  if (!usage || typeof usage !== "object") return null;
+  const inputTokens = num(usage.input_tokens);
+  const outputTokens = num(usage.output_tokens);
+  const cachedInputTokens = num(usage.cache_read_input_tokens);
+  const cacheCreationInputTokens =
+    num(usage.cache_creation_input_tokens) ||
+    num(usage.claude_cache_creation_5_m_tokens) ||
+    num(usage.claude_cache_creation_1_h_tokens);
+  const reasoningOutputTokens = num(usage.reasoning_output_tokens);
+  const totalTokens =
+    inputTokens + outputTokens + cachedInputTokens + cacheCreationInputTokens;
+  if (totalTokens === 0) return null;
+  return {
+    source: "claude",
+    model: obj.message.model || "unknown",
+    timestamp: obj.timestamp || obj.created_at || new Date().toISOString(),
+    projectRef: obj.cwd || projectFromFile(filePath),
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+    cacheCreationInputTokens,
+    reasoningOutputTokens,
+    totalTokens,
+    exact: true,
+  };
+}
+
+function projectFromFile(filePath) {
+  return filePath || null;
+}
+
+function num(value) {
+  return Number.isFinite(Number(value)) && Number(value) > 0 ? Math.round(Number(value)) : 0;
+}
+
+module.exports = {
+  scanClaude,
+  parseClaudeLine,
+};

package/src/providers/codex.js

@@ -0,0 +1,127 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const { walk } = require("../fs-utils");
+
+async function scanCodex(paths) {
+  const files = await walk(paths.codexSessionsDir, (p) => path.basename(p).startsWith("rollout-") && p.endsWith(".jsonl"));
+  const events = [];
+  for (const file of files) {
+    const text = await fs.readFile(file, "utf8").catch(() => "");
+    let lastTokenCountKey = null;
+    for (const line of text.split(/\r?\n/)) {
+      const event = parseCodexLine(line, file);
+      if (!event) continue;
+      if (event._tokenCountKey) {
+        if (event._tokenCountKey === lastTokenCountKey) continue;
+        lastTokenCountKey = event._tokenCountKey;
+        delete event._tokenCountKey;
+      }
+      events.push(event);
+    }
+  }
+  return {
+    provider: "codex",
+    files: files.length,
+    events,
+  };
+}
+
+function parseCodexLine(line, filePath) {
+  if (!line || !line.trim()) return null;
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const tokenCount = findTokenCount(obj);
+  if (tokenCount) return tokenCountToEvent(obj, tokenCount, filePath);
+
+  const response = findResponse(obj);
+  if (!response || !response.usage) return null;
+  const usage = response.usage;
+  const inputTokens = num(usage.input_tokens || usage.prompt_tokens);
+  const outputTokens = num(usage.output_tokens || usage.completion_tokens);
+  const cachedInputTokens = num(
+    usage.cached_input_tokens ||
+      usage.cache_read_input_tokens ||
+      usage.input_tokens_details?.cached_tokens ||
+      usage.prompt_tokens_details?.cached_tokens,
+  );
+  const cacheCreationInputTokens = num(usage.cache_creation_input_tokens);
+  const reasoningOutputTokens = num(
+    usage.reasoning_output_tokens || usage.output_tokens_details?.reasoning_tokens,
+  );
+  const totalTokens =
+    num(usage.total_tokens) ||
+    inputTokens + outputTokens + cacheCreationInputTokens;
+  if (totalTokens === 0) return null;
+  return {
+    source: "codex",
+    model: response.model || obj.model || "unknown",
+    timestamp: obj.timestamp || obj.ts || obj.created_at || new Date().toISOString(),
+    projectRef: inferProjectRef(obj, filePath),
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+    cacheCreationInputTokens,
+    reasoningOutputTokens,
+    totalTokens,
+    exact: true,
+  };
+}
+
+function findTokenCount(obj) {
+  if (obj.type === "event_msg" && obj.payload?.type === "token_count") return obj.payload.info || null;
+  if (obj.payload?.type === "token_count") return obj.payload.info || null;
+  return null;
+}
+
+function tokenCountToEvent(obj, info, filePath) {
+  const usage = info.last_token_usage || info.total_token_usage;
+  if (!usage) return null;
+  const inputTokens = num(usage.input_tokens);
+  const outputTokens = num(usage.output_tokens);
+  const cachedInputTokens = num(usage.cached_input_tokens || usage.cache_read_input_tokens);
+  const cacheCreationInputTokens = num(usage.cache_creation_input_tokens);
+  const reasoningOutputTokens = num(usage.reasoning_output_tokens);
+  const totalTokens = num(usage.total_tokens) || inputTokens + outputTokens + cacheCreationInputTokens;
+  if (totalTokens === 0) return null;
+  return {
+    source: "codex",
+    model: info.model || obj.model || "codex",
+    timestamp: obj.timestamp || obj.ts || obj.created_at || new Date().toISOString(),
+    projectRef: inferProjectRef(obj, filePath),
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+    cacheCreationInputTokens,
+    reasoningOutputTokens,
+    totalTokens,
+    exact: true,
+    _tokenCountKey: JSON.stringify(info.total_token_usage || usage),
+  };
+}
+
+function findResponse(obj) {
+  if (obj.response) return obj.response;
+  if (obj.msg?.response) return obj.msg.response;
+  if (obj.event?.response) return obj.event.response;
+  if (obj.type === "response.completed" && obj.data?.response) return obj.data.response;
+  if (obj.msg?.type === "response.completed" && obj.msg?.data?.response) return obj.msg.data.response;
+  if (obj.msg?.type === "response.completed" && obj.msg?.response) return obj.msg.response;
+  return null;
+}
+
+function inferProjectRef(obj, filePath) {
+  return obj.cwd || obj.project || obj.project_ref || null;
+}
+
+function num(value) {
+  return Number.isFinite(Number(value)) && Number(value) > 0 ? Math.round(Number(value)) : 0;
+}
+
+module.exports = {
+  scanCodex,
+  parseCodexLine,
+};

package/src/server.js

@@ -0,0 +1,117 @@
+const http = require("node:http");
+const fsp = require("node:fs/promises");
+const path = require("node:path");
+const { resolvePaths } = require("./paths");
+const { syncUsage } = require("./sync");
+
+async function serve(options = {}) {
+  const port = Number(options.port) || 7680;
+  const server = createServer(options);
+  await new Promise((resolve) => server.listen(port, "127.0.0.1", resolve));
+  process.stdout.write(`AI Token Usage Lite running at http://127.0.0.1:${port}\n`);
+  process.stdout.write(`Data: ${resolvePaths(options).usagePath}\n`);
+}
+
+function createServer(options = {}) {
+  const publicDir = path.resolve(__dirname, "../public");
+
+  return http.createServer(async (req, res) => {
+    try {
+      const pathname = requestPath(req);
+      if (isApiRoute(pathname, "/api/summary") && req.method === "GET") {
+        const result = await syncUsage(options);
+        send(res, 200, "application/json", JSON.stringify(result.data));
+        return;
+      }
+      if (isApiRoute(pathname, "/api/sync") && isSyncMethod(req.method)) {
+        const result = await syncUsage(options);
+        send(res, 200, "application/json", JSON.stringify(result.data));
+        return;
+      }
+      const filePath = staticFilePath(publicDir, pathname);
+      const content = await fsp.readFile(filePath);
+      send(res, 200, contentType(filePath), content);
+    } catch (err) {
+      handleError(res, req, err);
+    }
+  });
+}
+
+function send(res, status, type, body) {
+  res.writeHead(status, {
+    "Content-Type": type,
+    "Cache-Control": "no-cache",
+  });
+  res.end(body);
+}
+
+function sendJson(res, status, value) {
+  send(res, status, "application/json; charset=utf-8", JSON.stringify(value));
+}
+
+function isSyncMethod(method) {
+  return method === "POST" || method === "GET";
+}
+
+function requestPath(req) {
+  try {
+    return new URL(req.url || "/", "http://127.0.0.1").pathname;
+  } catch {
+    return "/";
+  }
+}
+
+function isApiRoute(pathname, suffix) {
+  const normalizedPath = stripTrailingSlash(pathname);
+  const normalizedSuffix = stripTrailingSlash(suffix);
+  return normalizedPath === normalizedSuffix || normalizedPath.endsWith(normalizedSuffix);
+}
+
+function stripTrailingSlash(value) {
+  if (!value || value === "/") return "/";
+  return value.replace(/\/+$/, "");
+}
+
+function staticFilePath(publicDir, pathname) {
+  if (!pathname || pathname === "/" || !path.extname(pathname) || path.basename(pathname) === "index.html") {
+    return path.join(publicDir, "index.html");
+  }
+  const normalizedPath = path.normalize(pathname).replace(/^(\.\.[/\\])+/, "");
+  const filePath = path.join(publicDir, normalizedPath);
+  if (!filePath.startsWith(publicDir)) {
+    return path.join(publicDir, "index.html");
+  }
+  return filePath;
+}
+
+function handleError(res, req, err) {
+  const pathname = requestPath(req);
+  if (isApiRoute(pathname, "/api/summary")) {
+    sendJson(res, 500, {
+      error: "读取统计数据失败",
+      detail: err && err.message ? err.message : String(err),
+    });
+    return;
+  }
+  if (isApiRoute(pathname, "/api/sync")) {
+    sendJson(res, 500, {
+      error: "同步失败",
+      detail: err && err.message ? err.message : String(err),
+    });
+    return;
+  }
+  if (err && err.code === "ENOENT") {
+    send(res, 404, "text/plain; charset=utf-8", "Not found");
+    return;
+  }
+  send(res, 500, "text/plain; charset=utf-8", "Internal server error");
+}
+
+function contentType(filePath) {
+  if (filePath.endsWith(".html")) return "text/html; charset=utf-8";
+  if (filePath.endsWith(".js")) return "text/javascript; charset=utf-8";
+  if (filePath.endsWith(".css")) return "text/css; charset=utf-8";
+  return "application/octet-stream";
+}
+
+module.exports = { serve, createServer };