claude-usage-rzp 0.1.0

package/src/config.ts

@@ -0,0 +1,34 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+let dataDir: string | null = null;
+
+export function getDataDir(): string {
+  if (dataDir) {
+    return dataDir;
+  }
+
+  // Check environment variable
+  const envDir = process.env.CLAUDE_DATA_DIR;
+  if (envDir) {
+    dataDir = envDir;
+    return dataDir;
+  }
+
+  // Default to ~/.claude
+  dataDir = join(homedir(), '.claude');
+  return dataDir;
+}
+
+export function setDataDir(path: string): void {
+  dataDir = path;
+}
+
+export function hasStatsCache(): boolean {
+  return existsSync(join(getDataDir(), 'stats-cache.json'));
+}
+
+export function hasProjects(): boolean {
+  return existsSync(join(getDataDir(), 'projects'));
+}

package/src/index.ts

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { setDataDir } from './config';
+import { interactiveCommand } from './commands/interactive';
+import { overviewCommand } from './commands/overview';
+import { projectsCommand } from './commands/projects';
+import { projectCommand } from './commands/project';
+import { sessionCommand } from './commands/session';
+import { configCommand } from './commands/config';
+
+const program = new Command();
+
+program
+  .name('claude-usage')
+  .description('View Claude Code API usage directly in your terminal')
+  .version('0.1.0')
+  .option('--data-dir <path>', 'Path to Claude data directory')
+  .hook('preAction', (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.dataDir) {
+      setDataDir(opts.dataDir);
+    }
+  });
+
+// Default command (interactive)
+program
+  .action(async () => {
+    await interactiveCommand();
+  });
+
+// Overview command (non-interactive, one-shot)
+program
+  .command('overview')
+  .description('Show usage overview and statistics (non-interactive)')
+  .action(() => {
+    overviewCommand();
+  });
+
+// Projects command
+program
+  .command('projects')
+  .description('List all projects with session counts and costs')
+  .action(() => {
+    projectsCommand();
+  });
+
+// Project command
+program
+  .command('project <path>')
+  .description('Show sessions for a specific project')
+  .action((path: string) => {
+    projectCommand(path);
+  });
+
+// Session command
+program
+  .command('session <session-id>')
+  .description('Show detailed message breakdown for a session')
+  .option('--project <path>', 'Project path (encoded or decoded)')
+  .action((sessionId: string, options: { project?: string }) => {
+    sessionCommand(sessionId, options);
+  });
+
+// Config command
+program
+  .command('config')
+  .description('Show current configuration')
+  .action(() => {
+    configCommand();
+  });
+
+program.parse();

package/src/loader.ts

