infra-kit 0.1.102 → 0.1.105

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'))
+  })
+})

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

@@ -0,0 +1,130 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,18 @@
+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

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