vibe-roast 0.98.0

package/src/lib/dates.js

@@ -0,0 +1,43 @@
+function dayBounds(from, to) {
+  return {
+    fromMs: from ? Date.parse(`${from}T00:00:00.000Z`) : null,
+    toMs: to ? Date.parse(`${to}T23:59:59.999Z`) : null,
+  };
+}
+
+function isInRange(timestamp, range) {
+  const bounds = normalizeRange(range);
+  const hasActiveRange = bounds.fromMs != null || bounds.toMs != null;
+  if (!timestamp) return !hasActiveRange;
+  const ms = Date.parse(timestamp);
+  if (!Number.isFinite(ms)) return !hasActiveRange;
+  if (bounds.fromMs != null && ms < bounds.fromMs) return false;
+  if (bounds.toMs != null && ms > bounds.toMs) return false;
+  return true;
+}
+
+function normalizeRange(range) {
+  if (!range) return { fromMs: null, toMs: null };
+  return {
+    fromMs: finiteNumber(range.fromMs) ?? parseBoundary(range.from, "start"),
+    toMs: finiteNumber(range.toMs) ?? parseBoundary(range.to, "end"),
+  };
+}
+
+function parseBoundary(value, side) {
+  if (!value) return null;
+  const raw = String(value);
+  const stamp = raw.includes("T")
+    ? raw
+    : `${raw}T${side === "start" ? "00:00:00.000Z" : "23:59:59.999Z"}`;
+  const ms = Date.parse(stamp);
+  return Number.isFinite(ms) ? ms : null;
+}
+
+function finiteNumber(value) {
+  if (value == null) return null;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+module.exports = { dayBounds, isInRange };

package/src/lib/hashtags.js

@@ -0,0 +1,150 @@
+/** Derive shareable #hashtags from vibe profile + category signals (EN / ZH). */
+
+const ARCHETYPE_TAGS = {
+  "01-builder": { en: "Builder", zh: "构建侠" },
+  "02-debugger": { en: "Debugger", zh: "调试猎手" },
+  "03-architect": { en: "Architect", zh: "架构师" },
+  "04-codex-believer": { en: "CodexBeliever", zh: "Codex信徒" },
+  "05-prompt-priest": { en: "PromptPriest", zh: "提示祭司" },
+  "06-tab-hoarder": { en: "TabHoarder", zh: "标签囤积癖" },
+  "07-context-maxxer": { en: "ContextMaxxer", zh: "上下文极限党" },
+  "08-yolo-shipper": { en: "YoloShipper", zh: "YOLO上线狂" },
+};
+
+const CODE_TAGS = {
+  SHIP: { en: "ShipIt", zh: "直接上线" },
+  HUNT: { en: "BugHunt", zh: "猎虫" },
+  DRAW: { en: "Blueprint", zh: "蓝图先行" },
+  FAITH: { en: "CodexFaith", zh: "Codex信仰" },
+  SPELL: { en: "SpellCraft", zh: "法术工艺" },
+  TABS: { en: "TabHoard", zh: "标签囤积" },
+  METER: { en: "CtxMeter", zh: "上下文表" },
+  YOLO: { en: "YoloShip", zh: "YOLO发车" },
+};
+
+const CATEGORY_TAGS = {
+  planning: { en: "Planning", zh: "规划" },
+  debugging: { en: "Debugging", zh: "调试" },
+  implementation: { en: "Implementation", zh: "实现" },
+  refactor: { en: "Refactor", zh: "重构" },
+  testing: { en: "Testing", zh: "测试" },
+  packaging: { en: "Packaging", zh: "打包" },
+  explanation: { en: "Explanation", zh: "讲解" },
+  research: { en: "Research", zh: "调研" },
+  ui_design: { en: "UIDesign", zh: "UI设计" },
+  workflow: { en: "Workflow", zh: "工作流" },
+};
+
+const TIER_TAGS = {
+  GOD: { en: "GOD", zh: "神级" },
+  ELITE: { en: "ELITE", zh: "精英" },
+  SOLID: { en: "SOLID", zh: "扎实" },
+  NPC: { en: "NPC", zh: "路人甲" },
+  TRASH: { en: "TRASH", zh: "垃分" },
+};
+
+function pickLocale(entry, zh) {
+  if (!entry) return "";
+  if (typeof entry === "string") return entry;
+  return zh ? entry.zh || entry.en : entry.en || entry.zh;
+}
+
+function pascalCase(value) {
+  return String(value || "")
+    .replace(/[_-]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .split(" ")
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+    .join("");
+}
+
+function categoryCount(categories, name) {
+  const row = categories?.[name];
+  if (row == null) return 0;
+  if (typeof row === "number") return Number.isFinite(row) ? row : 0;
+  const count = Number(row.count);
+  return Number.isFinite(count) ? count : 0;
+}
+
+function normalizeOpts(opts) {
+  if (typeof opts === "number") return { limit: opts };
+  return opts || {};
+}
+
+function buildHashtags(vibe, categories = {}, opts = {}) {
+  const options = normalizeOpts(opts);
+  const limit = options.limit ?? 8;
+  const zh = options.locale === "zh";
+  const tags = [];
+  const seen = new Set();
+
+  function push(raw) {
+    const bare = String(raw || "")
+      .replace(/^#+/, "")
+      .replace(/[^A-Za-z0-9\u4e00-\u9fff]/g, "");
+    if (!bare) return;
+    const tag = `#${bare}`;
+    const key = tag.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    tags.push(tag);
+  }
+
+  const arch = vibe?.archetype || {};
+  const archId = arch.id || "";
+  if (ARCHETYPE_TAGS[archId]) {
+    push(pickLocale(ARCHETYPE_TAGS[archId], zh));
+  } else if (arch.title) {
+    push(zh ? arch.titleZh || arch.title : pascalCase(arch.title));
+  }
+
+  if (arch.code && CODE_TAGS[arch.code]) {
+    push(pickLocale(CODE_TAGS[arch.code], zh));
+  } else if (arch.code) {
+    push(/^[MA][OP][VS][FX]$/.test(arch.code) ? arch.code : pascalCase(arch.code));
+  }
+
+  const tierId = vibe?.tier?.id;
+  if (!vibe?.type_code && tierId && TIER_TAGS[tierId]) push(pickLocale(TIER_TAGS[tierId], zh));
+  else if (!vibe?.type_code && tierId) push(tierId);
+
+  const ranked = Object.keys(CATEGORY_TAGS)
+    .map((key) => [key, categoryCount(categories, key)])
+    .filter(([, count]) => count > 0)
+    .sort((a, b) => b[1] - a[1]);
+
+  for (const [key] of ranked) {
+    push(pickLocale(CATEGORY_TAGS[key], zh));
+    if (tags.length >= limit) break;
+  }
+
+  const hookSrc = zh ? arch.hookZh || arch.hook : arch.hook;
+  if (hookSrc) {
+    const hookWord = String(hookSrc).split(/[\s·•\-–—,/，、]+/)[0];
+    if (hookWord && hookWord.length > 1) {
+      push(zh ? hookWord : pascalCase(hookWord));
+    }
+  }
+
+  return tags.slice(0, limit);
+}
+
+function mergeHashtags(generated = [], limit = 8) {
+  const tags = [];
+  const seen = new Set();
+  for (const raw of generated || []) {
+    const bare = String(raw || "")
+      .replace(/^#+/, "")
+      .replace(/[^A-Za-z0-9\u4e00-\u9fff]/g, "");
+    if (!bare) continue;
+    const key = bare.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    tags.push(`#${bare}`);
+  }
+  return tags.slice(0, limit);
+}
+
+module.exports = { buildHashtags, mergeHashtags, CODE_TAGS, ARCHETYPE_TAGS, CATEGORY_TAGS, TIER_TAGS };

package/src/lib/jsonl.js

@@ -0,0 +1,48 @@
+const fs = require("node:fs/promises");
+const fssync = require("node:fs");
+const path = require("node:path");
+const readline = require("node:readline");
+
+async function walkFiles(rootDir, predicate) {
+  const out = [];
+  const stack = [rootDir];
+
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const filePath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(filePath);
+      } else if (entry.isFile() && predicate(filePath, entry.name)) {
+        out.push(filePath);
+      }
+    }
+  }
+
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+
+async function readJsonl(filePath, onObject) {
+  const stream = fssync.createReadStream(filePath, { encoding: "utf8" });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      await onObject(JSON.parse(trimmed));
+    } catch {
+      // Session logs can contain partial tail writes. Skip malformed lines.
+    }
+  }
+}
+
+module.exports = { walkFiles, readJsonl };