@@ -0,0 +1,360 @@
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import {
+  OverviewStats,
+  ModelStats,
+  DailyActivity,
+  DailyModelTokens,
+  HistoryEntry,
+  SessionMessage,
+  SessionSummary,
+  AssistantMessage,
+} from './types';
+import { getDataDir } from './config';
+import { estimateCost } from './pricing';
+
+export function loadStatsCache(): OverviewStats | null {
+  const statsPath = join(getDataDir(), 'stats-cache.json');
+
+  if (!existsSync(statsPath)) {
+    return null;
+  }
+
+  try {
+    const raw = JSON.parse(readFileSync(statsPath, 'utf-8'));
+
+    // Parse daily activity
+    const dailyActivity: DailyActivity[] = (raw.dailyActivity || []).map((d: any) => ({
+      date: d.date,
+      messageCount: d.messageCount || 0,
+      sessionCount: d.sessionCount || 0,
+      toolCallCount: d.toolCallCount || 0,
+    }));
+
+    // Parse daily model tokens
+    const dailyModelTokens: DailyModelTokens[] = (raw.dailyModelTokens || []).map((d: any) => ({
+      date: d.date,
+      tokensByModel: d.tokensByModel || {},
+    }));
+
+    // Parse model stats
+    const modelStats: Record<string, ModelStats> = {};
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+
+    for (const [modelId, usage] of Object.entries(raw.modelUsage || {})) {
+      const u = usage as any;
+      const stats: ModelStats = {
+        modelId,
+        inputTokens: u.inputTokens || 0,
+        outputTokens: u.outputTokens || 0,
+        cacheCreationInputTokens: u.cacheCreationInputTokens || 0,
+        cacheReadInputTokens: u.cacheReadInputTokens || 0,
+      };
+      modelStats[modelId] = stats;
+      totalInputTokens += stats.inputTokens;
+      totalOutputTokens += stats.outputTokens;
+    }
+
+    return {
+      totalSessions: raw.totalSessions || 0,
+      totalMessages: raw.totalMessages || 0,
+      totalInputTokens,
+      totalOutputTokens,
+      firstSessionDate: raw.firstSessionDate,
+      lastComputedDate: raw.lastComputedDate,
+      dailyActivity,
+      dailyModelTokens,
+      modelStats,
+      hourCounts: raw.hourCounts || {},
+    };
+  } catch (error) {
+    console.error('Failed to load stats-cache.json:', error);
+    return null;
+  }
+}
+
+export function loadHistory(): Record<string, HistoryEntry> {
+  const historyPath = join(getDataDir(), 'history.jsonl');
+
+  if (!existsSync(historyPath)) {
+    return {};
+  }
+
+  const history: Record<string, HistoryEntry> = {};
+
+  try {
+    const lines = readFileSync(historyPath, 'utf-8').split('\n');
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      try {
+        const entry = JSON.parse(line);
+        const sessionId = entry.sessionId;
+
+        if (!sessionId) continue;
+
+        const display = (entry.display || '').trim();
+
+        // Check for /rename command
+        if (display.startsWith('/rename')) {
+          const renamed = display.substring(7).trim();
+          if (renamed) {
+            if (sessionId in history) {
+              history[sessionId].display = renamed;
+              history[sessionId].renamed = true;
+            } else {
+              history[sessionId] = {
+                project: entry.project,
+                timestamp: entry.timestamp,
+                display: renamed,
+                renamed: true,
+              };
+            }
+          }
+        } else {
+          // Regular entry
+          if (!(sessionId in history)) {
+            history[sessionId] = {
+              project: entry.project,
+              timestamp: entry.timestamp,
+              display,
+              renamed: false,
+            };
+          }
+        }
+      } catch (err) {
+        // Skip malformed lines
+        continue;
+      }
+    }
+  } catch (error) {
+    console.error('Failed to read history.jsonl:', error);
+    return {};
+  }
+
+  return history;
+}
+
+function parseMessageUsage(usage: any): {
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+} {
+  return {
+    inputTokens: usage.input_tokens || 0,
+    outputTokens: usage.output_tokens || 0,
+    cacheCreationInputTokens: usage.cache_creation_input_tokens || 0,
+    cacheReadInputTokens: usage.cache_read_input_tokens || 0,
+  };
+}
+
+export function loadSessionMessages(
+  encodedPath: string,
+  sessionId: string
+): SessionMessage[] {
+  const sessionPath = join(getDataDir(), 'projects', encodedPath, `${sessionId}.jsonl`);
+
+  if (!existsSync(sessionPath)) {
+    return [];
+  }
+
+  const messages: SessionMessage[] = [];
+
+  try {
+    const lines = readFileSync(sessionPath, 'utf-8').split('\n');
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      try {
+        const msg: AssistantMessage = JSON.parse(line);
+
+        // Skip non-assistant messages
+        if (msg.type !== 'assistant') continue;
+
+        // Skip synthetic models
+        if (msg.message?.model === '<synthetic>') continue;
+
+        // Skip sidechain
+        if (msg.isSidechain) continue;
+
+        const usage = msg.message?.usage;
+        if (!usage) continue;
+
+        const parsed = parseMessageUsage(usage);
+        const model = msg.message?.model || 'unknown';
+        const cost = estimateCost(
+          model,
+          parsed.inputTokens,
+          parsed.outputTokens,
+          parsed.cacheCreationInputTokens,
+          parsed.cacheReadInputTokens
+        );
+
+        messages.push({
+          timestamp: msg.timestamp || '',
+          model,
+          inputTokens: parsed.inputTokens,
+          outputTokens: parsed.outputTokens,
+          cacheCreationInputTokens: parsed.cacheCreationInputTokens,
+          cacheReadInputTokens: parsed.cacheReadInputTokens,
+          costUsd: cost,
+        });
+      } catch (err) {
+        // Skip malformed lines
+        continue;
+      }
+    }
+  } catch (error) {
+    console.error(`Failed to read session ${sessionId}:`, error);
+    return [];
+  }
+
+  return messages;
+}
+
+export function buildSessionSummary(
+  encodedPath: string,
+  sessionId: string,
+  history: Record<string, HistoryEntry>
+): SessionSummary | null {
+  const messages = loadSessionMessages(encodedPath, sessionId);
+
+  if (messages.length === 0) {
+    return null;
+  }
+
+  // Compute totals
+  let totalInput = messages.reduce((sum, m) => sum + m.inputTokens, 0);
+  let totalOutput = messages.reduce((sum, m) => sum + m.outputTokens, 0);
+  let totalCost = messages.reduce((sum, m) => sum + m.costUsd, 0);
+  const modelsUsed = new Set(messages.map(m => m.model));
+
+  const firstMsgTimestamp = messages[0]?.timestamp || '';
+  const histEntry = history[sessionId] || {};
+  const project = histEntry.project || `/${encodedPath}`;
+
+  let slug = histEntry.display?.trim() || '';
+
+  // Handle renamed sessions
+  if (histEntry.renamed && slug) {
+    slug = slug.substring(0, 100);
+  } else if (slug) {
+    slug = slug.replace(/\n/g, ' ').trim();
+    // Skip meta commands
+    if (slug.startsWith('/') || slug.startsWith('!') || ['yes', 'Sure', 'go ahead'].includes(slug)) {
+      slug = '';
+    } else {
+      slug = slug.substring(0, 80);
+    }
+  }
+
+  if (!slug) {
+    slug = sessionId.substring(0, 8);
+  }
+
+  // Merge subagent tokens
+  const subagentDir = join(getDataDir(), 'projects', encodedPath, sessionId, 'subagents');
+  if (existsSync(subagentDir)) {
+    try {
+      const agentFiles = readdirSync(subagentDir).filter(f => f.startsWith('agent-') && f.endsWith('.jsonl'));
+
+      for (const agentFile of agentFiles) {
+        const agentPath = join(subagentDir, agentFile);
+        const lines = readFileSync(agentPath, 'utf-8').split('\n');
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+
+          try {
+            const msg: AssistantMessage = JSON.parse(line);
+            if (msg.type !== 'assistant') continue;
+            if (msg.message?.model === '<synthetic>') continue;
+
+            const usage = msg.message?.usage;
+            if (!usage) continue;
+
+            const parsed = parseMessageUsage(usage);
+            const model = msg.message?.model || 'unknown';
+            const cost = estimateCost(
+              model,
+              parsed.inputTokens,
+              parsed.outputTokens,
+              parsed.cacheCreationInputTokens,
+              parsed.cacheReadInputTokens
+            );
+
+            totalInput += parsed.inputTokens;
+            totalOutput += parsed.outputTokens;
+            totalCost += cost;
+            modelsUsed.add(model);
+          } catch (err) {
+            continue;
+          }
+        }
+      }
+    } catch (error) {
+      // Ignore subagent errors
+    }
+  }
+
+  return {
+    sessionId,
+    slug,
+    project,
+    timestamp: firstMsgTimestamp,
+    messageCount: messages.length,
+    totalInputTokens: totalInput,
+    totalOutputTokens: totalOutput,
+    totalCostUsd: totalCost,
+    modelsUsed,
+  };
+}
+
+export function buildProjectSummaries(): Record<string, SessionSummary[]> {
+  const projectsDir = join(getDataDir(), 'projects');
+
+  if (!existsSync(projectsDir)) {
+    return {};
+  }
+
+  const history = loadHistory();
+  const projects: Record<string, SessionSummary[]> = {};
+
+  try {
+    const encodedDirs = readdirSync(projectsDir);
+
+    for (const encodedDir of encodedDirs) {
+      const dirPath = join(projectsDir, encodedDir);
+      const stat = require('fs').statSync(dirPath);
+
+      if (!stat.isDirectory()) continue;
+
+      const sessions: SessionSummary[] = [];
+      const files = readdirSync(dirPath);
+
+      for (const file of files) {
+        if (!file.endsWith('.jsonl')) continue;
+
+        const sessionId = file.replace('.jsonl', '');
+        const summary = buildSessionSummary(encodedDir, sessionId, history);
+
+        if (summary) {
+          sessions.push(summary);
+        }
+      }
+
+      if (sessions.length > 0) {
+        projects[encodedDir] = sessions;
+      }
+    }
+  } catch (error) {
+    console.error('Failed to build project summaries:', error);
+    return {};
+  }
+
+  return projects;
+}

