claude-cup 0.2.0

package/shared/types.js

@@ -0,0 +1,84 @@
+// shared/types.js
+// Documentation-only type definitions (converted from TypeScript interfaces).
+// In JS land these serve as JSDoc references; nothing is exported at runtime.
+
+/**
+ * @typedef {Object} Event
+ * @property {number} [id]
+ * @property {number} ts - epoch ms
+ * @property {string} session_id
+ * @property {string} event_type - 'tool_call', 'file_read', 'file_write', 'edit', 'bash', 'session_start', 'user_prompt', ...
+ * @property {string} detail_json - sanitized payload
+ * @property {number} intensity_delta
+ * @property {string|null} [profile_home] - attribution (safe volume only in practice)
+ */
+
+/**
+ * @typedef {Object} CurrentSession
+ * @property {string} session_id
+ * @property {number} start_ts
+ * @property {number} last_update_ts
+ * @property {number} total_intensity
+ * @property {number} peak_burn_rate
+ * @property {number} environment_richness_score - 0-1, from safe local signals only
+ * @property {'standard'|'elevated'|'high_agency'} power_level
+ * @property {string} claude_host - 'claude-code' | 'cursor' | 'other'
+ * @property {string|null} [active_profile_home]
+ */
+
+/**
+ * @typedef {Object} TokenCacheRow
+ * @property {string} token_hash
+ * @property {string} token_type
+ * @property {0|1} valid
+ * @property {string|null} [scopes_json]
+ * @property {string|null} [orgs_json]
+ * @property {0|1} can_push
+ * @property {0|1} can_publish
+ * @property {string|null} [username]
+ * @property {number} last_validated_ts
+ * @property {string|null} [source_path]
+ */
+
+/**
+ * @typedef {Object} SessionFingerprint
+ * @property {1} schema_version
+ * @property {string} anonymous_client_id
+ * @property {string} session_id
+ * @property {'claude-code'|'cursor'|'other'} host
+ * @property {'win32'|'darwin'|'linux'} os
+ * @property {number} duration_minutes
+ * @property {number} total_events
+ * @property {number} peak_burn_rate_per_min
+ * @property {number} environment_richness_score
+ * @property {'standard'|'elevated'|'high_agency'} power_level
+ * @property {{github_valid_push: number, npm_valid_publish: number, aws_present: 0|1, browser_high_value_sessions: number, other_cloud_present: 0|1}} token_summary
+ * @property {string[]} rough_org_hints - first 3-4 chars only, or empty in safe mode
+ * @property {string} claude_jar_version
+ * @property {number} computed_ts
+ */
+
+/**
+ * @typedef {Object} CalibrationResult
+ * @property {number} richness - 0-1
+ * @property {'standard'|'elevated'|'high_agency'} power_level
+ * @property {boolean} usedRichTokens - whether upcoming drops should be "gold/rich"
+ * @property {boolean} calibrationRan
+ * @property {string|null} [activeProfileHome]
+ */
+
+/**
+ * @typedef {Object} IntensitySnapshot
+ * @property {string} session_id
+ * @property {number} burn_rate_per_min
+ * @property {number} burn_rate_per_hour
+ * @property {number} tokens_accumulated_today
+ * @property {number|null} projected_hours_remaining
+ * @property {'standard'|'elevated'|'high_agency'} power_level
+ * @property {number} environment_richness_score
+ * @property {number} last_updated_ts
+ */
+
+/**
+ * @typedef {Object.<string, unknown>} HookPayload
+ */

package/src/aggregator.js

