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

package/dist/chunk-2KDSXJFJ.js

@@ -0,0 +1,294 @@
+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 {
+  readCatalog
+} from "./chunk-AY2IUF4K.js";
+import {
+  frameworkFacts,
+  frameworkGaps
+} from "./chunk-4GZXS6S2.js";
+import {
+  baseClonePath,
+  loadRepos
+} from "./chunk-PGKHJYOB.js";
+import {
+  auditItemHolds,
+  auditPrecision,
+  catalogDirOf,
+  factsDirOf,
+  factsFileOf,
+  factsRelOf,
+  headFromFiles,
+  isAdopted,
+  listQuestions,
+  parseAuditFile,
+  parseFacts,
+  require_dist
+} from "./chunk-577AJVRS.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/ui-api-trust.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+function rejectedLines(text2) {
+  const out = [];
+  for (const raw of (text2 ?? "").split(/\r?\n/)) {
+    if (!raw.trim())
+      continue;
+    let l;
+    try {
+      l = JSON.parse(raw);
+    } catch {
+      out.push({ code: "unreadable", message: raw.slice(0, 200) });
+      continue;
+    }
+    const f = l.fact && typeof l.fact === "object" ? l.fact : void 0;
+    const cite = f?.cite;
+    out.push({
+      ...typeof f?.id === "string" ? { fact: f.id } : {},
+      ...typeof f?.kind === "string" ? { kind: f.kind } : {},
+      ...typeof cite?.file === "string" ? { file: cite.file } : {},
+      ...typeof cite?.line === "number" && Number.isInteger(cite.line) ? { line: cite.line } : {},
+      code: typeof l.code === "string" ? l.code : "rejected",
+      message: typeof l.message === "string" ? l.message : ""
+    });
+  }
+  return out;
+}
+var SHA = /^[0-9a-f]{7,64}$/;
+var FACT_BY = /* @__PURE__ */ new Set(["assistant", "reader", "person"]);
+var UNKNOWN_SHOWN = 50;
+var firstLine = (e) => String(e.message ?? e).split("\n")[0];
+var text = (p) => readFile(p, "utf8").catch(() => void 0);
+function reportOf(raw) {
+  const r = raw;
+  if (!r || typeof r.accepted !== "number" || typeof r.rejected !== "number")
+    return "not a verifier's report: accepted and rejected are missing";
+  const list = (v) => Array.isArray(v) ? v.map(String) : [];
+  const unknown = list(r.coverage?.unknown);
+  return {
+    accepted: r.accepted,
+    rejected: r.rejected,
+    redacted: typeof r.redacted === "number" ? r.redacted : 0,
+    coverage: {
+      ratio: typeof r.coverage?.ratio === "number" ? r.coverage.ratio : 0,
+      read: typeof r.coverage?.read === "number" ? r.coverage.read : 0,
+      unknown: unknown.length,
+      excluded: list(r.coverage?.excluded).length
+    },
+    unknownFiles: unknown.slice(0, UNKNOWN_SHOWN),
+    ...typeof r.commit === "string" && SHA.test(r.commit) ? { commit: r.commit } : {}
+  };
+}
+var sameCommit = (a, b) => a && b ? a.startsWith(b) || b.startsWith(a) : null;
+function catalogSources(records) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const e of r.evidence) {
+      if (!e.repo)
+        continue;
+      const s = seen.get(e.repo) ?? { facts: false, readers: false };
+      if (!e.extractor && e.by && FACT_BY.has(e.by))
+        s.facts = true;
+      else if (e.source !== "manual")
+        s.readers = true;
+      seen.set(e.repo, s);
+    }
+    for (const [repo, s] of seen) {
+      const c = counts.get(repo) ?? { facts: 0, readers: 0 };
+      if (s.facts)
+        c.facts += 1;
+      else if (s.readers)
+        c.readers += 1;
+      counts.set(repo, c);
+    }
+  }
+  return counts;
+}
+function nextOf(repo, r) {
+  const read = { command: `atticus map ${repo}`, slash: `/atticus-map ${repo}` };
+  if (!r.facts.present)
+    return { state: "not-read", next: read };
+  const report = r.verify.report;
+  if (!report)
+    return { state: "unverified", next: { command: `atticus verify ${repo}` } };
+  if (report.rejected > 0)
+    return {
+      state: "rejected",
+      next: { command: `atticus verify ${repo}`, slash: `/atticus-map ${repo}` }
+    };
+  if (r.sameCommit === false)
+    return { state: "stale", next: read };
+  if (r.facts.unverified > 0)
+    return { state: "unverified", next: { command: `atticus verify ${repo}` } };
+  if (r.catalog.fromFacts === 0)
+    return { state: "unwritten", next: { command: `atticus verify ${repo} --write` } };
+  if (report.coverage.unknown > 0)
+    return { state: "unknown-files", next: read };
+  return { state: "trusted" };
+}
+async function trustView(root) {
+  const rel = (p) => relative(root, p).split(sep).join("/") || ".";
+  const problems = [];
+  const dir = factsDirOf(root);
+  const factsRel = factsRelOf(root);
+  const ids = [];
+  try {
+    for (const r of await loadRepos(root))
+      ids.push(r.id);
+  } catch (e) {
+    problems.push({ file: "org-pack/profiles", message: firstLine(e) });
+  }
+  const files = await readdir(dir).catch(() => []);
+  const named = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    const of = factsFileOf(f);
+    if (of && (of.facts || f.endsWith(".verify.yaml")))
+      named.add(of.repo);
+  }
+  for (const id of [...named].sort())
+    if (!ids.includes(id))
+      ids.push(id);
+  const catalog = await readCatalog(join(catalogDirOf(root), "generated"), { cacheRoot: root });
+  for (const p of catalog.problems)
+    problems.push({ file: rel(join(catalogDirOf(root), "generated", p.file)), message: p.message });
+  const counts = catalogSources(catalog.records);
+  const open = await listQuestions(root, { state: "open" }).then((l) => l.questions, () => []);
+  const adopted = isAdopted(root);
+  const repos = [];
+  for (const repo of ids) {
+    const factsPath = join(dir, `${repo}.jsonl`);
+    const raw = await text(factsPath);
+    const facts = {
+      path: rel(factsPath),
+      present: raw !== void 0,
+      count: 0,
+      unverified: 0
+    };
+    let frameworks;
+    let kept = [];
+    const lists = { rejected: [], excluded: [], asked: [], unverified: [] };
+    if (raw !== void 0 && raw.trim()) {
+      const parsed = parseFacts(raw);
+      if (parsed.ok) {
+        kept = parsed.facts;
+        facts.count = parsed.facts.length;
+        const unchecked = parsed.facts.filter((f) => f.verified === "none");
+        facts.unverified = unchecked.length;
+        lists.unverified = unchecked.slice(0, UNKNOWN_SHOWN).map((f) => ({
+          fact: f.id,
+          kind: f.kind,
+          file: f.cite.file,
+          line: f.cite.line
+        }));
+        const commit = parsed.facts[0]?.commit;
+        if (commit)
+          facts.commit = commit;
+        const gaps = new Map(frameworkGaps(parsed.facts).map((g) => [g.id, g.question]));
+        const built = frameworkFacts(parsed.facts).map((f) => ({
+          name: f.name,
+          ...f.version ? { version: f.version } : {},
+          ...f.component ? { component: f.component } : {},
+          cite: `${f.cite.file}:${f.cite.line}`,
+          ...gaps.has(f.id) ? { gap: gaps.get(f.id) } : {}
+        }));
+        if (built.length)
+          frameworks = built;
+      } else
+        problems.push({
+          file: rel(factsPath),
+          message: `doesn't read as facts: ${parsed.issues[0]?.message ?? "invalid"}`
+        });
+    }
+    const reportPath = join(dir, `${repo}.verify.yaml`);
+    let report = null;
+    let excluded = [];
+    const reportText = await text(reportPath);
+    if (reportText !== void 0) {
+      try {
+        const doc = (0, import_yaml.parse)(reportText);
+        const r = reportOf(doc);
+        if (typeof r === "string")
+          problems.push({ file: rel(reportPath), message: r });
+        else {
+          report = r;
+          const ex = doc?.coverage?.excluded;
+          if (Array.isArray(ex))
+            excluded = ex.map(String).slice(0, UNKNOWN_SHOWN);
+        }
+      } catch (e) {
+        problems.push({ file: rel(reportPath), message: `can't read YAML: ${firstLine(e)}` });
+      }
+    }
+    if (!facts.commit && report?.commit)
+      facts.commit = report.commit;
+    lists.rejected = rejectedLines(await text(join(dir, `${repo}.rejected.jsonl`)));
+    lists.excluded = excluded;
+    lists.asked = open.filter((q) => q.repo === repo).map((q) => ({ id: q.id, question: q.question, lines: q.evidence }));
+    let audit;
+    const auditPath = join(dir, `${repo}.audit.yaml`);
+    const auditText = await text(auditPath);
+    if (auditText !== void 0) {
+      const a = parseAuditFile(auditText);
+      if (!a.ok)
+        problems.push({ file: rel(auditPath), message: `isn't an audit file: ${a.issues[0]}` });
+      else {
+        const byId = new Map(kept.map((f) => [f.id, f]));
+        const p = auditPrecision(a.file.items, (i) => auditItemHolds(i, byId));
+        audit = { path: rel(auditPath), facts: p.facts, byKind: p.byKind, links: p.links };
+      }
+    }
+    let checkoutDir;
+    try {
+      checkoutDir = adopted ? root : baseClonePath(root, repo);
+    } catch {
+      checkoutDir = void 0;
+    }
+    const head = checkoutDir ? await headFromFiles(checkoutDir) : void 0;
+    const present = checkoutDir ? await stat(join(checkoutDir, ".git")).then(() => true, () => false) : false;
+    const checkout = {
+      path: checkoutDir ? rel(checkoutDir) : `workspace/${repo}`,
+      present,
+      ...head ? { commit: head } : {}
+    };
+    const c = counts.get(repo) ?? { facts: 0, readers: 0 };
+    const from = c.facts && c.readers ? "both" : c.facts ? "facts" : c.readers ? "readers" : "none";
+    const base = {
+      repo,
+      facts,
+      verify: { path: rel(reportPath), report },
+      checkout,
+      sameCommit: sameCommit(report?.commit ?? facts.commit, head),
+      catalog: { from, fromFacts: c.facts, fromReaders: c.readers }
+    };
+    const { state, next } = nextOf(repo, base);
+    repos.push({
+      ...base,
+      state,
+      ...next ? { next } : {},
+      ...frameworks ? { frameworks } : {},
+      lists,
+      ...audit ? { audit } : {}
+    });
+  }
+  return { factsDir: factsRel, repos, problems };
+}
+function uiTrustRoutes(r, ctx) {
+  return r.add("GET", "/api/trust", async () => ({ status: 200, body: await trustView(ctx.root) })).add("GET", "/api/trust/fresh", async () => {
+    const { estateFreshness } = await import("./chunk-G5SFOH7P.js");
+    const body = await estateFreshness(ctx.root);
+    return { status: 200, body };
+  });
+}
+
+export {
+  catalogSources,
+  uiTrustRoutes
+};

