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

package/dist/chunk-HLJAXMM4.js

@@ -0,0 +1,233 @@
+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 {
+  ExecutorError,
+  executorsCheck,
+  inputsSha256,
+  runStep
+} from "./chunk-QSXK2RGH.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  StepError,
+  exportStep,
+  fileStepStore,
+  recordStep
+} from "./chunk-7JUKDRSZ.js";
+
+// packages/cli/dist/todo-commands.js
+var iso = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+function fail(io, e) {
+  if (e instanceof StepError || e instanceof ExecutorError || e instanceof Error && e.name === "StepFileError") {
+    io.err(e.message);
+    for (const p of e.problems ?? [])
+      io.err(`  ${p}`);
+    return e.code === "invalid" ? 2 : 1;
+  }
+  throw e;
+}
+async function findStep(root, ref) {
+  const [change, id] = ref.includes("/") ? ref.split("/", 2) : [void 0, ref];
+  const store = fileStepStore(root);
+  const all = await store.list(change ? { change } : {});
+  return all.find((s) => s.id === id);
+}
+async function todoList(root, o, io) {
+  let steps;
+  try {
+    steps = await fileStepStore(root).list(o.change ? { change: o.change } : {});
+  } catch (e) {
+    return fail(io, e);
+  }
+  const shown = o.all ? steps : steps.filter((s) => s.state === "open");
+  const blocked = (s) => s.dependsOn.filter((d) => steps.find((x) => x.id === d)?.state === "open");
+  if (o.json) {
+    io.out(JSON.stringify(shown.map((s) => ({
+      id: s.id,
+      change: s.change,
+      system: s.system,
+      action: s.action,
+      state: s.state,
+      title: s.title,
+      where: s.where,
+      waitsFor: blocked(s),
+      record: s.result.map((f) => ({
+        name: f.name,
+        label: f.label,
+        format: f.format,
+        required: f.required
+      })),
+      ...s.procedure ? { procedure: s.procedure } : {},
+      ...s.reason ? { reason: s.reason } : {},
+      createdAt: s.createdAt
+    })), null, 2));
+    return 0;
+  }
+  if (shown.length === 0) {
+    io.out(o.all ? "No manual steps yet." : "Nothing to do: every manual step is done.");
+    return 0;
+  }
+  io.out(`${shown.length} ${o.all ? "manual" : "open"} step${shown.length === 1 ? "" : "s"}:`);
+  for (const line of table(["STEP", "CHANGE", "STATE", "WHAT"], shown.map((s) => {
+    const w = blocked(s);
+    return [
+      s.id,
+      s.change ?? "-",
+      s.state,
+      `${s.title}${w.length ? ` (after ${w.join(", ")})` : ""}`
+    ];
+  })))
+    io.out(line);
+  io.out("Show a step with atticus todo show <step>; record it with atticus todo done <step> --result name=value.");
+  return 0;
+}
+async function todoShow(root, stepRef, o, io) {
+  if (!stepRef) {
+    io.err("Usage: atticus todo show <step> [--export text|csv|import]");
+    return 2;
+  }
+  const format = o.export ?? "text";
+  if (!["text", "csv", "import"].includes(format)) {
+    io.err(`Unknown export ${o.export}. Use text, csv or import.`);
+    return 2;
+  }
+  try {
+    const s = await findStep(root, stepRef);
+    if (!s) {
+      io.err(`There is no step ${stepRef}.`);
+      return 1;
+    }
+    for (const l of exportStep(s, format).text.replace(/\n$/, "").split("\n"))
+      io.out(l);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+function results(raw) {
+  if (!raw)
+    return {};
+  if (!Array.isArray(raw))
+    return raw;
+  const out = {};
+  for (const r of raw) {
+    const i = r.indexOf("=");
+    if (i <= 0)
+      return `--result takes name=value, not ${r}`;
+    out[r.slice(0, i).trim()] = r.slice(i + 1).trim();
+  }
+  return out;
+}
+async function todoDone(root, stepRef, o, io, deps = {}) {
+  if (!stepRef || !o.by) {
+    io.err("Usage: atticus todo done <step> [--by <you>] [--result name=value]\u2026 [--skip --note <why>]");
+    return 2;
+  }
+  const values = results(o.result);
+  if (typeof values === "string") {
+    io.err(values);
+    return 2;
+  }
+  try {
+    const s = await findStep(root, stepRef);
+    if (!s) {
+      io.err(`There is no step ${stepRef}.`);
+      return 1;
+    }
+    const done = await recordStep(fileStepStore(root), s.id, {
+      by: o.by,
+      at: iso((deps.now ?? (() => /* @__PURE__ */ new Date()))()),
+      values,
+      ...o.skip ? { skip: true } : {},
+      ...o.note ? { note: o.note } : {}
+    });
+    io.out(done.state === "skipped" ? `Skipped step ${done.id}: ${o.note}` : `Recorded step ${done.id}${Object.keys(done.recorded?.values ?? {}).length ? `: ${Object.entries(done.recorded.values).map(([k, v]) => `${k} ${Array.isArray(v) ? v.join(", ") : String(v)}`).join(", ")}` : ""}.`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function todoRun(root, stepRef, o, io, deps = {}) {
+  if (!stepRef || !o.with) {
+    io.err("Usage: atticus todo run <step> --with <executor> [--approve <you> --inputs <sha-256>] [--fill-only]");
+    return 2;
+  }
+  try {
+    const s = await findStep(root, stepRef);
+    if (!s) {
+      io.err(`There is no step ${stepRef}.`);
+      return 1;
+    }
+    const sha = inputsSha256(s.inputs);
+    if (!o.approve) {
+      io.out(`Step ${s.id} would run with ${o.with} on these inputs:`);
+      for (const [k, v] of Object.entries(s.inputs))
+        io.out(`  ${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`);
+      io.out(`To approve exactly these inputs: atticus todo run ${s.id} --with ${o.with} --approve <you> --inputs ${sha}${o.fillOnly ? " --fill-only" : ""}`);
+      return 1;
+    }
+    const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+    const r = await runStep(root, s.id, {
+      executor: o.with,
+      approval: {
+        by: o.approve.replace(/^@/, ""),
+        at: iso(now()),
+        ref: s.id,
+        ...o.inputs ? { inputsSha256: o.inputs } : {}
+      },
+      ...o.fillOnly ? { fillOnly: true } : {},
+      ...deps.executors ? { executors: deps.executors } : {},
+      ...deps.client ? { client: deps.client } : {},
+      now: () => iso(now()),
+      onProgress: (p) => io.out(`  ${p.message}`)
+    });
+    io.out(r.message);
+    if (r.status === "done")
+      for (const [k, v] of Object.entries(r.step.recorded?.values ?? {}))
+        io.out(`  ${k}: ${Array.isArray(v) ? v.join(", ") : String(v)}`);
+    return r.status === "done" ? 0 : 1;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function executorsCheck2(root, o, io, deps = {}) {
+  const r = await executorsCheck(root, {
+    ...deps.executors ? { executors: deps.executors } : {},
+    ...deps.client ? { client: () => deps.client } : {}
+  });
+  if (o.json) {
+    io.out(JSON.stringify(r, null, 2));
+    return r.executors.every((e) => e.reachable) && r.problems.length === 0 ? 0 : 1;
+  }
+  for (const p of r.problems)
+    io.err(p);
+  if (r.executors.length === 0) {
+    io.out("No executors are configured. A person declares theirs in .atticus/executors.yaml; the org pack allows them per procedure.");
+    return r.problems.length ? 1 : 0;
+  }
+  for (const line of table(["EXECUTOR", "TRANSPORT", "ANSWERS", "COVERS", "ALLOWED FOR"], r.executors.map((e) => [
+    e.name,
+    e.transport,
+    e.reachable ? `yes${e.version ? ` (${e.version})` : ""}` : "no",
+    e.covers.join(", ") || "-",
+    e.allowedFor.join(", ") || "nothing (off)"
+  ])))
+    io.out(line);
+  for (const e of r.executors.filter((x) => x.problem))
+    io.out(`  ${e.name}: ${e.problem}`);
+  for (const m of r.missing)
+    io.out(`  Procedure ${m.procedure} allows ${m.executor}, which isn't configured here.`);
+  return r.executors.every((e) => e.reachable) && r.problems.length === 0 ? 0 : 1;
+}
+
+export {
+  todoList,
+  todoShow,
+  todoDone,
+  todoRun,
+  executorsCheck2 as executorsCheck
+};

package/dist/chunk-HVIMMDVB.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-T6AIP7H5.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  changesDirOf,
+  require_dist
+} from "./chunk-S2A7YC3Q.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-BYZCY6SP.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
+};

package/dist/chunk-HZVLAPN5.js

@@ -0,0 +1,32 @@
+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 {
+  catalogRecords,
+  guideCommand,
+  openChanges,
+  siteBuildCommand
+} from "./chunk-5FEOD73Z.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-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  catalogRecords,
+  guideCommand,
+  openChanges,
+  siteBuildCommand
+};

package/dist/chunk-I3E7CX4H.js

@@ -0,0 +1,155 @@
+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 {
+  addHistory,
+  historyEntry,
+  listHistory,
+  setLocalRecording
+} from "./chunk-G2B4ZQGH.js";
+import {
+  api_exports
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/history-commands.js
+var when = (iso) => iso.replace("T", " ").slice(0, 16);
+var KB = api_exports.HISTORY_TEXT_MAX_BYTES / 1024;
+function firstLine(text, max = 120) {
+  const lines = text.split(/\r?\n/).filter((l) => l.trim());
+  const first = (lines[0] ?? "").trim();
+  const cut = first.length > max ? `${first.slice(0, max - 1)}\u2026` : first;
+  return lines.length > 1 && cut === first ? `${cut} \u2026` : cut;
+}
+function recordingLine(r) {
+  if (r.on)
+    return "Recording is on: prompts and responses in this metarepo are kept in .atticus/history/, on this machine only.";
+  return r.offBy === "org-pack" ? "Recording is off (runtime.yaml history.record is false)." : "Recording is off on this machine (atticus history on turns it back on).";
+}
+var offWhy = (r) => r.offBy === "org-pack" ? "runtime.yaml history.record is false" : "atticus history off";
+async function historyAddCli(root, o, readText, io) {
+  const surface = api_exports.HistorySurface.safeParse(o.surface);
+  if (!surface.success) {
+    io.err(`--surface is claude-code, vscode or cli${o.surface ? `, not ${o.surface}` : ""}.`);
+    return 2;
+  }
+  const kind = api_exports.HistoryKind.safeParse(o.kind);
+  if (!kind.success) {
+    io.err(`--kind is prompt or response${o.kind ? `, not ${o.kind}` : ""}.`);
+    return 2;
+  }
+  const text = await readText();
+  if (!text.trim()) {
+    io.out("Nothing to record: the text is empty.");
+    return 0;
+  }
+  const r = await addHistory(root, {
+    surface: surface.data,
+    kind: kind.data,
+    text,
+    ...o.session ? { session: o.session } : {},
+    ...o.command ? { command: o.command } : {},
+    ...o.change ? { change: o.change } : {}
+  });
+  if (r.off) {
+    io.out(`Recording is off (${offWhy(r.off)}); nothing was recorded.`);
+    return 0;
+  }
+  const notes = [
+    ...r.record.truncated ? [`cut at ${KB} KB`] : [],
+    ...r.record.masked ? ["parts that looked like a secret were masked"] : []
+  ];
+  io.out(`Recorded ${r.record.id} (${r.record.kind}, ${r.record.size} bytes${notes.length ? `; ${notes.join("; ")}` : ""}).`);
+  return 0;
+}
+async function historyOnOffCli(root, on, io) {
+  await setLocalRecording(root, on);
+  io.out(on ? "Recording is on on this machine (.atticus/me.yaml). runtime.yaml can still turn it off for everyone." : "Recording is off on this machine (.atticus/me.yaml): nothing more is kept. What was recorded stays in .atticus/history/.");
+  return 0;
+}
+async function historyCli(root, o, io) {
+  const list = await listHistory(root, {
+    ...o.change ? { change: o.change } : {},
+    ...o.session ? { session: o.session } : {},
+    ...o.filter ? { filter: o.filter } : {},
+    limit: o.limit ?? 50
+  });
+  if (o.json) {
+    io.out(JSON.stringify(list, null, 2));
+    return 0;
+  }
+  io.out(recordingLine(list.recording));
+  if (!list.turns.length) {
+    io.out(o.change || o.session || o.filter ? "No prompts match." : "No prompts yet. Claude Code's (with the Atticus plugin) and @atticus's in VS Code are recorded here; Copilot's other chats can't be.");
+    return 0;
+  }
+  const sessions = /* @__PURE__ */ new Map();
+  for (const t of list.turns) {
+    const k = `${t.surface}\0${t.session}`;
+    sessions.set(k, [...sessions.get(k) ?? [], t]);
+  }
+  const indent = " ".repeat(20);
+  for (const turns of sessions.values()) {
+    io.out("");
+    io.out(`Session ${turns[0].session} (${turns[0].surface})`);
+    for (const t of turns) {
+      const tag = t.change ? `  [${t.change}]` : "";
+      if (t.prompt)
+        io.out(`  ${when(t.at)}  you: ${firstLine(t.prompt.text)}${tag}  ${t.prompt.id}`);
+      if (t.response)
+        io.out(`${t.prompt ? indent : `  ${when(t.at)}  `}reply: ${firstLine(t.response.text)}${t.prompt ? "" : tag}  ${t.response.id}`);
+      else
+        io.out(`${indent}no response yet`);
+    }
+  }
+  if (list.total > list.turns.length)
+    io.out(`
+${list.total - list.turns.length} older turns not shown (--limit n shows more).`);
+  return 0;
+}
+function printRecord(r, io) {
+  for (const l of r.text.replace(/\s+$/, "").split(/\r?\n/))
+    io.out(`  ${l}`);
+}
+async function historyShowCli(root, id, o, io) {
+  const e = await historyEntry(root, id);
+  if (!e) {
+    io.err(`There is no record ${id}. atticus history lists them.`);
+    return 2;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(e, null, 2));
+    return 0;
+  }
+  const r = e.record;
+  io.out([
+    `${r.id}: ${r.kind}`,
+    r.surface,
+    `session ${r.session}`,
+    when(r.at),
+    ...r.change ? [`change ${r.change}`] : [],
+    ...r.command ? [r.command] : [],
+    `${r.size} bytes`
+  ].join(", "));
+  if (r.truncated)
+    io.out(`Cut at ${KB} KB: the text was ${r.size} bytes.`);
+  if (r.masked)
+    io.out("Parts that looked like a secret were masked (***) before it was kept.");
+  printRecord(r, io);
+  if (e.pair) {
+    io.out(r.kind === "response" ? `In answer to ${e.pair.id}:` : `Answered by ${e.pair.id}:`);
+    printRecord(e.pair, io);
+  } else if (r.kind === "prompt")
+    io.out("No response yet.");
+  return 0;
+}
+export {
+  historyAddCli,
+  historyCli,
+  historyOnOffCli,
+  historyShowCli,
+  recordingLine
+};