@geoqiao/pi-usage 0.1.0

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

@@ -0,0 +1,196 @@
+import { createHash } from 'node:crypto';
+
+// Shared bucket/session aggregation used by every parser. Lives in its own
+// module (not the parser registry in index.js) so parsers never have to import
+// the registry that imports them — that circular dependency only worked because
+// these functions are hoisted declarations. Keeping them here breaks the cycle.
+//
+// Data model: parsers emit flat per-message "entries" (token usage) and
+// per-message "events" (timing), and these two functions fold them into the
+// bucket/session shapes described in AGENTS.md.
+
+export function roundToHalfHour(date) {
+  const d = new Date(date);
+  d.setMinutes(d.getMinutes() < 30 ? 0 : 30, 0, 0);
+  return d;
+}
+
+// Server column limits (usage_buckets: model varchar(100), project varchar(200)).
+// Anything longer aborts the whole INSERT chunk with 22001, so clamp here.
+const MODEL_MAX_LENGTH = 100;
+const PROJECT_MAX_LENGTH = 200;
+
+// Server token columns are bigint — a single fractional/NaN value aborts the
+// whole INSERT chunk with 22P02, taking every other tool's rows in the batch
+// down with it.
+function toTokenCount(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return 0;
+  return Math.round(n);
+}
+
+export function aggregateToBuckets(entries) {
+  const map = new Map();
+
+  for (const e of entries) {
+    const model = String(e.model || 'unknown').slice(0, MODEL_MAX_LENGTH);
+    const project = String(e.project || 'unknown').slice(0, PROJECT_MAX_LENGTH);
+    const bucketStart = roundToHalfHour(e.timestamp).toISOString();
+    const requestType = e.requestType || 'other';
+    const key = JSON.stringify([e.source, model, project, e.hostname || '', bucketStart, requestType]);
+
+    if (!map.has(key)) {
+      map.set(key, {
+        source: e.source,
+        ...(requestType !== 'other' ? { requestType } : {}),
+        model,
+        project,
+        // Cloud-sourced parsers (cursor) pre-set a fixed hostname sentinel; it
+        // must survive aggregation, or sync.js stamps the machine hostname and
+        // every machine gets its own duplicate row server-side.
+        ...(e.hostname ? { hostname: e.hostname } : {}),
+        bucketStart,
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedInputTokens: 0,
+        reasoningOutputTokens: 0,
+      });
+    }
+
+    const b = map.get(key);
+    b.inputTokens += e.inputTokens || 0;
+    b.outputTokens += e.outputTokens || 0;
+    b.cachedInputTokens += e.cachedInputTokens || 0;
+    b.reasoningOutputTokens += e.reasoningOutputTokens || 0;
+  }
+
+  // Clamp after summation, not per entry — rounding each entry first would
+  // discard sub-integer values instead of letting them accumulate.
+  return Array.from(map.values()).map((b) => {
+    const inputTokens = toTokenCount(b.inputTokens);
+    const outputTokens = toTokenCount(b.outputTokens);
+    const cachedInputTokens = toTokenCount(b.cachedInputTokens);
+    const reasoningOutputTokens = toTokenCount(b.reasoningOutputTokens);
+    return {
+      ...b,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens,
+      totalTokens: inputTokens + outputTokens + reasoningOutputTokens,
+    };
+  });
+}
+
+/**
+ * Incremental session aggregation for parsers whose event stream is already
+ * chronological. `extractSessions()` below keeps the sorting fallback for
+ * parsers that emit mixed or out-of-order sessions.
+ */
+export function createSessionAccumulator() {
+  return {
+    ordered: true,
+    first: null,
+    last: null,
+    lastTimestampMs: null,
+    activeSeconds: 0,
+    turnStartMs: null,
+    turnEndMs: null,
+    waitingForFirstResponse: false,
+    messageCount: 0,
+    userMessageCount: 0,
+    userPromptHours: new Array(24).fill(0),
+  };
+}
+
+function commitTurn(accumulator) {
+  const { turnStartMs, turnEndMs } = accumulator;
+  if (turnStartMs !== null && turnEndMs !== null && turnEndMs > turnStartMs) {
+    accumulator.activeSeconds += Math.round((turnEndMs - turnStartMs) / 1000);
+  }
+}
+
+export function accumulateSessionEvent(accumulator, event) {
+  const timestampMs = event.timestamp.getTime();
+  if (accumulator.lastTimestampMs !== null && timestampMs < accumulator.lastTimestampMs) {
+    accumulator.ordered = false;
+  }
+  if (accumulator.first === null) accumulator.first = event;
+  accumulator.last = event;
+  accumulator.lastTimestampMs = timestampMs;
+  accumulator.messageCount++;
+
+  if (event.role === 'user') {
+    commitTurn(accumulator);
+    accumulator.turnStartMs = null;
+    accumulator.turnEndMs = null;
+    accumulator.waitingForFirstResponse = true;
+    accumulator.userMessageCount++;
+    accumulator.userPromptHours[event.timestamp.getUTCHours()]++;
+  } else if (accumulator.waitingForFirstResponse) {
+    accumulator.turnStartMs = timestampMs;
+    accumulator.turnEndMs = timestampMs;
+    accumulator.waitingForFirstResponse = false;
+  } else if (accumulator.turnStartMs !== null) {
+    accumulator.turnEndMs = timestampMs;
+  }
+}
+
+export function sessionAccumulatorIsOrdered(accumulator) {
+  return accumulator.ordered;
+}
+
+export function finalizeSessionAccumulator(accumulator, sessionId, projectOverride) {
+  if (accumulator.first === null || accumulator.last === null) return null;
+  if (!accumulator.ordered) {
+    throw new TypeError('Session accumulator received out-of-order events');
+  }
+
+  let activeSeconds = accumulator.activeSeconds;
+  const { turnStartMs, turnEndMs } = accumulator;
+  if (turnStartMs !== null && turnEndMs !== null && turnEndMs > turnStartMs) {
+    activeSeconds += Math.round((turnEndMs - turnStartMs) / 1000);
+  }
+
+  const first = accumulator.first;
+  const last = accumulator.last;
+  const sessionHash = createHash('sha256').update(sessionId).digest('hex').slice(0, 16);
+  return {
+    source: first.source,
+    project: projectOverride || first.project || 'unknown',
+    sessionHash,
+    firstMessageAt: first.timestamp.toISOString(),
+    lastMessageAt: last.timestamp.toISOString(),
+    durationSeconds: Math.round((last.timestamp - first.timestamp) / 1000),
+    activeSeconds,
+    messageCount: accumulator.messageCount,
+    userMessageCount: accumulator.userMessageCount,
+    userPromptHours: accumulator.userPromptHours,
+  };
+}
+
+/**
+ * Extract session metadata from timing events.
+ * Each event: { sessionId, source, project, timestamp: Date, role: 'user'|'assistant' }
+ *
+ * Turn = first AI response → last AI response before next user prompt.
+ * activeSeconds = sum(generation durations), excluding queue/TTFT wait.
+ * durationSeconds = wall clock from first to last message.
+ */
+export function extractSessions(events) {
+  const groups = new Map();
+  for (const event of events) {
+    if (!groups.has(event.sessionId)) groups.set(event.sessionId, []);
+    groups.get(event.sessionId).push(event);
+  }
+
+  const sessions = [];
+  for (const [sessionId, sessionEvents] of groups) {
+    sessionEvents.sort((a, b) => a.timestamp - b.timestamp);
+    const accumulator = createSessionAccumulator();
+    for (const event of sessionEvents) accumulateSessionEvent(accumulator, event);
+    const session = finalizeSessionAccumulator(accumulator, sessionId);
+    if (session) sessions.push(session);
+  }
+  return sessions;
+}

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

