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

package/dist/chunk-Q4D5X7QB.js

@@ -0,0 +1,264 @@
+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-ZNCEKR4J.js";
+import "./chunk-VOGCSYOI.js";
+import {
+  changeFolder,
+  changeStore
+} from "./chunk-XY3P7JW7.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import {
+  estateFacts,
+  estateRepos,
+  joinReposOf,
+  outsideSystems
+} from "./chunk-27NKUS3X.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import {
+  attachToChange,
+  readChangeInputs,
+  readVendorSpec
+} from "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  PROTOTYPE_GROUPS,
+  comparePrototype,
+  factsDirOf,
+  inputsDirOf,
+  isPrototypeType,
+  parseFacts
+} from "./chunk-S2A7YC3Q.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."
+  },
+  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 = op.profiles.flatMap((p) => p.profile?.systems ?? []);
+  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] && s.boundary === "vendor");
+    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 } : {},
+        at: f.cite
+      }))
+    }));
+    if (prior) {
+      prior.operations.push(...operations);
+      prior.hosts.push(...spec.hosts);
+    } else
+      vendors.push({
+        system: system.id,
+        names: [system.name, ...system.aliases],
+        hosts: [...spec.hosts],
+        operations
+      });
+  }
+  const comparison = comparePrototype({
+    prototype: {
+      repo,
+      facts: parsed.facts,
+      ...manifest.component ? { component: manifest.component } : {}
+    },
+    estate: joinReposOf(op, estate.repos),
+    vendors,
+    outside: outsideSystems(op)
+  });
+  return {
+    repo,
+    ...manifest.description ? { about: manifest.description } : {},
+    comparison,
+    notes: estate.notes,
+    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(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), ""].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-Q5AMFEWD.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 {
+  aiJsonSchemas,
+  catalogJsonSchemas,
+  deserializeRecord,
+  executorJsonSchemas,
+  loadOrgPack,
+  openApiDocument,
+  orgPackJsonSchemas,
+  recordPath,
+  rulesJsonSchemas,
+  serializeRecord,
+  workspaceJsonSchemas
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/commands.js
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+async function schemaExport(dir, io) {
+  const groups = [
+    ["catalog", catalogJsonSchemas()],
+    ["workspace", workspaceJsonSchemas()],
+    ["rules", rulesJsonSchemas()],
+    ["orgpack", orgPackJsonSchemas()],
+    ["ai", aiJsonSchemas()],
+    ["executors", executorJsonSchemas()]
+  ];
+  let n = 0;
+  for (const [group, schemas] of groups) {
+    await mkdir(join(dir, group), { recursive: true });
+    for (const [name, schema] of Object.entries(schemas)) {
+      await writeFile(join(dir, group, `${name}.json`), JSON.stringify(schema, null, 2) + "\n", "utf8");
+      n++;
+    }
+  }
+  await mkdir(join(dir, "api"), { recursive: true });
+  await writeFile(join(dir, "api", "openapi.json"), JSON.stringify(openApiDocument(), null, 2) + "\n", "utf8");
+  io.out(`Wrote ${n} schemas and the API document to ${dir}`);
+  return n;
+}
+async function* yamlFiles(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const e of entries) {
+    const full = join(dir, e.name);
+    if (e.isDirectory())
+      yield* yamlFiles(full);
+    else if (e.isFile() && /\.ya?ml$/i.test(e.name))
+      yield full;
+  }
+}
+async function catalogValidate(dir, options, io) {
+  const summary = {
+    files: 0,
+    invalid: 0,
+    misplaced: 0,
+    notCanonical: 0,
+    fixed: 0
+  };
+  for await (const file of yamlFiles(dir)) {
+    summary.files++;
+    const rel = relative(dir, file).split(sep).join("/");
+    const text = await readFile(file, "utf8");
+    const result = deserializeRecord(text);
+    if (!result.ok) {
+      summary.invalid++;
+      for (const issue of result.issues)
+        io.err(`${rel}: ${issue.path || "(root)"}: ${issue.message}`);
+      continue;
+    }
+    const expected = recordPath(result.record);
+    if (rel !== expected && !rel.endsWith("/" + expected)) {
+      summary.misplaced++;
+      io.err(`${rel}: should be at ${expected}`);
+    }
+    const canonical = serializeRecord(result.record);
+    if (canonical !== text.replace(/\r\n/g, "\n")) {
+      if (options.fix) {
+        await writeFile(file, canonical, "utf8");
+        summary.fixed++;
+        io.out(`${rel}: rewritten in canonical form`);
+      } else {
+        summary.notCanonical++;
+        io.err(`${rel}: not in canonical form (run with --fix)`);
+      }
+    }
+  }
+  const problems = summary.invalid + summary.misplaced + summary.notCanonical;
+  io.out(`${summary.files} files checked: ${problems === 0 ? "all valid" : `${problems} with problems`}` + (summary.fixed ? `, ${summary.fixed} fixed` : ""));
+  return summary;
+}
+async function orgPackValidate(dir, io) {
+  const op = await loadOrgPack(dir);
+  for (const p of op.problems)
+    io.err(`${p.file}${p.path ? ` (${p.path})` : ""}: ${p.message}`);
+  const counts = [
+    `${op.profiles.length} profiles`,
+    `${op.patterns.length} patterns`,
+    `${op.dialects.length} dialects`,
+    `${op.checklists.length} checklist packs`,
+    `${op.skills.length} skills`,
+    `${op.serviceRequests.length} request templates`,
+    ...op.repoTypes.length ? [`${op.repoTypes.length} repo types`] : []
+  ].join(", ");
+  io.out(`${counts}${op.defaulted.length ? `; defaults used for ${op.defaulted.join(", ")}` : ""}`);
+  io.out(op.problems.length === 0 ? "Org pack is valid" : `${op.problems.length} problems`);
+  return op.problems.length === 0 ? 0 : 1;
+}
+export {
+  catalogValidate,
+  orgPackValidate,
+  schemaExport
+};

