ai-token-usage-lite 0.1.0

package/src/status.js

@@ -0,0 +1,40 @@
+const path = require("node:path");
+const { resolvePaths } = require("./paths");
+const { exists, walk } = require("./fs-utils");
+
+async function getStatus(options = {}) {
+  const paths = resolvePaths(options);
+  const claudeInstalled = await exists(paths.claudeProjectsDir);
+  const codexInstalled = await exists(paths.codexSessionsDir);
+  const claudeFiles = claudeInstalled
+    ? (await walk(paths.claudeProjectsDir, (p) => p.endsWith(".jsonl"))).length
+    : 0;
+  const codexFiles = codexInstalled
+    ? (await walk(paths.codexSessionsDir, (p) => path.basename(p).startsWith("rollout-") && p.endsWith(".jsonl"))).length
+    : 0;
+
+  return {
+    generatedAt: new Date().toISOString(),
+    paths: {
+      dataDir: paths.dataDir,
+      claudeProjectsDir: paths.claudeProjectsDir,
+      codexSessionsDir: paths.codexSessionsDir,
+    },
+    providers: {
+      claude: {
+        installed: claudeInstalled,
+        exact: true,
+        files: claudeFiles,
+        detail: claudeInstalled ? `${claudeFiles} jsonl files` : "projects directory missing",
+      },
+      codex: {
+        installed: codexInstalled,
+        exact: true,
+        files: codexFiles,
+        detail: codexInstalled ? `${codexFiles} rollout files` : "sessions directory missing",
+      },
+    },
+  };
+}
+
+module.exports = { getStatus };

package/src/sync.js

@@ -0,0 +1,33 @@
+const { aggregateEvents } = require("./aggregate");
+const { resolvePaths } = require("./paths");
+const { writeJson } = require("./fs-utils");
+const { scanClaude } = require("./providers/claude");
+const { scanCodex } = require("./providers/codex");
+const { analyzeTurns } = require("./turns");
+
+async function syncUsage(options = {}) {
+  const paths = resolvePaths(options);
+  const reports = [];
+
+  reports.push(await scanClaude(paths));
+  reports.push(await scanCodex(paths));
+
+  const events = reports.flatMap((report) => report.events || []);
+  const data = aggregateEvents(events);
+  data.turnAnalytics = await analyzeTurns(paths);
+  data.providers = reports.map((report) => ({
+    provider: report.provider,
+    files: report.files,
+    events: report.events ? report.events.length : 0,
+    skipped: report.skipped || null,
+    error: report.error || null,
+  }));
+
+  await writeJson(paths.usagePath, data);
+  return {
+    outputPath: paths.usagePath,
+    data,
+  };
+}
+
+module.exports = { syncUsage };

package/src/turns/aggregate-turns.js

@@ -0,0 +1,68 @@
+const { normalizeTimestamp, num } = require("./common");
+
+function aggregateTurnAnalytics(turns) {
+  const cleanTurns = (turns || []).map(sanitizeTurn).sort((a, b) => b.startTime.localeCompare(a.startTime));
+  const skillMap = new Map();
+  for (const turn of cleanTurns) {
+    for (const skill of turn.skills) {
+      const key = skill.name;
+      if (!skillMap.has(key)) {
+        skillMap.set(key, {
+          skill: key,
+          confidence: skill.confidence,
+          turnCount: 0,
+          durationMs: 0,
+          totalTokens: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cachedInputTokens: 0,
+          sources: new Set(),
+        });
+      }
+      const row = skillMap.get(key);
+      row.turnCount += 1;
+      row.durationMs += turn.durationMs;
+      row.totalTokens += turn.totalTokens;
+      row.inputTokens += turn.inputTokens;
+      row.outputTokens += turn.outputTokens;
+      row.cachedInputTokens += turn.cachedInputTokens;
+      row.sources.add(turn.source);
+      if (skill.confidence === "explicit") row.confidence = "explicit";
+    }
+  }
+  const bySkill = Array.from(skillMap.values())
+    .map((row) => ({
+      ...row,
+      sources: Array.from(row.sources).sort(),
+    }))
+    .sort((a, b) => b.totalTokens - a.totalTokens);
+  return {
+    turns: cleanTurns,
+    bySkill,
+  };
+}
+
+function sanitizeTurn(turn) {
+  return {
+    source: String(turn.source || "unknown"),
+    sessionId: turn.sessionId || null,
+    turnId: String(turn.turnId || ""),
+    model: String(turn.model || "unknown"),
+    startTime: normalizeTimestamp(turn.startTime),
+    endTime: normalizeTimestamp(turn.endTime || turn.startTime),
+    durationMs: num(turn.durationMs),
+    projectRef: turn.projectRef || null,
+    skills: (turn.skills || []).filter((skill) => skill && skill.name).map((skill) => ({
+      name: String(skill.name),
+      confidence: skill.confidence === "inferred" ? "inferred" : "explicit",
+    })),
+    inputTokens: num(turn.inputTokens),
+    outputTokens: num(turn.outputTokens),
+    cachedInputTokens: num(turn.cachedInputTokens),
+    totalTokens: num(turn.totalTokens),
+  };
+}
+
+module.exports = {
+  aggregateTurnAnalytics,
+};

