@geoqiao/pi-usage 0.1.0

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

@@ -0,0 +1,182 @@
+import { existsSync } from 'node:fs';
+import { projectFromPath } from './fs-utils.js';
+import { aggregateToBuckets } from './aggregate.js';
+import {
+  queryDbJsonSnapshotOnLock,
+  isSqliteUnavailableError,
+  sqliteUnavailableError,
+} from './sqlite.js';
+import { getMcodeDbPath } from '../tools.js';
+
+const SOURCE = 'mcode';
+
+// Strict column allow-list. The mcode token table also stores a `raw` JSON
+// payload (and the sessions table stores `record_json` / `extra_data_json`)
+// that contains message bodies — we never select those, neither in this
+// parser nor in any test fixture.
+const TOKEN_COLUMNS = [
+  'session_id',
+  'model',
+  'ts',
+  'input_tokens',
+  'output_tokens',
+  'reasoning_tokens',
+  'cache_read_tokens',
+  'cache_write_tokens',
+];
+
+// `local_runtime_sessions` carries both `workspace_dir` (per-session scratch
+// dir, always present) and `project_workspace_dir` (the project root when one
+// is known). We pick the project column first, then the workspace, then
+// fall back to "unknown". Never read `record_json` / `extra_data_json`.
+const SESSION_COLUMNS = ['session_id', 'workspace_dir', 'project_workspace_dir'];
+
+// Keep token rows and their project metadata in one SQLite statement. Separate
+// reads can observe different WAL snapshots while mcode is writing, causing a
+// token row to be uploaded once as "unknown" and again under its real project.
+const USAGE_SQL = `
+  SELECT
+    ${TOKEN_COLUMNS.map(column => `token.${column}`).join(', ')},
+    session.workspace_dir,
+    session.project_workspace_dir
+  FROM local_runtime_token_usage AS token
+  LEFT JOIN local_runtime_sessions AS session
+    ON session.session_id = token.session_id
+`;
+
+/**
+ * Resolve the mcode runtime-state SQLite database. Mirrors the precedence used
+ * by sibling tools (MiMoCode, DimAgent): explicit env var wins, then a
+ * tool-specific HOME, then the default layout.
+ *
+ * Defaults to `<homedir()>/.minimax/v2/sqlite/runtime-state.sqlite`, which is
+ * where the mcode CLI keeps its WAL database on macOS / Linux.
+ */
+export function resolveMcodeDbPath(env = process.env) {
+  return getMcodeDbPath(env);
+}
+
+/**
+ * Token count (ms vs seconds). The mcode runtime writes ts as integer
+ * milliseconds — confirmed against the live schema (`typeof(ts)=integer`,
+ * values ≈ 1.787e12 for 2026-08-29). Stay defensive: anything < 1e12 is
+ * treated as seconds and scaled up.
+ */
+function tsToDate(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return null;
+  const ms = n < 1e12 ? n * 1000 : n;
+  const d = new Date(ms);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+
+
+function toNonNegative(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return n;
+}
+
+function dbHasColumns(dbPath, table, columns) {
+  const info = queryDbJsonSnapshotOnLock(
+    dbPath,
+    `PRAGMA table_info(${table})`,
+    { tempPrefix: 'vibe-usage-mcode' },
+  );
+  const present = new Set(info.map(row => String(row.name)));
+  return columns.every(col => present.has(col));
+}
+
+export async function parse() {
+  const dbPath = resolveMcodeDbPath();
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
+
+  // Schema guard: every allow-listed column must exist. If the mcode
+  // runtime ever renames / drops a column, fail soft (skipped) so the
+  // incremental sync keeps the last good upload state for this source.
+  let schemaOk;
+  try {
+    schemaOk =
+      dbHasColumns(dbPath, 'local_runtime_token_usage', TOKEN_COLUMNS) &&
+      dbHasColumns(dbPath, 'local_runtime_sessions', SESSION_COLUMNS);
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
+    return { buckets: [], sessions: [], skipped: true };
+  }
+  if (!schemaOk) {
+    return { buckets: [], sessions: [], skipped: true };
+  }
+
+  // Read tokens and session project metadata from one statement/snapshot.
+  let usageRows;
+  try {
+    usageRows = queryDbJsonSnapshotOnLock(dbPath, USAGE_SQL, {
+      tempPrefix: 'vibe-usage-mcode',
+    });
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
+    return { buckets: [], sessions: [], skipped: true };
+  }
+
+  const entries = [];
+
+  for (const row of usageRows) {
+    const sessionId = row.session_id != null ? String(row.session_id) : '';
+    if (!sessionId) continue;
+    const ts = tsToDate(row.ts);
+    if (!ts) continue;
+
+    // MCode stores output and reasoning as separate counters. Its own
+    // summary code computes total = input + output + reasoning, so do not
+    // subtract reasoning from output here.
+    const inputRaw = toNonNegative(row.input_tokens);
+    const cacheWrite = toNonNegative(row.cache_write_tokens);
+    const outputRaw = toNonNegative(row.output_tokens);
+    const reasoningRaw = toNonNegative(row.reasoning_tokens);
+    const cacheRead = toNonNegative(row.cache_read_tokens);
+
+    const inputTokens = inputRaw + cacheWrite;
+    const reasoningOutputTokens = reasoningRaw;
+    const outputTokens = outputRaw;
+    const cachedInputTokens = cacheRead;
+
+    if (
+      inputTokens +
+        outputTokens +
+        cachedInputTokens +
+        reasoningOutputTokens ===
+      0
+    ) {
+      continue;
+    }
+
+    const projectPath = row.project_workspace_dir || row.workspace_dir;
+    const project = projectPath ? projectFromPath(String(projectPath)) : 'unknown';
+    const model = row.model != null && String(row.model).trim()
+      ? String(row.model).trim()
+      : 'unknown';
+
+    entries.push({
+      source: SOURCE,
+      model,
+      project,
+      timestamp: ts,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens,
+    });
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    // The token ledger contains assistant usage rows only. Reconstructing
+    // user prompts would require reading message payloads, which this parser
+    // deliberately never selects, so mcode emits buckets only like Alma.
+    sessions: [],
+  };
+}
+
+// Re-export for tests / external consumers.
+export { SOURCE as MCODE_SOURCE };

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

@@ -0,0 +1,88 @@
+import { existsSync } from 'node:fs';
+import { basename } from 'node:path';
+import { getMimocodeDbPath } from '../tools.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
+
+export { getMimocodeDbPath as resolveMimocodeDbPath };
+
+export async function parse() {
+  const dbPath = getMimocodeDbPath();
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
+
+  let rows;
+  try {
+    const hasExternalImports = queryDbJson(dbPath, `
+      SELECT 1
+      FROM sqlite_master
+      WHERE type = 'table' AND name = 'external_import'
+      LIMIT 1
+    `).length > 0;
+    const externalImportJoin = hasExternalImports
+      ? 'LEFT JOIN external_import ON external_import.session_id = message.session_id'
+      : '';
+    const externalImportFilter = hasExternalImports
+      ? 'WHERE external_import.session_id IS NULL'
+      : '';
+    rows = queryDbJson(dbPath, `
+      SELECT
+        message.session_id AS sessionID,
+        message.time_created AS created,
+        message.data AS data,
+        session.directory AS directory
+      FROM message
+      JOIN session ON session.id = message.session_id
+      ${externalImportJoin}
+      ${externalImportFilter}
+    `);
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('MiMoCode');
+    throw err;
+  }
+
+  const entries = [];
+  const events = [];
+  for (const row of rows) {
+    let data;
+    try {
+      data = typeof row.data === 'string' ? JSON.parse(row.data) : row.data;
+    } catch {
+      continue;
+    }
+    if (data?.role !== 'user' && data?.role !== 'assistant') continue;
+
+    const timestamp = new Date(data.time?.created ?? row.created);
+    if (Number.isNaN(timestamp.getTime())) continue;
+    const project = row.directory ? basename(row.directory) : 'unknown';
+    events.push({
+      sessionId: row.sessionID || 'unknown',
+      source: 'mimocode',
+      project,
+      timestamp,
+      role: data.role,
+    });
+
+    const tokens = data.tokens;
+    if (data.role !== 'assistant' || !data.modelID || !tokens) continue;
+    const inputTokens = (Number(tokens.input) || 0) + (Number(tokens.cache?.write) || 0);
+    const outputTokens = Number(tokens.output) || 0;
+    const reasoningOutputTokens = Number(tokens.reasoning) || 0;
+    const cachedInputTokens = Number(tokens.cache?.read) || 0;
+    if (inputTokens + outputTokens + reasoningOutputTokens + cachedInputTokens <= 0) continue;
+    entries.push({
+      source: 'mimocode',
+      model: data.modelID,
+      project,
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens,
+    });
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(events),
+  };
+}

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

@@ -0,0 +1,10 @@
+import { getOmpSessionDirs } from '../pi-roots.js';
+import { parsePiSessionJsonl } from './pi-session-jsonl.js';
+
+/** Parse Oh My Pi's Pi-compatible JSONL sessions, including profiles/XDG. */
+export async function parse() {
+  return parsePiSessionJsonl({
+    source: 'omp',
+    sessionsDirs: getOmpSessionDirs(),
+  });
+}

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

@@ -0,0 +1,142 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+
+// OpenClaw stores data at ~/.openclaw/agents/<agentId>/sessions/*.jsonl
+// Profile deployments use ~/.openclaw-<profile>/agents/...
+// Legacy paths: ~/.clawdbot, ~/.moltbot, ~/.moldbot
+function getPossibleRoots() {
+  const override = process.env.VIBE_USAGE_OPENCLAW_DIRS?.trim();
+  if (override) return override.split(process.platform === 'win32' ? ';' : ':').filter(Boolean);
+  const home = homedir();
+  const roots = [
+    join(home, '.clawdbot'),
+    join(home, '.moltbot'),
+    join(home, '.moldbot'),
+  ];
+  try {
+    for (const entry of readdirSync(home, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === '.openclaw' || /^\.openclaw-.+/.test(entry.name)) {
+        roots.push(join(home, entry.name));
+      }
+    }
+  } catch {
+    // ignore read errors
+  }
+  return roots;
+}
+
+/** Normalize usage fields — OpenClaw supports multiple naming conventions */
+function getTokens(usage, ...keys) {
+  for (const key of keys) {
+    const value = Number(usage[key]);
+    if (Number.isFinite(value) && value > 0) return value;
+  }
+  return 0;
+}
+
+export async function parse() {
+  const entries = [];
+  const sessionEvents = [];
+
+  for (const root of getPossibleRoots()) {
+    const agentsDir = join(root, 'agents');
+    if (!existsSync(agentsDir)) continue;
+
+    let agentDirs;
+    try {
+      agentDirs = readdirSync(agentsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory());
+    } catch {
+      continue;
+    }
+
+    for (const agentDir of agentDirs) {
+      const project = agentDir.name;
+      const sessionsDir = join(agentsDir, agentDir.name, 'sessions');
+      if (!existsSync(sessionsDir)) continue;
+
+      let files;
+      try {
+        files = readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl'));
+      } catch {
+        continue;
+      }
+
+      for (const file of files) {
+        const filePath = join(sessionsDir, file);
+
+        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);
+
+            if (obj.type !== 'message') continue;
+            const msg = obj.message;
+            if (!msg) continue;
+
+            const timestamp = obj.timestamp || msg.timestamp;
+            if (!timestamp) continue;
+            const ts = new Date(typeof timestamp === 'number' ? timestamp : timestamp);
+            if (isNaN(ts.getTime())) continue;
+
+            sessionEvents.push({
+              sessionId: filePath,
+              source: 'openclaw',
+              project,
+              timestamp: ts,
+              role: msg.role === 'user' ? 'user' : 'assistant',
+            });
+
+            if (msg.role !== 'assistant') continue;
+            const usage = msg.usage;
+            if (!usage) continue;
+
+            const inputTokens = getTokens(
+              usage,
+              'input',
+              'inputTokens',
+              'input_tokens',
+              'promptTokens',
+              'prompt_tokens',
+            );
+            const cacheWriteTokens = getTokens(
+              usage,
+              'cacheCreation',
+              'cacheCreationInputTokens',
+              'cacheWrite',
+              'cache_creation',
+              'cache_write',
+              'cache_creation_input_tokens',
+              'cache_write_input_tokens',
+            );
+
+            entries.push({
+              source: 'openclaw',
+              model: msg.model || obj.model || 'unknown',
+              project,
+              timestamp: ts,
+              inputTokens: inputTokens + cacheWriteTokens,
+              outputTokens: getTokens(usage, 'output', 'outputTokens', 'output_tokens', 'completionTokens', 'completion_tokens'),
+              cachedInputTokens: getTokens(usage, 'cacheRead', 'cache_read', 'cache_read_input_tokens'),
+              reasoningOutputTokens: 0,
+            });
+          } catch {
+            continue;
+          }
+        }
+      }
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}

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

