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

package/dist/chunk-MV4637YA.js

@@ -0,0 +1,174 @@
+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 {
+  setupSteps
+} from "./chunk-3WU7LVTL.js";
+import "./chunk-HR4DVO6X.js";
+import {
+  doctorChecks
+} from "./chunk-WCLAOKCH.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-LUPW4WLK.js";
+import "./chunk-NG5R2WIY.js";
+import "./chunk-6RGIM2ZH.js";
+import "./chunk-EV4TEFOD.js";
+import "./chunk-6N2GUZMZ.js";
+import "./chunk-T6ESD5KM.js";
+import {
+  changeStore
+} from "./chunk-3LU6YCSQ.js";
+import "./chunk-L7I5PKGD.js";
+import "./chunk-CAN3EBE5.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-XNRPCI23.js";
+import {
+  VERSION
+} from "./chunk-7RUMD56V.js";
+import {
+  loadRepos
+} from "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import {
+  API_VERSION,
+  catalogDirOf,
+  inputsDirOf,
+  isAdopted,
+  loadOrgPack,
+  orgPackDirOf,
+  zip
+} from "./chunk-JMOLB347.js";
+import {
+  SCHEMA_VERSION,
+  logFileOf,
+  redactText,
+  writeFileAtomic
+} from "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/support.js
+import { readdir, readFile, stat } from "node:fs/promises";
+import { arch, platform, release } from "node:os";
+import { join, resolve } from "node:path";
+var LOG_LINES = 2e3;
+function scrub(text, root) {
+  const variants = [root, root.replace(/\\/g, "/"), root.replace(/\//g, "\\")];
+  let out = text;
+  for (const v of variants)
+    if (v.length > 3)
+      out = out.split(v).join("<metarepo>");
+  return redactText(out);
+}
+async function countFiles(dir) {
+  try {
+    return (await readdir(dir, { recursive: true, withFileTypes: true })).filter((e) => e.isFile()).length;
+  } catch {
+    return 0;
+  }
+}
+async function lastLines(file, n) {
+  try {
+    const text = await readFile(file, "utf8");
+    return text.split("\n").slice(-n - 1).join("\n");
+  } catch {
+    return void 0;
+  }
+}
+async function bundleFiles(root, deps = {}) {
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const doctor = await doctorChecks(root, deps);
+  const setup = await setupSteps(root, { doctor });
+  const kinds = {};
+  for (const sub of ["generated", "curated"]) {
+    const dir = join(catalogDirOf(root), sub);
+    for (const k of await readdir(dir).catch(() => [])) {
+      if (!(await stat(join(dir, k)).catch(() => void 0))?.isDirectory())
+        continue;
+      kinds[`${sub}/${k}`] = await countFiles(join(dir, k));
+    }
+  }
+  const states = {};
+  for (const c of await changeStore(root).list().catch(() => []))
+    states[c.state] = (states[c.state] ?? 0) + 1;
+  const repos = await loadRepos(root).catch(() => []);
+  const about = {
+    atticus: VERSION,
+    catalogSchema: SCHEMA_VERSION,
+    api: API_VERSION,
+    node: process.versions.node,
+    os: { platform: platform(), release: release(), arch: arch() },
+    layout: isAdopted(root) ? "adopted" : "metarepo",
+    ai: op.runtime.ai,
+    modes: op.runtime.modes,
+    adapters: Object.fromEntries(Object.entries(op.runtime.adapters).filter(([, a]) => a).map(([k, a]) => [k, a.type])),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const counts = {
+    records: kinds,
+    changes: states,
+    repos: repos.length,
+    inputs: await countFiles(inputsDirOf(root))
+  };
+  const files = [
+    {
+      name: "README.txt",
+      text: [
+        "Atticus support bundle",
+        "",
+        "Written by `atticus support bundle` on this machine. Nothing was sent anywhere.",
+        "",
+        "What is in it:",
+        "  about.json      versions, operating system, layout, AI mode and adapter types",
+        "  doctor.json     the machine checks (atticus doctor)",
+        "  setup.json      the setup checklist",
+        "  org-pack.json   problems loading the org pack (file and message)",
+        "  counts.json     how many records, changes, repos and input files: numbers, never names",
+        "  atticus.log     the last lines of the local log, redacted",
+        "",
+        "What is not in it: catalog records, changes, org-pack files, documents, code, tokens",
+        "or passwords. Paths start at <metarepo>, and your home folder and user name are hidden.",
+        "",
+        "Read every file before you send this outside your organisation. Error messages can",
+        "name a system, change or file of yours; remove anything you can't share.",
+        ""
+      ].join("\n")
+    },
+    { name: "about.json", text: JSON.stringify(about, null, 2) },
+    { name: "doctor.json", text: JSON.stringify(doctor, null, 2) },
+    { name: "setup.json", text: JSON.stringify(setup, null, 2) },
+    { name: "org-pack.json", text: JSON.stringify(op.problems, null, 2) },
+    { name: "counts.json", text: JSON.stringify(counts, null, 2) }
+  ];
+  const log = await lastLines(logFileOf(root), LOG_LINES);
+  if (log !== void 0)
+    files.push({ name: "atticus.log", text: log });
+  return files.map((f) => ({ name: f.name, text: scrub(f.text, root) }));
+}
+async function supportBundleCommand(root, o, io, deps = {}) {
+  const now = o.now ?? /* @__PURE__ */ new Date();
+  const files = await bundleFiles(root, deps);
+  const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\..*$/, "").replace("T", "-");
+  const out = resolve(o.out ?? join(root, ".atticus", "logs", `atticus-support-${stamp}.zip`));
+  await writeFileAtomic(out, zip(files.map((f) => ({ name: f.name, data: f.text })), now));
+  if (o.json)
+    io.out(JSON.stringify({ file: out, files: files.map((f) => f.name) }, null, 2));
+  else {
+    io.out(`Wrote ${out} (${files.length} files, nothing sent anywhere):`);
+    for (const f of files)
+      io.out(`  ${f.name}`);
+    io.out("Read every file before you send it outside your organisation (README.txt says why).");
+  }
+  return 0;
+}
+export {
+  bundleFiles,
+  supportBundleCommand
+};

package/dist/chunk-MYKQVS5W.js

@@ -0,0 +1,296 @@
+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 {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  readCatalog
+} from "./chunk-IILZ7J3L.js";
+import {
+  TriageError,
+  buildTriage,
+  classify,
+  scanInputs
+} from "./chunk-WIMOJMAK.js";
+import {
+  readDrawio,
+  reconcile
+} from "./chunk-5V5BJACL.js";
+import {
+  inputsDirOf,
+  loadOrgPack,
+  orgPackDirOf,
+  recordPath,
+  serializeRecord
+} from "./chunk-JMOLB347.js";
+
+// packages/cli/dist/intake-commands.js
+import { createHash } from "node:crypto";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { userInfo } from "node:os";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+var inboxRelOf = (root) => relative(root, join(inputsDirOf(root), "inbox")).split(sep).join("/");
+async function filesUnder(dir) {
+  const out = [];
+  async function walk(d) {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries.sort((a, b) => a.name < b.name ? -1 : 1)) {
+      const full = join(d, e.name);
+      if (e.isDirectory())
+        await walk(full);
+      else if (e.isFile())
+        out.push(full);
+    }
+  }
+  await walk(dir);
+  return out;
+}
+var sha256 = (b) => createHash("sha256").update(b).digest("hex");
+var rel = (root, p) => relative(root, p).split(sep).join("/");
+async function addToInbox(root, files) {
+  const INBOX = inboxRelOf(root);
+  const inbox = join(root, ...INBOX.split("/"));
+  const known = /* @__PURE__ */ new Map();
+  for (const f of await filesUnder(inputsDirOf(root)))
+    known.set(sha256(new Uint8Array(await readFile(f))), rel(root, f));
+  const added = [];
+  const refused = [];
+  for (const { name, bytes } of files) {
+    if (!name || /[\\/]/.test(name) || name === "." || name === "..") {
+      refused.push({ name, why: "give a file name without a folder in it" });
+      continue;
+    }
+    if (bytes.length === 0) {
+      refused.push({ name, why: "it is empty" });
+      continue;
+    }
+    const hash = sha256(bytes);
+    const already = known.get(hash);
+    if (already) {
+      refused.push({ name, why: `it is already in inputs as ${already}` });
+      continue;
+    }
+    const dot = name.lastIndexOf(".");
+    const [stem, ext] = dot > 0 ? [name.slice(0, dot), name.slice(dot)] : [name, ""];
+    await mkdir(inbox, { recursive: true });
+    const taken = new Set(await readdir(inbox));
+    let target = name;
+    for (let n = 2; taken.has(target); n++)
+      target = `${stem}-${n}${ext}`;
+    await writeFile(join(inbox, target), bytes);
+    const path = `${INBOX}/${target}`;
+    known.set(hash, path);
+    added.push({ name, path, kind: classify(target, bytes).classification });
+  }
+  return { added, refused };
+}
+async function intakeAdd(root, files, io) {
+  if (files.length === 0) {
+    io.err("Name at least one file to add.");
+    return 2;
+  }
+  let problems = false;
+  let added = 0;
+  let documents = 0;
+  const ALREADY = "it is already in inputs as ";
+  for (const f of files) {
+    const src = resolve(f);
+    let bytes;
+    try {
+      bytes = new Uint8Array(await readFile(src));
+    } catch {
+      io.err(`Can't read ${f}.`);
+      problems = true;
+      continue;
+    }
+    const r = await addToInbox(root, [{ name: basename(src), bytes }]);
+    for (const x of r.refused) {
+      io.err(x.why.startsWith(ALREADY) ? `${f} is already in inputs as ${x.why.slice(ALREADY.length)}; not copied.` : `${f} wasn't copied: ${x.why}.`);
+      problems = true;
+    }
+    for (const a of r.added) {
+      const reading = a.kind === "document" || a.kind === "image" ? ", needs reading" : "";
+      io.out(`Added ${a.path} (${a.kind}${reading}).`);
+      added++;
+      if (a.kind === "document")
+        documents++;
+    }
+  }
+  if (added > 0)
+    io.out("Run atticus intake list to see what Atticus made of them.");
+  if (documents > 0)
+    io.out("To read the documents into knowledge every change can use: atticus sources sync --source inputs, then atticus knowledge scan --source inputs.");
+  return problems ? 1 : 0;
+}
+async function intakeContext(root, io) {
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const catalogDir = join(root, op.sources.layout.catalog);
+  const generated = await readCatalog(join(catalogDir, "generated"), { cacheRoot: root });
+  const curated = await readCatalog(join(catalogDir, "curated"), { cacheRoot: root });
+  for (const p of [...generated.problems, ...curated.problems])
+    io.err(`catalog ${p.file}: ${p.message}`);
+  const inputs = await scanInputs({
+    root,
+    orgPack: op,
+    records: [...generated.records, ...curated.records],
+    inputsDir: inputsDirOf(root)
+  });
+  return { op, records: generated.records, curated: curated.records, inputs };
+}
+var STATUS_WORDS = [
+  ["read", (n) => `${n} read`],
+  ["needs-reading", (n) => `${n} need${n === 1 ? "s" : ""} reading`],
+  ["no-reader", (n) => `${n} with no reader yet`],
+  ["unresolved", (n) => `${n} waiting for a system name`],
+  ["duplicate", (n) => `${n} duplicate${n === 1 ? "" : "s"}`],
+  ["superseded", (n) => `${n} older version${n === 1 ? "" : "s"}`],
+  ["failed", (n) => `${n} failed`]
+];
+function chains(docs) {
+  const byId = new Map(docs.filter((d) => d.id).map((d) => [d.id, d]));
+  const replaced = new Set(docs.flatMap((d) => d.supersededBy ? [d.supersededBy] : []));
+  const out = [];
+  for (const d of docs) {
+    if (!d.supersededBy || d.id && replaced.has(d.id))
+      continue;
+    const chain = [d.path];
+    const seen = /* @__PURE__ */ new Set([d.id]);
+    for (let next = byId.get(d.supersededBy); next && !seen.has(next.id); ) {
+      chain.push(next.path);
+      seen.add(next.id);
+      next = next.supersededBy ? byId.get(next.supersededBy) : void 0;
+    }
+    out.push(chain);
+  }
+  return out;
+}
+async function intakeList(root, io, o) {
+  const { inputs } = await intakeContext(root, io);
+  const { documents, problems } = inputs;
+  if (o.json) {
+    io.out(JSON.stringify({ documents, chains: chains(documents), problems }, null, 2));
+    return problems.length > 0 ? 1 : 0;
+  }
+  if (documents.length === 0) {
+    io.out("Nothing in inputs/ yet: drop files into inputs/inbox/, or run atticus intake add <files>.");
+    return problems.length > 0 ? 1 : 0;
+  }
+  for (const l of table(["PATH", "TYPE", "STATUS", "SYSTEMS"], documents.map((d) => [
+    d.path,
+    d.classification,
+    d.duplicateOf ? `duplicate of ${d.duplicateOf}` : d.status,
+    d.systems.join(", ")
+  ])))
+    io.out(l);
+  const ch = chains(documents);
+  if (ch.length > 0) {
+    io.out("Versions:");
+    for (const c of ch)
+      io.out(`  ${c.join(" \u2192 ")}`);
+  }
+  const counts = STATUS_WORDS.map(([s, words]) => {
+    const n = documents.filter((d) => d.status === s).length;
+    return n > 0 ? words(n) : "";
+  }).filter(Boolean);
+  io.out(`${documents.length} file${documents.length === 1 ? "" : "s"}: ${counts.join(", ")}.`);
+  for (const p of problems)
+    io.out(`  ! ${p.path}: ${p.message}`);
+  return problems.length > 0 ? 1 : 0;
+}
+async function triageOf(root, io) {
+  const { op, records, curated, inputs } = await intakeContext(root, io);
+  if (records.length === 0 && inputs.documents.length > 0)
+    io.err("The catalog is empty: run atticus scan first, or most diagram edges will look unknown.");
+  const profile = op.profiles.find((p) => p.profile)?.profile;
+  const all = [...records, ...curated];
+  const reconcileItems = [];
+  for (const d of inputs.documents.filter((x) => x.classification === "diagram" && x.status === "read" && x.reader?.startsWith("drawio@"))) {
+    const xml = await readFile(join(root, ...d.path.split("/")), "utf8");
+    reconcileItems.push({
+      file: d.path,
+      items: reconcile({
+        diagram: readDrawio(xml, profile?.legend),
+        file: d.path,
+        records: all,
+        systems: profile?.systems ?? [],
+        patterns: op.patterns
+      }).items
+    });
+  }
+  return buildTriage({ records, inputs, decisions: curated, reconcileItems, ai: op.runtime.ai });
+}
+async function triageList(root, io, o) {
+  const { items } = await triageOf(root, io);
+  if (o.json) {
+    io.out(JSON.stringify({ items }, null, 2));
+    return items.length > 0 ? 1 : 0;
+  }
+  if (items.length === 0) {
+    io.out("Nothing to triage.");
+    return 0;
+  }
+  io.out(`${items.length} item${items.length === 1 ? "" : "s"} to decide.`);
+  for (const i of items) {
+    io.out("");
+    io.out(`${i.id} (${i.kind})`);
+    io.out(`  ${i.summary}`);
+    const where = `${i.source.path}${i.source.line ? `:${i.source.line}` : ""}`;
+    io.out(`  at ${where}${i.source.cell ? ` (cell ${i.source.cell})` : ""}`);
+    i.options.forEach((opt, n) => io.out(`  ${n + 1}. ${opt.label}`));
+    if (i.next)
+      io.out(`  \u2192 ${i.next}`);
+  }
+  io.out("");
+  io.out("Decide one with: atticus triage decide <item> <option>");
+  return 1;
+}
+async function triageDecide(root, itemId, option, o, io) {
+  const t = await triageOf(root, io);
+  const item = t.items.find((i) => i.id === itemId);
+  if (!item) {
+    io.err(`There is no open triage item ${itemId}. List them with: atticus triage`);
+    return 1;
+  }
+  if (!Number.isInteger(option) || option < 1 || option > item.options.length) {
+    const n = item.options.length;
+    io.err(`${itemId} has ${n} option${n === 1 ? "" : "s"}; pick 1 to ${n}.`);
+    return 2;
+  }
+  let decision;
+  try {
+    decision = t.decide(itemId, option - 1, {
+      by: o.by ?? userInfo().username,
+      ...o.reason ? { reason: o.reason } : {}
+    });
+  } catch (e) {
+    if (e instanceof TriageError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const relPath = `${op.sources.layout.catalog}/curated/${recordPath(decision)}`;
+  const full = join(root, ...relPath.split("/"));
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(full, serializeRecord(decision), "utf8");
+  io.out(`Wrote ${relPath}: ${item.options[option - 1].label}. Commit it so everyone's triage uses it.`);
+  return 0;
+}
+
+export {
+  addToInbox,
+  intakeAdd,
+  intakeContext,
+  intakeList,
+  triageList,
+  triageDecide
+};

package/dist/chunk-MYOW3RPC.js

@@ -0,0 +1,143 @@
+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 {
+  readRound,
+  reviewedGates,
+  roundsOf
+} from "./chunk-T6ESD5KM.js";
+import {
+  changeStore,
+  liveHandoff
+} from "./chunk-3LU6YCSQ.js";
+import {
+  createAdapters
+} from "./chunk-CAN3EBE5.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-JMOLB347.js";
+
+// packages/cli/dist/digest-commands.js
+var norm = (s) => s.toLowerCase().replace(/^@/, "");
+async function buildDigest(root, user) {
+  const revise = [];
+  const blocking = [];
+  const changes = await changeStore(root).list().catch(() => []);
+  const me = norm(user);
+  for (const c of changes.sort((a, b) => a.id.localeCompare(b.id))) {
+    const h = liveHandoff(c);
+    if (h?.state === "changes-requested" && norm(h.by) === me)
+      revise.push({
+        change: c.id,
+        title: c.title,
+        phase: h.phase,
+        pr: h.pr.url,
+        openedAt: h.openedAt
+      });
+  }
+  for (const c of changes.sort((a, b) => a.id.localeCompare(b.id))) {
+    if (c.state === "archived")
+      continue;
+    const mine = norm(c.createdBy) === me || Object.values(c.owners ?? {}).some((hs) => hs.some((h) => norm(h) === me));
+    if (!mine)
+      continue;
+    let open = 0;
+    for (const gate of await reviewedGates(root, c.id)) {
+      const rounds = await roundsOf(root, c.id, gate);
+      if (!rounds.length)
+        continue;
+      const round = await readRound(root, c.id, gate, rounds.at(-1));
+      open += round.findings.filter((f) => f.finding.state === "open" && f.finding.severity === "blocking").length;
+    }
+    if (open)
+      blocking.push({ change: c.id, open });
+  }
+  const lines = [];
+  if (revise.length) {
+    lines.push(`${revise.length} hand-off${revise.length === 1 ? "" : "s"} to revise:`);
+    for (const w of revise)
+      lines.push(`- ${w.change} (${w.phase}): ${w.pr}`);
+  }
+  if (blocking.length) {
+    lines.push("Blocking findings on changes you are on:");
+    for (const b of blocking)
+      lines.push(`- ${b.change}: ${b.open} open`);
+  }
+  if (!lines.length)
+    lines.push("Nothing waits on you.");
+  const { readMe } = await import("./chunk-XJAJQGXJ.js");
+  const { watchLine } = await import("./chunk-4YWRU7JK.js");
+  const watching = [];
+  for (const c of (await readMe(root)).watch)
+    watching.push(await watchLine(root, c));
+  if (watching.length)
+    lines.push("Changes you watch:", ...watching.map((w) => `- ${w}`));
+  const n = revise.length + blocking.length;
+  return {
+    title: !n ? "Atticus: nothing waits on you" : n === 1 ? "Atticus: 1 thing waits on you" : `Atticus: ${n} things wait on you`,
+    body: lines.join("\n"),
+    lines,
+    revise,
+    blocking,
+    watching
+  };
+}
+async function digestCommand(root, o, io, deps = {}) {
+  if (!o.as) {
+    io.err("Usage: atticus digest [--as <you>] [--channel <c>] [--send] [--json]");
+    return 2;
+  }
+  const d = await buildDigest(root, o.as);
+  let sent;
+  let notSent;
+  if (o.send) {
+    let notify = deps.notify;
+    if (!notify) {
+      const op = await loadOrgPack(orgPackDirOf(root));
+      const cfg = op.runtime.adapters.notify;
+      if (!cfg)
+        notSent = "No notify adapter is set in org-pack/runtime.yaml (adapters.notify).";
+      else if (cfg.type === "manual")
+        notSent = "Notifications are manual here, so the digest is shown instead of sent.";
+      else
+        try {
+          notify = createAdapters({ adapters: { notify: cfg } }).notify;
+        } catch (e) {
+          notSent = e.message;
+        }
+    }
+    if (notify) {
+      const channel = o.channel ?? `@${o.as}`;
+      try {
+        const r = await notify.send({ channel, title: d.title, body: d.body, mentions: [o.as] }, {
+          by: o.as,
+          at: deps.now ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+          ref: `digest:${o.as}`
+        });
+        sent = { id: r.id, channel };
+      } catch (e) {
+        notSent = `The notify adapter refused: ${e.message}`;
+      }
+    }
+  }
+  if (o.json)
+    io.out(JSON.stringify({ ...d, ...sent ? { sent } : {}, ...notSent ? { notSent } : {} }, null, 2));
+  else {
+    io.out(d.title);
+    for (const l of d.lines)
+      io.out(l);
+    if (sent)
+      io.out(`Sent to ${sent.channel} (${sent.id}).`);
+    if (notSent)
+      io.err(notSent);
+  }
+  return o.send && !sent ? 1 : 0;
+}
+
+export {
+  buildDigest,
+  digestCommand
+};

package/dist/chunk-NBGBMRIS.js

@@ -0,0 +1,25 @@
+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 {
+  runtimeForCli
+} from "./chunk-BKFGGJKA.js";
+
+// packages/cli/dist/judging.js
+async function judgingRuntime(root, given) {
+  if (given === null)
+    return void 0;
+  if (given)
+    return given;
+  try {
+    return (await runtimeForCli(root)).runtime;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  judgingRuntime
+};