package/src/turns/claude-turns.js

@@ -0,0 +1,120 @@
+const fs = require("node:fs/promises");
+const { walk } = require("../fs-utils");
+const { detectSkillFromPath, detectSkillsFromText, mergeSkills } = require("./skill-detect");
+const { addTokenTotals, durationMs, emptyTokenTotals, normalizeTimestamp, num } = require("./common");
+
+async function analyzeClaudeTurns(paths) {
+  const files = await walk(paths.claudeProjectsDir, (p) => p.endsWith(".jsonl"));
+  const all = [];
+  for (const file of files) {
+    all.push(...(await analyzeClaudeTurnsFromFile(file)));
+  }
+  return all;
+}
+
+async function analyzeClaudeTurnsFromFile(filePath) {
+  const text = await fs.readFile(filePath, "utf8").catch(() => "");
+  const turns = [];
+  let current = null;
+
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const timestamp = normalizeTimestamp(obj.timestamp);
+    if (isHumanUserMessage(obj)) {
+      finishCurrent(turns, current);
+      current = createTurn({ obj, timestamp, filePath });
+      continue;
+    }
+    if (!current) continue;
+    if (obj.type === "assistant" || obj.type === "user") {
+      current.endTime = timestamp;
+    }
+    if (obj.type === "assistant" && obj.message?.usage) {
+      const usage = claudeUsageToTotals(obj.message.usage);
+      addTokenTotals(current, usage);
+      current.model = obj.message.model || current.model;
+    }
+    current.skills = mergeSkills(current.skills, extractSkillsFromClaudeObject(obj));
+  }
+
+  finishCurrent(turns, current);
+  return turns;
+}
+
+function isHumanUserMessage(obj) {
+  if (obj.type !== "user" || obj.message?.role !== "user") return false;
+  const content = obj.message.content;
+  if (typeof content === "string") return true;
+  if (!Array.isArray(content)) return false;
+  return content.some((item) => item && item.type !== "tool_result");
+}
+
+function createTurn({ obj, timestamp, filePath }) {
+  return {
+    source: "claude",
+    sessionId: obj.sessionId || null,
+    turnId: obj.promptId || obj.uuid || `${filePath}:${timestamp}`,
+    model: "unknown",
+    startTime: timestamp,
+    endTime: timestamp,
+    durationMs: 0,
+    projectRef: obj.cwd || null,
+    skills: [],
+    ...emptyTokenTotals(),
+  };
+}
+
+function finishCurrent(turns, current) {
+  if (!current) return;
+  current.durationMs = durationMs(current.startTime, current.endTime);
+  current.skills = mergeSkills([], current.skills);
+  delete current.cacheCreationInputTokens;
+  delete current.reasoningOutputTokens;
+  if (current.totalTokens > 0 || current.skills.length > 0) turns.push(current);
+}
+
+function claudeUsageToTotals(usage) {
+  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);
+  return {
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+    cacheCreationInputTokens,
+    reasoningOutputTokens: num(usage.reasoning_output_tokens),
+    totalTokens: inputTokens + outputTokens + cachedInputTokens + cacheCreationInputTokens,
+  };
+}
+
+function extractSkillsFromClaudeObject(obj) {
+  let skills = [];
+  const content = obj.message?.content;
+  if (typeof content === "string") {
+    skills = mergeSkills(skills, detectSkillsFromText(content));
+  }
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      if (typeof item?.text === "string") skills = mergeSkills(skills, detectSkillsFromText(item.text));
+      const filePath = item?.input?.file_path;
+      const skill = detectSkillFromPath(filePath);
+      if (skill) skills = mergeSkills(skills, [skill]);
+    }
+  }
+  return skills;
+}
+
+module.exports = {
+  analyzeClaudeTurns,
+  analyzeClaudeTurnsFromFile,
+};

