@vibe-cafe/vibe-usage 0.10.5 → 0.10.8

package/src/parsers/pi-coding-agent.js

@@ -1,144 +1,10 @@
-import { readdirSync, readFileSync, existsSync } from 'node:fs';
-import { join, basename } from 'node:path';
-import { homedir } from 'node:os';
-import { aggregateToBuckets, extractSessions } from './index.js';
-
-/**
- * pi-coding-agent parser.
- * Reads JSONL session files from ~/.pi/agent/sessions/ (or $PI_CODING_AGENT_DIR/sessions/).
- *
- * Session file layout:
- *   sessions/<encoded-cwd>/{timestamp}_{sessionId}.jsonl
- *
- * Each JSONL line is a session entry:
- *   - type "session": header with id, cwd, version
- *   - type "message": contains message object with role, usage, model, timestamp
- *   - type "model_change", "compaction", etc.: metadata (ignored for usage)
- *
- * Assistant messages carry per-message token usage:
- *   message.usage = { input, output, cacheRead, cacheWrite, totalTokens }
- */
-
-function getSessionsDir() {
-  const envDir = process.env.PI_CODING_AGENT_DIR;
-  if (envDir) return join(envDir, 'sessions');
-  return join(homedir(), '.pi', 'agent', 'sessions');
-}
-
-function findJsonlFiles(dir) {
-  const results = [];
-  if (!existsSync(dir)) return results;
-  try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const fullPath = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        results.push(...findJsonlFiles(fullPath));
-      } else if (entry.name.endsWith('.jsonl')) {
-        results.push(fullPath);
-      }
-    }
-  } catch {
-    // ignore unreadable directories
-  }
-  return results;
-}
-
-function extractProjectFromCwd(cwd) {
-  if (!cwd) return 'unknown';
-  const parts = cwd.replace(/\\/g, '/').split('/').filter(Boolean);
-  return parts.length > 0 ? parts[parts.length - 1] : 'unknown';
-}
-
-function extractProjectFromDir(filePath, sessionsDir) {
-  const relative = filePath.slice(sessionsDir.length + 1);
-  const firstSeg = relative.split('/')[0] || relative.split('\\')[0];
-  if (!firstSeg) return 'unknown';
-  const parts = firstSeg.split('-').filter(Boolean);
-  return parts.length > 0 ? parts[parts.length - 1] : 'unknown';
-}
+import { getPiSessionDirs } from '../pi-roots.js';
+import { parsePiSessionJsonl } from './pi-session-jsonl.js';
 
+/** Parse the official Pi agent's Pi-compatible JSONL sessions. */
 export async function parse() {
-  const sessionsDir = getSessionsDir();
-  const entries = [];
-  const sessionEvents = [];
-  const seenEntryIds = new Set();
-
-  const sessionFiles = findJsonlFiles(sessionsDir);
-
-  for (const filePath of sessionFiles) {
-    let content;
-    try {
-      content = readFileSync(filePath, 'utf-8');
-    } catch {
-      continue;
-    }
-
-    let sessionId = basename(filePath, '.jsonl');
-    let project = extractProjectFromDir(filePath, sessionsDir);
-
-    for (const line of content.split('\n')) {
-      if (!line.trim()) continue;
-
-      let obj;
-      try {
-        obj = JSON.parse(line);
-      } catch {
-        continue;
-      }
-
-      if (obj.type === 'session') {
-        if (obj.id) sessionId = obj.id;
-        if (obj.cwd) project = extractProjectFromCwd(obj.cwd);
-        continue;
-      }
-
-      if (obj.type !== 'message') continue;
-
-      const msg = obj.message;
-      if (!msg) continue;
-
-      let ts;
-      if (obj.timestamp) {
-        ts = new Date(obj.timestamp);
-      } else if (msg.timestamp) {
-        ts = new Date(msg.timestamp);
-      }
-      if (!ts || isNaN(ts.getTime())) continue;
-
-      if (msg.role === 'user' || msg.role === 'assistant' || msg.role === 'toolResult') {
-        sessionEvents.push({
-          sessionId,
-          source: 'pi-coding-agent',
-          project,
-          timestamp: ts,
-          role: msg.role === 'user' ? 'user' : 'assistant',
-        });
-      }
-
-      if (msg.role !== 'assistant') continue;
-      if (!msg.usage) continue;
-
-      const usage = msg.usage;
-      if (usage.input == null && usage.output == null) continue;
-
-      const entryId = obj.id;
-      if (entryId) {
-        if (seenEntryIds.has(entryId)) continue;
-        seenEntryIds.add(entryId);
-      }
-
-      entries.push({
-        source: 'pi-coding-agent',
-        model: msg.model || 'unknown',
-        project,
-        timestamp: ts,
-        inputTokens: usage.input || 0,
-        outputTokens: usage.output || 0,
-        cachedInputTokens: usage.cacheRead || 0,
-        reasoningOutputTokens: 0,
-      });
-    }
-  }
-
-  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+  return parsePiSessionJsonl({
+    source: 'pi-coding-agent',
+    sessionsDirs: getPiSessionDirs(),
+  });
 }

