vibe-roast 0.98.0

package/src/sources/aider.js

@@ -0,0 +1,150 @@
+const fs = require("node:fs/promises");
+const os = require("node:os");
+const path = require("node:path");
+
+const { isInRange } = require("../lib/dates");
+const { emptyTotals, emptyReport, cleanText, toIsoTimestamp } = require("./common");
+
+const DEFAULT_SEARCH_DIRS = ["projects", "dev", "src", "work", "code", "Desktop", "Documents"];
+
+async function inspectAider({ root, range, home = os.homedir() } = {}) {
+  const historyFiles = await findAiderHistoryFiles(root, home);
+  const prompts = [];
+  let filesScanned = 0;
+
+  for (const file of historyFiles) {
+    filesScanned += 1;
+    let text;
+    try {
+      text = await fs.readFile(file, "utf8");
+    } catch {
+      continue;
+    }
+    for (const entry of parseAiderHistory(text)) {
+      if (!isInRange(entry.timestamp, range)) continue;
+      prompts.push({
+        source: "aider",
+        timestamp: entry.timestamp,
+        session_file: file,
+        text: entry.text,
+      });
+    }
+  }
+
+  const usedRoot = root || (historyFiles[0] ? path.dirname(historyFiles[0]) : path.join(home, "projects"));
+  return {
+    ...(emptyReport(
+      "aider",
+      usedRoot,
+      historyFiles.length
+        ? []
+        : ["No .aider.chat.history.md files found under the search roots."],
+    )),
+    files_scanned: filesScanned,
+    prompt_count: prompts.length,
+    token_totals: emptyTotals(),
+    prompts,
+  };
+}
+
+async function findAiderHistoryFiles(root, home) {
+  if (root) {
+    try {
+      const st = await fs.stat(root);
+      if (st.isFile()) return path.basename(root).includes("aider") ? [root] : [root];
+    } catch {
+      return [];
+    }
+    return walkDepth(root, 4, (name) => name === ".aider.chat.history.md");
+  }
+
+  const out = [];
+  const cwdFile = path.join(process.cwd(), ".aider.chat.history.md");
+  try {
+    await fs.access(cwdFile);
+    out.push(cwdFile);
+  } catch {
+    // ignore
+  }
+
+  for (const dirName of DEFAULT_SEARCH_DIRS) {
+    const base = path.join(home, dirName);
+    const found = await walkDepth(base, 3, (name) => name === ".aider.chat.history.md");
+    out.push(...found);
+  }
+  return [...new Set(out)].sort((a, b) => a.localeCompare(b));
+}
+
+async function walkDepth(rootDir, maxDepth, predicate) {
+  const out = [];
+  const stack = [{ dir: rootDir, depth: 0 }];
+  while (stack.length) {
+    const { dir, depth } = stack.pop();
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      const filePath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (depth < maxDepth) stack.push({ dir: filePath, depth: depth + 1 });
+      } else if (entry.isFile() && predicate(entry.name, filePath)) {
+        out.push(filePath);
+      }
+    }
+  }
+  return out;
+}
+
+function parseAiderHistory(markdown) {
+  const entries = [];
+  const lines = String(markdown || "").split(/\r?\n/);
+  let current = null;
+
+  const flush = () => {
+    if (!current) return;
+    const text = cleanText(current.lines.join("\n"));
+    if (text) {
+      entries.push({
+        timestamp: current.timestamp,
+        text,
+      });
+    }
+    current = null;
+  };
+
+  for (const line of lines) {
+    if (/^#+\s*(?:aider:)?\s*(user|human)\b/i.test(line)) {
+      flush();
+      const stampMatch = line.match(/\((\d{4}-\d{2}-\d{2}[^)]*)\)/);
+      current = {
+        timestamp: toIsoTimestamp(stampMatch?.[1]) || null,
+        lines: [],
+      };
+      continue;
+    }
+
+    if (/^>\?\s+/.test(line)) {
+      flush();
+      current = {
+        timestamp: null,
+        lines: [line.replace(/^>\?\s+/, "")],
+      };
+      continue;
+    }
+
+    if (/^#+\s*(?:aider:)?\s*(assistant|model|ai|coder)\b/i.test(line)) {
+      flush();
+      continue;
+    }
+
+    if (current) current.lines.push(line);
+  }
+  flush();
+  return entries;
+}
+
+module.exports = { inspectAider, parseAiderHistory, extractAiderUserText: (md) => parseAiderHistory(md).map((e) => e.text) };

