usagelens 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aayush Jain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# usagelens
+
+A local dashboard for your AI coding usage — unified across **Claude Code**, **Codex CLI**, and **Cursor**. It reads the usage data those tools already store on your machine, and serves an interactive dashboard on `localhost`. Read-only, offline, zero runtime dependencies.
+
+```bash
+npx usagelens
+```
+
+That's it — it scans your local data, starts a server on <http://localhost:4319>, and opens your browser.
+
+## What you get
+
+- **Tokens, est. cost, sessions, cache hit-rate, streak** — with deltas vs the prior period
+- **Daily activity** bar chart and a **when-you-work** hour × weekday heatmap (hover for details)
+- **Tool breakdown** (Claude / Codex / Cursor) and **model mix** with per-model estimated cost
+- **Top projects** — which repos consume the most AI
+- **Session shape** (quick / standard / deep / marathon) with averages
+- **Cache effectiveness** trend and estimated savings
+- **Code authorship** (from Cursor) — AI-authored vs human lines over time
+
+## Options
+
+```bash
+usagelens                # start on :4319 and open the browser
+usagelens --port 8080    # custom port
+usagelens --no-open      # don't auto-open the browser
+```
+
+## Data sources
+
+Read-only, from your machine:
+
+- `~/.claude/projects/**/*.jsonl` — Claude Code (tokens, models, projects, cache)
+- `~/.codex/sessions/**` — Codex CLI (per-turn token usage)
+- `~/.cursor/ai-tracking/ai-code-tracking.db` — Cursor (AI vs human code authorship)
+
+Tools detected without usable local usage data (Gemini, GitHub Copilot, Ollama) are shown as detected-without-metrics rather than fabricated numbers.
+
+## Notes
+
+- **Cost is estimated** — list price × tokens ("API-equivalent value"), not a bill. If you're on a subscription, treat it as a proxy for usage.
+- Nothing is written to your tool directories, and nothing leaves your machine.
+- Requires **Node ≥ 22.5** (uses the built-in `node:sqlite`).
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "usagelens",
+  "version": "0.1.0",
+  "description": "Local dashboard for your AI coding usage across Claude Code, Codex CLI, and Cursor. Reads your machine's local data and serves an interactive dashboard on localhost. Read-only, offline, zero runtime dependencies.",
+  "type": "module",
+  "bin": {
+    "usagelens": "src/server.mjs"
+  },
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node src/server.mjs"
+  },
+  "keywords": [
+    "ai",
+    "usage",
+    "dashboard",
+    "claude",
+    "claude-code",
+    "codex",
+    "cursor",
+    "tokens",
+    "cost",
+    "analytics",
+    "cli"
+  ],
+  "author": "Aayush Jain",
+  "license": "MIT"
+}

package/src/lib/adapters.mjs

@@ -0,0 +1,137 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { costOf } from './pricing.mjs';
+
+const HOME = homedir();
+
+function walk(dir) {
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    let p = join(dir, name), st;
+    try { st = statSync(p); } catch { continue; }
+    if (st.isDirectory()) out.push(...walk(p));
+    else if (name.endsWith('.jsonl')) out.push(p);
+  }
+  return out;
+}
+
+// ---------- Claude ----------
+export function loadClaude() {
+  const root = join(HOME, '.claude', 'projects');
+  if (!existsSync(root)) return { events: [], commits: [], status: { tool: 'claude', available: false, note: 'no ~/.claude/projects' } };
+  const events = [];
+  for (const f of walk(root)) {
+    let text;
+    try { text = readFileSync(f, 'utf8'); } catch { continue; }
+    for (const line of text.split('\n')) {
+      if (!line.trim()) continue;
+      let row;
+      try { row = JSON.parse(line); } catch { continue; }
+      if (row.type !== 'assistant') continue;
+      const m = row.message, u = m?.usage;
+      if (!u || !m?.model) continue;
+      const cwd = row.cwd ?? 'unknown';
+      const t = {
+        inputTokens: u.input_tokens ?? 0,
+        outputTokens: u.output_tokens ?? 0,
+        cacheReadTokens: u.cache_read_input_tokens ?? 0,
+        cacheCreateTokens: u.cache_creation_input_tokens ?? 0,
+      };
+      events.push({
+        tool: 'claude', model: m.model, project: basename(cwd), projectPath: cwd,
+        gitBranch: row.gitBranch || undefined, timestamp: row.timestamp,
+        sessionId: row.sessionId ?? basename(f, '.jsonl'), ...t, costUsd: costOf(m.model, t),
+      });
+    }
+  }
+  const last = events.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined);
+  return { events, commits: [], status: { tool: 'claude', available: true, lastActivity: last, count: events.length } };
+}
+
+// ---------- Codex ----------
+export function loadCodex() {
+  const base = join(HOME, '.codex');
+  const files = ['sessions', 'archived_sessions'].flatMap((r) => walk(join(base, r)));
+  if (files.length === 0) return { events: [], commits: [], status: { tool: 'codex', available: false, note: 'no ~/.codex sessions' } };
+  const events = [];
+  for (const f of files) {
+    let text;
+    try { text = readFileSync(f, 'utf8'); } catch { continue; }
+    let model = 'gpt-5', cwd = 'unknown', sessionId = basename(f, '.jsonl');
+    for (const line of text.split('\n')) {
+      if (!line.trim()) continue;
+      let row;
+      try { row = JSON.parse(line); } catch { continue; }
+      const p = row.payload ?? row;
+      // Codex sessions nest the real event type inside event_msg/response_item payloads.
+      const kind = (row.type === 'event_msg' || row.type === 'response_item') ? (p.type ?? row.type) : row.type;
+      if (kind === 'session_meta') { cwd = p.cwd ?? cwd; sessionId = p.id ?? sessionId; }
+      else if (kind === 'turn_context') { if (p.model) model = p.model; if (p.cwd) cwd = p.cwd; }
+      else if (kind === 'token_count') {
+        const last = p.info?.last_token_usage;
+        if (!last) continue;
+        const cached = last.cached_input_tokens ?? 0;
+        const t = {
+          inputTokens: Math.max(0, (last.input_tokens ?? 0) - cached),
+          outputTokens: last.output_tokens ?? 0,
+          cacheReadTokens: cached, cacheCreateTokens: 0,
+        };
+        if (t.inputTokens + t.outputTokens + t.cacheReadTokens === 0) continue;
+        events.push({
+          tool: 'codex', model, project: basename(cwd), projectPath: cwd,
+          timestamp: row.timestamp, sessionId, ...t, costUsd: costOf(model, t),
+        });
+      }
+    }
+  }
+  const last = events.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined);
+  return { events, commits: [], status: { tool: 'codex', available: true, lastActivity: last, count: events.length } };
+}
+
+// ---------- Cursor ----------
+export function loadCursor() {
+  const path = join(HOME, '.cursor', 'ai-tracking', 'ai-code-tracking.db');
+  if (!existsSync(path)) return { events: [], commits: [], status: { tool: 'cursor', available: false, note: 'no cursor ai-tracking db' } };
+  const commits = [];
+  try {
+    const { DatabaseSync } = require('node:sqlite');
+    const db = new DatabaseSync(path, { readOnly: true });
+    const rows = db.prepare(
+      'SELECT commitHash, branchName, scoredAt, linesAdded, v1AiPercentage, v2AiPercentage FROM scored_commits'
+    ).all();
+    for (const r of rows) {
+      const total = r.linesAdded ?? 0;
+      const aiPct = Number(r.v2AiPercentage ?? r.v1AiPercentage ?? 0) || 0;
+      const aiLines = Math.round((total * aiPct) / 100);
+      commits.push({
+        tool: 'cursor', timestamp: new Date(Number(r.scoredAt)).toISOString(),
+        commitHash: r.commitHash, branchName: r.branchName ?? 'unknown',
+        totalLines: total, aiLines, humanLines: Math.max(0, total - aiLines), aiPct,
+      });
+    }
+    db.close();
+  } catch (e) {
+    return { events: [], commits: [], status: { tool: 'cursor', available: false, note: 'cursor db unreadable: ' + e.message } };
+  }
+  const last = commits.reduce((a, c) => (!a || c.timestamp > a ? c.timestamp : a), undefined);
+  return { events: [], commits, status: { tool: 'cursor', available: true, lastActivity: last, count: commits.length } };
+}
+
+// require shim for ESM (node:sqlite import)
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+export function loadAll() {
+  const events = [], commits = [], statuses = [];
+  for (const fn of [loadClaude, loadCodex, loadCursor]) {
+    try { const r = fn(); events.push(...r.events); commits.push(...r.commits); statuses.push(r.status); }
+    catch (e) { statuses.push({ tool: fn.name.replace('load', '').toLowerCase(), available: false, note: e.message }); }
+  }
+  // detect-only tools with no parseable usage
+  for (const [tool, rel] of [['gemini', '.gemini'], ['copilot', '.copilot'], ['ollama', '.ollama']]) {
+    if (existsSync(join(HOME, rel))) statuses.push({ tool, available: false, note: 'detected, no usage metrics exposed' });
+  }
+  return { events, commits, statuses };
+}

