infra-kit 0.1.128 → 0.1.130

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

@@ -1,270 +0,0 @@
-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', 'infra-kit-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': {},
-            'infra-kit-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'))
-  })
-})

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

@@ -1,130 +0,0 @@
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { checkFiles } from '../files-check'
-import { checkScripts } from '../scripts-check'
-import { checkTurbo } from '../turbo-check'
-
-const tmpDirs: string[] = []
-
-const makeTmpDir = (): string => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'checks-'))
-
-  tmpDirs.push(dir)
-
-  return dir
-}
-
-afterEach(() => {
-  while (tmpDirs.length > 0) {
-    const dir = tmpDirs.pop()
-
-    if (dir) {
-      fs.rmSync(dir, { recursive: true, force: true })
-    }
-  }
-})
-
-describe('checkScripts', () => {
-  it('passes a script defined with a runnable command', () => {
-    const checks = checkScripts({ build: 'tsc' }, ['build'])
-
-    expect(checks).toEqual([{ name: 'script:build', status: 'pass', message: 'defined' }])
-  })
-
-  it('fails a script that is absent from the scripts map', () => {
-    const checks = checkScripts({}, ['build'])
-
-    expect(checks[0]).toMatchObject({ name: 'script:build', status: 'fail' })
-    expect(checks[0]?.message).toContain('missing')
-  })
-
-  it('fails a script declared with an empty value', () => {
-    const checks = checkScripts({ build: '' }, ['build'])
-
-    expect(checks[0]).toMatchObject({ name: 'script:build', status: 'fail' })
-    expect(checks[0]?.message).toContain('empty')
-  })
-
-  it('fails a script declared with a whitespace-only value', () => {
-    const checks = checkScripts({ build: '   ' }, ['build'])
-
-    expect(checks[0]).toMatchObject({ name: 'script:build', status: 'fail' })
-    expect(checks[0]?.message).toContain('empty')
-  })
-})
-
-describe('checkFiles', () => {
-  it('passes a required path that is a regular file', async () => {
-    const dir = makeTmpDir()
-
-    fs.writeFileSync(path.join(dir, 'readme.md'), '# hi')
-
-    const checks = await checkFiles(dir, ['readme.md'])
-
-    expect(checks[0]).toMatchObject({ name: 'file:readme.md', status: 'pass' })
-  })
-
-  it('fails a required file that does not exist', async () => {
-    const dir = makeTmpDir()
-
-    const checks = await checkFiles(dir, ['readme.md'])
-
-    expect(checks[0]).toMatchObject({ name: 'file:readme.md', status: 'fail' })
-    expect(checks[0]?.message).toContain('missing file')
-  })
-
-  it('fails a required path that exists but is a directory', async () => {
-    const dir = makeTmpDir()
-
-    fs.mkdirSync(path.join(dir, 'readme.md'))
-
-    const checks = await checkFiles(dir, ['readme.md'])
-
-    expect(checks[0]).toMatchObject({ name: 'file:readme.md', status: 'fail' })
-    expect(checks[0]?.message).toContain('not a file')
-  })
-})
-
-describe('checkTurbo', () => {
-  it('returns no checks when no turbo tasks are required', async () => {
-    const dir = makeTmpDir()
-
-    expect(await checkTurbo(dir, [])).toEqual([])
-  })
-
-  it('fails with a single diagnostic when turbo.json cannot be read', async () => {
-    const dir = makeTmpDir()
-
-    const checks = await checkTurbo(dir, ['build'])
-
-    expect(checks).toHaveLength(1)
-    expect(checks[0]).toMatchObject({ name: 'turbo.json', status: 'fail' })
-    expect(checks[0]?.message).toContain('cannot read/parse')
-  })
-
-  it('fails with a single diagnostic when turbo.json has no tasks object', async () => {
-    const dir = makeTmpDir()
-
-    fs.writeFileSync(path.join(dir, 'turbo.json'), JSON.stringify({ $schema: 'x' }))
-
-    const checks = await checkTurbo(dir, ['build', 'test'])
-
-    expect(checks).toHaveLength(1)
-    expect(checks[0]).toMatchObject({ name: 'turbo.json', status: 'fail' })
-    expect(checks[0]?.message).toContain('no "tasks" object')
-  })
-
-  it('reports per-task results when a tasks object exists', async () => {
-    const dir = makeTmpDir()
-
-    fs.writeFileSync(path.join(dir, 'turbo.json'), JSON.stringify({ tasks: { build: {} } }))
-
-    const checks = await checkTurbo(dir, ['build', 'test'])
-
-    expect(checks).toContainEqual(expect.objectContaining({ name: 'turbo:build', status: 'pass' }))
-    expect(checks).toContainEqual(expect.objectContaining({ name: 'turbo:test', status: 'fail' }))
-  })
-})

