@vibe-cafe/vibe-usage 0.7.13 → 0.7.14

package/README.md

@@ -55,7 +55,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments) |
 | pi | `~/.pi/agent/sessions/` |
 | Qwen Code | `~/.qwen/tmp/` |
-| Kimi Code | `~/.kimi/sessions/` |
+| Kimi Code | `~/.kimi/sessions/<md5(workdir)>/<session-id>/wire.jsonl` (wire protocol 1.9, model from `~/.kimi/config.toml`, project from `~/.kimi/kimi.json`) |
 | Amp | `~/.local/share/amp/threads/` |
 | Droid | `~/.factory/sessions/` |
 | Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |

package/package.json

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

package/src/parsers/kimi-code.js

@@ -1,17 +1,31 @@
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
-import { join, sep } from 'node:path';
+import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
 import { aggregateToBuckets, extractSessions } 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}
+ * Kimi CLI parser (a.k.a. "Kimi Code"). MoonshotAI/kimi-cli.
+ *
+ * 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)
+ *
+ * Token data: StatusUpdate.payload.token_usage
+ *   = {input_other, output, input_cache_read, input_cache_creation}
+ *
+ * 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).
  */
 
-const KIMI_SESSIONS_DIR = join(homedir(), '.kimi', 'sessions');
-const KIMI_CONFIG = join(homedir(), '.kimi', 'kimi.json');
+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) {
   const results = [];
@@ -40,31 +54,78 @@ function findWireFiles(baseDir) {
   return results;
 }
 
+function projectNameFromPath(path) {
+  const parts = path.split('/').filter(Boolean);
+  return parts[parts.length - 1] || path;
+}
+
 function loadProjectMap() {
   const map = new Map();
-  if (!existsSync(KIMI_CONFIG)) return map;
+  if (!existsSync(KIMI_WORKDIRS_JSON)) return map;
 
+  let config;
   try {
-    const config = JSON.parse(readFileSync(KIMI_CONFIG, 'utf-8'));
-    const workspaces = config.workspaces || config.projects || {};
-    for (const [hash, info] of Object.entries(workspaces)) {
+    config = JSON.parse(readFileSync(KIMI_WORKDIRS_JSON, 'utf-8'));
+  } catch {
+    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;
+      if (typeof path !== 'string' || !path) continue;
+      const hash = createHash('md5').update(path).digest('hex');
+      map.set(hash, projectNameFromPath(path));
+    }
+  }
+
+  // Legacy schemas keyed by hash
+  for (const key of ['workspaces', 'projects']) {
+    const obj = config[key];
+    if (!obj || typeof obj !== 'object') continue;
+    for (const [hash, info] of Object.entries(obj)) {
       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);
-      }
+      if (typeof path === 'string' && path) map.set(hash, projectNameFromPath(path));
     }
-  } catch {
-    // config unreadable
   }
+
   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() {
+  if (!existsSync(KIMI_CONFIG_TOML)) return 'unknown';
+
+  let content;
+  try {
+    content = readFileSync(KIMI_CONFIG_TOML, 'utf-8');
+  } catch {
+    return 'unknown';
+  }
+
+  const defaultMatch = content.match(TOML_DEFAULT_MODEL_RE);
+  if (defaultMatch) return defaultMatch[1];
+
+  const sectionMatch = content.match(TOML_MODEL_SECTION_RE);
+  if (sectionMatch) return sectionMatch[1] || sectionMatch[2];
+
+  return 'unknown';
+}
+
+const USER_EVENT_TYPES = new Set(['TurnBegin', 'UserMessage', 'user_message', 'Input']);
+
 export async function parse() {
   const wireFiles = findWireFiles(KIMI_SESSIONS_DIR);
   if (wireFiles.length === 0) return { buckets: [], sessions: [] };
 
   const projectMap = loadProjectMap();
+  const defaultModel = loadModelFromConfig();
   const entries = [];
   const sessionEvents = [];
   const seenMessageIds = new Set();
@@ -78,61 +139,67 @@ export async function parse() {
     }
 
     const project = projectMap.get(workDirHash) || workDirHash;
-    let currentModel = 'unknown';
+    let currentModel = defaultModel;
     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 (lastTimestamp) {
-          const evTs = new Date(lastTimestamp);
-          if (!isNaN(evTs.getTime())) {
-            const isUser = type === 'UserMessage' || type === 'user_message' || type === 'Input';
-            sessionEvents.push({
-              sessionId: filePath,
-              source: 'kimi-code',
-              project,
-              timestamp: evTs,
-              role: isUser ? 'user' : 'assistant',
-            });
-          }
+      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') {
+        lastTimestamp = payload.timestamp * 1000;
+      }
+      if (payload.model) currentModel = payload.model;
+
+      if (lastTimestamp) {
+        const evTs = new Date(lastTimestamp);
+        if (!isNaN(evTs.getTime())) {
+          sessionEvents.push({
+            sessionId: filePath,
+            source: 'kimi-code',
+            project,
+            timestamp: evTs,
+            role: USER_EVENT_TYPES.has(type) ? 'user' : 'assistant',
+          });
         }
+      }
 
-        if (type !== 'StatusUpdate') continue;
-
-        const tokenUsage = payload.token_usage;
-        if (!tokenUsage) continue;
-        if (!tokenUsage.input_other && !tokenUsage.output) continue;
+      if (type !== 'StatusUpdate') continue;
 
-        const messageId = payload.message_id;
-        if (messageId) {
-          if (seenMessageIds.has(messageId)) continue;
-          seenMessageIds.add(messageId);
-        }
+      const tokenUsage = payload.token_usage;
+      if (!tokenUsage) continue;
+      if (!tokenUsage.input_other && !tokenUsage.output) continue;
 
-        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;
+      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,
+      });
     }
   }