infra-kit 0.1.102 → 0.1.107

package/src/lib/managed-block/managed-block.ts

@@ -0,0 +1,145 @@
+/**
+ * Generic "managed block" helpers — a marker-delimited region a tool owns and
+ * rewrites idempotently while never touching content outside the markers.
+ *
+ * This is the same mechanism `infra-kit init` already uses for the `~/.zshrc`
+ * shell block (`# -- infra-kit:begin -- … # -- infra-kit:end --`), lifted here so
+ * it can be reused for the repo agent-instruction files (`AGENTS.md`,
+ * `CLAUDE.md` import region, `.cursor/rules`). It mirrors the design of OMC's
+ * `<!-- OMC:START --> … <!-- OMC:END -->` CLAUDE.md installer.
+ */
+
+/**
+ * Where a freshly upserted block lands relative to existing content.
+ *
+ * - `replace-in-place`: if the block already exists, rewrite it where it sits
+ *   (surrounding text untouched, verbatim); if absent, append it at end-of-file.
+ * - `append-end`: strip any existing block from wherever it is, then append the
+ *   fresh block at end-of-file (i.e. always relocate to the end). This preserves
+ *   the historical `~/.zshrc` behavior of `removeExistingBlock` + append.
+ */
+export type BlockPlacement = 'replace-in-place' | 'append-end'
+
+export interface UpsertManagedBlockArgs {
+  /** Existing file content (`''` for a new file). */
+  content: string
+  /** Inner body to place between the markers (WITHOUT the markers). */
+  body: string
+  startMarker: string
+  endMarker: string
+  /** Defaults to `replace-in-place`. */
+  placement?: BlockPlacement
+}
+
+/**
+ * Whether `content` contains a well-formed `start … end` block. A reversed pair
+ * (end before start) is treated as absent — the same guard `doctor.ts` applies
+ * to the zshrc block, ported here so corrupted markers never match.
+ *
+ * @example
+ * hasManagedBlock('a<!--s-->x<!--e-->b', '<!--s-->', '<!--e-->') // => true
+ * hasManagedBlock('<!--e--><!--s-->', '<!--s-->', '<!--e-->')    // => false (reversed)
+ */
+export const hasManagedBlock = (content: string, startMarker: string, endMarker: string): boolean => {
+  const startIdx = content.indexOf(startMarker)
+  const endIdx = content.indexOf(endMarker)
+
+  return startIdx !== -1 && endIdx !== -1 && endIdx >= startIdx
+}
+
+/**
+ * Remove the first complete `start … end` block, preserving surrounding text.
+ * Returns `null` when no well-formed block is present (no markers, or reversed),
+ * so callers can fall through to legacy-format handling — this matches the
+ * `string | null` contract of `init.ts`'s original `removeBetween`, with the
+ * added reversed-marker guard.
+ *
+ * @example
+ * removeManagedBlock('top\n<!--s-->mid<!--e-->\nbot', '<!--s-->', '<!--e-->')
+ * // => 'top\nbot'
+ */
+export const removeManagedBlock = (content: string, startMarker: string, endMarker: string): string | null => {
+  const startIdx = content.indexOf(startMarker)
+  const endIdx = content.indexOf(endMarker)
+
+  if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) return null
+
+  // eslint-disable-next-line sonarjs/slow-regex
+  const before = content.slice(0, startIdx).replace(/\n+$/, '')
+  const after = content.slice(endIdx + endMarker.length).replace(/^\n+/, '')
+
+  return before + (after ? `\n${after}` : '')
+}
+
+/**
+ * Read the version token that follows `versionPrefix` (e.g.
+ * `'<!-- infra-kit:version '`). Returns the token up to the next whitespace or
+ * `>`, or `null` if the prefix is absent. Mirrors OMC's `OMC:VERSION:` line.
+ *
+ * @example
+ * extractVersion('<!-- infra-kit:version 0.1.105 -->', '<!-- infra-kit:version ')
+ * // => '0.1.105'
+ */
+export const extractVersion = (content: string, versionPrefix: string): string | null => {
+  const idx = content.indexOf(versionPrefix)
+
+  if (idx === -1) return null
+
+  const rest = content.slice(idx + versionPrefix.length)
+  const match = rest.match(/^([^\s>]+)/)
+
+  return match ? match[1]! : null
+}
+
+/**
+ * Compose a full block string: `start\n{body}\nend`. Kept identical in shape to
+ * the historical `buildShellBlock()` output so doctor's exact-match comparison
+ * stays valid.
+ */
+export const buildManagedBlock = (startMarker: string, body: string, endMarker: string): string => {
+  return `${startMarker}\n${body}\n${endMarker}`
+}
+
+/**
+ * Insert or update a managed block in `content`, preserving everything outside
+ * the markers. Idempotent: re-running with the same body yields the same block
+ * and never nests duplicates.
+ *
+ * @example
+ * // fresh file
+ * upsertManagedBlock({ content: '', body: 'hi', startMarker: '<!--s-->', endMarker: '<!--e-->' })
+ * // => '<!--s-->\nhi\n<!--e-->\n'
+ *
+ * @example
+ * // existing block replaced in place, surrounding text kept
+ * upsertManagedBlock({
+ *   content: 'top\n<!--s-->\nold\n<!--e-->\nbot',
+ *   body: 'new', startMarker: '<!--s-->', endMarker: '<!--e-->',
+ * })
+ * // => 'top\n<!--s-->\nnew\n<!--e-->\nbot'
+ */
+export const upsertManagedBlock = ({
+  content,
+  body,
+  startMarker,
+  endMarker,
+  placement = 'replace-in-place',
+}: UpsertManagedBlockArgs): string => {
+  const block = buildManagedBlock(startMarker, body, endMarker)
+  const present = hasManagedBlock(content, startMarker, endMarker)
+
+  if (placement === 'replace-in-place' && present) {
+    const startIdx = content.indexOf(startMarker)
+    const endIdx = content.indexOf(endMarker) + endMarker.length
+
+    return content.slice(0, startIdx) + block + content.slice(endIdx)
+  }
+
+  // append-end, or replace-in-place with no existing block: drop any stale block
+  // then append the fresh one at end-of-file.
+  const stripped = present ? (removeManagedBlock(content, startMarker, endMarker) ?? content) : content
+  // eslint-disable-next-line sonarjs/slow-regex
+  const base = stripped.replace(/\n+$/, '')
+
+  return base.length > 0 ? `${base}\n${block}\n` : `${block}\n`
+}

