@geoqiao/pi-usage 0.1.0

package/vendor/vibe-usage/src/parsers/trae-cli.js

@@ -0,0 +1,171 @@
+import { createReadStream, existsSync, readdirSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { join } from 'node:path';
+import { findTraeCliDataDirs } from '../tools.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { readJsonSafe, projectFromPath } from './fs-utils.js';
+
+// Trae writes each LLM call as several nested spans that share one session-level
+// traceID and copy the same usage onto every layer:
+//   model.stream.eino  (authoritative: includes reasoning tokens)
+//   model.real_call    (duplicate)
+//   model.call         (duplicate)
+// model.generate is a separate failover call (different model), not a duplicate.
+// Counting every layer would 3x; merging by traceID with max() collapses a
+// whole session of sequential calls into a single request. Keep one unique
+// layer per call, then SUM.
+const PRIMARY_LLM_CATEGORY = 'model.stream.eino';
+const FAILOVER_LLM_CATEGORY = 'model.generate';
+const FALLBACK_LLM_CATEGORIES = ['model.real_call', 'model.call'];
+
+function tagMapFrom(tags) {
+  const tagMap = {};
+  if (!Array.isArray(tags)) return tagMap;
+  for (const t of tags) {
+    if (t && typeof t === 'object' && t.key) tagMap[t.key] = t.value;
+  }
+  return tagMap;
+}
+
+function spanCategory(tagMap) {
+  return typeof tagMap['span.category'] === 'string' ? tagMap['span.category'] : '';
+}
+
+function usageFromTagMap(tagMap) {
+  const inputTokens = Math.max(0, Number(tagMap['usage.input_tokens']) || 0);
+  const outputTokens = Math.max(0, Number(tagMap['usage.output_tokens']) || 0);
+  const cacheReadTokens = Math.max(0, Number(tagMap['usage.cache_read_tokens']) || 0);
+  const reasoningTokens = Math.max(0, Number(tagMap['usage.reasoning_tokens']) || 0);
+  return { inputTokens, outputTokens, cacheReadTokens, reasoningTokens };
+}
+
+function hasUsage(usage) {
+  return usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.reasoningTokens > 0;
+}
+
+/**
+ * Pick the unique LLM-call spans from a session's traces.
+ * Prefer model.stream.eino (+ model.generate failovers). If a session has no
+ * primary layer (older traces), fall back to model.real_call, then model.call.
+ * @param {{category: string, usage: object, model: string|null, startTime: number}[]} spans
+ */
+export function selectTraeUsageSpans(spans) {
+  const withUsage = spans.filter((s) => hasUsage(s.usage));
+  const primary = withUsage.filter((s) => s.category === PRIMARY_LLM_CATEGORY);
+  const failover = withUsage.filter((s) => s.category === FAILOVER_LLM_CATEGORY);
+  if (primary.length > 0 || failover.length > 0) return primary.concat(failover);
+  for (const cat of FALLBACK_LLM_CATEGORIES) {
+    const subset = withUsage.filter((s) => s.category === cat);
+    if (subset.length > 0) return subset;
+  }
+  return withUsage;
+}
+
+/** Stream a JSONL file line by line. Skips missing files and malformed lines. */
+export async function forEachJsonl(path, onObj) {
+  if (!existsSync(path)) return;
+  const stream = createReadStream(path, { encoding: 'utf8' });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let obj;
+      try {
+        obj = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (obj && typeof obj === 'object') onObj(obj);
+    }
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+
+export async function parse() {
+  const cacheDirs = findTraeCliDataDirs();
+  if (cacheDirs.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const events = [];
+
+  for (const cacheDir of cacheDirs) {
+    let sessionDirs = [];
+    try {
+      sessionDirs = readdirSync(cacheDir, { withFileTypes: true })
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name);
+    } catch {
+      continue;
+    }
+
+    for (const sessionId of sessionDirs) {
+      const sessionPath = join(cacheDir, sessionId);
+      const sessionJson = readJsonSafe(join(sessionPath, 'session.json')) || {};
+      const project = projectFromPath(sessionJson.metadata?.cwd);
+      const fallbackModel = sessionJson.metadata?.model_name || 'trae-unknown';
+
+      const spans = [];
+      await forEachJsonl(join(sessionPath, 'traces.jsonl'), (line) => {
+        const tagMap = tagMapFrom(line.tags);
+        const usage = usageFromTagMap(tagMap);
+        if (!hasUsage(usage)) return;
+        const startTime = Number(line.startTime);
+        if (!Number.isFinite(startTime) || startTime <= 0) return;
+        spans.push({
+          category: spanCategory(tagMap),
+          model: tagMap['model.name'] || tagMap['semantic.name'] || null,
+          startTime,
+          usage,
+        });
+      });
+
+      for (const span of selectTraeUsageSpans(spans)) {
+        // Trae startTime is microseconds; Date expects milliseconds.
+        const timestamp = new Date(span.startTime / 1000);
+        if (Number.isNaN(timestamp.getTime())) continue;
+        entries.push({
+          source: 'trae-cli',
+          model: span.model || fallbackModel,
+          project,
+          timestamp,
+          inputTokens: span.usage.inputTokens,
+          outputTokens: span.usage.outputTokens,
+          cachedInputTokens: span.usage.cacheReadTokens,
+          reasoningOutputTokens: span.usage.reasoningTokens,
+        });
+      }
+
+      await forEachJsonl(join(sessionPath, 'events.jsonl'), (line) => {
+        if (!line.created_at) return;
+        const timestamp = new Date(line.created_at);
+        if (Number.isNaN(timestamp.getTime())) return;
+
+        if (line.agent_start) {
+          events.push({
+            sessionId,
+            source: 'trae-cli',
+            project,
+            timestamp,
+            role: 'user',
+          });
+        } else if (line.agent_end || line.tool_call || (line.message && line.message.message?.role === 'assistant')) {
+          events.push({
+            sessionId,
+            source: 'trae-cli',
+            project,
+            timestamp,
+            role: 'assistant',
+          });
+        }
+      });
+    }
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(events),
+  };
+}

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

@@ -0,0 +1,322 @@
+import { createReadStream, readdirSync, statSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { basename, join, relative, sep } from 'node:path';
+import { findWorkbuddyDataDirs } from '../workbuddy-roots.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+
+const SOURCE = 'workbuddy';
+const MAX_WARNINGS = 20;
+
+function warn(ctx, message) {
+  ctx.skipped = true;
+  if (ctx.warnings.length < MAX_WARNINGS && !ctx.warnings.includes(message)) {
+    ctx.warnings.push(message);
+  }
+}
+
+function finite(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : 0;
+}
+
+function dateFrom(value) {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    const date = new Date(value < 1e12 ? value * 1000 : value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  if (typeof value === 'string' && value.trim()) {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  return null;
+}
+
+function projectFromFile(filePath, projectsDir) {
+  const first = relative(projectsDir, filePath).split(sep).filter(Boolean)[0];
+  return first ? basename(first) : 'unknown';
+}
+
+function projectFromRecord(record) {
+  const cwd = typeof record.cwd === 'string' ? record.cwd.trim() : '';
+  if (!cwd) return null;
+  const parts = cwd
+    .replace(/[\\/]+$/, '')
+    .split(/[\\/]/)
+    .filter(Boolean)
+    .filter(part => !/^[a-zA-Z]:$/.test(part));
+  return parts.at(-1) || null;
+}
+
+function findJsonlFiles(dir, ctx) {
+  let children;
+  try {
+    children = readdirSync(dir, { withFileTypes: true })
+      .sort((a, b) => a.name.localeCompare(b.name));
+  } catch (error) {
+    if (error?.code === 'ENOENT') return [];
+    warn(ctx, 'workbuddy: cannot read a data directory');
+    return [];
+  }
+
+  const files = [];
+  for (const child of children) {
+    const filePath = join(dir, child.name);
+    if (child.isDirectory()) {
+      for (const nested of findJsonlFiles(filePath, ctx)) files.push(nested);
+    } else if (child.isFile() && child.name.endsWith('.jsonl')) {
+      files.push(filePath);
+    }
+  }
+  return files;
+}
+
+async function readJsonl(filePath, size, onRecord, ctx) {
+  if (size <= 0) return;
+  const stream = createReadStream(filePath, {
+    encoding: 'utf8',
+    start: 0,
+    end: size - 1,
+  });
+  let streamError = null;
+  stream.on('error', error => { streamError = error; });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+
+  try {
+    for await (const line of lines) {
+      if (!line.trim()) continue;
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (record && typeof record === 'object') onRecord(record);
+    }
+    if (streamError) throw streamError;
+  } catch {
+    warn(ctx, 'workbuddy: cannot read a session file');
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+
+function recordId(record) {
+  if (typeof record.id !== 'string' && typeof record.id !== 'number') return null;
+  const id = String(record.id).trim();
+  return id || null;
+}
+
+function roleFor(record) {
+  const role = record.role ?? record.message?.role;
+  if (role === 'user') return 'user';
+  if (role === 'assistant' || role === 'assistant_message') return 'assistant';
+  return null;
+}
+
+function isCompletedAssistant(record) {
+  if (record.type !== 'message' || roleFor(record) !== 'assistant') return false;
+  const status = String(
+    record.status ?? record.message?.status ?? record.state ?? record.message?.state ?? ''
+  ).toLowerCase();
+  return status === 'completed' || status === 'complete' || status === 'success';
+}
+
+function isUsageRecord(record) {
+  return isCompletedAssistant(record)
+    || (record.type === 'function_call'
+      && record.providerData
+      && typeof record.providerData === 'object');
+}
+
+function modelFor(record) {
+  const providerData = record.providerData && typeof record.providerData === 'object'
+    ? record.providerData
+    : {};
+  for (const value of [
+    providerData.requestModelId,
+    record.requestModelName,
+    providerData.requestModelName,
+    providerData.model,
+  ]) {
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return 'unknown';
+}
+
+function firstDetailValue(details, ...keys) {
+  for (const detail of Array.isArray(details) ? details : [details]) {
+    if (!detail || typeof detail !== 'object') continue;
+    for (const key of keys) {
+      if (detail[key] != null) return finite(detail[key]);
+    }
+  }
+  return 0;
+}
+
+function usageFor(record) {
+  const providerData = record.providerData && typeof record.providerData === 'object'
+    ? record.providerData
+    : {};
+  const primary = providerData.usage && typeof providerData.usage === 'object'
+    ? providerData.usage
+    : record.message?.usage && typeof record.message.usage === 'object'
+      ? record.message.usage
+      : null;
+  const raw = providerData.rawUsage && typeof providerData.rawUsage === 'object'
+    ? providerData.rawUsage
+    : null;
+  if (!primary && !raw) return null;
+
+  const inputDetails = primary?.input_details
+    ?? primary?.inputDetails
+    ?? primary?.inputTokensDetails
+    ?? raw?.prompt_tokens_details;
+  const outputDetails = primary?.output_details
+    ?? primary?.outputDetails
+    ?? primary?.outputTokensDetails
+    ?? raw?.completion_tokens_details;
+  const cachedInputTokens = firstDetailValue(inputDetails, 'cached_tokens', 'cachedTokens')
+    || finite(
+      primary?.cachedInputTokens
+      ?? primary?.cache_read_input_tokens
+      ?? primary?.cacheReadInputTokens
+      ?? raw?.prompt_cache_hit_tokens
+      ?? raw?.cache_read_input_tokens
+    );
+  const reasoningOutputTokens = firstDetailValue(outputDetails, 'reasoning_tokens', 'reasoningTokens')
+    || finite(
+      primary?.reasoningOutputTokens
+      ?? primary?.completion_thinking_tokens
+      ?? primary?.reasoning_tokens
+      ?? primary?.reasoningTokens
+      ?? raw?.completion_thinking_tokens
+    );
+  const inclusiveInput = finite(primary?.inputTokens ?? primary?.input_tokens ?? raw?.prompt_tokens);
+  const inclusiveOutput = finite(primary?.outputTokens ?? primary?.output_tokens ?? raw?.completion_tokens);
+  const cacheMiss = finite(raw?.prompt_cache_miss_tokens);
+
+  // WorkBuddy's aggregate input/output fields include cache reads/reasoning.
+  // Prefer the provider's exclusive cache-miss field when available.
+  const inputTokens = cacheMiss > 0
+    ? cacheMiss
+    : Math.max(0, inclusiveInput - cachedInputTokens);
+  const outputTokens = Math.max(0, inclusiveOutput - reasoningOutputTokens);
+  const score = inputTokens + outputTokens + cachedInputTokens + reasoningOutputTokens;
+  if (score === 0) return null;
+
+  return {
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+    reasoningOutputTokens,
+    score,
+  };
+}
+
+function timestampFor(record) {
+  return dateFrom(
+    record.completedAt
+    ?? record.completed_at
+    ?? record.timestamp
+    ?? record.createdAt
+    ?? record.created_at
+    ?? record.message?.createdAt
+  );
+}
+
+function sessionEventsWithPrompts(events) {
+  const sessionsWithUsers = new Set(
+    events.filter(event => event.role === 'user').map(event => event.sessionId)
+  );
+  return events.filter(event => sessionsWithUsers.has(event.sessionId));
+}
+
+export async function parse() {
+  const entriesById = new Map();
+  const eventsByKey = new Map();
+  const ctx = { skipped: false, warnings: [] };
+  const projectDirs = [...new Set(findWorkbuddyDataDirs().map(root => (
+    basename(root) === 'projects' ? root : join(root, 'projects')
+  )))];
+
+  for (const projectsDir of projectDirs) {
+    for (const filePath of findJsonlFiles(projectsDir, ctx)) {
+      let size;
+      try {
+        size = statSync(filePath).size;
+      } catch {
+        warn(ctx, 'workbuddy: cannot stat a session file');
+        continue;
+      }
+
+      const fallbackSessionId = basename(filePath, '.jsonl');
+      let project = projectFromFile(filePath, projectsDir);
+      const fileEntries = [];
+      const fileEvents = [];
+
+      await readJsonl(filePath, size, record => {
+        project = projectFromRecord(record) || project;
+        const timestamp = timestampFor(record);
+        const id = recordId(record);
+        const role = roleFor(record);
+        const explicitSessionId = record.sessionId ?? record.session_id;
+        const sessionId = explicitSessionId == null || String(explicitSessionId).trim() === ''
+          ? fallbackSessionId
+          : String(explicitSessionId);
+
+        const usage = isUsageRecord(record) ? usageFor(record) : null;
+        const eventRole = role === 'user'
+          ? 'user'
+          : isCompletedAssistant(record) || (record.type === 'function_call' && usage)
+            ? 'assistant'
+            : null;
+        if (timestamp && eventRole) {
+          fileEvents.push({ id, sessionId, timestamp, role: eventRole });
+        }
+
+        if (!id || !timestamp || !usage) return;
+        fileEntries.push({
+          id,
+          score: usage.score,
+          entry: {
+            source: SOURCE,
+            model: modelFor(record),
+            timestamp,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cachedInputTokens: usage.cachedInputTokens,
+            reasoningOutputTokens: usage.reasoningOutputTokens,
+          },
+        });
+      }, ctx);
+
+      for (const candidate of fileEntries) {
+        candidate.entry.project = project;
+        const current = entriesById.get(candidate.id);
+        if (!current || candidate.score > current.score) entriesById.set(candidate.id, candidate);
+      }
+      for (const candidate of fileEvents) {
+        const event = {
+          sessionId: candidate.sessionId,
+          source: SOURCE,
+          project,
+          timestamp: candidate.timestamp,
+          role: candidate.role,
+        };
+        const key = candidate.id
+          ? `id:${candidate.sessionId}:${candidate.id}:${candidate.role}`
+          : `fallback:${candidate.sessionId}:${candidate.role}:${candidate.timestamp.toISOString()}`;
+        eventsByKey.set(key, event);
+      }
+    }
+  }
+
+  return {
+    buckets: aggregateToBuckets([...entriesById.values()].map(({ entry }) => entry)),
+    sessions: extractSessions(sessionEventsWithPrompts([...eventsByKey.values()])),
+    ...(ctx.skipped ? { skipped: true } : {}),
+    ...(ctx.warnings.length > 0 ? { warnings: ctx.warnings } : {}),
+  };
+}

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

@@ -0,0 +1,115 @@
+import { existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
+
+// ZCode (z.ai / Zhipu's coding agent) stores everything in a SQLite database
+// at ~/.zcode/cli/db/db.sqlite. The `message` table is the canonical source:
+// each row is one user or assistant message, with an assistant message carrying
+// per-request token usage and the working directory. We read it directly rather
+// than the parallel `model_usage` ledger because `message` gives us BOTH session
+// timing (user + assistant rows) and token usage in one pass, with the project
+// path attached to each message.
+const DB_PATH = join(homedir(), '.zcode', 'cli', 'db', 'db.sqlite');
+
+/**
+ * Project name from a ZCode message's path. ZCode records both `cwd` and `root`;
+ * prefer `root` (the workspace root) and fall back to `cwd`, then to the
+ * session's `directory` column (joined in via the query) — taking the last path
+ * component, matching how every other parser names projects.
+ */
+function projectName(root, cwd, sessionDir) {
+  const p = root || cwd || sessionDir;
+  if (!p) return 'unknown';
+  return basename(String(p).replace(/[/\\]+$/, '')) || 'unknown';
+}
+
+export async function parse({ dbPath = DB_PATH } = {}) {
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
+
+  // Older databases may not have parts. Absence of a table is not evidence
+  // of absence of tools. EXISTS preserves one usage row even for parallel calls.
+  const columns = queryDbJson(dbPath, 'PRAGMA table_info(part)').map(row => row.name);
+  const hasParts = ['message_id', 'data'].every(name => columns.includes(name));
+  const requestType = hasParts ? `CASE
+    WHEN EXISTS (SELECT 1 FROM part p WHERE p.message_id = m.id
+      AND CASE WHEN json_valid(p.data) THEN json_extract(p.data, '$.type') = 'tool' ELSE 0 END) THEN 'tool'
+    WHEN json_extract(m.data, '$.finish') = 'stop'
+      AND NOT EXISTS (SELECT 1 FROM part p WHERE p.message_id = m.id AND NOT json_valid(p.data)) THEN 'non_tool'
+    ELSE 'other' END` : "'other'";
+
+  // Join each message to its session so we can fall back to the session's
+  // directory when an individual message has no path (older rows, lite agents).
+  const query = `SELECT
+    ${requestType} AS requestType,
+    m.session_id AS sessionId,
+    m.time_created AS created,
+    json_extract(m.data, '$.role') AS role,
+    json_extract(m.data, '$.modelID') AS modelID,
+    json_extract(m.data, '$.tokens') AS tokens,
+    json_extract(m.data, '$.path.root') AS pathRoot,
+    json_extract(m.data, '$.path.cwd') AS pathCwd,
+    s.directory AS sessionDir
+    FROM message m
+    LEFT JOIN session s ON s.id = m.session_id`;
+
+  let rows;
+  try {
+    rows = queryDbJson(dbPath, query);
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('ZCode');
+    throw err;
+  }
+  if (!rows.length) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const sessionEvents = [];
+
+  for (const row of rows) {
+    const timestamp = new Date(row.created);
+    if (isNaN(timestamp.getTime())) continue;
+
+    const project = projectName(row.pathRoot, row.pathCwd, row.sessionDir);
+    const sessionId = row.sessionId || 'unknown';
+
+    sessionEvents.push({
+      sessionId,
+      source: 'zcode',
+      project,
+      timestamp,
+      role: row.role === 'user' ? 'user' : 'assistant',
+    });
+
+    if (row.role !== 'assistant') continue;
+
+    let tokens;
+    try {
+      tokens = typeof row.tokens === 'string' ? JSON.parse(row.tokens) : row.tokens;
+    } catch {
+      continue;
+    }
+    if (!tokens || (!tokens.input && !tokens.output)) continue;
+
+    // ZCode follows Anthropic-style usage where `input` INCLUDES the cache-read
+    // tokens and `output` INCLUDES reasoning (verified: input + output == total).
+    // Normalize to this codebase's non-overlapping fields so cached/reasoning
+    // tokens aren't double-counted inside input/output.
+    const cachedInput = tokens.cache?.read || 0;
+    const reasoning = tokens.reasoning || 0;
+
+    entries.push({
+      source: 'zcode',
+      requestType: row.requestType,
+      model: row.modelID || 'unknown',
+      project,
+      timestamp,
+      inputTokens: (tokens.input || 0) - cachedInput,
+      outputTokens: (tokens.output || 0) - reasoning,
+      cachedInputTokens: cachedInput,
+      reasoningOutputTokens: reasoning,
+    });
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}