guilt-max 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shobhit99
+
+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,41 @@
+# Guilt Max 😇🔥
+
+Feel bad about your Claude Code token spend — beautifully, in your terminal.
+
+Guilt Max reads your local Claude Code usage logs and shows you exactly how many
+trees you've torched, litres you've boiled, dollars you've evaporated, and how
+much of a 2am gremlin you really are. Then it lets an AI roast you.
+
+## Usage
+
+```bash
+npx guilt-max          # launch the interactive TUI
+guilt-max --no-ai      # skip the claude-CLI roast (use local fallback)
+guilt-max --json       # dump computed facts + stats as JSON
+guilt-max --data-dir <path>   # read logs from a specific directory
+```
+
+Navigate with `1`–`4` / `←` `→`, regenerate the roast with `r`, quit with `q`.
+
+## How it works
+
+- Reads `~/.claude/projects/**/*.jsonl` (dedupes by message+request id).
+- Computes cost from a bundled model-price snapshot.
+- Derives playful "guilt" facts and behavioral stats.
+- The Roast tab shells out to your installed `claude` CLI (no API key). If it's
+  unavailable, a local rule-based roast steps in.
+
+## Disclaimer
+
+The environmental and money numbers are **deliberately rough, playful
+approximations** — tunable in `src/factors.ts`. This is a fun project, not a
+carbon audit.
+
+## Development
+
+```bash
+npm install
+npm test
+npm run dev       # tsx src/cli.ts
+npm run build     # bundle to dist/ with tsup
+```

package/dist/cli.js