package/src/turns/codex-turns.js

@@ -0,0 +1,117 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const { walk } = require("../fs-utils");
+const { detectSkillFromPath, detectSkillsFromText, mergeSkills } = require("./skill-detect");
+const { addTokenTotals, durationMs, emptyTokenTotals, normalizeTimestamp, num } = require("./common");
+
+async function analyzeCodexTurns(paths) {
+  const files = await walk(paths.codexSessionsDir, (p) => path.basename(p).startsWith("rollout-") && p.endsWith(".jsonl"));
+  const all = [];
+  for (const file of files) {
+    all.push(...(await analyzeCodexTurnsFromFile(file)));
+  }
+  return all;
+}
+
+async function analyzeCodexTurnsFromFile(filePath) {
+  const text = await fs.readFile(filePath, "utf8").catch(() => "");
+  const turns = [];
+  let current = null;
+
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const timestamp = normalizeTimestamp(obj.timestamp);
+    const payload = obj.payload || {};
+    if (obj.type === "event_msg" && payload.type === "task_started") {
+      finishCurrent(turns, current);
+      current = createTurn({ payload, timestamp, filePath, obj });
+      continue;
+    }
+    if (!current) continue;
+    current.endTime = timestamp;
+    current.skills = mergeSkills(current.skills, extractSkillsFromCodexObject(obj));
+    if (obj.type === "event_msg" && payload.type === "token_count") {
+      addTokenTotals(current, codexTokenCountToTotals(payload.info));
+    }
+    if (obj.type === "event_msg" && payload.type === "task_complete") {
+      current.completed = true;
+      finishCurrent(turns, current);
+      current = null;
+    }
+  }
+  finishCurrent(turns, current);
+  return turns;
+}
+
+function createTurn({ payload, timestamp, filePath, obj }) {
+  return {
+    source: "codex",
+    sessionId: null,
+    turnId: payload.turn_id || `${filePath}:${timestamp}`,
+    model: obj.model || "codex",
+    startTime: timestamp,
+    endTime: timestamp,
+    durationMs: 0,
+    projectRef: null,
+    completed: false,
+    skills: [],
+    ...emptyTokenTotals(),
+  };
+}
+
+function finishCurrent(turns, current) {
+  if (!current) return;
+  current.durationMs = durationMs(current.startTime, current.endTime);
+  current.skills = mergeSkills([], current.skills);
+  delete current.completed;
+  delete current.cacheCreationInputTokens;
+  delete current.reasoningOutputTokens;
+  if (current.totalTokens > 0 || current.skills.length > 0) turns.push(current);
+}
+
+function codexTokenCountToTotals(info = {}) {
+  if (!info || typeof info !== "object") return emptyTokenTotals();
+  const usage = info.last_token_usage || info.total_token_usage || {};
+  const inputTokens = num(usage.input_tokens);
+  const outputTokens = num(usage.output_tokens);
+  const cachedInputTokens = num(usage.cached_input_tokens);
+  const cacheCreationInputTokens = num(usage.cache_creation_input_tokens);
+  return {
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+    cacheCreationInputTokens,
+    reasoningOutputTokens: num(usage.reasoning_output_tokens),
+    totalTokens: num(usage.total_tokens) || inputTokens + outputTokens + cacheCreationInputTokens,
+  };
+}
+
+function extractSkillsFromCodexObject(obj) {
+  let skills = [];
+  const payload = obj.payload || {};
+  if (typeof payload.message === "string") skills = mergeSkills(skills, detectSkillsFromText(payload.message));
+  const content = payload.content;
+  if (typeof content === "string") skills = mergeSkills(skills, detectSkillsFromText(content));
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      if (typeof item?.text === "string") skills = mergeSkills(skills, detectSkillsFromText(item.text));
+      const skill = detectSkillFromPath(item?.input?.file_path);
+      if (skill) skills = mergeSkills(skills, [skill]);
+    }
+  }
+  const filePath = payload.input?.file_path || payload.arguments?.file_path;
+  const skill = detectSkillFromPath(filePath);
+  if (skill) skills = mergeSkills(skills, [skill]);
+  return skills;
+}
+
+module.exports = {
+  analyzeCodexTurns,
+  analyzeCodexTurnsFromFile,
+};

