cchubber 0.5.7 → 0.6.0

package/src/analyzers/reprice.js

@@ -0,0 +1,154 @@
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { FRONTIER_MODELS } from '../data/frontier-models.js';
+import { PRICE_OVERRIDES } from '../data/price-overrides.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Bundled offline prices (30 Sep 2026). Read lazily so a missing file only costs the offline path.
+let snapshotCache = null;
+export function loadSnapshot() {
+  if (!snapshotCache) snapshotCache = JSON.parse(readFileSync(join(__dirname, '..', 'data', 'price-snapshot.json'), 'utf-8'));
+  return snapshotCache;
+}
+
+const PARTS = ['input', 'output', 'cacheRead', 'cacheWrite'];
+
+// LiteLLM lists dollars per token; 1.32e-6 * 1e6 is 1.3199999999999998 in floating point, so round to 10 significant digits.
+const perMillion = (perToken) => Number((perToken * 1e6).toPrecision(10));
+
+/** One LiteLLM entry to per-million prices exactly as listed. A price LiteLLM does not list is null. */
+export function priceFromLiteLLM(entry) {
+  const f = (v) => (v == null ? null : perMillion(v));
+  return {
+    input: f(entry.input_cost_per_token),
+    output: f(entry.output_cost_per_token),
+    cacheRead: f(entry.cache_read_input_token_cost),
+    cacheWrite: f(entry.cache_creation_input_token_cost),
+  };
+}
+
+/**
+ * Apply the two fill rules and record which fields they touched.
+ *   cache read missing            -> the input price (no discount assumed)
+ *   cache write missing or zero   -> the input price (the provider bills cache writes as ordinary input)
+ */
+export function resolvePrice(p) {
+  const filled = [];
+  let cacheRead = p.cacheRead;
+  let cacheWrite = p.cacheWrite;
+  if (cacheRead == null) { cacheRead = p.input; filled.push('cacheRead'); }
+  if (cacheWrite == null || cacheWrite === 0) { cacheWrite = p.input; filled.push('cacheWrite'); }
+  return { price: { input: p.input, output: p.output, cacheRead, cacheWrite }, filled };
+}
+
+const usable = (p) => p && p.input > 0 && p.output > 0;
+
+function costParts(tokens, price) {
+  const parts = {
+    input: tokens.input / 1e6 * price.input,
+    output: tokens.output / 1e6 * price.output,
+    cacheRead: tokens.cacheRead / 1e6 * price.cacheRead,
+    cacheWrite: tokens.cacheWrite / 1e6 * price.cacheWrite,
+  };
+  return { parts, total: parts.input + parts.output + parts.cacheRead + parts.cacheWrite };
+}
+
+/**
+ * Find a model's raw per-million prices. LiteLLM live data wins; a manual override is used only when LiteLLM has no
+ * entry for the id; the bundled snapshot stands in when the fetch failed (and as the last resort online).
+ */
+function findPrice(id, { raw, snapshot, overrides }) {
+  const live = raw && raw[id] ? priceFromLiteLLM(raw[id]) : null;
+  if (usable(live)) return { source: 'litellm', raw: live };
+  const snap = snapshot?.models?.[id];
+  const ovr = overrides?.[id];
+  const fromOverride = ovr?.intro ? { source: 'override', raw: { cacheRead: null, cacheWrite: null, ...ovr.intro }, ovr } : null;
+  const fromSnapshot = usable(snap) ? { source: 'snapshot', raw: { cacheRead: null, cacheWrite: null, ...snap } } : null;
+  const order = raw ? [fromOverride, fromSnapshot] : [fromSnapshot, fromOverride];
+  return order.find(Boolean) || null;
+}
+
+/**
+ * Reprice the user's own token totals on each listed model's list price.
+ * `opts` exists so tests can pass a fixed price table: { raw (LiteLLM JSON or null = offline), fetchedAt, snapshot, overrides, models }.
+ */
+export function reprice(costAnalysis, opts = {}) {
+  const raw = opts.raw || null;
+  const models = opts.models || FRONTIER_MODELS;
+  const overrides = opts.overrides || PRICE_OVERRIDES;
+  const lookup = { raw, overrides, snapshot: opts.snapshot || safeSnapshot() };
+
+  const t = costAnalysis.totals || {};
+  const tokens = {
+    input: t.inputTokens || 0,
+    output: t.outputTokens || 0,
+    cacheRead: t.cacheReadTokens || 0,
+    cacheWrite: t.cacheWriteTokens || 0,
+  };
+
+  const rows = [];
+  const dailyDays = costAnalysis.dailyCosts || [];
+  for (const m of models) {
+    const found = findPrice(m.id, lookup);
+    if (!found) continue;
+    const { price, filled } = resolvePrice(found.raw);
+    const { parts, total } = costParts(tokens, price);
+    const row = {
+      id: m.id, label: m.label, maker: m.maker,
+      price, parts, total,
+      cacheShare: total > 0 ? (parts.cacheRead + parts.cacheWrite) / total : 0,
+      source: found.source,
+      filled,
+    };
+    if (found.ovr) {
+      row.sourceUrl = found.ovr.sourceUrl;
+      row.sourceName = found.ovr.sourceName;
+      row.checked = found.ovr.checked;
+      row.note = found.ovr.note;
+      row.assumption = found.ovr.assumption;
+      if (found.ovr.after) {
+        const a = resolvePrice({ cacheRead: null, cacheWrite: null, ...found.ovr.after });
+        const c = costParts(tokens, a.price);
+        row.after = { price: a.price, parts: c.parts, total: c.total, filled: a.filled };
+      }
+    }
+    rows.push(row);
+  }
+  rows.sort((a, b) => b.total - a.total);
+
+  // Running total per day, from each day's per-model token counts priced at this model's rates.
+  const dates = dailyDays.map(d => d.date);
+  const perModel = {};
+  for (const r of rows) {
+    let cum = 0;
+    perModel[r.id] = dailyDays.map(d => {
+      for (const dm of d.models || []) {
+        const tk = dm.tokens;
+        if (!tk || typeof tk !== 'object') continue;
+        cum += costParts({ input: tk.input || 0, output: tk.output || 0, cacheRead: tk.cacheRead || 0, cacheWrite: tk.cacheWrite || 0 }, r.price).total;
+      }
+      return round2(cum);
+    });
+  }
+  let actualCum = 0;
+  const actual = dailyDays.map(d => { actualCum += d.cost || 0; return round2(actualCum); });
+
+  return {
+    models: rows,
+    actualListCost: costAnalysis.totalCost || 0,
+    tokens,
+    readPerWrite: tokens.output > 0 ? (tokens.input + tokens.cacheRead + tokens.cacheWrite) / tokens.output : 0,
+    dailyCum: { dates, perModel, actual },
+    fetchedAt: opts.fetchedAt ?? null,
+    offline: !raw,
+    ...(raw ? {} : { snapshotDate: (lookup.snapshot || {}).date || null }),
+  };
+}
+
+function safeSnapshot() {
+  try { return loadSnapshot(); } catch { return null; }
+}
+
+const round2 = (n) => Math.round(n * 100) / 100;