package/src/lib/package-config/__tests__/package-config.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest'
+
+import { DEFAULT_RULES, ROOT_DEFAULT_RULES, defineConfig, resolvePackageConfig } from '../package-config'
+import { packageConfigSchema } from '../package-config-schema'
+
+describe('defineConfig', () => {
+  it('returns an object input unchanged (identity)', () => {
+    const input = { requiredScripts: ['build'] }
+
+    expect(defineConfig(input)).toBe(input)
+  })
+
+  it('returns a factory input unchanged so the loader can resolve it', () => {
+    const factory = () => {
+      return { requiredFiles: ['a.txt'] }
+    }
+
+    expect(defineConfig(factory)).toBe(factory)
+  })
+})
+
+describe('resolvePackageConfig', () => {
+  it('falls back to defaults for every unset key', () => {
+    const rules = resolvePackageConfig({})
+
+    expect(rules.requiredScripts).toEqual(DEFAULT_RULES.requiredScripts)
+    expect(rules.requiredFiles).toEqual(DEFAULT_RULES.requiredFiles)
+  })
+
+  it('replaces a key wholesale when provided, including an empty array opt-out', () => {
+    const rules = resolvePackageConfig({ requiredScripts: [], requiredFiles: ['serverless.common.yml'] })
+
+    expect(rules.requiredScripts).toEqual([])
+    expect(rules.requiredFiles).toEqual(['serverless.common.yml'])
+  })
+
+  it('does not share the default array reference with the resolved result', () => {
+    const rules = resolvePackageConfig({})
+
+    rules.requiredScripts.push('mutated')
+
+    expect(DEFAULT_RULES.requiredScripts).not.toContain('mutated')
+  })
+
+  it('falls back to the supplied baseline (root) for unset keys, including turbo tasks', () => {
+    const rules = resolvePackageConfig({}, ROOT_DEFAULT_RULES)
+
+    expect(rules.requiredScripts).toEqual(ROOT_DEFAULT_RULES.requiredScripts)
+    expect(rules.turboTasks).toEqual(ROOT_DEFAULT_RULES.turboTasks)
+  })
+
+  it('lets a config override turbo.requiredTasks', () => {
+    const rules = resolvePackageConfig({ turbo: { requiredTasks: ['build'] } }, ROOT_DEFAULT_RULES)
+
+    expect(rules.turboTasks).toEqual(['build'])
+  })
+
+  it('defaults turboTasks to an empty array for packages', () => {
+    const rules = resolvePackageConfig({})
+
+    expect(rules.turboTasks).toEqual([])
+  })
+})
+
+describe('packageConfigSchema', () => {
+  it('rejects unknown keys so config typos surface as errors', () => {
+    const result = packageConfigSchema.safeParse({ requiredScript: ['build'] })
+
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a non-array requiredScripts', () => {
+    const result = packageConfigSchema.safeParse({ requiredScripts: 'build' })
+
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts a well-formed config', () => {
+    const result = packageConfigSchema.safeParse({ requiredScripts: ['build'], requiredFiles: ['tsconfig.json'] })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts a turbo.requiredTasks block', () => {
+    const result = packageConfigSchema.safeParse({ turbo: { requiredTasks: ['build', 'validate'] } })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects an unknown key inside turbo', () => {
+    const result = packageConfigSchema.safeParse({ turbo: { tasks: ['build'] } })
+
+    expect(result.success).toBe(false)
+  })
+})