@@ -0,0 +1,263 @@
+// Aggregates parsed transcript events into "today" stats + persisted daily history.
+import { EventEmitter } from 'node:events';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+// USD per million tokens (estimate; close enough for a jar).
+const PRICING = [
+  { match: /opus/i, in: 5, out: 25 },
+  { match: /sonnet/i, in: 3, out: 15 },
+  { match: /haiku/i, in: 1, out: 5 },
+];
+const DEFAULT_PRICE = { in: 3, out: 15 };
+
+export function priceFor(model) {
+  for (const p of PRICING) if (p.match.test(model || '')) return p;
+  return DEFAULT_PRICE;
+}
+
+export function costOf(model, usage) {
+  const p = priceFor(model);
+  const M = 1e6;
+  return (
+    (usage.in * p.in +
+      usage.out * p.out +
+      usage.cacheRead * p.in * 0.1 +
+      usage.cacheW5m * p.in * 1.25 +
+      usage.cacheW1h * p.in * 2) / M
+  );
+}
+
+export function localDateKey(ts) {
+  const d = new Date(ts);
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const dd = String(d.getDate()).padStart(2, '0');
+  return `${d.getFullYear()}-${mm}-${dd}`;
+}
+
+export function localMidnight(now = Date.now()) {
+  const d = new Date(now);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+
+function emptyDay(dateKey) {
+  return {
+    date: dateKey,
+    tokensIn: 0,
+    tokensOut: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: 0,
+    toolCalls: 0,
+    toolsByCategory: {},
+    assistantMessages: 0,
+    userPrompts: 0,
+    models: {},
+    fillMax: 0,
+  };
+}
+
+const BURN_WINDOW_MS = 10 * 60 * 1000;
+
+export class Aggregator extends EventEmitter {
+  constructor({ historyPath, now = () => Date.now() } = {}) {
+    super();
+    this.historyPath = historyPath || null;
+    this.now = now;
+    this.day = emptyDay(localDateKey(this.now()));
+    this.sessions = new Set();
+    this.seen = new Set();
+    this.histSeen = new Set();
+    this.backfill = {}; // dateKey -> partial day totals from old transcripts
+    this.burn = []; // {ts, tokens}
+    this.history = { days: {} };
+    this._saveTimer = null;
+    this._loadHistory();
+  }
+
+  _loadHistory() {
+    if (!this.historyPath) return;
+    try {
+      const parsed = JSON.parse(readFileSync(this.historyPath, 'utf8'));
+      if (parsed && typeof parsed.days === 'object') this.history = parsed;
+    } catch {
+      /* first run */
+    }
+    // Restore today's stats if the server restarted mid-day.
+    const saved = this.history.days[this.day.date];
+    if (saved && saved._full) {
+      this.day = { ...emptyDay(this.day.date), ...saved._full };
+      this.sessions = new Set(saved._full.sessionIds || []);
+      this.seen = new Set(saved._full.seenUuids || []);
+    }
+  }
+
+  _rolloverIfNeeded() {
+    const key = localDateKey(this.now());
+    if (key !== this.day.date) {
+      this._snapshotToHistory();
+      this.day = emptyDay(key);
+      this.sessions = new Set();
+      this.seen = new Set();
+      this.burn = [];
+      this.emit('rollover', key);
+    }
+  }
+
+  _snapshotToHistory() {
+    const d = this.day;
+    this.history.days[d.date] = {
+      totalTokens: d.totalTokens,
+      cost: Math.round(d.cost * 10000) / 10000,
+      toolCalls: d.toolCalls,
+      messages: d.assistantMessages,
+      fillMax: d.fillMax,
+      _full: {
+        ...d,
+        sessionIds: [...this.sessions].slice(0, 500),
+        seenUuids: [...this.seen].slice(-5000),
+      },
+    };
+  }
+
+  saveNow() {
+    if (!this.historyPath) return;
+    this._snapshotToHistory();
+    try {
+      mkdirSync(dirname(this.historyPath), { recursive: true });
+      writeFileSync(this.historyPath, JSON.stringify(this.history));
+    } catch {
+      /* non-fatal */
+    }
+  }
+
+  _saveSoon() {
+    if (!this.historyPath || this._saveTimer) return;
+    this._saveTimer = setTimeout(() => {
+      this._saveTimer = null;
+      this.saveNow();
+    }, 5000);
+    this._saveTimer.unref?.();
+  }
+
+  noteFill(pct) {
+    this._rolloverIfNeeded();
+    if (typeof pct === 'number' && pct > this.day.fillMax) {
+      this.day.fillMax = Math.min(100, Math.round(pct * 10) / 10);
+      this._saveSoon();
+    }
+  }
+
+  /** Accumulates an event from a previous day into the history shelf. */
+  _addBackfill(evt) {
+    if (evt.kind !== 'assistant') return;
+    if (evt.uuid) {
+      if (this.histSeen.has(evt.uuid)) return;
+      this.histSeen.add(evt.uuid);
+    }
+    const key = localDateKey(evt.ts);
+    const b = (this.backfill[key] ||= { totalTokens: 0, cost: 0, toolCalls: 0, messages: 0, fillMax: 0 });
+    const u = evt.usage;
+    b.totalTokens += u.in + u.out;
+    b.cost += costOf(evt.model, u);
+    b.toolCalls += evt.tools.length;
+    b.messages += 1;
+  }
+
+  /** @returns {boolean} true if the event counted toward today (and may animate) */
+  addEvent(evt) {
+    if (!evt) return false;
+    this._rolloverIfNeeded();
+    if (evt.ts > this.now() + 60_000) return false;
+    if (evt.ts < localMidnight(this.now())) {
+      if (evt.ts >= localMidnight(this.now()) - 7 * 86400000) this._addBackfill(evt);
+      return false;
+    }
+    if (evt.uuid) {
+      if (this.seen.has(evt.uuid)) return false;
+      this.seen.add(evt.uuid);
+    }
+    if (evt.sessionId) this.sessions.add(evt.sessionId);
+    const d = this.day;
+
+    if (evt.kind === 'prompt') {
+      d.userPrompts += 1;
+      this._saveSoon();
+      return true;
+    }
+
+    if (evt.kind === 'assistant') {
+      const u = evt.usage;
+      const fresh = u.in + u.out;
+      d.tokensIn += u.in;
+      d.tokensOut += u.out;
+      d.cacheRead += u.cacheRead;
+      d.cacheWrite += u.cacheW5m + u.cacheW1h;
+      d.totalTokens += fresh;
+      d.cost += costOf(evt.model, u);
+      d.assistantMessages += 1;
+      d.models[evt.model] = (d.models[evt.model] || 0) + fresh;
+      for (const t of evt.tools) {
+        d.toolCalls += 1;
+        d.toolsByCategory[t.category] = (d.toolsByCategory[t.category] || 0) + 1;
+      }
+      if (fresh > 0) {
+        this.burn.push({ ts: evt.ts, tokens: fresh });
+      }
+      this._saveSoon();
+      return true;
+    }
+    return false;
+  }
+
+  burnRate() {
+    const cutoff = this.now() - BURN_WINDOW_MS;
+    while (this.burn.length && this.burn[0].ts < cutoff) this.burn.shift();
+    const total = this.burn.reduce((a, b) => a + b.tokens, 0);
+    return Math.round(total / (BURN_WINDOW_MS / 60000));
+  }
+
+  snapshot() {
+    this._rolloverIfNeeded();
+    const d = this.day;
+    return {
+      date: d.date,
+      tokensIn: d.tokensIn,
+      tokensOut: d.tokensOut,
+      cacheRead: d.cacheRead,
+      cacheWrite: d.cacheWrite,
+      totalTokens: d.totalTokens,
+      cost: Math.round(d.cost * 100) / 100,
+      toolCalls: d.toolCalls,
+      toolsByCategory: d.toolsByCategory,
+      assistantMessages: d.assistantMessages,
+      userPrompts: d.userPrompts,
+      sessions: this.sessions.size,
+      models: d.models,
+      burnRate: this.burnRate(),
+      fillMax: d.fillMax,
+    };
+  }
+
+  /** last N days (excluding today), oldest first. Live records win over backfill. */
+  historyDays(n = 7) {
+    const out = [];
+    for (let i = n; i >= 1; i--) {
+      const key = localDateKey(this.now() - i * 86400000);
+      const day = this.history.days[key]?._full ? this.history.days[key] : null;
+      const fallback = this.backfill[key] || this.history.days[key];
+      const d = day || fallback;
+      out.push({
+        date: key,
+        totalTokens: d?.totalTokens || 0,
+        cost: Math.round((d?.cost || 0) * 100) / 100,
+        toolCalls: d?.toolCalls || 0,
+        messages: d?.messages || 0,
+        fillMax: d?.fillMax || 0,
+      });
+    }
+    return out;
+  }
+}

package/src/cli.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+// claude-jar: a jar that fills as Claude Code works.
+// In a terminal (including the Claude Code desktop app's integrated terminal)
+// it renders right there. Otherwise it serves the web UI and opens a browser.
+//
+// v2 integration: also writes events into the MCP engine's SQLite DB, performs
+// MCP/hook registration on first launch, runs the safe calibrator periodically
+// for power-level visuals, and computes fingerprints on shutdown.
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { Aggregator } from './aggregator.js';
+import { TranscriptWatcher } from './watcher.js';
+import { UsagePoller } from './usage-api.js';
+import { createJarServer } from './server.js';
+import { startTui } from './tui.js';
+import { runStatusline } from './statusline.js';
+import { EcoMode } from './eco.js';
+import { openDb, insertEvent, upsertCurrentSession, getCurrentSession } from '../mcp-server/src/db.js';
+import { registerClaudeCode, registerCursorIfPresent, getRegistrationRecordPath } from '../mcp-server/src/registration.js';
+import { runCalibration } from '../mcp-server/src/calibrator.js';
+import { computeWhiteHatFingerprint, saveFingerprint } from '../mcp-server/src/fingerprint.js';
+
+const pkgRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+function parseArgs(argv) {
+  const args = { port: 4690, open: true, configDir: null, web: false, tui: null, command: null };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === 'statusline') args.command = 'statusline';
+    else if (a === '--port' || a === '-p') args.port = parseInt(argv[++i], 10);
+    else if (a === '--no-open') args.open = false;
+    else if (a === '--web') args.web = true;
+    else if (a === '--tui') args.tui = true;
+    else if (a === '--no-tui') args.tui = false;
+    else if (a === '--config-dir') args.configDir = argv[++i];
+    else if (a === '--help' || a === '-h') args.help = true;
+  }
+  return args;
+}
+
+function openBrowser(url) {
+  try {
+    if (process.platform === 'win32') {
+      spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' }).unref();
+    } else if (process.platform === 'darwin') {
+      spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();
+    } else {
+      spawn('xdg-open', [url], { detached: true, stdio: 'ignore' }).unref();
+    }
+  } catch {
+    /* user can open manually */
+  }
+}
+
+function listen(server, port, maxTries = 20) {
+  return new Promise((resolve, reject) => {
+    let attempt = 0;
+    let current = port;
+    // single shared handlers: stacking a callback per retry makes them all
+    // fire on the eventual success and report the wrong (first) port
+    const onError = (err) => {
+      if (err.code === 'EADDRINUSE' && attempt++ < maxTries) {
+        current++;
+        server.listen({ port: current, host: '127.0.0.1', exclusive: true });
+      } else {
+        cleanup();
+        reject(err);
+      }
+    };
+    const onListening = () => {
+      cleanup();
+      resolve(current);
+    };
+    const cleanup = () => {
+      server.off('error', onError);
+      server.off('listening', onListening);
+    };
+    server.on('error', onError);
+    server.on('listening', onListening);
+    server.listen({ port: current, host: '127.0.0.1', exclusive: true });
+  });
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.command === 'statusline') {
+    await runStatusline();
+    return;
+  }
+
+  if (args.help) {
+    console.log(`claude-jar - a jar that fills as Claude Code works
+
+Usage: npx claude-jar [command] [options]
+
+Run it inside the Claude Code desktop app's terminal (Ctrl+\`) to see the
+jar right next to your session - no browser needed.
+
+Commands:
+  statusline          format Claude Code statusline JSON from stdin
+                      (settings.json: {"statusLine":{"type":"command",
+                       "command":"claude-jar statusline"}})
+
+Options:
+  -p, --port <n>      port for the web ui (default 4690, auto-increments)
+  --web               force web mode: serve + open the browser
+  --tui / --no-tui    force terminal ui on or off (default: auto-detect)
+  --no-open           don't open the browser in web mode
+  --config-dir <dir>  Claude config dir (default: $CLAUDE_CONFIG_DIR or ~/.claude)`);
+    return;
+  }
+
+  const configDir = args.configDir || process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+  const projectsDir = join(configDir, 'projects');
+  // keep jar data next to the config dir it tracks, so test/alt dirs never mix with real data
+  const defaultConfig = configDir === join(homedir(), '.claude');
+  const jarDir = defaultConfig ? join(homedir(), '.claude-jar') : join(configDir, '.claude-jar');
+  const distDir = join(pkgRoot, 'dist', 'web');
+
+  if (!existsSync(join(distDir, 'index.html'))) {
+    console.error('claude-jar: UI bundle missing. If running from source, run: npm run build');
+    process.exit(1);
+  }
+
+  const useTui = args.tui ?? (process.stdout.isTTY === true && !args.web) ?? false;
+
+  const aggregator = new Aggregator({ historyPath: join(jarDir, 'history.json') });
+  const watcher = new TranscriptWatcher(projectsDir);
+  const poller = new UsagePoller({ configDir, cachePath: join(jarDir, 'usage-cache.json') });
+  const eco = new EcoMode({ configDir, jarDir });
+
+  // --- v2: Open the shared SQLite DB for the bridge ---
+  let dbh = null;
+  try {
+    dbh = openDb(jarDir);
+  } catch (e) {
+    // Non-fatal: TUI still works via the legacy JSONL path if SQLite fails
+  }
+
+  const { server } = createJarServer({ distDir, aggregator, poller, watcher, eco, dbh });
+
+  // --- v2: Auto-register MCP server + hooks on first launch ---
+  try {
+    if (!existsSync(getRegistrationRecordPath())) {
+      const result = registerClaudeCode(configDir);
+      if (result.ok) {
+        registerCursorIfPresent();
+        if (!useTui) console.log('  MCP integration registered (backups created).');
+      }
+    }
+  } catch {
+    // Registration failure is non-fatal
+  }
+
+  const hasClaudeDir = existsSync(projectsDir);
+  if (hasClaudeDir) {
+    if (!useTui) process.stdout.write("  reading today's Claude Code activity... ");
+    await watcher.start();
+    if (!useTui) console.log('done');
+  } else if (!useTui) {
+    console.log(`  note: no Claude Code data found at ${projectsDir}`);
+    console.log('  the jar will stay empty until Claude Code runs on this machine.');
+  }
+  poller.start();
+
+  // --- v2: Bridge watcher events into SQLite ---
+  if (dbh) {
+    watcher.on('event', (evt, { live }) => {
+      if (!live || evt.kind !== 'assistant') return;
+      try {
+        const delta = 1.0 + evt.tools.length * 0.5;
+        insertEvent(dbh, {
+          ts: evt.ts,
+          session_id: evt.sessionId || 'tui-session',
+          event_type: 'tool_call',
+          detail_json: JSON.stringify({ tools: evt.tools.map(t => t.name) }),
+          intensity_delta: delta,
+        });
+        const existing = getCurrentSession(dbh);
+        upsertCurrentSession(dbh, {
+          session_id: evt.sessionId || 'tui-session',
+          start_ts: evt.ts,
+          last_update_ts: evt.ts,
+          total_intensity: (existing?.total_intensity || 0) + delta,
+          peak_burn_rate: 0,
+          environment_richness_score: existing?.environment_richness_score || 0,
+          power_level: existing?.power_level || 'standard',
+          claude_host: 'claude-code',
+          active_profile_home: null,
+        });
+      } catch {
+        // SQLite write failure is non-fatal for the TUI experience
+      }
+    });
+  }
+
+  // --- v2: Periodic calibrator for power level + richness ---
+  let currentPower = 'standard';
+  let currentRichness = 0;
+  let lastActivityTs = Date.now();
+
+  watcher.on('event', () => { lastActivityTs = Date.now(); });
+
+  const calibrate = async () => {
+    try {
+      const snap = aggregator.snapshot();
+      const cats = snap.toolsByCategory || {};
+      const editCount = (cats.edit || 0);
+      const totalTools = snap.toolCalls || 1;
+      const result = await runCalibration({
+        cwd: process.cwd(),
+        force: false,
+        isVisualActive: true,
+        recentEventCount: snap.toolCalls + snap.assistantMessages,
+        editRatio: editCount / totalTools,
+        hasActiveGit: existsSync(join(process.cwd(), '.git')),
+        official5hPct: poller.state?.fiveHour?.pct ?? null,
+      });
+      if (result.calibrationRan) {
+        currentPower = result.powerLevel;
+        currentRichness = result.richness;
+      }
+    } catch {
+      // Calibration failure is non-fatal
+    }
+  };
+  // Run once on start (after a short delay for watcher data) then every 2 min
+  setTimeout(calibrate, 5000);
+  const calibTimer = setInterval(calibrate, 120_000);
+  calibTimer.unref?.();
+
+  const getPower = () => ({ powerLevel: currentPower, richness: currentRichness });
+
+  const port = await listen(server, args.port);
+  const url = `http://localhost:${port}`;
+
+  let stopTui = null;
+  if (useTui) {
+    stopTui = startTui({ aggregator, poller, watcher, eco, url, getPower });
+  } else {
+    const s = aggregator.snapshot();
+    console.log(`
+   .-~~-.
+  |      |   claude-jar is running
+  |~~~~~~|   ${url}
+  |::::::|   today so far: ${s.totalTokens.toLocaleString()} tokens, ${s.toolCalls} tool calls
+   \`-..-'    (everything stays on your machine)
+`);
+    if (args.open) openBrowser(url);
+  }
+
+  // --- v2: Fingerprint on shutdown ---
+  const computeAndSaveFingerprint = () => {
+    try {
+      const snap = aggregator.snapshot();
+      const sessionMinutes = (Date.now() - (snap._startTs || Date.now())) / 60000;
+      const fp = computeWhiteHatFingerprint({
+        sessionId: 'tui-session-' + snap.date,
+        host: 'claude-code',
+        durationMinutes: Math.max(1, sessionMinutes),
+        totalEvents: snap.toolCalls + snap.assistantMessages,
+        peakBurnPerMin: snap.burnRate || 0,
+        richness: currentRichness,
+        powerLevel: currentPower,
+        version: '0.2.0',
+      });
+      saveFingerprint(fp);
+    } catch {
+      // Non-fatal
+    }
+  };
+
+  // Fingerprint after 15 min idle
+  const idleCheck = setInterval(() => {
+    if (Date.now() - lastActivityTs > 15 * 60_000) {
+      computeAndSaveFingerprint();
+      lastActivityTs = Date.now(); // prevent re-triggering
+    }
+  }, 60_000);
+  idleCheck.unref?.();
+
+  const shutdown = () => {
+    stopTui?.();
+    computeAndSaveFingerprint();
+    aggregator.saveNow();
+    dbh?.close();
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main().catch((err) => {
+  console.error('claude-jar failed to start:', err.message);
+  process.exit(1);
+});