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

package/dist/chunk-LRS573EX.js

@@ -0,0 +1,104 @@
+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 {
+  hostQuestionDrafts,
+  unknownHosts
+} from "./chunk-AY2IUF4K.js";
+import {
+  baseClonePath,
+  loadRepos
+} from "./chunk-PGKHJYOB.js";
+import {
+  fsRepo
+} from "./chunk-MKRBG5EF.js";
+import {
+  HOSTS_NONE,
+  HOSTS_OUTSIDE_INTERNAL,
+  HOSTS_OUTSIDE_VENDOR,
+  HOSTS_STEP,
+  hostMatches,
+  hostOfQuestion,
+  listQuestions,
+  raiseQuestions,
+  retireQuestion,
+  writeQuestion
+} from "./chunk-577AJVRS.js";
+
+// packages/cli/dist/host-questions.js
+import { stat } from "node:fs/promises";
+var HOSTS_RERUN = "atticus scan";
+var isDir = (p) => stat(p).then((s) => s.isDirectory(), () => false);
+async function askHosts(root, records, o) {
+  const repos = await loadRepos(root).catch(() => []);
+  const dirs = /* @__PURE__ */ new Map();
+  for (const r of repos) {
+    const dir = baseClonePath(root, r.id);
+    if (await isDir(dir))
+      dirs.set(r.id, dir);
+  }
+  const asks = await unknownHosts({
+    records,
+    repos,
+    handle: (id) => dirs.has(id) ? fsRepo(id, dirs.get(id), "0".repeat(40)) : void 0
+  });
+  const before = (await listQuestions(root, { step: HOSTS_STEP })).questions;
+  const asked = new Set(before.map((q) => hostOfQuestion(q)));
+  const raised = [];
+  const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const reasked = [];
+  const OUTSIDE = /* @__PURE__ */ new Set([HOSTS_OUTSIDE_INTERNAL, HOSTS_OUTSIDE_VENDOR]);
+  for (const { repo, draft } of hostQuestionDrafts(asks)) {
+    if (asked.has(hostOfQuestion(draft))) {
+      const old = before.find((q) => hostOfQuestion(q) === hostOfQuestion(draft));
+      if (!old || old.state !== "open" || old.options.some((x) => OUTSIDE.has(x.label)))
+        continue;
+      const add = draft.options.filter((x) => OUTSIDE.has(x.label));
+      const none = old.options.findIndex((x) => x.label === HOSTS_NONE);
+      const at2 = none < 0 ? old.options.length : none;
+      const next = {
+        ...old,
+        options: [...old.options.slice(0, at2), ...add, ...old.options.slice(at2)]
+      };
+      await writeQuestion(root, next);
+      reasked.push(next);
+      continue;
+    }
+    const r = await raiseQuestions(root, [draft], {
+      step: HOSTS_STEP,
+      repo,
+      command: o.command,
+      rerun: o.rerun ?? HOSTS_RERUN,
+      at
+    });
+    raised.push(...r.raised);
+  }
+  const hosts = new Set(asks.map((a) => a.host));
+  const open = before.map((q) => reasked.find((x) => x.id === q.id) ?? q).filter((q) => q.state === "open" && hosts.has(hostOfQuestion(q)));
+  const lines = [];
+  for (const q of before) {
+    const host = hostOfQuestion(q);
+    if (q.state !== "open" || !host || hosts.has(host))
+      continue;
+    const [name, port] = host.split(/:(?=\d+$)/);
+    const listing = repos.filter((r) => [...r.hosts, ...r.modules.flatMap((m) => m.hosts)].some((p) => hostMatches(p, name, port ? Number(port) : void 0))).map((r) => r.id);
+    if (!listing.length)
+      continue;
+    const why = `${listing.join(", ")} ${listing.length === 1 ? "lists" : "list"} ${host} under hosts in repos.manifest.yaml`;
+    await retireQuestion(root, q.id, { why, at });
+    lines.push(`Retired ${q.id} (${q.question}): ${why}.`);
+  }
+  for (const q of raised)
+    lines.push(`Calls to ${hostOfQuestion(q)} join no repo: no repo lists it under hosts. Asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n> (1 is ${q.options[0].label}). If several repos answer on it (a shared gateway or platform host), don't pick one: list it under hosts on each of them in repos.manifest.yaml (with each one's basePath where the path tells them apart), and the question retires itself. If a system outside the estate answers on it, pick an outside system (another team's or a vendor's): it goes into the profile with the host as its alias.`);
+  for (const q of reasked)
+    lines.push(`Re-asked ${q.id} (${q.question}): it now offers an outside system, another team's or a vendor's, for a host no repo of the estate answers on.`);
+  for (const q of open)
+    lines.push(`Still open: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then ${o.rerun ?? HOSTS_RERUN}.`);
+  return { raised, reasked, open, lines };
+}
+
+export {
+  askHosts
+};