package/src/sources/amazonq.js

@@ -0,0 +1,113 @@
+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");
+
+/**
+ * Amazon Q Developer IDE chat history.
+ * Default: ~/.aws/amazonq/history/chat-history-*.json (LokiJS dump).
+ */
+async function inspectAmazonQ({ root, range, home = os.homedir() } = {}) {
+  const historyRoot = root || path.join(home, ".aws", "amazonq", "history");
+  const files = await walkFiles(
+    historyRoot,
+    (_filePath, name) =>
+      name.startsWith("chat-history") && name.endsWith(".json"),
+  );
+  const prompts = [];
+  const tokenTotals = emptyTotals();
+  const notes = [];
+
+  for (const file of files) {
+    const data = await readJsonFile(file);
+    if (!data) continue;
+    for (const entry of extractAmazonQEntries(data)) {
+      if (!isInRange(entry.timestamp, range)) continue;
+      prompts.push({
+        source: "amazonq",
+        timestamp: entry.timestamp,
+        session_file: file,
+        text: entry.text,
+      });
+      addTotals(tokenTotals, entry.tokens);
+    }
+  }
+
+  if (!files.length) {
+    notes.push("No Amazon Q chat-history-*.json under ~/.aws/amazonq/history.");
+  }
+
+  return {
+    ...(emptyReport("amazonq", historyRoot, notes)),
+    files_scanned: files.length,
+    prompt_count: prompts.length,
+    token_totals: tokenTotals,
+    prompts,
+  };
+}
+
+function extractAmazonQEntries(data) {
+  const out = [];
+  const tabs = collectAmazonQTabs(data);
+
+  for (const tab of tabs) {
+    const tabTs =
+      toIsoTimestamp(tab.updatedAt || tab.meta?.updated || tab.meta?.created) || null;
+    const conversations = Array.isArray(tab.conversations) ? tab.conversations : [];
+    for (const conversation of conversations) {
+      const messages = Array.isArray(conversation.messages) ? conversation.messages : [];
+      for (const msg of messages) {
+        const text = extractAmazonQUserText(msg);
+        if (!text) continue;
+        out.push({
+          text,
+          timestamp:
+            toIsoTimestamp(msg.timestamp || msg.createdAt || msg.time) || tabTs,
+          tokens: usageFromObject(msg),
+        });
+      }
+    }
+  }
+
+  return out;
+}
+
+function collectAmazonQTabs(data) {
+  if (!data || typeof data !== "object") return [];
+  if (Array.isArray(data.collections)) {
+    const tabs = [];
+    for (const collection of data.collections) {
+      if (!collection || collection.name !== "tabs") continue;
+      if (Array.isArray(collection.data)) tabs.push(...collection.data);
+    }
+    return tabs;
+  }
+  if (Array.isArray(data.tabs)) return data.tabs;
+  if (Array.isArray(data.conversations)) {
+    return [{ conversations: data.conversations, updatedAt: data.updatedAt }];
+  }
+  return [];
+}
+
+function extractAmazonQUserText(msg) {
+  if (!msg || typeof msg !== "object") return "";
+  const type = String(msg.type || msg.role || msg.kind || "").toLowerCase();
+  if (type && !/(prompt|user|human|request)/.test(type)) return "";
+  return cleanText(msg.body ?? msg.content ?? msg.text ?? msg.prompt ?? "");
+}
+
+module.exports = {
+  inspectAmazonQ,
+  extractAmazonQEntries,
+  extractAmazonQUserText,
+};

package/src/sources/antigravity.js

