@eslint-config-snapshot/api 0.1.0

package/src/workspace.ts

@@ -0,0 +1,130 @@
+import { getPackages } from '@manypkg/get-packages'
+import path from 'node:path'
+import picomatch from 'picomatch'
+
+import { normalizePath, sortUnique } from './core.js'
+
+export type WorkspaceDiscovery = {
+  rootAbs: string
+  workspacesRel: string[]
+}
+
+export type WorkspaceInput =
+  | {
+      mode: 'discover'
+    }
+  | {
+      mode: 'manual'
+      rootAbs?: string
+      workspaces: string[]
+    }
+
+export type GroupDefinition = {
+  name: string
+  match: string[]
+}
+
+export type GroupAssignment = {
+  name: string
+  workspaces: string[]
+}
+
+export async function discoverWorkspaces(options?: {
+  cwd?: string
+  workspaceInput?: WorkspaceInput
+}): Promise<WorkspaceDiscovery> {
+  const cwd = options?.cwd ? path.resolve(options.cwd) : process.cwd()
+  const workspaceInput = options?.workspaceInput ?? { mode: 'discover' as const }
+
+  if (workspaceInput.mode === 'manual') {
+    const rootAbs = path.resolve(workspaceInput.rootAbs ?? cwd)
+    return {
+      rootAbs,
+      workspacesRel: sortUnique(workspaceInput.workspaces)
+    }
+  }
+
+  const { rootDir, packages } = await getPackages(cwd)
+  const workspacesAbs = packages.map((pkg) => pkg.dir)
+  const rootAbs = rootDir ? path.resolve(rootDir) : lowestCommonAncestor(workspacesAbs)
+  const workspacesRel = sortUnique(workspacesAbs.map((entry) => normalizePath(path.relative(rootAbs, entry))))
+
+  return {
+    rootAbs,
+    workspacesRel
+  }
+}
+
+export function assignGroupsByMatch(workspacesRel: readonly string[], groups: readonly GroupDefinition[]): GroupAssignment[] {
+  const sortedWorkspaces = sortUnique([...workspacesRel])
+  const assignments = new Map<string, string[]>()
+
+  for (const group of groups) {
+    assignments.set(group.name, [])
+  }
+
+  const unmatched: string[] = []
+
+  for (const workspace of sortedWorkspaces) {
+    let assigned = false
+
+    for (const group of groups) {
+      if (matchesWorkspace(workspace, group.match)) {
+        assignments.get(group.name)?.push(workspace)
+        assigned = true
+        break
+      }
+    }
+
+    if (!assigned) {
+      unmatched.push(workspace)
+    }
+  }
+
+  if (unmatched.length > 0) {
+    throw new Error(`Unmatched workspaces: ${unmatched.join(', ')}`)
+  }
+
+  return groups.map((group) => ({
+    name: group.name,
+    workspaces: assignments.get(group.name) ?? []
+  }))
+}
+
+function matchesWorkspace(workspace: string, patterns: readonly string[]): boolean {
+  const positives = patterns.filter((pattern) => !pattern.startsWith('!'))
+  const negatives = patterns.filter((pattern) => pattern.startsWith('!')).map((pattern) => pattern.slice(1))
+
+  const isPositiveMatch = positives.some((pattern) => picomatch(pattern, { dot: true })(workspace))
+  if (!isPositiveMatch) {
+    return false
+  }
+
+  const isNegativeMatch = negatives.some((pattern) => picomatch(pattern, { dot: true })(workspace))
+  return !isNegativeMatch
+}
+
+function lowestCommonAncestor(paths: readonly string[]): string {
+  if (paths.length === 0) {
+    return process.cwd()
+  }
+
+  const segments = paths.map((entry) => path.resolve(entry).split(path.sep))
+  const minLen = Math.min(...segments.map((parts) => parts.length))
+
+  const common: string[] = []
+  for (let index = 0; index < minLen; index += 1) {
+    const value = segments[0][index]
+    if (segments.every((parts) => parts[index] === value)) {
+      common.push(value)
+    } else {
+      break
+    }
+  }
+
+  if (common.length === 0) {
+    return path.parse(path.resolve(paths[0])).root
+  }
+
+  return common.join(path.sep)
+}