package/src/cli/index.js

@@ -5,7 +5,7 @@ import { existsSync, writeFileSync } from 'fs';
 import { homedir, platform } from 'os';
 import { exec } from 'child_process';
 import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { dirname } from 'path';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -18,7 +18,8 @@ import { readSessionMeta } from '../readers/session-meta.js';
 import { readCacheBreaks } from '../readers/cache-breaks.js';
 import { readClaudeMdStack } from '../readers/claude-md.js';
 import { readOAuthUsage } from '../readers/oauth-usage.js';
-import { analyzeUsage, fetchPricing } from '../analyzers/cost-calculator.js';
+import { analyzeUsage, fetchPricing, getLiteLLMRaw } from '../analyzers/cost-calculator.js';
+import { reprice } from '../analyzers/reprice.js';
 import { analyzeCacheHealth } from '../analyzers/cache-health.js';
 import { detectAnomalies } from '../analyzers/anomaly-detector.js';
 import { generateRecommendations } from '../analyzers/recommendations.js';
@@ -27,8 +28,13 @@ import { analyzeSessionIntelligence } from '../analyzers/session-intelligence.js
 import { analyzeModelRouting } from '../analyzers/model-routing.js';
 import { analyzeValueTrend } from '../analyzers/value-tracker.js';
 import { renderHTML } from '../renderers/html-report.js';
