@intentius/chant 0.13.1 → 0.15.1

package/src/cli/commands/doctor.test.ts

@@ -1,8 +1,33 @@
 import { describe, test, expect } from "vitest";
 import { doctorCommand } from "./doctor";
 import { withTestDir } from "@intentius/chant-test-utils";
-import { writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
+import { writeFileSync, mkdirSync, rmSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+/**
+ * Root `node_modules/` — where a bare `@intentius/chant-capability-<name>`
+ * specifier actually resolves from from within this package (dynamic
+ * `import()` in ../../components/capability-plugin-loader.ts resolves
+ * relative to the importing module, not to whatever `testDir` a doctor test
+ * points `doctorCommand` at). Used below to install a throwaway, genuinely
+ * malformed capability package for the duration of one test, then remove it.
+ */
+const repoNodeModules = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "..", "..", "node_modules");
+
+/** Write a minimal CJS/ESM-agnostic package under `@intentius/chant-capability-<name>` in the real node_modules, for exercising the doctor's capability-plugin check end to end. Caller must remove it (see `finally` blocks below). */
+function installFakeCapabilityPackage(name: string, indexSource: string): string {
+  const pkgDir = join(repoNodeModules, "@intentius", `chant-capability-${name}`);
+  mkdirSync(pkgDir, { recursive: true });
+  writeFileSync(join(pkgDir, "package.json"), JSON.stringify({ name: `@intentius/chant-capability-${name}`, version: "1.0.0", type: "module", main: "index.js" }));
+  writeFileSync(join(pkgDir, "index.js"), indexSource);
+  return pkgDir;
+}
+
+function removeFakeCapabilityPackage(name: string): void {
+  const pkgDir = join(repoNodeModules, "@intentius", `chant-capability-${name}`);
+  if (existsSync(pkgDir)) rmSync(pkgDir, { recursive: true, force: true });
+}
 
 describe("doctorCommand", () => {
   test("config-exists fails when no config file present", async () => {
@@ -236,4 +261,93 @@ describe("doctorCommand", () => {
       expect(check!.status).toBe("pass");
     });
   });
+
+  // ── Capability plugin checks (#559, epic #551) ─────────────────────────
+
+  test("capability plugin check fails when the named package cannot be found", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(
+        join(testDir, "chant.config.json"),
+        JSON.stringify({ capabilities: ["nonexistent-capability-package"] }),
+      );
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "capability-nonexistent-capability-package");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("fail");
+      expect(check!.message).toContain("could not be loaded");
+      expect(report.success).toBe(false);
+    });
+  });
+
+  test("capability plugin check fails for a malformed package (no CapabilityPlugin export)", async () => {
+    installFakeCapabilityPackage("broken", "export const notAPlugin = { oops: true };\n");
+    try {
+      await withTestDir(async (testDir) => {
+        writeFileSync(
+          join(testDir, "chant.config.json"),
+          JSON.stringify({ capabilities: ["broken"] }),
+        );
+        const report = await doctorCommand(testDir);
+        const check = report.checks.find((c) => c.name === "capability-broken");
+        expect(check).toBeDefined();
+        expect(check!.status).toBe("fail");
+        expect(check!.message).toMatch(/could not be loaded|does not export/);
+        expect(report.success).toBe(false);
+      });
+    } finally {
+      removeFakeCapabilityPackage("broken");
+    }
+  });
+
+  test("capability plugin check fails when capabilities() is not a function (malformed shape)", async () => {
+    installFakeCapabilityPackage(
+      "half-broken",
+      "export const plugin = { name: 'half-broken', version: '1.0.0', capabilities: 'not-a-function' };\n",
+    );
+    try {
+      await withTestDir(async (testDir) => {
+        writeFileSync(
+          join(testDir, "chant.config.json"),
+          JSON.stringify({ capabilities: ["half-broken"] }),
+        );
+        const report = await doctorCommand(testDir);
+        const check = report.checks.find((c) => c.name === "capability-half-broken");
+        expect(check).toBeDefined();
+        expect(check!.status).toBe("fail");
+      });
+    } finally {
+      removeFakeCapabilityPackage("half-broken");
+    }
+  });
+
+  test("capability plugin check passes for a well-formed package", async () => {
+    installFakeCapabilityPackage(
+      "good",
+      "export const plugin = { name: 'good', version: '1.0.0', capabilities: () => [{ kind: 'demo-verb', run: async () => ({}) }] };\n",
+    );
+    try {
+      await withTestDir(async (testDir) => {
+        writeFileSync(
+          join(testDir, "chant.config.json"),
+          JSON.stringify({ capabilities: ["good"] }),
+        );
+        const report = await doctorCommand(testDir);
+        const check = report.checks.find((c) => c.name === "capability-good");
+        expect(check).toBeDefined();
+        expect(check!.status).toBe("pass");
+        expect(check!.message).toContain("1 capability(ies) registered");
+      });
+    } finally {
+      removeFakeCapabilityPackage("good");
+    }
+  });
+
+  test("no capability checks are added when config.capabilities is absent", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      const report = await doctorCommand(testDir);
+      const capabilityChecks = report.checks.filter((c) => c.name.startsWith("capability-"));
+      expect(capabilityChecks.length).toBe(0);
+    });
+  });
 });

