@vibe-cafe/vibe-usage 0.10.29 → 0.10.30

package/README.md

@@ -38,7 +38,7 @@ npx @vibe-cafe/vibe-usage init         # Re-run setup via browser login (also ho
 npx @vibe-cafe/vibe-usage init --manual-key <vbu_...>   # Skip browser, use pre-issued key (CI/headless)
 npx @vibe-cafe/vibe-usage sync         # Manual sync
 npx @vibe-cafe/vibe-usage sync --extra-codex-home /path/to/.codex  # Add another Codex Home for this run only
-npx @vibe-cafe/vibe-usage summary       # Print last 7 days as markdown (cost / tokens / by model / by project)
+npx @vibe-cafe/vibe-usage summary       # Print last 7 days as markdown (cost / tokens / by tool / by model / by project)
 npx @vibe-cafe/vibe-usage summary --days N  # Same, over the last N days (1-90)
 npx @vibe-cafe/vibe-usage daemon       # Continuous sync (every 30m, foreground)
 npx @vibe-cafe/vibe-usage daemon install    # Install background service (systemd/launchd/Task Scheduler)
@@ -84,7 +84,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads V0–V3 logs, including `session.v3.jsonl.zstd` from DSH `0.1.5-alpha.2`, with multi-frame Zstandard support (Node ≥ 22.15 built-in, `zstd` CLI fallback) and plain JSONL support. Each session uses its highest `session[.vN].jsonl[.zstd]` generation once, so frozen pre-migration logs are not double-counted. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Fork history uses V0/V1 `seedLength` or V2/V3's last `session/end-seed` tagged `inherited: true`, and is skipped only when the parent copy confirms it; missing parents retain the sole local history. Unknown versions warn and protect sync state. |
 | Hermes (CLI / Desktop) | `<home>/state.db` + `<home>/profiles/<name>/state.db` (SQLite, multi-profile). Home: `$HERMES_HOME`, otherwise `~/.hermes` on macOS/Linux or `%LOCALAPPDATA%\hermes` on Windows (falls back to an existing `~/.hermes` only when the Windows native root is absent). Cache writes join input; reasoning is separated from inclusive output. Usage is currently a cumulative session total attributed to session start: a session spanning several days does **not** yet provide an accurate daily breakdown. |
 | Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` whole-credit deltas as `kiro-credits` (floored cumulative diff — the server stores token counts as bigint); legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
-| Cline | Standalone `~/.cline/` plus `<host>/User/globalStorage/saoudrizwan.claude-dev/` across VSCode-fork hosts; migrated copies are deduplicated and empty leftover extension stores no longer count as installed |
+| Cline | Current CLI/SDK `~/.cline/data/sessions/*/*.messages.json` plus legacy `~/.cline/{,data/}state/taskHistory.json` and editor extension stores. Honors `CLINE_DIR`, `CLINE_DATA_DIR`, and `CLINE_SESSION_DATA_DIR`; copied history is deduplicated |
 | Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |
 | Trae CLI | macOS: `~/Library/Caches/trae-cli/sessions/`; Windows: `%LOCALAPPDATA%/trae-cli/cache/sessions/`; Linux: `~/.cache/trae-cli/sessions/` (CLI telemetry only; Trae IDE/Trae Work chats are not supported). Token usage is summed per unique LLM call (`model.stream.eino`, plus `model.generate` failovers); nested duplicate spans that share a session `traceID` are not max-merged. `traces.jsonl` / `events.jsonl` are streamed line-by-line so a multi-hundred-MB events file cannot hit Node's string-length limit. |
 | Antigravity | Scans App 2.0 `~/.gemini/antigravity/conversations/`, `agy` CLI `~/.gemini/antigravity-cli/conversations/`, and standalone IDE `~/.gemini/antigravity-ide/conversations/`. `.db` stores, including the same paths below explicitly added alternate Homes, are parsed offline (tokens, model, project, sessions). When Gemini blobs omit `chatStartMetadata.createdAt` or `modelDisplayName`, timestamps fall back to `steps.metadata` and model names to `responseModel`. `.pb` history in the default stores requires the corresponding App/IDE language server to be running; when several servers are open, the parser tries the others for unreadable conversations. Unavailable legacy history produces a warning and preserves prior sync state. |

package/package.json

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

package/src/cline-roots.js

@@ -1,18 +1,10 @@
-import { statSync } from 'node:fs';
+import { realpathSync, statSync } from 'node:fs';
 import { delimiter, join } from 'node:path';
 import { homedir } from 'node:os';
 
 const EXTENSION_ID = 'saoudrizwan.claude-dev';
 const HOSTS = ['Code', 'Cursor', 'Windsurf', 'VSCodium', 'Code - Insiders', 'Trae', 'Trae CN'];
 
-function hasTaskHistory(root) {
-  try {
-    return statSync(join(root, 'state', 'taskHistory.json')).isFile();
-  } catch {
-    return false;
-  }
-}
-
 function hostRoots() {
   const out = [];
   if (process.platform === 'darwin') {
@@ -28,13 +20,50 @@ function hostRoots() {
   return out;
 }
 
-export function findClineDataDirs() {
+/** Both legacy stores and the shared Cline 3.x CLI/extension SDK store. */
+export function findClineStores({ onWarning = () => {} } = {}) {
+  function isPath(path, directory = false) {
+    try {
+      const stat = statSync(path);
+      return directory ? stat.isDirectory() : stat.isFile();
+    } catch (err) {
+      if (err.code !== 'ENOENT' && err.code !== 'ENOTDIR') {
+        onWarning(`cline: 无法读取数据目录 ${path}: ${err.message}`);
+      }
+      return false;
+    }
+  }
+  function unique(paths) {
+    const seen = new Set();
+    return paths.filter(path => {
+      let key;
+      try { key = realpathSync(path); } catch { key = path; }
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
   const override = process.env.VIBE_USAGE_CLINE_DIRS?.trim();
-  const candidates = override
-    ? override.split(delimiter).map((value) => value.trim()).filter(Boolean)
-    : [
-        join(homedir(), '.cline'),
-        ...hostRoots().map((root) => join(root, 'User', 'globalStorage', EXTENSION_ID)),
-      ];
-  return [...new Set(candidates)].filter(hasTaskHistory);
+  const home = join(homedir(), '.cline');
+  const configuredHome = process.env.CLINE_DIR?.trim() || home;
+  const dataDir = process.env.CLINE_DATA_DIR?.trim() || join(configuredHome, 'data');
+  const roots = override
+    ? override.split(delimiter).map(value => value.trim()).filter(Boolean)
+    : [home, configuredHome, dataDir,
+        ...hostRoots().map(root => join(root, 'User', 'globalStorage', EXTENSION_ID))];
+  // Accept either a Cline home or its data directory. Keep the old standalone
+  // and editor stores so upgrading the runtime does not discard old history.
+  const dataRoots = unique(roots.flatMap(root => [root, join(root, 'data')]));
+  const legacyRoots = dataRoots.filter(root => isPath(join(root, 'state', 'taskHistory.json')));
+  const sessionDirs = override
+    ? dataRoots.map(root => join(root, 'sessions'))
+    : [...dataRoots.map(root => join(root, 'sessions')),
+        process.env.CLINE_SESSION_DATA_DIR?.trim()].filter(Boolean);
+  const sdkSessionDirs = unique(sessionDirs).filter(dir => isPath(dir, true));
+  return { legacyRoots: unique(legacyRoots), sdkSessionDirs };
+}
+
+export function findClineDataDirs() {
+  const { legacyRoots, sdkSessionDirs } = findClineStores();
+  return [...legacyRoots, ...sdkSessionDirs];
 }

package/src/daemon-service.js

@@ -115,6 +115,9 @@ function escapeXml(value) {
 // launchd/systemd unit that inherits nothing, so anything the parsers read for
 // discovery has to be captured into the unit at install time.
 const PRESERVED_SERVICE_ENV = [
+  'CLINE_DIR',
+  'CLINE_DATA_DIR',
+  'CLINE_SESSION_DATA_DIR',
   'COLA_DATA_DIR',
   'HERMES_HOME',
   'MCODE_HOME',

package/src/index.js

@@ -252,7 +252,7 @@ const FULL_HELP = `
     ${BARE} init --manual-key <vbu_...>   Skip browser, use a pre-issued key (CI/headless)
     ${BARE} sync         Manually sync usage data
     ${BARE} sync --extra-codex-home <path>  Use another Codex Home for this run
-    ${BARE} summary       Print last 7 days as markdown (cost/tokens/model/project)
+    ${BARE} summary       Print last 7 days as markdown (cost/tokens/tool/model/project)
     ${BARE} summary --days N   Same, but over the last N days (1-90)
     ${BARE} daemon       Continuous sync (every 30m, foreground)
     ${BARE} daemon install    Install background service (systemd/launchd/Task Scheduler)

package/src/parsers/cline-sdk.js

@@ -0,0 +1,106 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { projectFromCwd, toCount } from './fs-utils.js';
+
+// Verified with the shipped cline 3.0.61 / @cline/core 0.0.82. SQLite is only
+// the session index: per-call accounting lives in version-1 messages artifacts.
+// Read canonical artifacts, not DB prompt/metadata columns or provider settings.
+export function readClineSdk(sessionDirs, onWarning) {
+  const copies = [];
+  for (const dir of sessionDirs) {
+    let children;
+    try { children = readdirSync(dir, { withFileTypes: true }); }
+    catch (err) { onWarning(`cline: 无法读取会话目录 ${dir}: ${err.message}`); continue; }
+    for (const child of children) {
+      if (!child.isDirectory()) continue;
+      const sessionDir = join(dir, child.name);
+      let files, manifest;
+      try {
+        files = readdirSync(sessionDir, { withFileTypes: true })
+          .filter(file => file.isFile() && file.name.endsWith('.messages.json'));
+        if (!files.length) continue;
+        manifest = JSON.parse(readFileSync(join(sessionDir, `${child.name}.json`), 'utf8'));
+        if (manifest?.version !== 1 || manifest.session_id !== child.name) {
+          throw new Error('unsupported or inconsistent Cline session manifest');
+        }
+      } catch (err) {
+        onWarning(`cline: 无法读取会话目录 ${sessionDir}: ${err.message}`);
+        continue;
+      }
+      for (const file of files) {
+        const messagesPath = join(sessionDir, file.name);
+        try {
+          const payload = JSON.parse(readFileSync(messagesPath, 'utf8'));
+          if (payload?.version !== 1 || !Array.isArray(payload.messages)
+            || typeof payload.sessionId !== 'string'
+            || (payload.sessionId !== child.name && payload.origin?.parentThreadId !== child.name)) {
+            throw new Error('unsupported or inconsistent Cline session artifact');
+          }
+          const project = projectFromCwd(manifest.workspace_root || manifest.cwd);
+          // Reduce immediately to accounting/timing metadata. No prompt, response,
+          // system prompt, tool arguments, credentials, or stored costs survive.
+          const messages = payload.messages.flatMap(message => {
+            if (!message || !['user', 'assistant'].includes(message.role)) return [];
+            if (message.role === 'user' && (payload.agent !== 'lead'
+              || message.metadata?.kind || message.metadata?.userRunSpan === 0
+              || ['system', 'status', 'error', 'tool'].includes(message.metadata?.displayRole)
+              || (Array.isArray(message.content) && message.content.some(block =>
+                block?.type === 'tool_result' || block?.type === 'tool-result')))) return [];
+            if (typeof message.ts !== 'number' || !Number.isFinite(message.ts)
+              || !Number.isFinite(new Date(message.ts).getTime())) return [];
+            // Legacy migration inserts a cumulative metric on an old assistant
+            // without a timestamp. Never re-date that summary to the migration.
+            const metric = message.role === 'assistant' ? message.metrics : null;
+            const input = toCount(metric?.inputTokens);
+            const cachedInputTokens = Math.min(input, toCount(metric?.cacheReadTokens));
+            return [{
+              id: typeof message.id === 'string' ? message.id : null,
+              role: message.role,
+              timestamp: message.ts,
+              model: message.modelInfo?.id || manifest.model || 'cline-unknown',
+              inputTokens: input - cachedInputTokens,
+              outputTokens: toCount(metric?.outputTokens),
+              cachedInputTokens,
+            }];
+          });
+          copies.push({ sessionId: child.name, artifactId: payload.sessionId, project, messages,
+            // Restored/forked artifacts retain message ids/timestamps; attribute
+            // shared history to the earliest original session deterministically.
+            started: Date.parse(manifest.started_at) || 0, messagesPath });
+        } catch (err) {
+          onWarning(`cline: 无法读取会话 ${messagesPath}: ${err.message}`);
+        }
+      }
+    }
+  }
+  copies.sort((a, b) => a.started - b.started
+    || a.sessionId.localeCompare(b.sessionId) || a.messagesPath.localeCompare(b.messagesPath));
+  const records = new Map();
+  for (const copy of copies) {
+    copy.messages.forEach((message, index) => {
+      // Anonymous messages can be deduplicated only within copies of this
+      // logical session; equal usage in unrelated sessions remains distinct.
+      const identity = message.id || `${copy.artifactId}:${index}`;
+      const key = JSON.stringify([identity, message.role, message.timestamp]);
+      const next = { ...message, sessionId: copy.sessionId, project: copy.project };
+      const old = records.get(key);
+      const count = value => value.inputTokens + value.outputTokens + value.cachedInputTokens;
+      if (!old) records.set(key, next);
+      else if (count(next) > count(old)) {
+        records.set(key, { ...next, sessionId: old.sessionId, project: old.project });
+      }
+    });
+  }
+  const entries = [], events = [];
+  for (const message of records.values()) {
+    const base = { source: 'cline', project: message.project, timestamp: new Date(message.timestamp) };
+    if (message.role === 'assistant'
+      && message.inputTokens + message.outputTokens + message.cachedInputTokens > 0) {
+      entries.push({ ...base, model: message.model, inputTokens: message.inputTokens,
+        outputTokens: message.outputTokens, cachedInputTokens: message.cachedInputTokens,
+        reasoningOutputTokens: 0 });
+    }
+    events.push({ ...base, sessionId: message.sessionId, role: message.role });
+  }
+  return { entries, events };
+}

package/src/parsers/cline.js

@@ -2,11 +2,13 @@ import { statSync } from 'node:fs';
 import { join } from 'node:path';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { readJsonSafe, projectFromPath } from './fs-utils.js';
-import { findClineDataDirs } from '../cline-roots.js';
+import { findClineStores } from '../cline-roots.js';
+import { readClineSdk } from './cline-sdk.js';
 
 export async function parse() {
-  const extDirs = findClineDataDirs();
-  if (extDirs.length === 0) return { buckets: [], sessions: [] };
+  const warnings = [];
+  const onWarning = message => warnings.push(message);
+  const { legacyRoots: extDirs, sdkSessionDirs } = findClineStores({ onWarning });
 
   const entries = [];
   const events = [];
@@ -88,5 +90,8 @@ export async function parse() {
       }
   }
 
-  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(events) };
+  const sdk = readClineSdk(sdkSessionDirs, onWarning);
+  if (warnings.length) return { buckets: [], sessions: [], skipped: true, warnings };
+  return { buckets: aggregateToBuckets([...entries, ...sdk.entries]),
+    sessions: extractSessions([...events, ...sdk.events]) };
 }

package/src/summary.js

@@ -1,6 +1,12 @@
 import { loadConfig } from './config.js';
 import { getJson } from './api.js';
 import { failure } from './output.js';
+import { TOOLS } from './tools.js';
+
+// Server-side source ids are raw slugs ('claude-code'); TOOLS carries the
+// display names. A source the server knows but this CLI doesn't parse falls
+// back to its id rather than disappearing from the table.
+const TOOL_NAMES = new Map(TOOLS.map(t => [t.id, t.name]));
 
 export async function runSummary(args = []) {
   const days = parseDays(args);
@@ -36,7 +42,7 @@ function parseDays(args) {
   return v;
 }
 
-function render(data, days, apiUrl) {
+export function render(data, days, apiUrl) {
   const buckets = Array.isArray(data?.buckets) ? data.buckets : [];
   const sessions = Array.isArray(data?.sessions) ? data.sessions : [];
   const dashboard = `${apiUrl}/usage`;
@@ -47,6 +53,7 @@ function render(data, days, apiUrl) {
 
   let totalCost = 0;
   let totalTokens = 0;
+  const bySource = new Map();
   const byModel = new Map();
   const byProject = new Map();
 
@@ -55,6 +62,7 @@ function render(data, days, apiUrl) {
     const tokens = Number(b.totalTokens ?? 0);
     totalCost += cost;
     totalTokens += tokens;
+    accumulate(bySource, b.source || 'unknown', { cost, tokens });
     accumulate(byModel, b.model, { cost, tokens });
     accumulate(byProject, b.project || 'unknown', { cost, tokens, sessions: 0 });
   }
@@ -74,6 +82,16 @@ function render(data, days, apiUrl) {
   lines.push(`**总览**: $${totalCost.toFixed(2)} · ${formatTokens(totalTokens)} tokens · ${sessionsCount} sessions · ${activeHours.toFixed(1)}h active`);
   lines.push('');
 
+  lines.push('## 按工具');
+  lines.push('');
+  lines.push('| 工具 | 费用 | Tokens | 占比 |');
+  lines.push('|---|---:|---:|---:|');
+  for (const [source, { cost, tokens }] of topN(bySource, 'cost', 8)) {
+    const pct = totalCost > 0 ? ((cost / totalCost) * 100).toFixed(0) : '0';
+    lines.push(`| ${TOOL_NAMES.get(source) || source} | $${cost.toFixed(2)} | ${formatTokens(tokens)} | ${pct}% |`);
+  }
+  lines.push('');
+
   lines.push('## 按模型');
   lines.push('');
   lines.push('| 模型 | 费用 | Tokens | 占比 |');