package/src/turns/common.js

@@ -0,0 +1,42 @@
+function emptyTokenTotals() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cachedInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    reasoningOutputTokens: 0,
+    totalTokens: 0,
+  };
+}
+
+function addTokenTotals(target, usage) {
+  target.inputTokens += num(usage.inputTokens);
+  target.outputTokens += num(usage.outputTokens);
+  target.cachedInputTokens += num(usage.cachedInputTokens);
+  target.cacheCreationInputTokens += num(usage.cacheCreationInputTokens);
+  target.reasoningOutputTokens += num(usage.reasoningOutputTokens);
+  target.totalTokens += num(usage.totalTokens);
+}
+
+function normalizeTimestamp(value) {
+  const date = value ? new Date(value) : new Date();
+  return Number.isNaN(date.getTime()) ? new Date().toISOString() : date.toISOString();
+}
+
+function durationMs(startTime, endTime) {
+  const start = new Date(startTime).getTime();
+  const end = new Date(endTime).getTime();
+  return Number.isFinite(start) && Number.isFinite(end) && end >= start ? end - start : 0;
+}
+
+function num(value) {
+  return Number.isFinite(Number(value)) && Number(value) > 0 ? Math.round(Number(value)) : 0;
+}
+
+module.exports = {
+  emptyTokenTotals,
+  addTokenTotals,
+  normalizeTimestamp,
+  durationMs,
+  num,
+};

package/src/turns/index.js

@@ -0,0 +1,15 @@
+const { analyzeClaudeTurns } = require("./claude-turns");
+const { analyzeCodexTurns } = require("./codex-turns");
+const { aggregateTurnAnalytics } = require("./aggregate-turns");
+
+async function analyzeTurns(paths) {
+  const turns = [
+    ...(await analyzeClaudeTurns(paths)),
+    ...(await analyzeCodexTurns(paths)),
+  ];
+  return aggregateTurnAnalytics(turns);
+}
+
+module.exports = {
+  analyzeTurns,
+};

package/src/turns/skill-detect.js

@@ -0,0 +1,65 @@
+function detectSkillsFromText(text) {
+  const skills = new Map();
+  const raw = String(text || "");
+  const patterns = [
+    /Using\s+`(superpowers:[^`]+)`/gi,
+    /Using\s+`([^`]+)`[^.\n]{0,80}\bskill\b/gi,
+    /using\s+the\s+([a-z0-9:_-]+)\s+skill/gi,
+    /I'm using\s+the\s+([a-z0-9:_-]+)\s+skill/gi,
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(raw))) {
+      addSkill(skills, normalizeSkillName(match[1]), "explicit");
+    }
+  }
+  return Array.from(skills.values());
+}
+
+function detectSkillFromPath(filePath) {
+  const raw = String(filePath || "");
+  const match = raw.match(/[\\/](?:skills|\.system)[\\/]([^\\/]+)[\\/](?:SKILL\.md|skill\.md)$/i);
+  if (match) return { name: normalizeSkillName(match[1]), confidence: "inferred" };
+  return null;
+}
+
+function mergeSkills(target, skills) {
+  const map = new Map((target || []).map((skill) => [skill.name, skill]));
+  for (const skill of skills || []) {
+    if (!skill || !skill.name) continue;
+    const existing = map.get(skill.name);
+    if (!existing || existing.confidence !== "explicit") map.set(skill.name, skill);
+  }
+  return Array.from(map.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function addSkill(map, name, confidence) {
+  if (!isLikelySkillName(name)) return;
+  const existing = map.get(name);
+  if (!existing || existing.confidence !== "explicit") map.set(name, { name, confidence });
+}
+
+function normalizeSkillName(value) {
+  return String(value || "").trim().replace(/^\/+/, "");
+}
+
+function isLikelySkillName(name) {
+  const value = String(name || "");
+  if (!/^[a-z0-9][a-z0-9:_-]{2,}$/.test(value)) return false;
+  if (value.startsWith("superpowers:")) return true;
+  if (/[:_-]/.test(value)) return true;
+  return KNOWN_SINGLE_WORD_SKILLS.has(value);
+}
+
+const KNOWN_SINGLE_WORD_SKILLS = new Set([
+  "diagnose",
+  "prototype",
+  "tdd",
+  "triage",
+]);
+
+module.exports = {
+  detectSkillsFromText,
+  detectSkillFromPath,
+  mergeSkills,
+};