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

package/dist/chunk-R6UTCLH5.js

@@ -0,0 +1,166 @@
+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 {
+  ADOPTED_FILE,
+  ATTICUS_DIR,
+  ATTICUS_FOLDER_IGNORE,
+  AdoptError,
+  CHECKLISTS_README,
+  MockRepoListing,
+  NOT_TRANSLATABLE,
+  ORG_PACK_DIR,
+  REPO_TYPES,
+  SNAPSHOT_FILE,
+  STARTER_CHECKLISTS_README,
+  STATE_FOLDERS,
+  UNASSIGNED,
+  WALK_SKIP,
+  absorb,
+  acceptAbsorbed,
+  adopt,
+  bodyKey,
+  changeTemplateFrom,
+  checkZeroInstall,
+  copyDir,
+  detect,
+  detectRepoType,
+  exists,
+  federatedChanges,
+  federatedSources,
+  federationConflicts,
+  frontMatter,
+  hashTree,
+  inPlacePath,
+  init,
+  isDir,
+  isLocalState,
+  listDirs,
+  listFiles,
+  markdownItems,
+  openSource,
+  openSpecFrom,
+  orgPackDirOf,
+  packFor,
+  parseConstitution,
+  pathsFor,
+  promptToCommand,
+  readLayout,
+  readText,
+  reference,
+  referencedPaths,
+  refreshAbsorbed,
+  refreshAllAbsorbed,
+  renderZeroInstall,
+  reposDiscover,
+  resolveMetarepo,
+  schemaKind,
+  schemaReference,
+  sha256,
+  slug,
+  summarise,
+  takeSnapshot,
+  toPosix,
+  toSkill,
+  translateCriticItem,
+  typeFromDescription,
+  typeFromFrameworks,
+  typespecOutline,
+  typespecReference,
+  unadopt,
+  writeNew,
+  writeStartingPack,
+  yamlItems,
+  zeroInstallFiles
+} from "./chunk-NG5R2WIY.js";
+import "./chunk-6RGIM2ZH.js";
+import "./chunk-T6ESD5KM.js";
+import "./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-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  ADOPTED_FILE,
+  ATTICUS_DIR,
+  ATTICUS_FOLDER_IGNORE,
+  AdoptError,
+  CHECKLISTS_README,
+  MockRepoListing,
+  NOT_TRANSLATABLE,
+  ORG_PACK_DIR,
+  REPO_TYPES,
+  SNAPSHOT_FILE,
+  STARTER_CHECKLISTS_README,
+  STATE_FOLDERS,
+  UNASSIGNED,
+  WALK_SKIP,
+  absorb,
+  acceptAbsorbed,
+  adopt,
+  bodyKey,
+  changeTemplateFrom,
+  checkZeroInstall,
+  copyDir,
+  detect,
+  detectRepoType,
+  exists,
+  federatedChanges,
+  federatedSources,
+  federationConflicts,
+  frontMatter,
+  hashTree,
+  inPlacePath,
+  init,
+  isDir,
+  isLocalState,
+  listDirs,
+  listFiles,
+  markdownItems,
+  openSource,
+  openSpecFrom,
+  orgPackDirOf,
+  packFor,
+  parseConstitution,
+  pathsFor,
+  promptToCommand,
+  readLayout,
+  readText,
+  reference,
+  referencedPaths,
+  refreshAbsorbed,
+  refreshAllAbsorbed,
+  renderZeroInstall,
+  reposDiscover,
+  resolveMetarepo,
+  schemaKind,
+  schemaReference,
+  sha256,
+  slug,
+  summarise,
+  takeSnapshot,
+  toPosix,
+  toSkill,
+  translateCriticItem,
+  typeFromDescription,
+  typeFromFrameworks,
+  typespecOutline,
+  typespecReference,
+  unadopt,
+  writeNew,
+  writeStartingPack,
+  yamlItems,
+  zeroInstallFiles
+};

package/dist/chunk-RB2VSED2.js