-import { renderTerminal } from '../renderers/terminal-summary.js';
-import { shouldSendTelemetry, sendTelemetry } from '../telemetry.js';
+import { renderTerminal, vsOneLiner } from '../renderers/terminal-summary.js';
+import { renderS1 } from '../renderers/s1-report.js';
+import { readPlan, monthsBilled } from '../readers/plan.js';
+import { runDrift } from '../analyzers/drift-run.js';
+import { renderDrift } from '../renderers/drift-report.js';
+import { shouldSendTelemetry, sendTelemetry, beaconConfig } from '../telemetry.js';
+import { spentWellLine } from '../renderers/spent-well.js';
 import { saveRun, getDelta, getHistory } from '../history.js';
 
 const args = process.argv.slice(2);
@@ -37,6 +43,13 @@ const flags = {
   json: args.includes('--json'),
   noTelemetry: args.includes('--no-telemetry'),
   noOpen: args.includes('--no-open'),
+  s1: args.includes('--s1'),
+  drift: args.includes('--drift'),
+  vs: args.includes('--vs'),
+  redact: args.includes('--redact'),
+  showProject: args.includes('--show-project'),
+  name: (() => { const i = args.indexOf('--name'); return i !== -1 && args[i + 1] ? args[i + 1] : null; })(),
+  plan: (() => { const i = args.indexOf('--plan'); return i !== -1 && args[i + 1] ? args[i + 1] : null; })(),
   output: (() => {
     const idx = args.indexOf('--output') !== -1 ? args.indexOf('--output') : args.indexOf('-o');
     return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
@@ -62,7 +75,13 @@ if (flags.help) {
     --days, -d <n>     Analyze last N days (default: 30)
     --output, -o <path> Output HTML report to custom path
     --no-open          Don't auto-open the report in browser
-    --json             Output raw analysis as JSON
+    --json             Output raw analysis as JSON (includes reprice: your usage on other models)
+    --s1               Your usage as an IPO prospectus (parody)
+    --name <name>      Company name on the S-1 (default: You)
+    --plan <usd>       Monthly plan price, if it can't be detected
+    --show-project     Name your top project on the S-1
+    --drift            Your week vs what you said you'd do (a shareable card)
+    --redact           On --drift, replace detour names with categories
     -h, --help         Show this help
 
   Examples:
@@ -70,6 +89,19 @@ if (flags.help) {
     cchubber --days 7           Last 7 days only
     cchubber -o report.html     Custom output path
     cchubber --json             Machine-readable output
+    cchubber --drift            How much of your week went to the plan
+    cchubber --drift --redact   Same, with detour names hidden
+
+  Your usage on other models needs no flag. The report that cchubber opens has
+  a section for it: your own tokens repriced on each frontier model's list
+  price, a race built from your real days, and buttons to download a card, copy
+  the text or post it on X. Prices come live from LiteLLM, plus a manual entry
+  for a listed model LiteLLM does not carry yet (used only until LiteLLM has
+  it). Offline it uses bundled prices dated 30 Sep 2026. When a plan you wrote
+  down is found (plan.md or similar) the section also shows how much of your
+  last week went to it, computed locally.
+  Same tokens on each model's list price, cache included. Another model would
+  use a different number of tokens, so this compares prices, not outcomes.
 
   Shipped with Mover OS at speed.
   https://moveros.dev
@@ -86,6 +118,13 @@ async function main() {
     process.exit(1);
   }
 
+  // Hidden, for scripts: `--vs --json` prints only the repricing (no report work). Plain `--vs` is an alias of the normal
+  // run that opens the report scrolled to its "Your usage on other models" section. Nothing needs the flag.
+  if (flags.vs && flags.json) return vsJsonMode(claudeDir);
+
+  // Drift report: its own local pipeline (last week of sessions vs your stated plan). No cost reading, no network.
+  if (flags.drift) return driftMode(claudeDir);
+
   console.log(`
     /\\  _  /\\
    /  \\(_)/  \\   CC Hubber v${VERSION}
@@ -157,6 +196,14 @@ async function main() {
   if (communityStats) console.log(`  ✓ Community data: ${communityStats.totalReports} users from ${Object.keys(communityStats.countries || {}).length} countries`);
   else console.log('  ○ Community data unavailable (offline)');
 
+  // Your usage on other models. Never allowed to break the normal run.
+  let vsData = null;
+  try {
+    const live = getLiteLLMRaw();
+    vsData = reprice(costAnalysis, { raw: live?.data, fetchedAt: live?.fetchedAt });
+    console.log(vsData.offline ? '  ○ Other-model prices offline: bundled prices as of 30 Sep 2026' : '  ✓ Other-model prices: LiteLLM');
+  } catch { vsData = null; }
+
   const report = {
     generatedAt: new Date().toISOString(),
     periodDays: flags.days,
@@ -172,6 +219,7 @@ async function main() {
     recommendations,
     valueTrend,
     communityStats,
+    reprice: vsData,
     history: getHistory(),
   };
 
@@ -198,6 +246,12 @@ async function main() {
 
   renderTerminal(report);
 
+  // One line on what the same tokens would cost elsewhere; the rest is in the report.
+  try { const line = vsOneLiner(vsData); if (line) console.log(`\n  ${line}`); } catch {}
+
+  // The report's "Did you spend them well?" strip, pointed at from the terminal.
+  try { const line = spentWellLine(report); if (line) console.log(`\n  ${line}`); } catch {}
+
   // Anonymous telemetry (opt out: --no-telemetry or CC_HUBBER_TELEMETRY=0)
   if (shouldSendTelemetry(flags)) {
     console.log('  ○ Sharing anonymous stats...');
@@ -205,27 +259,121 @@ async function main() {
     console.log('  ✓ Stats shared (opt out: --no-telemetry)');
   }
 
+  if (flags.s1) {
+    const plan = readPlan(flags.plan);
+    const s1Path = flags.output || join(process.cwd(), 'cchubber-s1.html');
+    writeFileSync(s1Path, renderS1(report, { plan, name: flags.name, showProject: flags.showProject }), 'utf-8');
+    console.log(`\n  ✓ Your S-1 saved to: ${s1Path}`);
+    if (!plan) console.log('  ○ Plan not detected. Add --plan 100 (or 20, 200) to show what you paid.');
+    if (!flags.noOpen) { openInBrowser(s1Path); console.log('  ✓ Opened in browser\n'); }
+    return;
+  }
+
   const outputPath = flags.output || join(process.cwd(), 'cchubber-report.html');
-  const html = renderHTML(report);
+  const vsCtx = vsData ? vsContext(claudeDir, vsData) : null;
+  const html = renderHTML(report, { vs: vsCtx, telemetry: beaconConfig(flags) });
   writeFileSync(outputPath, html, 'utf-8');
   console.log(`\n  ✓ Report saved to: ${outputPath}`);
 
   if (!flags.noOpen) {
-    openInBrowser(outputPath);
+    openInBrowser(outputPath, flags.vs ? 'vs' : '');
     console.log('  ✓ Opened in browser\n');
   }
 }
 
+// What the "other models" section needs beyond the repricing: the plan paid for (if detected), billing months over the
+// logged window, and the drift headline when a stated plan is found and computes locally (about 2 seconds).
+function vsContext(claudeDir, rp) {
+  const plan = readPlan(flags.plan);
+  const dates = rp.dailyCum.dates;
+  const months = dates.length ? monthsBilled(dates[0], dates[dates.length - 1], plan?.since) : 1;
+  let driftPct = null;
+  try {
+    const t0 = Date.now();
+    const days = flags.days === 30 ? 7 : flags.days;
+    const drift = runDrift(claudeDir, { days });
+    if (drift.available && drift.source?.planNames?.length) driftPct = Math.round(drift.share * 100);
+    console.log(driftPct != null ? `  ✓ Drift: ${driftPct}% of your last ${days} days on what you said you'd do (${((Date.now() - t0) / 1000).toFixed(1)}s)` : '  ○ No stated plan found, so no drift line');
+  } catch { driftPct = null; }
+  return { plan, months, driftPct };
+}
+
 function getClaudeDir() {
   const home = homedir();
   return join(home, '.claude');
 }
 
-function openInBrowser(filePath) {
+async function vsJsonMode(claudeDir) {
+  // Progress goes to stderr so stdout is clean JSON
+  const log = (m) => process.stderr.write(m + '\n');
+  log('  Reading local Claude Code data...');
+
+  const jsonlEntries = readAllJSONL(claudeDir);
+  const statsCache = readStatsCache(claudeDir);
+  if (jsonlEntries.length === 0 && !statsCache) {
+    console.error('  ✗ No usage data found. Use Claude Code first, then run CC Hubber.\n');
+    process.exit(1);
+  }
+  const sessionMeta = readSessionMeta(claudeDir);
+  const dailyFromJSONL = aggregateDaily(jsonlEntries);
+  const modelFromJSONL = aggregateByModel(jsonlEntries);
+
+  await fetchPricing();
+  const live = getLiteLLMRaw();
+  const costAnalysis = analyzeUsage(statsCache, sessionMeta, 99999, dailyFromJSONL, modelFromJSONL);
+  const rp = reprice(costAnalysis, { raw: live?.data, fetchedAt: live?.fetchedAt });
+  log(rp.offline ? '  ○ Offline: prices as of 30 Sep 2026 (bundled)' : '  ✓ Live prices from LiteLLM');
+  process.stdout.write(JSON.stringify(rp, null, 2) + '\n');
+}
+
+async function driftMode(claudeDir) {
+  const days = flags.days === 30 ? 7 : flags.days; // 7-day week by default; --days overrides
+  // Progress goes to stderr so `--drift --json` emits clean JSON on stdout
+  const log = flags.json ? (m) => process.stderr.write(m + '\n') : (m) => console.log(m);
+
+  log(`
+    /\\  _  /\\
+   /  \\(_)/  \\   CC Hubber v${VERSION} — Drift Report
+   \\  / ~ \\  /   How much of your week went to what you said you'd do.
+    \\/  ·  \\/
+  `);
+  log(`  Reading the last ${days} days of local sessions...\n`);
+
+  const drift = runDrift(claudeDir, { days });
+
+  if (!drift.available) {
+    console.error('  ✗ No agent work found in the window. Use Claude Code (or Codex) this week, then try again.\n');
+    process.exit(1);
+  }
+
+  const pct = Math.round(drift.share * 100);
+  log(`  ✓ ${drift.totals.prompts} prompts across ${drift.totals.sessions} sessions (${drift.inputs.claude} Claude${drift.inputs.codex ? `, ${drift.inputs.codex} Codex` : ''})`);
+  log(`  ✓ What you said you'd do: ${drift.source.planNames.length ? drift.source.planNames.join(' + ') : 'your first ask of each session'}`);
+  if (!drift.inputs.codexPresent) log('  ○ No Codex sessions found (skipped)');
+  log(`\n  ${pct}% of your agent time went to what you said you'd do.`);
+  log(`  ${Math.round(drift.totals.onMs / 3600000)}h on plan · ${Math.round(drift.totals.detourMs / 3600000)}h on detours\n`);
+  for (const d of drift.detours.slice(0, 5)) {
+    const label = flags.redact ? d.category : (d.name || d.category);
+    log(`    · ${label}  ${Math.max(1, Math.round(d.ms / 60000))}m`);
+  }
+  log('');
+
+  if (flags.json) { process.stdout.write(JSON.stringify(drift, null, 2) + '\n'); return; }
+
+  const outPath = flags.output || join(process.cwd(), 'cchubber-drift.html');
+  writeFileSync(outPath, renderDrift(drift, { redact: flags.redact }), 'utf-8');
+  log(`  ✓ Card saved to: ${outPath}`);
+  log('  ○ It stayed on this machine. Nothing was uploaded.' + (flags.redact ? '' : ' Use --redact to hide detour names.'));
+  if (!flags.noOpen) { openInBrowser(outPath); log('  ✓ Opened in browser\n'); }
+}
+
+function openInBrowser(filePath, hash = '') {
   const p = platform();
-  const cmd = p === 'win32' ? `start "" "${filePath}"`
-    : p === 'darwin' ? `open "${filePath}"`
-    : `xdg-open "${filePath}"`;
+  // A file URL lets the browser scroll to a #section; a bare path cannot carry one.
+  const target = hash ? `${pathToFileURL(filePath).href}#${hash}` : filePath;
+  const cmd = p === 'win32' ? `start "" "${target}"`
+    : p === 'darwin' ? `open "${target}"`
+    : `xdg-open "${target}"`;
   exec(cmd, (err) => { if (err) console.log('  ○ Could not auto-open browser. Open the file manually.'); });
 }
 

package/src/data/frontier-models.js

@@ -0,0 +1,12 @@
+// The explicit comparison list for --vs. `id` is the LiteLLM key (model_prices_and_context_window.json).
+// Edit this list to add or drop a model; nothing else needs to change.
+export const FRONTIER_MODELS = [
+  { id: 'claude-fable-5-1', label: 'Claude Fable 5.1', maker: 'Anthropic' },
+  { id: 'claude-opus-5-5', label: 'Claude Opus 5.5', maker: 'Anthropic' },
+  { id: 'claude-sonnet-5-5', label: 'Claude Sonnet 5.5', maker: 'Anthropic' },
+  { id: 'gpt-6-astra', label: 'GPT-6 Astra', maker: 'OpenAI' },
+  { id: 'gpt-6-sol', label: 'GPT-6 Sol', maker: 'OpenAI' },
+  { id: 'gemini-4-argon', label: 'Gemini 4 Argon', maker: 'Google' },
+  { id: 'deepseek-v4-pro', label: 'DeepSeek V4 Pro', maker: 'DeepSeek' },
+  { id: 'moonshot/kimi-k3', label: 'Kimi K3', maker: 'Moonshot' },
+];

package/src/data/price-overrides.js

@@ -0,0 +1,16 @@
+// Manual prices for listed models that LiteLLM does not carry yet. Used ONLY when LiteLLM has no entry for the id,
+// so live data wins the day LiteLLM adds the model. All prices are USD per million tokens.
+//
+// A missing cacheWrite is deliberate: Google lists no cache-write premium, so reprice.js bills writes at the input
+// rate and records that in `filled` (an assumption, not a published price).
+export const PRICE_OVERRIDES = {
+  'gemini-4-argon': {
+    intro: { input: 2, output: 10, cacheRead: 0.10 },   // cached input is 95% off the input price
+    after: { input: 4, output: 20, cacheRead: 0.20 },   // standard price once the introductory period ends
+    sourceUrl: 'https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-argon/',
+    sourceName: 'blog.google',
+    checked: '2026-09-30',
+    note: 'introductory price',
+    assumption: 'Google lists no cache-write premium, so cache writes are priced at the input rate.',
+  },
+};

package/src/data/price-snapshot.json

@@ -0,0 +1,49 @@
+{
+  "date": "2026-09-30",
+  "source": "LiteLLM model_prices_and_context_window.json",
+  "note": "USD per million tokens as LiteLLM lists them; null means the field is absent (reprice.js fills it from the input price).",
+  "models": {
+    "claude-fable-5-1": {
+      "input": 10,
+      "output": 50,
+      "cacheRead": 0.25,
+      "cacheWrite": 12.5
+    },
+    "claude-opus-5-5": {
+      "input": 4,
+      "output": 20,
+      "cacheRead": 0.2,
+      "cacheWrite": 5
+    },
+    "claude-sonnet-5-5": {
+      "input": 2,
+      "output": 10,
+      "cacheRead": 0.2,
+      "cacheWrite": 2.5
+    },
+    "gpt-6-astra": {
+      "input": 10,
+      "output": 50,
+      "cacheRead": 1,
+      "cacheWrite": 12.5
+    },
+    "gpt-6-sol": {
+      "input": 2,
+      "output": 10,
+      "cacheRead": 0.2,
+      "cacheWrite": 2.5
+    },
+    "deepseek-v4-pro": {
+      "input": 1.32,
+      "output": 3.96,
+      "cacheRead": 0.044,
+      "cacheWrite": 0
+    },
+    "moonshot/kimi-k3": {
+      "input": 3,
+      "output": 15,
+      "cacheRead": 0.3,
+      "cacheWrite": null
+    }
+  }
+}

package/src/readers/jsonl-reader.js

@@ -8,24 +8,21 @@ import { homedir } from 'os';
  * Claude Code stores full conversation transcripts with token usage per message.
  */
 export function readAllJSONL(claudeDir) {
-  const projectsDir = join(claudeDir, 'projects');
-  const xdgDir = join(homedir(), '.config', 'claude', 'projects'); // XDG fallback for Linux
-
   const entries = [];
-
-  // Read from primary location
-  if (existsSync(projectsDir)) {
-    readProjectsDir(projectsDir, entries);
-  }
-
-  // XDG fallback (Linux with newer Claude Code)
-  if (existsSync(xdgDir) && xdgDir !== projectsDir) {
-    readProjectsDir(xdgDir, entries);
-  }
-
+  for (const dir of projectRoots(claudeDir)) readProjectsDir(dir, entries);
   return entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
 }
 
+/**
+ * Where Claude Code keeps its transcripts: ~/.claude/projects, plus the XDG path newer Linux builds use.
+ * Shared with the drift reader so both read the same sessions.
+ */
+export function projectRoots(claudeDir) {
+  const projectsDir = join(claudeDir, 'projects');
+  const xdgDir = join(homedir(), '.config', 'claude', 'projects');
+  return [projectsDir, xdgDir].filter((d, i, all) => all.indexOf(d) === i && existsSync(d));
+}
+
 function readProjectsDir(dir, entries) {
   try {
     const projectHashes = readdirSync(dir).filter(f => {

package/src/readers/plan.js

@@ -0,0 +1,56 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// Monthly list prices from claude.com/pricing and the Max plan help page, checked 29 Sep 2026 (US web prices, before tax).
+const PLAN_PRICES = { pro: 20, max_5x: 100, max_20x: 200 };
+const PLAN_NAMES = { pro: 'Claude Pro', max_5x: 'Claude Max 5x', max_20x: 'Claude Max 20x' };
+
+// Reads only the plan tier and start date from ~/.claude.json. Tokens and keys in that file are never touched.
+export function readPlan(override) {
+  if (override) {
+    const usd = Number(override);
+    if (Number.isFinite(usd) && usd > 0) return { key: 'custom', name: 'your plan', monthlyUSD: usd, since: null };
+  }
+  const file = join(homedir(), '.claude.json');
+  if (!existsSync(file)) return null;
+  try {
+    const acct = JSON.parse(readFileSync(file, 'utf-8')).oauthAccount || {};
+    const tier = String(acct.organizationRateLimitTier || acct.userRateLimitTier || '').toLowerCase();
+    const key = tier.includes('max_20x') ? 'max_20x' : tier.includes('max_5x') ? 'max_5x' : tier.includes('pro') ? 'pro' : null;
+    if (!key) return null;
+    return { key, name: PLAN_NAMES[key], monthlyUSD: PLAN_PRICES[key], since: acct.subscriptionCreatedAt || null };
+  } catch {
+    return null;
+  }
+}
+
+// `d` plus `k` months, clamped to the last day of a shorter month: a plan billed on the 31st renews 28 Feb, 31 Mar, 30 Apr.
+// (setUTCMonth alone rolls 31 Jan + 1 month over to 3 Mar, which silently drops February.)
+function addMonths(d, k) {
+  const y = d.getUTCFullYear();
+  const m = d.getUTCMonth() + k;
+  const lastDay = new Date(Date.UTC(y, m + 1, 0)).getUTCDate();
+  return new Date(Date.UTC(y, m, Math.min(d.getUTCDate(), lastDay)));
+}
+
+// Billing months inside the window the logs cover: every charge whose month overlaps it. Counting only the logged window
+// keeps "paid" and "consumed" about the same days, since Claude Code prunes old transcripts by default.
+// Charges land on the subscription's own anniversary (`since`, when ~/.claude.json has it), not on the first logged day;
+// without it the first logged day stands in as the billing day.
+export function monthsBilled(firstDate, lastDate, since) {
+  const a = new Date(firstDate + 'T00:00:00Z');
+  const b = new Date(lastDate + 'T00:00:00Z');
+  if (isNaN(a) || isNaN(b) || b < a) return 1;
+  let anchor = a;
+  if (since) {
+    const s = new Date(String(since).slice(0, 10) + 'T00:00:00Z');
+    if (!isNaN(s) && s <= b) anchor = s;
+  }
+  let n = 0;
+  for (let k = 0; ; k++) {
+    if (addMonths(anchor, k) > b) break;
+    if (addMonths(anchor, k + 1) > a) n++;
+  }
+  return Math.max(1, n);
+}