golem-cc 2.1.2 → 3.0.0

package/.golem/lib/tui.mjs

@@ -0,0 +1,368 @@
+import chalk from 'chalk';
+import { sparkline, formatTokens } from './usage.mjs';
+import { formatResetTime } from './ratelimit.mjs';
+
+const ESC = '\x1b';
+const write = (s) => process.stdout.write(s);
+
+// ANSI helpers
+const altScreenOn = () => write(`${ESC}[?1049h`);
+const altScreenOff = () => write(`${ESC}[?1049l`);
+const mouseOn = () => write(`${ESC}[?1000h${ESC}[?1006h`);
+const mouseOff = () => write(`${ESC}[?1000l${ESC}[?1006l`);
+const cursorHide = () => write(`${ESC}[?25l`);
+const cursorShow = () => write(`${ESC}[?25h`);
+const moveTo = (row, col = 1) => write(`${ESC}[${row};${col}H`);
+const clearLine = () => write(`${ESC}[K`);
+const setScrollRegion = (top, bottom) => write(`${ESC}[${top};${bottom}r`);
+const resetScrollRegion = () => write(`${ESC}[r`);
+const saveCursor = () => write(`${ESC}7`);
+const restoreCursor = () => write(`${ESC}8`);
+
+const HEADER_LINES = 8;
+
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+
+function wordWrap(str, maxWidth, indent = 0) {
+  if (maxWidth <= 0) return [str];
+  const visible = stripAnsi(str);
+  if (visible.length <= maxWidth) return [str];
+
+  const lines = [];
+  let visPos = 0;
+  let strPos = 0;
+  let lineStart = 0;
+  let lineVisStart = 0;
+  let lastSpaceVis = -1;
+  let lastSpaceStr = -1;
+  const prefix = ' '.repeat(indent);
+
+  while (strPos < str.length) {
+    // Skip ANSI sequences
+    const ansiMatch = str.slice(strPos).match(/^\x1b\[[0-9;]*m/);
+    if (ansiMatch) {
+      strPos += ansiMatch[0].length;
+      continue;
+    }
+
+    if (str[strPos] === ' ') {
+      lastSpaceVis = visPos;
+      lastSpaceStr = strPos;
+    }
+
+    visPos++;
+    strPos++;
+
+    const lineWidth = lines.length === 0 ? maxWidth : maxWidth - indent;
+    if (visPos - lineVisStart >= lineWidth) {
+      if (lastSpaceStr > lineStart) {
+        // Break at last space
+        lines.push(str.slice(lineStart, lastSpaceStr));
+        lineStart = lastSpaceStr + 1;
+        lineVisStart = lastSpaceVis + 1;
+      } else {
+        // No space found, hard break
+        lines.push(str.slice(lineStart, strPos));
+        lineStart = strPos;
+        lineVisStart = visPos;
+      }
+      lastSpaceVis = -1;
+      lastSpaceStr = -1;
+    }
+  }
+
+  if (lineStart < str.length) {
+    lines.push(str.slice(lineStart));
+  }
+
+  return lines.map((l, i) => i === 0 ? l : prefix + l);
+}
+
+export function createTui() {
+  let rows = process.stdout.rows || 24;
+  let cols = process.stdout.columns || 80;
+  let timer = null;
+  let startTime = Date.now();
+  let cumulativeMs = 0;
+  let destroyed = false;
+
+  // State for header
+  let state = {
+    taskId: '',
+    taskTitle: '',
+    stage: '',
+    done: 0,
+    total: 0,
+    attempt: 0,
+    maxAttempts: 0,
+    claudeCalls: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    todaySparkline: '',
+    todayTotal: '0',
+    weekSparkline: '',
+    weekTotal: '0',
+    opus5hPct: null,
+    opus5hResetsAt: null,
+    opus7dPct: null,
+    opus7dResetsAt: null,
+    sonnet5hPct: null,
+    sonnet5hResetsAt: null,
+    sonnet7dPct: null,
+    sonnet7dResetsAt: null,
+    taskModel: '',
+    extraUsed: null,
+    extraLimit: null,
+    extraPct: null,
+  };
+
+  function formatElapsed() {
+    const secs = Math.floor((Date.now() - startTime) / 1000);
+    const m = Math.floor(secs / 60);
+    const s = secs % 60;
+    return `${m}m ${String(s).padStart(2, '0')}s`;
+  }
+
+  function progressBar(done, total, width) {
+    if (total === 0) return '░'.repeat(width);
+    const filled = Math.round((done / total) * width);
+    return '█'.repeat(filled) + '░'.repeat(width - filled);
+  }
+
+  function pctStr(pct) {
+    return String(Math.round(pct)).padStart(3) + '%';
+  }
+
+  function colorPct(pct) {
+    const colorFn = pct >= 80 ? chalk.red : pct >= 50 ? chalk.yellow : chalk.green;
+    return colorFn(pctStr(pct));
+  }
+
+  function modelLine(name, pct5h, reset5h, pct7d, reset7d, isCurrent) {
+    const label = isCurrent ? chalk.white.bold(name.padEnd(6)) : chalk.dim(name.padEnd(6));
+    const marker = isCurrent ? chalk.white(' ←') : '';
+    const r5 = reset5h ? ' ' + formatResetTime(reset5h) : '';
+    const r7 = reset7d ? ' ' + formatResetTime(reset7d) : '';
+    const sep = chalk.dim(' │ ');
+    return ` ${label}${sep}${chalk.dim('5h')} ${colorPct(pct5h)}${chalk.dim(r5)}${sep}${chalk.dim('7d')} ${colorPct(pct7d)}${chalk.dim(r7)}${marker}`;
+  }
+
+  function drawHeader() {
+    if (destroyed) return;
+    saveCursor();
+
+    const pct = state.total > 0 ? Math.round((state.done / state.total) * 100) : 0;
+    const barWidth = Math.min(20, cols - 40);
+    const bar = progressBar(state.done, state.total, barWidth);
+
+    // Line 1: Title + progress bar
+    moveTo(1);
+    clearLine();
+    write(` ${chalk.bold.cyan('GOLEM BUILD')}  ${chalk.green(bar)}  ${state.done}/${state.total} (${pct}%)`);
+
+    // Line 2: Stage + claude call count
+    moveTo(2);
+    clearLine();
+    const stagePart = state.stage ? ` ${chalk.dim(state.stage)}` : '';
+    const callsPart = state.claudeCalls > 0 ? `  ${chalk.dim('calls:')} ${chalk.white(String(state.claudeCalls))}` : '';
+    write(`${stagePart}${callsPart}`);
+
+    // Line 3: Task info + attempt counter + timer
+    moveTo(3);
+    clearLine();
+    const taskLabel = state.taskId ? `Task ${state.taskId}: ${state.taskTitle}` : '';
+    const elapsed = formatElapsed();
+    const showAttempt = state.maxAttempts > 1 || state.attempt > 1;
+    const attemptStr = showAttempt ? `attempt ${state.attempt}/${state.maxAttempts}` : '';
+    const reservedWidth = elapsed.length + 6 + (showAttempt ? attemptStr.length + 4 : 0);
+    const taskStr = taskLabel.slice(0, Math.max(10, cols - reservedWidth - 4));
+    const attemptColored = showAttempt
+      ? (state.attempt >= 3 ? chalk.red : state.attempt === 2 ? chalk.yellow : chalk.green)(attemptStr)
+      : '';
+    const rightSide = (showAttempt ? attemptColored + '  ' : '') + chalk.dim('⏱') + ' ' + chalk.yellow(elapsed);
+    const rightLen = (showAttempt ? attemptStr.length + 2 : 0) + 2 + elapsed.length;
+    const gap = Math.max(1, cols - taskStr.length - rightLen - 2);
+    write(` ${chalk.white(taskStr)}${' '.repeat(gap)}${rightSide}`)
+
+    // Lines 4-5: Per-model rate limits or sparklines fallback
+    moveTo(4);
+    clearLine();
+    moveTo(5);
+    clearLine();
+    if (state.opus5hPct !== null) {
+      const cur = (state.taskModel || '').toLowerCase();
+      moveTo(4);
+      write(modelLine('opus', state.opus5hPct, state.opus5hResetsAt, state.opus7dPct, state.opus7dResetsAt, cur.includes('opus')));
+      moveTo(5);
+      write(modelLine('sonnet', state.sonnet5hPct, state.sonnet5hResetsAt, state.sonnet7dPct, state.sonnet7dResetsAt, cur.includes('sonnet')));
+      moveTo(6);
+      clearLine();
+      if (state.extraPct !== null) {
+        const used = `$${state.extraUsed.toFixed(2)}`;
+        const limit = `$${state.extraLimit}`;
+        const colorFn = state.extraPct >= 80 ? chalk.red : state.extraPct >= 50 ? chalk.yellow : chalk.green;
+        write(` ${chalk.dim('extra')}  ${colorFn(used)}${chalk.dim('/')}${chalk.dim(limit)} ${colorFn(pctStr(state.extraPct))}`);
+      }
+    } else {
+      moveTo(4);
+      const todayPart = `Today ${chalk.cyan(state.todaySparkline)}  ${chalk.white(state.todayTotal)} tokens`;
+      const weekPart = `Week ${chalk.cyan(state.weekSparkline)}  ${chalk.white(state.weekTotal)}`;
+      write(` ${todayPart}  ${chalk.dim('│')}  ${weekPart}`);
+    }
+
+    // Line 7: Separator
+    moveTo(7);
+    clearLine();
+    write(chalk.dim('─'.repeat(cols)));
+
+    restoreCursor();
+  }
+
+  function setupScrollRegion() {
+    rows = process.stdout.rows || 24;
+    cols = process.stdout.columns || 80;
+    setScrollRegion(HEADER_LINES, rows);
+    moveTo(rows); // cursor at bottom of scroll region
+  }
+
+  const tui = {
+    init(taskData, usageData) {
+      startTime = Date.now();
+
+      state.taskId = taskData.taskId || '';
+      state.taskTitle = taskData.taskTitle || '';
+      state.stage = taskData.stage || '';
+      state.done = taskData.done || 0;
+      state.total = taskData.total || 0;
+
+      if (usageData) {
+        state.todaySparkline = sparkline(usageData.today);
+        state.todayTotal = formatTokens(usageData.todayTotal);
+        state.weekSparkline = sparkline(usageData.week);
+        state.weekTotal = formatTokens(usageData.weekTotal);
+      }
+
+      altScreenOn();
+      cursorHide();
+      mouseOn();
+
+      if (process.stdin.isTTY && !process.stdin.isRaw) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('data', (data) => {
+          if (data[0] === 3) process.emit('SIGINT');
+        });
+      }
+
+      setupScrollRegion();
+      drawHeader();
+
+      timer = setInterval(() => drawHeader(), 1000);
+
+      process.stdout.on('resize', () => {
+        setupScrollRegion();
+        drawHeader();
+      });
+    },
+
+    resetTimer() {
+      cumulativeMs += Date.now() - startTime;
+      startTime = Date.now();
+    },
+
+    getCumulativeElapsed() {
+      return cumulativeMs + (Date.now() - startTime);
+    },
+
+    updateTask(taskData) {
+      if (taskData.taskId !== undefined) state.taskId = taskData.taskId;
+      if (taskData.taskTitle !== undefined) state.taskTitle = taskData.taskTitle;
+      if (taskData.stage !== undefined) state.stage = taskData.stage;
+      if (taskData.done !== undefined) state.done = taskData.done;
+      if (taskData.total !== undefined) state.total = taskData.total;
+      if (taskData.attempt !== undefined) state.attempt = taskData.attempt;
+      if (taskData.maxAttempts !== undefined) state.maxAttempts = taskData.maxAttempts;
+      if (taskData.claudeCalls !== undefined) state.claudeCalls = taskData.claudeCalls;
+      drawHeader();
+    },
+
+    updateTokens(input, output) {
+      state.inputTokens += input;
+      state.outputTokens += output;
+      drawHeader();
+    },
+
+    updateRateLimit(usage) {
+      // 5h is shared across models
+      state.opus5hPct = usage.fiveHour.utilization;
+      state.opus5hResetsAt = usage.fiveHour.resetsAt;
+      state.sonnet5hPct = usage.fiveHour.utilization;
+      state.sonnet5hResetsAt = usage.fiveHour.resetsAt;
+
+      // 7d: opus uses its own bucket, or falls back to overall seven_day
+      const opusBucket = usage.opus || usage.sevenDay;
+      state.opus7dPct = opusBucket.utilization;
+      state.opus7dResetsAt = opusBucket.resetsAt;
+
+      // 7d: sonnet has its own bucket, or falls back to overall
+      const sonnetBucket = usage.sonnet || usage.sevenDay;
+      state.sonnet7dPct = sonnetBucket.utilization;
+      state.sonnet7dResetsAt = sonnetBucket.resetsAt;
+
+      // Extra usage (overage billing)
+      if (usage.extraUsage && usage.extraUsage.enabled) {
+        state.extraUsed = usage.extraUsage.used;
+        state.extraLimit = usage.extraUsage.limit;
+        state.extraPct = usage.extraUsage.utilization;
+      }
+
+      drawHeader();
+    },
+
+    updateUsage(usageData) {
+      state.todaySparkline = sparkline(usageData.today);
+      state.todayTotal = formatTokens(usageData.todayTotal);
+      state.weekSparkline = sparkline(usageData.week);
+      state.weekTotal = formatTokens(usageData.weekTotal);
+      drawHeader();
+    },
+
+    setTaskModel(raw) {
+      // Normalize full model IDs to short names
+      const m = (raw || '').toLowerCase();
+      if (m.includes('opus')) state.taskModel = 'opus';
+      else if (m.includes('sonnet')) state.taskModel = 'sonnet';
+      else if (m.includes('haiku')) state.taskModel = 'haiku';
+      else state.taskModel = raw || '';
+      drawHeader();
+    },
+
+    appendLog(line) {
+      if (destroyed) return;
+      const maxWidth = cols - 2; // 2 char right padding
+      const wrapped = wordWrap(line, maxWidth, 8);
+      for (const wl of wrapped) {
+        moveTo(rows);
+        write('\n' + wl);
+      }
+    },
+
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      if (timer) clearInterval(timer);
+      process.stdout.removeAllListeners('resize');
+      mouseOff();
+      if (process.stdin.isTTY && process.stdin.isRaw) {
+        process.stdin.setRawMode(false);
+        process.stdin.removeAllListeners('data');
+        process.stdin.pause();
+      }
+      resetScrollRegion();
+      altScreenOff();
+      cursorShow();
+    },
+  };
+
+  return tui;
+}