package/dist/chunk-2M6WXO73.js

@@ -0,0 +1,38 @@
+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 {
+  changeEstimateCommand,
+  estimateOf
+} from "./chunk-X4W4XXWP.js";
+import "./chunk-67J3VZBA.js";
+import "./chunk-5YIBJXGB.js";
+import "./chunk-UYYN2IUZ.js";
+import "./chunk-P3TKKBAH.js";
+import "./chunk-7YYEKTYF.js";
+import "./chunk-XEG3FE2R.js";
+import "./chunk-KC5DROFC.js";
+import "./chunk-RK6MKKKP.js";
+import "./chunk-47QE246J.js";
+import "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-N4QZJJVB.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  changeEstimateCommand,
+  estimateOf
+};

package/dist/chunk-2RX7PI2Y.js

@@ -0,0 +1,166 @@
+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 {
+  readCatalog
+} from "./chunk-AY2IUF4K.js";
+import {
+  scopeWords
+} from "./chunk-6JLPXDWN.js";
+import {
+  baseClonePath,
+  loadManifest
+} from "./chunk-PGKHJYOB.js";
+import {
+  Sources,
+  catalogDirOf,
+  orgPackDirOf,
+  require_dist
+} from "./chunk-577AJVRS.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/ui-api-onboarding.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+var exists = (p) => stat(p).then(() => true, () => false);
+var firstLine = (e) => String(e.message ?? e).split("\n")[0];
+async function onboardingView(root) {
+  const rel = (p) => relative(root, p).split(sep).join("/");
+  const orgPack = orgPackDirOf(root);
+  const problems = [];
+  const manifests = [];
+  const listed = [];
+  const profiles = join(orgPack, "profiles");
+  const names = await readdir(profiles, { withFileTypes: true }).then((d) => d.filter((x) => x.isDirectory()).map((x) => x.name).sort(), () => []);
+  const seen = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const path = join(profiles, name, "repos.manifest.yaml");
+    if (!await exists(path))
+      continue;
+    try {
+      const m = await loadManifest(path);
+      manifests.push({ platform: m.platform, path: rel(path), repos: m.repos.length });
+      for (const r of m.repos) {
+        const other = seen.get(r.id);
+        if (other) {
+          problems.push({ file: rel(path), message: `repo id ${r.id} is also in ${other}` });
+          continue;
+        }
+        seen.set(r.id, rel(path));
+        listed.push({
+          repo: {
+            id: r.id,
+            platform: m.platform,
+            type: r.type,
+            owner: r.owner,
+            manifest: rel(path),
+            // ADR 0128: what it is, in a person's words, or a draft waiting for one.
+            ...r.description ? { description: r.description } : {},
+            // ADR 0123: the branch the catalog is read from, and those scanned beside it.
+            defaultBranch: r.defaultBranch,
+            branches: r.branches
+          }
+        });
+      }
+    } catch (e) {
+      problems.push({ file: rel(path), message: firstLine(e) });
+    }
+  }
+  const catalog = await readCatalog(join(catalogDirOf(root), "generated"), { cacheRoot: root });
+  for (const p of catalog.problems)
+    problems.push({ file: rel(join(catalogDirOf(root), "generated", p.file)), message: p.message });
+  const scans = /* @__PURE__ */ new Map();
+  for (const r of catalog.records) {
+    const repos2 = new Set(r.evidence.map((e) => e.repo).filter((x) => !!x));
+    for (const repo of repos2) {
+      const s = scans.get(repo) ?? { records: 0, kinds: {} };
+      s.records += 1;
+      s.kinds[r.kind] = (s.kinds[r.kind] ?? 0) + 1;
+      for (const e of r.evidence) {
+        if (e.repo !== repo || !e.scannedAt)
+          continue;
+        if (!s.scannedAt || e.scannedAt > s.scannedAt) {
+          s.scannedAt = e.scannedAt;
+          if (e.commit)
+            s.commit = e.commit;
+        }
+      }
+      if (!s.commit) {
+        const c = r.evidence.find((e) => e.repo === repo && e.commit)?.commit;
+        if (c)
+          s.commit = c;
+      }
+      scans.set(repo, s);
+    }
+  }
+  const repos = [];
+  for (const { repo } of listed) {
+    const settings = join(orgPack, "scan", `${repo.id}.yaml`);
+    repos.push({
+      ...repo,
+      cloned: await exists(join(baseClonePath(root, repo.id), ".git")),
+      scanSettings: { path: rel(settings), present: await exists(settings) },
+      lastScan: scans.get(repo.id) ?? null
+    });
+  }
+  const sourcesFile = join(orgPack, "sources.yaml");
+  const sources = {
+    path: rel(sourcesFile),
+    present: await exists(sourcesFile),
+    wikis: [],
+    absorbed: []
+  };
+  if (sources.present) {
+    try {
+      const s = Sources.safeParse((0, import_yaml.parse)(await readFile(sourcesFile, "utf8")));
+      if (!s.success)
+        problems.push({
+          file: rel(sourcesFile),
+          message: s.error.issues.map((i) => `${i.path.map(String).join(".") || "(file)"}: ${i.message}`).join("; ")
+        });
+      else {
+        sources.wikis = s.data.wikis.map((w) => ({
+          id: w.id,
+          type: w.type,
+          location: w.location,
+          spaces: w.spaces,
+          ...w.owner ? { owner: w.owner } : {},
+          // 2.30.0 (ADR 0132): how much its word counts, and where it applies.
+          ...w.authority ? { authority: w.authority } : {},
+          ...w.appliesTo ? { scope: scopeWords(w.appliesTo) } : {}
+        }));
+        sources.absorbed = s.data.absorbed.map((a) => ({
+          id: a.id,
+          url: a.url,
+          format: a.format,
+          mode: a.mode
+        }));
+      }
+    } catch (e) {
+      problems.push({ file: rel(sourcesFile), message: `can't read YAML: ${firstLine(e)}` });
+    }
+  }
+  return {
+    manifests,
+    repos,
+    sources,
+    catalog: { records: catalog.records.length },
+    problems
+  };
+}
+function uiOnboardingRoutes(r, ctx) {
+  return r.add("GET", "/api/onboarding", async () => ({
+    status: 200,
+    body: await onboardingView(ctx.root)
+  }));
+}
+
+export {
+  onboardingView,
+  uiOnboardingRoutes
+};

