@maycombhq/atticus 2.0.0-beta.23 → 2.0.0-beta.25

package/dist/chunk-WGOQZ4PQ.js

@@ -0,0 +1,488 @@
+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 {
+  appendLines
+} from "./chunk-7F4GZ7U2.js";
+import {
+  readCorrections
+} from "./chunk-XP5DF5MC.js";
+import {
+  HttpError,
+  badRequest,
+  notFound
+} from "./chunk-QSKY7FE3.js";
+import {
+  applyCorrections,
+  correctedFact,
+  correctionFor,
+  outsidePairingFor,
+  repairFormSlips
+} from "./chunk-CGVRLQAY.js";
+import {
+  loadRepos
+} from "./chunk-WS7KBKP4.js";
+import {
+  FACT_FIXED_FIELDS,
+  FactCorrection,
+  FactId,
+  api_exports,
+  correctionLine,
+  factsDirOf,
+  factsRelOf,
+  listQuestions,
+  parseAuditFile,
+  parseCorrections,
+  parseFactsLines,
+  questionsDirOf,
+  sampleConfirmed
+} from "./chunk-GLISHJ4G.js";
+import {
+  LockHeldError,
+  withSharedFileLock,
+  writeFileAtomic
+} from "./chunk-G3ZFEHCX.js";
+
+// packages/cli/dist/ui-api-facts.js
+import { mkdir, readdir as readdir2, readFile, rm } from "node:fs/promises";
+
+// packages/cli/dist/file-memo.js
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+var kept = /* @__PURE__ */ new Map();
+async function stampOf(paths) {
+  const parts = await Promise.all(paths.map((p) => stat(p).then((s) => `${s.size}:${s.mtimeMs}`, () => "-")));
+  return parts.join("|");
+}
+var asking = /* @__PURE__ */ new Map();
+function memoByFiles(key, paths, work, o = {}) {
+  const on = asking.get(key);
+  if (on)
+    return on;
+  const p = memoOnce(key, paths, work, o).finally(() => {
+    if (asking.get(key) === p)
+      asking.delete(key);
+  });
+  asking.set(key, p);
+  return p;
+}
+async function memoOnce(key, paths, work, o) {
+  const hit = kept.get(key);
+  if (hit && o.recheckAfterMs && Date.now() - hit.checked < o.recheckAfterMs)
+    return hit.value;
+  const stamp = await stampOf(typeof paths === "function" ? await paths() : paths);
+  if (hit && hit.stamp === stamp) {
+    hit.checked = Date.now();
+    return hit.value;
+  }
+  const value = work();
+  kept.set(key, { stamp, value, checked: Date.now() });
+  value.catch(() => {
+    if (kept.get(key)?.value === value)
+      kept.delete(key);
+  });
+  return value;
+}
+async function filesIn(dir) {
+  const names = await readdir(dir).catch(() => []);
+  return [dir, ...names.sort().map((n) => join(dir, n))];
+}
+async function filesUnder(dir) {
+  const out = [dir];
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  for (const e of entries.sort((a, b) => a.name < b.name ? -1 : 1)) {
+    const p = join(dir, e.name);
+    if (e.isDirectory())
+      out.push(...await filesUnder(p));
+    else
+      out.push(p);
+  }
+  return out;
+}
+function recheckNow(key) {
+  const hit = kept.get(key);
+  if (hit)
+    hit.checked = 0;
+}
+
+// packages/cli/dist/ui-api-facts.js
+import { join as join2 } from "node:path";
+var REPO = /^[a-z0-9][a-z0-9._-]{0,99}$/i;
+var fixed = new Set(FACT_FIXED_FIELDS);
+function factLabel(f) {
+  switch (f.kind) {
+    case "entry":
+      return `${f.method ? `${f.method} ` : ""}${f.path}`;
+    case "call":
+      return `${f.method ? `${f.method} ` : ""}${f.path}${f.to ? ` \u2192 ${f.to}` : ""}`;
+    case "store":
+      return `${f.name} (${f.op})`;
+    case "field":
+      return `${f.name}${f.type ? `: ${f.type}` : ""}`;
+    case "deploy":
+      return `${f.platform}${f.resourceName ? ` ${f.resourceName}` : ""}`;
+    case "config":
+      return `${f.key}${f.value !== void 0 ? ` = ${f.value}` : ""}`;
+    // ADR 0124 addendum A-framework: what the repo or the module is built on.
+    case "framework":
+      return `${f.name}${f.version ? ` ${f.version}` : ""}`;
+    case "flow":
+      return f.name;
+    // ADR 0163: a term of the organisation's, with the role a note gave it.
+    case "term":
+      return `${f.term} ${f.value} (${f.role})`;
+    // ADR 0180: what a component is.
+    case "component":
+      return `${f.component ?? f.repo} is a ${f.type}`;
+    // ADR 0192: what a component's build publishes, and what it builds on.
+    case "artifact":
+      return `publishes ${f.group}:${f.name}${f.version ? `:${f.version}` : ""}`;
+    case "dependency":
+      return `builds on ${f.group}:${f.name}${f.version ? `:${f.version}` : ""}${f.scope && f.scope !== "compile" ? ` (${f.scope})` : ""}`;
+  }
+}
+function claimOf(f) {
+  const out = {};
+  for (const [k, v] of Object.entries(f))
+    if (!fixed.has(k) && typeof v === "string")
+      out[k] = v;
+  out.value = f.cite.value;
+  return out;
+}
+var spot = (c) => ({
+  file: c.file,
+  line: c.line,
+  value: c.value,
+  ...c.quote ? { quote: c.quote } : {}
+});
+async function readFacts(root, repo) {
+  const file = `${factsRelOf(root)}/${repo}.jsonl`;
+  const text = await readFile(join2(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return { file, present: false, facts: [], bad: [] };
+  const read = parseFactsLines(text);
+  const p = repairFormSlips(read.facts, read.bad);
+  return {
+    file,
+    present: true,
+    facts: p.facts,
+    bad: [
+      ...p.slips.map((x) => ({
+        file,
+        message: `slip of form fixed as read (a note; atticus verify ${repo} writes the fix into the facts file): ${x.message}`
+      })),
+      ...p.bad.map((b) => ({
+        file,
+        message: `line ${b.line} isn't a fact: ${b.issues.map((i) => i.message).join("; ")}`
+      }))
+    ]
+  };
+}
+async function repoFactsView(root, repo) {
+  const dir = factsDirOf(root);
+  return memoByFiles(`facts-view\0${root}\0${repo}`, [
+    ...[`${repo}.jsonl`, `${repo}.corrections.jsonl`, `${repo}.audit.yaml`].map((f) => join2(dir, f)),
+    // Its open questions are part of the view.
+    ...await filesIn(questionsDirOf(root))
+  ], () => repoFactsViewNow(root, repo));
+}
+async function repoFactsViewNow(root, repo) {
+  const f = await readFacts(root, repo);
+  const cFile = `${factsRelOf(root)}/${repo}.corrections.jsonl`;
+  const c = await readCorrections(root, repo);
+  const problems = [
+    ...f.bad,
+    ...c.bad.map((b) => ({
+      file: cFile,
+      message: `line ${b.line} isn't a correction: ${b.message}`
+    }))
+  ];
+  const auditText = await readFile(join2(factsDirOf(root), `${repo}.audit.yaml`), "utf8").catch(() => void 0);
+  const audit = auditText === void 0 ? void 0 : parseAuditFile(auditText);
+  const sampled = sampleConfirmed(audit?.ok ? audit.file : void 0, f.facts);
+  if (audit && !audit.ok)
+    problems.push({
+      file: `${factsRelOf(root)}/${repo}.audit.yaml`,
+      message: `isn't an audit file: ${audit.issues[0] ?? "invalid"}`
+    });
+  const facts = f.facts.map((x) => {
+    const corr = correctionFor(x, c.corrections) ?? outsidePairingFor(x, c.corrections);
+    return {
+      id: x.id,
+      kind: x.kind,
+      label: factLabel(x),
+      claim: claimOf(x),
+      cite: spot(x.cite),
+      ...x.kind === "flow" ? {
+        steps: [
+          ...x.steps.map((s) => ({ ...spot(s.cite), what: s.what })),
+          ...x.errors.map((e) => ({ ...spot(e.cite), what: `${e.when} \u2192 ${e.then}` }))
+        ]
+      } : {},
+      verified: x.verified === "line" && sampled.has(x.id) ? "sample" : x.verified,
+      by: x.by,
+      ...corr ? { correction: corr } : {}
+    };
+  });
+  const staleAll = applyCorrections(f.facts, c.corrections).stale;
+  const stale = staleAll.filter((s) => s.why === "none").map((s) => s.correction.fact);
+  for (const s of staleAll)
+    if (s.why === "invalid")
+      problems.push({ file: cFile, message: s.message });
+  const questions = await listQuestions(root, { repo, state: "open" }).then((l) => l.questions.map((q) => ({ id: q.id, question: q.question, evidence: q.evidence })), () => []);
+  return {
+    repo,
+    file: f.file,
+    present: f.present,
+    ...f.facts[0] ? { commit: f.facts[0].commit } : {},
+    facts,
+    corrections: { file: cFile, count: c.corrections.length, stale: [...new Set(stale)].sort() },
+    questions,
+    verify: `atticus verify ${repo}`,
+    problems
+  };
+}
+var repoOf = (v) => {
+  if (!REPO.test(v))
+    throw badRequest(`${JSON.stringify(v)} isn't a repo name.`);
+  return v;
+};
+function correctionOfRequest(f, req, user, at) {
+  const fact = f.facts.find((x) => x.id === req.fact);
+  if (!fact)
+    throw notFound(`${f.file} has no fact ${req.fact}.`);
+  const was = claimOf(fact);
+  const set = Object.fromEntries(Object.entries(req.set ?? {}).map(([k, v]) => [k, v.trim()]).filter(([k, v]) => was[k] !== v));
+  const line = req.line !== void 0 && req.line !== fact.cite.line ? req.line : void 0;
+  const c = FactCorrection.safeParse({
+    schemaVersion: 1,
+    fact: fact.id,
+    target: {
+      kind: fact.kind,
+      file: fact.cite.file,
+      line: fact.cite.line,
+      value: fact.cite.value
+    },
+    action: req.action,
+    ...req.action === "edit" && Object.keys(set).length ? { set } : {},
+    ...req.action === "edit" && line !== void 0 ? { line } : {},
+    ...req.reason ? { reason: req.reason } : {},
+    by: user,
+    at: at.toISOString()
+  });
+  if (!c.success)
+    throw new HttpError(422, "Atticus can't record that", c.error.issues.map((i) => i.message).join("; "));
+  if (c.data.action === "edit") {
+    const fixedFact = correctedFact(fact, c.data);
+    if (typeof fixedFact === "string")
+      throw new HttpError(422, "That isn't a fact", `The corrected ${fact.kind} isn't one: ${fixedFact}.`);
+  }
+  return { c: c.data, fact };
+}
+var saysOf = (c) => JSON.stringify([
+  c.action,
+  Object.entries(c.set ?? {}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0),
+  c.line ?? null,
+  c.reason ?? null
+]);
+var LINK_CORRECTIONS_MAX_BODY = 16 * 1024 * 1024;
+var holdingAll = (files, work, o = {}) => files.length ? withSharedFileLock(files[0], () => holdingAll(files.slice(1), work, o), o) : work();
+async function repoSpellings(root) {
+  const byLower = /* @__PURE__ */ new Map();
+  const add = (n) => {
+    const k = n.toLowerCase();
+    byLower.set(k, (byLower.get(k) ?? /* @__PURE__ */ new Set()).add(n));
+  };
+  const manifests = /* @__PURE__ */ new Map();
+  for (const r of await loadRepos(root).catch(() => []))
+    manifests.set(r.id.toLowerCase(), r.id);
+  for (const n of await readdir2(factsDirOf(root)).catch(() => []))
+    if (n.endsWith(".jsonl") && !/\.(corrections|rejected|reviewed|questions)\.jsonl$/.test(n))
+      add(n.slice(0, -6));
+  return (name) => {
+    const k = name.toLowerCase();
+    const same = [...byLower.get(k) ?? []].sort();
+    const manifest = manifests.get(k);
+    if (!same.length && manifest)
+      return manifest;
+    if (!same.length)
+      throw notFound(`No repo of the estate is named ${name}.`);
+    if (same.length > 1)
+      throw new HttpError(422, "Atticus can't tell which repo that is", `The facts files spell ${same.join(", ")}, which differ only by case: one repo where case is ignored. Rename one (and its facts files) so each repo is spelt one way.`, { written: [] });
+    return same[0];
+  };
+}
+function uiFactsRoutes(r, ctx, deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const write = deps.write ?? writeFileAtomic;
+  return r.add("GET", "/api/facts/{repo}", async ({ params }) => ({
+    status: 200,
+    body: await repoFactsView(ctx.root, repoOf(params.repo))
+  })).add("GET", "/api/facts/{repo}/preview", async ({ params, query }) => {
+    const repo = repoOf(params.repo);
+    const fact = query.get("fact") || void 0;
+    if (fact && !FactId.safeParse(fact).success)
+      throw badRequest(`${JSON.stringify(fact)} isn't a fact id.`);
+    const { verifyWritePreview } = await import("./chunk-SGTAQNOP.js");
+    const v = await verifyWritePreview(ctx.root, repo, fact ? { fact } : {});
+    if (!v)
+      throw notFound(`There are no facts for ${repo} at ${factsRelOf(ctx.root)}/${repo}.jsonl.`);
+    return { status: 200, body: v };
+  }).add("POST", "/api/facts/{repo}/corrections", async ({ params, body }) => {
+    const repo = (await repoSpellings(ctx.root))(repoOf(params.repo));
+    const b = api_exports.FactCorrectionRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say which fact and what is wrong: { fact, action, set, line, reason }.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const f = await readFacts(ctx.root, repo);
+    if (!f.present)
+      throw notFound(`There are no facts for ${repo} at ${f.file}.`);
+    const { c, fact } = correctionOfRequest(f, b.data, ctx.user, now());
+    const rel = `${factsRelOf(ctx.root)}/${repo}.corrections.jsonl`;
+    const written = correctionLine(c);
+    await mkdir(factsDirOf(ctx.root), { recursive: true });
+    const cfile = join2(factsDirOf(ctx.root), `${repo}.corrections.jsonl`);
+    await appendLines(cfile, [written], { waitMs: deps.lockWaitMs ?? 15e3 }).catch((e) => {
+      if (!(e instanceof LockHeldError))
+        throw e;
+      throw new HttpError(409, "Another write holds a corrections file", `${e.message} Nothing was written; try again once it is done.`, { written: [] });
+    });
+    ctx.events.publish({ type: "file.changed", path: rel });
+    const result = {
+      correction: c,
+      file: rel,
+      commit: `git add ${rel}
+git commit -m "${repo}: a person's correction of ${fact.id}"`,
+      verify: `atticus verify ${repo}`,
+      line: written
+    };
+    return { status: 200, body: result };
+  }).add(
+    "POST",
+    "/api/links/corrections",
+    async ({ body }) => {
+      const b = api_exports.LinkCorrectionsRequest.safeParse(body ?? {});
+      if (!b.success)
+        throw badRequest("Say which calls and what is wrong: { items: [{ repo, fact, action, set }], reason }.", {
+          errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+        });
+      const at = now();
+      const byRepo = /* @__PURE__ */ new Map();
+      const read = /* @__PURE__ */ new Map();
+      const spelt = await repoSpellings(ctx.root);
+      for (const item of b.data.items) {
+        const repo = spelt(repoOf(item.repo));
+        let f = read.get(repo);
+        if (!f) {
+          f = await readFacts(ctx.root, repo);
+          read.set(repo, f);
+        }
+        if (!f.present)
+          throw notFound(`There are no facts for ${repo} at ${f.file}.`);
+        const reason = item.reason ?? b.data.reason;
+        const corrected = correctionOfRequest(f, {
+          fact: item.fact,
+          action: item.action,
+          ...item.set ? { set: item.set } : {},
+          ...reason ? { reason } : {}
+        }, ctx.user, at);
+        byRepo.set(repo, [...byRepo.get(repo) ?? [], corrected]);
+      }
+      await mkdir(factsDirOf(ctx.root), { recursive: true });
+      const repos = [...byRepo.keys()].sort((a, b2) => a < b2 ? -1 : a > b2 ? 1 : 0);
+      const fileOf = (repo) => join2(factsDirOf(ctx.root), `${repo}.corrections.jsonl`);
+      const relOf = (repo) => `${factsRelOf(ctx.root)}/${repo}.corrections.jsonl`;
+      const files = [];
+      const skipped = [];
+      const held = holdingAll(repos.map(fileOf), async () => {
+        const plan = [];
+        for (const repo of repos) {
+          const before = await readFile(fileOf(repo), "utf8").catch((e) => {
+            if (e.code === "ENOENT")
+              return void 0;
+            throw new HttpError(500, "Atticus wrote none of it", `${relOf(repo)} couldn't be read (${e instanceof Error ? e.message : String(e)}): nothing was written to any repo.`, { written: [] });
+          });
+          const onFile = parseCorrections(before ?? "").corrections;
+          const cs = [];
+          for (const { c, fact } of byRepo.get(repo)) {
+            const meets = correctionFor(fact, onFile);
+            if (meets && saysOf(meets) === saysOf(c)) {
+              if (!skipped.some((x) => x.repo === repo && x.fact === c.fact))
+                skipped.push({ repo, fact: c.fact });
+              continue;
+            }
+            onFile.push(c);
+            cs.push(c);
+          }
+          if (!cs.length)
+            continue;
+          const was = before ?? "";
+          const eol = /\r\n/.test(was) ? "\r\n" : "\n";
+          const lead = was && !was.endsWith("\n") ? eol : "";
+          const lines = cs.map(correctionLine);
+          plan.push({
+            repo,
+            before,
+            after: was + lead + lines.map((l) => `${l}${eol}`).join(""),
+            cs
+          });
+        }
+        const done = [];
+        for (const x of plan) {
+          try {
+            await write(fileOf(x.repo), x.after);
+            done.push(x);
+          } catch (e) {
+            const why = e instanceof Error ? e.message : String(e);
+            const kept2 = [];
+            for (const y of [...done].reverse())
+              await (y.before === void 0 ? rm(fileOf(y.repo), { force: true }) : write(fileOf(y.repo), y.before)).catch(() => kept2.push(y));
+            const written = kept2.sort((a, b2) => a.repo < b2.repo ? -1 : 1).map((y) => ({ repo: y.repo, file: relOf(y.repo) }));
+            for (const w of written)
+              ctx.events.publish({ type: "file.changed", path: w.file });
+            throw new HttpError(500, written.length ? "Atticus wrote only part of it" : "Atticus wrote none of it", written.length ? `${relOf(x.repo)} couldn't be written (${why}), and ${written.map((w) => w.file).join(", ")} couldn't be put back as it was: the corrections for ${written.map((w) => w.repo).join(", ")} are on file, the others are not. Asked again, the ones on file are skipped.` : `${relOf(x.repo)} couldn't be written (${why}): nothing was written to any repo.`, { written });
+          }
+        }
+        for (const x of done)
+          files.push({
+            repo: x.repo,
+            file: relOf(x.repo),
+            lines: x.cs.map(correctionLine),
+            corrections: x.cs
+          });
+      }, { waitMs: deps.lockWaitMs ?? 15e3 });
+      await held.catch((e) => {
+        if (!(e instanceof LockHeldError))
+          throw e;
+        throw new HttpError(409, "Another write holds a corrections file", `${e.message} Nothing was written to any repo; try again once it is done.`, { written: [] });
+      });
+      for (const f of files)
+        ctx.events.publish({ type: "file.changed", path: f.file });
+      const n = files.reduce((k, f) => k + f.corrections.length, 0);
+      const result = {
+        files,
+        // Nothing new written (every one on file already): nothing to commit.
+        commit: files.length ? `git add ${files.map((f) => f.file).join(" ")}
+git commit -m "A person's correction of ${n} call${n === 1 ? "" : "s"} on one link"` : "",
+        verify: files.map((f) => `atticus verify ${f.repo}`),
+        ...skipped.length ? { skipped } : {}
+      };
+      return { status: 200, body: result };
+    },
+    // Review of beta.24: up to 5000 calls in one request (every call edge-calls gives), each
+    // with its why: more than the server's usual 4 MB.
+    { maxBody: LINK_CORRECTIONS_MAX_BODY }
+  );
+}
+
+export {
+  memoByFiles,
+  filesUnder,
+  recheckNow,
+  factLabel,
+  claimOf,
+  uiFactsRoutes
+};

package/dist/{chunk-3EWKO457.js → chunk-WS7KBKP4.js}

@@ -4,19 +4,21 @@ var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
-  ChangeRepos,
-  RecordId,
-  RepoManifest,
-  WORKSPACE_SCHEMA_VERSION,
   changeBranch,
   changesDirOf,
   orgPackDirOf,
   runsDirOf,
   toCanonicalYaml
-} from "./chunk-FPBUTZI5.js";
+} from "./chunk-GLISHJ4G.js";
 import {
   withSharedFileLock
-} from "./chunk-B4AEL3RF.js";
+} from "./chunk-G3ZFEHCX.js";
+import {
+  ChangeRepos,
+  RecordId,
+  RepoManifest,
+  WORKSPACE_SCHEMA_VERSION
+} from "./chunk-LZFKJ2BR.js";
 import {
   require_dist
 } from "./chunk-BQGDB6ZL.js";