package/src/lib/package-validator/checks/config-check.ts

@@ -1,30 +0,0 @@
-import { DEFAULT_RULES } from 'src/lib/package-config'
-import type { ResolvedPackageRules } from 'src/lib/package-config'
-
-import { PACKAGE_CONFIG_FILE, loadPackageConfig } from '../loader'
-import type { PackageCheck } from '../types'
-
-/**
- * Build the "config present and valid" check, returning the resolved rules when
- * the load succeeds so the caller can run the rule-based checks against them.
- * When the config fails to load the rules are `null` and the caller skips the
- * rule-based checks (the expectations are unknown).
- */
-export const checkConfig = async (
-  packageDir: string,
-  baseline: Readonly<ResolvedPackageRules> = DEFAULT_RULES,
-): Promise<{ check: PackageCheck; rules: ResolvedPackageRules | null }> => {
-  try {
-    const rules = await loadPackageConfig(packageDir, baseline)
-
-    return {
-      check: { name: PACKAGE_CONFIG_FILE, status: 'pass', message: 'present and valid' },
-      rules,
-    }
-  } catch (err) {
-    return {
-      check: { name: PACKAGE_CONFIG_FILE, status: 'fail', message: (err as Error).message },
-      rules: null,
-    }
-  }
-}

package/src/lib/package-validator/checks/files-check.ts

@@ -1,29 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import type { PackageCheck } from '../types'
-
-/**
- * Check that every required file exists relative to the package root AND is a
- * regular file. A directory that happens to share the required name fails — a
- * required `readme.md` must be the file, not a folder.
- */
-export const checkFiles = async (packageDir: string, requiredFiles: string[]): Promise<PackageCheck[]> => {
-  return Promise.all(
-    requiredFiles.map(async (file) => {
-      const stat = await fs.stat(path.join(packageDir, file)).catch(() => {
-        return null
-      })
-
-      if (!stat) {
-        return { name: `file:${file}`, status: 'fail' as const, message: `missing file: ${file}` }
-      }
-
-      if (!stat.isFile()) {
-        return { name: `file:${file}`, status: 'fail' as const, message: `not a file: ${file} (found a directory)` }
-      }
-
-      return { name: `file:${file}`, status: 'pass' as const, message: 'exists' }
-    }),
-  )
-}

package/src/lib/package-validator/checks/index.ts

@@ -1,4 +0,0 @@
-export { checkConfig } from './config-check'
-export { checkFiles } from './files-check'
-export { checkScripts } from './scripts-check'
-export { checkTurbo } from './turbo-check'

package/src/lib/package-validator/checks/scripts-check.ts

@@ -1,23 +0,0 @@
-import type { PackageCheck } from '../types'
-
-/**
- * Check that every required script is present in the package.json `scripts` map
- * and carries a runnable command. A key declared with an empty or whitespace-only
- * value fails as well — an empty script silently no-ops in CI, so presence alone
- * is not enough.
- */
-export const checkScripts = (scripts: Record<string, string>, requiredScripts: string[]): PackageCheck[] => {
-  return requiredScripts.map((script) => {
-    const value = scripts[script]
-
-    if (typeof value !== 'string') {
-      return { name: `script:${script}`, status: 'fail', message: `missing "${script}" in package.json scripts` }
-    }
-
-    if (value.trim().length === 0) {
-      return { name: `script:${script}`, status: 'fail', message: `"${script}" is empty in package.json scripts` }
-    }
-
-    return { name: `script:${script}`, status: 'pass', message: 'defined' }
-  })
-}

package/src/lib/package-validator/checks/turbo-check.ts

@@ -1,47 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import type { PackageCheck } from '../types'
-
-const TURBO_FILE = 'turbo.json'
-
-/**
- * Check that every required turbo task is defined in turbo.json `tasks`. A root
- * task may be keyed as either `name` or `//#name`, so both forms count as present.
- * Runs only when the resolved rules ask for turbo tasks (the monorepo root).
- *
- * Reports a single clear diagnostic when turbo.json is unreadable or carries no
- * `tasks` object, rather than emitting one identical "missing task" line per
- * required task.
- */
-export const checkTurbo = async (packageDir: string, requiredTasks: string[]): Promise<PackageCheck[]> => {
-  if (requiredTasks.length === 0) {
-    return []
-  }
-
-  let parsed: { tasks?: Record<string, unknown> }
-
-  try {
-    const raw = await fs.readFile(path.join(packageDir, TURBO_FILE), 'utf-8')
-
-    parsed = JSON.parse(raw) as { tasks?: Record<string, unknown> }
-  } catch (err) {
-    return [{ name: TURBO_FILE, status: 'fail', message: `cannot read/parse ${TURBO_FILE}: ${(err as Error).message}` }]
-  }
-
-  const tasks = parsed.tasks
-
-  if (tasks === null || typeof tasks !== 'object') {
-    return [{ name: TURBO_FILE, status: 'fail', message: `no "tasks" object defined in ${TURBO_FILE}` }]
-  }
-
-  return requiredTasks.map((task) => {
-    const defined = task in tasks || `//#${task}` in tasks
-
-    return {
-      name: `turbo:${task}`,
-      status: defined ? 'pass' : 'fail',
-      message: defined ? 'defined' : `missing turbo task "${task}" in ${TURBO_FILE}`,
-    }
-  })
-}