package/dist/chunk-LTQANUDH.js

@@ -0,0 +1,119 @@
+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 {
+  estimateOf
+} from "./chunk-X4W4XXWP.js";
+import {
+  changeMapBody,
+  changeMapOf
+} from "./chunk-67J3VZBA.js";
+import "./chunk-5YIBJXGB.js";
+import "./chunk-UYYN2IUZ.js";
+import "./chunk-P3TKKBAH.js";
+import "./chunk-7YYEKTYF.js";
+import "./chunk-XEG3FE2R.js";
+import {
+  knowledgeAppliesMarkdown,
+  readKnowledgeApplies
+} from "./chunk-KC5DROFC.js";
+import "./chunk-RK6MKKKP.js";
+import {
+  readRound,
+  reviewedGates,
+  roundsOf
+} from "./chunk-47QE246J.js";
+import "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-N4QZJJVB.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/handoff-review.js
+var days = (d) => `${d.p20}\u2013${d.p80} days (most likely ${d.p50})`;
+async function handoffReview(root, change) {
+  const lines = [];
+  lines.push("### What it changes", "");
+  const map = await changeMapOf(root, change).catch(() => void 0);
+  if (map && map.flows > 0) {
+    lines.push("```mermaid", changeMapBody(change, map).mermaid.trimEnd(), "```", "");
+    lines.push(`From ${map.flows} target flow${map.flows === 1 ? "" : "s"} in ${map.source}.`, "");
+  } else
+    lines.push("No target flows yet: the architecture stage writes them.", "");
+  const applies = await readKnowledgeApplies(root, change).catch(() => void 0);
+  if (applies)
+    lines.push(knowledgeAppliesMarkdown(applies).trimEnd(), "");
+  lines.push("### Estimate", "");
+  const est = await estimateOf(root, change).catch(() => void 0);
+  if (est?.effort) {
+    lines.push(days(est.effort), "");
+    for (const d of est.drivers.filter((x) => x.count > 0).slice(0, 5))
+      lines.push(`- ${d.what}: ${d.count}`);
+    if (est.needsClass)
+      lines.push(`- ${est.needsClass} unit${est.needsClass === 1 ? "" : "s"} not sized yet`);
+    lines.push("");
+  } else
+    lines.push(est ? "Not sized yet: the org pack's estimates don't cover these units." : "Not sized yet.", "");
+  lines.push("### Since the last round", "");
+  const reviewed = await reviewedGates(root, change).catch(() => []);
+  const openIds = async (gate, n) => new Set((await readRound(root, change, gate, n)).findings.filter(({ finding: f }) => f.state === "open").map(({ finding: f }) => f.id));
+  const code = (ids) => ids.map((i) => `\`${i}\``).join(", ");
+  let any = false;
+  for (const gate of reviewed) {
+    const rounds = await roundsOf(root, change, gate);
+    if (!rounds.length)
+      continue;
+    any = true;
+    if (rounds.length === 1) {
+      lines.push(`- ${gate} gate: the first round.`);
+      continue;
+    }
+    const [before, now] = [rounds.at(-2), rounds.at(-1)];
+    const [was, is] = [await openIds(gate, before), await openIds(gate, now)];
+    const closed = [...was].filter((i) => !is.has(i)).sort();
+    const added = [...is].filter((i) => !was.has(i)).sort();
+    const still = [...is].filter((i) => was.has(i)).length;
+    lines.push(`- ${gate} gate, round ${now} against round ${before}: ${closed.length} closed${closed.length ? ` (${code(closed)})` : ""}, ${added.length} new${added.length ? ` (${code(added)})` : ""}, ${still} still open.`);
+  }
+  if (!any)
+    lines.push("No gate has been reviewed yet.");
+  lines.push("");
+  lines.push("### Findings still open", "");
+  const gates = await reviewedGates(root, change).catch(() => []);
+  const open = [];
+  for (const gate of gates) {
+    const rounds = await roundsOf(root, change, gate);
+    if (!rounds.length)
+      continue;
+    for (const { finding: f } of (await readRound(root, change, gate, rounds.at(-1))).findings)
+      if (f.state === "open")
+        open.push({ gate, severity: f.severity, summary: f.summary, id: f.id });
+  }
+  if (!gates.length)
+    lines.push("No gate has been reviewed yet.", "");
+  else if (!open.length)
+    lines.push("None open.", "");
+  else {
+    const order = ["blocking", "gap", "risk", "idea"];
+    for (const f of open.sort((a, b) => order.indexOf(a.severity) - order.indexOf(b.severity)))
+      lines.push(`- **${f.severity}** (${f.gate}): ${f.summary} \`${f.id}\``);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+export {
+  handoffReview
+};

package/dist/chunk-LVGBKKSM.js

@@ -0,0 +1,282 @@
+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-WARBF2KY.js";
+import "./chunk-VOGCSYOI.js";
+import {
+  changeFolder,
+  changeStore
+} from "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import {
+  estateFacts,
+  estateRepos,
+  hostAliases,
+  joinReposOf,
+  outsideProfileSystems,
+  outsideSystems
+} from "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import {
+  attachToChange,
+  readChangeInputs,
+  readVendorSpec
+} from "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  PROTOTYPE_GROUPS,
+  comparePrototype,
+  factsDirOf,
+  inputsDirOf,
+  isPrototypeType,
+  joinConventions,
+  parseFacts,
+  prototypeArchitectureSection
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/prototype-commands.js
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var PROTOTYPE_CLI_WORDS = {
+  usage: (change, repo) => `--prototype names a prototype repo, attached on its own: atticus change attach ${change} --prototype ${repo}`,
+  noChange: (change) => `There is no change ${change}: atticus change list shows them.`,
+  noRepo: (repo) => `There is no repo ${repo} in the manifests (org-pack/profiles/<platform>/repos.manifest.yaml); atticus repo add adds one.`,
+  notPrototype: (repo, type) => `${repo} isn't a prototype: repos.manifest.yaml types it ${type}. A prototype is typed prototype there; then attach it.`,
+  notRead: (repo) => `${repo} has no verified facts yet: read it with /atticus-map ${repo}, then atticus verify ${repo}.`,
+  about: (repo, about) => `${repo} (a prototype)${about ? `: ${about.text}${about.trust === "suggested" ? " (a draft nobody has confirmed)" : ""}` : ": nothing says what it is yet (atticus repo describe)."}`,
+  counts: (c) => {
+    const all = PROTOTYPE_GROUPS.reduce((n, g) => n + c[g], 0);
+    return `${all} call${all === 1 ? "" : "s"} compared with the estate: ${c.exists} exist${c.exists === 1 ? "s" : ""}, ${c.changes} change${c.changes === 1 ? "s" : ""}, ${c.new} new, ${c.vendor} only a vendor provides.`;
+  },
+  group: {
+    exists: "Exists: the estate serves it as the prototype needs.",
+    changes: "Changes: the estate serves the operation, but not as the prototype needs.",
+    new: "New: nothing in the estate serves it.",
+    vendor: "Vendor: only a vendor provides it, so it needs a route through the external gateway."
+  },
+  /** The vendor group's heading when another team's system provides one of its calls (O2). */
+  outside: "Outside: only a vendor or another team's system provides it; a vendor's needs a route through the external gateway, another team's is called as it publishes it.",
+  left: (n) => `${n} call${n === 1 ? "" : "s"} of the prototype reach${n === 1 ? "es" : ""} nothing in it and ${n === 1 ? "isn't" : "aren't"} compared:`,
+  attached: (path) => `Attached as ${path}: the change's feature and architecture stages read it as data, citing it by line.`,
+  unchanged: (path) => `The comparison is what ${path} already says: nothing to attach again.`,
+  footprint: (c) => {
+    const parts = [
+      c.repos.length ? `repos ${c.repos.join(", ")}` : "",
+      c.endpoints.length ? `Endpoints ${c.endpoints.join(", ")}` : "",
+      c.vendorOperations.length ? `vendor operations ${c.vendorOperations.join(", ")}` : ""
+    ].filter(Boolean);
+    return parts.length ? `Its footprint now has ${parts.join("; ")}.` : "Its footprint is unchanged: every call exists as the prototype needs, or is new.";
+  },
+  docTitle: (repo) => `# What the prototype ${repo} asks of the estate`
+};
+var SPECS = /* @__PURE__ */ new Set(["openapi", "swagger"]);
+async function loadPrototypeComparison(root, repo, io) {
+  const { op, inputs } = await intakeContext(root, io);
+  const manifest = estateRepos(op).find((r) => r.id === repo);
+  if (!manifest)
+    return { error: PROTOTYPE_CLI_WORDS.noRepo(repo) };
+  if (!isPrototypeType(manifest.type))
+    return { error: PROTOTYPE_CLI_WORDS.notPrototype(repo, manifest.type) };
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => "");
+  const parsed = text.trim() ? parseFacts(text) : void 0;
+  if (!parsed?.ok || !parsed.facts.length || parsed.facts.some((f) => f.verified === "none"))
+    return { error: PROTOTYPE_CLI_WORDS.notRead(repo) };
+  const estate = await estateFacts(root, op, repo);
+  const systems = outsideProfileSystems(op);
+  const vendors = [];
+  for (const d of inputs.documents) {
+    if (!d.id || d.supersededBy || !SPECS.has(d.classification))
+      continue;
+    const system = systems.find((s) => s.id === d.systems[0]);
+    if (!system)
+      continue;
+    const body = await readFile(join(inputsDirOf(root), ...d.path.split("/").slice(1)), "utf8");
+    const spec = readVendorSpec(d.path, body, system.id);
+    if (!spec)
+      continue;
+    const prior = vendors.find((v) => v.system === system.id);
+    const operations = spec.operations.map((o) => ({
+      id: o.id,
+      method: o.method,
+      path: o.path,
+      fullPath: o.fullPath,
+      cite: o.cite,
+      ...o.auth ? { auth: o.auth } : {},
+      scopes: o.scopes,
+      fields: [
+        ...o.request.map((f) => ({ side: "request", f })),
+        ...o.response.map((f) => ({ side: "response", f }))
+      ].map(({ side, f }) => ({
+        side,
+        name: f.name,
+        ...f.type ? { type: f.type } : {},
+        ...f.required !== void 0 ? { required: f.required } : {},
+        ...f.enum ? { enum: f.enum } : {},
+        ...f.in === "header" ? { in: f.in } : {},
+        at: f.cite
+      })),
+      ...o.errors ? { errors: o.errors.map((e) => ({ status: e.status, at: e.cite })) } : {}
+    }));
+    if (prior) {
+      prior.operations.push(...operations);
+      prior.hosts.push(...spec.hosts);
+    } else
+      vendors.push({
+        system: system.id,
+        names: [system.name, ...system.aliases],
+        hosts: [.../* @__PURE__ */ new Set([...spec.hosts, ...hostAliases(system.aliases)])],
+        ...system.boundary === "vendor" ? {} : { boundary: "internal" },
+        operations
+      });
+  }
+  const comparison = comparePrototype({
+    prototype: {
+      repo,
+      facts: parsed.facts,
+      ...manifest.component ? { component: manifest.component } : {}
+    },
+    estate: joinReposOf(op, estate.repos),
+    vendors,
+    outside: outsideSystems(op),
+    ...joinConventions(op)
+  });
+  return {
+    repo,
+    ...manifest.description ? { about: manifest.description } : {},
+    comparison,
+    notes: estate.notes,
+    architecture: prototypeArchitectureSection(comparison, parsed.facts),
+    systemOf: Object.fromEntries(estateRepos(op).flatMap((r) => r.system ? [[r.id, r.system]] : []))
+  };
+}
+var where = (e) => `${e.repo} ${e.at}`;
+function callLines(c) {
+  const other = c.estate ? `; ${where(c.estate.entry)}` : c.vendor?.at ? `; ${c.vendor.name} ${c.vendor.at}` : "";
+  return [
+    `  ${c.sentence}`,
+    `    ${c.call.repo} ${c.call.at} \u2192 ${c.lands.at}${other}`,
+    ...(c.candidates ?? []).map((x) => `    ? ${where(x)}`),
+    ...c.differences.map((d) => `    - ${d.message}`)
+  ];
+}
+function prototypeLines(l) {
+  const c = l.comparison;
+  const out = [PROTOTYPE_CLI_WORDS.about(l.repo, l.about), PROTOTYPE_CLI_WORDS.counts(c.counts)];
+  for (const g of PROTOTYPE_GROUPS) {
+    const calls = c.calls.filter((x) => x.group === g);
+    if (!calls.length)
+      continue;
+    out.push(g === "vendor" && calls.some((x) => x.vendor?.boundary === "internal") ? PROTOTYPE_CLI_WORDS.outside : PROTOTYPE_CLI_WORDS.group[g]);
+    for (const x of calls)
+      out.push(...callLines(x));
+  }
+  if (c.left.length) {
+    out.push(PROTOTYPE_CLI_WORDS.left(c.left.length));
+    for (const x of c.left)
+      out.push(`  ${x.why} (${x.call.at})`);
+  }
+  out.push(...l.notes);
+  return out;
+}
+function prototypeDocument(l) {
+  return {
+    name: `prototype-${l.repo}.md`,
+    text: [
+      PROTOTYPE_CLI_WORDS.docTitle(l.repo),
+      "",
+      ...prototypeLines(l),
+      "",
+      ...l.architecture
+    ].join("\n")
+  };
+}
+var sorted = (xs) => [...new Set(xs)].sort();
+var ATTACHED = /^prototype-(.+)\.md$/;
+async function changePrototypes(root, change) {
+  const quiet = { out: () => void 0, err: () => void 0 };
+  const files = (await readChangeInputs(changeFolder(root, change))).files.filter((f) => !f.supersededBy && ATTACHED.test(f.name)).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  const prototypes = [];
+  for (const f of files) {
+    const repo = ATTACHED.exec(f.name)[1];
+    const got = await loadPrototypeComparison(root, repo, quiet);
+    prototypes.push("error" in got ? { repo, attached: f.path, problem: got.error } : {
+      repo,
+      attached: f.path,
+      ...got.about ? { about: { text: got.about.text, trust: got.about.trust } } : {},
+      comparison: got.comparison
+    });
+  }
+  return { prototypes };
+}
+async function attachPrototype(root, change, repo, o, io) {
+  const store = changeStore(root);
+  const c = await store.read(change).catch(() => void 0);
+  if (!c) {
+    io.err(PROTOTYPE_CLI_WORDS.noChange(change));
+    return 1;
+  }
+  const got = await loadPrototypeComparison(root, repo, io);
+  if ("error" in got) {
+    io.err(got.error);
+    return 1;
+  }
+  const doc = prototypeDocument(got);
+  const dir = changeFolder(root, c.id);
+  const before = (await readChangeInputs(dir)).files.find((f) => f.name === doc.name && !f.supersededBy);
+  const r = await attachToChange(dir, [{ name: doc.name, bytes: new TextEncoder().encode(doc.text) }], {
+    by: o.by,
+    at: (o.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+    ...before ? { replaces: before.path } : {}
+  });
+  const added = r.added[0]?.path;
+  const path = added ?? before?.path ?? `inputs/${doc.name}`;
+  const cmp = got.comparison;
+  const fresh = await store.read(c.id);
+  const touches = {
+    ...fresh.touches,
+    repos: sorted([...fresh.touches.repos, ...cmp.repos]),
+    records: sorted([...fresh.touches.records, ...cmp.endpoints, ...cmp.vendorOperations])
+  };
+  const systems = sorted([
+    ...fresh.systems,
+    ...cmp.vendors,
+    ...cmp.repos.flatMap((x) => got.systemOf[x] ? [got.systemOf[x]] : [])
+  ]);
+  await store.write({ ...fresh, systems, touches });
+  if (o.json) {
+    io.out(JSON.stringify({
+      prototype: repo,
+      ...got.about ? { about: got.about } : {},
+      comparison: cmp,
+      attached: path,
+      touches: { repos: touches.repos, records: touches.records },
+      systems
+    }, null, 2));
+    return 0;
+  }
+  for (const l of prototypeLines(got))
+    io.out(l);
+  io.out(added ? PROTOTYPE_CLI_WORDS.attached(path) : PROTOTYPE_CLI_WORDS.unchanged(path));
+  io.out(PROTOTYPE_CLI_WORDS.footprint(cmp));
+  return 0;
+}
+export {
+  PROTOTYPE_CLI_WORDS,
+  attachPrototype,
+  changePrototypes,
+  loadPrototypeComparison,
+  prototypeDocument,
+  prototypeLines
+};

package/dist/chunk-MF7QH4AX.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-N4QZJJVB.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  changesDirOf,
+  require_dist
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.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-Y7KBQ4BD.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
+};