package/src/pricing.ts

@@ -0,0 +1,68 @@
+interface ModelPricing {
+  input: number;
+  output: number;
+  cacheWrite: number;
+  cacheRead: number;
+}
+
+// Pricing in $/MTok (million tokens)
+const FALLBACK_PRICING: Record<string, ModelPricing> = {
+  'claude-opus-4-6': {
+    input: 15.0,
+    output: 75.0,
+    cacheWrite: 18.75,
+    cacheRead: 1.5,
+  },
+  'claude-opus-4-5-20251101': {
+    input: 15.0,
+    output: 75.0,
+    cacheWrite: 18.75,
+    cacheRead: 1.5,
+  },
+  'claude-sonnet-4-5-20250929': {
+    input: 3.0,
+    output: 15.0,
+    cacheWrite: 3.75,
+    cacheRead: 0.3,
+  },
+  'claude-haiku-4-5-20251001': {
+    input: 0.8,
+    output: 4.0,
+    cacheWrite: 1.0,
+    cacheRead: 0.08,
+  },
+};
+
+const DEFAULT_PRICING = FALLBACK_PRICING['claude-sonnet-4-5-20250929'];
+
+export function getModelPricing(modelId: string): ModelPricing {
+  if (modelId in FALLBACK_PRICING) {
+    return FALLBACK_PRICING[modelId];
+  }
+  return DEFAULT_PRICING;
+}
+
+export function estimateCost(
+  modelId: string,
+  inputTokens: number = 0,
+  outputTokens: number = 0,
+  cacheCreationInputTokens: number = 0,
+  cacheReadInputTokens: number = 0
+): number {
+  const pricing = getModelPricing(modelId);
+  const cost =
+    (inputTokens * pricing.input +
+      outputTokens * pricing.output +
+      cacheCreationInputTokens * pricing.cacheWrite +
+      cacheReadInputTokens * pricing.cacheRead) /
+    1_000_000;
+  return cost;
+}
+
+export function formatCost(cost: number): string {
+  return `$${cost.toFixed(4)}`;
+}
+
+export function formatTokens(tokens: number): string {
+  return tokens.toLocaleString('en-US');
+}