package/src/cli/commands/doctor.ts

@@ -5,6 +5,8 @@ import { fileURLToPath } from "url";
 import { checkVersionCompatibility } from "../../lexicon-manifest";
 import { debug } from "../debug";
 import { loadPlugins, resolveProjectLexicons } from "../plugins";
+import { loadCapabilityPlugin } from "../../components/capability-plugin-loader";
+import { isCapabilityPlugin } from "../../components/capability-plugin";
 
 export interface DoctorCheck {
   name: string;
@@ -221,6 +223,50 @@ export async function doctorCommand(path: string): Promise<DoctorReport> {
     debug("skills check failed:", e);
   }
 
+  // Check: Capability plugin packages (#559, epic #551) — each name in
+  // config.capabilities must load and satisfy the CapabilityPlugin contract
+  // (../../components/capability-plugin.ts). A malformed capability package
+  // (missing/broken `capabilities()`, or the package failing to resolve at
+  // all) is reported as a `fail`, mirroring how a missing lexicon type
+  // directory fails above rather than warning.
+  const capabilityNames = config?.capabilities as string[] | undefined;
+  if (capabilityNames && Array.isArray(capabilityNames)) {
+    for (const name of capabilityNames) {
+      try {
+        const plugin = await loadCapabilityPlugin(name);
+        if (!isCapabilityPlugin(plugin)) {
+          checks.push({
+            name: `capability-${name}`,
+            status: "fail",
+            message: `Capability plugin "${name}" does not satisfy the CapabilityPlugin contract (missing name/version/capabilities())`,
+          });
+          continue;
+        }
+        const capabilities = plugin.capabilities();
+        if (!Array.isArray(capabilities)) {
+          checks.push({
+            name: `capability-${name}`,
+            status: "fail",
+            message: `Capability plugin "${name}": capabilities() did not return an array`,
+          });
+          continue;
+        }
+        checks.push({
+          name: `capability-${name}`,
+          status: "pass",
+          message: `${capabilities.length} capability(ies) registered`,
+        });
+      } catch (e) {
+        debug(`capability plugin check failed for ${name}:`, e);
+        checks.push({
+          name: `capability-${name}`,
+          status: "fail",
+          message: `Capability plugin "${name}" could not be loaded: ${e instanceof Error ? e.message : String(e)}`,
+        });
+      }
+    }
+  }
+
   return {
     checks,
     success: checks.every(c => c.status !== "fail"),

package/src/cli/commands/lexicon-rolling-upgrade.ts

@@ -0,0 +1,198 @@
+/**
+ * `chant dev rolling-upgrade <lexicon-dir>` command implementation.
+ *
+ * Detects rolling-spec drift for the aws, azure, and github lexicons. These
+ * lexicons pin no version constant — "latest" is fetched on every regen. This
+ * command regenerates from current-latest, diffs the produced API surface
+ * against the committed baseline (surface.snapshot.json), and REPORTS the
+ * result. It is a dry run: it never opens a PR, updates a branch, or writes the
+ * baseline. PR automation and scheduling live in #527.
+ *
+ * The PR label an eventual automation would apply is derived from severity:
+ *   additive → `minor`, breaking → `major`. This command only prints it.
+ */
+
+import { existsSync } from "fs";
+import { resolve } from "path";
+import {
+  checkRollingUpgrade,
+  type RollingUpgradeResult,
+} from "../../codegen/rolling-upgrade";
+
+// ── Types ─────────────────────────────────────────────────────────────
+
+export interface RollingUpgradeCliOptions {
+  /** Resolved path to the lexicon directory. */
+  lexiconDir: string;
+  /** Force re-fetch of the upstream spec (bypass cache). */
+  force?: boolean;
+  /** Print subprocess output while running. */
+  verbose?: boolean;
+}
+
+// ── Main entry ────────────────────────────────────────────────────────
+
+/**
+ * Run the rolling-upgrade check and return the result.
+ * Returns a synthetic failed result when the directory is missing.
+ */
+export async function runRollingUpgrade(
+  opts: RollingUpgradeCliOptions,
+): Promise<RollingUpgradeResult> {
+  const dir = resolve(opts.lexiconDir);
+
+  if (!existsSync(dir)) {
+    return {
+      lexicon: "aws",
+      hasUpgrade: false,
+      severity: "none",
+      delta: { added: [], changed: [], removed: [], severity: "none" },
+      deltaText: "",
+      validationOk: false,
+      failures: [{ step: "setup", output: `Lexicon directory not found: ${dir}` }],
+      apiVersionDelta: [],
+      freshSnapshot: null,
+    };
+  }
+
+  return checkRollingUpgrade({
+    lexiconDir: dir,
+    force: opts.force,
+    verbose: opts.verbose,
+  });
+}
+
+/**
+ * Map surface severity to the semver PR label an upgrade would carry.
+ * additive → minor, breaking → major, none → none.
+ */
+export function severityToLabel(severity: RollingUpgradeResult["severity"]): string {
+  if (severity === "breaking") return "major";
+  if (severity === "additive") return "minor";
+  return "none";
+}
+
+// ── Human-readable output ─────────────────────────────────────────────
+
+const COLORS = {
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  gray: "\x1b[90m",
+  bold: "\x1b[1m",
+  reset: "\x1b[0m",
+};
+
+function useColors(): boolean {
+  return !process.env.NO_COLOR && process.stdout.isTTY !== false;
+}
+
+function c(text: string, code: string): string {
+  return useColors() ? `${code}${text}${COLORS.reset}` : text;
+}
+
+/**
+ * Print the rolling-upgrade result to stdout.
+ */
+export function printRollingUpgradeResult(result: RollingUpgradeResult, json: boolean): void {
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          lexicon: result.lexicon,
+          hasUpgrade: result.hasUpgrade,
+          severity: result.severity,
+          label: severityToLabel(result.severity),
+          validationOk: result.validationOk,
+          delta: result.delta,
+          apiVersionDelta: result.apiVersionDelta,
+          failures: result.failures,
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+
+  console.log(c(`Rolling upgrade check: ${result.lexicon}`, COLORS.bold));
+  console.log("");
+
+  // Surface delta — the review payload
+  if (result.deltaText) {
+    console.log(result.deltaText);
+  } else {
+    console.log(c("No surface changes.", COLORS.green));
+  }
+
+  // azure API-version delta
+  if (result.apiVersionDelta.length > 0) {
+    console.log("");
+    console.log(c(`API version changes (${result.apiVersionDelta.length}):`, COLORS.bold));
+    for (const v of result.apiVersionDelta) {
+      const arrow =
+        v.kind === "added"
+          ? `+ ${v.provider} (${v.after})`
+          : v.kind === "removed"
+            ? `- ${v.provider} (was ${v.before})`
+            : `~ ${v.provider}: ${v.before} -> ${v.after}`;
+      console.log(`  ${arrow}`);
+    }
+  }
+
+  // Failures
+  if (result.failures.length > 0) {
+    console.log("");
+    console.log(c(`${result.failures.length} step(s) failed:`, COLORS.bold));
+    for (const f of result.failures) {
+      console.log(
+        c(
+          `  FAIL [${f.step}]${f.exitCode !== undefined ? ` (exit ${f.exitCode})` : ""}`,
+          COLORS.red,
+        ),
+      );
+      if (f.output) {
+        const indented = f.output
+          .split("\n")
+          .map((l) => `       ${l}`)
+          .join("\n");
+        console.log(c(indented, COLORS.gray));
+      }
+    }
+  }
+
+  console.log("");
+
+  // Decision line
+  const severityColor =
+    result.severity === "breaking"
+      ? COLORS.red
+      : result.severity === "additive"
+        ? COLORS.yellow
+        : COLORS.green;
+
+  const label = severityToLabel(result.severity);
+  const validationLabel = result.validationOk
+    ? c("ok", COLORS.green)
+    : c("FAILED", COLORS.red);
+
+  console.log(
+    `Upgrade: ${result.hasUpgrade}  Severity: ${c(result.severity, severityColor)}  ` +
+      `Label: ${label}  Validation: ${validationLabel}`,
+  );
+
+  if (result.hasUpgrade && result.validationOk) {
+    console.log(
+      c(
+        `A PR would be opened: chore(${result.lexicon}): regen from latest spec [${label}]`,
+        COLORS.gray,
+      ),
+    );
+  } else if (result.hasUpgrade && !result.validationOk) {
+    console.log(
+      c("Surface moved but validation failed — no PR; surfaces as a report/issue (#527).", COLORS.yellow),
+    );
+  } else {
+    console.log(c("No surface change — no PR.", COLORS.gray));
+  }
+}

package/src/cli/commands/lexicon-surface-diff.test.ts

@@ -0,0 +1,104 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import { mkdtempSync, writeFileSync, readFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import type { RegenResult } from "../../codegen/lexicon-regen";
+
+// Stub the heavy regen pipeline — these tests only exercise the re-baseline /
+// version-bump wiring (#616), not the actual spec fetch + tsc build.
+const regenLexicon = vi.fn<(...a: unknown[]) => Promise<RegenResult>>();
+const writeSurfaceSnapshot = vi.fn();
+vi.mock("../../codegen/lexicon-regen", () => ({
+  regenLexicon: (...args: unknown[]) => regenLexicon(...args),
+  writeSurfaceSnapshot: (...args: unknown[]) => writeSurfaceSnapshot(...args),
+  SNAPSHOT_FILENAME: "surface.snapshot.json",
+}));
+
+import { runSurfaceDiff } from "./lexicon-surface-diff";
+
+function result(over: Partial<RegenResult>): RegenResult {
+  return {
+    ok: true,
+    changed: true,
+    severity: "additive",
+    delta: { added: [], changed: [], removed: [], severity: "additive" },
+    deltaText: "",
+    failures: [],
+    freshSnapshot: { surface: "x" } as unknown as RegenResult["freshSnapshot"],
+    ...over,
+  };
+}
+
+function lexiconDir(version = "0.13.1"): string {
+  const dir = mkdtempSync(join(tmpdir(), "sd-"));
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "lex", version }, null, 2) + "\n");
+  return dir;
+}
+
+function readVersion(dir: string): string {
+  return (JSON.parse(readFileSync(join(dir, "package.json"), "utf-8")) as { version: string }).version;
+}
+
+describe("runSurfaceDiff --bump (#616)", () => {
+  beforeEach(() => {
+    regenLexicon.mockReset();
+    writeSurfaceSnapshot.mockReset();
+  });
+
+  test("additive drift with --update-snapshot --bump bumps the patch", async () => {
+    const dir = lexiconDir("0.13.1");
+    try {
+      regenLexicon.mockResolvedValue(result({ severity: "additive" }));
+      await runSurfaceDiff({ lexiconDir: dir, updateSnapshot: true, bump: true });
+      expect(readVersion(dir)).toBe("0.13.2");
+      expect(writeSurfaceSnapshot).toHaveBeenCalledOnce();
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("breaking drift bumps the minor (pre-1.0)", async () => {
+    const dir = lexiconDir("0.13.1");
+    try {
+      regenLexicon.mockResolvedValue(result({ severity: "breaking" }));
+      await runSurfaceDiff({ lexiconDir: dir, updateSnapshot: true, bump: true });
+      expect(readVersion(dir)).toBe("0.14.0");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("no --bump leaves the version untouched even when the surface changed", async () => {
+    const dir = lexiconDir("0.13.1");
+    try {
+      regenLexicon.mockResolvedValue(result({ severity: "additive" }));
+      await runSurfaceDiff({ lexiconDir: dir, updateSnapshot: true });
+      expect(readVersion(dir)).toBe("0.13.1");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("--bump with no surface change leaves the version untouched", async () => {
+    const dir = lexiconDir("0.13.1");
+    try {
+      regenLexicon.mockResolvedValue(result({ changed: false, severity: "none" }));
+      await runSurfaceDiff({ lexiconDir: dir, updateSnapshot: true, bump: true });
+      expect(readVersion(dir)).toBe("0.13.1");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("--bump without --update-snapshot does nothing (no re-baseline, no bump)", async () => {
+    const dir = lexiconDir("0.13.1");
+    try {
+      regenLexicon.mockResolvedValue(result({ severity: "additive" }));
+      await runSurfaceDiff({ lexiconDir: dir, bump: true });
+      expect(readVersion(dir)).toBe("0.13.1");
+      expect(writeSurfaceSnapshot).not.toHaveBeenCalled();
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/cli/commands/lexicon-surface-diff.ts

@@ -0,0 +1,185 @@
+/**
+ * `chant dev surface-diff <lexicon-dir>` command implementation.
+ *
+ * Regenerates a lexicon from its spec, validates the result, extracts the
+ * public API surface, and diffs it against the committed baseline snapshot.
+ *
+ * Outputs a human-readable delta to stdout and optionally a machine-readable
+ * JSON result to a file. Never auto-fixes: failures are captured and reported.
+ *
+ * The snapshot file is written to `<lexicon-dir>/surface.snapshot.json`.
+ * Pass `--update-snapshot` to commit the fresh snapshot after a successful run.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { resolve, join } from "path";
+import { regenLexicon, writeSurfaceSnapshot, SNAPSHOT_FILENAME, type RegenResult } from "../../codegen/lexicon-regen";
+import { bumpForSeverity, bumpPackageJsonVersion } from "../../codegen/version-bump";
+
+// ── Types ─────────────────────────────────────────────────────────────
+
+export interface SurfaceDiffOptions {
+  /** Resolved path to the lexicon directory. */
+  lexiconDir: string;
+  /** Force re-fetch of upstream spec (bypass cache). */
+  force?: boolean;
+  /** Print subprocess output while running. */
+  verbose?: boolean;
+  /** Skip the bundle step. */
+  skipBundle?: boolean;
+  /** Skip the build (tsc) step. */
+  skipBuild?: boolean;
+  /** Skip chant lint on examples. */
+  skipLint?: boolean;
+  /** Run the example build harness (opt-in; needs cloud creds). */
+  runExamples?: boolean;
+  /** Path to a SHA-256 digest file pinning the spec. */
+  pinnedDigestPath?: string;
+  /** After a successful regen, write the fresh snapshot as the new baseline. */
+  updateSnapshot?: boolean;
+  /**
+   * When re-baselining (`updateSnapshot`), also bump the lexicon's package.json
+   * version by the drift severity so the accepted surface is publishable (#616).
+   */
+  bump?: boolean;
+}
+
+// ── Main entry ────────────────────────────────────────────────────────
+
+/**
+ * Run the surface-diff pipeline and return the result.
+ * Logs human-readable output to stderr; machine-readable JSON goes to the caller.
+ */
+export async function runSurfaceDiff(opts: SurfaceDiffOptions): Promise<RegenResult> {
+  const dir = resolve(opts.lexiconDir);
+
+  if (!existsSync(dir)) {
+    const failure = {
+      step: "setup",
+      output: `Lexicon directory not found: ${dir}`,
+    };
+    return {
+      ok: false,
+      changed: false,
+      severity: "none",
+      delta: { added: [], changed: [], removed: [], severity: "none" },
+      deltaText: "",
+      failures: [failure],
+      freshSnapshot: null,
+    };
+  }
+
+  const result = await regenLexicon({
+    lexiconDir: dir,
+    force: opts.force,
+    verbose: opts.verbose,
+    skipBundle: opts.skipBundle,
+    skipBuild: opts.skipBuild,
+    skipLint: opts.skipLint,
+    skipExamples: !opts.runExamples,
+    pinnedDigestPath: opts.pinnedDigestPath,
+  });
+
+  // Update snapshot when requested and the run succeeded
+  if (opts.updateSnapshot && result.ok && result.freshSnapshot) {
+    writeSurfaceSnapshot(dir, result.freshSnapshot);
+    process.stderr.write(`Snapshot updated: ${dir}/${SNAPSHOT_FILENAME}\n`);
+
+    // #616: accepting drift on a rolling lexicon changes the surface but nothing
+    // bumps the version — so skip-if-unchanged would strand the new surface at
+    // publish time. `--bump` raises the version by the drift severity (0.x-aware)
+    // so the accepted drift actually ships.
+    if (opts.bump && result.changed && result.severity !== "none") {
+      const pkgPath = join(dir, "package.json");
+      if (existsSync(pkgPath)) {
+        const current = (JSON.parse(readFileSync(pkgPath, "utf-8")) as { version?: string }).version ?? "0.0.0";
+        const bumped = bumpForSeverity(current, result.severity);
+        if (bumped) {
+          bumpPackageJsonVersion(pkgPath, bumped);
+          process.stderr.write(`Version bumped: ${current} -> ${bumped} (${result.severity})\n`);
+        } else {
+          process.stderr.write(`Version unchanged: could not bump ${current} for severity ${result.severity}\n`);
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+// ── Human-readable output ─────────────────────────────────────────────
+
+const COLORS = {
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  gray: "\x1b[90m",
+  bold: "\x1b[1m",
+  reset: "\x1b[0m",
+};
+
+function useColors(): boolean {
+  return !process.env.NO_COLOR && process.stdout.isTTY !== false;
+}
+
+function c(text: string, code: string): string {
+  return useColors() ? `${code}${text}${COLORS.reset}` : text;
+}
+
+/**
+ * Print the surface-diff result as human-readable text to stdout.
+ */
+export function printSurfaceDiffResult(result: RegenResult, json: boolean): void {
+  if (json) {
+    console.log(JSON.stringify(
+      {
+        ok: result.ok,
+        changed: result.changed,
+        severity: result.severity,
+        delta: result.delta,
+        failures: result.failures,
+      },
+      null,
+      2,
+    ));
+    return;
+  }
+
+  // Surface delta
+  if (result.deltaText) {
+    console.log(result.deltaText);
+  } else if (result.changed) {
+    console.log("Surface changed (no baseline to diff against).");
+  } else {
+    console.log(c("No surface changes.", COLORS.green));
+  }
+
+  // Failures
+  if (result.failures.length > 0) {
+    console.log("");
+    console.log(c(`${result.failures.length} step(s) failed:`, COLORS.bold));
+    for (const f of result.failures) {
+      console.log(c(`  FAIL [${f.step}]${f.exitCode !== undefined ? ` (exit ${f.exitCode})` : ""}`, COLORS.red));
+      if (f.output) {
+        const indented = f.output
+          .split("\n")
+          .map((l) => `       ${l}`)
+          .join("\n");
+        console.log(c(indented, COLORS.gray));
+      }
+    }
+  }
+
+  console.log("");
+
+  // Summary line
+  const severityColor =
+    result.severity === "breaking" ? COLORS.red :
+    result.severity === "additive" ? COLORS.yellow :
+    COLORS.green;
+
+  const statusLabel = result.ok ? c("ok", COLORS.green) : c("FAILED", COLORS.red);
+  const severityLabel = c(result.severity, severityColor);
+
+  console.log(`Status: ${statusLabel}  Severity: ${severityLabel}  Changed: ${result.changed}`);
+}