@eslint-config-snapshot/cli 0.3.2 → 0.5.0

package/src/index.ts

@@ -5,18 +5,20 @@ import {
   buildSnapshot,
   diffSnapshots,
   discoverWorkspaces,
-  extractRulesFromPrintConfig,
+  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 { existsSync, readFileSync } from 'node:fs'
 import { access, mkdir, readFile, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import { createInterface } from 'node:readline'
@@ -32,44 +34,69 @@ type CheckFormat = 'summary' | 'status' | 'diff'
 type PrintFormat = 'json' | 'short'
 type InitTarget = 'file' | 'package-json'
 type InitPreset = 'recommended' | 'minimal' | 'full'
+type RuleEntry = [severity: 'off' | 'warn' | 'error'] | [severity: 'off' | 'warn' | 'error', options: unknown]
+type RuleObject = Record<string, RuleEntry>
+type GroupEslintVersions = Map<string, string[]>
 
 type RootOptions = {
   update?: boolean
 }
 
+type RunTimer = {
+  label: string
+  startedAtMs: number
+  pausedMs: number
+  pauseStartedAtMs: number | undefined
+}
+
+let activeRunTimer: RunTimer | undefined
+let cachedCliVersion: string | undefined
+
 export async function runCli(command: string | undefined, cwd: string, flags: string[] = []): Promise<number> {
   const argv = command ? [command, ...flags] : [...flags]
   return runArgv(argv, cwd)
 }
 
 async function runArgv(argv: string[], cwd: string): Promise<number> {
-  const hasCommandToken = argv.some((token) => !token.startsWith('-'))
-  if (!hasCommandToken) {
-    return runDefaultInvocation(argv, cwd)
-  }
+  const invocationLabel = resolveInvocationLabel(argv)
+  beginRunTimer(invocationLabel)
+  let exitCode = 1
+
+  try {
+    const hasCommandToken = argv.some((token) => !token.startsWith('-'))
+    if (!hasCommandToken) {
+      exitCode = await runDefaultInvocation(argv, cwd)
+      return exitCode
+    }
 
-  let actionCode: number | undefined
+    let actionCode: number | undefined
 
-  const program = createProgram(cwd, (code) => {
-    actionCode = code
-  })
+    const program = createProgram(cwd, (code) => {
+      actionCode = code
+    })
 
-  try {
-    await program.parseAsync(argv, { from: 'user' })
-  } catch (error: unknown) {
-    if (error instanceof CommanderError) {
-      if (error.code === 'commander.helpDisplayed') {
-        return 0
+    try {
+      await program.parseAsync(argv, { from: 'user' })
+    } catch (error: unknown) {
+      if (error instanceof CommanderError) {
+        if (error.code === 'commander.helpDisplayed') {
+          exitCode = 0
+          return exitCode
+        }
+        exitCode = error.exitCode
+        return exitCode
       }
-      return error.exitCode
+
+      const message = error instanceof Error ? error.message : String(error)
+      process.stderr.write(`${message}\n`)
+      return 1
     }
 
-    const message = error instanceof Error ? error.message : String(error)
-    process.stderr.write(`${message}\n`)
-    return 1
+    exitCode = actionCode ?? 0
+    return exitCode
+  } finally {
+    endRunTimer(exitCode)
   }
-
-  return actionCode ?? 0
 }
 
 async function runDefaultInvocation(argv: string[], cwd: string): Promise<number> {
@@ -238,6 +265,15 @@ function parseInitPreset(value: string): InitPreset {
 
 async function executeCheck(cwd: string, format: CheckFormat, defaultInvocation = false): Promise<number> {
   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('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'
@@ -257,8 +293,6 @@ async function executeCheck(cwd: string, format: CheckFormat, defaultInvocation
 
     throw error
   }
-  const storedSnapshots = await loadStoredSnapshots(cwd)
-
   if (storedSnapshots.size === 0) {
     const summary = summarizeSnapshots(currentSnapshots)
     process.stdout.write(
@@ -286,6 +320,7 @@ async function executeCheck(cwd: string, format: CheckFormat, defaultInvocation
   }
 
   const changes = compareSnapshotMaps(storedSnapshots, currentSnapshots)
+  const eslintVersionsByGroup = shouldShowRunLogs() ? await resolveGroupEslintVersions(cwd) : new Map<string, string[]>()
 
   if (format === 'status') {
     if (changes.length === 0) {
@@ -301,6 +336,7 @@ async function executeCheck(cwd: string, format: CheckFormat, defaultInvocation
   if (format === 'diff') {
     if (changes.length === 0) {
       process.stdout.write('Great news: no snapshot changes detected.\n')
+      writeEslintVersionSummary(eslintVersionsByGroup)
       return 0
     }
 
@@ -312,11 +348,17 @@ async function executeCheck(cwd: string, format: CheckFormat, defaultInvocation
     return 1
   }
 
-  return printWhatChanged(changes, currentSnapshots)
+  return printWhatChanged(changes, currentSnapshots, eslintVersionsByGroup)
 }
 
 async function executeUpdate(cwd: string, printSummary: boolean): Promise<number> {
   const foundConfig = await 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'
@@ -340,13 +382,25 @@ async function executeUpdate(cwd: string, printSummary: boolean): Promise<number
 
   if (printSummary) {
     const summary = summarizeSnapshots(currentSnapshots)
-    process.stdout.write(`Baseline updated: ${summary.groups} groups, ${summary.rules} rules.\n`)
+    const color = createColorizer()
+    const eslintVersionsByGroup = shouldShowRunLogs() ? await resolveGroupEslintVersions(cwd) : new Map<string, string[]>()
+    writeSectionTitle('Summary', color)
+    process.stdout.write(
+      `Baseline updated: ${summary.groups} groups, ${summary.rules} rules.\nSeverity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off.\n`
+    )
+    writeEslintVersionSummary(eslintVersionsByGroup)
   }
 
   return 0
 }
 
 async function executePrint(cwd: string, format: PrintFormat): Promise<void> {
+  const foundConfig = await 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') {
@@ -363,6 +417,11 @@ async function executePrint(cwd: string, format: PrintFormat): Promise<void> {
 
 async function executeConfig(cwd: string, format: PrintFormat): Promise<void> {
   const foundConfig = await 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 loadConfig(cwd)
   const resolved = await resolveWorkspaceAssignments(cwd, config)
   const payload = {
@@ -400,23 +459,23 @@ async function computeCurrentSnapshots(cwd: string): Promise<Map<string, BuiltSn
       let extractedCount = 0
       let lastExtractionError: string | undefined
 
-      for (const sampledRel of sampled) {
-        const sampledAbs = path.resolve(workspaceAbs, sampledRel)
-        try {
-          extractedForGroup.push(extractRulesFromPrintConfig(workspaceAbs, sampledAbs))
+      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
-        } catch (error: unknown) {
-          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) {
@@ -434,6 +493,15 @@ async function computeCurrentSnapshots(cwd: string): Promise<Map<string, BuiltSn
   return snapshots
 }
 
+function isRecoverableExtractionError(message: string): boolean {
+  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: string, config: Awaited<ReturnType<typeof loadConfig>>) {
   const discovery = await discoverWorkspaces({ cwd, workspaceInput: config.workspaceInput })
 
@@ -594,8 +662,8 @@ async function runInit(
 
 async function askInitPreferences(): Promise<{ target: InitTarget; preset: InitPreset }> {
   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 }
 }
 
@@ -625,8 +693,10 @@ async function askInitPreset(
 }
 
 function askQuestion(rl: ReturnType<typeof createInterface>, prompt: string): Promise<string> {
+  pauseRunTimer()
   return new Promise((resolve) => {
     rl.question(prompt, (answer) => {
+      resumeRunTimer()
       resolve(answer)
     })
   })
@@ -802,11 +872,13 @@ async function askRecommendedGroupAssignments(workspaces: string[]): Promise<Map
     '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<string>({
-    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<string>({
+      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 = new Map<string, number>()
   let nextGroup = 1
@@ -816,13 +888,15 @@ async function askRecommendedGroupAssignments(workspaces: string[]): Promise<Map
       nextGroup += 1
     }
 
-    const selected = await select<number | 'new'>({
-      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<number | 'new'>({
+        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)
   }
@@ -873,27 +947,34 @@ if (isDirectCliExecution()) {
   void main()
 }
 
-function printWhatChanged(changes: Array<{ groupId: string; diff: SnapshotDiff }>, currentSnapshots: Map<string, BuiltSnapshot>): number {
+function printWhatChanged(
+  changes: Array<{ groupId: string; diff: SnapshotDiff }>,
+  currentSnapshots: Map<string, BuiltSnapshot>,
+  eslintVersionsByGroup: GroupEslintVersions
+): number {
   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).\n`
+      `- baseline: ${currentSummary.groups} groups, ${currentSummary.rules} rules\n- severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off\n`
     )
+    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}\n`
-  )
-  process.stdout.write(
-    `Current rules: ${currentSummary.rules} (severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off)\n\n`
+    `- changed groups: ${changes.length}\n- introduced rules: ${changeSummary.introduced}\n- removed rules: ${changeSummary.removed}\n- severity changes: ${changeSummary.severity}\n- options changes: ${changeSummary.options}\n- workspace membership changes: ${changeSummary.workspace}\n- current baseline: ${currentSummary.groups} groups, ${currentSummary.rules} rules\n- current severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off\n\n`
   )
+  writeEslintVersionSummary(eslintVersionsByGroup)
+  process.stdout.write('\n')
 
+  writeSectionTitle('Changes', color)
   for (const change of changes) {
     process.stdout.write(color.bold(`group ${change.groupId}\n`))
     const lines = formatDiff(change.groupId, change.diff).split('\n').slice(1)
@@ -908,6 +989,10 @@ function printWhatChanged(changes: Array<{ groupId: string; diff: SnapshotDiff }
   return 1
 }
 
+function writeSectionTitle(title: string, color: ReturnType<typeof createColorizer>): void {
+  process.stdout.write(`${color.bold(title)}\n`)
+}
+
 function summarizeChanges(changes: Array<{ groupId: string; diff: SnapshotDiff }>) {
   let introduced = 0
   let removed = 0
@@ -925,22 +1010,7 @@ function summarizeChanges(changes: Array<{ groupId: string; diff: SnapshotDiff }
 }
 
 function summarizeSnapshots(snapshots: Map<string, BuiltSnapshot>) {
-  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 }
 }
 
@@ -974,11 +1044,234 @@ function writeSubtleInfo(text: string): void {
   process.stdout.write(color.dim(text))
 }
 
+function resolveInvocationLabel(argv: string[]): string {
+  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(): boolean {
+  if (process.env.ESLINT_CONFIG_SNAPSHOT_NO_PROGRESS === '1') {
+    return false
+  }
+  return process.stdout.isTTY === true
+}
+
+function beginRunTimer(label: string): void {
+  if (!shouldShowRunLogs()) {
+    activeRunTimer = undefined
+    return
+  }
+
+  activeRunTimer = {
+    label,
+    startedAtMs: Date.now(),
+    pausedMs: 0,
+    pauseStartedAtMs: undefined
+  }
+}
+
+function endRunTimer(exitCode: number): void {
+  if (!activeRunTimer || !shouldShowRunLogs()) {
+    return
+  }
+
+  if (activeRunTimer.pauseStartedAtMs !== undefined) {
+    activeRunTimer.pausedMs += Date.now() - activeRunTimer.pauseStartedAtMs
+    activeRunTimer.pauseStartedAtMs = undefined
+  }
+
+  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 / 1000).toFixed(2)
+  writeSubtleInfo(`Run ${status} in ${seconds}s\n`)
+  activeRunTimer = undefined
+}
+
+function pauseRunTimer(): void {
+  if (!activeRunTimer || activeRunTimer.pauseStartedAtMs !== undefined) {
+    return
+  }
+  activeRunTimer.pauseStartedAtMs = Date.now()
+}
+
+function resumeRunTimer(): void {
+  if (!activeRunTimer || activeRunTimer.pauseStartedAtMs === undefined) {
+    return
+  }
+
+  activeRunTimer.pausedMs += Date.now() - activeRunTimer.pauseStartedAtMs
+  activeRunTimer.pauseStartedAtMs = undefined
+}
+
+async function runPromptWithPausedTimer<T>(prompt: () => Promise<T>): Promise<T> {
+  pauseRunTimer()
+  try {
+    return await prompt()
+  } finally {
+    resumeRunTimer()
+  }
+}
+
+function readCliVersion(): string {
+  if (cachedCliVersion !== undefined) {
+    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) as { version?: string }
+        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: string,
+  commandLabel: string,
+  configPath: string | undefined,
+  storedSnapshots: Map<string, StoredSnapshot>
+): void {
+  if (!shouldShowRunLogs()) {
+    return
+  }
+
+  const color = createColorizer()
+  process.stdout.write(color.bold(`eslint-config-snapshot v${readCliVersion()}\n`))
+  process.stdout.write(`Command: ${commandLabel}\n`)
+  process.stdout.write(`Repository: ${cwd}\n`)
+  process.stdout.write(`Config: ${formatConfigSource(cwd, configPath)}\n`)
+  process.stdout.write(`Baseline: ${formatStoredSnapshotSummary(storedSnapshots)}\n\n`)
+}
+
+function formatConfigSource(cwd: string, configPath: string | undefined): string {
+  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: Map<string, StoredSnapshot>): string {
+  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: string): Promise<GroupEslintVersions> {
+  const config = await loadConfig(cwd)
+  const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config)
+  const result = new Map<string, string[]>()
+
+  for (const group of assignments) {
+    const versions = new Set<string>()
+    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: GroupEslintVersions): void {
+  if (!shouldShowRunLogs() || eslintVersionsByGroup.size === 0) {
+    return
+  }
+
+  const allVersions = new Set<string>()
+  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)\n`)
+    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(', ')}\n`)
+  }
+}
+
+function summarizeStoredSnapshots(snapshots: Map<string, StoredSnapshot>) {
+  const { rules, error, warn, off } = countRuleSeverities([...snapshots.values()].map((snapshot) => snapshot.rules))
+  return { groups: snapshots.size, rules, error, warn, off }
+}
+
+function countRuleSeverities(ruleObjects: RuleObject[]) {
+  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: Array<{
     groupId: string
     workspaces: string[]
-    rules: Record<string, [severity: 'off' | 'warn' | 'error'] | [severity: 'off' | 'warn' | 'error', options: unknown]>
+    rules: RuleObject
   }>
 ): string {
   const lines: string[] = []

package/test/cli.integration.test.ts

@@ -8,8 +8,11 @@ import { buildRecommendedConfigFromAssignments, runCli } from '../src/index.js'
 const fixtureTemplateRoot = path.resolve('test/fixtures/repo')
 let tmpDir = ''
 let fixtureRoot = ''
+let previousNoProgress = ''
 
 beforeEach(async () => {
+  previousNoProgress = process.env.ESLINT_CONFIG_SNAPSHOT_NO_PROGRESS ?? ''
+  process.env.ESLINT_CONFIG_SNAPSHOT_NO_PROGRESS = '1'
   tmpDir = await mkdtemp(path.join(os.tmpdir(), 'snapshot-cli-integration-'))
   fixtureRoot = path.join(tmpDir, 'repo')
   await cp(fixtureTemplateRoot, fixtureRoot, { recursive: true })
@@ -37,6 +40,11 @@ beforeEach(async () => {
 })
 
 afterEach(async () => {
+  if (previousNoProgress === '') {
+    delete process.env.ESLINT_CONFIG_SNAPSHOT_NO_PROGRESS
+  } else {
+    process.env.ESLINT_CONFIG_SNAPSHOT_NO_PROGRESS = previousNoProgress
+  }
   if (tmpDir) {
     await rm(tmpDir, { recursive: true, force: true })
     tmpDir = ''