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

package/dist/chunk-2DIQQJCB.js

@@ -0,0 +1,378 @@
+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 {
+  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";
+import {
+  houseDependencies,
+  learnFramework,
+  learnFrameworkFromJar,
+  learnJsFramework,
+  learnJsFrameworkFromTarball,
+  runFrameworkTests
+} from "./chunk-MC3H7736.js";
+import {
+  baseClonePath
+} from "./chunk-EFHQ3TWP.js";
+import {
+  fsRepo
+} from "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  FrameworkModel,
+  RecordId,
+  loadOrgPack,
+  orgPackDirOf,
+  require_dist,
+  toCanonicalYaml
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/framework-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function merge(existing, learned) {
+  if (!existing)
+    return { model: learned, keptServices: 0, keptOther: 0 };
+  const byName = (a, b) => [
+    ...b,
+    ...a.filter((x) => !b.some((y) => y.name === x.name))
+  ];
+  const clientKey = (c) => `${c.type}.${c.method}`;
+  const clients = [
+    ...learned.clients,
+    ...existing.clients.filter((c) => !learned.clients.some((l) => clientKey(l) === clientKey(c)))
+  ];
+  const callKey = (c) => `${c.function}|${c.receiver ?? ""}`;
+  const calls = [
+    ...learned.calls,
+    ...existing.calls.filter((c) => !learned.calls.some((l) => callKey(l) === callKey(c)))
+  ];
+  const routes = [
+    ...learned.routes,
+    ...existing.routes.filter((c) => !learned.routes.some((l) => callKey(l) === callKey(c)))
+  ];
+  const keptServices = Object.keys(existing.services).filter((k) => !(k in learned.services));
+  const keptOther = existing.annotations.filter((a) => !learned.annotations.some((l) => l.name === a.name)).length + (clients.length - learned.clients.length) + (calls.length - learned.calls.length) + (routes.length - learned.routes.length) + Object.keys(existing.constants).filter((k) => !(k in learned.constants)).length;
+  return {
+    model: FrameworkModel.parse({
+      ...learned,
+      packages: [.../* @__PURE__ */ new Set([...learned.packages, ...existing.packages])],
+      artifacts: [.../* @__PURE__ */ new Set([...learned.artifacts, ...existing.artifacts])],
+      annotations: byName(existing.annotations, learned.annotations).sort((a, b) => a.name < b.name ? -1 : 1),
+      clients,
+      calls,
+      routes,
+      services: { ...existing.services, ...learned.services },
+      constants: { ...existing.constants, ...learned.constants },
+      tests: existing.tests
+    }),
+    keptServices: keptServices.length,
+    keptOther
+  };
+}
+async function frameworksLearn(root, name, from, o, io) {
+  if (!RecordId.safeParse(name).success) {
+    io.err(`"${name}" isn't a framework name: use lower case, digits and dashes, e.g. tide-platform`);
+    return 2;
+  }
+  const dir = resolve(from);
+  const info = await stat(dir).catch(() => void 0);
+  const isJar = !!info?.isFile() && /\.jar$/i.test(dir);
+  const isTgz = !!info?.isFile() && /\.(tgz|tar\.gz)$/i.test(dir);
+  if (!info?.isDirectory() && !isJar && !isTgz) {
+    io.err(`${from} isn't a folder, a .jar or a .tgz: give the framework's source, its JAR or its npm package, e.g. --from workspace/tide-platform`);
+    return 2;
+  }
+  const opts = { name, ...o.packages?.length ? { packages: o.packages } : {} };
+  let learned;
+  try {
+    const repo = () => fsRepo(basename(dir), dir, "0".repeat(40));
+    learned = isJar ? learnFrameworkFromJar(await readFile(dir), { ...opts, jarName: basename(dir) }) : isTgz ? await learnJsFrameworkFromTarball(await readFile(dir), {
+      ...opts,
+      tarballName: basename(dir)
+    }) : await isJsPackage(dir) ? await learnJsFramework(repo(), opts) : await learnFramework(repo(), opts);
+  } catch (e) {
+    io.err(`${from} couldn't be read: ${e.message}`);
+    return 1;
+  }
+  return writeLearned(root, name, learned, basename(dir), isJar, !!o.dryRun, io);
+}
+async function isJsPackage(dir) {
+  const has = async (f) => !!(await stat(join(dir, f)).catch(() => void 0))?.isFile();
+  return await has("package.json") && !await has("pom.xml") && !await has("build.gradle") && !await has("build.gradle.kts");
+}
+async function writeLearned(root, name, learned, from, isJar, dryRun, io) {
+  const rel = `org-pack/frameworks/${name}.yaml`;
+  const file = join(orgPackDirOf(root), "frameworks", `${name}.yaml`);
+  let existing;
+  try {
+    existing = FrameworkModel.parse((0, import_yaml.parse)(await readFile(file, "utf8")));
+  } catch (e) {
+    if (e.code !== "ENOENT") {
+      io.err(`${rel} isn't a valid framework model (${e.message.split("\n")[0]}); fix or remove it first.`);
+      return 1;
+    }
+  }
+  const { model, keptServices, keptOther } = merge(existing, learned.model);
+  const m = learned.model;
+  const parts = m.calls.length + m.routes.length > 0 ? [plural(m.calls.length, "call"), plural(m.routes.length, "route")] : [plural(m.annotations.length, "annotation"), plural(m.clients.length, "wrapper method")];
+  const what = `${parts.join(", ")}, ${plural(Object.keys(m.constants).length, "constant")} (all from ${isJar ? "bytecode" : "code"})`;
+  const keptParts = [
+    ...keptServices ? [plural(keptServices, "service")] : [],
+    ...keptOther ? [plural(keptOther, "other entry", "other entries")] : []
+  ];
+  const keptText = keptParts.length ? `; kept ${keptParts.join(" and ")} a person added` : "";
+  if (dryRun) {
+    io.out(`Dry run: would write ${rel} from ${from}: ${what}${keptText}.`);
+  } else {
+    await mkdir(join(orgPackDirOf(root), "frameworks"), { recursive: true });
+    await writeFile(file, toCanonicalYaml(model, ["schemaVersion", "name"]), "utf8");
+    io.out(`Wrote ${rel} from ${from}: ${what}${keptText}.`);
+  }
+  for (const n of learned.notes)
+    io.out(`note: ${n}`);
+  if (m.annotations.length + m.clients.length + m.calls.length + m.routes.length === 0)
+    io.out("note: nothing in it reads as an annotation, a client, a call or a route the scanner knows; check --from is the framework's source or package.");
+  return 0;
+}
+var npmName = (d) => d.group.startsWith("@") ? `${d.group}/${d.artifact}` : d.artifact;
+var tgzBase = (name) => name.replace(/^@/, "").replace("/", "-");
+var bare = (v) => v.replace(/^[\^~>=<v\s]+/, "");
+async function findPackage(name, version, o) {
+  const file = `${tgzBase(name)}-${bare(version)}.tgz`;
+  for (const dir of o.dirs) {
+    const hit = join(resolve(dir), file);
+    if ((await stat(hit).catch(() => void 0))?.isFile())
+      return hit;
+  }
+  for (const c of o.clones) {
+    const dir = join(c, "node_modules", ...name.split("/"));
+    if ((await stat(join(dir, "package.json")).catch(() => void 0))?.isFile())
+      return dir;
+  }
+  return void 0;
+}
+async function findJar(d, o) {
+  const file = `${d.artifact}-${d.version}.jar`;
+  const search = async (dir, depth) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return void 0;
+    }
+    for (const e of entries.sort((a, b) => a.name < b.name ? -1 : 1))
+      if (e.isFile() && e.name === file)
+        return join(dir, e.name);
+    if (depth > 0) {
+      for (const e of entries)
+        if (e.isDirectory()) {
+          const hit = await search(join(dir, e.name), depth - 1);
+          if (hit)
+            return hit;
+        }
+    }
+    return void 0;
+  };
+  for (const dir of o.jars) {
+    const hit = await search(resolve(dir), 6);
+    if (hit)
+      return hit;
+  }
+  const m2 = join(o.home, ".m2", "repository", ...d.group.split("."), d.artifact, d.version, file);
+  if ((await stat(m2).catch(() => void 0))?.isFile())
+    return m2;
+  return search(join(o.home, ".gradle", "caches", "modules-2", "files-2.1", d.group, d.artifact, d.version), 1);
+}
+var byVersion = (a, b) => {
+  const pa = a.split(/[.-]/);
+  const pb = b.split(/[.-]/);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const x = pa[i] ?? "";
+    const y = pb[i] ?? "";
+    const nx = Number(x);
+    const ny = Number(y);
+    const c = !Number.isNaN(nx) && !Number.isNaN(ny) ? ny - nx : y.localeCompare(x);
+    if (c !== 0)
+      return c;
+  }
+  return 0;
+};
+async function frameworksDiscover(root, o, io) {
+  if (o.groups.length === 0) {
+    io.err("frameworks discover needs your house group, for example: atticus frameworks discover --group tide.platform");
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const repos = op.profiles.flatMap((p) => (p.repos?.repos ?? []).filter((r) => !r.archived));
+  const used = /* @__PURE__ */ new Map();
+  const missing = [];
+  const clones = [];
+  for (const r of repos) {
+    const dir = baseClonePath(root, r.id);
+    if (!(await stat(dir).catch(() => void 0))?.isDirectory()) {
+      missing.push(r.id);
+      continue;
+    }
+    clones.push(dir);
+    for (const d of await houseDependencies(fsRepo(r.id, dir, "0".repeat(40)), o.groups)) {
+      const npm = d.ecosystem === "npm";
+      const k = npm ? npmName(d) : `${d.group}:${d.artifact}`;
+      const u = used.get(k) ?? {
+        group: d.group,
+        artifact: d.artifact,
+        npm,
+        versions: /* @__PURE__ */ new Map()
+      };
+      const v = d.version ?? "(managed)";
+      u.versions.set(v, (u.versions.get(v) ?? /* @__PURE__ */ new Set()).add(r.id));
+      used.set(k, u);
+    }
+  }
+  const home = o.home ?? homedir();
+  const rows = [];
+  for (const [k, u] of [...used].sort(([a], [b]) => a < b ? -1 : 1)) {
+    const versions = [...u.versions.keys()].filter((v) => v !== "(managed)").sort(byVersion);
+    let jar;
+    let version;
+    for (const v of versions) {
+      jar = u.npm ? await findPackage(k, v, { dirs: o.jars ?? [], clones }) : await findJar({ group: u.group, artifact: u.artifact, version: v }, { jars: o.jars ?? [], home });
+      if (jar) {
+        version = v;
+        break;
+      }
+    }
+    rows.push({
+      artifact: k,
+      npm: u.npm,
+      versions: [...u.versions].map(([version2, rs]) => ({ version: version2, repos: [...rs].sort() })),
+      ...jar ? { jar, version } : {}
+    });
+  }
+  if (o.json)
+    io.out(JSON.stringify({
+      artifacts: rows.map(({ npm, ...r }) => ({ ...r, ...npm ? { ecosystem: "npm" } : {} })),
+      notCloned: missing
+    }, null, 2));
+  else {
+    if (rows.length === 0)
+      io.out(`No repo here declares an artifact of ${o.groups.join(", ")}.`);
+    for (const r of rows) {
+      io.out(`${r.artifact}: ${r.versions.map((v) => `${v.version} in ${v.repos.join(", ")}`).join("; ")}`);
+      const [g, a] = r.artifact.split(":");
+      const wanted = r.versions.find((v) => v.version !== "(managed)")?.version;
+      if (r.npm) {
+        io.out(r.jar ? `  Package: ${r.jar}` : `  Package: not on this machine. Put ${tgzBase(r.artifact)}-${bare(wanted ?? "<version>")}.tgz (npm pack, or from your registry) in a folder and pass --jars <folder>; ${r.artifact} isn't downloaded.`);
+        continue;
+      }
+      io.out(r.jar ? `  JAR: ${r.jar}` : `  JAR: not on this machine. Put ${a}-${wanted ?? "<version>"}.jar (from your artifact repository) in a folder and pass --jars <folder>; ${g}:${a} isn't downloaded.`);
+    }
+    if (missing.length)
+      io.out(`Not cloned here, so not read: ${missing.join(", ")} (atticus workspace sync).`);
+  }
+  if (!o.learn)
+    return 0;
+  let code = 0;
+  for (const r of rows.filter((x) => x.jar)) {
+    const name = r.npm ? tgzBase(r.artifact) : r.artifact.split(":")[1];
+    try {
+      const isTgz = /\.t(ar\.)?gz$/i.test(r.jar);
+      const learned = !r.npm ? learnFrameworkFromJar(await readFile(r.jar), { name, jarName: basename(r.jar) }) : isTgz ? await learnJsFrameworkFromTarball(await readFile(r.jar), {
+        name,
+        tarballName: basename(r.jar)
+      }) : await learnJsFramework(fsRepo(name, r.jar, "0".repeat(40)), { name });
+      code = Math.max(code, await writeLearned(root, name, learned, basename(r.jar), !r.npm, false, io));
+    } catch (e) {
+      io.err(`${r.jar} couldn't be read: ${e.message}`);
+      code = 1;
+    }
+  }
+  return code;
+}
+async function frameworksCheck(root, name, io) {
+  const op = await loadOrgPack(orgPackDirOf(root));
+  let bad = 0;
+  for (const p of op.problems.filter((x) => x.file.startsWith("frameworks/"))) {
+    io.err(`org-pack/${p.file}: ${p.path ? `${p.path}: ` : ""}${p.message}`);
+    bad++;
+  }
+  const models = op.frameworks.filter((m) => !name || m.name === name);
+  if (name && models.length === 0) {
+    io.err(`There's no framework model named ${name} in org-pack/frameworks/ (or it isn't valid; see above).`);
+    return 2;
+  }
+  if (models.length === 0 && bad === 0) {
+    io.out("There are no framework models in org-pack/frameworks/ yet: atticus frameworks learn or frameworks kit makes one.");
+    return 0;
+  }
+  for (const m of models) {
+    if (m.tests.length === 0) {
+      io.out(`${m.name}: no tests. Scans use it as written; add tests so a wrong entry can't go unnoticed.`);
+      continue;
+    }
+    const failures = await runFrameworkTests(m);
+    if (failures.length === 0) {
+      io.out(`${m.name}: ${plural(m.tests.length, "test")} ${m.tests.length === 1 ? "passes" : "pass"}; every drafted entry is exercised.`);
+      continue;
+    }
+    bad++;
+    for (const f of failures)
+      io.err(`${m.name}: test "${f.test}": ${f.message}`);
+    io.err(`${m.name} isn't used by scans until its tests pass.`);
+  }
+  return bad > 0 ? 1 : 0;
+}
+async function frameworksSurvey(root, o, io) {
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const handles = [];
+  const missing = [];
+  for (const r of op.profiles.flatMap((p) => (p.repos?.repos ?? []).filter((x) => !x.archived))) {
+    const dir = baseClonePath(root, r.id);
+    if ((await stat(dir).catch(() => void 0))?.isDirectory())
+      handles.push(fsRepo(r.id, dir, "0".repeat(40)));
+    else
+      missing.push(r.id);
+  }
+  const survey = await surveyFrameworks(handles, {
+    prefixes: o.prefixes,
+    models: op.frameworks
+  });
+  if (o.json) {
+    io.out(JSON.stringify({ ...survey, notCloned: missing }, null, 2));
+    return 0;
+  }
+  for (const l of formatFrameworkSurvey(survey))
+    io.out(l);
+  if (missing.length)
+    io.out(`Not cloned, so not surveyed: ${missing.sort().join(", ")} (atticus workspace sync clones them).`);
+  return 0;
+}
+async function frameworksKit(outDir, io) {
+  const files = await exportFrameworksKit(outDir);
+  io.out(`Wrote the framework-model kit (${plural(files.length, "file")}) to ${outDir}`);
+  return 0;
+}
+export {
+  frameworksCheck,
+  frameworksDiscover,
+  frameworksKit,
+  frameworksLearn,
+  frameworksSurvey
+};