package/src/lib/aggregate.mjs

@@ -0,0 +1,159 @@
+import { savingsOf } from './pricing.mjs';
+
+const MS_DAY = 86_400_000;
+const DAYS = { '7d': 7, '30d': 30, '90d': 90 };
+
+export function rangeWindow(range, now) { return { start: new Date(now.getTime() - DAYS[range] * MS_DAY), end: now }; }
+export function priorWindow(range, now) { const c = rangeWindow(range, now); return { start: new Date(c.start.getTime() - DAYS[range] * MS_DAY), end: c.start }; }
+const inWin = (iso, w) => { const t = new Date(iso).getTime(); return t >= w.start.getTime() && t <= w.end.getTime(); };
+
+export function localDayKey(iso) {
+  const d = typeof iso === 'string' ? new Date(iso) : iso;
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+function eachDay(start, end) {
+  const out = [], cur = new Date(start.getFullYear(), start.getMonth(), start.getDate());
+  const last = new Date(end.getFullYear(), end.getMonth(), end.getDate());
+  while (cur <= last) { out.push(localDayKey(cur)); cur.setDate(cur.getDate() + 1); }
+  return out;
+}
+const tokensOf = (e) => e.inputTokens + e.outputTokens + e.cacheReadTokens + e.cacheCreateTokens;
+const pct = (cur, prior) => (prior === 0 ? (cur === 0 ? 0 : 100) : ((cur - prior) / prior) * 100);
+
+function streaks(days) {
+  if (days.length === 0) return { current: 0, longest: 0 };
+  const s = [...new Set(days)].sort();
+  let longest = 1, run = 1;
+  for (let i = 1; i < s.length; i++) {
+    const gap = Math.round((new Date(s[i] + 'T00:00:00') - new Date(s[i - 1] + 'T00:00:00')) / MS_DAY);
+    run = gap === 1 ? run + 1 : 1;
+    longest = Math.max(longest, run);
+  }
+  return { current: run, longest };
+}
+
+function summarize(events, prior) {
+  const sum = (arr, f) => arr.reduce((a, e) => a + f(e), 0);
+  const byDay = new Map();
+  for (const e of events) { const k = localDayKey(e.timestamp); byDay.set(k, (byDay.get(k) ?? 0) + tokensOf(e)); }
+  let peakDay = { day: '', tokens: 0 };
+  for (const [day, tokens] of byDay) if (tokens > peakDay.tokens) peakDay = { day, tokens };
+  const input = sum(events, (e) => e.inputTokens);
+  const cacheRead = sum(events, (e) => e.cacheReadTokens);
+  const cacheCreate = sum(events, (e) => e.cacheCreateTokens);
+  const denom = cacheRead + cacheCreate + input;
+  const st = streaks([...byDay.keys()]);
+  const curTokens = sum(events, tokensOf), curCost = sum(events, (e) => e.costUsd);
+  return {
+    totalTokens: curTokens, inputTokens: input, outputTokens: sum(events, (e) => e.outputTokens),
+    cacheReadTokens: cacheRead, cacheCreateTokens: cacheCreate, costUsd: curCost,
+    sessions: new Set(events.map((e) => e.sessionId)).size, messages: events.length,
+    activeDays: byDay.size, currentStreak: st.current, longestStreak: st.longest, peakDay,
+    cacheHitRate: denom === 0 ? 0 : cacheRead / denom,
+    cacheSavingsUsd: events.reduce((a, e) => a + savingsOf(e.model, e.cacheReadTokens), 0),
+    deltas: {
+      tokensPct: pct(curTokens, sum(prior, tokensOf)),
+      costPct: pct(curCost, sum(prior, (e) => e.costUsd)),
+      sessionsAbs: new Set(events.map((e) => e.sessionId)).size - new Set(prior.map((e) => e.sessionId)).size,
+    },
+  };
+}
+
+function group(events, keyFn, cap) {
+  const map = new Map(); let total = 0;
+  for (const e of events) {
+    const k = keyFn(e), t = tokensOf(e); total += t;
+    const cur = map.get(k) ?? { tokens: 0, costUsd: 0, sessions: new Set() };
+    cur.tokens += t; cur.costUsd += e.costUsd; cur.sessions.add(e.sessionId); map.set(k, cur);
+  }
+  const slices = [...map.entries()]
+    .map(([key, v]) => ({ key, tokens: v.tokens, costUsd: v.costUsd, sessions: v.sessions.size, sharePct: total ? (v.tokens / total) * 100 : 0 }))
+    .sort((a, b) => b.tokens - a.tokens);
+  return cap ? slices.slice(0, cap) : slices;
+}
+
+function dailySeries(events, w) {
+  const agg = new Map();
+  for (const e of events) {
+    const k = localDayKey(e.timestamp);
+    const cur = agg.get(k) ?? { tokens: 0, costUsd: 0, read: 0, base: 0 };
+    cur.tokens += tokensOf(e); cur.costUsd += e.costUsd;
+    cur.read += e.cacheReadTokens; cur.base += e.cacheReadTokens + e.cacheCreateTokens + e.inputTokens;
+    agg.set(k, cur);
+  }
+  return eachDay(w.start, w.end).map((day) => {
+    const a = agg.get(day);
+    return { day, tokens: a?.tokens ?? 0, costUsd: a?.costUsd ?? 0, cacheHitRate: a && a.base ? a.read / a.base : 0 };
+  });
+}
+
+function heatmap(events) {
+  const cells = Array.from({ length: 7 }, () => Array.from({ length: 24 }, () => ({ count: 0, tokens: 0, cost: 0, sessions: new Set() })));
+  for (const e of events) {
+    const d = new Date(e.timestamp);
+    const c = cells[(d.getDay() + 6) % 7][d.getHours()];
+    c.count += 1; c.tokens += tokensOf(e); c.cost += e.costUsd; c.sessions.add(e.sessionId);
+  }
+  return cells.map((row) => row.map((c) => ({ count: c.count, tokens: c.tokens, cost: c.cost, sessions: c.sessions.size })));
+}
+
+const BUCKETS = [{ label: 'Quick', max: 1e4 }, { label: 'Standard', max: 1e5 }, { label: 'Deep', max: 1e6 }, { label: 'Marathon', max: Infinity }];
+function sessionShape(events) {
+  const sessions = new Map();
+  for (const e of events) {
+    const t = new Date(e.timestamp).getTime();
+    const cur = sessions.get(e.sessionId) ?? { tokens: 0, msgs: 0, first: t, last: t };
+    cur.tokens += tokensOf(e); cur.msgs += 1; cur.first = Math.min(cur.first, t); cur.last = Math.max(cur.last, t);
+    sessions.set(e.sessionId, cur);
+  }
+  const list = [...sessions.values()];
+  const counts = BUCKETS.map((b) => ({ label: b.label, count: 0, pct: 0 }));
+  for (const s of list) { const i = BUCKETS.findIndex((b) => s.tokens < b.max); counts[i === -1 ? 3 : i].count += 1; }
+  for (const c of counts) c.pct = list.length ? (c.count / list.length) * 100 : 0;
+  return {
+    buckets: counts,
+    avgMessages: list.length ? list.reduce((a, s) => a + s.msgs, 0) / list.length : 0,
+    avgDurationMs: list.length ? list.reduce((a, s) => a + (s.last - s.first), 0) / list.length : 0,
+    medianTokens: median(list.map((s) => s.tokens)),
+  };
+}
+function median(arr) { if (!arr.length) return 0; const s = [...arr].sort((a, b) => a - b); const m = Math.floor(s.length / 2); return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2; }
+
+function isoWeek(iso) {
+  const d = new Date(iso), day = (d.getDay() + 6) % 7;
+  const thu = new Date(d.getFullYear(), d.getMonth(), d.getDate() - day + 3);
+  const firstThu = new Date(thu.getFullYear(), 0, 4);
+  const week = 1 + Math.round(((thu - firstThu) / MS_DAY - 3 + ((firstThu.getDay() + 6) % 7)) / 7);
+  return `${thu.getFullYear()}-W${String(week).padStart(2, '0')}`;
+}
+function authorship(commits) {
+  const weekly = new Map(); let aiLines = 0, humanLines = 0;
+  for (const c of commits) {
+    aiLines += c.aiLines; humanLines += c.humanLines;
+    const wk = isoWeek(c.timestamp);
+    const cur = weekly.get(wk) ?? { aiLines: 0, humanLines: 0 };
+    cur.aiLines += c.aiLines; cur.humanLines += c.humanLines; weekly.set(wk, cur);
+  }
+  const total = aiLines + humanLines;
+  return {
+    totalCommits: commits.length, aiLines, humanLines, aiPct: total ? (aiLines / total) * 100 : 0,
+    weekly: [...weekly.entries()].map(([week, v]) => ({ week, ...v, aiPct: v.aiLines + v.humanLines ? (v.aiLines / (v.aiLines + v.humanLines)) * 100 : 0 })).sort((a, b) => a.week.localeCompare(b.week)),
+  };
+}
+
+export function buildPayload(ds, range, now) {
+  const win = rangeWindow(range, now), prior = priorWindow(range, now);
+  const cur = ds.events.filter((e) => inWin(e.timestamp, win));
+  const prev = ds.events.filter((e) => inWin(e.timestamp, prior));
+  const commits = ds.commits.filter((c) => inWin(c.timestamp, win));
+  return {
+    summary: summarize(cur, prev),
+    breakdowns: { byTool: group(cur, (e) => e.tool), byModel: group(cur, (e) => e.model), byProject: group(cur, (e) => e.project, 12) },
+    series: { daily: dailySeries(cur, win) },
+    heatmap: heatmap(cur),
+    sessions: sessionShape(cur),
+    authorship: authorship(commits),
+    tools: ds.statuses,
+    meta: { range, generatedAt: now.toISOString(), lastActivity: cur.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined) },
+  };
+}

