@sooneocean/claude-hud 0.1.0

package/src/transcript.ts

@@ -0,0 +1,268 @@
+import * as fs from 'fs';
+import * as readline from 'readline';
+import type { TranscriptData, ToolEntry, AgentEntry, TodoItem } from './types.js';
+import { readCache, writeCache, getDefaultCacheDir } from './cache.js';
+
+interface TranscriptLine {
+  timestamp?: string;
+  type?: string;
+  slug?: string;
+  customTitle?: string;
+  message?: {
+    content?: ContentBlock[];
+  };
+}
+
+interface ContentBlock {
+  type: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  tool_use_id?: string;
+  is_error?: boolean;
+}
+
+function restoreDates(data: TranscriptData): TranscriptData {
+  return {
+    ...data,
+    sessionStart: data.sessionStart ? new Date(data.sessionStart) : undefined,
+    tools: data.tools.map(t => ({
+      ...t,
+      startTime: new Date(t.startTime),
+      endTime: t.endTime ? new Date(t.endTime) : undefined,
+    })),
+    agents: data.agents.map(a => ({
+      ...a,
+      startTime: new Date(a.startTime),
+      endTime: a.endTime ? new Date(a.endTime) : undefined,
+    })),
+    todos: data.todos,
+  };
+}
+
+export async function parseTranscript(transcriptPath: string): Promise<TranscriptData> {
+  const result: TranscriptData = {
+    tools: [],
+    agents: [],
+    todos: [],
+  };
+
+  if (!transcriptPath) {
+    return result;
+  }
+
+  const cacheDir = getDefaultCacheDir();
+  const stats = fs.statSync(transcriptPath, { throwIfNoEntry: false });
+  if (!stats) return result;
+
+  const mtime = stats.mtimeMs;
+  const cacheKey = 'transcript-parsed';
+
+  const cached = readCache<TranscriptData>(cacheKey, 500, cacheDir, mtime);
+  if (cached) {
+    return restoreDates(cached);
+  }
+
+  if (!fs.existsSync(transcriptPath)) {
+    return result;
+  }
+
+  const toolMap = new Map<string, ToolEntry>();
+  const agentMap = new Map<string, AgentEntry>();
+  let latestTodos: TodoItem[] = [];
+  const taskIdToIndex = new Map<string, number>();
+  let latestSlug: string | undefined;
+  let customTitle: string | undefined;
+
+  try {
+    const fileStream = fs.createReadStream(transcriptPath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity,
+    });
+
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+
+      try {
+        const entry = JSON.parse(line) as TranscriptLine;
+        if (entry.type === 'custom-title' && typeof entry.customTitle === 'string') {
+          customTitle = entry.customTitle;
+        } else if (typeof entry.slug === 'string') {
+          latestSlug = entry.slug;
+        }
+        processEntry(entry, toolMap, agentMap, taskIdToIndex, latestTodos, result);
+      } catch {
+        // Skip malformed lines
+      }
+    }
+  } catch {
+    // Return partial results on error
+  }
+
+  result.tools = Array.from(toolMap.values()).slice(-20);
+  result.agents = Array.from(agentMap.values()).slice(-10);
+  result.todos = latestTodos;
+  result.sessionName = customTitle ?? latestSlug;
+
+  writeCache(cacheKey, result, cacheDir, mtime);
+  return result;
+}
+
+function processEntry(
+  entry: TranscriptLine,
+  toolMap: Map<string, ToolEntry>,
+  agentMap: Map<string, AgentEntry>,
+  taskIdToIndex: Map<string, number>,
+  latestTodos: TodoItem[],
+  result: TranscriptData
+): void {
+  const timestamp = entry.timestamp ? new Date(entry.timestamp) : new Date();
+
+  if (!result.sessionStart && entry.timestamp) {
+    result.sessionStart = timestamp;
+  }
+
+  const content = entry.message?.content;
+  if (!content || !Array.isArray(content)) return;
+
+  for (const block of content) {
+    if (block.type === 'tool_use' && block.id && block.name) {
+      const toolEntry: ToolEntry = {
+        id: block.id,
+        name: block.name,
+        target: extractTarget(block.name, block.input),
+        status: 'running',
+        startTime: timestamp,
+      };
+
+      if (block.name === 'Task') {
+        const input = block.input as Record<string, unknown>;
+        const agentEntry: AgentEntry = {
+          id: block.id,
+          type: (input?.subagent_type as string) ?? 'unknown',
+          model: (input?.model as string) ?? undefined,
+          description: (input?.description as string) ?? undefined,
+          status: 'running',
+          startTime: timestamp,
+        };
+        agentMap.set(block.id, agentEntry);
+      } else if (block.name === 'TodoWrite') {
+        const input = block.input as { todos?: TodoItem[] };
+        if (input?.todos && Array.isArray(input.todos)) {
+          latestTodos.length = 0;
+          taskIdToIndex.clear();
+          latestTodos.push(...input.todos);
+        }
+      } else if (block.name === 'TaskCreate') {
+        const input = block.input as Record<string, unknown>;
+        const subject = typeof input?.subject === 'string' ? input.subject : '';
+        const description = typeof input?.description === 'string' ? input.description : '';
+        const content = subject || description || 'Untitled task';
+        const status = normalizeTaskStatus(input?.status) ?? 'pending';
+        latestTodos.push({ content, status });
+
+        const rawTaskId = input?.taskId;
+        const taskId = typeof rawTaskId === 'string' || typeof rawTaskId === 'number'
+          ? String(rawTaskId)
+          : block.id;
+        if (taskId) {
+          taskIdToIndex.set(taskId, latestTodos.length - 1);
+        }
+      } else if (block.name === 'TaskUpdate') {
+        const input = block.input as Record<string, unknown>;
+        const index = resolveTaskIndex(input?.taskId, taskIdToIndex, latestTodos);
+        if (index !== null) {
+          const status = normalizeTaskStatus(input?.status);
+          if (status) {
+            latestTodos[index].status = status;
+          }
+
+          const subject = typeof input?.subject === 'string' ? input.subject : '';
+          const description = typeof input?.description === 'string' ? input.description : '';
+          const content = subject || description;
+          if (content) {
+            latestTodos[index].content = content;
+          }
+        }
+      } else {
+        toolMap.set(block.id, toolEntry);
+      }
+    }
+
+    if (block.type === 'tool_result' && block.tool_use_id) {
+      const tool = toolMap.get(block.tool_use_id);
+      if (tool) {
+        tool.status = block.is_error ? 'error' : 'completed';
+        tool.endTime = timestamp;
+      }
+
+      const agent = agentMap.get(block.tool_use_id);
+      if (agent) {
+        agent.status = 'completed';
+        agent.endTime = timestamp;
+      }
+    }
+  }
+}
+
+function extractTarget(toolName: string, input?: Record<string, unknown>): string | undefined {
+  if (!input) return undefined;
+
+  switch (toolName) {
+    case 'Read':
+    case 'Write':
+    case 'Edit':
+      return (input.file_path as string) ?? (input.path as string);
+    case 'Glob':
+      return input.pattern as string;
+    case 'Grep':
+      return input.pattern as string;
+    case 'Bash':
+      const cmd = input.command as string;
+      return cmd?.slice(0, 30) + (cmd?.length > 30 ? '...' : '');
+  }
+  return undefined;
+}
+
+function resolveTaskIndex(
+  taskId: unknown,
+  taskIdToIndex: Map<string, number>,
+  latestTodos: TodoItem[]
+): number | null {
+  if (typeof taskId === 'string' || typeof taskId === 'number') {
+    const key = String(taskId);
+    const mapped = taskIdToIndex.get(key);
+    if (typeof mapped === 'number') {
+      return mapped;
+    }
+
+    if (/^\d+$/.test(key)) {
+      const numericIndex = Number.parseInt(key, 10) - 1;
+      if (numericIndex >= 0 && numericIndex < latestTodos.length) {
+        return numericIndex;
+      }
+    }
+  }
+
+  return null;
+}
+
+function normalizeTaskStatus(status: unknown): TodoItem['status'] | null {
+  if (typeof status !== 'string') return null;
+
+  switch (status) {
+    case 'pending':
+    case 'not_started':
+      return 'pending';
+    case 'in_progress':
+    case 'running':
+      return 'in_progress';
+    case 'completed':
+    case 'complete':
+    case 'done':
+      return 'completed';
+    default:
+      return null;
+  }
+}

