@bastani/atomic 0.9.16-alpha.6 → 0.9.16-alpha.8

package/dist/builtin/workflows/builtin/chunk-cg9tmks0.js

@@ -0,0 +1,206 @@
+// dist/builtin/workflows/builtin/verification-criteria.ts
+import { Type } from "typebox";
+
+class RubricError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = code;
+    this.code = code;
+  }
+}
+
+class NoCriteria extends RubricError {
+  constructor(message = "no criteria found — check the `## Criteria` section and its `### Name {#id}` headings") {
+    super(message, "NoCriteria");
+    this.name = "NoCriteria";
+  }
+}
+
+class EmptyCriterion extends RubricError {
+  ids;
+  constructor(ids) {
+    super(`criteria have empty instructions: ${ids.join(", ")}`, "EmptyCriterion");
+    this.name = "EmptyCriterion";
+    this.ids = ids;
+  }
+}
+var CRITERION_ID_ANCHOR = /^(.*?)\s*\{#([A-Za-z0-9_-]+)\}\s*$/;
+var SLUG_MAX_LENGTH = 40;
+function slug_id(text) {
+  const slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return slug.slice(0, SLUG_MAX_LENGTH).replace(/_+$/g, "") || "criterion";
+}
+function dedup_id(cid, seen) {
+  let out = cid;
+  let n = 1;
+  while (seen.has(out)) {
+    n += 1;
+    out = `${cid}_${n}`;
+  }
+  seen.add(out);
+  return out;
+}
+function criterion(id, name, description) {
+  return { id, name, description };
+}
+function strip_html_comments(markdown) {
+  let sanitized = markdown;
+  while (true) {
+    const opener = sanitized.indexOf("<!--");
+    if (opener === -1)
+      return sanitized;
+    const closer = sanitized.indexOf("-->", opener + 4);
+    if (closer === -1)
+      return sanitized.slice(0, opener);
+    sanitized = sanitized.slice(0, opener) + sanitized.slice(closer + 3);
+  }
+}
+function parse_rubric(markdown) {
+  const lines = strip_html_comments(markdown).split(/\r?\n/);
+  let groundTruthNote = "";
+  let seenGroundTruth = false;
+  const criteria = [];
+  const seen = new Set;
+  let section = null;
+  let currentName = null;
+  let currentId = null;
+  let buf = [];
+  const flush = () => {
+    const text = buf.join(`
+`).trim();
+    buf = [];
+    if (section === "ground_truth") {
+      if (!seenGroundTruth) {
+        groundTruthNote = text;
+        seenGroundTruth = true;
+      }
+      return;
+    }
+    if (currentName === null || currentId === null)
+      return;
+    criteria.push(criterion(currentId, currentName, text));
+    currentName = null;
+    currentId = null;
+  };
+  for (const line of lines) {
+    if (line.startsWith("## ") && !line.startsWith("### ")) {
+      flush();
+      const heading = line.slice(3).trim().toLowerCase();
+      if (heading.includes("ground truth")) {
+        section = "ground_truth";
+      } else if (heading.includes("criteri")) {
+        section = "criteria";
+      } else {
+        section = null;
+      }
+      continue;
+    }
+    if (line.startsWith("### ") && section === "criteria") {
+      flush();
+      const heading = line.slice(4).trim();
+      const anchored = CRITERION_ID_ANCHOR.exec(heading);
+      const name = anchored ? anchored[1].trim() : heading;
+      const rawId = anchored ? anchored[2].trim() : slug_id(heading);
+      currentName = name;
+      currentId = dedup_id(rawId, seen);
+      continue;
+    }
+    if (line.startsWith("# ")) {
+      continue;
+    }
+    buf.push(line);
+  }
+  flush();
+  if (criteria.length === 0) {
+    throw new NoCriteria;
+  }
+  const empty = criteria.filter((item) => item.description.length === 0).map((item) => item.id);
+  if (empty.length > 0) {
+    throw new EmptyCriterion(empty);
+  }
+  return { groundTruthNote, criteria };
+}
+function isRecord(value) {
+  return Object.values(value).every((entry) => typeof entry === "string");
+}
+function isOptionalString(value, key) {
+  if (!(key in value))
+    return true;
+  return typeof value[key] === "string";
+}
+function isCriterionInput(value) {
+  return isOptionalString(value, "id") && isOptionalString(value, "name") && isOptionalString(value, "description");
+}
+function normalize_one(raw, index, seen) {
+  const cidRaw = typeof raw === "string" ? "" : String(raw.id ?? "");
+  const nameRaw = typeof raw === "string" ? raw : String(raw.name ?? "");
+  const desc = typeof raw === "string" ? raw : String(raw.description ?? "");
+  if (desc.length === 0) {
+    throw new EmptyCriterion([cidRaw || nameRaw || String(index)]);
+  }
+  const name = nameRaw || cidRaw || slug_id(desc);
+  const id = dedup_id(cidRaw || slug_id(name), seen);
+  return criterion(id, name, desc);
+}
+function normalize_criteria(input) {
+  if (input === null || typeof input !== "object") {
+    throw new TypeError(`criteria must be a record, string[], or CriterionInput[], got ${typeof input}`);
+  }
+  const rawItems = [];
+  if (Array.isArray(input)) {
+    for (const [index, raw] of input.entries()) {
+      if (typeof raw === "string") {
+        rawItems.push(raw);
+        continue;
+      }
+      if (isCriterionInput(raw)) {
+        rawItems.push(raw);
+        continue;
+      }
+      throw new TypeError(`criteria[${index}] must be a string or CriterionInput`);
+    }
+  } else if (isRecord(input)) {
+    for (const [name, description] of Object.entries(input)) {
+      rawItems.push({ name, description });
+    }
+  } else {
+    throw new TypeError("criteria record values must be strings");
+  }
+  const seen = new Set;
+  const out = rawItems.map((raw, index) => normalize_one(raw, index, seen));
+  if (out.length === 0) {
+    throw new NoCriteria("criteria is empty");
+  }
+  return out;
+}
+var VERIFICATION_SCALE = {
+  min: 1,
+  max: 20,
+  anchors: "1 = certainly fails … 10 = borderline … 20 = verified correct",
+  schema: Type.Integer({ minimum: 1, maximum: 20 })
+};
+function mean_score(scores) {
+  if (scores.length === 0)
+    return 0;
+  let total = 0;
+  for (const item of scores)
+    total += item.score;
+  return total / scores.length;
+}
+function decide_verification(round, policy) {
+  const { scores, expectedCount } = round;
+  const valid = scores.length;
+  const quorumNeeded = Math.ceil(expectedCount * policy.quorumFraction);
+  if (valid < quorumNeeded) {
+    return { kind: "indeterminate", missing: Math.max(0, expectedCount - valid) };
+  }
+  const mean = mean_score(scores);
+  const findings = scores.flatMap((item) => item.findings);
+  if (findings.some((item) => item.severity === "veto") || mean < policy.acceptMean) {
+    return { kind: "repair", mean, findings };
+  }
+  return { kind: "accept", mean };
+}
+
+export { parse_rubric, normalize_criteria, VERIFICATION_SCALE, decide_verification };