@domandigital/craft 0.11.0 → 0.13.0

package/dist/{chunk-2AJB27BJ.js → chunk-3VTPI7BU.js}

@@ -1,14 +1,16 @@
 import {
   CATALOGUE,
   CATALOGUE_VERSION,
+  HOUSE_LOCKED,
   applyHouseGate,
   checkCopy,
   extractCopy,
   extractStrings,
   fileKind,
+  holdHouseBlocks,
   houseRule,
   scanSource
-} from "./chunk-3NGWXZZE.js";
+} from "./chunk-GMVXADJ6.js";
 
 // src/character/config.ts
 var DEFAULT_IGNORE = [".claude", ".agents", ".cursor"];
@@ -526,7 +528,8 @@ var VALUE_FLAGS = {
   "--baseline": "baseline",
   "--sarif": "sarif",
   "--pages": "pages",
-  "--viewport": "viewport"
+  "--viewport": "viewport",
+  "--component": "component"
 };
 function parseFlags(args) {
   const flags = { positional: [], json: false, strict: false, staged: false, gate: false, updateBaseline: false };
@@ -637,25 +640,25 @@ 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));
+    return import("./cli-DRKAMFAH.js").then((m) => m.runDirection(rest, io));
   }
   if (command === "report" || command === "retrofit") {
-    return import("./cli-DBZMVYYV.js").then((m) => m.runReport(command, rest, io));
+    return import("./cli-J5ECRCD4.js").then((m) => m.runReport(command, rest, io));
   }
   if (command === "estate") {
-    return import("./cli-VREYWCT4.js").then((m) => m.runEstate(rest, io));
+    return import("./cli-BKJMLD3H.js").then((m) => m.runEstate(rest, io));
   }
   if (command === "null") {
-    return import("./cli-4ESXOLKV.js").then((m) => m.runNull(rest, io));
+    return import("./cli-ILH7OO5G.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) => {
+    return import("./cli-ILH7OO5G.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));
+    return import("./cli-N2IDXH7W.js").then((m) => m.runAudit(command, rest, io));
   }
   if (!command || command === "help" || command === "--help" || command === "-h") {
     io.out(HELP);
@@ -713,10 +716,22 @@ function run(argv, io) {
       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 exceptions = loadExceptions(flags, io.cwd);
+      let effective = config;
+      let refused = [];
+      if (command === "copy" && flags.gate) {
+        const held = holdHouseBlocks(exceptions, config.severity);
+        exceptions = held.exceptions;
+        effective = { ...config, severity: held.severity };
+        const warned = held.refusedSeverity.filter((tell) => config.severity[tell].level === "warn").map((tell) => ({ tell, because: `craft.config.json: ${config.severity[tell].because}` }));
+        refused = [...held.refused, ...warned];
+      }
       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 (command === "copy" && flags.gate) {
+        report = applyHouseGate(report);
+        report = { ...report, rejectedExceptions: [...report.rejectedExceptions, ...refused.map((exception) => ({ exception, reason: HOUSE_LOCKED }))] };
+      }
+      const prepared = prepareReport(report, flags, io, effective);
       if (!prepared) return 0;
       return finish(prepared, flags, command === "scan" ? "craft scan" : "craft copy", io);
     }

package/dist/chunk-CZDOMIVS.js

@@ -0,0 +1,19 @@
+import {
+  SNAPSHOT_VERSION
+} from "./chunk-GMVXADJ6.js";
+
+// src/snapshot/migrate.ts
+var READABLE_SNAPSHOT_VERSIONS = [1, 2];
+function readSnapshot(data, source = "snapshot") {
+  const v = data?.version;
+  if (typeof data !== "object" || data === null || !READABLE_SNAPSHOT_VERSIONS.includes(v)) {
+    throw new Error(`${source} is not a snapshot this craft reads (version ${String(v)}; reads ${READABLE_SNAPSHOT_VERSIONS.join(" and ")})`);
+  }
+  const snap = data;
+  if (snap.version === 1) return { ...snap, version: SNAPSHOT_VERSION, migratedFrom: 1 };
+  return snap;
+}
+
+export {
+  readSnapshot
+};

package/dist/chunk-ESCVTKPN.js

@@ -0,0 +1,217 @@
+import {
+  readSnapshot
+} from "./chunk-CZDOMIVS.js";
+import {
+  parseFlags,
+  toJson
+} from "./chunk-3VTPI7BU.js";
+import {
+  CATALOGUE_VERSION,
+  NULL_VERSION,
+  auditSnapshot,
+  checkCopy,
+  extractHtml,
+  extractStrings,
+  fingerprint,
+  harvest,
+  hueSwatch,
+  nullPrompt,
+  scanSource
+} from "./chunk-GMVXADJ6.js";
+
+// src/null/cli.ts
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join, relative, resolve } from "path";
+import { pathToFileURL } from "url";
+var readJson = (path) => JSON.parse(readFileSync(path, "utf8"));
+var pad = (n) => String(n).padStart(2, "0");
+function generate(prompt, model) {
+  const bin = process.env.CRAFT_CLAUDE ?? "claude";
+  const args = ["-p", "--tools", "", "--no-session-persistence", "--disable-slash-commands", "--setting-sources", "", "--strict-mcp-config", ...model ? ["--model", model] : [], prompt];
+  const cwd = mkdtempSync(join(tmpdir(), "craft-null-"));
+  return new Promise((done, fail) => {
+    const child = spawn(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (d) => out += d.toString());
+    child.stderr.on("data", (d) => err += d.toString());
+    child.on("error", (e) => fail(new Error(`${bin}: ${e.message}. Install Claude Code, or set CRAFT_CLAUDE.`)));
+    child.on("close", (code) => {
+      rmSync(cwd, { recursive: true, force: true });
+      if (code === 0) done(out);
+      else fail(new Error(`${bin} exited ${code}: ${(err || out).trim().slice(0, 200)}`));
+    });
+  });
+}
+async function pool(items, size, work) {
+  const queue = [...items];
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(size, queue.length)) }, async () => {
+    for (let item = queue.shift(); item !== void 0; item = queue.shift()) await work(item);
+  }));
+}
+function nullPath(target, cwd) {
+  const abs = resolve(cwd, target);
+  return existsSync(abs) && statSync(abs).isDirectory() ? join(abs, "null.json") : abs;
+}
+function loadNull(target, cwd) {
+  const path = nullPath(target, cwd);
+  if (!existsSync(path)) throw new Error(`no null model at ${target}. Build one with craft null build.`);
+  const model = readJson(path);
+  if (model.version !== NULL_VERSION) throw new Error(`${target} is null model version ${String(model.version)}; this craft reads ${NULL_VERSION}`);
+  return model;
+}
+function measureRun(id, html, snapshot) {
+  const file = { path: `${id}.html`, text: html };
+  const tells = new Set([...auditSnapshot(snapshot).findings, ...scanSource([file]).findings].map((f) => f.tell));
+  const copy = [...new Set(extractStrings(file).filter((b) => !b.literal).map((b) => b.text.replace(/\s+/g, " ").trim()).filter(Boolean))];
+  return { id, fingerprint: fingerprint(snapshot), tells: [...tells].sort(), copy };
+}
+async function build(flags, io) {
+  const brief = flags.brief ?? (flags.direction ? readJson(resolve(io.cwd, flags.direction)).brief : void 0);
+  if (!brief || brief.trim().split(/\s+/).length < 5) throw new Error('usage: craft null build --brief "<who, where, what they do>" --out <dir> [--runs 20] [--parallel 4]');
+  if (!flags.out) throw new Error("--out <dir> is where the pages and null.json go");
+  const runs = Number(flags.runs ?? 20);
+  const parallel = Number(flags.parallel ?? 4);
+  if (!Number.isInteger(runs) || runs < 5) throw new Error("--runs needs a whole number, 5 or more");
+  const dir = resolve(io.cwd, flags.out);
+  const pages = join(dir, "pages");
+  const shots = join(dir, "snapshots");
+  mkdirSync(pages, { recursive: true });
+  mkdirSync(shots, { recursive: true });
+  const prompt = nullPrompt(brief);
+  const ids = Array.from({ length: runs }, (_, i) => pad(i + 1));
+  for (const id of ids) {
+    const path = join(pages, `${id}.html`);
+    if (!existsSync(path)) continue;
+    const raw = readFileSync(path, "utf8");
+    const html = extractHtml(raw);
+    if (!html) {
+      writeFileSync(join(pages, `${id}.reply.txt`), raw);
+      rmSync(path);
+      rmSync(join(shots, `${id}.json`), { force: true });
+      io.out(`  ${id} was a reply, not a page: kept as ${id}.reply.txt and generated again`);
+    } else if (html !== raw) writeFileSync(path, html);
+  }
+  const missing = ids.filter((id) => !existsSync(join(pages, `${id}.html`)));
+  const failed = [];
+  if (missing.length) io.out(`craft null: generating ${missing.length} page${missing.length === 1 ? "" : "s"}, ${parallel} at a time`);
+  await pool(missing, parallel, async (id) => {
+    try {
+      const reply = await generate(prompt, flags.model);
+      const html = extractHtml(reply);
+      if (!html) {
+        writeFileSync(join(pages, `${id}.reply.txt`), reply);
+        failed.push(`${id}: the reply held no HTML page (kept as ${id}.reply.txt)`);
+        return;
+      }
+      writeFileSync(join(pages, `${id}.html`), html);
+      io.out(`  ${id} written`);
+    } catch (error) {
+      failed.push(`${id}: ${error.message}`);
+    }
+  });
+  const toShoot = ids.filter((id) => existsSync(join(pages, `${id}.html`)) && !existsSync(join(shots, `${id}.json`)));
+  if (toShoot.length) {
+    io.out(`craft null: snapshotting ${toShoot.length} page${toShoot.length === 1 ? "" : "s"}`);
+    const { snapshotUrls } = await import("./audit-5TYDYRXV.js");
+    const results = await snapshotUrls(toShoot.map((id) => pathToFileURL(join(pages, `${id}.html`)).href));
+    results.forEach((r, i) => {
+      const id = toShoot[i];
+      if (r.snapshot) writeFileSync(join(shots, `${id}.json`), `${JSON.stringify({ ...r.snapshot, url: `pages/${id}.html` }, null, 2)}
+`);
+      else failed.push(`${id}: the page would not render: ${r.error}`);
+    });
+  }
+  const measured = ids.filter((id) => existsSync(join(pages, `${id}.html`)) && existsSync(join(shots, `${id}.json`))).map((id) => measureRun(id, readFileSync(join(pages, `${id}.html`), "utf8"), readSnapshot(readJson(join(shots, `${id}.json`)), `${id}.json`)));
+  const model = {
+    version: NULL_VERSION,
+    brief: brief.trim(),
+    prompt,
+    model: flags.model ?? "default",
+    catalogueVersion: CATALOGUE_VERSION,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    runs: measured
+  };
+  writeFileSync(join(dir, "null.json"), `${JSON.stringify(model, null, 2)}
+`);
+  io.out(`craft null: ${measured.length} of ${runs} pages in ${relative(io.cwd, join(dir, "null.json")) || "null.json"}`);
+  for (const f of failed) io.err(`  ${f}`);
+  if (measured.length < runs) {
+    io.err(`craft null: ${runs - measured.length} missing. Run the same command again to fill them in.`);
+    return 1;
+  }
+  return 0;
+}
+function copyTell(phrase) {
+  const text = `We found that ${phrase} was there.`;
+  const hit = checkCopy([{ path: "phrase.md", text }]).findings[0];
+  return hit ? hit.tell : null;
+}
+function formatHarvest(candidates, models) {
+  const lines = [`craft tells harvest: ${models.reduce((s, m) => s + m.runs.length, 0)} null pages from ${models.length} brief${models.length === 1 ? "" : "s"}`];
+  const fresh = candidates.filter((c) => !c.known);
+  const known = candidates.filter((c) => c.known);
+  const runs = models.flatMap((m) => m.runs);
+  const line = (c) => {
+    const swatch = c.kind === "accent" ? hueSwatch(runs, c.value) : null;
+    const where = models.length > 1 ? `, ${c.briefs} brief${c.briefs === 1 ? "" : "s"}` : "";
+    return `  ${c.kind.padEnd(8)} ${`${c.value}${swatch ? ` (${swatch})` : ""}`.padEnd(44)} ${c.runs} of ${c.of}${where}${c.known ? `  caught by ${c.known}` : ""}`;
+  };
+  lines.push("", "Not on the catalogue: candidates for the next generation. A person decides.");
+  lines.push(...fresh.length ? fresh.map(line) : ["  none"]);
+  lines.push("", "Already caught: the catalogue still describes what the model builds.");
+  lines.push(...known.length ? known.map(line) : ["  none"]);
+  return lines.join("\n");
+}
+function describeTypicality(t, pages, briefs) {
+  const pct = Math.round(t.score * 100);
+  return [
+    `Typicality against ${pages} null pages from ${briefs} brief${briefs === 1 ? "" : "s"}`,
+    `  score      ${t.score.toFixed(2)}: ${t.typical ? "typical" : "not typical"}. ${pct}% of the model's own pages sit further from the rest than this one.`,
+    `  distance   ${t.distance.toFixed(3)} to its nearest null pages; the null's own median is ${t.baseline.toFixed(3)}`,
+    `  nearest    ${t.nearest.map((n) => `${n.id} ${n.distance.toFixed(2)}`).join(", ")}`,
+    `  shares     ${t.shared.map((s) => `${s.part} ${s.value} (${s.runs} of ${s.of})`).join(", ") || "no choice with a quarter of the null"}`
+  ].join("\n");
+}
+async function runNull(args, io) {
+  try {
+    const flags = parseFlags(args);
+    if (typeof flags === "string") throw new Error(flags);
+    if (flags.positional[0] !== "build") throw new Error('usage: craft null build --brief "<text>" --out <dir> [--runs 20] [--parallel 4] [--model <name>]');
+    return await build(flags, io);
+  } catch (error) {
+    io.err(`craft: ${error.message}`);
+    return 2;
+  }
+}
+function runHarvest(args, io) {
+  const flags = parseFlags(args);
+  if (typeof flags === "string") throw new Error(flags);
+  const targets = flags.positional.slice(1);
+  if (targets.length === 0) throw new Error("usage: craft tells harvest <null.json | dir>... [--share 0.25] [--json]");
+  const paths = targets.flatMap((t) => {
+    const abs = resolve(io.cwd, t);
+    if (existsSync(abs) && statSync(abs).isDirectory() && !existsSync(join(abs, "null.json"))) {
+      return readdirSync(abs).map((d) => join(abs, d, "null.json")).filter((p) => existsSync(p));
+    }
+    return [t];
+  });
+  const models = paths.map((p) => loadNull(p, io.cwd));
+  const minShare = flags.share === void 0 ? void 0 : Number(flags.share);
+  if (minShare !== void 0 && !(minShare > 0 && minShare <= 1)) throw new Error("--share needs a number above 0 and at most 1");
+  const candidates = harvest(models, { minShare, copyTell });
+  io.out(flags.json ? toJson({ briefs: models.map((m) => m.brief), candidates }) : formatHarvest(candidates, models));
+  return 0;
+}
+
+export {
+  nullPath,
+  loadNull,
+  measureRun,
+  formatHarvest,
+  describeTypicality,
+  runNull,
+  runHarvest
+};