@kodr/aiwrangler 0.1.1 → 0.1.2

package/dist/{chunk-2CIV4KGU.js → chunk-RZWCNEZS.js}

@@ -6,10 +6,384 @@ import {
   diffFingerprint,
   expandPath,
   formatFindings,
+  loadConfig,
   parseCargoJson,
   readRuntimeOverridesFile,
-  runDeterministic
-} from "./chunk-EAQASAXL.js";
+  runDeterministic,
+  sha256Hex
+} from "./chunk-F3YFQ4NW.js";
+
+// src/types.ts
+var PRECEDENCE = {
+  ruling: 0,
+  paper: 1,
+  door: 1,
+  spec: 2,
+  doc: 3,
+  nonRuling: 4
+};
+
+// src/groundtruth/sectionize.ts
+function splitMarkdown(md) {
+  const lines = md.split("\n");
+  const sections = [];
+  let current = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const m = line.match(/^(#{1,6})\s+(.*)$/);
+    if (m) {
+      if (current) sections.push(current);
+      current = { level: m[1].length, title: m[2].trim(), text: "", line: i + 1 };
+    } else if (current) {
+      current.text += line + "\n";
+    }
+  }
+  if (current) sections.push(current);
+  return sections.map((s) => ({ ...s, text: s.text.trim() }));
+}
+function slug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+}
+
+// src/groundtruth/parsers.ts
+function section(partial) {
+  return { precedence: PRECEDENCE.doc, ...partial };
+}
+var ROMAN_RE = /^[IVX]+(?:-[A-Z])?$/;
+function parseSpec(md, source) {
+  const out = [];
+  for (const sec of splitMarkdown(md)) {
+    const m = sec.title.match(/^(\d+)\.\s+(.*)$/);
+    if (!m) continue;
+    const title = m[2];
+    const ref = title.match(/\(([^)]+)\)\s*$/);
+    const paperRef = ref && ROMAN_RE.test(ref[1]) ? ref[1] : void 0;
+    out.push(
+      section({
+        id: `SPEC-${m[1]}`,
+        kind: "spec",
+        title,
+        text: sec.text,
+        source,
+        status: "info",
+        ...paperRef ? { paperRef } : {},
+        precedence: PRECEDENCE.spec
+      })
+    );
+  }
+  return out;
+}
+function parseRules(md, source) {
+  const lines = md.split("\n");
+  const out = [];
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    out.push(
+      section({
+        id: `RULE-${current.n}`,
+        kind: "rule",
+        title: current.lines[0].trim(),
+        text: current.lines.join("\n").trim(),
+        source,
+        status: "info",
+        precedence: PRECEDENCE.spec
+      })
+    );
+    current = null;
+  };
+  for (const line of lines) {
+    const m = line.match(/^(\d+)\.\s+(.*)$/);
+    if (m) {
+      flush();
+      current = { n: m[1], lines: [m[2]] };
+      continue;
+    }
+    if (current && (/^\s{2,}/.test(line) || line.trim() === "")) {
+      if (line.trim() === "" && current.lines[current.lines.length - 1] === "") continue;
+      current.lines.push(line.trim() === "" ? "" : line.trim());
+      continue;
+    }
+    flush();
+  }
+  flush();
+  return out;
+}
+function parseDivergences(md, source) {
+  const lines = md.split("\n");
+  const out = [];
+  let topic = "";
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    const body = current.lines.join("\n").trim();
+    const marker = body.indexOf("**RULED");
+    const ruled = marker >= 0;
+    const ruling = ruled ? body.slice(marker).replace(/\*\*/g, "").replace(/\s+/g, " ").trim().slice(0, 800) : void 0;
+    out.push(
+      section({
+        id: `DIV-D-${current.id}`,
+        kind: "divergence",
+        title: `${current.topic ? current.topic + ": " : ""}${current.lines[0].trim()}`,
+        text: body,
+        source,
+        status: ruled ? "ruled" : "open",
+        ...ruled && ruling ? { ruling } : {},
+        precedence: ruled ? PRECEDENCE.ruling : PRECEDENCE.nonRuling
+      })
+    );
+    current = null;
+  };
+  for (const line of lines) {
+    const h = line.match(/^##\s+(.*)$/);
+    if (h) {
+      flush();
+      topic = h[1].trim();
+      continue;
+    }
+    const m = line.match(/^D-(\d+)\s+(.*)$/);
+    if (m) {
+      flush();
+      current = { id: m[1], lines: [m[2]], topic };
+      continue;
+    }
+    if (current) current.lines.push(line);
+  }
+  flush();
+  return out;
+}
+function parseQuestions(md, source) {
+  const lines = md.split("\n");
+  const out = [];
+  let heading = "";
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    const body = current.lines.join("\n").trim();
+    const marker = body.indexOf("**ANSWERED");
+    const answered = marker >= 0;
+    const ruling = answered ? body.slice(marker).replace(/\*\*/g, "").replace(/\s+/g, " ").trim().slice(0, 800) : void 0;
+    out.push(
+      section({
+        id: `Q-${current.n}`,
+        kind: "question",
+        title: current.lines[0].trim(),
+        text: body,
+        source,
+        status: answered ? "answered" : "open",
+        ...answered && ruling ? { ruling } : {},
+        precedence: answered ? PRECEDENCE.ruling : PRECEDENCE.nonRuling
+      })
+    );
+    current = null;
+  };
+  for (const line of lines) {
+    const h = line.match(/^##\s+(.*)$/);
+    if (h) {
+      flush();
+      heading = h[1].trim();
+      continue;
+    }
+    const m = line.match(/^(\d+)\.\s+(.*)$/);
+    if (m) {
+      flush();
+      current = { n: m[1], lines: [m[2]], heading };
+      continue;
+    }
+    if (current) current.lines.push(line);
+  }
+  flush();
+  return out;
+}
+function parsePlan(md, source) {
+  const out = [];
+  for (const sec of splitMarkdown(md)) {
+    if (!/one-way door|launch gate/i.test(sec.title)) continue;
+    out.push(
+      section({
+        id: `DOOR-${slug(sec.title) || out.length + 1}`,
+        kind: "door",
+        title: sec.title,
+        text: sec.text,
+        source,
+        status: "info",
+        precedence: PRECEDENCE.door
+      })
+    );
+  }
+  return out;
+}
+function parseDoc(md, source, label) {
+  return splitMarkdown(md).filter((s) => s.text.length > 0).map(
+    (sec, i) => section({
+      id: `DOC-${label}-${String(i + 1).padStart(2, "0")}`,
+      kind: "doc",
+      title: sec.title || "(intro)",
+      text: sec.text,
+      source,
+      status: "info",
+      precedence: PRECEDENCE.doc
+    })
+  );
+}
+var PAPER_HEADING_RE = /^([IVX]+(?:-[A-Z])?)?\.?\s{1,4}(.+)$/;
+var ROMAN_ONLY_RE = /^[IVX]+$/;
+function mergeSpacedCaps(title) {
+  const tokens = title.split(/\s+/).filter(Boolean);
+  const merged = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    const next = tokens[i + 1];
+    if (next !== void 0 && /^-?[A-Z]$/.test(tok) && /^[A-Z]/.test(next) && next.length > 1) {
+      merged.push((tok.startsWith("-") ? tok : "") + next);
+      i += 2;
+      continue;
+    }
+    if (tok.length === 1 && /^[A-Z]$/.test(tok) && next !== void 0 && /^[A-Z]/.test(next)) {
+      merged.push(tok + next);
+      i += 2;
+      continue;
+    }
+    merged.push(tok);
+    i++;
+  }
+  return merged.join(" ").replace(/ -/g, "-").replace(/\s+,/g, ",");
+}
+function capsRatio(s) {
+  const letters = s.replace(/[^A-Za-z]/g, "");
+  if (letters.length === 0) return 0;
+  const upper = letters.replace(/[^A-Z]/g, "");
+  return upper.length / letters.length;
+}
+function parsePaper(text, source) {
+  const lines = text.split("\n").map((l) => l.replace(/^\f/, ""));
+  const byId = /* @__PURE__ */ new Map();
+  let current = null;
+  const looksLikeCapsFragment = (line) => {
+    const t = line.trim();
+    return t.length >= 3 && t.length <= 40 && !/[.:;]$/.test(t) && !/\.\s*\.\s*\./.test(t) && capsRatio(t) >= 0.6;
+  };
+  const flush = () => {
+    if (!current) return;
+    const body = current.lines.join("\n").trim();
+    const existing = byId.get(current.id);
+    if (existing) {
+      existing.text = (existing.text + "\n" + body).trim();
+    } else {
+      byId.set(
+        current.id,
+        section({
+          id: `PAPER-${current.id}`,
+          kind: "paper",
+          title: current.title,
+          text: body,
+          source,
+          status: "info",
+          precedence: PRECEDENCE.paper
+        })
+      );
+    }
+    current = null;
+  };
+  for (let li = 0; li < lines.length; li++) {
+    const line = lines[li] ?? "";
+    if (/\.\s*\.\s*\./.test(line)) continue;
+    const m = line.match(PAPER_HEADING_RE);
+    if (m && m[1] && !ROMAN_ONLY_RE.test(m[2] ?? "") && !/^[ivx]+$/.test(m[1])) {
+      let title = mergeSpacedCaps(m[2] ?? "");
+      let consumed = 1;
+      while (li + consumed < lines.length && looksLikeCapsFragment(lines[li + consumed] ?? "") && title.split(/\s+/).length < 10) {
+        title = title + " " + mergeSpacedCaps((lines[li + consumed] ?? "").trim());
+        consumed++;
+      }
+      const letters = title.replace(/[^A-Za-z]/g, "");
+      if (letters.length >= 4 && capsRatio(title) >= 0.7) {
+        flush();
+        current = { id: m[1], title: title.replace(/\s{2,}/g, " ").trim(), lines: [] };
+        li += consumed - 1;
+        continue;
+      }
+    }
+    if (current) current.lines.push(line);
+  }
+  flush();
+  return [...byId.values()];
+}
+
+// src/groundtruth/whitepaper.ts
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { join } from "path";
+function ensurePaperText(config, root) {
+  const pdf = expandPath(config.corpus.whitepaper, root);
+  const cacheDir = expandPath(config.cache.dir, root);
+  const cached = join(cacheDir, "whitepaper.txt");
+  const pdfMtime = existsSync(pdf) ? statSync(pdf).mtimeMs : 0;
+  if (existsSync(cached) && statSync(cached).mtimeMs >= pdfMtime) {
+    return { text: readFileSync(cached, "utf8"), extracted: false };
+  }
+  if (!existsSync(pdf)) return { text: null, extracted: false };
+  const res = spawnSync("pdftotext", [pdf, "-"], { encoding: "utf8", maxBuffer: 32 * 1024 * 1024 });
+  if (res.error || res.status !== 0) {
+    const reason = res.error ? res.error.message : `pdftotext exit ${res.status}`;
+    throw new Error(`whitepaper extraction failed (${reason}); is poppler-utils installed?`);
+  }
+  const text = res.stdout;
+  if (text.split(/\s+/).length < 1e3) throw new Error("whitepaper extraction produced suspiciously little text; refusing to cache");
+  mkdirSync(cacheDir, { recursive: true });
+  writeFileSync(cached, text, "utf8");
+  return { text, extracted: true };
+}
+
+// src/groundtruth/corpus.ts
+import { readFileSync as readFileSync2 } from "fs";
+function slugFromPath(rel) {
+  return rel.toLowerCase().replace(/\.[a-z0-9]+$/i, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+}
+function readOr(path, fallback) {
+  try {
+    return { text: readFileSync2(path, "utf8"), sections: [] };
+  } catch {
+    return { text: null, sections: fallback };
+  }
+}
+function loadCorpus(config, root) {
+  const sections = [];
+  const sources = [];
+  const addFile = (path, parse) => {
+    const resolved = expandPath(path, root);
+    const { text } = readOr(resolved, []);
+    if (text === null) return;
+    sources.push({ path: resolved, hash: sha256Hex(text) });
+    sections.push(...parse(text, resolved));
+  };
+  addFile(config.corpus.spec, parseSpec);
+  addFile(config.corpus.rules, parseRules);
+  addFile(config.corpus.divergences, parseDivergences);
+  addFile(config.corpus.questions, parseQuestions);
+  addFile(config.corpus.plan, parsePlan);
+  for (const doc of config.corpus.docs) {
+    const resolved = expandPath(doc, root);
+    let label = doc.split("/").pop()?.replace(/\.[a-z]+$/i, "") ?? "doc";
+    const rel = resolved.startsWith(root + "/") ? resolved.slice(root.length + 1) : null;
+    if (rel && rel.includes("/")) label = slugFromPath(rel);
+    addFile(doc, (md, source) => parseDoc(md, source, label));
+  }
+  const paper = ensurePaperText(config, root);
+  if (paper.text !== null) {
+    const paperPath = expandPath(config.corpus.whitepaper, root);
+    sources.push({ path: paperPath, hash: sha256Hex(paper.text) });
+    sections.push(...parsePaper(paper.text, paperPath));
+  }
+  const hash = sha256Hex(JSON.stringify({ sources: sources.map((s) => [s.path, s.hash]).sort((a, b) => (a[0] ?? "").localeCompare(b[0] ?? "")), ids: sections.map((s) => s.id).sort() }));
+  return { sections, sources, hash, paperText: paper.text ?? "" };
+}
+function loadCorpusFrom(startDir) {
+  const loaded = loadConfig(startDir);
+  const corpus = loadCorpus(loaded.config, loaded.root);
+  return { loaded, corpus };
+}
 
 // src/jev/questions.ts
 function noul(instructions, yes, no) {
@@ -48,9 +422,9 @@ function lexicalScore(index, query) {
   const qTerms = tokenize(query);
   const N = Math.max(index.sections.length, 1);
   const scores = [];
-  for (const section of index.sections) {
-    const titleTerms = new Set(tokenize(section.title));
-    const bodyTerms = tokenize(section.text);
+  for (const section2 of index.sections) {
+    const titleTerms = new Set(tokenize(section2.title));
+    const bodyTerms = tokenize(section2.text);
     const tf = /* @__PURE__ */ new Map();
     for (const t of bodyTerms) tf.set(t, (tf.get(t) ?? 0) + 1);
     let score2 = 0;
@@ -62,8 +436,8 @@ function lexicalScore(index, query) {
       if (tfCount > 0) score2 += idf * (1 + Math.log(tfCount)) / (1 + Math.log(bodyTerms.length || 1)) * 10;
       if (titleTerms.has(term)) score2 += idf * 3;
     }
-    if (section.kind === "door") score2 += 0.5;
-    scores.push({ section, score: score2 });
+    if (section2.kind === "door") score2 += 0.5;
+    scores.push({ section: section2, score: score2 });
   }
   return scores.sort((a, b) => b.score - a.score);
 }
@@ -831,12 +1205,12 @@ async function runCheckBattery(config, jev, corpus, input, opts = {}) {
   });
   return { findings, verdicts, sections: ranked, usage: res.usage, examinedFiles };
 }
-function overridesFor(section, rulings) {
+function overridesFor(section2, rulings) {
   const out = [];
   const sectionTerms = new Set(
-    section.title.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 3)
+    section2.title.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 3)
   );
-  if (section.paperRef) sectionTerms.add(section.paperRef.toLowerCase());
+  if (section2.paperRef) sectionTerms.add(section2.paperRef.toLowerCase());
   for (const r of rulings) {
     const text = (r.title + " " + (r.ruling ?? "")).toLowerCase();
     let hits = 0;
@@ -903,12 +1277,12 @@ async function selectRootCause(jev, diags) {
 }
 
 // src/gates/check/snapshot.ts
-import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync3, renameSync, statSync as statSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
 var SNAPSHOT_CAP = 2e5;
 var KEEP_SNAPSHOTS = 20;
 function snapshotsDir(config, root) {
-  return join(expandPath(config.cache.dir, root), "diffs");
+  return join2(expandPath(config.cache.dir, root), "diffs");
 }
 function renderDiffSnapshot(diffs) {
   const out = [`snapshot generated ${(/* @__PURE__ */ new Date()).toISOString()}; added lines carry their new-file line number`];
@@ -946,10 +1320,10 @@ function renderDiffSnapshot(diffs) {
 function writeDiffSnapshot(config, root, diffHash, diffs) {
   if (diffs.length === 0) return null;
   const dir = snapshotsDir(config, root);
-  mkdirSync(dir, { recursive: true });
-  const path = join(dir, `${diffHash}.txt`);
+  mkdirSync2(dir, { recursive: true });
+  const path = join2(dir, `${diffHash}.txt`);
   const tmp = path + ".tmp";
-  writeFileSync(tmp, renderDiffSnapshot(diffs) + "\n", "utf8");
+  writeFileSync2(tmp, renderDiffSnapshot(diffs) + "\n", "utf8");
   renameSync(tmp, path);
   pruneSnapshots(dir);
   return path;
@@ -964,21 +1338,21 @@ function pruneSnapshots(dir) {
   if (entries.length <= KEEP_SNAPSHOTS) return;
   const withTimes = entries.map((name) => {
     try {
-      return { name, mtime: statSync(join(dir, name)).mtimeMs };
+      return { name, mtime: statSync2(join2(dir, name)).mtimeMs };
     } catch {
       return null;
     }
   }).filter((e) => e !== null).sort((a, b) => b.mtime - a.mtime);
   for (const old of withTimes.slice(KEEP_SNAPSHOTS)) {
     try {
-      unlinkSync(join(dir, old.name));
+      unlinkSync(join2(dir, old.name));
     } catch {
     }
   }
 }
 
 // src/gates/check/run.ts
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var SEVERITY_RANK = { review: 1, block: 2, human: 3 };
 var FILES_SUMMARY_CAP = 200;
 function fileSummary(diffs) {
@@ -1042,7 +1416,7 @@ async function runCheck(config, root, corpus, jev, opts) {
     };
   }
   const stateDir = expandPath(config.cache.dir, root);
-  const tracker = new LoopTracker(join2(stateDir, "loop-state.json"));
+  const tracker = new LoopTracker(join3(stateDir, "loop-state.json"));
   const diffText = diffs.flatMap((d) => d.files.map((f) => f.path + "\n" + f.hunks.flatMap((h) => h.lines.filter((l) => l.kind === "add").map((l) => l.text)).join("\n"))).join("\n");
   const fingerprint = diffFingerprint(diffText);
   const files = fileSummary(diffs);
@@ -1264,6 +1638,19 @@ function overlaps(a, b) {
 }
 
 export {
+  PRECEDENCE,
+  splitMarkdown,
+  slug,
+  parseSpec,
+  parseRules,
+  parseDivergences,
+  parseQuestions,
+  parsePlan,
+  parseDoc,
+  parsePaper,
+  ensurePaperText,
+  loadCorpus,
+  loadCorpusFrom,
   runPlanGate,
   runCheck,
   formatReport,
@@ -1273,4 +1660,4 @@ export {
   paperSectionForSpec,
   authoritativeFor
 };
-//# sourceMappingURL=chunk-2CIV4KGU.js.map
+//# sourceMappingURL=chunk-RZWCNEZS.js.map