@sooneocean/claude-hud 0.1.0

package/src/render/tools-line.ts

@@ -0,0 +1,58 @@
+import type { RenderContext } from '../types.js';
+import { yellow, green, cyan, dim, magenta, red } from './colors.js';
+import { truncatePath } from '../utils/format.js';
+
+export function renderToolsLine(ctx: RenderContext): string | null {
+  const { tools } = ctx.transcript;
+
+  if (tools.length === 0) {
+    return null;
+  }
+
+  const parts: string[] = [];
+
+  const runningTools = tools.filter((t) => t.status === 'running');
+  const completedTools = tools.filter((t) => t.status === 'completed' || t.status === 'error');
+
+  for (const tool of runningTools.slice(-2)) {
+    const target = tool.target ? truncatePath(tool.target.replace(/\\/g, '/')) : '';
+    parts.push(`${yellow('◐')} ${cyan(tool.name)}${target ? dim(`: ${target}`) : ''}`);
+  }
+
+  const toolCounts = new Map<string, number>();
+  for (const tool of completedTools) {
+    const count = toolCounts.get(tool.name) ?? 0;
+    toolCounts.set(tool.name, count + 1);
+  }
+
+  const sortedTools = Array.from(toolCounts.entries())
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 4);
+
+  for (const [name, count] of sortedTools) {
+    parts.push(`${green('✓')} ${name} ${dim(`×${count}`)}`);
+  }
+
+  // Show error count if any tools failed
+  const errorCount = ctx.transcript.tools.filter(t => t.status === 'error').length;
+  if (errorCount > 0) {
+    parts.push(`${red('✘')} ${errorCount} err`);
+  }
+
+  if (ctx.config.display.mergeToolsAgents && ctx.transcript.agents.length > 0) {
+    const recentAgents = ctx.transcript.agents.slice(-2);
+    for (const agent of recentAgents) {
+      const icon = agent.status === 'running' ? magenta('◐') : green('✓');
+      const model = agent.model ? dim(`[${agent.model}]`) : '';
+      const desc = agent.description ? dim(`: ${agent.description.slice(0, 30)}`) : '';
+      parts.push(`${icon} ${agent.type || 'agent'}${model}${desc}`);
+    }
+  }
+
+  if (parts.length === 0) {
+    return null;
+  }
+
+  return parts.join(' | ');
+}
+

package/src/session-history.ts

@@ -0,0 +1,62 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const DEBUG = process.env.DEBUG?.includes('claude-hud') || process.env.DEBUG === '*';
+
+export interface SessionRecord {
+  startTime: string;        // ISO string
+  endTime: string;          // ISO string (when last seen)
+  duration: string;         // formatted "1h 23m"
+  model: string;
+  peakContextPercent: number;
+  autocompactCount: number;
+  totalToolCalls: number;
+  totalAgentRuns: number;
+}
+
+function getHistoryPath(): string {
+  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(process.env.HOME || '', '.claude');
+  return path.join(configDir, 'plugins', 'claude-hud', 'session-history.json');
+}
+
+export function loadHistory(): SessionRecord[] {
+  try {
+    const data = fs.readFileSync(getHistoryPath(), 'utf-8');
+    return JSON.parse(data);
+  } catch (err) {
+    if (DEBUG) console.error('[claude-hud:session-history] file read error:', err);
+    return [];
+  }
+}
+
+export function saveCurrentSession(record: Omit<SessionRecord, 'endTime'>): void {
+  const history = loadHistory();
+  const now = new Date().toISOString();
+
+  // Check if this is an update to the current session (same startTime)
+  const existingIdx = history.findIndex(r => r.startTime === record.startTime);
+  const fullRecord: SessionRecord = { ...record, endTime: now };
+
+  if (existingIdx >= 0) {
+    history[existingIdx] = fullRecord;
+  } else {
+    history.push(fullRecord);
+  }
+
+  // Keep last 50 sessions
+  while (history.length > 50) history.shift();
+
+  const dir = path.dirname(getHistoryPath());
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(getHistoryPath(), JSON.stringify(history, null, 2));
+}
+
+export function getLastSession(): SessionRecord | null {
+  const history = loadHistory();
+  // Return the second-to-last (last completed session, not current)
+  return history.length >= 2 ? history[history.length - 2] : null;
+}
+
+export function formatSessionSummary(record: SessionRecord): string {
+  return `Last: ${record.model} ${record.duration} | ${record.peakContextPercent}% peak | ${record.totalToolCalls} tools | ${record.autocompactCount} compacts`;
+}

