vibe-roast 0.98.0

package/src/sources/codex.js

@@ -0,0 +1,222 @@
+const os = require("node:os");
+const path = require("node:path");
+
+const { walkFiles, readJsonl } = require("../lib/jsonl");
+const { isInRange } = require("../lib/dates");
+const { normalizeWhitespace, textFromContent } = require("../extract/text");
+
+async function inspectCodex({ root, range } = {}) {
+  const sessionsRoot = root || path.join(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"), "sessions");
+  const files = await walkFiles(
+    sessionsRoot,
+    (_filePath, name) => name.endsWith(".jsonl") && (name.startsWith("rollout-") || true),
+  );
+  const prompts = [];
+  const tokenTotals = emptyTotals();
+  const contextByDay = new Map();
+
+  for (const file of files) {
+    let previousTotals = null;
+    let pendingTools = [];
+    await readJsonl(file, (obj) => {
+      const timestamp = obj.timestamp || obj.payload?.timestamp || null;
+      const inRequestedRange = isInRange(timestamp, range);
+
+      if (inRequestedRange) {
+        const text = extractCodexPrompt(obj);
+        if (text) {
+          prompts.push({
+            source: "codex",
+            timestamp,
+            session_file: file,
+            text,
+          });
+        }
+
+        const tokens = extractCodexTokens(obj);
+        if (tokens) addTotals(tokenTotals, tokens);
+
+        const tool = extractCodexTool(obj);
+        if (tool) pendingTools.push(tool);
+      }
+
+      const usage = extractCodexUsageEvent(obj);
+      if (usage) {
+        const delta = codexUsageDelta(usage, previousTotals);
+        if (usage.total) previousTotals = usage.total;
+        if (inRequestedRange) addCodexContext(contextByDay, timestamp, delta, pendingTools);
+        pendingTools = [];
+      }
+    });
+  }
+
+  return {
+    source: "codex",
+    root: sessionsRoot,
+    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 extractCodexPrompt(obj) {
+  const payload = obj?.payload || {};
+  const nested = payload.msg && typeof payload.msg === "object" ? payload.msg : null;
+  const type = String(payload.type || nested?.type || "").toLowerCase();
+  // Codex rollouts mix user / agent / tool / token events — only keep user prompts.
+  if (type !== "user_message") return "";
+
+  const candidates = [
+    payload.message,
+    payload.text,
+    payload.input,
+    payload.content,
+    nested?.message,
+    nested?.text,
+    nested?.input,
+    nested?.content,
+  ];
+  for (const candidate of candidates) {
+    const text = normalizeWhitespace(textFromContent(candidate));
+    if (text) return text;
+  }
+  return "";
+}
+
+function extractCodexTokens(obj) {
+  const payload = obj?.payload || {};
+  const info =
+    payload.type === "token_count" ? payload.info
+    : payload.msg?.type === "token_count" ? payload.msg.info
+    : null;
+  if (!info) return null;
+  return normalizeTotals(info.total_token_usage || info);
+}
+
+function extractCodexUsageEvent(obj) {
+  const payload = obj?.payload || {};
+  const info =
+    payload.type === "token_count" ? payload.info
+    : payload.msg?.type === "token_count" ? payload.msg.info
+    : null;
+  if (!info) return null;
+  return {
+    last: info.last_token_usage && typeof info.last_token_usage === "object"
+      ? info.last_token_usage
+      : null,
+    total: info.total_token_usage && typeof info.total_token_usage === "object"
+      ? info.total_token_usage
+      : null,
+  };
+}
+
+function extractCodexTool(obj) {
+  if (obj?.type !== "response_item" || obj?.payload?.type !== "function_call") return "";
+  const payload = obj.payload;
+  if (typeof payload.namespace === "string" && payload.namespace.startsWith("mcp__")) {
+    return `${payload.namespace}${payload.name || ""}`;
+  }
+  return typeof payload.name === "string" ? payload.name : "";
+}
+
+function codexUsageDelta(usage, previousTotals) {
+  if (!usage) return null;
+  if (usage.total && previousTotals) {
+    const total = normalizeCodexUsage(usage.total);
+    const previous = normalizeCodexUsage(previousTotals);
+    if (total.total_tokens >= previous.total_tokens) {
+      return Object.fromEntries(
+        Object.keys(total).map((key) => [key, Math.max(0, total[key] - previous[key])]),
+      );
+    }
+  }
+  return normalizeCodexUsage(usage.last || usage.total || {});
+}
+
+function normalizeCodexUsage(raw) {
+  const totals = normalizeTotals(raw);
+  // Codex reports input inclusive of cache reads.
+  totals.input_tokens = Math.max(0, totals.input_tokens - totals.cached_input_tokens);
+  totals.total_tokens =
+    totals.input_tokens +
+    totals.cached_input_tokens +
+    totals.cache_creation_input_tokens +
+    totals.output_tokens;
+  return totals;
+}
+
+function addCodexContext(byDay, timestamp, delta, tools) {
+  if (!delta?.total_tokens || !timestamp) return;
+  const day = String(timestamp).slice(0, 10);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) return;
+  const row = byDay.get(day) || emptyContextRow(day, "turn_delta");
+  const uniqueTools = [...new Set((tools || []).filter(Boolean))];
+  const toolShare = uniqueTools.length > 0 ? 1 : 0;
+  const reasoning = Math.min(delta.total_tokens, number(delta.reasoning_output_tokens));
+  const attributable = Math.max(0, delta.total_tokens - reasoning);
+  row.categories.reasoning += reasoning;
+  row.categories.tool_calls += attributable * toolShare;
+  row.categories.messages += attributable * (1 - toolShare);
+  row.total_tokens += delta.total_tokens;
+  row.input_tokens += number(delta.input_tokens)
+    + number(delta.cached_input_tokens)
+    + number(delta.cache_creation_input_tokens);
+  row.cached_input_tokens += number(delta.cached_input_tokens);
+  row.tool_call_count += uniqueTools.length;
+  row.event_count += 1;
+  byDay.set(day, row);
+}
+
+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 normalizeTotals(raw) {
+  return {
+    input_tokens: number(raw.input_tokens),
+    cached_input_tokens: number(raw.cached_input_tokens),
+    cache_creation_input_tokens: number(raw.cache_creation_input_tokens),
+    output_tokens: number(raw.output_tokens),
+    reasoning_output_tokens: number(raw.reasoning_output_tokens),
+    total_tokens: number(raw.total_tokens),
+  };
+}
+
+function emptyTotals() {
+  return normalizeTotals({});
+}
+
+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 = {
+  inspectCodex,
+  extractCodexPrompt,
+  extractCodexTokens,
+  extractCodexTool,
+  extractCodexUsageEvent,
+  codexUsageDelta,
+};

package/src/sources/common.js

@@ -0,0 +1,133 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const os = require("node:os");
+
+const { normalizeWhitespace, textFromContent } = require("../extract/text");
+
+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 number(value) {
+  const n = Number(value || 0);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+
+function addTotals(target, delta) {
+  if (!delta) return;
+  for (const key of Object.keys(target)) {
+    target[key] += number(delta[key]);
+  }
+}
+
+function normalizeTotals(raw = {}) {
+  return {
+    input_tokens: number(raw.input_tokens),
+    cached_input_tokens: number(raw.cached_input_tokens || raw.cache_read_input_tokens),
+    cache_creation_input_tokens: number(raw.cache_creation_input_tokens),
+    output_tokens: number(raw.output_tokens),
+    reasoning_output_tokens: number(raw.reasoning_output_tokens),
+    total_tokens:
+      number(raw.total_tokens) ||
+      number(raw.input_tokens) +
+        number(raw.cached_input_tokens || raw.cache_read_input_tokens) +
+        number(raw.cache_creation_input_tokens) +
+        number(raw.output_tokens) +
+        number(raw.reasoning_output_tokens),
+  };
+}
+
+function emptyReport(source, root, notes = []) {
+  return {
+    source,
+    root,
+    files_scanned: 0,
+    prompt_count: 0,
+    token_totals: emptyTotals(),
+    prompts: [],
+    notes,
+  };
+}
+
+function cleanText(value) {
+  return normalizeWhitespace(textFromContent(value) || String(value || ""));
+}
+
+function toIsoTimestamp(value) {
+  if (value == null || value === "") return null;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const ms = value < 1e12 ? value * 1000 : value;
+    const date = new Date(ms);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+  }
+  const raw = String(value).trim();
+  if (!raw) return null;
+  if (/^\d+$/.test(raw)) return toIsoTimestamp(Number(raw));
+  const ms = Date.parse(raw);
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : null;
+}
+
+function vscodeGlobalStorage(...parts) {
+  return resolveVscodeGlobalStorage({ parts });
+}
+
+function resolveVscodeGlobalStorage({
+  home = os.homedir(),
+  platform = process.platform,
+  env = process.env,
+  parts = [],
+  appName = "Code",
+} = {}) {
+  if (platform === "darwin") {
+    return path.join(home, "Library", "Application Support", appName, "User", "globalStorage", ...parts);
+  }
+  if (platform === "win32") {
+    const appData = env.APPDATA || path.join(home, "AppData", "Roaming");
+    return path.win32.join(appData, appName, "User", "globalStorage", ...parts);
+  }
+  const xdg = env.XDG_CONFIG_HOME || path.join(home, ".config");
+  return path.join(xdg, appName, "User", "globalStorage", ...parts);
+}
+
+async function readJsonFile(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function usageFromObject(obj) {
+  if (!obj || typeof obj !== "object") return null;
+  const usage =
+    obj.usage ||
+    obj.token_usage ||
+    obj.tokens ||
+    obj.message?.usage ||
+    obj.metrics?.tokens ||
+    null;
+  if (!usage) return null;
+  return normalizeTotals(usage);
+}
+
+module.exports = {
+  emptyTotals,
+  emptyReport,
+  number,
+  addTotals,
+  normalizeTotals,
+  cleanText,
+  toIsoTimestamp,
+  vscodeGlobalStorage,
+  resolveVscodeGlobalStorage,
+  readJsonFile,
+  usageFromObject,
+};

package/src/sources/continue.js

@@ -0,0 +1,67 @@
+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 inspectContinue({ root, range, home = os.homedir() } = {}) {
+  const sessionsRoot = root || path.join(home, ".continue", "sessions");
+  const files = await walkFiles(sessionsRoot, (_filePath, name) => name.endsWith(".json"));
+  const prompts = [];
+  const tokenTotals = emptyTotals();
+
+  for (const file of files) {
+    const data = await readJsonFile(file);
+    if (!data) continue;
+    const history = Array.isArray(data.history)
+      ? data.history
+      : Array.isArray(data.messages)
+        ? data.messages
+        : Array.isArray(data)
+          ? data
+          : [];
+
+    for (const row of history) {
+      const text = extractContinueUserText(row);
+      if (!text) continue;
+      const timestamp =
+        toIsoTimestamp(row.timestamp || row.time || row.dateCreated || data.dateCreated || data.createdAt) ||
+        null;
+      if (!isInRange(timestamp, range)) continue;
+      prompts.push({
+        source: "continue",
+        timestamp,
+        session_file: file,
+        text,
+      });
+      addTotals(tokenTotals, usageFromObject(row) || usageFromObject(row.message));
+    }
+  }
+
+  return {
+    ...(emptyReport("continue", sessionsRoot)),
+    files_scanned: files.length,
+    prompt_count: prompts.length,
+    token_totals: tokenTotals,
+    prompts,
+  };
+}
+
+function extractContinueUserText(row) {
+  if (!row || typeof row !== "object") return "";
+  const message = row.message && typeof row.message === "object" ? row.message : row;
+  const role = String(message.role || row.role || "").toLowerCase();
+  if (role && role !== "user") return "";
+  return cleanText(message.content ?? row.content ?? row.text ?? "");
+}
+
+module.exports = { inspectContinue, extractContinueUserText };

package/src/sources/copilot.js

@@ -0,0 +1,170 @@
+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,
+  resolveVscodeGlobalStorage,
+} = require("./common");
+
+const COPILOT_EXTENSION_IDS = [
+  "github.copilot-chat",
+  "GitHub.copilot-chat",
+];
+
+async function inspectCopilot({ root, range, home = os.homedir(), platform, env } = {}) {
+  const roots = root
+    ? [root]
+    : [
+        ...["Code", "Code - Insiders", "Cursor"].flatMap((appName) =>
+          COPILOT_EXTENSION_IDS.map((id) =>
+            resolveVscodeGlobalStorage({ home, platform, env, appName, parts: [id] }),
+          ),
+        ),
+        path.join(home, ".copilot"),
+      ];
+
+  const prompts = [];
+  const tokenTotals = emptyTotals();
+  let filesScanned = 0;
+  let usedRoot = roots[0] || null;
+  const notes = [];
+
+  for (const storeRoot of roots) {
+    const files = await walkFiles(
+      storeRoot,
+      (_filePath, name) =>
+        name.endsWith(".json") ||
+        name.endsWith(".jsonl") ||
+        name === "chat-sessions.json" ||
+        name.includes("chat"),
+    );
+    if (!files.length) continue;
+    usedRoot = storeRoot;
+
+    for (const file of files) {
+      const data = await readJsonFile(file);
+      if (!data) continue;
+      filesScanned += 1;
+      for (const entry of extractCopilotEntries(data, file)) {
+        if (!isInRange(entry.timestamp, range)) continue;
+        prompts.push({
+          source: "copilot",
+          timestamp: entry.timestamp,
+          session_file: file,
+          text: entry.text,
+        });
+        addTotals(tokenTotals, entry.tokens);
+      }
+    }
+    if (filesScanned > 0) break;
+  }
+
+  if (!filesScanned) {
+    notes.push(
+      "No readable GitHub Copilot Chat session JSON found under VS Code/Cursor globalStorage.",
+    );
+  }
+
+  return {
+    ...(emptyReport("copilot", usedRoot, notes)),
+    files_scanned: filesScanned,
+    prompt_count: prompts.length,
+    token_totals: tokenTotals,
+    prompts,
+  };
+}
+
+function extractCopilotEntries(data, file) {
+  const out = [];
+  const sessions = Array.isArray(data)
+    ? data
+    : Array.isArray(data.sessions)
+      ? data.sessions
+      : Array.isArray(data.chatSessions)
+        ? data.chatSessions
+        : [data];
+
+  for (const session of sessions) {
+    const requests = Array.isArray(session.requests)
+      ? session.requests
+      : Array.isArray(session.messages)
+        ? session.messages
+        : Array.isArray(session.history)
+          ? session.history
+          : [];
+
+    for (const req of requests) {
+      const text = extractCopilotUserText(req);
+      if (!text) continue;
+      out.push({
+        text,
+        timestamp: toIsoTimestamp(
+          req.timestamp ||
+            req.time ||
+            req.createdAt ||
+            session.creationDate ||
+            session.lastMessageDate ||
+            session.createdAt,
+        ),
+        tokens: usageFromObject(req) || usageFromObject(req.response),
+      });
+    }
+
+    // Some exports store the user message on the request itself.
+    if (!requests.length) {
+      const text = extractCopilotUserText(session);
+      if (text) {
+        out.push({
+          text,
+          timestamp: toIsoTimestamp(session.creationDate || session.createdAt || session.timestamp),
+          tokens: usageFromObject(session),
+        });
+      }
+    }
+  }
+
+  // Flat message list files
+  if (!out.length && data && typeof data === "object" && Array.isArray(data.messages)) {
+    for (const msg of data.messages) {
+      const text = extractCopilotUserText(msg);
+      if (!text) continue;
+      out.push({
+        text,
+        timestamp: toIsoTimestamp(msg.timestamp || msg.createdAt),
+        tokens: usageFromObject(msg),
+      });
+    }
+  }
+
+  void file;
+  return out;
+}
+
+function extractCopilotUserText(row) {
+  if (!row || typeof row !== "object") return "";
+  const role = String(row.role || row.kind || row.author || row.participant || "").toLowerCase();
+  if (role && !/(user|human|request)/.test(role) && role !== "0") {
+    // Copilot chat requests often omit role and use `message` / `prompt`.
+    if (!row.message && !row.prompt && !row.text && !row.request) return "";
+    if (/(assistant|bot|copilot|response|model)/.test(role)) return "";
+  }
+  return cleanText(
+    row.message ??
+      row.prompt ??
+      row.text ??
+      row.request ??
+      row.content ??
+      row.userMessage ??
+      "",
+  );
+}
+
+module.exports = { inspectCopilot, extractCopilotUserText, extractCopilotEntries };