@geoqiao/pi-usage 0.1.0

package/vendor/vibe-usage/src/parsers/pi-session-jsonl.js

@@ -0,0 +1,166 @@
+import { existsSync, readdirSync, readFileSync, realpathSync } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { projectFromCwd, toCount } from './fs-utils.js';
+import { requestTypeFor, mergeRequestTypes } from '../../../../src/analytics.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()) {
+      for (const nested of findJsonlFiles(filePath, includeFile, ctx)) files.push(nested);
+    } else if (child.name.endsWith('.jsonl') && includeFile(filePath)) {
+      files.push(filePath);
+    }
+  }
+  return files;
+}
+
+export function projectFromFirstDir(filePath, sessionsDir) {
+  const first = relative(sessionsDir, filePath).split(/[\\/]/)[0];
+  if (!first) return 'unknown';
+  return first.split('-').filter(Boolean).at(-1) || 'unknown';
+}
+
+// Configured stores can overlap: an ancestor and its descendant, or two paths
+// that resolve to the same place through a symlink. Record-level dedup only
+// covers entries carrying an `id`, so the same anonymous record would be
+// counted once per path that reaches it. Collapse on the canonical file path
+// instead, which also folds symlinked duplicates of a single file.
+function canonicalFilePath(filePath) {
+  try {
+    return realpathSync.native(filePath);
+  } catch {
+    return filePath;
+  }
+}
+
+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 = [];
+  const seenFiles = new Set();
+
+  for (const sessionsDir of sessionsDirs) {
+    for (const filePath of findJsonlFiles(sessionsDir, includeFile, ctx)) {
+      const canonical = canonicalFilePath(filePath);
+      if (seenFiles.has(canonical)) continue;
+      seenFiles.add(canonical);
+
+      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 = toCount(usage.input) + toCount(usage.cacheWrite);
+        // Pi's Usage type names this field `reasoning` (a documented subset of
+        // `output`); older/adjacent stores wrote `reasoningTokens`. Reading only
+        // the latter left every Pi reasoning token inside outputTokens.
+        const reasoningOutputTokens = toCount(usage.reasoning ?? usage.reasoningTokens);
+        // OMP/Pi usage.output includes reasoning; the shared bucket contract
+        // stores non-reasoning output and reasoning separately.
+        const outputTokens = Math.max(0, toCount(usage.output) - reasoningOutputTokens);
+        const cachedInputTokens = toCount(usage.cacheRead);
+        const score = inputTokens + outputTokens + cachedInputTokens + reasoningOutputTokens;
+        if (score === 0) continue;
+
+        const entry = {
+          source,
+          requestType: requestTypeFor(message),
+          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);
+          const requestType = mergeRequestTypes(current?.entry.requestType, entry.requestType);
+          if (!current || score > current.score) entriesById.set(recordId, { score, entry: { ...entry, requestType } });
+          else current.entry.requestType = requestType;
+        }
+      }
+    }
+  }
+
+  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/vendor/vibe-usage/src/parsers/qwen-code.js

