@vibe-cafe/vibe-usage 0.5.0 → 0.5.2

package/README.md

@@ -34,6 +34,8 @@ npx vibe-usage status       # Show config & detected tools
 | Gemini CLI | `~/.gemini/tmp/` |
 | OpenCode | `~/.local/share/opencode/opencode.db` (SQLite) |
 | OpenClaw | `~/.openclaw/agents/` |
+| Qwen Code | `~/.qwen/tmp/` |
+| Kimi Code | `~/.kimi/sessions/` |
 
 ## How It Works
 

package/package.json

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

package/src/index.js

@@ -1,5 +1,5 @@
 import { loadConfig, saveConfig, getConfigPath } from './config.js';
-import { detectInstalledTools, TOOLS } from './hooks.js';
+import { detectInstalledTools, TOOLS } from './tools.js';
 import { existsSync } from 'node:fs';
 
 async function showStatus() {

package/src/init.js

@@ -4,7 +4,7 @@ import { platform } from 'node:os';
 import { loadConfig, saveConfig } from './config.js';
 import { ingest } from './api.js';
 import { runSync } from './sync.js';
-import { detectInstalledTools } from './hooks.js';
+import { detectInstalledTools } from './tools.js';
 
 function prompt(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });

package/src/parsers/codex.js

@@ -115,15 +115,19 @@ export async function parse() {
 
         const model = info.model || payload.model || turnContextModel || sessionModel;
 
+        // OpenAI API: input_tokens INCLUDES cached, output_tokens INCLUDES reasoning.
+        // Normalize to Anthropic-style semantics where each field is non-overlapping.
+        const cachedInput = usage.cached_input_tokens || usage.cache_read_input_tokens || 0;
+        const reasoningOutput = usage.reasoning_output_tokens || 0;
         entries.push({
           source: 'codex',
           model,
           project: sessionProject,
           timestamp,
-          inputTokens: usage.input_tokens || 0,
-          outputTokens: usage.output_tokens || 0,
-          cachedInputTokens: usage.cached_input_tokens || usage.cache_read_input_tokens || 0,
-          reasoningOutputTokens: usage.reasoning_output_tokens || 0,
+          inputTokens: (usage.input_tokens || 0) - cachedInput,
+          outputTokens: (usage.output_tokens || 0) - reasoningOutput,
+          cachedInputTokens: cachedInput,
+          reasoningOutputTokens: reasoningOutput,
         });
       } catch {
         continue;

package/src/parsers/gemini-cli.js

@@ -59,28 +59,32 @@ export async function parse() {
       if (isNaN(ts.getTime())) continue;
 
       if (tokens) {
-        // New format: { input, output, cached, thoughts, tool, total }
+        // Gemini API: input INCLUDES cached, output INCLUDES thoughts. Normalize to non-overlapping.
+        const cached = tokens.cached || 0;
+        const thoughts = tokens.thoughts || 0;
         entries.push({
           source: 'gemini-cli',
           model: msg.model || data.model || 'unknown',
           project: 'unknown',
           timestamp: ts,
-          inputTokens: tokens.input || 0,
-          outputTokens: tokens.output || 0,
-          cachedInputTokens: tokens.cached || 0,
-          reasoningOutputTokens: tokens.thoughts || 0,
+          inputTokens: (tokens.input || 0) - cached,
+          outputTokens: (tokens.output || 0) - thoughts,
+          cachedInputTokens: cached,
+          reasoningOutputTokens: thoughts,
         });
       } else {
-        // Old format: { promptTokenCount, candidatesTokenCount, ... }
+        // Gemini API: promptTokenCount INCLUDES cachedContentTokenCount. Normalize to non-overlapping.
+        const cached = usage.cachedContentTokenCount || 0;
+        const thoughts = usage.thoughtsTokenCount || 0;
         entries.push({
           source: 'gemini-cli',
           model: msg.model || data.model || 'unknown',
           project: 'unknown',
           timestamp: ts,
-          inputTokens: usage.promptTokenCount || usage.input_tokens || 0,
-          outputTokens: usage.candidatesTokenCount || usage.output_tokens || 0,
-          cachedInputTokens: usage.cachedContentTokenCount || 0,
-          reasoningOutputTokens: usage.thoughtsTokenCount || 0,
+          inputTokens: (usage.promptTokenCount || usage.input_tokens || 0) - cached,
+          outputTokens: (usage.candidatesTokenCount || usage.output_tokens || 0) - thoughts,
+          cachedInputTokens: cached,
+          reasoningOutputTokens: thoughts,
         });
       }
     }

package/src/parsers/index.js

@@ -3,6 +3,8 @@ import { parse as parseCodex } from './codex.js';
 import { parse as parseGeminiCli } from './gemini-cli.js';
 import { parse as parseOpencode } from './opencode.js';
 import { parse as parseOpenclaw } from './openclaw.js';
+import { parse as parseQwenCode } from './qwen-code.js';
+import { parse as parseKimiCode } from './kimi-code.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
@@ -10,6 +12,8 @@ export const parsers = {
   'gemini-cli': parseGeminiCli,
   'opencode': parseOpencode,
   'openclaw': parseOpenclaw,
+  'qwen-code': parseQwenCode,
+  'kimi-code': parseKimiCode,
 };
 
 
@@ -45,7 +49,7 @@ export function aggregateToBuckets(entries) {
     b.outputTokens += e.outputTokens || 0;
     b.cachedInputTokens += e.cachedInputTokens || 0;
     b.reasoningOutputTokens += e.reasoningOutputTokens || 0;
-    b.totalTokens += (e.inputTokens || 0) + (e.outputTokens || 0);
+    b.totalTokens += (e.inputTokens || 0) + (e.outputTokens || 0) + (e.reasoningOutputTokens || 0);
   }
 
   return Array.from(map.values());

package/src/parsers/kimi-code.js

@@ -0,0 +1,125 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, sep } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets } from './index.js';
+
+/**
+ * Kimi Code CLI parser.
+ * Wire protocol JSONL at ~/.kimi/sessions/<work-dir-hash>/<session-id>/wire.jsonl
+ * Token data from StatusUpdate events: payload.token_usage.{input_other, output,
+ *   input_cache_read, input_cache_creation}
+ */
+
+const KIMI_SESSIONS_DIR = join(homedir(), '.kimi', 'sessions');
+const KIMI_CONFIG = join(homedir(), '.kimi', 'kimi.json');
+
+function findWireFiles(baseDir) {
+  const results = [];
+  if (!existsSync(baseDir)) return results;
+
+  try {
+    for (const workDir of readdirSync(baseDir, { withFileTypes: true })) {
+      if (!workDir.isDirectory()) continue;
+      const workDirPath = join(baseDir, workDir.name);
+
+      try {
+        for (const session of readdirSync(workDirPath, { withFileTypes: true })) {
+          if (!session.isDirectory()) continue;
+          const wireFile = join(workDirPath, session.name, 'wire.jsonl');
+          if (existsSync(wireFile)) {
+            results.push({ filePath: wireFile, workDirHash: workDir.name });
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+
+function loadProjectMap() {
+  const map = new Map();
+  if (!existsSync(KIMI_CONFIG)) return map;
+
+  try {
+    const config = JSON.parse(readFileSync(KIMI_CONFIG, 'utf-8'));
+    const workspaces = config.workspaces || config.projects || {};
+    for (const [hash, info] of Object.entries(workspaces)) {
+      const path = typeof info === 'string' ? info : (info?.path || info?.dir);
+      if (path) {
+        const parts = path.split('/').filter(Boolean);
+        map.set(hash, parts[parts.length - 1] || hash);
+      }
+    }
+  } catch {
+    // config unreadable
+  }
+  return map;
+}
+
+export async function parse() {
+  const wireFiles = findWireFiles(KIMI_SESSIONS_DIR);
+  if (wireFiles.length === 0) return [];
+
+  const projectMap = loadProjectMap();
+  const entries = [];
+  const seenMessageIds = new Set();
+
+  for (const { filePath, workDirHash } of wireFiles) {
+    let content;
+    try {
+      content = readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    const project = projectMap.get(workDirHash) || workDirHash;
+    let currentModel = 'unknown';
+    let lastTimestamp = null;
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        const type = obj.type;
+        const payload = obj.payload;
+        if (!payload) continue;
+
+        if (payload.timestamp) lastTimestamp = payload.timestamp;
+        if (payload.model) currentModel = payload.model;
+
+        if (type !== 'StatusUpdate') continue;
+
+        const tokenUsage = payload.token_usage;
+        if (!tokenUsage) continue;
+        if (!tokenUsage.input_other && !tokenUsage.output) continue;
+
+        const messageId = payload.message_id;
+        if (messageId) {
+          if (seenMessageIds.has(messageId)) continue;
+          seenMessageIds.add(messageId);
+        }
+
+        const ts = lastTimestamp ? new Date(lastTimestamp) : new Date();
+
+        entries.push({
+          source: 'kimi-code',
+          model: currentModel,
+          project,
+          timestamp: ts,
+          inputTokens: tokenUsage.input_other || 0,
+          outputTokens: tokenUsage.output || 0,
+          cachedInputTokens: tokenUsage.input_cache_read || 0,
+          reasoningOutputTokens: 0,
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return aggregateToBuckets(entries);
+}

package/src/parsers/qwen-code.js

@@ -0,0 +1,112 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, basename, sep } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets } from './index.js';
+
+/**
+ * Qwen Code parser (Gemini CLI fork).
+ * JSONL at ~/.qwen/tmp/<project_id>/chats/<sessionId>.jsonl
+ * Token fields: usageMetadata.{promptTokenCount, candidatesTokenCount,
+ *   cachedContentTokenCount, thoughtsTokenCount}
+ * Note: promptTokenCount INCLUDES cachedContentTokenCount (needs normalization).
+ */
+
+const QWEN_TMP_DIR = join(homedir(), '.qwen', 'tmp');
+
+function findSessionFiles(baseDir) {
+  const results = [];
+  if (!existsSync(baseDir)) return results;
+
+  try {
+    for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const chatsDir = join(baseDir, entry.name, 'chats');
+      if (!existsSync(chatsDir)) continue;
+      try {
+        for (const f of readdirSync(chatsDir)) {
+          if (f.endsWith('.jsonl')) {
+            results.push(join(chatsDir, f));
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+
+function extractProject(cwd, filePath) {
+  if (cwd) {
+    const parts = cwd.split('/').filter(Boolean);
+    if (parts.length > 0) return parts[parts.length - 1];
+  }
+  const tmpPrefix = QWEN_TMP_DIR + sep;
+  if (filePath.startsWith(tmpPrefix)) {
+    const relative = filePath.slice(tmpPrefix.length);
+    const projectId = relative.split(sep)[0];
+    if (projectId) return projectId;
+  }
+  return 'unknown';
+}
+
+export async function parse() {
+  const sessionFiles = findSessionFiles(QWEN_TMP_DIR);
+  if (sessionFiles.length === 0) return [];
+
+  const entries = [];
+  const seenUuids = new Set();
+
+  for (const filePath of sessionFiles) {
+    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 !== 'assistant') continue;
+        const usage = obj.usageMetadata;
+        if (!usage) continue;
+        if (usage.promptTokenCount == null && usage.candidatesTokenCount == null) continue;
+
+        const uuid = obj.uuid;
+        if (uuid) {
+          if (seenUuids.has(uuid)) continue;
+          seenUuids.add(uuid);
+        }
+
+        const timestamp = obj.timestamp;
+        if (!timestamp) continue;
+        const ts = new Date(timestamp);
+        if (isNaN(ts.getTime())) continue;
+
+        // promptTokenCount INCLUDES cachedContentTokenCount — normalize to non-overlapping
+        const cached = usage.cachedContentTokenCount || 0;
+        const thoughts = usage.thoughtsTokenCount || 0;
+
+        entries.push({
+          source: 'qwen-code',
+          model: obj.model || 'unknown',
+          project: extractProject(obj.cwd, filePath),
+          timestamp: ts,
+          inputTokens: (usage.promptTokenCount || 0) - cached,
+          outputTokens: (usage.candidatesTokenCount || 0) - thoughts,
+          cachedInputTokens: cached,
+          reasoningOutputTokens: thoughts,
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return aggregateToBuckets(entries);
+}

package/src/{hooks.js → tools.js}

@@ -28,6 +28,16 @@ export const TOOLS = [
     id: 'openclaw',
     dataDir: join(homedir(), '.openclaw', 'agents'),
   },
+  {
+    name: 'Qwen Code',
+    id: 'qwen-code',
+    dataDir: join(homedir(), '.qwen', 'tmp'),
+  },
+  {
+    name: 'Kimi Code',
+    id: 'kimi-code',
+    dataDir: join(homedir(), '.kimi', 'sessions'),
+  },
 ];
 
 export function detectInstalledTools() {