@twarc_net/groundtruth 0.1.0 → 0.3.0

package/dist/index.js

@@ -75,21 +75,34 @@ function extractClaims(summary) {
     seen.add(key);
     claims.push({ kind, target, polarity, source: source.trim() });
   };
-  for (const clause of splitClauses(summary)) {
+  for (const clause of splitClauses(stripCodeFences(summary))) {
     if (isIntent(clause)) continue;
     const polarity = detectPolarity(clause);
     const hasVerb = ADD_VERBS.test(clause) || REMOVE_VERBS.test(clause) || MODIFY_VERBS.test(clause);
     let concrete = false;
+    const renamed = matchRename(clause);
+    if (renamed) {
+      add("symbol", renamed.from, "remove", clause);
+      add("symbol", renamed.to, "add", clause);
+      concrete = true;
+    }
     for (const tok of backtickTokens(clause)) {
-      const kind = classifyToken(tok);
-      if (kind === "file") {
+      if (looksLikePath(tok)) {
         add("file", tok, polarity, clause);
         concrete = true;
-      } else if (kind === "symbol") {
-        add("symbol", stripCall(tok), polarity, clause);
-        concrete = true;
-      } else if (kind === "command") {
-        add("command", tok, polarity, clause);
+        continue;
+      }
+      if (tok.includes(" ")) {
+        const first = (tok.split(/\s+/)[0] ?? "").toLowerCase();
+        if (COMMAND_WORDS.has(first)) {
+          add("command", tok, polarity, clause);
+          concrete = true;
+        }
+        continue;
+      }
+      const sym = symbolName(tok);
+      if (sym) {
+        add("symbol", sym, polarity, clause);
         concrete = true;
       }
     }
@@ -248,22 +261,31 @@ var SPECIAL_FILES = /* @__PURE__ */ new Set([
   ".dockerignore",
   ".editorconfig"
 ]);
-function classifyToken(tok) {
-  if (looksLikePath(tok)) return "file";
-  if (tok.includes(" ")) {
-    const first = tok.split(/\s+/)[0] ?? "";
-    return COMMAND_WORDS.has(first.toLowerCase()) ? "command" : null;
-  }
+function symbolName(tok) {
+  const jsx = /^<\/?\s*([A-Za-z][\w.]*)\b[^>]*>$/.exec(tok);
+  if (jsx?.[1]) return jsx[1];
   const id = stripCall(tok);
-  if (/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(id)) return "symbol";
-  return null;
+  return /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(id) ? id : null;
+}
+function matchRename(clause) {
+  if (!/\brenam(?:e|ed|es|ing)\b/i.test(clause)) return null;
+  const m = /`([^`]+)`\s*(?:to|into|->|→|=>)\s*`([^`]+)`/i.exec(clause);
+  if (!m?.[1] || !m[2]) return null;
+  const from = symbolName(m[1]);
+  const to = symbolName(m[2]);
+  return from && to ? { from, to } : null;
+}
+function stripCodeFences(text) {
+  return text.replace(/```[\s\S]*?```/g, " ").replace(/~~~[\s\S]*?~~~/g, " ");
 }
 function looksLikePath(tok) {
   if (tok.includes(" ")) return false;
+  if (/[<>]/.test(tok)) return false;
   if (SPECIAL_FILES.has(tok)) return true;
   if (/^https?:\/\//i.test(tok)) return false;
-  if (tok.includes("/")) return true;
   const ext = extOf(tok);
+  if (tok.startsWith("/")) return ext !== null && CODE_EXTENSIONS.has(ext);
+  if (tok.includes("/")) return true;
   return ext !== null && CODE_EXTENSIONS.has(ext);
 }
 function extOf(tok) {
@@ -316,10 +338,104 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/config.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { join } from "path";
+var RC_FILE = ".groundtruthrc.json";
+var VALID_FAIL_LEVELS = /* @__PURE__ */ new Set(["unsupported", "unverifiable"]);
+var VALID_KINDS = /* @__PURE__ */ new Set([
+  "file",
+  "symbol",
+  "test",
+  "dependency",
+  "command",
+  "action"
+]);
+var VALID_OUTPUTS = /* @__PURE__ */ new Set(["terminal", "json", "markdown"]);
+function loadConfig(cwd) {
+  const pkg = readJson(join(cwd, "package.json"));
+  const fromPkg = pkg && isRecord2(pkg.groundtruth) ? pkg.groundtruth : void 0;
+  const fromRc = readJson(join(cwd, RC_FILE));
+  return { ...sanitize(fromPkg), ...sanitize(fromRc) };
+}
+function applyConfig(claims, config) {
+  const ignoreKinds = new Set(config.ignoreKinds ?? []);
+  const matchers = (config.ignore ?? []).map(toMatcher);
+  return claims.filter((claim) => {
+    if (ignoreKinds.has(claim.kind)) return false;
+    return !matchers.some((match) => match(claim.target));
+  });
+}
+function toMatcher(pattern) {
+  const p = pattern.toLowerCase();
+  if (p.includes("*")) {
+    const re = new RegExp(`^${p.split("*").map(escapeRe2).join(".*")}$`);
+    return (value) => re.test(value.toLowerCase());
+  }
+  return (value) => value.toLowerCase().includes(p);
+}
+function failingCount(report, config) {
+  const levels = config.failOn ?? ["unsupported"];
+  let n = 0;
+  if (levels.includes("unsupported")) n += report.summary.unsupported;
+  if (levels.includes("unverifiable")) n += report.summary.unverifiable;
+  return n;
+}
+function sanitize(input) {
+  if (!isRecord2(input)) return {};
+  const out = {};
+  if (typeof input.strict === "boolean") out.strict = input.strict;
+  if (typeof input.shadow === "boolean") out.shadow = input.shadow;
+  if (isStringArray(input.failOn)) {
+    out.failOn = input.failOn.filter((l) => VALID_FAIL_LEVELS.has(l));
+  }
+  if (isStringArray(input.ignore)) out.ignore = input.ignore;
+  if (isStringArray(input.ignoreKinds)) {
+    out.ignoreKinds = input.ignoreKinds.filter((k) => VALID_KINDS.has(k));
+  }
+  if (typeof input.output === "string" && VALID_OUTPUTS.has(input.output)) {
+    out.output = input.output;
+  }
+  return out;
+}
+function readJson(path) {
+  if (!existsSync(path)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return isRecord2(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isStringArray(v) {
+  return Array.isArray(v) && v.every((item) => typeof item === "string");
+}
+function escapeRe2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // src/git.ts
 import { execFileSync } from "child_process";
-function collectGitEvidence(cwd) {
+function collectGitEvidence(cwd, opts = {}) {
   const ev = emptyEvidence();
+  if (opts.staged) {
+    const diff2 = git(["diff", "--cached", "--no-color", "--unified=0"], cwd);
+    if (diff2 !== null) parseDiff(diff2, ev);
+    const names = git(["diff", "--cached", "--name-status"], cwd);
+    if (names !== null) parseNameStatus(names, ev);
+    return ev;
+  }
+  if (opts.base) {
+    const range = `${opts.base}...HEAD`;
+    const diff2 = git(["diff", range, "--no-color", "--unified=0"], cwd);
+    if (diff2 !== null) parseDiff(diff2, ev);
+    const names = git(["diff", "--name-status", range], cwd);
+    if (names !== null) parseNameStatus(names, ev);
+    return ev;
+  }
   const diff = git(["diff", "HEAD", "--no-color", "--unified=0"], cwd);
   if (diff !== null) parseDiff(diff, ev);
   const status = git(["status", "--porcelain"], cwd);
@@ -357,6 +473,17 @@ function stripDiffPath(raw) {
   if (t === "/dev/null") return "";
   return t.replace(/^[ab]\//, "");
 }
+function parseNameStatus(out, ev) {
+  for (const line of out.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("	");
+    const code = parts[0] ?? "";
+    const path = (parts.length > 2 ? parts[parts.length - 1] : parts[1]) ?? "";
+    if (!path) continue;
+    pushUnique(ev.touchedFiles, path);
+    if (code.startsWith("A")) pushUnique(ev.createdFiles, path);
+  }
+}
 function parseStatus(status, ev) {
   for (const line of status.split("\n")) {
     if (!line.trim()) continue;
@@ -375,10 +502,10 @@ function pushUnique(arr, value) {
 }
 
 // src/evidence.ts
-function buildEvidence(toolUses, cwd) {
+function buildEvidence(toolUses, cwd, git2 = {}) {
   const ev = emptyEvidence();
   collectToolEvidence(toolUses, ev);
-  if (cwd) mergeEvidence(ev, collectGitEvidence(cwd));
+  if (cwd) mergeEvidence(ev, collectGitEvidence(cwd, git2));
   return ev;
 }
 function emptyEvidence() {
@@ -410,7 +537,7 @@ ${str(input.old_string)}`;
         if (file) addFile(ev, file, false);
         const edits = Array.isArray(input.edits) ? input.edits : [];
         for (const edit of edits) {
-          if (!isRecord2(edit)) continue;
+          if (!isRecord3(edit)) continue;
           ev.addedText += `
 ${str(edit.new_string)}`;
           ev.removedText += `
@@ -458,7 +585,7 @@ function pushUnique2(arr, value) {
 function str(v) {
   return typeof v === "string" ? v : "";
 }
-function isRecord2(v) {
+function isRecord3(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 
@@ -556,8 +683,20 @@ function fileMatches(claimPath, actual) {
   if (b.endsWith(`/${a}`) || a.endsWith(`/${b}`)) return true;
   if (!a.includes("/") && base(b) === a) return true;
   if (!b.includes("/") && base(a) === b) return true;
+  if (!hasExt(a)) {
+    const bNoExt = stripExt(b);
+    if (a === bNoExt) return true;
+    if (bNoExt.endsWith(`/${a}`)) return true;
+    if (!a.includes("/") && base(bNoExt) === a) return true;
+  }
   return false;
 }
+function hasExt(path) {
+  return /\.[A-Za-z0-9]+$/.test(base(path));
+}
+function stripExt(path) {
+  return path.replace(/\.[A-Za-z0-9]+$/, "");
+}
 function identifierPresent(haystack, id) {
   if (!haystack) return false;
   const esc = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -807,23 +946,709 @@ function truncate(s, max) {
 // src/pipeline.ts
 function runPipeline(input) {
   const turn = input.turn ?? (input.transcriptPath ? parseTranscriptFile(input.transcriptPath) : { summary: "", toolUses: [] });
-  const evidence = buildEvidence(turn.toolUses, input.cwd);
-  const claims = extractClaims(turn.summary);
+  const config = input.config ?? (input.cwd ? loadConfig(input.cwd) : {});
+  const evidence = buildEvidence(turn.toolUses, input.cwd, {
+    base: input.base,
+    staged: input.staged
+  });
+  const claims = applyConfig(extractClaims(turn.summary), config);
   const verdicts = verifyClaims(claims, evidence);
   return buildReport(verdicts);
 }
+
+// src/adapters/index.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+
+// src/locate.ts
+import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import { join as join2, resolve } from "path";
+function findLatestTranscript(cwd) {
+  const dir = projectDir(cwd);
+  if (!existsSync2(dir)) return null;
+  let newest = null;
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith(".jsonl")) continue;
+    const path = join2(dir, name);
+    try {
+      const mtime = statSync(path).mtimeMs;
+      if (!newest || mtime > newest.mtime) newest = { path, mtime };
+    } catch {
+    }
+  }
+  return newest?.path ?? null;
+}
+function projectDir(cwd) {
+  const encoded = resolve(cwd).replace(/[^A-Za-z0-9]/g, "-");
+  return join2(homedir(), ".claude", "projects", encoded);
+}
+
+// src/adapters/turn.ts
+function assembleTurn(events) {
+  let start = -1;
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (events[i]?.role === "user") {
+      start = i;
+      break;
+    }
+  }
+  let summary = "";
+  const toolUses = [];
+  for (const e of events.slice(start + 1)) {
+    if (e.role === "assistant" && e.text && e.text.trim()) summary = e.text.trim();
+    if (e.tool) toolUses.push(e.tool);
+  }
+  return { summary, toolUses };
+}
+function parseJsonlLines(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return out;
+}
+function parseApplyPatch(patch) {
+  const tools = [];
+  let file = null;
+  let op = null;
+  let added = [];
+  let removed = [];
+  const flush = () => {
+    if (!file || !op) return;
+    if (op === "add") {
+      tools.push({ name: "Write", input: { file_path: file, content: added.join("\n") } });
+    } else {
+      tools.push({
+        name: "Edit",
+        input: { file_path: file, new_string: added.join("\n"), old_string: removed.join("\n") }
+      });
+    }
+    added = [];
+    removed = [];
+  };
+  for (const line of patch.split("\n")) {
+    const add = /^\*\*\* Add File: (.+)$/.exec(line);
+    const upd = /^\*\*\* Update File: (.+)$/.exec(line);
+    if (add?.[1]) {
+      flush();
+      file = add[1].trim();
+      op = "add";
+    } else if (upd?.[1]) {
+      flush();
+      file = upd[1].trim();
+      op = "update";
+    } else if (/^\*\*\* (End Patch|Begin Patch|Delete File:)/.test(line)) {
+      flush();
+      if (line.startsWith("*** End Patch")) {
+        file = null;
+        op = null;
+      }
+    } else if (line.startsWith("+") && !line.startsWith("+++")) {
+      added.push(line.slice(1));
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      removed.push(line.slice(1));
+    }
+  }
+  flush();
+  return tools;
+}
+function isRecord4(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function str2(v) {
+  return typeof v === "string" ? v : "";
+}
+
+// src/adapters/aider.ts
+function parseAider(raw) {
+  const sessions = raw.split(/^# aider chat started at .*$/m);
+  const last = sessions[sessions.length - 1] ?? raw;
+  const events = [];
+  let assistant = [];
+  let user = [];
+  const flushAssistant = () => {
+    const text = assistant.join("\n").trim();
+    if (text) {
+      events.push({ role: "assistant", text });
+      for (const tool of parseSearchReplace(text)) events.push({ role: "assistant", tool });
+    }
+    assistant = [];
+  };
+  const flushUser = () => {
+    const text = user.join("\n").trim();
+    if (text) events.push({ role: "user", text });
+    user = [];
+  };
+  for (const line of last.split("\n")) {
+    if (line.startsWith("#### ")) {
+      flushAssistant();
+      user.push(line.slice(5));
+    } else if (line.startsWith("> ")) {
+    } else {
+      flushUser();
+      assistant.push(line);
+    }
+  }
+  flushUser();
+  flushAssistant();
+  return assembleTurn(events);
+}
+function parseSearchReplace(text) {
+  const tools = [];
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (!/^<{5,9} SEARCH\s*$/.test(lines[i] ?? "")) continue;
+    let path = "";
+    for (let j = i - 1; j >= 0; j--) {
+      const l = (lines[j] ?? "").trim();
+      if (!l || l.startsWith("```")) continue;
+      path = l;
+      break;
+    }
+    const added = [];
+    let inReplace = false;
+    let k = i + 1;
+    for (; k < lines.length; k++) {
+      const l = lines[k] ?? "";
+      if (/^={5,9}\s*$/.test(l)) {
+        inReplace = true;
+        continue;
+      }
+      if (/^>{5,9} REPLACE\s*$/.test(l)) break;
+      if (inReplace) added.push(l);
+    }
+    if (path)
+      tools.push({ name: "Edit", input: { file_path: path, new_string: added.join("\n") } });
+    i = k;
+  }
+  return tools;
+}
+
+// src/adapters/codex.ts
+function parseCodex(raw) {
+  const events = [];
+  for (const line of parseJsonlLines(raw)) {
+    if (!isRecord4(line) || line.type !== "response_item" || !isRecord4(line.payload)) continue;
+    const p = line.payload;
+    switch (p.type) {
+      case "message": {
+        events.push({ role: p.role === "user" ? "user" : "assistant", text: textOf(p.content) });
+        break;
+      }
+      case "function_call": {
+        for (const tool of fromFunctionCall(str2(p.name), str2(p.arguments))) {
+          events.push({ role: "assistant", tool });
+        }
+        break;
+      }
+      case "custom_tool_call": {
+        if (str2(p.name) === "apply_patch") {
+          for (const tool of parseApplyPatch(str2(p.input)))
+            events.push({ role: "assistant", tool });
+        }
+        break;
+      }
+      case "local_shell_call": {
+        const cmd = isRecord4(p.action) ? commandToString(p.action.command) : "";
+        if (cmd)
+          events.push({ role: "assistant", tool: { name: "Bash", input: { command: cmd } } });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return assembleTurn(events);
+}
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter(isRecord4).map((b) => typeof b.text === "string" ? b.text : "").join("\n").trim();
+}
+function fromFunctionCall(name, argsJson) {
+  if (name === "apply_patch") {
+    const parsed = safeJson(argsJson);
+    const patch = isRecord4(parsed) && typeof parsed.input === "string" ? parsed.input : argsJson;
+    return parseApplyPatch(patch);
+  }
+  if (name === "shell" || name === "shell_command" || name === "bash") {
+    const parsed = safeJson(argsJson);
+    const cmd = isRecord4(parsed) ? commandToString(parsed.command) : "";
+    if (!cmd) return [];
+    if (cmd.includes("apply_patch") && cmd.includes("*** Begin Patch")) {
+      const m = /\*\*\* Begin Patch[\s\S]*?\*\*\* End Patch/.exec(cmd);
+      if (m) return parseApplyPatch(m[0]);
+    }
+    return [{ name: "Bash", input: { command: cmd } }];
+  }
+  return [];
+}
+function commandToString(command) {
+  if (typeof command === "string") return command;
+  if (Array.isArray(command)) return command.filter((c2) => typeof c2 === "string").join(" ");
+  return "";
+}
+function safeJson(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+
+// src/adapters/cursor.ts
+function parseCursor(raw) {
+  const events = [];
+  const seen = /* @__PURE__ */ new Set();
+  let resultText = "";
+  for (const line of parseJsonlLines(raw)) {
+    if (!isRecord4(line)) continue;
+    switch (line.type) {
+      case "user":
+        events.push({ role: "user", text: messageText(line.message) });
+        break;
+      case "assistant":
+        events.push({ role: "assistant", text: messageText(line.message) });
+        break;
+      case "tool_call": {
+        const id = str2(line.call_id);
+        if (id && seen.has(id)) break;
+        if (id) seen.add(id);
+        const tool = fromToolCall(line.tool_call);
+        if (tool) events.push({ role: "assistant", tool });
+        break;
+      }
+      case "result":
+        resultText = str2(line.result);
+        break;
+      default:
+        break;
+    }
+  }
+  if (resultText.trim()) events.push({ role: "assistant", text: resultText });
+  return assembleTurn(events);
+}
+function messageText(message) {
+  if (!isRecord4(message)) return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter(isRecord4).map((b) => typeof b.text === "string" ? b.text : "").join("\n").trim();
+}
+function fromToolCall(tc) {
+  if (!isRecord4(tc)) return null;
+  if (isRecord4(tc.writeToolCall)) {
+    const a = argsOf(tc.writeToolCall);
+    return { name: "Write", input: { file_path: str2(a.path), content: str2(a.fileText) } };
+  }
+  if (isRecord4(tc.editToolCall)) {
+    const a = argsOf(tc.editToolCall);
+    return {
+      name: "Edit",
+      input: {
+        file_path: str2(a.path),
+        new_string: str2(a.fileText ?? a.newString),
+        old_string: str2(a.oldString)
+      }
+    };
+  }
+  if (isRecord4(tc.shellToolCall)) {
+    const a = argsOf(tc.shellToolCall);
+    return { name: "Bash", input: { command: str2(a.command) } };
+  }
+  return null;
+}
+function argsOf(x) {
+  return isRecord4(x.args) ? x.args : {};
+}
+
+// src/adapters/gemini.ts
+function parseGemini(raw) {
+  const events = [];
+  for (const rec of records(raw)) {
+    if (!isRecord4(rec)) continue;
+    if (rec.type === "user") {
+      events.push({ role: "user", text: textOf2(rec.content) });
+    } else if (rec.type === "gemini") {
+      events.push({ role: "assistant", text: textOf2(rec.content) });
+      const calls = Array.isArray(rec.toolCalls) ? rec.toolCalls : [];
+      for (const call of calls) {
+        const tool = fromToolCall2(call);
+        if (tool) events.push({ role: "assistant", tool });
+      }
+    }
+  }
+  return assembleTurn(events);
+}
+function records(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      const obj = JSON.parse(trimmed);
+      if (isRecord4(obj) && Array.isArray(obj.messages)) return obj.messages;
+    } catch {
+    }
+  }
+  return parseJsonlLines(raw);
+}
+function textOf2(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter(isRecord4).map((b) => typeof b.text === "string" ? b.text : "").join("\n").trim();
+}
+function fromToolCall2(call) {
+  if (!isRecord4(call)) return null;
+  const name = str2(call.name);
+  const args = isRecord4(call.args) ? call.args : {};
+  if (name === "write_file") {
+    return { name: "Write", input: { file_path: str2(args.file_path), content: str2(args.content) } };
+  }
+  if (name === "replace") {
+    return {
+      name: "Edit",
+      input: {
+        file_path: str2(args.file_path),
+        new_string: str2(args.new_string),
+        old_string: str2(args.old_string)
+      }
+    };
+  }
+  if (name === "run_shell_command") {
+    return { name: "Bash", input: { command: str2(args.command) } };
+  }
+  return null;
+}
+
+// src/adapters/opencode.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { dirname, join as join3 } from "path";
+function parseOpenCode(input) {
+  const storageRoot = resolveStorageRoot(input);
+  const messageRoot = join3(storageRoot, "message");
+  if (!existsSync3(messageRoot)) return { summary: "", toolUses: [] };
+  const session = latestSession(messageRoot);
+  if (!session) return { summary: "", toolUses: [] };
+  const messages = loadMessages(join3(messageRoot, session)).sort((a, b) => a.created - b.created);
+  const events = [];
+  for (const msg of messages) {
+    const parts = loadParts(join3(storageRoot, "part", msg.id));
+    if (msg.role === "user") {
+      const text = parts.filter((p) => p.type === "text").map((p) => str2(p.text)).join("\n").trim();
+      events.push({ role: "user", text });
+      continue;
+    }
+    for (const part of parts) {
+      if (part.type === "text" && str2(part.text).trim()) {
+        events.push({ role: "assistant", text: str2(part.text) });
+      } else if (part.type === "tool") {
+        const tool = fromToolPart(part);
+        if (tool) events.push({ role: "assistant", tool });
+      }
+    }
+  }
+  return assembleTurn(events);
+}
+function resolveStorageRoot(p) {
+  try {
+    if (statSync2(p).isFile()) return dirname(dirname(dirname(p)));
+  } catch {
+  }
+  return p;
+}
+function latestSession(messageRoot) {
+  let best = null;
+  for (const session of listDirs(messageRoot)) {
+    for (const file of listJson(join3(messageRoot, session))) {
+      try {
+        const mtime = statSync2(join3(messageRoot, session, file)).mtimeMs;
+        if (!best || mtime > best.mtime) best = { session, mtime };
+      } catch {
+      }
+    }
+  }
+  return best?.session ?? null;
+}
+function loadMessages(dir) {
+  const out = [];
+  for (const file of listJson(dir)) {
+    const obj = readJson2(join3(dir, file));
+    if (!isRecord4(obj)) continue;
+    const id = str2(obj.id) || file.replace(/\.json$/, "");
+    const role = str2(obj.role);
+    const created = isRecord4(obj.time) && typeof obj.time.created === "number" ? obj.time.created : 0;
+    out.push({ id, role, created });
+  }
+  return out;
+}
+function loadParts(dir) {
+  if (!existsSync3(dir)) return [];
+  const out = [];
+  for (const file of listJson(dir)) {
+    const obj = readJson2(join3(dir, file));
+    if (isRecord4(obj) && typeof obj.type === "string") {
+      out.push({
+        type: obj.type,
+        text: typeof obj.text === "string" ? obj.text : void 0,
+        tool: typeof obj.tool === "string" ? obj.tool : void 0,
+        state: obj.state
+      });
+    }
+  }
+  return out;
+}
+function fromToolPart(part) {
+  const tool = str2(part.tool);
+  const state = isRecord4(part.state) ? part.state : {};
+  const input = isRecord4(state.input) ? state.input : {};
+  if (tool === "write") {
+    return {
+      name: "Write",
+      input: { file_path: str2(input.filePath), content: str2(input.content) }
+    };
+  }
+  if (tool === "edit") {
+    return {
+      name: "Edit",
+      input: {
+        file_path: str2(input.filePath),
+        new_string: str2(input.newString),
+        old_string: str2(input.oldString)
+      }
+    };
+  }
+  if (tool === "bash") {
+    return { name: "Bash", input: { command: str2(input.command) } };
+  }
+  return null;
+}
+function listDirs(dir) {
+  try {
+    return readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function listJson(dir) {
+  try {
+    return readdirSync2(dir).filter((n) => n.endsWith(".json"));
+  } catch {
+    return [];
+  }
+}
+function readJson2(path) {
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/adapters/index.ts
+var claude = {
+  name: "claude",
+  locate: (cwd) => findLatestTranscript(cwd),
+  parse: (path) => parseTranscriptFile(path)
+};
+var codex = {
+  name: "codex",
+  locate() {
+    const home = process.env.CODEX_HOME ?? join4(homedir2(), ".codex");
+    return newestMatch(
+      join4(home, "sessions"),
+      (n) => n.startsWith("rollout-") && n.endsWith(".jsonl")
+    );
+  },
+  parse: (path) => parseCodex(readFileSync4(path, "utf8"))
+};
+var gemini = {
+  name: "gemini",
+  locate(cwd) {
+    const home = process.env.GEMINI_DIR ?? join4(homedir2(), ".gemini");
+    const hash = createHash("sha256").update(cwd).digest("hex");
+    const scoped = newestMatch(
+      join4(home, "tmp", hash, "chats"),
+      (n) => n.endsWith(".jsonl") || n.endsWith(".json")
+    );
+    if (scoped) return scoped;
+    return newestMatch(join4(home, "tmp"), (n) => n.startsWith("session") && /\.jsonl?$/.test(n));
+  },
+  parse: (path) => parseGemini(readFileSync4(path, "utf8"))
+};
+var cursor = {
+  name: "cursor",
+  locate() {
+    return newestMatch(join4(homedir2(), ".cursor", "projects"), (n) => n.endsWith(".jsonl"));
+  },
+  parse: (path) => parseCursor(readFileSync4(path, "utf8"))
+};
+var opencode = {
+  name: "opencode",
+  locate() {
+    const base2 = process.env.XDG_DATA_HOME ? join4(process.env.XDG_DATA_HOME, "opencode") : join4(homedir2(), ".local", "share", "opencode");
+    return newestMatch(join4(base2, "storage", "message"), (n) => n.endsWith(".json"));
+  },
+  parse: (path) => parseOpenCode(path)
+};
+var aider = {
+  name: "aider",
+  locate(cwd) {
+    const file = join4(cwd, ".aider.chat.history.md");
+    return existsSync4(file) ? file : null;
+  },
+  parse: (path) => parseAider(readFileSync4(path, "utf8"))
+};
+var ADAPTERS = {
+  claude,
+  codex,
+  gemini,
+  cursor,
+  opencode,
+  aider
+};
+var AGENT_NAMES = Object.keys(ADAPTERS);
+function getAdapter(name) {
+  return ADAPTERS[name] ?? null;
+}
+function autoDetect(cwd) {
+  let best = null;
+  for (const adapter of Object.values(ADAPTERS)) {
+    const path = adapter.locate(cwd);
+    if (!path) continue;
+    try {
+      const mtime = statSync3(path).mtimeMs;
+      if (!best || mtime > best.mtime) best = { adapter, path, mtime };
+    } catch {
+    }
+  }
+  return best ? { adapter: best.adapter, path: best.path } : null;
+}
+function newestMatch(dir, test, depth = 6) {
+  const found = walk(dir, test, depth);
+  return found?.path ?? null;
+}
+function walk(dir, test, depth) {
+  if (depth < 0 || !existsSync4(dir)) return null;
+  let entries;
+  try {
+    entries = readdirSync3(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const entry of entries) {
+    const full = join4(dir, entry.name);
+    try {
+      if (entry.isDirectory()) {
+        const sub = walk(full, test, depth - 1);
+        if (sub && (!best || sub.mtime > best.mtime)) best = sub;
+      } else if (entry.isFile() && test(entry.name)) {
+        const mtime = statSync3(full).mtimeMs;
+        if (!best || mtime > best.mtime) best = { path: full, mtime };
+      }
+    } catch {
+    }
+  }
+  return best;
+}
+
+// src/ledger.ts
+import { appendFileSync, existsSync as existsSync5, mkdirSync, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join5 } from "path";
+function ledgerPath() {
+  return process.env.GROUNDTRUTH_LEDGER ?? join5(homedir3(), ".groundtruth", "ledger.jsonl");
+}
+function recordRun(report, cwd, session) {
+  if (report.summary.total === 0) return;
+  const entry = {
+    t: (/* @__PURE__ */ new Date()).toISOString(),
+    cwd,
+    v: report.summary.verified,
+    u: report.summary.unsupported,
+    r: report.summary.unverifiable
+  };
+  if (session) entry.session = session;
+  try {
+    const path = ledgerPath();
+    mkdirSync(dirname2(path), { recursive: true });
+    appendFileSync(path, `${JSON.stringify(entry)}
+`, "utf8");
+  } catch {
+  }
+}
+function readLedger() {
+  const path = ledgerPath();
+  if (!existsSync5(path)) return [];
+  const out = [];
+  try {
+    for (const line of readFileSync5(path, "utf8").split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (isEntry(parsed)) out.push(parsed);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function summarize(entries, opts = {}) {
+  const cutoff = opts.sinceDays !== void 0 ? Date.now() - opts.sinceDays * 864e5 : 0;
+  const sum = { runs: 0, verified: 0, unsupported: 0, unverifiable: 0 };
+  for (const e of entries) {
+    if (opts.cwd && e.cwd !== opts.cwd) continue;
+    if (opts.session && e.session !== opts.session) continue;
+    if (cutoff && Date.parse(e.t) < cutoff) continue;
+    sum.runs += 1;
+    sum.verified += e.v;
+    sum.unsupported += e.u;
+    sum.unverifiable += e.r;
+  }
+  return sum;
+}
+function isEntry(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const e = v;
+  return typeof e.t === "string" && typeof e.cwd === "string" && typeof e.v === "number" && typeof e.u === "number" && typeof e.r === "number";
+}
 export {
+  ADAPTERS,
+  AGENT_NAMES,
+  applyConfig,
+  autoDetect,
   buildEvidence,
   buildReport,
   collectGitEvidence,
   emptyEvidence,
   extractClaims,
+  failingCount,
+  getAdapter,
+  ledgerPath,
+  loadConfig,
   mergeEvidence,
+  parseAider,
+  parseCodex,
+  parseCursor,
+  parseGemini,
+  parseOpenCode,
   parseTranscript,
   parseTranscriptFile,
+  readLedger,
+  recordRun,
   renderJson,
   renderMarkdown,
   renderTerminal,
   runPipeline,
+  summarize,
   verifyClaims
 };