@@ -0,0 +1,122 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, basename, sep } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+
+/**
+ * Qwen Code parser (Gemini CLI fork).
+ * JSONL at ~/.qwen/tmp/<project_id>/chats/<sessionId>.jsonl
+ * Token fields: usageMetadata.{promptTokenCount, candidatesTokenCount,
+ *   cachedContentTokenCount, thoughtsTokenCount}
+ * Note: promptTokenCount INCLUDES cachedContentTokenCount (needs normalization).
+ */
+
+const QWEN_TMP_DIR = join(homedir(), '.qwen', 'tmp');
+
+function findSessionFiles(baseDir) {
+  const results = [];
+  if (!existsSync(baseDir)) return results;
+
+  try {
+    for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const chatsDir = join(baseDir, entry.name, 'chats');
+      if (!existsSync(chatsDir)) continue;
+      try {
+        for (const f of readdirSync(chatsDir)) {
+          if (f.endsWith('.jsonl')) {
+            results.push(join(chatsDir, f));
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+
+function extractProject(cwd, filePath) {
+  if (cwd) {
+    const parts = cwd.split('/').filter(Boolean);
+    if (parts.length > 0) return parts[parts.length - 1];
+  }
+  const tmpPrefix = QWEN_TMP_DIR + sep;
+  if (filePath.startsWith(tmpPrefix)) {
+    const relative = filePath.slice(tmpPrefix.length);
+    const projectId = relative.split(sep)[0];
+    if (projectId) return projectId;
+  }
+  return 'unknown';
+}
+
+export async function parse() {
+  const sessionFiles = findSessionFiles(QWEN_TMP_DIR);
+  if (sessionFiles.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const sessionEvents = [];
+  const seenUuids = new Set();
+
+  for (const filePath of sessionFiles) {
+    let content;
+    try {
+      content = readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+
+        const timestamp = obj.timestamp;
+        if (!timestamp) continue;
+        const ts = new Date(timestamp);
+        if (isNaN(ts.getTime())) continue;
+
+        if (obj.type === 'user' || obj.type === 'assistant') {
+          sessionEvents.push({
+            sessionId: filePath,
+            source: 'qwen-code',
+            project: extractProject(obj.cwd, filePath),
+            timestamp: ts,
+            role: obj.type === 'user' ? 'user' : 'assistant',
+          });
+        }
+
+        if (obj.type !== 'assistant') continue;
+        const usage = obj.usageMetadata;
+        if (!usage) continue;
+        if (usage.promptTokenCount == null && usage.candidatesTokenCount == null) continue;
+
+        const uuid = obj.uuid;
+        if (uuid) {
+          if (seenUuids.has(uuid)) continue;
+          seenUuids.add(uuid);
+        }
+
+        const cached = usage.cachedContentTokenCount || 0;
+        const thoughts = usage.thoughtsTokenCount || 0;
+
+        entries.push({
+          source: 'qwen-code',
+          model: obj.model || 'unknown',
+          project: extractProject(obj.cwd, filePath),
+          timestamp: ts,
+          inputTokens: (usage.promptTokenCount || 0) - cached,
+          outputTokens: (usage.candidatesTokenCount || 0) - thoughts,
+          cachedInputTokens: cached,
+          reasoningOutputTokens: thoughts,
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}

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

@@ -0,0 +1,123 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { readJsonSafe, projectFromPath } from './fs-utils.js';
+
+const EXTENSION_ID = 'rooveterinaryinc.roo-cline';
+
+const HOSTS = ['Code', 'Cursor', 'Windsurf', 'VSCodium', 'Code - Insiders', 'Trae', 'Trae CN'];
+
+function getHostRoots() {
+  const out = [];
+  if (process.platform === 'darwin') {
+    const base = join(homedir(), 'Library', 'Application Support');
+    for (const h of HOSTS) out.push(join(base, h));
+  } else if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    for (const h of HOSTS) out.push(join(appData, h));
+  } else {
+    const xdg = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+    for (const h of HOSTS) out.push(join(xdg, h));
+  }
+  return out;
+}
+
+export function findRooCodeExtensionDirs() {
+  const dirs = [];
+  for (const root of getHostRoots()) {
+    const ext = join(root, 'User', 'globalStorage', EXTENSION_ID);
+    try {
+      if (statSync(ext).isDirectory()) dirs.push(ext);
+    } catch {
+      // not installed in this host; skip
+    }
+  }
+  return dirs;
+}
+
+// Read all HistoryItems from `_index.json` if present, else fall back to
+// scanning per-task `history_item.json` files (Roo migrated to per-task
+// files in 2025; the index is a cache).
+function readHistoryItems(extDir) {
+  const tasksDir = join(extDir, 'tasks');
+  const indexPath = join(tasksDir, '_index.json');
+  const index = readJsonSafe(indexPath);
+  if (index && Array.isArray(index.entries)) return index.entries;
+
+  const items = [];
+  let names;
+  try { names = readdirSync(tasksDir, { withFileTypes: true }); } catch { return items; }
+  for (const entry of names) {
+    if (!entry.isDirectory() || entry.name.startsWith('_') || entry.name.startsWith('.')) continue;
+    const item = readJsonSafe(join(tasksDir, entry.name, 'history_item.json'));
+    if (item && typeof item === 'object') items.push(item);
+  }
+  return items;
+}
+
+export async function parse() {
+  const extDirs = findRooCodeExtensionDirs();
+  if (extDirs.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const events = [];
+
+  for (const extDir of extDirs) {
+    const items = readHistoryItems(extDir);
+    if (!items.length) continue;
+
+    for (const item of items) {
+      try {
+        if (!item || typeof item !== 'object' || !item.id) continue;
+        const taskId = String(item.id);
+        const project = projectFromPath(item.workspace);
+        // Roo doesn't store modelId; the profile name (apiConfigName) is the
+        // best fallback — users typically name profiles after the model.
+        const fallbackModel = (item.apiConfigName && String(item.apiConfigName).trim()) || 'roo-unknown';
+
+        const messages = readJsonSafe(join(extDir, 'tasks', taskId, 'ui_messages.json'));
+        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;
+
+            const model = (info.model && String(info.model).trim()) || fallbackModel;
+
+            entries.push({
+              source: 'roo-code',
+              model,
+              project,
+              timestamp,
+              inputTokens: inputTokens + cacheWrites,
+              outputTokens,
+              cachedInputTokens: cacheReads,
+              reasoningOutputTokens: 0,
+            });
+            events.push({ sessionId: taskId, source: 'roo-code', project, timestamp, role: 'assistant' });
+          } else if (msg.type === 'ask' || (msg.type === 'say' && msg.say === 'user_feedback')) {
+            events.push({ sessionId: taskId, source: 'roo-code', 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/sqlite.js

@@ -0,0 +1,148 @@
+import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { copyFileSync, existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Run a SQL query against a SQLite database and return rows as plain objects
+ * (column name → value), mirroring the shape of `sqlite3 -json` output.
+ *
+ * Prefers Node's built-in `node:sqlite` (available on Node >= 22.5, no external
+ * binary needed — important on Windows where the `sqlite3` CLI is rarely on
+ * PATH). Falls back to shelling out to the `sqlite3` CLI on older Node.
+ *
+ * If neither is available, throws an Error whose message contains "ENOENT" so
+ * callers can surface an "Install sqlite3" hint, matching the previous behavior.
+ */
+export function queryDbJson(
+  dbPath,
+  sql,
+  { timeout = 30000, maxBuffer = 100 * 1024 * 1024, readOnly = true } = {},
+) {
+  const db = openNodeSqlite(dbPath, readOnly);
+  if (db) {
+    try {
+      return db.prepare(sql).all();
+    } finally {
+      db.close();
+    }
+  }
+  return queryViaCli(dbPath, sql, { timeout, maxBuffer });
+}
+
+let nodeSqlite; // undefined = not tried, null = unavailable
+
+function getNodeSqlite() {
+  if (nodeSqlite !== undefined) return nodeSqlite;
+  try {
+    // Suppress the one-time "SQLite is an experimental feature" ExperimentalWarning
+    // on Node versions where node:sqlite is still flagged experimental.
+    const prevEmit = process.emitWarning;
+    process.emitWarning = (warning, ...rest) => {
+      const opts = rest[0];
+      const type = typeof opts === 'object' && opts ? opts.type : opts;
+      const name = typeof warning === 'object' && warning ? warning.name : undefined;
+      if ((type === 'ExperimentalWarning' || name === 'ExperimentalWarning') && String(warning).includes('SQLite')) return;
+      return prevEmit.call(process, warning, ...rest);
+    };
+    try {
+      nodeSqlite = require('node:sqlite');
+    } finally {
+      process.emitWarning = prevEmit;
+    }
+  } catch {
+    nodeSqlite = null;
+  }
+  return nodeSqlite;
+}
+
+function openNodeSqlite(dbPath, readOnly = true) {
+  const mod = getNodeSqlite();
+  if (!mod || !mod.DatabaseSync) return null;
+  let db;
+  try {
+    db = new mod.DatabaseSync(dbPath, { readOnly });
+    // Writable access is used only for disposable snapshots whose WAL metadata
+    // may need initialization. Keep the SQL connection itself read-only.
+    if (!readOnly) db.exec('PRAGMA query_only = ON');
+    return db;
+  } catch {
+    try {
+      db?.close();
+    } catch {
+      // Ignore cleanup failure while falling back to the sqlite3 CLI.
+    }
+    return null;
+  }
+}
+
+function queryViaCli(dbPath, sql, { timeout, maxBuffer }) {
+  const out = execFileSync('sqlite3', ['-json', dbPath, sql], {
+    encoding: 'utf-8',
+    maxBuffer,
+    timeout,
+  });
+  const trimmed = out.trim();
+  if (!trimmed || trimmed === '[]') return [];
+  return JSON.parse(trimmed);
+}
+
+/** Standard "sqlite3 unavailable" hint, reused by every SQLite-backed parser. */
+export function sqliteUnavailableError(label) {
+  return new Error(`sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync ${label} data.`);
+}
+
+/** True when the error is the "no sqlite3" hint (node:sqlite absent + CLI absent). */
+export function isSqliteUnavailableError(err) {
+  return !!err && (
+    err.code === 'ENOENT'
+    || err.status === 127
+    || /ENOENT|sqlite3.*not found/i.test(err?.message || '')
+  );
+}
+
+export function isLockError(err) {
+  return !!err && typeof err.message === 'string' && /database is locked/i.test(err.message);
+}
+
+function querySnapshot(dbPath, sql, { tempPrefix, opts } = {}) {
+  const snapshotDir = mkdtempSync(join(tmpdir(), tempPrefix || 'vibe-usage-sqlite-'));
+  const queryPath = join(snapshotDir, basename(dbPath));
+  try {
+    copyFileSync(dbPath, queryPath);
+    for (const suffix of ['-shm', '-wal']) {
+      const companion = `${dbPath}${suffix}`;
+      if (existsSync(companion)) copyFileSync(companion, `${queryPath}${suffix}`);
+    }
+    return queryDbJson(queryPath, sql, { ...opts, readOnly: false });
+  } finally {
+    rmSync(snapshotDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Query a disposable writable snapshot. Some WAL-mode databases cannot be
+ * opened read-only until SQLite has initialized their shared-memory metadata;
+ * doing that only in the temp copy keeps the source application database
+ * untouched and works without a sqlite3 binary on Node >= 22.5.
+ */
+export function queryDbJsonSnapshot(dbPath, sql, options = {}) {
+  return querySnapshot(dbPath, sql, options);
+}
+
+/**
+ * Run a query, and if the source app holds a write lock on the database, copy
+ * the DB (plus its -wal/-shm companions) to a temp dir and re-query the
+ * snapshot. Shared by Cursor / Antigravity / Kiro.
+ */
+export function queryDbJsonSnapshotOnLock(dbPath, sql, { tempPrefix = 'vibe-usage-sqlite', opts } = {}) {
+  try {
+    return queryDbJson(dbPath, sql, opts);
+  } catch (err) {
+    if (!isLockError(err)) throw err;
+    return querySnapshot(dbPath, sql, { tempPrefix, opts });
+  }
+}