@eslint-config-snapshot/cli 0.4.0 → 0.6.0

package/dist/index.js

@@ -14,44 +14,59 @@ import {
   loadConfig,
   normalizePath,
   readSnapshotFile,
+  resolveEslintVersionForWorkspace,
   sampleWorkspaceFiles,
   writeSnapshotFile
 } from "@eslint-config-snapshot/api";
 import { Command, CommanderError, InvalidArgumentError } from "commander";
 import fg from "fast-glob";
+import { existsSync, readFileSync } from "fs";
 import { access, mkdir, readFile, writeFile } from "fs/promises";
 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);
 }
 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 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 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"]);
@@ -157,6 +172,13 @@ function parseInitPreset(value) {
 }
 async function executeCheck(cwd, format, defaultInvocation = false) {
   const foundConfig = await findConfigPath(cwd);
+  const storedSnapshots = await loadStoredSnapshots(cwd);
+  if (format !== "status") {
+    writeRunContextHeader(cwd, defaultInvocation ? "check" : `check:${format}`, 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"
@@ -174,7 +196,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(
@@ -201,6 +222,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");
@@ -213,6 +235,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) {
@@ -222,10 +245,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 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"
@@ -247,16 +275,24 @@ async function executeUpdate(cwd, printSummary) {
   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.
 `
     );
+    writeEslintVersionSummary(eslintVersionsByGroup);
   }
   return 0;
 }
 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");
+  }
   const currentSnapshots = await computeCurrentSnapshots(cwd);
   if (format === "short") {
     process.stdout.write(formatShortPrint([...currentSnapshots.values()]));
@@ -271,6 +307,11 @@ async function executePrint(cwd, format) {
 }
 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("\u{1F50E} Resolving effective runtime configuration...\n");
+  }
   const config = await loadConfig(cwd);
   const resolved = await resolveWorkspaceAssignments(cwd, config);
   const payload = {
@@ -456,8 +497,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) {
@@ -480,8 +521,10 @@ async function askInitPreset(selectPrompt) {
   });
 }
 function askQuestion(rl, prompt) {
+  pauseRunTimer();
   return new Promise((resolve) => {
     rl.question(prompt, (answer) => {
+      resumeRunTimer();
       resolve(answer);
     });
   });
@@ -627,11 +670,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) {
@@ -639,13 +684,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);
   }
@@ -688,7 +735,7 @@ 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);
@@ -700,6 +747,7 @@ function printWhatChanged(changes, currentSnapshots) {
 - 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"));
@@ -716,6 +764,8 @@ function printWhatChanged(changes, currentSnapshots) {
 
 `
   );
+  writeEslintVersionSummary(eslintVersionsByGroup);
+  process.stdout.write("\n");
   writeSectionTitle("Changes", color);
   for (const change of changes) {
     process.stdout.write(color.bold(`group ${change.groupId}
@@ -751,22 +801,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 +831,203 @@ 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 seconds = (elapsedMs / 1e3).toFixed(2);
+  if (exitCode === 0) {
+    writeSubtleInfo(`${color.green("\u2705")} Finished in ${seconds}s
+`);
+  } else {
+    writeSubtleInfo(`${color.red("\u274C")} Finished 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 = path.resolve(path.dirname(scriptPath));
+  while (true) {
+    const packageJsonPath = path.join(current, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const raw = readFileSync(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        cachedCliVersion = parsed.version ?? "unknown";
+        return cachedCliVersion;
+      } catch {
+        break;
+      }
+    }
+    const parent = path.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(`\u2728 eslint-config-snapshot v${readCliVersion()}
+`));
+  process.stdout.write(`\u{1F9ED} Command: ${commandLabel}
+`);
+  process.stdout.write(`\u{1F4C1} Repository: ${cwd}
+`);
+  process.stdout.write(`\u2699\uFE0F Config source: ${formatConfigSource(cwd, configPath)}
+`);
+  process.stdout.write(`\u{1F5C2}\uFE0F Baseline: ${formatStoredSnapshotSummary(storedSnapshots)}
+
+`);
+}
+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 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 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));
+    }
+    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));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-config-snapshot/cli",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -30,6 +30,6 @@
     "@inquirer/prompts": "^8.2.0",
     "commander": "^14.0.3",
     "fast-glob": "^3.3.3",
-    "@eslint-config-snapshot/api": "0.4.0"
+    "@eslint-config-snapshot/api": "0.6.0"
   }
 }