@domandigital/craft 0.9.0 → 0.11.0

package/dist/chunk-2AJB27BJ.js

@@ -0,0 +1,743 @@
+import {
+  CATALOGUE,
+  CATALOGUE_VERSION,
+  applyHouseGate,
+  checkCopy,
+  extractCopy,
+  extractStrings,
+  fileKind,
+  houseRule,
+  scanSource
+} from "./chunk-3NGWXZZE.js";
+
+// src/character/config.ts
+var DEFAULT_IGNORE = [".claude", ".agents", ".cursor"];
+var KEYS = /* @__PURE__ */ new Set(["$schema", "ignore", "copyPaths", "severity"]);
+var LEVELS = /* @__PURE__ */ new Set(["warn", "block", "off"]);
+var MIN_BECAUSE = 12;
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isStringArray = (v) => Array.isArray(v) && v.every((s) => typeof s === "string");
+function parseCraftConfig(data, knownTells, source = "craft.config.json") {
+  if (!isRecord(data)) throw new Error(`${source}: expected an object`);
+  for (const key of Object.keys(data)) if (!KEYS.has(key)) throw new Error(`${source}: unknown key "${key}"`);
+  const ignore = data.ignore ?? [];
+  if (!isStringArray(ignore)) throw new Error(`${source}: "ignore" must be an array of glob strings`);
+  if (data.copyPaths !== void 0 && !isStringArray(data.copyPaths)) throw new Error(`${source}: "copyPaths" must be an array of paths`);
+  const severity = {};
+  const raw = data.severity ?? {};
+  if (!isRecord(raw)) throw new Error(`${source}: "severity" must map a tell id to { level, because }`);
+  for (const [tell, value] of Object.entries(raw)) {
+    if (!knownTells.has(tell)) throw new Error(`${source}: severity names no tell called "${tell}"`);
+    if (!isRecord(value) || !LEVELS.has(value.level)) {
+      throw new Error(`${source}: severity.${tell} needs a level of "warn", "block" or "off"`);
+    }
+    if (typeof value.because !== "string" || value.because.trim().length < MIN_BECAUSE) {
+      throw new Error(`${source}: severity.${tell} needs a because of at least a sentence`);
+    }
+    severity[tell] = { level: value.level, because: value.because };
+  }
+  return { ignore, severity, ...data.copyPaths ? { copyPaths: data.copyPaths } : {} };
+}
+function globToRegExp(glob) {
+  const pattern = glob.replace(/^\.\//, "").replace(/\/$/, "").replace(/\/\*\*$/, "");
+  let body = "";
+  for (let i = 0; i < pattern.length; i += 1) {
+    const c = pattern[i];
+    if (c === "*" && pattern[i + 1] === "*") {
+      const slash = pattern[i + 2] === "/";
+      body += slash ? "(?:.*/)?" : ".*";
+      i += slash ? 2 : 1;
+    } else if (c === "*") body += "[^/]*";
+    else if (c === "?") body += "[^/]";
+    else body += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  const anywhere = !pattern.includes("/");
+  return new RegExp(`^${anywhere ? "(?:.*/)?" : ""}${body}(?:/.*)?$`);
+}
+function ignoreMatcher(patterns) {
+  const res = patterns.map(globToRegExp);
+  return (path) => {
+    const p = path.replace(/\\/g, "/").replace(/^\.\//, "");
+    return res.some((re) => re.test(p));
+  };
+}
+function severityExceptions(config) {
+  return Object.entries(config.severity).filter(([, o]) => o.level === "off").map(([tell, o]) => ({ tell, because: `craft.config.json: ${o.because}` }));
+}
+function applySeverity(report, config) {
+  const findings = report.findings.map((f) => {
+    const o = config.severity[f.tell];
+    return o && o.level !== "off" ? { ...f, severity: o.level } : f;
+  });
+  return { ...report, findings, summary: { ...report.summary, blocking: findings.filter((f) => f.severity === "block").length } };
+}
+
+// src/character/json.ts
+var JSON_SCHEMA_VERSION = 1;
+function toJson(data) {
+  return JSON.stringify({ schemaVersion: JSON_SCHEMA_VERSION, ...data }, null, 2);
+}
+
+// src/character/cli.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+import { join, relative, resolve } from "path";
+
+// src/character/baseline.ts
+var BASELINE_VERSION = 1;
+function fnv1a(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+var excerptHash = (f) => fnv1a(f.excerpt.replace(/\s+/g, " ").trim());
+var keyOf = (tell, path, excerpt) => `${tell}\0${path}\0${excerpt}`;
+function findingKey(f) {
+  return keyOf(f.tell, f.path, excerptHash(f));
+}
+function createBaseline(report) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const f of report.findings) {
+    const excerpt = excerptHash(f);
+    const key = keyOf(f.tell, f.path, excerpt);
+    const entry = counts.get(key);
+    if (entry) entry.count += 1;
+    else counts.set(key, { tell: f.tell, path: f.path, excerpt, count: 1 });
+  }
+  const entries = [...counts.values()].sort((a, b) => a.path.localeCompare(b.path) || a.tell.localeCompare(b.tell) || a.excerpt.localeCompare(b.excerpt));
+  return { version: BASELINE_VERSION, catalogueVersion: report.catalogueVersion, entries };
+}
+function parseBaseline(data, source = "baseline") {
+  const b = data;
+  if (!b || typeof b !== "object" || b.version !== BASELINE_VERSION || !Array.isArray(b.entries)) {
+    throw new Error(`${source}: not a craft baseline (version ${BASELINE_VERSION})`);
+  }
+  for (const e of b.entries) {
+    if (typeof e?.tell !== "string" || typeof e.path !== "string" || typeof e.excerpt !== "string" || !Number.isInteger(e.count) || e.count < 1) {
+      throw new Error(`${source}: malformed entry ${JSON.stringify(e)}`);
+    }
+  }
+  return b;
+}
+function recount(report, findings) {
+  const byGeneration = { 1: 0, 2: 0, 3: 0 };
+  const byTell = {};
+  for (const f of findings) {
+    byGeneration[f.generation] += 1;
+    byTell[f.tell] = (byTell[f.tell] ?? 0) + 1;
+  }
+  return {
+    ...report,
+    findings,
+    summary: { ...report.summary, findings: findings.length, byGeneration, byTell, blocking: findings.filter((f) => f.severity === "block").length }
+  };
+}
+function applyBaseline(report, baseline) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const e of baseline.entries) {
+    const key = keyOf(e.tell, e.path, e.excerpt);
+    remaining.set(key, (remaining.get(key) ?? 0) + e.count);
+  }
+  const kept = [];
+  let baselined = 0;
+  for (const f of report.findings) {
+    const key = findingKey(f);
+    const left = remaining.get(key) ?? 0;
+    if (left > 0) {
+      remaining.set(key, left - 1);
+      baselined += 1;
+    } else kept.push(f);
+  }
+  return { ...recount(report, kept), baselined };
+}
+
+// src/character/sarif.ts
+var isUrl = (path) => /^[a-z][a-z0-9+.-]*:\/\//i.test(path);
+function toSarif(report, options) {
+  const byId = new Map(options.tells.map((t) => [t.id, t]));
+  const ids = [...new Set(report.findings.map((f) => f.tell))].sort();
+  const index = new Map(ids.map((id, i) => [id, i]));
+  const rules = ids.map((id) => {
+    const t = byId.get(id);
+    return {
+      id,
+      name: t?.name ?? id,
+      shortDescription: { text: t?.name ?? id },
+      ...t ? { fullDescription: { text: t.why }, help: { text: t.fix } } : {}
+    };
+  });
+  const results = report.findings.map((f) => ({
+    ruleId: f.tell,
+    ruleIndex: index.get(f.tell),
+    level: f.severity === "block" ? "error" : "warning",
+    message: { text: `${f.message}. ${f.fix}` },
+    locations: [
+      {
+        physicalLocation: {
+          artifactLocation: { uri: isUrl(f.path) ? f.path : f.path.replace(/\\/g, "/") },
+          ...f.line > 0 ? { region: { startLine: f.line, snippet: { text: f.excerpt } } } : {}
+        }
+      }
+    ],
+    partialFingerprints: { "craftFinding/v1": fnv1a(findingKey(f)) }
+  }));
+  return {
+    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "craft",
+            version: report.catalogueVersion,
+            informationUri: options.informationUri ?? "https://www.npmjs.com/package/@domandigital/craft",
+            rules
+          }
+        },
+        results
+      }
+    ]
+  };
+}
+
+// src/character/facts.ts
+var MONTH = "(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)";
+var PATTERNS = [
+  ["url", /\bhttps?:\/\/[^\s<>"'`)\]]+|\bwww\.[^\s<>"'`)\]]+/gi],
+  ["email", /\b[\w.+-]+@[\w-]+(?:\.[\w-]+)+\b/g],
+  ["phone", /(?:\+44\s?\(?0?\)?\s?|\b0)\d(?:[\s-]?\d){8,9}\b/g],
+  ["postcode", /\b[A-Z]{1,2}\d[A-Z\d]?\s?\d[A-Z]{2}\b/g],
+  ["money", /[£$€]\s?\d[\d,]*(?:\.\d{1,2})?(?:\s?(?:k|m|bn)\b)?|\b\d[\d,]*(?:\.\d{1,2})?\s?(?:pounds|GBP)\b/gi],
+  ["date", new RegExp(`\\b\\d{1,2}(?:st|nd|rd|th)?\\s+${MONTH}\\b(?:\\s+\\d{4})?|\\b${MONTH}\\s+\\d{1,2}(?:st|nd|rd|th)?\\b(?:,?\\s+\\d{4})?|\\b${MONTH}\\s+\\d{4}\\b|\\b\\d{1,2}\\/\\d{1,2}\\/\\d{2,4}\\b|\\b(?:19|20)\\d{2}\\b`, "g")],
+  ["time", /\b\d{1,2}(?:[:.]\d{2})?\s?(?:am|pm)\b|\b\d{1,2}:\d{2}\b/gi],
+  ["number", /\b\d[\d,]*(?:\.\d+)?%?|\b\d+(?:\.\d+)?\s?(?:per ?cent)\b/gi]
+];
+var NAME = /[A-Z][a-zA-Z’'&-]*[a-zA-Z](?:\s+(?:of|and|&|the)?\s*[A-Z][a-zA-Z’'&-]*[a-zA-Z])*/g;
+var normalise = (kind, value) => {
+  const v = value.trim();
+  if (kind === "phone") return v.replace(/[^\d+]/g, "").replace(/^\+44\(?0?\)?/, "0").replace(/^\+44/, "0");
+  if (kind === "money" || kind === "number") return v.replace(/[\s,]/g, "").toLowerCase();
+  if (kind === "postcode") return v.replace(/\s/g, "").toUpperCase();
+  if (kind === "url") return v.replace(/[.,;:]+$/, "").toLowerCase();
+  return v.replace(/\s+/g, " ").toLowerCase();
+};
+function visibleText(file) {
+  const prose = /\.(md|markdown|mdx|txt)$/i.test(file.path);
+  return (prose ? extractCopy(file) : extractStrings(file)).map((b) => b.text).join("\n");
+}
+function protectedFacts(text) {
+  const facts = [];
+  let rest = text;
+  const mask = (start, length) => {
+    rest = rest.slice(0, start) + " ".repeat(length) + rest.slice(start + length);
+  };
+  for (const [kind, pattern] of PATTERNS) {
+    for (const m of [...rest.matchAll(pattern)]) {
+      const value = m[0].replace(/[.,;:]+$/, "");
+      facts.push({ kind, value, key: `${kind}:${normalise(kind, value)}` });
+      mask(m.index ?? 0, m[0].length);
+    }
+  }
+  const lines = rest.split("\n");
+  for (const line of lines) {
+    if (/^\s{0,3}#{1,6}\s/.test(line)) continue;
+    for (const m of line.matchAll(NAME)) {
+      const at = m.index ?? 0;
+      const before = line.slice(0, at).trimEnd();
+      const opensSentence = before === "" || /[.!?:"“(>*-]$/.test(before) || /^\s*(?:[-*+]|\d+\.)$/.test(before);
+      const word = m[0];
+      const acronym = /^[A-Z]{2,}$/.test(word);
+      if (opensSentence && !acronym && !/\s/.test(word)) continue;
+      if (word === "I") continue;
+      facts.push({ kind: "name", value: word, key: `name:${normalise("name", word)}` });
+    }
+  }
+  return facts;
+}
+var unique = (facts) => [...new Map(facts.map((f) => [f.key, f])).values()];
+function compareFacts(before, after) {
+  const a = unique(protectedFacts(before));
+  const b = unique(protectedFacts(after));
+  const inA = new Set(a.map((f) => f.key));
+  const inB = new Set(b.map((f) => f.key));
+  return {
+    before: a.length,
+    after: b.length,
+    lost: a.filter((f) => !inB.has(f.key)),
+    added: b.filter((f) => !inA.has(f.key))
+  };
+}
+function formatComparison(result, beforePath, afterPath) {
+  const lines = [`craft copy compare: ${beforePath} -> ${afterPath}`, `  ${result.before} protected facts before, ${result.after} after`];
+  if (result.lost.length) {
+    lines.push("", `  Lost (${result.lost.length}): restore each, or say why it went`);
+    for (const f of result.lost) lines.push(`    ${f.kind.padEnd(9)} ${f.value}`);
+  }
+  if (result.added.length) {
+    lines.push("", `  Added (${result.added.length}): each needs a source, or it is invented`);
+    for (const f of result.added) lines.push(`    ${f.kind.padEnd(9)} ${f.value}`);
+  }
+  if (!result.lost.length && !result.added.length) lines.push("", "  Every fact kept, nothing added.");
+  return lines.join("\n");
+}
+
+// src/character/claims.ts
+var CLAIM_KINDS = /* @__PURE__ */ new Set(["money", "number", "date"]);
+var PROPER = "[A-Z][\\w&.\u2019'-]*(?:\\s+(?:of|and|&|the|for)?\\s*[A-Z][\\w&.\u2019'-]*)*";
+var NOT_A_SOURCE = /^(?:We|I|It|This|That|These|Those|They|He|She|You|Our|Your|The|A|An|Each|Every|Most|Many|Some|One|Research|Studies|Experts|Data|Analysis|If|When|So|But|And|Or|In|On|At|From|For|By|As|Since|After|Before|Across|Over|Under|Its|Their|External|Source|UK|US|EU|Sometimes|Public|Recent|Industry|Independent|What|How|Why|Who|Where|Businesses|Customers|Clients|Patients|Consumers|People|Users|Online)$/;
+var NOUN = "study|survey|report|research|analysis|benchmark|benchmarks|guidelines|docs|documentation|help centre|help center|pricing page|figures|statistics|case study";
+var OWNED_NOUN = "guide|audit|support|pricing|data|site|website|blog";
+var VERB = "found|finds|reports?|reported|says|said|states?|stated|estimates?|estimated|recommends?|publishes|published|advertises|advertised|shows|showed|claims";
+var ATTRIBUTION = [
+  new RegExp(`\\b[Aa]ccording to\\s+(?:the\\s+)?(${PROPER})`, "g"),
+  new RegExp(`\\b(?:${NOUN})\\s+(?:by|from|commissioned by)\\s+(?:the\\s+)?(${PROPER})`, "g"),
+  // "Akamai’s 2017 retail study", "the 2020 Deloitte study", "Bark’s UK guide", "Wix’s own developer guidelines".
+  new RegExp(`\\b(${PROPER})(?:(?:\u2019s|'s)\\s+(?:own\\s+)?(?:\\d{4}\\s+)?(?:[A-Za-z]+\\s+)?(?:${NOUN}|${OWNED_NOUN})|\\s+(?:\\d{4}\\s+)?(?:[a-z]+\\s+)?(?:${NOUN}))\\b`, "g"),
+  // "Google also reported", "Shopify UK currently advertises".
+  new RegExp(`\\b(${PROPER})\\s+(?:also\\s+|now\\s+|currently\\s+|still\\s+)?(?:${VERB})\\b`, "g"),
+  /\((?:[Ss]ources?:\s*|via\s+(?=[A-Z]))([^)]+)\)/g,
+  /^\s*(?:source|sources)\s*:\s*(.+)$/gim
+];
+var LINK = /\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)|\bhttps?:\/\/[^\s<>"')\]]+/g;
+function cleanName(raw) {
+  const words = raw.trim().replace(/[.,;:]+$/, "").split(/\s+/);
+  while (words.length && NOT_A_SOURCE.test(words[0])) words.shift();
+  return words.join(" ").replace(/(?:’s|'s)(?=\s|$).*$/, "").trim();
+}
+var IMPERATIVE = /^(?:Add|Use|Check|Make|Get|Set|Include|Create|Update|List|Keep|Ask|Write|Track|Test|Claim|Build|Link|Submit|Verify|Review|Fix|Remove|Upload|Respond|Reply|Choose|Pick|Start|Run|Open|Install|Connect|Enable|Turn|Put|Give|Send|Book|Call|Read|See|Try|Compare|Aim|Target|Avoid|Post|Share|Mark|Tag)$/;
+var atStart = (sentence, index) => /^[\s*_"“”’(>#|-]*(?:\d{1,3}[.)]\s*)?[\s*_]*(?:[\w ]+:\**\s*)?$/.test(sentence.slice(0, index)) || /\|\s*\**$/.test(sentence.slice(0, index));
+function namedSources(sentence) {
+  const found = /* @__PURE__ */ new Set();
+  ATTRIBUTION.forEach((pattern, i) => {
+    for (const m of sentence.matchAll(pattern)) {
+      const raw = m[1].trim();
+      const word = !/\s/.test(raw) && !/[’']s$/.test(m[0].split(/\s+/)[0]);
+      if (i === 2 && word && atStart(sentence, m.index ?? 0)) continue;
+      if (IMPERATIVE.test(raw.split(/\s+/)[0]) && atStart(sentence, m.index ?? 0)) continue;
+      const name = cleanName(raw);
+      if (!name || name.length < 2 || !/\s/.test(name) && /[a-z]ing$/.test(name)) continue;
+      found.add(name);
+    }
+  });
+  for (const m of sentence.matchAll(LINK)) found.add(m[2] ?? m[0]);
+  return [...found];
+}
+var FOOTNOTE_REF = /\[\^([\w-]+)\](?!:)/g;
+var FOOTNOTE_DEF = /^[ \t]*\[\^([\w-]+)\]:[ \t]*(.+)$/gm;
+var ASSUMPTION = /^(?:\*\*)?(?:assume|suppose|imagine|say|let's say|for example, say|picture)\b/i;
+var LEAD = /^\s*(?:#{1,6}\s+|>\s*|[-*+]\s+|\d+[.)]\s+)*/;
+function sentences(text) {
+  const out = [];
+  let start = 0;
+  let paragraph = 0;
+  const push = (end) => {
+    const raw = text.slice(start, end);
+    const lead = raw.length - raw.trimStart().length;
+    if (raw.trim()) out.push({ text: raw.trim(), offset: start + lead, paragraph });
+  };
+  for (const m of text.matchAll(/(?<!(?:^|\n)[ \t]*\d{1,3})[.!?](?:\[\^[\w-]+\])*(?=["”’)]?[ \t]+["“(*]*[A-Z0-9£$€])|\n+/g)) {
+    const end = (m.index ?? 0) + m[0].length;
+    push(end);
+    start = end;
+    if (/\n\s*\n/.test(m[0]) || /^\s*(?:#|\|)/.test(text.slice(end))) paragraph += 1;
+  }
+  push(text.length);
+  return out;
+}
+var MAX = 180;
+var trim = (s) => s.length > MAX ? `${s.slice(0, MAX - 1).trimEnd()}\u2026` : s;
+function findClaims(files) {
+  const claims = [];
+  for (const file of files) {
+    for (const block of extractCopy(file)) {
+      const notes = new Map([...block.text.matchAll(FOOTNOTE_DEF)].map((m) => [m[1], m[2].trim()]));
+      let carried;
+      for (const s of sentences(block.text)) {
+        if (/^\s*#{1,6}\s/.test(s.text) || /^\s*\[\^[\w-]+\]:/.test(s.text)) continue;
+        const refs = [...s.text.matchAll(FOOTNOTE_REF)].map((m) => notes.get(m[1]) ?? `footnote ${m[1]}`);
+        const text = s.text.replace(FOOTNOTE_REF, "");
+        const body = text.replace(LEAD, "");
+        const own = [...namedSources(text), ...refs];
+        if (own.length) carried = { paragraph: s.paragraph, sources: own };
+        if (ASSUMPTION.test(body)) continue;
+        const facts = protectedFacts(body).filter((f) => CLAIM_KINDS.has(f.kind));
+        if (facts.length === 0 && own.length === 0) continue;
+        const nearby = own.length === 0 && carried?.paragraph === s.paragraph ? carried.sources : void 0;
+        const at = block.offset + s.offset;
+        claims.push({
+          path: file.path,
+          line: file.text.slice(0, at).split("\n").length,
+          sentence: trim(text.replace(/\s+/g, " ")),
+          facts,
+          sources: own,
+          ...nearby ? { nearby } : {}
+        });
+      }
+    }
+  }
+  return { files: files.length, claims, unsourced: claims.filter((c) => c.sources.length === 0).length };
+}
+function formatClaims(report, label = "craft copy claims") {
+  const { claims, unsourced } = report;
+  if (claims.length === 0) return `${label}: no prices, figures, dates or named sources in ${report.files} file${report.files === 1 ? "" : "s"}.`;
+  const lines = [
+    `${label}: ${claims.length} claim${claims.length === 1 ? "" : "s"} to check, ${unsourced} with no source named.`,
+    "  Check each against its primary source before it ships. Sourced means a source is named, not that it agrees."
+  ];
+  for (const c of claims) {
+    const what = [
+      ...c.facts.map((f) => f.value),
+      ...c.sources.map((s) => `source: ${s}`),
+      ...c.nearby ? [`${c.nearby.join(", ")} named earlier in the paragraph: does it cover this?`] : []
+    ].join(" \xB7 ");
+    lines.push("", `  ${c.path}:${c.line}  ${c.sources.length ? "sourced  " : "UNSOURCED"}  ${what}`, `    ${c.sentence}`);
+  }
+  return lines.join("\n");
+}
+
+// src/character/format.ts
+function formatReport(report, title) {
+  const lines = [];
+  let current = "";
+  for (const f of report.findings) {
+    if (f.path !== current) {
+      current = f.path;
+      lines.push("", f.path);
+    }
+    lines.push(`  ${String(f.line).padStart(4)}  ${f.tell} (gen ${f.generation}, ${f.severity})  ${f.message}`);
+    lines.push(`        ${f.excerpt}`);
+  }
+  const fixes = new Map(report.findings.map((f) => [f.tell, f.fix]));
+  if (fixes.size > 0) {
+    lines.push("", "What to do instead:");
+    for (const [tell, fix] of fixes) lines.push(`  ${tell}: ${fix}`);
+  }
+  for (const r of report.rejectedExceptions) {
+    lines.push("", `Exception not applied (${r.exception.tell}): ${r.reason}`);
+  }
+  for (const e of report.excepted) {
+    lines.push("", `Excepted: ${e.count} \xD7 ${e.tell}, because ${e.because}`);
+  }
+  if (report.suppressed.length > 0) {
+    lines.push("", `Suppressed: ${report.suppressed.length} marked copy-ok or craft-ok (${report.suppressed.map((s) => `${s.path}:${s.line}`).join(", ")})`);
+  }
+  const { summary } = report;
+  const gens = `gen 1: ${summary.byGeneration[1]}, gen 2: ${summary.byGeneration[2]}, gen 3: ${summary.byGeneration[3]}`;
+  lines.push(
+    "",
+    `${title}: ${summary.findings} finding${summary.findings === 1 ? "" : "s"} in ${summary.files} file${summary.files === 1 ? "" : "s"} (${gens}). Catalogue ${report.catalogueVersion}.`
+  );
+  return lines.join("\n").replace(/^\n/, "");
+}
+
+// src/character/cli.ts
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "out", ".next", ".turbo", ".vercel", "coverage", "vendor", ".cache"]);
+var MAX_BYTES = 1e6;
+var NOT_SITE_COPY = /^(?:README|CHANGELOG|CLAUDE|AGENTS|CONTRIBUTING|LICENSE|CODE_OF_CONDUCT|SECURITY)(?:\.[a-z]+)?$/i;
+var HELP = `craft: find the AI look and say what to do instead.
+
+Usage
+  craft scan [paths...] [--staged] [--json] [--strict] [--direction <file>] [ci options]
+  craft copy [paths...] [--gate] [--json] [--strict] [--direction <file>] [ci options]
+  craft copy compare <before> <after> [--json]
+  craft copy claims <paths...> [--json]
+  craft tells list [--json]
+  craft tells harvest <null.json | dir>... [--share 0.25] [--json]
+  craft snapshot <url> [--out <file>] [--width <px>] [--height <px>]
+  craft audit <url | snapshot.json> [--repo <dir>] [--null <null.json>] [--out <file>] [--json] [--strict] [ci options]
+  craft audit --pages <sitemap.xml | urls.txt> [--viewport 390,768,1440] [the same]
+  craft direction init [--snapshot <file>] [--client <name>] [--out <file>]
+  craft direction validate [--snapshot <file>] [--direction <file>] [--json]
+  craft direction propose [--snapshot <file>] [--estate <estate.json | dir>] [--out <file>]
+  craft null build --brief "<text>" --out <dir> [--runs 20] [--parallel 4] [--model <name>]
+  craft estate add <url | snapshot.json> --id <id> [--client <name>] [--estate <file>]
+  craft estate compare [<url | snapshot.json | id>] [--null <dir>] [--json] [--strict]
+  craft report <url | snapshot.json> [--repo <dir>] [--null <dir>] [--estate <file>] [--direction <file>] [--json] [--strict]
+  craft retrofit <url | snapshot.json> [the same] [--out RETROFIT.md]
+
+scan      Markup, component code and stylesheets (source and compiled CSS).
+          --staged reads the git index, for a pre-commit hook.
+copy      The prose in Markdown, markup and content files.
+          --gate applies the house copy policy: the blocking tier of COPY.md
+          fails the run. What copy-check and the pre-commit hook run.
+          compare lists the protected facts (prices, numbers, dates, times,
+          phones, emails, links, postcodes, names) a rewrite lost or added.
+          Exit 1 if any: restore it, source it, or say why.
+          claims lists every sentence holding a price, figure, date or named
+          source, marked sourced or UNSOURCED, for a person to check against
+          the primary source. It cannot tell true from false. Always exit 0.
+tells     The catalogue this build judges against. harvest reads null models
+          for choices the model keeps making that the catalogue does not know.
+snapshot  Render a page in a browser and save what it looks like, as JSON.
+audit     Judge a rendered page (live, or a saved snapshot) and fingerprint it.
+          --repo also scans that site's source, so one report covers both.
+          --null scores how typical it is against a null model (comma-separate
+          several to pool them).
+          --pages audits every URL in a sitemap (a URL or a file) or a file of
+          URLs, one per line. --viewport audits each page at these widths.
+          snapshot and audit need Playwright: npm i -D playwright.
+direction The site's art-direction.json: every choice with a reason from the
+          client's world. init writes today's choices with empty reasons;
+          validate applies the reason rule; propose reads colours off the
+          sources' PNG photos and drafts choices for a person to confirm.
+null      The counterfactual: about 20 pages \`claude -p\` builds from the brief
+          alone, snapshotted and fingerprinted into null.json. Resumable.
+estate    The register of shipped sites (estate.json). add fingerprints a site;
+          compare lists the nearest, and marks siblings: two sites closer than
+          two pages Claude builds for one brief. --strict exits 1 on a sibling.
+report    Every signal for one site: tells, typicality, the estate, the reasons.
+          A verdict (default, mixed, decided, unproven) and what to do, in order.
+          Anything not given is "not measured", and never counts as a pass.
+retrofit  The report as a checklist: decide, then change type, colour, shape,
+          effects, motion and copy. Never the page grammar.
+
+ci options (scan, copy, audit)
+  --baseline <file>     Report only findings the baseline does not already
+                        hold. Keyed on tell, path and excerpt, not line.
+  --update-baseline     Write every current finding to --baseline, exit 0.
+  --sarif <file>        Also write SARIF 2.1.0, for GitHub code scanning.
+  --config <file>       craft.config.json, default: the working directory.
+
+Exceptions come from art-direction.json in the working directory, or --direction.
+craft.config.json holds ignore globs, copyPaths, and severity changes, each
+with a because. .claude, .agents and .cursor are never walked.
+Every tell ships as warn: exit 1 only on a block, or on any finding with --strict.
+--json output always carries schemaVersion.`;
+var VALUE_FLAGS = {
+  "--direction": "direction",
+  "--out": "out",
+  "--repo": "repo",
+  "--width": "width",
+  "--height": "height",
+  "--snapshot": "snapshot",
+  "--estate": "estate",
+  "--client": "client",
+  "--brief": "brief",
+  "--runs": "runs",
+  "--parallel": "parallel",
+  "--model": "model",
+  "--share": "share",
+  "--null": "null",
+  "--id": "id",
+  "--config": "config",
+  "--baseline": "baseline",
+  "--sarif": "sarif",
+  "--pages": "pages",
+  "--viewport": "viewport"
+};
+function parseFlags(args) {
+  const flags = { positional: [], json: false, strict: false, staged: false, gate: false, updateBaseline: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === "--json") flags.json = true;
+    else if (a === "--strict") flags.strict = true;
+    else if (a === "--staged") flags.staged = true;
+    else if (a === "--gate") flags.gate = true;
+    else if (a === "--update-baseline") flags.updateBaseline = true;
+    else if (a in VALUE_FLAGS) {
+      const value = args[i + 1];
+      i += 1;
+      if (!value || value.startsWith("--")) return `${a} needs a value`;
+      flags[VALUE_FLAGS[a]] = value;
+    } else if (a.startsWith("--")) return `unknown option ${a}`;
+    else flags.positional.push(a);
+  }
+  return flags;
+}
+function walk(root, cwd, into, wanted, skipDir = (_) => false, ignored = (_) => false) {
+  const stat = statSync(root);
+  if (stat.isFile()) {
+    if (stat.size <= MAX_BYTES) into.push({ path: relative(cwd, root) || root, text: readFileSync(root, "utf8") });
+    return;
+  }
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const path = join(root, entry.name);
+    if (ignored(relative(cwd, path))) continue;
+    if (entry.isDirectory()) {
+      if (!SKIP_DIRS.has(entry.name) && !skipDir(entry.name)) walk(path, cwd, into, wanted, skipDir, ignored);
+    } else if (entry.isFile() && wanted(entry.name)) {
+      walk(path, cwd, into, wanted, skipDir, ignored);
+    }
+  }
+}
+function readPaths(paths, cwd, wanted, skipDir, ignore = []) {
+  const files = [];
+  const ignored = ignoreMatcher([...DEFAULT_IGNORE, ...ignore]);
+  for (const p of paths) {
+    const abs = resolve(cwd, p);
+    if (!existsSync(abs)) throw new Error(`no such path: ${p}`);
+    walk(abs, cwd, files, wanted, skipDir, ignored);
+  }
+  return files;
+}
+function readStaged(cwd, wanted, ignore) {
+  const ignored = ignoreMatcher([...DEFAULT_IGNORE, ...ignore]);
+  const names = execFileSync("git", ["diff", "--cached", "--name-only", "--diff-filter=ACMR", "-z"], { cwd, encoding: "utf8" }).split("\0").filter((p) => p && wanted(p) && !ignored(p));
+  return names.map((path) => ({
+    path,
+    // The index, not the working tree: the commit is what gets checked.
+    text: execFileSync("git", ["show", `:${path}`], { cwd, encoding: "utf8", maxBuffer: MAX_BYTES * 4 })
+  }));
+}
+var NO_CONFIG = { ignore: [], severity: {} };
+function loadConfig(flags, root) {
+  const path = resolve(root, flags.config ?? "craft.config.json");
+  if (!existsSync(path)) {
+    if (flags.config) throw new Error(`no such file: ${flags.config}`);
+    return NO_CONFIG;
+  }
+  return parseCraftConfig(JSON.parse(readFileSync(path, "utf8")), new Set(CATALOGUE.map((t) => t.id)), flags.config ?? "craft.config.json");
+}
+function loadExceptions(flags, cwd) {
+  const fromConfig = severityExceptions(loadConfig(flags, cwd));
+  const path = resolve(cwd, flags.direction ?? "art-direction.json");
+  if (!existsSync(path)) {
+    if (flags.direction) throw new Error(`no such file: ${flags.direction}`);
+    return fromConfig;
+  }
+  const data = JSON.parse(readFileSync(path, "utf8"));
+  return [...Array.isArray(data.exceptions) ? data.exceptions : [], ...fromConfig];
+}
+function prepareReport(report, flags, io, config) {
+  let result = applySeverity(report, config);
+  if (flags.updateBaseline) {
+    if (!flags.baseline) throw new Error("--update-baseline needs --baseline <file>");
+    const baseline = createBaseline(result);
+    writeFileSync(resolve(io.cwd, flags.baseline), `${JSON.stringify(baseline, null, 2)}
+`);
+    io.out(`craft: baseline of ${result.findings.length} finding${result.findings.length === 1 ? "" : "s"} written to ${flags.baseline}`);
+    return null;
+  }
+  if (flags.baseline) {
+    const path = resolve(io.cwd, flags.baseline);
+    if (!existsSync(path)) throw new Error(`no such file: ${flags.baseline} (create it with --update-baseline)`);
+    result = applyBaseline(result, parseBaseline(JSON.parse(readFileSync(path, "utf8")), flags.baseline));
+  }
+  if (flags.sarif) {
+    writeFileSync(resolve(io.cwd, flags.sarif), `${JSON.stringify(toSarif(result, { tells: CATALOGUE }), null, 2)}
+`);
+  }
+  return result;
+}
+function finish(report, flags, title, io) {
+  io.out(flags.json ? toJson(report) : formatReport(report, title));
+  if (!flags.json && report.baselined) {
+    io.out(`${report.baselined} known finding${report.baselined === 1 ? "" : "s"} not shown: already in ${flags.baseline}.`);
+  }
+  if (report.summary.blocking > 0) return 1;
+  if (flags.strict && report.summary.findings > 0) return 1;
+  return 0;
+}
+var SOURCE_FILE = (p) => ["markup", "script", "css"].includes(fileKind(p)) && !/\.d\.ts$|\.min\.js$/.test(p);
+var COPY_FILE = (p) => (["markup", "prose", "script"].includes(fileKind(p)) || /\.jsonl?$/i.test(p)) && !NOT_SITE_COPY.test(p.split("/").pop() ?? p) && !/(?:^|\/)(?:package(?:-lock)?|tsconfig[\w.-]*|art-direction)\.json$/.test(p);
+var NOT_COPY_DIR = (name) => name.startsWith("_");
+function run(argv, io) {
+  const [command, ...rest] = argv;
+  if (command === "direction") {
+    return import("./cli-U3SZVHSK.js").then((m) => m.runDirection(rest, io));
+  }
+  if (command === "report" || command === "retrofit") {
+    return import("./cli-DBZMVYYV.js").then((m) => m.runReport(command, rest, io));
+  }
+  if (command === "estate") {
+    return import("./cli-VREYWCT4.js").then((m) => m.runEstate(rest, io));
+  }
+  if (command === "null") {
+    return import("./cli-4ESXOLKV.js").then((m) => m.runNull(rest, io));
+  }
+  if (command === "tells" && rest[0] === "harvest") {
+    return import("./cli-4ESXOLKV.js").then((m) => m.runHarvest(rest, io)).catch((error) => {
+      io.err(`craft: ${error.message}`);
+      return 2;
+    });
+  }
+  if (command === "snapshot" || command === "audit") {
+    return import("./cli-T5RD2BTK.js").then((m) => m.runAudit(command, rest, io));
+  }
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    io.out(HELP);
+    return command ? 0 : 2;
+  }
+  try {
+    if (command === "tells") {
+      const flags = parseFlags(rest);
+      if (typeof flags === "string") throw new Error(flags);
+      if (flags.positional[0] !== "list") throw new Error("usage: craft tells list [--json] | craft tells harvest <null.json>...");
+      if (flags.json) {
+        const data = CATALOGUE.map(({ id, name, generation, surface, severity, why, fix }) => ({
+          id,
+          name,
+          generation,
+          surface,
+          severity,
+          why,
+          fix,
+          ...surface === "copy" ? { house: houseRule(id, name).tier, houseLabel: houseRule(id, name).label } : {}
+        }));
+        io.out(toJson({ version: CATALOGUE_VERSION, tells: data }));
+      } else {
+        io.out(`Catalogue ${CATALOGUE_VERSION}`);
+        for (const t of CATALOGUE) io.out(`  ${t.id.padEnd(24)} gen ${t.generation}  ${t.surface.padEnd(6)}  ${t.name}`);
+      }
+      return 0;
+    }
+    if (command === "copy" && rest[0] === "compare") {
+      const flags = parseFlags(rest.slice(1));
+      if (typeof flags === "string") throw new Error(flags);
+      if (flags.positional.length !== 2) throw new Error("usage: craft copy compare <before> <after> [--json]");
+      const [before, after] = flags.positional.map((p) => {
+        const abs = resolve(io.cwd, p);
+        if (!existsSync(abs)) throw new Error(`no such path: ${p}`);
+        return visibleText({ path: p, text: readFileSync(abs, "utf8") });
+      });
+      const result = compareFacts(before, after);
+      io.out(flags.json ? toJson(result) : formatComparison(result, flags.positional[0], flags.positional[1]));
+      return result.lost.length || result.added.length ? 1 : 0;
+    }
+    if (command === "copy" && rest[0] === "claims") {
+      const flags = parseFlags(rest.slice(1));
+      if (typeof flags === "string") throw new Error(flags);
+      if (flags.positional.length === 0) throw new Error("usage: craft copy claims <paths...> [--json]");
+      const report = findClaims(readPaths(flags.positional, io.cwd, COPY_FILE, NOT_COPY_DIR));
+      io.out(flags.json ? toJson(report) : formatClaims(report));
+      return 0;
+    }
+    if (command === "scan" || command === "copy") {
+      const flags = parseFlags(rest);
+      if (typeof flags === "string") throw new Error(flags);
+      const wanted = command === "scan" ? SOURCE_FILE : COPY_FILE;
+      const config = loadConfig(flags, io.cwd);
+      const paths = flags.positional.length > 0 ? flags.positional : command === "copy" ? config.copyPaths ?? [] : ["."];
+      if (command === "copy" && paths.length === 0 && !flags.staged) throw new Error("usage: craft copy <paths...> (or copyPaths in craft.config.json)");
+      const files = flags.staged ? readStaged(io.cwd, wanted, config.ignore) : readPaths(paths, io.cwd, wanted, command === "copy" ? NOT_COPY_DIR : void 0, config.ignore);
+      const exceptions = loadExceptions(flags, io.cwd);
+      let report = command === "scan" ? scanSource(files, { exceptions }) : checkCopy(files, { exceptions });
+      if (command === "copy" && flags.gate) report = applyHouseGate(report);
+      const prepared = prepareReport(report, flags, io, config);
+      if (!prepared) return 0;
+      return finish(prepared, flags, command === "scan" ? "craft scan" : "craft copy", io);
+    }
+    throw new Error(`unknown command "${command}". Run craft --help.`);
+  } catch (error) {
+    io.err(`craft: ${error.message}`);
+    return 2;
+  }
+}
+
+export {
+  applySeverity,
+  toJson,
+  parseFlags,
+  readPaths,
+  loadConfig,
+  loadExceptions,
+  prepareReport,
+  finish,
+  SOURCE_FILE,
+  COPY_FILE,
+  NOT_COPY_DIR,
+  run
+};