package/dist/chunk-2XM6PYQQ.js

@@ -0,0 +1,199 @@
+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 {
+  CLEAR_MATCH,
+  NO_SETTINGS,
+  PARTIAL_MATCH,
+  TARGETS_NONE,
+  TARGETS_SPLIT,
+  TARGETS_STEP,
+  TIE_MARGIN,
+  applyClients,
+  applyFactJoins,
+  applyPrefixes,
+  auditLinkCandidates,
+  catalogWithFacts,
+  checkScanSettings,
+  checkSpec,
+  citedFileHashes,
+  citedLine,
+  componentRenames,
+  curatedDirOf,
+  diffCatalogs,
+  diffIsEmpty,
+  draftRepoType,
+  estateFacts,
+  estateFlow,
+  estateFromFacts,
+  estateJoinOf,
+  estateMergeInput,
+  estateRepos,
+  estateStepKey,
+  factsForScan,
+  factsRecords,
+  familyMismatches,
+  fieldLineage,
+  flattenEstateFlow,
+  forgetCatalogs,
+  globName,
+  groupedTargetDrafts,
+  hostAliases,
+  hostQuestionDrafts,
+  isCodeFile,
+  isConfigFile,
+  isPrototypeRepo,
+  joinBase,
+  joinEstate,
+  joinReposOf,
+  keepCatalogsInMemory,
+  lineNamesUiWord,
+  lineSetsPort,
+  matchRepoType,
+  measureLinks,
+  mergeEstate,
+  orgPackDirFor,
+  outsideProfileSystems,
+  outsideSystems,
+  parseLinkReference,
+  pathScore,
+  pluginApplies,
+  pluginExtractor,
+  prefixOf,
+  productionRepos,
+  prototypeLeftOut,
+  prototypeScanNotes,
+  readCatalog,
+  remapIds,
+  repoComponents,
+  resolveSettingsTemplate,
+  resourceKey,
+  ruleCoversCall,
+  ruledTargets,
+  runPluginTests,
+  scanEstate,
+  specTriggers,
+  splitTargetGroups,
+  staleFlows,
+  staleTargetQuestions,
+  targetGroupQuestion,
+  targetPathPrefix,
+  targetQuestionDrafts,
+  targetQuestionFor,
+  targetsFromAnswers,
+  uiFindings,
+  unknownHosts,
+  usablePlugins,
+  withExcludes,
+  withPluginScan,
+  writeCatalog
+} from "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  fieldKey,
+  lineNamesField,
+  lineNamesRoute,
+  lineNamesWord
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  CLEAR_MATCH,
+  NO_SETTINGS,
+  PARTIAL_MATCH,
+  TARGETS_NONE,
+  TARGETS_SPLIT,
+  TARGETS_STEP,
+  TIE_MARGIN,
+  applyClients,
+  applyFactJoins,
+  applyPrefixes,
+  auditLinkCandidates,
+  catalogWithFacts,
+  checkScanSettings,
+  checkSpec,
+  citedFileHashes,
+  citedLine,
+  componentRenames,
+  curatedDirOf,
+  diffCatalogs,
+  diffIsEmpty,
+  draftRepoType,
+  estateFacts,
+  estateFlow,
+  estateFromFacts,
+  estateJoinOf,
+  estateMergeInput,
+  estateRepos,
+  estateStepKey,
+  factsForScan,
+  factsRecords,
+  familyMismatches,
+  fieldKey,
+  fieldLineage,
+  flattenEstateFlow,
+  forgetCatalogs,
+  globName,
+  groupedTargetDrafts,
+  hostAliases,
+  hostQuestionDrafts,
+  isCodeFile,
+  isConfigFile,
+  isPrototypeRepo,
+  joinBase,
+  joinEstate,
+  joinReposOf,
+  keepCatalogsInMemory,
+  lineNamesField,
+  lineNamesRoute,
+  lineNamesUiWord,
+  lineNamesWord,
+  lineSetsPort,
+  matchRepoType,
+  measureLinks,
+  mergeEstate,
+  orgPackDirFor,
+  outsideProfileSystems,
+  outsideSystems,
+  parseLinkReference,
+  pathScore,
+  pluginApplies,
+  pluginExtractor,
+  prefixOf,
+  productionRepos,
+  prototypeLeftOut,
+  prototypeScanNotes,
+  readCatalog,
+  remapIds,
+  repoComponents,
+  resolveSettingsTemplate,
+  resourceKey,
+  ruleCoversCall,
+  ruledTargets,
+  runPluginTests,
+  scanEstate,
+  specTriggers,
+  splitTargetGroups,
+  staleFlows,
+  staleTargetQuestions,
+  targetGroupQuestion,
+  targetPathPrefix,
+  targetQuestionDrafts,
+  targetQuestionFor,
+  targetsFromAnswers,
+  uiFindings,
+  unknownHosts,
+  usablePlugins,
+  withExcludes,
+  withPluginScan,
+  writeCatalog
+};