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

package/dist/chunk-5KLGBXG5.js

@@ -0,0 +1,48 @@
+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 {
+  MIN_GIT,
+  MIN_NODE,
+  doctorChecks,
+  doctorCommand,
+  stepModelChoices,
+  stepModelLine
+} from "./chunk-AIOQPLA5.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-YISXLPHN.js";
+import "./chunk-GDLULHTC.js";
+import "./chunk-IPKHE5D6.js";
+import "./chunk-CKSITVS4.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-3HI6Z55Y.js";
+import "./chunk-XY3P7JW7.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-27NKUS3X.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-T6AIP7H5.js";
+import {
+  versionAtLeast
+} from "./chunk-RZPYKDWS.js";
+import "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  MIN_GIT,
+  MIN_NODE,
+  doctorChecks,
+  doctorCommand,
+  stepModelChoices,
+  stepModelLine,
+  versionAtLeast
+};

package/dist/chunk-5WG5YP4T.js

@@ -0,0 +1,34 @@
+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 {
+  coverageCommand,
+  patternsScan,
+  questionsCommand,
+  sourcesAdd,
+  sourcesSync
+} from "./chunk-PCVDV3UZ.js";
+import "./chunk-ABWHYWNI.js";
+import "./chunk-BWZ77RQT.js";
+import "./chunk-VOGCSYOI.js";
+import "./chunk-27NKUS3X.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  coverageCommand,
+  patternsScan,
+  questionsCommand,
+  sourcesAdd,
+  sourcesSync
+};

package/dist/chunk-64EQYWCA.js

