@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/chunk-WCEF7H6L.js

@@ -0,0 +1,221 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  badRequest
+} from "./chunk-HK3VOHIE.js";
+import {
+  catalogRecords
+} from "./chunk-FY3QIRTL.js";
+import {
+  RecordId,
+  catalogDirOf,
+  changesDirOf,
+  readRepoSpec,
+  require_dist,
+  specRepos,
+  specsDirOf
+} from "./chunk-PAINMSID.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/ui-api-cites.js
+import { readdir, readFile, stat } from "node:fs/promises";
+import { isAbsolute, join, relative, sep } from "node:path";
+var import_yaml = __toESM(require_dist(), 1);
+async function fingerprint(dirs) {
+  let count = 0;
+  let newest = 0;
+  const walk = async (d) => {
+    const entries = await readdir(d, { withFileTypes: true }).catch(() => []);
+    for (const e of entries) {
+      const p = join(d, e.name);
+      if (e.isDirectory())
+        await walk(p);
+      else {
+        count++;
+        const s = await stat(p).catch(() => void 0);
+        if (s && s.mtimeMs > newest)
+          newest = s.mtimeMs;
+      }
+    }
+  };
+  for (const d of dirs)
+    await walk(d);
+  return `${count}:${newest}`;
+}
+async function build(root) {
+  const index = /* @__PURE__ */ new Map();
+  const lineOf = (repo, path, line) => {
+    const files = index.get(repo) ?? /* @__PURE__ */ new Map();
+    index.set(repo, files);
+    const lines = files.get(path) ?? /* @__PURE__ */ new Map();
+    files.set(path, lines);
+    const l = lines.get(line) ?? { line, flows: [], records: [] };
+    lines.set(line, l);
+    return l;
+  };
+  for (const specRepo of await specRepos(root))
+    for (const f of (await readRepoSpec(root, specRepo, { cacheRoot: root })).flows) {
+      const parts = [
+        { step: 0, kind: f.trigger.kind, evidence: f.trigger.evidence },
+        ...f.steps.map((s, i) => ({
+          step: i + 1,
+          kind: s.kind,
+          ...s.confirmedBy ? { confirmedBy: s.confirmedBy } : {},
+          evidence: s.evidence
+        }))
+      ];
+      for (const part of parts)
+        for (const e of part.evidence) {
+          if (!e.path || e.line === void 0)
+            continue;
+          const l = lineOf(e.repo ?? specRepo, e.path, e.line);
+          if (l.flows.some((x) => x.flow === f.id && x.step === part.step))
+            continue;
+          l.flows.push({
+            repo: specRepo,
+            flow: f.id,
+            name: f.name,
+            step: part.step,
+            kind: part.kind,
+            ...part.confirmedBy ? { confirmedBy: part.confirmedBy } : {}
+          });
+        }
+    }
+  for (const r of await catalogRecords(root)) {
+    const name = r.name;
+    for (const e of r.evidence) {
+      if (!e.repo || !e.path || e.line === void 0)
+        continue;
+      const l = lineOf(e.repo, e.path, e.line);
+      if (l.records.some((x) => x.kind === r.kind && x.id === r.id))
+        continue;
+      l.records.push({
+        kind: r.kind,
+        id: r.id,
+        ...typeof name === "string" && name !== r.id ? { name } : {},
+        source: e.source
+      });
+    }
+  }
+  return index;
+}
+var DONE = /* @__PURE__ */ new Set(["released", "archived", "post-release-review"]);
+async function inFlight(root) {
+  const out = /* @__PURE__ */ new Map();
+  const dir = changesDirOf(root);
+  for (const e of await readdir(dir, { withFileTypes: true }).catch(() => [])) {
+    if (!e.isDirectory() || e.name === "archive")
+      continue;
+    const yaml = await readFile(join(dir, e.name, "change.yaml"), "utf8").catch(() => "");
+    const state = (() => {
+      try {
+        return (0, import_yaml.parse)(yaml)?.state;
+      } catch {
+        return void 0;
+      }
+    })();
+    if (!yaml || typeof state === "string" && DONE.has(state))
+      continue;
+    for (const f of await readdir(join(dir, e.name, "target-flows")).catch(() => []))
+      if (f.endsWith(".yaml")) {
+        const flow = f.slice(0, -".yaml".length);
+        out.set(flow, [...out.get(flow) ?? [], e.name]);
+      }
+  }
+  return out;
+}
+async function citeList(root, index, repo, path) {
+  const lines = [...index.get(repo)?.get(path)?.values() ?? []].sort((a, b) => a.line - b.line);
+  const flying = await inFlight(root);
+  const shown = lines.map((l) => ({
+    ...l,
+    flows: [...l.flows].sort((a, b) => a.flow.localeCompare(b.flow) || a.step - b.step).map((f) => flying.get(f.flow)?.length ? { ...f, changes: flying.get(f.flow) } : f)
+  }));
+  return { repo, path, lines: shown };
+}
+function fileInRepo(root, file) {
+  const rel = relative(root, file);
+  if (!rel || rel.startsWith("..") || isAbsolute(rel))
+    return void 0;
+  const parts = rel.split(sep);
+  if (parts[0] !== "workspace")
+    return { path: parts.join("/") };
+  const at = parts[1] === ".worktrees" ? 3 : parts[1] === ".branches" ? 2 : 1;
+  const repo = parts[at];
+  const rest = parts.slice(parts[1] === ".branches" ? 4 : at + 1);
+  if (!repo || !rest.length || !RecordId.safeParse(repo).success)
+    return void 0;
+  return { repo, path: rest.join("/") };
+}
+async function citesCli(root, o, io) {
+  let repo = o.repo;
+  let path = o.path;
+  const index = await build(root);
+  if (o.file) {
+    const at = fileInRepo(root, o.file);
+    if (!at) {
+      io.err(`${o.file} isn't in this metarepo or a repo's checkout in its workspace.`);
+      return 1;
+    }
+    path = at.path;
+    repo = at.repo ?? [...index.keys()].find((r) => index.get(r).has(at.path)) ?? void 0;
+    if (!repo) {
+      if (o.json)
+        io.out(JSON.stringify({ repo: "", path, lines: [] }, null, 2));
+      else
+        io.out(`Nothing in the specs or the catalog cites ${path}.`);
+      return 0;
+    }
+  }
+  if (!repo || !path || !RecordId.safeParse(repo).success) {
+    io.err("Say which file: atticus cites --repo <repo> --path <its path in the repo>, or --file <path on disk>.");
+    return 2;
+  }
+  const v = await citeList(root, index, repo, path);
+  if (o.json) {
+    io.out(JSON.stringify(v, null, 2));
+    return 0;
+  }
+  if (!v.lines.length) {
+    io.out(`Nothing in the specs or the catalog cites ${repo}/${path}.`);
+    return 0;
+  }
+  for (const l of v.lines) {
+    const flows = l.flows.map((f) => `${f.name} (step ${f.step})${f.changes?.length ? `, changed by ${f.changes.join(", ")}` : ""}`);
+    const records = l.records.map((r) => `${r.kind} ${r.name ?? r.id}`);
+    io.out(`Line ${l.line}: ${[...flows, ...records].join("; ")}`);
+  }
+  return 0;
+}
+function uiCiteRoutes(r, ctx) {
+  const root = ctx.root;
+  let cached;
+  const indexNow = async () => {
+    const print = await fingerprint([specsDirOf(root), catalogDirOf(root)]);
+    if (cached?.print !== print)
+      cached = { print, index: build(root) };
+    return cached.index;
+  };
+  void indexNow().catch(() => void 0);
+  r.add("GET", "/api/cites", async ({ query }) => {
+    const repo = query.get("repo");
+    const path = query.get("path");
+    if (!repo || !RecordId.safeParse(repo).success)
+      throw badRequest("Say which repo: ?repo=<the repo's id>.");
+    if (!path)
+      throw badRequest("Say which file: ?path=<its path in the repo>.");
+    return { status: 200, body: await citeList(root, await indexNow(), repo, path) };
+  });
+  return r;
+}
+
+export {
+  fileInRepo,
+  citesCli,
+  uiCiteRoutes
+};