package/dist/chunk-X7QLAUNS.js

@@ -0,0 +1,47 @@
+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 {
+  explainCommand,
+  learnCheck,
+  learnList,
+  learnStart,
+  sandboxCreate
+} from "./chunk-UCKG6UE7.js";
+import "./chunk-EAGSM3XY.js";
+import "./chunk-C5LX54QK.js";
+import "./chunk-H7GAPNGQ.js";
+import "./chunk-VOGCSYOI.js";
+import "./chunk-IWQEZFVV.js";
+import "./chunk-EM7F6XEU.js";
+import "./chunk-GDGE7ZHC.js";
+import "./chunk-JQGWP3SC.js";
+import "./chunk-UTZMF5CV.js";
+import "./chunk-U7YZ3IRI.js";
+import "./chunk-DLNQ3HUM.js";
+import "./chunk-YRKAJ42V.js";
+import "./chunk-CGVRLQAY.js";
+import "./chunk-RL7PETU6.js";
+import "./chunk-PGKCRK77.js";
+import "./chunk-M6HI36T3.js";
+import "./chunk-2VN4TLGI.js";
+import "./chunk-4U3JLIRC.js";
+import "./chunk-MXPKXCGP.js";
+import "./chunk-QQD25YNF.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-WS7KBKP4.js";
+import "./chunk-GLISHJ4G.js";
+import "./chunk-G3ZFEHCX.js";
+import "./chunk-LZFKJ2BR.js";
+import "./chunk-CTJHEG6A.js";
+import "./chunk-BQGDB6ZL.js";
+import "./chunk-TV45EUGM.js";
+export {
+  explainCommand,
+  learnCheck,
+  learnList,
+  learnStart,
+  sandboxCreate
+};