package/src/types.ts

@@ -0,0 +1,146 @@
+import type { HudConfig } from './config.js';
+import type { GitStatus } from './git.js';
+import type { CostEstimate } from './cost-tracker.js';
+
+export interface StdinData {
+  transcript_path?: string;
+  cwd?: string;
+  model?: {
+    id?: string;
+    display_name?: string;
+  };
+  context_window?: {
+    context_window_size?: number;
+    current_usage?: {
+      input_tokens?: number;
+      output_tokens?: number;
+      cache_creation_input_tokens?: number;
+      cache_read_input_tokens?: number;
+    } | null;
+    // Native percentage fields (Claude Code v2.1.6+)
+    used_percentage?: number | null;
+    remaining_percentage?: number | null;
+  };
+}
+
+export interface ToolEntry {
+  id: string;
+  name: string;
+  target?: string;
+  status: 'running' | 'completed' | 'error';
+  startTime: Date;
+  endTime?: Date;
+}
+
+export interface AgentEntry {
+  id: string;
+  type: string;
+  model?: string;
+  description?: string;
+  status: 'running' | 'completed';
+  startTime: Date;
+  endTime?: Date;
+}
+
+export interface TodoItem {
+  content: string;
+  status: 'pending' | 'in_progress' | 'completed';
+}
+
+/** Usage window data from the OAuth API */
+export interface UsageWindow {
+  utilization: number | null;  // 0-100 percentage, null if unavailable
+  resetAt: Date | null;
+}
+
+export interface UsageData {
+  planName: string | null;  // 'Max', 'Pro', or null for API users
+  fiveHour: number | null;  // 0-100 percentage, null if unavailable
+  sevenDay: number | null;  // 0-100 percentage, null if unavailable
+  fiveHourResetAt: Date | null;
+  sevenDayResetAt: Date | null;
+  apiUnavailable?: boolean; // true if API call failed (user should check DEBUG logs)
+  apiError?: string; // short error reason (e.g., 401, timeout)
+}
+
+/** Check if usage limit is reached (either window at 100%) */
+export function isLimitReached(data: UsageData): boolean {
+  return data.fiveHour === 100 || data.sevenDay === 100;
+}
+
+export interface TranscriptData {
+  tools: ToolEntry[];
+  agents: AgentEntry[];
+  todos: TodoItem[];
+  sessionStart?: Date;
+  sessionName?: string;
+}
+
+// Framework provider types
+export interface FrameworkEntry {
+  label: string;
+  status: 'running' | 'completed' | 'error' | 'waiting';
+  progress?: string;
+  detail?: string;
+}
+
+export interface FrameworkStatus {
+  provider: string;
+  entries: FrameworkEntry[];
+}
+
+export interface FrameworkProvider {
+  name: string;
+  isAvailable(): boolean;
+  fetch(): Promise<FrameworkStatus | null>;
+}
+
+// Alert types
+export interface AlertAction {
+  visual: boolean;
+  bell: boolean;
+  predict: boolean;
+}
+
+export interface Alert {
+  type: 'context-warning' | 'context-critical' | 'usage-5h-warning' | 'usage-5h-critical' | 'usage-7d-warning';
+  message: string;
+  actions: AlertAction;
+}
+
+// Burn rate
+export interface BurnRate {
+  tokensPerMinute: number;
+  estimatedCallsRemaining: number;
+}
+
+// Session stats
+export interface SessionStats {
+  startTime?: Date;
+  totalToolCalls: number;
+  totalAgentRuns: number;
+  peakContextPercent: number;
+  autocompactCount: number;
+}
+
+export interface RenderContext {
+  stdin: StdinData;
+  transcript: TranscriptData;
+  claudeMdCount: number;
+  rulesCount: number;
+  mcpCount: number;
+  hooksCount: number;
+  sessionDuration: string;
+  gitStatus: GitStatus | null;
+  usageData: UsageData | null;
+  config: HudConfig;
+  extraLabel: string | null;
+  frameworkStatus: FrameworkStatus[];
+  alerts: Alert[];
+  burnRate: BurnRate | null;
+  sessionStats: SessionStats;
+  sparkline: number[];
+  terminalWidth: number | null;
+  costEstimate: CostEstimate | null;
+  apiLatency: number | null;
+}