package/test/api.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest'
+
+import { normalizePath, sortUnique } from '../src/index.js'
+
+describe('api', () => {
+  it('re-exports core utils', () => {
+    expect(normalizePath('a\\b/')).toBe('a/b')
+    expect(sortUnique(['b', 'a'])).toEqual(['a', 'b'])
+  })
+})

package/test/config.test.ts

@@ -0,0 +1,100 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { DEFAULT_CONFIG, loadConfig } from '../src/index.js'
+
+let tmp = ''
+
+afterEach(async () => {
+  if (tmp) {
+    await rm(tmp, { recursive: true, force: true })
+    tmp = ''
+  }
+})
+
+describe('loadConfig', () => {
+  it('returns defaults when no config is found', async () => {
+    tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-config-'))
+    const config = await loadConfig(tmp)
+    expect(config).toEqual(DEFAULT_CONFIG)
+  })
+
+  it('uses deterministic search order and picks the first matching file', async () => {
+    tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-config-'))
+    await writeFile(path.join(tmp, '.eslint-config-snapshot.cjs'), 'module.exports = { sampling: { maxFilesPerWorkspace: 2 } }\n')
+    await writeFile(path.join(tmp, 'eslint-config-snapshot.config.mjs'), 'export default { sampling: { maxFilesPerWorkspace: 9 } }\n')
+
+    const config = await loadConfig(tmp)
+    expect(config.sampling.maxFilesPerWorkspace).toBe(2)
+  })
+
+  it('loads config from package.json field', async () => {
+    tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-config-'))
+    await writeFile(
+      path.join(tmp, 'package.json'),
+      JSON.stringify(
+        {
+          name: 'fixture',
+          private: true,
+          'eslint-config-snapshot': {
+            workspaceInput: { mode: 'manual', workspaces: ['packages/z', 'packages/a'] },
+            grouping: { mode: 'standalone' },
+            sampling: { maxFilesPerWorkspace: 5, includeGlobs: ['**/*.tsx'] }
+          }
+        },
+        null,
+        2
+      )
+    )
+
+    const config = await loadConfig(tmp)
+    expect(config.workspaceInput).toEqual({ mode: 'manual', workspaces: ['packages/z', 'packages/a'] })
+    expect(config.grouping.mode).toBe('standalone')
+    expect(config.sampling.maxFilesPerWorkspace).toBe(5)
+    expect(config.sampling.includeGlobs).toEqual(['**/*.tsx'])
+    expect(config.sampling.excludeGlobs).toEqual(DEFAULT_CONFIG.sampling.excludeGlobs)
+  })
+
+  it('loads config from rc json file', async () => {
+    tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-config-'))
+    await writeFile(path.join(tmp, '.eslint-config-snapshotrc.json'), JSON.stringify({ sampling: { maxFilesPerWorkspace: 7 } }))
+
+    const config = await loadConfig(tmp)
+    expect(config.sampling.maxFilesPerWorkspace).toBe(7)
+  })
+
+  it('executes function exports', async () => {
+    tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-config-'))
+    await writeFile(
+      path.join(tmp, '.eslint-config-snapshot.js'),
+      'export default () => ({ grouping: { mode: "standalone" }, sampling: { hintGlobs: ["src/**"] } })\n'
+    )
+
+    const config = await loadConfig(tmp)
+    expect(config.grouping.mode).toBe('standalone')
+    expect(config.sampling.hintGlobs).toEqual(['src/**'])
+  })
+
+  it('executes async function exports', async () => {
+    tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-config-'))
+    await writeFile(
+      path.join(tmp, '.eslint-config-snapshot.mjs'),
+      'export default async () => ({ sampling: { maxFilesPerWorkspace: 3, hintGlobs: ["src/**"] } })\n'
+    )
+
+    const config = await loadConfig(tmp)
+    expect(config.sampling.maxFilesPerWorkspace).toBe(3)
+    expect(config.sampling.hintGlobs).toEqual(['src/**'])
+  })
+
+  it('throws deterministic error when config export is invalid', async () => {
+    tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-config-'))
+    await writeFile(path.join(tmp, '.eslint-config-snapshot.cjs'), 'module.exports = 42\n')
+
+    await expect(loadConfig(tmp)).rejects.toThrow(
+      'Invalid config export: expected object, function, or async function returning an object'
+    )
+  })
+})