@@ -0,0 +1,180 @@
+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 {
+  diffCatalogs,
+  readCatalog
+} from "./chunk-27NKUS3X.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import {
+  baseClonePath,
+  branchSlug,
+  checkoutState,
+  gitUser,
+  loadRepos,
+  remoteDefaultBranch
+} from "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  ManifestEditError,
+  REPO_DESCRIPTION_MAX,
+  RepoDescription,
+  RepoManifest,
+  catalogDirOf,
+  orgPackDirOf,
+  require_dist,
+  setManifestDescription
+} from "./chunk-S2A7YC3Q.js";
+import {
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/repo-branches.js
+var import_yaml = __toESM(require_dist(), 1);
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+async function branchScans(root) {
+  const dir = join(catalogDirOf(root), "branches");
+  const out = [];
+  for (const d of (await readdir(dir).catch(() => [])).sort()) {
+    const text = await readFile(join(dir, d, "branch.yaml"), "utf8").catch(() => void 0);
+    if (!text)
+      continue;
+    const m = (0, import_yaml2.parse)(text);
+    if (typeof m.branch === "string" && typeof m.scannedAt === "string" && Array.isArray(m.repos))
+      out.push({ branch: m.branch, scannedAt: m.scannedAt, repos: m.repos });
+  }
+  return out;
+}
+async function repoBranches(root) {
+  const scans = await branchScans(root);
+  const repos = [];
+  for (const r of await loadRepos(root)) {
+    if (r.archived)
+      continue;
+    const base = baseClonePath(root, r.id);
+    const remoteDefault = await remoteDefaultBranch(base);
+    const commit = await checkoutState(base).then((s) => s.commit, () => void 0);
+    repos.push({
+      id: r.id,
+      platform: r.platform,
+      url: r.url,
+      type: r.type,
+      owner: r.owner,
+      // What it is, in a person's words, or a draft nobody has confirmed (ADR 0128).
+      ...r.description ? { description: r.description } : {},
+      defaultBranch: r.defaultBranch,
+      ...remoteDefault ? { remoteDefault } : {},
+      branches: r.branches,
+      ...commit ? { commit } : {},
+      scans: scans.flatMap((s) => s.repos.filter((x) => x.id === r.id).map((x) => ({ branch: s.branch, scannedAt: s.scannedAt, commit: x.commit })))
+    });
+  }
+  return { repos };
+}
+var key = (r) => `${r.kind}/${r.id}`;
+async function compareBranch(root, branch) {
+  const scan = (await branchScans(root)).find((s) => s.branch === branch);
+  if (!scan)
+    return void 0;
+  const ids = new Set(scan.repos.map((r) => r.id));
+  const ofRepos = (records) => records.filter((r) => r.evidence.some((e) => e.repo && ids.has(e.repo)));
+  const cat = catalogDirOf(root);
+  const before = await readCatalog(join(cat, "generated"), { cacheRoot: root });
+  const after = await readCatalog(join(cat, "branches", branchSlug(branch), "generated"), {
+    cacheRoot: root
+  });
+  const d = diffCatalogs(ofRepos(before.records), ofRepos(after.records));
+  return {
+    branch,
+    scannedAt: scan.scannedAt,
+    repos: scan.repos,
+    added: d.added.map(key),
+    removed: d.removed.map(key),
+    changed: d.changed.map((c) => ({ record: key(c), fields: c.fields }))
+  };
+}
+var RepoEditError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+async function editRepoBranches(root, repoId, set) {
+  const repo = (await loadRepos(root)).find((r) => r.id === repoId);
+  if (!repo)
+    throw new RepoEditError("not-found", `There is no repo ${repoId} in any manifest.`);
+  const rel = `org-pack/profiles/${repo.platform}/repos.manifest.yaml`;
+  const file = join(orgPackDirOf(root), "profiles", repo.platform, "repos.manifest.yaml");
+  const doc = (0, import_yaml.parseDocument)(await readFile(file, "utf8"));
+  const list = doc.get("repos");
+  const item = (0, import_yaml.isSeq)(list) ? list.items.find((x) => (0, import_yaml.isMap)(x) && x.get("id") === repoId) : void 0;
+  if (!(0, import_yaml.isMap)(item))
+    throw new RepoEditError("not-found", `${rel} doesn't list ${repoId}.`);
+  const branches = set.branches?.map((b) => b.trim()).filter(Boolean);
+  const def = set.defaultBranch?.trim() || repo.defaultBranch;
+  if (branches?.includes(def))
+    throw new RepoEditError("invalid", `${def} is the default branch: its catalog is the baseline, so it isn't one of the branches scanned beside it.`);
+  if (set.defaultBranch?.trim())
+    item.set("defaultBranch", set.defaultBranch.trim());
+  if (branches) {
+    if (branches.length)
+      item.set("branches", doc.createNode([...new Set(branches)]));
+    else
+      item.delete("branches");
+  }
+  const check = RepoManifest.safeParse(doc.toJS());
+  if (!check.success)
+    throw new RepoEditError("invalid", check.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; "));
+  await writeFileAtomic(file, doc.toString({ flowCollectionPadding: true }));
+  return rel;
+}
+async function editRepoDescription(root, repoId, set, o = {}) {
+  const repo = (await loadRepos(root)).find((r) => r.id === repoId);
+  if (!repo)
+    throw new RepoEditError("not-found", `There is no repo ${repoId} in any manifest.`);
+  const now = o.now ?? /* @__PURE__ */ new Date();
+  let next;
+  if (!set.reject) {
+    const text = set.text?.trim() || (set.accept ? repo.description?.text : void 0);
+    if (!text)
+      throw new RepoEditError("invalid", set.accept ? `${repoId} has no drafted description to confirm. Write one instead.` : `Say what ${repoId} is, in one line.`);
+    if (text.length > REPO_DESCRIPTION_MAX)
+      throw new RepoEditError("invalid", `That is ${text.length} characters; a description is one line, up to ${REPO_DESCRIPTION_MAX}.`);
+    const by = o.by ?? await gitUser(root).then((u) => u.handle, () => "someone");
+    next = RepoDescription.parse({
+      text,
+      trust: "verified",
+      by,
+      at: now.toISOString().replace(/\.\d{3}Z$/, "Z")
+    });
+  } else if (!repo.description)
+    throw new RepoEditError("invalid", `${repoId} has no description to drop.`);
+  try {
+    const f = await setManifestDescription(root, repoId, next);
+    return { file: f.rel, ...next ? { description: next } : {} };
+  } catch (e) {
+    if (e instanceof ManifestEditError)
+      throw new RepoEditError(e.code === "not-found" ? "not-found" : "invalid", e.message);
+    throw e;
+  }
+}
+export {
+  RepoEditError,
+  compareBranch,
+  editRepoBranches,
+  editRepoDescription,
+  repoBranches
+};

package/dist/chunk-652QWTLZ.js

@@ -0,0 +1,242 @@
+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 {
+  AUDIENCES,
+  ReleaseError,
+  deploymentPlan,
+  evidencePack,
+  loadRelease,
+  outcomesView,
+  recordOutcome,
+  releaseForecast,
+  releaseNotes,
+  securityReview,
+  writeEvidencePack
+} from "./chunk-BOHJZTEQ.js";
+import {
+  judgingRuntime
+} from "./chunk-BWZ77RQT.js";
+import {
+  changeStore
+} from "./chunk-XY3P7JW7.js";
+
+// packages/cli/dist/release-commands.js
+import { resolve } from "node:path";
+function fail(io, e) {
+  if (e instanceof ReleaseError) {
+    io.err(e.message);
+    return e.code === "usage" ? 2 : 1;
+  }
+  throw e;
+}
+var load = async (root, id, deps) => {
+  const runtime = await judgingRuntime(root, deps.runtime);
+  return loadRelease(root, id, {
+    ...deps.now ? { now: deps.now() } : {},
+    ...runtime ? { runtime } : {}
+  });
+};
+function lines(io, text) {
+  for (const l of text.replace(/\n$/, "").split("\n"))
+    io.out(l);
+}
+function planText(p, f) {
+  const out = [`Deployment plan for ${p.change} (${p.state}), ${p.today}`, ""];
+  for (const w of p.before)
+    out.push(`0. Before anything: ${w.requestType}${w.record ? ` for ${w.record}` : ""} (${w.state}${w.readyBy ? `, ready by ${w.readyBy}` : ""}). ${w.source}`);
+  for (const s of p.steps) {
+    out.push(`${s.n}. ${s.repo} (${s.kind})${s.waitDays ? `, from ${s.earliest}` : ""}`);
+    for (const w of s.what)
+      out.push(`   - ${w}`);
+    for (const y of s.why)
+      out.push(`   why: ${y}`);
+    for (const w of s.waitsOn)
+      out.push(`   waits on: ${w.requestType}${w.record ? ` for ${w.record}` : ""}, ${w.state === "filed" ? `filed${w.number ? ` as ${w.number}` : ""}` : w.state === "waiting" ? "waiting for a person to file it" : "not filed"}${w.readyBy ? `, ready by ${w.readyBy} (${w.waitDays} working days)` : ""}${w.missing.length ? `; missing ${w.missing.join(", ")}` : ""}`);
+    out.push(`   rollback: ${s.rollback.text ? `${s.rollback.text} (${s.rollback.source})` : `GAP: ${s.rollback.gap}`}`);
+  }
+  if (!p.steps.length)
+    out.push("No repo to deploy: the change names no interface, data change, task or repo.");
+  for (const x of p.external)
+    out.push(`External: ${x.what}${x.beforeStep ? `, before step ${x.beforeStep}` : ""}.`);
+  out.push("", "Release sections (design.md):");
+  for (const s of p.sections)
+    out.push(`  ${s.name}: ${s.text ? `${s.heading} (${s.source})` : `GAP: ${s.gap}`}`);
+  if (p.findings.length) {
+    out.push("", "Release lens findings still open:");
+    for (const x of p.findings)
+      out.push(`  ${x.severity}: ${x.summary} (${x.path})`);
+  }
+  out.push("", `Forecast: ${f.ready ? `ready by ${f.ready}` : "no date"}${f.target ? `, target ${f.target.date} (${f.status})` : ""}.`);
+  for (const d of f.drivers)
+    out.push(`  ${d.until}: ${d.what}. ${d.source}`);
+  const gaps = p.gaps.filter((g) => !/^No rollback step (written|judged)|^design\.md (has no|says nothing)/.test(g));
+  if (gaps.length) {
+    out.push("", "Gaps:");
+    for (const g of gaps)
+      out.push(`  - ${g}`);
+  }
+  for (const n of [...p.notes, ...f.notes])
+    out.push(`Note: ${n}`);
+  return out;
+}
+async function releasePlanCommand(root, id, o, io, deps = {}) {
+  if (!id) {
+    io.err("Usage: atticus release plan <change> [--json]");
+    return 2;
+  }
+  try {
+    const ctx = await load(root, id, deps);
+    const plan = await deploymentPlan(ctx);
+    const forecast = await releaseForecast(ctx, plan);
+    if (o.json)
+      io.out(JSON.stringify({ ...plan, forecast }, null, 2));
+    else
+      for (const l of planText(plan, forecast))
+        io.out(l);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function releaseForecastCommand(root, id, o, io, deps = {}) {
+  if (!id) {
+    io.err("Usage: atticus release forecast <change> [--json]");
+    return 2;
+  }
+  try {
+    const f = await releaseForecast(await load(root, id, deps));
+    if (o.json) {
+      io.out(JSON.stringify(f, null, 2));
+      return 0;
+    }
+    io.out(f.status === "released" ? `${f.change} is released${f.ready ? ` (${f.ready})` : ""}.` : `${f.change}: ready by ${f.ready} (${f.waitDays} working days)${f.target ? `; target ${f.target.date}, ${f.status} (${f.target.source})` : "; no target date"}.`);
+    for (const d of f.drivers)
+      io.out(`  ${d.until}: ${d.what}. ${d.source}`);
+    for (const n of f.notes)
+      io.out(`Note: ${n}`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function releaseEvidenceCommand(root, id, o, io, deps = {}) {
+  if (!id) {
+    io.err("Usage: atticus release evidence <change> [--out <dir>] [--json]");
+    return 2;
+  }
+  try {
+    const ctx = await load(root, id, deps);
+    if (o.out) {
+      const dir = resolve(o.out);
+      const written = await writeEvidencePack(ctx, dir);
+      if (o.json)
+        io.out(JSON.stringify({ out: dir, written }, null, 2));
+      else
+        io.out(`Wrote the evidence pack for ${id} to ${dir}: evidence.md, manifest.json and ${written.length - 2} files.`);
+      return 0;
+    }
+    const pack = await evidencePack(ctx);
+    if (o.json)
+      io.out(JSON.stringify(pack, null, 2));
+    else
+      lines(io, pack.markdown);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function releaseNotesCommand(root, id, o, io, deps = {}) {
+  const audience = o.audience ?? "business";
+  if (!id || !AUDIENCES.includes(audience)) {
+    io.err("Usage: atticus release notes <change> [--audience business|technical] [--json]");
+    return 2;
+  }
+  try {
+    const n = await releaseNotes(await load(root, id, deps), audience);
+    if (o.json)
+      io.out(JSON.stringify(n, null, 2));
+    else
+      lines(io, n.markdown);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function releaseSecurityCommand(root, id, o, io, deps = {}) {
+  if (!id) {
+    io.err("Usage: atticus release security <change> [--json]");
+    return 2;
+  }
+  try {
+    const s = await securityReview(await load(root, id, deps));
+    if (o.json)
+      io.out(JSON.stringify(s, null, 2));
+    else
+      lines(io, s.markdown);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function outcomeList(root, o, io, deps = {}) {
+  try {
+    const ids = o.change ? [o.change] : (await changeStore(root).list()).map((c) => c.id).sort();
+    const views = [];
+    for (const id of ids)
+      views.push(await outcomesView(await load(root, id, deps)));
+    if (o.json) {
+      io.out(JSON.stringify(o.change ? views[0] : views, null, 2));
+      return 0;
+    }
+    if (!views.length)
+      io.out("No changes yet.");
+    for (const v of views) {
+      io.out(`${v.change} (${v.state}): ${v.title}`);
+      if (!v.measures.length)
+        io.out(`  ${v.gaps[0] ?? "No success measures."}`);
+      for (const m of v.measures)
+        io.out(`  ${m.n}. ${m.measure} [${m.id}]: ${m.latest ? `${m.latest.value} (${m.latest.by}, ${m.latest.at.slice(0, 10)})` : "not measured yet"}`);
+      for (const x of v.orphans)
+        io.out(`  ! ${x.id}: recorded, but brief.md no longer has this measure`);
+      if (v.why && v.measures.length)
+        io.out(`  ${v.why}`);
+    }
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function outcomeRecord(root, id, measure, o, io, deps = {}) {
+  if (!id || !measure || !o.value?.trim() || !o.by) {
+    io.err('Usage: atticus outcome record <change> <measure id or number> --value "<what you measured>" [--by <you>] [--note "<how>"]');
+    return 2;
+  }
+  try {
+    const r = await recordOutcome(await load(root, id, deps), {
+      measure,
+      value: o.value,
+      by: o.by,
+      ...o.note ? { note: o.note } : {}
+    });
+    if (o.json)
+      io.out(JSON.stringify(r, null, 2));
+    else
+      io.out(`Recorded "${r.value.value}" for ${r.measure.id} as ${r.value.by}. Wrote ${r.written}.`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+
+export {
+  releasePlanCommand,
+  releaseForecastCommand,
+  releaseEvidenceCommand,
+  releaseNotesCommand,
+  releaseSecurityCommand,
+  outcomeList,
+  outcomeRecord
+};