@maycombhq/atticus 2.0.0-beta.26 → 2.0.0-beta.27.1

package/dist/{chunk-IDRCBMJF.js → chunk-SP5BWA5H.js}

@@ -6,44 +6,44 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   FRESH_STATES,
   estateFreshness
-} from "./chunk-IL7PVMUO.js";
-import "./chunk-EUTZTJIO.js";
-import "./chunk-RBO4A7TC.js";
-import "./chunk-ET7SPOBA.js";
-import "./chunk-BD7HBZLP.js";
-import "./chunk-V5FT3MZG.js";
+} from "./chunk-FBG3QHOL.js";
+import "./chunk-4HMOOBIR.js";
+import "./chunk-2WPUSHB6.js";
+import "./chunk-YHS7TSQS.js";
+import "./chunk-UXETN43F.js";
 import {
   loadReadPlan,
   readCostOf
-} from "./chunk-P6DM2EFI.js";
-import "./chunk-XDLMQL5A.js";
-import "./chunk-PBDIVTFL.js";
-import "./chunk-XI3GPYP4.js";
+} from "./chunk-VVLWEM2Y.js";
+import "./chunk-QPAANKUR.js";
+import "./chunk-FADIWOA5.js";
+import "./chunk-44XGOSUU.js";
+import "./chunk-ELZGWEK4.js";
 import "./chunk-3G4YI4ZU.js";
+import "./chunk-6GX3OFEZ.js";
 import "./chunk-VOGCSYOI.js";
-import "./chunk-2SCZZQNQ.js";
-import "./chunk-VIQHZA53.js";
-import "./chunk-WH3ZFLXT.js";
-import "./chunk-UTZMF5CV.js";
-import "./chunk-6U65YB54.js";
-import "./chunk-SZDOBIWE.js";
+import "./chunk-LP6BFBE5.js";
+import "./chunk-YBAJ5SAR.js";
+import "./chunk-23TTURB2.js";
 import {
   componentRenames,
   estateFacts,
   isPrototypeRepo,
   joinReposOf,
   outsideSystems
-} from "./chunk-2HDNOUJU.js";
-import "./chunk-RK5P2DWD.js";
-import "./chunk-K3QKOVZN.js";
-import "./chunk-QAFQLILX.js";
-import "./chunk-HQMLY2R6.js";
-import "./chunk-I2EWY3MG.js";
-import "./chunk-UFIQ5FWY.js";
-import "./chunk-MTIRNHRJ.js";
-import "./chunk-ZDA72732.js";
-import "./chunk-QA4O2GGC.js";
-import "./chunk-XIJBQM45.js";
+} from "./chunk-6H62UHY5.js";
+import "./chunk-YIGSUTW2.js";
+import "./chunk-N5DLB74D.js";
+import "./chunk-4NPWOUI2.js";
+import "./chunk-I57IH5X6.js";
+import "./chunk-LCQIRCOT.js";
+import "./chunk-X5B7KYPD.js";
+import "./chunk-IPSZDVLI.js";
+import "./chunk-2MRYL45Z.js";
+import "./chunk-ELJ5Q4J2.js";
+import "./chunk-XZY4GTCX.js";
+import "./chunk-3M3MDBOG.js";
+import "./chunk-QK3UFHFC.js";
 import {
   HOSTS_STEP,
   LINK_QUESTION_STEPS,
@@ -59,16 +59,17 @@ import {
   listQuestions,
   orgPackDirOf,
   parseFacts
-} from "./chunk-6ZDAEUKB.js";
-import "./chunk-MEMEO7YO.js";
+} from "./chunk-WJWSB65O.js";
+import "./chunk-SMFFUFMN.js";
 import {
   joinConventions,
   loadOrgPack
-} from "./chunk-LZFKJ2BR.js";
-import "./chunk-CTJHEG6A.js";
+} from "./chunk-A3LVMCA5.js";
+import "./chunk-NWMFVPEP.js";
 import {
   require_dist
 } from "./chunk-BQGDB6ZL.js";
+import "./chunk-R4TUWD4C.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/chunk-SRIU7L4Z.js

