@eslint-config-snapshot/cli 0.9.0 → 0.14.0

package/dist/index.js

@@ -1,187 +1,540 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import {
-  aggregateRules,
-  assignGroupsByMatch,
-  buildSnapshot,
-  diffSnapshots,
-  discoverWorkspaces,
-  extractRulesForWorkspaceSamples,
-  findConfigPath,
-  getConfigScaffold,
-  hasDiff,
-  loadConfig,
-  normalizePath,
-  readSnapshotFile,
-  resolveEslintVersionForWorkspace,
-  sampleWorkspaceFiles,
-  writeSnapshotFile
-} from "@eslint-config-snapshot/api";
 import { Command, CommanderError, InvalidArgumentError } from "commander";
-import fg from "fast-glob";
+import createDebug2 from "debug";
+import path4 from "path";
+
+// src/commands/check.ts
+import { findConfigPath } from "@eslint-config-snapshot/api";
+
+// src/formatters.ts
+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 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));
+}
+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 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) {
+  const { rules, error, warn, off } = countRuleSeverities([...snapshots.values()].map((snapshot) => snapshot.rules));
+  return { groups: snapshots.size, rules, error, warn, off };
+}
+function countUniqueWorkspaces(snapshots) {
+  const workspaces = /* @__PURE__ */ new Set();
+  for (const snapshot of snapshots.values()) {
+    for (const workspace of snapshot.workspaces) {
+      workspaces.add(workspace);
+    }
+  }
+  return workspaces.size;
+}
+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 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 = getPrimarySeverity(snapshot.rules[name]);
+      if (severity) {
+        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];
+      if (!entry) {
+        continue;
+      }
+      if (!Array.isArray(entry[0])) {
+        const singleEntry = entry;
+        const suffix = singleEntry.length > 1 ? ` ${JSON.stringify(singleEntry[1])}` : "";
+        lines.push(`${ruleName}: ${singleEntry[0]}${suffix}`);
+        continue;
+      }
+      const variants = entry;
+      lines.push(`${ruleName}: ${JSON.stringify(variants)}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function formatShortConfig(payload) {
+  const lines = [
+    `source: ${payload.source}`,
+    `workspaces (${payload.workspaces.length}): ${payload.workspaces.join(", ") || "(none)"}`,
+    `grouping mode: ${payload.grouping.mode} (allow empty: ${payload.grouping.allowEmptyGroups})`
+  ];
+  for (const group of payload.grouping.groups) {
+    lines.push(`group ${group.name} (${group.workspaces.length}): ${group.workspaces.join(", ") || "(none)"}`);
+  }
+  lines.push(`workspaceInput: ${JSON.stringify(payload.workspaceInput)}`, `sampling: ${JSON.stringify(payload.sampling)}`);
+  return `${lines.join("\n")}
+`;
+}
+function formatCommandDisplayLabel(commandLabel) {
+  switch (commandLabel) {
+    case "check":
+    case "check:summary": {
+      return "Check drift against baseline (summary)";
+    }
+    case "check:diff": {
+      return "Check drift against baseline (detailed diff)";
+    }
+    case "check:status": {
+      return "Check drift against baseline (status only)";
+    }
+    case "update": {
+      return "Update baseline snapshot";
+    }
+    case "print:json": {
+      return "Print aggregated rules (JSON)";
+    }
+    case "print:short": {
+      return "Print aggregated rules (short view)";
+    }
+    case "config:json": {
+      return "Show effective runtime config (JSON)";
+    }
+    case "config:short": {
+      return "Show effective runtime config (short view)";
+    }
+    case "init": {
+      return "Initialize local configuration";
+    }
+    case "help": {
+      return "Show CLI help";
+    }
+    default: {
+      return commandLabel;
+    }
+  }
+}
+function formatStoredSnapshotSummary(storedSnapshots) {
+  if (storedSnapshots.size === 0) {
+    return "none";
+  }
+  const summary = summarizeSnapshots(storedSnapshots);
+  return `${summary.groups} groups, ${summary.rules} rules (severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off)`;
+}
+function countRuleSeverities(ruleObjects) {
+  let rules = 0;
+  let error = 0;
+  let warn = 0;
+  let off = 0;
+  for (const rulesObject of ruleObjects) {
+    for (const entry of Object.values(rulesObject)) {
+      rules += 1;
+      const severity = getPrimarySeverity(entry);
+      if (severity === "error") {
+        error += 1;
+      } else if (severity === "warn") {
+        warn += 1;
+      } else {
+        off += 1;
+      }
+    }
+  }
+  return { rules, error, warn, off };
+}
+function getPrimarySeverity(entry) {
+  if (!entry) {
+    return void 0;
+  }
+  if (!Array.isArray(entry[0])) {
+    return entry[0];
+  }
+  const variants = entry;
+  if (variants.some((variant) => variant[0] === "error")) {
+    return "error";
+  }
+  if (variants.some((variant) => variant[0] === "warn")) {
+    return "warn";
+  }
+  return "off";
+}
+
+// src/run-context.ts
+import { normalizePath } from "@eslint-config-snapshot/api";
 import { existsSync, readFileSync } from "fs";
-import { access, mkdir, readFile, writeFile } from "fs/promises";
 import { createRequire } from "module";
 import path from "path";
-import { createInterface } from "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";
-var activeRunTimer;
 var cachedCliVersion;
-async function runCli(command, cwd, flags = []) {
-  const argv = command ? [command, ...flags] : [...flags];
-  return runArgv(argv, cwd);
+function writeRunContextHeader(terminal, cwd, commandLabel, configPath, storedSnapshots) {
+  if (!terminal.showProgress) {
+    return;
+  }
+  terminal.write(terminal.bold(`eslint-config-snapshot v${readCliVersion()} \u2022 ${formatCommandDisplayLabel(commandLabel)}
+`));
+  terminal.write(`\u{1F4C1} Repository: ${cwd}
+`);
+  terminal.write(`\u{1F4C1} Baseline: ${formatStoredSnapshotSummary(storedSnapshots)}
+`);
+  terminal.write(`\u2699\uFE0F Config source: ${formatConfigSource(cwd, configPath)}
+`);
+  terminal.write("\n");
 }
-async function runArgv(argv, cwd) {
-  const invocationLabel = resolveInvocationLabel(argv);
-  beginRunTimer(invocationLabel);
-  let exitCode = 1;
+function writeEslintVersionSummary(terminal, eslintVersionsByGroup) {
+  if (!terminal.showProgress || eslintVersionsByGroup.size === 0) {
+    return;
+  }
+  const allVersions = /* @__PURE__ */ new Set();
+  for (const versions of eslintVersionsByGroup.values()) {
+    for (const version of versions) {
+      allVersions.add(version);
+    }
+  }
+  const sortedAllVersions = [...allVersions].sort((a, b) => a.localeCompare(b));
+  if (sortedAllVersions.length === 1) {
+    terminal.write(`- \u{1F9E9} eslint runtime: ${sortedAllVersions[0]} (all groups)
+`);
+    return;
+  }
+  terminal.write("- \u{1F9E9} eslint runtime by group:\n");
+  const sortedEntries = [...eslintVersionsByGroup.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+  for (const [groupName, versions] of sortedEntries) {
+    terminal.write(`  - ${groupName}: ${versions.join(", ")}
+`);
+  }
+}
+function formatConfigSource(cwd, configPath) {
+  if (!configPath) {
+    return "built-in defaults";
+  }
+  const rel = normalizePath(path.relative(cwd, configPath));
+  if (path.basename(configPath) === "package.json") {
+    return `${rel} (eslint-config-snapshot field)`;
+  }
+  return rel;
+}
+function readCliVersion() {
+  if (cachedCliVersion !== void 0) {
+    return cachedCliVersion;
+  }
+  const envPackageName = process.env.npm_package_name;
+  const envPackageVersion = process.env.npm_package_version;
+  if (isCliPackageName(envPackageName) && typeof envPackageVersion === "string" && envPackageVersion.length > 0) {
+    cachedCliVersion = envPackageVersion;
+    return cachedCliVersion;
+  }
+  const scriptPath = process.argv[1];
+  if (!scriptPath) {
+    cachedCliVersion = "unknown";
+    return cachedCliVersion;
+  }
   try {
-    const hasCommandToken = argv.some((token) => !token.startsWith("-"));
-    if (!hasCommandToken) {
-      exitCode = await runDefaultInvocation(argv, cwd);
-      return exitCode;
+    const req = createRequire(path.resolve(scriptPath));
+    const resolvedCliEntry = req.resolve("@eslint-config-snapshot/cli");
+    const resolvedVersion = readVersionFromResolvedEntry(resolvedCliEntry);
+    if (resolvedVersion !== void 0) {
+      cachedCliVersion = resolvedVersion;
+      return cachedCliVersion;
     }
-    let actionCode;
-    const program = createProgram(cwd, (code) => {
-      actionCode = code;
-    });
-    try {
-      await program.parseAsync(argv, { from: "user" });
-    } catch (error) {
-      if (error instanceof CommanderError) {
-        if (error.code === "commander.helpDisplayed") {
-          exitCode = 0;
-          return exitCode;
+  } catch {
+  }
+  let current = path.resolve(path.dirname(scriptPath));
+  let fallbackVersion;
+  while (true) {
+    const packageJsonPath = path.join(current, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const raw = readFileSync(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.version === "string" && parsed.version.length > 0) {
+          if (isCliPackageName(parsed.name)) {
+            cachedCliVersion = parsed.version;
+            return cachedCliVersion;
+          }
+          if (fallbackVersion === void 0) {
+            fallbackVersion = parsed.version;
+          }
         }
-        exitCode = error.exitCode;
-        return exitCode;
+      } catch {
       }
-      const message = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`${message}
-`);
-      return 1;
     }
-    exitCode = actionCode ?? 0;
-    return exitCode;
-  } finally {
-    endRunTimer(exitCode);
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
   }
+  cachedCliVersion = fallbackVersion ?? "unknown";
+  return cachedCliVersion;
 }
-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;
+function isCliPackageName(value) {
+  return value === "@eslint-config-snapshot/cli" || value === "eslint-config-snapshot";
+}
+function readVersionFromResolvedEntry(entryAbs) {
+  let current = path.resolve(path.dirname(entryAbs));
+  while (true) {
+    const packageJsonPath = path.join(current, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const raw = readFileSync(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (isCliPackageName(parsed.name) && typeof parsed.version === "string" && parsed.version.length > 0) {
+          return parsed.version;
+        }
+      } catch {
+      }
     }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
   }
-  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);
+  return void 0;
 }
-function createProgram(cwd, onActionExit) {
-  const program = new 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("config").description("Print effective evaluated config").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 executeConfig(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: recommended|minimal|full", parseInitPreset).option("--show-effective", "Print the evaluated config that will be written").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 select prompts for target/preset.
-    Recommended preset keeps a dynamic catch-all default group ("*") and asks only for static exception groups.
 
-  $ eslint-config-snapshot init --yes --target package-json --preset recommended --show-effective
-    Non-interactive recommended setup in package.json, with effective preview.
-
-  $ 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;
+// src/runtime.ts
+import {
+  aggregateRules,
+  assignGroupsByMatch,
+  buildSnapshot,
+  diffSnapshots,
+  discoverWorkspaces,
+  extractRulesForWorkspaceSamples,
+  hasDiff,
+  loadConfig,
+  readSnapshotFile,
+  resolveEslintVersionForWorkspace,
+  sampleWorkspaceFiles,
+  writeSnapshotFile
+} from "@eslint-config-snapshot/api";
+import createDebug from "debug";
+import fg from "fast-glob";
+import { mkdir } from "fs/promises";
+import path2 from "path";
+var debugWorkspace = createDebug("eslint-config-snapshot:workspace");
+var debugDiff = createDebug("eslint-config-snapshot:diff");
+var debugTiming = createDebug("eslint-config-snapshot:timing");
+async function computeCurrentSnapshots(cwd) {
+  const computeStartedAt = Date.now();
+  const configStartedAt = Date.now();
+  const config = await loadConfig(cwd);
+  debugTiming("phase=loadConfig elapsedMs=%d", Date.now() - configStartedAt);
+  const assignmentStartedAt = Date.now();
+  const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config);
+  debugTiming("phase=resolveWorkspaceAssignments elapsedMs=%d", Date.now() - assignmentStartedAt);
+  debugWorkspace("root=%s groups=%d workspaces=%d", discovery.rootAbs, assignments.length, discovery.workspacesRel.length);
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const group of assignments) {
+    const groupStartedAt = Date.now();
+    const extractedForGroup = [];
+    debugWorkspace("group=%s workspaces=%o", group.name, group.workspaces);
+    for (const workspaceRel of group.workspaces) {
+      const workspaceAbs = path2.resolve(discovery.rootAbs, workspaceRel);
+      const sampleStartedAt = Date.now();
+      const sampled = await sampleWorkspaceFiles(workspaceAbs, config.sampling);
+      debugWorkspace(
+        "group=%s workspace=%s sampled=%d sampleElapsedMs=%d files=%o",
+        group.name,
+        workspaceRel,
+        sampled.length,
+        Date.now() - sampleStartedAt,
+        sampled
+      );
+      let extractedCount = 0;
+      let lastExtractionError;
+      const sampledAbs = sampled.map((sampledRel) => path2.resolve(workspaceAbs, sampledRel));
+      const extractStartedAt = Date.now();
+      const results = await extractRulesForWorkspaceSamples(workspaceAbs, sampledAbs);
+      debugTiming(
+        "phase=extract group=%s workspace=%s sampled=%d elapsedMs=%d",
+        group.name,
+        workspaceRel,
+        sampledAbs.length,
+        Date.now() - extractStartedAt
+      );
+      for (const result of results) {
+        if (result.rules) {
+          extractedForGroup.push(result.rules);
+          extractedCount += 1;
+          continue;
+        }
+        const message = result.error instanceof Error ? result.error.message : String(result.error);
+        if (isRecoverableExtractionError(message)) {
+          lastExtractionError = message;
+          continue;
+        }
+        throw result.error ?? new Error(message);
+      }
+      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}`
+        );
+      }
+      debugWorkspace(
+        "group=%s workspace=%s extracted=%d failed=%d",
+        group.name,
+        workspaceRel,
+        extractedCount,
+        results.length - extractedCount
+      );
+    }
+    const aggregated = aggregateRules(extractedForGroup);
+    snapshots.set(group.name, buildSnapshot(group.name, group.workspaces, aggregated));
+    debugWorkspace(
+      "group=%s aggregatedRules=%d groupElapsedMs=%d",
+      group.name,
+      aggregated.size,
+      Date.now() - groupStartedAt
+    );
+  }
+  debugTiming("phase=computeCurrentSnapshots elapsedMs=%d", Date.now() - computeStartedAt);
+  return snapshots;
 }
