@eslint-config-snapshot/cli 0.1.0

package/test/cli.integration.test.ts

@@ -0,0 +1,247 @@
+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 { parseInitPresetChoice, parseInitTargetChoice, 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 })
+})
+
+beforeEach(async () => {
+  await rm(path.join(fixtureRoot, '.eslint-config-snapshot'), { recursive: true, force: 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 })
+
+  await writeFile(
+    path.join(fixtureRoot, 'packages/ws-a/node_modules/eslint/bin/eslint.js'),
+    "console.log(JSON.stringify({ rules: { 'no-console': 1, eqeqeq: [2, 'always'] } }))\n"
+  )
+  await writeFile(
+    path.join(fixtureRoot, 'packages/ws-a/node_modules/eslint/package.json'),
+    JSON.stringify({ name: 'eslint', version: '9.0.0' }, null, 2)
+  )
+
+  await writeFile(
+    path.join(fixtureRoot, 'packages/ws-b/node_modules/eslint/bin/eslint.js'),
+    "console.log(JSON.stringify({ rules: { 'no-console': 2, 'no-debugger': 0 } }))\n"
+  )
+  await writeFile(
+    path.join(fixtureRoot, 'packages/ws-b/node_modules/eslint/package.json'),
+    JSON.stringify({ name: 'eslint', version: '9.0.0' }, null, 2)
+  )
+})
+
+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()
+  })
+
+  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('snapshot writes deterministic snapshot files', async () => {
+    const code = await runCli('snapshot', fixtureRoot)
+    expect(code).toBe(0)
+
+    const snapshotRaw = await readFile(path.join(fixtureRoot, '.eslint-config-snapshot/default.json'), 'utf8')
+    const snapshot = JSON.parse(snapshotRaw)
+
+    expect(snapshot).toEqual({
+      formatVersion: 1,
+      groupId: 'default',
+      workspaces: ['packages/ws-a', 'packages/ws-b'],
+      rules: {
+        eqeqeq: ['error', 'always'],
+        'no-console': ['error'],
+        'no-debugger': ['off']
+      }
+    })
+
+    expect(snapshotRaw.endsWith('\n')).toBe(true)
+    expect(snapshotRaw.includes('src/index.ts')).toBe(false)
+  })
+
+  it('compare returns non-zero when snapshots changed', async () => {
+    expect(await runCli('snapshot', fixtureRoot)).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: 0 } }))\n"
+    )
+
+    const code = await runCli('compare', fixtureRoot)
+    expect(code).toBe(1)
+  })
+
+  it('status is minimal and exits 0 when clean', async () => {
+    await runCli('snapshot', fixtureRoot)
+
+    const writeSpy = vi.spyOn(process.stdout, 'write')
+    const code = await runCli('status', fixtureRoot)
+    expect(code).toBe(0)
+    expect(writeSpy).toHaveBeenCalledWith('clean\n')
+  })
+
+  it('print emits aggregated rules and exits 0', async () => {
+    const writeSpy = vi.spyOn(process.stdout, 'write')
+    const code = await runCli('print', fixtureRoot)
+    expect(code).toBe(0)
+    expect(writeSpy).toHaveBeenCalled()
+  })
+
+  it('print --short emits compact human-readable output', async () => {
+    const writeSpy = vi.spyOn(process.stdout, 'write')
+    const code = await runCli('print', fixtureRoot, ['--short'])
+    expect(code).toBe(0)
+    expect(writeSpy).toHaveBeenCalledWith(
+      `group: default
+workspaces (2): packages/ws-a, packages/ws-b
+rules (3): error 2, warn 0, off 1
+eqeqeq: error "always"
+no-console: error
+no-debugger: off
+`
+    )
+  })
+
+  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'])
+    expect(code).toBe(0)
+
+    const content = await readFile(path.join(tmp, 'eslint-config-snapshot.config.mjs'), 'utf8')
+    expect(content).toContain("workspaceInput: { mode: 'discover' }")
+
+    await rm(tmp, { recursive: true, force: true })
+  })
+
+  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))
+
+    const code = await runCli('init', tmp, ['--yes', '--target', 'package-json', '--preset', 'minimal'])
+    expect(code).toBe(0)
+
+    const packageJsonRaw = await readFile(path.join(tmp, 'package.json'), 'utf8')
+    const parsed = JSON.parse(packageJsonRaw) as {
+      'eslint-config-snapshot'?: Record<string, unknown>
+    }
+    expect(parsed['eslint-config-snapshot']).toEqual({})
+
+    await rm(tmp, { recursive: true, force: true })
+  })
+
+  it('help prints usage and exits 0', async () => {
+    const writeSpy = vi.spyOn(process.stdout, 'write')
+    const code = await runCli('--help', fixtureRoot)
+    expect(code).toBe(0)
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('Usage:'))
+  })
+
+  it('runs update mode without command', async () => {
+    const writeSpy = vi.spyOn(process.stdout, 'write')
+    const code = await runCli(undefined, fixtureRoot, ['--update'])
+    expect(code).toBe(0)
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('Baseline updated:'))
+  })
+
+  it('supports canonical check and update commands', async () => {
+    expect(await runCli('update', fixtureRoot)).toBe(0)
+    expect(await runCli('check', 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 })
+
+    await writeFile(
+      path.join(tmp, 'eslint-config-snapshot.config.mjs'),
+      `export default {
+  workspaceInput: { mode: 'manual', workspaces: ['packages/ws-a', 'packages/ws-b'] },
+  grouping: {
+    mode: 'match',
+    groups: [
+      { name: 'modern', match: ['packages/**', '!packages/ws-b'] },
+      { name: 'legacy', match: ['packages/ws-b'] }
+    ]
+  },
+  sampling: {
+    maxFilesPerWorkspace: 8,
+    includeGlobs: ['**/*.ts'],
+    excludeGlobs: ['**/node_modules/**'],
+    hintGlobs: []
+  }
+}
+`
+    )
+
+    const code = await runCli('snapshot', tmp)
+    expect(code).toBe(0)
+
+    const modern = JSON.parse(await readFile(path.join(tmp, '.eslint-config-snapshot/modern.json'), 'utf8'))
+    const legacy = JSON.parse(await readFile(path.join(tmp, '.eslint-config-snapshot/legacy.json'), 'utf8'))
+
+    expect(modern.workspaces).toEqual(['packages/ws-a'])
+    expect(modern.rules).toEqual({
+      eqeqeq: ['error', 'always'],
+      'no-console': ['warn']
+    })
+
+    expect(legacy.workspaces).toEqual(['packages/ws-b'])
+    expect(legacy.rules).toEqual({
+      'no-console': ['error'],
+      'no-debugger': ['off']
+    })
+
+    await rm(tmp, { recursive: true, force: true })
+  })
+
+  it('supports standalone mode with workspace path group ids', async () => {
+    const tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-cli-standalone-'))
+    await cp(fixtureRoot, tmp, { recursive: true })
+
+    await writeFile(
+      path.join(tmp, 'eslint-config-snapshot.config.mjs'),
+      `export default {
+  workspaceInput: { mode: 'manual', workspaces: ['packages/ws-a', 'packages/ws-b'] },
+  grouping: { mode: 'standalone' },
+  sampling: {
+    maxFilesPerWorkspace: 8,
+    includeGlobs: ['**/*.ts'],
+    excludeGlobs: ['**/node_modules/**'],
+    hintGlobs: []
+  }
+}
+`
+    )
+
+    const snapshotCode = await runCli('snapshot', tmp)
+    expect(snapshotCode).toBe(0)
+
+    const wsAPath = path.join(tmp, '.eslint-config-snapshot/packages/ws-a.json')
+    const wsBPath = path.join(tmp, '.eslint-config-snapshot/packages/ws-b.json')
+    expect(JSON.parse(await readFile(wsAPath, 'utf8')).groupId).toBe('packages/ws-a')
+    expect(JSON.parse(await readFile(wsBPath, 'utf8')).groupId).toBe('packages/ws-b')
+
+    const compareCode = await runCli('compare', tmp)
+    expect(compareCode).toBe(0)
+
+    await rm(tmp, { recursive: true, force: true })
+  })
+})

