@maycombhq/atticus 2.0.0-beta.10 → 2.0.0-beta.11

package/dist/{chunk-2RX7PI2Y.js → chunk-HOUUBE74.js}

@@ -5,20 +5,20 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   readCatalog
-} from "./chunk-AY2IUF4K.js";
+} from "./chunk-IILZ7J3L.js";
 import {
   scopeWords
-} from "./chunk-6JLPXDWN.js";
+} from "./chunk-TEBBD4XH.js";
 import {
   baseClonePath,
   loadManifest
-} from "./chunk-PGKHJYOB.js";
+} from "./chunk-XZJE6WIT.js";
 import {
   Sources,
   catalogDirOf,
   orgPackDirOf,
   require_dist
-} from "./chunk-577AJVRS.js";
+} from "./chunk-JMOLB347.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/{chunk-BDEKREZH.js → chunk-HQMCHHY5.js}

@@ -8,11 +8,11 @@ import {
   historyEntry,
   listHistory,
   setLocalRecording
-} from "./chunk-MH5OCRUM.js";
+} from "./chunk-5ACUW753.js";
 import {
   api_exports
-} from "./chunk-577AJVRS.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/history-commands.js

package/dist/{chunk-DPHCFZ7W.js → chunk-HR4DVO6X.js}

@@ -5,13 +5,13 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   changeStore
-} from "./chunk-XQ3YIV5R.js";
+} from "./chunk-3LU6YCSQ.js";
 import {
   readCatalog
-} from "./chunk-AY2IUF4K.js";
+} from "./chunk-IILZ7J3L.js";
 import {
   catalogDirOf
-} from "./chunk-577AJVRS.js";
+} from "./chunk-JMOLB347.js";
 
 // packages/cli/dist/site-commands.js
 import { resolve, join as join2 } from "node:path";

package/dist/chunk-HZYFLEWO.js

@@ -0,0 +1,39 @@
+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 {
+  NOTE_RULES_FILE,
+  repoTypeDetect,
+  repoTypeNew,
+  repoTypeNote,
+  repoTypeRules,
+  termNoteOffer
+} from "./chunk-IRW64JFF.js";
+import "./chunk-NIYB5K5B.js";
+import "./chunk-BUWSOQLU.js";
+import "./chunk-LDIARP6F.js";
+import "./chunk-XKJRPVJO.js";
+import "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-YVCOQ5TZ.js";
+import "./chunk-XNRPCI23.js";
+import "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  NOTE_RULES_FILE,
+  repoTypeDetect,
+  repoTypeNew,
+  repoTypeNote,
+  repoTypeRules,
+  termNoteOffer
+};

package/dist/chunk-IA2RKC6I.js

