@vibe-cafe/vibe-usage 0.6.8 → 0.7.1

package/README.md

@@ -19,7 +19,12 @@ This will:
 npx @vibe-cafe/vibe-usage              # Init (first run) or sync (subsequent runs)
 npx @vibe-cafe/vibe-usage init         # Re-run setup
 npx @vibe-cafe/vibe-usage sync         # Manual sync
-npx @vibe-cafe/vibe-usage daemon       # Continuous sync (every 5 minutes)
+npx @vibe-cafe/vibe-usage daemon       # Continuous sync (every 5m, foreground)
+npx @vibe-cafe/vibe-usage daemon install    # Install background service (systemd/launchd)
+npx @vibe-cafe/vibe-usage daemon uninstall  # Remove background service
+npx @vibe-cafe/vibe-usage daemon status     # Show background service status
+npx @vibe-cafe/vibe-usage daemon stop       # Stop background service
+npx @vibe-cafe/vibe-usage daemon restart    # Restart background service
 npx @vibe-cafe/vibe-usage reset        # Delete all data and re-upload from local logs
 npx @vibe-cafe/vibe-usage reset --local  # Delete this host's data only and re-upload
 npx @vibe-cafe/vibe-usage skill         # Install skill for AI coding assistants
@@ -89,13 +94,34 @@ Config stored at `~/.vibe-usage/config.json` (dev: `config.dev.json`). Contains
 
 ## Daemon Mode
 
+### Background service (recommended)
+
+Install as a system service for automatic background syncing:
+
+```bash
+npx @vibe-cafe/vibe-usage daemon install
+```
+
+This creates a user-level service (systemd on Linux, launchd on macOS) that syncs every 5 minutes and starts automatically on login. Manage with:
+
+```bash
+npx @vibe-cafe/vibe-usage daemon status
+npx @vibe-cafe/vibe-usage daemon stop
+npx @vibe-cafe/vibe-usage daemon restart
+npx @vibe-cafe/vibe-usage daemon uninstall
+```
+
+For reliable operation, install globally first: `npm install -g @vibe-cafe/vibe-usage`
+
+### Foreground mode
+
 Run continuous syncing in the foreground (every 5 minutes):
 
 ```bash
 npx @vibe-cafe/vibe-usage daemon
 ```
 