@@ -0,0 +1,94 @@
+import { existsSync } from 'node:fs';
+import { basename } from 'node:path';
+import { getAlmaDbPath } from '../tools.js';
+import { aggregateToBuckets } from './aggregate.js';
+import { toCount } from './fs-utils.js';
+import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
+
+export { getAlmaDbPath as resolveAlmaDbPath };
+
+export function normalizeAlmaModel(value) {
+  if (typeof value !== 'string') return 'unknown';
+  const model = value.trim();
+  if (!model) return 'unknown';
+  const separator = model.lastIndexOf(':');
+  if (separator === -1) return model;
+  return model.slice(separator + 1).trim() || 'unknown';
+}
+
+const ALMA_USAGE_SQL = `
+  SELECT
+    usage_records.model AS model,
+    usage_records.timestamp AS timestamp,
+    usage_records.input_tokens AS inputTokens,
+    usage_records.output_tokens AS outputTokens,
+    usage_records.cached_input_tokens AS cachedInputTokens,
+    usage_records.reasoning_tokens AS reasoningOutputTokens,
+    usage_records.cache_write_input_tokens AS cacheWriteInputTokens,
+    workspaces.name AS workspaceName
+  FROM usage_records
+  LEFT JOIN chat_threads ON chat_threads.id = usage_records.thread_id
+  LEFT JOIN workspaces ON workspaces.id = chat_threads.workspace_id
+`;
+
+function safeWorkspaceName(value) {
+  if (typeof value !== 'string') return 'unknown';
+  const normalized = value.trim().replace(/\\/g, '/').replace(/\/+$/, '');
+  return basename(normalized) || 'unknown';
+}
+
+function skippedResult(error) {
+  const message = error?.message || String(error);
+  let reason = message;
+  if (/database is locked/i.test(message)) reason = 'database is locked';
+  else if (/no such (table|column)/i.test(message)) reason = 'incompatible database schema';
+  return {
+    buckets: [],
+    sessions: [],
+    skipped: true,
+    warnings: [`alma: cannot read usage database (${reason})`],
+  };
+}
+
+export async function parse() {
+  const dbPath = getAlmaDbPath();
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
+
+  let rows;
+  try {
+    rows = queryDbJson(dbPath, ALMA_USAGE_SQL);
+  } catch (error) {
+    if (isSqliteUnavailableError(error)) throw sqliteUnavailableError('Alma');
+    return skippedResult(error);
+  }
+
+  const entries = [];
+  for (const row of rows) {
+    const timestamp = new Date(row.timestamp);
+    if (Number.isNaN(timestamp.getTime())) continue;
+
+    const inputTokens = toCount(row.inputTokens) + toCount(row.cacheWriteInputTokens);
+    const outputTokens = toCount(row.outputTokens);
+    const cachedInputTokens = toCount(row.cachedInputTokens);
+    const reasoningOutputTokens = toCount(row.reasoningOutputTokens);
+    if (inputTokens + outputTokens + cachedInputTokens + reasoningOutputTokens === 0) continue;
+
+    entries.push({
+      source: 'alma',
+      model: normalizeAlmaModel(row.model),
+      project: safeWorkspaceName(row.workspaceName),
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens,
+    });
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    // Alma's usage ledger contains assistant responses only. Reconstructing
+    // user turns would require reading chat records outside the usage contract.
+    sessions: [],
+  };
+}

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

