@eslint-config-snapshot/cli 1.1.1 → 1.3.0

package/src/commands/print.ts

@@ -1,25 +1,29 @@
-import { DEFAULT_CONFIG, findConfigPath, loadConfig, type SnapshotConfig } from '@eslint-config-snapshot/api'
+import { loadConfig } from '@eslint-config-snapshot/api'
 
 import { formatShortConfig, formatShortPrint } from '../formatters.js'
-import { writeRunContextHeader } from '../run-context.js'
-import { computeCurrentSnapshots, loadStoredSnapshots, resolveWorkspaceAssignments, type WorkspaceAssignments } from '../runtime.js'
+import { resolveWorkspaceAssignments, type WorkspaceAssignments } from '../runtime.js'
 import { type TerminalIO } from '../terminal.js'
+import { prepareSnapshotExecution } from './snapshot-executor.js'
 
 export type PrintFormat = 'json' | 'short'
 
-export async function executePrint(cwd: string, terminal: TerminalIO, snapshotDir: string, format: PrintFormat): Promise<void> {
-  const foundConfig = await findConfigPath(cwd)
-  const storedSnapshots = await loadStoredSnapshots(cwd, snapshotDir)
-  writeRunContextHeader(terminal, cwd, `print:${format}`, foundConfig?.path, storedSnapshots)
-  if (terminal.showProgress) {
-    terminal.subtle('🔎 Checking current ESLint configuration...\n')
+export async function executePrint(cwd: string, terminal: TerminalIO, snapshotDir: string, format: PrintFormat): Promise<number> {
+  const prepared = await prepareSnapshotExecution({
+    cwd,
+    snapshotDir,
+    terminal,
+    commandLabel: `print:${format}`,
+    progressMessage: '🔎 Checking current ESLint configuration...\n'
+  })
+  if (!prepared.ok) {
+    return prepared.exitCode
   }
-  const allowWorkspaceExtractionFailure = !foundConfig || isDefaultEquivalentConfig(foundConfig.config)
-  const currentSnapshots = await computeCurrentSnapshots(cwd, { allowWorkspaceExtractionFailure })
+
+  const { currentSnapshots } = prepared
 
   if (format === 'short') {
     terminal.write(formatShortPrint([...currentSnapshots.values()]))
-    return
+    return 0
   }
 
   const output = [...currentSnapshots.values()].map((snapshot) => ({
@@ -27,15 +31,22 @@ export async function executePrint(cwd: string, terminal: TerminalIO, snapshotDi
     rules: snapshot.rules
   }))
   terminal.write(`${JSON.stringify(output, null, 2)}\n`)
+  return 0
 }
 
-export async function executeConfig(cwd: string, terminal: TerminalIO, snapshotDir: string, format: PrintFormat): Promise<void> {
-  const foundConfig = await findConfigPath(cwd)
-  const storedSnapshots = await loadStoredSnapshots(cwd, snapshotDir)
-  writeRunContextHeader(terminal, cwd, `config:${format}`, foundConfig?.path, storedSnapshots)
-  if (terminal.showProgress) {
-    terminal.subtle('⚙️ Resolving effective runtime configuration...\n')
+export async function executeConfig(cwd: string, terminal: TerminalIO, snapshotDir: string, format: PrintFormat): Promise<number> {
+  const prepared = await prepareSnapshotExecution({
+    cwd,
+    snapshotDir,
+    terminal,
+    commandLabel: `config:${format}`,
+    progressMessage: '⚙️ Resolving effective runtime configuration...\n'
+  })
+  if (!prepared.ok) {
+    return prepared.exitCode
   }
+
+  const { foundConfig } = prepared
   const config = await loadConfig(cwd)
   const resolved: WorkspaceAssignments = await resolveWorkspaceAssignments(cwd, config)
   const payload = {
@@ -52,12 +63,9 @@ export async function executeConfig(cwd: string, terminal: TerminalIO, snapshotD
 
   if (format === 'short') {
     terminal.write(formatShortConfig(payload))
-    return
+    return 0
   }
 
   terminal.write(`${JSON.stringify(payload, null, 2)}\n`)
-}
-
-function isDefaultEquivalentConfig(config: SnapshotConfig): boolean {
-  return JSON.stringify(config) === JSON.stringify(DEFAULT_CONFIG)
+  return 0
 }

package/src/commands/skipped-workspaces.ts

@@ -3,6 +3,15 @@ import path from 'node:path'
 import { type SkippedWorkspace } from '../runtime.js'
 import { type TerminalIO } from '../terminal.js'
 
+export function writeDiscoveredWorkspacesSummary(terminal: TerminalIO, workspacesRel: string[]): void {
+  if (workspacesRel.length === 0) {
+    terminal.subtle('Auto-discovered workspaces: none\n')
+    return
+  }
+
+  terminal.subtle(`Auto-discovered workspaces (${workspacesRel.length}): ${workspacesRel.join(', ')}\n`)
+}
+
 export function writeSkippedWorkspaceSummary(
   terminal: TerminalIO,
   cwd: string,

package/src/commands/snapshot-executor.ts

@@ -0,0 +1,97 @@
+import { DEFAULT_CONFIG, findConfigPath, type SnapshotConfig } from '@eslint-config-snapshot/api'
+
+import { writeRunContextHeader } from '../run-context.js'
+import { type BuiltSnapshot, computeCurrentSnapshots, loadStoredSnapshots, type SkippedWorkspace, type StoredSnapshot } from '../runtime.js'
+import { type TerminalIO } from '../terminal.js'
+
+type SnapshotPreparationSuccess = {
+  ok: true
+  foundConfig: Awaited<ReturnType<typeof findConfigPath>>
+  storedSnapshots: Map<string, StoredSnapshot>
+  currentSnapshots: Map<string, BuiltSnapshot>
+  discoveredWorkspaces: string[]
+  skippedWorkspaces: SkippedWorkspace[]
+}
+
+type SnapshotPreparationFailure = {
+  ok: false
+  exitCode: number
+}
+
+export type SnapshotPreparationResult = SnapshotPreparationSuccess | SnapshotPreparationFailure
+
+export async function prepareSnapshotExecution(options: {
+  cwd: string
+  snapshotDir: string
+  terminal: TerminalIO
+  commandLabel: string
+  progressMessage: string
+  showContext?: boolean
+}): Promise<SnapshotPreparationResult> {
+  const { cwd, snapshotDir, terminal, commandLabel, progressMessage, showContext = true } = options
+
+  const foundConfig = await findConfigPath(cwd)
+  const storedSnapshots = await loadStoredSnapshots(cwd, snapshotDir)
+  if (showContext) {
+    writeRunContextHeader(terminal, cwd, commandLabel, foundConfig?.path, storedSnapshots)
+  }
+  if (showContext && terminal.showProgress && progressMessage.length > 0) {
+    terminal.subtle(progressMessage)
+  }
+
+  if (showContext && !foundConfig) {
+    terminal.subtle(
+      'Tip: no explicit config found. Using safe built-in defaults. Run `eslint-config-snapshot init` to customize when needed.\n'
+    )
+  }
+
+  const skippedWorkspaces: SkippedWorkspace[] = []
+  let discoveredWorkspaces: string[] = []
+  const allowWorkspaceExtractionFailure = !foundConfig || isDefaultEquivalentConfig(foundConfig.config)
+
+  let currentSnapshots: Map<string, BuiltSnapshot>
+  try {
+    currentSnapshots = await computeCurrentSnapshots(cwd, {
+      allowWorkspaceExtractionFailure,
+      onWorkspacesDiscovered: (workspacesRel) => {
+        discoveredWorkspaces = workspacesRel
+      },
+      onWorkspaceSkipped: (skipped) => {
+        skippedWorkspaces.push(skipped)
+      }
+    })
+  } catch (error: unknown) {
+    if (allowWorkspaceExtractionFailure && isWorkspaceDiscoveryDefaultsError(error)) {
+      if (showContext) {
+        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 { ok: false, exitCode: 1 }
+    }
+
+    throw error
+  }
+
+  return {
+    ok: true,
+    foundConfig,
+    storedSnapshots,
+    currentSnapshots,
+    discoveredWorkspaces,
+    skippedWorkspaces
+  }
+}
+
+export function isWorkspaceDiscoveryDefaultsError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error)
+  return (
+    message.includes('Unable to discover workspaces') ||
+    message.includes('Unmatched workspaces') ||
+    message.includes('zero-config mode')
+  )
+}
+
+function isDefaultEquivalentConfig(config: SnapshotConfig): boolean {
+  return JSON.stringify(config) === JSON.stringify(DEFAULT_CONFIG)
+}

package/src/commands/update.ts

@@ -1,49 +1,23 @@
-import { DEFAULT_CONFIG, findConfigPath, type SnapshotConfig } from '@eslint-config-snapshot/api'
-
 import { countUniqueWorkspaces, formatBaselineSummaryLines, summarizeSnapshots } from '../formatters.js'
-import { writeEslintVersionSummary, writeRunContextHeader } from '../run-context.js'
-import { computeCurrentSnapshots, loadStoredSnapshots, resolveGroupEslintVersions, type SkippedWorkspace, writeSnapshots } from '../runtime.js'
+import { writeEslintVersionSummary } from '../run-context.js'
+import { resolveGroupEslintVersions, writeSnapshots } from '../runtime.js'
 import { type TerminalIO } from '../terminal.js'
-import { writeSkippedWorkspaceSummary } from './skipped-workspaces.js'
+import { writeDiscoveredWorkspacesSummary, writeSkippedWorkspaceSummary } from './skipped-workspaces.js'
+import { prepareSnapshotExecution } from './snapshot-executor.js'
 
 export async function executeUpdate(cwd: string, terminal: TerminalIO, snapshotDir: string, printSummary: boolean): Promise<number> {
-  const foundConfig = await findConfigPath(cwd)
-  const storedSnapshots = await loadStoredSnapshots(cwd, snapshotDir)
-  writeRunContextHeader(terminal, cwd, 'update', foundConfig?.path, storedSnapshots)
-  if (terminal.showProgress) {
-    terminal.subtle('🔎 Checking current ESLint configuration...\n')
+  const prepared = await prepareSnapshotExecution({
+    cwd,
+    snapshotDir,
+    terminal,
+    commandLabel: 'update',
+    progressMessage: '🔎 Checking current ESLint configuration...\n'
+  })
+  if (prepared.ok === false) {
+    return prepared.exitCode
   }
 
-  if (!foundConfig) {
-    terminal.subtle(
-      'Tip: no explicit config found. Using safe built-in defaults. Run `eslint-config-snapshot init` to customize when needed.\n'
-    )
-  }
-
-  let currentSnapshots
-  const skippedWorkspaces: SkippedWorkspace[] = []
-  let discoveredWorkspaces: string[] = []
-  const allowWorkspaceExtractionFailure = !foundConfig || isDefaultEquivalentConfig(foundConfig.config)
-  try {
-    currentSnapshots = await computeCurrentSnapshots(cwd, {
-      allowWorkspaceExtractionFailure,
-      onWorkspacesDiscovered: (workspacesRel) => {
-        discoveredWorkspaces = workspacesRel
-      },
-      onWorkspaceSkipped: (skipped) => {
-        skippedWorkspaces.push(skipped)
-      }
-    })
-  } catch (error: unknown) {
-    if (!foundConfig && isWorkspaceDiscoveryDefaultsError(error)) {
-      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
-  }
+  const { foundConfig, storedSnapshots, currentSnapshots, discoveredWorkspaces, skippedWorkspaces } = prepared
   if (!foundConfig) {
     writeDiscoveredWorkspacesSummary(terminal, discoveredWorkspaces)
   }
@@ -63,25 +37,3 @@ export async function executeUpdate(cwd: string, terminal: TerminalIO, snapshotD
 
   return 0
 }
-
-function isWorkspaceDiscoveryDefaultsError(error: unknown): boolean {
-  const message = error instanceof Error ? error.message : String(error)
-  return (
-    message.includes('Unable to discover workspaces') ||
-    message.includes('Unmatched workspaces') ||
-    message.includes('zero-config mode')
-  )
-}
-
-function isDefaultEquivalentConfig(config: SnapshotConfig): boolean {
-  return JSON.stringify(config) === JSON.stringify(DEFAULT_CONFIG)
-}
-
-function writeDiscoveredWorkspacesSummary(terminal: TerminalIO, workspacesRel: string[]): void {
-  if (workspacesRel.length === 0) {
-    terminal.subtle('Auto-discovered workspaces: none\n')
-    return
-  }
-
-  terminal.subtle(`Auto-discovered workspaces (${workspacesRel.length}): ${workspacesRel.join(', ')}\n`)
-}

package/src/formatters.ts

@@ -8,6 +8,32 @@ export type SnapshotLike = {
   workspaces: string[]
   rules: RuleObject
 }
+export type RuleCatalogLike = {
+  groupId: string
+  availableRules: string[]
+  coreRules: string[]
+  pluginRulesByPrefix: Record<string, string[]>
+  observedRules: string[]
+  missingRules: string[]
+  observedOffRules: string[]
+  observedActiveRules: string[]
+  totalStats: UsageStats & { observedOutsideCatalog: number }
+  coreStats: UsageStats
+  pluginStats: Array<{ pluginId: string } & UsageStats>
+}
+
+export type UsageStats = {
+  totalAvailable: number
+  inUse: number
+  active: number
+  inactive: number
+  error: number
+  warn: number
+  off: number
+  missing: number
+  inUsePct: number
+  activePctOfInUse: number
+}
 
 export function formatDiff(groupId: string, diff: SnapshotDiff): string {
   const lines = [`group: ${groupId}`]
@@ -110,40 +136,60 @@ export function formatShortPrint(snapshots: SnapshotLike[]): string {
   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 }
+    appendShortSnapshotSection(lines, snapshot)
+  }
 
-    for (const name of ruleNames) {
-      const severity = getPrimarySeverity(snapshot.rules[name])
-      if (severity) {
-        severityCounts[severity] += 1
-      }
+  return `${lines.join('\n')}\n`
+}
+
+function appendShortSnapshotSection(lines: string[], snapshot: SnapshotLike): void {
+  const ruleNames = Object.keys(snapshot.rules).sort()
+  const severityCounts = countRuleNameSeverities(ruleNames, snapshot.rules)
+  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 line = formatShortRuleLine(ruleName, snapshot.rules[ruleName])
+    if (line) {
+      lines.push(line)
     }
+  }
+}
 
-    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}`
-    )
+function countRuleNameSeverities(
+  ruleNames: string[],
+  rules: RuleObject
+): {
+  error: number
+  warn: number
+  off: number
+} {
+  const counts = { error: 0, warn: 0, off: 0 }
+  for (const name of ruleNames) {
+    const severity = getPrimarySeverity(rules[name])
+    if (severity) {
+      counts[severity] += 1
+    }
+  }
+  return counts
+}
 
-    for (const ruleName of ruleNames) {
-      const entry = snapshot.rules[ruleName]
-      if (!entry) {
-        continue
-      }
-      if (!Array.isArray(entry[0])) {
-        const singleEntry = entry as RuleEntry
-        const suffix = singleEntry.length > 1 ? ` ${JSON.stringify(singleEntry[1])}` : ''
-        lines.push(`${ruleName}: ${singleEntry[0]}${suffix}`)
-        continue
-      }
+function formatShortRuleLine(ruleName: string, entry: SnapshotRuleEntry | undefined): string | undefined {
+  if (!entry) {
+    return undefined
+  }
 
-      const variants = entry as RuleEntry[]
-      lines.push(`${ruleName}: ${JSON.stringify(variants)}`)
-    }
+  if (!Array.isArray(entry[0])) {
+    const singleEntry = entry as RuleEntry
+    const suffix = singleEntry.length > 1 ? ` ${JSON.stringify(singleEntry[1])}` : ''
+    return `${ruleName}: ${singleEntry[0]}${suffix}`
   }
 
-  return `${lines.join('\n')}\n`
+  const variants = entry as RuleEntry[]
+  return `${ruleName}: ${JSON.stringify(variants)}`
 }
 
 export function formatShortConfig(payload: {
@@ -165,6 +211,42 @@ export function formatShortConfig(payload: {
   return `${lines.join('\n')}\n`
 }
 
+export function formatShortCatalog(catalogs: RuleCatalogLike[], missingOnly: boolean): string {
+  const lines: string[] = []
+  const sorted = [...catalogs].sort((a, b) => a.groupId.localeCompare(b.groupId))
+  const showGroupHeader = sorted.length > 1 || sorted.some((catalog) => catalog.groupId !== 'default')
+  for (const catalog of sorted) {
+    if (showGroupHeader) {
+      lines.push(`🧭 group: ${catalog.groupId}`)
+    }
+    lines.push(
+      `📦 total: ${formatUsageLine(catalog.totalStats)} | outside catalog observed: ${catalog.totalStats.observedOutsideCatalog}`,
+      `🧱 core: ${formatUsageLine(catalog.coreStats)}`,
+      `🔌 plugins tracked: ${catalog.pluginStats.length}`
+    )
+    for (const plugin of catalog.pluginStats) {
+      lines.push(`  - ${plugin.pluginId}: ${formatUsageLine(plugin)}`)
+    }
+
+    const detailRules = missingOnly ? catalog.missingRules : catalog.availableRules
+    lines.push(`${missingOnly ? '🕳️ missing list' : '📚 available list'} (${detailRules.length}):`)
+    for (const ruleName of detailRules) {
+      lines.push(`  - ${ruleName}`)
+    }
+    if (showGroupHeader) {
+      lines.push('')
+    }
+  }
+  if (showGroupHeader && lines.at(-1) === '') {
+    lines.pop()
+  }
+  return `${lines.join('\n')}\n`
+}
+
+function formatUsageLine(stats: UsageStats): string {
+  return `${stats.inUse}/${stats.totalAvailable} in use (${stats.inUsePct}%) | error ${stats.error} | warn ${stats.warn} | off ${stats.off} | not used ${stats.missing}`
+}
+
 export function formatCommandDisplayLabel(commandLabel: string): string {
   switch (commandLabel) {
     case 'check':
@@ -192,6 +274,12 @@ export function formatCommandDisplayLabel(commandLabel: string): string {
     case 'config:short': {
       return 'Show effective runtime config (short view)'
     }
+    case 'catalog:json': {
+      return 'Show discovered rule catalog (JSON)'
+    }
+    case 'catalog:short': {
+      return 'Show discovered rule catalog (short view)'
+    }
     case 'init': {
       return 'Initialize local configuration'
     }

package/src/index.ts

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
+import { loadConfig } from '@eslint-config-snapshot/api'
 import { Command, CommanderError, InvalidArgumentError } from 'commander'
 import createDebug from 'debug'
 import path from 'node:path'
 
+import { type CatalogFormat, executeCatalog, executeCatalogCheck, executeCatalogUpdate } from './commands/catalog.js'
 import { type CheckFormat, executeCheck } from './commands/check.js'
 import { executeConfig, executePrint, type PrintFormat } from './commands/print.js'
 import { executeUpdate } from './commands/update.js'
@@ -79,7 +81,7 @@ async function runArgv(argv: string[], cwd: string): Promise<number> {
 }
 
 async function runDefaultInvocation(argv: string[], cwd: string, terminal: TerminalIO): Promise<number> {
-  const known = new Set(['-u', '--update', '-h', '--help'])
+  const known = new Set(['-u', '--update', '-h', '--help', '--experimental-with-catalog'])
   for (const token of argv) {
     if (!known.has(token)) {
       terminal.error(`error: unknown option '${token}'\n`)
@@ -96,10 +98,22 @@ async function runDefaultInvocation(argv: string[], cwd: string, terminal: Termi
   }
 
   if (argv.includes('-u') || argv.includes('--update')) {
-    return executeUpdate(cwd, terminal, SNAPSHOT_DIR, true)
+    const updateCode = await executeUpdate(cwd, terminal, SNAPSHOT_DIR, true)
+    const withCatalog = argv.includes('--experimental-with-catalog') || (await isCatalogHookEnabled(cwd))
+    if (!withCatalog) {
+      return updateCode
+    }
+    const catalogCode = await executeCatalogUpdate(cwd, terminal, SNAPSHOT_DIR)
+    return updateCode !== 0 || catalogCode !== 0 ? 1 : 0
   }
 
-  return executeCheck(cwd, 'summary', terminal, SNAPSHOT_DIR, true)
+  const checkCode = await executeCheck(cwd, 'summary', terminal, SNAPSHOT_DIR, true)
+  const withCatalog = argv.includes('--experimental-with-catalog') || (await isCatalogHookEnabled(cwd))
+  if (!withCatalog) {
+    return checkCode
+  }
+  const catalogCode = await executeCatalogCheck(cwd, terminal, SNAPSHOT_DIR)
+  return checkCode !== 0 || catalogCode !== 0 ? 1 : 0
 }
 
 function createProgram(cwd: string, terminal: TerminalIO, onActionExit: (code: number) => void): Command {
@@ -122,16 +136,34 @@ function createProgram(cwd: string, terminal: TerminalIO, onActionExit: (code: n
     .command('check')
     .description('Compare current state against stored snapshots')
     .option('--format <format>', 'Output format: summary|status|diff', parseCheckFormat, 'summary')
-    .action(async (opts: { format: CheckFormat }) => {
-      onActionExit(await executeCheck(cwd, opts.format, terminal, SNAPSHOT_DIR))
+    .option('--experimental-with-catalog', 'Also run catalog baseline check after regular check')
+    .action(async (opts: { format: CheckFormat; experimentalWithCatalog?: boolean }) => {
+      const checkCode = await executeCheck(cwd, opts.format, terminal, SNAPSHOT_DIR)
+      const withCatalog = opts.experimentalWithCatalog === true || (await isCatalogHookEnabled(cwd))
+      if (!withCatalog) {
+        onActionExit(checkCode)
+        return
+      }
+
+      const catalogCode = await executeCatalogCheck(cwd, terminal, SNAPSHOT_DIR)
+      onActionExit(checkCode !== 0 || catalogCode !== 0 ? 1 : 0)
     })
 
   program
     .command('update')
     .alias('snapshot')
     .description('Compute and write snapshots to .eslint-config-snapshot/')
-    .action(async () => {
-      onActionExit(await executeUpdate(cwd, terminal, SNAPSHOT_DIR, true))
+    .option('--experimental-with-catalog', 'Also update catalog baseline after regular update')
+    .action(async (opts: { experimentalWithCatalog?: boolean }) => {
+      const updateCode = await executeUpdate(cwd, terminal, SNAPSHOT_DIR, true)
+      const withCatalog = opts.experimentalWithCatalog === true || (await isCatalogHookEnabled(cwd))
+      if (!withCatalog) {
+        onActionExit(updateCode)
+        return
+      }
+
+      const catalogCode = await executeCatalogUpdate(cwd, terminal, SNAPSHOT_DIR)
+      onActionExit(updateCode !== 0 || catalogCode !== 0 ? 1 : 0)
     })
 
   program
@@ -141,8 +173,32 @@ function createProgram(cwd: string, terminal: TerminalIO, onActionExit: (code: n
     .option('--short', 'Alias for --format short')
     .action(async (opts: { format: PrintFormat; short?: boolean }) => {
       const format: PrintFormat = opts.short ? 'short' : opts.format
-      await executePrint(cwd, terminal, SNAPSHOT_DIR, format)
-      onActionExit(0)
+      onActionExit(await executePrint(cwd, terminal, SNAPSHOT_DIR, format))
+    })
+
+  program
+    .command('catalog')
+    .description('Print discovered rule catalog and missing rules')
+    .option('--format <format>', 'Output format: json|short', parsePrintFormat, 'json')
+    .option('--short', 'Alias for --format short')
+    .option('--missing', 'Only print rules that are available but not observed in current snapshots')
+    .action(async (opts: { format: CatalogFormat; short?: boolean; missing?: boolean }) => {
+      const format: CatalogFormat = opts.short ? 'short' : opts.format
+      onActionExit(await executeCatalog(cwd, terminal, SNAPSHOT_DIR, format, Boolean(opts.missing)))
+    })
+
+  program
+    .command('catalog-check')
+    .description('Compare current catalog against stored catalog baseline')
+    .action(async () => {
+      onActionExit(await executeCatalogCheck(cwd, terminal, SNAPSHOT_DIR))
+    })
+
+  program
+    .command('catalog-update')
+    .description('Compute and write catalog baselines to .eslint-config-snapshot/')
+    .action(async () => {
+      onActionExit(await executeCatalogUpdate(cwd, terminal, SNAPSHOT_DIR))
     })
 
   program
@@ -152,8 +208,7 @@ function createProgram(cwd: string, terminal: TerminalIO, onActionExit: (code: n
     .option('--short', 'Alias for --format short')
     .action(async (opts: { format: PrintFormat; short?: boolean }) => {
       const format: PrintFormat = opts.short ? 'short' : opts.format
-      await executeConfig(cwd, terminal, SNAPSHOT_DIR, format)
-      onActionExit(0)
+      onActionExit(await executeConfig(cwd, terminal, SNAPSHOT_DIR, format))
     })
 
   program
@@ -247,6 +302,11 @@ function parseInitPreset(value: string): InitPreset {
   throw new InvalidArgumentError('Expected one of: recommended, minimal, full')
 }
 
+async function isCatalogHookEnabled(cwd: string): Promise<boolean> {
+  const config = await loadConfig(cwd)
+  return config.experimentalWithCatalog === true
+}
+
 export async function main(): Promise<void> {
   const code = await runArgv(process.argv.slice(2), process.cwd())
   process.exitCode = code