vibe-roast 0.98.0

package/src/inspect.js

@@ -0,0 +1,261 @@
+const { dayBounds } = require("./lib/dates");
+const { wordCloudRecords, wordFrequenciesFromRecords } = require("./extract/phrase-stats");
+const { analyzePrompts } = require("./extract/prompt-analysis");
+const { inspectEnvironment } = require("./extract/environment");
+const { buildVibeProfile } = require("./lib/agent-score");
+const { buildRoastEvidence } = require("./lib/roast-evidence");
+const { inspectTokenTracker } = require("./sources/token-tracker");
+const { SOURCE_INSPECTORS, normalizeSources } = require("./sources");
+
+async function inspectSources({ from, to, sources, roots = {}, injectedReports = {} } = {}) {
+  const range = dayBounds(from, to);
+  const injectedSourceNames = Object.keys(injectedReports || {});
+  const selected = Array.isArray(sources) && sources.length === 0 && injectedSourceNames.length > 0
+    ? injectedSourceNames
+    : normalizeSources(sources);
+  const sourceReports = {};
+  const prompts = [];
+  const tokenTrackerActivity = await inspectTokenTracker({
+    queuePath: roots.tokenTrackerQueue,
+    range,
+  });
+
+  for (const source of selected) {
+    const inspect = SOURCE_INSPECTORS[source];
+    if (!inspect && !injectedReports[source]) continue;
+    const report = injectedReports[source] || await inspect({
+      root: roots[source],
+      dbPath: roots.cursorDb || roots.cursor,
+      range,
+      home: roots.home,
+    });
+    sourceReports[source] = stripPrompts(report);
+    prompts.push(...(report.prompts || []));
+  }
+
+  prompts.sort((a, b) => String(a.timestamp || "").localeCompare(String(b.timestamp || "")));
+  const promptAnalysis = analyzePrompts(prompts);
+  const wordSourcePrompts = prompts.filter((prompt) => prompt.timestamp);
+  const wordPromptAnalysis = analyzePrompts(wordSourcePrompts.length > 0 ? wordSourcePrompts : prompts, {
+    usefulLimit: prompts.length,
+  });
+  const environment = await inspectEnvironment({
+    home: roots.home,
+    codexHome: roots.codexHome,
+  });
+  const activity = enrichActivity(buildActivity(tokenTrackerActivity, prompts, sourceReports));
+  const summary = buildSummary(sourceReports, prompts, activity);
+  const vibe_profile = buildVibeProfile({
+    categories: promptAnalysis.categories || {},
+    env: environment?.codex || {},
+    summary,
+    promptAnalysis,
+    activity,
+  });
+  const word_cloud_records = wordCloudRecords(
+    wordPromptAnalysis.useful_for_stats || wordPromptAnalysis.useful_prompts,
+  );
+
+  const report = {
+    generated_at: new Date().toISOString(),
+    range: { from: from || null, to: to || null },
+    summary,
+    sources: sourceReports,
+    activity,
+    word_frequencies: wordFrequenciesFromRecords(word_cloud_records),
+    word_cloud_records,
+    profile_signals: {
+      prompt_analysis: promptAnalysis,
+      environment,
+    },
+    vibe_profile,
+    prompts,
+  };
+  report.roast_evidence = buildRoastEvidence(report);
+  return report;
+}
+
+function buildActivity(tokenTrackerActivity, prompts = [], sourceReports = {}) {
+  if (tokenTrackerActivity?.daily_rows?.length > 0) {
+    return {
+      source: "token-tracker",
+      metric: "tokens",
+      daily_rows: attachContextBreakdown(tokenTrackerActivity.daily_rows, sourceReports),
+      total_tokens: tokenTrackerActivity.token_totals?.total_tokens || 0,
+      active_day_count: tokenTrackerActivity.active_day_count || 0,
+      bucket_count: tokenTrackerActivity.bucket_count || 0,
+      daily_row_count: tokenTrackerActivity.daily_rows.length,
+      root: tokenTrackerActivity.root,
+      estimated_cost_usd: parseOptionalCost(tokenTrackerActivity.estimated_cost_usd),
+    };
+  }
+
+  const byDay = new Map();
+  for (const prompt of prompts || []) {
+    if (!prompt?.timestamp) continue;
+    const day = String(prompt.timestamp).slice(0, 10);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) continue;
+    const row = byDay.get(day) || { day, value: 0, conversation_count: 0, models: {}, sources: {} };
+    row.value += 1;
+    row.conversation_count += 1;
+    const source = prompt.source || "unknown";
+    row.sources[source] = (row.sources[source] || 0) + 1;
+    row.models[source] = (row.models[source] || 0) + 1;
+    byDay.set(day, row);
+  }
+
+  const daily_rows = [...byDay.values()]
+    .sort((a, b) => a.day.localeCompare(b.day))
+    .map((row) => ({
+      day: row.day,
+      value: row.value,
+      total_tokens: row.value,
+      billable_total_tokens: row.value,
+      conversation_count: row.conversation_count,
+      models: row.models,
+      sources: row.sources,
+    }));
+
+  return {
+    source: "prompts",
+    metric: "prompts",
+    daily_rows,
+    total_tokens: 0,
+    active_day_count: daily_rows.length,
+    bucket_count: 0,
+    daily_row_count: daily_rows.length,
+    root: null,
+    estimated_cost_usd: null,
+  };
+}
+
+function attachContextBreakdown(dailyRows, sourceReports) {
+  const contextByDay = new Map();
+  for (const [source, report] of Object.entries(sourceReports || {})) {
+    for (const row of report?.context_breakdown_daily || []) {
+      if (!row?.day) continue;
+      const day = contextByDay.get(row.day) || {};
+      day[source] = row;
+      contextByDay.set(row.day, day);
+    }
+  }
+  return (dailyRows || []).map((row) => ({
+    ...row,
+    context_breakdown: contextByDay.get(row.day) || {},
+  }));
+}
+
+function enrichActivity(activity) {
+  const { summarizeActivity } = require("./lib/activity-metrics");
+  const stats = summarizeActivity(activity);
+  return {
+    ...activity,
+    total_tokens: activity.metric === "tokens"
+      ? (activity.total_tokens || stats.totalValue)
+      : activity.total_tokens || 0,
+    active_day_count: stats.activeDays || activity.active_day_count || 0,
+    longest_streak: stats.maxStreak,
+    peak_day: stats.peakDay.day
+      ? { day: stats.peakDay.day, value: stats.peakDay.value }
+      : null,
+    top_agent: stats.topAgent,
+    top_provider: stats.topProvider,
+    top_model: stats.topModel,
+    active_rate: stats.activeRate,
+    estimated_cost_usd: parseOptionalCost(activity.estimated_cost_usd),
+  };
+}
+
+function parseOptionalCost(value) {
+  if (value == null || value === "") return null;
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+function stripPrompts(report) {
+  const { prompts: _prompts, ...rest } = report;
+  return rest;
+}
+
+function buildSummary(sourceReports, prompts, activity) {
+  const tokenTotals = emptyTotals();
+  let filesScanned = 0;
+  for (const report of Object.values(sourceReports)) {
+    filesScanned += report.files_scanned || 0;
+    addTotals(tokenTotals, report.token_totals || {});
+  }
+
+  const timestampedPrompts = prompts.filter((prompt) => prompt.timestamp);
+  const activeSources = rankActiveSources(sourceReports, prompts, activity);
+
+  return {
+    // Kept for CLI/API compatibility: this is the number of adapters inspected.
+    source_count: Object.keys(sourceReports).length,
+    active_source_count: activeSources.length,
+    active_sources: activeSources,
+    files_scanned: filesScanned,
+    prompt_count: prompts.length,
+    first_prompt_at: timestampedPrompts[0]?.timestamp || null,
+    last_prompt_at: timestampedPrompts[timestampedPrompts.length - 1]?.timestamp || null,
+    token_totals: tokenTotals,
+  };
+}
+
+function rankActiveSources(sourceReports, prompts, activity) {
+  const scores = new Map();
+  const add = (source, value = 1) => {
+    const key = normalizeSourceId(source);
+    const amount = Number(value);
+    if (!key || !Number.isFinite(amount) || amount <= 0) return;
+    scores.set(key, (scores.get(key) || 0) + amount);
+  };
+
+  for (const prompt of prompts || []) add(prompt?.source);
+
+  for (const [key, report] of Object.entries(sourceReports || {})) {
+    const promptCount = Number(report?.prompt_count || 0);
+    const tokenCount = Number(report?.token_totals?.total_tokens || 0);
+    if (promptCount > 0 || tokenCount > 0) add(report?.source || key, promptCount || tokenCount);
+  }
+
+  for (const row of activity?.daily_rows || []) {
+    for (const [source, value] of Object.entries(row?.sources || {})) add(source, value);
+  }
+
+  return [...scores.entries()]
+    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+    .map(([source]) => source);
+}
+
+function normalizeSourceId(source) {
+  const key = String(source || "").trim().toLowerCase().replace(/[\s_]+/g, "-");
+  if (!key || key === "unknown") return null;
+  const aliases = {
+    "claude-code": "claude",
+    "github-copilot": "copilot",
+    "amazon-q": "amazonq",
+    "gemini-cli": "gemini",
+    "roo-code": "roo",
+  };
+  return aliases[key] || key;
+}
+
+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)) {
+    const n = Number(delta[key] || 0);
+    target[key] += Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+  }
+}
+
+module.exports = { inspectSources, SOURCE_INSPECTORS, normalizeSources };

