@eslint-config-snapshot/cli 1.2.0 → 1.3.1

package/src/runtime.ts

@@ -3,6 +3,7 @@ import {
   assignGroupsByMatch,
   buildSnapshot,
   diffSnapshots,
+  discoverWorkspaceRuleCatalog,
   discoverWorkspaces,
   extractRulesForWorkspaceSamples,
   type GroupAssignment,
@@ -32,11 +33,22 @@ export type WorkspaceAssignments = {
   discovery: WorkspaceDiscovery
   assignments: GroupAssignment[]
 }
+export type GroupRuleCatalog = {
+  coreRules: string[]
+  pluginRulesByPrefix: Record<string, string[]>
+  allRules: string[]
+}
+export type GroupRuleCatalogs = Map<string, GroupRuleCatalog>
 export type SkippedWorkspace = {
   groupId: string
   workspaceRel: string
   reason: string
 }
+type SnapshotComputationOptions = {
+  allowWorkspaceExtractionFailure: boolean
+  onWorkspacesDiscovered?: (workspacesRel: string[]) => void
+  onWorkspaceSkipped?: (skipped: SkippedWorkspace) => void
+}
 
 export async function computeCurrentSnapshots(
   cwd: string,
@@ -46,9 +58,11 @@ export async function computeCurrentSnapshots(
     onWorkspaceSkipped?: (skipped: SkippedWorkspace) => void
   }
 ): Promise<Map<string, BuiltSnapshot>> {
-  const allowWorkspaceExtractionFailure = options?.allowWorkspaceExtractionFailure ?? false
-  const onWorkspacesDiscovered = options?.onWorkspacesDiscovered
-  const onWorkspaceSkipped = options?.onWorkspaceSkipped
+  const resolvedOptions: SnapshotComputationOptions = {
+    allowWorkspaceExtractionFailure: options?.allowWorkspaceExtractionFailure ?? false,
+    onWorkspacesDiscovered: options?.onWorkspacesDiscovered,
+    onWorkspaceSkipped: options?.onWorkspaceSkipped
+  }
   const computeStartedAt = Date.now()
   const configStartedAt = Date.now()
   const config = await loadConfig(cwd)
@@ -56,113 +70,171 @@ export async function computeCurrentSnapshots(
 
   const assignmentStartedAt = Date.now()
   const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config)
-  onWorkspacesDiscovered?.(discovery.workspacesRel)
+  resolvedOptions.onWorkspacesDiscovered?.(discovery.workspacesRel)
   debugTiming('phase=resolveWorkspaceAssignments elapsedMs=%d', Date.now() - assignmentStartedAt)
   debugWorkspace('root=%s groups=%d workspaces=%d', discovery.rootAbs, assignments.length, discovery.workspacesRel.length)
 
   const snapshots = new Map<string, BuiltSnapshot>()
 
   for (const group of assignments) {
-    const groupStartedAt = Date.now()
-    const extractedForGroup = []
-    const extractedWorkspaces: string[] = []
-    debugWorkspace('group=%s workspaces=%o', group.name, group.workspaces)
+    const builtGroup = await buildGroupSnapshot(config, discovery, group, resolvedOptions)
+    if (!builtGroup) {
+      continue
+    }
+    snapshots.set(group.name, builtGroup)
+  }
 
-    for (const workspaceRel of group.workspaces) {
-      const workspaceAbs = path.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: string | undefined
-
-      const sampledAbs = sampled.map((sampledRel) => path.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) || allowWorkspaceExtractionFailure) {
-          lastExtractionError = message
-          continue
-        }
-
-        throw result.error ?? new Error(message)
-      }
+  debugTiming('phase=computeCurrentSnapshots elapsedMs=%d', Date.now() - computeStartedAt)
+  if (snapshots.size === 0) {
+    throw new Error('Unable to extract ESLint config from discovered workspaces in zero-config mode')
+  }
+  return snapshots
+}
 