package/src/lib/pricing.mjs

@@ -0,0 +1,28 @@
+// Per-Mtok USD list prices. ESTIMATED, API-equivalent. Not a bill.
+const TABLE = [
+  { m: /opus/i,               p: { input: 15,   output: 75, cacheWrite: 18.75, cacheRead: 1.5 } },
+  { m: /sonnet/i,             p: { input: 3,    output: 15, cacheWrite: 3.75,  cacheRead: 0.3 } },
+  { m: /haiku/i,              p: { input: 0.8,  output: 4,  cacheWrite: 1.0,   cacheRead: 0.08 } },
+  { m: /fable/i,              p: { input: 3,    output: 15, cacheWrite: 3.75,  cacheRead: 0.3 } },
+  { m: /gpt-5|codex|o[134]/i, p: { input: 1.25, output: 10, cacheWrite: 1.25,  cacheRead: 0.125 } },
+];
+const DEFAULT = { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 };
+
+export function priceFor(model) {
+  return (TABLE.find((r) => r.m.test(model || ''))?.p) ?? DEFAULT;
+}
+
+export function costOf(model, t) {
+  const p = priceFor(model);
+  return (
+    t.inputTokens * p.input +
+    t.outputTokens * p.output +
+    t.cacheCreateTokens * p.cacheWrite +
+    t.cacheReadTokens * p.cacheRead
+  ) / 1_000_000;
+}
+
+export function savingsOf(model, cacheReadTokens) {
+  const p = priceFor(model);
+  return (cacheReadTokens * (p.input - p.cacheRead)) / 1_000_000;
+}

