@eslint-config-snapshot/cli 0.1.0

package/dist/index.cjs

@@ -0,0 +1,720 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  main: () => main,
+  parseInitPresetChoice: () => parseInitPresetChoice,
+  parseInitTargetChoice: () => parseInitTargetChoice,
+  runCli: () => runCli
+});
+module.exports = __toCommonJS(index_exports);
+var import_api = require("@eslint-config-snapshot/api");
+var import_commander = require("commander");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_readline = require("readline");
+var SNAPSHOT_DIR = ".eslint-config-snapshot";
+var UPDATE_HINT = "Tip: when you intentionally accept changes, run `eslint-config-snapshot --update` to refresh the baseline.\n";
+async function runCli(command, cwd, flags = []) {
+  const argv = command ? [command, ...flags] : [...flags];
+  return runArgv(argv, cwd);
+}
+async function runArgv(argv, cwd) {
+  const hasCommandToken = argv.some((token) => !token.startsWith("-"));
+  if (!hasCommandToken) {
+    return runDefaultInvocation(argv, cwd);
+  }
+  let actionCode;
+  const program = createProgram(cwd, (code) => {
+    actionCode = code;
+  });
+  try {
+    await program.parseAsync(argv, { from: "user" });
+  } catch (error) {
+    if (error instanceof import_commander.CommanderError) {
+      if (error.code === "commander.helpDisplayed") {
+        return 0;
+      }
+      return error.exitCode;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}
+`);
+    return 1;
+  }
+  return actionCode ?? 0;
+}
+async function runDefaultInvocation(argv, cwd) {
+  const known = /* @__PURE__ */ new Set(["-u", "--update", "-h", "--help"]);
+  for (const token of argv) {
+    if (!known.has(token)) {
+      process.stderr.write(`error: unknown option '${token}'
+`);
+      return 1;
+    }
+  }
+  if (argv.includes("-h") || argv.includes("--help")) {
+    const program = createProgram(cwd, () => {
+    });
+    program.outputHelp();
+    return 0;
+  }
+  if (argv.includes("-u") || argv.includes("--update")) {
+    return executeUpdate(cwd, true);
+  }
+  return executeCheck(cwd, "summary", true);
+}
+function createProgram(cwd, onActionExit) {
+  const program = new import_commander.Command();
+  program.name("eslint-config-snapshot").description("Deterministic ESLint config snapshot drift checker for workspaces").showHelpAfterError("(add --help for usage)").option("-u, --update", "Update snapshots (default mode only)");
+  program.hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.update) {
+      throw new Error("--update can only be used without a command");
+    }
+  });
+  program.command("check").description("Compare current state against stored snapshots").option("--format <format>", "Output format: summary|status|diff", parseCheckFormat, "summary").action(async (opts) => {
+    onActionExit(await executeCheck(cwd, opts.format));
+  });
+  program.command("update").alias("snapshot").description("Compute and write snapshots to .eslint-config-snapshot/").action(async () => {
+    onActionExit(await executeUpdate(cwd, true));
+  });
+  program.command("print").description("Print aggregated rules").option("--format <format>", "Output format: json|short", parsePrintFormat, "json").option("--short", "Alias for --format short").action(async (opts) => {
+    const format = opts.short ? "short" : opts.format;
+    await executePrint(cwd, format);
+    onActionExit(0);
+  });
+  program.command("init").description("Initialize config (file or package.json)").option("--target <target>", "Config target: file|package-json", parseInitTarget).option("--preset <preset>", "Config preset: minimal|full", parseInitPreset).option("-f, --force", "Allow init even when an existing config is detected").option("-y, --yes", "Skip prompts and use defaults/options").addHelpText(
+    "after",
+    `
+Examples:
+  $ eslint-config-snapshot init
+    Runs interactive numbered prompts:
+      target: 1) package-json, 2) file
+      preset: 1) minimal, 2) full
+
+  $ eslint-config-snapshot init --yes --target package-json --preset minimal
+    Non-interactive minimal setup in package.json.
+
+  $ eslint-config-snapshot init --yes --force --target file --preset full
+    Overwrite-safe bypass when a config is already detected.
+`
+  ).action(async (opts) => {
+    onActionExit(await runInit(cwd, opts));
+  });
+  program.command("compare", { hidden: true }).action(async () => {
+    onActionExit(await executeCheck(cwd, "diff"));
+  });
+  program.command("status", { hidden: true }).action(async () => {
+    onActionExit(await executeCheck(cwd, "status"));
+  });
+  program.command("what-changed", { hidden: true }).action(async () => {
+    onActionExit(await executeCheck(cwd, "summary"));
+  });
+  program.exitOverride();
+  return program;
+}
+function parseCheckFormat(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "summary" || normalized === "status" || normalized === "diff") {
+    return normalized;
+  }
+  throw new import_commander.InvalidArgumentError("Expected one of: summary, status, diff");
+}
+function parsePrintFormat(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "json" || normalized === "short") {
+    return normalized;
+  }
+  throw new import_commander.InvalidArgumentError("Expected one of: json, short");
+}
+function parseInitTarget(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "file" || normalized === "package-json") {
+    return normalized;
+  }
+  throw new import_commander.InvalidArgumentError("Expected one of: file, package-json");
+}
+function parseInitPreset(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "minimal" || normalized === "full") {
+    return normalized;
+  }
+  throw new import_commander.InvalidArgumentError("Expected one of: minimal, full");
+}
+async function executeCheck(cwd, format, defaultInvocation = false) {
+  const foundConfig = await (0, import_api.findConfigPath)(cwd);
+  if (!foundConfig) {
+    writeSubtleInfo(
+      "Tip: no explicit config found. Using safe built-in defaults. Run `eslint-config-snapshot init` to customize when needed.\n"
+    );
+  }
+  let currentSnapshots;
+  try {
+    currentSnapshots = await computeCurrentSnapshots(cwd);
+  } catch (error) {
+    if (!foundConfig) {
+      process.stdout.write(
+        "Automatic workspace discovery could not complete with defaults.\nRun `eslint-config-snapshot init` to configure workspaces, then run `eslint-config-snapshot --update`.\n"
+      );
+      return 1;
+    }
+    throw error;
+  }
+  const storedSnapshots = await loadStoredSnapshots(cwd);
+  if (storedSnapshots.size === 0) {
+    const summary = summarizeSnapshots(currentSnapshots);
+    process.stdout.write(
+      `Current rule state: ${summary.groups} groups, ${summary.rules} rules (severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off).
+`
+    );
+    const canPromptBaseline = defaultInvocation || format === "summary";
+    if (canPromptBaseline && process.stdin.isTTY && process.stdout.isTTY) {
+      const shouldCreateBaseline = await askYesNo(
+        "No baseline yet. Use current rule state as your baseline now? [Y/n] ",
+        true
+      );
+      if (shouldCreateBaseline) {
+        await writeSnapshots(cwd, currentSnapshots);
+        const summary2 = summarizeSnapshots(currentSnapshots);
+        process.stdout.write(`Great start: baseline created with ${summary2.groups} groups and ${summary2.rules} rules.
+`);
+        writeSubtleInfo(UPDATE_HINT);
+        return 0;
+      }
+    }
+    process.stdout.write("You are almost set: no baseline snapshot found yet.\n");
+    process.stdout.write("Run `eslint-config-snapshot --update` to create your first baseline.\n");
+    return 1;
+  }
+  const changes = compareSnapshotMaps(storedSnapshots, currentSnapshots);
+  if (format === "status") {
+    if (changes.length === 0) {
+      process.stdout.write("clean\n");
+      return 0;
+    }
+    process.stdout.write("changes\n");
+    writeSubtleInfo(UPDATE_HINT);
+    return 1;
+  }
+  if (format === "diff") {
+    if (changes.length === 0) {
+      process.stdout.write("Great news: no snapshot changes detected.\n");
+      return 0;
+    }
+    for (const change of changes) {
+      process.stdout.write(`${formatDiff(change.groupId, change.diff)}
+`);
+    }
+    writeSubtleInfo(UPDATE_HINT);
+    return 1;
+  }
+  return printWhatChanged(changes, currentSnapshots);
+}
+async function executeUpdate(cwd, printSummary) {
+  const foundConfig = await (0, import_api.findConfigPath)(cwd);
+  if (!foundConfig) {
+    writeSubtleInfo(
+      "Tip: no explicit config found. Using safe built-in defaults. Run `eslint-config-snapshot init` to customize when needed.\n"
+    );
+  }
+  let currentSnapshots;
+  try {
+    currentSnapshots = await computeCurrentSnapshots(cwd);
+  } catch (error) {
+    if (!foundConfig) {
+      process.stdout.write(
+        "Automatic workspace discovery could not complete with defaults.\nRun `eslint-config-snapshot init` to configure workspaces, then run `eslint-config-snapshot --update`.\n"
+      );
+      return 1;
+    }
+    throw error;
+  }
+  await writeSnapshots(cwd, currentSnapshots);
+  if (printSummary) {
+    const summary = summarizeSnapshots(currentSnapshots);
+    process.stdout.write(`Baseline updated: ${summary.groups} groups, ${summary.rules} rules.
+`);
+  }
+  return 0;
+}
+async function executePrint(cwd, format) {
+  const currentSnapshots = await computeCurrentSnapshots(cwd);
+  if (format === "short") {
+    process.stdout.write(formatShortPrint([...currentSnapshots.values()]));
+    return;
+  }
+  const output = [...currentSnapshots.values()].map((snapshot) => ({
+    groupId: snapshot.groupId,
+    rules: snapshot.rules
+  }));
+  process.stdout.write(`${JSON.stringify(output, null, 2)}
+`);
+}
+async function computeCurrentSnapshots(cwd) {
+  const config = await (0, import_api.loadConfig)(cwd);
+  const discovery = await (0, import_api.discoverWorkspaces)({ cwd, workspaceInput: config.workspaceInput });
+  const assignments = config.grouping.mode === "standalone" ? discovery.workspacesRel.map((workspace) => ({ name: workspace, workspaces: [workspace] })) : (0, import_api.assignGroupsByMatch)(discovery.workspacesRel, config.grouping.groups ?? [{ name: "default", match: ["**/*"] }]);
+  const allowEmptyGroups = config.grouping.allowEmptyGroups ?? false;
+  if (!allowEmptyGroups) {
+    const empty = assignments.filter((group) => group.workspaces.length === 0);
+    if (empty.length > 0) {
+      throw new Error(`Empty groups are not allowed: ${empty.map((entry) => entry.name).join(", ")}`);
+    }
+  }
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const group of assignments) {
+    const extractedForGroup = [];
+    for (const workspaceRel of group.workspaces) {
+      const workspaceAbs = import_node_path.default.resolve(discovery.rootAbs, workspaceRel);
+      const sampled = await (0, import_api.sampleWorkspaceFiles)(workspaceAbs, config.sampling);
+      let extractedCount = 0;
+      let lastExtractionError;
+      for (const sampledRel of sampled) {
+        const sampledAbs = import_node_path.default.resolve(workspaceAbs, sampledRel);
+        try {
+          extractedForGroup.push((0, import_api.extractRulesFromPrintConfig)(workspaceAbs, sampledAbs));
+          extractedCount += 1;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          if (message.startsWith("Invalid JSON from eslint --print-config") || message.startsWith("Empty ESLint print-config output")) {
+            lastExtractionError = message;
+            continue;
+          }
+          throw error;
+        }
+      }
+      if (extractedCount === 0) {
+        const context = lastExtractionError ? ` Last error: ${lastExtractionError}` : "";
+        throw new Error(
+          `Unable to extract ESLint config for workspace ${workspaceRel}. All sampled files were ignored or produced non-JSON output.${context}`
+        );
+      }
+    }
+    const aggregated = (0, import_api.aggregateRules)(extractedForGroup);
+    snapshots.set(group.name, (0, import_api.buildSnapshot)(group.name, group.workspaces, aggregated));
+  }
+  return snapshots;
+}
+async function loadStoredSnapshots(cwd) {
+  const dir = import_node_path.default.join(cwd, SNAPSHOT_DIR);
+  const files = await (0, import_fast_glob.default)("**/*.json", { cwd: dir, absolute: true, onlyFiles: true, dot: true, suppressErrors: true });
+  const snapshots = /* @__PURE__ */ new Map();
+  const sortedFiles = [...files].sort((a, b) => a.localeCompare(b));
+  for (const file of sortedFiles) {
+    const snapshot = await (0, import_api.readSnapshotFile)(file);
+    snapshots.set(snapshot.groupId, snapshot);
+  }
+  return snapshots;
+}
+async function writeSnapshots(cwd, snapshots) {
+  await (0, import_promises.mkdir)(import_node_path.default.join(cwd, SNAPSHOT_DIR), { recursive: true });
+  for (const snapshot of snapshots.values()) {
+    await (0, import_api.writeSnapshotFile)(import_node_path.default.join(cwd, SNAPSHOT_DIR), snapshot);
+  }
+}
+function compareSnapshotMaps(before, after) {
+  const ids = [.../* @__PURE__ */ new Set([...before.keys(), ...after.keys()])].sort();
+  const changes = [];
+  for (const id of ids) {
+    const prev = before.get(id) ?? {
+      formatVersion: 1,
+      groupId: id,
+      workspaces: [],
+      rules: {}
+    };
+    const next = after.get(id) ?? {
+      formatVersion: 1,
+      groupId: id,
+      workspaces: [],
+      rules: {}
+    };
+    const diff = (0, import_api.diffSnapshots)(prev, next);
+    if ((0, import_api.hasDiff)(diff)) {
+      changes.push({ groupId: id, diff });
+    }
+  }
+  return changes;
+}
+function formatDiff(groupId, diff) {
+  const lines = [`group: ${groupId}`];
+  addListSection(lines, "introduced rules", diff.introducedRules);
+  addListSection(lines, "removed rules", diff.removedRules);
+  if (diff.severityChanges.length > 0) {
+    lines.push("severity changed:");
+    for (const change of diff.severityChanges) {
+      lines.push(`  - ${change.rule}: ${change.before} -> ${change.after}`);
+    }
+  }
+  const optionChanges = getDisplayOptionChanges(diff);
+  if (optionChanges.length > 0) {
+    lines.push("options changed:");
+    for (const change of optionChanges) {
+      lines.push(`  - ${change.rule}: ${formatValue(change.before)} -> ${formatValue(change.after)}`);
+    }
+  }
+  addListSection(lines, "workspaces added", diff.workspaceMembershipChanges.added);
+  addListSection(lines, "workspaces removed", diff.workspaceMembershipChanges.removed);
+  return lines.join("\n");
+}
+function addListSection(lines, title, values) {
+  if (values.length === 0) {
+    return;
+  }
+  lines.push(`${title}:`);
+  for (const value of values) {
+    lines.push(`  - ${value}`);
+  }
+}
+function formatValue(value) {
+  const serialized = JSON.stringify(value);
+  return serialized === void 0 ? "undefined" : serialized;
+}
+function getDisplayOptionChanges(diff) {
+  const removedRules = new Set(diff.removedRules);
+  const severityChangedRules = new Set(diff.severityChanges.map((change) => change.rule));
+  return diff.optionChanges.filter((change) => !removedRules.has(change.rule) && !severityChangedRules.has(change.rule));
+}
+async function runInit(cwd, opts = {}) {
+  const force = opts.force ?? false;
+  const existing = await (0, import_api.findConfigPath)(cwd);
+  if (existing && !force) {
+    process.stderr.write(
+      `Existing config detected at ${existing.path}. Creating another config can cause conflicts. Remove the existing config or rerun with --force.
+`
+    );
+    return 1;
+  }
+  let target = opts.target;
+  let preset = opts.preset;
+  if (!opts.yes && !target && !preset && process.stdin.isTTY && process.stdout.isTTY) {
+    const interactive = await askInitPreferences();
+    target = interactive.target;
+    preset = interactive.preset;
+  }
+  const finalTarget = target ?? "file";
+  const finalPreset = preset ?? "minimal";
+  if (finalTarget === "package-json") {
+    return runInitInPackageJson(cwd, finalPreset, force);
+  }
+  return runInitInFile(cwd, finalPreset, force);
+}
+async function askInitPreferences() {
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  try {
+    const target = await askInitTarget(rl);
+    const preset = await askInitPreset(rl);
+    return { target, preset };
+  } finally {
+    rl.close();
+  }
+}
+async function askInitTarget(rl) {
+  while (true) {
+    const answer = await askQuestion(
+      rl,
+      "Select config target:\n  1) package-json (recommended)\n  2) file\nChoose [1]: "
+    );
+    const parsed = parseInitTargetChoice(answer);
+    if (parsed) {
+      return parsed;
+    }
+    process.stdout.write("Please choose 1 (package-json) or 2 (file).\n");
+  }
+}
+async function askInitPreset(rl) {
+  while (true) {
+    const answer = await askQuestion(rl, "Select preset:\n  1) minimal (recommended)\n  2) full\nChoose [1]: ");
+    const parsed = parseInitPresetChoice(answer);
+    if (parsed) {
+      return parsed;
+    }
+    process.stdout.write("Please choose 1 (minimal) or 2 (full).\n");
+  }
+}
+function parseInitTargetChoice(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "") {
+    return "package-json";
+  }
+  if (normalized === "1" || normalized === "package-json" || normalized === "packagejson" || normalized === "package" || normalized === "pkg") {
+    return "package-json";
+  }
+  if (normalized === "2" || normalized === "file") {
+    return "file";
+  }
+  return void 0;
+}
+function parseInitPresetChoice(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "") {
+    return "minimal";
+  }
+  if (normalized === "1" || normalized === "minimal" || normalized === "min") {
+    return "minimal";
+  }
+  if (normalized === "2" || normalized === "full") {
+    return "full";
+  }
+  return void 0;
+}
+function askQuestion(rl, prompt) {
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      resolve(answer);
+    });
+  });
+}
+async function askYesNo(prompt, defaultYes) {
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  try {
+    const answerRaw = await askQuestion(rl, prompt);
+    const answer = answerRaw.trim().toLowerCase();
+    if (answer.length === 0) {
+      return defaultYes;
+    }
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function runInitInFile(cwd, preset, force) {
+  const candidates = [
+    ".eslint-config-snapshot.js",
+    ".eslint-config-snapshot.cjs",
+    ".eslint-config-snapshot.mjs",
+    "eslint-config-snapshot.config.js",
+    "eslint-config-snapshot.config.cjs",
+    "eslint-config-snapshot.config.mjs"
+  ];
+  for (const candidate of candidates) {
+    try {
+      await (0, import_promises.access)(import_node_path.default.join(cwd, candidate));
+      if (!force) {
+        process.stderr.write(`Config already exists: ${candidate}
+`);
+        return 1;
+      }
+    } catch {
+    }
+  }
+  const target = import_node_path.default.join(cwd, "eslint-config-snapshot.config.mjs");
+  await (0, import_promises.writeFile)(target, (0, import_api.getConfigScaffold)(preset), "utf8");
+  process.stdout.write(`Created ${import_node_path.default.basename(target)}
+`);
+  return 0;
+}
+async function runInitInPackageJson(cwd, preset, force) {
+  const packageJsonPath = import_node_path.default.join(cwd, "package.json");
+  let packageJsonRaw;
+  try {
+    packageJsonRaw = await (0, import_promises.readFile)(packageJsonPath, "utf8");
+  } catch {
+    process.stderr.write("package.json not found in current directory.\n");
+    return 1;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(packageJsonRaw);
+  } catch {
+    process.stderr.write("Invalid package.json (must be valid JSON).\n");
+    return 1;
+  }
+  if (parsed["eslint-config-snapshot"] !== void 0 && !force) {
+    process.stderr.write("Config already exists in package.json: eslint-config-snapshot\n");
+    return 1;
+  }
+  parsed["eslint-config-snapshot"] = preset === "full" ? getFullPresetObject() : {};
+  await (0, import_promises.writeFile)(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+  process.stdout.write('Created config in package.json under "eslint-config-snapshot"\n');
+  return 0;
+}
+function getFullPresetObject() {
+  return {
+    workspaceInput: { mode: "discover" },
+    grouping: {
+      mode: "match",
+      groups: [{ name: "default", match: ["**/*"] }]
+    },
+    sampling: {
+      maxFilesPerWorkspace: 8,
+      includeGlobs: ["**/*.{js,jsx,ts,tsx,cjs,mjs}"],
+      excludeGlobs: ["**/node_modules/**", "**/dist/**"],
+      hintGlobs: []
+    }
+  };
+}
+async function main() {
+  const code = await runArgv(process.argv.slice(2), process.cwd());
+  process.exit(code);
+}
+function isDirectCliExecution() {
+  const entry = process.argv[1];
+  if (!entry) {
+    return false;
+  }
+  const normalized = import_node_path.default.basename(entry).toLowerCase();
+  return normalized === "index.js" || normalized === "index.cjs" || normalized === "index.ts" || normalized === "eslint-config-snapshot";
+}
+if (isDirectCliExecution()) {
+  void main();
+}
+function printWhatChanged(changes, currentSnapshots) {
+  const color = createColorizer();
+  const currentSummary = summarizeSnapshots(currentSnapshots);
+  const changeSummary = summarizeChanges(changes);
+  if (changes.length === 0) {
+    process.stdout.write(color.green("Great news: no snapshot drift detected.\n"));
+    process.stdout.write(
+      `Baseline status: ${currentSummary.groups} groups, ${currentSummary.rules} rules (severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off).
+`
+    );
+    return 0;
+  }
+  process.stdout.write(color.red("Heads up: snapshot drift detected.\n"));
+  process.stdout.write(
+    `Changed groups: ${changes.length} | introduced: ${changeSummary.introduced} | removed: ${changeSummary.removed} | severity: ${changeSummary.severity} | options: ${changeSummary.options} | workspace membership: ${changeSummary.workspace}
+`
+  );
+  process.stdout.write(
+    `Current rules: ${currentSummary.rules} (severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off)
+
+`
+  );
+  for (const change of changes) {
+    process.stdout.write(color.bold(`group ${change.groupId}
+`));
+    const lines = formatDiff(change.groupId, change.diff).split("\n").slice(1);
+    for (const line of lines) {
+      const decorated = decorateDiffLine(line, color);
+      process.stdout.write(`${decorated}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  writeSubtleInfo(UPDATE_HINT);
+  return 1;
+}
+function summarizeChanges(changes) {
+  let introduced = 0;
+  let removed = 0;
+  let severity = 0;
+  let options = 0;
+  let workspace = 0;
+  for (const change of changes) {
+    introduced += change.diff.introducedRules.length;
+    removed += change.diff.removedRules.length;
+    severity += change.diff.severityChanges.length;
+    options += getDisplayOptionChanges(change.diff).length;
+    workspace += change.diff.workspaceMembershipChanges.added.length + change.diff.workspaceMembershipChanges.removed.length;
+  }
+  return { introduced, removed, severity, options, workspace };
+}
+function summarizeSnapshots(snapshots) {
+  let rules = 0;
+  let error = 0;
+  let warn = 0;
+  let off = 0;
+  for (const snapshot of snapshots.values()) {
+    for (const entry of Object.values(snapshot.rules)) {
+      rules += 1;
+      if (entry[0] === "error") {
+        error += 1;
+      } else if (entry[0] === "warn") {
+        warn += 1;
+      } else {
+        off += 1;
+      }
+    }
+  }
+  return { groups: snapshots.size, rules, error, warn, off };
+}
+function decorateDiffLine(line, color) {
+  if (line.startsWith("introduced rules:") || line.startsWith("workspaces added:")) {
+    return color.green(`+ ${line}`);
+  }
+  if (line.startsWith("removed rules:") || line.startsWith("workspaces removed:")) {
+    return color.red(`- ${line}`);
+  }
+  if (line.startsWith("severity changed:") || line.startsWith("options changed:")) {
+    return color.yellow(`~ ${line}`);
+  }
+  return line;
+}
+function createColorizer() {
+  const enabled = process.stdout.isTTY && process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb";
+  const wrap = (code, text) => enabled ? `\x1B[${code}m${text}\x1B[0m` : text;
+  return {
+    green: (text) => wrap("32", text),
+    yellow: (text) => wrap("33", text),
+    red: (text) => wrap("31", text),
+    bold: (text) => wrap("1", text),
+    dim: (text) => wrap("2", text)
+  };
+}
+function writeSubtleInfo(text) {
+  const color = createColorizer();
+  process.stdout.write(color.dim(text));
+}
+function formatShortPrint(snapshots) {
+  const lines = [];
+  const sorted = [...snapshots].sort((a, b) => a.groupId.localeCompare(b.groupId));
+  for (const snapshot of sorted) {
+    const ruleNames = Object.keys(snapshot.rules).sort();
+    const severityCounts = { error: 0, warn: 0, off: 0 };
+    for (const name of ruleNames) {
+      const severity = snapshot.rules[name][0];
+      severityCounts[severity] += 1;
+    }
+    lines.push(
+      `group: ${snapshot.groupId}`,
+      `workspaces (${snapshot.workspaces.length}): ${snapshot.workspaces.length > 0 ? snapshot.workspaces.join(", ") : "(none)"}`,
+      `rules (${ruleNames.length}): error ${severityCounts.error}, warn ${severityCounts.warn}, off ${severityCounts.off}`
+    );
+    for (const ruleName of ruleNames) {
+      const entry = snapshot.rules[ruleName];
+      const suffix = entry.length > 1 ? ` ${JSON.stringify(entry[1])}` : "";
+      lines.push(`${ruleName}: ${entry[0]}${suffix}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main,
+  parseInitPresetChoice,
+  parseInitTargetChoice,
+  runCli
+});