reasonix 0.0.6 → 0.2.2

package/dist/index.js

@@ -1284,7 +1284,13 @@ var CacheFirstLoop = class {
           name,
           content: result
         });
-        yield { turn: this._turn, role: "tool", content: result, toolName: name };
+        yield {
+          turn: this._turn,
+          role: "tool",
+          content: result,
+          toolName: name,
+          toolArgs: args
+        };
       }
     }
     yield { turn: this._turn, role: "done", content: "[max_tool_iters reached]" };
@@ -1337,8 +1343,431 @@ function loadDotenv(path = ".env") {
   }
 }
 
+// src/transcript.ts
+import { createWriteStream, readFileSync as readFileSync3 } from "fs";
+function recordFromLoopEvent(ev, extra) {
+  const rec = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    turn: ev.turn,
+    role: ev.role,
+    content: ev.content
+  };
+  if (ev.toolName !== void 0) rec.tool = ev.toolName;
+  if (ev.toolArgs !== void 0) rec.args = ev.toolArgs;
+  if (ev.error !== void 0) rec.error = ev.error;
+  if (ev.stats) {
+    rec.usage = {
+      prompt_tokens: ev.stats.usage.promptTokens,
+      completion_tokens: ev.stats.usage.completionTokens,
+      total_tokens: ev.stats.usage.totalTokens,
+      prompt_cache_hit_tokens: ev.stats.usage.promptCacheHitTokens,
+      prompt_cache_miss_tokens: ev.stats.usage.promptCacheMissTokens
+    };
+    rec.cost = ev.stats.cost;
+    rec.model = ev.stats.model;
+    rec.prefixHash = extra.prefixHash;
+  } else if (ev.role === "assistant_final") {
+    rec.model = extra.model;
+    rec.prefixHash = extra.prefixHash;
+  }
+  return rec;
+}
+function writeRecord(stream, record) {
+  stream.write(`${JSON.stringify(record)}
+`);
+}
+function writeMeta(stream, meta) {
+  const line = { role: "_meta", meta };
+  stream.write(`${JSON.stringify(line)}
+`);
+}
+function openTranscriptFile(path, meta) {
+  const stream = createWriteStream(path, { flags: "a" });
+  writeMeta(stream, meta);
+  return stream;
+}
+function readTranscript(path) {
+  const raw = readFileSync3(path, "utf8");
+  return parseTranscript(raw);
+}
+function parseTranscript(raw) {
+  const out = { meta: null, records: [] };
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!obj || typeof obj !== "object") continue;
+    const rec = obj;
+    if (rec.role === "_meta" && rec.meta && typeof rec.meta === "object") {
+      out.meta = rec.meta;
+      continue;
+    }
+    if (typeof rec.ts === "string" && typeof rec.turn === "number" && typeof rec.role === "string" && typeof rec.content === "string") {
+      out.records.push(rec);
+    }
+  }
+  return out;
+}
+
+// src/replay.ts
+function replayFromFile(path) {
+  const parsed = readTranscript(path);
+  return { parsed, stats: computeReplayStats(parsed.records) };
+}
+function computeReplayStats(records) {
+  const turns = [];
+  const models = /* @__PURE__ */ new Set();
+  const prefixHashes = /* @__PURE__ */ new Set();
+  let userTurns = 0;
+  let toolCalls = 0;
+  for (const rec of records) {
+    if (rec.role === "user") userTurns++;
+    else if (rec.role === "tool") toolCalls++;
+    else if (rec.role === "assistant_final") {
+      if (rec.model) models.add(rec.model);
+      if (rec.prefixHash) prefixHashes.add(rec.prefixHash);
+      if (rec.usage && rec.model) {
+        const u = new Usage(
+          rec.usage.prompt_tokens ?? 0,
+          rec.usage.completion_tokens ?? 0,
+          rec.usage.total_tokens ?? 0,
+          rec.usage.prompt_cache_hit_tokens ?? 0,
+          rec.usage.prompt_cache_miss_tokens ?? 0
+        );
+        turns.push({
+          turn: rec.turn,
+          model: rec.model,
+          usage: u,
+          // `rec.cost` wins when present — honors whatever the writer computed
+          // even if pricing tables have since changed. Only recompute when
+          // the transcript didn't record it (old format).
+          cost: rec.cost ?? costUsd(rec.model, u),
+          cacheHitRatio: u.cacheHitRatio
+        });
+      }
+    }
+  }
+  return {
+    perTurn: turns,
+    models: [...models],
+    prefixHashes: [...prefixHashes],
+    userTurns,
+    toolCalls,
+    ...summarizeTurns(turns)
+  };
+}
+function summarizeTurns(turns) {
+  const totalCost = turns.reduce((s, t) => s + t.cost, 0);
+  const totalClaude = turns.reduce((s, t) => s + claudeEquivalentCost(t.usage), 0);
+  let hit = 0;
+  let miss = 0;
+  for (const t of turns) {
+    hit += t.usage.promptCacheHitTokens;
+    miss += t.usage.promptCacheMissTokens;
+  }
+  const cacheHitRatio = hit + miss > 0 ? hit / (hit + miss) : 0;
+  const savingsVsClaude = totalClaude > 0 ? 1 - totalCost / totalClaude : 0;
+  return {
+    turns: turns.length,
+    totalCostUsd: round2(totalCost, 6),
+    claudeEquivalentUsd: round2(totalClaude, 6),
+    savingsVsClaudePct: round2(savingsVsClaude * 100, 2),
+    cacheHitRatio: round2(cacheHitRatio, 4)
+  };
+}
+function round2(n, digits) {
+  const f = 10 ** digits;
+  return Math.round(n * f) / f;
+}
+
+// src/diff.ts
+function diffTranscripts(a, b) {
+  const aSide = {
+    label: a.label,
+    meta: a.parsed.meta,
+    records: a.parsed.records,
+    stats: computeReplayStats(a.parsed.records)
+  };
+  const bSide = {
+    label: b.label,
+    meta: b.parsed.meta,
+    records: b.parsed.records,
+    stats: computeReplayStats(b.parsed.records)
+  };
+  const aByTurn = groupByTurn(a.parsed.records);
+  const bByTurn = groupByTurn(b.parsed.records);
+  const turns = [.../* @__PURE__ */ new Set([...aByTurn.keys(), ...bByTurn.keys()])].sort((x, y) => x - y);
+  const pairs = [];
+  let firstDivergenceTurn = null;
+  for (const turn of turns) {
+    const aGroup = aByTurn.get(turn) ?? { assistant: void 0, tools: [] };
+    const bGroup = bByTurn.get(turn) ?? { assistant: void 0, tools: [] };
+    const aAssistant = aGroup.assistant;
+    const bAssistant = bGroup.assistant;
+    const aTools = aGroup.tools;
+    const bTools = bGroup.tools;
+    let kind;
+    let divergenceNote;
+    if (!aAssistant && bAssistant) kind = "only_in_b";
+    else if (aAssistant && !bAssistant) kind = "only_in_a";
+    else if (!aAssistant && !bAssistant)
+      kind = "diverge";
+    else {
+      divergenceNote = classifyDivergence(aAssistant, bAssistant, aTools, bTools);
+      kind = divergenceNote ? "diverge" : "match";
+    }
+    if (kind !== "match" && firstDivergenceTurn === null) firstDivergenceTurn = turn;
+    pairs.push({ turn, aAssistant, bAssistant, aTools, bTools, kind, divergenceNote });
+  }
+  return { a: aSide, b: bSide, pairs, firstDivergenceTurn };
+}
+function classifyDivergence(a, b, aTools, bTools) {
+  const aNames = aTools.map((t) => t.tool ?? "").sort();
+  const bNames = bTools.map((t) => t.tool ?? "").sort();
+  if (aNames.join(",") !== bNames.join(",")) {
+    return `tool calls differ: A=[${aNames.join(",") || "\u2014"}] B=[${bNames.join(",") || "\u2014"}]`;
+  }
+  for (let i = 0; i < aTools.length; i++) {
+    const at = aTools[i];
+    const bt = bTools[i];
+    if (at.tool !== bt.tool) continue;
+    if ((at.args ?? "") !== (bt.args ?? "")) {
+      return `"${at.tool}" args differ`;
+    }
+  }
+  const simRatio = similarity(a.content, b.content);
+  if (simRatio < 0.75) return `text similarity ${(simRatio * 100).toFixed(0)}%`;
+  return void 0;
+}
+function similarity(a, b) {
+  if (a === b) return 1;
+  if (!a && !b) return 1;
+  if (!a || !b) return 0;
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen > 2e3) return tokenOverlap(a, b);
+  const dist = levenshtein(a, b);
+  return 1 - dist / maxLen;
+}
+function tokenOverlap(a, b) {
+  const ta = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+  const tb = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+  if (ta.size === 0 && tb.size === 0) return 1;
+  let shared = 0;
+  for (const t of ta) if (tb.has(t)) shared++;
+  return 2 * shared / (ta.size + tb.size);
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
+function groupByTurn(records) {
+  const out = /* @__PURE__ */ new Map();
+  for (const rec of records) {
+    if (rec.role === "user") continue;
+    const g = out.get(rec.turn) ?? { tools: [] };
+    if (rec.role === "assistant_final") g.assistant = rec;
+    else if (rec.role === "tool") g.tools.push(rec);
+    out.set(rec.turn, g);
+  }
+  return out;
+}
+function renderSummaryTable(report, _opts = {}) {
+  const a = report.a;
+  const b = report.b;
+  const lines = [];
+  lines.push("Comparing:");
+  lines.push(`  A  ${a.label}`);
+  lines.push(`  B  ${b.label}`);
+  lines.push("");
+  lines.push(row(["", "A", "B", "\u0394"], [20, 14, 14, 14]));
+  lines.push(
+    row(["\u2500".repeat(20), "\u2500".repeat(14), "\u2500".repeat(14), "\u2500".repeat(14)], [20, 14, 14, 14])
+  );
+  lines.push(statRow("model calls", a.stats.turns, b.stats.turns));
+  lines.push(statRow("user turns", a.stats.userTurns, b.stats.userTurns));
+  lines.push(statRow("tool calls", a.stats.toolCalls, b.stats.toolCalls));
+  lines.push(
+    row(
+      [
+        "cache hit",
+        `${pct(a.stats.cacheHitRatio)}`,
+        `${pct(b.stats.cacheHitRatio)}`,
+        signPct(b.stats.cacheHitRatio - a.stats.cacheHitRatio)
+      ],
+      [20, 14, 14, 14]
+    )
+  );
+  lines.push(
+    row(
+      [
+        "cost (USD)",
+        `$${a.stats.totalCostUsd.toFixed(6)}`,
+        `$${b.stats.totalCostUsd.toFixed(6)}`,
+        costDelta(a.stats.totalCostUsd, b.stats.totalCostUsd)
+      ],
+      [20, 14, 14, 14]
+    )
+  );
+  lines.push(statRow("prefix hashes", a.stats.prefixHashes.length, b.stats.prefixHashes.length));
+  lines.push("");
+  const aPrefixStable = a.stats.prefixHashes.length <= 1;
+  const bPrefixStable = b.stats.prefixHashes.length <= 1;
+  if (aPrefixStable !== bPrefixStable) {
+    const stable = aPrefixStable ? "A" : "B";
+    const churn = aPrefixStable ? "B" : "A";
+    const churnCount = aPrefixStable ? b.stats.prefixHashes.length : a.stats.prefixHashes.length;
+    lines.push(
+      `prefix stability: ${stable} stayed byte-stable across ${Math.max(
+        a.stats.turns,
+        b.stats.turns
+      )} turns; ${churn} churned ${churnCount} distinct prefixes.`
+    );
+    lines.push("");
+  } else if (a.stats.prefixHashes[0] && a.stats.prefixHashes[0] === b.stats.prefixHashes[0]) {
+    lines.push(
+      `prefix: A and B share the same prefix hash (${a.stats.prefixHashes[0].slice(0, 12)}\u2026) \u2014 cache delta is attributable to log stability, not prompt change.`
+    );
+    lines.push("");
+  }
+  if (report.firstDivergenceTurn !== null) {
+    const p = report.pairs.find((p2) => p2.turn === report.firstDivergenceTurn);
+    lines.push(
+      `first divergence: turn ${report.firstDivergenceTurn} \u2014 ${p?.divergenceNote ?? "?"}`
+    );
+    if (p?.aAssistant) lines.push(`  A \u2192 ${truncate(p.aAssistant.content, 100)}`);
+    if (p?.bAssistant) lines.push(`  B \u2192 ${truncate(p.bAssistant.content, 100)}`);
+  } else {
+    lines.push("no material divergence detected (texts within similarity threshold).");
+  }
+  return lines.join("\n");
+}
+function renderMarkdown(report) {
+  const a = report.a;
+  const b = report.b;
+  const out = [];
+  out.push(`# Transcript diff: ${a.label} vs ${b.label}`);
+  out.push("");
+  if (a.meta || b.meta) {
+    out.push("## Meta");
+    out.push("");
+    out.push(`| | ${a.label} | ${b.label} |`);
+    out.push("|---|---|---|");
+    out.push(`| source | ${a.meta?.source ?? "\u2014"} | ${b.meta?.source ?? "\u2014"} |`);
+    out.push(`| model | ${a.meta?.model ?? "\u2014"} | ${b.meta?.model ?? "\u2014"} |`);
+    out.push(`| task | ${a.meta?.task ?? "\u2014"} | ${b.meta?.task ?? "\u2014"} |`);
+    out.push(`| startedAt | ${a.meta?.startedAt ?? "\u2014"} | ${b.meta?.startedAt ?? "\u2014"} |`);
+    out.push("");
+  }
+  out.push("## Summary");
+  out.push("");
+  out.push(`| metric | ${a.label} | ${b.label} | delta |`);
+  out.push("|---|---:|---:|---:|");
+  out.push(
+    `| model calls | ${a.stats.turns} | ${b.stats.turns} | ${signed(b.stats.turns - a.stats.turns)} |`
+  );
+  out.push(
+    `| user turns | ${a.stats.userTurns} | ${b.stats.userTurns} | ${signed(b.stats.userTurns - a.stats.userTurns)} |`
+  );
+  out.push(
+    `| tool calls | ${a.stats.toolCalls} | ${b.stats.toolCalls} | ${signed(b.stats.toolCalls - a.stats.toolCalls)} |`
+  );
+  out.push(
+    `| cache hit | ${pct(a.stats.cacheHitRatio)} | ${pct(b.stats.cacheHitRatio)} | **${signPct(b.stats.cacheHitRatio - a.stats.cacheHitRatio)}** |`
+  );
+  out.push(
+    `| cost (USD) | $${a.stats.totalCostUsd.toFixed(6)} | $${b.stats.totalCostUsd.toFixed(6)} | ${costDelta(a.stats.totalCostUsd, b.stats.totalCostUsd)} |`
+  );
+  out.push(
+    `| prefix hashes | ${a.stats.prefixHashes.length} | ${b.stats.prefixHashes.length} | \u2014 |`
+  );
+  out.push("");
+  out.push("## Turn-by-turn");
+  out.push("");
+  out.push(`| turn | kind | ${a.label} tool calls | ${b.label} tool calls | note |`);
+  out.push("|---:|:---:|---|---|---|");
+  for (const p of report.pairs) {
+    const aTools = p.aTools.map((t) => t.tool).filter(Boolean).join(", ") || "\u2014";
+    const bTools = p.bTools.map((t) => t.tool).filter(Boolean).join(", ") || "\u2014";
+    out.push(`| ${p.turn} | ${p.kind} | ${aTools} | ${bTools} | ${p.divergenceNote ?? ""} |`);
+  }
+  out.push("");
+  if (report.firstDivergenceTurn !== null) {
+    const p = report.pairs.find((x) => x.turn === report.firstDivergenceTurn);
+    out.push(`## First divergence (turn ${report.firstDivergenceTurn})`);
+    out.push("");
+    out.push(p?.divergenceNote ?? "");
+    out.push("");
+    if (p?.aAssistant) {
+      out.push(`**${a.label}:**`);
+      out.push("");
+      out.push("```");
+      out.push(p.aAssistant.content);
+      out.push("```");
+      out.push("");
+    }
+    if (p?.bAssistant) {
+      out.push(`**${b.label}:**`);
+      out.push("");
+      out.push("```");
+      out.push(p.bAssistant.content);
+      out.push("```");
+      out.push("");
+    }
+  }
+  return out.join("\n");
+}
+function row(cols, widths) {
+  return cols.map((c, i) => padRight(c, widths[i] ?? c.length)).join(" ");
+}
+function statRow(label, av, bv) {
+  return row([label, `${av}`, `${bv}`, signed(bv - av)], [20, 14, 14, 14]);
+}
+function padRight(s, w) {
+  return s.length >= w ? s : s + " ".repeat(w - s.length);
+}
+function signed(n) {
+  if (n === 0) return "0";
+  return `${n > 0 ? "+" : ""}${n}`;
+}
+function signPct(diff) {
+  if (diff === 0) return "0pp";
+  const s = (diff * 100).toFixed(1);
+  return `${diff > 0 ? "+" : ""}${s}pp`;
+}
+function pct(x) {
+  return `${(x * 100).toFixed(1)}%`;
+}
+function costDelta(a, b) {
+  if (a === 0 && b === 0) return "\u2014";
+  if (a === 0) return "new";
+  const pctChange = (b - a) / a * 100;
+  return `${pctChange > 0 ? "+" : ""}${pctChange.toFixed(1)}%`;
+}
+function truncate(s, n) {
+  return s.length > n ? `${s.slice(0, n)}\u2026` : s;
+}
+
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join2 } from "path";
 function defaultConfigPath() {
@@ -1346,7 +1775,7 @@ function defaultConfigPath() {
 }
 function readConfig(path = defaultConfigPath()) {
   try {
-    const raw = readFileSync3(path, "utf8");
+    const raw = readFileSync4(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -1381,7 +1810,7 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.0.1";
+var VERSION = "0.2.2";
 export {
   AppendOnlyLog,
   CacheFirstLoop,
@@ -1398,10 +1827,12 @@ export {
   analyzeSchema,
   appendSessionMessage,
   claudeEquivalentCost,
+  computeReplayStats,
   costUsd,
   defaultConfigPath,
   defaultSelector,
   deleteSession,
+  diffTranscripts,
   emptyPlanState,
   fetchWithRetry,
   flattenSchema,
@@ -1413,15 +1844,25 @@ export {
   loadDotenv,
   loadSessionMessages,
   nestArguments,
+  openTranscriptFile,
+  parseTranscript,
   readConfig,
+  readTranscript,
+  recordFromLoopEvent,
   redactKey,
+  renderMarkdown as renderDiffMarkdown,
+  renderSummaryTable as renderDiffSummary,
   repairTruncatedJson,
+  replayFromFile,
   runBranches,
   sanitizeName as sanitizeSessionName,
   saveApiKey,
   scavengeToolCalls,
   sessionPath,
   sessionsDir,
-  writeConfig
+  similarity,
+  writeConfig,
+  writeMeta,
+  writeRecord
 };
 //# sourceMappingURL=index.js.map