package/test/cli.npm-isolated.integration.test.ts

@@ -0,0 +1,109 @@
+import { spawnSync } from 'node:child_process'
+import { access, cp, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { setTimeout as delay } from 'node:timers/promises'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+
+const templateRoot = path.resolve('test/fixtures/npm-isolated-template')
+const cliDist = path.resolve('dist/index.js')
+
+let fixtureRoot = ''
+
+function npmCmd(): string {
+  const base = path.dirname(process.execPath)
+  return process.platform === 'win32' ? path.join(base, 'npm.cmd') : path.join(base, 'npm')
+}
+
+function run(command: string, args: string[], cwd: string): { status: number; stdout: string; stderr: string } {
+  const proc = spawnSync(command, args, {
+    cwd,
+    encoding: 'utf8',
+    env: { ...process.env },
+    shell: process.platform === 'win32'
+  })
+
+  return {
+    status: proc.status ?? 1,
+    stdout: proc.stdout ?? '',
+    stderr: `${proc.stderr ?? ''}${proc.error ? `\n${String(proc.error)}` : ''}`
+  }
+}
+
+async function runWithRetry(
+  command: string,
+  args: string[],
+  cwd: string,
+  retries = 2
+): Promise<{ status: number; stdout: string; stderr: string }> {
+  let attempt = 0
+  let lastResult = run(command, args, cwd)
+  while (lastResult.status !== 0 && attempt < retries) {
+    attempt += 1
+    await delay(1000 * attempt)
+    lastResult = run(command, args, cwd)
+  }
+  return lastResult
+}
+
+describe('cli npm-isolated integration', () => {
+  beforeAll(async () => {
+    const tmpBase = await mkdtemp(path.join(os.tmpdir(), 'snapshot-npm-it-'))
+    fixtureRoot = path.join(tmpBase, 'repo')
+    await cp(templateRoot, fixtureRoot, { recursive: true })
+
+    const wsA = path.join(fixtureRoot, 'packages/ws-a')
+    const wsB = path.join(fixtureRoot, 'packages/ws-b')
+
+    const installA = await runWithRetry(npmCmd(), ['install', '--no-audit', '--no-fund', '--workspaces=false'], wsA)
+    expect(installA.status, `${installA.stdout}\n${installA.stderr}`).toBe(0)
+    await access(path.join(wsA, 'node_modules/eslint/package.json'))
+
+    const installB = await runWithRetry(npmCmd(), ['install', '--no-audit', '--no-fund', '--workspaces=false'], wsB)
+    expect(installB.status, `${installB.stdout}\n${installB.stderr}`).toBe(0)
+    await access(path.join(wsB, 'node_modules/eslint/package.json'))
+  }, 180000)
+
+  afterAll(async () => {
+    if (fixtureRoot) {
+      await rm(path.dirname(fixtureRoot), { recursive: true, force: true })
+    }
+  })
+
+  it('runs commands in isolated subprocesses with workspace-local npm eslint', async () => {
+    const snapshot = run(process.execPath, [cliDist, 'snapshot'], fixtureRoot)
+    expect(snapshot.status, snapshot.stderr).toBe(0)
+
+    const snapshotRaw = await readFile(path.join(fixtureRoot, '.eslint-config-snapshot/default.json'), 'utf8')
+    const parsed = JSON.parse(snapshotRaw)
+    expect(parsed).toEqual({
+      formatVersion: 1,
+      groupId: 'default',
+      workspaces: ['packages/ws-a', 'packages/ws-b'],
+      rules: {
+        eqeqeq: ['error', 'always'],
+        'no-console': ['error'],
+        'no-debugger': ['off']
+      }
+    })
+
+    const compareClean = run(process.execPath, [cliDist, 'compare'], fixtureRoot)
+    expect(compareClean.status, compareClean.stdout + compareClean.stderr).toBe(0)
+
+    const statusClean = run(process.execPath, [cliDist, 'status'], fixtureRoot)
+    expect(statusClean.status).toBe(0)
+    expect(statusClean.stdout).toContain('clean')
+
+    const printOut = run(process.execPath, [cliDist, 'print'], fixtureRoot)
+    expect(printOut.status, printOut.stderr).toBe(0)
+    expect(printOut.stdout).toContain('"groupId": "default"')
+
+    await writeFile(
+      path.join(fixtureRoot, 'packages/ws-a/.eslintrc.cjs'),
+      "module.exports = { root: true, rules: { 'no-console': 'warn', eqeqeq: 'off' } }\n"
+    )
+
+    const compareChanged = run(process.execPath, [cliDist, 'compare'], fixtureRoot)
+    expect(compareChanged.status).toBe(1)
+  }, 180000)
+})

package/test/cli.pnpm-isolated.integration.test.ts

@@ -0,0 +1,140 @@
+import { spawnSync } from 'node:child_process'
+import { access, cp, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { setTimeout as delay } from 'node:timers/promises'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+
+const templateRoot = path.resolve('test/fixtures/npm-isolated-template')
+const cliDist = path.resolve('dist/index.js')
+
+let fixtureRoot = ''
+
+type RunResult = {
+  status: number
+  stdout: string
+  stderr: string
+  errorCode?: string
+}
+
+type ExecCandidate = {
+  command: string
+  argsPrefix: string[]
+}
+
+function getPnpmCandidates(): ExecCandidate[] {
+  const candidates: ExecCandidate[] = []
+  const execPath = process.env.npm_execpath
+  if (execPath && execPath.toLowerCase().includes('pnpm')) {
+    candidates.push({ command: process.execPath, argsPrefix: [execPath] })
+  }
+
+  candidates.push({ command: 'pnpm', argsPrefix: [] })
+  if (process.platform === 'win32') {
+    candidates.push({ command: 'pnpm.cmd', argsPrefix: [] })
+  }
+
+  return candidates
+}
+
+function run(command: string, args: string[], cwd: string): RunResult {
+  const proc = spawnSync(command, args, {
+    cwd,
+    encoding: 'utf8',
+    env: { ...process.env },
+    shell: process.platform === 'win32'
+  })
+
+  return {
+    status: proc.status ?? 1,
+    stdout: proc.stdout ?? '',
+    stderr: `${proc.stderr ?? ''}${proc.error ? `\n${String(proc.error)}` : ''}`,
+    errorCode: proc.error?.code
+  }
+}
+
+async function runWithRetry(
+  command: string,
+  args: string[],
+  cwd: string,
+  retries = 2
+): Promise<RunResult> {
+  let attempt = 0
+  let lastResult = run(command, args, cwd)
+  while (lastResult.status !== 0 && attempt < retries) {
+    attempt += 1
+    await delay(1000 * attempt)
+    lastResult = run(command, args, cwd)
+  }
+  return lastResult
+}
+
+async function runPnpmWithRetry(args: string[], cwd: string, retries = 2): Promise<RunResult> {
+  const candidates = getPnpmCandidates()
+  let lastResult: RunResult = { status: 1, stdout: '', stderr: 'pnpm command not found' }
+
+  for (const candidate of candidates) {
+    const attempt = await runWithRetry(candidate.command, [...candidate.argsPrefix, ...args], cwd, retries)
+    if (attempt.status === 0) {
+      return attempt
+    }
+
+    lastResult = attempt
+    if (attempt.errorCode !== 'ENOENT' && !attempt.stderr.includes('ENOENT')) {
+      return attempt
+    }
+  }
+
+  return lastResult
+}
+
+describe('cli pnpm-isolated integration', () => {
+  beforeAll(async () => {
+    const tmpBase = await mkdtemp(path.join(os.tmpdir(), 'snapshot-pnpm-it-'))
+    fixtureRoot = path.join(tmpBase, 'repo')
+    await cp(templateRoot, fixtureRoot, { recursive: true })
+
+    const wsA = path.join(fixtureRoot, 'packages/ws-a')
+    const wsB = path.join(fixtureRoot, 'packages/ws-b')
+
+    const installA = await runPnpmWithRetry(['install', '--ignore-workspace', '--no-frozen-lockfile'], wsA)
+    expect(installA.status, `${installA.stdout}\n${installA.stderr}`).toBe(0)
+    await access(path.join(wsA, 'node_modules/eslint/package.json'))
+
+    const installB = await runPnpmWithRetry(['install', '--ignore-workspace', '--no-frozen-lockfile'], wsB)
+    expect(installB.status, `${installB.stdout}\n${installB.stderr}`).toBe(0)
+    await access(path.join(wsB, 'node_modules/eslint/package.json'))
+  }, 180000)
+
+  afterAll(async () => {
+    if (fixtureRoot) {
+      await rm(path.dirname(fixtureRoot), { recursive: true, force: true })
+    }
+  })
+
+  it('runs commands with workspace-local eslint installed by pnpm in isolated mode', async () => {
+    const snapshot = run(process.execPath, [cliDist, 'snapshot'], fixtureRoot)
+    expect(snapshot.status, snapshot.stderr).toBe(0)
+
+    const snapshotRaw = await readFile(path.join(fixtureRoot, '.eslint-config-snapshot/default.json'), 'utf8')
+    const parsed = JSON.parse(snapshotRaw)
+    expect(parsed).toEqual({
+      formatVersion: 1,
+      groupId: 'default',
+      workspaces: ['packages/ws-a', 'packages/ws-b'],
+      rules: {
+        eqeqeq: ['error', 'always'],
+        'no-console': ['error'],
+        'no-debugger': ['off']
+      }
+    })
+
+    await writeFile(
+      path.join(fixtureRoot, 'packages/ws-a/.eslintrc.cjs'),
+      "module.exports = { root: true, rules: { 'no-console': 'warn', eqeqeq: 'off' } }\n"
+    )
+
+    const compareChanged = run(process.execPath, [cliDist, 'compare'], fixtureRoot)
+    expect(compareChanged.status).toBe(1)
+  }, 180000)
+})