package/test/core.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest'
+
+import { canonicalizeJson, normalizePath, normalizeSeverity, sortUnique } from '../src/index.js'
+
+describe('core utils', () => {
+  it('normalizes path separators and trailing slash', () => {
+    expect(normalizePath('packages\\a\\')).toBe('packages/a')
+  })
+
+  it('sorts unique normalized list', () => {
+    expect(sortUnique(['b', 'a/', 'a', 'b\\c'])).toEqual(['a', 'b', 'b/c'])
+  })
+
+  it('canonicalizes object keys recursively', () => {
+    const input = { z: 1, a: { d: 1, c: 2 } }
+    expect(canonicalizeJson(input)).toEqual({ a: { c: 2, d: 1 }, z: 1 })
+  })
+
+  it('normalizes numeric severity', () => {
+    expect(normalizeSeverity(0)).toBe('off')
+    expect(normalizeSeverity(1)).toBe('warn')
+    expect(normalizeSeverity(2)).toBe('error')
+  })
+})

package/test/diff.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest'
+
+import { diffSnapshots, hasDiff } from '../src/index.js'
+
+describe('diffSnapshots', () => {
+  it('detects rule and workspace changes', () => {
+    const before = {
+      formatVersion: 1 as const,
+      groupId: 'default',
+      workspaces: ['packages/a'],
+      rules: {
+        a: ['warn'] as ['warn'],
+        b: ['error', { allow: false }] as ['error', { allow: boolean }]
+      }
+    }
+
+    const after = {
+      formatVersion: 1 as const,
+      groupId: 'default',
+      workspaces: ['packages/b'],
+      rules: {
+        a: ['error'] as ['error'],
+        c: ['warn'] as ['warn']
+      }
+    }
+
+    const diff = diffSnapshots(before, after)
+    expect(diff.introducedRules).toEqual(['c'])
+    expect(diff.removedRules).toEqual(['b'])
+    expect(diff.severityChanges).toEqual([{ rule: 'a', before: 'warn', after: 'error' }])
+    expect(diff.workspaceMembershipChanges).toEqual({ added: ['packages/b'], removed: ['packages/a'] })
+    expect(hasDiff(diff)).toBe(true)
+  })
+
+  it('ignores option changes when severity is off and keeps meaningful option diffs', () => {
+    const before = {
+      formatVersion: 1 as const,
+      groupId: 'default',
+      workspaces: ['packages/a'],
+      rules: {
+        offRule: ['off', { a: 1 }] as ['off', { a: number }],
+        configured: ['error', { allow: false }] as ['error', { allow: boolean }]
+      }
+    }
+
+    const after = {
+      formatVersion: 1 as const,
+      groupId: 'default',
+      workspaces: ['packages/a'],
+      rules: {
+        offRule: ['off'] as ['off'],
+        configured: ['error', { allow: true }] as ['error', { allow: boolean }]
+      }
+    }
+
+    const diff = diffSnapshots(before, after)
+    expect(diff.removedRules).toContain('offRule')
+    expect(diff.optionChanges).toEqual([{ rule: 'configured', before: { allow: false }, after: { allow: true } }])
+  })
+})

package/test/extract.test.ts

