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

package/dist/chunk-EHVTK3UE.js

@@ -0,0 +1,116 @@
+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 {
+  diffLines
+} from "./chunk-TAVDMUV3.js";
+import "./chunk-4BMDGTED.js";
+import "./chunk-RCU3MPY2.js";
+import "./chunk-V5PKHHQQ.js";
+import "./chunk-7UFQZXZA.js";
+import "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import {
+  diffCatalogs,
+  readCatalog,
+  scanEstate,
+  writeCatalog
+} from "./chunk-OLWFG75W.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import {
+  branchSlug,
+  createWorkspace,
+  isInPlace,
+  loadRepos
+} from "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  catalogDirOf,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import {
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/branch-scan-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { join } from "node:path";
+var branchCatalogRel = (branch) => `branches/${branchSlug(branch)}`;
+var fromRepos = (records, repos) => records.filter((r) => r.evidence.some((e) => e.repo && repos.has(e.repo)));
+async function scanBranch(root, branch, o, io) {
+  const all = (await loadRepos(root)).filter((r) => !r.archived && !isInPlace(r.url));
+  const named = o.repos?.length ? all.filter((r) => o.repos.includes(r.id)) : void 0;
+  const baseline = (named ?? all).filter((r) => r.defaultBranch === branch);
+  if (baseline.length) {
+    io.err(`${branch} is the default branch of ${baseline.map((r) => r.id).join(", ")}: its catalog is the baseline. Run atticus scan for it.`);
+    return 2;
+  }
+  const repos = named ?? all.filter((r) => r.branches.includes(branch));
+  if (!repos.length) {
+    io.err(`No repo lists ${branch} under branches in its manifest. Add it there (or on Set up \u203A Repos), or name the repos: atticus scan --ref ${branch} --repos <id>,<id>.`);
+    return 2;
+  }
+  const ws = createWorkspace(root);
+  const dirs = /* @__PURE__ */ new Map();
+  const commits = [];
+  let problems = 0;
+  for (const r of repos)
+    try {
+      const c = await ws.checkoutBranch(r, branch);
+      dirs.set(r.id, c.dir);
+      commits.push({ id: r.id, commit: c.commit });
+    } catch (e) {
+      io.err(`${e.message}; it is left out of this scan.`);
+      problems++;
+    }
+  if (!dirs.size)
+    return 1;
+  const ids = [...dirs.keys()];
+  const scannedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const scan = await scanEstate({
+    root,
+    repos: ids,
+    repoDir: (id) => dirs.get(id),
+    // The branch's code only: inputs/ and other metarepos belong to the baseline.
+    inputsDir: null,
+    federated: [],
+    scannedAt,
+    ...o.full ? { cache: null } : {}
+  });
+  const rel = branchCatalogRel(branch);
+  const dir = join(catalogDirOf(root), ...rel.split("/"));
+  const write = await writeCatalog(join(dir, "generated"), scan.records);
+  await writeFileAtomic(join(dir, "branch.yaml"), (0, import_yaml.stringify)({ schemaVersion: 1, branch, scannedAt, repos: commits }));
+  const ofRepos = new Set(ids);
+  const before = await readCatalog(join(catalogDirOf(root), "generated"), { cacheRoot: root });
+  const diff = diffCatalogs(fromRepos(before.records, ofRepos), fromRepos(scan.records, ofRepos));
+  problems += scan.problems.length;
+  if (o.json) {
+    io.out(JSON.stringify({ branch, repos: commits, folder: `catalog/${rel}`, diff, problems: scan.problems }, null, 2));
+    return problems ? 1 : 0;
+  }
+  io.out(`Scanned ${branch} of ${ids.join(", ")}: ${scan.records.length} records in catalog/${rel}/generated (${write.written} written, ${write.unchanged} unchanged, ${write.removed} removed).`);
+  const lines = diffLines(diff);
+  io.out(`${branch} against the baseline: ${lines[0]}`);
+  for (const l of lines.slice(1))
+    io.out(l);
+  for (const p of scan.problems)
+    io.err(`${"repo" in p && p.repo ? `${p.repo}: ` : ""}${p.message}`);
+  io.out(`The baseline (catalog/generated) is unchanged: a branch is compared with it, never merged into it.`);
+  return problems ? 1 : 0;
+}
+export {
+  branchCatalogRel,
+  scanBranch
+};

