@vibe-cafe/vibe-usage 0.7.7 → 0.7.8

package/README.md

@@ -57,7 +57,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Kimi Code | `~/.kimi/sessions/` |
 | Amp | `~/.local/share/amp/threads/` |
 | Droid | `~/.factory/sessions/` |
-| Hermes | `~/.hermes/state.db` (SQLite) |
+| Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
 
 ## How It Works
 

package/package.json

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

package/src/parsers/hermes.js

@@ -1,95 +1,129 @@
 import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
 
 const HERMES_HOME = process.env.HERMES_HOME || join(homedir(), '.hermes');
-const DB_PATH = join(HERMES_HOME, 'state.db');
 
 /**
- * Parse Hermes Agent usage data from its SQLite database (~/.hermes/state.db).
+ * Parse Hermes Agent usage data from its SQLite databases.
+ *
+ * Hermes supports multiple profiles — the default profile lives at
+ * ~/.hermes/state.db, while named profiles live at ~/.hermes/profiles/<name>/state.db.
+ * Each profile is an independent HERMES_HOME with its own state.db, so we scan all of them.
  *
  * Token buckets come from the sessions table (cumulative per-session totals).
  * Session timing comes from the messages table (per-message role + timestamp).
  */
 export async function parse() {
-  if (!existsSync(DB_PATH)) return { buckets: [], sessions: [] };
-
-  let sessionRows;
-  try {
-    sessionRows = queryDb(`SELECT
-      id,
-      model,
-      started_at as startedAt,
-      input_tokens as inputTokens,
-      output_tokens as outputTokens,
-      cache_read_tokens as cacheReadTokens,
-      reasoning_tokens as reasoningTokens
-      FROM sessions
-      WHERE input_tokens > 0 OR output_tokens > 0`);
-  } catch (err) {
-    if (err.message && err.message.includes('ENOENT')) {
-      throw new Error('sqlite3 CLI not found. Install sqlite3 to sync Hermes data.');
-    }
-    throw err;
-  }
+  const dbs = discoverDbPaths(HERMES_HOME);
+  if (dbs.length === 0) return { buckets: [], sessions: [] };
 
   const entries = [];
-  for (const row of sessionRows) {
-    // started_at is a Unix timestamp (float)
-    const timestamp = new Date(row.startedAt * 1000);
-    if (isNaN(timestamp.getTime())) continue;
-
-    // Hermes stores input_tokens exclusive of cache (Anthropic-style semantics)
-    entries.push({
-      source: 'hermes',
-      model: row.model || 'unknown',
-      project: 'unknown',
-      timestamp,
-      inputTokens: row.inputTokens || 0,
-      outputTokens: row.outputTokens || 0,
-      cachedInputTokens: row.cacheReadTokens || 0,
-      reasoningOutputTokens: row.reasoningTokens || 0,
-    });
-  }
+  const sessionEvents = [];
 
-  // Session events from messages table for active time calculation
-  let messageRows;
-  try {
-    messageRows = queryDb(`SELECT
-      session_id as sessionId,
-      role,
-      timestamp
-      FROM messages
-      WHERE role IN ('user', 'assistant')
-      ORDER BY timestamp`);
-  } catch {
-    // Messages query failed — return buckets only
-    return { buckets: aggregateToBuckets(entries), sessions: [] };
-  }
+  for (const { path: dbPath, profile } of dbs) {
+    let sessionRows;
+    try {
+      sessionRows = queryDb(dbPath, `SELECT
+        id,
+        model,
+        started_at as startedAt,
+        input_tokens as inputTokens,
+        output_tokens as outputTokens,
+        cache_read_tokens as cacheReadTokens,
+        reasoning_tokens as reasoningTokens
+        FROM sessions
+        WHERE input_tokens > 0 OR output_tokens > 0`);
+    } catch (err) {
+      if (err.message && err.message.includes('ENOENT')) {
+        throw new Error('sqlite3 CLI not found. Install sqlite3 to sync Hermes data.');
+      }
+      throw err;
+    }
 
-  const sessionEvents = [];
-  for (const row of messageRows) {
-    const timestamp = new Date(row.timestamp * 1000);
-    if (isNaN(timestamp.getTime())) continue;
-
-    sessionEvents.push({
-      sessionId: row.sessionId,
-      source: 'hermes',
-      project: 'unknown',
-      timestamp,
-      role: row.role === 'user' ? 'user' : 'assistant',
-    });
+    for (const row of sessionRows) {
+      // started_at is a Unix timestamp (float)
+      const timestamp = new Date(row.startedAt * 1000);
+      if (isNaN(timestamp.getTime())) continue;
+
+      // Hermes stores input_tokens exclusive of cache (Anthropic-style semantics)
+      entries.push({
+        source: 'hermes',
+        model: row.model || 'unknown',
+        project: profile,
+        timestamp,
+        inputTokens: row.inputTokens || 0,
+        outputTokens: row.outputTokens || 0,
+        cachedInputTokens: row.cacheReadTokens || 0,
+        reasoningOutputTokens: row.reasoningTokens || 0,
+      });
+    }
+
+    let messageRows;
+    try {
+      messageRows = queryDb(dbPath, `SELECT
+        session_id as sessionId,
+        role,
+        timestamp
+        FROM messages
+        WHERE role IN ('user', 'assistant')
+        ORDER BY timestamp`);
+    } catch {
+      // Messages query failed for this profile — skip its session events
+      continue;
+    }
+
+    for (const row of messageRows) {
+      const timestamp = new Date(row.timestamp * 1000);
+      if (isNaN(timestamp.getTime())) continue;
+
+      sessionEvents.push({
+        sessionId: row.sessionId,
+        source: 'hermes',
+        project: profile,
+        timestamp,
+        role: row.role === 'user' ? 'user' : 'assistant',
+      });
+    }
   }
 
   return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
 }
 
-function queryDb(sql) {
+function discoverDbPaths(home) {
+  const dbs = [];
+
+  const defaultDb = join(home, 'state.db');
+  if (existsSync(defaultDb)) dbs.push({ path: defaultDb, profile: 'default' });
+
+  const profilesDir = join(home, 'profiles');
+  if (existsSync(profilesDir)) {
+    let entries;
+    try {
+      entries = readdirSync(profilesDir, { withFileTypes: true });
+    } catch {
+      return dbs;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const profileDb = join(profilesDir, entry.name, 'state.db');
+      try {
+        if (statSync(profileDb).isFile()) dbs.push({ path: profileDb, profile: entry.name });
+      } catch {
+        // missing or unreadable — skip
+      }
+    }
+  }
+
+  return dbs;
+}
+
+function queryDb(dbPath, sql) {
   const output = execFileSync('sqlite3', [
     '-json',
-    DB_PATH,
+    dbPath,
     sql,
   ], { encoding: 'utf-8', maxBuffer: 100 * 1024 * 1024, timeout: 30000 });