@@ -0,0 +1,231 @@
+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 {
+  intakeContext
+} from "./chunk-MYKQVS5W.js";
+import "./chunk-VOGCSYOI.js";
+import {
+  estateFacts,
+  estateRepos,
+  hostAliases,
+  joinReposOf,
+  outsideProfileSystems
+} from "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import {
+  readVendorSpec,
+  slug,
+  vendorImpact
+} from "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import {
+  inputsDirOf,
+  joinConventions,
+  readFlow,
+  specFlowFiles
+} from "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/vendor-impact-commands.js
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+var IMPACT_WORDS = {
+  usage: "Name the vendor spec: atticus intake impact <spec> [--json]",
+  noSuchSpec: (spec) => `There is no ${spec} in inputs/. atticus intake list shows what is there.`,
+  notASpec: (path) => `${path} isn't an OpenAPI 3 or Swagger 2 spec, so it has no operations to compare.`,
+  noOtherVersion: (path) => `${path} has no other version beside it in inputs/, so there is nothing to compare. Add each version of a vendor's spec beside the last (atticus intake add), never over it.`,
+  noSystem: (path) => `${path} isn't linked to a system yet, so its operations belong to nobody. atticus triage asks which system it is.`,
+  header: (name, older, newer) => `${name}: ${older.path}${older.version ? ` (${older.version})` : ""} \u2192 ${newer.path}${newer.version ? ` (${newer.version})` : ""}`,
+  counts: (all, breaking) => all === 0 ? "The two versions publish the same operations, fields and auth." : `${all} change${all === 1 ? "" : "s"}: ${breaking} breaking, ${all - breaking} additive.`,
+  severity: { breaking: "Breaking", additive: "Additive" },
+  reachesNothing: "Nothing in the estate reaches it.",
+  direct: (component, what, where2, name) => `called directly by ${component}: ${what}, ${where2} (on ${name})`,
+  gap: (message, where2) => `Forwarded, but not in the older version either: ${message} (${where2}).`,
+  ask: (question) => `Asked: ${question}`,
+  affected: (repos, flows) => `Affected: ${repos.join(", ")}${flows.length ? `; flows ${flows.join(", ")}` : ""}.`,
+  nothingAffected: "Nothing in the estate reaches these changes.",
+  start: (spec) => `Start a change with this as its footprint: atticus change new "<title>" --type <type> --impact ${spec}`,
+  docTitle: (name, version) => `# What ${name} ${version} changes, and what in the estate it reaches`,
+  started: (name, version, i, attached) => `Its footprint is what ${name} ${version} reaches: ${i.repos.length} repo${i.repos.length === 1 ? "" : "s"}, ${i.flows.length} flow${i.flows.length === 1 ? "" : "s"}, ${i.interfaces.length} Interface${i.interfaces.length === 1 ? "" : "s"}. The impact is attached as ${attached}.`
+};
+var posix = (p) => p.split(sep).join("/");
+var SPECS = /* @__PURE__ */ new Set(["openapi", "swagger"]);
+function findDocument(root, docs, spec) {
+  const kept = docs.filter((d) => d.id);
+  if (!isAbsolute(spec) && spec.includes("/") && existsSync(resolve(spec)))
+    spec = resolve(spec);
+  const rel = isAbsolute(spec) ? `inputs/${posix(relative(inputsDirOf(root), spec))}` : posix(spec);
+  return kept.find((d) => d.path === rel) ?? kept.find((d) => d.path === `inputs/${rel}`) ?? kept.find((d) => d.id === spec) ?? (() => {
+    const named = kept.filter((d) => d.path.split("/").pop() === rel);
+    return named.length === 1 ? named[0] : void 0;
+  })();
+}
+async function loadVendorImpact(root, spec, io) {
+  const { op, inputs } = await intakeContext(root, io);
+  const doc = findDocument(root, inputs.documents, spec);
+  if (!doc)
+    return { error: IMPACT_WORDS.noSuchSpec(spec) };
+  if (!SPECS.has(doc.classification))
+    return { error: IMPACT_WORDS.notASpec(doc.path) };
+  const byId = new Map(inputs.documents.filter((d) => d.id).map((d) => [d.id, d]));
+  const older = doc.supersededBy ? doc : inputs.documents.find((d) => d.supersededBy === doc.id && SPECS.has(d.classification));
+  const newer = doc.supersededBy ? byId.get(doc.supersededBy) : doc;
+  if (!older || !newer || !SPECS.has(newer.classification))
+    return { error: IMPACT_WORDS.noOtherVersion(doc.path) };
+  const systemId = newer.systems[0] ?? older.systems[0];
+  const system = op.profiles.flatMap((p) => p.profile?.systems ?? []).find((s) => s.id === systemId);
+  if (!systemId || !system)
+    return { error: IMPACT_WORDS.noSystem(newer.path) };
+  const inputsDir = inputsDirOf(root);
+  const read = async (d) => readVendorSpec(d.path, await readFile(join(inputsDir, ...d.path.split("/").slice(1)), "utf8"), systemId);
+  const [olderSpec, newerSpec] = [await read(older), await read(newer)];
+  if (!olderSpec)
+    return { error: IMPACT_WORDS.notASpec(older.path) };
+  if (!newerSpec)
+    return { error: IMPACT_WORDS.notASpec(newer.path) };
+  const estate = await estateFacts(root, op, "");
+  const repos = joinReposOf(op, estate.repos);
+  const flows = [];
+  for (const [id, f] of await specFlowFiles(root).catch(() => /* @__PURE__ */ new Map())) {
+    const flow = await readFlow(root, f.repo, id).catch(() => void 0);
+    if (!flow)
+      continue;
+    flows.push({
+      id,
+      repo: f.repo,
+      ...flow.trigger.ref ? { trigger: flow.trigger.ref } : {},
+      refs: flow.steps.flatMap((s) => s.refs ?? [])
+    });
+  }
+  const systemOfRepo = Object.fromEntries(estateRepos(op).flatMap((r) => r.system ? [[r.id, r.system]] : []));
+  const team = system.boundary !== "vendor" && outsideProfileSystems(op).some((s) => s.id === system.id);
+  const hosts = hostAliases(system.aliases);
+  const { diff, impact } = vendorImpact({
+    vendor: {
+      system: systemId,
+      names: [system.name, ...system.aliases],
+      ...hosts.length ? { hosts } : {},
+      ...team ? { boundary: "internal" } : {}
+    },
+    older: { id: older.id, spec: olderSpec },
+    newer: { id: newer.id, spec: newerSpec },
+    repos,
+    targets: estate.targets,
+    // The org pack's facing words and gateway bundle folders (ADR 0147), as the catalog joins.
+    ...joinConventions(op),
+    flows,
+    systemOfRepo
+  });
+  const facts = /* @__PURE__ */ new Map();
+  for (const r of estate.repos)
+    for (const f of r.facts)
+      facts.set(`${r.repo}\0${f.id}`, f);
+  return { name: system.name, diff, impact, notes: estate.notes, facts };
+}
+var where = (e) => `${e.repo} ${e.at}`;
+var callWhat = (l, e) => {
+  const call = l.facts.get(`${e.repo}\0${e.fact}`);
+  return call?.kind === "call" ? [call.method?.toUpperCase(), call.path].filter(Boolean).join(" ") : e.fact;
+};
+var fieldWords = (s, field) => s.field ? s.field.uses === "sends" || s.field.uses === "reads" ? `, ${s.field.uses} ${field}${s.field.at ? ` (${s.field.at})` : ""}` : `, ${s.field.uses === "does-not-send" ? "doesn't send" : "doesn't read"} ${field}` : "";
+var upstreamLine = (u, indent) => {
+  const uvia = u.via?.length ? `, through ${u.via.join(" \u2192 ")}` : "";
+  return `${indent}\u2190 ${u.call.component}: ${where(u.call)}${uvia}${u.under ? `, under ${where(u.under)}` : ""}`;
+};
+function impactLines(l) {
+  const { impact, diff } = l;
+  const out = [];
+  out.push(IMPACT_WORDS.header(l.name, impact.older, impact.newer));
+  out.push(IMPACT_WORDS.counts(diff.length, diff.filter((c) => c.severity === "breaking").length));
+  const byId = new Map(diff.map((c) => [c.id, c]));
+  for (const c of impact.changes) {
+    const d = byId.get(c.id);
+    out.push("");
+    out.push(`${IMPACT_WORDS.severity[c.severity]}: ${c.says}`);
+    const cites = [
+      ...d.before ? [`was ${d.before.cite}`] : [],
+      ...d.after ? [`now ${d.after.cite}`] : []
+    ];
+    if (cites.length)
+      out.push(`  ${cites.join(", ")}`);
+    if (!c.forwards.length)
+      out.push(`  ${IMPACT_WORDS.reachesNothing}`);
+    for (const f of c.forwards) {
+      if (f.direct) {
+        const s = f.callers[0];
+        out.push(`  ${IMPACT_WORDS.direct(f.call.component, callWhat(l, f.call), where(f.call), l.name)}${fieldWords(s, d.field)}`);
+        if (s.under)
+          out.push(`    under ${where(s.under)}`);
+        for (const u of s.upstream)
+          out.push(upstreamLine(u, "    "));
+        continue;
+      }
+      const to = f.tie ? `to ${l.name} through ${f.tie.at}` : `to ${l.name}`;
+      out.push(`  forwarded by ${f.call.component}: ${callWhat(l, f.call)}, ${where(f.call)} (${to})`);
+      for (const s of f.callers) {
+        const via = s.via?.length ? `, through ${s.via.join(" \u2192 ")}` : "";
+        out.push(`    called by ${s.call.component}: ${where(s.call)}${fieldWords(s, d.field)}${via}`);
+        if (s.under)
+          out.push(`      under ${where(s.under)}`);
+        for (const u of s.upstream)
+          out.push(upstreamLine(u, "      "));
+      }
+    }
+  }
+  if (impact.gaps.length || impact.asks.length)
+    out.push("");
+  for (const g of impact.gaps)
+    out.push(IMPACT_WORDS.gap(g.message, where(g.call)));
+  for (const a of impact.asks)
+    out.push(IMPACT_WORDS.ask(a.question));
+  out.push("");
+  out.push(impact.repos.length ? IMPACT_WORDS.affected(impact.repos, impact.flows.map((f) => f.id)) : IMPACT_WORDS.nothingAffected);
+  return out;
+}
+async function intakeImpact(root, spec, o, io) {
+  if (!spec) {
+    io.err(IMPACT_WORDS.usage);
+    return 2;
+  }
+  const l = await loadVendorImpact(root, spec, io);
+  if ("error" in l) {
+    io.err(l.error);
+    return 1;
+  }
+  for (const n of l.notes)
+    io.err(n);
+  const reaches = l.impact.changes.some((c) => c.severity === "breaking" && c.forwards.length > 0);
+  if (o.json) {
+    io.out(JSON.stringify({ diff: l.diff, impact: l.impact }, null, 2));
+    return reaches ? 1 : 0;
+  }
+  for (const line of impactLines(l))
+    io.out(line);
+  if (l.impact.repos.length)
+    io.out(IMPACT_WORDS.start(l.impact.newer.path));
+  return reaches ? 1 : 0;
+}
+function impactDocument(l) {
+  const version = l.impact.newer.version ?? l.impact.newer.id;
+  return {
+    name: `${slug(`${l.name} ${version}`)}-impact.md`,
+    text: [IMPACT_WORDS.docTitle(l.name, version), "", ...impactLines(l), ""].join("\n")
+  };
+}
+export {
+  IMPACT_WORDS,
+  impactDocument,
+  impactLines,
+  intakeImpact,
+  loadVendorImpact
+};