package/src/session-stats.ts

@@ -0,0 +1,65 @@
+import { readCache, writeCache } from './cache.js';
+import type { SessionStats } from './types.js';
+
+const CACHE_KEY = 'session-stats';
+const HISTORY_KEY = 'context-history';
+const SPARKLINE_KEY = 'context-sparkline';
+const TTL = 24 * 60 * 60 * 1000;
+const DROP_THRESHOLD = 20;
+const SPARKLINE_MAX = 20;
+
+interface ContextHistory {
+  values: number[];
+}
+
+interface UpdateInput {
+  contextPercent: number;
+  toolCount: number;
+  agentCount: number;
+}
+
+export function getSparkline(cacheDir: string): number[] {
+  return readCache<number[]>(SPARKLINE_KEY, TTL, cacheDir) ?? [];
+}
+
+export function getSessionStats(cacheDir: string): SessionStats {
+  const cached = readCache<SessionStats>(CACHE_KEY, TTL, cacheDir);
+  return cached ?? {
+    totalToolCalls: 0,
+    totalAgentRuns: 0,
+    peakContextPercent: 0,
+    autocompactCount: 0,
+  };
+}
+
+export function updateSessionStats(cacheDir: string, input: UpdateInput): void {
+  const stats = getSessionStats(cacheDir);
+  const history = readCache<ContextHistory>(HISTORY_KEY, TTL, cacheDir) ?? { values: [] };
+
+  stats.totalToolCalls = input.toolCount;
+  stats.totalAgentRuns = input.agentCount;
+  if (input.contextPercent > stats.peakContextPercent) {
+    stats.peakContextPercent = input.contextPercent;
+  }
+
+  history.values.push(input.contextPercent);
+  if (history.values.length > 3) history.values.shift();
+
+  if (history.values.length >= 3) {
+    const [prev2, prev1, current] = history.values.slice(-3);
+    const dropFromPrev2 = prev2 - prev1;
+    const sustainedDrop = prev2 - current;
+    if (dropFromPrev2 > DROP_THRESHOLD && sustainedDrop > DROP_THRESHOLD) {
+      stats.autocompactCount++;
+      history.values = [current];
+    }
+  }
+
+  const sparkline = readCache<number[]>(SPARKLINE_KEY, TTL, cacheDir) ?? [];
+  sparkline.push(input.contextPercent);
+  if (sparkline.length > SPARKLINE_MAX) sparkline.shift();
+  writeCache(SPARKLINE_KEY, sparkline, cacheDir);
+
+  writeCache(CACHE_KEY, stats, cacheDir);
+  writeCache(HISTORY_KEY, history, cacheDir);
+}

package/src/speed-tracker.ts

@@ -0,0 +1,51 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import type { StdinData } from './types.js';
+import { readCache, writeCache } from './cache.js';
+import { getHudPluginDir } from './claude-config-dir.js';
+
+const SPEED_WINDOW_MS = 2000;
+const SPEED_CACHE_KEY = 'speed-tracker';
+
+interface SpeedCache {
+  outputTokens: number;
+  timestamp: number;
+}
+
+export type SpeedTrackerDeps = {
+  homeDir: () => string;
+  now: () => number;
+};
+
+const defaultDeps: SpeedTrackerDeps = {
+  homeDir: () => os.homedir(),
+  now: () => Date.now(),
+};
+
+function getCacheDir(homeDir: string): string {
+  return path.join(getHudPluginDir(homeDir), '.cache');
+}
+
+export function getOutputSpeed(stdin: StdinData, overrides: Partial<SpeedTrackerDeps> = {}): number | null {
+  const outputTokens = stdin.context_window?.current_usage?.output_tokens;
+  if (typeof outputTokens !== 'number' || !Number.isFinite(outputTokens)) {
+    return null;
+  }
+
+  const deps = { ...defaultDeps, ...overrides };
+  const now = deps.now();
+  const cacheDir = getCacheDir(deps.homeDir());
+  const previous = readCache<SpeedCache>(SPEED_CACHE_KEY, 5000, cacheDir);
+
+  let speed: number | null = null;
+  if (previous && outputTokens >= previous.outputTokens) {
+    const deltaTokens = outputTokens - previous.outputTokens;
+    const deltaMs = now - previous.timestamp;
+    if (deltaTokens > 0 && deltaMs > 0 && deltaMs <= SPEED_WINDOW_MS) {
+      speed = deltaTokens / (deltaMs / 1000);
+    }
+  }
+
+  writeCache<SpeedCache>(SPEED_CACHE_KEY, { outputTokens, timestamp: now }, cacheDir);
+  return speed;
+}