-Press Ctrl+C to stop. For background use: `nohup npx @vibe-cafe/vibe-usage daemon &`
+Press Ctrl+C to stop.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.6.8",
+  "version": "0.7.1",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "bin": {

package/src/daemon-service.js

@@ -0,0 +1,272 @@
+import { execFileSync } from 'node:child_process';
+import { writeFileSync, unlinkSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, platform } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const SERVICE_NAME = 'vibe-usage';
+const LAUNCHD_LABEL = 'ai.vibecafe.vibe-usage';
+
+function detectPlatform() {
+  const os = platform();
+  if (os === 'linux') {
+    if (existsSync('/run/systemd/system')) return 'systemd';
+    return null;
+  }
+  if (os === 'darwin') {
+    return 'launchd';
+  }
+  return null;
+}
+
+function resolvePaths() {
+  const nodePath = process.execPath;
+  const thisFile = fileURLToPath(import.meta.url);
+  const binPath = join(thisFile, '..', '..', 'bin', 'vibe-usage.js');
+
+  // npx cache paths are unstable — service will break when cache is cleared
+  const isNpxCache = binPath.includes('.npm/_npx');
+
+  return { nodePath, binPath, isNpxCache };
+}
+
+function getServicePaths(plat) {
+  if (plat === 'systemd') {
+    const dir = join(homedir(), '.config', 'systemd', 'user');
+    return { dir, file: join(dir, `${SERVICE_NAME}.service`) };
+  }
+  if (plat === 'launchd') {
+    const dir = join(homedir(), 'Library', 'LaunchAgents');
+    return { dir, file: join(dir, `${LAUNCHD_LABEL}.plist`) };
+  }
+  return null;
+}
+
+function generateSystemdUnit(nodePath, binPath) {
+  return `[Unit]
+Description=VibeCafe Usage Tracker
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${binPath} daemon
+Restart=on-failure
+RestartSec=10
+Environment=NODE_ENV=production
+WorkingDirectory=${homedir()}
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function generateLaunchdPlist(nodePath, binPath) {
+  const logDir = join(homedir(), '.vibe-usage');
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${LAUNCHD_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${binPath}</string>
+        <string>daemon</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>WorkingDirectory</key>
+    <string>${homedir()}</string>
+    <key>StandardOutPath</key>
+    <string>${join(logDir, 'daemon.log')}</string>
+    <key>StandardErrorPath</key>
+    <string>${join(logDir, 'daemon.err')}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>NODE_ENV</key>
+        <string>production</string>
+    </dict>
+</dict>
+</plist>
+`;
+}
+
+function run(cmd, args) {
+  try {
+    const output = execFileSync(cmd, args, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { ok: true, output: output.trim() };
+  } catch (err) {
+    return { ok: false, output: (err.stderr || err.stdout || err.message || '').trim() };
+  }
+}
+
+function install() {
+  const plat = detectPlatform();
+  if (!plat) {
+    console.log('Daemon install is not supported on this platform.');
+    console.log('Supported: Linux (systemd), macOS (launchd).');
+    return;
+  }
+
+  const { nodePath, binPath, isNpxCache } = resolvePaths();
+
+  if (isNpxCache) {
+    console.log('Warning: vibe-usage appears to be running from the npx cache.');
+    console.log('The daemon may break when the cache is cleared.');
+    console.log('For reliable operation, install globally first:');
+    console.log('  npm install -g @vibe-cafe/vibe-usage\n');
+  }
+
+  const paths = getServicePaths(plat);
+
+  if (existsSync(paths.file)) {
+    console.log('Service is already installed. Run `vibe-usage daemon restart` or `daemon uninstall` first.');
+    return;
+  }
+
+  mkdirSync(paths.dir, { recursive: true });
+
+  if (plat === 'systemd') {
+    writeFileSync(paths.file, generateSystemdUnit(nodePath, binPath), 'utf-8');
+    console.log(`Created ${paths.file}`);
+
+    run('systemctl', ['--user', 'daemon-reload']);
+    const result = run('systemctl', ['--user', 'enable', '--now', `${SERVICE_NAME}.service`]);
+    if (!result.ok) {
+      console.error(`Failed to start service: ${result.output}`);
+      return;
+    }
+    console.log('Service enabled and started.');
+  }
+
+  if (plat === 'launchd') {
+    mkdirSync(join(homedir(), '.vibe-usage'), { recursive: true });
+    writeFileSync(paths.file, generateLaunchdPlist(nodePath, binPath), 'utf-8');
+    console.log(`Created ${paths.file}`);
+
+    const result = run('launchctl', ['load', paths.file]);
+    if (!result.ok) {
+      console.error(`Failed to load service: ${result.output}`);
+      return;
+    }
+    console.log('Service loaded and started.');
+  }
+
+  console.log('\nDaemon installed. Usage data will sync automatically every 5 minutes.');
+  console.log('Run `vibe-usage daemon status` to check.');
+}
+
+function uninstall() {
+  const plat = detectPlatform();
+  if (!plat) {
+    console.log('No supported service platform detected.');
+    return;
+  }
+
+  const paths = getServicePaths(plat);
+
+  if (!existsSync(paths.file)) {
+    console.log('No daemon service is installed.');
+    return;
+  }
+
+  if (plat === 'systemd') {
+    run('systemctl', ['--user', 'stop', `${SERVICE_NAME}.service`]);
+    run('systemctl', ['--user', 'disable', `${SERVICE_NAME}.service`]);
+    unlinkSync(paths.file);
+    run('systemctl', ['--user', 'daemon-reload']);
+    console.log('Service stopped, disabled, and removed.');
+  }
+
+  if (plat === 'launchd') {
+    run('launchctl', ['unload', paths.file]);
+    unlinkSync(paths.file);
+    console.log('Service unloaded and removed.');
+  }
+}
+
+function status() {
+  const plat = detectPlatform();
+  if (!plat) {
+    console.log('No supported service platform detected.');
+    return;
+  }
+
+  const paths = getServicePaths(plat);
+
+  if (!existsSync(paths.file)) {
+    console.log('No daemon service is installed.');
+    console.log('Run `vibe-usage daemon install` to set up.');
+    return;
+  }
+
+  if (plat === 'systemd') {
+    const result = run('systemctl', ['--user', 'status', `${SERVICE_NAME}.service`]);
+    console.log(result.output);
+  }
+
+  if (plat === 'launchd') {
+    const result = run('launchctl', ['list', LAUNCHD_LABEL]);
+    if (result.ok) {
+      console.log(`Service: ${LAUNCHD_LABEL}`);
+      console.log(result.output);
+    } else {
+      console.log('Service is installed but not currently running.');
+    }
+  }
+}
+
+function stop() {
+  const plat = detectPlatform();
+  if (!plat) {
+    console.log('No supported service platform detected.');
+    return;
+  }
+
+  if (plat === 'systemd') {
+    const result = run('systemctl', ['--user', 'stop', `${SERVICE_NAME}.service`]);
+    console.log(result.ok ? 'Service stopped.' : `Failed: ${result.output}`);
+  }
+
+  if (plat === 'launchd') {
+    const result = run('launchctl', ['stop', LAUNCHD_LABEL]);
+    console.log(result.ok ? 'Service stopped.' : `Failed: ${result.output}`);
+  }
+}
+
+function restart() {
+  const plat = detectPlatform();
+  if (!plat) {
+    console.log('No supported service platform detected.');
+    return;
+  }
+
+  if (plat === 'systemd') {
+    const result = run('systemctl', ['--user', 'restart', `${SERVICE_NAME}.service`]);
+    console.log(result.ok ? 'Service restarted.' : `Failed: ${result.output}`);
+  }
+
+  if (plat === 'launchd') {
+    run('launchctl', ['stop', LAUNCHD_LABEL]);
+    const result = run('launchctl', ['start', LAUNCHD_LABEL]);
+    console.log(result.ok ? 'Service restarted.' : `Failed: ${result.output}`);
+  }
+}
+
+const SUBCOMMANDS = { install, uninstall, status, stop, restart };
+
+export async function manageDaemon(subcommand) {
+  const fn = SUBCOMMANDS[subcommand];
+  if (!fn) {
+    console.error(`Unknown daemon subcommand: ${subcommand}`);
+    console.error('Usage: vibe-usage daemon <install|uninstall|status|stop|restart>');
+    process.exit(1);
+  }
+  fn();
+}

package/src/index.js

@@ -109,8 +109,14 @@ export async function run(args) {
     }
     case 'daemon':
     case '--daemon': {
-      const { runDaemon } = await import('./daemon.js');
-      await runDaemon();
+      const sub = args[1];
+      if (sub && ['install', 'uninstall', 'status', 'stop', 'restart'].includes(sub)) {
+        const { manageDaemon } = await import('./daemon-service.js');
+        await manageDaemon(sub);
+      } else {
+        const { runDaemon } = await import('./daemon.js');
+        await runDaemon();
+      }
       break;
     }
     case 'skill': {
@@ -136,7 +142,12 @@ export async function run(args) {
     npx @vibe-cafe/vibe-usage              Init (first run) or sync
     npx @vibe-cafe/vibe-usage init         Set up API key
     npx @vibe-cafe/vibe-usage sync         Manually sync usage data
-    npx @vibe-cafe/vibe-usage daemon       Continuous sync (every 5m)
+    npx @vibe-cafe/vibe-usage daemon       Continuous sync (every 5m, foreground)
+    npx @vibe-cafe/vibe-usage daemon install    Install background service (systemd/launchd)
+    npx @vibe-cafe/vibe-usage daemon uninstall  Remove background service
+    npx @vibe-cafe/vibe-usage daemon status     Show background service status
+    npx @vibe-cafe/vibe-usage daemon stop       Stop background service
+    npx @vibe-cafe/vibe-usage daemon restart    Restart background service
     npx @vibe-cafe/vibe-usage reset        Delete all data and re-upload
     npx @vibe-cafe/vibe-usage reset --local  Delete data for this host only and re-upload
     npx @vibe-cafe/vibe-usage skill         Install skill for AI coding tools

package/src/init.js

@@ -75,4 +75,8 @@ export async function runInit() {
   await runSync();
 
   console.log(`\nSetup complete! View your dashboard at: ${apiUrl}/usage`);
+
+  if (process.platform === 'linux' || process.platform === 'darwin') {
+    console.log('\nTip: Run `npx @vibe-cafe/vibe-usage daemon install` to sync automatically in the background.');
+  }
 }

package/src/parsers/antigravity.js

@@ -0,0 +1,346 @@
+import { execSync } from 'node:child_process';
+import { readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+
+
+/**
+ * Antigravity parser (file-based).
+ * Scans .pb files in ~/.gemini/antigravity/conversations/ to discover cascade IDs.
+ * Calls GetCascadeTrajectory via a running language server to extract token usage
+ * (from generatorMetadata) and session events (from trajectory steps).
+ */
+
+const SOURCE = 'antigravity';
+const CONVERSATIONS_DIR = join(homedir(), '.gemini', 'antigravity', 'conversations');
+
+// User sources → role 'user'; Model source → role 'assistant'; System sources → skip
+const USER_SOURCES = new Set([
+  'CORTEX_STEP_SOURCE_USER_EXPLICIT',
+  'CORTEX_STEP_SOURCE_USER_IMPLICIT',
+]);
+const ASSISTANT_SOURCES = new Set([
+  'CORTEX_STEP_SOURCE_MODEL',
+]);
+
+// ── Process discovery (single instance) ──────────────────────────────
+
+const IS_WIN = process.platform === 'win32';
+
+/**
+ * Find ONE running language server process with a CSRF token.
+ * Returns { pid, csrfToken } or null.
+ */
+function findLanguageServer() {
+  try {
+    return IS_WIN ? findLanguageServerWin() : findLanguageServerUnix();
+  } catch {
+    return null;
+  }
+}
+
+function findLanguageServerUnix() {
+  const out = execSync("ps aux | grep 'antigravity/bin/language_server_'", { encoding: 'utf-8', timeout: 5000 });
+  for (const line of out.split('\n')) {
+    if (!line.trim()) continue;
+    if (line.includes('grep')) continue;
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 2) continue;
+    const pid = parts[1];
+    const csrfMatch = line.match(/--csrf_token\s+([0-9a-f-]+)/);
+    const csrfToken = csrfMatch ? csrfMatch[1] : '';
+    if (csrfToken) return { pid, csrfToken };
+  }
+  return null;
+}
+
+function findLanguageServerWin() {
+  const out = execSync(
+    'wmic process where "CommandLine like \'%antigravity%language_server%\'" get ProcessId,CommandLine /format:list',
+    { encoding: 'utf-8', timeout: 5000, shell: 'cmd.exe' },
+  );
+  // wmic /format:list outputs lines like "CommandLine=..." and "ProcessId=..."
+  let cmdLine = '';
+  let pid = '';
+  for (const line of out.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('CommandLine=')) {
+      const val = trimmed.slice('CommandLine='.length);
+      if (/WMIC\.exe/i.test(val)) continue; // skip wmic's own process
+      cmdLine = val;
+    }
+    if (trimmed.startsWith('ProcessId=')) pid = trimmed.slice('ProcessId='.length);
+  }
+  if (!pid || !cmdLine) return null;
+  const csrfMatch = cmdLine.match(/--csrf_token\s+([0-9a-f-]+)/);
+  const csrfToken = csrfMatch ? csrfMatch[1] : '';
+  if (!csrfToken) return null;
+  return { pid, csrfToken };
+}
+
+function findListeningPorts(pid) {
+  try {
+    return IS_WIN ? findListeningPortsWin(pid) : findListeningPortsUnix(pid);
+  } catch {
+    return [];
+  }
+}
+
+function findListeningPortsUnix(pid) {
+  const out = execSync(`lsof -iTCP -sTCP:LISTEN -nP -a -p ${pid}`, {
+    encoding: 'utf-8',
+    timeout: 5000,
+  });
+  const ports = [];
+  for (const line of out.split('\n')) {
+    const match = line.match(/:(\d+)\s+\(LISTEN\)/);
+    if (match) ports.push(parseInt(match[1], 10));
+  }
+  return ports;
+}
+
+function findListeningPortsWin(pid) {
+  // netstat output: TCP  127.0.0.1:49327  0.0.0.0:0  LISTENING  12345
+  const out = execSync('netstat -ano', { encoding: 'utf-8', timeout: 5000 });
+  const ports = [];
+  for (const line of out.split('\n')) {
+    if (!line.includes('LISTENING')) continue;
+    const parts = line.trim().split(/\s+/);
+    // parts: [TCP, local_addr:port, foreign_addr, LISTENING, pid]
+    const linePid = parts[parts.length - 1];
+    if (linePid !== String(pid)) continue;
+    const addrMatch = parts[1]?.match(/:(\d+)$/);
+    if (addrMatch) ports.push(parseInt(addrMatch[1], 10));
+  }
+  return ports;
+}
+
+async function rpcPost(baseUrl, path, body, csrfToken, timeoutMs = 10000) {
+  const url = new URL(path, baseUrl);
+  const headers = {
+    'Content-Type': 'application/json',
+    'Connect-Protocol-Version': '1',
+  };
+  if (csrfToken) headers['X-Codeium-Csrf-Token'] = csrfToken;
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status} from ${path}`);
+  return res.json();
+}
+
+async function probeHttpPort(ports, csrfToken) {
+  for (const port of ports) {
+    const baseUrl = `http://127.0.0.1:${port}`;
+    try {
+      await rpcPost(
+        baseUrl,
+        '/exa.language_server_pb.LanguageServerService/GetWorkspaceInfos',
+        {},
+        csrfToken,
+        3000,
+      );
+      return baseUrl;
+    } catch {
+      // Not the right port, try next
+    }
+  }
+  return null;
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+/**
+ * Normalize model names to canonical forms.
+ */
+const MODEL_NORMALIZE_MAP = {
+  'claude-opus-4-6-thinking': 'claude-opus-4-6',
+  'claude-sonnet-4-6-thinking': 'claude-sonnet-4-6',
+  'gemini-3-flash-c': 'gemini-3-flash',
+  "gemini-3.1-pro-high": "gemini-3.1-pro",
+  "gemini-3.1-pro-low": "gemini-3.1-pro",
+  "gemini-3-pro-high": "gemini-3-pro",
+  "gemini-3-pro-low": "gemini-3-pro",
+};
+
+/**
+ * Map internal placeholder model IDs to canonical names.
+ * Used when responseModel is empty and only chatModel.model is available.
+ */
+const PLACEHOLDER_MODEL_MAP = {
+  'MODEL_PLACEHOLDER_M37': 'gemini-3.1-pro',
+  'MODEL_PLACEHOLDER_M36': 'gemini-3.1-pro',
+  'MODEL_PLACEHOLDER_M47': 'gemini-3-flash',
+  'MODEL_PLACEHOLDER_M35': 'claude-sonnet-4-6',
+  'MODEL_PLACEHOLDER_M26': 'claude-opus-4-6',
+  'MODEL_OPENAI_GPT_OSS_120B_MEDIUM': 'gpt-oss-120b',
+};
+
+function normalizeModel(raw) {
+  return MODEL_NORMALIZE_MAP[raw] || raw;
+}
+
+/**
+ * Resolve model name: prefer responseModel, fall back to placeholder map.
+ */
+function resolveModel(chatModel) {
+  if (chatModel.responseModel) return normalizeModel(chatModel.responseModel);
+  const placeholder = chatModel.model || '';
+  if (PLACEHOLDER_MODEL_MAP[placeholder]) return PLACEHOLDER_MODEL_MAP[placeholder];
+  return 'unknown';
+}
+
+function toSafeNumber(value) {
+  if (value == null) return 0;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : 0;
+}
+
+/**
+ * Extract project name from a workspace URI (e.g. "file:///Users/x/myproject" → "myproject").
+ */
+function projectFromUri(uri) {
+  if (!uri) return null;
+  const parts = uri.replace(/\/$/, '').split('/');
+  return parts[parts.length - 1] || null;
+}
+
+/**
+ * List cascade IDs from .pb files in the conversations directory.
+ */
+function listCascades() {
+  try {
+    const files = readdirSync(CONVERSATIONS_DIR);
+    const results = [];
+    for (const f of files) {
+      if (!f.endsWith('.pb')) continue;
+      results.push(f.slice(0, -3)); // strip .pb → cascadeId
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+// ── Main parse ───────────────────────────────────────────────────────
+
+export async function parse() {
+  // Step 1: List cascade .pb files
+  const cascadeIds = listCascades();
+  if (cascadeIds.length === 0) return { buckets: [], sessions: [] };
+
+  // Step 2: Find a running language server to make RPC calls
+  const server = findLanguageServer();
+  if (!server) return { buckets: [], sessions: [] };
+
+  const ports = findListeningPorts(server.pid);
+  if (ports.length === 0) return { buckets: [], sessions: [] };
+
+  const baseUrl = await probeHttpPort(ports, server.csrfToken);
+  if (!baseUrl) return { buckets: [], sessions: [] };
+
+  const rpc = (method, body) =>
+    rpcPost(
+      baseUrl,
+      `/exa.language_server_pb.LanguageServerService/${method}`,
+      body,
+      server.csrfToken,
+    );
+
+  // Step 3: Fetch trajectory for each changed cascade
+  const entries = [];
+  const sessionEvents = [];
+  const seenResponseIds = new Set();
+
+  for (const cascadeId of cascadeIds) {
+    let resp;
+    try {
+      resp = await rpc('GetCascadeTrajectory', { cascadeId });
+    } catch {
+      continue; // skip this cascade if RPC fails
+    }
+
+    const trajectory = resp?.trajectory;
+    if (!trajectory) continue;
+
+    const steps = trajectory.steps || [];
+    const metadataList = trajectory.generatorMetadata || [];
+
+
+    // Extract project from trajectory metadata workspaces
+    let project = 'unknown';
+    const workspaces = trajectory.metadata?.workspaces || [];
+    if (workspaces.length > 0) {
+      project = workspaces[0].repository?.computedName || projectFromUri(workspaces[0].workspaceFolderAbsoluteUri) || 'unknown';
+    }
+
+    // ── Token entries from generatorMetadata ──
+    for (const meta of metadataList) {
+      const chatModel = meta?.chatModel;
+      if (!chatModel) continue;
+
+      const responseModel = resolveModel(chatModel);
+      const createdAt = chatModel?.chatStartMetadata?.createdAt;
+      const ts = createdAt ? new Date(createdAt) : null;
+      if (!ts || isNaN(ts.getTime())) continue;
+
+      const retryInfos = chatModel.retryInfos || [];
+      for (const retry of retryInfos) {
+        const usage = retry.usage;
+        if (!usage) continue;
+
+        const responseId = usage.responseId || '';
+        if (responseId && seenResponseIds.has(responseId)) continue;
+        if (responseId) seenResponseIds.add(responseId);
+
+        entries.push({
+          source: SOURCE,
+          model: responseModel,
+          project,
+          timestamp: ts,
+          inputTokens: toSafeNumber(usage.inputTokens),
+          outputTokens: toSafeNumber(usage.outputTokens),
+          cachedInputTokens: toSafeNumber(usage.cacheReadTokens),
+          reasoningOutputTokens: toSafeNumber(usage.thinkingOutputTokens),
+        });
+      }
+    }
+
+    // ── Session events from trajectory steps ──
+    for (const step of steps) {
+      const stepSource = step?.metadata?.source || '';
+      let role;
+      if (USER_SOURCES.has(stepSource)) {
+        role = 'user';
+      } else if (ASSISTANT_SOURCES.has(stepSource)) {
+        role = 'assistant';
+      } else {
+        continue; // skip SYSTEM / SYSTEM_SDK / UNSPECIFIED
+      }
+
+      const createdAt = step?.metadata?.createdAt;
+      const ts = createdAt ? new Date(createdAt) : null;
+      if (!ts || isNaN(ts.getTime())) continue;
+
+      sessionEvents.push({
+        sessionId: cascadeId,
+        source: SOURCE,
+        project,
+        timestamp: ts,
+        role,
+      });
+    }
+
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(sessionEvents),
+  };
+}

package/src/parsers/index.js

@@ -9,6 +9,7 @@ import { parse as parseQwenCode } from './qwen-code.js';
 import { parse as parseKimiCode } from './kimi-code.js';
 import { parse as parseAmp } from './amp.js';
 import { parse as parseDroid } from './droid.js';
+import { parse as parseAntigravity } from './antigravity.js';
 import { parse as parsePiCodingAgent } from './pi-coding-agent.js';
 
 export const parsers = {
@@ -22,6 +23,7 @@ export const parsers = {
   'kimi-code': parseKimiCode,
   'amp': parseAmp,
   'droid': parseDroid,
+  'antigravity': parseAntigravity,
   'pi-coding-agent': parsePiCodingAgent,
 };
 

package/src/tools.js

@@ -3,6 +3,11 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 
 export const TOOLS = [
+  {
+    name: 'Antigravity',
+    id: 'antigravity',
+    dataDir: join(homedir(), '.gemini', 'antigravity'),
+  },
   {
     name: 'Claude Code',
     id: 'claude-code',