lostvibe 0.0.0-stage → 0.7.0

package/src/logs.mjs

@@ -0,0 +1,586 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import zlib from 'node:zlib';
+import crypto from 'node:crypto';
+import { costOf, normalizeModel } from './prices.mjs';
+
+const hash = (s) => crypto.createHash('sha256').update(s).digest('hex').slice(0, 32);
+// A day means the owner's day. One computer keeps one zone forever, so a trip cannot
+// move a past response into another day and count it twice on the server.
+let zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+const formatters = new Map();
+export function setZone(next) { if (next) zone = next; }
+export function localDate(ts, tz = zone) {
+  const d = new Date(ts);
+  if (Number.isNaN(d.getTime())) return null;
+  if (!formatters.has(tz)) formatters.set(tz, new Intl.DateTimeFormat('en-CA', { timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit' }));
+  return formatters.get(tz).format(d);
+}
+function* walk(dir, match, depth = 0) {
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) { if (depth < 16 && e.name !== 'node_modules' && e.name !== '.git') yield* walk(p, match, depth + 1); }
+    else if (e.isFile() && match(e.name, p)) yield p;
+  }
+}
+function* walkAll(dirs, match) { for (const d of dirs) yield* walk(d, match); }
+const isJsonl = (name) => /\.jsonl(\.zst)?$/.test(name);
+function readJsonFile(p) { try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
+}
+async function* lines(file) {
+  const input = fs.createReadStream(file, { encoding: 'utf8' });
+  const rl = readline.createInterface({ input, crlfDelay: Infinity });
+  try { for await (const line of rl) yield line; } finally { rl.close(); input.destroy(); }
+}
+// A wall clock with no zone, read in the fixed zone of this computer.
+function wallToIso(y, mo, d, h, mi, s) {
+  const want = Date.UTC(y, mo - 1, d, h, mi, s);
+  let guess = want;
+  const f = new Intl.DateTimeFormat('en-US', { timeZone: zone, hourCycle: 'h23', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit' });
+  for (let i = 0; i < 3; i++) {
+    const p = Object.fromEntries(f.formatToParts(new Date(guess)).map((x) => [x.type, Number(x.value)]));
+    const seen = Date.UTC(p.year, p.month - 1, p.day, p.hour % 24, p.minute, p.second);
+    if (seen === want) break;
+    guess += want - seen;
+  }
+  return new Date(guess).toISOString();
+}
+// node:sqlite is built in from Node 22.13 but still announces itself; that notice is not the owner's concern.
+let sqliteModule = null;
+async function sqlite() {
+  if (sqliteModule) return sqliteModule;
+  const prev = process.listeners('warning');
+  process.removeAllListeners('warning');
+  process.on('warning', (w) => { if (!/sqlite/i.test(String(w?.message))) for (const fn of prev) fn(w); });
+  sqliteModule = await import('node:sqlite');
+  return sqliteModule;
+}
+async function queryDb(file, sqlFor) {
+  const { DatabaseSync } = await sqlite();
+  const db = new DatabaseSync(file, { readOnly: true });
+  try {
+    const tables = new Set(db.prepare("select name from sqlite_master where type in ('table','view')").all().map((r) => r.name));
+    const q = sqlFor(tables);
+    return q ? db.prepare(q).all() : [];
+  } finally { db.close(); }
+}
+async function* records(file) {
+  const raw = fs.createReadStream(file);
+  const input = file.endsWith('.zst') ? raw.pipe(zlib.createZstdDecompress()) : raw;
+  raw.on('error', (e) => input.destroy(e));
+  const lines = readline.createInterface({ input, crlfDelay: Infinity });
+  try {
+    for await (const line of lines) {
+      if (!/"(usage|session_meta|turn_context|token_usage_record|token_count)"/.test(line)) continue;
+      try { yield JSON.parse(line); } catch { /* unfinished last line is read again next time */ }
+    }
+  } finally { lines.close(); raw.destroy(); input.destroy(); }
+}
+const zeroTokens = () => ({ input: 0, output: 0, cache_create: 0, cache_read: 0, cc1h: 0 });
+const num = (n) => typeof n === 'number' && Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+// A tool that prices its own responses fills in for models the table does not know.
+function event(tool, key, cwd, model, ts, session, t, aliases = [], reportedCost = null) {
+  const at = new Date(ts);
+  if (Number.isNaN(at.getTime())) return null;
+  let cost = costOf(normalizeModel(model), t);
+  let unpriced = cost === null;
+  if (cost === null && typeof reportedCost === 'number' && Number.isFinite(reportedCost) && reportedCost >= 0) { cost = reportedCost; unpriced = false; }
+  return { id: hash(`${tool}:${key}`), aliases, tool, cwd: cwd || 'unknown', model: normalizeModel(model),
+    at: at.toISOString(), session: hash(`${tool}:${session || key}`),
+    ...t, cost: cost === null ? 0 : cost, unpriced };
+}
+function mergeEvents(list) {
+  const out = new Map();
+  for (const e of list.filter(Boolean)) {
+    const prev = out.get(e.id);
+    if (!prev) { out.set(e.id, { ...e }); continue; }
+    for (const k of ['input', 'output', 'cache_create', 'cache_read', 'cc1h', 'cost']) prev[k] = Math.max(prev[k] || 0, e[k] || 0);
+    prev.aliases = [...new Set([...(prev.aliases || []), ...(e.aliases || [])])];
+    if (e.at < prev.at) prev.at = e.at;
+    if (prev.model.startsWith('unknown') && !e.model.startsWith('unknown')) { prev.model = e.model; prev.unpriced = e.unpriced; }
+  }
+  return [...out.values()];
+}
+async function claudeFile(file) {
+  const out = [];
+  for await (const o of records(file)) {
+    if (o.type !== 'assistant' || !o.message?.usage || !o.message.model || o.message.model === '<synthetic>') continue;
+    const u = o.message.usage;
+    const key = o.message.id ? `${o.message.id}:${o.requestId || ''}` : `${o.sessionId}:${o.timestamp}:${o.message.model}`;
+    out.push(event('claude-code', key, o.cwd, o.message.model, o.timestamp, o.sessionId, {
+      input: num(u.input_tokens), output: num(u.output_tokens), cache_create: num(u.cache_creation_input_tokens),
+      cache_read: num(u.cache_read_input_tokens), cc1h: num(u.cache_creation?.ephemeral_1h_input_tokens),
+    }));
+  }
+  return mergeEvents(out);
+}
+function codexTokens(u) {
+  const cached = num(u.cached_input_tokens); const write = num(u.cache_write_input_tokens);
+  return { input: Math.max(0, num(u.input_tokens) - cached - write), output: num(u.output_tokens), cache_create: write, cache_read: cached, cc1h: 0 };
+}
+async function codexFile(file) {
+  let cwd = null; let model = null; let session = null;
+  const out = [];
+  for await (const o of records(file)) {
+    const p = o.payload || {};
+    if (o.type === 'session_meta') { cwd = p.cwd || cwd; session = p.session_id || p.id || session; }
+    else if (o.type === 'turn_context') { cwd = p.cwd || cwd; model = p.model || model; }
+    else if (o.type === 'token_usage_record') {
+      out.push(event('codex', `response:${p.response_id || `${session}:${o.timestamp}`}`, cwd, p.model || model || 'unknown-codex', o.timestamp, p.session_id || session, codexTokens(p.usage || {})));
+    } else if (o.type === 'event_msg' && p.type === 'token_count' && p.info?.last_token_usage) {
+      const total = p.info.total_token_usage?.total_tokens;
+      if (typeof total !== 'number') continue;
+      const e = event('codex', `total:${session || hash(file)}:${total}`, cwd, model || 'unknown-codex', o.timestamp, session, codexTokens(p.info.last_token_usage));
+      if (e) { e.legacy = true; e.cumulative = total; }
+      out.push(e);
+    }
+  }
+  return mergeEvents(out);
+}
+// Pair old/new representations before adding either, including copies in other files.
+// Matching is one-to-one; repeated equal-size responses remain separate events.
+function reconcileCodex(list) {
+  const unique = mergeEvents(list);
+  const legacy = new Map();
+  const signature = (e) => `${e.session}:${e.input}:${e.output}:${e.cache_create}:${e.cache_read}`;
+  for (const e of unique) if (e.legacy) {
+    const k = signature(e); if (!legacy.has(k)) legacy.set(k, []); legacy.get(k).push(e);
+  }
+  const removed = new Set();
+  const prefix = new Map();
+  const modern = unique.filter((e) => !e.legacy).sort((a,b) => a.at.localeCompare(b.at) || a.id.localeCompare(b.id));
+  for (const e of modern) {
+    const running = (prefix.get(e.session) || 0)+e.input+e.output+e.cache_create+e.cache_read;
+    prefix.set(e.session,running);
+    const candidates = (legacy.get(signature(e)) || []).filter((x) => !removed.has(x.id) && Math.abs(Date.parse(x.at)-Date.parse(e.at))<=60000);
+    // Prefer the counter's cumulative position. A completed response can precede
+    // its compatibility counter by several seconds while tool output is flushed.
+    const old = candidates.find((x) => x.cumulative === running) || candidates.sort((a,b) => Math.abs(Date.parse(a.at)-Date.parse(e.at))-Math.abs(Date.parse(b.at)-Date.parse(e.at)))[0];
+    if (old) { e.aliases = [...new Set([...e.aliases, old.id])]; removed.add(old.id); }
+  }
+  return unique.filter((e) => !removed.has(e.id));
+}
+async function readTool(buckets, tool, fileList, parseFile, cache) {
+  const entries = [];
+  let files = 0;
+  const cacheFiles = cache?.files || {};
+  const seen = new Set();
+  for (const file of fileList) {
+    if (seen.has(file)) continue;
+    seen.add(file);
+    let st;
+    try { st = fs.statSync(file); } catch { continue; }
+    files++;
+    const prev = cacheFiles[file];
+    let events;
+    if (prev?.size === st.size && prev?.mtime === st.mtimeMs && prev.tool === tool) events = prev.events;
+    else {
+      // A store that is locked or half-written keeps what the last read found.
+      let parsed;
+      try { parsed = await parseFile(file); } catch { continue; }
+      events = mergeEvents([...(prev?.tool === tool ? prev.events : []), ...parsed]);
+    }
+    cacheFiles[file] = { tool, size: st.size, mtime: st.mtimeMs, events };
+  }
+  // Cached normalized events survive log cleanup. Caches contain no conversation content.
+  for (const entry of Object.values(cacheFiles)) if (entry.tool === tool) entries.push(...entry.events);
+  const events = tool === 'codex' ? reconcileCodex(entries) : mergeEvents(entries);
+  for (const e of events) {
+    if (!buckets.has(e.cwd)) buckets.set(e.cwd, emptyBucket());
+    buckets.get(e.cwd).events.set(e.id, e);
+  }
+  for (const [cwd, b] of buckets) buckets.set(cwd, bucketFromEvents([...b.events.values()]));
+  return { files };
+}
+export async function readClaude(buckets, { cache = { files: {} } } = {}) {
+  return readTool(buckets, 'claude-code', walkAll([path.join(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'), 'projects')], isJsonl), claudeFile, cache);
+}
+export async function readCodex(buckets, { cache = { files: {} } } = {}) {
+  const home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  return readTool(buckets, 'codex', walkAll(['sessions', 'archived_sessions'].map((d) => path.join(home, d)), isJsonl), codexFile, cache);
+}
+
+// ---- Gemini CLI: ~/.gemini/tmp/<project>/chats/session-*.jsonl (older: .json), tokens on each model message.
+function geminiProjects(tmpDir, candidates) {
+  // New folders are named by a slug and carry .project_root; older ones are sha256(path) and keep no path.
+  const bySlug = new Map();
+  const reg = readJsonFile(path.join(path.dirname(tmpDir), 'projects.json'));
+  for (const [p, slug] of Object.entries(reg?.projects || {})) if (typeof slug === 'string') bySlug.set(slug, p);
+  for (const c of candidates) bySlug.set(crypto.createHash('sha256').update(c).digest('hex'), c);
+  return (id) => {
+    try { const root = fs.readFileSync(path.join(tmpDir, id, '.project_root'), 'utf8').trim(); if (root) return root; } catch { /* older folder */ }
+    return bySlug.get(id) || null;
+  };
+}
+function geminiMessage(tool, session, cwd, m) {
+  const t = m?.tokens;
+  if (m?.type !== 'gemini' || !t || typeof t !== 'object') return null;
+  const cached = num(t.cached);
+  return event(tool, `${session}:${m.id}`, cwd, m.model || 'unknown-gemini-cli', m.timestamp, session, {
+    input: Math.max(0, num(t.input) - cached) + num(t.tool), output: num(t.output) + num(t.thoughts), cache_create: 0, cache_read: cached, cc1h: 0,
+  });
+}
+async function geminiFile(file, project) {
+  const chats = path.dirname(file).split(path.sep);
+  const id = chats[chats.lastIndexOf('chats') - 1];
+  const cwd = project(id);
+  const out = [];
+  if (file.endsWith('.json')) {
+    const o = readJsonFile(file);
+    for (const m of o?.messages || []) out.push(geminiMessage('gemini-cli', o.sessionId || hash(file), cwd, m));
+    return mergeEvents(out);
+  }
+  let session = null;
+  for await (const line of lines(file)) {
+    if (!/"(sessionId|tokens)"/.test(line)) continue;
+    let o; try { o = JSON.parse(line); } catch { continue; }
+    if (o.sessionId && !o.id) session = o.sessionId;
+    else out.push(geminiMessage('gemini-cli', session || hash(file), cwd, o));
+  }
+  return mergeEvents(out);
+}
+export async function readGemini(buckets, { cache = { files: {} }, candidates = [] } = {}) {
+  const home = process.env.GEMINI_CLI_HOME || os.homedir();
+  const roots = [path.join(home, '.gemini', 'tmp'), path.join(home, '.cache', '.gemini', 'tmp')];
+  const match = (name, p) => /\.jsonl?$/.test(name) && p.split(path.sep).includes('chats');
+  let total = { files: 0 };
+  for (const tmpDir of roots) {
+    const project = geminiProjects(tmpDir, candidates);
+    const r = await readTool(buckets, 'gemini-cli', walk(tmpDir, match), (f) => geminiFile(f, project), cache);
+    total.files += r.files;
+  }
+  return total;
+}
+
+// ---- Grok Build (xAI): ~/.grok/sessions/<cwd>/<session>/usage.json, one row per turn and model.
+function grokCwd(sessionDir) {
+  const summary = readJsonFile(path.join(sessionDir, 'summary.json'));
+  if (typeof summary?.info?.cwd === 'string' && summary.info.cwd) return summary.info.cwd;
+  const parent = path.dirname(sessionDir);
+  try { const c = fs.readFileSync(path.join(parent, '.cwd'), 'utf8').trim(); if (c) return c; } catch { /* short name */ }
+  try { const name = decodeURIComponent(path.basename(parent)); if (/^([a-zA-Z]:)?[\\/]/.test(name)) return name; } catch { /* not a path */ }
+  return null;
+}
+function grokTurn(t, model, u) {
+  const cached = num(u.cachedReadTokens);
+  return { input: Math.max(0, num(u.inputTokens) - cached), output: num(u.outputTokens), cache_create: num(u.cacheCreationTokens), cache_read: cached, cc1h: 0 };
+}
+async function grokUsageFile(file) {
+  const o = readJsonFile(file);
+  if (!o || !Array.isArray(o.turns)) return [];
+  const dir = path.dirname(file);
+  const session = o.sessionId || path.basename(dir);
+  const cwd = grokCwd(dir);
+  const out = [];
+  for (const t of o.turns) {
+    const per = t.modelUsage && typeof t.modelUsage === 'object' ? Object.entries(t.modelUsage) : [];
+    const list = per.length ? per : [[t.primaryModelId || o.session?.primaryModelId || 'unknown-grok-cli', t]];
+    for (const [model, u] of list) {
+      const cost = typeof u.costUsdTicks === 'number' ? u.costUsdTicks / 1e10 : null;
+      out.push(event('grok-cli', `${session}:${t.turnNumber}:${model}`, cwd, model, t.endedAt || o.updatedAt, session, grokTurn(t, model, u), [], cost));
+    }
+  }
+  return mergeEvents(out);
+}
+// grok-dev (superagent-ai/grok-cli): ~/.grok/grok.db, usage_events joined to sessions for the cwd. No cache split is stored.
+async function grokDbFile(file) {
+  const rows = await queryDb(file, (tables) => (tables.has('usage_events') && tables.has('sessions')
+    ? 'select u.id, u.session_id, u.model, u.input_tokens, u.output_tokens, u.cost_micros, u.created_at, s.cwd_at_start, s.model as session_model from usage_events u left join sessions s on s.id = u.session_id' : null));
+  return mergeEvents(rows.map((r) => event('grok-cli', `db:${r.session_id}:${r.id}`, r.cwd_at_start, r.model || r.session_model || 'unknown-grok-cli', r.created_at, r.session_id,
+    { input: num(r.input_tokens), output: num(r.output_tokens), cache_create: 0, cache_read: 0, cc1h: 0 }, [], typeof r.cost_micros === 'number' ? r.cost_micros / 1e6 : null)));
+}
+export async function readGrok(buckets, { cache = { files: {} } } = {}) {
+  const home = process.env.GROK_HOME || path.join(os.homedir(), '.grok');
+  const a = await readTool(buckets, 'grok-cli', walk(path.join(home, 'sessions'), (name) => name === 'usage.json'), grokUsageFile, cache);
+  const dbFile = path.join(home, 'grok.db');
+  const b = fs.existsSync(dbFile) ? await readTool(buckets, 'grok-cli', [dbFile], grokDbFile, cache) : { files: 0 };
+  return { files: a.files + b.files };
+}
+
+// ---- Cline, Roo Code, Kilo Code task logs: <globalStorage>/<extension>/tasks/<task>/ui_messages.json.
+// Only the numbers inside api_req_started are read; the request text beside them never leaves the parser.
+const TASK_LOG_EXTENSIONS = {
+  cline: ['saoudrizwan.claude-dev'],
+  'roo-code': ['rooveterinaryinc.roo-cline', 'rooveterinaryinc.roo-code', 'rooveterinaryinc.roo-code-nightly', 'roovscode.roo-cline', 'roovscode.roo-code'],
+  'kilo-code': ['kilocode.kilo-code'],
+};
+function vscodeStorageDirs() {
+  if (process.env.LOSTVIBE_VSCODE_STORAGE) return process.env.LOSTVIBE_VSCODE_STORAGE.split(path.delimiter).filter(Boolean);
+  const home = os.homedir();
+  const base = process.platform === 'darwin' ? path.join(home, 'Library', 'Application Support')
+    : process.platform === 'win32' ? (process.env.APPDATA || path.join(home, 'AppData', 'Roaming'))
+      : (process.env.XDG_CONFIG_HOME || path.join(home, '.config'));
+  return ['Code', 'Code - Insiders', 'Code - OSS', 'VSCodium', 'Cursor', 'Windsurf', 'Trae', 'Positron'].map((p) => path.join(base, p, 'User', 'globalStorage'));
+}
+function clineDataDir() {
+  return process.env.CLINE_DATA_DIR || path.join(process.env.CLINE_DIR || path.join(os.homedir(), '.cline'), 'data');
+}
+// Where each store keeps the workspace and model of a task: beside the task (Roo), in an index (Roo), in state/ (Cline).
+async function taskIndex(extDir, extIds) {
+  const items = new Map();
+  const add = (it) => { if (it && typeof it.id === 'string') items.set(it.id, { ...(items.get(it.id) || {}), ...it }); };
+  for (const it of readJsonFile(path.join(extDir, 'state', 'taskHistory.json')) || []) add(it);
+  for (const it of readJsonFile(path.join(extDir, 'tasks', '_index.json'))?.entries || []) add(it);
+  const vscdb = path.join(path.dirname(extDir), 'state.vscdb');
+  if (fs.existsSync(vscdb)) {
+    try {
+      const rows = await queryDb(vscdb, (tables) => (tables.has('ItemTable') ? `select value from ItemTable where lower(key) in (${extIds.map((x) => `'${x.toLowerCase()}'`).join(',')})` : null));
+      for (const r of rows) { let v; try { v = JSON.parse(r.value); } catch { continue; } for (const it of v?.taskHistory || []) add(it); }
+    } catch { /* VS Code may hold the file */ }
+  }
+  return items;
+}
+function taskMeta(taskDir, taskId, index) {
+  const it = { ...(index.get(taskId) || {}), ...(readJsonFile(path.join(taskDir, 'history_item.json')) || {}) };
+  const usage = readJsonFile(path.join(taskDir, 'task_metadata.json'))?.model_usage;
+  const models = (Array.isArray(usage) ? usage : []).filter((u) => typeof u?.model_id === 'string').sort((a, b) => (a.ts || 0) - (b.ts || 0));
+  return { cwd: it.workspace || it.cwdOnTaskInitialization || null, model: it.modelId || null, models };
+}
+async function taskLogFile(tool, file, index) {
+  const taskDir = path.dirname(file);
+  const taskId = path.basename(taskDir);
+  const msgs = readJsonFile(file);
+  if (!Array.isArray(msgs)) return [];
+  const meta = taskMeta(taskDir, taskId, index);
+  const out = [];
+  for (const m of msgs) {
+    if (m?.say !== 'api_req_started' || typeof m.text !== 'string') continue;
+    let info; try { info = JSON.parse(m.text); } catch { continue; }
+    const t = { input: num(info.tokensIn), output: num(info.tokensOut), cache_create: num(info.cacheWrites), cache_read: num(info.cacheReads), cc1h: 0 };
+    if (!t.input && !t.output && !t.cache_create && !t.cache_read) continue;
+    // OpenAI-style counts carry the cached part inside tokensIn; Anthropic-style counts keep it apart.
+    if ((info.apiProtocol || m.apiProtocol) === 'openai') t.input = Math.max(0, t.input - t.cache_create - t.cache_read);
+    const atModel = meta.models.filter((u) => (u.ts || 0) <= (m.ts || 0)).pop() || meta.models[0];
+    const model = atModel?.model_id || meta.model || `unknown-${tool}`;
+    out.push(event(tool, `${taskId}:${m.ts}`, meta.cwd, model, m.ts, taskId, t, [], typeof info.cost === 'number' ? info.cost : null));
+  }
+  return mergeEvents(out);
+}
+// Cline 4.x keeps sessions in ~/.cline/data/sessions/<id>/<id>.messages.json with metrics and model on each reply.
+function clineSessionCwd(sessionDir, id) {
+  const manifest = readJsonFile(path.join(sessionDir, `${id}.json`));
+  for (const k of ['cwd', 'workspaceRoot', 'workspace_root', 'directory']) if (typeof manifest?.[k] === 'string' && manifest[k]) return manifest[k];
+  return null;
+}
+async function clineSessionFile(file, dbRows) {
+  const dir = path.dirname(file);
+  const id = path.basename(file).replace(/\.messages\.json$/, '');
+  const cwd = clineSessionCwd(dir, id) || dbRows.get(id)?.cwd || null;
+  let msgs = readJsonFile(file);
+  if (!Array.isArray(msgs)) {
+    msgs = [];
+    for await (const line of lines(file)) { try { msgs.push(JSON.parse(line)); } catch { /* partial */ } }
+  }
+  const out = [];
+  msgs.forEach((m, i) => {
+    const x = m?.metrics;
+    if (!x || typeof x !== 'object') return;
+    const t = { input: num(x.inputTokens), output: num(x.outputTokens), cache_create: num(x.cacheWriteTokens), cache_read: num(x.cacheReadTokens), cc1h: 0 };
+    if (!t.input && !t.output && !t.cache_create && !t.cache_read) return;
+    out.push(event('cline', `sdk:${id}:${m.id || m.ts || i}`, cwd, m.modelInfo?.id || dbRows.get(id)?.model || 'unknown-cline', m.ts || dbRows.get(id)?.started || Date.now(), id, t, [], typeof x.cost === 'number' ? x.cost : null));
+  });
+  return mergeEvents(out);
+}
+async function clineSessionRows(dataDir) {
+  const rows = new Map();
+  const db = path.join(dataDir, 'db', 'sessions.db');
+  if (!fs.existsSync(db)) return rows;
+  try {
+    for (const r of await queryDb(db, (tables) => (tables.has('sessions') ? 'select session_id, cwd, workspace_root, model, started_at from sessions' : null))) {
+      rows.set(r.session_id, { cwd: r.cwd || r.workspace_root || null, model: r.model || null, started: r.started_at || null });
+    }
+  } catch { /* locked */ }
+  return rows;
+}
+export async function readTaskLogs(buckets, { cache = { files: {} } } = {}) {
+  const stores = vscodeStorageDirs();
+  const files = {};
+  for (const [tool, extIds] of Object.entries(TASK_LOG_EXTENSIONS)) {
+    files[tool] = 0;
+    const extDirs = stores.flatMap((s) => extIds.map((e) => path.join(s, e)));
+    if (tool === 'cline') extDirs.push(clineDataDir());
+    for (const extDir of extDirs) {
+      if (!fs.existsSync(path.join(extDir, 'tasks'))) continue;
+      const index = await taskIndex(extDir, extIds);
+      const r = await readTool(buckets, tool, walk(path.join(extDir, 'tasks'), (name) => name === 'ui_messages.json'), (f) => taskLogFile(tool, f, index), cache);
+      files[tool] += r.files;
+    }
+  }
+  const sessions = path.join(clineDataDir(), 'sessions');
+  if (fs.existsSync(sessions)) {
+    const rows = await clineSessionRows(clineDataDir());
+    const r = await readTool(buckets, 'cline', walk(sessions, (name) => name.endsWith('.messages.json')), (f) => clineSessionFile(f, rows), cache);
+    files.cline += r.files;
+  }
+  return { files };
+}
+
+// ---- Aider: "> Tokens: 4.3k sent, 1.1k received." lines in .aider.chat.history.md at the git root.
+// Counts are rounded to the nearest hundred or thousand in that file; nothing finer exists on disk.
+function kTokens(s) {
+  const m = /^([\d.]+)(k)?$/.exec(String(s || ''));
+  if (!m) return 0;
+  const n = Number(m[1]) * (m[2] ? 1000 : 1);
+  return Number.isFinite(n) ? Math.round(n) : 0;
+}
+async function aiderFile(file) {
+  const cwd = path.dirname(file);
+  let start = null; let model = 'unknown-aider'; let n = 0;
+  const out = [];
+  for await (const line of lines(file)) {
+    let m;
+    if ((m = /^# aider chat started at (\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/.exec(line))) { start = wallToIso(...m.slice(1).map(Number)); n = 0; }
+    else if ((m = /^> (?:Main model|Model): (\S+) with /.exec(line))) model = m[1];
+    else if ((m = /^> Tokens: (\S+) sent(?:, (\S+) cache write)?(?:, (\S+) cache hit)?, (\S+) received\./.exec(line))) {
+      n++;
+      const sent = kTokens(m[1]); const write = kTokens(m[2]); const hit = kTokens(m[3]);
+      // "sent" already includes the cache write when there is one.
+      out.push(event('aider', `${cwd}:${start}:${n}`, cwd, model, start || fs.statSync(file).mtime, `${cwd}:${start}`,
+        { input: Math.max(0, sent - write), output: kTokens(m[4]), cache_create: write, cache_read: hit, cc1h: 0 }));
+    }
+  }
+  return mergeEvents(out);
+}
+export async function readAider(buckets, { cache = { files: {} }, dirs = [] } = {}) {
+  // One folder under two names (a symlinked /var on macOS) is one history file; the first name is its project.
+  const files = new Map();
+  const env = process.env.AIDER_CHAT_HISTORY_FILE;
+  const list = [...dirs.map((d) => path.join(d, '.aider.chat.history.md')), ...(env && path.isAbsolute(env) ? [env] : [])];
+  for (const f of list) {
+    let real; try { real = fs.realpathSync(f); } catch { continue; }
+    if (!files.has(real)) files.set(real, f);
+  }
+  return readTool(buckets, 'aider', [...files.values()], aiderFile, cache);
+}
+
+// ---- OpenCode (and Kilo Code 7+, its fork): sqlite under $XDG_DATA_HOME/<app>/, assistant messages carry tokens.
+// Only numbers and ids are selected from the database; message text stays inside sqlite.
+function opencodeRow(tool, r, directory) {
+  const t = { input: num(r.input), output: num(r.output) + num(r.reasoning), cache_create: num(r.cache_write), cache_read: num(r.cache_read), cc1h: 0 };
+  return event(tool, `${r.session_id}:${r.id}`, directory, r.model || 'unknown-opencode', r.created || r.time_created, r.session_id, t, [], typeof r.cost === 'number' ? r.cost : null);
+}
+const OC_TOKENS = "json_extract(m.data,'$.tokens.input') as input, json_extract(m.data,'$.tokens.output') as output, json_extract(m.data,'$.tokens.reasoning') as reasoning, json_extract(m.data,'$.tokens.cache.read') as cache_read, json_extract(m.data,'$.tokens.cache.write') as cache_write, json_extract(m.data,'$.cost') as cost, json_extract(m.data,'$.time.created') as created, json_extract(m.data,'$.path.cwd') as cwd";
+async function opencodeDbFile(tool, file) {
+  const rows = await queryDb(file, (tables) => {
+    if (tables.has('session_message') && tables.has('session_v2')) return `select m.id, m.session_id, m.time_created, s.directory, json_extract(m.data,'$.model.id') as model, ${OC_TOKENS} from session_message m left join session_v2 s on s.id = m.session_id where m.type = 'assistant'`;
+    if (tables.has('message') && tables.has('session')) return `select m.id, m.session_id, m.time_created, s.directory, json_extract(m.data,'$.modelID') as model, ${OC_TOKENS} from message m left join session s on s.id = m.session_id where json_extract(m.data,'$.role') = 'assistant'`;
+    return null;
+  });
+  return mergeEvents(rows.map((r) => opencodeRow(tool, r, r.directory || r.cwd || null)));
+}
+async function opencodeJsonFile(tool, file, sessionDir) {
+  const m = readJsonFile(file);
+  if (m?.role !== 'assistant' || !m.tokens) return [];
+  const sid = m.sessionID || path.basename(path.dirname(file));
+  let directory = m.path?.cwd || null;
+  if (!directory) for (const f of walk(sessionDir, (name) => name === `${sid}.json`)) { directory = readJsonFile(f)?.directory || null; break; }
+  const r = { id: m.id || path.basename(file, '.json'), session_id: sid, model: m.modelID, input: m.tokens.input, output: m.tokens.output, reasoning: m.tokens.reasoning, cache_read: m.tokens.cache?.read, cache_write: m.tokens.cache?.write, cost: m.cost, created: m.time?.created };
+  return mergeEvents([opencodeRow(tool, r, directory)]);
+}
+export async function readOpenCode(buckets, { cache = { files: {} }, tool = 'opencode', app = 'opencode' } = {}) {
+  const root = path.join(process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share'), app);
+  const dbs = [];
+  try { for (const e of fs.readdirSync(root)) if (/^(opencode|kilo)[\w-]*\.db$/.test(e)) dbs.push(path.join(root, e)); } catch { return { files: 0 }; }
+  const a = await readTool(buckets, tool, dbs, (f) => opencodeDbFile(tool, f), cache);
+  const sessionDir = path.join(root, 'storage', 'session');
+  const b = await readTool(buckets, tool, walk(path.join(root, 'storage', 'message'), (name) => name.endsWith('.json')), (f) => opencodeJsonFile(tool, f, sessionDir), cache);
+  return { files: a.files + b.files };
+}
+
+function emptyBucket() {
+  return { tokens: { input: 0, output: 0, cache_create: 0, cache_read: 0 }, models: new Map(), daily: new Map(),
+    dailyTools: new Map(), dayRows: new Map(), events: new Map(), sessions: new Set(), tools: new Set(), first: null, last: null };
+}
+function bucketFromEvents(events) {
+  const b = emptyBucket();
+  for (const e of mergeEvents(events)) {
+    b.events.set(e.id, e);
+    const total = e.input + e.output + e.cache_create + e.cache_read;
+    const date = localDate(e.at);
+    const rowKey = `${date}|${e.tool}|${e.model}`;
+    if (!b.dayRows.has(rowKey)) b.dayRows.set(rowKey, { date, tool: e.tool, model: e.model, input: 0, output: 0, cache_create: 0, cache_read: 0, cost: 0, unpriced: 0 });
+    const row = b.dayRows.get(rowKey);
+    for (const k of ['input', 'output', 'cache_create', 'cache_read', 'cost']) row[k] += e[k] || 0;
+    if (e.unpriced) row.unpriced += total;
+    for (const k of Object.keys(b.tokens)) b.tokens[k] += e[k];
+    if (!b.models.has(e.model)) b.models.set(e.model, zeroTokens());
+    for (const k of Object.keys(zeroTokens())) b.models.get(e.model)[k] += e[k] || 0;
+    b.daily.set(date, (b.daily.get(date) || 0) + total);
+    if (!b.dailyTools.has(date)) b.dailyTools.set(date, { claude: 0, gpt: 0, other: 0 });
+    b.dailyTools.get(date)[e.tool === 'claude-code' ? 'claude' : e.tool === 'codex' ? 'gpt' : 'other'] += total;
+    b.sessions.add(`${e.tool}:${e.session}`); b.tools.add(e.tool);
+    if (!b.first || date < b.first) b.first = date;
+    if (!b.last || date > b.last) b.last = date;
+  }
+  return b;
+}
+export function mergeBuckets(list) {
+  if (list.every((b) => b.events instanceof Map)) return bucketFromEvents(list.flatMap((b) => [...b.events.values()]));
+  // Also accept old buckets used by reports and callers with no response ledger.
+  const out = emptyBucket();
+  for (const b of list) {
+    for (const k of Object.keys(out.tokens)) out.tokens[k] += b.tokens[k];
+    for (const [m, t] of b.models) {
+      if (!out.models.has(m)) out.models.set(m, zeroTokens());
+      for (const k of Object.keys(zeroTokens())) out.models.get(m)[k] += t[k] || 0;
+    }
+    for (const [d, n] of b.daily) out.daily.set(d, (out.daily.get(d) || 0) + n);
+    for (const s of b.sessions) out.sessions.add(s);
+    for (const t of b.tools) out.tools.add(t);
+    if (b.first && (!out.first || b.first < out.first)) out.first = b.first;
+    if (b.last && (!out.last || b.last > out.last)) out.last = b.last;
+  }
+  return out;
+}
+// What leaves this computer: one summed row per day, tool and model. Never single responses.
+export function usageDays(b) {
+  return [...(b.dayRows?.values() || [])]
+    .map((r) => ({ ...r, cost: Math.round(r.cost * 1e6) / 1e6 }))
+    .sort((a, b2) => a.date.localeCompare(b2.date) || a.tool.localeCompare(b2.tool) || a.model.localeCompare(b2.model));
+}
+export function bucketToAi(b, codexScope, priceDate, launchDate) {
+  const total = b.tokens.input + b.tokens.output + b.tokens.cache_create + b.tokens.cache_read;
+  const byModel = [...b.models.entries()]
+    .map(([model, t]) => ({ model, tokens: t.input + t.output + t.cache_create + t.cache_read, t }))
+    .filter((m) => m.tokens > 0)
+    .sort((x, y) => y.tokens - x.tokens);
+  let cost = 0;
+  let unpriced = 0;
+  const unpricedModels = [];
+  for (const m of byModel) {
+    const c = costOf(m.model, m.t);
+    if (c === null) { unpriced += m.tokens; unpricedModels.push(m.model); } else cost += c;
+  }
+  // Tools other than Claude Code and Codex appear in the split only when they used anything.
+  const split = (t) => (t ? { claude: t.claude, gpt: t.gpt, ...(t.other ? { other: t.other } : {}) } : {});
+  const daily = [...b.daily.entries()].sort(([a], [c]) => (a < c ? -1 : 1)).map(([date, tokens]) => ({ date, tokens, ...split(b.dailyTools?.get(date)) }));
+  let before = null;
+  let after = null;
+  if (launchDate) {
+    before = 0; after = 0;
+    for (const d of daily) { if (d.date < launchDate) before += d.tokens; else after += d.tokens; }
+  }
+  return {
+    tools: [...b.tools].sort(),
+    tokens: { ...b.tokens, total },
+    ...(b.dailyTools?.size ? { by_tool: split([...b.dailyTools.values()].reduce((s,d) => ({ claude: s.claude+d.claude, gpt: s.gpt+d.gpt, other: s.other+(d.other || 0) }), { claude: 0, gpt: 0, other: 0 })) } : {}),
+    by_model: byModel.map(({ model, tokens }) => ({ model, tokens })),
+    main_model: byModel[0]?.model || null,
+    daily_tokens: daily,
+    sessions: b.sessions.size,
+    first_session: b.first,
+    last_session: b.last,
+    cost_usd_estimate: Math.round(cost * 100) / 100,
+    cost_is_estimate: true,
+    unpriced_tokens: unpriced,
+    unpriced_models: unpricedModels,
+    price_table_date: priceDate,
+    before_launch_tokens: before,
+    after_launch_tokens: after,
+    codex_scope: codexScope,
+  };
+}