package/.golem/lib/usage.mjs

@@ -0,0 +1,119 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const PROJECTS_DIR = join(homedir(), '.claude', 'projects');
+const SPARK_CHARS = '▁▂▃▄▅▆▇█';
+
+/**
+ * Generate a sparkline string from an array of numeric values.
+ */
+export function sparkline(values) {
+  if (!values.length) return '';
+  const max = Math.max(...values);
+  if (max === 0) return SPARK_CHARS[0].repeat(values.length);
+  return values.map(v => SPARK_CHARS[Math.min(Math.floor((v / max) * 7), 7)]).join('');
+}
+
+/**
+ * Format token count for display: 1.2k, 142k, 1.3M
+ */
+export function formatTokens(n) {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${Math.round(n / 1_000)}k`;
+  return String(n);
+}
+
+/**
+ * Scan all JSONL session files, sum input+output tokens.
+ * Returns { today: number[], todayTotal: number, week: number[], weekTotal: number }
+ *   today = 24-element array (tokens per hour)
+ *   week  = 7-element array (tokens per day, index 0 = 6 days ago, 6 = today)
+ */
+export async function getUsageData() {
+  const now = new Date();
+  const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const weekStart = new Date(todayStart);
+  weekStart.setDate(weekStart.getDate() - 6);
+
+  const hourly = new Array(24).fill(0);
+  const daily = new Array(7).fill(0);
+  let todayTotal = 0;
+  let weekTotal = 0;
+
+  let projectDirs;
+  try {
+    projectDirs = await readdir(PROJECTS_DIR);
+  } catch {
+    return { today: hourly, todayTotal: 0, week: daily, weekTotal: 0 };
+  }
+
+  for (const dir of projectDirs) {
+    const projectPath = join(PROJECTS_DIR, dir);
+    let files;
+    try {
+      files = await readdir(projectPath);
+    } catch {
+      continue;
+    }
+
+    for (const file of files) {
+      if (!file.endsWith('.jsonl')) continue;
+      const filePath = join(projectPath, file);
+
+      let fileStat;
+      try {
+        fileStat = await stat(filePath);
+      } catch {
+        continue;
+      }
+
+      // Skip files not modified in the last 7 days
+      if (fileStat.mtimeMs < weekStart.getTime()) continue;
+
+      let content;
+      try {
+        content = await readFile(filePath, 'utf-8');
+      } catch {
+        continue;
+      }
+
+      for (const line of content.split('\n')) {
+        if (!line) continue;
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+
+        const msg = obj.message;
+        if (!msg || typeof msg !== 'object') continue;
+        const usage = msg.usage;
+        if (!usage) continue;
+
+        const tokens = (usage.input_tokens || 0) + (usage.output_tokens || 0);
+        if (tokens === 0) continue;
+
+        const ts = obj.timestamp ? new Date(obj.timestamp) : null;
+        if (!ts || ts < weekStart) continue;
+
+        // Weekly bucket
+        const dayIndex = Math.floor((ts - weekStart) / 86_400_000);
+        if (dayIndex >= 0 && dayIndex < 7) {
+          daily[dayIndex] += tokens;
+          weekTotal += tokens;
+        }
+
+        // Hourly bucket (today only)
+        if (ts >= todayStart) {
+          const hour = ts.getHours();
+          hourly[hour] += tokens;
+          todayTotal += tokens;
+        }
+      }
+    }
+  }
+
+  return { today: hourly, todayTotal, week: daily, weekTotal };
+}