package/src/parsers/pi-session-jsonl.js

@@ -0,0 +1,148 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+const MAX_WARNINGS = 20;
+
+function warn(ctx, message) {
+  ctx.incomplete = true;
+  if (ctx.warnings.length < MAX_WARNINGS) ctx.warnings.push(message);
+}
+
+function findJsonlFiles(dir, includeFile, ctx) {
+  if (!existsSync(dir)) return [];
+  let children;
+  try {
+    children = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    warn(ctx, `${ctx.source}: cannot read directory ${dir}: ${err.message}`);
+    return [];
+  }
+
+  const files = [];
+  for (const child of children) {
+    const filePath = join(dir, child.name);
+    if (child.isDirectory()) files.push(...findJsonlFiles(filePath, includeFile, ctx));
+    else if (child.name.endsWith('.jsonl') && includeFile(filePath)) files.push(filePath);
+  }
+  return files;
+}
+
+function tokenCount(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+
+export function projectFromCwd(cwd) {
+  if (typeof cwd !== 'string') return 'unknown';
+  const parts = cwd.replace(/\\/g, '/').split('/').filter(Boolean);
+  return parts.at(-1) || 'unknown';
+}
+
+export function projectFromFirstDir(filePath, sessionsDir) {
+  const first = relative(sessionsDir, filePath).split(/[\\/]/)[0];
+  if (!first) return 'unknown';
+  return first.split('-').filter(Boolean).at(-1) || 'unknown';
+}
+
+export async function parsePiSessionJsonl({
+  source,
+  sessionsDirs,
+  includeFile = () => true,
+  projectFromPath = projectFromFirstDir,
+}) {
+  const ctx = { source, warnings: [], incomplete: false };
+  const entriesById = new Map();
+  const anonymousEntries = [];
+  const eventsById = new Map();
+  const anonymousEvents = [];
+
+  for (const sessionsDir of sessionsDirs) {
+    for (const filePath of findJsonlFiles(sessionsDir, includeFile, ctx)) {
+      let content;
+      try {
+        content = readFileSync(filePath, 'utf8');
+      } catch (err) {
+        warn(ctx, `${source}: cannot read ${filePath}: ${err.message}`);
+        continue;
+      }
+
+      let sessionId = basename(filePath, '.jsonl');
+      let project = projectFromPath(filePath, sessionsDir) || 'unknown';
+
+      for (const line of content.split('\n')) {
+        if (!line.trim()) continue;
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+
+        if (obj.type === 'session') {
+          if (obj.id) sessionId = String(obj.id);
+          if (obj.cwd) project = projectFromCwd(obj.cwd);
+          continue;
+        }
+        if (obj.type !== 'message' || !obj.message) continue;
+
+        const message = obj.message;
+        const timestamp = new Date(obj.timestamp || message.timestamp || 0);
+        if (Number.isNaN(timestamp.getTime())) continue;
+        const recordId = obj.id ? `${sessionId}:${obj.id}` : null;
+
+        if (message.role === 'user' || message.role === 'assistant' || message.role === 'toolResult') {
+          const event = {
+            sessionId,
+            source,
+            project,
+            timestamp,
+            role: message.role === 'user' ? 'user' : 'assistant',
+          };
+          if (recordId) eventsById.set(recordId, event);
+          else anonymousEvents.push(event);
+        }
+
+        if (message.role !== 'assistant' || !message.usage) continue;
+        const usage = message.usage;
+        const inputTokens = tokenCount(usage.input) + tokenCount(usage.cacheWrite);
+        const reasoningOutputTokens = tokenCount(usage.reasoningTokens);
+        // OMP/Pi usage.output includes reasoning; the shared bucket contract
+        // stores non-reasoning output and reasoning separately.
+        const outputTokens = Math.max(0, tokenCount(usage.output) - reasoningOutputTokens);
+        const cachedInputTokens = tokenCount(usage.cacheRead);
+        const score = inputTokens + outputTokens + cachedInputTokens + reasoningOutputTokens;
+        if (score === 0) continue;
+
+        const entry = {
+          source,
+          model: message.model || message.modelId || obj.model || obj.modelId || 'unknown',
+          project,
+          timestamp,
+          inputTokens,
+          outputTokens,
+          cachedInputTokens,
+          reasoningOutputTokens,
+        };
+        if (!recordId) {
+          anonymousEntries.push(entry);
+        } else {
+          const current = entriesById.get(recordId);
+          if (!current || score > current.score) entriesById.set(recordId, { score, entry });
+        }
+      }
+    }
+  }
+
+  const entries = [
+    ...anonymousEntries,
+    ...[...entriesById.values()].map(({ entry }) => entry),
+  ];
+  const events = [...anonymousEvents, ...eventsById.values()];
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(events),
+    ...(ctx.incomplete ? { skipped: true } : {}),
+    ...(ctx.warnings.length > 0 ? { warnings: ctx.warnings } : {}),
+  };
+}

package/src/parsers/workbuddy.js

