tokengolf 0.3.0 → 0.4.0

package/src/lib/cost.js

@@ -4,9 +4,9 @@ import os from 'os';
 
 // Pricing per million tokens (Anthropic list prices)
 const PRICING = {
-  'claude-opus-4':   { input: 15.00, output: 75.00, cacheWrite: 18.75, cacheRead: 1.50 },
-  'claude-sonnet-4': { input:  3.00, output: 15.00, cacheWrite:  3.75, cacheRead: 0.30 },
-  'claude-haiku-4':  { input:  0.80, output:  4.00, cacheWrite:  1.00, cacheRead: 0.08 },
+  'claude-opus-4': { input: 15.0, output: 75.0, cacheWrite: 18.75, cacheRead: 1.5 },
+  'claude-sonnet-4': { input: 3.0, output: 15.0, cacheWrite: 3.75, cacheRead: 0.3 },
+  'claude-haiku-4': { input: 0.8, output: 4.0, cacheWrite: 1.0, cacheRead: 0.08 },
 };
 
 function getPrice(model) {
@@ -33,14 +33,17 @@ export function parseCostFromTranscript(transcriptPath) {
           const model = entry.message.model;
           const p = getPrice(model);
           const u = entry.message.usage;
-          const cost = (u.input_tokens || 0) / 1e6 * p.input
-            + (u.output_tokens || 0) / 1e6 * p.output
-            + (u.cache_creation_input_tokens || 0) / 1e6 * p.cacheWrite
-            + (u.cache_read_input_tokens || 0) / 1e6 * p.cacheRead;
+          const cost =
+            ((u.input_tokens || 0) / 1e6) * p.input +
+            ((u.output_tokens || 0) / 1e6) * p.output +
+            ((u.cache_creation_input_tokens || 0) / 1e6) * p.cacheWrite +
+            ((u.cache_read_input_tokens || 0) / 1e6) * p.cacheRead;
           total += cost;
           byModel[model] = (byModel[model] || 0) + cost;
         }
-      } catch { /* skip malformed lines */ }
+      } catch {
+        /* skip malformed lines */
+      }
     }
     return total > 0 ? { total, byModel } : null;
   } catch {
@@ -51,9 +54,13 @@ export function parseCostFromTranscript(transcriptPath) {
 // Returns all transcript paths modified at or after sinceMs
 function findTranscriptsSince(projectDir, sinceMs) {
   try {
-    return fs.readdirSync(projectDir)
-      .filter(f => f.endsWith('.jsonl'))
-      .map(f => ({ p: path.join(projectDir, f), mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
+    return fs
+      .readdirSync(projectDir)
+      .filter((f) => f.endsWith('.jsonl'))
+      .map((f) => ({
+        p: path.join(projectDir, f),
+        mtime: fs.statSync(path.join(projectDir, f)).mtimeMs,
+      }))
       .filter(({ mtime }) => mtime >= sinceMs)
       .map(({ p }) => p);
   } catch {
@@ -71,7 +78,7 @@ export function parseThinkingFromTranscripts(paths) {
         try {
           const entry = JSON.parse(line);
           if (entry.type === 'assistant' && Array.isArray(entry.message?.content)) {
-            const thinkBlocks = entry.message.content.filter(b => b.type === 'thinking');
+            const thinkBlocks = entry.message.content.filter((b) => b.type === 'thinking');
             if (thinkBlocks.length > 0) {
               invocations++;
               for (const block of thinkBlocks) {
@@ -79,9 +86,13 @@ export function parseThinkingFromTranscripts(paths) {
               }
             }
           }
-        } catch { /* skip malformed lines */ }
+        } catch {
+          /* skip malformed lines */
+        }
       }
-    } catch { /* skip unreadable files */ }
+    } catch {
+      /* skip unreadable files */
+    }
   }
   return invocations > 0 ? { thinkingInvocations: invocations, thinkingTokens: tokens } : null;
 }
@@ -101,19 +112,53 @@ function parseAllTranscripts(paths) {
   return total > 0 ? { total, byModel } : null;
 }
 
+export function modelFamily(model) {
+  const m = (model || '').toLowerCase();
+  if (m.includes('haiku')) return 'haiku';
+  if (m.includes('sonnet')) return 'sonnet';
+  if (m.includes('opus')) return 'opus';
+  return 'unknown';
+}
+
+export function parseModelSwitches(transcriptPath) {
+  try {
+    const lines = fs.readFileSync(transcriptPath, 'utf8').trim().split('\n');
+    let lastFamily = null;
+    let switches = 0;
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'assistant' && entry.message?.model) {
+          const family = modelFamily(entry.message.model);
+          if (lastFamily !== null && family !== lastFamily) switches++;
+          lastFamily = family;
+        }
+      } catch {
+        /* skip */
+      }
+    }
+    return { switches };
+  } catch {
+    return { switches: 0 };
+  }
+}
+
 export function findTranscript(sessionId, projectDir) {
   if (sessionId) {
     try {
       const p = path.join(projectDir, `${sessionId}.jsonl`);
       fs.accessSync(p);
       return p;
-    } catch { /* fall through */ }
+    } catch {
+      /* fall through */
+    }
   }
   // Fall back to most recently modified transcript
   try {
-    const files = fs.readdirSync(projectDir)
-      .filter(f => f.endsWith('.jsonl'))
-      .map(f => ({ f, mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
+    const files = fs
+      .readdirSync(projectDir)
+      .filter((f) => f.endsWith('.jsonl'))
+      .map((f) => ({ f, mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
       .sort((a, b) => b.mtime - a.mtime);
     return files.length ? path.join(projectDir, files[0].f) : null;
   } catch {
@@ -127,9 +172,10 @@ export function autoDetectCost(run) {
 
   // Scan all transcripts modified since session start to capture subagent sidechains
   const sinceMs = run.startedAt ? new Date(run.startedAt).getTime() : 0;
-  const paths = sinceMs > 0
-    ? findTranscriptsSince(projectDir, sinceMs)
-    : [findTranscript(run.sessionId, projectDir)].filter(Boolean);
+  const paths =
+    sinceMs > 0
+      ? findTranscriptsSince(projectDir, sinceMs)
+      : [findTranscript(run.sessionId, projectDir)].filter(Boolean);
 
   const parsed = paths.length > 0 ? parseAllTranscripts(paths) : null;
 
@@ -140,10 +186,27 @@ export function autoDetectCost(run) {
   // Always use parsed model breakdown (Stop hook doesn't capture it)
   const modelBreakdown = parsed?.byModel ?? run.modelBreakdown ?? null;
   const thinking = parseThinkingFromTranscripts(paths);
+
+  // Model switch detection: only on primary transcript (user-initiated switches)
+  const primaryPath = findTranscript(run.sessionId, projectDir);
+  const { switches: modelSwitches } = primaryPath
+    ? parseModelSwitches(primaryPath)
+    : { switches: 0 };
+
+  // Distinct model families across ALL transcripts (includes subagents)
+  const families = new Set(
+    Object.keys(parsed?.byModel ?? {})
+      .map(modelFamily)
+      .filter((f) => f !== 'unknown')
+  );
+  const distinctModels = families.size;
+
   return {
     spent,
     modelBreakdown,
     thinkingInvocations: thinking?.thinkingInvocations ?? 0,
     thinkingTokens: thinking?.thinkingTokens ?? 0,
+    modelSwitches,
+    distinctModels,
   };
 }

package/src/lib/demo.js

@@ -0,0 +1,186 @@
+const R = '\x1b[31m';
+const G = '\x1b[32m';
+const Y = '\x1b[33m';
+const M = '\x1b[35m';
+const C = '\x1b[36m';
+const DIM = '\x1b[2m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+
+function hudLine({ quest, model, cost, budget, ctxPct, effort, fainted, floor }) {
+  const m = (model || '').toLowerCase();
+  let modelName, modelEmoji;
+  if (m.includes('haiku')) {
+    modelName = 'Haiku';
+    modelEmoji = '🏹';
+  } else if (m.includes('sonnet')) {
+    modelName = 'Sonnet';
+    modelEmoji = '⚔️';
+  } else if (m.includes('opus')) {
+    modelName = 'Opus';
+    modelEmoji = '🧙';
+  } else {
+    modelName = '?';
+    modelEmoji = '?';
+  }
+
+  const labelParts = [`${modelEmoji} ${modelName}`];
+  if (effort) labelParts.push(effort.charAt(0).toUpperCase() + effort.slice(1));
+  const modelLabel = labelParts.join('·');
+
+  let tierEmoji;
+  if (cost < 0.1) tierEmoji = '💎';
+  else if (cost < 0.3) tierEmoji = '🥇';
+  else if (cost < 1.0) tierEmoji = '🥈';
+  else if (cost < 3.0) tierEmoji = '🥉';
+  else tierEmoji = '💸';
+
+  const sep = ` ${DIM}|${RESET} `;
+  let costStr, ratingStr;
+
+  if (budget) {
+    const pct = (cost / budget) * 100;
+    let rating, rc;
+    if (pct <= 25) {
+      rating = 'LEGENDARY';
+      rc = M;
+    } else if (pct <= 50) {
+      rating = 'EFFICIENT';
+      rc = C;
+    } else if (pct <= 75) {
+      rating = 'SOLID';
+      rc = G;
+    } else if (pct <= 100) {
+      rating = 'CLOSE CALL';
+      rc = Y;
+    } else {
+      rating = 'BUSTED';
+      rc = R;
+    }
+    costStr = `${tierEmoji} $${cost.toFixed(4)}/$${budget.toFixed(2)} ${pct.toFixed(0)}%`;
+    ratingStr = `${rc}${rating}${RESET}`;
+  } else {
+    costStr = `${tierEmoji} $${cost.toFixed(4)}`;
+    ratingStr = null;
+  }
+
+  let ctxStr = null;
+  if (ctxPct != null) {
+    if (ctxPct >= 90) ctxStr = `${R}📦 ${ctxPct}%${RESET}`;
+    else if (ctxPct >= 75) ctxStr = `${Y}🎒 ${ctxPct}%${RESET}`;
+    else if (ctxPct >= 50) ctxStr = `${G}🪶 ${ctxPct}%${RESET}`;
+  }
+
+  const icon = fainted ? '💤' : '⛳';
+  const prefix = `${BOLD}${C}${icon}${RESET}`;
+  const parts = [`${prefix} ${quest}`, costStr];
+  if (ratingStr) parts.push(ratingStr);
+  if (ctxStr) parts.push(ctxStr);
+  parts.push(`${C}${modelLabel}${RESET}`);
+  if (budget && floor) parts.push(`Floor ${floor}`);
+
+  return `${DIM} ───────────────${RESET}\n${parts.join(sep)}\n${DIM} ───────────────${RESET}`;
+}
+
+const SCENARIOS = [
+  {
+    title: 'Flow mode  (passive — no quest, no budget)',
+    hud: { quest: 'Flow', model: 'claude-sonnet-4-6', cost: 0.0034 },
+  },
+  {
+    title: 'Roguelike · Sonnet · EFFICIENT',
+    hud: {
+      quest: 'add pagination to /users',
+      model: 'claude-sonnet-4-6',
+      cost: 0.54,
+      budget: 1.5,
+      ctxPct: 34,
+      floor: '2/5',
+    },
+  },
+  {
+    title: 'Roguelike · Sonnet·High · LEGENDARY',
+    hud: {
+      quest: 'implement SSO with SAML',
+      model: 'claude-sonnet-4-6',
+      cost: 0.41,
+      budget: 2.0,
+      ctxPct: 29,
+      effort: 'high',
+      floor: '1/5',
+    },
+  },
+  {
+    title: 'Roguelike · Opus · LEGENDARY · 🪶 context',
+    hud: {
+      quest: 'refactor auth middleware',
+      model: 'claude-opus-4-6',
+      cost: 0.82,
+      budget: 4.0,
+      ctxPct: 52,
+      floor: '3/5',
+    },
+  },
+  {
+    title: 'Roguelike · Haiku · CLOSE CALL · 🎒 context',
+    hud: {
+      quest: 'fix N+1 query in dashboard',
+      model: 'claude-haiku-4-5-20251001',
+      cost: 0.46,
+      budget: 0.5,
+      ctxPct: 78,
+      floor: '4/5',
+    },
+  },
+  {
+    title: 'Roguelike · BUSTED — over budget',
+    hud: {
+      quest: 'migrate postgres schema',
+      model: 'claude-sonnet-4-6',
+      cost: 2.41,
+      budget: 2.0,
+      floor: '2/5',
+    },
+  },
+  {
+    title: 'Roguelike · Opus · EFFICIENT · 📦 overencumbered',
+    hud: {
+      quest: 'refactor entire API layer',
+      model: 'claude-opus-4-6',
+      cost: 3.1,
+      budget: 10.0,
+      ctxPct: 91,
+      floor: '3/5',
+    },
+  },
+  {
+    title: 'Fainted 💤 — usage limit hit, run resumes next session',
+    hud: {
+      quest: 'write test suite for payments',
+      model: 'claude-sonnet-4-6',
+      cost: 1.22,
+      budget: 3.0,
+      ctxPct: 67,
+      fainted: true,
+      floor: '2/5',
+    },
+  },
+];
+
+export function runDemo() {
+  console.log('');
+  console.log(`${BOLD}${C}⛳ TokenGolf — HUD Demo${RESET}`);
+  console.log(`${DIM}Live statusline shown in every Claude Code session${RESET}`);
+  console.log('');
+
+  for (const { title, hud } of SCENARIOS) {
+    console.log(`${DIM}${title}${RESET}`);
+    console.log(hudLine(hud));
+    console.log('');
+  }
+
+  console.log(
+    `${DIM}Run ${RESET}tokengolf start${DIM} to begin a roguelike run, or just open Claude Code — flow mode tracks automatically.${RESET}`
+  );
+  console.log('');
+}

package/src/lib/install.js

@@ -1,30 +1,30 @@
-import fs from "fs";
-import path from "path";
-import os from "os";
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
 
 // Follow symlinks (npm link creates a symlink in the nvm/node bin dir)
 // to find the actual project directory, then resolve hooks/ relative to it.
 const realEntry = fs.realpathSync(process.argv[1]);
-const HOOKS_DIR = path.resolve(path.dirname(realEntry), "../hooks");
-const STATUSLINE_PATH = path.join(HOOKS_DIR, "statusline.sh");
-const WRAPPER_PATH = path.join(HOOKS_DIR, "statusline-wrapper.sh");
-const CLAUDE_DIR = path.join(os.homedir(), ".claude");
-const CLAUDE_SETTINGS = path.join(CLAUDE_DIR, "settings.json");
+const HOOKS_DIR = path.resolve(path.dirname(realEntry), '../hooks');
+const STATUSLINE_PATH = path.join(HOOKS_DIR, 'statusline.sh');
+const WRAPPER_PATH = path.join(HOOKS_DIR, 'statusline-wrapper.sh');
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const CLAUDE_SETTINGS = path.join(CLAUDE_DIR, 'settings.json');
 
 export function installHooks() {
-  console.log("\n⛳ TokenGolf — Installing Claude Code hooks\n");
+  console.log('\n⛳ TokenGolf — Installing Claude Code hooks\n');
 
   let settings = {};
   if (fs.existsSync(CLAUDE_SETTINGS)) {
     try {
-      settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS, "utf8"));
-      console.log("  ✓ Found ~/.claude/settings.json");
+      settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS, 'utf8'));
+      console.log('  ✓ Found ~/.claude/settings.json');
     } catch {
-      console.log("  ⚠️  Could not parse settings.json — starting fresh");
+      console.log('  ⚠️  Could not parse settings.json — starting fresh');
     }
   } else {
     fs.mkdirSync(CLAUDE_DIR, { recursive: true });
-    console.log("  ℹ️  Creating ~/.claude/settings.json");
+    console.log('  ℹ️  Creating ~/.claude/settings.json');
   }
 
   if (!settings.hooks) settings.hooks = {};
@@ -37,73 +37,106 @@ export function installHooks() {
         !h._tg &&
         !h.hooks?.some(
           (e) =>
-            e.command?.includes("tokengolf") ||
-            e.command?.includes("session-start.js") ||
-            e.command?.includes("session-stop.js") ||
-            e.command?.includes("session-end.js") ||
-            e.command?.includes("pre-compact.js") ||
-            e.command?.includes("post-tool-use.js") ||
-            e.command?.includes("user-prompt-submit.js"),
-        ),
+            e.command?.includes('tokengolf') ||
+            e.command?.includes('session-start.js') ||
+            e.command?.includes('session-stop.js') ||
+            e.command?.includes('session-end.js') ||
+            e.command?.includes('pre-compact.js') ||
+            e.command?.includes('post-tool-use.js') ||
+            e.command?.includes('post-tool-use-failure.js') ||
+            e.command?.includes('subagent-start.js') ||
+            e.command?.includes('stop.js') ||
+            e.command?.includes('user-prompt-submit.js')
+        )
     );
     settings.hooks[event] = [...filtered, { _tg: true, ...entry }];
   }
 
-  // Remove Stop hook if present (replaced by SessionEnd)
+  // Remove old session-stop.js Stop hook if present (superseded by session-end.js)
   if (settings.hooks.Stop) {
     settings.hooks.Stop = (settings.hooks.Stop || []).filter(
-      (h) =>
-        !h._tg && !h.hooks?.some((e) => e.command?.includes("session-stop.js")),
+      (h) => !h._tg && !h.hooks?.some((e) => e.command?.includes('session-stop.js'))
     );
     if (settings.hooks.Stop.length === 0) delete settings.hooks.Stop;
   }
 
-  upsertHook("SessionStart", {
+  upsertHook('SessionStart', {
     hooks: [
       {
-        type: "command",
-        command: `node ${path.join(HOOKS_DIR, "session-start.js")}`,
+        type: 'command',
+        command: `node ${path.join(HOOKS_DIR, 'session-start.js')}`,
         timeout: 5,
       },
     ],
   });
 
-  upsertHook("PostToolUse", {
-    matcher: "",
+  upsertHook('PostToolUse', {
+    matcher: '',
     hooks: [
       {
-        type: "command",
-        command: `node ${path.join(HOOKS_DIR, "post-tool-use.js")}`,
+        type: 'command',
+        command: `node ${path.join(HOOKS_DIR, 'post-tool-use.js')}`,
         timeout: 5,
       },
     ],
   });
 
-  upsertHook("UserPromptSubmit", {
+  upsertHook('UserPromptSubmit', {
     hooks: [
       {
-        type: "command",
-        command: `node ${path.join(HOOKS_DIR, "user-prompt-submit.js")}`,
+        type: 'command',
+        command: `node ${path.join(HOOKS_DIR, 'user-prompt-submit.js')}`,
         timeout: 5,
       },
     ],
   });
 
-  upsertHook("SessionEnd", {
+  upsertHook('SessionEnd', {
     hooks: [
       {
-        type: "command",
-        command: `node ${path.join(HOOKS_DIR, "session-end.js")}`,
+        type: 'command',
+        command: `node ${path.join(HOOKS_DIR, 'session-end.js')}`,
         timeout: 30,
       },
     ],
   });
 
-  upsertHook("PreCompact", {
+  upsertHook('PreCompact', {
+    hooks: [
+      {
+        type: 'command',
+        command: `node ${path.join(HOOKS_DIR, 'pre-compact.js')}`,
+        timeout: 5,
+      },
+    ],
+  });
+
+  upsertHook('PostToolUseFailure', {
+    matcher: '',
     hooks: [
       {
-        type: "command",
-        command: `node ${path.join(HOOKS_DIR, "pre-compact.js")}`,
+        type: 'command',
+        command: `node ${path.join(HOOKS_DIR, 'post-tool-use-failure.js')}`,
+        timeout: 5,
+      },
+    ],
+  });
+
+  upsertHook('SubagentStart', {
+    hooks: [
+      {
+        type: 'command',
+        command: `node ${path.join(HOOKS_DIR, 'subagent-start.js')}`,
+        timeout: 5,
+      },
+    ],
+  });
+
+  upsertHook('Stop', {
+    hooks: [
+      {
+        type: 'command',
+        command: `node ${path.join(HOOKS_DIR, 'stop.js')}`,
         timeout: 5,
       },
     ],
@@ -115,49 +148,46 @@ export function installHooks() {
   } catch {}
 
   const existing = settings.statusLine;
-  const existingCmd =
-    typeof existing === "string" ? existing : (existing?.command ?? null);
-  const alreadyOurs =
-    existingCmd === STATUSLINE_PATH || existingCmd === WRAPPER_PATH;
+  const existingCmd = typeof existing === 'string' ? existing : (existing?.command ?? null);
+  const alreadyOurs = existingCmd === STATUSLINE_PATH || existingCmd === WRAPPER_PATH;
 
   if (!alreadyOurs && existingCmd) {
     fs.writeFileSync(
       WRAPPER_PATH,
       [
-        "#!/usr/bin/env bash",
-        "SESSION_JSON=$(cat)",
+        '#!/usr/bin/env bash',
+        'SESSION_JSON=$(cat)',
         `echo "$SESSION_JSON" | ${existingCmd} 2>/dev/null || true`,
         `echo "$SESSION_JSON" | bash ${STATUSLINE_PATH}`,
-      ].join("\n") + "\n",
+      ].join('\n') + '\n'
     );
     fs.chmodSync(WRAPPER_PATH, 0o755);
     settings.statusLine = {
-      type: "command",
+      type: 'command',
       command: WRAPPER_PATH,
       padding: 1,
     };
-    console.log(
-      "  ✓ statusLine       → wrapped your existing statusline + tokengolf HUD",
-    );
+    console.log('  ✓ statusLine       → wrapped your existing statusline + tokengolf HUD');
   } else if (!alreadyOurs) {
     settings.statusLine = {
-      type: "command",
+      type: 'command',
       command: STATUSLINE_PATH,
       padding: 1,
     };
-    console.log("  ✓ statusLine       → live HUD in every Claude session");
+    console.log('  ✓ statusLine       → live HUD in every Claude session');
   } else {
-    console.log("  ✓ statusLine       → already installed");
+    console.log('  ✓ statusLine       → already installed');
   }
 
   fs.writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));
 
-  console.log("  ✓ SessionStart     → injects run context into Claude");
-  console.log("  ✓ PostToolUse      → tracks tool calls + 80% budget warning");
-  console.log("  ✓ UserPromptSubmit → counts prompts + 50% nudge");
-  console.log("  ✓ SessionEnd       → auto-displays scorecard on /exit");
-  console.log(
-    "  ✓ PreCompact       → tracks compaction events for gear achievements",
-  );
-  console.log("\n  ✅ Done! Start a run: tokengolf start\n");
+  console.log('  ✓ SessionStart     → injects run context into Claude');
+  console.log('  ✓ PostToolUse      → tracks tool calls + 80% budget warning');
+  console.log('  ✓ UserPromptSubmit → counts prompts + 50% nudge');
+  console.log('  ✓ SessionEnd       → auto-displays scorecard on /exit');
+  console.log('  ✓ PreCompact           → tracks compaction events for gear achievements');
+  console.log('  ✓ PostToolUseFailure   → tracks failed tool calls');
+  console.log('  ✓ SubagentStart        → tracks subagent spawns');
+  console.log('  ✓ Stop                 → tracks turn count');
+  console.log('\n  ✅ Done! Start a run: tokengolf start\n');
 }