@@ -0,0 +1,643 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import React from "react";
+import { render } from "ink";
+
+// src/loader.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { homedir } from "os";
+import { join, basename } from "path";
+var DEFAULT_DIRS = [
+  join(homedir(), ".claude", "projects"),
+  join(homedir(), ".config", "claude", "projects")
+];
+async function findDataDir(dirs = DEFAULT_DIRS) {
+  for (const d of dirs) {
+    try {
+      if ((await stat(d)).isDirectory()) return d;
+    } catch {
+    }
+  }
+  return null;
+}
+function parseLine(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return { malformed: true };
+  }
+  const msg = obj?.message;
+  const usage = msg?.usage;
+  if (!usage || msg?.role !== "assistant") return {};
+  const ts = obj.timestamp ? new Date(obj.timestamp) : null;
+  if (!ts || Number.isNaN(ts.getTime())) return {};
+  const tool = usage.server_tool_use ?? {};
+  return {
+    record: {
+      timestamp: ts,
+      model: msg.model ?? "unknown",
+      project: obj.cwd ? basename(obj.cwd) : "unknown",
+      sessionId: obj.sessionId ?? "unknown",
+      inputTokens: usage.input_tokens ?? 0,
+      outputTokens: usage.output_tokens ?? 0,
+      cacheCreationTokens: usage.cache_creation_input_tokens ?? 0,
+      cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+      webSearches: tool.web_search_requests ?? 0,
+      webFetches: tool.web_fetch_requests ?? 0,
+      messageId: msg.id,
+      requestId: obj.requestId
+    }
+  };
+}
+async function loadUsage(opts) {
+  const dataDir = opts?.dataDir ?? await findDataDir();
+  if (!dataDir) return { records: [], skipped: 0, dataDir: null };
+  let entries;
+  try {
+    entries = await readdir(dataDir, { recursive: true });
+  } catch {
+    return { records: [], skipped: 0, dataDir: null };
+  }
+  const files = entries.filter((e) => e.endsWith(".jsonl")).map((e) => join(dataDir, e));
+  const seen = /* @__PURE__ */ new Set();
+  const records = [];
+  let skipped = 0;
+  for (const file of files) {
+    let content;
+    try {
+      content = await readFile(file, "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      const { record, malformed } = parseLine(line);
+      if (malformed) {
+        skipped++;
+        continue;
+      }
+      if (!record) continue;
+      if (record.messageId && record.requestId) {
+        const key = `${record.messageId}:${record.requestId}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+      }
+      records.push(record);
+    }
+  }
+  return { records, skipped, dataDir };
+}
+
+// src/pricing.ts
+var PRICES = {
+  "claude-opus-4": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-sonnet-4": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-haiku-3-5": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+  "claude-3-5-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-3-opus": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-3-haiku": { input: 0.25, output: 1.25, cacheRead: 0.03, cacheWrite: 0.3 }
+};
+function priceFor(model) {
+  let best = null;
+  for (const key of Object.keys(PRICES)) {
+    if (model.startsWith(key) && (best === null || key.length > best.length)) best = key;
+  }
+  return best ? PRICES[best] : null;
+}
+function isKnownModel(model) {
+  return priceFor(model) !== null;
+}
+function costOf(rec) {
+  const p = priceFor(rec.model);
+  if (!p) return 0;
+  const M = 1e6;
+  return (rec.inputTokens * p.input + rec.outputTokens * p.output + rec.cacheReadTokens * p.cacheRead + rec.cacheCreationTokens * p.cacheWrite) / M;
+}
+
+// src/aggregate.ts
+function pad(n) {
+  return String(n).padStart(2, "0");
+}
+function localDayKey(d) {
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+function aggregate(records) {
+  const byModel = {};
+  const byDay = {};
+  const byHour = new Array(24).fill(0);
+  const byDow = new Array(7).fill(0);
+  const byProject = {};
+  const sessionMap = /* @__PURE__ */ new Map();
+  let totalTokens = 0, inputTokens = 0, outputTokens = 0;
+  let cacheCreationTokens = 0, cacheReadTokens = 0;
+  let totalCostUsd = 0, unknownModelTokens = 0, webSearches = 0, webFetches = 0;
+  let firstSeen = null;
+  let lastSeen = null;
+  for (const r of records) {
+    const t = r.inputTokens + r.outputTokens + r.cacheCreationTokens + r.cacheReadTokens;
+    totalTokens += t;
+    inputTokens += r.inputTokens;
+    outputTokens += r.outputTokens;
+    cacheCreationTokens += r.cacheCreationTokens;
+    cacheReadTokens += r.cacheReadTokens;
+    webSearches += r.webSearches;
+    webFetches += r.webFetches;
+    const cost = costOf(r);
+    totalCostUsd += cost;
+    if (!isKnownModel(r.model)) unknownModelTokens += t;
+    byModel[r.model] ??= { tokens: 0, costUsd: 0 };
+    byModel[r.model].tokens += t;
+    byModel[r.model].costUsd += cost;
+    byDay[localDayKey(r.timestamp)] = (byDay[localDayKey(r.timestamp)] ?? 0) + t;
+    byHour[r.timestamp.getHours()] += t;
+    byDow[r.timestamp.getDay()] += t;
+    byProject[r.project] = (byProject[r.project] ?? 0) + t;
+    const s = sessionMap.get(r.sessionId);
+    if (!s) {
+      sessionMap.set(r.sessionId, {
+        id: r.sessionId,
+        start: r.timestamp,
+        end: r.timestamp,
+        tokens: t,
+        project: r.project
+      });
+    } else {
+      if (r.timestamp < s.start) s.start = r.timestamp;
+      if (r.timestamp > s.end) s.end = r.timestamp;
+      s.tokens += t;
+    }
+    if (!firstSeen || r.timestamp < firstSeen) firstSeen = r.timestamp;
+    if (!lastSeen || r.timestamp > lastSeen) lastSeen = r.timestamp;
+  }
+  return {
+    recordCount: records.length,
+    totalTokens,
+    inputTokens,
+    outputTokens,
+    cacheCreationTokens,
+    cacheReadTokens,
+    totalCostUsd,
+    unknownModelTokens,
+    webSearches,
+    webFetches,
+    byModel,
+    byDay,
+    byHour,
+    byDow,
+    byProject,
+    sessions: [...sessionMap.values()],
+    firstSeen,
+    lastSeen
+  };
+}
+
+// src/format.ts
+function fmtNum(n, decimals = 1) {
+  if (!Number.isFinite(n)) return "0";
+  const abs = Math.abs(n);
+  if (abs >= 1e3) return Math.round(n).toLocaleString("en-US");
+  if (abs >= 10) return n.toFixed(0);
+  return n.toFixed(decimals);
+}
+function fmtInt(n) {
+  return Math.round(n).toLocaleString("en-US");
+}
+function fmtUsd(n) {
+  return `$${n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+function fmtDuration(ms) {
+  const totalMin = Math.max(0, Math.round(ms / 6e4));
+  const h = Math.floor(totalMin / 60);
+  const m = totalMin % 60;
+  return h > 0 ? `${h}h ${m}m` : `${m}m`;
+}
+
+// src/factors.ts
+var FACTORS = {
+  ENERGY_WH_PER_1K_TOKENS: 0.4,
+  // Wh per 1,000 tokens
+  GRID_CO2_KG_PER_KWH: 0.4,
+  // grid carbon intensity
+  DC_WATER_L_PER_KWH: 1.8,
+  // data-center water per kWh
+  TREE_CO2_KG_PER_YEAR: 21,
+  // CO2 a tree sequesters per year
+  PHONE_KWH_PER_CHARGE: 0.019,
+  // energy to charge a phone
+  LED_WATTS: 10,
+  // LED bulb wattage
+  CAR_CO2_KG_PER_MILE: 0.25,
+  // gas car emissions per mile
+  LATTE_USD: 5,
+  NETFLIX_USD: 15.49,
+  PS5_USD: 499,
+  AVOCADO_TOAST_USD: 12,
+  WAR_AND_PEACE_TOKENS: 78e4,
+  TOKENS_PER_WORD: 1.33,
+  LIFETIME_SPOKEN_WORDS: 86e7
+};
+function energyKwh(totalTokens) {
+  return totalTokens / 1e3 * FACTORS.ENERGY_WH_PER_1K_TOKENS / 1e3;
+}
+function fact(key, emoji, value, unit, display, headline) {
+  return { key, emoji, value, unit, display, headline };
+}
+function guiltFacts(agg) {
+  const t = agg.totalTokens;
+  const kwh = energyKwh(t);
+  const co2 = kwh * FACTORS.GRID_CO2_KG_PER_KWH;
+  const water = kwh * FACTORS.DC_WATER_L_PER_KWH;
+  const trees = FACTORS.TREE_CO2_KG_PER_YEAR > 0 ? co2 / FACTORS.TREE_CO2_KG_PER_YEAR : 0;
+  const phones = FACTORS.PHONE_KWH_PER_CHARGE > 0 ? kwh / FACTORS.PHONE_KWH_PER_CHARGE : 0;
+  const ledHours = kwh / (FACTORS.LED_WATTS / 1e3);
+  const miles = FACTORS.CAR_CO2_KG_PER_MILE > 0 ? co2 / FACTORS.CAR_CO2_KG_PER_MILE : 0;
+  const cost = agg.totalCostUsd;
+  const lattes = cost / FACTORS.LATTE_USD;
+  const netflix = cost / FACTORS.NETFLIX_USD;
+  const ps5 = cost / FACTORS.PS5_USD;
+  const toasts = cost / FACTORS.AVOCADO_TOAST_USD;
+  const wap = t / FACTORS.WAR_AND_PEACE_TOKENS;
+  const words = t / FACTORS.TOKENS_PER_WORD;
+  const lifetimes = words / FACTORS.LIFETIME_SPOKEN_WORDS;
+  const opusTokens = Object.entries(agg.byModel).filter(([m]) => m.includes("opus")).reduce((s, [, v]) => s + v.tokens, 0);
+  const opusPct = t > 0 ? opusTokens / t * 100 : 0;
+  const freshInput = agg.inputTokens + agg.cacheCreationTokens;
+  const inputSide = freshInput + agg.cacheReadTokens;
+  const cacheMissPct = inputSide > 0 ? freshInput / inputSide * 100 : 0;
+  const environmental = [
+    fact("trees", "\u{1F333}", trees, "trees", fmtNum(trees), `\u{1F333} You've torched ${fmtNum(trees)} trees. The planet sends its regards.`),
+    fact("water", "\u{1F4A7}", water, "L", fmtNum(water), `\u{1F4A7} ${fmtNum(water)} L of water boiled off \u2014 a spa day for the data center.`),
+    fact("co2", "\u2601\uFE0F", co2, "kg", fmtNum(co2), `\u2601\uFE0F ${fmtNum(co2)} kg of CO\u2082. Your keyboard has a tailpipe now.`),
+    fact("kwh", "\u26A1", kwh, "kWh", fmtNum(kwh), `\u26A1 ${fmtNum(kwh)} kWh incinerated on your behalf.`),
+    fact("phones", "\u{1F4F1}", phones, "charges", fmtInt(phones), `\u{1F4F1} Enough juice to charge a phone ${fmtInt(phones)} times.`),
+    fact("ledHours", "\u{1F4A1}", ledHours, "hours", fmtInt(ledHours), `\u{1F4A1} ${fmtInt(ledHours)} hours of a lightbulb, gone.`),
+    fact("carMiles", "\u{1F697}", miles, "miles", fmtNum(miles), `\u{1F697} ${fmtNum(miles)} miles of driving in emissions.`)
+  ];
+  const money = [
+    fact("cost", "\u{1F4B8}", cost, "USD", fmtUsd(cost), `\u{1F4B8} ${fmtUsd(cost)} of cold, hard, evaporated cash.`),
+    fact("lattes", "\u2615", lattes, "lattes", fmtInt(lattes), `\u2615 That's ${fmtInt(lattes)} oat-milk lattes you'll never drink.`),
+    fact("netflix", "\u{1F4FA}", netflix, "months", fmtNum(netflix), `\u{1F4FA} ${fmtNum(netflix)} months of Netflix, up in smoke.`),
+    fact("ps5", "\u{1F3AE}", ps5, "PS5s", fmtNum(ps5), `\u{1F3AE} ${fmtNum(ps5)} PlayStation 5s. The physical kind.`),
+    fact("toasts", "\u{1F951}", toasts, "toasts", fmtInt(toasts), `\u{1F951} ${fmtInt(toasts)} avocado toasts. Millennials weep.`)
+  ];
+  const volume = [
+    fact("warAndPeace", "\u{1F4DA}", wap, "\xD7 War & Peace", fmtNum(wap), `\u{1F4DA} You've generated ${fmtNum(wap)}\xD7 War & Peace.`),
+    fact("lifetimes", "\u{1F5E3}\uFE0F", lifetimes, "lifetimes", fmtNum(lifetimes), `\u{1F5E3}\uFE0F ${fmtNum(lifetimes)} human lifetimes of non-stop talking.`),
+    fact("opusPct", "\u{1F451}", opusPct, "%", fmtNum(opusPct), `\u{1F451} ${fmtNum(opusPct)}% of your tokens were Opus. Champagne taste.`),
+    fact("cacheMissPct", "\u{1F5D1}\uFE0F", cacheMissPct, "%", fmtNum(cacheMissPct), `\u{1F5D1}\uFE0F ${fmtNum(cacheMissPct)}% cache-miss rate. You love paying full price.`),
+    fact("webSearches", "\u{1F50E}", agg.webSearches, "searches", fmtInt(agg.webSearches), `\u{1F50E} ${fmtInt(agg.webSearches)} web searches you could've Googled yourself.`)
+  ];
+  const byKey = {};
+  for (const f of [...environmental, ...money, ...volume]) byKey[f.key] = f;
+  return { environmental, money, volume, byKey };
+}
+
+// src/stats.ts
+var NIGHT_HOURS = /* @__PURE__ */ new Set([22, 23, 0, 1, 2, 3, 4]);
+function argmaxIndex(arr) {
+  let best = 0;
+  for (let i = 1; i < arr.length; i++) if (arr[i] > arr[best]) best = i;
+  return best;
+}
+function longestStreak(dayKeys) {
+  if (dayKeys.length === 0) return 0;
+  const days = [...new Set(dayKeys)].sort();
+  const toNum = (k) => {
+    const [y, m, d] = k.split("-").map(Number);
+    return Date.UTC(y, m - 1, d) / 864e5;
+  };
+  let best = 1;
+  let run = 1;
+  for (let i = 1; i < days.length; i++) {
+    if (toNum(days[i]) - toNum(days[i - 1]) === 1) run++;
+    else run = 1;
+    if (run > best) best = run;
+  }
+  return best;
+}
+function behaviorStats(records, agg) {
+  const total = agg.totalTokens;
+  let nightTokens = 0;
+  for (let h = 0; h < 24; h++) if (NIGHT_HOURS.has(h)) nightTokens += agg.byHour[h];
+  const nightOwlPct = total > 0 ? nightTokens / total * 100 : 0;
+  const peakHour = argmaxIndex(agg.byHour);
+  const weekendTokens = agg.byDow[0] + agg.byDow[6];
+  const weekendPct = total > 0 ? weekendTokens / total * 100 : 0;
+  let longest = { ms: 0, project: "\u2014" };
+  for (const s of agg.sessions) {
+    const ms = s.end.getTime() - s.start.getTime();
+    if (ms > longest.ms) longest = { ms, project: s.project };
+  }
+  let topProject = "\u2014";
+  let topProjectTokens = 0;
+  for (const [proj, tok] of Object.entries(agg.byProject)) {
+    if (tok > topProjectTokens) {
+      topProjectTokens = tok;
+      topProject = proj;
+    }
+  }
+  const streak = longestStreak(Object.keys(agg.byDay));
+  const isNightOwl = nightOwlPct >= 30 || NIGHT_HOURS.has(peakHour);
+  const headlines = {
+    nightOwl: `\u{1F989} ${fmtNum(nightOwlPct)}% of your tokens burned between 10pm and 5am.`,
+    peakHour: `\u23F0 Peak guilt hour: ${String(peakHour).padStart(2, "0")}:00.`,
+    weekend: `\u{1F4C6} ${fmtNum(weekendPct)}% on weekends. Rest is for the weak.`,
+    longestSession: `\u{1F525} Longest binge: ${fmtDuration(longest.ms)} in "${longest.project}".`,
+    mostAbused: `\u{1F3AF} Most-abused project: "${topProject}" (${fmtInt(topProjectTokens)} tokens).`,
+    streak: `\u{1F4C8} Longest daily streak: ${streak} day${streak === 1 ? "" : "s"}. Touch grass.`,
+    verdict: isNightOwl ? "\u{1F319} Verdict: certified night owl." : "\u{1F31E} Verdict: suspiciously well-adjusted."
+  };
+  return {
+    nightOwlPct,
+    peakHour,
+    isNightOwl,
+    weekendPct,
+    longestSessionMs: longest.ms,
+    longestSessionProject: longest.project,
+    mostAbusedProject: topProject,
+    mostAbusedProjectTokens: topProjectTokens,
+    longestStreakDays: streak,
+    headlines
+  };
+}
+
+// src/ai.ts
+import { execa } from "execa";
+var ALLOWED_COLORS = ["red", "green", "yellow", "blue", "magenta", "cyan"];
+var PROMPT = [
+  'You are a witty, playful roast-master for "Guilt Max", a tool that makes',
+  "developers feel (lightly) guilty about their AI token spend. You will receive",
+  "a JSON summary of one user's usage. Respond with ONLY a single JSON object,",
+  "no prose, of the exact shape:",
+  '{"roast": "<2-4 sentence playful, self-aware roast about their habits and spend>",',
+  ' "preset": {"persona": "<a fun 1-3 word persona title>",',
+  `  "accentColor": "<one of: ${ALLOWED_COLORS.join(", ")}>",`,
+  '  "headlineFactKey": "<one fact key from the payload factKeys array>"}}',
+  "Keep it funny, never cruel. British-tabloid energy."
+].join(" ");
+function buildPayload(agg, facts, stats) {
+  return {
+    totalTokens: agg.totalTokens,
+    costUsd: Number(agg.totalCostUsd.toFixed(2)),
+    topFacts: [...facts.environmental, ...facts.money, ...facts.volume].slice(0, 8).map((f) => f.headline),
+    nightOwlPct: Number(stats.nightOwlPct.toFixed(1)),
+    peakHour: stats.peakHour,
+    weekendPct: Number(stats.weekendPct.toFixed(1)),
+    opusPct: Number(facts.byKey["opusPct"]?.value.toFixed(1) ?? 0),
+    cacheMissPct: Number(facts.byKey["cacheMissPct"]?.value.toFixed(1) ?? 0),
+    mostAbusedProject: stats.mostAbusedProject,
+    factKeys: Object.keys(facts.byKey)
+  };
+}
+function parseRoast(raw) {
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end <= start) return null;
+  try {
+    const obj = JSON.parse(raw.slice(start, end + 1));
+    if (typeof obj?.roast !== "string" || typeof obj?.preset?.persona !== "string") return null;
+    return {
+      roast: obj.roast,
+      preset: {
+        persona: obj.preset.persona,
+        accentColor: obj.preset.accentColor,
+        headlineFactKey: obj.preset.headlineFactKey
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function sanitizePreset(p, facts) {
+  return {
+    persona: p.persona?.slice(0, 40) || "Token Gremlin",
+    accentColor: ALLOWED_COLORS.includes(p.accentColor) ? p.accentColor : "cyan",
+    headlineFactKey: Object.prototype.hasOwnProperty.call(facts.byKey, p.headlineFactKey) ? p.headlineFactKey : "trees"
+  };
+}
+function localPreset(agg, facts, stats) {
+  const opusPct = facts.byKey["opusPct"]?.value ?? 0;
+  const cacheMiss = facts.byKey["cacheMissPct"]?.value ?? 0;
+  if (stats.nightOwlPct >= 50) return { persona: "Night Owl", accentColor: "magenta", headlineFactKey: "kwh" };
+  if (opusPct >= 40) return { persona: "Opus Aristocrat", accentColor: "yellow", headlineFactKey: "cost" };
+  if (agg.totalCostUsd >= 200) return { persona: "Big Spender", accentColor: "red", headlineFactKey: "cost" };
+  if (cacheMiss >= 60) return { persona: "Cache Criminal", accentColor: "blue", headlineFactKey: "cacheMissPct" };
+  return { persona: "Token Gremlin", accentColor: "green", headlineFactKey: "trees" };
+}
+function localRoast(preset, facts, stats) {
+  const trees = facts.byKey["trees"]?.display ?? "0";
+  const cost = fmtUsd(facts.byKey["cost"]?.value ?? 0);
+  return [
+    `${preset.persona}, is it? ${cost} and ${trees} trees later, here we are.`,
+    stats.isNightOwl ? "The 2am sessions are showing." : "At least you sleep.",
+    "The models thank you for your service. The planet, less so."
+  ].join(" ");
+}
+var defaultRunner = async (input) => {
+  const { stdout } = await execa("claude", ["-p", PROMPT], { input, timeout: 6e4 });
+  return stdout;
+};
+async function generateRoast(ctx, opts) {
+  const fallback = () => {
+    const preset = localPreset(ctx.agg, ctx.facts, ctx.stats);
+    return { roast: localRoast(preset, ctx.facts, ctx.stats), preset, offline: true };
+  };
+  if (opts?.noAi) return fallback();
+  try {
+    const raw = await (opts?.runner ?? defaultRunner)(JSON.stringify(buildPayload(ctx.agg, ctx.facts, ctx.stats)));
+    const parsed = parseRoast(raw);
+    if (!parsed) return fallback();
+    return { roast: parsed.roast, preset: sanitizePreset(parsed.preset, ctx.facts), offline: false };
+  } catch {
+    return fallback();
+  }
+}
+
+// src/tui/App.tsx
+import { useState, useEffect, useRef, useCallback } from "react";
+import { Box as Box5, Text as Text5, useApp, useInput, useStdout } from "ink";
+
+// src/tui/tabs/Guilt.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function GuiltTab({ facts, accent }) {
+  const rows = [...facts.environmental, ...facts.money, ...facts.volume];
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { color: accent, bold: true, children: "Your crimes against the planet & your wallet:" }),
+    rows.map((f) => /* @__PURE__ */ jsx(Text, { children: f.headline }, f.key))
+  ] });
+}
+
+// src/tui/tabs/Charts.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/charts.ts
+var BLOCKS = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+function level(value, max) {
+  if (max <= 0) return BLOCKS[0];
+  const idx = Math.round(value / max * (BLOCKS.length - 1));
+  return BLOCKS[Math.min(BLOCKS.length - 1, Math.max(0, idx))];
+}
+function sparkline(values) {
+  const max = Math.max(0, ...values);
+  return values.map((v) => level(v, max)).join("");
+}
+function hourHeatmap(byHour) {
+  const max = Math.max(0, ...byHour);
+  return byHour.map((v) => level(v, max)).join("");
+}
+function barChart(data, width = 24) {
+  const max = Math.max(0, ...data.map(([, v]) => v));
+  const labelW = Math.max(0, ...data.map(([l]) => l.length));
+  return data.map(([label, val]) => {
+    const len = max > 0 ? Math.round(val / max * width) : 0;
+    return `${label.padEnd(labelW)} ${"\u2588".repeat(len)}`;
+  });
+}
+
+// src/tui/tabs/Charts.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ChartsTab({ agg }) {
+  const days = Object.keys(agg.byDay).sort();
+  const recentDays = days.slice(-60);
+  const daily = recentDays.map((d) => agg.byDay[d]);
+  const models = Object.entries(agg.byModel).map(([m, v]) => [m.replace("claude-", ""), v.tokens]).sort((a, b) => b[1] - a[1]);
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Text2, { bold: true, children: [
+      "Daily tokens",
+      days.length > 60 ? " (last 60 days)" : ""
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { children: daily.length ? sparkline(daily) : "(no data)" }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Hour of day (local)" }) }),
+    /* @__PURE__ */ jsx2(Text2, { children: hourHeatmap(agg.byHour) }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "0     6     12    18" }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { bold: true, children: "By model (tokens)" }) }),
+    barChart(models, 20).map((line, i) => /* @__PURE__ */ jsx2(Text2, { children: line }, i))
+  ] });
+}
+
+// src/tui/tabs/Behavior.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function BehaviorTab({ stats }) {
+  const order = ["verdict", "nightOwl", "peakHour", "weekend", "longestSession", "mostAbused", "streak"];
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: order.map((k) => /* @__PURE__ */ jsx3(Text3, { children: stats.headlines[k] }, k)) });
+}
+
+// src/tui/tabs/Roast.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function RoastTab({ result, loading }) {
+  if (loading || !result) {
+    return /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "\u{1F525} Summoning your personalized roast\u2026" });
+  }
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Text4, { color: result.preset.accentColor, bold: true, children: [
+      "\u258D ",
+      result.preset.persona
+    ] }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { children: result.roast }) }),
+    result.offline && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "(offline roast \u2014 claude CLI unavailable)" }) }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "press r to regenerate" }) })
+  ] });
+}
+
+// src/tui/App.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var TABS = ["Guilt", "Charts", "Behavior", "Roast"];
+function App({ agg, facts, stats, accent = "cyan", noAi }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [tab, setTab] = useState(0);
+  const [roast, setRoast] = useState(null);
+  const [roastLoading, setRoastLoading] = useState(false);
+  const roastStarted = useRef(false);
+  const runRoast = useCallback(() => {
+    setRoastLoading(true);
+    generateRoast({ agg, facts, stats }, { noAi }).then((r) => {
+      setRoast(r);
+      setRoastLoading(false);
+    });
+  }, [agg, facts, stats, noAi]);
+  useEffect(() => {
+    if (tab === 3 && !roastStarted.current) {
+      roastStarted.current = true;
+      runRoast();
+    }
+  }, [tab, runRoast]);
+  useInput((input, key) => {
+    if (input === "q" || key.ctrl && input === "c") exit();
+    else if (key.leftArrow) setTab((t) => (t + TABS.length - 1) % TABS.length);
+    else if (key.rightArrow || key.tab) setTab((t) => (t + 1) % TABS.length);
+    else if (["1", "2", "3", "4"].includes(input)) setTab(Number(input) - 1);
+    else if (input === "r" && tab === 3) runRoast();
+  });
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", borderStyle: "round", paddingX: 1, minHeight: stdout?.rows ?? 24, children: [
+    /* @__PURE__ */ jsxs4(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "GUILT MAX  " }),
+      TABS.map((label, i) => /* @__PURE__ */ jsxs4(Text5, { color: i === tab ? accent : "gray", bold: i === tab, children: [
+        "[",
+        i + 1,
+        "]",
+        label,
+        "  "
+      ] }, label))
+    ] }),
+    /* @__PURE__ */ jsxs4(Box5, { marginTop: 1, flexDirection: "column", children: [
+      tab === 0 && /* @__PURE__ */ jsx5(GuiltTab, { facts, accent }),
+      tab === 1 && /* @__PURE__ */ jsx5(ChartsTab, { agg }),
+      tab === 2 && /* @__PURE__ */ jsx5(BehaviorTab, { stats }),
+      tab === 3 && /* @__PURE__ */ jsx5(RoastTab, { result: roast, loading: roastLoading })
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2190\u2192 / 1-4 switch \xB7 r roast \xB7 q quit" }) })
+  ] });
+}
+
+// src/cli.ts
+function getFlag(args, name) {
+  const eq = args.find((a) => a.startsWith(`--${name}=`));
+  if (eq) return eq.slice(name.length + 3);
+  const idx = args.indexOf(`--${name}`);
+  if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith("--")) return args[idx + 1];
+  return void 0;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const noAi = args.includes("--no-ai");
+  const dataDir = getFlag(args, "data-dir");
+  const jsonOut = args.includes("--json") || !process.stdout.isTTY;
+  const { records, skipped, dataDir: found } = await loadUsage(dataDir ? { dataDir } : void 0);
+  if (!found || records.length === 0) {
+    console.error("\u{1F607} No Claude usage found. Looked in ~/.claude/projects (and ~/.config/claude/projects).");
+    console.error("   Use Claude Code a bit, then come back to feel bad about it.");
+    process.exit(0);
+  }
+  const agg = aggregate(records);
+  const facts = guiltFacts(agg);
+  const stats = behaviorStats(records, agg);
+  if (jsonOut) {
+    process.stdout.write(JSON.stringify({ agg, facts, stats, skipped }, null, 2) + "\n");
+    return;
+  }
+  const accent = localPreset(agg, facts, stats).accentColor;
+  const enterAltScreen = "\x1B[?1049h";
+  const leaveAltScreen = "\x1B[?1049l";
+  let restored = false;
+  const restore = () => {
+    if (restored) return;
+    restored = true;
+    process.stdout.write(leaveAltScreen);
+  };
+  process.stdout.write(enterAltScreen);
+  process.on("exit", restore);
+  const { waitUntilExit } = render(React.createElement(App, { agg, facts, stats, accent, noAi }));
+  await waitUntilExit();
+  restore();
+}
+main().catch((err) => {
+  console.error("guilt-max crashed:", err?.message ?? err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "guilt-max",
+  "version": "0.1.0",
+  "description": "Feel bad about your Claude Code token spend, beautifully, in your terminal.",
+  "type": "module",
+  "bin": { "guilt-max": "dist/cli.js" },
+  "files": ["dist"],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "cli",
+    "tui",
+    "ink",
+    "tokens",
+    "usage",
+    "cost",
+    "guilt"
+  ],
+  "author": "shobhit99 <shobhitbhosure7@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shobhit99/guilt-max.git"
+  },
+  "homepage": "https://github.com/shobhit99/guilt-max#readme",
+  "bugs": {
+    "url": "https://github.com/shobhit99/guilt-max/issues"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsup src/cli.ts --format esm --clean --target node18",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "execa": "^9.5.0",
+    "ink": "^5.1.0",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.9.0",
+    "@types/react": "^18.3.12",
+    "ink-testing-library": "^4.0.0",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.5"
+  },
+  "engines": { "node": ">=18" }
+}