@@ -0,0 +1,287 @@
+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 './index.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;
+  return basename(cwd.replace(/[\\/]+$/, '')) || 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()) files.push(...findJsonlFiles(filePath, ctx));
+    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 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;
+  const outputDetails = primary?.output_details
+    ?? primary?.outputDetails
+    ?? primary?.outputTokensDetails;
+  const cachedInputTokens = firstDetailValue(inputDetails, 'cached_tokens', 'cachedTokens')
+    || finite(
+      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?.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
+  );
+}
+
+export async function parse() {
+  const entriesById = new Map();
+  const eventsById = new Map();
+  const anonymousEvents = [];
+  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 sessionId = 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);
+
+        if (timestamp && (role === 'user' || isCompletedAssistant(record))) {
+          fileEvents.push({ id, sessionId, timestamp, role });
+        }
+
+        if (!id || !timestamp || !isCompletedAssistant(record)) return;
+        const usage = usageFor(record);
+        if (!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,
+        };
+        if (candidate.id) eventsById.set(candidate.id, event);
+        else anonymousEvents.push(event);
+      }
+    }
+  }
+
+  return {
+    buckets: aggregateToBuckets([...entriesById.values()].map(({ entry }) => entry)),
+    sessions: extractSessions([...eventsById.values(), ...anonymousEvents]),
+    ...(ctx.skipped ? { skipped: true } : {}),
+    ...(ctx.warnings.length > 0 ? { warnings: ctx.warnings } : {}),
+  };
+}

package/src/pi-roots.js

@@ -0,0 +1,89 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { homedir } from 'node:os';
+
+function expandHome(value) {
+  const trimmed = value.trim();
+  if (trimmed === '~') return homedir();
+  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return join(homedir(), trimmed.slice(2));
+  }
+  return trimmed;
+}
+
+function uniqueExistingDirs(paths) {
+  return [...new Set(paths.map(expandHome))].filter(existsSync);
+}
+
+function profileSessionDirs(profilesRoot, includesAgentDir) {
+  const dirs = [];
+  let profiles;
+  try {
+    profiles = readdirSync(profilesRoot, { withFileTypes: true });
+  } catch {
+    return dirs;
+  }
+  for (const profile of profiles) {
+    if (!profile.isDirectory()) continue;
+    dirs.push(join(
+      profilesRoot,
+      profile.name,
+      ...(includesAgentDir ? ['agent', 'sessions'] : ['sessions']),
+    ));
+  }
+  return dirs;
+}
+
+export function looksLikeOmpAgentDir(agentDir) {
+  const normalized = agentDir.replace(/\\/g, '/');
+  return normalized.includes('/.omp/')
+    || existsSync(join(agentDir, 'config.yml'))
+    || existsSync(join(agentDir, 'agent.db'));
+}
+
+export function getPiSessionDirs() {
+  const override = process.env.VIBE_USAGE_PI_SESSION_DIRS?.trim();
+  if (override) return uniqueExistingDirs(override.split(delimiter));
+
+  const agentDir = process.env.PI_CODING_AGENT_DIR?.trim();
+  if (agentDir) {
+    const expanded = expandHome(agentDir);
+    // OMP inherits PI_CODING_AGENT_DIR from Pi. Do not parse an identifiable
+    // OMP store again as source=pi-coding-agent.
+    return looksLikeOmpAgentDir(expanded) ? [] : uniqueExistingDirs([join(expanded, 'sessions')]);
+  }
+  return uniqueExistingDirs([join(homedir(), '.pi', 'agent', 'sessions')]);
+}
+
+export function getOmpSessionDirs() {
+  const override = process.env.VIBE_USAGE_OMP_SESSION_DIRS?.trim();
+  if (override) return uniqueExistingDirs(override.split(delimiter));
+
+  const dirs = [];
+  const configName = process.env.PI_CONFIG_DIR?.trim() || '.omp';
+  const configRoot = join(homedir(), configName);
+  dirs.push(join(configRoot, 'agent', 'sessions'));
+  dirs.push(...profileSessionDirs(join(configRoot, 'profiles'), true));
+
+  const agentOverride = process.env.PI_CODING_AGENT_DIR?.trim();
+  if (agentOverride) {
+    const expanded = expandHome(agentOverride);
+    if (looksLikeOmpAgentDir(expanded)) dirs.push(join(expanded, 'sessions'));
+  }
+
+  // OMP's XDG migration flattens the agent/ segment:
+  // ~/.omp/agent/sessions -> $XDG_DATA_HOME/omp/sessions.
+  if (process.platform === 'linux' || process.platform === 'darwin') {
+    const xdgDataHome = process.env.XDG_DATA_HOME?.trim();
+    if (xdgDataHome) {
+      const xdgRoot = join(expandHome(xdgDataHome), 'omp');
+      dirs.push(join(xdgRoot, 'sessions'));
+      dirs.push(...profileSessionDirs(join(xdgRoot, 'profiles'), false));
+    }
+  }
+
+  return uniqueExistingDirs(dirs);
+}
+
+export const findPiDataDirs = getPiSessionDirs;
+export const findOmpDataDirs = getOmpSessionDirs;