@eslint-config-snapshot/cli 0.1.5 → 0.3.0

package/src/index.ts

@@ -10,6 +10,7 @@ import {
   getConfigScaffold,
   hasDiff,
   loadConfig,
+  normalizePath,
   readSnapshotFile,
   sampleWorkspaceFiles,
   writeSnapshotFile
@@ -30,7 +31,7 @@ type SnapshotDiff = ReturnType<typeof diffSnapshots>
 type CheckFormat = 'summary' | 'status' | 'diff'
 type PrintFormat = 'json' | 'short'
 type InitTarget = 'file' | 'package-json'
-type InitPreset = 'minimal' | 'full'
+type InitPreset = 'recommended' | 'minimal' | 'full'
 
 type RootOptions = {
   update?: boolean
@@ -138,11 +139,23 @@ function createProgram(cwd: string, onActionExit: (code: number) => void): Comma
       onActionExit(0)
     })
 
+  program
+    .command('config')
+    .description('Print effective evaluated config')
+    .option('--format <format>', 'Output format: json|short', parsePrintFormat, 'json')
+    .option('--short', 'Alias for --format short')
+    .action(async (opts: { format: PrintFormat; short?: boolean }) => {
+      const format: PrintFormat = opts.short ? 'short' : opts.format
+      await executeConfig(cwd, format)
+      onActionExit(0)
+    })
+
   program
     .command('init')
     .description('Initialize config (file or package.json)')
     .option('--target <target>', 'Config target: file|package-json', parseInitTarget)
-    .option('--preset <preset>', 'Config preset: minimal|full', parseInitPreset)
+    .option('--preset <preset>', 'Config preset: recommended|minimal|full', parseInitPreset)
+    .option('--show-effective', 'Print the evaluated config that will be written')
     .option('-f, --force', 'Allow init even when an existing config is detected')
     .option('-y, --yes', 'Skip prompts and use defaults/options')
     .addHelpText(
@@ -150,18 +163,17 @@ function createProgram(cwd: string, onActionExit: (code: number) => void): Comma
       `
 Examples:
   $ eslint-config-snapshot init
-    Runs interactive numbered prompts:
-      target: 1) package-json, 2) file
-      preset: 1) minimal, 2) full
+    Runs interactive select prompts for target/preset.
+    Recommended preset uses checkbox selection for non-default workspaces and group selection.
 
-  $ eslint-config-snapshot init --yes --target package-json --preset minimal
-    Non-interactive minimal setup in package.json.
+  $ eslint-config-snapshot init --yes --target package-json --preset recommended --show-effective
+    Non-interactive recommended setup in package.json, with effective preview.
 
   $ eslint-config-snapshot init --yes --force --target file --preset full
     Overwrite-safe bypass when a config is already detected.
 `
     )
