@goodbones/cli 0.1.0-beta.3 → 0.1.0-beta.5

package/src/run.ts

@@ -1,18 +1,20 @@
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 
 import {
   type Baseline,
   baselineOf,
+  type CoverageFamily,
   coverageOf,
-  coverageShortfalls,
+  cyclesIn,
   decodeBaseline,
   decodeManifest,
   EMPTY_BASELINE,
   evaluateGraph,
   evaluateMemberSite,
+  evaluateResolvedEdge,
   evaluateSelectedBindings,
-  evaluateSelectedEdge,
   evaluateStructure,
   evaluateSurface,
   exportRulesSelecting,
@@ -21,26 +23,34 @@ import {
   formatManifestYaml,
   formatMessage,
   fractionsOf,
+  type Graph,
   hasGraphRules,
+  heightOf,
   listSourceFiles,
+  makeBaselineFilter,
   MANIFEST_FILENAMES,
   MANIFEST_SCHEMA_ID,
   memberRulesSelecting,
+  type ObservedEdge,
   readManifestFile,
   requiredSiblingsOf,
+  residueOf,
   rulesSelecting,
   serializeBaseline,
+  slackOf,
+  type Snapshot,
+  SNAPSHOT_VERSION,
   type SourceFacts,
   staleEntriesOf,
   surfaceRulesSelecting,
-  unbaselined,
   type Violation,
 } from "@goodbones/core";
 import * as Effect from "effect/Effect";
 import * as Result from "effect/Result";
 
-import { type LoadedPolicy, loadPolicyFromFile } from "./config-loader.js";
+import { type LoadedPolicy, loadPolicyFromFile, manifestPathOf } from "./config-loader.js";
 import { buildGraph } from "./graph.js";
+import { infer } from "./infer.js";
 import { sourceFactsOf } from "./source-facts.js";
 
 // The policy, run with no linter in the loop.
@@ -59,16 +69,41 @@ export type CliFailure = { readonly _tag: "CliFailure"; readonly message: string
 
 const fail = (message: string): CliFailure => ({ _tag: "CliFailure", message });
 
+// An edge the resolver could not turn into a file. It is reported on its own,
+// since every import rule about it enforces nothing.
+export type UnresolvedEdge = {
+  readonly file: string;
+  readonly specifier: string;
+  readonly detail: string;
+};
+
 export type Findings = {
   readonly violations: ReadonlyArray<Violation>;
-  readonly unresolved: ReadonlyArray<string>;
+  readonly unresolved: ReadonlyArray<UnresolvedEdge>;
   readonly files: number;
+  // Every edge resolved from a file under an import rule — what the slack
+  // report reads. An edge from a file no import rule selects is not here,
+  // since no allowlist could have admitted it.
+  readonly edges: ReadonlyArray<ObservedEdge>;
+  // The import graph, when a graph rule needed it or the caller asked.
+  readonly graph: Graph | null;
 };
 
-export const collectFindings = (policy: LoadedPolicy, roots: ReadonlyArray<string>): Findings => {
+export type CollectOptions = {
+  // Build the graph even when no rule needs it — the snapshot counts cycles
+  // and orders violations by it.
+  readonly graph?: boolean;
+};
+
+export const collectFindings = (
+  policy: LoadedPolicy,
+  roots: ReadonlyArray<string>,
+  options: CollectOptions = {},
+): Findings => {
   const files = listSourceFiles(policy.repoRoot, roots, policy.languages);
   const violations: Array<Violation> = [];
-  const unresolved: Array<string> = [];
+  const unresolved: Array<UnresolvedEdge> = [];
+  const edges: Array<ObservedEdge> = [];
 
   // Each file is parsed at most once, whether the per-file families or the
   // graph pass asks first.
@@ -83,13 +118,12 @@ export const collectFindings = (policy: LoadedPolicy, roots: ReadonlyArray<strin
 
   // The graph is the whole repository resolved at once — the one question no
   // per-file adapter can ask — and is built only when a rule needs it.
-  if (hasGraphRules(policy.graph)) {
-    for (const violation of evaluateGraph(
-      policy.graph,
-      buildGraph(files, policy.resolver, factsOf),
-    )) {
-      violations.push(violation);
-    }
+  const graph =
+    options.graph === true || hasGraphRules(policy.graph)
+      ? buildGraph(files, policy.resolver, factsOf)
+      : null;
+  if (graph !== null && hasGraphRules(policy.graph)) {
+    for (const violation of evaluateGraph(policy.graph, graph)) violations.push(violation);
   }
 
   for (const file of files) {
@@ -124,14 +158,21 @@ export const collectFindings = (policy: LoadedPolicy, roots: ReadonlyArray<strin
     for (const specifier of facts.specifiers) {
       const edge = { importer: file, specifier };
 
-      const imported = evaluateSelectedEdge(selectedImports, policy.resolver, edge);
-      if (Result.isFailure(imported)) {
-        if (policy.config.resolve.unresolved === "off") continue;
-        if (policy.ignoreUnresolved.some((pattern) => pattern.test(specifier))) continue;
-        unresolved.push(`${file} → ${specifier} (${imported.failure.detail})`);
-        continue;
+      // A file no import rule selects never needs its imports resolved, which
+      // is what keeps resolution off the hot path for the bulk of the repo.
+      if (selectedImports.length > 0) {
+        const resolved = policy.resolver.resolve(file, specifier);
+        if (Result.isFailure(resolved)) {
+          if (policy.config.resolve.unresolved === "off") continue;
+          if (policy.ignoreUnresolved.some((pattern) => pattern.test(specifier))) continue;
+          unresolved.push({ file, specifier, detail: resolved.failure.detail });
+          continue;
+        }
+        edges.push({ importer: file, target: resolved.success });
+        for (const violation of evaluateResolvedEdge(selectedImports, file, resolved.success)) {
+          violations.push(violation);
+        }
       }
-      for (const violation of imported.success) violations.push(violation);
 
       const bound = facts.bindings.get(specifier) ?? [];
       const exported = evaluateSelectedBindings(selectedExports, policy.resolver, {
@@ -144,7 +185,7 @@ export const collectFindings = (policy: LoadedPolicy, roots: ReadonlyArray<strin
     }
   }
 
-  return { violations, unresolved, files: files.length };
+  return { violations, unresolved, files: files.length, edges, graph };
 };
 
 const baselinePathOf = (policy: LoadedPolicy): string | null =>
@@ -170,68 +211,338 @@ const report = (lines: ReadonlyArray<string>): Effect.Effect<void> =>
 const describe = (violation: Violation): string =>
   `  ${violation.file}\n      ${formatMessage(violation)}`;
 
+// Everything `check` has to say, as one value: the two renderers below read
+// it, and nothing else computes a finding. `version` is here so a document
+// that grows this shape (a conformance snapshot) can say which one it grew.
+export type ReportedViolation = Violation & {
+  readonly fingerprint: string;
+  readonly baselined: boolean;
+};
+
+export type CoverageReport = Readonly<
+  Record<
+    CoverageFamily,
+    { readonly covered: number; readonly total: number; readonly floor?: number }
+  >
+>;
+
+export type CheckReport = {
+  readonly version: 1;
+  readonly files: number;
+  readonly roots: ReadonlyArray<string>;
+  readonly ok: boolean;
+  // The file the policy was read from, repo-relative, and a hash of its
+  // bytes — the root file only, when the manifest is split with `include`.
+  readonly manifest: { readonly path: string; readonly sha256: string };
+  // Every finding, baselined ones included; `baselined` says which.
+  readonly violations: ReadonlyArray<ReportedViolation>;
+  readonly unresolved: ReadonlyArray<UnresolvedEdge>;
+  // Baseline entries the code no longer produces.
+  readonly stale: ReadonlyArray<string>;
+  readonly coverage: CoverageReport;
+  readonly adoption: {
+    readonly unrestricted: ReadonlyArray<string>;
+    readonly partial: ReadonlyArray<string>;
+  };
+};
+
+const COVERAGE_FAMILIES: ReadonlyArray<CoverageFamily> = [
+  "imports",
+  "structure",
+  "members",
+  "surface",
+  "graph",
+];
+
+const sha256Of = (file: string): string => {
+  try {
+    return createHash("sha256").update(readFileSync(file)).digest("hex");
+  } catch {
+    return "";
+  }
+};
+
+export const checkReport = (
+  policy: LoadedPolicy,
+  roots: ReadonlyArray<string>,
+  manifestPath: string,
+): CheckReport => reportOf(policy, roots, manifestPath, collectFindings(policy, roots));
+
+const reportOf = (
+  policy: LoadedPolicy,
+  roots: ReadonlyArray<string>,
+  manifestPath: string,
+  findings: Findings,
+): CheckReport => {
+  const baseline = readBaseline(policy);
+  const stale = staleEntriesOf(baseline, findings.violations);
+  const { isBaselined } = makeBaselineFilter(baseline);
+  const violations = findings.violations.map((violation) => ({
+    ...violation,
+    fingerprint: fingerprintOf(violation),
+    baselined: isBaselined(violation),
+  }));
+
+  // The floors. A policy states how much of the tree it reaches, per
+  // family; falling under is a policy that quietly stopped covering files.
+  const floors = policy.config.limits?.coverage ?? {};
+  const found = coverageOf(policy, listSourceFiles(policy.repoRoot, roots, policy.languages));
+  const covered = (family: CoverageFamily): number =>
+    family === "structure" ? found.structure.enumerated : found[family].covered;
+  const coverage = Object.fromEntries(
+    COVERAGE_FAMILIES.map((family) => {
+      const floor = floors[family];
+      return [
+        family,
+        {
+          covered: covered(family),
+          total: found.files,
+          ...(floor === undefined ? {} : { floor }),
+        },
+      ];
+    }),
+  ) as CoverageReport;
+  const shortfalls = shortfallsOf(coverage);
+
+  const reportable = violations.filter((one) => !one.baselined).length;
+  return {
+    version: 1,
+    files: findings.files,
+    roots,
+    ok:
+      reportable === 0 &&
+      findings.unresolved.length === 0 &&
+      stale.length === 0 &&
+      shortfalls.length === 0,
+    manifest: {
+      path: path.relative(policy.repoRoot, manifestPath).replaceAll(path.sep, "/"),
+      sha256: sha256Of(manifestPath),
+    },
+    violations,
+    unresolved: findings.unresolved,
+    stale,
+    coverage,
+    adoption: {
+      unrestricted: policy.adoption.unrestricted,
+      partial: policy.adoption.partial,
+    },
+  };
+};
+
+// Why a report is not `ok`, in the order the text renderer explains it: a
+// stale baseline first, since nothing else is trustworthy until the file
+// describes something real.
+type Shortfall = {
+  readonly family: CoverageFamily;
+  readonly actual: number;
+  readonly floor: number;
+};
+
+const shortfallsOf = (coverage: CoverageReport): ReadonlyArray<Shortfall> =>
+  COVERAGE_FAMILIES.flatMap((family) => {
+    const { covered, floor, total } = coverage[family];
+    const actual = total === 0 ? 1 : covered / total;
+    return floor === undefined || actual >= floor ? [] : [{ family, actual, floor }];
+  });
+
+const failureOf = (
+  report: CheckReport,
+  shortfalls: ReadonlyArray<Shortfall>,
+): CliFailure | null => {
+  if (report.stale.length > 0) return fail("stale baseline entries");
+  if (shortfalls.length > 0) return fail("coverage below floor");
+  if (report.ok) return null;
+  return fail("architecture violations");
+};
+
+const renderText = (report: CheckReport): ReadonlyArray<string> => {
+  const reportable = report.violations.filter((one) => !one.baselined);
+  const carried = report.violations.length - reportable.length;
+  const shortfalls = shortfallsOf(report.coverage);
+  return [
+    ...reportable.map(describe),
+    ...report.unresolved.map(
+      (one) => `  unresolved: ${one.file} → ${one.specifier} (${one.detail})`,
+    ),
+    "",
+    `${String(report.files)} files, ${String(reportable.length)} violations` +
+      (carried > 0 ? `, ${String(carried)} carried by the baseline` : ""),
+    // The ratchet: a fixed violation must leave the baseline, or the floor
+    // never rises and the file stops describing anything real.
+    ...(report.stale.length === 0
+      ? []
+      : [
+          "",
+          `${String(report.stale.length)} baseline entries no longer fire. The code was fixed; prune them:`,
+          ...report.stale.map((entry) => `  ${entry}`),
+          "",
+          "  architecture baseline    # rewrites the file from what still fires",
+        ]),
+    ...(shortfalls.length === 0
+      ? []
+      : [
+          "",
+          "coverage is below the floor the policy states for itself:",
+          ...shortfalls.map(
+            (one) => `  ${one.family}: ${percent(one.actual)} covered, floor ${percent(one.floor)}`,
+          ),
+          "",
+          "  architecture coverage    # which files no rule reaches",
+        ]),
+  ];
+};
+
+export type CheckOptions = {
+  readonly format: "text" | "json";
+  readonly manifestPath: string;
+};
+
 export const check = (
   policy: LoadedPolicy,
   roots: ReadonlyArray<string>,
+  options: CheckOptions,
 ): Effect.Effect<void, CliFailure> =>
   Effect.gen(function* () {
-    const findings = collectFindings(policy, roots);
-    const baseline = readBaseline(policy);
-    const reportable = unbaselined(baseline, findings.violations);
-    const stale = staleEntriesOf(baseline, findings.violations);
+    const report_ = checkReport(policy, roots, options.manifestPath);
+    // JSON is one object on stdout and nothing else there; the failure, when
+    // there is one, is a sentence on stderr and the exit code, as in text.
+    yield* report(
+      options.format === "json" ? [JSON.stringify(report_, null, 2)] : renderText(report_),
+    );
+    const failure = failureOf(report_, shortfallsOf(report_.coverage));
+    if (failure !== null) return yield* Effect.fail(failure);
+  });
 
-    yield* report(reportable.map(describe));
-    yield* report(findings.unresolved.map((one) => `  unresolved: ${one}`));
+const percent = (fraction: number): string => `${String(Math.floor(fraction * 100))}%`;
 
-    const carried = findings.violations.length - reportable.length;
-    yield* report([
-      "",
-      `${String(findings.files)} files, ${String(reportable.length)} violations` +
-        (carried > 0 ? `, ${String(carried)} carried by the baseline` : ""),
-    ]);
+// The conformance snapshot: `check`'s report grown with what no family
+// reaches, what the allowlists permit and nothing uses, the cycle count and
+// the size of the debt — the whole distance between the tree and the
+// manifest, as one document another run can be compared against. Its shape
+// is the core's `Snapshot`, and the schema published beside the manifest's.
+export const snapshotOf = (
+  policy: LoadedPolicy,
+  roots: ReadonlyArray<string>,
+  manifestPath: string,
+): Snapshot => {
+  const findings = collectFindings(policy, roots, { graph: true });
+  const report_ = reportOf(policy, roots, manifestPath, findings);
+  const files = listSourceFiles(policy.repoRoot, roots, policy.languages);
+  const graph = findings.graph ?? { files, edges: new Map() };
+  const heights = heightOf(graph);
+
+  // Leaf edges first. A violation names a target when it is about an edge;
+  // the cost of fixing it is roughly how much of the graph stands beneath
+  // that target, so the ones nearest the ground come first and a reader
+  // starting at the top of the list is starting where a fix stays local.
+  // Ties keep the fingerprint order, so the list is the same on every run.
+  const heightOfViolation = (one: ReportedViolation): number =>
+    heights.get(one.subject ?? "") ?? heights.get(one.file) ?? 0;
+  const violations = [...report_.violations].sort((left, right) => {
+    const byHeight = heightOfViolation(left) - heightOfViolation(right);
+    return byHeight !== 0 ? byHeight : left.fingerprint.localeCompare(right.fingerprint);
+  });
 
-    if (stale.length > 0) {
-      // The ratchet: a fixed violation must leave the baseline, or the floor
-      // never rises and the file stops describing anything real.
-      yield* report([
-        "",
-        `${String(stale.length)} baseline entries no longer fire. The code was fixed; prune them:`,
-        ...stale.map((entry) => `  ${entry}`),
-        "",
-        "  architecture baseline    # rewrites the file from what still fires",
-      ]);
-      return yield* Effect.fail(fail("stale baseline entries"));
-    }
+  return {
+    version: SNAPSHOT_VERSION,
+    manifest: report_.manifest,
+    roots: report_.roots,
+    files: report_.files,
+    ok: report_.ok,
+    coverage: report_.coverage,
+    residue: residueOf(policy, files),
+    violations,
+    unresolved: report_.unresolved,
+    stale: report_.stale,
+    baseline: { size: readBaseline(policy).entries.length },
+    cycles: cyclesIn(graph).length,
+    slack: slackOf(policy.importRules, findings.edges),
+    adoption: report_.adoption,
+  };
+};
 
-    // The floors. A policy states how much of the tree it reaches, per
-    // family; falling under is a policy that quietly stopped covering files.
-    const floors = policy.config.limits?.coverage;
-    const shortfalls =
-      floors === undefined
-        ? []
-        : coverageShortfalls(
-            coverageOf(policy, listSourceFiles(policy.repoRoot, roots, policy.languages)),
-            floors,
-          );
-    if (shortfalls.length > 0) {
-      yield* report([
-        "",
-        "coverage is below the floor the policy states for itself:",
-        ...shortfalls.map(
-          (one) => `  ${one.family}: ${percent(one.actual)} covered, floor ${percent(one.floor)}`,
-        ),
-        "",
-        "  architecture coverage    # which files no rule reaches",
-      ]);
-      return yield* Effect.fail(fail("coverage below floor"));
-    }
+const renderSnapshot = (snapshot: Snapshot): ReadonlyArray<string> => {
+  const reportable = snapshot.violations.filter((one) => !one.baselined);
+  const carried = snapshot.violations.length - reportable.length;
+  const count = (n: number, noun: string, plural = `${noun}s`): string =>
+    `${String(n)} ${n === 1 ? noun : plural}`;
+  const row = (family: CoverageFamily): string => {
+    const { covered, floor, total } = snapshot.coverage[family];
+    const fraction = total === 0 ? 1 : covered / total;
+    const mark =
+      floor === undefined
+        ? ""
+        : fraction >= floor
+          ? `  ≥ ${percent(floor)} ✓`
+          : `  < ${percent(floor)} ✗`;
+    return `  ${family.padEnd(10)} ${String(covered).padStart(5)}/${String(total)}  ${percent(fraction).padStart(4)}${mark}`;
+  };
+  const section = (title: string, lines: ReadonlyArray<string>): ReadonlyArray<string> => [
+    "",
+    title,
+    ...lines,
+  ];
+
+  return [
+    `${String(snapshot.files)} files under ${snapshot.roots.join(", ")}, against ${snapshot.manifest.path}`,
+    ...section("coverage", COVERAGE_FAMILIES.map(row)),
+    ...section(
+      `residue: ${count(snapshot.residue.files.length, "file")} no family reaches` +
+        (snapshot.residue.folders.length === 0
+          ? ""
+          : `, ${count(snapshot.residue.folders.length, "folder")} wholly`),
+      [
+        ...snapshot.residue.folders.map((folder) => `  ${folder}/`),
+        ...snapshot.residue.files
+          .filter(
+            (file) => !snapshot.residue.folders.some((folder) => file.startsWith(`${folder}/`)),
+          )
+          .map((file) => `  ${file}`),
+      ],
+    ),
+    ...section(
+      `violations: ${count(reportable.length, "reportable")}` +
+        (carried > 0 ? `, ${String(carried)} carried by the baseline` : "") +
+        (snapshot.stale.length > 0
+          ? `, ${count(snapshot.stale.length, "stale entry", "stale entries")}`
+          : "") +
+        (reportable.length > 0 ? " — nearest the ground first" : ""),
+      reportable.map(describe),
+    ),
+    ...(snapshot.unresolved.length === 0
+      ? []
+      : section(
+          `unresolved: ${count(snapshot.unresolved.length, "import")} no rule can police`,
+          snapshot.unresolved.map((one) => `  ${one.file} → ${one.specifier} (${one.detail})`),
+        )),
+    ...section(
+      `slack: ${count(snapshot.slack.length, "allowance")} nothing imports through`,
+      snapshot.slack.map((one) => `  ${one.node}: ${one.kind} ${JSON.stringify(one.entry)}`),
+    ),
+    "",
+    `cycles: ${String(snapshot.cycles)}`,
+    `baseline: ${count(snapshot.baseline.size, "entry", "entries")}`,
+    `adoption: ${count(snapshot.adoption.unrestricted.length, "unrestricted tier")}, ${count(snapshot.adoption.partial.length, "partial tier")}`,
+  ];
+};
 
-    if (reportable.length > 0 || findings.unresolved.length > 0) {
-      return yield* Effect.fail(fail("architecture violations"));
-    }
-  });
+export type ConformanceOptions = CheckOptions;
 
-const percent = (fraction: number): string => `${String(Math.floor(fraction * 100))}%`;
+// The report of the tree against the manifest. Unlike `check`, it never
+// fails: it is a measurement, and the manifest it measures against may be one
+// the tree was never expected to satisfy yet — `--against` names a target.
+// `ok` in the document says what `check` would have done.
+export const conformance = (
+  policy: LoadedPolicy,
+  roots: ReadonlyArray<string>,
+  options: ConformanceOptions,
+): Effect.Effect<void, CliFailure> =>
+  Effect.gen(function* () {
+    const snapshot = snapshotOf(policy, roots, options.manifestPath);
+    yield* report(
+      options.format === "json" ? [JSON.stringify(snapshot, null, 2)] : renderSnapshot(snapshot),
+    );
+  });
 
 // How much of the tree the policy reaches. A probe proves a rule can fire;
 // this is whether the files are there to fire on. Reported per family, with the
@@ -585,23 +896,58 @@ export const run = (
   Effect.gen(function* () {
     const [command = "check", ...rest] = argv;
 
-    // The two commands that write a manifest rather than read one.
+    // The three commands that write a manifest rather than read one.
     if (command === "init") return yield* init(repoRoot);
     if (command === "migrate") return yield* migrate(repoRoot, configFilename);
+    if (command === "infer") {
+      yield* infer(repoRoot, rest, configFilename);
+      return;
+    }
+
+    // `--against <file>` measures the tree against a manifest other than the
+    // repository's own — the target the team is moving toward. Only
+    // `conformance` takes it: a `check` against a manifest nobody is held to
+    // yet would fail for no one's benefit.
+    const againstAt = rest.indexOf("--against");
+    const against = againstAt === -1 ? undefined : rest[againstAt + 1];
+    if (againstAt !== -1 && (against === undefined || against.startsWith("--"))) {
+      return yield* Effect.fail(fail("--against needs a manifest path"));
+    }
+    if (against !== undefined && command !== "conformance") {
+      return yield* Effect.fail(
+        fail(`--against is a \`conformance\` flag; ${command} does not take it`),
+      );
+    }
+    const manifestFilename = against ?? configFilename;
 
     const policy = yield* Effect.tryPromise({
-      try: () => loadPolicyFromFile(repoRoot, configFilename),
+      try: () => loadPolicyFromFile(repoRoot, manifestFilename),
       catch: (cause) => fail(String(cause)),
     });
     yield* Effect.sync(() => {
       for (const notice of policy.notices) process.stderr.write(`deprecated: ${notice}\n`);
     });
 
-    const roots = rest.length > 0 ? rest : ["packages"];
+    const json = rest.includes("--json");
+    const positional = rest.filter(
+      (argument, index) =>
+        argument !== "--json" &&
+        argument !== "--against" &&
+        (againstAt === -1 || index !== againstAt + 1),
+    );
+    const roots = positional.length > 0 ? positional : ["packages"];
 
     switch (command) {
       case "check":
-        return yield* check(policy, roots);
+        return yield* check(policy, roots, {
+          format: json ? "json" : "text",
+          manifestPath: manifestPathOf(repoRoot, configFilename),
+        });
+      case "conformance":
+        return yield* conformance(policy, roots, {
+          format: json ? "json" : "text",
+          manifestPath: manifestPathOf(repoRoot, manifestFilename),
+        });
       case "baseline":
         return yield* writeBaseline(policy, roots);
       case "explain": {
@@ -612,14 +958,14 @@ export const run = (
       case "coverage":
         return yield* coverage(policy, roots);
       case "facts": {
-        const [file] = rest.filter((argument) => argument !== "--json");
+        const [file] = positional;
         if (file === undefined) return yield* Effect.fail(fail("facts needs a file path"));
-        return yield* facts(policy, file, rest.includes("--json") ? "json" : "text");
+        return yield* facts(policy, file, json ? "json" : "text");
       }
       default:
         return yield* Effect.fail(
           fail(
-            `unknown command "${command}". Try: check | baseline | coverage | explain <file> | facts <file> [--json] | init | migrate`,
+            `unknown command "${command}". Try: check [--json] | conformance [--json] [--against <manifest>] | baseline | coverage | explain <file> | facts <file> [--json] | init | infer | migrate`,
           ),
         );
     }