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

package/dist/chunk-T6DQR5TV.js

@@ -0,0 +1,323 @@
+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-SFUP7TTO.js";
+import {
+  headCommitOf
+} from "./chunk-7FTTA3HD.js";
+import {
+  denyHashesAt
+} from "./chunk-ZQ3ON2VQ.js";
+import {
+  componentRenames,
+  estateFacts,
+  estateJoinOf,
+  hostAliases,
+  joinReposOf,
+  outsideProfileSystems
+} from "./chunk-J2JAKCIW.js";
+import {
+  sameCommit
+} from "./chunk-CXJ6FUKN.js";
+import {
+  openApiContractSpecs,
+  readContractSpecs,
+  readRepoSpecs,
+  readVendorSpec
+} from "./chunk-QKUJMING.js";
+import {
+  VERSION
+} from "./chunk-F3P7N7SF.js";
+import {
+  createGit
+} from "./chunk-PKBHS4AA.js";
+import {
+  SpecsFile,
+  catalogDirOf,
+  checkContracts,
+  factsDirOf,
+  factsRelOf,
+  inputsDirOf,
+  joinConventions,
+  joinVendorOperations,
+  newFindings,
+  orgPackDirOf,
+  questionsDirOf
+} from "./chunk-Q2TECDIT.js";
+import {
+  writeFileAtomic
+} from "./chunk-TUULXQRW.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/contract-check-files.js
+var import_yaml = __toESM(require_dist(), 1);
+import { createHash } from "node:crypto";
+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();
+var cacheFileOf = (root, name) => join(resolve(root), ".atticus", "cache", `${name}.json`);
+var stampKey = (stamp) => createHash("sha256").update(VERSION).update("\0").update(stamp).digest("hex");
+async function readCached(root, name, stamp) {
+  try {
+    const c = JSON.parse(await readFile(cacheFileOf(root, name), "utf8"));
+    return c.key === stampKey(stamp) ? c.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function writeCached(root, name, stamp, value) {
+  await writeFileAtomic(cacheFileOf(root, name), JSON.stringify({ key: stampKey(stamp), value })).catch(() => void 0);
+}
+var breathe = () => new Promise((r) => setImmediate(r));
+async function estateJoinOnFile(root, op, estate, stamp) {
+  const at = stamp ?? await stampOf(root);
+  const hit = await readCached(root, "estate-join", at);
+  if (hit)
+    return hit;
+  await breathe();
+  const join2 = estateJoinOf(op, estate.repos, estate.targets, estate.pairs, estate.aiTargets);
+  await writeCached(root, "estate-join", at, join2);
+  return join2;
+}
+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 = (async () => {
+    const disk = await readCached(root, "contract-check", stamp);
+    if (disk)
+      return { ...disk, newBySystem: new Map(disk.newBySystem) };
+    const v = await workOutContractCheck(root, stamp);
+    await writeCached(root, "contract-check", stamp, {
+      ...v,
+      newBySystem: [...v.newBySystem]
+    });
+    return v;
+  })();
+  kept.set(key, { stamp, value });
+  value.catch(() => {
+    if (kept.get(key)?.value === value)
+      kept.delete(key);
+  });
+  return value;
+}
+async function workOutContractCheck(root, stamp) {
+  const quiet = { out: () => void 0, err: () => void 0 };
+  const { op, inputs } = await intakeContext(root, quiet);
+  const estate = await estateFacts(root, op, "");
+  const join2 = await estateJoinOnFile(root, op, estate, stamp);
+  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
+    });
+  };
+  await breathe();
+  const result = run((o) => o.newest);
+  const newBySystem = /* @__PURE__ */ new Map();
+  if (outside.some((o) => o.previous)) {
+    await breathe();
+    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,
+  stampOf,
+  estateJoinOnFile,
+  contractCheckOf
+};