guilt-max 0.1.0 → 0.1.1

package/README.md

@@ -17,6 +17,33 @@ guilt-max --data-dir <path>   # read logs from a specific directory
 
 Navigate with `1`–`4` / `←` `→`, regenerate the roast with `r`, quit with `q`.
 
+## `usage` — day-wise token & cost breakdown
+
+Prints a `ccusage`-style table (date · input · output · cache · total · cost) with a
+grand total, then exits — no TUI:
+
+```bash
+guilt-max usage          # daily breakdown + total (table)
+guilt-max usage --json   # same data as JSON (daily[], totals, machines[])
+```
+
+### Across all your machines
+
+guilt-max reads local Claude Code logs (`~/.claude/projects`), so a single machine
+only sees its own usage. To get your **combined** usage, copy each machine's
+`~/.claude/projects` into its own folder and point `--data-dir` at each (repeatable,
+or comma-separated). Records are merged and de-duplicated by message id, and each is
+tagged with its folder for the per-machine summary:
+
+```bash
+guilt-max usage --data-dir ~/claude-logs/laptop --data-dir ~/claude-logs/desktop
+```
+
+> Cost is estimated from a bundled price snapshot. On a Pro/Max subscription you pay a
+> flat fee, so the dollar figure is the **notional API-equivalent** value, not what you
+> were billed. (There is no Anthropic API that reports aggregate subscription usage, so
+> merging local logs is the only way to see all machines together.)
+
 ## How it works
 
 - Reads `~/.claude/projects/**/*.jsonl` (dedupes by message+request id).

package/dist/cli.js

@@ -52,42 +52,53 @@ function parseLine(line) {
   };
 }
 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 };
+  let dirs;
+  if (opts?.dataDirs?.length) dirs = opts.dataDirs;
+  else if (opts?.dataDir) dirs = [opts.dataDir];
+  else {
+    const found = await findDataDir();
+    dirs = found ? [found] : [];
   }
-  const files = entries.filter((e) => e.endsWith(".jsonl")).map((e) => join(dataDir, e));
   const seen = /* @__PURE__ */ new Set();
   const records = [];
+  const used = [];
   let skipped = 0;