package/src/lib/load-env.js

@@ -0,0 +1,59 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function parseEnvValue(raw) {
+  const value = String(raw || "").trim();
+  if (value.length >= 2 && value[0] === "\"" && value[value.length - 1] === "\"") {
+    return value.slice(1, -1)
+      .replace(/\\n/g, "\n")
+      .replace(/\\r/g, "\r")
+      .replace(/\\t/g, "\t")
+      .replace(/\\"/g, "\"")
+      .replace(/\\\\/g, "\\");
+  }
+  if (value.length >= 2 && value[0] === "'" && value[value.length - 1] === "'") {
+    return value.slice(1, -1);
+  }
+  return value.replace(/\s+#.*$/, "").trim();
+}
+
+function loadEnvFallback(filePath) {
+  const text = fs.readFileSync(filePath, "utf8");
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+    if (!match || process.env[match[1]] !== undefined) continue;
+    process.env[match[1]] = parseEnvValue(match[2]);
+  }
+}
+
+function resolveLocalEnv(cwd = process.cwd()) {
+  for (const name of [".env.local", ".env"]) {
+    const candidate = path.resolve(cwd, name);
+    try {
+      if (fs.statSync(candidate).isFile()) return candidate;
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+    }
+  }
+  return null;
+}
+
+function loadLocalEnv(filePath) {
+  const resolved = filePath || resolveLocalEnv();
+  if (!resolved) return false;
+  if (typeof process.loadEnvFile === "function") {
+    process.loadEnvFile(resolved);
+  } else {
+    loadEnvFallback(resolved);
+  }
+  return true;
+}
+
+module.exports = {
+  loadLocalEnv,
+  loadEnvFallback,
+  parseEnvValue,
+  resolveLocalEnv,
+};