package/src/stdin.ts

@@ -0,0 +1,169 @@
+import type { StdinData } from './types.js';
+import { AUTOCOMPACT_BUFFER_PERCENT } from './constants.js';
+
+export async function readStdin(): Promise<StdinData | null> {
+  if (process.stdin.isTTY) {
+    return null;
+  }
+
+  const chunks: string[] = [];
+
+  try {
+    process.stdin.setEncoding('utf8');
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk as string);
+    }
+    const raw = chunks.join('');
+    if (!raw.trim()) {
+      return null;
+    }
+    return JSON.parse(raw) as StdinData;
+  } catch {
+    return null;
+  }
+}
+
+export function getTotalTokens(stdin: StdinData): number {
+  const usage = stdin.context_window?.current_usage;
+  return (
+    (usage?.input_tokens ?? 0) +
+    (usage?.cache_creation_input_tokens ?? 0) +
+    (usage?.cache_read_input_tokens ?? 0)
+  );
+}
+
+/**
+ * Get native percentage from Claude Code v2.1.6+ if available.
+ * Returns null if not available or invalid, triggering fallback to manual calculation.
+ */
+function getNativePercent(stdin: StdinData): number | null {
+  const nativePercent = stdin.context_window?.used_percentage;
+  if (typeof nativePercent === 'number' && !Number.isNaN(nativePercent)) {
+    return Math.min(100, Math.max(0, Math.round(nativePercent)));
+  }
+  return null;
+}
+
+export function getContextPercent(stdin: StdinData): number {
+  // Prefer native percentage (v2.1.6+) - accurate and matches /context
+  const native = getNativePercent(stdin);
+  if (native !== null) {
+    return native;
+  }
+
+  // Fallback: manual calculation without buffer
+  const size = stdin.context_window?.context_window_size;
+  if (!size || size <= 0) {
+    return 0;
+  }
+
+  const totalTokens = getTotalTokens(stdin);
+  return Math.min(100, Math.round((totalTokens / size) * 100));
+}
+
+export function getBufferedPercent(stdin: StdinData): number {
+  // Prefer native percentage (v2.1.6+) so the HUD matches Claude Code's
+  // own context output. The buffered fallback only approximates older versions.
+  const native = getNativePercent(stdin);
+  if (native !== null) {
+    return native;
+  }
+
+  // Fallback: manual calculation with buffer for older Claude Code versions
+  const size = stdin.context_window?.context_window_size;
+  if (!size || size <= 0) {
+    return 0;
+  }
+
+  const totalTokens = getTotalTokens(stdin);
+
+  // Scale buffer by raw usage: no buffer at ≤5% (e.g. after /clear),
+  // full buffer at ≥50%. Autocompact doesn't kick in at very low usage.
+  const rawRatio = totalTokens / size;
+  const LOW = 0.05;
+  const HIGH = 0.50;
+  const scale = Math.min(1, Math.max(0, (rawRatio - LOW) / (HIGH - LOW)));
+  const buffer = size * AUTOCOMPACT_BUFFER_PERCENT * scale;
+
+  return Math.min(100, Math.round(((totalTokens + buffer) / size) * 100));
+}
+
+export function getModelName(stdin: StdinData): string {
+  const displayName = stdin.model?.display_name?.trim();
+  if (displayName) {
+    return displayName;
+  }
+
+  const modelId = stdin.model?.id?.trim();
+  if (!modelId) {
+    return 'Unknown';
+  }
+
+  const normalizedBedrockLabel = normalizeBedrockModelLabel(modelId);
+  return normalizedBedrockLabel ?? modelId;
+}
+
+export function isBedrockModelId(modelId?: string): boolean {
+  if (!modelId) {
+    return false;
+  }
+  const normalized = modelId.toLowerCase();
+  return normalized.includes('anthropic.claude-');
+}
+
+export function getProviderLabel(stdin: StdinData): string | null {
+  if (isBedrockModelId(stdin.model?.id)) {
+    return 'Bedrock';
+  }
+  return null;
+}
+
+function normalizeBedrockModelLabel(modelId: string): string | null {
+  if (!isBedrockModelId(modelId)) {
+    return null;
+  }
+
+  const lowercaseId = modelId.toLowerCase();
+  const claudePrefix = 'anthropic.claude-';
+  const claudeIndex = lowercaseId.indexOf(claudePrefix);
+  if (claudeIndex === -1) {
+    return null;
+  }
+
+  let suffix = lowercaseId.slice(claudeIndex + claudePrefix.length);
+  suffix = suffix.replace(/-v\d+:\d+$/, '');
+  suffix = suffix.replace(/-\d{8}$/, '');
+
+  const tokens = suffix.split('-').filter(Boolean);
+  if (tokens.length === 0) {
+    return null;
+  }
+
+  const familyIndex = tokens.findIndex((token) => token === 'haiku' || token === 'sonnet' || token === 'opus');
+  if (familyIndex === -1) {
+    return null;
+  }
+
+  const family = tokens[familyIndex];
+  const beforeVersion = readNumericVersion(tokens, familyIndex - 1, -1).reverse();
+  const afterVersion = readNumericVersion(tokens, familyIndex + 1, 1);
+  const versionParts = beforeVersion.length >= afterVersion.length ? beforeVersion : afterVersion;
+  const version = versionParts.length ? versionParts.join('.') : null;
+  const familyLabel = family[0].toUpperCase() + family.slice(1);
+
+  return version ? `Claude ${familyLabel} ${version}` : `Claude ${familyLabel}`;
+}
+
+function readNumericVersion(tokens: string[], startIndex: number, step: -1 | 1): string[] {
+  const parts: string[] = [];
+  for (let i = startIndex; i >= 0 && i < tokens.length; i += step) {
+    if (!/^\d+$/.test(tokens[i])) {
+      break;
+    }
+    parts.push(tokens[i]);
+    if (parts.length === 2) {
+      break;
+    }
+  }
+  return parts;
+}