package/dist/{chunk-2DIQQJCB.js → chunk-WEOMJHPV.js}

@@ -7,12 +7,12 @@ import {
   exportFrameworksKit,
   formatFrameworkSurvey,
   surveyFrameworks
-} from "./chunk-KEM4SDDP.js";
-import "./chunk-27NKUS3X.js";
-import "./chunk-L24C55VN.js";
-import "./chunk-PAMPPUR6.js";
-import "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
+} from "./chunk-P2VBXX7N.js";
+import "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
 import {
   houseDependencies,
   learnFramework,
@@ -20,14 +20,14 @@ import {
   learnJsFramework,
   learnJsFrameworkFromTarball,
   runFrameworkTests
-} from "./chunk-MC3H7736.js";
+} from "./chunk-TWQRPM76.js";
 import {
   baseClonePath
-} from "./chunk-EFHQ3TWP.js";
+} from "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
 import {
   fsRepo
-} from "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
+} from "./chunk-7AB6OWTV.js";
 import {
   FrameworkModel,
   RecordId,
@@ -35,8 +35,8 @@ import {
   orgPackDirOf,
   require_dist,
   toCanonicalYaml
-} from "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/{chunk-FHH4I4ZV.js → chunk-WFU77T3A.js}

@@ -5,23 +5,25 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   targetFlowsOf
-} from "./chunk-TDD55CJH.js";
+} from "./chunk-GNWAOVFQ.js";
 import {
   estimateChange,
   loadRelease,
   releaseForecast
-} from "./chunk-BOHJZTEQ.js";
+} from "./chunk-36RY7ZXM.js";
 import {
   gateStatus,
   reviewedGates
-} from "./chunk-3HI6Z55Y.js";
+} from "./chunk-K332XW7K.js";
 import {
-  detectConflicts
-} from "./chunk-XY3P7JW7.js";
+  detectConflicts,
+  outsideSystemsOf
+} from "./chunk-HSZMPH5T.js";
 import {
   loadEstimates,
+  loadOrgPack,
   orgPackDirOf
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-PAINMSID.js";
 
 // packages/cli/dist/change-estimate.js
 import { relative, sep } from "node:path";
@@ -42,6 +44,9 @@ async function estimateOf(root, change, o = {}) {
       systemOf.set(r.id, r.system);
   }
   const boundaryOf = (c) => systems.get(systemOf.get(c) ?? c);
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  const outside = op ? outsideSystemsOf(op) : /* @__PURE__ */ new Map();
+  const otherTeam = (c) => boundaryOf(c) !== "vendor" && outside.get(systemOf.get(c) ?? c) === "other-team";
   let openBlocking = 0;
   for (const gate of await reviewedGates(root, change).catch(() => []))
     openBlocking += await gateStatus(root, change, gate).then((s) => s.open.blocking, () => 0);
@@ -76,6 +81,7 @@ async function estimateOf(root, change, o = {}) {
     flows,
     ...estimates ? { table: estimates } : {},
     boundaryOf,
+    otherTeam,
     openBlocking,
     conflicts,
     ...waitDays !== void 0 ? { waitDays } : {}

package/dist/chunk-WIWTJMMR.js

@@ -0,0 +1,292 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  targetFlowsOf
+} from "./chunk-GNWAOVFQ.js";
+import {
+  withFileLock
+} from "./chunk-THN26IEF.js";
+import "./chunk-5QUOPNLN.js";
+import {
+  TARGET_DIR,
+  applyStroke,
+  endpointKey,
+  loadEstate,
+  planSketchWrite,
+  readDeltas,
+  writeSketch
+} from "./chunk-BEPCKDCP.js";
+import "./chunk-HWD4JPU7.js";
+import "./chunk-5WERBKLE.js";
+import "./chunk-K332XW7K.js";
+import {
+  changeFolder
+} from "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
+import "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import {
+  labelText,
+  readDrawio
+} from "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import {
+  changesRelOf
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/change-sketch.js
+import { readFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+var METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+function lineParts(text) {
+  const toks = text.trim().split(/\s+/).filter(Boolean);
+  if (toks.length >= 2 && METHODS.has(toks[0].toUpperCase()) && toks[1].startsWith("/"))
+    return { method: toks[0].toUpperCase(), path: toks[1] };
+  if (toks.length === 1 && /^[A-Za-z0-9][\w.-]*\.[\w.-]+$/.test(toks[0]))
+    return { topic: toks[0] };
+  return {};
+}
+function readMermaidSketch(text) {
+  const labels = /* @__PURE__ */ new Map();
+  const lines = [];
+  const problems = [];
+  const legendOf = (s) => {
+    const m = /^\s*[[(]\s*(new|modify|modified|changed|retire|retired|removed)\s*[\])]\s*(.*)$/i.exec(s);
+    if (!m)
+      return { text: s.trim() };
+    const w = m[1].toLowerCase();
+    return {
+      legend: w.startsWith("new") ? "new" : w.startsWith("ret") || w === "removed" ? "retire" : "modify",
+      text: m[2].trim()
+    };
+  };
+  const node = (tok) => {
+    const m = /^([A-Za-z0-9_.-]+)(?:\[\s*"?([^\]"]*)"?\s*\]|\(+\s*"?([^)"]*)"?\s*\)+|\{+\s*"?([^}"]*)"?\s*\}+|>\s*"?([^\]"]*)"?\s*\])?$/.exec(tok.trim());
+    if (!m)
+      return tok.trim();
+    const label = (m[2] ?? m[3] ?? m[4] ?? m[5])?.trim();
+    if (label)
+      labels.set(m[1], label);
+    return m[1];
+  };
+  const rows = text.split(/\r?\n/);
+  rows.forEach((raw, i) => {
+    const row = raw.replace(/%%.*$/, "").trim();
+    if (!row || /^(flowchart|graph)\b/i.test(row) || /^(subgraph|end|classDef|class|style|direction)\b/i.test(row))
+      return;
+    if (/<\s*[-=.]/.test(row)) {
+      problems.push(`line ${i + 1}: a two-way line: draw one line each way: ${row}`);
+      return;
+    }
+    const m = /^(.+?)\s*(?:--+|==+|-\.+-?)\s*(?:\|([^|]*)\||"?([^">=-]*?)"?\s*(?:--+|==+|\.-+))?\s*>\s*(?:\|([^|]*)\|)?\s*(.+)$/.exec(row);
+    if (!m) {
+      if (/^[A-Za-z0-9_.-]+\s*[[({]/.test(row))
+        node(row);
+      else
+        problems.push(`line ${i + 1}: not a box or a line: ${row}`);
+      return;
+    }
+    if (/-->|==>|\.->|&/.test(m[1]) || /-->|==>|\.->|&/.test(m[5])) {
+      problems.push(`line ${i + 1}: one line between two boxes at a time (no chains or &): ${row}`);
+      return;
+    }
+    const from = node(m[1]);
+    const to = node(m[5]);
+    const { legend, text: label } = legendOf((m[2] ?? m[3] ?? m[4] ?? "").trim().replace(/^"(.*)"$/, "$1"));
+    lines.push({
+      from: labels.get(from) ?? from,
+      to: labels.get(to) ?? to,
+      label,
+      ...lineParts(label),
+      ...legend ? { legend } : {},
+      at: `line ${i + 1}`
+    });
+  });
+  for (const l of lines) {
+    l.from = labels.get(l.from) ?? l.from;
+    l.to = labels.get(l.to) ?? l.to;
+  }
+  return { lines, problems };
+}
+function readDrawioSketch(xml) {
+  const d = readDrawio(xml);
+  const lines = d.edges.map((e) => ({
+    from: e.from,
+    to: e.to,
+    label: labelText(e.label),
+    ...e.method ? { method: e.method } : {},
+    ...e.path ? { path: e.path } : {},
+    ...e.topic ? { topic: e.topic } : {},
+    ...e.legend ? { legend: e.legend } : {},
+    at: `${e.page}:${e.line}`
+  }));
+  return { lines, problems: d.problems.map((p) => `${p.cell}: ${p.message}`) };
+}
+var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+function componentOf(label, estate) {
+  const s = slug(label);
+  const known = (id) => estate.ids.has(id) || estate.flows.some((f) => f.flow.component === id);
+  if (known(label))
+    return label;
+  if (known(s))
+    return s;
+  for (const r of estate.records)
+    if (r.kind === "Component" && (slug(("name" in r && typeof r.name === "string" ? r.name : "") ?? "") === s || slug(r.id) === s))
+      return r.id;
+  return void 0;
+}
+function strokesOfLines(lines, estate, drawnAlready = []) {
+  const plan = { strokes: [], skipped: [] };
+  for (const l of lines) {
+    const from = componentOf(l.from, estate);
+    const to = componentOf(l.to, estate) ?? slug(l.to);
+    if (!from) {
+      plan.skipped.push({
+        line: l,
+        why: `${l.from} isn't a component of the catalog: a stroke can't start from it here (a new box needs a flow name and a trigger; draw it in the app).`
+      });
+      continue;
+    }
+    const entry = l.topic ?? (l.method && l.path ? `${l.method} ${l.path}` : l.label);
+    if (!entry) {
+      plan.skipped.push({
+        line: l,
+        why: "the line has no label: say the API (METHOD /path) or the topic."
+      });
+      continue;
+    }
+    const todaySteps = estate.flows.filter((f) => f.flow.component === from).flatMap((f) => f.flow.steps.map((s, i) => ({ flow: f.flow.id, step: i + 1, s })).filter(({ s }) => s.to?.component === to && (s.to.entry === entry || !!l.path && s.to.entry.replace(/^[A-Z]+\s+/, "") === l.path)));
+    if (l.legend === "retire") {
+      if (!todaySteps.length) {
+        plan.skipped.push({
+          line: l,
+          why: `marked retired, but today's map has no step from ${from} to ${to} ${entry}.`
+        });
+        continue;
+      }
+      for (const t of todaySteps)
+        plan.strokes.push({
+          line: l,
+          stroke: {
+            kind: "remove",
+            flow: t.flow,
+            step: t.step,
+            why: `Removed in the sketch (${l.at}).`
+          }
+        });
+      continue;
+    }
+    if (todaySteps.length && l.legend !== "new") {
+      plan.skipped.push({ line: l, why: "already on today's map; nothing to draw." });
+      continue;
+    }
+    const drawnBefore = drawnAlready.some((d) => (d.repo === from || d.runsOn?.component === from || d.flow.startsWith(`${from}.`)) && d.steps.some((st) => st.op === "add" && (l.topic && st.kind === "publish" && st.to?.entry === l.topic || !l.topic && st.to?.component === to && st.to.entry === entry)));
+    if (drawnBefore) {
+      plan.skipped.push({ line: l, why: "already drawn in this change; nothing to add." });
+      continue;
+    }
+    const isNew = !componentOf(l.to, estate) || !!l.method && !estate.endpoints.has(endpointKey(entry));
+    plan.strokes.push({
+      line: l,
+      stroke: l.topic ? {
+        kind: "topic",
+        from: { component: from },
+        topic: l.topic,
+        ...componentOf(l.to, estate) && to !== from ? { listener: { component: to } } : {},
+        what: `Publishes ${l.topic} (${l.at}).`
+      } : {
+        kind: "call",
+        from: { component: from },
+        to: { component: to, entry, new: isNew },
+        what: `Calls ${to}'s ${entry} (${l.at}).`
+      }
+    });
+  }
+  return plan;
+}
+async function changeSketchCommand(root, change, o, io) {
+  if (!change || !o.from) {
+    io.err("Usage: atticus change sketch <change> --from <file.drawio|.mmd> [--save]");
+    return 2;
+  }
+  const t = await targetFlowsOf(root, change);
+  if (!t) {
+    io.err(`There is no change ${change}.`);
+    return 2;
+  }
+  const text = await readFile(o.from, "utf8").catch(() => void 0);
+  if (text === void 0) {
+    io.err(`${o.from} can't be read.`);
+    return 2;
+  }
+  const ext = extname(o.from).toLowerCase();
+  const read = ext === ".drawio" || ext === ".xml" || text.trimStart().startsWith("<") ? readDrawioSketch(text) : readMermaidSketch(text);
+  const estate = await loadEstate(root, t.records);
+  const dir = changeFolder(root, change);
+  const plan = strokesOfLines(read.lines, estate, (await readDeltas(dir)).deltas);
+  const by = `${o.by ?? "a person"} from ${basename(o.from)}`;
+  const problems = [...read.problems];
+  const drawn = [];
+  await withFileLock(join(dir, TARGET_DIR), async () => {
+    const read2 = await readDeltas(dir);
+    if (read2.problems.length) {
+      problems.push(...read2.problems.map((x) => `${x} (fix it before drawing over it)`));
+      return;
+    }
+    let deltas = read2.deltas;
+    const changed = [];
+    for (const s of plan.strokes) {
+      const r = applyStroke(deltas, s.stroke, estate, by);
+      if (r.problem) {
+        plan.skipped.push({ line: s.line, why: r.problem });
+        continue;
+      }
+      deltas = r.deltas;
+      changed.push(...r.changed);
+      drawn.push(`${s.line.from} \u2192 ${s.line.to} ${s.line.label} (${s.line.at})`);
+    }
+    if (o.save && drawn.length)
+      await writeSketch(dir, await planSketchWrite(dir, deltas, changed, estate, by));
+  });
+  if (o.json) {
+    io.out(JSON.stringify({
+      change,
+      written: !!o.save && drawn.length > 0,
+      drawn,
+      skipped: plan.skipped,
+      problems
+    }, null, 2));
+    return 0;
+  }
+  for (const d of drawn)
+    io.out(`${o.save ? "Drawn" : "Would draw"}: ${d}`);
+  for (const s of plan.skipped)
+    io.out(`Left out: ${s.line.from} \u2192 ${s.line.to} ${s.line.label} (${s.line.at}): ${s.why}`);
+  for (const p of problems)
+    io.out(`Didn't read: ${p}`);
+  if (!drawn.length) {
+    io.out("Nothing to draw from this file.");
+    return plan.skipped.length || problems.length ? 1 : 0;
+  }
+  io.out(o.save ? `${drawn.length} stroke${drawn.length === 1 ? "" : "s"} written to ${changesRelOf(root)}/${change}/${TARGET_DIR}/; the change diagram shows them, and atticus change architecture ${change} fills in the rest.` : `${drawn.length} stroke${drawn.length === 1 ? "" : "s"} to draw; nothing written. Add --save to draw them.`);
+  return 0;
+}
+export {
+  changeSketchCommand,
+  componentOf,
+  lineParts,
+  readDrawioSketch,
+  readMermaidSketch,
+  strokesOfLines
+};

package/dist/{chunk-2BFCZ3RK.js → chunk-WNTIOBOG.js}

@@ -3,35 +3,35 @@ import { fileURLToPath as __atticusFileURLToPath } from "node:url";
 var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
-import "./chunk-GLUX4EEP.js";
+import "./chunk-K6JB6XTX.js";
 import {
   loadCatalog
-} from "./chunk-FITWGOJ2.js";
+} from "./chunk-5QUOPNLN.js";
 import {
   repoFor
-} from "./chunk-O3WI5KWW.js";
-import "./chunk-KEM4SDDP.js";
+} from "./chunk-TGVVUKTG.js";
+import "./chunk-P2VBXX7N.js";
 import {
   askHosts
-} from "./chunk-RVH5SUW5.js";
-import "./chunk-ZVM6AKKM.js";
+} from "./chunk-TYD6I4CZ.js";
+import "./chunk-ZOSD4FXV.js";
+import "./chunk-5WERBKLE.js";
 import {
   estateFlow,
   estateStepKey,
   fieldLineage,
   joinEstate
-} from "./chunk-27NKUS3X.js";
-import "./chunk-L24C55VN.js";
-import "./chunk-PAMPPUR6.js";
-import "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import "./chunk-T6AIP7H5.js";
-import "./chunk-EFHQ3TWP.js";
+} from "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
 import {
   fsRepo
-} from "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
+} from "./chunk-7AB6OWTV.js";
 import {
   listQuestions,
   loadOrgPack,
@@ -45,8 +45,8 @@ import {
   specsRelOf,
   templateRef,
   writeEstateJoins
-} from "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/estate-commands.js