codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/test-clock.js

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var test_clock_exports = {};
+__export(test_clock_exports, {
+  clockOffsetMs: () => clockOffsetMs,
+  moveClock: () => moveClock
+});
+module.exports = __toCommonJS(test_clock_exports);
+function clockOffsetMs(env = process.env) {
+  const raw = env.CODETRELLIS_CLOCK_OFFSET_MS;
+  if (!raw || !/^-?\d+$/.test(raw)) return 0;
+  return Number(raw);
+}
+function moveClock(offset) {
+  if (!offset) return () => {
+  };
+  const RealDate = Date;
+  const realNow = RealDate.now.bind(RealDate);
+  class MovedDate extends RealDate {
+    constructor(...args) {
+      if (args.length === 0) super(realNow() + offset);
+      else super(...args);
+    }
+    static now() {
+      return realNow() + offset;
+    }
+  }
+  globalThis.Date = MovedDate;
+  return () => {
+    globalThis.Date = RealDate;
+  };
+}
+moveClock(clockOffsetMs());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clockOffsetMs,
+  moveClock
+});

package/src/backend/services/tests/grounding.js

@@ -0,0 +1,266 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var grounding_exports = {};
+__export(grounding_exports, {
+  NotAFileError: () => NotAFileError,
+  groundingMap: () => groundingMap,
+  groundingMapAt: () => groundingMapAt,
+  groundingOf: () => groundingOf,
+  groundingWords: () => groundingWords,
+  testFileOf: () => testFileOf,
+  wordsOf: () => wordsOf
+});
+module.exports = __toCommonJS(grounding_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_importers = require("../importers");
+var import_database = require("../database");
+var import_confined_fs = require("../confined-fs");
+var import_trusted_roots = require("../trusted-roots");
+var import_test_results = require("./test-results");
+var import_replay_frames = require("../replay-frames");
+var import_trellis_service = require("../trellis-service");
+var import_teammate_runs = require("./teammate-runs");
+class NotAFileError extends Error {
+}
+const SLACK_MS = 2e3;
+const looksLikeFile = (s) => !!s && (/[\\/]/.test(s) || /\.[a-z]{1,5}$/i.test(s));
+function testFileOf(root, t) {
+  const raw = [t.file, t.classname, t.suite].find(looksLikeFile);
+  if (!raw) return null;
+  const abs = import_node_path.default.isAbsolute(raw) ? raw : import_node_path.default.join(root, raw);
+  const rel = (0, import_trusted_roots.projectRelative)(root, abs);
+  return rel.startsWith("..") || import_node_path.default.isAbsolute(rel) ? null : rel.split(import_node_path.default.sep).join("/");
+}
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function groundingWords(tests, lastRunAt, changedAt) {
+  return wordsOf(tests, changedAt !== null && lastRunAt !== null && changedAt > lastRunAt + SLACK_MS);
+}
+function wordsOf(tests, stale) {
+  const n = (t) => t.count ?? 1;
+  const total = tests.reduce((a, t) => a + n(t), 0);
+  if (total === 0) return { state: "untested", words: "\u25CB no tests: no test with a reported result imports it" };
+  const failing = tests.filter((t) => t.result === "failed" || t.result === "error").reduce((a, t) => a + n(t), 0);
+  const ran = tests.filter((t) => t.result !== "skipped").reduce((a, t) => a + n(t), 0);
+  if (failing) return { state: "failing", words: `\u2717 ${failing} of ${plural(total, "test")} failing${stale ? ", and it changed after they ran" : ""}` };
+  if (stale) return { state: "stale", words: `\u26A0 tests older than the code: it changed after its ${plural(total, "test")} last ran` };
+  if (ran === 0) return { state: "untested", words: `\u25CB ${plural(total, "test")}, all skipped` };
+  return { state: "passing", words: `\u2713 ${plural(ran, "test")} passing` };
+}
+function runEntries(run, f) {
+  const out = f.failing.map((x) => ({ label: x.name, result: x.result, message: x.why, ranAt: run.at, testFile: f.file }));
+  if (f.failed > f.failing.length) out.push({ label: `${f.failed - f.failing.length} more failing`, result: "failed", message: null, ranAt: run.at, testFile: f.file, count: f.failed - f.failing.length });
+  if (f.passed) out.push({ label: `${plural(f.passed, "test")} passing`, result: "passed", message: null, ranAt: run.at, testFile: f.file, count: f.passed });
+  if (f.skipped) out.push({ label: `${plural(f.skipped, "test")} skipped`, result: "skipped", message: null, ranAt: run.at, testFile: f.file, count: f.skipped });
+  return out;
+}
+function groundingOf(projectRoot, candidate, known, knownRuns) {
+  const abs = (0, import_confined_fs.resolveWithin)(projectRoot, import_node_path.default.isAbsolute(candidate) ? candidate : import_node_path.default.join(projectRoot, candidate), "file");
+  const rel = (0, import_trusted_roots.projectRelative)(projectRoot, abs).split(import_node_path.default.sep).join("/");
+  try {
+    if (import_node_fs.default.lstatSync(abs).isDirectory()) throw new NotAFileError(`${rel || "."} is a folder, not a file.`);
+  } catch (err) {
+    if (err instanceof NotAFileError) throw err;
+  }
+  const results = known ?? (0, import_test_results.listTestResults)(projectRoot, { limit: 1e5 });
+  const runs = knownRuns ?? (0, import_teammate_runs.listTeammateRuns)(projectRoot);
+  const withFile = results.map((t) => ({ t, testFile: testFileOf(projectRoot, t) }));
+  const isOwn = withFile.some((x) => x.testFile === rel) || runs.some((r) => r.files.some((f) => f.file === rel));
+  let testFiles;
+  if (isOwn) {
+    testFiles = [rel];
+  } else {
+    const importers = new Set((0, import_importers.importersOf)(import_node_path.default.join(projectRoot, rel)).map((i) => i.relativePath.split(import_node_path.default.sep).join("/")));
+    const known2 = /* @__PURE__ */ new Set([...withFile.map((x) => x.testFile).filter((f) => !!f), ...runs.flatMap((r) => r.files.map((f) => f.file))]);
+    testFiles = [...known2].filter((f) => importers.has(f)).sort();
+  }
+  let changedAt = null;
+  try {
+    changedAt = Math.round(import_node_fs.default.lstatSync(abs).mtimeMs);
+  } catch {
+  }
+  const tests = [];
+  let stale = false;
+  let lastRunAt = null;
+  let newestRun = null;
+  for (const tf of testFiles) {
+    const local = withFile.filter((x) => x.testFile === tf);
+    const localAt = local.length ? Math.max(...local.map((x) => x.t.ranAt)) : -Infinity;
+    let best = null;
+    for (const run of runs) {
+      const f = run.files.find((x) => x.file === tf);
+      if (f && run.at > localAt && (!best || run.at > best.run.at)) best = { run, file: f };
+    }
+    if (best) {
+      tests.push(...runEntries(best.run, best.file));
+      const since = best.run.commit ? (0, import_teammate_runs.changedSinceCommit)(projectRoot, best.run.commit) : null;
+      if (!since || since.has(rel) || since.has(tf) || best.run.dirty.includes(rel) || best.run.dirty.includes(tf)) stale = true;
+      if (!newestRun || best.run.at > newestRun.at) newestRun = best.run;
+      lastRunAt = Math.max(lastRunAt ?? 0, best.run.at);
+    } else if (local.length) {
+      tests.push(...local.map((x) => ({ label: x.t.label, result: x.t.result, message: x.t.message, ranAt: x.t.ranAt, testFile: tf })));
+      if (changedAt !== null && changedAt > localAt + SLACK_MS) stale = true;
+      lastRunAt = Math.max(lastRunAt ?? 0, localAt);
+    }
+  }
+  const words = wordsOf(tests, stale);
+  if (newestRun && tests.length) words.words += `, in ${newestRun.who}'s run at ${newestRun.commit ? newestRun.commit.slice(0, 7) : "an unknown commit"}${newestRun.verified ? "" : ", unverified"}`;
+  return {
+    path: rel,
+    state: words.state,
+    words: words.words,
+    testFiles: testFiles.filter((tf) => tests.some((t) => t.testFile === tf)),
+    tests,
+    lastRunAt,
+    changedAt,
+    isTest: isOwn,
+    from: newestRun ? { who: newestRun.who, verified: newestRun.verified, commit: newestRun.commit, at: newestRun.at } : null
+  };
+}
+const MAX_BARRELS = 5;
+function groundingMap(projectRoot) {
+  const results = (0, import_test_results.listTestResults)(projectRoot, { limit: 1e5 });
+  const runs = (0, import_teammate_runs.listTeammateRuns)(projectRoot);
+  const counts = { failing: 0, stale: 0, passing: 0, untested: 0 };
+  const files = {};
+  if (results.length === 0 && runs.length === 0) return { files, hasResults: false, counts };
+  const testFiles = /* @__PURE__ */ new Set([
+    ...results.map((t) => testFileOf(projectRoot, t)).filter((f) => !!f),
+    ...runs.flatMap((r) => r.files.map((f) => f.file))
+  ]);
+  const importsOf = (absFile) => ((0, import_database.getDb)().exec(
+    `SELECT i.resolved_path, i.is_reexport FROM imports i JOIN files f ON i.file_id = f.id
+        WHERE f.path = ? AND i.resolved_path IS NOT NULL`,
+    [absFile]
+  )[0]?.values ?? []).map((r) => ({ path: String(r[0]), reexport: r[1] === 1 }));
+  const candidates = new Set(testFiles);
+  for (const tf of testFiles) {
+    const start = import_node_path.default.join(projectRoot, tf);
+    const seen = /* @__PURE__ */ new Set([start]);
+    let frontier = importsOf(start).map((i) => i.path);
+    for (let depth = 0; depth <= MAX_BARRELS && frontier.length; depth++) {
+      const next = [];
+      for (const abs of frontier) {
+        if (seen.has(abs)) continue;
+        seen.add(abs);
+        const rel = (0, import_trusted_roots.projectRelative)(projectRoot, abs);
+        if (rel.startsWith("..") || import_node_path.default.isAbsolute(rel)) continue;
+        candidates.add(rel.split(import_node_path.default.sep).join("/"));
+        next.push(...importsOf(abs).filter((i) => i.reexport).map((i) => i.path));
+      }
+      frontier = next;
+    }
+  }
+  for (const rel of candidates) {
+    let g;
+    try {
+      g = groundingOf(projectRoot, rel, results, runs);
+    } catch {
+      continue;
+    }
+    if (g.state === "untested" && g.tests.length === 0) continue;
+    files[rel] = { state: g.state, words: g.words };
+    counts[g.state]++;
+  }
+  return { files, hasResults: true, counts };
+}
+function groundingMapAt(projectRoot, at) {
+  const counts = { failing: 0, stale: 0, passing: 0, untested: 0 };
+  const files = {};
+  const note = (0, import_teammate_runs.listTeammateRuns)(projectRoot).length > 0 ? "Teammates' runs are shown live only: only their latest is kept, so a past moment counts the runs reported here." : null;
+  const frameBy = (t) => (0, import_replay_frames.listFrames)(projectRoot, { to: t, limit: 1, newestFirst: true })[0] ?? null;
+  const frame = frameBy(at);
+  const results = (0, import_test_results.testResultsAt)(projectRoot, at);
+  if (results.length === 0) return { files, hasResults: false, counts, at, frameAt: frame?.at ?? null, note };
+  if (!frame) return { files, hasResults: true, counts, at, frameAt: null, note };
+  const graphs = /* @__PURE__ */ new Map();
+  const graphOf = (id) => {
+    if (!graphs.has(id)) graphs.set(id, (0, import_trellis_service.getSnapshot)(id)?.data ?? null);
+    return graphs.get(id);
+  };
+  const then = graphOf(frame.id);
+  if (!then) return { files, hasResults: true, counts, at, frameAt: frame.at, note };
+  const hashThen = new Map(then.files.map((f) => [f.path, f.contentHash]));
+  const importsOf = /* @__PURE__ */ new Map();
+  for (const e of then.edges) importsOf.set(e.source, [...importsOf.get(e.source) ?? [], e.target]);
+  const reexports = new Set(((0, import_database.getDb)().exec(
+    `SELECT f.relative_path, t.relative_path FROM imports i JOIN files f ON i.file_id = f.id JOIN files t ON t.path = i.resolved_path
+      WHERE i.is_reexport = 1`
+  )[0]?.values ?? []).map((r) => `${String(r[0]).split(import_node_path.default.sep).join("/")}\0${String(r[1]).split(import_node_path.default.sep).join("/")}`));
+  const byTestFile = /* @__PURE__ */ new Map();
+  for (const t of results) {
+    const tf = testFileOf(projectRoot, t);
+    if (tf) byTestFile.set(tf, [...byTestFile.get(tf) ?? [], t]);
+  }
+  const reachedBy = /* @__PURE__ */ new Map();
+  const reach = (file, tf) => reachedBy.set(file, (reachedBy.get(file) ?? /* @__PURE__ */ new Set()).add(tf));
+  for (const tf of byTestFile.keys()) {
+    reach(tf, tf);
+    const seen = /* @__PURE__ */ new Set([tf]);
+    let frontier = (importsOf.get(tf) ?? []).map((target) => ({ from: tf, target }));
+    for (let depth = 0; depth <= MAX_BARRELS && frontier.length; depth++) {
+      const next = [];
+      for (const { target } of frontier) {
+        if (seen.has(target)) continue;
+        seen.add(target);
+        reach(target, tf);
+        next.push(...(importsOf.get(target) ?? []).filter((t) => reexports.has(`${target}\0${t}`)).map((t) => ({ from: target, target: t })));
+      }
+      frontier = next;
+    }
+  }
+  for (const [file, testFiles] of reachedBy) {
+    if (!hashThen.has(file)) continue;
+    const own = byTestFile.has(file) ? [file] : [...testFiles].filter((tf) => tf !== file);
+    const tests = [];
+    let stale = false;
+    for (const tf of own) {
+      const rows = byTestFile.get(tf) ?? [];
+      tests.push(...rows);
+      const ranAt = Math.max(...rows.map((r) => r.ranAt));
+      const atRun = (0, import_replay_frames.listFrames)(projectRoot, { from: ranAt, to: frame.at, limit: 1 })[0] ?? null;
+      const hashAtRun = atRun ? graphOf(atRun.id)?.files.find((f) => f.path === file)?.contentHash : void 0;
+      if (hashAtRun !== void 0 && hashAtRun !== hashThen.get(file)) stale = true;
+    }
+    const g = wordsOf(tests, stale);
+    if (g.state === "untested" && tests.length === 0) continue;
+    files[file] = g;
+    counts[g.state]++;
+  }
+  return { files, hasResults: true, counts, at, frameAt: frame.at, note };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NotAFileError,
+  groundingMap,
+  groundingMapAt,
+  groundingOf,
+  groundingWords,
+  testFileOf,
+  wordsOf
+});

