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

package/dist/chunk-4BMDGTED.js

@@ -0,0 +1,69 @@
+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-OLWFG75W.js";
+import {
+  baseClonePath,
+  loadRepos
+} from "./chunk-KJPMEAI4.js";
+import {
+  fsRepo
+} from "./chunk-GQ4N4WKF.js";
+import {
+  HOSTS_STEP,
+  hostOfQuestion,
+  listQuestions,
+  raiseQuestions
+} from "./chunk-S2A7YC3Q.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();
+  for (const { repo, draft } of hostQuestionDrafts(asks)) {
+    if (asked.has(hostOfQuestion(draft)))
+      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.filter((q) => q.state === "open" && hosts.has(hostOfQuestion(q)));
+  const lines = [];
+  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}).`);
+  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, open, lines };
+}
+
+export {
+  askHosts
+};

package/dist/chunk-4NDAAFQT.js

@@ -0,0 +1,103 @@
+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 {
+  DEFAULT_LEGEND,
+  IMAGE_EXTENSIONS,
+  NEEDS_READING_FLAG,
+  ReadError,
+  documentFormat,
+  documentId,
+  docxIngestor,
+  edgeParts,
+  extOf,
+  figmaIngestor,
+  fileBase,
+  htmlIngestor,
+  imageFormat,
+  imageIngestor,
+  isoDate,
+  legendOf,
+  legendWord,
+  listIngestors,
+  looksLikeFigma,
+  lucidIngestor,
+  markdownIngestor,
+  mermaidIngestor,
+  officeFormat,
+  parseCsv,
+  pdfIngestor,
+  pickIngestor,
+  pptxIngestor,
+  readDiagram,
+  readDocument,
+  readFigma,
+  readImage,
+  readLucidCsv,
+  readMermaid,
+  readVsdx,
+  sourceDocument,
+  stem,
+  textIngestor,
+  utf8,
+  visioIngestor,
+  xlsxIngestor
+} from "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-GQ4N4WKF.js";
+import {
+  ZIP_LIMITS,
+  ZipError,
+  peekZip,
+  readZip
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  DEFAULT_LEGEND,
+  IMAGE_EXTENSIONS,
+  NEEDS_READING_FLAG,
+  ReadError,
+  ZIP_LIMITS,
+  ZipError,
+  documentFormat,
+  documentId,
+  docxIngestor,
+  edgeParts,
+  extOf,
+  figmaIngestor,
+  fileBase,
+  htmlIngestor,
+  imageFormat,
+  imageIngestor,
+  isoDate,
+  legendOf,
+  legendWord,
+  listIngestors,
+  looksLikeFigma,
+  lucidIngestor,
+  markdownIngestor,
+  mermaidIngestor,
+  officeFormat,
+  parseCsv,
+  pdfIngestor,
+  peekZip,
+  pickIngestor,
+  pptxIngestor,
+  readDiagram,
+  readDocument,
+  readFigma,
+  readImage,
+  readLucidCsv,
+  readMermaid,
+  readVsdx,
+  readZip,
+  sourceDocument,
+  stem,
+  textIngestor,
+  utf8,
+  visioIngestor,
+  xlsxIngestor
+};

package/dist/chunk-4Q3NN7VF.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));
+
+// packages/cli/dist/handoff-steps.js
+var STEPS = /* @__PURE__ */ new Set([
+  "scan survey",
+  "scan verify",
+  "spec draft",
+  "knowledge scan",
+  // ADR 0087: the feature and architecture stages (plan stories already takes it).
+  "change feature",
+  "change architecture",
+  // ADR 0113: the fast path's one step.
+  "change small",
+  "change draft",
+  "plan stories",
+  // ADR 0101: what a change needs from the organisation.
+  "change needs",
+  "knowledge find",
+  "knowledge ask"
+]);
+var isHandoffStep = (group, command) => STEPS.has(`${group ?? ""} ${command ?? ""}`) || isCritic(group, command) || // ADR 0124 §4: atticus map <repo>, the batched read, one batch per hand-off.
+group === "map" && !!command && !command.startsWith("-");
+var isCritic = (group, command) => group === "critic" && !!command && command !== "stats";
+
+export {
+  isHandoffStep,
+  isCritic
+};

package/dist/chunk-4RS5KZQD.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 {
+  executorsCheck,
+  todoDone,
+  todoList,
+  todoRun,
+  todoShow
+} from "./chunk-HLJAXMM4.js";
+import "./chunk-QSXK2RGH.js";
+import "./chunk-VOGCSYOI.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  executorsCheck,
+  todoDone,
+  todoList,
+  todoRun,
+  todoShow
+};

package/dist/chunk-4SKZDI62.js

@@ -0,0 +1,22 @@
+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 {
+  distance,
+  flagNames,
+  nearest,
+  nearestCommand,
+  unknownFlagMessages,
+  unknownFlags
+} from "./chunk-7EFILTCI.js";
+import "./chunk-TV45EUGM.js";
+export {
+  distance,
+  flagNames,
+  nearest,
+  nearestCommand,
+  unknownFlagMessages,
+  unknownFlags
+};

package/dist/chunk-55YODD3N.js

@@ -0,0 +1,385 @@
+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 {
+  diffLines
+} from "./chunk-TAVDMUV3.js";
+import {
+  askHosts
+} from "./chunk-4BMDGTED.js";
+import "./chunk-RCU3MPY2.js";
+import "./chunk-V5PKHHQQ.js";
+import "./chunk-7UFQZXZA.js";
+import "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import {
+  TARGETS_STEP,
+  catalogWithFacts,
+  diffCatalogs,
+  diffIsEmpty,
+  estateFacts,
+  isPrototypeRepo,
+  prototypeLeftOut,
+  readCatalog,
+  targetQuestionDrafts,
+  targetsFromAnswers,
+  writeCatalog
+} from "./chunk-OLWFG75W.js";
+import "./chunk-L24C55VN.js";
+import {
+  codeLinkerFor,
+  frameworkFacts,
+  frameworkGaps,
+  renderMap,
+  trustOf
+} from "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import {
+  baseClonePath,
+  loadRepos
+} from "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  SPEC_HEADER_SCHEMA_VERSION,
+  catalogDirOf,
+  factsDirOf,
+  flowFiles,
+  isAdopted,
+  listQuestions,
+  loadOrgPack,
+  mapDirOf,
+  mapRelOf,
+  orgPackDirOf,
+  parseFacts,
+  parseRecord,
+  questionsRelOf,
+  raiseQuestions,
+  readRepoSpec,
+  removeFlow,
+  require_dist,
+  specFileHash,
+  specRelOf,
+  writeFlow,
+  writeSpecHeader
+} from "./chunk-S2A7YC3Q.js";
+import {
+  LockHeldError,
+  acquireLock,
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/map-render-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { readFile, readdir, rm } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+var FACTS_TEMPLATE = "facts@1";
+var posix = (p) => p.split(sep).join("/");
+function countByKind(d) {
+  const out = {};
+  const of = (k) => out[k] ??= { added: 0, changed: 0, removed: 0 };
+  for (const r of d.added)
+    of(r.kind).added++;
+  for (const r of [...d.changed, ...d.evidenceOnly])
+    of(r.kind).changed++;
+  for (const r of d.removed)
+    of(r.kind).removed++;
+  return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a < b ? -1 : 1));
+}
+function kindLine(byKind) {
+  const parts = Object.entries(byKind).map(([kind, c]) => [
+    kind,
+    c.added ? `+${c.added}` : "",
+    c.changed ? `~${c.changed}` : "",
+    c.removed ? `-${c.removed}` : ""
+  ].filter(Boolean).join(" "));
+  return parts.join(", ");
+}
+async function writeFactsIntoCatalog(root, repo, facts, o, io) {
+  let lock;
+  try {
+    lock = await acquireLock(root, "scan", o.command);
+  } catch (e) {
+    if (e instanceof LockHeldError) {
+      io.err(e.message);
+      return void 0;
+    }
+    throw e;
+  }
+  try {
+    const op = await loadOrgPack(orgPackDirOf(root));
+    const generated = join(catalogDirOf(root), "generated");
+    const existing = await readCatalog(generated, { cacheRoot: root });
+    if (isPrototypeRepo(op, repo)) {
+      for (const n of prototypeLeftOut({ repo, facts, existing: [], op, decisions: [] }).notes)
+        io.out(n);
+      const none = diffCatalogs(existing.records, existing.records);
+      return {
+        written: { written: 0, unchanged: 0, removed: 0 },
+        flows: [],
+        questions: [],
+        map: [],
+        changes: { ...none, byKind: {} }
+      };
+    }
+    const curated = await readCatalog(join(catalogDirOf(root), "curated"), { cacheRoot: root });
+    const rerun = `atticus verify ${repo} --write`;
+    const answered = (await listQuestions(root, { repo, step: TARGETS_STEP })).questions;
+    const estate = await estateFacts(root, op, repo);
+    const result = catalogWithFacts({
+      repo,
+      facts,
+      existing: existing.records,
+      op,
+      decisions: curated.records,
+      targets: targetsFromAnswers(repo, facts, answered),
+      estate: estate.repos,
+      estateTargets: estate.targets
+    });
+    for (const i of result.invalid)
+      io.err(`A merged record isn't valid C1 (a bug): ${i.issues.map((x) => `${x.path}: ${x.message}`).join("; ")}`);
+    const diff = diffCatalogs(existing.records, result.records);
+    const written = await writeCatalog(generated, result.records);
+    const flows = result.flows.filter((f) => {
+      const p = parseRecord(f);
+      if (p.ok)
+        return true;
+      io.err(`The flow ${f.id} isn't written to ${specRelOf(root, repo)}/: ${p.issues.map((i) => `${i.path}: ${i.message}`).join("; ")}. Have your assistant fix its flow fact (each call-out step's ref names the call it makes), then run ${rerun}.`);
+      return false;
+    });
+    const spec = await readRepoSpec(root, repo, { cacheRoot: root });
+    const ids = new Set(flows.map((f) => f.id));
+    for (const f of spec.flows)
+      if (f.template === FACTS_TEMPLATE && !ids.has(f.id))
+        await removeFlow(root, repo, f.id);
+    const flowPaths = [];
+    for (const f of flows)
+      flowPaths.push(await writeFlow(root, repo, f));
+    const files = {};
+    for (const f of flows)
+      for (const p of flowFiles(f)) {
+        const text = await readFile(join(o.dir, ...p.split("/")), "utf8").catch(() => void 0);
+        if (text !== void 0)
+          files[p] = specFileHash(text);
+      }
+    const commit = facts.map((f) => f.commit).sort()[0];
+    const kept = spec.flows.filter((f) => f.template !== FACTS_TEMPLATE).map((f) => f.id);
+    const header = spec.header;
+    await writeSpecHeader(root, {
+      schemaVersion: SPEC_HEADER_SCHEMA_VERSION,
+      repo,
+      template: header?.template ?? FACTS_TEMPLATE,
+      templateReviewed: header?.templateReviewed ?? false,
+      ...commit ? { commit } : {},
+      ...header?.drafted ? { drafted: header.drafted } : {},
+      flows: [.../* @__PURE__ */ new Set([...kept, ...ids])].sort(),
+      files: Object.fromEntries(Object.entries({ ...header?.files ?? {}, ...files }).sort(([a], [b]) => a < b ? -1 : 1)),
+      questions: header?.questions ?? []
+    });
+    const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+    const hosts = await askHosts(root, result.records, { command: o.command, rerun, now: o.now });
+    const loose = new Set(result.unresolved.map((u) => u.factId));
+    const ambiguous = new Set((result.join?.asks ?? []).filter((a) => a.reason === "ambiguous" && a.call.repo === repo).map((a) => a.call.fact));
+    const named = new Set(facts.filter((f) => f.kind === "call" && f.to).map((f) => f.id));
+    const raised = [...hosts.raised];
+    const lines = [...hosts.lines];
+    for (const t of targetQuestionDrafts(facts, result.records, op, result.join?.asks)) {
+      if (!(loose.has(t.factId) || ambiguous.has(t.factId)))
+        continue;
+      if (answered.some((q) => q.id === t.id))
+        continue;
+      const r = await raiseQuestions(root, [t.draft], {
+        step: TARGETS_STEP,
+        repo,
+        command: o.command,
+        rerun,
+        at
+      });
+      for (const q of r.raised) {
+        raised.push(q);
+        lines.push(named.has(t.factId) ? `A call names a target the estate doesn't have, and more than one entry serves it: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.` : `A call names no target: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.`);
+      }
+    }
+    const byKind = countByKind(diff);
+    io.out(`Wrote the catalog for ${repo}: ${written.written} files written, ${written.removed} removed, ${written.unchanged} unchanged.`);
+    io.out(diffIsEmpty(diff) ? "  No catalog changes." : `  Records: ${kindLine(byKind)}.`);
+    if (o.verbose)
+      for (const l of diffLines(diff).slice(1))
+        io.out(`    ${l}`);
+    const specsRel = specRelOf(root, repo);
+    io.out(`  Flows: ${flowPaths.length} in ${specsRel}/.`);
+    if (o.verbose)
+      for (const p of flowPaths)
+        io.out(`    ${p}`);
+    else if (!diffIsEmpty(diff) || flowPaths.length)
+      io.out(`  atticus verify ${repo} --write --verbose lists each record and flow.`);
+    for (const p of result.curated.problems)
+      io.out(`Curated decision ${p.decision} no longer applies: ${p.message}`);
+    for (const p of result.projectionIssues)
+      io.out(`  ${p.code}: ${p.message}`);
+    for (const l of joinLines(repo, result.join, estate.notes, { verbose: o.verbose === true }))
+      io.out(l);
+    for (const l of lines)
+      io.out(l);
+    const map = await renderRepoMap(root, repo, io);
+    return {
+      written,
+      flows: flowPaths,
+      questions: raised.map((q) => q.id),
+      map: map ?? [],
+      changes: { ...diff, byKind }
+    };
+  } finally {
+    await lock.release();
+  }
+}
+function joinLines(repo, join2, notes = [], o = {}) {
+  if (!join2)
+    return [...notes];
+  const out = [...notes];
+  const mine = join2.joins.filter((j) => j.call.repo === repo && j.call.repo !== j.entry.repo);
+  const into = join2.joins.filter((j) => j.entry.repo === repo && j.call.repo !== repo);
+  if (mine.length || into.length)
+    out.push(`Joined across repos: ${mine.length} of ${repo}'s calls to the entries that serve them, ${into.length} calls of other repos into ${repo}, each citing both ends.`);
+  const guessed = join2.joins.filter((j) => j.call.repo === repo && j.inferred);
+  if (guessed.length) {
+    const own = guessed.filter((j) => j.inferred.within === "repo").length;
+    const where = [
+      own ? `${own} in ${repo} itself` : "",
+      guessed.length - own ? `${guessed.length - own} in another repo${guessed.length - own === 1 ? "" : "s"}` : ""
+    ].filter(Boolean).join(", ");
+    out.push(`Joined by method and path, inferred: ${guessed.length} of ${repo}'s calls name no target the estate has, so each joined the one entry that serves it (${where}).`);
+    if (o.verbose)
+      for (const j of guessed) {
+        const what = j.method ? `${j.method} ${j.path}` : j.path;
+        const named = j.inferred.named ? ` (named ${j.inferred.named})` : "";
+        const there = j.entry.repo === repo ? "" : ` (${j.entry.repo})`;
+        out.push(`  ${j.call.at} ${what}${named} \u2192 ${j.entry.component}${there}`);
+      }
+  }
+  for (const m of join2.misses)
+    out.push(`Not joined: ${m.message} (${m.call.at}).`);
+  for (const g of join2.gaps.slice(0, 10))
+    out.push(`Field gap: ${g.message}.`);
+  return out;
+}
+async function renderRepoMap(root, repo, io) {
+  const records = (await readCatalog(join(catalogDirOf(root), "generated"), { cacheRoot: root })).records;
+  const spec = await readRepoSpec(root, repo, { cacheRoot: root });
+  const ofRepo = records.some((r) => r.kind === "Component" && r.repo === repo);
+  if (!ofRepo && spec.flows.length === 0) {
+    io.err(`Nothing of ${repo} is in the catalog yet. Have your assistant read it (/atticus map), then run atticus verify ${repo} --write.`);
+    return void 0;
+  }
+  let trust;
+  const report = join(factsDirOf(root), `${repo}.verify.yaml`);
+  if (existsSync(report)) {
+    try {
+      trust = trustOf((0, import_yaml.parse)(await readFile(report, "utf8")));
+    } catch {
+      trust = void 0;
+    }
+  }
+  const open = (await listQuestions(root, { state: "open", repo })).questions;
+  const manifest = (await loadRepos(root).catch(() => [])).find((r) => r.id === repo);
+  const adopted = isAdopted(root);
+  const url = manifest?.url && manifest.url !== "." && !manifest.url.startsWith("./") ? manifest.url : void 0;
+  const codeLink = codeLinkerFor(url ? { url } : { dir: adopted ? "" : posix(relative(root, baseClonePath(root, repo))) });
+  const rel = `${mapRelOf(root)}/${repo}`;
+  const files = renderMap({
+    repo,
+    records,
+    flows: spec.flows,
+    ...trust ? { trust } : {},
+    // What a person says the repo is (ADR 0128), above the trust line.
+    ...manifest?.description ? {
+      about: {
+        text: manifest.description.text,
+        trust: manifest.description.trust,
+        ...manifest.description.by ? { by: manifest.description.by } : {}
+      }
+    } : {},
+    // What the repo is built on (ADR 0124 addendum A-framework): read from the facts, since no
+    // catalog record holds a framework.
+    ...builtOnOf(await factsOf(root, repo)),
+    questions: open.map((q) => ({ id: q.id, question: q.question, evidence: q.evidence })),
+    paths: { map: rel, questions: questionsRelOf(root), specs: specRelOf(root, repo) },
+    codeLink
+  });
+  const dir = join(mapDirOf(root), repo);
+  for (const old of await listFiles(dir))
+    if (!(old in files))
+      await rm(join(dir, ...old.split("/")), { force: true });
+  for (const [path, text] of Object.entries(files)) {
+    const full = join(dir, ...path.split("/"));
+    const now = await readFile(full, "utf8").catch(() => void 0);
+    if (now !== text)
+      await writeFileAtomic(full, text);
+  }
+  const paths = Object.keys(files).map((p) => `${rel}/${p}`);
+  io.out(`Map: ${rel}/map.md (${Object.keys(files).length} files; review them in the PR).`);
+  return paths;
+}
+async function factsOf(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return [];
+  const p = parseFacts(text);
+  return p.ok ? p.facts : [];
+}
+function builtOnOf(facts) {
+  const built = frameworkFacts(facts).map((f) => ({
+    name: f.name,
+    ...f.version ? { version: f.version } : {},
+    ...f.component ? { component: f.component } : {},
+    cite: { path: f.cite.file, line: f.cite.line, commit: f.commit }
+  }));
+  if (!built.length)
+    return {};
+  const gaps = frameworkGaps(facts).map((g) => ({ framework: g.framework, question: g.question }));
+  return { frameworks: { built, ...gaps.length ? { gaps } : {} } };
+}
+async function listFiles(dir) {
+  const out = [];
+  const walk = async (d, prefix) => {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries)
+      if (e.isDirectory())
+        await walk(join(d, e.name), `${prefix}${e.name}/`);
+      else
+        out.push(`${prefix}${e.name}`);
+  };
+  await walk(dir, "");
+  return out.sort();
+}
+async function mapRenderCommand(root, repo, o, io) {
+  const quiet = o.json ? { ...io, out: () => void 0 } : io;
+  const written = await renderRepoMap(root, repo, quiet);
+  if (!written)
+    return 2;
+  if (o.json)
+    io.out(JSON.stringify({ repo, files: written }, null, 2));
+  return 0;
+}
+export {
+  builtOnOf,
+  countByKind,
+  joinLines,
+  kindLine,
+  mapRenderCommand,
+  writeFactsIntoCatalog
+};