package/src/lib/roast-evidence.js

@@ -0,0 +1,186 @@
+/** Build the privacy-bounded, deterministic evidence packet consumed by an AI roast writer. */
+
+function finiteNumber(value, fallback = 0) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+
+function categoryRows(categories = {}) {
+  return Object.entries(categories)
+    .map(([key, row]) => ({
+      key,
+      count: finiteNumber(typeof row === "number" ? row : row?.count),
+    }))
+    .filter((row) => row.count > 0)
+    .sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
+}
+
+function conceptRows(wordFrequencies = [], limit = 16) {
+  return (wordFrequencies || [])
+    .map((row) => ({
+      term: String(row?.term || "").trim().slice(0, 48),
+      occurrence_count: finiteNumber(row?.count),
+      prompt_coverage: finiteNumber(row?.prompt_count),
+      weight: finiteNumber(row?.weight),
+    }))
+    .filter((row) => row.term && row.occurrence_count > 0)
+    .slice(0, limit);
+}
+
+function domainConceptRows(records = [], limit = 12) {
+  const concepts = new Map();
+  for (const record of records || []) {
+    const seen = new Set();
+    for (const item of record?.concepts || []) {
+      if (!item?.key || item.kind === "category" || item.vibe) continue;
+      const row = concepts.get(item.key) || {
+        key: item.key,
+        acronym: Boolean(item.acronym),
+        occurrence_count: 0,
+        prompt_coverage: 0,
+        variants: new Map(),
+      };
+      for (const [term, rawCount] of Object.entries(item.variants || {})) {
+        const count = Math.max(0, finiteNumber(rawCount));
+        if (!term || count <= 0) continue;
+        row.occurrence_count += count;
+        row.variants.set(term, (row.variants.get(term) || 0) + count);
+      }
+      if (!seen.has(item.key)) {
+        row.prompt_coverage += 1;
+        seen.add(item.key);
+      }
+      concepts.set(item.key, row);
+    }
+  }
+
+  return [...concepts.values()]
+    .filter((row) => row.prompt_coverage >= 3)
+    .map((row) => {
+      const term = [...row.variants.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0]?.[0] || row.key;
+      const repetition = row.occurrence_count / Math.max(1, row.prompt_coverage);
+      return {
+        term: String(term).slice(0, 48),
+        occurrence_count: row.occurrence_count,
+        prompt_coverage: row.prompt_coverage,
+        acronym: row.acronym,
+        salience: Math.round(
+          Math.log2(1 + row.prompt_coverage) * Math.min(3, repetition) * (row.acronym ? 1.25 : 1) * 1000,
+        ) / 1000,
+      };
+    })
+    .sort((a, b) => (
+      b.salience - a.salience
+      || b.prompt_coverage - a.prompt_coverage
+      || b.occurrence_count - a.occurrence_count
+      || a.term.localeCompare(b.term)
+    ))
+    .slice(0, limit);
+}
+
+function dimensionRows(dimensions = []) {
+  return (dimensions || []).map((dimension) => ({
+    key: dimension.key,
+    label: dimension.label,
+    label_zh: dimension.labelZh,
+    value: finiteNumber(dimension.value),
+  }));
+}
+
+function axisRows(axes = []) {
+  return (axes || []).map((axis) => ({
+    key: axis.key,
+    chosen: axis.letter,
+    left: { code: axis.left?.code, percent: finiteNumber(axis.left?.percent) },
+    right: { code: axis.right?.code, percent: finiteNumber(axis.right?.percent) },
+    margin: finiteNumber(axis.margin),
+  }));
+}
+
+function buildContradictions(vibe, categories) {
+  const notes = [];
+  const dimensions = [...(vibe?.dimensions || [])]
+    .sort((a, b) => finiteNumber(a.value) - finiteNumber(b.value));
+  const closest = [...(vibe?.type_axes || [])]
+    .sort((a, b) => finiteNumber(a.margin) - finiteNumber(b.margin))[0];
+  const rows = categoryRows(categories);
+  const counts = Object.fromEntries(rows.map((row) => [row.key, row.count]));
+
+  if (dimensions.length >= 2) {
+    notes.push({
+      kind: "strongest_vs_weakest_dimension",
+      strongest: dimensions[dimensions.length - 1].key,
+      strongest_value: finiteNumber(dimensions[dimensions.length - 1].value),
+      weakest: dimensions[0].key,
+      weakest_value: finiteNumber(dimensions[0].value),
+    });
+  }
+  if (closest) {
+    notes.push({
+      kind: "closest_personality_split",
+      axis: closest.key,
+      left: `${closest.left?.code}:${finiteNumber(closest.left?.percent)}`,
+      right: `${closest.right?.code}:${finiteNumber(closest.right?.percent)}`,
+    });
+  }
+
+  const building = finiteNumber(counts.implementation) + finiteNumber(counts.packaging) + finiteNumber(counts.ui_design);
+  const verifying = finiteNumber(counts.testing) + finiteNumber(counts.debugging) + finiteNumber(counts.refactor);
+  if (building + verifying > 0) {
+    notes.push({
+      kind: "building_vs_verifying",
+      building,
+      verifying,
+      ratio: Math.round((building / Math.max(verifying, 1)) * 10) / 10,
+    });
+  }
+  return notes;
+}
+
+function buildRoastEvidence(report = {}) {
+  const vibe = report.vibe_profile || {};
+  const categories = report.profile_signals?.prompt_analysis?.categories || {};
+  const activity = report.activity || {};
+  const summary = report.summary || {};
+
+  return {
+    schema_version: 1,
+    immutable_profile: {
+      type_code: vibe.type_code,
+      personality: vibe.personality?.title,
+      personality_zh: vibe.personality?.titleZh,
+      confidence: finiteNumber(vibe.confidence),
+      status: vibe.status,
+      axes: axisRows(vibe.type_axes),
+      dimensions: dimensionRows(vibe.dimensions),
+    },
+    prompt_behavior: {
+      useful_prompt_count: finiteNumber(report.profile_signals?.prompt_analysis?.useful_prompt_count),
+      categories: categoryRows(categories),
+      recurring_behavior_terms: conceptRows(report.word_frequencies, 12),
+      recurring_domain_concepts: domainConceptRows(report.word_cloud_records),
+    },
+    activity: {
+      metric: activity.metric,
+      total_tokens: finiteNumber(activity.total_tokens),
+      active_days: finiteNumber(activity.active_day_count),
+      longest_streak: finiteNumber(activity.longest_streak),
+      active_rate: activity.active_rate || null,
+      top_agent: activity.top_agent || null,
+      top_provider: activity.top_provider || null,
+      top_model: activity.top_model || null,
+      active_agents: (summary.active_sources || []).slice(0, 12),
+    },
+    roast_targets: buildContradictions(vibe, categories),
+    guardrails: {
+      profile_is_immutable: true,
+      aggregate_evidence_only: true,
+      raw_prompts_included: false,
+      attack_behavior_not_identity: true,
+      unsupported_claims_forbidden: true,
+    },
+  };
+}
+
+module.exports = { buildRoastEvidence, buildContradictions, domainConceptRows };