package/src/backend/services/tests/junit.js

@@ -0,0 +1,104 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var junit_exports = {};
+__export(junit_exports, {
+  MAX_CASES: () => MAX_CASES,
+  parseJUnit: () => parseJUnit,
+  testLabel: () => testLabel
+});
+module.exports = __toCommonJS(junit_exports);
+const MAX_CASES = 2e4;
+const MAX_TEXT = 300;
+const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+function decode(s) {
+  return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e) => {
+    if (e[0] === "#") {
+      const code = e[1] === "x" || e[1] === "X" ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10);
+      return Number.isFinite(code) && code > 0 && code < 1114112 ? String.fromCodePoint(code) : m;
+    }
+    return ENTITIES[e.toLowerCase()] ?? m;
+  });
+}
+function attr(tag, name) {
+  const m = new RegExp(`\\s${name}\\s*=\\s*("([^"]*)"|'([^']*)')`).exec(tag);
+  if (!m) return null;
+  const v = decode(m[2] ?? m[3] ?? "").trim();
+  return v ? v.slice(0, MAX_TEXT) : null;
+}
+function firstLine(tag, body) {
+  const fromAttr = attr(tag, "message");
+  const text = fromAttr ?? decode(body.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1").replace(/<[^>]*>/g, "")).trim();
+  const line = text.split(/\r?\n/).map((l) => l.trim()).find(Boolean);
+  return line ? line.slice(0, MAX_TEXT) : null;
+}
+function parseJUnit(xml) {
+  if (!/<testsuites?\b/.test(xml) && !/<testcase\b/.test(xml)) return null;
+  const cases = [];
+  let truncated = false;
+  const suites = [];
+  const re = /<testsuite\b([^>]*?)(\/?)>|<\/testsuite>|<testcase\b([^>]*?)(?:\/>|>([\s\S]*?)<\/testcase>)/g;
+  for (let m = re.exec(xml); m; m = re.exec(xml)) {
+    if (m[0].startsWith("</testsuite")) {
+      suites.pop();
+      continue;
+    }
+    if (m[0].startsWith("<testsuite")) {
+      if (m[2] !== "/") suites.push(attr(`<s${m[1]}`, "name"));
+      continue;
+    }
+    if (cases.length >= MAX_CASES) {
+      truncated = true;
+      break;
+    }
+    const tag = `<c${m[3] ?? ""}`;
+    const body = m[4] ?? "";
+    const name = attr(tag, "name");
+    if (!name) continue;
+    const failure = /<failure\b([^>]*?)(?:\/>|>([\s\S]*?)<\/failure>)/.exec(body);
+    const error = /<error\b([^>]*?)(?:\/>|>([\s\S]*?)<\/error>)/.exec(body);
+    const skipped = /<skipped\b/.test(body);
+    const result = failure ? "failed" : error ? "error" : skipped ? "skipped" : "passed";
+    const why = failure ?? error;
+    const seconds = Number(attr(tag, "time"));
+    cases.push({
+      suite: suites.length ? suites[suites.length - 1] : null,
+      classname: attr(tag, "classname"),
+      name,
+      file: attr(tag, "file"),
+      result,
+      durationMs: Number.isFinite(seconds) && seconds >= 0 ? Math.round(seconds * 1e3) : null,
+      message: why ? firstLine(`<x${why[1] ?? ""}`, why[2] ?? "") : null
+    });
+  }
+  if (cases.length === 0 && !/<testsuites?\b/.test(xml)) return null;
+  const count = (r) => cases.filter((c) => c.result === r).length;
+  return {
+    cases,
+    totals: { tests: cases.length, passed: count("passed"), failed: count("failed"), errors: count("error"), skipped: count("skipped") },
+    truncated
+  };
+}
+function testLabel(c) {
+  return c.classname ? `${c.classname} \u203A ${c.name}` : c.name;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_CASES,
+  parseJUnit,
+  testLabel
+});