package/src/lib/package-validator/fs-utils.ts

@@ -1,18 +0,0 @@
-import fs from 'node:fs/promises'
-
-/**
- * Resolve whether a path is reachable, suppressing ENOENT into a boolean.
- *
- * @example
- * await pathExists('/etc/hosts') // => true
- * await pathExists('/nope')      // => false
- */
-export const pathExists = async (target: string): Promise<boolean> => {
-  try {
-    await fs.access(target)
-
-    return true
-  } catch {
-    return false
-  }
-}

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

@@ -1,3 +0,0 @@
-export { pathExists } from './fs-utils'
-export { discoverPackages, loadPackageConfig, validatePackage } from './package-validator'
-export type { PackageCheck, PackageValidationResult } from './package-validator'

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

@@ -1,77 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-import { z } from 'zod'
-
-import { DEFAULT_RULES, packageConfigSchema, resolvePackageConfig } from 'src/lib/package-config'
-import type { ResolvedPackageRules } from 'src/lib/package-config'
-
-import { pathExists } from '../fs-utils'
-
-/** Per-package config filename every validated package must provide. */
-export const PACKAGE_CONFIG_FILE = 'infra-kit.config.ts'
-
-interface PackageJsonShape {
-  name?: string
-  scripts?: Record<string, string>
-}
-
-/**
- * Read and JSON-parse a package.json, returning an empty object when it is
- * missing or unreadable so callers can degrade into a clear "missing" check.
- */
-export const readPackageJson = async (packageDir: string): Promise<PackageJsonShape> => {
-  try {
-    const raw = await fs.readFile(path.join(packageDir, 'package.json'), 'utf-8')
-
-    return JSON.parse(raw) as PackageJsonShape
-  } catch {
-    return {}
-  }
-}
-
-/**
- * Load, resolve, and validate a package's `infra-kit.config.ts`.
- *
- * Dynamic-imports the file (ESM), resolves the Vite-style factory or object
- * default export, validates the result against {@link packageConfigSchema}, and
- * merges it over the defaults. Throws a descriptive error when the file is
- * absent or the resolved config violates the schema.
- *
- * @example
- * await loadPackageConfig('/repo/packages/serverless-config')
- * // => { requiredScripts: [], requiredFiles: ['serverless.common.yml'], turboTasks: [] }
- */
-export const loadPackageConfig = async (
-  packageDir: string,
-  baseline: Readonly<ResolvedPackageRules> = DEFAULT_RULES,
-): Promise<ResolvedPackageRules> => {
-  const configPath = path.join(packageDir, PACKAGE_CONFIG_FILE)
-
-  if (!(await pathExists(configPath))) {
-    throw new Error(`${PACKAGE_CONFIG_FILE} not found at ${configPath}`)
-  }
-
-  // Cache-bust with the file mtime so repeated loads (long-running MCP server)
-  // pick up edits without a process restart. `.ts` configs load via Node's
-  // native type stripping (the repo requires Node >= 24).
-  const stat = await fs.stat(configPath)
-  const moduleUrl = `${pathToFileURL(configPath).href}?mtime=${Number(stat.mtimeMs)}`
-
-  const imported = (await import(moduleUrl)) as { default?: unknown }
-  const rawExport = imported.default
-
-  if (rawExport === undefined) {
-    throw new Error(`${PACKAGE_CONFIG_FILE} at ${configPath} has no default export`)
-  }
-
-  const resolvedExport = typeof rawExport === 'function' ? await (rawExport as () => unknown)() : rawExport
-
-  const parsed = packageConfigSchema.safeParse(resolvedExport)
-
-  if (!parsed.success) {
-    throw new Error(`Invalid ${PACKAGE_CONFIG_FILE} at ${configPath}: ${z.prettifyError(parsed.error)}`)
-  }
-
-  return resolvePackageConfig(parsed.data, baseline)
-}

package/src/lib/package-validator/loader/index.ts

@@ -1,2 +0,0 @@
-export { loadPackageConfig, PACKAGE_CONFIG_FILE, readPackageJson } from './config-loader'
-export { discoverPackages } from './package-discovery'