@@ -0,0 +1,156 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+
+function resolveThreadsDir() {
+  if (process.env.AMP_DATA_DIR) return process.env.AMP_DATA_DIR;
+  if (process.env.XDG_DATA_HOME) return join(process.env.XDG_DATA_HOME, 'amp', 'threads');
+  return join(homedir(), '.local', 'share', 'amp', 'threads');
+}
+
+function findThreadFiles(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()) {
+        for (const nested of findThreadFiles(fullPath)) results.push(nested);
+      } else if (entry.isFile() && entry.name.startsWith('T-') && entry.name.endsWith('.json')) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+
+  return results;
+}
+
+function setMessageTimestamp(map, messageId, timestamp) {
+  if (!Number.isInteger(messageId)) return;
+  const current = map.get(messageId);
+  if (!current || timestamp < current) {
+    map.set(messageId, timestamp);
+  }
+}
+
+function buildMessageTimestampMap(events) {
+  const map = new Map();
+  if (!Array.isArray(events)) return map;
+
+  for (const event of events) {
+    const ts = new Date(event?.timestamp);
+    if (isNaN(ts.getTime())) continue;
+
+    setMessageTimestamp(map, event.fromMessageId, ts);
+    setMessageTimestamp(map, event.toMessageId, ts);
+  }
+
+  return map;
+}
+
+export async function parse() {
+  const threadsDir = resolveThreadsDir();
+  const threadFiles = findThreadFiles(threadsDir);
+  if (threadFiles.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const sessionEvents = [];
+
+  for (const filePath of threadFiles) {
+    let thread;
+    try {
+      thread = JSON.parse(readFileSync(filePath, 'utf-8'));
+    } catch {
+      continue;
+    }
+
+    const sessionId = thread?.id || filePath;
+    const messages = Array.isArray(thread?.messages) ? thread.messages : [];
+    const ledgerEvents = Array.isArray(thread?.usageLedger?.events) ? thread.usageLedger.events : [];
+    const hasLedger = ledgerEvents.length > 0;
+
+    if (hasLedger) {
+      for (const event of ledgerEvents) {
+        const ts = new Date(event?.timestamp);
+        if (isNaN(ts.getTime())) continue;
+
+        const inputTokens = event?.tokens?.input || 0;
+        const outputTokens = event?.tokens?.output || 0;
+
+        const toMessage = Number.isInteger(event.toMessageId) ? messages[event.toMessageId] : null;
+        const cacheReadInputTokens = toMessage?.usage?.cacheReadInputTokens || 0;
+        const cacheCreationInputTokens = toMessage?.usage?.cacheCreationInputTokens || 0;
+        if (
+          inputTokens === 0
+          && outputTokens === 0
+          && cacheReadInputTokens === 0
+          && cacheCreationInputTokens === 0
+        ) continue;
+
+        entries.push({
+          source: 'amp',
+          model: event?.model || 'unknown',
+          project: 'unknown',
+          timestamp: ts,
+          inputTokens: inputTokens + cacheCreationInputTokens,
+          outputTokens,
+          cachedInputTokens: cacheReadInputTokens,
+          reasoningOutputTokens: 0,
+        });
+      }
+    } else {
+      for (const message of messages) {
+        const usage = message?.usage;
+        if (!usage) continue;
+
+        const ts = new Date(message?.timestamp || thread?.created);
+        if (isNaN(ts.getTime())) continue;
+
+        const inputTokens = usage.inputTokens || 0;
+        const outputTokens = usage.outputTokens || 0;
+        const cacheCreationInputTokens = usage.cacheCreationInputTokens || 0;
+        if (
+          inputTokens === 0
+          && outputTokens === 0
+          && (usage.cacheReadInputTokens || 0) === 0
+          && cacheCreationInputTokens === 0
+        ) continue;
+
+        entries.push({
+          source: 'amp',
+          model: usage.model || 'unknown',
+          project: 'unknown',
+          timestamp: ts,
+          inputTokens: inputTokens + cacheCreationInputTokens,
+          outputTokens,
+          cachedInputTokens: usage.cacheReadInputTokens || 0,
+          reasoningOutputTokens: 0,
+        });
+      }
+    }
+
+    const messageTsMap = buildMessageTimestampMap(ledgerEvents);
+    const baseTimestamp = new Date(thread?.created);
+    const hasBaseTimestamp = !isNaN(baseTimestamp.getTime());
+
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i];
+      const mappedTs = messageTsMap.get(i);
+      const ts = mappedTs || (hasBaseTimestamp ? baseTimestamp : null);
+      if (!ts || isNaN(ts.getTime())) continue;
+
+      sessionEvents.push({
+        sessionId,
+        source: 'amp',
+        project: 'unknown',
+        timestamp: ts,
+        role: message?.role === 'user' ? 'user' : 'assistant',
+      });
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}