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

package/dist/chunk-JQX6BSE4.js

@@ -0,0 +1,130 @@
+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 {
+  estateFacts,
+  measureLinks,
+  parseLinkReference
+} from "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/measure-commands.js
+import { readFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+var MEASURE_WORDS = {
+  usage: "Usage: atticus join measure <reference.yaml> [--json] (docs/guide/measure.md)",
+  noFile: (file) => `There is no reference file at ${file}. List a few known repos' entries and calls in it (docs/guide/measure.md), then run atticus join measure again.`,
+  badFile: (file) => `${file} isn't a reference Atticus can read:`,
+  nothing: (file) => `${file} lists no calls or entries, so there is nothing to measure. List a few known repos' entries and calls (docs/guide/measure.md).`,
+  head: (file, m, repos) => `Measured against ${file}${m.estate ? ` (${m.estate})` : ""}: ${plural(repos, "repo")}, ${plural(m.reading.entries.want, "entry", "entries")} and ${plural(m.reading.calls.want, "call")} listed.`,
+  reading: (m) => `Reading: ${m.reading.entries.found} of ${plural(m.reading.entries.want, "entry", "entries")} and ${m.reading.calls.found} of ${plural(m.reading.calls.want, "call")} are in the facts${pct(m.reading.entries.found + m.reading.calls.found, m.reading.entries.want + m.reading.calls.want)}.`,
+  precision: (m) => m.links.precision === null ? "Join precision: no listed call is joined to a repo yet." : `Join precision ${m.links.precision}: ${m.links.right} of the ${plural(m.links.joined, "listed call")} joined to a repo reach the one you named.`,
+  recall: (m) => m.links.recall === null ? "Join recall: no listed call should reach a repo of the estate." : `Join recall ${m.links.recall}: ${m.links.right} of the ${plural(m.links.want, "call")} that should reach a repo of the estate do.`,
+  rest: (m) => [
+    `${m.links.asked} asked`,
+    `${m.links.inferred.joined} guessed (${m.links.inferred.right} right)`,
+    `${m.links.outside.right} of ${m.links.outside.want} outside right`,
+    ...m.links.none.want ? [`${m.links.none.right} of ${m.links.none.want} "none" right`] : [],
+    `${m.links.unlinked} unlinked`,
+    ...m.links.missed ? [`${m.links.missed} with no entry serving them`] : [],
+    `${m.links.notRead} not read`
+  ].join(", ") + ".",
+  calls: "Each listed call:",
+  missed: "Listed but not in the facts (read the repo again, or check the line and path you wrote):",
+  readOnly: "Nothing was written."
+};
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var pct = (a, b) => b ? ` (${Math.round(a / b * 100)}%)` : "";
+var wantText = (w) => "repo" in w ? w.repo : "outside" in w ? `outside ${w.outside}` : "none";
+function gotText(g) {
+  switch (g.kind) {
+    case "joined":
+      return `${g.repo} ${g.entry}${g.via?.length ? ` via ${g.via.join(", ")}` : ""}${g.inferred ? ` (a guess: ${g.inferred})` : ""}`;
+    case "outside":
+      return `outside ${g.system}`;
+    case "asked":
+      return `asked (${g.reason}): atticus questions`;
+    case "missed":
+      return `named ${g.target}, which serves nothing like it`;
+    case "unlinked":
+      return "nothing";
+    case "not-read":
+      return "not in the facts";
+  }
+}
+async function joinMeasure(root, file, o, io) {
+  if (!file) {
+    io.err(MEASURE_WORDS.usage);
+    return 2;
+  }
+  const path = isAbsolute(file) ? file : resolve(root, file);
+  const text = await readFile(path, "utf8").catch(() => void 0);
+  if (text === void 0) {
+    io.err(MEASURE_WORDS.noFile(file));
+    return 2;
+  }
+  const parsed = parseLinkReference(text);
+  if (!parsed.ok) {
+    io.err(MEASURE_WORDS.badFile(file));
+    for (const i of parsed.issues)
+      io.err(`  ${i}`);
+    return 2;
+  }
+  const ref = parsed.reference;
+  if (!ref.repos.some((r) => r.calls.length || r.entries.length)) {
+    io.err(MEASURE_WORDS.nothing(file));
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const estate = await estateFacts(root, op, "");
+  const m = measureLinks({ op, repos: estate.repos, targets: estate.targets, reference: ref });
+  const notes = [...estate.notes, ...m.notes];
+  if (o.json) {
+    io.out(JSON.stringify({ reference: file, ...m, notes }, null, 2));
+    return 0;
+  }
+  io.out(MEASURE_WORDS.head(file, m, ref.repos.length));
+  io.out(MEASURE_WORDS.reading(m));
+  io.out(MEASURE_WORDS.precision(m));
+  io.out(MEASURE_WORDS.recall(m));
+  io.out(MEASURE_WORDS.rest(m));
+  if (m.calls.length) {
+    io.out("");
+    io.out(MEASURE_WORDS.calls);
+    for (const c of m.calls)
+      io.out(`  ${c.right ? "ok" : "--"}  ${c.repo} ${c.call}: wanted ${wantText(c.want)}, got ${gotText(c.got)}`);
+  }
+  if (m.reading.missed.length) {
+    io.out("");
+    io.out(MEASURE_WORDS.missed);
+    for (const x of m.reading.missed)
+      io.out(`  ${x}`);
+  }
+  if (notes.length) {
+    io.out("");
+    for (const n of notes)
+      io.out(n);
+  }
+  io.out("");
+  io.out(MEASURE_WORDS.readOnly);
+  return 0;
+}
+export {
+  MEASURE_WORDS,
+  joinMeasure
+};

package/dist/chunk-JRPQX2EK.js

@@ -0,0 +1,376 @@
+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 {
+  judgingRuntime
+} from "./chunk-NBGBMRIS.js";
+import {
+  draftChange,
+  draftTemplates,
+  metarepoAdapters,
+  planStories,
+  readStoryEval,
+  snowDraft,
+  storyBar,
+  submitRequests,
+  syncWorkItems
+} from "./chunk-EV4TEFOD.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  runtimeForCli
+} from "./chunk-BKFGGJKA.js";
+import {
+  changesRelOf,
+  proposalsRelOf
+} from "./chunk-JMOLB347.js";
+
+// packages/cli/dist/plan-commands.js
+import { resolve } from "node:path";
+var KNOWN = /* @__PURE__ */ new Set([
+  "PlannerError",
+  "ChangeError",
+  "ChangeFileError",
+  "AdapterError",
+  "RuntimeConfigError",
+  "StepFileError"
+]);
+function fail(io, e) {
+  if (e instanceof Error && KNOWN.has(e.name)) {
+    io.err(e.message);
+    for (const p of e.problems ?? [])
+      io.err(`  ${p}`);
+    return e.code === "invalid" ? 2 : 1;
+  }
+  throw e;
+}
+var plural = (n, w) => `${n} ${n === 1 ? w : w.endsWith("y") && !/[aeiou]y$/.test(w) ? `${w.slice(0, -1)}ies` : `${w}s`}`;
+var iso = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+async function runtimeOf(root, mode, deps) {
+  if (deps.runtime)
+    return deps.runtime;
+  return (await runtimeForCli(root, mode ? { mode } : {})).runtime;
+}
+async function planStories2(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus plan stories <change> [--force] [--resume <run>] [--mode <mode>] [--json]");
+    return 2;
+  }
+  try {
+    const runtime = await runtimeOf(root, o.mode, deps);
+    const r = await planStories(root, changeId, {
+      runtime,
+      ...deps.now ? { now: deps.now() } : {},
+      ...o.force ? { force: true } : {},
+      ...o.resume ? { resume: o.resume } : {},
+      ...o.draft ? { draft: true } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify({
+        change: r.change,
+        state: r.state,
+        stories: r.skeleton.stories.map((s) => ({
+          id: s.id,
+          title: r.prose.get(s.id)?.title,
+          source: s.source,
+          systems: s.systems,
+          repos: s.repos,
+          tests: s.tests,
+          dependsOn: s.dependsOn,
+          openQuestions: s.openQuestions.map((q) => q.text)
+        })),
+        notPlanned: r.skeleton.notPlanned,
+        tasks: r.skeleton.tasks,
+        fallback: r.fallback,
+        discarded: r.discarded,
+        files: r.files,
+        ...r.waiting ? { waiting: r.waiting } : {}
+      }, null, 2));
+      return r.state === "written" ? 0 : 1;
+    }
+    if (r.state === "waiting") {
+      io.out(`Handed the story prose to your assistant (run ${r.waiting.runId}). When it is done, run: atticus plan stories ${changeId} --resume ${r.waiting.runId}`);
+      return 1;
+    }
+    if (o.draft)
+      io.out("These are draft stories from the design as it stands; plan again once the design is approved.");
+    io.out(`Planned ${plural(r.skeleton.stories.length, "story")} and ${plural(r.skeleton.tasks.length, "task")} for ${r.change} in ${plural(r.skeleton.repos.length, "repo")}.`);
+    for (const line of table(["STORY", "TITLE", "REPOS", "TESTS"], r.skeleton.stories.map((s) => [
+      s.id,
+      r.prose.get(s.id)?.title ?? "",
+      s.repos.join(", "),
+      s.tests.join(", ")
+    ])))
+      io.out(line);
+    for (const n of r.skeleton.notPlanned)
+      io.out(`Not planned: ${n.what}: ${n.why}.`);
+    if (r.fallback.length)
+      io.out(`No AI prose for ${r.fallback.join(", ")}: a person words ${r.fallback.length === 1 ? "it" : "them"}.`);
+    for (const d of r.discarded)
+      io.out(`Discarded AI output${d.id ? ` for ${d.id}` : ""}: ${d.reason}.`);
+    io.out(`Next: atticus plan snow ${changeId}, then atticus plan bar ${changeId}.`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function snowDraft2(root, changeId, o, io) {
+  if (!changeId) {
+    io.err("Usage: atticus plan snow <change> [--force] [--json]");
+    return 2;
+  }
+  try {
+    const r = await snowDraft(root, changeId, o.force ? { force: true } : {});
+    if (o.json) {
+      io.out(JSON.stringify(r.drafts.map((d) => ({
+        template: d.need.template.id,
+        record: d.need.record,
+        why: d.need.why,
+        fields: d.fields,
+        assumed: d.assumed,
+        missing: d.missing
+      })), null, 2));
+      return r.drafts.some((d) => d.missing.length) ? 1 : 0;
+    }
+    if (r.drafts.length === 0) {
+      io.out(`${changeId} needs no service-desk request.`);
+      return 0;
+    }
+    io.out(`Wrote ${plural(r.drafts.length, "service-desk draft")} to ${changesRelOf(root)}/${changeId}/snow.md.`);
+    for (const d of r.drafts) {
+      io.out(`  ${d.need.template.requestType} for ${d.need.record} (${d.need.template.leadTimeDays} days): ${d.need.why}`);
+      for (const m of d.missing)
+        io.out(`    To fill: ${m}`);
+      for (const a of d.assumed)
+        io.out(`    Assumed: ${a}`);
+    }
+    return r.drafts.some((d) => d.missing.length) ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function storyBarCommand(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus plan bar <change> [--eval <expected stories.yaml>] [--json]");
+    return 2;
+  }
+  try {
+    const ev = o.eval ? await readStoryEval(resolve(root, o.eval)) : void 0;
+    const runtime = await judgingRuntime(root, deps.runtime);
+    const r = await storyBar(root, changeId, {
+      ...ev ? { eval: ev } : {},
+      ...runtime ? { runtime } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return r.met ? 0 : 1;
+    }
+    const pct = Math.round(r.ready.rate * 100);
+    io.out(`${r.ready.passed} of ${r.ready.total} stories are ready (${pct}%, the bar is ${Math.round(r.ready.min * 100)}%); ${r.gaps.filter((g) => g.covered).length} of ${r.gaps.length} gaps covered; ${plural(r.invented.length, "invented name")}.`);
+    for (const s of r.stories.filter((x) => !x.ready))
+      io.out(`  ${s.id}: ${s.problems.join("; ")}`);
+    for (const s of r.stories.filter((x) => x.wording.length))
+      io.out(`  ${s.id} (wording): ${s.wording.join("; ")}`);
+    for (const g of r.gaps.filter((x) => !x.covered))
+      io.out(`  Gap not covered: ${g.id}: ${g.what}`);
+    for (const x of [...r.outline, ...r.regressions])
+      io.out(`  ${x}`);
+    const open = r.dor.filter((d) => d.notJudged?.length);
+    if (open.length)
+      io.out(`  For a person: no one has judged which of the bar's checks ${open.length === 1 ? "this definition-of-ready item asks" : "these definition-of-ready items ask"} for (no model was asked), so ${open.length === 1 ? "it isn't" : "they aren't"} checked: ${open.map((d) => `"${d.item}"`).join(", ")}.`);
+    io.out(r.met ? "The story bar is met." : "The story bar is not met.");
+    return r.met ? 0 : 1;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+function printSync(r, what, io) {
+  const todo = r.writes.filter((w) => w.action === "create" || w.action === "update");
+  if (r.dryRun) {
+    io.out(`Dry run: ${plural(todo.length, `${what} write`)} for ${r.change}. Nothing was sent.`);
+    for (const line of table(["ACTION", "KEY", "TITLE"], r.writes.filter((w) => w.action !== "unchanged").map((w) => [w.action, w.key, w.title])))
+      io.out(line);
+    if (todo.length)
+      io.out("Approve every write listed with --approve (you approve as your Git user).");
+    return 0;
+  }
+  io.out(`Sent ${plural(r.done.length, `${what} write`)} for ${r.change}.`);
+  for (const d of r.done)
+    io.out(d.id.startsWith("manual:") ? `  ${d.action} ${d.key}: a step for a person (${d.id.slice(7)}); see atticus todo.` : `  ${d.action} ${d.key}: ${d.id}`);
+  for (const s of r.skipped)
+    io.out(`  Skipped ${s.key}: ${s.reason}.`);
+  for (const f of r.failed)
+    io.err(`  Failed ${f.key}: ${f.reason}.`);
+  return r.failed.length ? 1 : 0;
+}
+var approver = (by, now) => by ? (w) => ({ by: by.replace(/^@/, ""), at: iso(now()), ref: w.key }) : void 0;
+async function adoSync(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus ado sync <change> [--dry-run] [--approve <you>] [--epic <id>] [--json]");
+    return 2;
+  }
+  try {
+    const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+    const workTracker = deps.workTracker ?? (await metarepoAdapters(root, {
+      change: changeId,
+      onFallback: (e) => io.err(`The work tracker can't be reached (${e.code}); writing steps for a person instead.`)
+    })).workTracker;
+    if (!workTracker) {
+      io.err("runtime.yaml configures no work tracker. Set adapters.workTracker (type manual works with no integration).");
+      return 1;
+    }
+    const approve = approver(o.approve, now);
+    const r = await syncWorkItems(root, changeId, {
+      workTracker,
+      dryRun: o.dryRun || !approve,
+      ...approve ? { approve } : {},
+      ...o.epic ? { epic: o.epic } : {},
+      now: iso(now())
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return r.failed.length ? 1 : 0;
+    }
+    return printSync(r, "work-item", io);
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function snowSubmit(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus plan submit <change> [--dry-run] [--approve <you>] [--json]");
+    return 2;
+  }
+  try {
+    const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+    const serviceDesk = deps.serviceDesk ?? (await metarepoAdapters(root, { change: changeId })).serviceDesk;
+    if (!serviceDesk) {
+      io.err("runtime.yaml configures no service desk. Set adapters.serviceDesk (type manual works with no integration).");
+      return 1;
+    }
+    const approve = approver(o.approve, now);
+    const r = await submitRequests(root, changeId, {
+      serviceDesk,
+      dryRun: o.dryRun || !approve,
+      ...approve ? { approve } : {},
+      now: iso(now())
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return r.failed.length ? 1 : 0;
+    }
+    return printSync(r, "service-desk", io);
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function templatesDraft(root, o, io, deps = {}) {
+  try {
+    const runtime = o.noAi ? void 0 : await runtimeOf(root, o.mode, deps);
+    const r = await draftTemplates(root, {
+      ...runtime ? { runtime } : {},
+      ...deps.now ? { now: deps.now() } : {}
+    });
+    return reportTemplates(root, r, o, io);
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function completeTemplatesDraft(root, run, io, deps = {}) {
+  try {
+    const r = await draftTemplates(root, {
+      finished: run,
+      ...deps.now ? { now: deps.now() } : {}
+    });
+    return reportTemplates(root, r, {}, io);
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+function reportTemplates(root, r, o, io) {
+  {
+    if (o.json) {
+      io.out(JSON.stringify({
+        templates: r.templates.map((t) => ({
+          id: t.id,
+          existing: t.existing,
+          template: t.template,
+          notes: t.notes,
+          problems: t.problems
+        })),
+        procedures: r.procedures.map((p) => p.id),
+        workItems: r.workItems,
+        triage: r.triage,
+        files: r.files,
+        problems: r.problems
+      }, null, 2));
+      return 0;
+    }
+    io.out(`Read ${plural(r.sources.howTos.length, "how-to source")}, ${plural(r.sources.tickets.length, "ticket export")} and ${plural(r.sources.workItems.length, "work-item export")}.`);
+    for (const t of r.templates)
+      io.out(`  ${t.id}: ${t.existing === "matches" ? "the org pack's template agrees" : t.existing === "differs" ? "the org pack's template disagrees (see triage)" : "new draft"}`);
+    for (const t of r.triage)
+      io.out(`  Needs a decision: ${t.summary}`);
+    for (const p of r.problems)
+      io.err(`  ${p}`);
+    io.out(`Wrote the proposal to ${proposalsRelOf(root)}/templates/ (${plural(r.files.length, "file")}); read SUMMARY.md, then copy what you accept into org-pack/ in a pull request.`);
+    return 0;
+  }
+}
+async function changeDraft(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus change draft <change> [--attempts n] [--force] [--resume <run>] [--mode <mode>] [--json]");
+    return 2;
+  }
+  try {
+    const runtime = await runtimeOf(root, o.mode, deps);
+    const r = await draftChange(root, changeId, {
+      runtime,
+      ...deps.now ? { now: deps.now() } : {},
+      ...o.attempts ? { attempts: o.attempts } : {},
+      ...o.force ? { force: true } : {},
+      ...o.resume ? { resume: o.resume } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return r.state === "written" ? 0 : 1;
+    }
+    if (r.state === "waiting") {
+      if (r.problems.length) {
+        io.out("The last draft went back to your assistant to fix:");
+        for (const p of r.problems)
+          io.out(`  ${p}`);
+      }
+      io.out(`Handed the draft to your assistant (run ${r.waiting.runId}), with the brief and ${plural(r.map.length, "catalog record")} it is about. When it is done, run: atticus change draft ${changeId} --resume ${r.waiting.runId}`);
+      return 1;
+    }
+    if (r.state === "failed") {
+      io.err(`The draft still had problems after ${plural(r.attempts, "attempt")}; nothing was written:`);
+      for (const p of r.problems)
+        io.err(`  ${p}`);
+      return 1;
+    }
+    const dir = `${changesRelOf(root)}/${r.change}`;
+    io.out(`Drafted ${r.files.join(", ")} in ${dir} (${plural(r.attempts, "attempt")}), from the brief and ${plural(r.map.length, "catalog record")}. Review and edit them; they are yours now.`);
+    for (const d of r.discarded)
+      io.out(`Left out ${d}: a draft writes only the change's design files.`);
+    io.out(`Next: atticus critic ${r.change}, then atticus plan stories ${r.change}.`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+
+export {
+  planStories2 as planStories,
+  snowDraft2 as snowDraft,
+  storyBarCommand,
+  adoSync,
+  snowSubmit,
+  templatesDraft,
+  completeTemplatesDraft,
+  changeDraft
+};

package/dist/chunk-JUQHYTXN.js

@@ -0,0 +1,45 @@
+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 {
+  AUDIT_WORDS,
+  answerAudit,
+  auditCommand,
+  auditLines,
+  defaultAuditSeed,
+  precisionOf,
+  prepareAudit,
+  tallyWords,
+  writeAudit
+} from "./chunk-V4XKYGLK.js";
+import "./chunk-Y5AYBGLB.js";
+import "./chunk-52WCHTVZ.js";
+import "./chunk-LVBPY2M6.js";
+import "./chunk-ASKDCMW5.js";
+import "./chunk-LDIARP6F.js";
+import "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-RJDP642F.js";
+import "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  AUDIT_WORDS,
+  answerAudit,
+  auditCommand,
+  auditLines,
+  defaultAuditSeed,
+  precisionOf,
+  prepareAudit,
+  tallyWords,
+  writeAudit
+};