@@ -0,0 +1,425 @@
+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 {
+  buildAndWrite,
+  buildCatalog,
+  buildLines,
+  curatedDirOf,
+  factsSlotOf,
+  forgetCatalogs,
+  forgetKeptReads,
+  listUndo,
+  loadBuildInputs,
+  readCatalog,
+  readersSlotRead,
+  rollBackUndo,
+  undoDirOf,
+  withSlotWrites
+} from "./chunk-6H62UHY5.js";
+import "./chunk-YIGSUTW2.js";
+import "./chunk-N5DLB74D.js";
+import {
+  factsSlotPaths,
+  legacyJoinsPath,
+  parseLegacyJoins,
+  readersSlotPath,
+  serializeFactsSlotMeta,
+  serializeLegacyJoins,
+  serializeReadersSlot,
+  sha256Of
+} from "./chunk-4NPWOUI2.js";
+import {
+  loadRepos
+} from "./chunk-X5B7KYPD.js";
+import "./chunk-IPSZDVLI.js";
+import "./chunk-2MRYL45Z.js";
+import "./chunk-ELJ5Q4J2.js";
+import "./chunk-XZY4GTCX.js";
+import "./chunk-3M3MDBOG.js";
+import {
+  FACTS_COMPANIONS,
+  ManifestEditError,
+  factsDirOf,
+  factsRelOf,
+  listQuestions,
+  mapRelOf,
+  orgPackDirOf,
+  parseRecord,
+  questionFileOf,
+  questionFileText,
+  recordPath,
+  renamedManifest,
+  serializeRecord,
+  specRelOf
+} from "./chunk-WJWSB65O.js";
+import {
+  LockHeldError,
+  acquireLock
+} from "./chunk-SMFFUFMN.js";
+import {
+  Question,
+  RecordId,
+  loadOrgPack
+} from "./chunk-A3LVMCA5.js";
+import "./chunk-NWMFVPEP.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
+import "./chunk-R4TUWD4C.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/repo-rename.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+var posix = (p) => p.split(sep).join("/");
+function renamed(v, from, to) {
+  let changed = false;
+  const walk = (x) => {
+    if (Array.isArray(x))
+      return x.map(walk);
+    if (x && typeof x === "object") {
+      const out = {};
+      for (const [k, y] of Object.entries(x)) {
+        if (k === "repo" && y === from) {
+          out[k] = to;
+          changed = true;
+        } else
+          out[k] = walk(y);
+      }
+      return out;
+    }
+    return x;
+  };
+  return { value: walk(v), changed };
+}
+function renamedText(text, from, to) {
+  const esc = from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return text.replace(new RegExp(`(?<![A-Za-z0-9._-])${esc}(?![A-Za-z0-9._-])`, "g"), to);
+}
+function rewriteFactsFile(name, text, from, to) {
+  if (name.endsWith(".jsonl"))
+    return text.split(/\r?\n/).map((line) => {
+      if (!line.trim())
+        return line;
+      try {
+        const r = renamed(JSON.parse(line), from, to);
+        return r.changed ? JSON.stringify(r.value) : line;
+      } catch {
+        return line;
+      }
+    }).join("\n");
+  try {
+    const r = renamed((0, import_yaml.parse)(text), from, to);
+    return r.changed ? (0, import_yaml.stringify)(r.value) : text;
+  } catch {
+    return text;
+  }
+}
+var renameHooks = {};
+async function repoRename(root, from, to, io, o = {}) {
+  const breakSlots = renameHooks.breakNewSlots === true;
+  renameHooks.breakNewSlots = void 0;
+  if (!from || !to) {
+    io.err("Usage: atticus repo rename <old id> <new id>");
+    return 2;
+  }
+  if (!RecordId.safeParse(to).success) {
+    io.err(`${to} isn't a repo id: ids are lowercase slugs (a-z, 0-9, '.', '_' and '-').`);
+    return 2;
+  }
+  let lock;
+  try {
+    lock = await acquireLock(root, "scan", `atticus repo rename ${from} ${to}`);
+  } catch (e) {
+    if (e instanceof LockHeldError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  try {
+    return await renameLocked(root, from, to, io, o, breakSlots);
+  } finally {
+    await lock.release();
+  }
+}
+async function renameLocked(root, from, to, io, o, breakSlots) {
+  const refusedJson = (reasons, message) => {
+    if (o.json)
+      io.out(JSON.stringify({ renamed: false, refused: { reasons, message } }, null, 2));
+  };
+  const listed = await loadRepos(root).catch(() => []);
+  if (!listed.some((r) => r.id === from)) {
+    io.err(`There is no repo ${from} in any manifest (atticus repos list shows the ids).`);
+    return 2;
+  }
+  if (listed.some((r) => r.id === to)) {
+    io.err(`${to} is already listed; repo ids are unique across every profile.`);
+    return 2;
+  }
+  const factsDir = factsDirOf(root);
+  const fRel = factsRelOf(root);
+  const moves = [];
+  for (const suffix of [".jsonl", ...FACTS_COMPANIONS]) {
+    const src = join(factsDir, `${from}${suffix}`);
+    if (!existsSync(src))
+      continue;
+    moves.push({
+      src,
+      dst: join(factsDir, `${to}${suffix}`),
+      rel: `${fRel}/${from}${suffix}`,
+      relTo: `${fRel}/${to}${suffix}`,
+      name: suffix
+    });
+  }
+  const scanDir = join(orgPackDirOf(root), "scan");
+  const scanSrc = join(scanDir, `${from}.yaml`);
+  if (existsSync(scanSrc)) {
+    const rel = posix(relative(root, scanDir));
+    moves.push({
+      src: scanSrc,
+      dst: join(scanDir, `${to}.yaml`),
+      rel: `${rel}/${from}.yaml`,
+      relTo: `${rel}/${to}.yaml`,
+      name: ".yaml"
+    });
+  }
+  const taken = moves.filter((m) => existsSync(m.dst));
+  if (taken.length) {
+    for (const m of taken)
+      io.err(`${m.relTo} is already there: move or remove it first, so ${m.rel} doesn't overwrite it. Nothing was changed.`);
+    return 1;
+  }
+  const slotWrites = [];
+  const readText = (p) => readFile(p, "utf8").then((t) => t.replace(/\r\n?/g, "\n"), () => void 0);
+  const rOld = readersSlotPath(root, from);
+  const rText = await readText(rOld);
+  if (rText !== void 0) {
+    const read = readersSlotRead(rText);
+    const next0 = "slot" in read ? serializeReadersSlot(renamed({ ...read.slot }, from, to).value) : void 0;
+    const next = breakSlots && next0 ? next0.slice(0, -10) : next0;
+    const check = next === void 0 ? void 0 : readersSlotRead(next);
+    if (!next || !check || !("slot" in check) || check.slot.repo !== to) {
+      const why = `The readers slot of ${from} doesn't read under ${to} (${"problem" in read ? read.problem : "problem" in (check ?? {}) ? check.problem : "renamed, it isn't a slot"}); nothing was changed.`;
+      io.err(why);
+      refusedJson(["build-failed"], why);
+      return 1;
+    }
+    slotWrites.push({ path: readersSlotPath(root, to), text: next });
+  }
+  const fOld = factsSlotPaths(root, from);
+  const [fText, mText] = [await readText(fOld.facts), await readText(fOld.meta)];
+  if (fText !== void 0 || mText !== void 0) {
+    const facts = fText === void 0 ? void 0 : rewriteFactsFile(".jsonl", fText, from, to);
+    let meta;
+    try {
+      const m = mText === void 0 ? void 0 : JSON.parse(mText);
+      if (m && facts !== void 0) {
+        const n = renamed(m, from, to).value;
+        meta = serializeFactsSlotMeta({
+          ...n,
+          repo: to,
+          factsHash: sha256Of(facts)
+        });
+      }
+    } catch {
+      meta = void 0;
+    }
+    const check = factsSlotOf(to, facts, breakSlots && meta ? meta.slice(0, -10) : meta);
+    if (!check?.ok || facts === void 0 || meta === void 0) {
+      const why = `The facts snapshot of ${from} doesn't read under ${to} (${check && !check.ok ? check.problem : "its meta isn't JSON"}); nothing was changed.`;
+      io.err(why);
+      refusedJson(["build-failed"], why);
+      return 1;
+    }
+    const p = factsSlotPaths(root, to);
+    slotWrites.push({ path: p.facts, text: facts }, { path: p.meta, text: meta });
+  }
+  const ljPath = legacyJoinsPath(root);
+  const ljText = await readText(ljPath);
+  if (ljText !== void 0) {
+    const lj = parseLegacyJoins(ljText);
+    if (!lj.ok) {
+      const why = `catalog/sources/legacy/joins.json doesn't read (${lj.issues[0]?.message ?? "invalid"}); nothing was changed.`;
+      io.err(why);
+      refusedJson(["build-failed"], why);
+      return 1;
+    }
+    const relPath = (abs) => posix(relative(root, abs));
+    const moved = /* @__PURE__ */ new Map();
+    for (const w of slotWrites)
+      if (w.text !== null)
+        moved.set(relPath(w.path).replace(`/${to}.`, `/${from}.`), relPath(w.path));
+    const inputs2 = {};
+    for (const [k, h] of Object.entries(lj.slot.inputs)) {
+      const next2 = moved.get(k);
+      const w = next2 ? slotWrites.find((x) => relPath(x.path) === next2) : void 0;
+      if (next2 && w?.text)
+        inputs2[next2] = sha256Of(w.text);
+      else
+        inputs2[k] = h;
+    }
+    const records = lj.slot.records.map((r) => {
+      const n = renamed(r, from, to);
+      if (!n.changed)
+        return r;
+      const p = parseRecord(n.value);
+      return p.ok ? p.record : r;
+    });
+    const next = serializeLegacyJoins({ ...lj.slot, records, inputs: inputs2 });
+    if (next !== ljText)
+      slotWrites.push({ path: ljPath, text: next });
+  }
+  forgetKeptReads();
+  const said = [];
+  const inputWrites = [];
+  const inputRemovals = [];
+  let manifest;
+  try {
+    manifest = await renamedManifest(root, from, to);
+  } catch (e) {
+    if (e instanceof ManifestEditError) {
+      io.err(e.message);
+      return e.code === "not-found" ? 2 : 1;
+    }
+    throw e;
+  }
+  inputWrites.push({ path: manifest.file.path, text: manifest.next, input: true });
+  said.push(`${manifest.file.rel}: the entry's id`);
+  for (const m of moves) {
+    const text = await readFile(m.src, "utf8");
+    inputWrites.push({ path: m.dst, text: rewriteFactsFile(m.name, text, from, to), input: true });
+    inputRemovals.push({ path: m.src, text: null, input: true });
+    said.push(`${m.rel} \u2192 ${m.relTo}`);
+  }
+  const questions = (await listQuestions(root)).questions.map((q) => q.repo === from ? Question.parse({
+    ...q,
+    repo: to,
+    rerun: renamedText(q.rerun, from, to),
+    askedBy: { ...q.askedBy, command: renamedText(q.askedBy.command, from, to) },
+    ...q.scope.level === "repo" && q.scope.id === from ? { scope: { ...q.scope, id: to } } : {}
+  }) : q);
+  const qMoved = questions.filter((q) => q.repo === to);
+  for (const q of qMoved)
+    inputWrites.push({ path: questionFileOf(root, q.id), text: questionFileText(q), input: true });
+  if (qMoved.length)
+    said.push(`${qMoved.length} question${qMoved.length === 1 ? "" : "s"} (repo ${to})`);
+  const op0 = await loadOrgPack(orgPackDirOf(root));
+  const op = structuredClone(op0);
+  for (const p of op.profiles)
+    for (const r of p.repos?.repos ?? [])
+      if (r.id === from)
+        r.id = to;
+  for (const s of op.scanSettings)
+    if (s.repo === from)
+      s.repo = to;
+  const curatedDir = curatedDirOf(root, op0);
+  const curatedNow = await readCatalog(curatedDir, { cacheRoot: root, fresh: true });
+  let decisions = 0;
+  const curatedNext = curatedNow.records.map((r) => {
+    const n = renamed(r, from, to);
+    if (!n.changed)
+      return r;
+    const p = parseRecord(n.value);
+    if (!p.ok) {
+      io.err(`${r.kind} ${r.id} names ${from} but wouldn't be valid renamed (${p.issues.map((i) => i.message).join("; ")}); left as it is.`);
+      return r;
+    }
+    inputWrites.push({
+      path: join(curatedDir, ...recordPath(p.record).split("/")),
+      text: serializeRecord(p.record),
+      input: true
+    });
+    decisions++;
+    return p.record;
+  });
+  const writes = [
+    ...slotWrites,
+    ...inputWrites,
+    ...inputRemovals,
+    // The old slot files go last, once the new ones are written.
+    ...rText !== void 0 ? [{ path: rOld, text: null }] : [],
+    ...fText !== void 0 ? [{ path: fOld.facts, text: null }] : [],
+    ...mText !== void 0 ? [{ path: fOld.meta, text: null }] : []
+  ];
+  const pending = /* @__PURE__ */ new Map();
+  for (const w of [...inputWrites, ...inputRemovals])
+    pending.set(w.path, w.text);
+  const command = `atticus repo rename ${from} ${to}`;
+  const inputs = await loadBuildInputs(root, { op, curated: curatedNext, pending, questions });
+  const build = await buildCatalog({
+    ...inputs,
+    slots: await withSlotWrites(root, inputs.slots, writes.filter((w) => !w.input))
+  });
+  const confirm = {
+    ...o.allowRemovals !== void 0 ? { allowRemovals: o.allowRemovals } : {},
+    ...o.discardEdits !== void 0 ? { discardEdits: o.discardEdits } : {}
+  };
+  const undoDir = await undoDirOf(root);
+  const newest = (await listUndo(undoDir))[0]?.n ?? 0;
+  let written;
+  try {
+    written = await buildAndWrite(root, { command, build, slots: writes, ...confirm });
+  } catch (e) {
+    await rollBackUndo(root, undoDir, newest);
+    forgetKeptReads();
+    io.err(`The rename stopped part way (${e instanceof Error ? e.message : String(e)}); every file it had written was put back, so nothing was renamed.`);
+    throw e;
+  }
+  if (written.guard.refused) {
+    for (const l of buildLines(root, written))
+      io.err(l);
+    io.err("Nothing was renamed.");
+    if (o.json)
+      io.out(JSON.stringify({ renamed: false, refused: written.guard.refused }, null, 2));
+    return 1;
+  }
+  if (decisions)
+    said.push(`${decisions} curated decision${decisions === 1 ? "" : "s"} (repo ${to})`);
+  for (const l of buildLines(root, written))
+    said.push(l);
+  forgetCatalogs();
+  if (o.json) {
+    io.out(JSON.stringify({
+      renamed: true,
+      from,
+      to,
+      files: written.write ? {
+        written: written.write.written,
+        unchanged: written.write.unchanged,
+        removed: written.write.removed
+      } : null,
+      slots: written.write?.slots ?? [],
+      removed: (written.write?.removals ?? []).map((x) => ({
+        kind: x.kind,
+        id: x.id,
+        repos: x.repos,
+        explainedBy: x.explainedBy,
+        reasons: x.reasons
+      }))
+    }, null, 2));
+    return 0;
+  }
+  io.out(`Renamed ${from} to ${to}:`);
+  for (const l of said)
+    io.out(`  ${l}`);
+  const left = [
+    existsSync(join(root, ...specRelOf(root, from).split("/"))) ? specRelOf(root, from) : "",
+    existsSync(join(root, ...`${mapRelOf(root)}/${from}`.split("/"))) ? `${mapRelOf(root)}/${from}` : ""
+  ].filter(Boolean);
+  if (left.length)
+    io.out(`Left as they are: ${left.join(" and ")}. atticus verify ${to} --write writes them under ${to}; remove the old ones in the same pull request.`);
+  io.out(`Review the change and commit it in a pull request: Atticus commits and pushes nothing. A clone under the old id is cloned again under ${to} by atticus workspace sync.`);
+  return 0;
+}
+export {
+  renameHooks,
+  repoRename
+};