vibe-roast 0.98.0

package/src/sources/cursor.js

@@ -0,0 +1,238 @@
+const cp = require("node:child_process");
+const os = require("node:os");
+const path = require("node:path");
+
+const { isInRange } = require("../lib/dates");
+const { normalizeWhitespace, textFromContent } = require("../extract/text");
+
+function resolveCursorDbPath({ home = os.homedir(), platform = process.platform, env = process.env } = {}) {
+  if (platform === "darwin") {
+    return path.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+  if (platform === "win32") {
+    const appData = env.APPDATA || path.join(home, "AppData", "Roaming");
+    return path.win32.join(appData, "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+  const xdg = env.XDG_CONFIG_HOME || path.join(home, ".config");
+  return path.join(xdg, "Cursor", "User", "globalStorage", "state.vscdb");
+}
+
+async function inspectCursor({ dbPath, range } = {}) {
+  const stateDbPath = dbPath || resolveCursorDbPath();
+  const rows = readCursorRows(stateDbPath);
+  const allEntries = extractCursorEntriesFromRows(rows);
+  const prompts = allEntries.filter((entry) => isInRange(entry.timestamp, range));
+  const tokenTotals = emptyTotals();
+  for (const prompt of prompts) addTotals(tokenTotals, prompt.tokens);
+
+  return {
+    source: "cursor",
+    root: stateDbPath,
+    files_scanned: rows.length > 0 ? 1 : 0,
+    prompt_count: prompts.length,
+    token_totals: tokenTotals,
+    prompts: prompts.map(({ tokens, ...entry }) => entry),
+    notes: buildCursorNotes(rows, prompts),
+  };
+}
+
+function buildCursorNotes(rows, prompts) {
+  if (rows.length === 0) {
+    return [
+      "No readable Cursor SQLite rows found. Install sqlite3 or pass --cursor-db to a readable state.vscdb.",
+    ];
+  }
+  if (prompts.some((prompt) => !prompt.timestamp)) {
+    return [
+      "Cursor bubble rows expose prompt text but not reliable timestamps in the compact local query; date-filtered views omit undated Cursor prompts.",
+    ];
+  }
+  return [];
+}
+
+function readCursorRows(dbPath) {
+  const itemSql =
+    "SELECT key, value FROM ItemTable WHERE key LIKE '%bubble%' OR key LIKE '%composer%' OR key LIKE '%chat%' LIMIT 20000;";
+  const diskSql =
+    "SELECT key, json_object('type', json_extract(value, '$.type'), 'text', json_extract(value, '$.text'), 'timestamp', json_extract(value, '$.timestamp'), 'createdAt', json_extract(value, '$.createdAt')) AS value FROM cursorDiskKV WHERE key LIKE 'bubbleId:%' AND json_extract(value, '$.type') = 1 AND length(COALESCE(json_extract(value, '$.text'), '')) > 0 LIMIT 20000;";
+  return [...readSqliteRows(dbPath, itemSql), ...readSqliteRows(dbPath, diskSql)];
+}
+
+function readSqliteRows(dbPath, sql) {
+  try {
+    const out = cp.execFileSync("sqlite3", ["-json", dbPath, sql], {
+      encoding: "utf8",
+      timeout: 10000,
+      maxBuffer: 32 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    const parsed = JSON.parse(out || "[]");
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function extractCursorEntriesFromRows(rows) {
+  const entries = [];
+  for (const row of rows || []) {
+    if (!isCursorPromptKey(row.key)) continue;
+    if (isCursorAssistantKey(row.key)) continue;
+    const value = parseMaybeJson(row.value);
+    const candidates = collectCursorPromptCandidates(value);
+    for (const candidate of candidates) {
+      const text = normalizeWhitespace(textFromContent(candidate.text));
+      if (!looksLikePrompt(text)) continue;
+      if (isNonUserNoise(text)) continue;
+      entries.push({
+        source: "cursor",
+        timestamp: candidate.timestamp || value?.timestamp || value?.createdAt || null,
+        session_file: row.key || "cursor-state",
+        text,
+        tokens: normalizeCursorTokens(candidate.usage || value?.usage || value),
+      });
+    }
+  }
+  return dedupeEntries(entries);
+}
+
+function isCursorPromptKey(key) {
+  return /(bubble|composer|chat|conversation|message)/i.test(String(key || ""));
+}
+
+function isCursorAssistantKey(key) {
+  return /(assistant|ai[-_]?message|bot[-_]?reply)/i.test(String(key || ""));
+}
+
+function collectCursorPromptCandidates(value) {
+  const out = [];
+  visit(value, (node) => {
+    if (!node || typeof node !== "object") return;
+    if (!isCursorUserNode(node)) return;
+    const text = node.text ?? node.content ?? node.message ?? node.prompt;
+    if (!text || typeof text === "object") return;
+    out.push({
+      text,
+      timestamp: node.timestamp || node.createdAt || node.time || null,
+      usage: node.usage || node.tokenUsage || node.tokens || null,
+    });
+  });
+  return out;
+}
+
+/** Require an explicit user signal when role/type is present; reject assistant/system/tool. */
+function isCursorUserNode(node) {
+  const type = node.type;
+  const role = String(node.role || node.kind || "").toLowerCase();
+  const typeStr = String(type ?? "").toLowerCase();
+
+  if (type === 2 || typeStr === "2") return false;
+  if (/(assistant|system|tool|function|model)/i.test(role)) return false;
+  if (/(assistant|system|tool|ai)/i.test(String(node.bubbleType || node.capabilityType || ""))) {
+    return false;
+  }
+  if (/(assistant|system|tool)/i.test(typeStr) && typeStr !== "1") return false;
+
+  if (type === 1 || typeStr === "1") return true;
+  if (/^(user|human|prompt|request)$/.test(role)) return true;
+  if (typeStr === "user") return true;
+
+  // Containers that nest many messages — don't treat the shell as a prompt.
+  if (Array.isArray(node.messages) || Array.isArray(node.bubbles) || Array.isArray(node.fullConversationHeadersOnly)) {
+    return false;
+  }
+
+  // Legacy ItemTable bubbles: plain { text } with no role/type.
+  if (role || (typeStr && typeStr !== "undefined" && typeStr !== "null")) {
+    // Unknown non-user role/type — skip.
+    if (!/^(1|user|human|prompt|request|bubble)$/.test(role || typeStr)) return false;
+  }
+
+  return node.text != null || node.prompt != null;
+}
+
+function isNonUserNoise(text) {
+  const raw = String(text || "");
+  if (/<system_notification>/i.test(raw)) return true;
+  if (/^\s*<(?:system|tool_result|tool_call|agent_transcript)[\s>]/i.test(raw)) return true;
+  if (/\bThe following task has finished\b/i.test(raw)) return true;
+  if (/^\s*\[?(system|assistant|tool)\]?\s*:/i.test(raw)) return true;
+  return false;
+}
+
+function visit(value, fn, seen = new Set()) {
+  if (value == null) return;
+  if (typeof value !== "object") return;
+  if (seen.has(value)) return;
+  seen.add(value);
+  fn(value);
+  if (Array.isArray(value)) {
+    for (const item of value) visit(item, fn, seen);
+    return;
+  }
+  for (const item of Object.values(value)) visit(item, fn, seen);
+}
+
+function parseMaybeJson(value) {
+  if (value && typeof value === "object") return value;
+  if (typeof value !== "string") return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return { text: value };
+  }
+}
+
+function looksLikePrompt(text) {
+  if (!text || text.length < 4) return false;
+  if (/^(true|false|null|undefined)$/i.test(text)) return false;
+  return /[\p{Letter}\p{Script=Han}]/u.test(text);
+}
+
+function normalizeCursorTokens(raw) {
+  const input = number(raw?.inputTokens || raw?.input_tokens || raw?.promptTokens || raw?.tokens_prompt);
+  const output = number(raw?.outputTokens || raw?.output_tokens || raw?.generatedTokens || raw?.tokens_generated);
+  const total = number(raw?.totalTokens || raw?.total_tokens) || input + output;
+  return {
+    input_tokens: input,
+    cached_input_tokens: 0,
+    cache_creation_input_tokens: 0,
+    output_tokens: output,
+    reasoning_output_tokens: 0,
+    total_tokens: total,
+  };
+}
+
+function dedupeEntries(entries) {
+  const seen = new Set();
+  const out = [];
+  for (const entry of entries) {
+    const key = `${entry.timestamp || ""}|${entry.text}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(entry);
+  }
+  return out;
+}
+
+function emptyTotals() {
+  return {
+    input_tokens: 0,
+    cached_input_tokens: 0,
+    cache_creation_input_tokens: 0,
+    output_tokens: 0,
+    reasoning_output_tokens: 0,
+    total_tokens: 0,
+  };
+}
+
+function addTotals(target, delta) {
+  for (const key of Object.keys(target)) target[key] += number(delta[key]);
+}
+
+function number(value) {
+  const n = Number(value || 0);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+
+module.exports = { inspectCursor, resolveCursorDbPath, extractCursorEntriesFromRows };

package/src/sources/gemini.js

@@ -0,0 +1,75 @@
+const os = require("node:os");
+const path = require("node:path");
+
+const { walkFiles } = require("../lib/jsonl");
+const { isInRange } = require("../lib/dates");
+const {
+  emptyTotals,
+  emptyReport,
+  addTotals,
+  usageFromObject,
+  cleanText,
+  toIsoTimestamp,
+  readJsonFile,
+} = require("./common");
+
+async function inspectGemini({ root, range, home = os.homedir() } = {}) {
+  const geminiRoot = root || path.join(home, ".gemini", "tmp");
+  const files = await walkFiles(
+    geminiRoot,
+    (filePath, name) =>
+      (name.endsWith(".json") || name.endsWith(".jsonl")) &&
+      (/chats?[\\/]/i.test(filePath) || /session/i.test(name) || name.startsWith("session-")),
+  );
+  const prompts = [];
+  const tokenTotals = emptyTotals();
+
+  for (const file of files) {
+    if (file.endsWith(".jsonl")) {
+      // Rare JSONL exports under gemini tmp — reuse Continue-like objects via readJsonFile line-by-line isn't needed often.
+      continue;
+    }
+    const data = await readJsonFile(file);
+    if (!data) continue;
+    const messages = Array.isArray(data.messages)
+      ? data.messages
+      : Array.isArray(data.history)
+        ? data.history
+        : Array.isArray(data)
+          ? data
+          : [];
+
+    for (const row of messages) {
+      const text = extractGeminiUserText(row);
+      if (!text) continue;
+      const timestamp = toIsoTimestamp(
+        row.timestamp || row.time || row.createdAt || data.lastUpdated || data.startTime || data.sessionId,
+      );
+      if (!isInRange(timestamp, range)) continue;
+      prompts.push({
+        source: "gemini",
+        timestamp,
+        session_file: file,
+        text,
+      });
+      addTotals(tokenTotals, usageFromObject(row));
+    }
+  }
+
+  return {
+    ...(emptyReport("gemini", geminiRoot)),
+    files_scanned: files.length,
+    prompt_count: prompts.length,
+    token_totals: tokenTotals,
+    prompts,
+  };
+}
+
+function extractGeminiUserText(row) {
+  if (!row || typeof row !== "object") return "";
+  const type = String(row.type || row.role || "").toLowerCase();
+  if (type && !["user", "human", "input"].includes(type)) return "";
+  return cleanText(row.content ?? row.text ?? row.message ?? row.parts ?? "");
+}
+
+module.exports = { inspectGemini, extractGeminiUserText };

package/src/sources/index.js

@@ -0,0 +1,61 @@
+const { inspectCodex } = require("./codex");
+const { inspectClaude } = require("./claude");
+const { inspectCursor } = require("./cursor");
+const { inspectVibeTracker } = require("./vibe-tracker");
+const { inspectCline } = require("./cline");
+const { inspectRoo } = require("./roo");
+const { inspectContinue } = require("./continue");
+const { inspectGemini } = require("./gemini");
+const { inspectAider } = require("./aider");
+const { inspectWindsurf } = require("./windsurf");
+const { inspectCopilot } = require("./copilot");
+const { inspectAmazonQ } = require("./amazonq");
+const { inspectAntigravity } = require("./antigravity");
+
+const SOURCE_INSPECTORS = {
+  codex: inspectCodex,
+  claude: inspectClaude,
+  cursor: inspectCursor,
+  "vibe-tracker": inspectVibeTracker,
+  cline: inspectCline,
+  roo: inspectRoo,
+  continue: inspectContinue,
+  gemini: inspectGemini,
+  aider: inspectAider,
+  windsurf: inspectWindsurf,
+  copilot: inspectCopilot,
+  amazonq: inspectAmazonQ,
+  antigravity: inspectAntigravity,
+};
+
+/** Primary + best-effort mainstream local agents. Missing dirs return empty counts. */
+const DEFAULT_SOURCES = [
+  "codex",
+  "claude",
+  "cursor",
+  "cline",
+  "roo",
+  "continue",
+  "gemini",
+  "aider",
+  "windsurf",
+  "copilot",
+  "amazonq",
+  "antigravity",
+];
+
+const KNOWN_SOURCES = Object.keys(SOURCE_INSPECTORS);
+
+function normalizeSources(sources) {
+  if (typeof sources === "string") {
+    return sources.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  return Array.isArray(sources) && sources.length > 0 ? sources : DEFAULT_SOURCES.slice();
+}
+
+module.exports = {
+  SOURCE_INSPECTORS,
+  DEFAULT_SOURCES,
+  KNOWN_SOURCES,
+  normalizeSources,
+};

package/src/sources/roo.js

@@ -0,0 +1,11 @@
+const { inspectVscodeTaskStore, extractTaskUserText } = require("./vscode-tasks");
+
+async function inspectRoo(options = {}) {
+  return inspectVscodeTaskStore({
+    source: "roo",
+    extensionId: "rooveterinaryinc.roo-cline",
+    ...options,
+  });
+}
+
+module.exports = { inspectRoo, extractTaskUserText };

package/src/sources/token-tracker.js

@@ -0,0 +1,171 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const { createInterface } = require("node:readline");
+
+const DEFAULT_QUEUE = path.join(os.homedir(), ".tokentracker", "tracker", "queue.jsonl");
+
+async function inspectTokenTracker({ queuePath, range } = {}) {
+  const file = queuePath || DEFAULT_QUEUE;
+  let filesScanned = 0;
+  const buckets = new Map();
+
+  try {
+    filesScanned = 1;
+    const rl = createInterface({
+      input: fs.createReadStream(file, "utf8"),
+      crlfDelay: Infinity,
+    });
+
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let row;
+      try {
+        row = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      const timestamp = row.hour_start || row.timestamp || row.ended_at || row.created_at;
+      if (!timestamp || !inRange(timestamp, range)) continue;
+
+      const totals = normalizeTotals(row);
+      if (totals.total_tokens <= 0 && totals.billable_total_tokens <= 0) continue;
+
+      const source = normalizeText(row.source, "unknown").toLowerCase();
+      const model = normalizeText(row.model, "unknown");
+      buckets.set(`${source}|${model}|${timestamp}`, {
+        ...row,
+        source,
+        model,
+        hour_start: timestamp,
+      });
+    }
+  } catch {
+    return emptyReport(file, filesScanned);
+  }
+
+  const daily = new Map();
+  const tokenTotals = emptyTotals();
+
+  for (const row of buckets.values()) {
+    const timestamp = row.hour_start;
+    const totals = normalizeTotals(row);
+    addTotals(tokenTotals, totals);
+
+    const day = String(timestamp).slice(0, 10);
+    const current = daily.get(day) || {
+      day,
+      total_tokens: 0,
+      billable_total_tokens: 0,
+      input_tokens: 0,
+      cached_input_tokens: 0,
+      cache_creation_input_tokens: 0,
+      output_tokens: 0,
+      reasoning_output_tokens: 0,
+      conversation_count: 0,
+      models: {},
+      sources: {},
+    };
+
+    addTotals(current, totals);
+    current.conversation_count += number(row.conversation_count);
+
+    const source = row.source;
+    const model = row.model;
+    const modelKey = `${source}/${model}`;
+    const value = totals.billable_total_tokens || totals.total_tokens;
+    current.models[modelKey] = (current.models[modelKey] || 0) + value;
+    current.sources[source] = (current.sources[source] || 0) + value;
+    daily.set(day, current);
+  }
+
+  const dailyRows = Array.from(daily.values()).sort((a, b) => a.day.localeCompare(b.day));
+
+  return {
+    source: "token-tracker",
+    root: file,
+    files_scanned: filesScanned,
+    bucket_count: buckets.size,
+    active_day_count: dailyRows.filter((row) => (row.billable_total_tokens || row.total_tokens) > 0).length,
+    token_totals: publicTotals(tokenTotals),
+    daily_rows: dailyRows.map((row) => ({
+      ...row,
+      value: row.billable_total_tokens || row.total_tokens,
+      level_value: row.billable_total_tokens || row.total_tokens,
+    })),
+    prompts: [],
+  };
+}
+
+function normalizeText(value, fallback) {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+
+function emptyReport(file, filesScanned = 0) {
+  return {
+    source: "token-tracker",
+    root: file,
+    files_scanned: filesScanned,
+    bucket_count: 0,
+    active_day_count: 0,
+    token_totals: publicTotals(emptyTotals()),
+    daily_rows: [],
+    prompts: [],
+  };
+}
+
+function inRange(timestamp, range) {
+  if (!range) return true;
+  const ms = Date.parse(timestamp);
+  if (!Number.isFinite(ms)) return true;
+  const fromMs = range.fromMs ?? (range.from ? Date.parse(range.from) : null);
+  const toMs = range.toMs ?? (range.to ? Date.parse(range.to) : null);
+  if (Number.isFinite(fromMs) && ms < fromMs) return false;
+  if (Number.isFinite(toMs) && ms > toMs) return false;
+  return true;
+}
+
+function normalizeTotals(row) {
+  const totals = {
+    input_tokens: number(row.input_tokens),
+    cached_input_tokens: number(row.cached_input_tokens),
+    cache_creation_input_tokens: number(row.cache_creation_input_tokens),
+    output_tokens: number(row.output_tokens),
+    reasoning_output_tokens: number(row.reasoning_output_tokens),
+    total_tokens: number(row.total_tokens),
+    billable_total_tokens: number(row.billable_total_tokens),
+  };
+  if (!totals.billable_total_tokens) totals.billable_total_tokens = totals.total_tokens;
+  return totals;
+}
+
+function emptyTotals() {
+  return {
+    input_tokens: 0,
+    cached_input_tokens: 0,
+    cache_creation_input_tokens: 0,
+    output_tokens: 0,
+    reasoning_output_tokens: 0,
+    total_tokens: 0,
+    billable_total_tokens: 0,
+  };
+}
+
+function publicTotals(totals) {
+  const { billable_total_tokens: _billable, ...rest } = totals;
+  return rest;
+}
+
+function addTotals(target, delta) {
+  for (const key of Object.keys(delta)) {
+    target[key] = number(target[key]) + number(delta[key]);
+  }
+}
+
+function number(value) {
+  const n = Number(value || 0);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+
+module.exports = { inspectTokenTracker };

package/src/sources/vibe-tracker.js

@@ -0,0 +1,79 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const { createInterface } = require("node:readline");
+
+const STORE_DIR = path.join(os.homedir(), ".vibe-wrapper");
+
+async function inspectVibeTracker({ range } = {}) {
+  const storeFile = path.join(STORE_DIR, "sessions.jsonl");
+  const prompts = [];
+  let tokenTotals = emptyTotals();
+  let filesScanned = 0;
+
+  try {
+    filesScanned = 1;
+    const stream = fs.createReadStream(storeFile, "utf8");
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const record = JSON.parse(line);
+        if (!inRange(record.ended_at, range)) continue;
+
+        tokenTotals.input_tokens += Number(record.input_tokens || 0);
+        tokenTotals.output_tokens += Number(record.output_tokens || 0);
+        tokenTotals.cached_input_tokens += Number(record.cached_input_tokens || 0);
+        tokenTotals.cache_creation_input_tokens += Number(record.cache_creation_input_tokens || 0);
+        tokenTotals.total_tokens += Number(record.total_tokens || 0);
+
+        prompts.push({
+          source: "vibe-tracker",
+          timestamp: record.ended_at,
+          text: `Session by ${record.source}: ${record.model || "unknown"} — ${formatTokens(record.total_tokens)} tokens`,
+          input_tokens: record.input_tokens,
+          output_tokens: record.output_tokens,
+          cached_input_tokens: record.cached_input_tokens,
+          cache_creation_input_tokens: record.cache_creation_input_tokens,
+        });
+      } catch { /* skip */ }
+    }
+  } catch {
+    // No data yet — return empty
+  }
+
+  return {
+    files_scanned: filesScanned,
+    prompt_count: prompts.length,
+    token_totals: tokenTotals,
+    prompts,
+  };
+}
+
+function inRange(timestamp, range) {
+  if (!timestamp || !range) return true;
+  if (range.from && timestamp < range.from + "T00:00:00.000Z") return false;
+  if (range.to && timestamp > range.to + "T23:59:59.999Z") return false;
+  return true;
+}
+
+function emptyTotals() {
+  return {
+    input_tokens: 0,
+    cached_input_tokens: 0,
+    cache_creation_input_tokens: 0,
+    output_tokens: 0,
+    reasoning_output_tokens: 0,
+    total_tokens: 0,
+  };
+}
+
+function formatTokens(n) {
+  n = Number(n || 0);
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + "K";
+  return String(n);
+}
+
+module.exports = { inspectVibeTracker };