package/dist/{chunk-4FLNCK6Q.js → chunk-XC5ZDFW7.js}

@@ -3,31 +3,33 @@ 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 {
+  doctorChecks
+} from "./chunk-F36DIKJ3.js";
 import {
   buildSite,
   catalogRecords,
   openChanges
-} from "./chunk-NAPHHWW2.js";
-import {
-  doctorChecks
-} from "./chunk-BYBU2EIB.js";
+} from "./chunk-N3OEBQTA.js";
 import {
   readProbes,
   whatRunsWhere
-} from "./chunk-J4CPHJUL.js";
+} from "./chunk-H7GAPNGQ.js";
 import {
   baseClonePath,
   loadRepos
-} from "./chunk-3EWKO457.js";
+} from "./chunk-WS7KBKP4.js";
 import {
-  CatalogBaseline,
-  DEFAULT_RUNTIME,
-  WORKSPACE_SCHEMA_VERSION,
   catalogDirOf,
   inputsDirOf,
-  loadOrgPack,
   orgPackDirOf
-} from "./chunk-FPBUTZI5.js";
+} from "./chunk-GLISHJ4G.js";
+import {
+  CatalogBaseline,
+  DEFAULT_RUNTIME,
+  WORKSPACE_SCHEMA_VERSION,
+  loadOrgPack
+} from "./chunk-LZFKJ2BR.js";
 import {
   require_dist
 } from "./chunk-BQGDB6ZL.js";

