@vibe-cafe/vibe-usage 0.9.1 → 0.9.3

package/README.md

@@ -66,6 +66,8 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Kiro | `~/Library/Application Support/Kiro/User/globalStorage/kiro.kiroagent/dev_data/devdata.sqlite` (SQLite, JSONL fallback; model name resolved from `.chat` timeline) |
 | Cline | `<host>/User/globalStorage/saoudrizwan.claude-dev/{state/taskHistory.json,tasks/<id>/ui_messages.json}` (walks all VSCode-fork hosts: Code, Cursor, Windsurf, VSCodium, Trae, ...) |
 | Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |
+| Antigravity | `~/.gemini/antigravity/conversations/*.pb` to discover cascades, then reads token usage + sessions from the running language server via Connect RPC (process discovered with `ps`/`lsof` on macOS/Linux, PowerShell CIM with a `wmic` fallback on Windows) |
+| ZCode | `~/.zcode/cli/db/db.sqlite` (SQLite; reads the `message` table for per-message tokens, model, and project `cwd`/`root`, joined to `session.directory`) |
 
 ## How It Works
 

package/package.json

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

package/src/parsers/antigravity.js

@@ -1,5 +1,5 @@
 import { execSync } from 'node:child_process';
-import { readdirSync, existsSync } from 'node:fs';
+import { readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
@@ -57,27 +57,89 @@ function findLanguageServerUnix() {
 }
 
 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 = '';
+  // Prefer PowerShell/CIM: wmic is disabled by default on Windows 11 23H2+
+  // and removed entirely from 25H2 onward. Fall back to wmic for old/stripped
+  // environments without PowerShell. Each probe is independently time-boxed and
+  // failures are swallowed, so a missing/hung tool never blocks the next one or
+  // the parsers that run after antigravity.
+  const out = queryProcessesWinPowerShell() ?? queryProcessesWinWmic();
+  if (!out) return null;
+  return parseWinProcessList(out);
+}
+
+/**
+ * Query language_server processes via PowerShell + CIM.
+ * Emits "ProcessId=..." / "CommandLine=..." lines (wmic /format:list shape)
+ * so parseWinProcessList handles either source. Returns null on failure.
+ */
+function queryProcessesWinPowerShell() {
+  // Filter is applied in PowerShell so the LIKE wildcards stay server-side.
+  // A "---" separator before each process's ProcessId/CommandLine lines keeps
+  // fields grouped even when multiple processes match.
+  const script =
+    "Get-CimInstance Win32_Process -Filter \"CommandLine LIKE '%antigravity%language_server%'\" | " +
+    'ForEach-Object { "---"; "ProcessId=" + $_.ProcessId; "CommandLine=" + $_.CommandLine }';
+  for (const exe of ['powershell.exe', 'pwsh.exe']) {
+    try {
+      const out = execSync(
+        `${exe} -NoProfile -NonInteractive -Command "${script.replace(/"/g, '\\"')}"`,
+        { encoding: 'utf-8', timeout: 4000, windowsHide: true },
+      );
+      if (out && out.trim()) return out;
+      // Empty (no matching process) — no point trying another shell.
+      return null;
+    } catch {
+      // Try next shell (pwsh on systems without legacy powershell.exe).
+    }
+  }
+  return null;
+}
+
+/** Legacy fallback: wmic /format:list. Returns null on failure. */
+function queryProcessesWinWmic() {
+  try {
+    return execSync(
+      'wmic process where "CommandLine like \'%antigravity%language_server%\'" get ProcessId,CommandLine /format:list',
+      { encoding: 'utf-8', timeout: 4000, shell: 'cmd.exe' },
+    );
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse "ProcessId=..." / "CommandLine=..." records (from either PowerShell or
+ * wmic /format:list) and return the first language_server that carries a
+ * --csrf_token, or null. PowerShell emits an explicit "---" separator per
+ * process; wmic does not and may emit the two fields in either order, so a
+ * record also ends whenever a field we've already captured reappears.
+ */
+function parseWinProcessList(out) {
   let pid = '';
+  let cmdLine = '';
+  const finish = () => {
+    if (pid && cmdLine && !/WMIC\.exe|powershell\.exe|pwsh\.exe/i.test(cmdLine)) {
+      const csrfMatch = cmdLine.match(/--csrf_token\s+([0-9a-f-]+)/);
+      if (csrfMatch) return { pid, csrfToken: csrfMatch[1] };
+    }
+    return null;
+  };
+  const reset = () => { pid = ''; cmdLine = ''; };
   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;
+    const isPid = trimmed.startsWith('ProcessId=');
+    const isCmd = trimmed.startsWith('CommandLine=');
+    // Record boundary: explicit "---", or a field that would overwrite one we
+    // already hold (next process began without a separator, e.g. wmic output).
+    if (trimmed === '---' || (isPid && pid) || (isCmd && cmdLine)) {
+      const found = finish();
+      if (found) return found;
+      reset();
     }
-    if (trimmed.startsWith('ProcessId=')) pid = trimmed.slice('ProcessId='.length);
+    if (isPid) pid = trimmed.slice('ProcessId='.length);
+    else if (isCmd) cmdLine = trimmed.slice('CommandLine='.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 };
+  return finish();
 }
 
 function findListeningPorts(pid) {

package/src/parsers/index.js

@@ -16,6 +16,7 @@ import { parse as parseAntigravity } from './antigravity.js';
 import { parse as parseHermes } from './hermes.js';
 import { parse as parseKiro } from './kiro.js';
 import { parse as parsePiCodingAgent } from './pi-coding-agent.js';
+import { parse as parseZcode } from './zcode.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
@@ -35,6 +36,7 @@ export const parsers = {
   'hermes': parseHermes,
   'kiro': parseKiro,
   'pi-coding-agent': parsePiCodingAgent,
+  'zcode': parseZcode,
 };
 
 

package/src/parsers/zcode.js

@@ -0,0 +1,104 @@
+import { existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './index.js';
+import { queryDbJson } from './sqlite.js';
+
+// ZCode (z.ai / Zhipu's coding agent) stores everything in a SQLite database
+// at ~/.zcode/cli/db/db.sqlite. The `message` table is the canonical source:
+// each row is one user or assistant message, with an assistant message carrying
+// per-request token usage and the working directory. We read it directly rather
+// than the parallel `model_usage` ledger because `message` gives us BOTH session
+// timing (user + assistant rows) and token usage in one pass, with the project
+// path attached to each message.
+const DB_PATH = join(homedir(), '.zcode', 'cli', 'db', 'db.sqlite');
+
+/**
+ * Project name from a ZCode message's path. ZCode records both `cwd` and `root`;
+ * prefer `root` (the workspace root) and fall back to `cwd`, then to the
+ * session's `directory` column (joined in via the query) — taking the last path
+ * component, matching how every other parser names projects.
+ */
+function projectName(root, cwd, sessionDir) {
+  const p = root || cwd || sessionDir;
+  if (!p) return 'unknown';
+  return basename(String(p).replace(/[/\\]+$/, '')) || 'unknown';
+}
+
+export async function parse() {
+  if (!existsSync(DB_PATH)) return { buckets: [], sessions: [] };
+
+  // Join each message to its session so we can fall back to the session's
+  // directory when an individual message has no path (older rows, lite agents).
+  const query = `SELECT
+    m.session_id AS sessionId,
+    m.time_created AS created,
+    json_extract(m.data, '$.role') AS role,
+    json_extract(m.data, '$.modelID') AS modelID,
+    json_extract(m.data, '$.tokens') AS tokens,
+    json_extract(m.data, '$.path.root') AS pathRoot,
+    json_extract(m.data, '$.path.cwd') AS pathCwd,
+    s.directory AS sessionDir
+    FROM message m
+    LEFT JOIN session s ON s.id = m.session_id`;
+
+  let rows;
+  try {
+    rows = queryDbJson(DB_PATH, query);
+  } catch (err) {
+    if (err.status === 127 || (err.message && err.message.includes('ENOENT'))) {
+      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync ZCode data.');
+    }
+    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 = projectName(row.pathRoot, row.pathCwd, row.sessionDir);
+    const sessionId = row.sessionId || 'unknown';
+
+    sessionEvents.push({
+      sessionId,
+      source: 'zcode',
+      project,
+      timestamp,
+      role: row.role === 'user' ? 'user' : 'assistant',
+    });
+
+    if (row.role !== 'assistant') continue;
+
+    let tokens;
+    try {
+      tokens = typeof row.tokens === 'string' ? JSON.parse(row.tokens) : row.tokens;
+    } catch {
+      continue;
+    }
+    if (!tokens || (!tokens.input && !tokens.output)) continue;
+
+    // ZCode follows Anthropic-style usage where `input` INCLUDES the cache-read
+    // tokens and `output` INCLUDES reasoning (verified: input + output == total).
+    // Normalize to this codebase's non-overlapping fields so cached/reasoning
+    // tokens aren't double-counted inside input/output.
+    const cachedInput = tokens.cache?.read || 0;
+    const reasoning = tokens.reasoning || 0;
+
+    entries.push({
+      source: 'zcode',
+      model: row.modelID || 'unknown',
+      project,
+      timestamp,
+      inputTokens: (tokens.input || 0) - cachedInput,
+      outputTokens: (tokens.output || 0) - reasoning,
+      cachedInputTokens: cachedInput,
+      reasoningOutputTokens: reasoning,
+    });
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}

package/src/tools.js

@@ -195,6 +195,11 @@ export const TOOLS = [
     dataDir: join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline'),
     detectDataDirs: findRooCodeDataDirs,
   },
+  {
+    name: 'ZCode',
+    id: 'zcode',
+    dataDir: join(homedir(), '.zcode', 'cli', 'db', 'db.sqlite'),
+  },
 ];
 
 export function detectInstalledTools() {