cchubber 0.1.0

package/README.md

@@ -0,0 +1,104 @@
+# CC Hubber
+
+**What you spent. Why you spent it. Is that normal.**
+
+Offline CLI that reads your local Claude Code data and generates a diagnostic HTML report. No API keys. No telemetry. Everything stays on your machine.
+
+Built because Claude Code users had zero visibility into the [March 2026 cache bug](https://github.com/anthropics/claude-code/issues/41930) that silently inflated costs by 10-20x. Your `$100 plan` shouldn't feel like a `$20 plan`.
+
+![CC Hubber Report](https://raw.githubusercontent.com/azkhh/cchubber/master/screenshot.png)
+
+## What it does
+
+- **Cost breakdown** — Per-day, per-model, per-project cost calculated from your actual token counts
+- **Cache health grade** — Trend-weighted (recent 7 days dominate). If you hit the cache bug, you'll see D/F, not a misleading A
+- **Inflection point detection** — "Your efficiency dropped 4.7x starting March 29. Before: 360:1. After: 1,676:1."
+- **Anomaly detection** — Flags days where your cost/ratio deviates >2 standard deviations
+- **Cache break analysis** — Reads `~/.claude/tmp/cache-break-*.diff` files. Shows why your cache broke and how often
+- **CLAUDE.md cost analysis** — How much your rules files cost per message (cached vs uncached)
+- **Per-project breakdown** — Which project is eating your budget
+- **Live rate limits** — 5-hour and 7-day utilization (if OAuth token available)
+- **Shareable card** — Export your report as a PNG
+
+## Install
+
+```bash
+npx cchubber
+```
+
+Or install globally:
+
+```bash
+npm install -g cchubber
+cchubber
+```
+
+Requires Node.js 18+. Runs on macOS, Windows, and Linux.
+
+## Usage
+
+```bash
+cchubber                      # Scan and open HTML report
+cchubber --days 7             # Default view: last 7 days
+cchubber -o report.html       # Custom output path
+cchubber --no-open            # Don't auto-open in browser
+cchubber --json               # Machine-readable JSON output
+```
+
+## What it reads
+
+All data is local. Nothing leaves your machine.
+
+| Source | Path | What |
+|--------|------|------|
+| JSONL conversations | `~/.claude/projects/*/` | Token counts per message, per model, per session |
+| Stats cache | `~/.claude/stats-cache.json` | Pre-aggregated daily totals |
+| Session meta | `~/.claude/usage-data/session-meta/` | Duration, tool counts, lines changed |
+| Cache breaks | `~/.claude/tmp/cache-break-*.diff` | Why your prompt cache invalidated |
+| CLAUDE.md stack | `~/.claude/CLAUDE.md`, project-level | File sizes and per-message cost impact |
+| OAuth usage | `~/.claude/.credentials.json` | Live rate limit utilization |
+
+## The March 2026 cache bug
+
+Between v2.1.69 and v2.1.89, multiple bugs caused Claude Code's prompt cache to silently fail:
+
+- A sentinel replacement bug in the Bun fork dropped cache read rates from ~95% to 4-17%
+- The `--resume` flag caused full prompt-cache misses on every resume
+- One session generated 652,069 output tokens with no user input — $342 on a single session
+
+**v2.1.90 fixes most of these.** Update immediately: `claude update`
+
+CC Hubber detects whether you were affected by showing your cache efficiency trend over time. If you see a sharp inflection point, that's probably when it hit you.
+
+## Best practices (from the community)
+
+These tips surfaced during the March crisis. CC Hubber helps you verify whether they're working:
+
+- **Start fresh sessions per task** — don't try to extend long sessions
+- **Avoid `--resume` on older versions** — fixed in v2.1.90
+- **Switch to Sonnet 4.6 for routine work** — same quality, fraction of the quota
+- **Keep CLAUDE.md under 200 lines** — it's re-read on every message
+- **Use `/compact` every 30-40 tool calls** — prevents context bloat
+- **Create `.claudeignore`** — exclude `node_modules/`, `dist/`, `*.lock`
+- **Shift heavy work to off-peak hours** — outside 5am-11am PT weekdays
+
+## How cost is calculated
+
+Claude Code doesn't report costs for Max/Pro plans (`costUSD` is always 0). CC Hubber calculates costs from token counts using dynamic pricing from [LiteLLM](https://github.com/BerriAI/litellm), with hardcoded fallbacks.
+
+This gives you an **equivalent API cost** — what you would pay on the API tier for the same usage. Useful for understanding relative consumption, not for billing disputes.
+
+## Prior art
+
+- [ccusage](https://github.com/jikyo/ccusage) (12K+ stars) — token tracking and cost visualization
+- [Claude-Code-Usage-Monitor](https://github.com/nicobailon/Claude-Code-Usage-Monitor) — basic session tracking
+
+CC Hubber focuses on **diagnosis** — cache health grading, inflection detection, cache break analysis — not just accounting. If ccusage tells you *what* you spent, CC Hubber tells you *why* and whether it's normal.
+
+## License
+
+MIT
+
+## Credits
+
+Built by [@azkhh](https://x.com/asmirkn). Shipped with [Mover OS](https://moveros.dev).

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "cchubber",
+  "version": "0.1.0",
+  "description": "What you spent. Why you spent it. Is that normal. — Claude Code usage diagnosis with beautiful HTML reports.",
+  "type": "module",
+  "bin": {
+    "cchubber": "./src/cli/index.js"
+  },
+  "scripts": {
+    "start": "node src/cli/index.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "usage",
+    "tokens",
+    "cost",
+    "diagnosis",
+    "cache",
+    "analytics"
+  ],
+  "author": "Asmir Khan (@azkhh)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/azkhh/cchubber"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "src/**/*"
+  ]
+}

package/src/analyzers/anomaly-detector.js

@@ -0,0 +1,59 @@
+export function detectAnomalies(costAnalysis) {
+  const dailyCosts = costAnalysis.dailyCosts || [];
+  if (dailyCosts.length < 3) return { anomalies: [], hasAnomalies: false };
+
+  const costs = dailyCosts.filter(d => d.cost > 0.01).map(d => d.cost);
+  if (costs.length < 3) return { anomalies: [], hasAnomalies: false };
+
+  const mean = costs.reduce((a, b) => a + b, 0) / costs.length;
+  const variance = costs.reduce((sum, c) => sum + Math.pow(c - mean, 2), 0) / costs.length;
+  const stdDev = Math.sqrt(variance);
+
+  const anomalies = [];
+
+  for (const day of dailyCosts) {
+    if (day.cost < 0.01) continue;
+
+    const zScore = stdDev > 0 ? (day.cost - mean) / stdDev : 0;
+
+    if (Math.abs(zScore) > 2) {
+      // Check cache ratio too
+      const ratioAnomaly = day.cacheOutputRatio > 2000;
+
+      anomalies.push({
+        date: day.date,
+        cost: day.cost,
+        zScore: Math.round(zScore * 100) / 100,
+        severity: Math.abs(zScore) > 3 ? 'critical' : 'warning',
+        type: zScore > 0 ? 'spike' : 'dip',
+        avgCost: Math.round(mean * 100) / 100,
+        deviation: Math.round((day.cost - mean) * 100) / 100,
+        cacheRatioAnomaly: ratioAnomaly,
+        cacheOutputRatio: day.cacheOutputRatio,
+      });
+    }
+  }
+
+  // Trend detection: are costs increasing over time?
+  let trend = 'stable';
+  if (dailyCosts.length >= 7) {
+    const recent = dailyCosts.slice(-7).filter(d => d.cost > 0.01);
+    const older = dailyCosts.slice(0, -7).filter(d => d.cost > 0.01);
+    if (recent.length > 0 && older.length > 0) {
+      const recentAvg = recent.reduce((s, d) => s + d.cost, 0) / recent.length;
+      const olderAvg = older.reduce((s, d) => s + d.cost, 0) / older.length;
+      const change = ((recentAvg - olderAvg) / olderAvg) * 100;
+      if (change > 50) trend = 'rising_fast';
+      else if (change > 20) trend = 'rising';
+      else if (change < -50) trend = 'dropping_fast';
+      else if (change < -20) trend = 'dropping';
+    }
+  }
+
+  return {
+    anomalies: anomalies.sort((a, b) => b.cost - a.cost),
+    hasAnomalies: anomalies.length > 0,
+    stats: { mean: Math.round(mean * 100) / 100, stdDev: Math.round(stdDev * 100) / 100 },
+    trend,
+  };
+}

package/src/analyzers/cache-health.js

@@ -0,0 +1,135 @@
+export function analyzeCacheHealth(statsCache, cacheBreaks, days, dailyFromJSONL) {
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - days);
+
+  // Cache break analysis
+  const reasonCounts = {};
+  let totalBreaks = 0;
+
+  for (const brk of cacheBreaks) {
+    totalBreaks++;
+    for (const reason of brk.reasons) {
+      reasonCounts[reason] = (reasonCounts[reason] || 0) + 1;
+    }
+  }
+
+  // Sort reasons by frequency
+  const reasonsRanked = Object.entries(reasonCounts)
+    .sort((a, b) => b[1] - a[1])
+    .map(([reason, count]) => ({ reason, count, percentage: totalBreaks > 0 ? Math.round(count / totalBreaks * 100) : 0 }));
+
+  // Cache efficiency from stats cache
+  let totalCacheRead = 0;
+  let totalCacheWrite = 0;
+  let totalInput = 0;
+  let totalOutput = 0;
+
+  // Use JSONL data if available (more accurate), fallback to stats-cache
+  if (dailyFromJSONL && dailyFromJSONL.length > 0) {
+    const cutoffStr = cutoffDate.toISOString().split('T')[0];
+    for (const day of dailyFromJSONL.filter(d => d.date >= cutoffStr)) {
+      totalCacheRead += day.cacheReadTokens || 0;
+      totalCacheWrite += day.cacheCreationTokens || 0;
+      totalInput += day.inputTokens || 0;
+      totalOutput += day.outputTokens || 0;
+    }
+  } else if (statsCache?.modelUsage) {
+    for (const usage of Object.values(statsCache.modelUsage)) {
+      totalCacheRead += usage.cacheReadInputTokens || 0;
+      totalCacheWrite += usage.cacheCreationInputTokens || 0;
+      totalInput += usage.inputTokens || 0;
+      totalOutput += usage.outputTokens || 0;
+    }
+  }
+
+  // Cache hit rate: what % of input tokens were served from cache
+  const totalInputAttempts = totalCacheRead + totalCacheWrite + totalInput;
+  const cacheHitRate = totalInputAttempts > 0 ? (totalCacheRead / totalInputAttempts) * 100 : 0;
+
+  // Cache efficiency ratio: cache reads per output token (lower = more efficient)
+  const efficiencyRatio = totalOutput > 0 ? Math.round(totalCacheRead / totalOutput) : 0;
+
+  // Trend-weighted grade: recent 7 days count 3x more than older days
+  const grade = calculateGrade(efficiencyRatio, totalBreaks, days, dailyFromJSONL);
+
+  // Estimated cost savings from caching
+  // Without cache: all cache reads would be standard input ($5/M for Opus)
+  // With cache: reads are $0.50/M
+  const savingsFromCache = totalCacheRead / 1_000_000 * (5.0 - 0.50);
+
+  // Cost wasted from cache breaks (rough estimate)
+  // Each cache break forces a full re-read at write price ($6.25/M) instead of read price ($0.50/M)
+  // Estimate ~200K tokens re-cached per break
+  const wastedFromBreaks = totalBreaks * 200_000 / 1_000_000 * (6.25 - 0.50);
+
+  return {
+    totalCacheBreaks: totalBreaks,
+    reasonsRanked,
+    cacheHitRate: Math.round(cacheHitRate * 10) / 10,
+    efficiencyRatio,
+    grade,
+    savings: {
+      fromCaching: Math.round(savingsFromCache),
+      wastedFromBreaks: Math.round(wastedFromBreaks),
+    },
+    totals: {
+      cacheRead: totalCacheRead,
+      cacheWrite: totalCacheWrite,
+      input: totalInput,
+      output: totalOutput,
+    },
+  };
+}
+
+function calculateGrade(allTimeRatio, breaks, days, dailyFromJSONL) {
+  // Trend-weighted scoring: recent 7 days dominate the grade.
+  // A user with great all-time stats but a recent cache bug spike should get D/F.
+  let score = 100;
+
+  // Compute recent 7-day ratio from daily data
+  let recentRatio = allTimeRatio;
+  let olderRatio = allTimeRatio;
+
+  if (dailyFromJSONL && dailyFromJSONL.length > 0) {
+    const sorted = [...dailyFromJSONL].sort((a, b) => a.date.localeCompare(b.date));
+    const recent = sorted.slice(-7);
+    const older = sorted.slice(0, -7);
+
+    const recentOutput = recent.reduce((s, d) => s + (d.outputTokens || 0), 0);
+    const recentCacheRead = recent.reduce((s, d) => s + (d.cacheReadTokens || 0), 0);
+    recentRatio = recentOutput > 0 ? Math.round(recentCacheRead / recentOutput) : 0;
+
+    const olderOutput = older.reduce((s, d) => s + (d.outputTokens || 0), 0);
+    const olderCacheRead = older.reduce((s, d) => s + (d.cacheReadTokens || 0), 0);
+    olderRatio = olderOutput > 0 ? Math.round(olderCacheRead / olderOutput) : 0;
+  }
+
+  // Weighted ratio: 70% recent, 30% older (recent dominates)
+  const weightedRatio = dailyFromJSONL && dailyFromJSONL.length >= 7
+    ? Math.round(recentRatio * 0.7 + olderRatio * 0.3)
+    : allTimeRatio;
+
+  // Penalize based on weighted ratio
+  if (weightedRatio > 3000) score -= 45;
+  else if (weightedRatio > 2000) score -= 35;
+  else if (weightedRatio > 1500) score -= 28;
+  else if (weightedRatio > 1000) score -= 20;
+  else if (weightedRatio > 500) score -= 10;
+
+  // Extra penalty if recent is sharply worse than older (deterioration signal)
+  if (olderRatio > 0 && recentRatio > olderRatio * 2) {
+    score -= 15; // Recent degradation penalty
+  }
+
+  // Penalize high break frequency
+  const breaksPerDay = days > 0 ? breaks / days : 0;
+  if (breaksPerDay > 20) score -= 30;
+  else if (breaksPerDay > 10) score -= 20;
+  else if (breaksPerDay > 5) score -= 10;
+
+  if (score >= 90) return { letter: 'A', color: '#10b981', label: 'Excellent' };
+  if (score >= 75) return { letter: 'B', color: '#22d3ee', label: 'Good' };
+  if (score >= 60) return { letter: 'C', color: '#f59e0b', label: 'Fair' };
+  if (score >= 40) return { letter: 'D', color: '#f97316', label: 'Poor' };
+  return { letter: 'F', color: '#ef4444', label: 'Critical' };
+}

package/src/analyzers/cost-calculator.js

@@ -0,0 +1,357 @@
+import https from 'https';
+
+// Fallback pricing — used when LiteLLM fetch fails (per million tokens)
+const FALLBACK_PRICING = {
+  'claude-opus-4-6': { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.50 },
+  'claude-opus-4-5-20251101': { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.50 },
+  'claude-sonnet-4-6': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
+  'claude-sonnet-4-5-20250929': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
+  'claude-sonnet-4-20250514': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
+  'claude-haiku-4-5-20251001': { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.10 },
+  'default': { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.50 },
+};
+
+// Dynamic pricing cache (populated by fetchPricing)
+let dynamicPricing = null;
+
+/**
+ * Fetch latest pricing from LiteLLM. Returns map of model -> pricing.
+ * Falls back to hardcoded pricing on failure.
+ */
+export async function fetchPricing() {
+  if (dynamicPricing) return dynamicPricing;
+
+  try {
+    const data = await new Promise((resolve, reject) => {
+      const req = https.get('https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json', (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try { resolve(JSON.parse(body)); } catch { reject(new Error('Bad JSON')); }
+        });
+      });
+      req.on('error', reject);
+      req.setTimeout(5000, () => { req.destroy(); reject(new Error('Timeout')); });
+    });
+
+    // Parse LiteLLM format into our format
+    const pricing = {};
+    for (const [key, info] of Object.entries(data)) {
+      if (!key.startsWith('claude') && !key.includes('claude')) continue;
+
+      // LiteLLM uses per-token pricing, we use per-million
+      const inputPerM = (info.input_cost_per_token || 0) * 1_000_000;
+      const outputPerM = (info.output_cost_per_token || 0) * 1_000_000;
+      const cacheReadPerM = (info.cache_read_input_token_cost || 0) * 1_000_000;
+      const cacheWritePerM = (info.cache_creation_input_token_cost || 0) * 1_000_000;
+
+      if (inputPerM > 0) {
+        pricing[key] = { input: inputPerM, output: outputPerM, cacheWrite: cacheWritePerM || inputPerM * 1.25, cacheRead: cacheReadPerM || inputPerM * 0.1 };
+      }
+    }
+
+    if (Object.keys(pricing).length > 0) {
+      dynamicPricing = pricing;
+      return pricing;
+    }
+  } catch {
+    // Fall through to fallback
+  }
+
+  dynamicPricing = FALLBACK_PRICING;
+  return FALLBACK_PRICING;
+}
+
+const PRICING = FALLBACK_PRICING; // Sync access for calculateCost
+
+function getPricing(modelName) {
+  const source = dynamicPricing || PRICING;
+  // Try exact match
+  if (source[modelName]) return source[modelName];
+  // Try with/without claude/ prefix (LiteLLM uses "claude/claude-opus-4-6" format)
+  const altKey = 'claude/' + modelName;
+  if (source[altKey]) return source[altKey];
+  // Infer from name
+  if (modelName.includes('haiku')) return source['claude-haiku-4-5-20251001'] || PRICING['claude-haiku-4-5-20251001'];
+  if (modelName.includes('sonnet')) return source['claude-sonnet-4-6'] || PRICING['claude-sonnet-4-6'];
+  if (modelName.includes('opus')) return source['claude-opus-4-6'] || PRICING['claude-opus-4-6'];
+  return PRICING['default'];
+}
+
+function calculateCost(modelName, tokens) {
+  const pricing = getPricing(modelName);
+  const input = (tokens.inputTokens || 0) / 1_000_000 * pricing.input;
+  const output = (tokens.outputTokens || 0) / 1_000_000 * pricing.output;
+  const cacheWrite = (tokens.cacheCreationInputTokens || tokens.cacheCreationTokens || 0) / 1_000_000 * pricing.cacheWrite;
+  const cacheRead = (tokens.cacheReadInputTokens || tokens.cacheReadTokens || 0) / 1_000_000 * pricing.cacheRead;
+  return { input, output, cacheWrite, cacheRead, total: input + output + cacheWrite + cacheRead };
+}
+
+export function analyzeUsage(statsCache, sessionMeta, days, dailyFromJSONL, modelFromJSONL) {
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - days);
+  const cutoffStr = cutoffDate.toISOString().split('T')[0];
+
+  // PRIMARY: Use JSONL aggregated data (has actual token counts, we calculate costs)
+  if (dailyFromJSONL && dailyFromJSONL.length > 0) {
+    return analyzeFromJSONL(dailyFromJSONL, modelFromJSONL, sessionMeta, days, cutoffStr);
+  }
+
+  // FALLBACK: Use stats-cache (less detailed)
+  const dailyCosts = [];
+  let totalCost = 0;
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalCacheRead = 0;
+  let totalCacheWrite = 0;
+  let activeDays = 0;
+
+  if (statsCache?.modelUsage) {
+    // Calculate total from aggregate model usage
+    for (const [modelName, usage] of Object.entries(statsCache.modelUsage)) {
+      const cost = calculateCost(modelName, usage);
+      totalCost += cost.total;
+      totalInput += usage.inputTokens || 0;
+      totalOutput += usage.outputTokens || 0;
+      totalCacheRead += usage.cacheReadInputTokens || 0;
+      totalCacheWrite += usage.cacheCreationInputTokens || 0;
+    }
+  }
+
+  // Build daily view from dailyData
+  if (statsCache?.dailyData) {
+    for (const day of statsCache.dailyData) {
+      if (day.date < cutoffStr) continue;
+
+      let dayCost = 0;
+      let dayOutput = 0;
+      let dayCacheRead = 0;
+      const modelBreakdowns = [];
+
+      for (const model of day.models) {
+        const tokens = model.tokens || {};
+        const cost = calculateCost(model.modelName, {
+          inputTokens: tokens.inputTokens || tokens,
+          outputTokens: tokens.outputTokens || 0,
+          cacheCreationInputTokens: tokens.cacheCreationInputTokens || 0,
+          cacheReadInputTokens: tokens.cacheReadInputTokens || 0,
+        });
+
+        // If tokens is just a number (total), estimate breakdown
+        if (typeof tokens === 'number') {
+          dayCost += tokens / 1_000_000 * 0.50; // Rough estimate at cache read rate
+          dayCacheRead += tokens;
+        } else {
+          dayCost += cost.total;
+          dayOutput += tokens.outputTokens || 0;
+          dayCacheRead += tokens.cacheReadInputTokens || 0;
+        }
+
+        modelBreakdowns.push({
+          model: model.modelName,
+          cost: typeof tokens === 'number' ? tokens / 1_000_000 * 0.50 : cost.total,
+          tokens: typeof tokens === 'number' ? tokens : {
+            input: tokens.inputTokens || 0,
+            output: tokens.outputTokens || 0,
+            cacheRead: tokens.cacheReadInputTokens || 0,
+            cacheWrite: tokens.cacheCreationInputTokens || 0,
+          },
+        });
+      }
+
+      if (dayCost > 0.01) activeDays++;
+
+      const ratio = dayOutput > 0 ? Math.round(dayCacheRead / dayOutput) : 0;
+
+      dailyCosts.push({
+        date: day.date,
+        cost: dayCost,
+        outputTokens: dayOutput,
+        cacheReadTokens: dayCacheRead,
+        cacheOutputRatio: ratio,
+        messageCount: day.messageCount,
+        sessionCount: day.sessionCount,
+        toolCallCount: day.toolCallCount,
+        models: modelBreakdowns,
+      });
+    }
+  }
+
+  // Session analysis
+  const recentSessions = sessionMeta.filter(s => {
+    if (!s.startTime) return true;
+    return s.startTime >= cutoffStr;
+  });
+
+  const totalSessions = recentSessions.length;
+  const avgSessionDuration = totalSessions > 0
+    ? recentSessions.reduce((sum, s) => sum + s.durationMinutes, 0) / totalSessions
+    : 0;
+
+  const totalLinesAdded = recentSessions.reduce((sum, s) => sum + s.linesAdded, 0);
+  const totalLinesRemoved = recentSessions.reduce((sum, s) => sum + s.linesRemoved, 0);
+  const totalFilesModified = recentSessions.reduce((sum, s) => sum + s.filesModified, 0);
+
+  // Tool usage aggregation
+  const toolAgg = {};
+  for (const session of recentSessions) {
+    for (const [tool, count] of Object.entries(session.toolCounts || {})) {
+      toolAgg[tool] = (toolAgg[tool] || 0) + count;
+    }
+  }
+
+  // Model cost breakdown
+  const modelCosts = {};
+  for (const day of dailyCosts) {
+    for (const m of day.models) {
+      const name = cleanModelName(m.model);
+      if (!modelCosts[name]) modelCosts[name] = 0;
+      modelCosts[name] += m.cost;
+    }
+  }
+
+  const periodCost = dailyCosts.reduce((sum, d) => sum + d.cost, 0);
+  const avgDailyCost = activeDays > 0 ? periodCost / activeDays : 0;
+  const peakDay = dailyCosts.reduce((max, d) => d.cost > (max?.cost || 0) ? d : max, null);
+
+  return {
+    periodDays: days,
+    activeDays,
+    totalCost: periodCost,
+    avgDailyCost,
+    medianDailyCost: median(dailyCosts.filter(d => d.cost > 0.01).map(d => d.cost)),
+    peakDay,
+    dailyCosts,
+    modelCosts,
+    sessions: {
+      total: totalSessions,
+      avgDurationMinutes: avgSessionDuration,
+      totalLinesAdded,
+      totalLinesRemoved,
+      totalFilesModified,
+    },
+    toolUsage: toolAgg,
+    totals: {
+      inputTokens: totalInput,
+      outputTokens: totalOutput,
+      cacheReadTokens: totalCacheRead,
+      cacheWriteTokens: totalCacheWrite,
+    },
+  };
+}
+
+function cleanModelName(name) {
+  return (name || 'unknown')
+    .replace('claude-', '')
+    .replace(/-20\d{6}$/, '') // Remove date suffixes like -20251001
+    .replace(/^(opus|sonnet|haiku)-(\d+)-(\d+)$/, '$1 $2.$3') // opus-4-6 -> opus 4.6
+    .replace(/^(opus|sonnet|haiku)-(\d+)$/, '$1 $2') // opus-4 -> opus 4
+    .replace(/^(\w)/, c => c.toUpperCase()); // Capitalize first letter
+}
+
+function median(arr) {
+  if (arr.length === 0) return 0;
+  const sorted = [...arr].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+
+function analyzeFromJSONL(dailyFromJSONL, modelFromJSONL, sessionMeta, days, cutoffStr) {
+  const filtered = dailyFromJSONL.filter(d => d.date >= cutoffStr);
+
+  // Calculate costs from token counts (costUSD is 0 for Max plan users)
+  const dailyCosts = filtered.map(d => {
+    let dayCost = 0;
+    const modelBreakdowns = [];
+
+    for (const [modelName, m] of Object.entries(d.models)) {
+      const cost = calculateCost(modelName, {
+        inputTokens: m.inputTokens,
+        outputTokens: m.outputTokens,
+        cacheCreationTokens: m.cacheCreationTokens,
+        cacheReadTokens: m.cacheReadTokens,
+      });
+      dayCost += cost.total;
+      modelBreakdowns.push({
+        model: modelName,
+        cost: cost.total,
+        tokens: {
+          input: m.inputTokens,
+          output: m.outputTokens,
+          cacheRead: m.cacheReadTokens,
+          cacheWrite: m.cacheCreationTokens,
+        },
+      });
+    }
+
+    return {
+      date: d.date,
+      cost: dayCost,
+      outputTokens: d.outputTokens,
+      cacheReadTokens: d.cacheReadTokens,
+      cacheOutputRatio: d.cacheOutputRatio,
+      messageCount: d.messageCount,
+      sessionCount: d.sessionCount,
+      models: modelBreakdowns,
+    };
+  });
+
+  const activeDays = dailyCosts.filter(d => d.cost > 0.01).length;
+
+  // Model cost breakdown — from filtered daily data (must match period)
+  const modelCosts = {};
+  for (const day of dailyCosts) {
+    for (const m of day.models) {
+      const name = cleanModelName(m.model);
+      if (!modelCosts[name]) modelCosts[name] = 0;
+      modelCosts[name] += m.cost;
+    }
+  }
+
+  // Session analysis
+  const recentSessions = (sessionMeta || []).filter(s => {
+    if (!s.startTime) return true;
+    return s.startTime >= cutoffStr;
+  });
+
+  const totalSessions = recentSessions.length;
+  const avgSessionDuration = totalSessions > 0
+    ? recentSessions.reduce((sum, s) => sum + s.durationMinutes, 0) / totalSessions
+    : 0;
+
+  const periodCost = dailyCosts.reduce((sum, d) => sum + d.cost, 0);
+  const avgDailyCost = activeDays > 0 ? periodCost / activeDays : 0;
+  const peakDay = dailyCosts.reduce((max, d) => d.cost > (max?.cost || 0) ? d : max, null);
+
+  // Totals
+  const totalInput = filtered.reduce((s, d) => s + d.inputTokens, 0);
+  const totalOutput = filtered.reduce((s, d) => s + d.outputTokens, 0);
+  const totalCacheRead = filtered.reduce((s, d) => s + d.cacheReadTokens, 0);
+  const totalCacheWrite = filtered.reduce((s, d) => s + d.cacheCreationTokens, 0);
+
+  return {
+    periodDays: days,
+    activeDays,
+    totalCost: periodCost,
+    avgDailyCost,
+    medianDailyCost: median(dailyCosts.filter(d => d.cost > 0.01).map(d => d.cost)),
+    peakDay,
+    dailyCosts,
+    modelCosts,
+    sessions: {
+      total: totalSessions,
+      avgDurationMinutes: avgSessionDuration,
+      totalLinesAdded: recentSessions.reduce((s, x) => s + x.linesAdded, 0),
+      totalLinesRemoved: recentSessions.reduce((s, x) => s + x.linesRemoved, 0),
+      totalFilesModified: recentSessions.reduce((s, x) => s + x.filesModified, 0),
+    },
+    totals: {
+      inputTokens: totalInput,
+      outputTokens: totalOutput,
+      cacheReadTokens: totalCacheRead,
+      cacheWriteTokens: totalCacheWrite,
+    },
+  };
+}
+
+export { PRICING, calculateCost, cleanModelName };