@vibe-cafe/vibe-usage 0.6.5 → 0.6.6

package/package.json

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

package/src/parsers/amp.js

@@ -0,0 +1,144 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+function resolveThreadsDir() {
+  if (process.env.AMP_DATA_DIR) return process.env.AMP_DATA_DIR;
+  if (process.env.XDG_DATA_HOME) return join(process.env.XDG_DATA_HOME, 'amp', 'threads');
+  return join(homedir(), '.local', 'share', 'amp', 'threads');
+}
+
+function findThreadFiles(dir) {
+  const results = [];
+  if (!existsSync(dir)) return results;
+
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findThreadFiles(fullPath));
+      } else if (entry.isFile() && entry.name.startsWith('T-') && entry.name.endsWith('.json')) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+
+  return results;
+}
+
+function setMessageTimestamp(map, messageId, timestamp) {
+  if (!Number.isInteger(messageId)) return;
+  const current = map.get(messageId);
+  if (!current || timestamp < current) {
+    map.set(messageId, timestamp);
+  }
+}
+
+function buildMessageTimestampMap(events) {
+  const map = new Map();
+  if (!Array.isArray(events)) return map;
+
+  for (const event of events) {
+    const ts = new Date(event?.timestamp);
+    if (isNaN(ts.getTime())) continue;
+
+    setMessageTimestamp(map, event.fromMessageId, ts);
+    setMessageTimestamp(map, event.toMessageId, ts);
+  }
+
+  return map;
+}
+
+export async function parse() {
+  const threadsDir = resolveThreadsDir();
+  const threadFiles = findThreadFiles(threadsDir);
+  if (threadFiles.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const sessionEvents = [];
+
+  for (const filePath of threadFiles) {
+    let thread;
+    try {
+      thread = JSON.parse(readFileSync(filePath, 'utf-8'));
+    } catch {
+      continue;
+    }
+
+    const sessionId = thread?.id || filePath;
+    const messages = Array.isArray(thread?.messages) ? thread.messages : [];
+    const ledgerEvents = Array.isArray(thread?.usageLedger?.events) ? thread.usageLedger.events : [];
+    const hasLedger = ledgerEvents.length > 0;
+
+    if (hasLedger) {
+      for (const event of ledgerEvents) {
+        const ts = new Date(event?.timestamp);
+        if (isNaN(ts.getTime())) continue;
+
+        const inputTokens = event?.tokens?.input || 0;
+        const outputTokens = event?.tokens?.output || 0;
+        if (inputTokens === 0 && outputTokens === 0) continue;
+
+        const toMessage = Number.isInteger(event.toMessageId) ? messages[event.toMessageId] : null;
+        const cacheReadInputTokens = toMessage?.usage?.cacheReadInputTokens || 0;
+
+        entries.push({
+          source: 'amp',
+          model: event?.model || 'unknown',
+          project: 'unknown',
+          timestamp: ts,
+          inputTokens,
+          outputTokens,
+          cachedInputTokens: cacheReadInputTokens,
+          reasoningOutputTokens: 0,
+        });
+      }
+    } else {
+      for (const message of messages) {
+        const usage = message?.usage;
+        if (!usage) continue;
+
+        const ts = new Date(message?.timestamp || thread?.created);
+        if (isNaN(ts.getTime())) continue;
+
+        const inputTokens = usage.inputTokens || 0;
+        const outputTokens = usage.outputTokens || 0;
+        if (inputTokens === 0 && outputTokens === 0 && (usage.cacheReadInputTokens || 0) === 0) continue;
+
+        entries.push({
+          source: 'amp',
+          model: usage.model || 'unknown',
+          project: 'unknown',
+          timestamp: ts,
+          inputTokens,
+          outputTokens,
+          cachedInputTokens: usage.cacheReadInputTokens || 0,
+          reasoningOutputTokens: 0,
+        });
+      }
+    }
+
+    const messageTsMap = buildMessageTimestampMap(ledgerEvents);
+    const baseTimestamp = new Date(thread?.created);
+    const hasBaseTimestamp = !isNaN(baseTimestamp.getTime());
+
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i];
+      const mappedTs = messageTsMap.get(i);
+      const ts = mappedTs || (hasBaseTimestamp ? baseTimestamp : null);
+      if (!ts || isNaN(ts.getTime())) continue;
+
+      sessionEvents.push({
+        sessionId,
+        source: 'amp',
+        project: 'unknown',
+        timestamp: ts,
+        role: message?.role === 'user' ? 'user' : 'assistant',
+      });
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}

package/src/parsers/droid.js

@@ -0,0 +1,113 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, basename, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+const DROID_SESSIONS_DIR = join(homedir(), '.factory', 'sessions');
+
+function findJsonlFiles(dir) {
+  const results = [];
+  if (!existsSync(dir)) return results;
+
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findJsonlFiles(fullPath));
+      } else if (entry.name.endsWith('.jsonl') && !entry.name.endsWith('.settings.json')) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+
+  return results;
+}
+
+function extractProjectFromSlug(slug) {
+  const parts = slug.split('-').filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : 'unknown';
+}
+
+function toSafeNumber(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : 0;
+}
+
+export async function parse() {
+  const entries = [];
+  const sessionEvents = [];
+  const sessionFiles = findJsonlFiles(DROID_SESSIONS_DIR);
+
+  for (const filePath of sessionFiles) {
+    const sessionId = basename(filePath, '.jsonl');
+    const slug = basename(dirname(filePath));
+    const project = extractProjectFromSlug(slug);
+    let firstMessageTimestamp = null;
+
+    let content;
+    try {
+      content = readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+
+      let obj;
+      try {
+        obj = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      if (obj.type !== 'message') continue;
+      if (!obj.timestamp) continue;
+
+      const ts = new Date(obj.timestamp);
+      if (isNaN(ts.getTime())) continue;
+
+      if (firstMessageTimestamp === null) firstMessageTimestamp = ts;
+
+      sessionEvents.push({
+        sessionId,
+        source: 'droid',
+        project,
+        timestamp: ts,
+        role: obj.message?.role === 'user' ? 'user' : 'assistant',
+      });
+    }
+
+    const settingsPath = join(dirname(filePath), `${sessionId}.settings.json`);
+    if (!existsSync(settingsPath) || firstMessageTimestamp === null) continue;
+
+    let settings;
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    } catch {
+      continue;
+    }
+
+    const tokenUsage = settings?.tokenUsage;
+    if (!tokenUsage) continue;
+
+    const cacheReadTokens = toSafeNumber(tokenUsage.cacheReadTokens);
+    const thinkingTokens = toSafeNumber(tokenUsage.thinkingTokens);
+    const inputTokens = Math.max(0, toSafeNumber(tokenUsage.inputTokens) - cacheReadTokens);
+    const outputTokens = Math.max(0, toSafeNumber(tokenUsage.outputTokens) - thinkingTokens);
+
+    entries.push({
+      source: 'droid',
+      model: settings.model || 'unknown',
+      project,
+      timestamp: firstMessageTimestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens: cacheReadTokens,
+      reasoningOutputTokens: thinkingTokens,
+    });
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}

package/src/parsers/index.js

@@ -7,6 +7,8 @@ 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';
+import { parse as parseAmp } from './amp.js';
+import { parse as parseDroid } from './droid.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
@@ -17,6 +19,8 @@ export const parsers = {
   'openclaw': parseOpenclaw,
   'qwen-code': parseQwenCode,
   'kimi-code': parseKimiCode,
+  'amp': parseAmp,
+  'droid': parseDroid,
 };
 
 

package/src/tools.js

@@ -43,6 +43,16 @@ export const TOOLS = [
     id: 'kimi-code',
     dataDir: join(homedir(), '.kimi', 'sessions'),
   },
+  {
+    name: 'Amp',
+    id: 'amp',
+    dataDir: join(homedir(), '.local', 'share', 'amp', 'threads'),
+  },
+  {
+    name: 'Droid',
+    id: 'droid',
+    dataDir: join(homedir(), '.factory', 'sessions'),
+  },
 ];
 
 export function detectInstalledTools() {