package/src/types.ts

@@ -0,0 +1,78 @@
+export interface ModelStats {
+  modelId: string;
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+}
+
+export interface DailyActivity {
+  date: string;
+  messageCount: number;
+  sessionCount: number;
+  toolCallCount: number;
+}
+
+export interface DailyModelTokens {
+  date: string;
+  tokensByModel: Record<string, number>;
+}
+
+export interface OverviewStats {
+  totalSessions: number;
+  totalMessages: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  firstSessionDate?: string;
+  lastComputedDate?: string;
+  dailyActivity: DailyActivity[];
+  dailyModelTokens: DailyModelTokens[];
+  modelStats: Record<string, ModelStats>;
+  hourCounts: Record<string, number>;
+}
+
+export interface SessionMessage {
+  timestamp: string;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+  costUsd: number;
+}
+
+export interface SessionSummary {
+  sessionId: string;
+  slug: string;
+  project: string;
+  timestamp: string;
+  messageCount: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCostUsd: number;
+  modelsUsed: Set<string>;
+}
+
+export interface HistoryEntry {
+  project?: string;
+  timestamp?: string;
+  display: string;
+  renamed: boolean;
+}
+
+export interface MessageUsage {
+  input_tokens: number;
+  output_tokens: number;
+  cache_creation_input_tokens: number;
+  cache_read_input_tokens: number;
+}
+
+export interface AssistantMessage {
+  type: string;
+  timestamp?: string;
+  isSidechain?: boolean;
+  message?: {
+    model?: string;
+    usage?: MessageUsage;
+  };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}