package/dist/chunk-QRAOANID.js

@@ -0,0 +1,214 @@
+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 {
+  contextFlags,
+  contextLines
+} from "./chunk-R6RY4Q5T.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  findNeeds,
+  markNeed,
+  readNeeds
+} from "./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 {
+  readKnowledge
+} from "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-T6AIP7H5.js";
+import "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import {
+  RuntimeConfigError,
+  runtimeForCli
+} from "./chunk-CNUKCS2T.js";
+import {
+  changesDirOf,
+  changesRelOf,
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/needs-commands.js
+import { readdir } from "node:fs/promises";
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+var stamp = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+var forWords = (t) => t === "change" ? "the change" : t.replace(":", " ");
+async function changeNeeds(root, change, o, deps, io) {
+  let runtime = deps.runtime;
+  if (!runtime)
+    try {
+      runtime = (await runtimeForCli(root, o.mode ? { mode: o.mode } : {})).runtime;
+    } catch (e) {
+      if (e instanceof RuntimeConfigError) {
+        io.err(e.message);
+        return 2;
+      }
+      throw e;
+    }
+  const k = await readKnowledge(root, { cacheRoot: root });
+  if (!k.items.length) {
+    io.err("There are no knowledge items to check the change against yet. Run atticus sources sync, then atticus knowledge scan.");
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const r = await findNeeds(root, change, {
+    runtime,
+    orgPack: op,
+    ...deps.now ? { now: deps.now } : {},
+    ...o.resume ? { resume: o.resume } : {},
+    maxAttempts: o.attempts ?? 3,
+    ...o.context ? { context: o.context } : {}
+  }).catch((e) => {
+    io.err(e.message);
+    return void 0;
+  });
+  if (!r)
+    return 2;
+  if (o.json) {
+    io.out(JSON.stringify(r, null, 2));
+    return r.status === "failed" ? 1 : 0;
+  }
+  if (r.status === "waiting") {
+    io.out(`Handed the change's needs to your assistant (run ${r.runId}). When it is done: atticus handoff done ${r.runId}, then atticus change needs ${change} --resume ${r.runId}`);
+    return 0;
+  }
+  if (r.status === "failed") {
+    io.err(`No answer passed the checks after ${plural(r.attempts.length, "attempt")}: ${r.attempts.at(-1)?.problems.join("; ") ?? "no run"}. Nothing was written.`);
+    return 1;
+  }
+  for (const l of contextLines(r.context))
+    io.out(l);
+  const f = r.file;
+  const open = f.needs.filter((n) => n.status === "open");
+  io.out(`${change} needs ${plural(f.needs.length, "thing")} from the organisation (${open.length} open), each checked against the change's own words.`);
+  for (const n of f.needs)
+    io.out(`  ${line(n)}`);
+  io.out(`Written to ${changesRelOf(root)}/${change}/needs.yaml and needs.md. Mark each with atticus needs done or atticus needs skip.`);
+  return 0;
+}
+function line(n) {
+  const box = n.status === "open" ? "[ ]" : n.status === "done" ? "[x]" : "[-]";
+  return `${box} ${n.title} (${n.kind}, for ${forWords(n.for)})${n.leadTime ? `, ${n.leadTime}` : ""}${n.handledBy ? `, ${n.handledBy}` : ""}`;
+}
+async function changeIds(root) {
+  return (await readdir(changesDirOf(root), { withFileTypes: true }).catch(() => [])).filter((e) => e.isDirectory() && e.name !== "archive").map((e) => e.name).sort();
+}
+async function needsList(root, o, io) {
+  const k = await readKnowledge(root, { cacheRoot: root });
+  const rows = [];
+  for (const c of o.change ? [o.change] : await changeIds(root)) {
+    const f = await readNeeds(root, c);
+    for (const n of f?.needs ?? [])
+      if (o.all || n.status === "open") {
+        const rv = k.reviews[n.item];
+        rows.push({
+          ...n,
+          change: c,
+          ...rv && (rv.state === "verified" || rv.state === "corrected") ? { verified: rv.by } : {}
+        });
+      }
+  }
+  if (o.json) {
+    io.out(JSON.stringify(rows, null, 2));
+    return 0;
+  }
+  if (!rows.length) {
+    io.out(o.change ? `${o.change} has no ${o.all ? "" : "open "}needs. atticus change needs ${o.change} finds them.` : "No change has an open need.");
+    return 0;
+  }
+  for (const l of table(["CHANGE", "NEED", "KIND", "FOR", "LEAD TIME", "HANDLED BY", "STATE"], rows.map((n) => [
+    n.change,
+    `${n.item}${n.verified ? " \u2713" : ""}`,
+    n.kind,
+    forWords(n.for),
+    n.leadTime ?? "",
+    n.handledBy ?? "",
+    n.status
+  ])))
+    io.out(l);
+  if (rows.some((n) => n.verified))
+    io.out("\u2713 a person verified the knowledge item it comes from");
+  return 0;
+}
+async function needsCli(root, positionals, values, io, who, deps = {}) {
+  const [group, command, a, b] = positionals;
+  const str = (v) => typeof v === "string" && v.trim() ? v : void 0;
+  const json = values.json === true;
+  if (group === "change" && command === "needs") {
+    if (!a) {
+      io.err("Usage: atticus change needs <change> [--mode m] [--resume run] [--attempts 3]");
+      return 2;
+    }
+    const attempts = Number(str(values.attempts) ?? "3");
+    if (!Number.isInteger(attempts) || attempts < 1 || attempts > 10) {
+      io.err("--attempts is a whole number from 1 to 10.");
+      return 2;
+    }
+    const flags = contextFlags(values);
+    if ("error" in flags) {
+      io.err(flags.error);
+      return 2;
+    }
+    return changeNeeds(root, a, {
+      attempts,
+      json,
+      context: flags.context,
+      ...str(values.resume) ? { resume: str(values.resume) } : {},
+      ...str(values.mode) ? { mode: str(values.mode) } : {}
+    }, deps, io);
+  }
+  if (group !== "needs")
+    return void 0;
+  if (command === "done" || command === "skip" || command === "reopen") {
+    if (!a || !b) {
+      io.err(`Usage: atticus needs ${command} <change> <item> [--for target]${command === "skip" ? " --note why" : " [--note text]"}`);
+      return 2;
+    }
+    const r = await markNeed(root, a, b, {
+      status: command === "done" ? "done" : command === "skip" ? "not-needed" : "open",
+      by: who(),
+      at: stamp(deps.now ?? /* @__PURE__ */ new Date()),
+      ...str(values.note) ? { note: str(values.note) } : {},
+      ...str(values.for) ? { for: str(values.for) } : {}
+    });
+    if ("error" in r) {
+      io.err(r.error);
+      return 2;
+    }
+    if (json)
+      io.out(JSON.stringify(r.need, null, 2));
+    else
+      io.out(`${r.need.title} (${forWords(r.need.for)}) is ${r.need.status === "not-needed" ? "not needed" : r.need.status} for ${a}${r.need.by && r.need.status !== "open" ? `, by ${r.need.by}` : ""}. Commit ${changesRelOf(root)}/${a}/needs.yaml with the change.`);
+    return 0;
+  }
+  if (command && command !== "list") {
+    io.err("Usage: atticus needs [--change id] [--all] | needs done|skip|reopen <change> <item>");
+    return 2;
+  }
+  return needsList(root, {
+    json,
+    all: values.all === true,
+    ...str(values.change) ? { change: str(values.change) } : {}
+  }, io);
+}
+export {
+  changeNeeds,
+  needsCli,
+  needsList
+};