@vibe-cafe/vibe-usage 0.9.2 → 0.9.4

package/README.md

@@ -67,6 +67,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | 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.2",
+  "version": "0.9.4",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "bin": {

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/kimi-code.js

@@ -1,33 +1,209 @@
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
 import { aggregateToBuckets, extractSessions } from './index.js';
 
 /**
- * Kimi CLI parser (a.k.a. "Kimi Code"). MoonshotAI/kimi-cli.
+ * Kimi Code CLI parser. MoonshotAI/kimi-cli (a.k.a. "Kimi Code").
  *
- * Wire protocol JSONL at ~/.kimi/sessions/<md5(workdir)>/<session-id>/wire.jsonl
- * - First line is a metadata header: {"type":"metadata","protocol_version":"1.9"}
- * - Each subsequent line (1.9):  {"timestamp": <float seconds>, "message": {"type", "payload"}}
- * - Legacy 1.1 line:             {"type", "payload"}  (no message wrapper, ts may live in payload)
+ * Two on-disk layouts are supported:
  *
- * Token data: StatusUpdate.payload.token_usage
- *   = {input_other, output, input_cache_read, input_cache_creation}
+ * 1. Current ("~/.kimi-code", protocol >= 1.4). Sessions live at
+ *      ~/.kimi-code/sessions/wd_<slug>_<hash>/session_<id>/agents/<agentId>/wire.jsonl
+ *    Each line is a self-describing event with a top-level integer-ms `time`:
+ *      {"type":"usage.record","model":"kimi-code/kimi-for-coding",
+ *       "usage":{"inputOther","output","inputCacheRead","inputCacheCreation"},
+ *       "usageScope":"turn","time":<ms>}
+ *    `usage.record` events are per-step deltas (one per assistant step), so they
+ *    sum to the session total. The model name rides on each record — no config
+ *    lookup needed. User turns are `turn.prompt` with origin.kind === "user".
+ *    The real working directory per session is recorded in
+ *      ~/.kimi-code/session_index.jsonl  -> {sessionId, sessionDir, workDir}
+ *    which gives an accurate project name (last path component of workDir).
  *
- * Model name is NOT present on StatusUpdate events; we read it from
- * ~/.kimi/config.toml (default_model, falling back to first [models.X] table).
- *
- * Project name comes from ~/.kimi/kimi.json -> work_dirs[].path; the dir name
- * under sessions/ is md5(path).
+ * 2. Legacy ("~/.kimi", protocol 1.1 / 1.9). Sessions live at
+ *      ~/.kimi/sessions/<md5(workdir)>/<session-id>/wire.jsonl
+ *    with a different envelope (StatusUpdate.payload.token_usage, float-second
+ *    `timestamp`) and the model in ~/.kimi/config.toml. Kept for users who have
+ *    not migrated; see parseLegacyKimi() below.
+ */
+
+// ---------------------------------------------------------------------------
+// Current format: ~/.kimi-code
+// ---------------------------------------------------------------------------
+
+const KIMI_CODE_DIR = join(homedir(), '.kimi-code');
+const KIMI_CODE_SESSIONS_DIR = join(KIMI_CODE_DIR, 'sessions');
+const KIMI_CODE_SESSION_INDEX = join(KIMI_CODE_DIR, 'session_index.jsonl');
+
+function projectNameFromPath(path) {
+  if (typeof path !== 'string' || !path) return null;
+  return basename(path.replace(/[/\\]+$/, '')) || path;
+}
+
+/**
+ * Map each session directory (absolute path) to a project name, read from
+ * ~/.kimi-code/session_index.jsonl. Falls back gracefully if the file is
+ * missing or malformed — callers default to the wd_ bucket name.
  */
+function loadSessionIndex() {
+  const map = new Map();
+  if (!existsSync(KIMI_CODE_SESSION_INDEX)) return map;
+
+  let content;
+  try {
+    content = readFileSync(KIMI_CODE_SESSION_INDEX, 'utf-8');
+  } catch {
+    return map;
+  }
+
+  for (const line of content.split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    const dir = entry?.sessionDir;
+    const project = projectNameFromPath(entry?.workDir);
+    if (typeof dir === 'string' && dir && project) map.set(dir, project);
+  }
+  return map;
+}
+
+// Strip the trailing _<hash> from a "wd_<slug>_<hash>" bucket name so the slug
+// can serve as a last-resort project label when session_index has no entry.
+function projectFromBucketName(name) {
+  const m = /^wd_(.+)_[0-9a-f]+$/.exec(name);
+  return m ? m[1] : name;
+}
+
+// Collect every agents/<id>/wire.jsonl under sessions/wd_<...>/session_<...>/.
+function findKimiCodeWireFiles(baseDir) {
+  const results = [];
+  if (!existsSync(baseDir)) return results;
+
+  let workDirs;
+  try {
+    workDirs = readdirSync(baseDir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+
+  for (const workDir of workDirs) {
+    if (!workDir.isDirectory()) continue;
+    const workDirPath = join(baseDir, workDir.name);
+    const bucketProject = projectFromBucketName(workDir.name);
+
+    let sessions;
+    try {
+      sessions = readdirSync(workDirPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const session of sessions) {
+      if (!session.isDirectory()) continue;
+      const sessionDir = join(workDirPath, session.name);
+      const agentsDir = join(sessionDir, 'agents');
+
+      let agents;
+      try {
+        agents = readdirSync(agentsDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+
+      for (const agent of agents) {
+        if (!agent.isDirectory()) continue;
+        const wireFile = join(agentsDir, agent.name, 'wire.jsonl');
+        if (existsSync(wireFile)) {
+          results.push({ wireFile, sessionDir, bucketProject });
+        }
+      }
+    }
+  }
+  return results;
+}
+
+function parseKimiCode() {
+  const wireFiles = findKimiCodeWireFiles(KIMI_CODE_SESSIONS_DIR);
+  if (wireFiles.length === 0) return null;
+
+  const sessionIndex = loadSessionIndex();
+  const entries = [];
+  const sessionEvents = [];
+
+  for (const { wireFile, sessionDir, bucketProject } of wireFiles) {
+    let content;
+    try {
+      content = readFileSync(wireFile, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    const project = sessionIndex.get(sessionDir) || bucketProject || 'unknown';
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      let evt;
+      try { evt = JSON.parse(line); } catch { continue; }
+
+      const type = evt.type;
+      // Top-level `time` is integer milliseconds since epoch.
+      const time = typeof evt.time === 'number' ? evt.time : null;
+
+      // Session timing: a user turn vs. anything the model emits.
+      if (type === 'turn.prompt' && evt.origin?.kind === 'user' && time) {
+        const ts = new Date(time);
+        if (!isNaN(ts.getTime())) {
+          sessionEvents.push({ sessionId: wireFile, source: 'kimi-code', project, timestamp: ts, role: 'user' });
+        }
+        continue;
+      }
+
+      if (type !== 'usage.record') continue;
+
+      const usage = evt.usage;
+      if (!usage) continue;
+
+      const inputTokens = usage.inputOther || 0;
+      const outputTokens = usage.output || 0;
+      const cachedInputTokens = usage.inputCacheRead || 0;
+      if (!inputTokens && !outputTokens && !cachedInputTokens) continue;
+
+      const ts = time ? new Date(time) : new Date();
+
+      entries.push({
+        source: 'kimi-code',
+        model: evt.model || 'unknown',
+        project,
+        timestamp: ts,
+        inputTokens,
+        outputTokens,
+        cachedInputTokens,
+        reasoningOutputTokens: 0,
+      });
+
+      // Each usage.record marks an assistant step completing — use it as an
+      // assistant timing event so active-time math has both sides of a turn.
+      if (time && !isNaN(ts.getTime())) {
+        sessionEvents.push({ sessionId: wireFile, source: 'kimi-code', project, timestamp: ts, role: 'assistant' });
+      }
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}
+
+// ---------------------------------------------------------------------------
+// Legacy format: ~/.kimi  (kept for users who haven't migrated to ~/.kimi-code)
+// ---------------------------------------------------------------------------
 
 const KIMI_DIR = join(homedir(), '.kimi');
 const KIMI_SESSIONS_DIR = join(KIMI_DIR, 'sessions');
 const KIMI_WORKDIRS_JSON = join(KIMI_DIR, 'kimi.json');
 const KIMI_CONFIG_TOML = join(KIMI_DIR, 'config.toml');
 
-function findWireFiles(baseDir) {
+function findLegacyWireFiles(baseDir) {
   const results = [];
   if (!existsSync(baseDir)) return results;
 
@@ -54,12 +230,7 @@ function findWireFiles(baseDir) {
   return results;
 }
 
-function projectNameFromPath(path) {
-  const parts = path.split('/').filter(Boolean);
-  return parts[parts.length - 1] || path;
-}
-
-function loadProjectMap() {
+function loadLegacyProjectMap() {
   const map = new Map();
   if (!existsSync(KIMI_WORKDIRS_JSON)) return map;
 
@@ -70,7 +241,6 @@ function loadProjectMap() {
     return map;
   }
 
-  // 1.9 schema: { work_dirs: [{ path, kaos, last_session_id }] }
   if (Array.isArray(config.work_dirs)) {
     for (const entry of config.work_dirs) {
       const path = entry?.path;
@@ -80,7 +250,6 @@ function loadProjectMap() {
     }
   }
 
-  // Legacy schemas keyed by hash
   for (const key of ['workspaces', 'projects']) {
     const obj = config[key];
     if (!obj || typeof obj !== 'object') continue;
@@ -93,13 +262,10 @@ function loadProjectMap() {
   return map;
 }
 
-// Matches both bare-key `[models.kimi-for-coding]` and quoted
-// `[models."kimi-code/kimi-for-coding"]` forms (TOML bare keys can't
-// contain `/`, so quoting is mandatory for hierarchical names).
 const TOML_MODEL_SECTION_RE = /^\s*\[models\.(?:"([^"]+)"|([A-Za-z0-9_-]+))\]/m;
 const TOML_DEFAULT_MODEL_RE = /^\s*default_model\s*=\s*["']([^"']+)["']/m;
 
-function loadModelFromConfig() {
+function loadLegacyModelFromConfig() {
   if (!existsSync(KIMI_CONFIG_TOML)) return 'unknown';
 
   let content;
@@ -118,14 +284,14 @@ function loadModelFromConfig() {
   return 'unknown';
 }
 
-const USER_EVENT_TYPES = new Set(['TurnBegin', 'UserMessage', 'user_message', 'Input']);
+const LEGACY_USER_EVENT_TYPES = new Set(['TurnBegin', 'UserMessage', 'user_message', 'Input']);
 
-export async function parse() {
-  const wireFiles = findWireFiles(KIMI_SESSIONS_DIR);
+function parseLegacyKimi() {
+  const wireFiles = findLegacyWireFiles(KIMI_SESSIONS_DIR);
   if (wireFiles.length === 0) return { buckets: [], sessions: [] };
 
-  const projectMap = loadProjectMap();
-  const defaultModel = loadModelFromConfig();
+  const projectMap = loadLegacyProjectMap();
+  const defaultModel = loadLegacyModelFromConfig();
   const entries = [];
   const sessionEvents = [];
   const seenMessageIds = new Set();
@@ -147,15 +313,11 @@ export async function parse() {
       let raw;
       try { raw = JSON.parse(line); } catch { continue; }
 
-      // Unwrap 1.9 envelope; fall through to top-level for legacy 1.1.
-      // Metadata header line has no payload and is filtered by the next check.
       const envelope = raw.message || raw;
       const type = envelope.type || raw.type;
       const payload = envelope.payload || raw.payload;
       if (!payload) continue;
 
-      // 1.9 puts timestamp at the outer level (Unix seconds, float).
-      // Legacy 1.1 sometimes puts it inside payload.
       if (typeof raw.timestamp === 'number') {
         lastTimestamp = raw.timestamp * 1000;
       } else if (typeof payload.timestamp === 'number') {
@@ -171,7 +333,7 @@ export async function parse() {
             source: 'kimi-code',
             project,
             timestamp: evTs,
-            role: USER_EVENT_TYPES.has(type) ? 'user' : 'assistant',
+            role: LEGACY_USER_EVENT_TYPES.has(type) ? 'user' : 'assistant',
           });
         }
       }
@@ -205,3 +367,11 @@ export async function parse() {
 
   return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
 }
+
+export async function parse() {
+  // Prefer the current ~/.kimi-code layout; fall back to legacy ~/.kimi only
+  // when no kimi-code sessions exist, so migrated users aren't double-counted.
+  const current = parseKimiCode();
+  if (current) return current;
+  return parseLegacyKimi();
+}

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

@@ -104,6 +104,15 @@ function findCodexDataDirs() {
   ].filter(existsSync);
 }
 
+// Kimi Code moved its store from ~/.kimi to ~/.kimi-code; recognize either so
+// users on either version are detected. The parser prefers ~/.kimi-code.
+function findKimiCodeDataDirs() {
+  return [
+    join(homedir(), '.kimi-code', 'sessions'),
+    join(homedir(), '.kimi', 'sessions'),
+  ].filter(existsSync);
+}
+
 export const TOOLS = [
   {
     name: 'Antigravity',
@@ -167,7 +176,10 @@ export const TOOLS = [
   {
     name: 'Kimi Code',
     id: 'kimi-code',
-    dataDir: join(homedir(), '.kimi', 'sessions'),
+    // Current layout is ~/.kimi-code/sessions; ~/.kimi/sessions is the legacy
+    // path. The parser reads whichever exists (preferring ~/.kimi-code).
+    dataDir: join(homedir(), '.kimi-code', 'sessions'),
+    detectDataDirs: findKimiCodeDataDirs,
   },
   {
     name: 'Amp',
@@ -195,6 +207,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() {