codetrellis 0.0.0-stage → 0.3.0

package/src/cli/verbs.js

@@ -0,0 +1,360 @@
+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 verbs_exports = {};
+__export(verbs_exports, {
+  UsageError: () => UsageError,
+  VERBS: () => VERBS,
+  projectRoot: () => projectRoot,
+  runVerb: () => runVerb
+});
+module.exports = __toCommonJS(verbs_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_args = require("./args");
+var import_sarif = require("./sarif");
+var import_review_output = require("./review-output");
+var import_rule_baseline = require("../backend/services/rule-baseline");
+var import_confined_fs = require("../backend/services/confined-fs");
+var import_package = require("../../package.json");
+var import_conformity = require("./conformity");
+var import_pipeline = require("../backend/services/pipeline");
+var import_pipeline2 = require("./pipeline");
+const VERBS = /* @__PURE__ */ new Set(["next", "claim", "update", "stuck", "done", "request", "brief", "awareness", "check", "report-tests", "rules"]);
+class UsageError extends Error {
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const asObj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+function projectRoot(cwd) {
+  try {
+    const top = (0, import_node_child_process.execFileSync)("git", ["-C", cwd, "rev-parse", "--show-toplevel"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (top) return import_node_fs.default.realpathSync(top);
+  } catch {
+  }
+  return import_node_fs.default.realpathSync(cwd);
+}
+function said(a, words, ctx) {
+  if (a.isError) return { out: a.text, code: 1 };
+  if (ctx.json) return { out: a.json !== null ? JSON.stringify(a.json) : JSON.stringify({ text: a.text }), code: 0 };
+  return { out: a.json !== null ? words(asObj(a.json)) : a.text, code: 0 };
+}
+async function plansHere(ctx) {
+  const a = await ctx.agent.call("list_plans", { project_path: projectRoot(ctx.cwd), limit: 100 });
+  if (a.isError) return [];
+  return asObj(a.json).plans ?? [];
+}
+async function planOf(ctx) {
+  const named = (0, import_args.flag)(ctx.p, "plan");
+  if (named) return named;
+  const plans = (await plansHere(ctx)).filter((pl) => pl.status !== "archived" && pl.status !== "done");
+  if (plans.length === 1) return plans[0].uid;
+  if (plans.length === 0) throw new UsageError(`No plan in ${projectRoot(ctx.cwd)}. Name one with --plan <uid>.`);
+  throw new UsageError(`Several plans in this project; name one with --plan:
+${plans.map((pl) => `  ${pl.uid}  ${pl.title}`).join("\n")}`);
+}
+async function taskOf(ctx, ref) {
+  if (!ref) throw new UsageError("Which task? Give its uid, or the first characters of it.");
+  const want = ref.replace(/^task\s+/i, "").trim().toLowerCase();
+  if (UUID.test(want)) return want;
+  if (!/^[0-9a-f-]{6,}$/.test(want)) throw new UsageError(`"${ref}" is not a task uid or the start of one.`);
+  const found = [];
+  for (const pl of await plansHere(ctx)) {
+    const a = await ctx.agent.call("list_items", { plan_uid: pl.uid, limit: 500 });
+    for (const it of asObj(a.json).items ?? []) {
+      if (it.uid.toLowerCase().startsWith(want)) found.push(it);
+    }
+  }
+  if (found.length === 1) return found[0].uid;
+  if (found.length === 0) throw new UsageError(`No task starting "${want}" in this project's plans.`);
+  throw new UsageError(`"${want}" names ${found.length} tasks; give more of the uid:
+${found.map((t) => `  ${t.uid}  ${t.title}`).join("\n")}`);
+}
+const taskWords = (t) => `${t.title ?? "a task"} (${t.uid ?? "?"})${t.status ? `, ${String(t.status).replace("_", " ")}` : ""}`;
+async function runVerb(verb, agent, p, cwd) {
+  const ctx = { agent, p, cwd, json: p.flags.json === true };
+  const [first, ...more] = p.rest;
+  switch (verb) {
+    case "next": {
+      const a = await agent.call("get_next_item", { plan_uid: await planOf(ctx) });
+      return said(a, (j) => {
+        const item = asObj(j.item ?? j.next ?? j);
+        return item.uid ? `Next: ${taskWords(item)}${j.reason ? `
+${String(j.reason)}` : ""}` : typeof j.message === "string" ? j.message : "Nothing to pick up: every task is done, claimed or waiting.";
+      }, ctx);
+    }
+    case "claim": {
+      const a = await agent.call("claim_item", { uid: await taskOf(ctx, first) });
+      return said(a, (j) => `Claimed ${taskWords(asObj(j.item ?? j))}.`, ctx);
+    }
+    case "update": {
+      const uid = await taskOf(ctx, first);
+      const raw = (0, import_args.flag)(p, "progress");
+      const percent = raw === void 0 ? NaN : Number(raw);
+      if (!Number.isInteger(percent) || percent < 0 || percent > 100) throw new UsageError("--progress takes a whole number from 0 to 100.");
+      const note = (0, import_args.flag)(p, "note");
+      const a = await agent.call("update_item_progress", { uid, percent, ...note ? { message: note } : {} });
+      return said(a, () => `${percent}%${note ? `: ${note}` : ""}`, ctx);
+    }
+    case "stuck": {
+      const uid = await taskOf(ctx, first);
+      const reason = more.join(" ").trim();
+      if (!reason) throw new UsageError("Say why: codetrellis stuck <task> <why\u2026>");
+      const a = await agent.call("set_item_blocked", { uid, reason });
+      return said(a, () => `Blocked: ${reason}`, ctx);
+    }
+    case "done": {
+      const uid = await taskOf(ctx, first);
+      const list = await agent.call("list_criteria", { item_uid: uid });
+      const criteria = Array.isArray(list.json) ? list.json : asObj(list.json).criteria ?? [];
+      const failing = [];
+      for (const c of criteria) {
+        const chk = await agent.call("check_criterion", { criterion_uid: c.uid });
+        const j = asObj(chk.json);
+        if (!chk.isError && j.ok === false) {
+          const findings = (j.findings ?? []).filter((f) => f.status === "fail").map((f) => f.message);
+          failing.push({ text: c.text, findings });
+        }
+      }
+      if (failing.length) {
+        if (ctx.json) return { out: JSON.stringify({ done: false, failing }), code: 1 };
+        return { out: `Not marked done: ${failing.length === 1 ? "a criterion's check fails" : `${failing.length} criteria's checks fail`}.
+${failing.map((f) => `  \u2717 ${f.text}${f.findings.length ? `
+    ${f.findings.join("\n    ")}` : ""}`).join("\n")}`, code: 1 };
+      }
+      const a = await agent.call("update_item", { uid, status: "done" });
+      return said(a, (j) => `Done: ${taskWords(asObj(j.item ?? j))}`, ctx);
+    }
+    case "request":
+      return request(ctx, [first, ...more].filter(Boolean).join(" ").trim());
+    case "brief": {
+      const a = await agent.call("get_brief", { item_uid: await taskOf(ctx, first) });
+      if (a.isError) return { out: a.text, code: 1 };
+      return { out: ctx.json || a.json === null ? a.json !== null ? JSON.stringify(a.json) : a.text : JSON.stringify(a.json, null, 2), code: 0 };
+    }
+    case "awareness": {
+      const a = await agent.call("get_awareness", { project_path: projectRoot(cwd) });
+      return said(a, (j) => {
+        const signals = j.signals ?? [];
+        return signals.length ? signals.map((s) => `${s.severity === "high" ? "\u26A0" : "\xB7"} ${s.summary}`).join("\n") : "Nothing overlaps your work.";
+      }, ctx);
+    }
+    case "check":
+      return check(ctx, first);
+    case "rules": {
+      if (first !== "baseline") throw new UsageError("codetrellis rules baseline \u2014 record each rule's breaches now, so the check fails on new ones");
+      return writeBaseline(ctx, projectRoot(cwd));
+    }
+    case "report-tests": {
+      if (!first) throw new UsageError("Which report? codetrellis report-tests <junit.xml>");
+      const a = await agent.call("report_tests", { path: first, project_path: projectRoot(cwd) });
+      return said(a, (j) => {
+        const failing = j.failing ?? [];
+        return [typeof j.says === "string" ? j.says : JSON.stringify(j), ...failing.map((f) => `  \u2717 ${f.test}${f.why ? ` \u2014 ${f.why}` : ""}`)].join("\n");
+      }, ctx);
+    }
+    default:
+      throw new UsageError(`unknown verb ${verb}`);
+  }
+}
+async function request(ctx, question) {
+  if (!question) throw new UsageError("Ask something: codetrellis request <question\u2026>");
+  const plan = await planOf(ctx);
+  const item = (0, import_args.flag)(ctx.p, "item") ? await taskOf(ctx, (0, import_args.flag)(ctx.p, "item")) : null;
+  const options = ((0, import_args.flag)(ctx.p, "options") ?? "").split(",").map((o) => o.trim()).filter(Boolean);
+  const since = Date.now() - 1e3;
+  const posted = await ctx.agent.call("post_channel_event", {
+    plan_uid: plan,
+    item_uid: item,
+    message: question,
+    event_type: options.length ? "need-decision" : "need-context",
+    ...options.length ? { options } : {}
+  });
+  if (posted.isError) return { out: posted.text, code: 1 };
+  const uid = String(asObj(posted.json).uid ?? "");
+  if (ctx.p.flags["no-wait"]) {
+    return { out: ctx.json ? JSON.stringify({ asked: uid, answered: false }) : `Asked (${uid}). Not waiting for the answer.`, code: 0 };
+  }
+  const timeout = Number((0, import_args.flag)(ctx.p, "timeout") ?? 300);
+  if (!Number.isFinite(timeout) || timeout < 0) throw new UsageError("--timeout takes seconds.");
+  const until = Date.now() + timeout * 1e3;
+  for (; ; ) {
+    const a = await ctx.agent.call("list_channel_events", { plan_uid: plan, event_types: ["steer"], since_ms: since });
+    const events = Array.isArray(a.json) ? a.json : asObj(a.json).events ?? [];
+    const reply = events.find((e) => {
+      const payload = asObj(e.payload);
+      return e.respondsTo === uid || e.responds_to === uid || payload.respondsTo === uid || payload.responds_to === uid;
+    });
+    if (reply) {
+      const text = String(reply.message ?? asObj(reply.payload).message ?? "");
+      const by = String(reply.author ?? reply.authorName ?? "the person");
+      return { out: ctx.json ? JSON.stringify({ asked: uid, answered: true, answer: text, by }) : `${by}: ${text}`, code: 0 };
+    }
+    if (Date.now() >= until) {
+      return { out: ctx.json ? JSON.stringify({ asked: uid, answered: false, timedOut: true }) : `No answer yet to ${uid}; it stays open on the plan.`, code: 3 };
+    }
+    await new Promise((r) => setTimeout(r, Math.min(2e3, Math.max(100, until - Date.now()))));
+  }
+}
+async function check(ctx, file) {
+  const root = projectRoot(ctx.cwd);
+  if (!file) return conforms(ctx, root);
+  const rel = import_node_path.default.isAbsolute(file) ? import_node_path.default.relative(root, file) : import_node_path.default.relative(root, import_node_path.default.resolve(ctx.cwd, file));
+  const footprint = await ctx.agent.call("check_footprint", { paths: [rel], project_path: root });
+  const breakpoint = await ctx.agent.call("check_breakpoint", { path: rel });
+  const bp = asObj(breakpoint.json);
+  const held = bp.status === "paused" || bp.status === "stop";
+  if (ctx.json) return { out: JSON.stringify({ path: rel, held, footprint: footprint.json ?? footprint.text, breakpoint: breakpoint.json ?? breakpoint.text }), code: held ? 3 : 0 };
+  const lines = [];
+  if (held) lines.push(`\u270B ${String(bp.message ?? breakpoint.text)}`);
+  else if (bp.status === "continue") lines.push(`${rel}: go ahead${bp.steer ? `, with this steer: ${String(bp.steer)}` : ""}.`);
+  else lines.push(`${rel}: no breakpoint holds it.`);
+  const entry = asObj((asObj(footprint.json).paths ?? [])[0]);
+  const changedIn = entry.changed_in ?? [];
+  const importedBy = entry.imported_by ?? [];
+  if (changedIn.length) lines.push(`  also changed in ${changedIn.map((c) => c.branch ?? c.workstream).join(", ")}`);
+  if (importedBy.length) lines.push(`  imported by ${importedBy.length} file${importedBy.length === 1 ? "" : "s"}: ${importedBy.slice(0, 5).join(", ")}${importedBy.length > 5 ? ", \u2026" : ""}`);
+  if (footprint.isError) lines.push(footprint.text);
+  return { out: lines.join("\n"), code: held ? 3 : 0 };
+}
+async function conforms(ctx, root) {
+  let changed;
+  try {
+    changed = (0, import_conformity.changedFiles)(root, (0, import_args.flag)(ctx.p, "base"), process.env);
+  } catch (err) {
+    throw new UsageError(err.message);
+  }
+  if (ctx.p.flags.pipeline === true || (0, import_args.flag)(ctx.p, "stage") !== void 0) {
+    const piped = await pipelined(ctx, root, changed);
+    if (piped) return piped;
+  }
+  const g = await (0, import_conformity.gate)(ctx.agent, root, changed, ctx.p.flags.strict === true, { suite: (0, import_args.flag)(ctx.p, "suite"), rule: (0, import_args.flag)(ctx.p, "rule"), path: (0, import_args.flag)(ctx.p, "path"), tag: (0, import_args.flag)(ctx.p, "tag") });
+  if ("error" in g) return { out: g.error, code: 1 };
+  const format = (0, import_args.flag)(ctx.p, "format") ?? (ctx.json ? "json" : "text");
+  if (format === "sarif") {
+    const read2 = (rel) => {
+      try {
+        return import_node_fs.default.readFileSync(import_node_path.default.join(root, rel), "utf8");
+      } catch {
+        return null;
+      }
+    };
+    return { out: JSON.stringify((0, import_sarif.toSarif)(g, { version: import_package.version, root, read: read2, ruleFile: (0, import_sarif.ruleFileIn)(root) }), null, 2), code: g.ok ? 0 : 3 };
+  }
+  const read = (rel) => {
+    try {
+      return import_node_fs.default.readFileSync(import_node_path.default.join(root, rel), "utf8");
+    } catch {
+      return null;
+    }
+  };
+  if (format === "json") return { out: JSON.stringify({ ...g, rules: (0, import_conformity.withPlaces)(g, read).rules }), code: g.ok ? 0 : 3 };
+  if (format === "markdown") return { out: (0, import_conformity.gateMarkdown)(g, read), code: g.ok ? 0 : 3 };
+  if (format !== "text") throw new UsageError(`--format is text, json, markdown or sarif, not ${format}`);
+  return { out: (0, import_conformity.gateWords)(g, { read, color: (0, import_conformity.wantsColor)(process.stdout, process.env, ctx.p.flags["no-color"] === true) }), code: g.ok ? 0 : 3 };
+}
+async function pipelined(ctx, root, changed) {
+  const got = changed.since ? await (0, import_pipeline.pipelineAt)(root, changed.since) : (0, import_pipeline.readPipeline)(root);
+  if (!got) return null;
+  if (!got.pipeline) return { out: `The pipeline${changed.since ? ` at ${changed.since.slice(0, 7)}` : ""} could not be read: ${got.problems.join("; ")}`, code: 1 };
+  const strict = ctx.p.flags.strict === true;
+  let review = null;
+  if ((0, import_args.flag)(ctx.p, "agent") !== void 0) {
+    const { review: runReview, reviewOptions, ReviewUsageError } = await Promise.resolve().then(() => __toESM(require("./review")));
+    let o;
+    try {
+      o = reviewOptions(ctx.p, ctx.cwd, process.env);
+    } catch (err) {
+      if (err instanceof ReviewUsageError) throw new UsageError(err.message);
+      throw err;
+    }
+    const me = (0, import_args.selfCommand)(import_node_path.default.resolve(__dirname, "..", "..", "bin"), { execPath: process.execPath, electron: process.versions.electron });
+    const sinkFor = (dir) => ({ command: me.command, args: [...me.args, "review-sink", "--pass", dir], env: me.env });
+    review = async (stage, scope, grounding) => {
+      const r = await runReview(ctx.agent, { ...o, scope: { suite: scope.suite, rule: scope.rule, path: scope.path, engine: scope.engine, strength: scope.strength, tag: scope.tag }, stage: stage.id, grounding, format: "json", failOn: /* @__PURE__ */ new Set(["block"]), post: null }, ctx.cwd, process.env, sinkFor, { version: import_package.version });
+      let j;
+      try {
+        j = JSON.parse(r.out);
+      } catch {
+        return { error: r.out };
+      }
+      if (j.error) return { error: j.error };
+      const findings = (j.passes ?? []).flatMap((pass) => pass.kept.filter((k) => k.path).map((k) => ({ stage: stage.id, path: k.path, says: k.says, rule: k.rule })));
+      return { ok: r.code === 0, out: j.says ?? (j.passes ?? []).flatMap((pass) => [`review: ${pass.says}`, ...pass.kept.map((k) => `  ${(0, import_review_output.findingWords)(k)}`)]).join("\n"), findings };
+    };
+  }
+  const result = await (0, import_pipeline2.runPipeline)(got.pipeline, { gate: (scope) => (0, import_conformity.gate)(ctx.agent, root, changed, strict, scope), review }, (0, import_args.flag)(ctx.p, "stage"));
+  const code = result.stages.some((s) => !s.ok && !s.advisory && (s.gate && "error" in s.gate)) ? 1 : result.ok ? 0 : 3;
+  if (ctx.json || (0, import_args.flag)(ctx.p, "format") === "json") return { out: JSON.stringify(result), code };
+  const read = (rel) => {
+    try {
+      return import_node_fs.default.readFileSync(import_node_path.default.join(root, rel), "utf8");
+    } catch {
+      return null;
+    }
+  };
+  const color = (0, import_conformity.wantsColor)(process.stdout, process.env, ctx.p.flags["no-color"] === true);
+  return { out: (0, import_pipeline2.pipelineWords)(result, (g) => (0, import_conformity.gateWords)(g, { read, color })), code };
+}
+async function writeBaseline(ctx, root) {
+  const a = await ctx.agent.call("list_rules", { project_path: root });
+  if (a.isError) return { out: a.text, code: 1 };
+  const views = asObj(a.json).rules ?? [];
+  if (views.some((v) => v.rule.strength !== "guide" && v.breaches === null)) {
+    return { out: "The rules' breaches could not be read: this project's imports are not loaded. Run `codetrellis start` in it first.", code: 1 };
+  }
+  const now = new Map(views.filter((v) => v.rule.strength !== "guide").map((v) => [v.rule.id, new Set((v.breaches ?? []).map((b) => `${b.from} > ${b.to}`))]));
+  const before = (0, import_rule_baseline.readBaseline)(root);
+  const next = /* @__PURE__ */ new Map();
+  const lines = [];
+  let held = 0;
+  for (const [id, entries] of now) {
+    const was = before?.get(id);
+    if (!was) {
+      next.set(id, entries);
+      lines.push(`  ${id}: ${entries.size} ${entries.size === 1 ? "breach" : "breaches"} recorded`);
+      continue;
+    }
+    const kept = new Set([...entries].filter((e) => was.has(e)));
+    held += entries.size - kept.size;
+    next.set(id, kept);
+    lines.push(`  ${id}: ${kept.size}${kept.size < was.size ? `, down from ${was.size}` : ""}`);
+  }
+  (0, import_confined_fs.writeFileWithin)(root, import_rule_baseline.BASELINE_FILE, (0, import_rule_baseline.baselineYaml)(next), "rule baseline");
+  if (ctx.json) return { out: JSON.stringify({ file: import_rule_baseline.BASELINE_FILE, rules: Object.fromEntries([...next].map(([k, v]) => [k, [...v]])), notAdded: held }), code: 0 };
+  return {
+    out: [`Wrote ${import_rule_baseline.BASELINE_FILE}:`, ...lines, ...held ? [`${held} new ${held === 1 ? "breach is" : "breaches are"} not added: a baseline only shrinks. Fix ${held === 1 ? "it" : "them"}, or change the rule in the app.`] : [], "Commit it with the code."].join("\n"),
+    code: 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UsageError,
+  VERBS,
+  projectRoot,
+  runVerb
+});

package/src/shared/build-info.js

@@ -0,0 +1,39 @@
+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 build_info_exports = {};
+__export(build_info_exports, {
+  BUILD_INFO: () => BUILD_INFO
+});
+module.exports = __toCommonJS(build_info_exports);
+var import_package = require("../../package.json");
+const UNSTAMPED = {
+  buildTime: "",
+  buildNumber: 0,
+  commit: "",
+  commitShort: "",
+  branch: "",
+  dirty: false
+};
+const BUILD_INFO = {
+  version: import_package.version,
+  ...typeof __CODETRELLIS_BUILD__ === "undefined" ? UNSTAMPED : __CODETRELLIS_BUILD__
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUILD_INFO
+});

package/src/shared/lib/agent-review.js

@@ -0,0 +1,199 @@
+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 agent_review_exports = {};
+__export(agent_review_exports, {
+  FINDING_KINDS: () => FINDING_KINDS,
+  TOPIC_RE: () => TOPIC_RE,
+  agentFindingLine: () => agentFindingLine,
+  parseAgentReview: () => parseAgentReview,
+  parseUnifiedDiff: () => parseUnifiedDiff,
+  reviewBlockWords: () => reviewBlockWords,
+  reviewOutcome: () => reviewOutcome,
+  reviewWords: () => reviewWords,
+  verifyFindings: () => verifyFindings,
+  wholeFile: () => wholeFile
+});
+module.exports = __toCommonJS(agent_review_exports);
+const FINDING_KINDS = ["rule", "bug", "risk", "question", "suspicious"];
+const TOPIC_RE = /^[a-z0-9][a-z0-9-]{1,62}$/;
+function parseUnifiedDiff(text2) {
+  const out = /* @__PURE__ */ new Map();
+  let file = null;
+  let line = 0;
+  for (const raw of text2.split("\n")) {
+    if (raw.startsWith("+++ ")) {
+      const p = raw.slice(4).trim();
+      file = p === "/dev/null" ? null : p.replace(/^b\//, "");
+      if (file && !out.has(file)) out.set(file, /* @__PURE__ */ new Map());
+      continue;
+    }
+    if (raw.startsWith("--- ") || raw.startsWith("diff ") || raw.startsWith("index ")) continue;
+    const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(raw);
+    if (hunk) {
+      line = Number(hunk[1]);
+      continue;
+    }
+    if (!file || line === 0) continue;
+    if (raw.startsWith("+") || raw.startsWith(" ")) {
+      out.get(file).set(line, raw.slice(1));
+      line += 1;
+    }
+  }
+  return out;
+}
+function wholeFile(text2) {
+  const lines = text2.split("\n");
+  if (lines.length && lines[lines.length - 1] === "") lines.pop();
+  return new Map(lines.map((l, i) => [i + 1, l]));
+}
+const MAX_FINDINGS = 100;
+const MAX_SPAN = 200;
+const squash = (s) => s.replace(/\s+/g, " ").trim();
+const text = (v, max) => typeof v === "string" && v.trim() ? v.trim().slice(0, max) : null;
+function verifyFindings(diff, rules, reported) {
+  const kept = [];
+  const dropped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const r of reported.slice(0, MAX_FINDINGS)) {
+    const says = text(r.says, 1e3);
+    const drop = (why) => dropped.push({ says: says ?? "(no words)", why });
+    if (!says) {
+      drop("it says nothing");
+      continue;
+    }
+    if (!FINDING_KINDS.includes(r.kind)) {
+      drop(`its kind, ${String(r.kind)}, is not one of ${FINDING_KINDS.join(", ")}`);
+      continue;
+    }
+    const kind = r.kind;
+    const cited = !!(r.file || r.start_line || r.quote);
+    let path = null;
+    let start = null;
+    let end = null;
+    let quote = null;
+    if (cited || kind !== "question") {
+      path = text(r.file, 500);
+      const lines = path ? diff.get(path) : void 0;
+      if (!path || !lines) {
+        drop(path ? `${path} is not in the change` : "it names no file");
+        continue;
+      }
+      start = Number.isSafeInteger(r.start_line) ? r.start_line : null;
+      end = Number.isSafeInteger(r.end_line) ? r.end_line : start;
+      if (start === null || end === null || end < start || end - start > MAX_SPAN) {
+        drop("it names no line range in the file");
+        continue;
+      }
+      const span = [];
+      for (let n = start; n <= end; n++) {
+        const l = lines.get(n);
+        if (l === void 0) break;
+        span.push(l);
+      }
+      if (span.length !== end - start + 1) {
+        drop(`lines ${start}\u2013${end} of ${path} are not in the diff`);
+        continue;
+      }
+      quote = text(r.quote, 2e3);
+      if (!quote) {
+        drop("it quotes no code");
+        continue;
+      }
+      if (!squash(span.join("\n")).includes(squash(quote))) {
+        drop(`its quote is not what lines ${start}\u2013${end} of ${path} say`);
+        continue;
+      }
+    }
+    const rule = text(r.rule, 63);
+    if (kind === "rule" && (!rule || !rules.has(rule))) {
+      drop(rule ? `the rule ${rule} is not in scope` : "a rule finding names no rule");
+      continue;
+    }
+    const key = `${kind}|${path}|${start}|${end}|${squash(says)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const topic = typeof r.topic === "string" && TOPIC_RE.test(r.topic.trim()) ? r.topic.trim() : null;
+    kept.push({ kind, path, start, end, quote, says, rule: kind === "rule" ? rule : rule && rules.has(rule) ? rule : null, fix: text(r.fix, 500), topic });
+  }
+  if (reported.length > MAX_FINDINGS) dropped.push({ says: `${reported.length - MAX_FINDINGS} more`, why: `a review reports at most ${MAX_FINDINGS} findings` });
+  return { kept, dropped };
+}
+function reviewOutcome(reported, kept) {
+  if (reported.inconclusive) return { outcome: "inconclusive", reason: reported.inconclusive };
+  if (kept.length > 0) return { outcome: "findings", reason: null };
+  if (reported.findings.length > 0) return { outcome: "inconclusive", reason: "none of its findings could be grounded in the change" };
+  return { outcome: "pass", reason: null };
+}
+const GLYPH = { rule: "\u2717", bug: "\u2717", risk: "\u26A0", question: "?", suspicious: "\u2691" };
+function reviewWords(r) {
+  const dropped = r.dropped.length ? ` \xB7 ${r.dropped.length} dropped` : "";
+  if (r.outcome === "error") return `\u2717 error: ${r.reason ?? "the agent could not run"}`;
+  if (r.outcome === "inconclusive") return `? inconclusive: ${r.reason ?? "no reason given"}${dropped}`;
+  if (r.outcome === "pass") return `\u2713 nothing found${dropped}`;
+  const questions = r.findings.filter((f) => f.kind === "question").length;
+  const others = r.findings.length - questions;
+  return [
+    others ? `\u26A0 ${others} ${others === 1 ? "finding" : "findings"}` : null,
+    questions ? `? ${questions} ${questions === 1 ? "question" : "questions"}` : null
+  ].filter(Boolean).join(" \xB7 ") + dropped;
+}
+function reviewBlockWords(r, blocks) {
+  return `${blocks > 0 ? `\u2717 ${blocks} block \xB7 ` : ""}${reviewWords(r)}`;
+}
+function agentFindingLine(f) {
+  const where = f.path ? `${f.path}${f.start ? `:${f.start}${f.end && f.end !== f.start ? `\u2013${f.end}` : ""}` : ""}` : "the change";
+  return `${GLYPH[f.kind]} ${f.kind}${f.rule ? ` (${f.rule})` : ""} \xB7 ${where}: ${f.says}${f.fix ? ` \u2192 ${f.fix}` : ""}`;
+}
+function parseAgentReview(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const outcome = ["pass", "findings", "inconclusive", "error"].find((o) => o === r.outcome);
+  if (!outcome) return null;
+  const findings = (Array.isArray(r.findings) ? r.findings : []).slice(0, MAX_FINDINGS).flatMap((x) => {
+    const f = x && typeof x === "object" ? x : {};
+    const kind = FINDING_KINDS.includes(f.kind) ? f.kind : null;
+    const says = text(f.says, 1e3);
+    if (!kind || !says) return [];
+    const n = (v) => Number.isSafeInteger(v) && v > 0 ? v : null;
+    const p = typeof f.path === "string" && f.path && !f.path.startsWith("/") && !f.path.split("/").includes("..") ? f.path.slice(0, 500) : null;
+    const topic = typeof f.topic === "string" && TOPIC_RE.test(f.topic) ? f.topic : null;
+    return [{ kind, path: p, start: n(f.start), end: n(f.end), quote: text(f.quote, 2e3), says, rule: text(f.rule, 63), fix: text(f.fix, 500), topic }];
+  });
+  const dropped = (Array.isArray(r.dropped) ? r.dropped : []).slice(0, 200).flatMap((x) => {
+    const d = x && typeof x === "object" ? x : {};
+    const says = text(d.says, 1e3);
+    const why = text(d.why, 300);
+    return says && why ? [{ says, why }] : [];
+  });
+  const refused = (Array.isArray(r.refused) ? r.refused : []).map((x) => text(x, 300)).filter((x) => !!x).slice(0, 200);
+  const retries = Number.isSafeInteger(r.retries) && r.retries > 0 ? Math.min(r.retries, 10) : 0;
+  return { outcome, reason: text(r.reason, 500), agent: text(r.agent, 80) ?? "an agent", findings, dropped, refused, pass: text(r.pass, 80), retries, verify: text(r.verify, 300) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FINDING_KINDS,
+  TOPIC_RE,
+  agentFindingLine,
+  parseAgentReview,
+  parseUnifiedDiff,
+  reviewBlockWords,
+  reviewOutcome,
+  reviewWords,
+  verifyFindings,
+  wholeFile
+});