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

package/dist/chunk-BVS2K73A.js

@@ -0,0 +1,33 @@
+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 {
+  citesCli,
+  fileInRepo,
+  uiCiteRoutes
+} from "./chunk-GK6XK5SP.js";
+import "./chunk-5FEOD73Z.js";
+import "./chunk-7UFQZXZA.js";
+import "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-OLWFG75W.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 "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  citesCli,
+  fileInRepo,
+  uiCiteRoutes
+};

package/dist/chunk-BWZ77RQT.js

@@ -0,0 +1,25 @@
+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 {
+  runtimeForCli
+} from "./chunk-CNUKCS2T.js";
+
+// packages/cli/dist/judging.js
+async function judgingRuntime(root, given) {
+  if (given === null)
+    return void 0;
+  if (given)
+    return given;
+  try {
+    return (await runtimeForCli(root)).runtime;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  judgingRuntime
+};

package/dist/chunk-BYBUDX4T.js

@@ -0,0 +1,163 @@
+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 {
+  ASSISTANT_FORMATS,
+  assistantTier,
+  probeFileOf,
+  probeTier,
+  writeProbe
+} from "./chunk-V5PKHHQQ.js";
+import "./chunk-KJPMEAI4.js";
+import {
+  AssistantId,
+  external_exports,
+  loadOrgPack,
+  orgPackDirOf,
+  runsDirOf,
+  runsRelOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/probe-commands.js
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var OPEN_HOURS = 24;
+var Challenge = external_exports.strictObject({
+  schemaVersion: external_exports.literal(1),
+  assistant: AssistantId,
+  code: external_exports.string().regex(/^[0-9a-f]{8}$/),
+  started: external_exports.iso.datetime(),
+  maxTokens: external_exports.number().int().min(1e3).optional()
+});
+var probeDir = (root) => join(runsDirOf(root), "probe");
+var probeRel = (root) => `${runsRelOf(root)}/probe`;
+function startIn(id) {
+  const f = ASSISTANT_FORMATS[id];
+  return id === "agents-md" ? `In ${f.typeIn}, ask it to follow ${f.commandPath("atticus-probe")}.` : `In ${f.typeIn}, run /atticus-probe.`;
+}
+async function probeCommand(root, o, io, deps = {}) {
+  const rt = (await loadOrgPack(orgPackDirOf(root))).runtime;
+  if (rt.ai === "off") {
+    io.err("AI is off here (runtime.yaml): there is no assistant to probe.");
+    return 1;
+  }
+  const want = o.assistant ?? rt.assistants.default;
+  const id = AssistantId.safeParse(want);
+  if (!id.success || !rt.assistants.allowed.includes(id.data)) {
+    io.err(`runtime.yaml doesn't allow ${want} here: it allows ${rt.assistants.allowed.join(", ")}.`);
+    return 2;
+  }
+  const assistant = id.data;
+  const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+  const challenge = {
+    schemaVersion: 1,
+    assistant,
+    code: deps.code?.() ?? randomBytes(4).toString("hex"),
+    started: now.toISOString(),
+    ...o.maxTokens !== void 0 ? { maxTokens: o.maxTokens } : {}
+  };
+  const dir = probeDir(root);
+  await rm(dir, { recursive: true, force: true });
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, "probe.json"), `${JSON.stringify(challenge, null, 2)}
+`, "utf8");
+  await writeFile(join(dir, "challenge.md"), [
+    "# Atticus capability probe",
+    "",
+    `Code: ${challenge.code}`,
+    "",
+    `Atticus wrote this file at ${challenge.started} for /atticus-probe. The steps of /atticus-probe say what to do with the code.`,
+    ""
+  ].join("\n"), "utf8");
+  const rel = probeRel(root);
+  const name = ASSISTANT_FORMATS[assistant].name;
+  const result = probeFileOf(assistant);
+  if (o.json) {
+    io.out(JSON.stringify({
+      assistant,
+      challenge: `${rel}/challenge.md`,
+      answerFile: `${rel}/answer.txt`,
+      result,
+      started: challenge.started,
+      expires: new Date(now.getTime() + OPEN_HOURS * 36e5).toISOString(),
+      ...o.maxTokens !== void 0 ? { maxTokens: o.maxTokens } : {}
+    }, null, 2));
+    return 0;
+  }
+  io.out(`Probing ${name} (another assistant runtime.yaml allows: --assistant <id>).`);
+  io.out(`${startIn(assistant)} It asks the assistant to open ${rel}/challenge.md, write the code it holds to ${rel}/answer.txt, and run atticus probe answer <code> itself.`);
+  io.out("An assistant that can't run commands gives you a line to paste in this terminal instead: atticus probe answer <code> --pasted.");
+  io.out("A chat with no /atticus-probe (a web chat) can't open files here: run atticus probe answer none --pasted.");
+  if (o.maxTokens === void 0)
+    io.out("Give your model's limit, the most tokens it takes in one prompt, with --max-tokens <n> on the answer if you know it: Atticus never guesses it.");
+  else
+    io.out(`Model limit: ${o.maxTokens} tokens, as you stated it.`);
+  io.out(`The probe is open for ${OPEN_HOURS} hours. Nothing leaves this machine: the answer is checked here and kept in ${result}.`);
+  return 0;
+}
+var yesNo = (b) => b ? "yes" : "no";
+async function probeAnswerCommand(root, given, o, io, deps = {}) {
+  if (!given) {
+    io.err("Usage: atticus probe answer <code|none> [--pasted] [--max-tokens n] [--json]");
+    return 2;
+  }
+  const dir = probeDir(root);
+  const rel = probeRel(root);
+  const parsed = Challenge.safeParse(await readFile(join(dir, "probe.json"), "utf8").then((t2) => JSON.parse(t2)).catch(() => void 0));
+  if (!parsed.success) {
+    io.err("No probe is under way here: start one with atticus probe.");
+    return 1;
+  }
+  const c = parsed.data;
+  const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+  if (now.getTime() - Date.parse(c.started) > OPEN_HOURS * 36e5) {
+    io.err(`The probe started at ${c.started} is more than ${OPEN_HOURS} hours old: start a new one with atticus probe.`);
+    return 1;
+  }
+  const code = given.trim().toLowerCase();
+  if (code !== "none" && code !== c.code) {
+    io.err(`${given.trim()} isn't the code in ${rel}/challenge.md: the assistant didn't read that file. Nothing was recorded. Run /atticus-probe again, or answer none if the assistant can't open files.`);
+    return 1;
+  }
+  const answerFile = join(dir, "answer.txt");
+  const written = existsSync(answerFile) ? (await readFile(answerFile, "utf8").catch(() => "")).trim().toLowerCase() : void 0;
+  const read = code === c.code;
+  const write = written === c.code;
+  const run = o.pasted !== true;
+  const maxTokens = o.maxTokens ?? c.maxTokens;
+  const result = {
+    schemaVersion: 1,
+    assistant: c.assistant,
+    measured: now.toISOString(),
+    tier: probeTier({ read, write, run }),
+    read,
+    write,
+    run,
+    answered: run ? "command" : "pasted",
+    ...maxTokens !== void 0 ? { maxTokens } : {}
+  };
+  const file = await writeProbe(root, result);
+  await rm(dir, { recursive: true, force: true });
+  const rt = (await loadOrgPack(orgPackDirOf(root))).runtime;
+  const t = assistantTier({ ...rt, assistants: { allowed: [c.assistant], default: c.assistant } }, { probes: [result], now });
+  if (o.json) {
+    io.out(JSON.stringify({ ...result, file, how: t.how }, null, 2));
+    return 0;
+  }
+  const name = ASSISTANT_FORMATS[c.assistant].name;
+  io.out(`Measured ${name}: opened the file Atticus wrote: ${yesNo(read)}; wrote a file: ${write ? "yes" : written === void 0 ? "no" : `no (${rel}/answer.txt doesn't hold the code)`}; ran a command itself: ${run ? "yes" : "no (the line was pasted)"}. That is ${result.tier === 1 ? "agentic (tier 1)" : result.tier === 2 ? "batched hand-off (tier 2)" : "copy-paste (tier 3)"}.`);
+  io.out(`The first read of a repo: ${t.how}`);
+  io.out(maxTokens !== void 0 ? `Model limit: ${maxTokens} tokens, as stated.` : "No model limit was stated: atticus probe --max-tokens <n> measures again with it, or give --max-tokens <n> on each atticus map.");
+  io.out(`Kept in ${file}, on this machine only (never committed). atticus doctor, init, adopt and map --estimate say this tier from now on.`);
+  return 0;
+}
+export {
+  probeAnswerCommand,
+  probeCommand
+};

package/dist/chunk-BYZCY6SP.js

@@ -0,0 +1,230 @@
+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 {
+  renderTaskContext,
+  taskContext
+} from "./chunk-VPTTCYOC.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-7UFQZXZA.js";
+import {
+  changeFolder,
+  changeStore
+} from "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-OLWFG75W.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import {
+  attachToChange
+} from "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-T6AIP7H5.js";
+import "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  changesRelOf,
+  inputsDirOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/attach-commands.js
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join, relative, resolve, sep } from "node:path";
+var sha256 = (b) => createHash("sha256").update(b).digest("hex");
+async function filesUnder(dir) {
+  const out = [];
+  const walk = async (d) => {
+    for (const e of await readdir(d, { withFileTypes: true }).catch(() => []))
+      if (e.isDirectory())
+        await walk(join(d, e.name));
+      else if (e.isFile())
+        out.push(join(d, e.name));
+  };
+  await walk(dir);
+  return out;
+}
+async function metarepoInputs(root) {
+  const out = /* @__PURE__ */ new Map();
+  for (const f of await filesUnder(inputsDirOf(root)))
+    out.set(sha256(new Uint8Array(await readFile(f))), relative(root, f).split(sep).join("/"));
+  return out;
+}
+var AttachError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AttachError";
+  }
+};
+async function attachFiles(root, change, files, by, now = /* @__PURE__ */ new Date(), replaces) {
+  const c = await changeStore(root).read(change).catch(() => {
+    throw new AttachError("not-found", `There is no change ${change}: atticus change list shows them.`);
+  });
+  const known = await metarepoInputs(root);
+  return attachToChange(changeFolder(root, c.id), files, {
+    by,
+    at: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+    elsewhere: (h) => known.get(h),
+    ...replaces ? { replaces } : {}
+  });
+}
+async function promoteChangeInput(root, change, file) {
+  const c = await changeStore(root).read(change).catch(() => {
+    throw new AttachError("not-found", `There is no change ${change}: atticus change list shows them.`);
+  });
+  const name = file.replace(/^inputs\//, "");
+  if (!name || /[\\/]/.test(name) || name === "." || name === "..")
+    throw new AttachError("invalid", `Name one attached file, such as inputs/${basename(file) || "rules.pdf"}.`);
+  let bytes;
+  try {
+    bytes = new Uint8Array(await readFile(join(changeFolder(root, c.id), "inputs", name)));
+  } catch {
+    throw new AttachError("not-found", `inputs/${name} isn't attached to ${c.id}: atticus change attach ${c.id} adds it.`);
+  }
+  const { addToInbox } = await import("./chunk-WZ2BXIGG.js");
+  const r = await addToInbox(root, [{ name, bytes }]);
+  const added = r.added[0];
+  if (!added)
+    throw new AttachError("invalid", `inputs/${name}: ${r.refused[0]?.why ?? "refused"}`);
+  return {
+    path: added.path,
+    note: `Copied to ${added.path}: general knowledge, read at the next atticus sources sync. ${c.id} keeps its copy. Commit both through a pull request.`
+  };
+}
+function attachedLine(rel, a) {
+  const what = a.read === "text" ? `${a.kind}, ${a.format}; read, cited by ${a.citeBy}` : a.kind === "image" ? "a picture: your assistant looks at it in the chat; Atticus doesn't read pictures" : `${a.format}: no reader takes it, so the steps name it without its text`;
+  return `Attached ${rel}/${a.path} (${what})${a.supersedes ? `, a newer version of ${a.supersedes}` : ""}${a.defences ? `; the defences found ${a.defences.risk} risk` : ""}.`;
+}
+async function changeAttachCli(root, change, paths, o, io) {
+  if (change && o.prototype) {
+    if (paths.length) {
+      const { PROTOTYPE_CLI_WORDS } = await import("./chunk-KUUQR4HA.js");
+      io.err(PROTOTYPE_CLI_WORDS.usage(change, o.prototype));
+      return 2;
+    }
+    const { attachPrototype } = await import("./chunk-KUUQR4HA.js");
+    return attachPrototype(root, change, o.prototype, { by: o.by, ...o.json ? { json: true } : {}, ...o.now ? { now: o.now } : {} }, io);
+  }
+  if (change && o.like) {
+    if (paths.length) {
+      io.err("--like names an archived change, attached on its own: atticus change attach add-refund-window --like raise-transfer-limit");
+      return 2;
+    }
+    const { attachPastChange, findPastChange } = await import("./chunk-HVIMMDVB.js");
+    const folder = await findPastChange(root, o.like);
+    if (!folder) {
+      io.err(`There is no archived change ${o.like}: atticus change similar "<what it is about>" lists them.`);
+      return 1;
+    }
+    try {
+      const name = await attachPastChange(root, change, folder, o.by, o.now);
+      io.out(`Attached ${folder} as inputs/${name}: the change's steps read it as an example.`);
+      return 0;
+    } catch (e) {
+      if (e instanceof AttachError) {
+        io.err(e.message);
+        return 1;
+      }
+      throw e;
+    }
+  }
+  if (change && o.promote) {
+    if (paths.length) {
+      io.err("--promote names one file already attached; attach new files without it, for example: atticus change attach add-refund-window --promote inputs/refund-rules.pdf");
+      return 2;
+    }
+    try {
+      const r2 = await promoteChangeInput(root, change, o.promote);
+      if (o.json)
+        io.out(JSON.stringify(r2, null, 2));
+      else
+        io.out(r2.note);
+      return 0;
+    } catch (e) {
+      if (e instanceof AttachError) {
+        io.err(e.message);
+        return 1;
+      }
+      throw e;
+    }
+  }
+  if (!change || paths.length === 0) {
+    io.err("Usage: atticus change attach <change> <files...>, for example: atticus change attach add-refund-window refund-rules.pdf");
+    return 2;
+  }
+  if (o.replaces && paths.length !== 1) {
+    io.err("--replaces names the one attached file that the file given replaces: attach one file with it, for example: atticus change attach add-refund-window refund-rules-v2.pdf --replaces inputs/refund-rules-v1.pdf");
+    return 2;
+  }
+  const files = [];
+  let problems = false;
+  for (const p of paths) {
+    try {
+      files.push({ name: basename(p), bytes: new Uint8Array(await readFile(resolve(p))) });
+    } catch {
+      io.err(`Can't read ${p}.`);
+      problems = true;
+    }
+  }
+  let r;
+  try {
+    r = await attachFiles(root, change, files, o.by, o.now, o.replaces);
+  } catch (e) {
+    if (e instanceof AttachError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(r, null, 2));
+    return r.refused.length || problems ? 1 : 0;
+  }
+  const rel = `${changesRelOf(root)}/${change}`;
+  for (const a of r.added)
+    io.out(attachedLine(rel, a));
+  for (const x of r.refused)
+    io.err(`${x.name}: not attached. ${x.why}`);
+  for (const n of r.notes)
+    io.out(n);
+  if (r.added.length)
+    io.out(`The change's steps read them as data, citing each by file and line or page: atticus next says which step is next. Commit ${rel}/inputs/ with the change.`);
+  return r.refused.length || problems ? 1 : 0;
+}
+async function taskContextCli(root, change, task, o, io) {
+  if (!change || !task) {
+    io.err("Usage: atticus task context <change> <task> [--json|--markdown], for example: atticus task context add-refund-window 1.2");
+    return 2;
+  }
+  try {
+    const command = `atticus task context ${change} ${task}`;
+    const c = await taskContext(root, change, task, {
+      ask: { command, rerun: command, at: (o.now ?? /* @__PURE__ */ new Date()).toISOString() }
+    });
+    io.out(o.json && !o.markdown ? JSON.stringify(c, null, 2) : renderTaskContext(c).trimEnd());
+    return 0;
+  } catch (e) {
+    if (e instanceof Error && ["PlannerError", "ChangeError", "ChangeFileError"].includes(e.name)) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+}
+export {
+  AttachError,
+  attachFiles,
+  attachedLine,
+  changeAttachCli,
+  promoteChangeInput,
+  taskContextCli
+};

package/dist/chunk-C6EKFH7J.js

@@ -0,0 +1,169 @@
+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 {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  QueryError,
+  askLookup,
+  impact,
+  openIndex,
+  runContextTool,
+  translate
+} from "./chunk-T6AIP7H5.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/index-commands.js
+async function withIndex(root, io, fn, rebuild = false) {
+  const ix = await openIndex(root, { rebuild });
+  try {
+    for (const p of ix.problems)
+      io.err(`${p.file}: ${p.message} (left out of the index)`);
+    return fn(ix);
+  } finally {
+    ix.close();
+  }
+}
+async function askCommand(root, question, o, io) {
+  const asked = await withIndex(root, io, (ix) => {
+    return translate(question, askLookup(ix));
+  });
+  if (!o.json) {
+    io.out(asked.explanation);
+    io.out(`Query: ${asked.query}`);
+    io.out("");
+  }
+  if (asked.action === "impact")
+    return impactCommand(root, asked.id, { json: o.json === true }, io);
+  return queryCommand(root, asked.query, { json: o.json === true }, io);
+}
+async function queryCommand(root, q, o, io) {
+  return withIndex(root, io, (ix) => {
+    let res;
+    try {
+      res = ix.query(q, { limit: o.limit ?? 100 });
+    } catch (e) {
+      if (e instanceof QueryError) {
+        io.err(e.message);
+        return 2;
+      }
+      throw e;
+    }
+    if (o.json) {
+      io.out(JSON.stringify({ total: res.total, records: ix.records(res.rows) }, null, 2));
+      return 0;
+    }
+    if (res.rows.length > 0)
+      for (const l of table(["KIND", "ID", "NAME", "STATUS", "CONFIDENCE", "SYSTEM"], res.rows.map((r) => [r.kind, r.id, r.name, r.status, r.confidence, r.system ?? ""])))
+        io.out(l);
+    io.out(res.rows.length < res.total ? `${res.rows.length} of ${res.total} records (use --limit to see more)` : `${res.total} record${res.total === 1 ? "" : "s"}`);
+    return 0;
+  });
+}
+async function searchCommand(root, text, o, io) {
+  if (o.by && o.by !== "words") {
+    if (o.by !== "meaning" && o.by !== "both") {
+      io.err("--by is words, meaning or both.");
+      return 2;
+    }
+    const ix = await openIndex(root, { embedOnOpen: Number.MAX_SAFE_INTEGER });
+    try {
+      const kinds = o.kind?.split(",").map((k) => k.trim()).filter(Boolean);
+      io.out(await runContextTool(ix, root, "search", {
+        text,
+        by: o.by,
+        limit: Math.min(o.limit ?? 20, 20),
+        ...kinds?.length ? { kinds } : {}
+      }));
+      return 0;
+    } finally {
+      ix.close();
+    }
+  }
+  return withIndex(root, io, (ix) => {
+    const kinds = o.kind ? o.kind.split(",").map((k) => k.trim()).filter(Boolean) : void 0;
+    const hits = ix.search(text, { limit: o.limit ?? 20, ...kinds ? { kinds } : {} });
+    if (o.json) {
+      io.out(JSON.stringify({ total: hits.length, hits }, null, 2));
+      return 0;
+    }
+    if (hits.length > 0)
+      for (const l of table(["KIND", "ID", "NAME", "FILE"], hits.map((h) => [h.kind, h.id, h.name.slice(0, 60), h.file])))
+        io.out(l);
+    io.out(hits.length ? `${hits.length} hit${hits.length === 1 ? "" : "s"}, best first` : "Nothing in the index matches those words.");
+    return 0;
+  });
+}
+async function impactCommand(root, id, o, io) {
+  return withIndex(root, io, (ix) => {
+    const r = impact(ix, id, o.depth ?? 4);
+    if (!r) {
+      io.err(`No record with id "${id}" in the catalog. Try: atticus query ${id}`);
+      return 1;
+    }
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return 0;
+    }
+    io.out(`Changing ${id} reaches ${r.affected.length} record${r.affected.length === 1 ? "" : "s"}:`);
+    if (r.affected.length > 0)
+      for (const l of table(["KIND", "ID", "OWNER", "WHY"], r.affected.map((a) => [a.kind, a.id, a.owner ?? "", a.reason])))
+        io.out(`  ${l}`);
+    if (r.gaps.length > 0) {
+      io.out("Open questions:");
+      for (const g of r.gaps)
+        io.out(`  - ${g.question} (${g.record})`);
+    }
+    return 0;
+  });
+}
+async function indexEmbed(root, io) {
+  const ix = await openIndex(root, { embedOnOpen: 0 });
+  try {
+    const before = ix.meaning();
+    if (!ix.embedder) {
+      io.err(`${before.note}. Set retrieval.embeddings.model in the org pack's runtime.yaml.`);
+      return 1;
+    }
+    let last = Date.now();
+    const n = await ix.embed({
+      progress: (done, of) => {
+        if (Date.now() - last > 5e3 || done === of) {
+          io.out(`Embedded ${done} of ${of}`);
+          last = Date.now();
+        }
+      }
+    });
+    const after = ix.meaning();
+    io.out(`${n ? `Embedded ${n} new text${n === 1 ? "" : "s"}. ` : ""}${after.note}.`);
+    return after.on ? 0 : 1;
+  } catch (e) {
+    io.err(`The embedding model couldn't run: ${e.message.split("\n")[0]}`);
+    return 1;
+  } finally {
+    ix.close();
+  }
+}
+async function indexRebuild(root, io) {
+  return withIndex(root, io, (ix) => {
+    const kinds = ix.kinds();
+    const total = kinds.reduce((n, k) => n + k.count, 0);
+    io.out(`Indexed ${total} records of ${kinds.length} kinds into ${ix.file}`);
+    return ix.problems.length > 0 ? 1 : 0;
+  }, true);
+}
+export {
+  askCommand,
+  impactCommand,
+  indexEmbed,
+  indexRebuild,
+  queryCommand,
+  searchCommand,
+  table
+};