@@ -0,0 +1,140 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { afterAll, describe, expect, it } from 'vitest'
+
+import { extractRulesFromPrintConfig, resolveEslintBinForWorkspace } from '../src/index.js'
+
+const workspace = path.join(os.tmpdir(), `snapshot-extract-${Date.now()}`)
+
+afterAll(async () => {
+  await rm(workspace, { recursive: true, force: true })
+  await rm(`${workspace}-exports`, { recursive: true, force: true })
+})
+
+describe('extract', () => {
+  it('resolves eslint workspace-locally and normalizes rules', async () => {
+    await mkdir(path.join(workspace, 'node_modules/eslint/bin'), { recursive: true })
+    await mkdir(path.join(workspace, 'src'), { recursive: true })
+
+    await writeFile(
+      path.join(workspace, 'node_modules/eslint/package.json'),
+      JSON.stringify({ name: 'eslint', version: '0.0.0' }, null, 2)
+    )
+
+    await writeFile(
+      path.join(workspace, 'node_modules/eslint/bin/eslint.js'),
+      "console.log(JSON.stringify({ rules: { 'no-console': 1, eqeqeq: [2, 'always'] } }))"
+    )
+
+    const fileAbs = path.join(workspace, 'src/index.ts')
+    await writeFile(fileAbs, 'export {}\n')
+
+    const resolved = resolveEslintBinForWorkspace(workspace)
+    expect(resolved.replaceAll('\\', '/').includes('eslint/bin/eslint')).toBe(true)
+
+    const rules = extractRulesFromPrintConfig(workspace, fileAbs)
+    expect(Object.fromEntries(rules.entries())).toEqual({
+      'no-console': ['warn'],
+      eqeqeq: ['error', 'always']
+    })
+  })
+
+  it('falls back to eslint package entry when bin subpath is not directly resolvable', async () => {
+    const exportedWorkspace = `${workspace}-exports`
+    await mkdir(path.join(exportedWorkspace, 'node_modules/eslint/bin'), { recursive: true })
+    await mkdir(path.join(exportedWorkspace, 'src'), { recursive: true })
+
+    await writeFile(
+      path.join(exportedWorkspace, 'node_modules/eslint/package.json'),
+      JSON.stringify(
+        {
+          name: 'eslint',
+          version: '0.0.0',
+          type: 'commonjs',
+          main: './index.js',
+          exports: {
+            '.': './index.js'
+          },
+          bin: {
+            eslint: './bin/eslint.js'
+          }
+        },
+        null,
+        2
+      )
+    )
+
+    await writeFile(path.join(exportedWorkspace, 'node_modules/eslint/index.js'), 'module.exports = {}')
+    await writeFile(
+      path.join(exportedWorkspace, 'node_modules/eslint/bin/eslint.js'),
+      "console.log(JSON.stringify({ rules: { 'no-alert': 2 } }))"
+    )
+
+    const fileAbs = path.join(exportedWorkspace, 'src/index.ts')
+    await writeFile(fileAbs, 'export {}\n')
+
+    const resolved = resolveEslintBinForWorkspace(exportedWorkspace)
+    expect(resolved.replaceAll('\\', '/').endsWith('/node_modules/eslint/bin/eslint.js')).toBe(true)
+
+    const rules = extractRulesFromPrintConfig(exportedWorkspace, fileAbs)
+    expect(Object.fromEntries(rules.entries())).toEqual({
+      'no-alert': ['error']
+    })
+  })
+
+  it('throws when eslint cannot be resolved from workspace', () => {
+    const missingWorkspace = `${workspace}-missing`
+    expect(() => resolveEslintBinForWorkspace(missingWorkspace)).toThrow(
+      `Unable to resolve eslint from workspace: ${missingWorkspace}`
+    )
+  })
+
+  it('throws when eslint print-config returns invalid JSON', async () => {
+    const invalidWorkspace = `${workspace}-invalid-json`
+    await mkdir(path.join(invalidWorkspace, 'node_modules/eslint/bin'), { recursive: true })
+    await mkdir(path.join(invalidWorkspace, 'src'), { recursive: true })
+    await writeFile(path.join(invalidWorkspace, 'node_modules/eslint/package.json'), JSON.stringify({ name: 'eslint', version: '0.0.0' }, null, 2))
+    await writeFile(path.join(invalidWorkspace, 'node_modules/eslint/bin/eslint.js'), "console.log('not json')\n")
+
+    const fileAbs = path.join(invalidWorkspace, 'src/index.ts')
+    await writeFile(fileAbs, 'export {}\n')
+
+    expect(() => extractRulesFromPrintConfig(invalidWorkspace, fileAbs)).toThrow(
+      `Invalid JSON from eslint --print-config for ${fileAbs}`
+    )
+  })
+
+  it('throws when eslint print-config returns undefined output', async () => {
+    const undefinedWorkspace = `${workspace}-undefined`
+    await mkdir(path.join(undefinedWorkspace, 'node_modules/eslint/bin'), { recursive: true })
+    await mkdir(path.join(undefinedWorkspace, 'src'), { recursive: true })
+    await writeFile(path.join(undefinedWorkspace, 'node_modules/eslint/package.json'), JSON.stringify({ name: 'eslint', version: '0.0.0' }, null, 2))
+    await writeFile(path.join(undefinedWorkspace, 'node_modules/eslint/bin/eslint.js'), "console.log('undefined')\n")
+
+    const fileAbs = path.join(undefinedWorkspace, 'src/index.ts')
+    await writeFile(fileAbs, 'export {}\n')
+
+    expect(() => extractRulesFromPrintConfig(undefinedWorkspace, fileAbs)).toThrow(
+      `Empty ESLint print-config output for ${fileAbs}`
+    )
+  })
+
+  it('throws when eslint print-config exits non-zero', async () => {
+    const failingWorkspace = `${workspace}-failing`
+    await mkdir(path.join(failingWorkspace, 'node_modules/eslint/bin'), { recursive: true })
+    await mkdir(path.join(failingWorkspace, 'src'), { recursive: true })
+    await writeFile(path.join(failingWorkspace, 'node_modules/eslint/package.json'), JSON.stringify({ name: 'eslint', version: '0.0.0' }, null, 2))
+    await writeFile(
+      path.join(failingWorkspace, 'node_modules/eslint/bin/eslint.js'),
+      "process.stderr.write('failure'); process.exit(2)\n"
+    )
+
+    const fileAbs = path.join(failingWorkspace, 'src/index.ts')
+    await writeFile(fileAbs, 'export {}\n')
+
+    expect(() => extractRulesFromPrintConfig(failingWorkspace, fileAbs)).toThrow(
+      `Failed to run eslint --print-config for ${fileAbs}`
+    )
+  })
+})