package/src/lib/package-config/index.ts

@@ -0,0 +1,3 @@
+export { DEFAULT_RULES, defineConfig, resolvePackageConfig, ROOT_DEFAULT_RULES } from './package-config'
+export type { InfraKitPackageConfig, InfraKitPackageConfigInput, ResolvedPackageRules } from './package-config'
+export { packageConfigSchema } from './package-config-schema'

package/src/lib/package-config/package-config-schema.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod'
+
+/**
+ * Schema for the resolved (post-factory) package config object. `strictObject`
+ * rejects unknown keys so typos in `infra-kit.config.ts` surface as validation
+ * errors instead of being silently ignored.
+ *
+ * Kept in its own module — separate from the public `defineConfig`/types entry —
+ * so the published `infra-kit` type surface stays free of a `zod` import.
+ */
+export const packageConfigSchema = z.strictObject({
+  requiredScripts: z.array(z.string().min(1)).optional(),
+  requiredFiles: z.array(z.string().min(1)).optional(),
+  turbo: z
+    .strictObject({
+      requiredTasks: z.array(z.string().min(1)).optional(),
+    })
+    .optional(),
+})

package/src/lib/package-config/package-config.ts

@@ -0,0 +1,99 @@
+/**
+ * Validation rules for a single workspace package, declared in its
+ * `infra-kit.config.js`. Every field is optional: a key left unset falls back to
+ * the active baseline ({@link DEFAULT_RULES} for packages, {@link ROOT_DEFAULT_RULES}
+ * for the monorepo root), and a key set replaces that default wholesale (per-key,
+ * no array concatenation) so a package can opt out with an explicit empty array.
+ *
+ * Most packages need none of these — the standard rules live in the baseline, so
+ * a typical config is just `defineConfig(() => ({}))`.
+ *
+ * @example
+ * // infra-kit.config.js
+ * import { defineConfig } from 'infra-kit'
+ *
+ * export default defineConfig(() => ({}))
+ */
+export interface InfraKitPackageConfig {
+  /** Scripts that must be present in the package's package.json `scripts` map. */
+  requiredScripts?: string[]
+  /** Files (relative to the package root) that must exist on disk. */
+  requiredFiles?: string[]
+  /** Turborepo expectations — only meaningful where a turbo.json lives (the root). */
+  turbo?: {
+    /** Tasks that must be defined in turbo.json `tasks`. */
+    requiredTasks?: string[]
+  }
+}
+
+/**
+ * Accepted shapes for a package config's default export — mirrors Vite's
+ * `defineConfig` input: a plain object, a sync factory, or an async factory.
+ */
+export type InfraKitPackageConfigInput =
+  | InfraKitPackageConfig
+  | (() => InfraKitPackageConfig)
+  | (() => Promise<InfraKitPackageConfig>)
+
+/**
+ * Identity helper that gives `infra-kit.config.js` authors full type inference
+ * and editor autocomplete without changing the value — exactly like Vite's
+ * `defineConfig`. Resolution of the factory form happens in the loader, not here.
+ *
+ * @example
+ * export default defineConfig(() => ({}))
+ *
+ * @example
+ * export default defineConfig(() => ({ requiredScripts: [] }))
+ */
+export const defineConfig = (config: InfraKitPackageConfigInput): InfraKitPackageConfigInput => {
+  return config
+}
+
+/** Fully-resolved rules with every defaultable field present. */
+export interface ResolvedPackageRules {
+  requiredScripts: string[]
+  requiredFiles: string[]
+  turboTasks: string[]
+}
+
+/**
+ * Baseline rules for a standard TypeScript workspace package, applied to any key
+ * a package leaves unset. These are the "under the hood" defaults so a conforming
+ * package's config can stay empty; non-standard packages override the relevant key.
+ */
+export const DEFAULT_RULES: Readonly<ResolvedPackageRules> = {
+  requiredScripts: ['build', 'ts-check', 'eslint-check', 'prettier-check', 'test'],
+  requiredFiles: ['tsconfig.json', 'eslint.config.js', 'readme.md'],
+  turboTasks: [],
+}
+
+/**
+ * Baseline rules for the monorepo root (`infra-kit audit --root`). Checks the
+ * root commands, the workspace/turbo files, and that the turbo pipeline defines
+ * the expected tasks — so the root's own config can also stay empty.
+ */
+export const ROOT_DEFAULT_RULES: Readonly<ResolvedPackageRules> = {
+  requiredScripts: ['build', 'dev', 'test', 'qa', 'check', 'fix'],
+  requiredFiles: ['turbo.json', 'pnpm-workspace.yaml'],
+  turboTasks: ['build', 'test', 'ts-check', 'eslint-check', 'prettier-check', 'check'],
+}
+
+/**
+ * Merge a parsed package config over a baseline. Each key is replaced wholesale
+ * when the package provides it, otherwise the baseline value is used.
+ *
+ * @example
+ * resolvePackageConfig({ requiredScripts: [] })
+ * // => { requiredScripts: [], requiredFiles: [...DEFAULT_RULES.requiredFiles], turboTasks: [] }
+ */
+export const resolvePackageConfig = (
+  config: InfraKitPackageConfig,
+  baseline: Readonly<ResolvedPackageRules> = DEFAULT_RULES,
+): ResolvedPackageRules => {
+  return {
+    requiredScripts: config.requiredScripts ?? [...baseline.requiredScripts],
+    requiredFiles: config.requiredFiles ?? [...baseline.requiredFiles],
+    turboTasks: config.turbo?.requiredTasks ?? [...baseline.turboTasks],
+  }
+}