package/dist/chunk-REWZE2XI.js

@@ -0,0 +1,53 @@
+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 {
+  assistantFiles,
+  describeRun,
+  driftCommand,
+  specHandDown,
+  specHandUp,
+  taskHandoff,
+  taskRun
+} from "./chunk-5P5BGG5L.js";
+import {
+  isTaskRun
+} from "./chunk-7HWXYP4H.js";
+import "./chunk-EI4KQYJ3.js";
+import "./chunk-6RGIM2ZH.js";
+import "./chunk-PQW7PYUR.js";
+import "./chunk-SKMHS4CL.js";
+import "./chunk-EV4TEFOD.js";
+import "./chunk-6N2GUZMZ.js";
+import "./chunk-T6ESD5KM.js";
+import "./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 "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import {
+  runtimeForCli
+} from "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  assistantFiles,
+  describeRun,
+  driftCommand,
+  isTaskRun,
+  runtimeForCli,
+  specHandDown,
+  specHandUp,
+  taskHandoff,
+  taskRun
+};

package/dist/chunk-RIEFYHXI.js

@@ -0,0 +1,162 @@
+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 {
+  openIndex,
+  searchIndex
+} from "./chunk-XNRPCI23.js";
+import "./chunk-BKFGGJKA.js";
+import {
+  changesDirOf,
+  require_dist
+} from "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/similar-changes.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+var archiveDir = (root) => join(changesDirOf(root), "archive");
+var DATED = /^(\d{4}-\d{2}-\d{2})-(.+)$/;
+function summaryOf(text) {
+  const paras = text.split(/\n\s*\n/).map((p) => p.trim()).filter((p) => p && !p.startsWith("#") && !p.startsWith("<!--"));
+  return (paras[0] ?? "").replace(/\s+/g, " ").slice(0, 400);
+}
+async function pastChange(root, folder, score) {
+  const dir = join(archiveDir(root), folder);
+  let file = join(dir, "brief.md");
+  let text = await readFile(file, "utf8").catch(() => void 0);
+  if (text === void 0) {
+    file = join(dir, "proposal.md");
+    text = await readFile(file, "utf8").catch(() => "");
+  }
+  const meta = (0, import_yaml.parse)(await readFile(join(dir, "change.yaml"), "utf8").catch(() => "")) ?? {};
+  const dated = DATED.exec(folder);
+  return {
+    id: folder,
+    change: meta.id ?? dated?.[2] ?? folder,
+    title: meta.title ?? /^#\s+(.+)$/m.exec(text)?.[1]?.trim() ?? folder,
+    ...dated ? { archived: dated[1] } : {},
+    summary: summaryOf(text),
+    file: relative(root, file).split(sep).join("/"),
+    score
+  };
+}
+async function similarChanges(root, brief, o = {}) {
+  const limit = o.limit ?? 5;
+  const folders = (await readdir(archiveDir(root), { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory()).map((d) => d.name);
+  if (!folders.length)
+    return { how: "words", changes: [] };
+  const ix = await openIndex(root);
+  try {
+    const m = ix.meaning();
+    let hits;
+    if (m.on) {
+      await ix.prepare({ text: brief });
+      const sim = ix.similar({ text: brief }, { kinds: ["PastChange"], limit });
+      if ("hits" in sim)
+        hits = sim.hits.map((h) => ({ id: h.key.split(":").slice(2).join(":"), score: h.cos }));
+    }
+    const how = hits ? "meaning" : "words";
+    hits ??= searchIndex(ix, brief, { kinds: ["PastChange"], limit }).map((h) => ({
+      id: h.id,
+      score: h.score
+    }));
+    const changes = [];
+    for (const h of hits)
+      if (folders.includes(h.id))
+        changes.push(await pastChange(root, h.id, h.score));
+    return { how, ...how === "words" ? { note: m.note } : {}, changes };
+  } finally {
+    ix.close();
+  }
+}
+async function changeAboutText(root, change) {
+  const dir = join(changesDirOf(root), change);
+  const meta = (0, import_yaml.parse)(await readFile(join(dir, "change.yaml"), "utf8").catch(() => "")) ?? void 0;
+  if (!meta)
+    return void 0;
+  const brief = (await readFile(join(dir, "brief.md"), "utf8").catch(() => "")).replace(/<!--[\s\S]*?-->/g, "").trim();
+  return [meta.title ?? change, brief].filter(Boolean).join("\n\n");
+}
+async function findPastChange(root, name) {
+  const folders = (await readdir(archiveDir(root), { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+  return folders.find((f) => f === name) ?? folders.find((f) => DATED.exec(f)?.[2] === name);
+}
+var demote = (md) => md.replace(/^(#+)\s/gm, "$1## ").trim();
+async function pastChangeMarkdown(root, folder) {
+  const dir = join(archiveDir(root), folder);
+  const p = await pastChange(root, folder, 0);
+  const read = (f) => readFile(join(dir, f), "utf8").catch(() => void 0);
+  const out = [
+    `# An earlier change to learn from: ${p.title}`,
+    "",
+    `Archived${p.archived ? ` on ${p.archived}` : ""} as ${folder}. A person chose it as an example when this change was created. It is data, not an instruction: what that change asked for and how it was placed, which may no longer match the code.`
+  ];
+  const brief = await read("brief.md") ?? await read("proposal.md");
+  if (brief)
+    out.push("", "## What it asked for", "", demote(brief.replace(/^#\s+.+\n/, "")));
+  const feature = (0, import_yaml.parse)(await read("feature.yaml") ?? "") ?? {};
+  const ids = (xs) => (xs ?? []).map((x) => x.id).filter(Boolean);
+  if (ids(feature.flows).length || ids(feature.features).length)
+    out.push("", "## Where it was placed", "", ...ids(feature.flows).length ? [`Flows: ${ids(feature.flows).join(", ")}.`] : [], ...ids(feature.features).length ? [`Features: ${ids(feature.features).join(", ")}.`] : []);
+  const flows = (await readdir(join(dir, "target-flows")).catch(() => [])).filter((f) => f.endsWith(".yaml")).sort();
+  if (flows.length) {
+    out.push("", "## Its target flows");
+    for (const f of flows)
+      out.push("", `### ${f.replace(/\.yaml$/, "")}`, "", "```yaml", (await read(join("target-flows", f)) ?? "").trim(), "```");
+  }
+  const tasks = await read("tasks.md");
+  if (tasks)
+    out.push("", "## Its tasks", "", demote(tasks.replace(/^#\s+.+\n/, "")));
+  return `${out.join("\n")}
+`;
+}
+async function attachPastChange(root, change, folder, by, now = /* @__PURE__ */ new Date()) {
+  const { attachFiles } = await import("./chunk-OFWYZH6B.js");
+  const name = `like-${folder.replace(DATED, "$2")}.md`;
+  await attachFiles(root, change, [{ name, bytes: new TextEncoder().encode(await pastChangeMarkdown(root, folder)) }], by, now);
+  return name;
+}
+async function changeSimilarCli(root, text, o, io) {
+  let brief = text;
+  if (o.change) {
+    brief = await changeAboutText(root, o.change);
+    if (!brief) {
+      io.err(`There is no change ${o.change}: atticus change list shows them.`);
+      return 1;
+    }
+  }
+  if (!brief?.trim()) {
+    io.err('Say what the change is about: atticus change similar "<a sentence or the brief>"');
+    return 2;
+  }
+  const r = await similarChanges(root, brief, o);
+  if (o.json) {
+    io.out(JSON.stringify(r, null, 2));
+    return 0;
+  }
+  if (!r.changes.length) {
+    io.out("No archived change is near this one yet (or none is archived).");
+    return 0;
+  }
+  io.out(r.how === "meaning" ? "The archived changes nearest in meaning, best first:" : `The archived changes that share most words with it, best first (${r.note ?? "similarity in meaning is off"}):`);
+  for (const c of r.changes)
+    io.out(`  ${c.id}  ${c.title}${c.summary ? `
+      ${c.summary}` : ""}`);
+  io.out(`To start from one: atticus change new "<title>" --type <type> --like ${r.changes[0].id}`);
+  return 0;
+}
+export {
+  attachPastChange,
+  changeAboutText,
+  changeSimilarCli,
+  findPastChange,
+  pastChangeMarkdown,
+  similarChanges
+};