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

package/dist/chunk-LUPW4WLK.js

@@ -0,0 +1,526 @@
+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 {
+  ATTICUS_FOLDER_IGNORE,
+  CHECKLISTS_README,
+  STARTER_CHECKLISTS_README
+} from "./chunk-NG5R2WIY.js";
+import {
+  openspecRootOf,
+  rewriteStories
+} from "./chunk-EV4TEFOD.js";
+import {
+  STARTER_REVIEW_PATH,
+  readPackFiles,
+  starterReviewText
+} from "./chunk-T6ESD5KM.js";
+import {
+  metarepoOrigin
+} from "./chunk-3LU6YCSQ.js";
+import {
+  ORG_FLOW_VERSION,
+  STORE_MARKER,
+  orgFlowVersionOf,
+  readStoreMarker,
+  storeIdOf,
+  writeOrgFlowSchema,
+  writeStoreMarker
+} from "./chunk-L7I5PKGD.js";
+import {
+  VERSION,
+  versionAtLeast
+} from "./chunk-7RUMD56V.js";
+import {
+  IGNORED,
+  ensureGitignore,
+  gitUser
+} from "./chunk-XZJE6WIT.js";
+import {
+  MetarepoStamp,
+  WORKSPACE_SCHEMA_VERSION,
+  catalogDirOf,
+  changesDirOf,
+  changesRelOf,
+  isAdopted,
+  layoutOf,
+  loadOrgPack,
+  migrateCatalog,
+  migrateChangeTypesText,
+  migrateGatesText,
+  migrateManifests,
+  migrateQuestions,
+  migrateRolesText,
+  migrateRuntimeText,
+  migrateSourcesText,
+  orgPackDirOf,
+  require_dist,
+  specsDirOf,
+  specsRelOf
+} from "./chunk-JMOLB347.js";
+import {
+  LOCAL_ONLY,
+  ensureLocalIgnore,
+  writeFileAtomic
+} from "./chunk-MMB2OHUY.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/upgrade.js
+var import_yaml = __toESM(require_dist(), 1);
+import { cp, mkdir, readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+var STAMP_FILE = join(".atticus", "metarepo.yaml");
+var rel = (prefix, files) => files.map((f) => `${prefix}/${f}`);
+var MIGRATIONS = [
+  // The version-1 files; each is written at the current version (ADR 0031, 0125).
+  catalogStep("catalog-schema-v2", "Catalog records at schema version 2 (ADR 0031)", [1]),
+  {
+    id: "local-files-ignored",
+    summary: "This machine's files kept out of Git (.atticus/.gitignore, ADR 0050)",
+    async pending(root) {
+      const text = await readFile(join(root, ".atticus", ".gitignore"), "utf8").catch(() => "");
+      const have = new Set(text.split(/\r?\n/).map((l) => l.trim()));
+      return LOCAL_ONLY.every((l) => have.has(l)) ? [] : [".atticus/.gitignore"];
+    },
+    async apply(root) {
+      await ensureLocalIgnore(root);
+      return [".atticus/.gitignore"];
+    }
+  },
+  {
+    id: "state-folders-ignored",
+    summary: "Base clones, the index and run folders kept out of Git (metarepo .gitignore)",
+    async pending(root) {
+      if (isAdopted(root))
+        return [];
+      const text = await readFile(join(root, ".gitignore"), "utf8").catch(() => "");
+      const norm = (l) => l.trim().replace(/^\//, "").replace(/\/$/, "");
+      const have = new Set(text.split(/\r?\n/).map(norm));
+      return IGNORED.every((p) => have.has(norm(p))) ? [] : [".gitignore"];
+    },
+    async apply(root) {
+      return (await ensureGitignore(root)).length ? [".gitignore"] : [];
+    }
+  },
+  {
+    id: "gates-v2",
+    summary: "gates.yaml at version 2: each gate's critic round limit written out, so leaving it out means no limit (ADR 0087)",
+    async pending(root) {
+      const rel2 = gatesRel(root);
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      return text !== void 0 && migrateGatesText(text).changed ? [rel2] : [];
+    },
+    async apply(root) {
+      const rel2 = gatesRel(root);
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      if (text === void 0)
+        return [];
+      const r = migrateGatesText(text);
+      if (!r.changed)
+        return [];
+      await writeFileAtomic(join(root, rel2), r.text);
+      return [rel2];
+    }
+  },
+  {
+    id: "flow-schema-v2",
+    summary: "Spec flows at schema version 2: loops and retries can say which steps they repeat (ADR 0095)",
+    async pending(root) {
+      const r = await migrateCatalog(specsDirOf(root), { dryRun: true });
+      return rel(specsRelOf(root), r.migrated);
+    },
+    async apply(root) {
+      const r = await migrateCatalog(specsDirOf(root));
+      return rel(specsRelOf(root), r.migrated);
+    }
+  },
+  {
+    id: "change-types-v2",
+    summary: "change-types.yaml at version 2: a type can be small and take the fast path; every type stays standard until a person marks it (ADR 0113)",
+    async pending(root) {
+      const rel2 = packRel(root, "change-types.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      return text !== void 0 && migrateChangeTypesText(text).changed ? [rel2] : [];
+    },
+    async apply(root) {
+      const rel2 = packRel(root, "change-types.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      if (text === void 0)
+        return [];
+      const r = migrateChangeTypesText(text);
+      if (!r.changed)
+        return [];
+      await writeFileAtomic(join(root, rel2), r.text);
+      return [rel2];
+    }
+  },
+  {
+    // The id is kept as it was first shipped (stamps record it); the step writes the current version.
+    id: "questions-v3",
+    summary: "Questions at schema version 4: a question can name the earlier one it may be the same as (ADR 0117), an answer can carry its rule and the proposal it accepted (ADR 0153), and a question the code later disagreed with keeps why it reopened and the answer it had (ADR 0162)",
+    pending: (root) => migrateQuestions(root, { dryRun: true }),
+    apply: (root) => migrateQuestions(root)
+  },
+  {
+    id: "starter-review",
+    summary: "The starter review: AI rules for the critic's lenses in checklists/review.yaml, for an org pack with no AI review of its own (ADR 0120)",
+    async pending(root) {
+      return (await starterReviewPlan(root)).map((f) => f.rel);
+    },
+    async apply(root) {
+      const out = [];
+      for (const f of await starterReviewPlan(root)) {
+        await writeFileAtomic(join(root, ...f.rel.split("/")), f.text);
+        out.push(f.rel);
+      }
+      return out;
+    }
+  },
+  // The version-2 files: only the number changes, no field gains a required (ADR 0125).
+  catalogStep("catalog-schema-v3", "Catalog records at schema version 3: a Schema field can say whether it is required (ADR 0125)", [2]),
+  // The version-3 files: only the number changes; version 4 adds a Schema format (ADR 0164).
+  catalogStep("catalog-schema-v4", "Catalog records at schema version 4: a Schema can be a protobuf message (ADR 0164)", [3]),
+  sourcesStep("sources-v2", "sources.yaml at version 2: a wiki can include and exclude pages by pattern; every wiki still reads every page (ADR 0083)", { from: 1, to: 2 }),
+  // ADR 0132: from version 1 or 2 (a version 1 file is moved to 2 by the step before, then here).
+  sourcesStep("sources-v3", "sources.yaml at version 3: a wiki can say how much its word counts (authority) and where it applies (appliesTo); every wiki still ranks as a team's and applies everywhere (ADR 0132)", { to: 3 }),
+  {
+    // ADR 0124 addendum B-place: `atticus init` ignored the whole of .atticus/, so the stamp this
+    // command asks a person to commit (ADR 0051) was never committed.
+    id: "stamp-committed",
+    summary: "The stamp .atticus/metarepo.yaml committed, the rest of .atticus/ kept out of Git (metarepo .gitignore, ADR 0051)",
+    async pending(root) {
+      if (isAdopted(root))
+        return [];
+      const text = await readFile(join(root, ".gitignore"), "utf8").catch(() => "");
+      return stampIgnored(text) ? [".gitignore"] : [];
+    },
+    async apply(root) {
+      if (isAdopted(root))
+        return [];
+      const text = await readFile(join(root, ".gitignore"), "utf8").catch(() => "");
+      if (!stampIgnored(text))
+        return [];
+      await writeFileAtomic(join(root, ".gitignore"), text.replace(WHOLE_FOLDER, ATTICUS_FOLDER_IGNORE.join("\n")));
+      return [".gitignore"];
+    }
+  },
+  {
+    id: "runtime-v2",
+    summary: "runtime.yaml at version 2: a model can be named for each kind of step (read, draft, critic, knowledge, quick); every step still runs on the one model until one is named (ADR 0121)",
+    async pending(root) {
+      const rel2 = packRel(root, "runtime.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      return text !== void 0 && migrateRuntimeText(text).changed ? [rel2] : [];
+    },
+    async apply(root) {
+      const rel2 = packRel(root, "runtime.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      if (text === void 0)
+        return [];
+      const r = migrateRuntimeText(text);
+      if (!r.changed)
+        return [];
+      await writeFileAtomic(join(root, rel2), r.text);
+      return [rel2];
+    }
+  },
+  {
+    id: "roles-v2",
+    summary: "roles.yaml at version 2: it can name the teams repos are owned by and who is on each, so questions go to their owner; no team is named until a person writes one (ADR 0140)",
+    async pending(root) {
+      const rel2 = packRel(root, "roles.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      return text !== void 0 && migrateRolesText(text).changed ? [rel2] : [];
+    },
+    async apply(root) {
+      const rel2 = packRel(root, "roles.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      if (text === void 0)
+        return [];
+      const r = migrateRolesText(text);
+      if (!r.changed)
+        return [];
+      await writeFileAtomic(join(root, rel2), r.text);
+      return [rel2];
+    }
+  },
+  {
+    // ADR 0006 addendum (2026-10-25): org-flow version 2 lists Atticus 2's artifacts (proposal,
+    // design, stories, specs, tasks), so `openspec status` and `validate` agree with Atticus.
+    id: "org-flow-v2",
+    summary: "OpenSpec's org-flow schema at version 2: the artifacts Atticus 2 writes, in its stage order (ADR 0006 addendum)",
+    async pending(root) {
+      const os = openspecRootOf(root);
+      if (!os)
+        return [];
+      const v = await orgFlowVersionOf(os);
+      return v !== void 0 && v < ORG_FLOW_VERSION ? [orgFlowRel(root)] : [];
+    },
+    async apply(root) {
+      const os = openspecRootOf(root);
+      if (!os)
+        return [];
+      await writeOrgFlowSchema(os);
+      return [orgFlowRel(root)];
+    }
+  },
+  {
+    // ADR 0124 addendum B-short: a change's stories written again from its kept answer, no model
+    // call: short story files, task prompts in tasks/, tasks numbered per story, OpenSpec specs.
+    id: "stories-b-short",
+    summary: "Each change's stories in the short form, with OpenSpec spec deltas and a proposal, from the kept stories answer (no model call; ADR 0124 addendum B-short)",
+    async pending(root) {
+      return (await longStories(root)).map((c) => `${changesRelOf(root)}/${c}/stories`);
+    },
+    async apply(root) {
+      const out = [];
+      for (const c of await longStories(root))
+        for (const f of await rewriteStories(root, c).catch(() => []))
+          out.push(`${changesRelOf(root)}/${c}/${f}`);
+      return out;
+    }
+  },
+  {
+    id: "manifest-schema-v2",
+    summary: "repos.manifest.yaml at version 2: a repo can say what it is, in a person's words (ADR 0128)",
+    pending: (root) => migrateManifests(root, { dryRun: true, to: 2 }),
+    apply: (root) => migrateManifests(root, { to: 2 })
+  },
+  {
+    id: "manifest-schema-v3",
+    summary: "repos.manifest.yaml at version 3: a repo can give the base path it answers under on a shared host (ADR 0134)",
+    pending: (root) => migrateManifests(root, { dryRun: true, to: 3 }),
+    apply: (root) => migrateManifests(root, { to: 3 })
+  }
+];
+var orgFlowRel = (root) => `${layoutOf(root).openspec.replace(/\/+$/, "")}/schemas/org-flow/schema.yaml`;
+async function longStories(root) {
+  const out = [];
+  const dir = changesDirOf(root);
+  for (const c of (await readdir(dir).catch(() => [])).sort()) {
+    if (c === "archive")
+      continue;
+    if (!await exists(join(dir, c, "stage", "stories-answer.yaml")))
+      continue;
+    for (const f of await readdir(join(dir, c, "stories")).catch(() => []))
+      if (f.endsWith(".md") && (await readFile(join(dir, c, "stories", f), "utf8")).includes("Prompt for Copilot or Claude Code:")) {
+        out.push(c);
+        break;
+      }
+  }
+  return out;
+}
+function sourcesStep(id, summary, v) {
+  return {
+    id,
+    summary,
+    async pending(root) {
+      const rel2 = packRel(root, "sources.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      return text !== void 0 && migrateSourcesText(text, v).changed ? [rel2] : [];
+    },
+    async apply(root) {
+      const rel2 = packRel(root, "sources.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      if (text === void 0)
+        return [];
+      const r = migrateSourcesText(text, v);
+      if (!r.changed)
+        return [];
+      await writeFileAtomic(join(root, rel2), r.text);
+      return [rel2];
+    }
+  };
+}
+var WHOLE_FOLDER = /^\/?\.atticus\/?[ \t]*$/m;
+var stampIgnored = (text) => WHOLE_FOLDER.test(text) && !/^!\/?\.atticus\/metarepo\.yaml\s*$/m.test(text);
+function catalogStep(id, summary, versions) {
+  const run = async (root, dryRun) => {
+    const out = [];
+    for (const sub of ["generated", "curated"]) {
+      const r = await migrateCatalog(join(catalogDirOf(root), sub), {
+        dryRun,
+        versions,
+        pendingOnly: dryRun
+      });
+      out.push(...rel(`catalog/${sub}`, r.migrated));
+    }
+    return out;
+  };
+  return { id, summary, pending: (root) => run(root, true), apply: (root) => run(root, false) };
+}
+async function starterReviewPlan(root) {
+  if ((await readStamp(root))?.migrations.includes("starter-review"))
+    return [];
+  const dirRel = packRel(root, "checklists");
+  const reviewRel = packRel(root, STARTER_REVIEW_PATH);
+  if (await exists(join(root, ...reviewRel.split("/"))))
+    return [];
+  const { packs } = await readPackFiles(root, join(root, ...dirRel.split("/")));
+  if (packs.some((p) => p.pack.name === "review" || p.pack.rules.some((r) => r.check.type === "ai")))
+    return [];
+  const readmeRel = `${dirRel}/README.md`;
+  const readme = await readFile(join(root, ...readmeRel.split("/")), "utf8").catch(() => void 0);
+  const norm = (t) => t.replace(/\r\n/g, "\n");
+  if (readme !== void 0 && norm(readme).includes("starter review"))
+    return [];
+  const out = [{ rel: reviewRel, text: await starterReviewText() }];
+  if (readme === void 0 || norm(readme) === CHECKLISTS_README)
+    out.unshift({ rel: readmeRel, text: STARTER_CHECKLISTS_README });
+  return out;
+}
+async function exists(path) {
+  return stat(path).then(() => true, () => false);
+}
+function packRel(root, file) {
+  return `${isAdopted(root) ? ".atticus/org-pack" : "org-pack"}/${file}`;
+}
+function gatesRel(root) {
+  return packRel(root, "gates.yaml");
+}
+async function readStamp(root) {
+  try {
+    const r = MetarepoStamp.safeParse((0, import_yaml.parse)(await readFile(join(root, STAMP_FILE), "utf8")));
+    return r.success ? r.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var newerThan = (a, b) => !versionAtLeast(b, a.replace(/-.*$/, ""));
+async function upgradeCheck(root, version = VERSION) {
+  const [stamp, found] = await Promise.all([
+    readStamp(root),
+    Promise.all(MIGRATIONS.map(async (m) => ({ m, files: await m.pending(root) })))
+  ]);
+  const pending = found.filter((x) => x.files.length).map(({ m, files }) => ({ id: m.id, summary: m.summary, files }));
+  return {
+    atticus: version,
+    ...stamp ? { stamp } : {},
+    newer: !!stamp && newerThan(stamp.atticus.replace(/-.*$/, ""), version.replace(/-.*$/, "")),
+    pending
+  };
+}
+async function openspecStorePlan(root) {
+  const where = layoutOf(root).openspec.replace(/\/+$/, "");
+  if (where !== "openspec")
+    return {
+      action: "refused",
+      why: `An OpenSpec store keeps openspec/ at its root; this metarepo keeps it in ${where}, so it can't be one. Nothing was changed.`
+    };
+  const name = (await loadOrgPack(orgPackDirOf(root))).pack?.name;
+  const id = name ? storeIdOf(name) : void 0;
+  if (!id)
+    return {
+      action: "refused",
+      why: "The org pack has no name to make a store id from (org-pack/pack.yaml name). Nothing was changed."
+    };
+  const have = await readStoreMarker(root);
+  if (!have.missing)
+    return have.marker?.id === id ? { action: "present", id } : { action: "differs", id, ...have.marker ? { has: have.marker.id } : {} };
+  const remote = await metarepoOrigin(root);
+  return { action: "create", id, ...remote ? { remote } : {} };
+}
+function storeLine(s) {
+  if (s.action === "present")
+    return `This metarepo is already the OpenSpec store ${s.id} (${STORE_MARKER}).`;
+  if (s.action === "differs")
+    return s.has ? `${STORE_MARKER} names the store ${s.has}, not ${s.id}: left as it is.` : `${STORE_MARKER} is there but can't be read: left as it is.`;
+  return `Wrote ${STORE_MARKER}: this metarepo is the OpenSpec store ${s.id} (beta). Commit it; then a developer runs openspec store register <their clone> once to use it from plain OpenSpec.`;
+}
+async function upgradeCommand(root, o, io, version = VERSION) {
+  const c = await upgradeCheck(root, version);
+  if (c.newer) {
+    io.err(`This metarepo was upgraded by Atticus ${c.stamp.atticus}; this is ${version}. Install ${c.stamp.atticus} or later before working in it, so nothing it wrote is lost.`);
+    if (o.json)
+      io.out(JSON.stringify(c, null, 2));
+    return 1;
+  }
+  const store = o.openspecStore ? await openspecStorePlan(root) : void 0;
+  if (store?.action === "refused") {
+    io.err(store.why);
+    if (o.json)
+      io.out(JSON.stringify({ ...c, openspecStore: store }, null, 2));
+    return 1;
+  }
+  if (o.check || o.dryRun) {
+    const steps = c.pending.length + (store?.action === "create" ? 1 : 0);
+    if (o.json)
+      io.out(JSON.stringify(store ? { ...c, openspecStore: store } : c, null, 2));
+    else if (!steps) {
+      io.out(`Up to date for Atticus ${version}.`);
+      if (store)
+        io.out(storeLine(store));
+    } else {
+      io.out(`${steps} upgrade step${steps === 1 ? "" : "s"} to run (atticus upgrade):`);
+      for (const p of c.pending)
+        io.out(`  ${p.summary}: ${p.files.length} file${p.files.length === 1 ? "" : "s"}`);
+      if (store?.action === "create")
+        io.out(`  Make this metarepo the OpenSpec store ${store.id} (beta): ${STORE_MARKER}`);
+      else if (store)
+        io.out(storeLine(store));
+    }
+    return o.check && steps ? 1 : 0;
+  }
+  const now = o.now ?? /* @__PURE__ */ new Date();
+  const by = o.by ?? (await gitUser(root)).handle;
+  const stampTime = now.toISOString().replace(/\.\d{3}Z$/, "Z");
+  const backup = join(root, ".atticus", "backups", stampTime.replace(/[-:]/g, "").replace("T", "-").replace("Z", ""));
+  const changed = [];
+  if (c.pending.length) {
+    await mkdir(backup, { recursive: true });
+    await ensureLocalIgnore(root);
+    for (const p of c.pending)
+      for (const f of p.files)
+        await cp(join(root, ...f.split("/")), join(backup, ...f.split("/"))).catch(() => void 0);
+    for (const p of c.pending) {
+      const m = MIGRATIONS.find((x) => x.id === p.id);
+      changed.push(...await m.apply(root));
+    }
+  }
+  const stamp = MetarepoStamp.parse({
+    schemaVersion: WORKSPACE_SCHEMA_VERSION,
+    atticus: version,
+    upgradedAt: stampTime,
+    upgradedBy: by,
+    migrations: [.../* @__PURE__ */ new Set([...c.stamp?.migrations ?? [], ...MIGRATIONS.map((m) => m.id)])]
+  });
+  await writeFileAtomic(join(root, STAMP_FILE), (0, import_yaml.stringify)(stamp));
+  if (store?.action === "create") {
+    await writeStoreMarker(root, {
+      id: store.id,
+      ...store.remote ? { remote: store.remote } : {}
+    });
+    changed.push(STORE_MARKER);
+  }
+  if (o.json)
+    io.out(JSON.stringify({
+      upgraded: c.pending.map((p) => p.id),
+      files: changed,
+      stamp,
+      ...store ? { openspecStore: store } : {}
+    }, null, 2));
+  else {
+    if (c.pending.length) {
+      for (const p of c.pending)
+        io.out(`Done: ${p.summary} (${p.files.length} file${p.files.length === 1 ? "" : "s"})`);
+      io.out(`The files as they were are in ${backup}.`);
+    } else if (store?.action !== "create")
+      io.out(`Nothing to change for Atticus ${version}.`);
+    if (store)
+      io.out(storeLine(store));
+    io.out(`Recorded Atticus ${version} in ${STAMP_FILE.split("\\").join("/")}. Commit the changes in a pull request.`);
+  }
+  return 0;
+}
+
+export {
+  STAMP_FILE,
+  MIGRATIONS,
+  readStamp,
+  upgradeCheck,
+  upgradeCommand
+};