package/src/lib/package-validator/__tests__/package-validator.test.ts

@@ -0,0 +1,263 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { DEFAULT_RULES, ROOT_DEFAULT_RULES } from 'src/lib/package-config'
+
+import { discoverPackages, loadPackageConfig, validatePackage } from '../package-validator'
+
+const tmpDirs: string[] = []
+
+const makeTmpDir = (): string => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pkg-validator-'))
+
+  tmpDirs.push(dir)
+
+  return dir
+}
+
+interface PackageFixture {
+  packageJson?: Record<string, unknown>
+  config?: string
+  files?: Record<string, string>
+}
+
+const writePackage = (dir: string, fixture: PackageFixture): void => {
+  const packageJson = fixture.packageJson ?? { name: '@x/pkg', type: 'module' }
+
+  fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify(packageJson, null, 2))
+
+  if (fixture.config !== undefined) {
+    fs.writeFileSync(path.join(dir, 'infra-kit.config.ts'), fixture.config)
+  }
+
+  for (const [name, content] of Object.entries(fixture.files ?? {})) {
+    fs.writeFileSync(path.join(dir, name), content)
+  }
+}
+
+afterEach(() => {
+  while (tmpDirs.length > 0) {
+    const dir = tmpDirs.pop()
+
+    if (dir) {
+      fs.rmSync(dir, { recursive: true, force: true })
+    }
+  }
+})
+
+describe('loadPackageConfig', () => {
+  it('throws when infra-kit.config.js is missing', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {})
+
+    await expect(loadPackageConfig(dir)).rejects.toThrow(/not found/)
+  })
+
+  it('loads an object default export and merges defaults', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, { config: 'export default { requiredScripts: [] }' })
+
+    const rules = await loadPackageConfig(dir)
+
+    expect(rules.requiredScripts).toEqual([])
+    expect(rules.requiredFiles).toEqual(DEFAULT_RULES.requiredFiles)
+  })
+
+  it('resolves a factory (function) default export', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, { config: "export default () => ({ requiredFiles: ['a.txt'] })" })
+
+    const rules = await loadPackageConfig(dir)
+
+    expect(rules.requiredFiles).toEqual(['a.txt'])
+  })
+
+  it('rejects an invalid config shape with a descriptive error', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, { config: "export default { requiredScripts: 'build' }" })
+
+    await expect(loadPackageConfig(dir)).rejects.toThrow(/Invalid/)
+  })
+
+  it('rejects an unknown key (typo protection)', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, { config: 'export default { requiredScript: [] }' })
+
+    await expect(loadPackageConfig(dir)).rejects.toThrow(/Invalid/)
+  })
+})
+
+describe('validatePackage', () => {
+  it('passes when config, required scripts, and required files are all satisfied', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: { name: '@x/ok', type: 'module', scripts: { build: 'x' } },
+      config: "export default { requiredScripts: ['build'], requiredFiles: ['tsconfig.json'] }",
+      files: { 'tsconfig.json': '{}' },
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(true)
+    expect(result.packageName).toBe('@x/ok')
+  })
+
+  it('applies the under-the-hood defaults when the config is empty', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: {
+        name: '@x/std',
+        type: 'module',
+        scripts: { build: 'x', 'ts-check': 'x', 'eslint-check': 'x', 'prettier-check': 'x', test: 'x' },
+      },
+      config: 'export default {}',
+      files: { 'tsconfig.json': '{}', 'eslint.config.js': '', 'readme.md': '' },
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(true)
+  })
+
+  it('fails when a required script is missing', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: { name: '@x/no-script', type: 'module', scripts: { build: 'x' } },
+      config: "export default { requiredScripts: ['build', 'ts-check'], requiredFiles: [] }",
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(false)
+    expect(result.checks).toContainEqual(expect.objectContaining({ name: 'script:ts-check', status: 'fail' }))
+  })
+
+  it('fails when a required file is missing', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: { name: '@x/no-file', type: 'module', scripts: {} },
+      config: "export default { requiredScripts: [], requiredFiles: ['tsconfig.json'] }",
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(false)
+    expect(result.checks).toContainEqual(expect.objectContaining({ name: 'file:tsconfig.json', status: 'fail' }))
+  })
+
+  it('fails with only the config check when infra-kit.config.ts is missing', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, { packageJson: { name: '@x/no-config', type: 'module' } })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(false)
+    expect(result.checks).toHaveLength(1)
+    expect(result.checks[0]).toMatchObject({ name: 'infra-kit.config.ts', status: 'fail' })
+  })
+})
+
+describe('validatePackage — root / turbo', () => {
+  it('passes the root baseline when scripts, files, and turbo tasks are present', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: {
+        name: 'monorepo',
+        type: 'module',
+        scripts: { build: 'x', dev: 'x', test: 'x', qa: 'x', check: 'x', fix: 'x' },
+      },
+      config: 'export default {}',
+      files: {
+        'pnpm-workspace.yaml': 'packages: []\n',
+        'turbo.json': JSON.stringify({
+          tasks: { build: {}, test: {}, 'ts-check': {}, 'eslint-check': {}, 'prettier-check': {}, check: {} },
+        }),
+      },
+    })
+
+    const result = await validatePackage(dir, ROOT_DEFAULT_RULES)
+
+    expect(result.passed).toBe(true)
+  })
+
+  it('fails when a required turbo task is missing from turbo.json', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: { name: 'monorepo', type: 'module' },
+      config: "export default { requiredScripts: [], requiredFiles: [], turbo: { requiredTasks: ['build', 'lint'] } }",
+      files: { 'turbo.json': JSON.stringify({ tasks: { build: {} } }) },
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.passed).toBe(false)
+    expect(result.checks).toContainEqual(expect.objectContaining({ name: 'turbo:lint', status: 'fail' }))
+    expect(result.checks).toContainEqual(expect.objectContaining({ name: 'turbo:build', status: 'pass' }))
+  })
+
+  it('accepts a root task keyed as //#name in turbo.json', async () => {
+    const dir = makeTmpDir()
+
+    writePackage(dir, {
+      packageJson: { name: 'monorepo', type: 'module' },
+      config: "export default { requiredScripts: [], requiredFiles: [], turbo: { requiredTasks: ['check-root'] } }",
+      files: { 'turbo.json': JSON.stringify({ tasks: { '//#check-root': {} } }) },
+    })
+
+    const result = await validatePackage(dir)
+
+    expect(result.checks).toContainEqual(expect.objectContaining({ name: 'turbo:check-root', status: 'pass' }))
+  })
+})
+
+describe('discoverPackages', () => {
+  it('expands non-vendor globs and excludes vendor and negations', async () => {
+    const root = makeTmpDir()
+
+    fs.writeFileSync(
+      path.join(root, 'pnpm-workspace.yaml'),
+      'packages:\n  - apps/*/*\n  - packages/*\n  - vendor/packages/*\n  - "!**/test/**"\n',
+    )
+
+    const dirs = ['apps/infra-kit/cli', 'packages/p1', 'vendor/packages/v1']
+
+    for (const dir of dirs) {
+      const full = path.join(root, dir)
+
+      fs.mkdirSync(full, { recursive: true })
+      fs.writeFileSync(path.join(full, 'package.json'), '{}')
+    }
+
+    const found = await discoverPackages(root)
+
+    expect(found).toContain(path.join(root, 'apps/infra-kit/cli'))
+    expect(found).toContain(path.join(root, 'packages/p1'))
+    expect(found).not.toContain(path.join(root, 'vendor/packages/v1'))
+  })
+
+  it('omits directories that lack a package.json', async () => {
+    const root = makeTmpDir()
+
+    fs.writeFileSync(path.join(root, 'pnpm-workspace.yaml'), 'packages:\n  - packages/*\n')
+
+    fs.mkdirSync(path.join(root, 'packages/empty'), { recursive: true })
+
+    const found = await discoverPackages(root)
+
+    expect(found).not.toContain(path.join(root, 'packages/empty'))
+  })
+})