-    .action(async (opts: { target?: InitTarget; preset?: InitPreset; force?: boolean; yes?: boolean }) => {
+    .action(async (opts: { target?: InitTarget; preset?: InitPreset; force?: boolean; yes?: boolean; showEffective?: boolean }) => {
       onActionExit(await runInit(cwd, opts))
     })
 
@@ -217,11 +229,11 @@ function parseInitTarget(value: string): InitTarget {
 
 function parseInitPreset(value: string): InitPreset {
   const normalized = value.trim().toLowerCase()
-  if (normalized === 'minimal' || normalized === 'full') {
+  if (normalized === 'recommended' || normalized === 'minimal' || normalized === 'full') {
     return normalized
   }
 
-  throw new InvalidArgumentError('Expected one of: minimal, full')
+  throw new InvalidArgumentError('Expected one of: recommended, minimal, full')
 }
 
 async function executeCheck(cwd: string, format: CheckFormat, defaultInvocation = false): Promise<number> {
@@ -349,23 +361,34 @@ async function executePrint(cwd: string, format: PrintFormat): Promise<void> {
   process.stdout.write(`${JSON.stringify(output, null, 2)}\n`)
 }
 
-async function computeCurrentSnapshots(cwd: string): Promise<Map<string, BuiltSnapshot>> {
+async function executeConfig(cwd: string, format: PrintFormat): Promise<void> {
+  const foundConfig = await findConfigPath(cwd)
   const config = await loadConfig(cwd)
-  const discovery = await discoverWorkspaces({ cwd, workspaceInput: config.workspaceInput })
-
-  const assignments =
-    config.grouping.mode === 'standalone'
-      ? discovery.workspacesRel.map((workspace) => ({ name: workspace, workspaces: [workspace] }))
-      : assignGroupsByMatch(discovery.workspacesRel, config.grouping.groups ?? [{ name: 'default', match: ['**/*'] }])
+  const resolved = await resolveWorkspaceAssignments(cwd, config)
+  const payload = {
+    source: foundConfig?.path ?? 'built-in-defaults',
+    workspaceInput: config.workspaceInput,
+    workspaces: resolved.discovery.workspacesRel,
+    grouping: {
+      mode: config.grouping.mode,
+      allowEmptyGroups: config.grouping.allowEmptyGroups ?? false,
+      groups: resolved.assignments.map((entry) => ({ name: entry.name, workspaces: entry.workspaces }))
+    },
+    sampling: config.sampling
+  }
 
-  const allowEmptyGroups = config.grouping.allowEmptyGroups ?? false
-  if (!allowEmptyGroups) {
-    const empty = assignments.filter((group) => group.workspaces.length === 0)
-    if (empty.length > 0) {
-      throw new Error(`Empty groups are not allowed: ${empty.map((entry) => entry.name).join(', ')}`)
-    }
+  if (format === 'short') {
+    process.stdout.write(formatShortConfig(payload))
+    return
   }
 
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`)
+}
+
+async function computeCurrentSnapshots(cwd: string): Promise<Map<string, BuiltSnapshot>> {
+  const config = await loadConfig(cwd)
+  const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config)
+
   const snapshots = new Map<string, BuiltSnapshot>()
 
   for (const group of assignments) {
@@ -411,6 +434,25 @@ async function computeCurrentSnapshots(cwd: string): Promise<Map<string, BuiltSn
   return snapshots
 }
 
+async function resolveWorkspaceAssignments(cwd: string, config: Awaited<ReturnType<typeof loadConfig>>) {
+  const discovery = await discoverWorkspaces({ cwd, workspaceInput: config.workspaceInput })
+
+  const assignments =
+    config.grouping.mode === 'standalone'
+      ? discovery.workspacesRel.map((workspace) => ({ name: workspace, workspaces: [workspace] }))
+      : assignGroupsByMatch(discovery.workspacesRel, config.grouping.groups ?? [{ name: 'default', match: ['**/*'] }])
+
+  const allowEmptyGroups = config.grouping.allowEmptyGroups ?? false
+  if (!allowEmptyGroups) {
+    const empty = assignments.filter((group) => group.workspaces.length === 0)
+    if (empty.length > 0) {
+      throw new Error(`Empty groups are not allowed: ${empty.map((entry) => entry.name).join(', ')}`)
+    }
+  }
+
+  return { discovery, assignments }
+}
+
 async function loadStoredSnapshots(cwd: string): Promise<Map<string, StoredSnapshot>> {
   const dir = path.join(cwd, SNAPSHOT_DIR)
   const files = await fg('**/*.json', { cwd: dir, absolute: true, onlyFiles: true, dot: true, suppressErrors: true })
@@ -515,9 +557,10 @@ function getDisplayOptionChanges(diff: SnapshotDiff): SnapshotDiff['optionChange
 
 async function runInit(
   cwd: string,
-  opts: { target?: InitTarget; preset?: InitPreset; force?: boolean; yes?: boolean } = {}
+  opts: { target?: InitTarget; preset?: InitPreset; force?: boolean; yes?: boolean; showEffective?: boolean } = {}
 ): Promise<number> {
   const force = opts.force ?? false
+  const showEffective = opts.showEffective ?? false
   const existing = await findConfigPath(cwd)
   if (existing && !force) {
     process.stderr.write(
@@ -535,77 +578,50 @@ async function runInit(
   }
 
   const finalTarget = target ?? 'file'
-  const finalPreset = preset ?? 'minimal'
+  const finalPreset = preset ?? 'recommended'
+  const configObject = await resolveInitConfigObject(cwd, finalPreset, Boolean(opts.yes))
 
-  if (finalTarget === 'package-json') {
-    return runInitInPackageJson(cwd, finalPreset, force)
+  if (showEffective) {
+    process.stdout.write(`Effective config preview:\n${JSON.stringify(configObject, null, 2)}\n`)
   }
 
-  return runInitInFile(cwd, finalPreset, force)
-}
-
-async function askInitPreferences(): Promise<{ target: InitTarget; preset: InitPreset }> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout })
-  try {
-    const target = await askInitTarget(rl)
-    const preset = await askInitPreset(rl)
-    return { target, preset }
-  } finally {
-    rl.close()
+  if (finalTarget === 'package-json') {
+    return runInitInPackageJson(cwd, configObject, force)
   }
-}
 
-async function askInitTarget(rl: ReturnType<typeof createInterface>): Promise<InitTarget> {
-  while (true) {
-    const answer = await askQuestion(
-      rl,
-      'Select config target:\n  1) package-json (recommended)\n  2) file\nChoose [1]: '
-    )
-    const parsed = parseInitTargetChoice(answer)
-    if (parsed) {
-      return parsed
-    }
-    process.stdout.write('Please choose 1 (package-json) or 2 (file).\n')
-  }
+  return runInitInFile(cwd, configObject, force)
 }
 
-async function askInitPreset(rl: ReturnType<typeof createInterface>): Promise<InitPreset> {
-  while (true) {
-    const answer = await askQuestion(rl, 'Select preset:\n  1) minimal (recommended)\n  2) full\nChoose [1]: ')
-    const parsed = parseInitPresetChoice(answer)
-    if (parsed) {
-      return parsed
-    }
-    process.stdout.write('Please choose 1 (minimal) or 2 (full).\n')
-  }
+async function askInitPreferences(): Promise<{ target: InitTarget; preset: InitPreset }> {
+  const { select } = await import('@inquirer/prompts')
+  const target = await askInitTarget(select)
+  const preset = await askInitPreset(select)
+  return { target, preset }
 }
 
-export function parseInitTargetChoice(value: string): InitTarget | undefined {
-  const normalized = value.trim().toLowerCase()
-  if (normalized === '') {
-    return 'package-json'
-  }
-  if (normalized === '1' || normalized === 'package-json' || normalized === 'packagejson' || normalized === 'package' || normalized === 'pkg') {
-    return 'package-json'
-  }
-  if (normalized === '2' || normalized === 'file') {
-    return 'file'
-  }
-  return undefined
+async function askInitTarget(
+  selectPrompt: (options: { message: string; choices: Array<{ name: string; value: InitTarget }> }) => Promise<InitTarget>
+): Promise<InitTarget> {
+  return selectPrompt({
+    message: 'Select config target',
+    choices: [
+      { name: 'package-json (recommended)', value: 'package-json' },
+      { name: 'file', value: 'file' }
+    ]
+  })
 }
 
-export function parseInitPresetChoice(value: string): InitPreset | undefined {
-  const normalized = value.trim().toLowerCase()
-  if (normalized === '') {
-    return 'minimal'
-  }
-  if (normalized === '1' || normalized === 'minimal' || normalized === 'min') {
-    return 'minimal'
-  }
-  if (normalized === '2' || normalized === 'full') {
-    return 'full'
-  }
-  return undefined
+async function askInitPreset(
+  selectPrompt: (options: { message: string; choices: Array<{ name: string; value: InitPreset }> }) => Promise<InitPreset>
+): Promise<InitPreset> {
+  return selectPrompt({
+    message: 'Select preset',
+    choices: [
+      { name: 'recommended (default group "*" + static overrides)', value: 'recommended' },
+      { name: 'minimal', value: 'minimal' },
+      { name: 'full', value: 'full' }
+    ]
+  })
 }
 
 function askQuestion(rl: ReturnType<typeof createInterface>, prompt: string): Promise<string> {
@@ -631,7 +647,7 @@ async function askYesNo(prompt: string, defaultYes: boolean): Promise<boolean> {
   }
 }
 
-async function runInitInFile(cwd: string, preset: InitPreset, force: boolean): Promise<number> {
+async function runInitInFile(cwd: string, configObject: Record<string, unknown>, force: boolean): Promise<number> {
   const candidates = [
     '.eslint-config-snapshot.js',
     '.eslint-config-snapshot.cjs',
@@ -654,12 +670,12 @@ async function runInitInFile(cwd: string, preset: InitPreset, force: boolean): P
   }
 
   const target = path.join(cwd, 'eslint-config-snapshot.config.mjs')
-  await writeFile(target, getConfigScaffold(preset), 'utf8')
+  await writeFile(target, toConfigScaffold(configObject), 'utf8')
   process.stdout.write(`Created ${path.basename(target)}\n`)
   return 0
 }
 
-async function runInitInPackageJson(cwd: string, preset: InitPreset, force: boolean): Promise<number> {
+async function runInitInPackageJson(cwd: string, configObject: Record<string, unknown>, force: boolean): Promise<number> {
   const packageJsonPath = path.join(cwd, 'package.json')
 
   let packageJsonRaw: string
@@ -683,12 +699,142 @@ async function runInitInPackageJson(cwd: string, preset: InitPreset, force: bool
       return 1
     }
 
-  parsed['eslint-config-snapshot'] = preset === 'full' ? getFullPresetObject() : {}
+  parsed['eslint-config-snapshot'] = configObject
   await writeFile(packageJsonPath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf8')
   process.stdout.write('Created config in package.json under "eslint-config-snapshot"\n')
   return 0
 }
 
+async function resolveInitConfigObject(
+  cwd: string,
+  preset: InitPreset,
+  nonInteractive: boolean
+): Promise<Record<string, unknown>> {
+  if (preset === 'minimal') {
+    return {}
+  }
+
+  if (preset === 'full') {
+    return getFullPresetObject()
+  }
+
+  return buildRecommendedPresetObject(cwd, nonInteractive)
+}
+
+async function buildRecommendedPresetObject(cwd: string, nonInteractive: boolean): Promise<Record<string, unknown>> {
+  const workspaces = await discoverInitWorkspaces(cwd)
+  const useInteractiveGrouping = !nonInteractive && process.stdin.isTTY && process.stdout.isTTY
+  const assignments = useInteractiveGrouping ? await askRecommendedGroupAssignments(workspaces) : new Map<string, number>()
+  return buildRecommendedConfigFromAssignments(workspaces, assignments)
+}
+
+export function buildRecommendedConfigFromAssignments(
+  workspaces: string[],
+  assignments: Map<string, number>
+): Record<string, unknown> {
+  const groupNumbers = [...new Set(assignments.values())].sort((a, b) => a - b)
+  if (groupNumbers.length === 0) {
+    return {}
+  }
+
+  const explicitGroups = groupNumbers.map((number) => ({
+    name: `group-${number}`,
+    match: workspaces.filter((workspace) => assignments.get(workspace) === number)
+  }))
+
+  return {
+    grouping: {
+      mode: 'match',
+      groups: [...explicitGroups, { name: 'default', match: ['**/*'] }]
+    }
+  }
+}
+
+async function discoverInitWorkspaces(cwd: string): Promise<string[]> {
+  const discovered = await discoverWorkspaces({ cwd, workspaceInput: { mode: 'discover' } })
+  if (!(discovered.workspacesRel.length === 1 && discovered.workspacesRel[0] === '.')) {
+    return discovered.workspacesRel
+  }
+
+  const packageJsonPath = path.join(cwd, 'package.json')
+  try {
+    const raw = await readFile(packageJsonPath, 'utf8')
+    const parsed = JSON.parse(raw) as { workspaces?: string[] | { packages?: string[] } }
+    let workspacePatterns: string[] = []
+    if (Array.isArray(parsed.workspaces)) {
+      workspacePatterns = parsed.workspaces
+    } else if (parsed.workspaces && typeof parsed.workspaces === 'object' && Array.isArray(parsed.workspaces.packages)) {
+      workspacePatterns = parsed.workspaces.packages
+    }
+
+    if (workspacePatterns.length === 0) {
+      return discovered.workspacesRel
+    }
+
+    const workspacePackageFiles = await fg(
+      workspacePatterns.map((pattern) => `${trimTrailingSlashes(pattern)}/package.json`),
+      { cwd, onlyFiles: true, dot: true }
+    )
+    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => normalizePath(path.dirname(entry))))].sort((a, b) =>
+      a.localeCompare(b)
+    )
+    if (workspaceDirs.length > 0) {
+      return workspaceDirs
+    }
+  } catch {
+    // fallback to discovered output
+  }
+
+  return discovered.workspacesRel
+}
+
+function trimTrailingSlashes(value: string): string {
+  let normalized = value
+  while (normalized.endsWith('/')) {
+    normalized = normalized.slice(0, -1)
+  }
+  return normalized
+}
+
+async function askRecommendedGroupAssignments(workspaces: string[]): Promise<Map<string, number>> {
+  const { checkbox, select } = await import('@inquirer/prompts')
+  process.stdout.write('Recommended setup: select only workspaces that should leave default group "*".\n')
+  const overrides = await checkbox<string>({
+    message: 'Workspaces outside default group:',
+    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
+  for (const workspace of overrides) {
+    const usedGroups = [...new Set(assignments.values())].sort((a, b) => a - b)
+    while (usedGroups.includes(nextGroup)) {
+      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 groupNumber = selected === 'new' ? nextGroup : selected
+    assignments.set(workspace, groupNumber)
+  }
+
+  return assignments
+}
+
+function toConfigScaffold(configObject: Record<string, unknown>): string {
+  if (Object.keys(configObject).length === 0) {
+    return getConfigScaffold('minimal')
+  }
+
+  return `export default ${JSON.stringify(configObject, null, 2)}\n`
+}
+
 function getFullPresetObject() {
   return {
     workspaceInput: { mode: 'discover' },
@@ -859,3 +1005,22 @@ function formatShortPrint(
 
   return `${lines.join('\n')}\n`
 }
+
+function formatShortConfig(payload: {
+  source: string
+  workspaceInput: unknown
+  workspaces: string[]
+  grouping: { mode: string; allowEmptyGroups: boolean; groups: Array<{ name: string; workspaces: string[] }> }
+  sampling: unknown
+}): string {
+  const lines: string[] = [
+    `source: ${payload.source}`,
+    `workspaces (${payload.workspaces.length}): ${payload.workspaces.join(', ') || '(none)'}`,
+    `grouping mode: ${payload.grouping.mode} (allow empty: ${payload.grouping.allowEmptyGroups})`
+  ]
+  for (const group of payload.grouping.groups) {
+    lines.push(`group ${group.name} (${group.workspaces.length}): ${group.workspaces.join(', ') || '(none)'}`)
+  }
+  lines.push(`workspaceInput: ${JSON.stringify(payload.workspaceInput)}`, `sampling: ${JSON.stringify(payload.sampling)}`)
+  return `${lines.join('\n')}\n`
+}

package/test/cli.integration.test.ts

@@ -1,18 +1,19 @@
 import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
-import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { parseInitPresetChoice, parseInitTargetChoice, runCli } from '../src/index.js'
+import { buildRecommendedConfigFromAssignments, runCli } from '../src/index.js'
 
-const fixtureRoot = path.resolve('test/fixtures/repo')
-
-afterAll(async () => {
-  await rm(path.join(fixtureRoot, '.eslint-config-snapshot'), { recursive: true, force: true })
-})
+const fixtureTemplateRoot = path.resolve('test/fixtures/repo')
+let tmpDir = ''
+let fixtureRoot = ''
 
 beforeEach(async () => {
-  await rm(path.join(fixtureRoot, '.eslint-config-snapshot'), { recursive: true, force: true })
+  tmpDir = await mkdtemp(path.join(os.tmpdir(), 'snapshot-cli-integration-'))
+  fixtureRoot = path.join(tmpDir, 'repo')
+  await cp(fixtureTemplateRoot, fixtureRoot, { recursive: true })
+
   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 })
 
@@ -35,24 +36,31 @@ beforeEach(async () => {
   )
 })
 
-describe('cli integration', () => {
-  it('parses init interactive target choices from numeric and aliases', () => {
-    expect(parseInitTargetChoice('')).toBe('package-json')
-    expect(parseInitTargetChoice('1')).toBe('package-json')
-    expect(parseInitTargetChoice('package')).toBe('package-json')
-    expect(parseInitTargetChoice('pkg')).toBe('package-json')
-    expect(parseInitTargetChoice('2')).toBe('file')
-    expect(parseInitTargetChoice('file')).toBe('file')
-    expect(parseInitTargetChoice('invalid')).toBeUndefined()
+afterEach(async () => {
+  if (tmpDir) {
+    await rm(tmpDir, { recursive: true, force: true })
+    tmpDir = ''
+    fixtureRoot = ''
+  }
+})
+
+describe.sequential('cli integration', () => {
+  it('builds recommended config as dynamic-only when no static overrides are selected', () => {
+    const config = buildRecommendedConfigFromAssignments(['packages/ws-a', 'packages/ws-b'], new Map())
+    expect(config).toEqual({})
   })
 
-  it('parses init interactive preset choices from numeric and aliases', () => {
-    expect(parseInitPresetChoice('')).toBe('minimal')
-    expect(parseInitPresetChoice('1')).toBe('minimal')
-    expect(parseInitPresetChoice('min')).toBe('minimal')
-    expect(parseInitPresetChoice('2')).toBe('full')
-    expect(parseInitPresetChoice('full')).toBe('full')
-    expect(parseInitPresetChoice('invalid')).toBeUndefined()
+  it('builds recommended config with static overrides plus dynamic catch-all', () => {
+    const config = buildRecommendedConfigFromAssignments(['packages/ws-a', 'packages/ws-b'], new Map([['packages/ws-b', 2]]))
+    expect(config).toEqual({
+      grouping: {
+        mode: 'match',
+        groups: [
+          { name: 'group-2', match: ['packages/ws-b'] },
+          { name: 'default', match: ['**/*'] }
+        ]
+      }
+    })
   })
 
   it('snapshot writes deterministic snapshot files', async () => {
@@ -126,11 +134,22 @@ no-debugger: off
     expect(code).toBe(0)
 
     const content = await readFile(path.join(tmp, 'eslint-config-snapshot.config.mjs'), 'utf8')
-    expect(content).toContain("workspaceInput: { mode: 'discover' }")
+    expect(content).toContain('"workspaceInput"')
+    expect(content).toContain('"grouping"')
+    expect(content).toContain('"sampling"')
 
     await rm(tmp, { recursive: true, force: true })
   })
 
+  it('config prints effective evaluated config and exits 0', async () => {
+    const writeSpy = vi.spyOn(process.stdout, 'write')
+    const code = await runCli('config', fixtureRoot)
+    expect(code).toBe(0)
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('"workspaceInput"'))
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('"workspaces"'))
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('"groups"'))
+  })
+
   it('init writes minimal config to package.json when target=package-json', async () => {
     const tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-init-pkg-'))
     await writeFile(path.join(tmp, 'package.json'), JSON.stringify({ name: 'fixture', private: true }, null, 2))

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

@@ -66,6 +66,7 @@ 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('config [options]')
     expect(result.stdout).toContain('init')
     expect(result.stderr).toBe('')
   })
@@ -232,6 +233,15 @@ no-debugger: off
     expect(existing.stderr).toContain('rerun with --force')
   })
 
+  it('config prints effective evaluated config output', () => {
+    const result = run(['config'])
+    expect(result.status).toBe(0)
+    expect(result.stdout).toContain('"workspaceInput"')
+    expect(result.stdout).toContain('"workspaces"')
+    expect(result.stdout).toContain('"groups"')
+    expect(result.stderr).toBe('')
+  })
+
   it('init can write config to package.json', async () => {
     const initRoot = path.join(tmpDir, 'init-package-json-case')
     await rm(initRoot, { recursive: true, force: true })
@@ -250,6 +260,44 @@ no-debugger: off
     expect(parsed['eslint-config-snapshot']).toEqual({})
   })
 
+  it('init recommended writes grouped workspace config in package.json', async () => {
+    const initRoot = path.join(tmpDir, 'init-recommended-package-json-case')
+    await rm(initRoot, { recursive: true, force: true })
+    await cp(fixtureRoot, initRoot, { recursive: true })
+    repoRoot = initRoot
+
+    await rm(path.join(repoRoot, 'eslint-config-snapshot.config.mjs'), { force: true })
+
+    const created = run(['init', '--yes', '--target', 'package-json', '--preset', 'recommended'])
+    expect(created.status).toBe(0)
+    expect(created.stdout).toBe('Created config in package.json under "eslint-config-snapshot"\n')
+    expect(created.stderr).toBe('')
+
+    const packageJsonRaw = await readFile(path.join(repoRoot, 'package.json'), 'utf8')
+    const parsed = JSON.parse(packageJsonRaw) as {
+      'eslint-config-snapshot'?: Record<string, unknown>
+    }
+
+    expect(parsed['eslint-config-snapshot']).toEqual({})
+  })
+
+  it('init recommended --show-effective prints preview without explicit sampling block', async () => {
+    const initRoot = path.join(tmpDir, 'init-recommended-preview-case')
+    await rm(initRoot, { recursive: true, force: true })
+    await cp(fixtureRoot, initRoot, { recursive: true })
+    repoRoot = initRoot
+
+    await rm(path.join(repoRoot, 'eslint-config-snapshot.config.mjs'), { force: true })
+
+    const result = run(['init', '--yes', '--target', 'package-json', '--preset', 'recommended', '--show-effective'])
+    expect(result.status).toBe(0)
+    expect(result.stdout).toContain('Effective config preview:')
+    expect(result.stdout).toContain('{}')
+    expect(result.stdout).not.toContain('"workspaceInput"')
+    expect(result.stdout).not.toContain('"grouping"')
+    expect(result.stdout).not.toContain('"sampling"')
+  })
+
   it('init fails early on existing config unless --force is provided', async () => {
     const initRoot = path.join(tmpDir, 'init-force-case')
     await rm(initRoot, { recursive: true, force: true })
@@ -335,14 +383,14 @@ no-debugger: off
     expect(result.stderr).toBe('')
   })
 
-  it('prints init help with numbered prompt and force guidance', () => {
+  it('prints init help with select-prompt and force guidance', () => {
     const result = run(['init', '--help'])
     expect(result.status).toBe(0)
     expect(result.stdout).toContain('Initialize config (file or package.json)')
     expect(result.stdout).toContain('-f, --force')
-    expect(result.stdout).toContain('Runs interactive numbered prompts:')
-    expect(result.stdout).toContain('target: 1) package-json, 2) file')
-    expect(result.stdout).toContain('preset: 1) minimal, 2) full')
+    expect(result.stdout).toContain('Runs interactive select prompts for target/preset.')
+    expect(result.stdout).toContain('Recommended preset uses checkbox selection')
+    expect(result.stdout).toContain('--show-effective')
     expect(result.stdout).toContain('--yes --force --target file --preset full')
     expect(result.stderr).toBe('')
   })

package/test/fixtures/repo/packages/ws-a/node_modules/eslint/bin/eslint.js

@@ -1 +0,0 @@
-console.log(JSON.stringify({ rules: { 'no-console': 1, eqeqeq: [2, 'always'] } }))

package/test/fixtures/repo/packages/ws-a/node_modules/eslint/package.json

@@ -1,4 +0,0 @@
-{
-  "name": "eslint",
-  "version": "9.0.0"
-}

package/test/fixtures/repo/packages/ws-b/node_modules/eslint/bin/eslint.js

@@ -1 +0,0 @@
-console.log(JSON.stringify({ rules: { 'no-console': 2, 'no-debugger': 0 } }))