-  for (const file of files) {
-    let content;
+  for (const dir of dirs) {
+    let entries;
     try {
-      content = await readFile(file, "utf8");
+      entries = await readdir(dir, { recursive: true });
     } catch {
       continue;
     }
-    for (const line of content.split("\n")) {
-      if (!line.trim()) continue;
-      const { record, malformed } = parseLine(line);
-      if (malformed) {
-        skipped++;
+    used.push(dir);
+    const source = basename(dir);
+    const files = entries.filter((e) => e.endsWith(".jsonl")).map((e) => join(dir, e));
+    for (const file of files) {
+      let content;
+      try {
+        content = await readFile(file, "utf8");
+      } catch {
         continue;
       }
-      if (!record) continue;
-      if (record.messageId && record.requestId) {
-        const key = `${record.messageId}:${record.requestId}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
+      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);
+        }
+        record.source = source;
+        records.push(record);
       }
-      records.push(record);
     }
   }
-  return { records, skipped, dataDir };
+  return { records, skipped, dataDir: used[0] ?? null, dataDirs: used };
 }
 
 // src/pricing.ts
@@ -456,6 +467,82 @@ async function generateRoast(ctx, opts) {
   }
 }
 
+// src/usage.ts
+function dailyUsage(records) {
+  const byDay = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const date = localDayKey(r.timestamp);
+    let d = byDay.get(date);
+    if (!d) {
+      d = { date, inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, totalTokens: 0, costUsd: 0 };
+      byDay.set(date, d);
+    }
+    d.inputTokens += r.inputTokens;
+    d.outputTokens += r.outputTokens;
+    d.cacheCreationTokens += r.cacheCreationTokens;
+    d.cacheReadTokens += r.cacheReadTokens;
+    d.totalTokens += r.inputTokens + r.outputTokens + r.cacheCreationTokens + r.cacheReadTokens;
+    d.costUsd += costOf(r);
+  }
+  return [...byDay.values()].sort((a, b) => a.date < b.date ? -1 : a.date > b.date ? 1 : 0);
+}
+function usageTotals(rows) {
+  return rows.reduce(
+    (t, r) => {
+      t.inputTokens += r.inputTokens;
+      t.outputTokens += r.outputTokens;
+      t.cacheCreationTokens += r.cacheCreationTokens;
+      t.cacheReadTokens += r.cacheReadTokens;
+      t.totalTokens += r.totalTokens;
+      t.costUsd += r.costUsd;
+      return t;
+    },
+    { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, totalTokens: 0, costUsd: 0 }
+  );
+}
+function byMachine(records) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const source = r.source ?? "local";
+    let m = map.get(source);
+    if (!m) {
+      m = { source, records: 0, totalTokens: 0, costUsd: 0 };
+      map.set(source, m);
+    }
+    m.records++;
+    m.totalTokens += r.inputTokens + r.outputTokens + r.cacheCreationTokens + r.cacheReadTokens;
+    m.costUsd += costOf(r);
+  }
+  return [...map.values()].sort((a, b) => b.totalTokens - a.totalTokens);
+}
+var COLUMNS = [
+  { header: "Date", align: "left", cell: (r) => r.date },
+  { header: "Input", align: "right", cell: (r) => fmtInt(r.inputTokens) },
+  { header: "Output", align: "right", cell: (r) => fmtInt(r.outputTokens) },
+  { header: "Cache Wr", align: "right", cell: (r) => fmtInt(r.cacheCreationTokens) },
+  { header: "Cache Rd", align: "right", cell: (r) => fmtInt(r.cacheReadTokens) },
+  { header: "Total", align: "right", cell: (r) => fmtInt(r.totalTokens) },
+  { header: "Cost", align: "right", cell: (r) => fmtUsd(r.costUsd) }
+];
+function padCell(s, width, align) {
+  return align === "right" ? s.padStart(width) : s.padEnd(width);
+}
+function renderUsageTable(rows, totals) {
+  const totalRow = { date: "TOTAL", ...totals };
+  const body = rows.map((r) => COLUMNS.map((c) => c.cell(r)));
+  const totalCells = COLUMNS.map((c) => c.cell(totalRow));
+  const widths = COLUMNS.map(
+    (c, i) => Math.max(c.header.length, totalCells[i].length, ...body.map((cells) => cells[i].length))
+  );
+  const gap = "  ";
+  const line = (cells) => cells.map((s, i) => padCell(s, widths[i], COLUMNS[i].align)).join(gap);
+  const sep = "-".repeat(widths.reduce((a, b) => a + b, 0) + gap.length * (COLUMNS.length - 1));
+  const out = [line(COLUMNS.map((c) => c.header)), sep];
+  for (const cells of body) out.push(line(cells));
+  out.push(sep, line(totalCells));
+  return out.join("\n");
+}
+
 // src/tui/App.tsx
 import { useState, useEffect, useRef, useCallback } from "react";
 import { Box as Box5, Text as Text5, useApp, useInput, useStdout } from "ink";
@@ -597,24 +684,53 @@ function App({ agg, facts, stats, accent = "cyan", noAi }) {
 }
 
 // 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;
+function getFlagAll(args, name) {
+  const out = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith(`--${name}=`)) out.push(a.slice(name.length + 3));
+    else if (a === `--${name}` && args[i + 1] && !args[i + 1].startsWith("--")) out.push(args[i + 1]);
+  }
+  return out.flatMap((v) => v.split(",")).map((s) => s.trim()).filter(Boolean);
 }
 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);
+  const dataDirs = getFlagAll(args, "data-dir");
+  const jsonFlag = args.includes("--json");
+  const jsonOut = jsonFlag || !process.stdout.isTTY;
+  const usageMode = args.includes("usage") || args.includes("daily") || args.includes("--usage");
+  const { records, skipped, dataDir: found, dataDirs: usedDirs } = await loadUsage(
+    dataDirs.length ? { dataDirs } : 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);
   }
+  if (usageMode) {
+    const rows = dailyUsage(records);
+    const totals = usageTotals(rows);
+    const machines = byMachine(records);
+    if (jsonFlag) {
+      process.stdout.write(JSON.stringify({ daily: rows, totals, machines, sources: usedDirs, skipped }, null, 2) + "\n");
+      return;
+    }
+    const out = [renderUsageTable(rows, totals)];
+    if (machines.length > 1) {
+      out.push("", "By machine:");
+      for (const m of machines) {
+        out.push(`  ${m.source.padEnd(14)}${fmtInt(m.totalTokens).padStart(16)}   ${fmtUsd(m.costUsd)}`);
+      }
+    }
+    out.push(
+      "",
+      `Merged ${usedDirs.length} folder${usedDirs.length === 1 ? "" : "s"} \xB7 ${records.length.toLocaleString("en-US")} messages.`,
+      "Cost is estimated from a bundled price snapshot \u2014 for subscription usage it is the notional API-equivalent value, not what you paid."
+    );
+    process.stdout.write(out.join("\n") + "\n");
+    return;
+  }
   const agg = aggregate(records);
   const facts = guiltFacts(agg);
   const stats = behaviorStats(records, agg);

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "guilt-max",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Feel bad about your Claude Code token spend, beautifully, in your terminal.",
   "type": "module",
-  "bin": { "guilt-max": "dist/cli.js" },
-  "files": ["dist"],
+  "bin": {
+    "guilt-max": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
   "keywords": [
     "claude",
     "claude-code",
@@ -49,5 +53,7 @@
     "typescript": "^5.6.3",
     "vitest": "^2.1.5"
   },
-  "engines": { "node": ">=18" }
+  "engines": {
+    "node": ">=18"
+  }
 }