ai-usage-analyzer 0.1.0

package/src/detectors.js

@@ -0,0 +1,300 @@
+// Auto-detect AI coding agent data directories.
+//
+// Strategy:
+//   1. Honor $AI_USAGE_PATHS_JSON if set (JSON map of { toolKey: "/abs/path" })
+//   2. Honor per-tool env var (e.g. $CLAUDE_HOME, $CODEX_HOME, $OPENCODE_HOME)
+//   3. Probe well-known locations per platform (mac/linux) relative to $HOME
+//   4. Return a status for each tool: 'present' | 'absent' | 'disabled'
+//
+// Tools that share the opencode SQLite schema are auto-registered.
+
+import { existsSync, statSync, readdirSync } from 'node:fs';
+import { join, isAbsolute } from 'node:path';
+import { homedir, platform } from 'node:os';
+import { env, exitCode } from 'node:process';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+const HOME = homedir();
+const OS = platform(); // 'darwin' | 'linux' | 'win32'
+
+// macOS Application Support helper
+const APP_SUPPORT = OS === 'darwin'
+  ? join(HOME, 'Library', 'Application Support')
+  : process.env.XDG_DATA_HOME
+    ? join(process.env.XDG_DATA_HOME, '..')  // XDG_DATA_HOME/../ = ~/.local/share
+    : join(HOME, '.local', 'share');
+
+const CONFIG_HOME = process.env.XDG_CONFIG_HOME || join(HOME, '.config');
+
+// Probe = array of candidate paths; first one that exists wins.
+function firstExisting(paths) {
+  for (const p of paths) {
+    if (p && existsSync(p)) return p;
+  }
+  return null;
+}
+
+function isFile(p) {
+  try { return statSync(p).isFile(); } catch { return false; }
+}
+function isDir(p) {
+  try { return statSync(p).isDirectory(); } catch { return false; }
+}
+
+// ---------------------------------------------------------------------------
+// Detector definitions. Each entry returns:
+//   { key, name, kind, status, path, count, details }
+// ---------------------------------------------------------------------------
+
+const DETECTORS = [
+  // -----------------------------------------------------------------------
+  // Claude Code
+  // -----------------------------------------------------------------------
+  {
+    key: 'claude',
+    name: 'Claude Code',
+    kind: 'jsonl',
+    envVar: 'CLAUDE_HOME',
+    candidatePaths: () => {
+      const base = env.CLAUDE_HOME || join(HOME, '.claude');
+      return [
+        join(base, 'transcripts'),
+        join(base, 'projects'),
+      ];
+    },
+    count: (p) => {
+      if (!p) return 0;
+      let n = 0;
+      try {
+        for (const f of readdirSync(p)) {
+          if (f.startsWith('ses_') && f.endsWith('.jsonl')) n++;
+        }
+      } catch {}
+      return n;
+    },
+    hasTokens: false,  // transcripts only contain text, no token counts
+    description: '~/.claude/transcripts/*.jsonl  (no token data stored locally)',
+  },
+
+  // -----------------------------------------------------------------------
+  // Codex
+  // -----------------------------------------------------------------------
+  {
+    key: 'codex',
+    name: 'Codex',
+    kind: 'jsonl-rollout',
+    envVar: 'CODEX_HOME',
+    candidatePaths: () => [
+      env.CODEX_HOME || join(HOME, '.codex', 'sessions'),
+    ],
+    count: (p) => {
+      if (!p) return 0;
+      let n = 0;
+      function walk(dir) {
+        try {
+          for (const e of readdirSync(dir, { withFileTypes: true })) {
+            const full = join(dir, e.name);
+            if (e.isDirectory()) walk(full);
+            else if (e.isFile() && e.name.startsWith('rollout-') && e.name.endsWith('.jsonl')) n++;
+          }
+        } catch {}
+      }
+      walk(p);
+      return n;
+    },
+    hasTokens: true,
+    description: '~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl',
+  },
+
+  // -----------------------------------------------------------------------
+  // OpenCode
+  // -----------------------------------------------------------------------
+  {
+    key: 'opencode',
+    name: 'OpenCode',
+    kind: 'sqlite',
+    envVar: 'OPENCODE_HOME',
+    candidatePaths: () => [
+      env.OPENCODE_HOME
+        ? join(env.OPENCODE_HOME, 'opencode.db')
+        : join(HOME, '.local', 'share', 'opencode', 'opencode.db'),
+    ],
+    count: (p) => {
+      if (!p) return 0;
+      try {
+        const { DatabaseSync } = require('node:sqlite');
+        const db = new DatabaseSync(p, { readOnly: true });
+        return db.prepare('SELECT COUNT(*) AS c FROM session').get().c;
+      } catch { return 0; }
+    },
+    hasTokens: true,
+    description: '~/.local/share/opencode/opencode.db  (tokens + cost)',
+  },
+
+  // -----------------------------------------------------------------------
+  // MimoCode (same schema as OpenCode)
+  // -----------------------------------------------------------------------
+  {
+    key: 'mimocode',
+    name: 'MimoCode',
+    kind: 'sqlite',
+    envVar: 'MIMOCODE_HOME',
+    candidatePaths: () => [
+      env.MIMOCODE_HOME
+        ? join(env.MIMOCODE_HOME, 'mimocode.db')
+        : join(HOME, '.local', 'share', 'mimocode', 'mimocode.db'),
+    ],
+    count: (p) => {
+      if (!p) return 0;
+      try {
+        const { DatabaseSync } = require('node:sqlite');
+        const db = new DatabaseSync(p, { readOnly: true });
+        return db.prepare('SELECT COUNT(*) AS c FROM session').get().c;
+      } catch { return 0; }
+    },
+    hasTokens: true,
+    description: '~/.local/share/mimocode/mimocode.db  (tokens + cost)',
+  },
+
+  // -----------------------------------------------------------------------
+  // GitHub Copilot CLI
+  // -----------------------------------------------------------------------
+  {
+    key: 'copilot',
+    name: 'GitHub Copilot',
+    kind: 'jsonl-events',
+    envVar: 'COPILOT_HOME',
+    candidatePaths: () => {
+      const base = env.COPILOT_HOME || join(HOME, '.copilot');
+      return [
+        join(base, 'session-state'),
+        base,
+      ];
+    },
+    count: (p) => {
+      if (!p) return 0;
+      let n = 0;
+      function walk(dir) {
+        try {
+          for (const e of readdirSync(dir, { withFileTypes: true })) {
+            const full = join(dir, e.name);
+            if (e.isDirectory()) walk(full);
+            else if (e.isFile() && e.name.endsWith('.jsonl')) n++;
+          }
+        } catch {}
+      }
+      walk(p);
+      return n;
+    },
+    hasTokens: false,
+    description: '~/.copilot/session-state/*/events.jsonl  (no token data)',
+  },
+
+  // -----------------------------------------------------------------------
+  // Antigravity (VS Code variant) - mostly cache; no token data
+  // -----------------------------------------------------------------------
+  {
+    key: 'antigravity',
+    name: 'Antigravity',
+    kind: 'dir',
+    envVar: 'ANTIGRAVITY_HOME',
+    candidatePaths: () => {
+      const base = env.ANTIGRAVITY_HOME || join(APP_SUPPORT, 'Antigravity');
+      return [
+        base,
+        join(HOME, '.antigravity'),
+      ];
+    },
+    count: (p) => {
+      if (!p) return 0;
+      let n = 0;
+      try {
+        for (const e of readdirSync(p)) {
+          const full = join(p, e);
+          if (statSync(full).isDirectory()) n++;
+        }
+      } catch {}
+      return n;
+    },
+    hasTokens: false,
+    description: '~/Library/Application Support/Antigravity  (no token data)',
+  },
+
+  // -----------------------------------------------------------------------
+  // Gemini CLI
+  // -----------------------------------------------------------------------
+  {
+    key: 'gemini',
+    name: 'Gemini CLI',
+    kind: 'protobuf',
+    envVar: 'GEMINI_HOME',
+    candidatePaths: () => {
+      const base = env.GEMINI_HOME || join(HOME, '.gemini');
+      return [
+        join(base, 'antigravity', 'conversations'),
+        join(base, 'conversations'),
+      ];
+    },
+    count: (p) => {
+      if (!p) return 0;
+      let n = 0;
+      try {
+        for (const f of readdirSync(p)) {
+          if (f.endsWith('.pb')) n++;
+        }
+      } catch {}
+      return n;
+    },
+    hasTokens: false,
+    description: '~/.gemini/antigravity/conversations/*.pb  (binary, no token data)',
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Public: run all detectors
+// ---------------------------------------------------------------------------
+
+export function detectAll(opts = {}) {
+  const override = opts.override || (env.AI_USAGE_PATHS_JSON
+    ? safeParseJSON(env.AI_USAGE_PATHS_JSON)
+    : {});
+
+  const results = [];
+  for (const def of DETECTORS) {
+    let candidatePaths = def.candidatePaths();
+
+    // Apply override if user supplied one
+    if (override[def.key]) {
+      const ov = override[def.key];
+      if (typeof ov === 'string' && isAbsolute(ov)) {
+        candidatePaths = [ov, ...candidatePaths];
+      }
+    }
+
+    const path = firstExisting(candidatePaths);
+    const status = path ? 'present' : 'absent';
+    const count = path ? def.count(path) : 0;
+    results.push({
+      key: def.key,
+      name: def.name,
+      kind: def.kind,
+      status,
+      path,
+      count,
+      hasTokens: def.hasTokens,
+      description: def.description,
+    });
+  }
+  return results;
+}
+
+function safeParseJSON(s) {
+  try { return JSON.parse(s); } catch { return {}; }
+}
+
+// ---------------------------------------------------------------------------
+// Public: just keys in order (for stable UI columns)
+// ---------------------------------------------------------------------------
+
+export const TOOL_ORDER = DETECTORS.map(d => d.key);

package/src/loaders.js

@@ -0,0 +1,249 @@
+// Loaders: turn detector results into a unified stream of session records.
+//
+// Unified record shape:
+//   {
+//     tool:        'opencode' | 'codex' | 'mimocode' | string,
+//     sessionId:   string,
+//     project:     string,          // working directory or '(unknown)'
+//     title:       string,
+//     week:        'YYYY-Www',      // ISO week, UTC
+//     month:       'YYYY-MM',
+//     ts:          number,          // session start, ms since epoch
+//     tokensInput, tokensOutput, tokensCacheRead, tokensCacheWrite, tokensReasoning,
+//     tokensTotal: number,
+//     cost:        number,          // USD
+//     model:       string,
+//   }
+
+import { readdirSync, readFileSync, statSync, openSync, readSync, closeSync } from 'node:fs';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { createInterface } from 'node:readline';
+import { createReadStream } from 'node:fs';
+
+// ---------------------------------------------------------------------------
+// Date helpers
+// ---------------------------------------------------------------------------
+
+function isoWeekKey(ts) {
+  const d = new Date(ts);
+  // ISO week: Thu in current week decides the year
+  const target = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+  const dayNum = (target.getUTCDay() + 6) % 7; // Mon=0..Sun=6
+  target.setUTCDate(target.getUTCDate() - dayNum + 3); // Thu
+  const firstThu = new Date(Date.UTC(target.getUTCFullYear(), 0, 4));
+  const week = 1 + Math.round(((target - firstThu) / 86400000 - 3 + ((firstThu.getUTCDay() + 6) % 7)) / 7);
+  return `${target.getUTCFullYear()}-W${String(week).padStart(2, '0')}`;
+}
+
+function monthKey(ts) {
+  const d = new Date(ts);
+  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}`;
+}
+
+function parseIsoMs(s) {
+  if (!s) return null;
+  const t = Date.parse(s);
+  return Number.isFinite(t) ? t : null;
+}
+
+function compactHome(p) {
+  if (!p) return '(unknown)';
+  const home = process.env.HOME || '';
+  return p.startsWith(home) ? '~' + p.slice(home.length) : p;
+}
+
+// ---------------------------------------------------------------------------
+// SQLite loader (OpenCode + MimoCode share schema)
+// ---------------------------------------------------------------------------
+
+function loadOpencodeStyleSqlite(dbPath, toolKey) {
+  let db;
+  try {
+    db = new DatabaseSync(dbPath, { readOnly: true });
+  } catch (e) {
+    return { records: [], error: `cannot open ${dbPath}: ${e.message}` };
+  }
+
+  // Introspect session table for token columns (MimoCode schema is a subset)
+  const cols = db.prepare(`PRAGMA table_info(session)`).all();
+  const colSet = new Set(cols.map(c => c.name));
+  const hasTokens = colSet.has('tokens_input')
+                 && colSet.has('tokens_output')
+                 && colSet.has('tokens_cache_read')
+                 && colSet.has('tokens_cache_write');
+
+  if (!hasTokens) {
+    db.close();
+    return { records: [], info: 'session table has no token columns' };
+  }
+
+  const rows = db.prepare(`
+    SELECT id, directory, title, time_created,
+           tokens_input, tokens_output, tokens_reasoning,
+           tokens_cache_read, tokens_cache_write, cost, model
+    FROM session
+    WHERE time_archived IS NULL
+  `).all();
+  db.close();
+
+  const records = [];
+  for (const r of rows) {
+    const tot = (r.tokens_input || 0) + (r.tokens_output || 0)
+              + (r.tokens_reasoning || 0) + (r.tokens_cache_read || 0)
+              + (r.tokens_cache_write || 0);
+    if (tot === 0) continue;
+    records.push({
+      tool: toolKey,
+      sessionId: r.id,
+      project: compactHome(r.directory),
+      title: r.title || '',
+      week: isoWeekKey(r.time_created),
+      month: monthKey(r.time_created),
+      ts: r.time_created,
+      tokensInput: r.tokens_input || 0,
+      tokensOutput: r.tokens_output || 0,
+      tokensCacheRead: r.tokens_cache_read || 0,
+      tokensCacheWrite: r.tokens_cache_write || 0,
+      tokensReasoning: r.tokens_reasoning || 0,
+      tokensTotal: tot,
+      cost: r.cost || 0,
+      model: r.model || '',
+    });
+  }
+  return { records };
+}
+
+// ---------------------------------------------------------------------------
+// Codex JSONL rollout loader
+// ---------------------------------------------------------------------------
+
+async function loadCodexRollouts(rootDir) {
+  const records = [];
+  const errors = [];
+  const files = walkJsonl(rootDir, 'rollout-');
+
+  for (const f of files) {
+    try {
+      const rec = await parseCodexRollout(f);
+      if (rec) records.push(rec);
+    } catch (e) {
+      errors.push(`${f}: ${e.message}`);
+    }
+  }
+  return { records, errors };
+}
+
+async function parseCodexRollout(path) {
+  // Use a streaming reader to avoid loading huge files into memory.
+  // The 'token_count' event accumulates usage; we take the LAST one (final snapshot).
+  let sessionMeta = null;
+  let lastUsage = null;
+  let lastModel = '';
+
+  const stream = createReadStream(path, { encoding: 'utf8' });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line) continue;
+    let ev;
+    try { ev = JSON.parse(line); } catch { continue; }
+    const t = ev.type;
+    const p = ev.payload || {};
+    if (t === 'session_meta') {
+      sessionMeta = { ts: ev.timestamp, cwd: p.cwd || p.CWD || '' };
+    } else if (t === 'event_msg' && p.type === 'token_count') {
+      const info = p.info || {};
+      const u = info.total_token_usage;
+      if (u) lastUsage = u;
+      const m = info.model || p.model;
+      if (m) lastModel = m;
+    }
+  }
+  if (!sessionMeta || !lastUsage) return null;
+
+  const ts = parseIsoMs(sessionMeta.ts);
+  if (!ts) return null;
+
+  const tokensInput = lastUsage.input_tokens || 0;
+  const tokensOutput = lastUsage.output_tokens || 0;
+  const tokensCacheRead = lastUsage.cached_input_tokens || 0;
+  const tokensReasoning = lastUsage.reasoning_output_tokens || 0;
+  const tot = tokensInput + tokensOutput + tokensCacheRead + tokensReasoning;
+  if (tot === 0) return null;
+
+  return {
+    tool: 'codex',
+    sessionId: path.split('-').pop().replace('.jsonl', ''),
+    project: compactHome(sessionMeta.cwd),
+    title: '',  // not available in codex rollouts
+    week: isoWeekKey(ts),
+    month: monthKey(ts),
+    ts,
+    tokensInput,
+    tokensOutput,
+    tokensCacheRead,
+    tokensCacheWrite: 0,  // codex doesn't expose cache_write separately
+    tokensReasoning,
+    tokensTotal: tot,
+    cost: 0,
+    model: lastModel,
+  };
+}
+
+function walkJsonl(root, prefix) {
+  const out = [];
+  function walk(dir) {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) walk(full);
+      else if (e.isFile() && e.name.startsWith(prefix) && e.name.endsWith('.jsonl')) {
+        out.push(full);
+      }
+    }
+  }
+  walk(root);
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Public: load all session records for given detectors
+// ---------------------------------------------------------------------------
+
+export async function loadAll(detections) {
+  const all = [];
+  const errors = [];
+
+  for (const d of detections) {
+    if (d.status !== 'present') continue;
+    if (d.key === 'opencode' || d.key === 'mimocode') {
+      const r = loadOpencodeStyleSqlite(d.path, d.key);
+      all.push(...r.records);
+      if (r.error) errors.push(`${d.name}: ${r.error}`);
+      if (r.info) errors.push(`${d.name}: ${r.info}`);
+    } else if (d.key === 'codex') {
+      const r = await loadCodexRollouts(d.path);
+      all.push(...r.records);
+      if (r.errors) errors.push(...r.errors);
+    }
+    // For other tools (claude, copilot, antigravity, gemini), we only have
+    // presence info — no token data to load.
+  }
+  return { records: all, errors };
+}
+
+// ---------------------------------------------------------------------------
+// Public: date range helper
+// ---------------------------------------------------------------------------
+
+export function dateRange(records) {
+  if (records.length === 0) return [null, null];
+  let min = Infinity, max = -Infinity;
+  for (const r of records) {
+    if (r.ts < min) min = r.ts;
+    if (r.ts > max) max = r.ts;
+  }
+  const fmt = (ms) => new Date(ms).toISOString().slice(0, 10);
+  return [fmt(min), fmt(max)];
+}