package/test/sampling.test.ts

@@ -0,0 +1,91 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { afterAll, describe, expect, it } from 'vitest'
+
+import { sampleWorkspaceFiles } from '../src/index.js'
+
+const tmp = path.join(os.tmpdir(), `snapshot-sampling-${Date.now()}`)
+
+afterAll(async () => {
+  await import('node:fs/promises').then((fs) => fs.rm(tmp, { recursive: true, force: true }))
+})
+
+describe('sampleWorkspaceFiles', () => {
+  it('returns deterministic sorted sample', async () => {
+    await mkdir(path.join(tmp, 'src'), { recursive: true })
+    await writeFile(path.join(tmp, 'src', 'b.ts'), '')
+    await writeFile(path.join(tmp, 'src', 'a.ts'), '')
+
+    const result = await sampleWorkspaceFiles(tmp, {
+      maxFilesPerWorkspace: 8,
+      includeGlobs: ['**/*.ts'],
+      excludeGlobs: [],
+      hintGlobs: []
+    })
+
+    expect(result).toEqual(['src/a.ts', 'src/b.ts'])
+  })
+
+  it('selects uniformly distributed files when candidates exceed max', async () => {
+    await mkdir(path.join(tmp, 'many'), { recursive: true })
+    for (let index = 0; index < 20; index += 1) {
+      const name = `file-${String(index).padStart(2, '0')}.ts`
+      await writeFile(path.join(tmp, 'many', name), '')
+    }
+
+    const result = await sampleWorkspaceFiles(tmp, {
+      maxFilesPerWorkspace: 8,
+      includeGlobs: ['many/**/*.ts'],
+      excludeGlobs: [],
+      hintGlobs: []
+    })
+
+    expect(result).toEqual([
+      'many/file-00.ts',
+      'many/file-01.ts',
+      'many/file-04.ts',
+      'many/file-07.ts',
+      'many/file-10.ts',
+      'many/file-13.ts',
+      'many/file-16.ts',
+      'many/file-19.ts'
+    ])
+  })
+
+  it('prefers token-diverse hinted files before fallback spacing', async () => {
+    await mkdir(path.join(tmp, 'tokens'), { recursive: true })
+    const files = [
+      'tokens/auth.service.ts',
+      'tokens/billing.service.ts',
+      'tokens/catalog.service.ts',
+      'tokens/auth.controller.ts',
+      'tokens/billing.controller.ts',
+      'tokens/catalog.controller.ts',
+      'tokens/shared.util.ts',
+      'tokens/shared.helper.ts',
+      'tokens/shared.format.ts',
+      'tokens/shared.view.ts'
+    ]
+
+    for (const file of files) {
+      await writeFile(path.join(tmp, file), '')
+    }
+
+    const result = await sampleWorkspaceFiles(tmp, {
+      maxFilesPerWorkspace: 6,
+      includeGlobs: ['tokens/**/*.ts'],
+      excludeGlobs: [],
+      hintGlobs: ['tokens/**/*.service.ts']
+    })
+
+    expect(result).toEqual([
+      'tokens/auth.controller.ts',
+      'tokens/auth.service.ts',
+      'tokens/billing.service.ts',
+      'tokens/catalog.service.ts',
+      'tokens/shared.format.ts',
+      'tokens/shared.view.ts'
+    ])
+  })
+})

