@geoqiao/pi-usage 0.1.0

package/vendor/vibe-usage/src/parsers/claude-code.js

@@ -0,0 +1,372 @@
+import { createReadStream, readdirSync, statSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { join, basename, sep } from 'node:path';
+import {
+  accumulateSessionEvent,
+  aggregateToBuckets,
+  createSessionAccumulator,
+  extractSessions,
+  finalizeSessionAccumulator,
+  sessionAccumulatorIsOrdered,
+} from './aggregate.js';
+import { projectFromCwd, toCount } from './fs-utils.js';
+import { getClaudeRoots } from '../claude-roots.js';
+import { requestTypeFor, mergeRequestTypes } from '../../../../src/analytics.js';
+
+const MAX_WARNINGS = 20;
+
+function addWarning(ctx, message) {
+  ctx.incomplete = true;
+  if (ctx.warnings.length < MAX_WARNINGS) ctx.warnings.push(message);
+}
+
+/** Recursively collect JSONL files without making one unreadable branch fatal. */
+function findJsonlFiles(dir, ctx) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    if (err?.code !== 'ENOENT') {
+      addWarning(ctx, `Claude Code: cannot read directory ${dir}: ${err.message}`);
+    }
+    return [];
+  }
+
+  const results = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      for (const nested of findJsonlFiles(fullPath, ctx)) results.push(nested);
+    } else if (entry.name.endsWith('.jsonl')) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+function projectRelativePath(filePath, projectsDir) {
+  const prefix = projectsDir + sep;
+  return filePath.startsWith(prefix) ? filePath.slice(prefix.length) : null;
+}
+
+/** Best-effort fallback for old records without cwd. */
+function projectFromRelative(relative) {
+  if (!relative) return 'unknown';
+  const firstSegment = relative.split(sep)[0];
+  if (!firstSegment) return 'unknown';
+  const parts = firstSegment.split('-').filter(Boolean);
+  return parts.at(-1) || 'unknown';
+}
+
+function cacheCreationTokens(usage) {
+  const direct = toCount(usage.cache_creation_input_tokens);
+  const breakdown = usage.cache_creation || {};
+  const split =
+    toCount(breakdown.ephemeral_5m_input_tokens) +
+    toCount(breakdown.ephemeral_1h_input_tokens);
+  // Current Claude logs carry both the total and its TTL breakdown. max()
+  // avoids double-counting while remaining tolerant of partially populated logs.
+  return Math.max(direct, split);
+}
+
+function candidateIsBetter(next, current) {
+  if (!current) return true;
+  if (next.size !== current.size) return next.size > current.size;
+  if (next.mtimeMs !== current.mtimeMs) return next.mtimeMs > current.mtimeMs;
+  return next.filePath.localeCompare(current.filePath) < 0;
+}
+
+/**
+ * Group physical files by logical session id and keep candidates ordered by
+ * completeness. A session copied between ~/.claude and CLAUDE_CONFIG_DIR must
+ * use its largest/newest copy, not whichever root happened to be scanned first.
+ */
+function collectCandidates(roots, directoryName, ctx) {
+  const groups = new Map();
+  for (const root of roots) {
+    const baseDir = join(root, directoryName);
+    for (const filePath of findJsonlFiles(baseDir, ctx)) {
+      let stat;
+      try {
+        stat = statSync(filePath);
+      } catch (err) {
+        addWarning(ctx, `Claude Code: cannot stat ${filePath}: ${err.message}`);
+        continue;
+      }
+      const sessionId = basename(filePath, '.jsonl');
+      const relative = projectRelativePath(filePath, baseDir);
+      const candidate = {
+        filePath,
+        sessionId,
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        fallbackProject: directoryName === 'projects'
+          ? projectFromRelative(relative)
+          : 'unknown',
+      };
+      const group = groups.get(sessionId) || [];
+      group.push(candidate);
+      groups.set(sessionId, group);
+    }
+  }
+  for (const group of groups.values()) {
+    group.sort((a, b) => candidateIsBetter(a, b) ? -1 : candidateIsBetter(b, a) ? 1 : 0);
+  }
+  return groups;
+}
+
+/** Read only the file size captured during discovery, so live appends wait. */
+async function readJsonl(candidate, onObject) {
+  if (candidate.size === 0) return;
+  const stream = createReadStream(candidate.filePath, {
+    encoding: 'utf8',
+    start: 0,
+    end: candidate.size - 1,
+  });
+  let streamError = null;
+  stream.on('error', (err) => { streamError = err; });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+
+  try {
+    for await (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        onObject(JSON.parse(line));
+      } catch {
+        // Claude may be appending the final JSONL record while we snapshot it.
+        // A later sync will see the complete line; malformed historical lines
+        // are isolated instead of taking the whole parser down.
+      }
+    }
+    if (streamError) throw streamError;
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+
+function timingEvent(obj, sessionId, project) {
+  if (
+    obj.type !== 'user' &&
+    obj.type !== 'assistant' &&
+    obj.type !== 'tool_use' &&
+    obj.type !== 'tool_result'
+  ) return null;
+  if (!obj.timestamp) return null;
+  const timestamp = new Date(obj.timestamp);
+  if (Number.isNaN(timestamp.getTime())) return null;
+  return {
+    sessionId,
+    source: 'claude-code',
+    project,
+    timestamp,
+    role: obj.type === 'user' ? 'user' : 'assistant',
+  };
+}
+async function collectTimingEvents(candidate, projectForObject) {
+  const events = [];
+  await readJsonl(candidate, (obj) => {
+    const event = timingEvent(
+      obj,
+      candidate.sessionId,
+      projectForObject(obj),
+    );
+    if (event) events.push(event);
+  });
+  return events;
+}
+
+async function finalizeCandidateSession(
+  candidate,
+  accumulator,
+  projectForObject,
+  projectOverride,
+) {
+  if (sessionAccumulatorIsOrdered(accumulator)) {
+    return finalizeSessionAccumulator(
+      accumulator,
+      candidate.sessionId,
+      projectOverride,
+    );
+  }
+
+  // JSONL is normally append-ordered. Preserve the old sort semantics for an
+  // unusual copied/rewritten file without retaining every event on the common
+  // path: re-read only that candidate and let extractSessions() sort it.
+  const events = await collectTimingEvents(candidate, projectForObject);
+  return extractSessions(events)[0] || null;
+}
+
+async function scanProjectCandidate(candidate) {
+  const usageEntries = {
+    entriesByKey: new Map(),
+    anonymousEntries: [],
+  };
+  const sessionAccumulator = createSessionAccumulator();
+  let lastModel = null;
+  let sessionProject = candidate.fallbackProject;
+  let foundSessionCwd = false;
+
+  await readJsonl(candidate, (obj) => {
+    // cwd can change after Claude runs `cd`; project attribution should remain
+    // the directory where this session started, not fragment into subfolders.
+    if (!foundSessionCwd && typeof obj.cwd === 'string' && obj.cwd.trim()) {
+      sessionProject = projectFromCwd(obj.cwd, candidate.fallbackProject);
+      foundSessionCwd = true;
+    }
+    const event = timingEvent(obj, candidate.sessionId, sessionProject);
+    if (event) accumulateSessionEvent(sessionAccumulator, event);
+
+    if (obj.type !== 'assistant' || !obj.message?.usage || !obj.timestamp) return;
+    const timestamp = new Date(obj.timestamp);
+    if (Number.isNaN(timestamp.getTime())) return;
+
+    const usage = obj.message.usage;
+    const rawModel = typeof obj.message.model === 'string'
+      ? obj.message.model.trim()
+      : '';
+    if (rawModel && rawModel !== '<synthetic>') lastModel = rawModel;
+    const model = rawModel && rawModel !== '<synthetic>'
+      ? rawModel
+      : lastModel || 'claude-unknown';
+    const inputTokens = toCount(usage.input_tokens) + cacheCreationTokens(usage);
+    const outputTokens = toCount(usage.output_tokens);
+    const cachedInputTokens = toCount(usage.cache_read_input_tokens);
+    const usageScore = inputTokens + outputTokens + cachedInputTokens;
+
+    // Synthetic bookkeeping messages are common and carry zero usage. Do not
+    // inflate the CLI's bucket count with rows the server will discard anyway.
+    if (usageScore === 0) return;
+
+    mergeUsageEntry(usageEntries, {
+      dedupeKey: usageDedupeKey(obj),
+      usageScore,
+      source: 'claude-code',
+      requestType: requestTypeFor(obj.message),
+      model,
+      project: sessionProject,
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens: 0,
+    });
+  });
+
+  // A cwd can appear after initial metadata/messages. Normalize the completed
+  // session in one place so early records receive the same project label.
+  for (const entry of usageEntries.anonymousEntries) entry.project = sessionProject;
+  for (const entry of usageEntries.entriesByKey.values()) entry.project = sessionProject;
+  const session = await finalizeCandidateSession(
+    candidate,
+    sessionAccumulator,
+    () => sessionProject,
+    sessionProject,
+  );
+  return { usageEntries, session };
+}
+
+async function scanTranscriptCandidate(candidate) {
+  const sessionAccumulator = createSessionAccumulator();
+  const projectForObject = (obj) => projectFromCwd(obj.cwd, 'unknown');
+  await readJsonl(candidate, (obj) => {
+    const event = timingEvent(
+      obj,
+      candidate.sessionId,
+      projectForObject(obj),
+    );
+    if (event) accumulateSessionEvent(sessionAccumulator, event);
+  });
+  const session = await finalizeCandidateSession(
+    candidate,
+    sessionAccumulator,
+    projectForObject,
+  );
+  return { session };
+}
+
+async function scanBestCandidate(candidates, scanner, ctx) {
+  for (const candidate of candidates) {
+    try {
+      return await scanner(candidate);
+    } catch (err) {
+      addWarning(ctx, `Claude Code: cannot read ${candidate.filePath}: ${err.message}`);
+    }
+  }
+  return null;
+}
+
+// One API call is written as several assistant lines - one per content block -
+// that share `message.id`/`requestId` and repeat the same `usage` object, so a
+// per-line key counts the same call once per block. Streaming also emits an
+// early partial line (lower `output_tokens`) before the final one under that
+// same id. Keying on the call identity collapses both, and the existing
+// highest-usageScore wins rule then keeps the final, complete payload.
+// Records without either id (older logs) fall back to the line uuid.
+function usageDedupeKey(obj) {
+  const messageId = typeof obj.message?.id === 'string' ? obj.message.id.trim() : '';
+  const requestId = typeof obj.requestId === 'string' ? obj.requestId.trim() : '';
+  if (messageId || requestId) return `call:${messageId}\u0000${requestId}`;
+  return typeof obj.uuid === 'string' && obj.uuid ? obj.uuid : null;
+}
+
+function mergeUsageEntry(ctx, entry) {
+  if (!entry.dedupeKey) {
+    ctx.anonymousEntries.push(entry);
+    return;
+  }
+  const current = ctx.entriesByKey.get(entry.dedupeKey);
+  // Claude sometimes copies the same record into another session with zeroed
+  // usage. Keep the most complete payload, independent of directory order.
+  const requestType = mergeRequestTypes(current?.requestType, entry.requestType);
+  if (!current || entry.usageScore > current.usageScore) {
+    ctx.entriesByKey.set(entry.dedupeKey, { ...entry, requestType });
+  } else current.requestType = requestType;
+}
+
+function mergeUsageEntries(target, source) {
+  for (const entry of source.anonymousEntries) mergeUsageEntry(target, entry);
+  for (const entry of source.entriesByKey.values()) mergeUsageEntry(target, entry);
+}
+
+function* iterateUsageEntries(ctx) {
+  for (const entry of ctx.anonymousEntries) yield entry;
+  for (const entry of ctx.entriesByKey.values()) yield entry;
+}
+
+export async function parse() {
+  const ctx = {
+    entriesByKey: new Map(),
+    anonymousEntries: [],
+    sessions: [],
+    warnings: [],
+    incomplete: false,
+  };
+  const roots = getClaudeRoots({
+    onWarning: (message) => addWarning(ctx, message),
+  });
+  const projectGroups = collectCandidates(roots, 'projects', ctx);
+  const projectSessionIds = new Set();
+
+  for (const [sessionId, candidates] of projectGroups) {
+    const parsed = await scanBestCandidate(candidates, scanProjectCandidate, ctx);
+    if (!parsed) continue;
+    projectSessionIds.add(sessionId);
+    if (parsed.session) ctx.sessions.push(parsed.session);
+    mergeUsageEntries(ctx, parsed.usageEntries);
+  }
+
+  const transcriptGroups = collectCandidates(roots, 'transcripts', ctx);
+  for (const [sessionId, candidates] of transcriptGroups) {
+    if (projectSessionIds.has(sessionId)) continue;
+    const parsed = await scanBestCandidate(candidates, scanTranscriptCandidate, ctx);
+    if (parsed?.session) ctx.sessions.push(parsed.session);
+  }
+
+  return {
+    buckets: aggregateToBuckets(iterateUsageEntries(ctx)),
+    sessions: ctx.sessions,
+    ...(ctx.incomplete ? { skipped: true } : {}),
+    ...(ctx.warnings.length > 0 ? { warnings: ctx.warnings } : {}),
+  };
+}

package/vendor/vibe-usage/src/parsers/cline.js

@@ -0,0 +1,92 @@
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { readJsonSafe, projectFromPath } from './fs-utils.js';
+import { findClineDataDirs } from '../cline-roots.js';
+
+export async function parse() {
+  const extDirs = findClineDataDirs();
+  if (extDirs.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const events = [];
+
+  const candidates = new Map();
+  for (const extDir of extDirs) {
+    const history = readJsonSafe(join(extDir, 'state', 'taskHistory.json'));
+    if (!Array.isArray(history)) continue;
+
+    for (const item of history) {
+      if (!item || typeof item !== 'object' || !item.id) continue;
+      const taskId = String(item.id);
+      const messagesPath = join(extDir, 'tasks', taskId, 'ui_messages.json');
+      let stat;
+      try {
+        stat = statSync(messagesPath);
+      } catch {
+        continue;
+      }
+      const key = item.ulid ? String(item.ulid) : taskId;
+      const next = { item, taskId, messagesPath, size: stat.size, mtimeMs: stat.mtimeMs };
+      const current = candidates.get(key);
+      if (!current || next.size > current.size || (
+        next.size === current.size && next.mtimeMs > current.mtimeMs
+      )) candidates.set(key, next);
+    }
+  }
+
+  for (const { item, taskId, messagesPath } of candidates.values()) {
+      try {
+        const project = projectFromPath(
+          item.cwdOnTaskInitialization || item.shadowGitConfigWorkTree || item.cwd,
+        );
+        const fallbackModel = (item.modelId && String(item.modelId).trim()) || 'cline-unknown';
+
+        const messages = readJsonSafe(messagesPath);
+        if (!Array.isArray(messages)) continue;
+
+        for (const msg of messages) {
+          if (!msg || typeof msg !== 'object') continue;
+          const ts = Number(msg.ts);
+          if (!Number.isFinite(ts)) continue;
+          const timestamp = new Date(ts);
+
+          if (msg.type === 'say' && msg.say === 'api_req_started') {
+            let info = null;
+            try { info = JSON.parse(msg.text); } catch { /* skip */ }
+            if (!info) continue;
+
+            const inputTokens = Math.max(0, Number(info.tokensIn) || 0);
+            const outputTokens = Math.max(0, Number(info.tokensOut) || 0);
+            const cacheWrites = Math.max(0, Number(info.cacheWrites) || 0);
+            const cacheReads = Math.max(0, Number(info.cacheReads) || 0);
+            if (inputTokens + outputTokens + cacheWrites + cacheReads === 0) continue;
+
+            // Newer Cline embeds the model id directly on the api_req_started payload.
+            const model = (info.model && String(info.model).trim()) || fallbackModel;
+
+            // Bucket schema (matches Cursor's CSV semantics):
+            //   inputTokens       = non-cache input + cache-write tokens (both billed as input)
+            //   cachedInputTokens = cache-read tokens (10% input rate)
+            entries.push({
+              source: 'cline',
+              model,
+              project,
+              timestamp,
+              inputTokens: inputTokens + cacheWrites,
+              outputTokens,
+              cachedInputTokens: cacheReads,
+              reasoningOutputTokens: 0,
+            });
+            events.push({ sessionId: taskId, source: 'cline', project, timestamp, role: 'assistant' });
+          } else if (msg.type === 'ask' || (msg.type === 'say' && msg.say === 'user_feedback')) {
+            events.push({ sessionId: taskId, source: 'cline', project, timestamp, role: 'user' });
+          }
+        }
+      } catch {
+        // Skip this task; keep going for the rest of the history.
+      }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(events) };
+}

package/vendor/vibe-usage/src/parsers/codex-cache.js

@@ -0,0 +1,138 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { createHash, randomBytes } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+// Parser caches are disposable derived data. Keep their schema/version fully
+// separate from ~/.vibe-usage/state.json, whose hashes are the authoritative
+// record of successful uploads and must remain backward-compatible.
+export const CODEX_CACHE_SCHEMA_VERSION = 1;
+export const CODEX_PARSER_ALGORITHM_VERSION = 4;
+
+function hash(value, length = 24) {
+  return createHash('sha256').update(value).digest('hex').slice(0, length);
+}
+
+export function codexCacheEnabled() {
+  return process.env.VIBE_USAGE_CODEX_CACHE !== '0';
+}
+
+export function fileSignature(stat) {
+  return {
+    size: stat.size,
+    mtimeMs: stat.mtimeMs,
+    dev: String(stat.dev),
+    ino: String(stat.ino),
+  };
+}
+
+function sameSignature(a, b) {
+  return a?.size === b.size
+    && a?.mtimeMs === b.mtimeMs
+    && a?.dev === b.dev
+    && a?.ino === b.ino;
+}
+
+export function codexCacheDir(codexHome) {
+  const base = process.env.PI_USAGE_CACHE_DIR?.trim()
+    || join(homedir(), '.pi', 'usage', 'cache');
+  return join(base, 'codex', `root-${hash(codexHome)}`);
+}
+
+function entryPath(codexHome, filePath) {
+  return join(codexCacheDir(codexHome), `${hash(filePath, 32)}.json`);
+}
+
+function tailPath(codexHome, filePath) {
+  return join(codexCacheDir(codexHome), `${hash(filePath, 32)}.tail.json`);
+}
+
+export function loadCodexFileCache(codexHome, filePath, signature) {
+  if (!codexCacheEnabled()) return null;
+  const path = entryPath(codexHome, filePath);
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (parsed.schemaVersion !== CODEX_CACHE_SCHEMA_VERSION) return null;
+    if (parsed.algorithmVersion !== CODEX_PARSER_ALGORITHM_VERSION) return null;
+    if (parsed.filePath !== filePath) return null;
+    if (signature && !sameSignature(parsed.signature, signature)) return null;
+    return parsed;
+  } catch {
+    // Cache corruption is a performance miss, never a correctness failure.
+    return null;
+  }
+}
+
+export function saveCodexFileCache(codexHome, filePath, signature, data) {
+  if (!codexCacheEnabled()) return;
+  const dir = codexCacheDir(codexHome);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const path = entryPath(codexHome, filePath);
+  const tempPath = `${path}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
+  const payload = {
+    schemaVersion: CODEX_CACHE_SCHEMA_VERSION,
+    algorithmVersion: CODEX_PARSER_ALGORITHM_VERSION,
+    filePath,
+    signature,
+    ...data,
+  };
+  try {
+    writeFileSync(tempPath, `${JSON.stringify(payload)}\n`, { encoding: 'utf8', mode: 0o600 });
+    renameSync(tempPath, path);
+  } finally {
+    // A killed writer can leave a unique temp file; a normal failed writer
+    // should not. rmSync is safe here because the target is this call's exact,
+    // random temporary path inside the versioned cache directory.
+    rmSync(tempPath, { force: true });
+  }
+}
+
+export function loadCodexFileTail(codexHome, filePath) {
+  if (!codexCacheEnabled()) return null;
+  const path = tailPath(codexHome, filePath);
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (parsed.schemaVersion !== CODEX_CACHE_SCHEMA_VERSION) return null;
+    if (parsed.algorithmVersion !== CODEX_PARSER_ALGORITHM_VERSION) return null;
+    if (parsed.filePath !== filePath || !parsed.signature || !parsed.tail) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export function saveCodexFileTail(codexHome, filePath, signature, tail) {
+  if (!codexCacheEnabled() || !tail) return;
+  const dir = codexCacheDir(codexHome);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const path = tailPath(codexHome, filePath);
+  const tempPath = `${path}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
+  const payload = {
+    schemaVersion: CODEX_CACHE_SCHEMA_VERSION,
+    algorithmVersion: CODEX_PARSER_ALGORITHM_VERSION,
+    filePath,
+    signature,
+    tail,
+  };
+  try {
+    writeFileSync(tempPath, `${JSON.stringify(payload)}\n`, { encoding: 'utf8', mode: 0o600 });
+    renameSync(tempPath, path);
+  } finally {
+    rmSync(tempPath, { force: true });
+  }
+}
+
+export function removeCodexFileCache(codexHome, filePath) {
+  if (!codexCacheEnabled()) return;
+  rmSync(entryPath(codexHome, filePath), { force: true });
+  rmSync(tailPath(codexHome, filePath), { force: true });
+}