package/src/themes.ts

@@ -0,0 +1,90 @@
+import type { HudColorOverrides } from './config.js';
+
+export interface ColorTheme {
+  name: string;
+  colors: HudColorOverrides;
+}
+
+export const THEMES: Record<string, ColorTheme> = {
+  default: {
+    name: 'Default',
+    colors: {
+      context: 'green',
+      usage: 'brightBlue',
+      warning: 'yellow',
+      usageWarning: 'brightMagenta',
+      critical: 'red',
+    },
+  },
+  catppuccin: {
+    name: 'Catppuccin Mocha',
+    colors: {
+      context: '#a6e3a1',      // green
+      usage: '#89b4fa',        // blue
+      warning: '#f9e2af',      // yellow
+      usageWarning: '#cba6f7', // mauve
+      critical: '#f38ba8',     // red
+    },
+  },
+  dracula: {
+    name: 'Dracula',
+    colors: {
+      context: '#50fa7b',      // green
+      usage: '#8be9fd',        // cyan
+      warning: '#f1fa8c',      // yellow
+      usageWarning: '#bd93f9', // purple
+      critical: '#ff5555',     // red
+    },
+  },
+  nord: {
+    name: 'Nord',
+    colors: {
+      context: '#a3be8c',      // green
+      usage: '#81a1c1',        // blue
+      warning: '#ebcb8b',      // yellow
+      usageWarning: '#b48ead', // purple
+      critical: '#bf616a',     // red
+    },
+  },
+  catppuccin_latte: {
+    name: 'Catppuccin Latte',
+    colors: {
+      context: '#40a02b',      // green
+      usage: '#1e66f5',        // blue
+      warning: '#df8e1d',      // yellow
+      usageWarning: '#8839ef', // mauve
+      critical: '#d20f39',     // red
+    },
+  },
+  nord_light: {
+    name: 'Nord Light',
+    colors: {
+      context: '#a3be8c',      // green (same as dark)
+      usage: '#5e81ac',        // blue
+      warning: '#ebcb8b',      // yellow (same as dark)
+      usageWarning: '#b48ead', // purple (same as dark)
+      critical: '#bf616a',     // red (same as dark)
+    },
+  },
+};
+
+export function getTheme(name: string): ColorTheme | undefined {
+  return THEMES[name.toLowerCase()];
+}
+
+export function getThemeNames(): string[] {
+  return Object.keys(THEMES);
+}
+
+export function detectTerminalTheme(): 'dark' | 'light' | null {
+  // COLORFGBG format: "foreground;background" (e.g., "15;0" = white on black = dark)
+  const colorfgbg = process.env.COLORFGBG;
+  if (!colorfgbg) return null;
+
+  const parts = colorfgbg.split(';');
+  const bg = parseInt(parts[parts.length - 1], 10);
+  if (isNaN(bg)) return null;
+
+  // Low background color = dark theme, high = light theme
+  return bg < 8 ? 'dark' : 'light';
+}