package/src/lib/roast-snapshot.js

@@ -0,0 +1,58 @@
+const SNAPSHOT_VERSION = 1;
+const WRITER_PROMPT_VERSION = 3;
+
+function finite(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : 0;
+}
+
+function normalizedTerm(value) {
+  return String(value || "").trim().toLocaleLowerCase().slice(0, 48);
+}
+
+function buildRoastSnapshot(evidence = {}) {
+  const profile = evidence.immutable_profile || {};
+  const categories = evidence.prompt_behavior?.categories || [];
+  const categoryTotal = categories.reduce((total, row) => total + Math.max(0, finite(row?.count)), 0);
+  const concepts = [
+    ...(evidence.prompt_behavior?.recurring_domain_concepts || []),
+    ...(evidence.prompt_behavior?.recurring_behavior_terms || []),
+  ];
+
+  return {
+    snapshot_version: SNAPSHOT_VERSION,
+    writer_prompt_version: WRITER_PROMPT_VERSION,
+    evidence_schema_version: finite(evidence.schema_version),
+    type_code: String(profile.type_code || ""),
+    status: String(profile.status || ""),
+    confidence: Math.round(finite(profile.confidence)),
+    axes: (profile.axes || []).map((axis) => ({
+      key: String(axis?.key || ""),
+      chosen: String(axis?.chosen || ""),
+      left_percent: Math.round(finite(axis?.left?.percent)),
+    })).filter((axis) => axis.key),
+    dimensions: (profile.dimensions || []).map((dimension) => ({
+      key: String(dimension?.key || ""),
+      value: Math.round(finite(dimension?.value)),
+    })).filter((dimension) => dimension.key),
+    category_shares: categories.map((row) => ({
+      key: String(row?.key || ""),
+      share: categoryTotal > 0
+        ? Math.round((Math.max(0, finite(row?.count)) / categoryTotal) * 100)
+        : 0,
+    })).filter((row) => row.key),
+    concepts: [...new Set(concepts.map((row) => normalizedTerm(row?.term)).filter(Boolean))].slice(0, 8),
+    top_agent: String(evidence.activity?.top_agent || ""),
+  };
+}
+
+function encodeRoastSnapshot(evidence) {
+  return Buffer.from(JSON.stringify(buildRoastSnapshot(evidence)), "utf8").toString("base64url");
+}
+
+module.exports = {
+  SNAPSHOT_VERSION,
+  WRITER_PROMPT_VERSION,
+  buildRoastSnapshot,
+  encodeRoastSnapshot,
+};