@ugurcandede/cc-cost 0.1.0

package/dist/reports.js

@@ -0,0 +1,410 @@
+import { agentOf, avgContext, byCost, cacheHitRatio, contextTokens, daysBetween, groupBy, modelLabel, repriceAs, totals, weekOf, } from "./aggregate.js";
+import { PLANS } from "./config.js";
+import { int, paint, table, tokens, usd } from "./format.js";
+import { fill, L, lang } from "./i18n.js";
+import { localClock } from "./scan.js";
+import { T, UNKNOWN } from "./types.js";
+const col = (title, kind) => ({ title, kind });
+const FMT = {
+    text: String, usd, int, tok: tokens, pct: (v) => v.toFixed(1) + '%', x: (v) => v.toFixed(1) + '×',
+};
+export function renderTable(r) {
+    const cell = (v, i) => (typeof v === 'number' ? FMT[r.cols[i].kind](v) : v);
+    const left = r.cols.flatMap((c, i) => (c.kind === 'text' ? [i] : []));
+    return table(r.cols.map((c) => c.title), r.rows.map((row) => row.map(cell)), { foot: r.foot?.map(cell), left, dim: r.dim });
+}
+const csvCell = (v) => typeof v === 'number' ? String(Math.round(v * 1e4) / 1e4) : /[",\n]/.test(v) ? `"${v.replace(/"/g, '""')}"` : v;
+export const renderCsv = (r) => [r.cols.map((c) => c.title), ...r.rows].map((row) => row.map(csvCell).join(',')).join('\n');
+const round = (n) => Math.round(n * 1e4) / 1e4;
+const pctOf = (part, whole) => (whole ? (part / whole) * 100 : 0);
+const at = (t, i) => t.t[i] ?? 0;
+const writes = (t) => at(t, T.write5m) + at(t, T.write1h);
+const span = (t) => {
+    const days = [...t.days].sort();
+    return { first: days[0] ?? '', last: days[days.length - 1] ?? '' };
+};
+export function toJson(t) {
+    return {
+        cost: round(t.cost),
+        costBreakdown: { input: round(t.c[0]), cacheWrite: round(t.c[1]), cacheRead: round(t.c[2]), output: round(t.c[3]), webSearch: round(t.c[4]) },
+        inputTokens: at(t, T.input),
+        cacheWrite5mTokens: at(t, T.write5m),
+        cacheWrite1hTokens: at(t, T.write1h),
+        cacheReadTokens: at(t, T.read),
+        outputTokens: at(t, T.output),
+        thinkingTokens: at(t, T.thinking),
+        webSearches: at(t, T.webSearch),
+        calls: at(t, T.calls),
+        sessions: t.sessions.size,
+        avgContext: Math.round(avgContext(t.t)),
+        maxContext: at(t, T.maxContext),
+    };
+}
+export const PERIODS = ['daily', 'weekly', 'monthly'];
+const periodKey = {
+    daily: (r) => r.d,
+    weekly: (r) => weekOf(r.d),
+    monthly: (r) => r.d.slice(0, 7),
+};
+const byKey = (m) => [...m].sort((a, b) => a[0].localeCompare(b[0]));
+export function periodReport(rows, period, opts = {}) {
+    const c = L().col;
+    const nums = (t) => [at(t, T.input), at(t, T.output), writes(t), at(t, T.read), at(t, T.calls), t.cost];
+    const numCols = [col(c.input, 'tok'), col(c.output, 'tok'), col(c.cacheWrite, 'tok'), col(c.cacheRead, 'tok'), col(c.calls, 'int'), col(c.cost, 'usd')];
+    const label = col({ daily: c.date, weekly: c.week, monthly: c.month }[period], 'text');
+    const groups = byKey(groupBy(rows, periodKey[period]));
+    const models = (key) => byCost(groupBy(rows.filter((r) => periodKey[period](r) === key), modelLabel));
+    // CSV wants one self-contained row per period and model rather than indented sub-rows
+    if (opts.breakdown && opts.flat)
+        return {
+            cols: [label, col(c.model, 'text'), ...numCols],
+            rows: groups.flatMap(([key]) => models(key).map(([m, t]) => [key, m, ...nums(t)])),
+        };
+    const body = [];
+    const dim = new Set();
+    for (const [key, t] of groups) {
+        body.push([key, ...nums(t)]);
+        if (opts.breakdown)
+            for (const [m, mt] of models(key)) {
+                dim.add(body.length);
+                body.push(['  └ ' + m, ...nums(mt)]);
+            }
+    }
+    return { cols: [label, ...numCols], rows: body, foot: [c.total, ...nums(totals(rows))], dim };
+}
+export function periodJson(rows, period, breakdown) {
+    return {
+        [period]: byKey(groupBy(rows, periodKey[period])).map(([key, t]) => ({
+            period: key,
+            ...toJson(t),
+            ...(breakdown && {
+                models: byCost(groupBy(rows.filter((r) => periodKey[period](r) === key), modelLabel)).map(([m, mt]) => ({ model: m, ...toJson(mt) })),
+            }),
+        })),
+        totals: toJson(totals(rows)),
+    };
+}
+export const DIMENSIONS = ['models', 'machines', 'projects', 'agents', 'skills', 'mcp', 'sessions'];
+const none = () => L().dash.none;
+// The main thread is "main" in data and filters, and a translated label on screen
+const agentLabel = (key) => (key === 'main' ? L().dash.main : key);
+const dimensionKey = {
+    models: modelLabel,
+    machines: (r) => r.machine,
+    projects: (r) => r.p,
+    agents: agentOf,
+    skills: (r) => r.k ?? none(),
+    mcp: (r) => r.x ?? none(),
+    sessions: (r) => r.s,
+};
+const singular = {
+    models: 'model', machines: 'machine', projects: 'project', agents: 'agent', skills: 'skill', mcp: 'mcp', sessions: 'session',
+};
+function dimensionGroups(rows, dimension, limit) {
+    // Legacy data has no session ids; lumped together it would pose as one huge session.
+    const source = dimension === 'sessions' ? rows.filter((r) => r.s !== UNKNOWN) : rows;
+    const all = byCost(groupBy(source, dimensionKey[dimension]));
+    return limit ? all.slice(0, limit) : all;
+}
+const sessionInfo = (rows, id) => {
+    const r = rows.find((x) => x.s === id);
+    return { project: r?.p ?? '', machine: r?.machine ?? '' };
+};
+export function dimensionReport(rows, dimension, limit) {
+    const c = L().col;
+    const groups = dimensionGroups(rows, dimension, limit);
+    if (dimension === 'sessions')
+        return {
+            cols: [col(c.session, 'text'), col(c.project, 'text'), col(c.machine, 'text'), col(c.first, 'text'), col(c.last, 'text'),
+                col(c.calls, 'int'), col(c.avgContext, 'tok'), col(c.cost, 'usd')],
+            rows: groups.map(([id, t]) => {
+                const { project, machine } = sessionInfo(rows, id);
+                const { first, last } = span(t);
+                return [id.slice(0, 8), project, machine, first, last, at(t, T.calls), avgContext(t.t), t.cost];
+            }),
+        };
+    const grand = totals(rows);
+    const name = { models: c.model, machines: c.machine, projects: c.project, agents: c.agent, skills: c.skill, mcp: c.mcp }[dimension];
+    const nums = (t) => [at(t, T.calls), avgContext(t.t), at(t, T.read), at(t, T.output), t.cost, pctOf(t.cost, grand.cost)];
+    return {
+        cols: [col(name, 'text'), col(c.calls, 'int'), col(c.avgContext, 'tok'), col(c.cacheRead, 'tok'), col(c.output, 'tok'), col(c.cost, 'usd'), col(c.share, 'pct')],
+        rows: groups.map(([key, t]) => [dimension === 'agents' ? agentLabel(key) : key, ...nums(t)]),
+        foot: [c.total, ...nums(grand)],
+    };
+}
+export function dimensionJson(rows, dimension, limit) {
+    return {
+        [dimension]: dimensionGroups(rows, dimension, limit).map(([key, t]) => ({
+            [singular[dimension]]: key,
+            ...(dimension === 'sessions' && { ...sessionInfo(rows, key), ...span(t) }),
+            ...toJson(t),
+        })),
+        totals: toJson(totals(rows)),
+    };
+}
+// ---------- summary
+export function summary(rows) {
+    const L_ = L(), c = L_.col, grand = totals(rows);
+    const costTable = (title, groups) => ({
+        cols: [col(title, 'text'), col(c.cost, 'usd'), col(c.share, 'pct')],
+        rows: groups.map(([k, t]) => [k, t.cost, pctOf(t.cost, grand.cost)]),
+    });
+    const items = [
+        [L_.item.read, grand.c[2]], [L_.item.write, grand.c[1]], [L_.item.output, grand.c[3]], [L_.item.input, grand.c[0]], [L_.item.web, grand.c[4]],
+    ];
+    return [
+        paint('bold', fill(L_.total, { cost: usd(grand.cost), calls: int(at(grand, T.calls)), machines: grand.machines.size })),
+        renderTable({ cols: [col(c.month, 'text'), col(c.cost, 'usd')], rows: byKey(groupBy(rows, periodKey.monthly)).map(([k, t]) => [k, t.cost]) }),
+        renderTable(costTable(c.machine, byCost(groupBy(rows, dimensionKey.machines)))),
+        renderTable(costTable(c.model, byCost(groupBy(rows, modelLabel)))),
+        renderTable(costTable(c.project, byCost(groupBy(rows, dimensionKey.projects)).slice(0, 5))),
+        renderTable({
+            cols: [col(c.item, 'text'), col(c.cost, 'usd'), col(c.share, 'pct')],
+            rows: items.filter(([, v]) => v > 0).sort((a, b) => b[1] - a[1]).map(([k, v]) => [k, v, pctOf(v, grand.cost)]),
+        }),
+    ].join('\n\n');
+}
+export function summaryJson(rows) {
+    return {
+        totals: toJson(totals(rows)),
+        months: periodJson(rows, 'monthly').monthly,
+        machines: dimensionJson(rows, 'machines').machines,
+        models: dimensionJson(rows, 'models').models,
+        projects: dimensionJson(rows, 'projects').projects,
+    };
+}
+// ---------- insights
+const weekdayName = (w) => new Intl.DateTimeFormat(lang() === 'tr' ? 'tr-TR' : 'en-US', { weekday: 'long', timeZone: 'UTC' }).format(new Date(Date.UTC(2026, 0, 4 + w))); // 2026-01-04 is a Sunday
+function topBy(entries) {
+    let best;
+    for (const e of entries)
+        if (!best || e[1] > best[1])
+            best = e;
+    return best;
+}
+export function insights({ rows, hours, limits, table: prices, timezone }) {
+    const g = totals(rows), t = g.t;
+    const dates = [...g.days].sort();
+    const calendar = dates.length ? daysBetween(dates[0], dates[dates.length - 1]) : 0;
+    // Part of each row's cache reads that went to context beyond 200K tokens, assuming its calls sat at the row's average
+    const above200k = rows.reduce((acc, r) => {
+        const avg = avgContext(r.t);
+        return acc + (avg > 200_000 ? r.c[2] * (1 - 200_000 / avg) : 0);
+    }, 0);
+    const buckets = [T.ctx50k, T.ctx200k, T.ctx500k, T.ctxOver500k].map((i) => at(g, i));
+    const bigSessions = [...groupBy(rows.filter((r) => r.s !== UNKNOWN), (r) => r.s)].sort((a, b) => b[1].c[2] - a[1].c[2]).slice(0, 5);
+    const withKey = (key) => byCost(groupBy(rows.filter((r) => key(r) !== undefined), (r) => key(r)));
+    const models = byCost(groupBy(rows, modelLabel));
+    const baseModels = [...new Set(rows.map((r) => r.m))];
+    const whatIf = baseModels
+        .flatMap((m) => {
+        const cost = repriceAs(rows, prices, m);
+        return cost === undefined ? [] : [{ model: m, cost }];
+    })
+        .sort((a, b) => a.cost - b.cost);
+    const fast = rows.filter((r) => r.f).reduce((a, r) => a + r.cost, 0);
+    const weekdays = new Map();
+    for (const r of rows) {
+        const w = new Date(r.d + 'T00:00:00Z').getUTCDay();
+        weekdays.set(w, (weekdays.get(w) ?? 0) + r.cost);
+    }
+    const hourCost = new Map();
+    for (const h of hours ?? [])
+        hourCost.set(h.h, (hourCost.get(h.h) ?? 0) + h.cost);
+    const busiestDay = topBy(weekdays), busiestHour = topBy(hourCost);
+    const clock = localClock(timezone);
+    const hits = limits.filter((l) => l.status === 'rejected');
+    const hitTypes = new Map();
+    for (const l of hits)
+        hitTypes.set(l.type, (hitTypes.get(l.type) ?? 0) + 1);
+    const lastHit = hits.map((l) => l.ts).sort().pop();
+    const localTime = (iso) => {
+        const k = clock(iso);
+        return `${k.d} ${String(k.h).padStart(2, '0')}:${String(k.min).padStart(2, '0')}`;
+    };
+    const json = {
+        cost: round(g.cost),
+        calls: at(g, T.calls),
+        activeDays: dates.length,
+        calendarDays: calendar,
+        avgContext: Math.round(avgContext(t)),
+        maxContext: at(g, T.maxContext),
+        cacheHitRatio: round(cacheHitRatio(t)),
+        cacheReadShare: round(pctOf(g.c[2], g.cost) / 100),
+        cacheWriteShare: round(pctOf(g.c[1], g.cost) / 100),
+        oneHourWriteShare: round(writes(g) ? at(g, T.write1h) / writes(g) : 0),
+        contextBuckets: { under50k: buckets[0], from50kTo200k: buckets[1], from200kTo500k: buckets[2], over500k: buckets[3] },
+        cacheReadAbove200kEstimate: round(above200k),
+        largestContextSessions: bigSessions.map(([id, s]) => ({ session: id, ...sessionInfo(rows, id), calls: at(s, T.calls), avgContext: Math.round(avgContext(s.t)), cacheReadCost: round(s.c[2]), cost: round(s.cost) })),
+        agents: withKey(agentOf).map(([k, s]) => ({ agent: k, cost: round(s.cost), calls: at(s, T.calls) })),
+        skills: withKey((r) => r.k).map(([k, s]) => ({ skill: k, cost: round(s.cost), calls: at(s, T.calls) })),
+        mcp: withKey((r) => r.x).map(([k, s]) => ({ mcp: k, cost: round(s.cost), calls: at(s, T.calls) })),
+        effort: withKey((r) => r.e).map(([k, s]) => ({ effort: k, cost: round(s.cost), calls: at(s, T.calls) })),
+        models: models.map(([k, s]) => ({ model: k, cost: round(s.cost) })),
+        sameTokensOn: whatIf.map((w) => ({ model: w.model, cost: round(w.cost) })),
+        fastModeCost: round(fast),
+        thinkingShareOfOutput: round(at(g, T.output) ? at(g, T.thinking) / at(g, T.output) : 0),
+        busiestWeekday: busiestDay && { weekday: weekdayName(busiestDay[0]), cost: round(busiestDay[1]) },
+        busiestHour: busiestHour && { hour: busiestHour[0], cost: round(busiestHour[1]) },
+        rateLimitHits: { total: hits.length, byType: Object.fromEntries(hitTypes), last: lastHit },
+    };
+    const I = L().ins, c = L().col;
+    const pct = (v) => v.toFixed(1) + '%';
+    const out = [];
+    const section = (title, lines) => out.push(paint('bold', title) + '\n' + lines.join('\n'));
+    const kv = (pairs) => {
+        const w = Math.max(...pairs.map(([k]) => k.length));
+        return pairs.map(([k, v]) => '  ' + paint('dim', k.padEnd(w)) + '  ' + v);
+    };
+    const shareTable = (title, groups) => renderTable({ cols: [col(title, 'text'), col(c.calls, 'int'), col(c.cost, 'usd'), col(c.share, 'pct')], rows: groups.map(([k, s]) => [k, at(s, T.calls), s.cost, pctOf(s.cost, g.cost)]) });
+    section(I.overview, kv([
+        [I.cost, usd(g.cost)],
+        [I.calls, `${int(at(g, T.calls))}  (${fill(I.perCall, { cost: usd(g.cost / (at(g, T.calls) || 1)) })})`],
+        [I.activeDays, fill(I.activeOf, { active: dates.length, calendar })],
+        [I.avgContext, fill(I.avgContextValue, { avg: tokens(avgContext(t)), max: tokens(at(g, T.maxContext)) })],
+    ]));
+    section(I.cache, kv([
+        [I.hitRatio, fill(I.hitRatioValue, { pct: pct(cacheHitRatio(t) * 100) })],
+        [I.readShare, fill(I.ofCost, { pct: pct(pctOf(g.c[2], g.cost)) })],
+        [I.writeShare, fill(I.oneHour, { pct: pct(pctOf(g.c[1], g.cost)), tier: pct(pctOf(at(g, T.write1h), writes(g))) })],
+    ]));
+    const bucketTotal = buckets.reduce((a, b) => a + b, 0);
+    if (bucketTotal)
+        section(I.contextSize, [
+            renderTable({ cols: [col(c.context, 'text'), col(c.calls, 'int'), col(c.share, 'pct')], rows: buckets.map((b, i) => [I.bucket[i], b, pctOf(b, bucketTotal)]) }),
+            fill(I.above200k, { cost: usd(above200k) }),
+            paint('dim', I.contextTip),
+        ]);
+    if (bigSessions.length)
+        section(I.bigSessions, [renderTable({
+                cols: [col(c.session, 'text'), col(c.project, 'text'), col(c.calls, 'int'), col(c.avgContext, 'tok'), col(c.readCost, 'usd'), col(c.cost, 'usd')],
+                rows: bigSessions.map(([id, s]) => [id.slice(0, 8), sessionInfo(rows, id).project, at(s, T.calls), avgContext(s.t), s.c[2], s.cost]),
+            })]);
+    section(I.agents, [shareTable(c.agent, withKey(agentOf).map(([k, s]) => [agentLabel(k), s]))]);
+    const skills = withKey((r) => r.k), mcps = withKey((r) => r.x), efforts = withKey((r) => r.e);
+    if (skills.length)
+        section(I.skills, [shareTable(c.skill, skills.slice(0, 5))]);
+    if (mcps.length)
+        section(I.mcp, [shareTable(c.mcp, mcps.slice(0, 5))]);
+    if (efforts.length)
+        section(I.effort, [shareTable(c.effort, efforts)]);
+    section(I.models, [
+        shareTable(c.model, models),
+        ...(whatIf.length > 1 ? whatIf.map((w) => fill(I.whatIf, { model: w.model, cost: usd(w.cost) })) : []),
+        ...kv([
+            ...(fast ? [[I.fast, `${usd(fast)} (${pct(pctOf(fast, g.cost))})`]] : []),
+            [I.thinking, fill(I.thinkingValue, { pct: pct(pctOf(at(g, T.thinking), at(g, T.output))) })],
+        ]),
+    ]);
+    const when = [];
+    if (busiestDay)
+        when.push([I.weekday, `${weekdayName(busiestDay[0])} (${usd(busiestDay[1])})`]);
+    if (busiestHour)
+        when.push([I.hour, `${String(busiestHour[0]).padStart(2, '0')}:00–${String((busiestHour[0] + 1) % 24).padStart(2, '0')}:00 (${usd(busiestHour[1])})`]);
+    if (when.length)
+        section(I.when, kv(when));
+    section(I.limits, ['  ' + (hits.length
+            ? fill(I.limitsValue, { n: hits.length, types: [...hitTypes].map(([k, v]) => `${k}: ${v}`).join(', '), last: localTime(lastHit) })
+            : I.noLimits)]);
+    return { text: out.join('\n\n'), json };
+}
+// ---------- plan
+// Limit events filtered to the rows' date range, by local date
+export function limitsInRange(limits, timezone, since, until, machines) {
+    const clock = localClock(timezone);
+    return limits.filter((l) => {
+        const d = clock(l.ts).d;
+        return (!since || d >= since) && (!until || d <= until) && (!machines || machines(l.machine));
+    });
+}
+export function planReport(rows, limits, opts) {
+    const c = L().col, P = L().plan;
+    const dates = [...new Set(rows.map((r) => r.d))].sort();
+    const first = dates[0] ?? '', last = dates[dates.length - 1] ?? '';
+    const clock = localClock(opts.timezone);
+    const hitsIn = (month) => limits.filter((l) => l.status === 'rejected' && (!month || clock(l.ts).d.startsWith(month))).length;
+    const plans = Object.entries(PLANS);
+    const line = (label, days, cost, hits) => {
+        const perMonth = days ? (cost / days) * 30 : 0;
+        return [label, days, cost, perMonth, ...plans.map(([, price]) => perMonth / price), hits];
+    };
+    const months = byKey(groupBy(rows, (r) => r.d.slice(0, 7))).map(([m, t]) => {
+        // calendar days of the month that fall inside the recorded range; idle days count, days before the first record don't
+        const [y, mo] = m.split('-').map(Number);
+        const monthEnd = new Date(Date.UTC(y, mo, 0)).toISOString().slice(0, 10);
+        const from = m + '-01' > first ? m + '-01' : first;
+        const to = monthEnd < last ? monthEnd : last;
+        return line(m, daysBetween(from, to), t.cost, hitsIn(m));
+    });
+    const grand = totals(rows);
+    const foot = line(c.total, first ? daysBetween(first, last) : 0, grand.cost, hitsIn());
+    const planName = { pro: 'Pro', max5x: 'Max 5x', max20x: 'Max 20x' };
+    const report = {
+        cols: [col(c.month, 'text'), col(c.days, 'int'), col(c.cost, 'usd'), col(c.perMonth, 'usd'),
+            ...plans.map(([k, price]) => col(`${planName[k] ?? k} ($${price})`, 'x')), col(c.limitHits, 'int')],
+        rows: months,
+        foot,
+    };
+    const perMonth = foot[3];
+    const price = opts.plan ? PLANS[opts.plan] : undefined;
+    const notes = [
+        price ? fill(P.yours, { plan: planName[opts.plan] ?? opts.plan, price, multiple: (perMonth / price).toFixed(1) }) : P.noPlan,
+        paint('dim', P.note),
+    ];
+    const json = {
+        months: months.map((r) => ({ month: r[0], days: r[1], cost: round(r[2]), per30Days: round(r[3]), limitHits: r[r.length - 1] })),
+        total: { days: foot[1], cost: round(grand.cost), per30Days: round(perMonth), limitHits: foot[foot.length - 1] },
+        multiples: Object.fromEntries(plans.map(([k, p]) => [k, round(perMonth / p)])),
+        plan: opts.plan ?? null,
+    };
+    return { report, notes, json };
+}
+// ---------- 5-hour blocks
+// Claude's usage limits reset in 5-hour windows that start with the first message. With hourly data a
+// window starts at the top of its first active hour, and the next activity after it closes opens a new one.
+export function blocksReport(hours, limits, opts) {
+    const c = L().col;
+    const clock = localClock(opts.timezone);
+    const index = (d, h) => Date.UTC(+d.slice(0, 4), +d.slice(5, 7) - 1, +d.slice(8, 10), h) / 36e5;
+    const label = (i) => new Date(i * 36e5).toISOString().slice(0, 13).replace('T', ' ') + ':00';
+    const byHour = new Map();
+    for (const h of hours) {
+        const k = index(h.d, h.h);
+        const acc = byHour.get(k) ?? { cost: 0, calls: 0, tokens: 0 };
+        acc.cost += h.cost;
+        acc.calls += h.t[T.calls] ?? 0;
+        acc.tokens += contextTokens(h.t) + (h.t[T.output] ?? 0);
+        byHour.set(k, acc);
+    }
+    const blocks = [];
+    for (const k of [...byHour.keys()].sort((a, b) => a - b)) {
+        let b = blocks[blocks.length - 1];
+        if (!b || k >= b.start + 5)
+            blocks.push((b = { start: k, cost: 0, calls: 0, tokens: 0, hits: 0 }));
+        const v = byHour.get(k);
+        b.cost += v.cost;
+        b.calls += v.calls;
+        b.tokens += v.tokens;
+    }
+    for (const l of limits) {
+        if (l.status !== 'rejected')
+            continue;
+        const k = clock(l.ts), i = index(k.d, k.h);
+        const b = blocks.find((x) => i >= x.start && i < x.start + 5);
+        if (b)
+            b.hits++;
+    }
+    const now = clock((opts.now ?? new Date()).toISOString());
+    const nowAt = index(now.d, now.h) + now.min / 60;
+    const shown = opts.limit ? blocks.slice(-opts.limit) : blocks;
+    return {
+        cols: [col(c.start, 'text'), col(c.end, 'text'), col(c.calls, 'int'), col(c.tokens, 'tok'), col(c.cost, 'usd'), col(c.limitHits, 'int'), col(c.state, 'text')],
+        rows: shown.map((b) => {
+            const left = b.start + 5 - nowAt;
+            const active = nowAt >= b.start && left > 0;
+            const state = active ? fill(L().blocks.active, { left: `${Math.floor(left)}h ${Math.round((left % 1) * 60)}m` }) : '';
+            return [label(b.start), label(b.start + 5), b.calls, b.tokens, b.cost, b.hits, state];
+        }),
+        foot: [c.total, '', shown.reduce((a, b) => a + b.calls, 0), shown.reduce((a, b) => a + b.tokens, 0), shown.reduce((a, b) => a + b.cost, 0), shown.reduce((a, b) => a + b.hits, 0), ''],
+    };
+}

package/dist/scan.js

@@ -0,0 +1,178 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import { normModel } from "./pricing.js";
+import { CTX_BOUNDS, T, T_LEN, UNKNOWN } from "./types.js";
+const zeros = () => new Array(T_LEN).fill(0);
+// Snapshots are synced JSON; keep absent dimensions out of them instead of writing nulls.
+function defined(o) {
+    for (const k of Object.keys(o))
+        if (o[k] === undefined)
+            delete o[k];
+    return o;
+}
+// The git repository a working directory belongs to, so a session that cd's into src/foo still
+// counts for its repo. Missing directories (deleted since) resolve through their nearest existing
+// parent; worktrees resolve to their main repository. Falls back to the directory itself.
+export function projectRoot(cwd) {
+    // Walking up a relative path (or a Windows path read on macOS/Linux) would search wherever cc-cost runs from
+    if (!path.isAbsolute(cwd))
+        return cwd;
+    const home = os.homedir();
+    for (let dir = cwd;;) {
+        // a dotfiles repo in $HOME must not claim every project under it
+        if (dir !== home || dir === cwd) {
+            const git = path.join(dir, '.git');
+            try {
+                if (fs.statSync(git).isDirectory())
+                    return dir;
+                const gitdir = fs.readFileSync(git, 'utf8').match(/^gitdir:\s*(.+)$/m)?.[1]?.trim();
+                if (!gitdir)
+                    return dir;
+                const [main, worktree] = path.resolve(dir, gitdir).split(/[\\/]\.git[\\/]worktrees[\\/]/);
+                return worktree ? main : dir;
+            }
+            catch {
+                // no .git here, or the directory no longer exists
+            }
+        }
+        const up = path.dirname(dir);
+        if (up === dir)
+            return cwd;
+        dir = up;
+    }
+}
+function listJsonl(dir, out) {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        const p = path.join(dir, e.name);
+        if (e.isDirectory())
+            listJsonl(p, out);
+        else if (e.name.endsWith('.jsonl'))
+            out.push(p);
+    }
+}
+// ISO timestamp -> local date and hour in the given IANA zone
+export function localClock(timezone) {
+    const fmt = new Intl.DateTimeFormat('en-CA', {
+        timeZone: timezone, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hourCycle: 'h23',
+    });
+    return (iso) => {
+        const p = {};
+        for (const part of fmt.formatToParts(new Date(iso)))
+            p[part.type] = part.value;
+        return { d: `${p.year}-${p.month}-${p.day}`, h: Number(p.hour), min: Number(p.minute) };
+    };
+}
+function addUsage(t, u) {
+    const cc = u.cache_creation ?? {};
+    // Older transcripts only have the combined counter; treat it as the 5m tier.
+    const w5 = cc.ephemeral_5m_input_tokens ?? (cc.ephemeral_1h_input_tokens ? 0 : u.cache_creation_input_tokens ?? 0);
+    const w1 = cc.ephemeral_1h_input_tokens ?? 0;
+    const input = u.input_tokens ?? 0, read = u.cache_read_input_tokens ?? 0;
+    t[T.input] += input;
+    t[T.write5m] += w5;
+    t[T.write1h] += w1;
+    t[T.read] += read;
+    t[T.output] += u.output_tokens ?? 0;
+    t[T.calls] += 1;
+    t[T.thinking] += u.output_tokens_details?.thinking_tokens ?? 0;
+    t[T.webSearch] += u.server_tool_use?.web_search_requests ?? 0;
+    t[T.webFetch] += u.server_tool_use?.web_fetch_requests ?? 0;
+    const context = input + w5 + w1 + read;
+    t[T.maxContext] = Math.max(t[T.maxContext], context);
+    const bucket = CTX_BOUNDS.findIndex((b) => context < b);
+    t[T.ctx50k + (bucket < 0 ? CTX_BOUNDS.length : bucket)] += 1;
+}
+export async function scan(dirs, opts) {
+    const files = [];
+    for (const dir of dirs)
+        listJsonl(path.join(dir, 'projects'), files);
+    const calls = new Map();
+    const limits = new Map();
+    let duplicates = 0;
+    for (const file of files) {
+        const rl = readline.createInterface({ input: fs.createReadStream(file), crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (!line.includes('"usage"') && !line.includes('"quotaLimits"'))
+                continue;
+            let d;
+            try {
+                d = JSON.parse(line);
+            }
+            catch {
+                continue; // a line cut off by a crash or a concurrent write
+            }
+            const q = d.quotaLimits;
+            if (q && d.timestamp) {
+                // Retries inside one limit period share resetsAt; keep the first hit of each period.
+                const key = `${q.rateLimitType}|${q.status}|${q.resetsAt ?? d.timestamp}`;
+                const seen = limits.get(key);
+                if (!seen || d.timestamp < seen.ts)
+                    limits.set(key, { ts: d.timestamp, type: String(q.rateLimitType), status: String(q.status), ...(typeof q.resetsAt === 'number' && { resetsAt: q.resetsAt }) });
+            }
+            const msg = d.message;
+            if (d.type !== 'assistant' || !msg?.usage || !msg.model || msg.model === '<synthetic>' || !d.timestamp)
+                continue;
+            // Resume and compaction rewrite the same message into several files; streaming writes one
+            // line per content block with output_tokens still growing. Keep the most complete copy.
+            const key = `${msg.id}|${d.requestId}`;
+            const prev = calls.get(key);
+            if (prev)
+                duplicates++;
+            if (prev && (prev.usage.output_tokens ?? 0) >= (msg.usage.output_tokens ?? 0))
+                continue;
+            calls.set(key, {
+                ts: d.timestamp,
+                session: d.sessionId ?? '',
+                cwd: d.cwd ?? '',
+                model: msg.model,
+                usage: msg.usage,
+                agent: d.isSidechain ? d.attributionAgent || 'subagent' : undefined,
+                skill: d.attributionSkill,
+                mcp: d.attributionMcpServer,
+                effort: d.effort,
+                entrypoint: d.entrypoint,
+                background: d.sessionKind === 'bg',
+            });
+        }
+    }
+    const at = localClock(opts.timezone);
+    const projects = new Map();
+    const project = (cwd) => {
+        let name = projects.get(cwd);
+        if (name === undefined) {
+            name = (cwd && projectRoot(cwd).split(/[\\/]/).filter(Boolean).pop()) || UNKNOWN;
+            if (opts.anonymize)
+                name = 'p-' + createHash('sha256').update(name).digest('hex').slice(0, 8);
+            projects.set(cwd, name);
+        }
+        return name;
+    };
+    const rows = new Map(), hourly = new Map();
+    const sessions = {};
+    for (const c of calls.values()) {
+        const { d, h } = at(c.ts);
+        const m = normModel(c.model), f = c.usage.speed === 'fast' ? 1 : undefined, p = project(c.cwd);
+        const bg = c.background ? 1 : undefined;
+        const rowKey = [d, p, c.session, m, f, c.agent, c.skill, c.mcp, c.effort, c.entrypoint, bg].join('\0');
+        let row = rows.get(rowKey);
+        if (!row) {
+            row = defined({ d, p, s: c.session, m, f, a: c.agent, k: c.skill, x: c.mcp, e: c.effort, ep: c.entrypoint, bg, t: zeros() });
+            rows.set(rowKey, row);
+        }
+        addUsage(row.t, c.usage);
+        const hourKey = `${d}|${h}|${m}|${f}`;
+        let hr = hourly.get(hourKey);
+        if (!hr)
+            hourly.set(hourKey, (hr = defined({ d, h, m, f, t: zeros() })));
+        addUsage(hr.t, c.usage);
+        const s = (sessions[c.session] ??= { p, first: c.ts, last: c.ts });
+        if (c.ts < s.first)
+            s.first = c.ts;
+        if (c.ts > s.last)
+            s.last = c.ts;
+    }
+    return { rows: [...rows.values()], hourly: [...hourly.values()], sessions, limits: [...limits.values()], files: files.length, duplicates };
+}