@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.3

package/dist/chunk-KQDZXGNR.js

@@ -0,0 +1,14 @@
+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 {
+  isCritic,
+  isHandoffStep
+} from "./chunk-4Q3NN7VF.js";
+import "./chunk-TV45EUGM.js";
+export {
+  isCritic,
+  isHandoffStep
+};

package/dist/chunk-KUUQR4HA.js

@@ -0,0 +1,264 @@
+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 {
+  intakeContext
+} from "./chunk-FVQISWPW.js";
+import "./chunk-VOGCSYOI.js";
+import {
+  changeFolder,
+  changeStore
+} from "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import {
+  estateFacts,
+  estateRepos,
+  joinReposOf,
+  outsideSystems
+} from "./chunk-OLWFG75W.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import {
+  attachToChange,
+  readChangeInputs,
+  readVendorSpec
+} from "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  PROTOTYPE_GROUPS,
+  comparePrototype,
+  factsDirOf,
+  inputsDirOf,
+  isPrototypeType,
+  parseFacts
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/prototype-commands.js
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var PROTOTYPE_CLI_WORDS = {
+  usage: (change, repo) => `--prototype names a prototype repo, attached on its own: atticus change attach ${change} --prototype ${repo}`,
+  noChange: (change) => `There is no change ${change}: atticus change list shows them.`,
+  noRepo: (repo) => `There is no repo ${repo} in the manifests (org-pack/profiles/<platform>/repos.manifest.yaml); atticus repo add adds one.`,
+  notPrototype: (repo, type) => `${repo} isn't a prototype: repos.manifest.yaml types it ${type}. A prototype is typed prototype there; then attach it.`,
+  notRead: (repo) => `${repo} has no verified facts yet: read it with /atticus-map ${repo}, then atticus verify ${repo}.`,
+  about: (repo, about) => `${repo} (a prototype)${about ? `: ${about.text}${about.trust === "suggested" ? " (a draft nobody has confirmed)" : ""}` : ": nothing says what it is yet (atticus repo describe)."}`,
+  counts: (c) => {
+    const all = PROTOTYPE_GROUPS.reduce((n, g) => n + c[g], 0);
+    return `${all} call${all === 1 ? "" : "s"} compared with the estate: ${c.exists} exist${c.exists === 1 ? "s" : ""}, ${c.changes} change${c.changes === 1 ? "s" : ""}, ${c.new} new, ${c.vendor} only a vendor provides.`;
+  },
+  group: {
+    exists: "Exists: the estate serves it as the prototype needs.",
+    changes: "Changes: the estate serves the operation, but not as the prototype needs.",
+    new: "New: nothing in the estate serves it.",
+    vendor: "Vendor: only a vendor provides it, so it needs a route through the external gateway."
+  },
+  left: (n) => `${n} call${n === 1 ? "" : "s"} of the prototype reach${n === 1 ? "es" : ""} nothing in it and ${n === 1 ? "isn't" : "aren't"} compared:`,
+  attached: (path) => `Attached as ${path}: the change's feature and architecture stages read it as data, citing it by line.`,
+  unchanged: (path) => `The comparison is what ${path} already says: nothing to attach again.`,
+  footprint: (c) => {
+    const parts = [
+      c.repos.length ? `repos ${c.repos.join(", ")}` : "",
+      c.endpoints.length ? `Endpoints ${c.endpoints.join(", ")}` : "",
+      c.vendorOperations.length ? `vendor operations ${c.vendorOperations.join(", ")}` : ""
+    ].filter(Boolean);
+    return parts.length ? `Its footprint now has ${parts.join("; ")}.` : "Its footprint is unchanged: every call exists as the prototype needs, or is new.";
+  },
+  docTitle: (repo) => `# What the prototype ${repo} asks of the estate`
+};
+var SPECS = /* @__PURE__ */ new Set(["openapi", "swagger"]);
+async function loadPrototypeComparison(root, repo, io) {
+  const { op, inputs } = await intakeContext(root, io);
+  const manifest = estateRepos(op).find((r) => r.id === repo);
+  if (!manifest)
+    return { error: PROTOTYPE_CLI_WORDS.noRepo(repo) };
+  if (!isPrototypeType(manifest.type))
+    return { error: PROTOTYPE_CLI_WORDS.notPrototype(repo, manifest.type) };
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => "");
+  const parsed = text.trim() ? parseFacts(text) : void 0;
+  if (!parsed?.ok || !parsed.facts.length || parsed.facts.some((f) => f.verified === "none"))
+    return { error: PROTOTYPE_CLI_WORDS.notRead(repo) };
+  const estate = await estateFacts(root, op, repo);
+  const systems = op.profiles.flatMap((p) => p.profile?.systems ?? []);
+  const vendors = [];
+  for (const d of inputs.documents) {
+    if (!d.id || d.supersededBy || !SPECS.has(d.classification))
+      continue;
+    const system = systems.find((s) => s.id === d.systems[0] && s.boundary === "vendor");
+    if (!system)
+      continue;
+    const body = await readFile(join(inputsDirOf(root), ...d.path.split("/").slice(1)), "utf8");
+    const spec = readVendorSpec(d.path, body, system.id);
+    if (!spec)
+      continue;
+    const prior = vendors.find((v) => v.system === system.id);
+    const operations = spec.operations.map((o) => ({
+      id: o.id,
+      method: o.method,
+      path: o.path,
+      fullPath: o.fullPath,
+      cite: o.cite,
+      ...o.auth ? { auth: o.auth } : {},
+      scopes: o.scopes,
+      fields: [
+        ...o.request.map((f) => ({ side: "request", f })),
+        ...o.response.map((f) => ({ side: "response", f }))
+      ].map(({ side, f }) => ({
+        side,
+        name: f.name,
+        ...f.type ? { type: f.type } : {},
+        ...f.required !== void 0 ? { required: f.required } : {},
+        at: f.cite
+      }))
+    }));
+    if (prior) {
+      prior.operations.push(...operations);
+      prior.hosts.push(...spec.hosts);
+    } else
+      vendors.push({
+        system: system.id,
+        names: [system.name, ...system.aliases],
+        hosts: [...spec.hosts],
+        operations
+      });
+  }
+  const comparison = comparePrototype({
+    prototype: {
+      repo,
+      facts: parsed.facts,
+      ...manifest.component ? { component: manifest.component } : {}
+    },
+    estate: joinReposOf(op, estate.repos),
+    vendors,
+    outside: outsideSystems(op)
+  });
+  return {
+    repo,
+    ...manifest.description ? { about: manifest.description } : {},
+    comparison,
+    notes: estate.notes,
+    systemOf: Object.fromEntries(estateRepos(op).flatMap((r) => r.system ? [[r.id, r.system]] : []))
+  };
+}
+var where = (e) => `${e.repo} ${e.at}`;
+function callLines(c) {
+  const other = c.estate ? `; ${where(c.estate.entry)}` : c.vendor?.at ? `; ${c.vendor.name} ${c.vendor.at}` : "";
+  return [
+    `  ${c.sentence}`,
+    `    ${c.call.repo} ${c.call.at} \u2192 ${c.lands.at}${other}`,
+    ...(c.candidates ?? []).map((x) => `    ? ${where(x)}`),
+    ...c.differences.map((d) => `    - ${d.message}`)
+  ];
+}
+function prototypeLines(l) {
+  const c = l.comparison;
+  const out = [PROTOTYPE_CLI_WORDS.about(l.repo, l.about), PROTOTYPE_CLI_WORDS.counts(c.counts)];
+  for (const g of PROTOTYPE_GROUPS) {
+    const calls = c.calls.filter((x) => x.group === g);
+    if (!calls.length)
+      continue;
+    out.push(PROTOTYPE_CLI_WORDS.group[g]);
+    for (const x of calls)
+      out.push(...callLines(x));
+  }
+  if (c.left.length) {
+    out.push(PROTOTYPE_CLI_WORDS.left(c.left.length));
+    for (const x of c.left)
+      out.push(`  ${x.why} (${x.call.at})`);
+  }
+  out.push(...l.notes);
+  return out;
+}
+function prototypeDocument(l) {
+  return {
+    name: `prototype-${l.repo}.md`,
+    text: [PROTOTYPE_CLI_WORDS.docTitle(l.repo), "", ...prototypeLines(l), ""].join("\n")
+  };
+}
+var sorted = (xs) => [...new Set(xs)].sort();
+var ATTACHED = /^prototype-(.+)\.md$/;
+async function changePrototypes(root, change) {
+  const quiet = { out: () => void 0, err: () => void 0 };
+  const files = (await readChangeInputs(changeFolder(root, change))).files.filter((f) => !f.supersededBy && ATTACHED.test(f.name)).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  const prototypes = [];
+  for (const f of files) {
+    const repo = ATTACHED.exec(f.name)[1];
+    const got = await loadPrototypeComparison(root, repo, quiet);
+    prototypes.push("error" in got ? { repo, attached: f.path, problem: got.error } : {
+      repo,
+      attached: f.path,
+      ...got.about ? { about: { text: got.about.text, trust: got.about.trust } } : {},
+      comparison: got.comparison
+    });
+  }
+  return { prototypes };
+}
+async function attachPrototype(root, change, repo, o, io) {
+  const store = changeStore(root);
+  const c = await store.read(change).catch(() => void 0);
+  if (!c) {
+    io.err(PROTOTYPE_CLI_WORDS.noChange(change));
+    return 1;
+  }
+  const got = await loadPrototypeComparison(root, repo, io);
+  if ("error" in got) {
+    io.err(got.error);
+    return 1;
+  }
+  const doc = prototypeDocument(got);
+  const dir = changeFolder(root, c.id);
+  const before = (await readChangeInputs(dir)).files.find((f) => f.name === doc.name && !f.supersededBy);
+  const r = await attachToChange(dir, [{ name: doc.name, bytes: new TextEncoder().encode(doc.text) }], {
+    by: o.by,
+    at: (o.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+    ...before ? { replaces: before.path } : {}
+  });
+  const added = r.added[0]?.path;
+  const path = added ?? before?.path ?? `inputs/${doc.name}`;
+  const cmp = got.comparison;
+  const fresh = await store.read(c.id);
+  const touches = {
+    ...fresh.touches,
+    repos: sorted([...fresh.touches.repos, ...cmp.repos]),
+    records: sorted([...fresh.touches.records, ...cmp.endpoints, ...cmp.vendorOperations])
+  };
+  const systems = sorted([
+    ...fresh.systems,
+    ...cmp.vendors,
+    ...cmp.repos.flatMap((x) => got.systemOf[x] ? [got.systemOf[x]] : [])
+  ]);
+  await store.write({ ...fresh, systems, touches });
+  if (o.json) {
+    io.out(JSON.stringify({
+      prototype: repo,
+      ...got.about ? { about: got.about } : {},
+      comparison: cmp,
+      attached: path,
+      touches: { repos: touches.repos, records: touches.records },
+      systems
+    }, null, 2));
+    return 0;
+  }
+  for (const l of prototypeLines(got))
+    io.out(l);
+  io.out(added ? PROTOTYPE_CLI_WORDS.attached(path) : PROTOTYPE_CLI_WORDS.unchanged(path));
+  io.out(PROTOTYPE_CLI_WORDS.footprint(cmp));
+  return 0;
+}
+export {
+  PROTOTYPE_CLI_WORDS,
+  attachPrototype,
+  changePrototypes,
+  loadPrototypeComparison,
+  prototypeDocument,
+  prototypeLines
+};