-function parseCheckFormat(value) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "summary" || normalized === "status" || normalized === "diff") {
-    return normalized;
+function isRecoverableExtractionError(message) {
+  return message.startsWith("Invalid JSON from eslint --print-config") || message.startsWith("Empty ESLint print-config output") || message.includes("File ignored because of a matching ignore pattern") || message.includes("File ignored by default");
+}
+async function resolveWorkspaceAssignments(cwd, config) {
+  const discovery = await discoverWorkspaces({ cwd, workspaceInput: config.workspaceInput });
+  const assignments = config.grouping.mode === "standalone" ? discovery.workspacesRel.map((workspace) => ({ name: workspace, workspaces: [workspace] })) : 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(", ")}`);
+    }
   }
-  throw new InvalidArgumentError("Expected one of: summary, status, diff");
+  return { discovery, assignments };
 }
-function parsePrintFormat(value) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "json" || normalized === "short") {
-    return normalized;
+async function loadStoredSnapshots(cwd, snapshotDir) {
+  const dir = path2.join(cwd, snapshotDir);
+  const files = await fg("**/*.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 readSnapshotFile(file);
+    snapshots.set(snapshot.groupId, snapshot);
   }
-  throw new InvalidArgumentError("Expected one of: json, short");
+  return snapshots;
 }
-function parseInitTarget(value) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "file" || normalized === "package-json") {
-    return normalized;
+async function writeSnapshots(cwd, snapshotDir, snapshots) {
+  await mkdir(path2.join(cwd, snapshotDir), { recursive: true });
+  for (const snapshot of snapshots.values()) {
+    await writeSnapshotFile(path2.join(cwd, snapshotDir), snapshot);
   }
-  throw new InvalidArgumentError("Expected one of: file, package-json");
 }
-function parseInitPreset(value) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "recommended" || normalized === "minimal" || normalized === "full") {
-    return normalized;
+function compareSnapshotMaps(before, after) {
+  const startedAt = Date.now();
+  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 = diffSnapshots(prev, next);
+    if (hasDiff(diff)) {
+      changes.push({ groupId: id, diff });
+    }
   }
-  throw new InvalidArgumentError("Expected one of: recommended, minimal, full");
+  debugDiff("groupsCompared=%d changedGroups=%d elapsedMs=%d", ids.length, changes.length, Date.now() - startedAt);
+  return changes;
+}
+async function resolveGroupEslintVersions(cwd) {
+  const config = await loadConfig(cwd);
+  const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config);
+  const result = /* @__PURE__ */ new Map();
+  for (const group of assignments) {
+    const versions = /* @__PURE__ */ new Set();
+    for (const workspaceRel of group.workspaces) {
+      const workspaceAbs = path2.resolve(discovery.rootAbs, workspaceRel);
+      versions.add(resolveEslintVersionForWorkspace(workspaceAbs));
+    }
+    result.set(group.name, [...versions].sort((a, b) => a.localeCompare(b)));
+  }
+  return result;
 }
-async function executeCheck(cwd, format, defaultInvocation = false) {
+
+// src/commands/check.ts
+var UPDATE_HINT = "Tip: when you intentionally accept changes, run `eslint-config-snapshot --update` to refresh the baseline.\n";
+async function executeCheck(cwd, format, terminal, snapshotDir, defaultInvocation = false) {
   const foundConfig = await findConfigPath(cwd);
-  const storedSnapshots = await loadStoredSnapshots(cwd);
+  const storedSnapshots = await loadStoredSnapshots(cwd, snapshotDir);
   if (format !== "status") {
-    writeRunContextHeader(cwd, defaultInvocation ? "check" : `check:${format}`, foundConfig?.path, storedSnapshots);
-    if (shouldShowRunLogs()) {
-      writeSubtleInfo("\u{1F50E} Checking current ESLint configuration...\n");
+    writeRunContextHeader(terminal, cwd, defaultInvocation ? "check" : `check:${format}`, foundConfig?.path, storedSnapshots);
+    if (terminal.showProgress) {
+      terminal.subtle("\u{1F50E} Checking current ESLint configuration...\n");
     }
   }
   if (!foundConfig) {
-    writeSubtleInfo(
+    terminal.subtle(
       "Tip: no explicit config found. Using safe built-in defaults. Run `eslint-config-snapshot init` to customize when needed.\n"
     );
   }
@@ -190,7 +543,7 @@ async function executeCheck(cwd, format, defaultInvocation = false) {
     currentSnapshots = await computeCurrentSnapshots(cwd);
   } catch (error) {
     if (!foundConfig) {
-      process.stdout.write(
+      terminal.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;
@@ -199,121 +552,133 @@ async function executeCheck(cwd, format, defaultInvocation = false) {
   }
   if (storedSnapshots.size === 0) {
     const summary = summarizeSnapshots(currentSnapshots);
-    process.stdout.write(
+    terminal.write(
       `Rules found in this analysis: ${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(
+    if (canPromptBaseline && terminal.isInteractive) {
+      const shouldCreateBaseline = await terminal.askYesNo(
         "No baseline yet. Do you want to save this analyzed 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.
+        await writeSnapshots(cwd, snapshotDir, currentSnapshots);
+        const createdSummary = summarizeSnapshots(currentSnapshots);
+        terminal.write(`Great start: baseline created with ${createdSummary.groups} groups and ${createdSummary.rules} rules.
 `);
-        writeSubtleInfo(UPDATE_HINT);
+        terminal.subtle(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");
+    terminal.write("You are almost set: no baseline snapshot found yet.\n");
+    terminal.write("Run `eslint-config-snapshot --update` to create your first baseline.\n");
     return 1;
   }
   const changes = compareSnapshotMaps(storedSnapshots, currentSnapshots);
-  const eslintVersionsByGroup = shouldShowRunLogs() ? await resolveGroupEslintVersions(cwd) : /* @__PURE__ */ new Map();
+  const eslintVersionsByGroup = terminal.showProgress ? await resolveGroupEslintVersions(cwd) : /* @__PURE__ */ new Map();
   if (format === "status") {
     if (changes.length === 0) {
-      process.stdout.write("clean\n");
+      terminal.write("clean\n");
       return 0;
     }
-    process.stdout.write("changes\n");
-    writeSubtleInfo(UPDATE_HINT);
+    terminal.write("changes\n");
+    terminal.subtle(UPDATE_HINT);
     return 1;
   }
   if (format === "diff") {
     if (changes.length === 0) {
-      process.stdout.write("Great news: no snapshot changes detected.\n");
-      writeEslintVersionSummary(eslintVersionsByGroup);
+      terminal.write("Great news: no snapshot changes detected.\n");
+      writeEslintVersionSummary(terminal, eslintVersionsByGroup);
       return 0;
     }
     for (const change of changes) {
-      process.stdout.write(`${formatDiff(change.groupId, change.diff)}
+      terminal.write(`${formatDiff(change.groupId, change.diff)}
 `);
     }
-    writeSubtleInfo(UPDATE_HINT);
+    terminal.subtle(UPDATE_HINT);
     return 1;
   }
-  return printWhatChanged(changes, currentSnapshots, eslintVersionsByGroup);
+  return printWhatChanged(terminal, changes, currentSnapshots, eslintVersionsByGroup);
 }
-async function executeUpdate(cwd, printSummary) {
-  const foundConfig = await findConfigPath(cwd);
-  const storedSnapshots = await loadStoredSnapshots(cwd);
-  writeRunContextHeader(cwd, "update", foundConfig?.path, storedSnapshots);
-  if (shouldShowRunLogs()) {
-    writeSubtleInfo("\u{1F50E} Checking current ESLint configuration...\n");
-  }
-  if (!foundConfig) {
-    writeSubtleInfo(
-      "Tip: no explicit config found. Using safe built-in defaults. Run `eslint-config-snapshot init` to customize when needed.\n"
+function printWhatChanged(terminal, changes, currentSnapshots, eslintVersionsByGroup) {
+  const color = terminal.colors;
+  const currentSummary = summarizeSnapshots(currentSnapshots);
+  const workspaceCount = countUniqueWorkspaces(currentSnapshots);
+  const changeSummary = summarizeChanges(changes);
+  if (changes.length === 0) {
+    terminal.write(color.green("\u2705 Great news: no snapshot drift detected.\n"));
+    terminal.section("\u{1F4CA} Summary");
+    terminal.write(
+      `- \u{1F4E6} baseline: ${currentSummary.groups} groups, ${currentSummary.rules} rules
+- \u{1F5C2}\uFE0F workspaces scanned: ${workspaceCount}
+- \u{1F39A}\uFE0F severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off
+`
     );
+    writeEslintVersionSummary(terminal, eslintVersionsByGroup);
+    return 0;
   }
-  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);
-    const color = createColorizer();
-    const eslintVersionsByGroup = shouldShowRunLogs() ? await resolveGroupEslintVersions(cwd) : /* @__PURE__ */ new Map();
-    writeSectionTitle("Summary", color);
-    process.stdout.write(
-      `Baseline updated: ${summary.groups} groups, ${summary.rules} rules.
-Severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off.
+  terminal.write(color.red("\u26A0\uFE0F Heads up: snapshot drift detected.\n"));
+  terminal.section("\u{1F4CA} Summary");
+  terminal.write(
+    `- changed groups: ${changes.length}
+- introduced rules: ${changeSummary.introduced}
+- removed rules: ${changeSummary.removed}
+- severity changes: ${changeSummary.severity}
+- options changes: ${changeSummary.options}
+- workspace membership changes: ${changeSummary.workspace}
+- \u{1F5C2}\uFE0F workspaces scanned: ${workspaceCount}
+- current baseline: ${currentSummary.groups} groups, ${currentSummary.rules} rules
+- current severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off
 `
-    );
-    writeEslintVersionSummary(eslintVersionsByGroup);
+  );
+  writeEslintVersionSummary(terminal, eslintVersionsByGroup);
+  terminal.write("\n");
+  terminal.section("\u{1F9FE} Changes");
+  for (const change of changes) {
+    terminal.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);
+      terminal.write(`${decorated}
+`);
+    }
+    terminal.write("\n");
   }
-  return 0;
+  terminal.subtle(UPDATE_HINT);
+  return 1;
 }
-async function executePrint(cwd, format) {
-  const foundConfig = await findConfigPath(cwd);
-  const storedSnapshots = await loadStoredSnapshots(cwd);
-  writeRunContextHeader(cwd, `print:${format}`, foundConfig?.path, storedSnapshots);
-  if (shouldShowRunLogs()) {
-    writeSubtleInfo("\u{1F50E} Checking current ESLint configuration...\n");
+
+// src/commands/print.ts
+import { findConfigPath as findConfigPath2, loadConfig as loadConfig2 } from "@eslint-config-snapshot/api";
+async function executePrint(cwd, terminal, snapshotDir, format) {
+  const foundConfig = await findConfigPath2(cwd);
+  const storedSnapshots = await loadStoredSnapshots(cwd, snapshotDir);
+  writeRunContextHeader(terminal, cwd, `print:${format}`, foundConfig?.path, storedSnapshots);
+  if (terminal.showProgress) {
+    terminal.subtle("\u{1F50E} Checking current ESLint configuration...\n");
   }
   const currentSnapshots = await computeCurrentSnapshots(cwd);
   if (format === "short") {
-    process.stdout.write(formatShortPrint([...currentSnapshots.values()]));
+    terminal.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)}
+  terminal.write(`${JSON.stringify(output, null, 2)}
 `);
 }
-async function executeConfig(cwd, format) {
-  const foundConfig = await findConfigPath(cwd);
-  const storedSnapshots = await loadStoredSnapshots(cwd);
-  writeRunContextHeader(cwd, `config:${format}`, foundConfig?.path, storedSnapshots);
-  if (shouldShowRunLogs()) {
-    writeSubtleInfo("\u2699\uFE0F Resolving effective runtime configuration...\n");
+async function executeConfig(cwd, terminal, snapshotDir, format) {
+  const foundConfig = await findConfigPath2(cwd);
+  const storedSnapshots = await loadStoredSnapshots(cwd, snapshotDir);
+  writeRunContextHeader(terminal, cwd, `config:${format}`, foundConfig?.path, storedSnapshots);
+  if (terminal.showProgress) {
+    terminal.subtle("\u2699\uFE0F Resolving effective runtime configuration...\n");
   }
-  const config = await loadConfig(cwd);
+  const config = await loadConfig2(cwd);
   const resolved = await resolveWorkspaceAssignments(cwd, config);
   const payload = {
     source: foundConfig?.path ?? "built-in-defaults",
@@ -327,150 +692,67 @@ async function executeConfig(cwd, format) {
     sampling: config.sampling
   };
   if (format === "short") {
-    process.stdout.write(formatShortConfig(payload));
+    terminal.write(formatShortConfig(payload));
     return;
   }
-  process.stdout.write(`${JSON.stringify(payload, null, 2)}
+  terminal.write(`${JSON.stringify(payload, null, 2)}
 `);
 }
-async function computeCurrentSnapshots(cwd) {
-  const config = await loadConfig(cwd);
-  const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config);
-  const snapshots = /* @__PURE__ */ new Map();
-  for (const group of assignments) {
-    const extractedForGroup = [];
-    for (const workspaceRel of group.workspaces) {
-      const workspaceAbs = path.resolve(discovery.rootAbs, workspaceRel);
-      const sampled = await sampleWorkspaceFiles(workspaceAbs, config.sampling);
-      let extractedCount = 0;
-      let lastExtractionError;
-      const sampledAbs = sampled.map((sampledRel) => path.resolve(workspaceAbs, sampledRel));
-      const results = await extractRulesForWorkspaceSamples(workspaceAbs, sampledAbs);
-      for (const result of results) {
-        if (result.rules) {
-          extractedForGroup.push(result.rules);
-          extractedCount += 1;
-          continue;
-        }
-        const message = result.error instanceof Error ? result.error.message : String(result.error);
-        if (isRecoverableExtractionError(message)) {
-          lastExtractionError = message;
-          continue;
-        }
-        throw result.error ?? new Error(message);
-      }
-      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 = aggregateRules(extractedForGroup);
-    snapshots.set(group.name, buildSnapshot(group.name, group.workspaces, aggregated));
-  }
-  return snapshots;
-}
-function isRecoverableExtractionError(message) {
-  return message.startsWith("Invalid JSON from eslint --print-config") || message.startsWith("Empty ESLint print-config output") || message.includes("File ignored because of a matching ignore pattern") || message.includes("File ignored by default");
-}
-async function resolveWorkspaceAssignments(cwd, config) {
-  const discovery = await discoverWorkspaces({ cwd, workspaceInput: config.workspaceInput });
-  const assignments = config.grouping.mode === "standalone" ? discovery.workspacesRel.map((workspace) => ({ name: workspace, workspaces: [workspace] })) : 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(", ")}`);
-    }
-  }
-  return { discovery, assignments };
-}
-async function loadStoredSnapshots(cwd) {
-  const dir = path.join(cwd, SNAPSHOT_DIR);
-  const files = await fg("**/*.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 readSnapshotFile(file);
-    snapshots.set(snapshot.groupId, snapshot);
-  }
-  return snapshots;
-}
-async function writeSnapshots(cwd, snapshots) {
-  await mkdir(path.join(cwd, SNAPSHOT_DIR), { recursive: true });
-  for (const snapshot of snapshots.values()) {
-    await writeSnapshotFile(path.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 = diffSnapshots(prev, next);
-    if (hasDiff(diff)) {
-      changes.push({ groupId: id, diff });
-    }
+
+// src/commands/update.ts
+import { findConfigPath as findConfigPath3 } from "@eslint-config-snapshot/api";
+async function executeUpdate(cwd, terminal, snapshotDir, printSummary) {
+  const foundConfig = await findConfigPath3(cwd);
+  const storedSnapshots = await loadStoredSnapshots(cwd, snapshotDir);
+  writeRunContextHeader(terminal, cwd, "update", foundConfig?.path, storedSnapshots);
+  if (terminal.showProgress) {
+    terminal.subtle("\u{1F50E} Checking current ESLint configuration...\n");
   }
-  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}`);
-    }
+  if (!foundConfig) {
+    terminal.subtle(
+      "Tip: no explicit config found. Using safe built-in defaults. Run `eslint-config-snapshot init` to customize when needed.\n"
+    );
   }
-  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)}`);
+  let currentSnapshots;
+  try {
+    currentSnapshots = await computeCurrentSnapshots(cwd);
+  } catch (error) {
+    if (!foundConfig) {
+      terminal.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;
   }
-  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}`);
+  await writeSnapshots(cwd, snapshotDir, currentSnapshots);
+  if (printSummary) {
+    const summary = summarizeSnapshots(currentSnapshots);
+    const workspaceCount = countUniqueWorkspaces(currentSnapshots);
+    const eslintVersionsByGroup = terminal.showProgress ? await resolveGroupEslintVersions(cwd) : /* @__PURE__ */ new Map();
+    terminal.section("\u{1F4CA} Summary");
+    terminal.write(
+      `Baseline updated: ${summary.groups} groups, ${summary.rules} rules.
+Workspaces scanned: ${workspaceCount}.
+Severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off.
+`
+    );
+    writeEslintVersionSummary(terminal, eslintVersionsByGroup);
   }
+  return 0;
 }
-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 = {}) {
+
+// src/init.ts
+import { discoverWorkspaces as discoverWorkspaces2, findConfigPath as findConfigPath4, getConfigScaffold, normalizePath as normalizePath2 } from "@eslint-config-snapshot/api";
+import fg2 from "fast-glob";
+import { access, readFile, writeFile } from "fs/promises";
+import path3 from "path";
+async function runInit(cwd, opts, runtime) {
   const force = opts.force ?? false;
   const showEffective = opts.showEffective ?? false;
-  const existing = await findConfigPath(cwd);
+  const existing = await findConfigPath4(cwd);
   if (existing && !force) {
-    process.stderr.write(
+    runtime.writeStderr(
       `Existing config detected at ${existing.path}. Creating another config can cause conflicts. Remove the existing config or rerun with --force.
 `
     );
@@ -479,27 +761,27 @@ async function runInit(cwd, opts = {}) {
   let target = opts.target;
   let preset = opts.preset;
   if (!opts.yes && !target && !preset && process.stdin.isTTY && process.stdout.isTTY) {
-    const interactive = await askInitPreferences();
+    const interactive = await askInitPreferences(runtime);
     target = interactive.target;
     preset = interactive.preset;
   }
   const finalTarget = target ?? "file";
   const finalPreset = preset ?? "recommended";
-  const configObject = await resolveInitConfigObject(cwd, finalPreset, Boolean(opts.yes));
+  const configObject = await resolveInitConfigObject(cwd, finalPreset, Boolean(opts.yes), runtime);
   if (showEffective) {
-    process.stdout.write(`Effective config preview:
+    runtime.writeStdout(`Effective config preview:
 ${JSON.stringify(configObject, null, 2)}
 `);
   }
   if (finalTarget === "package-json") {
-    return runInitInPackageJson(cwd, configObject, force);
+    return runInitInPackageJson(cwd, configObject, force, runtime);
   }
-  return runInitInFile(cwd, configObject, force);
+  return runInitInFile(cwd, configObject, force, runtime);
 }
-async function askInitPreferences() {
+async function askInitPreferences(runtime) {
   const { select } = await import("@inquirer/prompts");
-  const target = await runPromptWithPausedTimer(() => askInitTarget(select));
-  const preset = await runPromptWithPausedTimer(() => askInitPreset(select));
+  const target = await runtime.runPromptWithPausedTimer(() => askInitTarget(select));
+  const preset = await runtime.runPromptWithPausedTimer(() => askInitPreset(select));
   return { target, preset };
 }
 async function askInitTarget(selectPrompt) {
@@ -521,29 +803,7 @@ async function askInitPreset(selectPrompt) {
     ]
   });
 }
-function askQuestion(rl, prompt) {
-  pauseRunTimer();
-  return new Promise((resolve) => {
-    rl.question(prompt, (answer) => {
-      resumeRunTimer();
-      resolve(answer);
-    });
-  });
-}
-async function askYesNo(prompt, defaultYes) {
-  const rl = 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, configObject, force) {
+async function runInitInFile(cwd, configObject, force, runtime) {
   const candidates = [
     ".eslint-config-snapshot.js",
     ".eslint-config-snapshot.cjs",
@@ -554,60 +814,60 @@ async function runInitInFile(cwd, configObject, force) {
   ];
   for (const candidate of candidates) {
     try {
-      await access(path.join(cwd, candidate));
+      await access(path3.join(cwd, candidate));
       if (!force) {
-        process.stderr.write(`Config already exists: ${candidate}
+        runtime.writeStderr(`Config already exists: ${candidate}
 `);
         return 1;
       }
     } catch {
     }
   }
-  const target = path.join(cwd, "eslint-config-snapshot.config.mjs");
+  const target = path3.join(cwd, "eslint-config-snapshot.config.mjs");
   await writeFile(target, toConfigScaffold(configObject), "utf8");
-  process.stdout.write(`Created ${path.basename(target)}
+  runtime.writeStdout(`Created ${path3.basename(target)}
 `);
   return 0;
 }
-async function runInitInPackageJson(cwd, configObject, force) {
-  const packageJsonPath = path.join(cwd, "package.json");
+async function runInitInPackageJson(cwd, configObject, force, runtime) {
+  const packageJsonPath = path3.join(cwd, "package.json");
   let packageJsonRaw;
   try {
     packageJsonRaw = await readFile(packageJsonPath, "utf8");
   } catch {
-    process.stderr.write("package.json not found in current directory.\n");
+    runtime.writeStderr("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");
+    runtime.writeStderr("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");
+    runtime.writeStderr("Config already exists in package.json: eslint-config-snapshot\n");
     return 1;
   }
   parsed["eslint-config-snapshot"] = configObject;
   await writeFile(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf8");
-  process.stdout.write('Created config in package.json under "eslint-config-snapshot"\n');
+  runtime.writeStdout('Created config in package.json under "eslint-config-snapshot"\n');
   return 0;
 }
-async function resolveInitConfigObject(cwd, preset, nonInteractive) {
+async function resolveInitConfigObject(cwd, preset, nonInteractive, runtime) {
   if (preset === "minimal") {
     return {};
   }
   if (preset === "full") {
     return getFullPresetObject();
   }
-  return buildRecommendedPresetObject(cwd, nonInteractive);
+  return buildRecommendedPresetObject(cwd, nonInteractive, runtime);
 }
-async function buildRecommendedPresetObject(cwd, nonInteractive) {
+async function buildRecommendedPresetObject(cwd, nonInteractive, runtime) {
   const workspaces = await discoverInitWorkspaces(cwd);
   const useInteractiveGrouping = !nonInteractive && process.stdin.isTTY && process.stdout.isTTY;
-  const assignments = useInteractiveGrouping ? await askRecommendedGroupAssignments(workspaces) : /* @__PURE__ */ new Map();
+  const assignments = useInteractiveGrouping ? await askRecommendedGroupAssignments(workspaces, runtime) : /* @__PURE__ */ new Map();
   return buildRecommendedConfigFromAssignments(workspaces, assignments);
 }
 function buildRecommendedConfigFromAssignments(workspaces, assignments) {
@@ -627,11 +887,11 @@ function buildRecommendedConfigFromAssignments(workspaces, assignments) {
   };
 }
 async function discoverInitWorkspaces(cwd) {
-  const discovered = await discoverWorkspaces({ cwd, workspaceInput: { mode: "discover" } });
+  const discovered = await discoverWorkspaces2({ cwd, workspaceInput: { mode: "discover" } });
   if (!(discovered.workspacesRel.length === 1 && discovered.workspacesRel[0] === ".")) {
     return discovered.workspacesRel;
   }
-  const packageJsonPath = path.join(cwd, "package.json");
+  const packageJsonPath = path3.join(cwd, "package.json");
   try {
     const raw = await readFile(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -644,11 +904,12 @@ async function discoverInitWorkspaces(cwd) {
     if (workspacePatterns.length === 0) {
       return discovered.workspacesRel;
     }
-    const workspacePackageFiles = await fg(
-      workspacePatterns.map((pattern) => `${trimTrailingSlashes(pattern)}/package.json`),
-      { cwd, onlyFiles: true, dot: true }
-    );
-    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => normalizePath(path.dirname(entry))))].sort(
+    const workspacePackageFiles = await fg2(workspacePatterns.map((pattern) => `${trimTrailingSlashes(pattern)}/package.json`), {
+      cwd,
+      onlyFiles: true,
+      dot: true
+    });
+    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => normalizePath2(path3.dirname(entry))))].sort(
       (a, b) => a.localeCompare(b)
     );
     if (workspaceDirs.length > 0) {
@@ -665,13 +926,11 @@ function trimTrailingSlashes(value) {
   }
   return normalized;
 }
-async function askRecommendedGroupAssignments(workspaces) {
+async function askRecommendedGroupAssignments(workspaces, runtime) {
   const { checkbox, select } = await import("@inquirer/prompts");
-  process.stdout.write(
-    'Recommended setup: default group "*" is a dynamic catch-all for every discovered workspace.\n'
-  );
-  process.stdout.write("Select only workspaces that should move to explicit static groups.\n");
-  const overrides = await runPromptWithPausedTimer(
+  runtime.writeStdout('Recommended setup: default group "*" is a dynamic catch-all for every discovered workspace.\n');
+  runtime.writeStdout("Select only workspaces that should move to explicit static groups.\n");
+  const overrides = await runtime.runPromptWithPausedTimer(
     () => checkbox({
       message: 'Choose exception workspaces (leave empty to keep all in default "*"):',
       choices: workspaces.map((workspace) => ({ name: workspace, value: workspace })),
@@ -685,7 +944,7 @@ async function askRecommendedGroupAssignments(workspaces) {
     while (usedGroups.includes(nextGroup)) {
       nextGroup += 1;
     }
-    const selected = await runPromptWithPausedTimer(
+    const selected = await runtime.runPromptWithPausedTimer(
       () => select({
         message: `Select group for ${workspace}`,
         choices: [
@@ -714,439 +973,358 @@ function getFullPresetObject() {
       groups: [{ name: "default", match: ["**/*"] }]
     },
     sampling: {
-      maxFilesPerWorkspace: 8,
-      includeGlobs: ["**/*.{js,jsx,ts,tsx,cjs,mjs}"],
+      maxFilesPerWorkspace: 10,
+      includeGlobs: ["**/*.{js,jsx,ts,tsx,cjs,mjs,md,mdx}"],
       excludeGlobs: ["**/node_modules/**", "**/dist/**"],
-      hintGlobs: []
+      tokenHints: [
+        "chunk",
+        "conf",
+        "config",
+        "container",
+        "controller",
+        "helpers",
+        "mock",
+        "mocks",
+        "presentation",
+        "repository",
+        "route",
+        "routes",
+        "schema",
+        "setup",
+        "spec",
+        "stories",
+        "style",
+        "styles",
+        "test",
+        "type",
+        "types",
+        "utils",
+        "view",
+        "views"
+      ]
     }
   };
 }
-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 = path.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, eslintVersionsByGroup) {
-  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"));
-    writeSectionTitle("Summary", color);
-    process.stdout.write(
-      `- baseline: ${currentSummary.groups} groups, ${currentSummary.rules} rules
-- severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off
-`
-    );
-    writeEslintVersionSummary(eslintVersionsByGroup);
-    return 0;
-  }
-  process.stdout.write(color.red("Heads up: snapshot drift detected.\n"));
-  writeSectionTitle("Summary", color);
-  process.stdout.write(
-    `- changed groups: ${changes.length}
-- introduced rules: ${changeSummary.introduced}
-- removed rules: ${changeSummary.removed}
-- severity changes: ${changeSummary.severity}
-- options changes: ${changeSummary.options}
-- workspace membership changes: ${changeSummary.workspace}
-- current baseline: ${currentSummary.groups} groups, ${currentSummary.rules} rules
-- current severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off
-`
-  );
-  writeEslintVersionSummary(eslintVersionsByGroup);
-  process.stdout.write("\n");
-  writeSectionTitle("Changes", color);
-  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}
-`);
+
+// src/terminal.ts
+import { createInterface } from "readline";
+var TerminalIO = class {
+  color = createColorizer();
+  activeRunTimer;
+  get isTTY() {
+    return process.stdout.isTTY === true;
+  }
+  get isInteractive() {
+    return process.stdin.isTTY === true && process.stdout.isTTY === true;
+  }
+  get showProgress() {
+    if (process.env.ESLINT_CONFIG_SNAPSHOT_NO_PROGRESS === "1") {
+      return false;
     }
-    process.stdout.write("\n");
-  }
-  writeSubtleInfo(UPDATE_HINT);
-  return 1;
-}
-function writeSectionTitle(title, color) {
-  process.stdout.write(`${color.bold(title)}
-`);
-}
-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) {
-  const { rules, error, warn, off } = countRuleSeverities([...snapshots.values()].map((snapshot) => snapshot.rules));
-  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 resolveInvocationLabel(argv) {
-  const commandToken = argv.find((entry) => !entry.startsWith("-"));
-  if (commandToken) {
-    return commandToken;
-  }
-  if (argv.includes("-u") || argv.includes("--update")) {
-    return "update";
-  }
-  if (argv.includes("-h") || argv.includes("--help")) {
-    return "help";
+    return this.isTTY;
   }
-  return "check";
-}
-function shouldShowRunLogs() {
-  if (process.env.ESLINT_CONFIG_SNAPSHOT_NO_PROGRESS === "1") {
-    return false;
+  get colors() {
+    return this.color;
   }
-  return process.stdout.isTTY === true;
-}
-function beginRunTimer(label) {
-  if (!shouldShowRunLogs()) {
-    activeRunTimer = void 0;
-    return;
+  write(text) {
+    process.stdout.write(text);
   }
-  activeRunTimer = {
-    label,
-    startedAtMs: Date.now(),
-    pausedMs: 0,
-    pauseStartedAtMs: void 0
-  };
-}
-function endRunTimer(exitCode) {
-  if (!activeRunTimer || !shouldShowRunLogs()) {
-    return;
+  error(text) {
+    process.stderr.write(text);
   }
-  if (activeRunTimer.pauseStartedAtMs !== void 0) {
-    activeRunTimer.pausedMs += Date.now() - activeRunTimer.pauseStartedAtMs;
-    activeRunTimer.pauseStartedAtMs = void 0;
+  subtle(text) {
+    this.write(this.color.dim(text));
   }
-  const elapsedMs = Math.max(0, Date.now() - activeRunTimer.startedAtMs - activeRunTimer.pausedMs);
-  const seconds = (elapsedMs / 1e3).toFixed(2);
-  if (exitCode === 0) {
-    writeSubtleInfo(`Finished in ${seconds}s
+  section(title) {
+    this.write(`${this.color.bold(title)}
 `);
-  } else {
-    writeSubtleInfo(`Finished with errors in ${seconds}s
-`);
-  }
-  activeRunTimer = void 0;
-}
-function pauseRunTimer() {
-  if (!activeRunTimer || activeRunTimer.pauseStartedAtMs !== void 0) {
-    return;
-  }
-  activeRunTimer.pauseStartedAtMs = Date.now();
-}
-function resumeRunTimer() {
-  if (!activeRunTimer || activeRunTimer.pauseStartedAtMs === void 0) {
-    return;
-  }
-  activeRunTimer.pausedMs += Date.now() - activeRunTimer.pauseStartedAtMs;
-  activeRunTimer.pauseStartedAtMs = void 0;
-}
-async function runPromptWithPausedTimer(prompt) {
-  pauseRunTimer();
-  try {
-    return await prompt();
-  } finally {
-    resumeRunTimer();
-  }
-}
-function readCliVersion() {
-  if (cachedCliVersion !== void 0) {
-    return cachedCliVersion;
   }
-  const envPackageName = process.env.npm_package_name;
-  const envPackageVersion = process.env.npm_package_version;
-  if (isCliPackageName(envPackageName) && typeof envPackageVersion === "string" && envPackageVersion.length > 0) {
-    cachedCliVersion = envPackageVersion;
-    return cachedCliVersion;
-  }
-  const scriptPath = process.argv[1];
-  if (!scriptPath) {
-    cachedCliVersion = "unknown";
-    return cachedCliVersion;
-  }
-  try {
-    const req = createRequire(path.resolve(scriptPath));
-    const resolvedCliEntry = req.resolve("@eslint-config-snapshot/cli");
-    const resolvedVersion = readVersionFromResolvedEntry(resolvedCliEntry);
-    if (resolvedVersion !== void 0) {
-      cachedCliVersion = resolvedVersion;
-      return cachedCliVersion;
-    }
-  } catch {
-  }
-  let current = path.resolve(path.dirname(scriptPath));
-  let fallbackVersion;
-  while (true) {
-    const packageJsonPath = path.join(current, "package.json");
-    if (existsSync(packageJsonPath)) {
-      try {
-        const raw = readFileSync(packageJsonPath, "utf8");
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.version === "string" && parsed.version.length > 0) {
-          if (isCliPackageName(parsed.name)) {
-            cachedCliVersion = parsed.version;
-            return cachedCliVersion;
-          }
-          if (fallbackVersion === void 0) {
-            fallbackVersion = parsed.version;
-          }
-        }
-      } catch {
-      }
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
+  success(text) {
+    this.write(this.color.green(text));
   }
-  cachedCliVersion = fallbackVersion ?? "unknown";
-  return cachedCliVersion;
-}
-function isCliPackageName(value) {
-  return value === "@eslint-config-snapshot/cli" || value === "eslint-config-snapshot";
-}
-function readVersionFromResolvedEntry(entryAbs) {
-  let current = path.resolve(path.dirname(entryAbs));
-  while (true) {
-    const packageJsonPath = path.join(current, "package.json");
-    if (existsSync(packageJsonPath)) {
-      try {
-        const raw = readFileSync(packageJsonPath, "utf8");
-        const parsed = JSON.parse(raw);
-        if (isCliPackageName(parsed.name) && typeof parsed.version === "string" && parsed.version.length > 0) {
-          return parsed.version;
-        }
-      } catch {
-      }
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
+  warning(text) {
+    this.write(this.color.yellow(text));
   }
-  return void 0;
-}
-function writeRunContextHeader(cwd, commandLabel, configPath, storedSnapshots) {
-  if (!shouldShowRunLogs()) {
-    return;
+  danger(text) {
+    this.write(this.color.red(text));
   }
-  const color = createColorizer();
-  process.stdout.write(color.bold(`eslint-config-snapshot v${readCliVersion()} \u2022 ${formatCommandDisplayLabel(commandLabel)}
-`));
-  process.stdout.write(`\u{1F4C1} Repository: ${cwd}
-`);
-  process.stdout.write(`\u{1F4C1} Baseline: ${formatStoredSnapshotSummary(storedSnapshots)}
-`);
-  process.stdout.write(`\u2699\uFE0F Config source: ${formatConfigSource(cwd, configPath)}
-`);
-  process.stdout.write("\n");
-}
-function formatCommandDisplayLabel(commandLabel) {
-  switch (commandLabel) {
-    case "check":
-    case "check:summary": {
-      return "Check drift against baseline (summary)";
-    }
-    case "check:diff": {
-      return "Check drift against baseline (detailed diff)";
-    }
-    case "check:status": {
-      return "Check drift against baseline (status only)";
-    }
-    case "update": {
-      return "Update baseline snapshot";
-    }
-    case "print:json": {
-      return "Print aggregated rules (JSON)";
+  bold(text) {
+    return this.color.bold(text);
+  }
+  beginRun(label) {
+    if (!this.showProgress) {
+      this.activeRunTimer = void 0;
+      return;
     }
-    case "print:short": {
-      return "Print aggregated rules (short view)";
+    this.activeRunTimer = {
+      label,
+      startedAtMs: Date.now(),
+      pausedMs: 0,
+      pauseStartedAtMs: void 0
+    };
+  }
+  endRun(exitCode, logTiming) {
+    if (!this.activeRunTimer || !this.showProgress) {
+      return;
     }
-    case "config:json": {
-      return "Show effective runtime config (JSON)";
+    if (this.activeRunTimer.pauseStartedAtMs !== void 0) {
+      this.activeRunTimer.pausedMs += Date.now() - this.activeRunTimer.pauseStartedAtMs;
+      this.activeRunTimer.pauseStartedAtMs = void 0;
     }
-    case "config:short": {
-      return "Show effective runtime config (short view)";
+    const elapsedMs = Math.max(0, Date.now() - this.activeRunTimer.startedAtMs - this.activeRunTimer.pausedMs);
+    logTiming(this.activeRunTimer, elapsedMs);
+    const seconds = (elapsedMs / 1e3).toFixed(2);
+    this.subtle(exitCode === 0 ? `\u23F1\uFE0F Finished in ${seconds}s
+` : `\u23F1\uFE0F Finished with errors in ${seconds}s
+`);
+    this.activeRunTimer = void 0;
+  }
+  pauseRun() {
+    if (!this.activeRunTimer || this.activeRunTimer.pauseStartedAtMs !== void 0) {
+      return;
     }
-    case "init": {
-      return "Initialize local configuration";
+    this.activeRunTimer.pauseStartedAtMs = Date.now();
+  }
+  resumeRun() {
+    if (!this.activeRunTimer || this.activeRunTimer.pauseStartedAtMs === void 0) {
+      return;
     }
-    case "help": {
-      return "Show CLI help";
+    this.activeRunTimer.pausedMs += Date.now() - this.activeRunTimer.pauseStartedAtMs;
+    this.activeRunTimer.pauseStartedAtMs = void 0;
+  }
+  async withPausedRunTimer(task) {
+    this.pauseRun();
+    try {
+      return await task();
+    } finally {
+      this.resumeRun();
     }
-    default: {
-      return commandLabel;
+  }
+  async askYesNo(prompt, defaultYes) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      const answerRaw = await this.askQuestion(rl, prompt);
+      const answer = answerRaw.trim().toLowerCase();
+      if (answer.length === 0) {
+        return defaultYes;
+      }
+      return answer === "y" || answer === "yes";
+    } finally {
+      rl.close();
     }
   }
-}
-function formatConfigSource(cwd, configPath) {
-  if (!configPath) {
-    return "built-in defaults";
+  async askQuestion(rl, prompt) {
+    this.pauseRun();
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer) => {
+        this.resumeRun();
+        resolve(answer);
+      });
+    });
   }
-  const rel = normalizePath(path.relative(cwd, configPath));
-  if (path.basename(configPath) === "package.json") {
-    return `${rel} (eslint-config-snapshot field)`;
+};
+function resolveInvocationLabel(argv) {
+  const commandToken = argv.find((entry) => !entry.startsWith("-"));
+  if (commandToken) {
+    return commandToken;
   }
-  return rel;
-}
-function formatStoredSnapshotSummary(storedSnapshots) {
-  if (storedSnapshots.size === 0) {
-    return "none";
+  if (argv.includes("-u") || argv.includes("--update")) {
+    return "update";
   }
-  const summary = summarizeStoredSnapshots(storedSnapshots);
-  return `${summary.groups} groups, ${summary.rules} rules (severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off)`;
+  if (argv.includes("-h") || argv.includes("--help")) {
+    return "help";
+  }
+  return "check";
 }
-async function resolveGroupEslintVersions(cwd) {
-  const config = await loadConfig(cwd);
-  const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config);
-  const result = /* @__PURE__ */ new Map();
-  for (const group of assignments) {
-    const versions = /* @__PURE__ */ new Set();
-    for (const workspaceRel of group.workspaces) {
-      const workspaceAbs = path.resolve(discovery.rootAbs, workspaceRel);
-      versions.add(resolveEslintVersionForWorkspace(workspaceAbs));
+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)
+  };
+}
+
+// src/index.ts
+var SNAPSHOT_DIR = ".eslint-config-snapshot";
+var debugRun = createDebug2("eslint-config-snapshot:run");
+var debugTiming2 = createDebug2("eslint-config-snapshot:timing");
+async function runCli(command, cwd, flags = []) {
+  const argv = command ? [command, ...flags] : [...flags];
+  return runArgv(argv, cwd);
+}
+async function runArgv(argv, cwd) {
+  const terminal = new TerminalIO();
+  const invocationLabel = resolveInvocationLabel(argv);
+  terminal.beginRun(invocationLabel);
+  debugRun("start label=%s cwd=%s argv=%o", invocationLabel, cwd, argv);
+  let exitCode = 1;
+  try {
+    const hasCommandToken = argv.some((token) => !token.startsWith("-"));
+    if (!hasCommandToken) {
+      exitCode = await runDefaultInvocation(argv, cwd, terminal);
+      return exitCode;
     }
-    result.set(group.name, [...versions].sort((a, b) => a.localeCompare(b)));
+    let actionCode;
+    const program = createProgram(cwd, terminal, (code) => {
+      actionCode = code;
+    });
+    try {
+      await program.parseAsync(argv, { from: "user" });
+    } catch (error) {
+      if (error instanceof CommanderError) {
+        if (error.code === "commander.helpDisplayed") {
+          exitCode = 0;
+          return exitCode;
+        }
+        exitCode = error.exitCode;
+        return exitCode;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      terminal.error(`${message}
+`);
+      return 1;
+    }
+    exitCode = actionCode ?? 0;
+    debugRun("done label=%s exitCode=%d", invocationLabel, exitCode);
+    return exitCode;
+  } finally {
+    terminal.endRun(exitCode, (timer, elapsedMs) => {
+      debugTiming2(
+        "command=%s exitCode=%d elapsedMs=%d pausedMs=%d",
+        timer.label,
+        exitCode,
+        elapsedMs,
+        timer.pausedMs
+      );
+    });
   }
-  return result;
 }
-function writeEslintVersionSummary(eslintVersionsByGroup) {
-  if (!shouldShowRunLogs() || eslintVersionsByGroup.size === 0) {
-    return;
-  }
-  const allVersions = /* @__PURE__ */ new Set();
-  for (const versions of eslintVersionsByGroup.values()) {
-    for (const version of versions) {
-      allVersions.add(version);
+async function runDefaultInvocation(argv, cwd, terminal) {
+  const known = /* @__PURE__ */ new Set(["-u", "--update", "-h", "--help"]);
+  for (const token of argv) {
+    if (!known.has(token)) {
+      terminal.error(`error: unknown option '${token}'
+`);
+      return 1;
     }
   }
-  const sortedAllVersions = [...allVersions].sort((a, b) => a.localeCompare(b));
-  if (sortedAllVersions.length === 1) {
-    process.stdout.write(`- eslint runtime: ${sortedAllVersions[0]} (all groups)
-`);
-    return;
+  if (argv.includes("-h") || argv.includes("--help")) {
+    const program = createProgram(cwd, terminal, () => {
+    });
+    program.outputHelp();
+    return 0;
   }
-  process.stdout.write("- eslint runtime by group:\n");
-  const sortedEntries = [...eslintVersionsByGroup.entries()].sort((a, b) => a[0].localeCompare(b[0]));
-  for (const [groupName, versions] of sortedEntries) {
-    process.stdout.write(`  - ${groupName}: ${versions.join(", ")}
-`);
+  if (argv.includes("-u") || argv.includes("--update")) {
+    return executeUpdate(cwd, terminal, SNAPSHOT_DIR, true);
   }
+  return executeCheck(cwd, "summary", terminal, SNAPSHOT_DIR, true);
 }
-function summarizeStoredSnapshots(snapshots) {
-  const { rules, error, warn, off } = countRuleSeverities([...snapshots.values()].map((snapshot) => snapshot.rules));
-  return { groups: snapshots.size, rules, error, warn, off };
-}
-function countRuleSeverities(ruleObjects) {
-  let rules = 0;
-  let error = 0;
-  let warn = 0;
-  let off = 0;
-  for (const rulesObject of ruleObjects) {
-    for (const entry of Object.values(rulesObject)) {
-      rules += 1;
-      if (entry[0] === "error") {
-        error += 1;
-      } else if (entry[0] === "warn") {
-        warn += 1;
-      } else {
-        off += 1;
-      }
+function createProgram(cwd, terminal, onActionExit) {
+  const program = new 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, terminal, SNAPSHOT_DIR));
+  });
+  program.command("update").alias("snapshot").description("Compute and write snapshots to .eslint-config-snapshot/").action(async () => {
+    onActionExit(await executeUpdate(cwd, terminal, SNAPSHOT_DIR, 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, terminal, SNAPSHOT_DIR, format);
+    onActionExit(0);
+  });
+  program.command("config").description("Print effective evaluated config").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 executeConfig(cwd, terminal, SNAPSHOT_DIR, 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: recommended|minimal|full", parseInitPreset).option("--show-effective", "Print the evaluated config that will be written").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 select prompts for target/preset.
+    Recommended preset keeps a dynamic catch-all default group ("*") and asks only for static exception groups.
+
+  $ eslint-config-snapshot init --yes --target package-json --preset recommended --show-effective
+    Non-interactive recommended setup in package.json, with effective preview.
+
+  $ 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, {
+        runPromptWithPausedTimer: terminal.withPausedRunTimer.bind(terminal),
+        writeStdout: terminal.write.bind(terminal),
+        writeStderr: terminal.error.bind(terminal)
+      })
+    );
+  });
+  program.command("compare", { hidden: true }).action(async () => {
+    onActionExit(await executeCheck(cwd, "diff", terminal, SNAPSHOT_DIR));
+  });
+  program.command("status", { hidden: true }).action(async () => {
+    onActionExit(await executeCheck(cwd, "status", terminal, SNAPSHOT_DIR));
+  });
+  program.command("what-changed", { hidden: true }).action(async () => {
+    onActionExit(await executeCheck(cwd, "summary", terminal, SNAPSHOT_DIR));
+  });
+  program.exitOverride();
+  return program;
+}
+function parseCheckFormat(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "summary" || normalized === "status" || normalized === "diff") {
+    return normalized;
   }
-  return { rules, error, warn, off };
+  throw new InvalidArgumentError("Expected one of: summary, status, diff");
 }
-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}`);
-    }
+function parsePrintFormat(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "json" || normalized === "short") {
+    return normalized;
   }
-  return `${lines.join("\n")}
-`;
+  throw new InvalidArgumentError("Expected one of: json, short");
 }
-function formatShortConfig(payload) {
-  const lines = [
-    `source: ${payload.source}`,
-    `workspaces (${payload.workspaces.length}): ${payload.workspaces.join(", ") || "(none)"}`,
-    `grouping mode: ${payload.grouping.mode} (allow empty: ${payload.grouping.allowEmptyGroups})`
-  ];
-  for (const group of payload.grouping.groups) {
-    lines.push(`group ${group.name} (${group.workspaces.length}): ${group.workspaces.join(", ") || "(none)"}`);
+function parseInitTarget(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "file" || normalized === "package-json") {
+    return normalized;
   }
-  lines.push(`workspaceInput: ${JSON.stringify(payload.workspaceInput)}`, `sampling: ${JSON.stringify(payload.sampling)}`);
-  return `${lines.join("\n")}
-`;
+  throw new InvalidArgumentError("Expected one of: file, package-json");
+}
+function parseInitPreset(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "recommended" || normalized === "minimal" || normalized === "full") {
+    return normalized;
+  }
+  throw new InvalidArgumentError("Expected one of: recommended, minimal, full");
+}
+async function main() {
+  const code = await runArgv(process.argv.slice(2), process.cwd());
+  process.exitCode = code;
+}
+function isDirectCliExecution() {
+  const entry = process.argv[1];
+  if (!entry) {
+    return false;
+  }
+  const normalized = path4.basename(entry).toLowerCase();
+  return normalized === "index.js" || normalized === "index.cjs" || normalized === "index.ts" || normalized === "eslint-config-snapshot";
+}
+if (isDirectCliExecution()) {
+  void main();
 }
 export {
   buildRecommendedConfigFromAssignments,