@vibe-cafe/vibe-usage 0.6.5 → 0.6.8

package/README.md

@@ -22,6 +22,8 @@ npx @vibe-cafe/vibe-usage sync         # Manual sync
 npx @vibe-cafe/vibe-usage daemon       # Continuous sync (every 5 minutes)
 npx @vibe-cafe/vibe-usage reset        # Delete all data and re-upload from local logs
 npx @vibe-cafe/vibe-usage reset --local  # Delete this host's data only and re-upload
+npx @vibe-cafe/vibe-usage skill         # Install skill for AI coding assistants
+npx @vibe-cafe/vibe-usage skill --remove  # Remove installed skills
 npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 ```
 
@@ -35,18 +37,41 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Gemini CLI | `~/.gemini/tmp/` |
 | OpenCode | `~/.local/share/opencode/opencode.db` (SQLite, `json_extract` query) |
 | OpenClaw | `~/.openclaw/agents/` |
+| pi | `~/.pi/agent/sessions/` |
 | Qwen Code | `~/.qwen/tmp/` |
 | Kimi Code | `~/.kimi/sessions/` |
+| Amp | `~/.local/share/amp/threads/` |
+| Droid | `~/.factory/sessions/` |
 
 ## How It Works
 
 - Parses local session logs from each AI coding tool
 - Aggregates token usage into 30-minute buckets
-- Extracts session metadata from all 8 parsers: active time (AI generation time, excluding queue/TTFT wait), total duration, message counts
+- Extracts session metadata from all 10 parsers: active time (AI generation time, excluding queue/TTFT wait), total duration, message counts
 - Uploads buckets + sessions to your vibecafe.ai dashboard
 - Stateless: computes full totals from local logs each sync (idempotent, no state files)
 - For continuous syncing, use `npx @vibe-cafe/vibe-usage daemon` or the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app)
 
+## AI Skill
+
+Install vibe-usage as a skill for your AI coding assistant, so it knows how to sync usage data on your behalf:
+
+```bash
+npx @vibe-cafe/vibe-usage skill
+```
+
+This auto-detects installed AI tools (Claude Code, Cursor, Windsurf, Codex CLI) and writes a `SKILL.md` to each tool's global skills directory. To remove:
+
+```bash
+npx @vibe-cafe/vibe-usage skill --remove
+```
+
+You can also install via the [open skills ecosystem](https://github.com/vercel-labs/skills):
+
+```bash
+npx skills add vibe-cafe/vibe-usage
+```
+
 ## Development
 
 Test against a local vibe-cafe dev server without publishing:

package/package.json

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

package/src/index.js

@@ -113,6 +113,11 @@ export async function run(args) {
       await runDaemon();
       break;
     }
+    case 'skill': {
+      const { runSkill } = await import('./skill.js');
+      await runSkill(args.slice(1));
+      break;
+    }
     case 'config': {
       handleConfig(args.slice(1));
       break;
@@ -134,6 +139,8 @@ export async function run(args) {
     npx @vibe-cafe/vibe-usage daemon       Continuous sync (every 5m)
     npx @vibe-cafe/vibe-usage reset        Delete all data and re-upload
     npx @vibe-cafe/vibe-usage reset --local  Delete data for this host only and re-upload
+    npx @vibe-cafe/vibe-usage skill         Install skill for AI coding tools
+    npx @vibe-cafe/vibe-usage skill --remove  Remove installed skills
     npx @vibe-cafe/vibe-usage status       Show config and detected tools
     npx @vibe-cafe/vibe-usage config show  Show full config as JSON
     npx @vibe-cafe/vibe-usage config get <key>   Get a config value

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

package/src/parsers/pi-coding-agent.js

@@ -0,0 +1,144 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+/**
+ * pi-coding-agent parser.
+ * Reads JSONL session files from ~/.pi/agent/sessions/ (or $PI_CODING_AGENT_DIR/sessions/).
+ *
+ * Session file layout:
+ *   sessions/<encoded-cwd>/{timestamp}_{sessionId}.jsonl
+ *
+ * Each JSONL line is a session entry:
+ *   - type "session": header with id, cwd, version
+ *   - type "message": contains message object with role, usage, model, timestamp
+ *   - type "model_change", "compaction", etc.: metadata (ignored for usage)
+ *
+ * Assistant messages carry per-message token usage:
+ *   message.usage = { input, output, cacheRead, cacheWrite, totalTokens }
+ */
+
+function getSessionsDir() {
+  const envDir = process.env.PI_CODING_AGENT_DIR;
+  if (envDir) return join(envDir, 'sessions');
+  return join(homedir(), '.pi', 'agent', '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')) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+    // ignore unreadable directories
+  }
+  return results;
+}
+
+function extractProjectFromCwd(cwd) {
+  if (!cwd) return 'unknown';
+  const parts = cwd.replace(/\\/g, '/').split('/').filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : 'unknown';
+}
+
+function extractProjectFromDir(filePath, sessionsDir) {
+  const relative = filePath.slice(sessionsDir.length + 1);
+  const firstSeg = relative.split('/')[0] || relative.split('\\')[0];
+  if (!firstSeg) return 'unknown';
+  const parts = firstSeg.split('-').filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : 'unknown';
+}
+
+export async function parse() {
+  const sessionsDir = getSessionsDir();
+  const entries = [];
+  const sessionEvents = [];
+  const seenEntryIds = new Set();
+
+  const sessionFiles = findJsonlFiles(sessionsDir);
+
+  for (const filePath of sessionFiles) {
+    let content;
+    try {
+      content = readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    let sessionId = basename(filePath, '.jsonl');
+    let project = extractProjectFromDir(filePath, sessionsDir);
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+
+      let obj;
+      try {
+        obj = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      if (obj.type === 'session') {
+        if (obj.id) sessionId = obj.id;
+        if (obj.cwd) project = extractProjectFromCwd(obj.cwd);
+        continue;
+      }
+
+      if (obj.type !== 'message') continue;
+
+      const msg = obj.message;
+      if (!msg) continue;
+
+      let ts;
+      if (obj.timestamp) {
+        ts = new Date(obj.timestamp);
+      } else if (msg.timestamp) {
+        ts = new Date(msg.timestamp);
+      }
+      if (!ts || isNaN(ts.getTime())) continue;
+
+      if (msg.role === 'user' || msg.role === 'assistant' || msg.role === 'toolResult') {
+        sessionEvents.push({
+          sessionId,
+          source: 'pi-coding-agent',
+          project,
+          timestamp: ts,
+          role: msg.role === 'user' ? 'user' : 'assistant',
+        });
+      }
+
+      if (msg.role !== 'assistant') continue;
+      if (!msg.usage) continue;
+
+      const usage = msg.usage;
+      if (usage.input == null && usage.output == null) continue;
+
+      const entryId = obj.id;
+      if (entryId) {
+        if (seenEntryIds.has(entryId)) continue;
+        seenEntryIds.add(entryId);
+      }
+
+      entries.push({
+        source: 'pi-coding-agent',
+        model: msg.model || 'unknown',
+        project,
+        timestamp: ts,
+        inputTokens: usage.input || 0,
+        outputTokens: usage.output || 0,
+        cachedInputTokens: usage.cacheRead || 0,
+        reasoningOutputTokens: 0,
+      });
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}

package/src/skill.js

@@ -0,0 +1,134 @@
+import { existsSync, mkdirSync, writeFileSync, unlinkSync, rmdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const SKILL_TARGETS = [
+  {
+    name: 'Claude Code',
+    detectDir: join(homedir(), '.claude'),
+    skillDir: join(homedir(), '.claude', 'skills', 'vibe-usage'),
+  },
+  {
+    name: 'Codex CLI',
+    detectDir: join(homedir(), '.codex'),
+    skillDir: join(homedir(), '.codex', 'skills', 'vibe-usage'),
+  },
+  {
+    name: 'Cursor',
+    detectDir: join(homedir(), '.cursor'),
+    skillDir: join(homedir(), '.cursor', 'skills', 'vibe-usage'),
+  },
+  {
+    name: 'Windsurf',
+    detectDir: join(homedir(), '.codeium', 'windsurf'),
+    skillDir: join(homedir(), '.codeium', 'windsurf', 'skills', 'vibe-usage'),
+  },
+];
+
+function tildePath(absPath) {
+  const home = homedir();
+  return absPath.startsWith(home) ? absPath.replace(home, '~') : absPath;
+}
+
+const SKILL_CONTENT = `---
+name: vibe-usage
+description: Track and sync AI coding tool token usage to vibecafe.ai dashboard.
+---
+
+# Vibe Usage
+
+Track your AI coding tool token usage and sync to [vibecafe.ai](https://vibecafe.ai/usage).
+
+## Setup
+
+First-time setup (interactive — asks for API key):
+
+\`\`\`bash
+npx @vibe-cafe/vibe-usage
+\`\`\`
+
+Get your API key at https://vibecafe.ai/usage/setup
+
+## Commands
+
+When the user asks to sync usage, check costs, or track tokens, run:
+
+\`\`\`bash
+npx @vibe-cafe/vibe-usage sync
+\`\`\`
+
+Other available commands:
+
+| Command | Description |
+|---------|-------------|
+| \`npx @vibe-cafe/vibe-usage sync\` | Sync latest usage data |
+| \`npx @vibe-cafe/vibe-usage status\` | Show config and detected tools |
+| \`npx @vibe-cafe/vibe-usage daemon\` | Continuous sync every 5 minutes |
+| \`npx @vibe-cafe/vibe-usage reset\` | Delete all data and re-upload |
+| \`npx @vibe-cafe/vibe-usage reset --local\` | Delete this host's data and re-upload |
+
+## When to Use
+
+- User says "sync my usage", "upload usage", "track tokens"
+- User asks "how much have I spent?", "what's my cost?"
+- User wants to check if sync is working: run \`status\`
+- User wants continuous background sync: run \`daemon\`
+
+## Notes
+
+- Requires initial setup with an API key (run \`npx @vibe-cafe/vibe-usage\` first)
+- Config is stored at \`~/.vibe-usage/config.json\`
+- Supports: Claude Code, Codex CLI, Copilot CLI, Gemini CLI, OpenCode, OpenClaw, Qwen Code, Kimi Code, Amp, Droid
+`;
+
+export async function runSkill(args = []) {
+  const remove = args.includes('--remove');
+
+  console.log('\nvibe-usage skill\n');
+
+  console.log('  AI coding tools:');
+  for (const t of SKILL_TARGETS) {
+    const found = existsSync(t.detectDir);
+    console.log(`    ${found ? '\u2713' : '\u2717'} ${t.name}`);
+  }
+  console.log();
+
+  const detected = SKILL_TARGETS.filter(t => existsSync(t.detectDir));
+
+  if (detected.length === 0) {
+    console.log('  No supported tools detected. Nothing to do.\n');
+    return;
+  }
+
+  if (remove) {
+    let removed = 0;
+    for (const t of detected) {
+      const skillFile = join(t.skillDir, 'SKILL.md');
+      if (existsSync(skillFile)) {
+        unlinkSync(skillFile);
+        try { rmdirSync(t.skillDir); } catch {}
+        console.log(`  Removed: ${tildePath(skillFile)}`);
+        removed++;
+      }
+    }
+    if (removed === 0) {
+      console.log('  No skills installed to remove.\n');
+    } else {
+      console.log(`\n  Removed vibe-usage skill from ${removed} tool${removed > 1 ? 's' : ''}.\n`);
+    }
+    return;
+  }
+
+  let installed = 0;
+  for (const t of detected) {
+    const skillFile = join(t.skillDir, 'SKILL.md');
+    mkdirSync(t.skillDir, { recursive: true });
+    writeFileSync(skillFile, SKILL_CONTENT, 'utf-8');
+    console.log(`  Installed: ${tildePath(skillFile)}`);
+    installed++;
+  }
+
+  console.log(`\n  Installed vibe-usage skill for ${installed} tool${installed > 1 ? 's' : ''}.\n`);
+  console.log('  Your AI coding assistant now knows how to sync usage data.');
+  console.log('  Try asking: "sync my vibe usage" or "how much have I spent?"\n');
+}

package/src/tools.js

@@ -33,6 +33,11 @@ export const TOOLS = [
     id: 'openclaw',
     dataDir: join(homedir(), '.openclaw', 'agents'),
   },
+  {
+    name: 'pi',
+    id: 'pi-coding-agent',
+    dataDir: join(homedir(), '.pi', 'agent', 'sessions'),
+  },
   {
     name: 'Qwen Code',
     id: 'qwen-code',
@@ -43,6 +48,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() {