package/src/lib/activity-metrics.js

@@ -0,0 +1,238 @@
+function number(value) {
+  const n = Number(value || 0);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+
+function compactNumber(value) {
+  const n = Number(value) || 0;
+  if (n < 1000) return String(Math.round(n));
+  if (n < 1000000) return `${(n / 1000).toFixed(n >= 10000 ? 0 : 1)}K`;
+  if (n < 10000000) return `${(n / 1000000).toFixed(2)}M`;
+  if (n < 1000000000) return `${(n / 1000000).toFixed(1)}M`;
+  return `${(n / 1000000000).toFixed(n >= 10000000000 ? 0 : 2)}B`;
+}
+
+function formatUsd(value) {
+  if (value == null || value === "") return null;
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  return `$${n.toFixed(n >= 100 ? 0 : 2)}`;
+}
+
+/** Derive streak / peak / totals from activity.daily_rows (sorted or unsorted). */
+function summarizeActivity(activity = {}) {
+  const rows = Array.isArray(activity.daily_rows) ? [...activity.daily_rows] : [];
+  rows.sort((a, b) => String(a.day || "").localeCompare(String(b.day || "")));
+
+  let totalValue = 0;
+  let activeDays = 0;
+  let maxStreak = 0;
+  let currentStreak = 0;
+  let peakDay = { day: null, value: 0 };
+  const sourceTotals = new Map();
+  const providerTotals = new Map();
+  const modelTotals = new Map();
+
+  let prevDay = null;
+  for (const row of rows) {
+    const value = number(row.value ?? row.billable_total_tokens ?? row.total_tokens);
+    totalValue += value;
+    if (value > 0) {
+      activeDays += 1;
+      if (prevDay && consecutiveDays(prevDay, row.day)) currentStreak += 1;
+      else currentStreak = 1;
+      maxStreak = Math.max(maxStreak, currentStreak);
+      prevDay = row.day;
+    } else {
+      currentStreak = 0;
+      prevDay = row.day;
+    }
+    if (value > peakDay.value) peakDay = { day: row.day, value };
+
+    for (const [source, raw] of Object.entries(row.sources || {})) {
+      sourceTotals.set(source, (sourceTotals.get(source) || 0) + number(raw));
+    }
+    for (const [key, raw] of Object.entries(row.models || {})) {
+      const value = number(raw);
+      if (!value) continue;
+      const model = modelFromKey(key);
+      if (!isConcreteModel(model)) continue;
+      modelTotals.set(model, (modelTotals.get(model) || 0) + value);
+      const provider = inferModelProvider(model);
+      if (provider) providerTotals.set(provider, (providerTotals.get(provider) || 0) + value);
+    }
+  }
+
+  if (!totalValue && number(activity.total_tokens)) {
+    totalValue = number(activity.total_tokens);
+  }
+  if (!activeDays && number(activity.active_day_count)) {
+    activeDays = number(activity.active_day_count);
+  }
+
+  const topAgent = topKey(sourceTotals);
+  const topProvider = topKey(providerTotals);
+  const topModel = topKey(modelTotals);
+  const metric = activity.metric || (totalValue > 0 && activity.source === "token-tracker" ? "tokens" : "prompts");
+  const spanDays = rows.length > 0
+    ? Math.max(1, daysBetween(rows[0].day, rows[rows.length - 1].day) + 1)
+    : 0;
+  const activeRate = spanDays ? ((activeDays / spanDays) * 100).toFixed(1) : null;
+
+  return {
+    metric,
+    totalValue,
+    activeDays,
+    maxStreak,
+    peakDay,
+    topAgent,
+    topProvider,
+    topModel,
+    activeRate,
+    estimatedCostUsd: activity.estimated_cost_usd == null || activity.estimated_cost_usd === ""
+      ? null
+      : (Number.isFinite(Number(activity.estimated_cost_usd)) ? Number(activity.estimated_cost_usd) : null),
+  };
+}
+
+function topKey(totals) {
+  return [...totals.entries()]
+    .sort((a, b) => b[1] - a[1] || String(a[0]).localeCompare(String(b[0])))[0]?.[0] || null;
+}
+
+function modelFromKey(key) {
+  const [, ...modelParts] = String(key || "").split("/");
+  return (modelParts.join("/") || String(key || "")).trim();
+}
+
+function isConcreteModel(model) {
+  const normalized = String(model || "").trim().toLowerCase();
+  return Boolean(normalized) && !["auto", "unknown", "default", "other", "n/a"].includes(normalized);
+}
+
+function inferModelProvider(model) {
+  const value = String(model || "").trim().toLowerCase();
+  if (!isConcreteModel(value)) return null;
+  if (/(^|[-_/.])(gpt|chatgpt|codex|o[1-9])([-_/.]|$)/.test(value)) return "OpenAI";
+  if (/(claude|sonnet|opus|haiku)/.test(value)) return "Anthropic";
+  if (/(gemini|gemma)/.test(value)) return "Google";
+  if (/deepseek/.test(value)) return "DeepSeek";
+  if (/grok/.test(value)) return "xAI";
+  if (/(qwen|qwq)/.test(value)) return "Alibaba";
+  if (/llama/.test(value)) return "Meta";
+  if (/(mistral|mixtral|codestral)/.test(value)) return "Mistral";
+  if (/(command-r|cohere)/.test(value)) return "Cohere";
+  if (/(kimi|moonshot)/.test(value)) return "Moonshot";
+  if (/(glm|zhipu)/.test(value)) return "Zhipu";
+  if (/(ernie|baidu)/.test(value)) return "Baidu";
+  if (/(doubao|seed-code)/.test(value)) return "ByteDance";
+  if (/minimax/.test(value)) return "MiniMax";
+  if (/(nova|amazon)/.test(value)) return "Amazon";
+  if (/(phi[-_.]|^phi$)/.test(value)) return "Microsoft";
+  if (/composer/.test(value)) return "Cursor";
+  return null;
+}
+
+function formatModelName(model) {
+  return String(model || "")
+    .replace(/^gpt(?=[-_.]|$)/i, "GPT")
+    .replace(/^claude(?=[-_.]|$)/i, "Claude")
+    .replace(/^gemini(?=[-_.]|$)/i, "Gemini")
+    .replace(/^deepseek(?=[-_.]|$)/i, "DeepSeek")
+    .replace(/^grok(?=[-_.]|$)/i, "Grok");
+}
+
+function consecutiveDays(prev, next) {
+  if (!prev || !next) return false;
+  return daysBetween(prev, next) === 1;
+}
+
+function daysBetween(a, b) {
+  const am = Date.parse(`${a}T00:00:00.000Z`);
+  const bm = Date.parse(`${b}T00:00:00.000Z`);
+  if (!Number.isFinite(am) || !Number.isFinite(bm)) return NaN;
+  return Math.round((bm - am) / 86400000);
+}
+
+/**
+ * Score-card signals for Roast Result — prefers TokenTracker token KPIs
+ * over useful-prompt counts when daily token rows exist.
+ */
+function buildActivitySignals({ activity = {}, summary = {}, categories = {} } = {}) {
+  const stats = summarizeActivity(activity);
+  const topCategory = Object.entries(categories)
+    .filter(([key]) => key !== "reference")
+    .map(([key, row]) => [key, Number(row?.count || 0)])
+    .filter(([, count]) => count > 0)
+    .sort((a, b) => b[1] - a[1])[0];
+
+  if (stats.metric === "tokens" && stats.totalValue > 0) {
+    const signals = [
+      { label: "Total tokens", labelZh: "总 Tokens", value: compactNumber(stats.totalValue) },
+      {
+        label: "Active days",
+        labelZh: "活跃天数",
+        value: String(stats.activeDays || summary.active_day_count || 0),
+      },
+    ];
+    const cost = formatUsd(stats.estimatedCostUsd);
+    if (cost) {
+      signals.push({ label: "Est. cost", labelZh: "估算费用", value: cost });
+    }
+    if (stats.topAgent) {
+      signals.push({
+        label: "Top agent",
+        labelZh: "主 Agent",
+        value: String(stats.topAgent).toUpperCase(),
+      });
+    }
+    if (stats.topProvider) {
+      signals.push({
+        label: "Top provider",
+        labelZh: "主供应商",
+        value: stats.topProvider,
+      });
+    }
+    if (stats.topModel) {
+      signals.push({
+        label: "Top model",
+        labelZh: "主模型",
+        value: formatModelName(stats.topModel),
+      });
+    }
+    if (signals.length === 2) {
+      signals.push({
+        label: "Peak day",
+        labelZh: "峰值日",
+        value: stats.peakDay.value > 0 ? compactNumber(stats.peakDay.value) : "—",
+      });
+    }
+    return signals;
+  }
+
+  return [
+    {
+      label: "Active days",
+      labelZh: "活跃天数",
+      value: String(stats.activeDays || activity.active_day_count || 0),
+    },
+    {
+      label: "Agents found",
+      labelZh: "检测到 Agent",
+      value: String(summary.active_source_count ?? summary.source_count ?? 0),
+    },
+    {
+      label: "Top category",
+      labelZh: "主类别",
+      value: topCategory ? String(topCategory[0]) : "—",
+    },
+  ];
+}
+
+module.exports = {
+  compactNumber,
+  formatUsd,
+  inferModelProvider,
+  summarizeActivity,
+  buildActivitySignals,
+};