@eslint-config-snapshot/cli 0.3.2 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @eslint-config-snapshot/cli
 
+## 0.5.0
+
+### Minor Changes
+
+- Add ESLint runtime version reporting by group in CLI summaries and improve pnpm/corepack isolated test resilience.
+
+### Patch Changes
+
+- Updated dependencies
+  - @eslint-config-snapshot/api@0.5.0
+
+## 0.4.0
+
+### Minor Changes
+
+- Minor release with improved CLI output consistency and faster workspace extraction using ESLint API fallback strategy.
+
+### Patch Changes
+
+- Updated dependencies
+  - @eslint-config-snapshot/api@0.4.0
+
 ## 0.3.2
 
 ### Patch Changes

package/dist/index.cjs

@@ -39,39 +39,53 @@ 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_node_fs = require("fs");
 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";
+var activeRunTimer;
+var cachedCliVersion;
 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;
-  });
+  const invocationLabel = resolveInvocationLabel(argv);
+  beginRunTimer(invocationLabel);
+  let exitCode = 1;
   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 hasCommandToken = argv.some((token) => !token.startsWith("-"));
+    if (!hasCommandToken) {
+      exitCode = await runDefaultInvocation(argv, cwd);
+      return exitCode;
     }
-    const message = error instanceof Error ? error.message : String(error);
-    process.stderr.write(`${message}
+    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") {
+          exitCode = 0;
+          return exitCode;
+        }
+        exitCode = error.exitCode;
+        return exitCode;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`${message}
 `);
-    return 1;
+      return 1;
+    }
+    exitCode = actionCode ?? 0;
+    return exitCode;
+  } finally {
+    endRunTimer(exitCode);
   }
-  return actionCode ?? 0;
 }
 async function runDefaultInvocation(argv, cwd) {
   const known = /* @__PURE__ */ new Set(["-u", "--update", "-h", "--help"]);
@@ -177,6 +191,13 @@ function parseInitPreset(value) {
 }
 async function executeCheck(cwd, format, defaultInvocation = false) {
   const foundConfig = await (0, import_api.findConfigPath)(cwd);
+  const storedSnapshots = await loadStoredSnapshots(cwd);
+  if (format !== "status") {
+    writeRunContextHeader(cwd, defaultInvocation ? "check" : `check:${format}`, foundConfig?.path, storedSnapshots);
+    if (shouldShowRunLogs()) {
+      writeSubtleInfo("Analyzing 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"
@@ -194,7 +215,6 @@ async function executeCheck(cwd, format, defaultInvocation = false) {
     }
     throw error;
   }
-  const storedSnapshots = await loadStoredSnapshots(cwd);
   if (storedSnapshots.size === 0) {
     const summary = summarizeSnapshots(currentSnapshots);
     process.stdout.write(
@@ -221,6 +241,7 @@ async function executeCheck(cwd, format, defaultInvocation = false) {
     return 1;
   }
   const changes = compareSnapshotMaps(storedSnapshots, currentSnapshots);
+  const eslintVersionsByGroup = shouldShowRunLogs() ? await resolveGroupEslintVersions(cwd) : /* @__PURE__ */ new Map();
   if (format === "status") {
     if (changes.length === 0) {
       process.stdout.write("clean\n");
@@ -233,6 +254,7 @@ async function executeCheck(cwd, format, defaultInvocation = false) {
   if (format === "diff") {
     if (changes.length === 0) {
       process.stdout.write("Great news: no snapshot changes detected.\n");
+      writeEslintVersionSummary(eslintVersionsByGroup);
       return 0;
     }
     for (const change of changes) {
@@ -242,10 +264,15 @@ async function executeCheck(cwd, format, defaultInvocation = false) {
     writeSubtleInfo(UPDATE_HINT);
     return 1;
   }
-  return printWhatChanged(changes, currentSnapshots);
+  return printWhatChanged(changes, currentSnapshots, eslintVersionsByGroup);
 }
 async function executeUpdate(cwd, printSummary) {
   const foundConfig = await (0, import_api.findConfigPath)(cwd);
+  const storedSnapshots = await loadStoredSnapshots(cwd);
+  writeRunContextHeader(cwd, "update", foundConfig?.path, storedSnapshots);
+  if (shouldShowRunLogs()) {
+    writeSubtleInfo("Analyzing 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"
@@ -266,12 +293,25 @@ async function executeUpdate(cwd, printSummary) {
   await writeSnapshots(cwd, currentSnapshots);
   if (printSummary) {
     const summary = summarizeSnapshots(currentSnapshots);
-    process.stdout.write(`Baseline updated: ${summary.groups} groups, ${summary.rules} rules.
-`);
+    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.
+`
+    );
+    writeEslintVersionSummary(eslintVersionsByGroup);
   }
   return 0;
 }
 async function executePrint(cwd, format) {
+  const foundConfig = await (0, import_api.findConfigPath)(cwd);
+  const storedSnapshots = await loadStoredSnapshots(cwd);
+  writeRunContextHeader(cwd, `print:${format}`, foundConfig?.path, storedSnapshots);
+  if (shouldShowRunLogs()) {
+    writeSubtleInfo("Analyzing current ESLint configuration...\n");
+  }
   const currentSnapshots = await computeCurrentSnapshots(cwd);
   if (format === "short") {
     process.stdout.write(formatShortPrint([...currentSnapshots.values()]));
@@ -286,6 +326,11 @@ async function executePrint(cwd, format) {
 }
 async function executeConfig(cwd, format) {
   const foundConfig = await (0, import_api.findConfigPath)(cwd);
+  const storedSnapshots = await loadStoredSnapshots(cwd);
+  writeRunContextHeader(cwd, `config:${format}`, foundConfig?.path, storedSnapshots);
+  if (shouldShowRunLogs()) {
+    writeSubtleInfo("Resolving effective runtime configuration...\n");
+  }
   const config = await (0, import_api.loadConfig)(cwd);
   const resolved = await resolveWorkspaceAssignments(cwd, config);
   const payload = {
@@ -317,19 +362,20 @@ async function computeCurrentSnapshots(cwd) {
       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));
+      const sampledAbs = sampled.map((sampledRel) => import_node_path.default.resolve(workspaceAbs, sampledRel));
+      const results = await (0, import_api.extractRulesForWorkspaceSamples)(workspaceAbs, sampledAbs);
+      for (const result of results) {
+        if (result.rules) {
+          extractedForGroup.push(result.rules);
           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;
+          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}` : "";
@@ -343,6 +389,9 @@ async function computeCurrentSnapshots(cwd) {
   }
   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 (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: ["**/*"] }]);
@@ -467,8 +516,8 @@ ${JSON.stringify(configObject, null, 2)}
 }
 async function askInitPreferences() {
   const { select } = await import("@inquirer/prompts");
-  const target = await askInitTarget(select);
-  const preset = await askInitPreset(select);
+  const target = await runPromptWithPausedTimer(() => askInitTarget(select));
+  const preset = await runPromptWithPausedTimer(() => askInitPreset(select));
   return { target, preset };
 }
 async function askInitTarget(selectPrompt) {
@@ -491,8 +540,10 @@ async function askInitPreset(selectPrompt) {
   });
 }
 function askQuestion(rl, prompt) {
+  pauseRunTimer();
   return new Promise((resolve) => {
     rl.question(prompt, (answer) => {
+      resumeRunTimer();
       resolve(answer);
     });
   });
@@ -638,11 +689,13 @@ async function askRecommendedGroupAssignments(workspaces) {
     '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 checkbox({
-    message: 'Choose exception workspaces (leave empty to keep all in default "*"):',
-    choices: workspaces.map((workspace) => ({ name: workspace, value: workspace })),
-    pageSize: Math.min(12, Math.max(4, workspaces.length))
-  });
+  const overrides = await runPromptWithPausedTimer(
+    () => checkbox({
+      message: 'Choose exception workspaces (leave empty to keep all in default "*"):',
+      choices: workspaces.map((workspace) => ({ name: workspace, value: workspace })),
+      pageSize: Math.min(12, Math.max(4, workspaces.length))
+    })
+  );
   const assignments = /* @__PURE__ */ new Map();
   let nextGroup = 1;
   for (const workspace of overrides) {
@@ -650,13 +703,15 @@ async function askRecommendedGroupAssignments(workspaces) {
     while (usedGroups.includes(nextGroup)) {
       nextGroup += 1;
     }
-    const selected = await select({
-      message: `Select group for ${workspace}`,
-      choices: [
-        ...usedGroups.map((group) => ({ name: `group-${group}`, value: group })),
-        { name: `create new group (group-${nextGroup})`, value: "new" }
-      ]
-    });
+    const selected = await runPromptWithPausedTimer(
+      () => select({
+        message: `Select group for ${workspace}`,
+        choices: [
+          ...usedGroups.map((group) => ({ name: `group-${group}`, value: group })),
+          { name: `create new group (group-${nextGroup})`, value: "new" }
+        ]
+      })
+    );
     const groupNumber = selected === "new" ? nextGroup : selected;
     assignments.set(workspace, groupNumber);
   }
@@ -699,28 +754,38 @@ function isDirectCliExecution() {
 if (isDirectCliExecution()) {
   void main();
 }
-function printWhatChanged(changes, currentSnapshots) {
+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 status: ${currentSummary.groups} groups, ${currentSummary.rules} rules (severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off).
+      `- 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: ${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)
+    `- 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}
 `));
@@ -735,6 +800,10 @@ function printWhatChanged(changes, currentSnapshots) {
   writeSubtleInfo(UPDATE_HINT);
   return 1;
 }
+function writeSectionTitle(title, color) {
+  process.stdout.write(`${color.bold(title)}
+`);
+}
 function summarizeChanges(changes) {
   let introduced = 0;
   let removed = 0;
@@ -751,22 +820,7 @@ function summarizeChanges(changes) {
   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;
-      }
-    }
-  }
+  const { rules, error, warn, off } = countRuleSeverities([...snapshots.values()].map((snapshot) => snapshot.rules));
   return { groups: snapshots.size, rules, error, warn, off };
 }
 function decorateDiffLine(line, color) {
@@ -796,6 +850,199 @@ 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 "check";
+}
+function shouldShowRunLogs() {
+  if (process.env.ESLINT_CONFIG_SNAPSHOT_NO_PROGRESS === "1") {
+    return false;
+  }
+  return process.stdout.isTTY === true;
+}
+function beginRunTimer(label) {
+  if (!shouldShowRunLogs()) {
+    activeRunTimer = void 0;
+    return;
+  }
+  activeRunTimer = {
+    label,
+    startedAtMs: Date.now(),
+    pausedMs: 0,
+    pauseStartedAtMs: void 0
+  };
+}
+function endRunTimer(exitCode) {
+  if (!activeRunTimer || !shouldShowRunLogs()) {
+    return;
+  }
+  if (activeRunTimer.pauseStartedAtMs !== void 0) {
+    activeRunTimer.pausedMs += Date.now() - activeRunTimer.pauseStartedAtMs;
+    activeRunTimer.pauseStartedAtMs = void 0;
+  }
+  const elapsedMs = Math.max(0, Date.now() - activeRunTimer.startedAtMs - activeRunTimer.pausedMs);
+  const color = createColorizer();
+  const status = exitCode === 0 ? color.green("done") : color.red("failed");
+  const seconds = (elapsedMs / 1e3).toFixed(2);
+  writeSubtleInfo(`Run ${status} 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 scriptPath = process.argv[1];
+  if (!scriptPath) {
+    cachedCliVersion = "unknown";
+    return cachedCliVersion;
+  }
+  let current = import_node_path.default.resolve(import_node_path.default.dirname(scriptPath));
+  while (true) {
+    const packageJsonPath = import_node_path.default.join(current, "package.json");
+    if ((0, import_node_fs.existsSync)(packageJsonPath)) {
+      try {
+        const raw = (0, import_node_fs.readFileSync)(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        cachedCliVersion = parsed.version ?? "unknown";
+        return cachedCliVersion;
+      } catch {
+        break;
+      }
+    }
+    const parent = import_node_path.default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  cachedCliVersion = "unknown";
+  return cachedCliVersion;
+}
+function writeRunContextHeader(cwd, commandLabel, configPath, storedSnapshots) {
+  if (!shouldShowRunLogs()) {
+    return;
+  }
+  const color = createColorizer();
+  process.stdout.write(color.bold(`eslint-config-snapshot v${readCliVersion()}
+`));
+  process.stdout.write(`Command: ${commandLabel}
+`);
+  process.stdout.write(`Repository: ${cwd}
+`);
+  process.stdout.write(`Config: ${formatConfigSource(cwd, configPath)}
+`);
+  process.stdout.write(`Baseline: ${formatStoredSnapshotSummary(storedSnapshots)}
+
+`);
+}
+function formatConfigSource(cwd, configPath) {
+  if (!configPath) {
+    return "built-in defaults";
+  }
+  const rel = (0, import_api.normalizePath)(import_node_path.default.relative(cwd, configPath));
+  if (import_node_path.default.basename(configPath) === "package.json") {
+    return `${rel} (eslint-config-snapshot field)`;
+  }
+  return rel;
+}
+function formatStoredSnapshotSummary(storedSnapshots) {
+  if (storedSnapshots.size === 0) {
+    return "none";
+  }
+  const summary = summarizeStoredSnapshots(storedSnapshots);
+  return `${summary.groups} groups, ${summary.rules} rules (severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off)`;
+}
+async function resolveGroupEslintVersions(cwd) {
+  const config = await (0, import_api.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 = import_node_path.default.resolve(discovery.rootAbs, workspaceRel);
+      versions.add((0, import_api.resolveEslintVersionForWorkspace)(workspaceAbs));
+    }
+    result.set(group.name, [...versions].sort((a, b) => a.localeCompare(b)));
+  }
+  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);
+    }
+  }
+  const sortedAllVersions = [...allVersions].sort((a, b) => a.localeCompare(b));
+  if (sortedAllVersions.length === 1) {
+    process.stdout.write(`- eslint runtime: ${sortedAllVersions[0]} (all groups)
+`);
+    return;
+  }
+  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(", ")}
+`);
+  }
+}
+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;
+      }
+    }
+  }
+  return { rules, error, warn, off };
+}
 function formatShortPrint(snapshots) {
   const lines = [];
   const sorted = [...snapshots].sort((a, b) => a.groupId.localeCompare(b.groupId));