@@ -0,0 +1,147 @@
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs/promises");
+
+const { walkFiles } = require("../lib/jsonl");
+const { isInRange } = require("../lib/dates");
+const {
+  emptyTotals,
+  emptyReport,
+  addTotals,
+  usageFromObject,
+  cleanText,
+  toIsoTimestamp,
+  readJsonFile,
+} = require("./common");
+
+/**
+ * Google Antigravity IDE — best-effort.
+ * Conversations live as encrypted/binary `.pb` under ~/.gemini/antigravity(-ide)/conversations.
+ * We only ingest plaintext JSON/JSONL exports if present; otherwise return empty with notes.
+ */
+async function inspectAntigravity({ root, range, home = os.homedir(), platform, env } = {}) {
+  const roots = root
+    ? [root]
+    : defaultAntigravityRoots({ home, platform, env });
+
+  const prompts = [];
+  const tokenTotals = emptyTotals();
+  let filesScanned = 0;
+  let pbSeen = 0;
+  let usedRoot = roots[0] || null;
+  const notes = [];
+
+  for (const storeRoot of roots) {
+    const files = await walkFiles(storeRoot, () => true);
+    if (!files.length) continue;
+    usedRoot = storeRoot;
+
+    for (const file of files) {
+      const name = path.basename(file).toLowerCase();
+      if (name.endsWith(".pb")) {
+        pbSeen += 1;
+        continue;
+      }
+      if (!name.endsWith(".json") && !name.endsWith(".jsonl")) continue;
+
+      const data = await readJsonFile(file);
+      if (!data) continue;
+      filesScanned += 1;
+      for (const entry of extractAntigravityEntries(data)) {
+        if (!isInRange(entry.timestamp, range)) continue;
+        prompts.push({
+          source: "antigravity",
+          timestamp: entry.timestamp,
+          session_file: file,
+          text: entry.text,
+        });
+        addTotals(tokenTotals, entry.tokens);
+      }
+    }
+    if (filesScanned > 0 || pbSeen > 0) break;
+  }
+
+  if (pbSeen > 0 && prompts.length === 0) {
+    notes.push(
+      `Found ${pbSeen} Antigravity conversation .pb file(s); content is protobuf/binary and not parsed.`,
+    );
+  } else if (!filesScanned && !pbSeen) {
+    notes.push(
+      "No Antigravity conversation dir found (~/.gemini/antigravity(-ide)/conversations or App Support state).",
+    );
+  }
+
+  return {
+    ...(emptyReport("antigravity", usedRoot, notes)),
+    files_scanned: filesScanned + pbSeen,
+    prompt_count: prompts.length,
+    token_totals: tokenTotals,
+    prompts,
+  };
+}
+
+function defaultAntigravityRoots({ home, platform = process.platform, env = process.env }) {
+  const support =
+    platform === "darwin"
+      ? path.join(home, "Library", "Application Support")
+      : platform === "win32"
+        ? path.join(env.APPDATA || path.join(home, "AppData", "Roaming"))
+        : path.join(home, ".config");
+
+  return [
+    path.join(home, ".gemini", "antigravity-ide", "conversations"),
+    path.join(home, ".gemini", "antigravity", "conversations"),
+    path.join(support, "Antigravity IDE", "User", "globalStorage"),
+    path.join(support, "Antigravity", "User", "globalStorage"),
+    path.join(support, "antigravity", "User", "globalStorage"),
+  ];
+}
+
+function extractAntigravityEntries(data) {
+  const out = [];
+  const messages = Array.isArray(data)
+    ? data
+    : Array.isArray(data.messages)
+      ? data.messages
+      : Array.isArray(data.history)
+        ? data.history
+        : Array.isArray(data.conversations)
+          ? data.conversations.flatMap((c) => (Array.isArray(c.messages) ? c.messages : []))
+          : [];
+
+  for (const row of messages) {
+    const text = extractAntigravityUserText(row);
+    if (!text) continue;
+    out.push({
+      text,
+      timestamp: toIsoTimestamp(row.timestamp || row.createdAt || row.time || data.updatedAt),
+      tokens: usageFromObject(row),
+    });
+  }
+  return out;
+}
+
+function extractAntigravityUserText(row) {
+  if (!row || typeof row !== "object") return "";
+  const role = String(row.role || row.type || row.author || "").toLowerCase();
+  if (role && !/(user|human|prompt|request)/.test(role)) return "";
+  return cleanText(row.content ?? row.text ?? row.body ?? row.prompt ?? "");
+}
+
+/** Exists helper for tests / docs. */
+async function pathExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  inspectAntigravity,
+  extractAntigravityEntries,
+  extractAntigravityUserText,
+  defaultAntigravityRoots,
+  pathExists,
+};

package/src/sources/claude.js