@@ -0,0 +1,151 @@
+import { readdirSync, readFileSync, 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';
+
+const DATA_DIR = join(homedir(), '.local', 'share', 'opencode');
+const DB_PATH = join(DATA_DIR, 'opencode.db');
+const MESSAGES_DIR = join(DATA_DIR, 'storage', 'message');
+
+/**
+ * Parse opencode usage data.
+ * Tries SQLite database first (opencode >= v0.2), falls back to legacy JSON files.
+ */
+export async function parse() {
+  if (existsSync(DB_PATH)) {
+    try {
+      return parseFromSqlite();
+    } catch (err) {
+      process.stderr.write(`warn: opencode sqlite parse failed (${err.message}), trying legacy json...\n`);
+    }
+  }
+  return parseFromJson();
+}
+
+function parseFromSqlite() {
+  const query = `SELECT
+    session_id as sessionID,
+    json_extract(data, '$.role') as role,
+    json_extract(data, '$.time.created') as created,
+    json_extract(data, '$.modelID') as modelID,
+    json_extract(data, '$.tokens') as tokens,
+    json_extract(data, '$.path.root') as rootPath
+    FROM message`;
+
+  let rows;
+  try {
+    rows = queryDbJson(DB_PATH, query);
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('OpenCode');
+    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 = row.rootPath ? basename(row.rootPath) : 'unknown';
+    const sessionId = row.sessionID || 'unknown';
+
+    sessionEvents.push({
+      sessionId,
+      source: 'opencode',
+      project,
+      timestamp,
+      role: row.role === 'user' ? 'user' : 'assistant',
+    });
+
+    if (!row.modelID) continue;
+    let tokens;
+    try {
+      tokens = typeof row.tokens === 'string' ? JSON.parse(row.tokens) : row.tokens;
+    } catch {
+      continue;
+    }
+    if (!tokens || (!tokens.input && !tokens.output)) continue;
+
+    entries.push({
+      source: 'opencode',
+      model: row.modelID || 'unknown',
+      project,
+      timestamp,
+      inputTokens: tokens.input || 0,
+      outputTokens: tokens.output || 0,
+      cachedInputTokens: tokens.cache?.read || 0,
+      reasoningOutputTokens: tokens.reasoning || 0,
+    });
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}
+
+function parseFromJson() {
+  if (!existsSync(MESSAGES_DIR)) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const sessionEvents = [];
+  let sessionDirs;
+  try {
+    sessionDirs = readdirSync(MESSAGES_DIR, { withFileTypes: true })
+      .filter(d => d.isDirectory() && d.name.startsWith('ses_'));
+  } catch {
+    return { buckets: [], sessions: [] };
+  }
+
+  for (const sessionDir of sessionDirs) {
+    const sessionPath = join(MESSAGES_DIR, sessionDir.name);
+    let msgFiles;
+    try {
+      msgFiles = readdirSync(sessionPath).filter(f => f.endsWith('.json'));
+    } catch {
+      continue;
+    }
+
+    for (const file of msgFiles) {
+      const filePath = join(sessionPath, file);
+
+      let data;
+      try {
+        data = JSON.parse(readFileSync(filePath, 'utf-8'));
+      } catch {
+        continue;
+      }
+
+      const timestamp = new Date(data.time?.created);
+      if (isNaN(timestamp.getTime())) continue;
+
+      const rootPath = data.path?.root;
+      const project = rootPath ? basename(rootPath) : 'unknown';
+
+      sessionEvents.push({
+        sessionId: sessionDir.name,
+        source: 'opencode',
+        project,
+        timestamp,
+        role: data.role === 'user' ? 'user' : 'assistant',
+      });
+
+      if (!data.modelID) continue;
+      const tokens = data.tokens;
+      if (!tokens) continue;
+      if (!tokens.input && !tokens.output) continue;
+
+      entries.push({
+        source: 'opencode',
+        model: data.modelID || 'unknown',
+        project,
+        timestamp,
+        inputTokens: tokens.input || 0,
+        outputTokens: tokens.output || 0,
+        cachedInputTokens: tokens.cache?.read || 0,
+        reasoningOutputTokens: tokens.reasoning || 0,
+      });
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}

package/vendor/vibe-usage/src/parsers/pi-coding-agent.js

@@ -0,0 +1,27 @@
+import { normalizeExtraRoot, piSessionsDir } from '../extra-roots.js';
+import { getPiSessionDirs } from '../pi-roots.js';
+import { mergeCindyHarnessUsage, readCindyHarnessUsage } from './cindy-ledger.js';
+import { parsePiSessionJsonl } from './pi-session-jsonl.js';
+
+/** Parse the official Pi agent's Pi-compatible JSONL sessions. */
+export async function parse({ extraRoots = [] } = {}) {
+  for (const root of extraRoots) {
+    // piSessionsDir re-resolves the root's shape, so an agent home that lost
+    // its `sessions/` child is caught here too, not just a root that vanished.
+    if (piSessionsDir(root) !== null) continue;
+    // An explicitly configured root that is momentarily unreadable is not
+    // proof that its usage disappeared, so skip instead of reporting empty.
+    return {
+      buckets: [],
+      sessions: [],
+      skipped: true,
+      warnings: [`pi-coding-agent: 额外根目录不可用，已跳过本次 Pi 同步: ${normalizeExtraRoot(root)}`],
+    };
+  }
+
+  const nativeResult = await parsePiSessionJsonl({
+    source: 'pi-coding-agent',
+    sessionsDirs: getPiSessionDirs(extraRoots),
+  });
+  return mergeCindyHarnessUsage(nativeResult, readCindyHarnessUsage('pi'));
+}