package/test/snapshot.test.ts

@@ -0,0 +1,64 @@
+import { mkdtemp, readFile, rm } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { afterAll, describe, expect, it } from 'vitest'
+
+import { aggregateRules, buildSnapshot, writeSnapshotFile } from '../src/index.js'
+
+let tmpDir = ''
+
+afterAll(async () => {
+  if (tmpDir) {
+    await rm(tmpDir, { recursive: true, force: true })
+  }
+})
+
+describe('snapshot', () => {
+  it('writes deterministic json', async () => {
+    tmpDir = await mkdtemp(path.join(os.tmpdir(), 'snapshot-snapshot-'))
+
+    const snapshot = buildSnapshot('default', ['packages/b', 'packages/a'], new Map([
+      ['z-rule', ['warn']],
+      ['a-rule', ['error', { b: 1, a: 2 }]]
+    ]))
+
+    const output = await writeSnapshotFile(tmpDir, snapshot)
+    const content = await readFile(output, 'utf8')
+
+    expect(content).toContain('"formatVersion": 1')
+    expect(content.endsWith('\n')).toBe(true)
+    expect(content.indexOf('"a-rule"')).toBeLessThan(content.indexOf('"z-rule"'))
+  })
+
+  it('aggregates by highest severity', () => {
+    const result = aggregateRules([
+      new Map([['no-console', ['warn'] as const]]),
+      new Map([['no-console', ['error'] as const], ['eqeqeq', ['error', 'always'] as const]])
+    ])
+
+    expect(Object.fromEntries(result.entries())).toEqual({
+      eqeqeq: ['error', 'always'],
+      'no-console': ['error']
+    })
+  })
+
+  it('uses options from highest severity when severities differ', () => {
+    const result = aggregateRules([
+      new Map([['no-unused-vars', ['warn', { args: 'none' }] as const]]),
+      new Map([['no-unused-vars', ['error', { argsIgnorePattern: '^_' }] as const]])
+    ])
+
+    expect(Object.fromEntries(result.entries())).toEqual({
+      'no-unused-vars': ['error', { argsIgnorePattern: '^_' }]
+    })
+  })
+
+  it('throws on conflicting options at same severity', () => {
+    expect(() =>
+      aggregateRules([
+        new Map([['no-restricted-imports', ['error', { paths: ['a'] }] as const]]),
+        new Map([['no-restricted-imports', ['error', { paths: ['b'] }] as const]])
+      ])
+    ).toThrow('Conflicting rule options for no-restricted-imports at severity error')
+  })
+})

package/test/workspace.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest'
+
+import { assignGroupsByMatch } from '../src/index.js'
+
+describe('assignGroupsByMatch', () => {
+  it('assigns by first matching group and supports negatives', () => {
+    const result = assignGroupsByMatch(['ops/a', 'packages/new', 'packages/legacy/x'], [
+      { name: 'ops', match: ['ops/**'] },
+      { name: 'modern', match: ['packages/**', '!packages/legacy/**'] },
+      { name: 'default', match: ['**/*'] }
+    ])
+
+    expect(result).toEqual([
+      { name: 'ops', workspaces: ['ops/a'] },
+      { name: 'modern', workspaces: ['packages/new'] },
+      { name: 'default', workspaces: ['packages/legacy/x'] }
+    ])
+  })
+
+  it('throws deterministic unmatched error', () => {
+    expect(() => assignGroupsByMatch(['packages/a'], [{ name: 'ops', match: ['ops/**'] }])).toThrow(
+      'Unmatched workspaces: packages/a'
+    )
+  })
+})

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "extends":  "../../tsconfig.base.json",
+    "compilerOptions":  {
+
+                        },
+    "include":  [
+                    "src/**/*.ts"
+                ],
+    "references":  [
+
+                   ]
+}