@@ -0,0 +1,262 @@
+const os = require("node:os");
+const path = require("node:path");
+
+const { walkFiles, readJsonl } = require("../lib/jsonl");
+const { isInRange } = require("../lib/dates");
+const { normalizeWhitespace } = require("../extract/text");
+
+async function inspectClaude({ root, range } = {}) {
+  const projectsRoot = root || path.join(os.homedir(), ".claude", "projects");
+  const files = await walkFiles(projectsRoot, (_filePath, name) => name.endsWith(".jsonl"));
+  const prompts = [];
+  const tokenTotals = emptyTotals();
+  const contextByDay = new Map();
+  const seenContextMessages = new Set();
+
+  for (const file of files) {
+    const sessionState = { systemPrefixSeen: false };
+    const contextMessages = new Map();
+    await readJsonl(file, (obj) => {
+      const timestamp = obj.timestamp || null;
+      if (!isInRange(timestamp, range)) return;
+
+      const text = extractClaudePrompt(obj);
+      if (text) {
+        prompts.push({
+          source: "claude",
+          timestamp,
+          session_file: file,
+          text,
+        });
+      }
+
+      const tokens = extractClaudeTokens(obj);
+      if (tokens) addTotals(tokenTotals, tokens);
+
+      if (tokens?.total_tokens > 0) collectClaudeContextMessage(contextMessages, obj, timestamp);
+    });
+
+    for (const message of contextMessages.values()) {
+      if (message.key && seenContextMessages.has(message.key)) continue;
+      if (message.key) seenContextMessages.add(message.key);
+      addClaudeContext(contextByDay, message.timestamp, {
+        message: {
+          usage: message.usage,
+          content: message.content,
+        },
+      }, sessionState);
+    }
+  }
+
+  return {
+    source: "claude",
+    root: projectsRoot,
+    files_scanned: files.length,
+    prompt_count: prompts.length,
+    token_totals: tokenTotals,
+    context_breakdown_daily: [...contextByDay.values()].sort((a, b) => a.day.localeCompare(b.day)),
+    prompts,
+  };
+}
+
+function extractClaudePrompt(obj) {
+  if (obj?.type !== "user" && obj?.message?.role !== "user") return "";
+  // Skip synthetic user rows that only wrap tool results / meta.
+  if (obj?.isMeta || obj?.isCompactSummary) return "";
+  const content = obj?.message?.content ?? obj?.content;
+  return normalizeWhitespace(textFromClaudeUserContent(content));
+}
+
+function textFromClaudeUserContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((block) => {
+      if (!block || typeof block !== "object") return "";
+      if (block.type && block.type !== "text") return "";
+      return typeof block.text === "string" ? block.text : "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+function extractClaudeTokens(obj) {
+  const usage = obj?.message?.usage || obj?.usage;
+  if (!usage) return null;
+  return {
+    input_tokens: number(usage.input_tokens),
+    cached_input_tokens: number(usage.cache_read_input_tokens || usage.cached_input_tokens),
+    cache_creation_input_tokens: number(usage.cache_creation_input_tokens),
+    output_tokens: number(usage.output_tokens),
+    reasoning_output_tokens: 0,
+    total_tokens:
+      number(usage.input_tokens) +
+      number(usage.cache_read_input_tokens || usage.cached_input_tokens) +
+      number(usage.cache_creation_input_tokens) +
+      number(usage.output_tokens),
+  };
+}
+
+function claudeContextKey(obj) {
+  const messageId = obj?.message?.id || "";
+  const requestId = obj?.requestId || obj?.request_id || "";
+  if (!messageId && !requestId) return "";
+  return `${messageId}|${requestId}`;
+}
+
+function collectClaudeContextMessage(messages, obj, timestamp) {
+  const key = claudeContextKey(obj) || `${timestamp}|${messages.size}`;
+  const usage = obj?.message?.usage || obj?.usage;
+  const content = Array.isArray(obj?.message?.content) ? obj.message.content : [];
+  const current = messages.get(key) || {
+    key: claudeContextKey(obj),
+    timestamp,
+    usage,
+    content: [],
+    blockKeys: new Set(),
+  };
+  if (claudeUsageTotal(usage) >= claudeUsageTotal(current.usage)) current.usage = usage;
+  current.timestamp = current.timestamp || timestamp;
+
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const blockKey = block.id
+      ? `${block.type || ""}:${block.id}`
+      : JSON.stringify(block);
+    if (current.blockKeys.has(blockKey)) continue;
+    current.blockKeys.add(blockKey);
+    current.content.push(block);
+  }
+  messages.set(key, current);
+}
+
+function claudeUsageTotal(usage) {
+  return number(usage?.input_tokens)
+    + number(usage?.cache_read_input_tokens || usage?.cached_input_tokens)
+    + number(usage?.cache_creation_input_tokens)
+    + number(usage?.output_tokens);
+}
+
+function addClaudeContext(byDay, timestamp, obj, sessionState) {
+  if (!timestamp) return;
+  const day = String(timestamp).slice(0, 10);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) return;
+  const usage = obj?.message?.usage || obj?.usage;
+  if (!usage) return;
+
+  const input = number(usage.input_tokens);
+  const cached = number(usage.cache_read_input_tokens || usage.cached_input_tokens);
+  const cacheCreation = number(usage.cache_creation_input_tokens);
+  const output = number(usage.output_tokens);
+  const row = byDay.get(day) || emptyContextRow(day, "content_blocks");
+
+  row.categories.messages += input + cached;
+  if (cacheCreation > 0 && !sessionState.systemPrefixSeen) {
+    row.categories.system_prompt += cacheCreation;
+    sessionState.systemPrefixSeen = true;
+  } else {
+    row.categories.messages += cacheCreation;
+  }
+
+  const outputSplit = splitClaudeOutput(output, number(usage.reasoning_output_tokens), obj?.message?.content);
+  row.categories.messages += outputSplit.messages;
+  row.categories.tool_calls += outputSplit.tool_calls;
+  row.categories.reasoning += outputSplit.reasoning;
+  row.categories.custom_agents += outputSplit.custom_agents;
+  row.total_tokens += input + cached + cacheCreation + output;
+  row.input_tokens += input + cached + cacheCreation;
+  row.cached_input_tokens += cached;
+  row.tool_call_count += outputSplit.tool_call_count;
+  row.event_count += 1;
+  byDay.set(day, row);
+}
+
+function splitClaudeOutput(total, explicitReasoning, content) {
+  const blocks = Array.isArray(content) ? content : [];
+  const weights = { messages: 0, tool_calls: 0, reasoning: 0, custom_agents: 0 };
+  let toolCallCount = 0;
+
+  for (const block of blocks) {
+    if (!block || typeof block !== "object") continue;
+    if (block.type === "text") {
+      weights.messages += String(block.text || "").length || 1;
+    } else if (block.type === "thinking") {
+      weights.reasoning += String(block.thinking || block.text || "").length || 1;
+    } else if (block.type === "tool_use") {
+      const weight = String(block.name || "").length
+        + (block.input ? JSON.stringify(block.input).length : 0)
+        + 1;
+      const category = block.name === "Agent" || block.name === "Task"
+        ? "custom_agents"
+        : "tool_calls";
+      weights[category] += weight;
+      toolCallCount += 1;
+    }
+  }
+
+  const reasoning = Math.min(total, explicitReasoning);
+  const remaining = Math.max(0, total - reasoning);
+  if (reasoning > 0) weights.reasoning = 0;
+  const weightTotal = Object.values(weights).reduce((sum, value) => sum + value, 0);
+  const allocated = { messages: 0, tool_calls: 0, reasoning, custom_agents: 0 };
+
+  if (weightTotal <= 0) {
+    allocated.messages = remaining;
+  } else {
+    let used = 0;
+    for (const key of ["tool_calls", "custom_agents", "reasoning"]) {
+      allocated[key] += Math.floor(remaining * (weights[key] / weightTotal));
+      used += Math.floor(remaining * (weights[key] / weightTotal));
+    }
+    allocated.messages = remaining - used;
+  }
+
+  return { ...allocated, tool_call_count: toolCallCount };
+}
+
+function emptyContextRow(day, method) {
+  return {
+    day,
+    method,
+    categories: {
+      messages: 0,
+      tool_calls: 0,
+      reasoning: 0,
+      system_prompt: 0,
+      custom_agents: 0,
+    },
+    total_tokens: 0,
+    input_tokens: 0,
+    cached_input_tokens: 0,
+    tool_call_count: 0,
+    event_count: 0,
+  };
+}
+
+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 = {
+  inspectClaude,
+  extractClaudePrompt,
+  extractClaudeTokens,
+  collectClaudeContextMessage,
+  splitClaudeOutput,
+};

package/src/sources/cline.js

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