@@ -0,0 +1,279 @@
+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-MYKQVS5W.js";
+import {
+  headCommitOf
+} from "./chunk-EBWIOODZ.js";
+import {
+  denyHashesAt
+} from "./chunk-BA5DTXHQ.js";
+import {
+  componentRenames,
+  estateFacts,
+  estateJoinOf,
+  hostAliases,
+  joinReposOf,
+  outsideProfileSystems
+} from "./chunk-IILZ7J3L.js";
+import {
+  sameCommit
+} from "./chunk-XPWSNKF3.js";
+import {
+  openApiContractSpecs,
+  readContractSpecs,
+  readRepoSpecs,
+  readVendorSpec
+} from "./chunk-WIMOJMAK.js";
+import {
+  createGit
+} from "./chunk-XZJE6WIT.js";
+import {
+  SpecsFile,
+  catalogDirOf,
+  checkContracts,
+  factsDirOf,
+  factsRelOf,
+  inputsDirOf,
+  joinConventions,
+  joinVendorOperations,
+  newFindings,
+  orgPackDirOf,
+  questionsDirOf,
+  require_dist
+} from "./chunk-JMOLB347.js";
+import {
+  writeFileAtomic
+} from "./chunk-MMB2OHUY.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/contract-check-files.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { readdir, readFile, rm, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+var SPEC_CLASSES = /* @__PURE__ */ new Set(["openapi", "swagger", "asyncapi", "protobuf", "avro"]);
+async function specsCommitOf(facts, dir, git = createGit()) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const f of facts)
+    counts.set(f.commit, (counts.get(f.commit) ?? 0) + 1);
+  if (!counts.size)
+    return void 0;
+  const head = await headCommitOf(dir);
+  const atHead = head ? [...counts.keys()].find((c) => sameCommit(c, head)) : void 0;
+  if (atHead)
+    return atHead;
+  const most = Math.max(...counts.values());
+  const top = [...counts].filter(([, n]) => n === most).map(([c]) => c).sort();
+  if (top.length === 1)
+    return top[0];
+  const newest = await git(["rev-list", "--no-walk", ...top], dir).then((r) => r.stdout.split("\n")[0]?.trim(), () => void 0);
+  return top.find((c) => !!newest && sameCommit(c, newest)) ?? top[0];
+}
+async function commitTree(dir, commit, git) {
+  const listed = await git(["ls-tree", "-r", "-l", "-z", "--full-tree", commit], dir).then((r) => r.stdout, () => void 0);
+  if (listed === void 0)
+    return void 0;
+  const files = listed.split("\0").filter(Boolean).flatMap((line) => {
+    const tab = line.indexOf("	");
+    const [mode, type, , size] = line.slice(0, tab).trim().split(/\s+/);
+    if (tab < 0 || type !== "blob" || mode === "120000")
+      return [];
+    return [{ path: line.slice(tab + 1), size: Number(size) || 0 }];
+  });
+  return {
+    files: async () => files,
+    read: (p) => git(["cat-file", "blob", `${commit}:${p}`], dir).then((r) => r.stdout, () => void 0)
+  };
+}
+async function specTreeOf(repo, dir, commit, git, note) {
+  const as = commit ? { commit } : {};
+  if (!existsSync(join(dir, ".git")))
+    return as;
+  if (commit) {
+    const tree2 = await commitTree(dir, commit, git);
+    if (tree2)
+      return { tree: tree2, commit };
+    note?.(`${repo}: the facts' commit ${commit.slice(0, 12)} isn't in the clone, so its specs are read at the clone's HEAD; fetch it, or read the repo again.`);
+  }
+  const tree = await commitTree(dir, "HEAD", git);
+  if (!tree) {
+    note?.(`${repo}: git can't list the clone's files, so its specs are read from the folder.`);
+    return as;
+  }
+  const head = await headCommitOf(dir);
+  return { tree, ...head ? { commit: head } : as };
+}
+async function writeRepoSpecs(root, repo, dir, facts, onRefused, git = createGit()) {
+  const { tree, commit } = await specTreeOf(repo, dir, await specsCommitOf(facts, dir, git), git, onRefused);
+  const deny = await denyHashesAt(root);
+  const file = await readRepoSpecs(dir, {
+    repo,
+    ...commit ? { commit } : {},
+    ...tree ? { tree } : {},
+    facts,
+    ...deny.size ? { denyHashes: deny } : {},
+    ...onRefused ? { onRefused } : {}
+  });
+  const path = join(factsDirOf(root), `${repo}.specs.yaml`);
+  if (file.specs.length)
+    await writeFileAtomic(path, (0, import_yaml.stringify)(file, { lineWidth: 0 }));
+  else
+    await rm(path, { force: true });
+  return file;
+}
+async function loadRepoSpecs(root) {
+  const files = [];
+  const problems = [];
+  const rel = factsRelOf(root);
+  for (const n of (await readdir(factsDirOf(root)).catch(() => [])).sort()) {
+    if (!n.endsWith(".specs.yaml"))
+      continue;
+    let v;
+    try {
+      v = (0, import_yaml.parse)(await readFile(join(factsDirOf(root), n), "utf8"));
+    } catch (e) {
+      problems.push(`${rel}/${n} isn't YAML (${e.message}); it is left out.`);
+      continue;
+    }
+    const p = SpecsFile.safeParse(v);
+    if (p.success)
+      files.push(p.data);
+    else
+      problems.push(`${rel}/${n} isn't a specs file; it is left out.`);
+  }
+  return { files, problems };
+}
+async function intakenSpec(root, doc, system) {
+  const body = await readFile(join(inputsDirOf(root), ...doc.path.split("/").slice(1)), "utf8").catch(() => void 0);
+  if (body === void 0)
+    return void 0;
+  const vendor = readVendorSpec(doc.path, body, system);
+  const specs = vendor ? openApiContractSpecs(vendor) : readContractSpecs(doc.path, body);
+  if (!specs.length)
+    return void 0;
+  return {
+    path: doc.path,
+    ...doc.title ? { title: doc.title } : {},
+    ...doc.version ? { version: doc.version } : {},
+    specs,
+    operations: (vendor?.operations ?? []).map((o) => ({
+      id: o.id,
+      method: o.method,
+      path: o.path,
+      fullPath: o.fullPath,
+      cite: o.cite
+    })),
+    hosts: vendor?.hosts ?? []
+  };
+}
+async function stampOf(root) {
+  const out = [];
+  const walk = async (dir, rel) => {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => void 0);
+    if (!entries)
+      return;
+    await Promise.all(entries.map(async (e) => {
+      const p = join(dir, e.name);
+      if (e.isDirectory())
+        return walk(p, `${rel}/${e.name}`);
+      const s = await stat(p).catch(() => void 0);
+      if (s)
+        out.push(`${rel}/${e.name}\0${s.size}\0${s.mtimeMs}`);
+    }));
+  };
+  const dirs = [
+    factsDirOf(root),
+    inputsDirOf(root),
+    orgPackDirOf(root),
+    questionsDirOf(root),
+    join(catalogDirOf(root), "curated")
+  ];
+  await Promise.all(dirs.map((d, i) => walk(d, String(i))));
+  return out.sort().join("\n");
+}
+var kept = /* @__PURE__ */ new Map();
+async function contractCheckOf(root) {
+  const key = resolve(root);
+  const stamp = await stampOf(root);
+  const hit = kept.get(key);
+  if (hit && hit.stamp === stamp)
+    return hit.value;
+  const value = workOutContractCheck(root);
+  kept.set(key, { stamp, value });
+  value.catch(() => {
+    if (kept.get(key)?.value === value)
+      kept.delete(key);
+  });
+  return value;
+}
+async function workOutContractCheck(root) {
+  const quiet = { out: () => void 0, err: () => void 0 };
+  const { op, inputs } = await intakeContext(root, quiet);
+  const estate = await estateFacts(root, op, "");
+  const join2 = estateJoinOf(op, estate.repos, estate.targets);
+  const { files, problems } = await loadRepoSpecs(root);
+  const systems = outsideProfileSystems(op);
+  const outside = [];
+  for (const s of systems) {
+    const docs = inputs.documents.filter((d) => d.id && SPEC_CLASSES.has(d.classification) && d.systems[0] === s.id);
+    const newestDoc = docs.find((d) => !d.supersededBy);
+    const previousDoc = newestDoc ? docs.find((d) => d.supersededBy === newestDoc.id) : void 0;
+    const newest = newestDoc ? await intakenSpec(root, newestDoc, s.id) : void 0;
+    const previous = previousDoc ? await intakenSpec(root, previousDoc, s.id) : void 0;
+    outside.push({
+      system: s.id,
+      name: s.name,
+      ...newest ? { newest } : {},
+      ...previous ? { previous } : {}
+    });
+  }
+  const repos = joinReposOf(op, estate.repos, componentRenames(estate.repos, op));
+  const run = (pick) => {
+    const specs = [];
+    const vendors = [];
+    for (const o of outside) {
+      const s = pick(o);
+      if (!s)
+        continue;
+      const sys = systems.find((x) => x.id === o.system);
+      specs.push({ system: o.system, name: o.name, specs: s.specs });
+      if (s.operations.length)
+        vendors.push({
+          system: o.system,
+          boundary: "internal",
+          names: [sys.name, ...sys.aliases],
+          hosts: [.../* @__PURE__ */ new Set([...s.hosts, ...hostAliases(sys.aliases)])],
+          operations: s.operations
+        });
+    }
+    const matched = vendors.length ? joinVendorOperations({ repos, vendors, targets: estate.targets, ...joinConventions(op) }) : { matches: [] };
+    return checkContracts({
+      repos: estate.repos,
+      join: join2,
+      specs: files,
+      outside: specs,
+      vendorMatches: matched.matches
+    });
+  };
+  const result = run((o) => o.newest);
+  const newBySystem = /* @__PURE__ */ new Map();
+  if (outside.some((o) => o.previous)) {
+    const before = run((o) => o.previous ?? o.newest);
+    for (const o of outside)
+      if (o.previous)
+        newBySystem.set(o.system, newFindings(result.findings.filter((f) => f.system === o.system), before.findings.filter((f) => f.system === o.system)));
+  }
+  return { result, notes: [...estate.notes, ...problems], outside, newBySystem };
+}
+
+export {
+  writeRepoSpecs,
+  contractCheckOf
+};