package/src/backend/services/tests/teammate-runs.js

@@ -0,0 +1,134 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var teammate_runs_exports = {};
+__export(teammate_runs_exports, {
+  changedSinceCommit: () => changedSinceCommit,
+  forgetTeammateRuns: () => forgetTeammateRuns,
+  knownRunCounters: () => knownRunCounters,
+  listTeammateRuns: () => listTeammateRuns,
+  putTeammateRun: () => putTeammateRun,
+  teammateRunSummaries: () => teammateRunSummaries
+});
+module.exports = __toCommonJS(teammate_runs_exports);
+var import_node_child_process = require("node:child_process");
+var import_database = require("../database");
+var import_persistence = require("../persistence");
+const parse = (s, fallback) => {
+  try {
+    return JSON.parse(String(s));
+  } catch {
+    return fallback;
+  }
+};
+function listTeammateRuns(projectRoot) {
+  const rows = (0, import_database.getDb)().exec(
+    `SELECT writer, counter, name, by_author, by_type, commit_sha, dirty, at, report, totals, files, verdict
+       FROM teammate_test_runs WHERE project_root = ? ORDER BY at DESC`,
+    [projectRoot]
+  )[0]?.values ?? [];
+  return rows.map((r) => {
+    const verdict = parse(r[11], {});
+    const name = verdict.verified && verdict.who ? verdict.who : String(r[2]);
+    const person = r[4] === "human" || r[4] === "unverified" || r[3] === r[2];
+    return {
+      writer: String(r[0]),
+      counter: Number(r[1]),
+      who: person ? name : `${String(r[3])} for ${name}`,
+      verified: verdict.verified === true,
+      why: verdict.verified ? null : verdict.why ?? null,
+      commit: r[5] ?? null,
+      dirty: parse(r[6], []),
+      at: Number(r[7]),
+      report: String(r[8]),
+      totals: parse(r[9], { tests: 0, passed: 0, failed: 0, errors: 0, skipped: 0 }),
+      files: parse(r[10], [])
+    };
+  });
+}
+function teammateRunSummaries(projectRoot) {
+  return listTeammateRuns(projectRoot).map(({ files: _files, dirty: _dirty, ...r }) => {
+    const failing = r.totals.failed + r.totals.errors;
+    const how = failing ? `${failing} of ${r.totals.tests} failing` : `${r.totals.tests - r.totals.skipped} passing`;
+    return { ...r, says: `${r.who}'s run at ${r.commit ? r.commit.slice(0, 7) : "an unknown commit"}: ${how}${r.verified ? "" : ` (unverified: ${r.why ?? "not signed"})`}` };
+  });
+}
+function knownRunCounters(projectRoot) {
+  const rows = (0, import_database.getDb)().exec("SELECT writer, counter FROM teammate_test_runs WHERE project_root = ?", [projectRoot])[0]?.values ?? [];
+  return new Map(rows.map((r) => [String(r[0]), Number(r[1])]));
+}
+function putTeammateRun(projectRoot, run) {
+  (0, import_database.getDb)().run(
+    `INSERT INTO teammate_test_runs (project_root, writer, counter, name, by_author, by_type, commit_sha, dirty, at, report, totals, files, verdict)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(project_root, writer) DO UPDATE SET counter = excluded.counter, name = excluded.name, by_author = excluded.by_author,
+       by_type = excluded.by_type, commit_sha = excluded.commit_sha, dirty = excluded.dirty, at = excluded.at, report = excluded.report,
+       totals = excluded.totals, files = excluded.files, verdict = excluded.verdict
+     WHERE excluded.counter > teammate_test_runs.counter`,
+    [
+      projectRoot,
+      run.writer,
+      run.counter,
+      run.name,
+      run.by.author,
+      run.by.authorType,
+      run.commit,
+      JSON.stringify(run.dirty),
+      run.at,
+      run.report,
+      JSON.stringify(run.totals),
+      JSON.stringify(run.files),
+      JSON.stringify(run.verdict)
+    ]
+  );
+  (0, import_persistence.markDirty)();
+}
+function forgetTeammateRuns(q) {
+  const where = q.projectRoot ? "project_root = ?" : "writer = ?";
+  const arg = q.projectRoot ?? q.writer ?? "";
+  const n = Number((0, import_database.getDb)().exec(`SELECT COUNT(*) FROM teammate_test_runs WHERE ${where}`, [arg])[0]?.values[0]?.[0] ?? 0);
+  if (n) {
+    (0, import_database.getDb)().run(`DELETE FROM teammate_test_runs WHERE ${where}`, [arg]);
+    (0, import_persistence.markDirty)();
+  }
+  return n;
+}
+const diffCache = /* @__PURE__ */ new Map();
+const DIFF_TTL_MS = 2e3;
+function changedSinceCommit(projectRoot, commit, now = Date.now()) {
+  const key = `${projectRoot}\0${commit}`;
+  const hit = diffCache.get(key);
+  if (hit && now - hit.at < DIFF_TTL_MS) return hit.files;
+  let files;
+  try {
+    const out = (0, import_node_child_process.execFileSync)("git", ["-C", projectRoot, "diff", "--name-only", commit, "--"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 32 * 1024 * 1024 });
+    files = new Set(out.split("\n").map((s) => s.trim()).filter(Boolean));
+  } catch {
+    files = null;
+  }
+  diffCache.set(key, { at: now, files });
+  return files;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  changedSinceCommit,
+  forgetTeammateRuns,
+  knownRunCounters,
+  listTeammateRuns,
+  putTeammateRun,
+  teammateRunSummaries
+});