package/src/public/app.js

@@ -0,0 +1,240 @@
+'use strict';
+const $ = (s) => document.querySelector(s);
+const el = (t, a = {}, kids = []) => {
+  const n = document.createElement(t);
+  for (const k in a) { if (k === 'style') n.style.cssText = a[k]; else if (k === 'html') n.innerHTML = a[k]; else n.setAttribute(k, a[k]); }
+  for (const c of [].concat(kids)) n.append(c && c.nodeType ? c : document.createTextNode(c ?? ''));
+  return n;
+};
+// ---- floating tooltip (shared by every chart) ----
+const tipEl = el('div', { style: 'position:fixed;z-index:80;pointer-events:none;background:#12151d;color:#fff;font-family:var(--mono);font-size:11px;line-height:1.55;padding:9px 11px;border-radius:9px;box-shadow:0 8px 30px rgba(0,0,0,.22);opacity:0;transition:opacity .09s;max-width:260px;white-space:nowrap' });
+document.body.append(tipEl);
+function moveTip(x, y) {
+  const pad = 14, r = tipEl.getBoundingClientRect();
+  let left = x + pad, top = y + pad;
+  if (left + r.width > innerWidth - 8) left = x - r.width - pad;
+  if (top + r.height > innerHeight - 8) top = y - r.height - pad;
+  tipEl.style.left = Math.max(8, left) + 'px'; tipEl.style.top = Math.max(8, top) + 'px';
+}
+function bindTip(node, htmlFn) {
+  node.style.cursor = 'default';
+  node.addEventListener('mousemove', (e) => { tipEl.innerHTML = htmlFn(); tipEl.style.opacity = '1'; moveTip(e.clientX, e.clientY); });
+  node.addEventListener('mouseleave', () => { tipEl.style.opacity = '0'; });
+  return node;
+}
+// escape any data-derived string before it enters an innerHTML/html: template
+const esc = (s) => String(s ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+const SERIES = ['var(--c0)', 'var(--c1)', 'var(--c2)', 'var(--c3)', 'var(--c4)', 'var(--c5)'];
+const TOOLCOLOR = { claude: 'var(--c0)', codex: 'var(--c1)', cursor: 'var(--c2)' };
+
+const fmtTok = (n) => n >= 1e9 ? (n / 1e9).toFixed(2) + 'B' : n >= 1e6 ? (n / 1e6).toFixed(1) + 'M' : n >= 1e3 ? (n / 1e3).toFixed(1) + 'K' : String(Math.round(n));
+const fmtUsd = (n) => n >= 1000 ? '$' + (n / 1000).toFixed(1) + 'K' : n >= 1 ? '$' + n.toFixed(2) : '$' + n.toFixed(3);
+const fmtInt = (n) => new Intl.NumberFormat('en-US').format(Math.round(n));
+const fmtPct = (n) => (n >= 0 ? '+' : '') + n.toFixed(n <= -100 || n >= 1000 ? 0 : 1) + '%';
+const ago = (iso) => { if (!iso) return '—'; const d = (Date.now() - new Date(iso)) / 86400000; return d < 1 ? 'today' : d < 2 ? '1d ago' : Math.floor(d) + 'd ago'; };
+
+function card(label, val, opts = {}) {
+  const kids = [el('div', { class: 'clabel' }, label), el('div', { class: 'cval' }, val)];
+  if (opts.delta !== undefined) {
+    const up = opts.delta >= 0;
+    kids.push(el('div', { class: 'delta ' + (up ? 'up' : 'down') }, (up ? '▲ ' : '▼ ') + fmtPct(opts.delta)));
+  }
+  if (opts.sub) kids.push(el('div', { class: 'csub' }, opts.sub));
+  return el('div', { class: 'card' }, kids);
+}
+
+function barRow(label, right, pctWidth, color) {
+  return el('div', { class: 'barRow' }, [
+    el('div', { class: 'top' }, [el('span', {}, label), el('span', { class: 'r' }, right)]),
+    el('div', { class: 'track' }, [el('div', { class: 'fill', style: `width:${Math.max(1, pctWidth)}%;background:${color}` })]),
+  ]);
+}
+
+// SVG bar chart (daily tokens)
+function barChart(data, h = 170) {
+  const w = 1000, pad = 4, max = Math.max(1, ...data.map((d) => d.tokens));
+  const bw = w / data.length;
+  const svg = mk('svg', { viewBox: `0 0 ${w} ${h}`, preserveAspectRatio: 'none' });
+  svg.style.height = h + 'px'; svg.style.width = '100%';
+  data.forEach((d, i) => {
+    const bh = (d.tokens / max) * (h - 22);
+    const x = i * bw, y = (h - 20) - bh;
+    const color = d.tokens > 0 ? 'var(--accent)' : 'var(--line)';
+    const r = mk('rect', { x: x + pad / 2, y: d.tokens > 0 ? y : h - 21, width: Math.max(1, bw - pad), height: d.tokens > 0 ? bh : 1, rx: 2, fill: color });
+    const wd = new Date(d.day + 'T00:00:00').toLocaleDateString(undefined, { weekday: 'short' });
+    bindTip(r, () => `<b>${wd} ${d.day}</b><br>${fmtInt(d.tokens)} tokens (${fmtTok(d.tokens)})<br>${fmtUsd(d.costUsd)} est · ${(d.cacheHitRate * 100).toFixed(0)}% cache`);
+    svg.append(r);
+  });
+  data.forEach((d, i) => {
+    if (i % Math.ceil(data.length / 6) === 0 || i === data.length - 1)
+      svg.append(mk('text', { class: 'tip', x: i * bw + bw / 2, y: h - 6, 'text-anchor': 'middle' }, d.day.slice(5)));
+  });
+  return svg;
+}
+
+// SVG donut
+function donut(slices) {
+  const size = 132, r = 52, sw = 20, cx = size / 2, cy = size / 2, C = 2 * Math.PI * r;
+  const total = slices.reduce((a, s) => a + s.tokens, 0) || 1;
+  let off = 0;
+  const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+  svg.setAttribute('viewBox', `0 0 ${size} ${size}`); svg.style.width = size + 'px'; svg.style.height = size + 'px';
+  svg.append(mk('circle', { cx, cy, r, fill: 'none', stroke: 'var(--line)', 'stroke-width': sw }));
+  slices.forEach((s, i) => {
+    const len = (s.tokens / total) * C;
+    const c = mk('circle', { cx, cy, r, fill: 'none', stroke: SERIES[i % 6], 'stroke-width': sw,
+      'stroke-dasharray': `${len} ${C - len}`, 'stroke-dashoffset': -off, transform: `rotate(-90 ${cx} ${cy})` });
+    bindTip(c, () => `<b>${esc(s.key)}</b><br>${s.sharePct.toFixed(1)}% of tokens · ${fmtTok(s.tokens)}<br>${fmtUsd(s.costUsd)} est${s.sessions != null ? ` · ${s.sessions} sess` : ''}`);
+    svg.append(c); off += len;
+  });
+  svg.append(mk('text', { x: cx, y: cy - 2, 'text-anchor': 'middle', 'font-size': 22, 'font-weight': 700, fill: 'var(--ink)' }, String(slices.length)));
+  svg.append(mk('text', { x: cx, y: cy + 14, 'text-anchor': 'middle', 'font-size': 9, fill: 'var(--sub)', 'letter-spacing': 1 }, 'MODELS'));
+  return svg;
+}
+function mk(t, a, txt) { const n = document.createElementNS('http://www.w3.org/2000/svg', t); for (const k in a) n.setAttribute(k, a[k]); if (txt != null) n.textContent = txt; return n; }
+
+// area sparkline for cache hit rate
+function area(data, h = 70) {
+  const w = 600, max = 100, pts = data.map((d, i) => [i / Math.max(1, data.length - 1) * w, h - (d.cacheHitRate * 100 / max) * (h - 8) - 4]);
+  const line = pts.map((p, i) => (i ? 'L' : 'M') + p[0].toFixed(1) + ' ' + p[1].toFixed(1)).join(' ');
+  const fill = line + ` L ${w} ${h} L 0 ${h} Z`;
+  const svg = mk('svg', { viewBox: `0 0 ${w} ${h}`, preserveAspectRatio: 'none' }); svg.style.height = h + 'px'; svg.style.width = '100%';
+  svg.append(mk('path', { d: fill, fill: 'var(--accent)', 'fill-opacity': .12 }));
+  svg.append(mk('path', { d: line, fill: 'none', stroke: 'var(--accent)', 'stroke-width': 2 }));
+  return svg;
+}
+
+// stacked authorship bars
+function stacked(weekly, h = 190) {
+  const w = 1000, max = Math.max(1, ...weekly.map((d) => d.aiLines + d.humanLines)), bw = w / weekly.length;
+  const svg = mk('svg', { viewBox: `0 0 ${w} ${h}`, preserveAspectRatio: 'none' }); svg.style.height = h + 'px';
+  weekly.forEach((d, i) => {
+    const total = d.aiLines + d.humanLines, x = i * bw + 3, bwi = Math.max(1, bw - 6);
+    const aih = (d.aiLines / max) * (h - 24), hh = (d.humanLines / max) * (h - 24);
+    const aiRect = mk('rect', { x, y: (h - 18) - aih, width: bwi, height: aih, fill: 'var(--accent)', rx: 1 });
+    const huRect = mk('rect', { x, y: (h - 18) - aih - hh, width: bwi, height: hh, fill: 'var(--line)', rx: 1 });
+    const tip = () => `<b>${d.week}</b><br>${d.aiPct.toFixed(0)}% AI-authored<br>${fmtInt(d.aiLines)} AI · ${fmtInt(d.humanLines)} human lines`;
+    bindTip(aiRect, tip); bindTip(huRect, tip);
+    svg.append(huRect); svg.append(aiRect);
+    if (i % Math.ceil(weekly.length / 8) === 0) svg.append(mk('text', { class: 'tip', x: x + bwi / 2, y: h - 4, 'text-anchor': 'middle' }, d.week.slice(5)));
+  });
+  return svg;
+}
+
+function heatCell(v, max) {
+  const op = v === 0 ? 0.55 : 0.2 + 0.8 * (v / max);
+  const bg = v === 0 ? 'var(--line)' : 'var(--accent)';
+  const c = el('div', { class: 'cell', style: `background:${bg};opacity:${op}` });
+  return c;
+}
+
+function panel(titleText, meta, body) {
+  const head = el('div', { class: 'panelHead' }, [el('div', { class: 't' }, titleText), meta ? el('div', { class: 'm' }, meta) : '']);
+  return el('div', { class: 'card' }, [head, body]);
+}
+
+function render(d) {
+  const app = $('#app'); app.innerHTML = '';
+  const s = d.summary, rng = d.meta.range;
+  $('#eyebrow').textContent = `ANALYTICS · LAST ${rng.toUpperCase()}`;
+
+  // hero
+  const hero = el('div', {}, [
+    el('h1', { class: 'hero', html: `You wrote <b>${fmtTok(s.totalTokens)}</b> tokens across <b>${fmtInt(s.sessions)}</b> sessions.` }),
+    el('p', { class: 'heroSub', html:
+      `<b>${s.activeDays}</b> active days · last activity <b>${ago(d.meta.lastActivity)}</b> · est. <b>${fmtUsd(s.costUsd)}</b> · peak day <b>${s.peakDay.day ? fmtTok(s.peakDay.tokens) : '—'}</b>` }),
+  ]);
+  app.append(hero);
+
+  // KPIs
+  const kpis = el('div', { class: 'grid kpis' }, [
+    card('TOKENS', fmtTok(s.totalTokens), { delta: s.deltas.tokensPct, sub: `${fmtInt(s.messages)} msgs` }),
+    card('COST (EST.)', fmtUsd(s.costUsd), { delta: s.deltas.costPct, sub: 'API-equivalent' }),
+    card('SESSIONS', fmtInt(s.sessions), { sub: `${s.deltas.sessionsAbs >= 0 ? '+' : ''}${s.deltas.sessionsAbs} vs prior` }),
+    card('CACHE HIT', (s.cacheHitRate * 100).toFixed(0) + '%', { sub: `saved ${fmtUsd(s.cacheSavingsUsd)}` }),
+    card('STREAK', s.currentStreak + 'd', { sub: `longest ${s.longestStreak}d` }),
+  ]);
+  app.append(kpis);
+
+  // activity
+  app.append(el('div', { class: 'grid' }, [panel('DAILY ACTIVITY · TOKENS', `peak ${s.peakDay.day || '—'}`, barChart(d.series.daily))]));
+
+  // tool + model
+  const maxTool = d.breakdowns.byTool[0]?.tokens || 1;
+  const toolBody = el('div', {}, d.breakdowns.byTool.map((t) =>
+    barRow(t.key, `${fmtTok(t.tokens)} · ${fmtUsd(t.costUsd)} · ${t.sharePct.toFixed(0)}%`, (t.tokens / maxTool) * 100, TOOLCOLOR[t.key] || 'var(--accent)')));
+  const modelLegend = el('div', { class: 'legend' }, d.breakdowns.byModel.slice(0, 6).map((m, i) =>
+    el('div', { class: 'li' }, [
+      el('span', { html: `<span class="dot" style="background:${SERIES[i % 6]}"></span>${esc(m.key)}` }),
+      el('span', { class: 'num', style: 'color:var(--sub)' }, `${m.sharePct.toFixed(1)}% · ${fmtUsd(m.costUsd)}`),
+    ])));
+  const modelBody = el('div', { style: 'display:flex;gap:18px;align-items:center' }, [donut(d.breakdowns.byModel.slice(0, 6)), el('div', { style: 'flex:1' }, [modelLegend])]);
+  app.append(el('div', { class: 'grid two' }, [panel('TOOL BREAKDOWN', 'tokens · cost · share', toolBody), panel('MODEL MIX', `${d.breakdowns.byModel.length} models`, modelBody)]));
+
+  // projects + heatmap
+  const maxProj = d.breakdowns.byProject[0]?.tokens || 1;
+  const projBody = el('div', {}, d.breakdowns.byProject.map((p) =>
+    barRow(p.key, `${fmtTok(p.tokens)} · ${fmtUsd(p.costUsd)}`, (p.tokens / maxProj) * 100, 'var(--accent)')));
+  const dayName = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
+  const days = ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN'];
+  const maxHeat = Math.max(1, ...d.heatmap.flat().map((c) => c.count));
+  const hr = (h) => String(h).padStart(2, '0');
+  const heatGrid = el('div', { class: 'heat' });
+  d.heatmap.forEach((rowv, r) => {
+    heatGrid.append(el('div', { class: 'dl' }, days[r]));
+    rowv.forEach((cell, h) => {
+      const c = heatCell(cell.count, maxHeat);
+      if (cell.count > 0) bindTip(c, () =>
+        `<b>${dayName[r]} ${hr(h)}:00–${hr((h + 1) % 24)}:00</b><br>${fmtInt(cell.count)} msgs · ${cell.sessions} session${cell.sessions === 1 ? '' : 's'}<br>${fmtTok(cell.tokens)} tokens · ${fmtUsd(cell.cost)} est`);
+      heatGrid.append(c);
+    });
+  });
+  const hoursRow = el('div', { class: 'heatHours' }, [el('span', {}, '')].concat([0, 3, 6, 9, 12, 15, 18, 21].flatMap((hh) => { const arr = [el('span', { style: 'grid-column:span 3' }, String(hh).padStart(2, '0'))]; return arr; })));
+  app.append(el('div', { class: 'grid two' }, [panel('TOP PROJECTS', 'by tokens', projBody), panel('WHEN · BY HOUR & WEEKDAY', 'local time', el('div', {}, [heatGrid, hoursRow]))]));
+
+  // session shape + cache
+  const shBody = el('div', {}, [
+    ...d.sessions.buckets.map((b) => barRow(b.label, `${b.count} (${b.pct.toFixed(0)}%)`, b.pct, 'var(--accent)')),
+    el('div', { class: 'statPair' }, [
+      el('div', {}, [el('div', { class: 'k' }, 'AVG MSGS'), el('div', { class: 'v' }, fmtInt(d.sessions.avgMessages))]),
+      el('div', {}, [el('div', { class: 'k' }, 'AVG DURATION'), el('div', { class: 'v' }, (d.sessions.avgDurationMs / 3600000).toFixed(1) + 'h')]),
+      el('div', {}, [el('div', { class: 'k' }, 'MEDIAN TOKENS'), el('div', { class: 'v' }, fmtTok(d.sessions.medianTokens))]),
+    ]),
+  ]);
+  const cacheBody = el('div', {}, [
+    el('div', { style: 'font-size:34px;font-weight:700;color:var(--accent);font-variant-numeric:tabular-nums' }, (s.cacheHitRate * 100).toFixed(0) + '%'),
+    area(d.series.daily),
+    el('div', { class: 'csub' }, `Tokens served from cache: ${fmtTok(s.cacheReadTokens)} · est. saved ${fmtUsd(s.cacheSavingsUsd)}`),
+  ]);
+  app.append(el('div', { class: 'grid two' }, [panel('SESSION SHAPE', 'by token size', shBody), panel('CACHE EFFECTIVENESS', 'daily hit rate', cacheBody)]));
+
+  // authorship
+  let authBody;
+  if (d.authorship.totalCommits === 0) authBody = el('div', { class: 'csub' }, 'No Cursor commit data in this range.');
+  else authBody = el('div', {}, [
+    el('div', { class: 'csub', style: 'margin-bottom:8px' }, `AI wrote ${d.authorship.aiPct.toFixed(0)}% of ${fmtInt(d.authorship.aiLines + d.authorship.humanLines)} lines across ${fmtInt(d.authorship.totalCommits)} commits · AI ▮ Human ▯`),
+    stacked(d.authorship.weekly),
+  ]);
+  app.append(el('div', { class: 'grid' }, [panel('CODE AUTHORSHIP · CURSOR', 'weekly AI vs human lines', authBody)]));
+
+  // tool chips
+  const chips = el('div', { class: 'tools' }, d.tools.map((t) =>
+    el('div', { class: 'chip ' + (t.available ? 'on' : ''), html: `<span class="d" style="background:${t.available ? 'var(--good)' : 'var(--line)'};width:8px;height:8px;border-radius:50%;display:inline-block"></span><b>${esc(t.tool)}</b> ${t.available ? (t.count != null ? fmtInt(t.count) + ' records' : 'active') : esc(t.note || 'no data')}` })));
+  app.append(el('div', {}, [el('div', { class: 'clabel', style: 'margin-top:8px' }, 'TOOLS DETECTED'), chips]));
+  app.append(el('div', { class: 'foot' }, `Generated ${new Date(d.meta.generatedAt).toLocaleString()} · read-only from ~/.claude, ~/.codex, ~/.cursor · cost is estimated API-equivalent, not a bill`));
+}
+
+let range = '30d';
+async function load() {
+  try {
+    const r = await fetch('/api/dashboard?range=' + range);
+    render(await r.json());
+  } catch (e) { $('#app').innerHTML = '<div class="loading">Failed: ' + e.message + '</div>'; }
+}
+$('#toggle').addEventListener('click', (e) => {
+  const b = e.target.closest('button'); if (!b) return;
+  range = b.dataset.r;
+  [...$('#toggle').children].forEach((c) => c.classList.toggle('on', c === b));
+  $('#app').innerHTML = '<div class="loading">Loading…</div>'; load();
+});
+load();

package/src/public/index.html

@@ -0,0 +1,84 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>usagelens — My AI Usage</title>
+<style>
+  :root{
+    --bg:#f5f6f8; --panel:#fff; --ink:#191d28; --sub:#6b7280; --line:#e7e9ee;
+    --accent:#5b5bd6; --accent2:#8b5cf6; --good:#16a34a; --warn:#dc2626;
+    --c0:#5b5bd6; --c1:#16a34a; --c2:#f59e0b; --c3:#e5484d; --c4:#0ea5e9; --c5:#8b5cf6;
+    --mono:ui-monospace,SFMono-Regular,Menlo,monospace;
+  }
+  *{box-sizing:border-box}
+  body{margin:0;background:var(--bg);color:var(--ink);
+    font-family:ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,sans-serif;-webkit-font-smoothing:antialiased}
+  .wrap{max-width:1240px;margin:0 auto;padding:28px 28px 80px}
+  .row{display:flex;align-items:center;justify-content:space-between;gap:16px;flex-wrap:wrap}
+  .eyebrow{font-size:11px;letter-spacing:1.5px;color:var(--sub);font-weight:700;font-family:var(--mono)}
+  h1.hero{font-family:Georgia,"Times New Roman",serif;font-weight:500;font-size:clamp(26px,3.4vw,42px);
+    line-height:1.15;margin:14px 0 6px}
+  h1.hero b{color:var(--accent);font-weight:600;font-variant-numeric:tabular-nums}
+  .heroSub{color:var(--sub);font-size:14px;margin:0}
+  .heroSub b{color:var(--ink);font-weight:600}
+  .toggle{display:inline-flex;gap:2px;background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:3px}
+  .toggle button{border:0;background:transparent;color:var(--sub);font-weight:600;font-size:13px;
+    padding:6px 14px;border-radius:7px;cursor:pointer;font-family:var(--mono)}
+  .toggle button.on{background:var(--accent);color:#fff}
+  .grid{display:grid;gap:14px;margin-top:14px}
+  .kpis{grid-template-columns:repeat(5,1fr)}
+  .two{grid-template-columns:1fr 1fr}
+  @media(max-width:880px){.kpis{grid-template-columns:repeat(2,1fr)}.two{grid-template-columns:1fr}}
+  .card{background:var(--panel);border:1px solid var(--line);border-radius:14px;padding:16px 18px}
+  .clabel{font-size:11px;letter-spacing:1.2px;color:var(--sub);font-weight:700;font-family:var(--mono)}
+  .cval{font-size:30px;font-weight:650;margin-top:6px;font-variant-numeric:tabular-nums;letter-spacing:-.5px}
+  .csub{font-size:12px;color:var(--sub);margin-top:5px}
+  .delta{font-size:12px;font-weight:600;font-family:var(--mono)}
+  .delta.up{color:var(--good)} .delta.down{color:var(--warn)}
+  .panelHead{display:flex;justify-content:space-between;align-items:baseline;margin-bottom:12px}
+  .panelHead .t{font-size:12px;letter-spacing:1px;color:var(--sub);font-weight:700;font-family:var(--mono)}
+  .panelHead .m{font-size:12px;color:var(--sub);font-family:var(--mono)}
+  .barRow{margin-bottom:11px}
+  .barRow .top{display:flex;justify-content:space-between;font-size:13px;margin-bottom:5px}
+  .barRow .top .r{color:var(--sub);font-variant-numeric:tabular-nums;font-family:var(--mono)}
+  .track{height:7px;background:var(--line);border-radius:4px;overflow:hidden}
+  .fill{height:100%;border-radius:4px}
+  .legend{display:flex;flex-direction:column;gap:7px;font-size:13px}
+  .legend .li{display:flex;justify-content:space-between;align-items:center}
+  .dot{width:9px;height:9px;border-radius:50%;display:inline-block;margin-right:8px}
+  .num{font-variant-numeric:tabular-nums;font-family:var(--mono)}
+  .heat{display:grid;grid-template-columns:34px repeat(24,1fr);gap:3px}
+  .heat .dl{font-size:9px;color:var(--sub);align-self:center;font-family:var(--mono)}
+  .heat .cell{aspect-ratio:1;border-radius:3px;transition:box-shadow .08s}
+  .heat .cell:hover{box-shadow:0 0 0 2px var(--ink)}
+  svg rect{transition:opacity .08s} svg rect:hover{opacity:.8}
+  .heatHours{display:grid;grid-template-columns:34px repeat(24,1fr);gap:3px;margin-top:5px}
+  .heatHours span{font-size:8px;color:var(--sub);text-align:center;font-family:var(--mono)}
+  .statPair{display:flex;gap:32px;margin-top:6px}
+  .statPair .k{font-size:11px;letter-spacing:1px;color:var(--sub);font-weight:700;font-family:var(--mono)}
+  .statPair .v{font-size:22px;font-weight:600;font-variant-numeric:tabular-nums}
+  .tools{display:flex;flex-wrap:wrap;gap:8px;margin-top:14px}
+  .chip{font-size:12px;font-family:var(--mono);padding:5px 10px;border-radius:20px;border:1px solid var(--line);background:var(--panel);color:var(--sub)}
+  .chip b{color:var(--ink)} .chip.on b{color:var(--good)} .chip .d{margin-right:6px}
+  .foot{margin-top:22px;font-size:12px;color:var(--sub);font-family:var(--mono)}
+  .loading{padding:60px;text-align:center;color:var(--sub)}
+  svg{display:block;width:100%;overflow:visible}
+  .tip{fill:var(--sub);font-size:9px;font-family:var(--mono)}
+</style>
+</head>
+<body>
+<div class="wrap">
+  <div class="row">
+    <div class="eyebrow" id="eyebrow">ANALYTICS · LAST 30 DAYS</div>
+    <div class="toggle" id="toggle">
+      <button data-r="7d">7d</button>
+      <button data-r="30d" class="on">30d</button>
+      <button data-r="90d">90d</button>
+    </div>
+  </div>
+  <div id="app"><div class="loading">Reading your local AI data…</div></div>
+</div>
+<script src="/app.js"></script>
+</body>
+</html>

package/src/server.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// Silence the experimental warning from the built-in node:sqlite (used read-only for Cursor).
+const _emitWarning = process.emitWarning.bind(process);
+process.emitWarning = (warning, ...rest) => {
+  const type = typeof rest[0] === 'object' && rest[0] ? rest[0].type : rest[0];
+  if (type === 'ExperimentalWarning' && /SQLite/i.test(String(warning))) return;
+  return _emitWarning(warning, ...rest);
+};
+import { createReadStream, existsSync, statSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+import { platform } from 'node:os';
+import { extname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadAll } from './lib/adapters.mjs';
+import { buildPayload } from './lib/aggregate.mjs';
+
+const PUBLIC = join(fileURLToPath(new URL('.', import.meta.url)), 'public');
+const MIME = { '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css', '.json': 'application/json', '.svg': 'image/svg+xml' };
+
+function parseArgs(argv) {
+  const o = { port: 4319, open: true };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--port') o.port = Number(argv[++i]) || o.port;
+    else if (argv[i] === '--no-open') o.open = false;
+  }
+  return o;
+}
+
+const { port, open } = parseArgs(process.argv.slice(2));
+
+process.stdout.write('usagelens · scanning ~/.claude, ~/.codex, ~/.cursor …\n');
+const t0 = Date.now();
+const dataset = loadAll();
+process.stdout.write(`usagelens · loaded ${dataset.events.length} usage events + ${dataset.commits.length} commits in ${Date.now() - t0}ms\n`);
+for (const s of dataset.statuses) process.stdout.write(`   ${s.available ? '✓' : '·'} ${s.tool}${s.count != null ? ` (${s.count})` : ''}${s.note ? ' — ' + s.note : ''}\n`);
+
+const server = createServer((req, res) => {
+  const url = new URL(req.url ?? '/', 'http://localhost');
+  if (url.pathname === '/api/dashboard') {
+    const rq = url.searchParams.get('range');
+    const range = ['7d', '30d', '90d'].includes(rq) ? rq : '30d';
+    const body = JSON.stringify(buildPayload(dataset, range, new Date()));
+    res.writeHead(200, { 'content-type': 'application/json' }).end(body);
+    return;
+  }
+  const name = url.pathname === '/' ? 'index.html' : url.pathname.replace(/^\/+/, '').replace(/\.\./g, '');
+  const file = join(PUBLIC, name);
+  if (existsSync(file) && statSync(file).isFile()) {
+    res.writeHead(200, { 'content-type': MIME[extname(file)] ?? 'application/octet-stream' });
+    createReadStream(file).pipe(res);
+  } else {
+    res.writeHead(404).end('not found');
+  }
+});
+
+server.listen(port, () => {
+  const link = `http://localhost:${port}`;
+  process.stdout.write(`\nusagelens · dashboard → ${link}\n`);
+  if (open) {
+    const cmd = platform() === 'darwin' ? 'open' : platform() === 'win32' ? 'start' : 'xdg-open';
+    try { spawn(cmd, [link], { stdio: 'ignore', detached: true }).unref(); } catch {}
+  }
+});