cchubber 0.1.0

package/src/readers/jsonl-reader.js

@@ -0,0 +1,247 @@
+import { readdirSync, readFileSync, existsSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+
+/**
+ * Read all JSONL conversation files from Claude Code's data directories.
+ * This is the primary data source — same approach as ccusage (12K stars, proven pattern).
+ * Claude Code stores full conversation transcripts with token usage per message.
+ */
+export function readAllJSONL(claudeDir) {
+  const projectsDir = join(claudeDir, 'projects');
+  const xdgDir = join(homedir(), '.config', 'claude', 'projects'); // XDG fallback for Linux
+
+  const entries = [];
+
+  // Read from primary location
+  if (existsSync(projectsDir)) {
+    readProjectsDir(projectsDir, entries);
+  }
+
+  // XDG fallback (Linux with newer Claude Code)
+  if (existsSync(xdgDir) && xdgDir !== projectsDir) {
+    readProjectsDir(xdgDir, entries);
+  }
+
+  return entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+
+function readProjectsDir(dir, entries) {
+  try {
+    const projectHashes = readdirSync(dir).filter(f => {
+      const full = join(dir, f);
+      return statSync(full).isDirectory();
+    });
+
+    for (const hash of projectHashes) {
+      const projectDir = join(dir, hash);
+      const jsonlFiles = readdirSync(projectDir).filter(f => f.endsWith('.jsonl'));
+
+      for (const file of jsonlFiles) {
+        const sessionId = basename(file, '.jsonl');
+        const filePath = join(projectDir, file);
+
+        try {
+          const raw = readFileSync(filePath, 'utf-8');
+          const lines = raw.split('\n').filter(l => l.trim());
+
+          for (const line of lines) {
+            try {
+              const record = JSON.parse(line);
+
+              // Only assistant messages have token usage
+              if (record.type !== 'assistant') continue;
+
+              const usage = record.message?.usage;
+              if (!usage) continue;
+
+              entries.push({
+                sessionId,
+                projectHash: hash,
+                timestamp: record.timestamp || '',
+                model: record.message?.model || 'unknown',
+                inputTokens: usage.input_tokens || 0,
+                outputTokens: usage.output_tokens || 0,
+                cacheCreationTokens: usage.cache_creation_input_tokens || 0,
+                cacheReadTokens: usage.cache_read_input_tokens || 0,
+                costUSD: record.costUSD || 0, // Pre-calculated by Claude Code
+              });
+            } catch {
+              // Skip malformed lines
+            }
+          }
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    }
+  } catch {
+    // Directory read failed
+  }
+}
+
+/**
+ * Aggregate JSONL entries into daily summaries.
+ */
+export function aggregateDaily(entries) {
+  const byDate = {};
+
+  for (const entry of entries) {
+    // Extract date from timestamp
+    let date;
+    if (entry.timestamp && entry.timestamp.length >= 10) {
+      date = entry.timestamp.slice(0, 10);
+    } else if (entry.timestamp) {
+      // Epoch milliseconds
+      const ts = parseInt(entry.timestamp);
+      if (!isNaN(ts)) {
+        date = new Date(ts).toISOString().slice(0, 10);
+      }
+    }
+    if (!date) continue;
+
+    if (!byDate[date]) {
+      byDate[date] = {
+        date,
+        totalCost: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        messageCount: 0,
+        models: {},
+        sessions: new Set(),
+      };
+    }
+
+    const day = byDate[date];
+    day.totalCost += entry.costUSD;
+    day.inputTokens += entry.inputTokens;
+    day.outputTokens += entry.outputTokens;
+    day.cacheCreationTokens += entry.cacheCreationTokens;
+    day.cacheReadTokens += entry.cacheReadTokens;
+    day.messageCount++;
+    day.sessions.add(entry.sessionId);
+
+    // Per-model breakdown
+    const model = entry.model;
+    if (!day.models[model]) {
+      day.models[model] = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        cost: 0,
+        messageCount: 0,
+      };
+    }
+    const m = day.models[model];
+    m.inputTokens += entry.inputTokens;
+    m.outputTokens += entry.outputTokens;
+    m.cacheCreationTokens += entry.cacheCreationTokens;
+    m.cacheReadTokens += entry.cacheReadTokens;
+    m.cost += entry.costUSD;
+    m.messageCount++;
+  }
+
+  // Convert sets to counts and sort
+  return Object.values(byDate)
+    .map(d => ({
+      ...d,
+      sessionCount: d.sessions.size,
+      sessions: undefined,
+      cacheOutputRatio: d.outputTokens > 0 ? Math.round(d.cacheReadTokens / d.outputTokens) : 0,
+    }))
+    .sort((a, b) => a.date.localeCompare(b.date));
+}
+
+/**
+ * Aggregate entries into per-model totals.
+ */
+export function aggregateByModel(entries) {
+  const byModel = {};
+
+  for (const entry of entries) {
+    const model = cleanModelName(entry.model);
+    if (!byModel[model]) {
+      byModel[model] = { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, cost: 0, messageCount: 0 };
+    }
+    const m = byModel[model];
+    m.inputTokens += entry.inputTokens;
+    m.outputTokens += entry.outputTokens;
+    m.cacheCreationTokens += entry.cacheCreationTokens;
+    m.cacheReadTokens += entry.cacheReadTokens;
+    m.cost += entry.costUSD;
+    m.messageCount++;
+  }
+
+  return byModel;
+}
+
+/**
+ * Aggregate entries into per-project totals.
+ * Uses the project directory hash — resolves to real path where possible.
+ */
+export function aggregateByProject(entries, claudeDir) {
+  const byProject = {};
+
+  for (const entry of entries) {
+    const hash = entry.projectHash || 'unknown';
+    if (!byProject[hash]) {
+      byProject[hash] = {
+        hash,
+        path: null,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        messageCount: 0,
+        sessionCount: 0,
+        sessions: new Set(),
+        firstSeen: entry.timestamp,
+        lastSeen: entry.timestamp,
+      };
+    }
+    const p = byProject[hash];
+    p.inputTokens += entry.inputTokens;
+    p.outputTokens += entry.outputTokens;
+    p.cacheCreationTokens += entry.cacheCreationTokens;
+    p.cacheReadTokens += entry.cacheReadTokens;
+    p.messageCount++;
+    p.sessions.add(entry.sessionId);
+    if (entry.timestamp > p.lastSeen) p.lastSeen = entry.timestamp;
+    if (entry.timestamp < p.firstSeen) p.firstSeen = entry.timestamp;
+  }
+
+  // Resolve project paths from .claude/projects/<hash>/.project_path if available
+  const projectsDir = join(claudeDir, 'projects');
+  for (const proj of Object.values(byProject)) {
+    proj.sessionCount = proj.sessions.size;
+    delete proj.sessions;
+
+    // Try to read the project path file
+    try {
+      const pathFile = join(projectsDir, proj.hash, '.project_path');
+      if (existsSync(pathFile)) {
+        const raw = readFileSync(pathFile, 'utf-8').trim();
+        proj.path = raw;
+        // Use last directory segment as display name
+        proj.name = raw.split(/[/\\]/).filter(Boolean).pop() || proj.hash.slice(0, 8);
+      } else {
+        proj.name = proj.hash.slice(0, 8);
+      }
+    } catch {
+      proj.name = proj.hash.slice(0, 8);
+    }
+  }
+
+  return Object.values(byProject)
+    .sort((a, b) => b.messageCount - a.messageCount);
+}
+
+function cleanModelName(name) {
+  return (name || 'unknown')
+    .replace('claude-', '')
+    .replace(/-\d{8}$/, '')
+    .replace(/-20\d{6}$/, '');
+}

package/src/readers/oauth-usage.js

@@ -0,0 +1,82 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import https from 'https';
+
+export async function readOAuthUsage(claudeDir) {
+  const token = getOAuthToken(claudeDir);
+  if (!token) return null;
+
+  try {
+    const data = await fetchUsage(token);
+    return data;
+  } catch {
+    // Try cached version
+    return readCachedUsage(claudeDir);
+  }
+}
+
+function getOAuthToken(claudeDir) {
+  // Check env var first
+  if (process.env.CLAUDE_CODE_OAUTH_TOKEN) {
+    return process.env.CLAUDE_CODE_OAUTH_TOKEN;
+  }
+
+  // Read from credentials file
+  const credPath = join(claudeDir, '.credentials.json');
+  if (!existsSync(credPath)) return null;
+
+  try {
+    const raw = readFileSync(credPath, 'utf-8');
+    const creds = JSON.parse(raw);
+    return creds?.claudeAiOauth?.accessToken || null;
+  } catch {
+    return null;
+  }
+}
+
+function fetchUsage(token) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'api.anthropic.com',
+      path: '/api/oauth/usage',
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'anthropic-beta': 'oauth-2025-04-20',
+        'Content-Type': 'application/json',
+      },
+    };
+
+    const req = https.request(options, (res) => {
+      let body = '';
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', () => {
+        if (res.statusCode === 200) {
+          try {
+            resolve(JSON.parse(body));
+          } catch {
+            reject(new Error('Invalid JSON'));
+          }
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}`));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(5000, () => { req.destroy(); reject(new Error('Timeout')); });
+    req.end();
+  });
+}
+
+function readCachedUsage(claudeDir) {
+  const cachePath = join(claudeDir, 'tmp', 'statusline-usage.json');
+  if (!existsSync(cachePath)) return null;
+
+  try {
+    const raw = readFileSync(cachePath, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}

package/src/readers/session-meta.js

@@ -0,0 +1,42 @@
+import { readdirSync, readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+export function readSessionMeta(claudeDir) {
+  const metaDir = join(claudeDir, 'usage-data', 'session-meta');
+  if (!existsSync(metaDir)) return [];
+
+  const sessions = [];
+
+  try {
+    const files = readdirSync(metaDir).filter(f => f.endsWith('.json'));
+
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(metaDir, file), 'utf-8');
+        const data = JSON.parse(raw);
+        sessions.push({
+          sessionId: data.session_id || file.replace('.json', ''),
+          projectPath: data.project_path || 'unknown',
+          startTime: data.start_time || null,
+          durationMinutes: data.duration_minutes || 0,
+          userMessageCount: data.user_message_count || 0,
+          assistantMessageCount: data.assistant_message_count || 0,
+          toolCounts: data.tool_counts || {},
+          inputTokens: data.input_tokens || 0,
+          outputTokens: data.output_tokens || 0,
+          usesTaskAgent: data.uses_task_agent || false,
+          usesMcp: data.uses_mcp || false,
+          linesAdded: data.lines_added || 0,
+          linesRemoved: data.lines_removed || 0,
+          filesModified: data.files_modified || 0,
+        });
+      } catch {
+        // Skip corrupt files
+      }
+    }
+  } catch {
+    return [];
+  }
+
+  return sessions.sort((a, b) => (a.startTime || '').localeCompare(b.startTime || ''));
+}

package/src/readers/stats-cache.js

@@ -0,0 +1,54 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+export function readStatsCache(claudeDir) {
+  const filePath = join(claudeDir, 'stats-cache.json');
+  if (!existsSync(filePath)) return null;
+
+  try {
+    const raw = readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(raw);
+
+    // Extract daily model tokens into a usable format
+    const dailyData = [];
+    const dailyTokens = data.dailyModelTokens || [];
+    const dailyActivity = data.dailyActivity || [];
+
+    // Build a map of activity data
+    const activityMap = {};
+    for (const entry of dailyActivity) {
+      activityMap[entry.date] = entry;
+    }
+
+    for (const entry of dailyTokens) {
+      const models = [];
+      for (const [modelName, tokens] of Object.entries(entry.tokensByModel || {})) {
+        models.push({ modelName, tokens });
+      }
+
+      const activity = activityMap[entry.date] || {};
+
+      dailyData.push({
+        date: entry.date,
+        models,
+        messageCount: activity.messageCount || 0,
+        sessionCount: activity.sessionCount || 0,
+        toolCallCount: activity.toolCallCount || 0,
+      });
+    }
+
+    // Also extract the aggregate model usage with full token breakdowns
+    const modelUsage = data.modelUsage || {};
+
+    return {
+      version: data.version,
+      lastComputedDate: data.lastComputedDate,
+      totalSessions: data.totalSessions || 0,
+      totalMessages: data.totalMessages || 0,
+      dailyData,
+      modelUsage,
+    };
+  } catch (err) {
+    return null;
+  }
+}