package/dist/chunk-EPTBZ3GP.js

@@ -0,0 +1,101 @@
+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 {
+  parseFactLine
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/memory-room.js
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { freemem } from "node:os";
+import { getHeapStatistics } from "node:v8";
+var NoRoomError = class extends Error {
+  usedMB;
+  ceilingMB;
+  constructor(what, usedMB, ceilingMB) {
+    super(`${what} need more memory than Node was given: ${usedMB} MB of the ${ceilingMB} MB ceiling is in use. Run it again with ATTICUS_MAX_OLD_SPACE=${Math.max(4096, ceilingMB * 2)} (megabytes Node may use for the heap), or in parts, a repo at a time. Closing an IDE frees the memory this needs.`);
+    this.name = "NoRoomError";
+    this.usedMB = usedMB;
+    this.ceilingMB = ceilingMB;
+  }
+};
+var MB = 1024 * 1024;
+var SHARE = 0.8;
+function ceilingOf(env = process.env) {
+  const heap = getHeapStatistics().heap_size_limit;
+  const asked = Number(env.ATTICUS_MAX_OLD_SPACE);
+  const limit = Number.isFinite(asked) && asked > 0 ? Math.min(heap, asked * MB) : heap;
+  const free = freemem();
+  return free > 0 ? Math.min(limit, free + process.memoryUsage.rss()) : limit;
+}
+function roomGuard(o) {
+  const ceiling = o.ceilingBytes ?? ceilingOf();
+  const every = o.every ?? 32;
+  const used = o.used ?? (() => process.memoryUsage.rss());
+  const bar = ceiling * SHARE;
+  let n = 0;
+  return () => {
+    if (n++ % every !== 0)
+      return;
+    const now = used();
+    if (now <= bar)
+      return;
+    throw new NoRoomError(o.what, Math.round(now / MB), Math.max(1, Math.round(ceiling / MB)));
+  };
+}
+function maxOldSpaceIn(args) {
+  for (const a of args) {
+    const m = /^--max[-_]old[-_]space[-_]size[= ](\d+)$/.exec(a.trim());
+    if (m)
+      return Number(m[1]);
+  }
+  return void 0;
+}
+function reExecForMemory(env, execArgv) {
+  if (env.ATTICUS_RESTARTED_FOR_MEMORY)
+    return void 0;
+  const mb = Number(env.ATTICUS_MAX_OLD_SPACE);
+  if (!Number.isInteger(mb) || mb < 256 || mb > 1048576)
+    return void 0;
+  const already = [
+    maxOldSpaceIn(execArgv),
+    maxOldSpaceIn((env.NODE_OPTIONS ?? "").split(/\s+/))
+  ].filter((n) => n !== void 0);
+  if (already.length && Math.max(...already) >= mb)
+    return void 0;
+  return { maxOldSpaceMB: mb };
+}
+async function streamFacts(file, room) {
+  const facts = [];
+  const bad = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = createInterface({
+    input: createReadStream(file, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  let line = 0;
+  try {
+    for await (const raw of lines) {
+      room?.();
+      const r = parseFactLine(raw, ++line, seen);
+      if (r.fact)
+        facts.push(r.fact);
+      else if (r.bad)
+        bad.push(r.bad);
+    }
+  } finally {
+    lines.close();
+  }
+  return { facts, bad };
+}
+
+export {
+  NoRoomError,
+  ceilingOf,
+  roomGuard,
+  reExecForMemory,
+  streamFacts
+};