-      if (extractedCount === 0) {
-        const context = lastExtractionError ? ` Last error: ${lastExtractionError}` : ''
-        if (allowWorkspaceExtractionFailure && isSkippableWorkspaceExtractionFailure(lastExtractionError)) {
-          onWorkspaceSkipped?.({
-            groupId: group.name,
-            workspaceRel,
-            reason: lastExtractionError ?? 'unknown extraction failure'
-          })
-          debugWorkspace(
-            'group=%s workspace=%s skipped=true reason=%s',
-            group.name,
-            workspaceRel,
-            lastExtractionError ?? 'unknown extraction failure'
-          )
-          continue
-        }
-
-        throw new Error(`Unable to extract ESLint config for workspace ${workspaceRel}.${context}`)
-      }
-      extractedWorkspaces.push(workspaceRel)
-
-      debugWorkspace(
-        'group=%s workspace=%s extracted=%d failed=%d',
-        group.name,
-        workspaceRel,
-        extractedCount,
-        results.length - extractedCount
-      )
+async function buildGroupSnapshot(
+  config: SnapshotConfig,
+  discovery: WorkspaceDiscovery,
+  group: GroupAssignment,
+  options: SnapshotComputationOptions
+): Promise<BuiltSnapshot | undefined> {
+  const groupStartedAt = Date.now()
+  const extractedForGroup = []
+  const extractedWorkspaces: string[] = []
+  debugWorkspace('group=%s workspaces=%o', group.name, group.workspaces)
+
+  for (const workspaceRel of group.workspaces) {
+    const workspaceOutcome = await extractWorkspaceRules(discovery, group.name, workspaceRel, config, options)
+    if (workspaceOutcome.kind === 'skip') {
+      continue
     }
+    extractedForGroup.push(...workspaceOutcome.rules)
+    extractedWorkspaces.push(workspaceRel)
+  }
 
-    if (extractedForGroup.length === 0) {
-      if (allowWorkspaceExtractionFailure) {
-        debugWorkspace('group=%s skipped=true reason=no-extracted-workspaces', group.name)
-        continue
-      }
-      throw new Error(`Unable to extract ESLint config for group ${group.name}: no workspace produced a valid config`)
+  if (extractedForGroup.length === 0) {
+    if (options.allowWorkspaceExtractionFailure) {
+      debugWorkspace('group=%s skipped=true reason=no-extracted-workspaces', group.name)
+      return undefined
     }
+    throw new Error(`Unable to extract ESLint config for group ${group.name}: no workspace produced a valid config`)
+  }
+
+  const aggregated = aggregateRules(extractedForGroup)
+  debugWorkspace(
+    'group=%s aggregatedRules=%d groupElapsedMs=%d',
+    group.name,
+    aggregated.size,
+    Date.now() - groupStartedAt
+  )
+  return buildSnapshot(group.name, extractedWorkspaces, aggregated)
+}
+
+type WorkspaceExtractionOutcome =
+  | { kind: 'ok'; rules: Array<NonNullable<Awaited<ReturnType<typeof extractRulesForWorkspaceSamples>>[number]['rules']>> }
+  | { kind: 'skip' }
+
+async function extractWorkspaceRules(
+  discovery: WorkspaceDiscovery,
+  groupName: string,
+  workspaceRel: string,
+  config: SnapshotConfig,
+  options: SnapshotComputationOptions
+): Promise<WorkspaceExtractionOutcome> {
+  const workspaceAbs = path.resolve(discovery.rootAbs, workspaceRel)
+  const sampled = await sampleWorkspaceForGroup(groupName, workspaceRel, workspaceAbs, config)
+  const sampledAbs = sampled.map((sampledRel) => path.resolve(workspaceAbs, sampledRel))
+  const extracted = await extractRulesForSampledFiles(
+    groupName,
+    workspaceRel,
+    workspaceAbs,
+    sampledAbs,
+    options.allowWorkspaceExtractionFailure
+  )
 
-    const aggregated = aggregateRules(extractedForGroup)
-    snapshots.set(group.name, buildSnapshot(group.name, extractedWorkspaces, aggregated))
+  if (extracted.extracted.length > 0) {
     debugWorkspace(
-      'group=%s aggregatedRules=%d groupElapsedMs=%d',
-      group.name,
-      aggregated.size,
-      Date.now() - groupStartedAt
+      'group=%s workspace=%s extracted=%d failed=%d',
+      groupName,
+      workspaceRel,
+      extracted.extracted.length,
+      extracted.total - extracted.extracted.length
     )
+    return { kind: 'ok', rules: extracted.extracted }
   }
 
-  debugTiming('phase=computeCurrentSnapshots elapsedMs=%d', Date.now() - computeStartedAt)
-  if (snapshots.size === 0) {
-    throw new Error('Unable to extract ESLint config from discovered workspaces in zero-config mode')
+  const skipReason = extracted.lastError ?? 'unknown extraction failure'
+  if (options.allowWorkspaceExtractionFailure && isSkippableWorkspaceExtractionFailure(extracted.lastError)) {
+    options.onWorkspaceSkipped?.({
+      groupId: groupName,
+      workspaceRel,
+      reason: skipReason
+    })
+    debugWorkspace('group=%s workspace=%s skipped=true reason=%s', groupName, workspaceRel, skipReason)
+    return { kind: 'skip' }
   }
-  return snapshots
+
+  const context = extracted.lastError ? ` Last error: ${extracted.lastError}` : ''
+  throw new Error(`Unable to extract ESLint config for workspace ${workspaceRel}.${context}`)
+}
+
+async function sampleWorkspaceForGroup(
+  groupName: string,
+  workspaceRel: string,
+  workspaceAbs: string,
+  config: SnapshotConfig
+): Promise<string[]> {
+  const sampleStartedAt = Date.now()
+  const sampled = await sampleWorkspaceFiles(workspaceAbs, config.sampling)
+  debugWorkspace(
+    'group=%s workspace=%s sampled=%d sampleElapsedMs=%d files=%o',
+    groupName,
+    workspaceRel,
+    sampled.length,
+    Date.now() - sampleStartedAt,
+    sampled
+  )
+  return sampled
+}
+
+async function extractRulesForSampledFiles(
+  groupName: string,
+  workspaceRel: string,
+  workspaceAbs: string,
+  sampledAbs: string[],
+  allowWorkspaceExtractionFailure: boolean
+): Promise<{
+  extracted: Array<NonNullable<Awaited<ReturnType<typeof extractRulesForWorkspaceSamples>>[number]['rules']>>
+  total: number
+  lastError?: string
+}> {
+  const extractStartedAt = Date.now()
+  const results = await extractRulesForWorkspaceSamples(workspaceAbs, sampledAbs)
+  debugTiming(
+    'phase=extract group=%s workspace=%s sampled=%d elapsedMs=%d',
+    groupName,
+    workspaceRel,
+    sampledAbs.length,
+    Date.now() - extractStartedAt
+  )
+
+  const extracted: Array<NonNullable<Awaited<ReturnType<typeof extractRulesForWorkspaceSamples>>[number]['rules']>> = []
+  let lastError: string | undefined
+  for (const result of results) {
+    if (result.rules) {
+      extracted.push(result.rules)
+      continue
+    }
+
+    const message = result.error instanceof Error ? result.error.message : String(result.error)
+    if (isRecoverableExtractionError(message) || allowWorkspaceExtractionFailure) {
+      lastError = message
+      continue
+    }
+
+    throw result.error ?? new Error(message)
+  }
+
+  return { extracted, total: results.length, lastError }
 }
 
 function isRecoverableExtractionError(message: string): boolean {
@@ -277,3 +349,41 @@ export async function resolveGroupEslintVersions(cwd: string): Promise<GroupEsli
 
   return result
 }
+
+export async function resolveGroupRuleCatalogs(cwd: string): Promise<GroupRuleCatalogs> {
+  const config = await loadConfig(cwd)
+  const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config)
+  const result: GroupRuleCatalogs = new Map()
+
+  for (const group of assignments) {
+    const coreRules = new Set<string>()
+    const allRules = new Set<string>()
+    const pluginRulesByPrefix: Record<string, string[]> = {}
+
+    for (const workspaceRel of group.workspaces) {
+      const workspaceAbs = path.resolve(discovery.rootAbs, workspaceRel)
+      const catalog = await discoverWorkspaceRuleCatalog(workspaceAbs)
+      for (const ruleName of catalog.coreRules) {
+        coreRules.add(ruleName)
+      }
+      for (const ruleName of catalog.allRules) {
+        allRules.add(ruleName)
+      }
+      for (const [prefix, rules] of Object.entries(catalog.pluginRulesByPrefix)) {
+        const current = pluginRulesByPrefix[prefix] ?? []
+        current.push(...rules)
+        pluginRulesByPrefix[prefix] = [...new Set(current)].sort((a, b) => a.localeCompare(b))
+      }
+    }
+
+    result.set(group.name, {
+      coreRules: [...coreRules].sort((a, b) => a.localeCompare(b)),
+      pluginRulesByPrefix: Object.fromEntries(
+        Object.entries(pluginRulesByPrefix).sort((a, b) => a[0].localeCompare(b[0]))
+      ),
+      allRules: [...allRules].sort((a, b) => a.localeCompare(b))
+    })
+  }
+
+  return result
+}

package/test/cli.integration.test.ts

@@ -19,6 +19,7 @@ beforeEach(async () => {
 
   await mkdir(path.join(fixtureRoot, 'packages/ws-a/node_modules/eslint/bin'), { recursive: true })
   await mkdir(path.join(fixtureRoot, 'packages/ws-b/node_modules/eslint/bin'), { recursive: true })
+  await mkdir(path.join(fixtureRoot, 'packages/ws-a/node_modules/eslint-plugin-alpha'), { recursive: true })
 
   await writeFile(
     path.join(fixtureRoot, 'packages/ws-a/node_modules/eslint/bin/eslint.js'),
@@ -37,6 +38,19 @@ beforeEach(async () => {
     path.join(fixtureRoot, 'packages/ws-b/node_modules/eslint/package.json'),
     JSON.stringify({ name: 'eslint', version: '9.0.0' }, null, 2)
   )
+
+  await writeFile(
+    path.join(fixtureRoot, 'packages/ws-a/node_modules/eslint/use-at-your-own-risk.js'),
+    "module.exports = { builtinRules: new Map([['no-console', {}], ['no-alert', {}], ['eqeqeq', {}]]) }\n"
+  )
+  await writeFile(
+    path.join(fixtureRoot, 'packages/ws-a/node_modules/eslint-plugin-alpha/package.json'),
+    JSON.stringify({ name: 'eslint-plugin-alpha', version: '1.0.0', main: 'index.js' }, null, 2)
+  )
+  await writeFile(
+    path.join(fixtureRoot, 'packages/ws-a/node_modules/eslint-plugin-alpha/index.js'),
+    "module.exports = { rules: { 'only-in-catalog': {}, observed: {} } }\n"
+  )
 })
 
 afterEach(async () => {
@@ -203,6 +217,33 @@ no-debugger: off
     )
   })
 
+  it('catalog emits available and missing rules in json output', async () => {
+    const writeSpy = vi.spyOn(process.stdout, 'write')
+    const code = await runCli('catalog', fixtureRoot, ['--missing'])
+    expect(code).toBe(0)
+    const finalWrite = writeSpy.mock.calls.at(-1)?.[0]
+    expect(typeof finalWrite).toBe('string')
+    expect(finalWrite).toContain('"missingRules": [')
+    expect(finalWrite).toContain('"alpha/observed"')
+    expect(finalWrite).toContain('"alpha/only-in-catalog"')
+    expect(finalWrite).toContain('"no-alert"')
+  })
+
+  it('catalog --short prints compact catalog summary', async () => {
+    const writeSpy = vi.spyOn(process.stdout, 'write')
+    const code = await runCli('catalog', fixtureRoot, ['--short', '--missing'])
+    expect(code).toBe(0)
+    const output = String(writeSpy.mock.calls.at(-1)?.[0] ?? '')
+    expect(output).toContain('📦 total: 2/5 in use')
+    expect(output).toContain('🧱 core: 2/3 in use')
+    expect(output).toContain('🔌 plugins tracked: 1')
+    expect(output).toContain('  - alpha: 0/2 in use')
+    expect(output).toContain('🕳️ missing list (3):')
+    expect(output).toContain('alpha/observed')
+    expect(output).toContain('alpha/only-in-catalog')
+    expect(output).toContain('no-alert')
+  })
+
   it('init creates scaffold config file when target=file', async () => {
     const tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-init-'))
     const code = await runCli('init', tmp, ['--yes', '--target', 'file', '--preset', 'full'])
@@ -260,6 +301,57 @@ no-debugger: off
     expect(await runCli('check', fixtureRoot)).toBe(0)
   })
 
+  it('supports catalog baseline update/check and experimental combined mode', async () => {
+    expect(await runCli('catalog-update', fixtureRoot)).toBe(0)
+    expect(await runCli('catalog-check', fixtureRoot)).toBe(0)
+
+    const catalogBaselineRaw = await readFile(path.join(fixtureRoot, '.eslint-config-snapshot/default.catalog.json'), 'utf8')
+    const catalogBaseline = JSON.parse(catalogBaselineRaw) as {
+      formatVersion: number
+      groupId: string
+      totalStats: { totalAvailable: number; inUse: number; error: number; warn: number; off: number }
+    }
+    expect(catalogBaseline.formatVersion).toBe(1)
+    expect(catalogBaseline.groupId).toBe('default')
+    expect(catalogBaseline.totalStats).toMatchObject({
+      totalAvailable: 5,
+      inUse: 2,
+      error: 2,
+      warn: 0,
+      off: 0
+    })
+
+    expect(await runCli(undefined, fixtureRoot, ['--update', '--experimental-with-catalog'])).toBe(0)
+    expect(await runCli(undefined, fixtureRoot, ['--experimental-with-catalog'])).toBe(0)
+
+    await writeFile(
+      path.join(fixtureRoot, 'packages/ws-a/node_modules/eslint/bin/eslint.js'),
+      "console.log(JSON.stringify({ rules: { 'no-console': 1, eqeqeq: [1, 'always'] } }))\n"
+    )
+    expect(await runCli('catalog-check', fixtureRoot)).toBe(1)
+  })
+
+  it('uses experimentalWithCatalog from config without CLI flag', async () => {
+    await writeFile(
+      path.join(fixtureRoot, 'eslint-config-snapshot.config.mjs'),
+      `export default {
+  experimentalWithCatalog: true,
+  workspaceInput: { mode: 'manual', workspaces: ['packages/ws-a', 'packages/ws-b'] },
+  grouping: { mode: 'match', groups: [{ name: 'default', match: ['**/*'] }] },
+  sampling: { maxFilesPerWorkspace: 8, includeGlobs: ['**/*.ts'], excludeGlobs: ['**/node_modules/**'] }
+}
+`
+    )
+
+    expect(await runCli(undefined, fixtureRoot, ['--update'])).toBe(0)
+    const catalogRaw = await readFile(path.join(fixtureRoot, '.eslint-config-snapshot/default.catalog.json'), 'utf8')
+    const catalog = JSON.parse(catalogRaw) as { formatVersion: number; groupId: string }
+    expect(catalog.formatVersion).toBe(1)
+    expect(catalog.groupId).toBe('default')
+
+    expect(await runCli(undefined, fixtureRoot, [])).toBe(0)
+  })
+
   it('supports ordered multi-group matching with first match wins', async () => {
     const tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-cli-grouped-'))
     await cp(fixtureRoot, tmp, { recursive: true })

package/test/cli.terminal.integration.test.ts

@@ -30,6 +30,7 @@ beforeEach(async () => {
   await cp(fixtureRoot, repoRoot, { recursive: true })
   await mkdir(path.join(repoRoot, 'packages/ws-a/node_modules/eslint/bin'), { recursive: true })
   await mkdir(path.join(repoRoot, 'packages/ws-b/node_modules/eslint/bin'), { recursive: true })
+  await mkdir(path.join(repoRoot, 'packages/ws-a/node_modules/eslint-plugin-alpha'), { recursive: true })
 
   await writeFile(
     path.join(repoRoot, 'packages/ws-a/node_modules/eslint/bin/eslint.js'),
@@ -48,6 +49,18 @@ beforeEach(async () => {
     path.join(repoRoot, 'packages/ws-b/node_modules/eslint/package.json'),
     JSON.stringify({ name: 'eslint', version: '9.0.0' }, null, 2)
   )
+  await writeFile(
+    path.join(repoRoot, 'packages/ws-a/node_modules/eslint/use-at-your-own-risk.js'),
+    "module.exports = { builtinRules: new Map([['no-console', {}], ['no-alert', {}], ['eqeqeq', {}]]) }\n"
+  )
+  await writeFile(
+    path.join(repoRoot, 'packages/ws-a/node_modules/eslint-plugin-alpha/package.json'),
+    JSON.stringify({ name: 'eslint-plugin-alpha', version: '1.0.0', main: 'index.js' }, null, 2)
+  )
+  await writeFile(
+    path.join(repoRoot, 'packages/ws-a/node_modules/eslint-plugin-alpha/index.js'),
+    "module.exports = { rules: { 'only-in-catalog': {}, observed: {} } }\n"
+  )
 })
 
 afterEach(async () => {
@@ -66,6 +79,9 @@ describe('cli terminal invocation', () => {
     expect(result.stdout).toContain('check [options]')
     expect(result.stdout).toContain('update|snapshot')
     expect(result.stdout).toContain('print [options]')
+    expect(result.stdout).toContain('catalog [options]')
+    expect(result.stdout).toContain('catalog-check')
+    expect(result.stdout).toContain('catalog-update')
     expect(result.stdout).toContain('config [options]')
     expect(result.stdout).toContain('init')
     expect(result.stderr).toBe('')
@@ -218,6 +234,64 @@ no-debugger: off
     expect(result.stderr).toBe('')
   })
 
+  it('catalog --missing returns deterministic json output', () => {
+    const result = run(['catalog', '--missing'])
+    expect(result.status).toBe(0)
+    expect(result.stdout).toContain('"groupId": "default"')
+    expect(result.stdout).toContain('"totalStats"')
+    expect(result.stdout).toContain('"coreStats"')
+    expect(result.stdout).toContain('"pluginStats"')
+    expect(result.stdout).toContain('"missingRules"')
+    expect(result.stdout).toContain('"alpha/observed"')
+    expect(result.stdout).toContain('"alpha/only-in-catalog"')
+    expect(result.stdout).toContain('"no-alert"')
+    expect(result.stderr).toBe('')
+  })
+
+  it('catalog --short --missing returns compact output', () => {
+    const result = run(['catalog', '--short', '--missing'])
+    expect(result.status).toBe(0)
+    expect(result.stdout).toContain('📦 total: 2/5 in use')
+    expect(result.stdout).toContain('🧱 core: 2/3 in use')
+    expect(result.stdout).toContain('🔌 plugins tracked: 1')
+    expect(result.stdout).toContain('  - alpha: 0/2 in use')
+    expect(result.stdout).toContain('🕳️ missing list (3):')
+    expect(result.stdout).toContain('alpha/observed')
+    expect(result.stdout).toContain('alpha/only-in-catalog')
+    expect(result.stdout).toContain('no-alert')
+    expect(result.stderr).toBe('')
+  })
+
+  it('catalog-update writes baseline and catalog-check returns clean', () => {
+    const update = run(['catalog-update'])
+    expect(update.status).toBe(0)
+    expect(update.stdout).toContain('Catalog baseline updated:')
+    expect(update.stdout).toContain('📦 total:')
+    expect(update.stdout).toContain('🔌 plugins tracked:')
+    expect(update.stderr).toBe('')
+
+    const check = run(['catalog-check'])
+    expect(check.status).toBe(0)
+    expect(check.stdout).toContain('Great news: no catalog drift detected.')
+    expect(check.stdout).toContain('📦 total:')
+    expect(check.stdout).toContain('🔌 plugins tracked:')
+    expect(check.stderr).toBe('')
+  })
+
+  it('default experimental mode updates and checks catalog baseline', () => {
+    const update = run(['--update', '--experimental-with-catalog'])
+    expect(update.status).toBe(0)
+    expect(update.stdout).toContain('baseline was successfully created')
+    expect(update.stdout).toContain('Catalog baseline updated:')
+    expect(update.stderr).toBe('')
+
+    const check = run(['--experimental-with-catalog'])
+    expect(check.status).toBe(0)
+    expect(check.stdout).toContain('Great news: no snapshot drift detected.')
+    expect(check.stdout).toContain('Great news: no catalog drift detected.')
+    expect(check.stderr).toBe('')
+  })
+
   it('init handles success and existing-file error paths', async () => {
     const initRoot = path.join(tmpDir, 'init-case')
     await rm(initRoot, { recursive: true, force: true })

package/test/formatters.unit.test.ts

@@ -44,4 +44,35 @@ describe('output helpers', () => {
     )
     expect(summary).toEqual({ groups: 1, rules: 3, error: 1, warn: 1, off: 1 })
   })
+
+  it('deduplicates rules across groups in summary', () => {
+    const summary = summarizeSnapshots(
+      new Map([
+        [
+          'group-a',
+          {
+            groupId: 'group-a',
+            workspaces: ['packages/a'],
+            rules: {
+              shared: ['warn'],
+              onlyA: ['off']
+            }
+          }
+        ],
+        [
+          'group-b',
+          {
+            groupId: 'group-b',
+            workspaces: ['packages/b'],
+            rules: {
+              shared: ['error'],
+              onlyB: ['warn']
+            }
+          }
+        ]
+      ])
+    )
+
+    expect(summary).toEqual({ groups: 2, rules: 3, error: 1, warn: 1, off: 1 })
+  })
 })