package/dist/{chunk-VRO7KSGL.js → chunk-XF5UMMQL.js}

@@ -15,30 +15,32 @@ import {
   glossaryScan,
   testsGenerate,
   traceCommand
-} from "./chunk-JMEWJPF2.js";
-import "./chunk-EMVZIOOD.js";
+} from "./chunk-IMTAHDME.js";
+import "./chunk-SEBBJQWK.js";
 import "./chunk-MUWDB4R4.js";
 import "./chunk-VOGCSYOI.js";
-import "./chunk-ZR6J4QFQ.js";
-import "./chunk-MLGWSBF4.js";
-import "./chunk-CA3DKO4D.js";
-import "./chunk-D6BVLTDV.js";
-import "./chunk-RCG5IAAT.js";
-import "./chunk-WZYM5M4U.js";
-import "./chunk-NC755EKE.js";
-import "./chunk-FL344WQD.js";
-import "./chunk-IKAW2KJU.js";
-import "./chunk-CZ2ZS7AT.js";
-import "./chunk-4GAB5ZOZ.js";
-import "./chunk-A4JXVO5O.js";
-import "./chunk-TDSCKP3V.js";
-import "./chunk-G6EFXTUO.js";
-import "./chunk-PQQKZPBU.js";
-import "./chunk-3EWKO457.js";
-import "./chunk-3424TLIJ.js";
+import "./chunk-JWLABUXL.js";
+import "./chunk-IWQEZFVV.js";
+import "./chunk-EM7F6XEU.js";
+import "./chunk-GDGE7ZHC.js";
+import "./chunk-JQGWP3SC.js";
+import "./chunk-UTZMF5CV.js";
+import "./chunk-U7YZ3IRI.js";
+import "./chunk-DLNQ3HUM.js";
+import "./chunk-YRKAJ42V.js";
+import "./chunk-CGVRLQAY.js";
+import "./chunk-RL7PETU6.js";
+import "./chunk-PGKCRK77.js";
+import "./chunk-M6HI36T3.js";
+import "./chunk-2VN4TLGI.js";
+import "./chunk-4U3JLIRC.js";
+import "./chunk-QQD25YNF.js";
 import "./chunk-QA4O2GGC.js";
-import "./chunk-FPBUTZI5.js";
-import "./chunk-B4AEL3RF.js";
+import "./chunk-WS7KBKP4.js";
+import "./chunk-GLISHJ4G.js";
+import "./chunk-G3ZFEHCX.js";
+import "./chunk-LZFKJ2BR.js";
+import "./chunk-CTJHEG6A.js";
 import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {

package/dist/{chunk-WOMQQWTO.js → chunk-XM3JE4QY.js}

@@ -5,19 +5,21 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   metarepoToolBox
-} from "./chunk-FQVSLBTV.js";
+} from "./chunk-UVKJVTKX.js";
 import {
   CONTEXT_TOOLS
-} from "./chunk-RCG5IAAT.js";
+} from "./chunk-DLNQ3HUM.js";
 import {
   TOOL_LIMITS,
   ToolSession,
   readToolCalls,
   recordToolCalls
-} from "./chunk-3424TLIJ.js";
+} from "./chunk-QQD25YNF.js";
 import "./chunk-QA4O2GGC.js";
-import "./chunk-FPBUTZI5.js";
-import "./chunk-B4AEL3RF.js";
+import "./chunk-GLISHJ4G.js";
+import "./chunk-G3ZFEHCX.js";
+import "./chunk-LZFKJ2BR.js";
+import "./chunk-CTJHEG6A.js";
 import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";