infra-kit 0.1.102 → 0.1.105

package/src/lib/git-utils/__tests__/git-utils.test.ts

@@ -0,0 +1,49 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { getCurrentWorktrees } from 'src/lib/git-utils'
+
+const worktreeList = vi.hoisted(() => {
+  return { stdout: '' }
+})
+
+vi.mock('zx', () => {
+  return {
+    $: vi.fn(() => {
+      return Promise.resolve(worktreeList)
+    }),
+  }
+})
+
+const asWorktreeLine = (branch: string): string => {
+  return `/repos/project-worktrees/${branch}  abc1234 [${branch}]`
+}
+
+describe('getCurrentWorktrees', () => {
+  beforeEach(() => {
+    worktreeList.stdout = [
+      asWorktreeLine('main'),
+      asWorktreeLine('release/v1.18.22'),
+      asWorktreeLine('release/n/checkout-redesign'),
+      asWorktreeLine('release/garbage'),
+      asWorktreeLine('feature/login-page'),
+      '/repos/project  abc1234 (bare)',
+      '',
+    ].join('\n')
+  })
+
+  it('returns versioned AND named release worktrees for type release', async () => {
+    await expect(getCurrentWorktrees('release')).resolves.toEqual(['release/v1.18.22', 'release/n/checkout-redesign'])
+  })
+
+  it('excludes junk release branches and non-release branches', async () => {
+    const branches = await getCurrentWorktrees('release')
+
+    expect(branches).not.toContain('release/garbage')
+    expect(branches).not.toContain('feature/login-page')
+    expect(branches).not.toContain('main')
+  })
+
+  it('returns feature worktrees for type feature', async () => {
+    await expect(getCurrentWorktrees('feature')).resolves.toEqual(['feature/login-page'])
+  })
+})

package/src/lib/git-utils/git-utils.ts

@@ -1,6 +1,8 @@
 import path from 'node:path'
 import { $ } from 'zx'
 
+import { isReleaseBranch } from 'src/lib/release-id'
+
 /**
  * Get current git worktrees
  *
@@ -60,7 +62,7 @@ const parseWorktreeBranch = (line: string): string | null => {
 const releaseWorktreePredicate = (line: string): string | null => {
   const branch = parseWorktreeBranch(line)
 
-  return branch?.startsWith('release/v') ? branch : null
+  return isReleaseBranch(branch) ? branch : null
 }
 
 /**

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

@@ -0,0 +1,270 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Import AFTER the mock is declared so the module picks up the mocked dep.
+import { getProjectRoot, getRepoName } from 'src/lib/git-utils'
+
+import { getInfraKitConfig, resetInfraKitConfigCache } from '../infra-kit-config'
+
+vi.mock('src/lib/git-utils', () => {
+  return {
+    getProjectRoot: vi.fn(),
+    getRepoName: vi.fn(),
+  }
+})
+
+const VALID_JSON = JSON.stringify({
+  environments: ['dev', 'staging'],
+  envManagement: { provider: 'doppler', config: { name: 'my-project' } },
+})
+
+const ALTERNATE_JSON = JSON.stringify({
+  environments: ['dev'],
+  envManagement: { provider: 'doppler', config: { name: 'other-project' } },
+})
+
+const withTmpRepo = async (fn: (tmp: string) => Promise<void>): Promise<void> => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'infra-kit-config-test-'))
+
+  vi.mocked(getProjectRoot).mockResolvedValue(tmp)
+  vi.mocked(getRepoName).mockResolvedValue(path.basename(tmp))
+  // Point os.homedir() at the tmp dir so user-scope override layers
+  // (~/.infra-kit/config.json, ~/.infra-kit/projects/<repo>/infra-kit.json)
+  // can't leak the developer's real config into the test.
+  const homedirSpy = vi.spyOn(os, 'homedir').mockReturnValue(tmp)
+
+  resetInfraKitConfigCache()
+
+  try {
+    await fn(tmp)
+  } finally {
+    homedirSpy.mockRestore()
+    resetInfraKitConfigCache()
+    fs.rmSync(tmp, { recursive: true, force: true })
+  }
+}
+
+describe('getInfraKitConfig', () => {
+  beforeEach(() => {
+    resetInfraKitConfigCache()
+  })
+
+  afterEach(() => {
+    resetInfraKitConfigCache()
+    vi.clearAllMocks()
+  })
+
+  it('reads and validates a well-formed infra-kit.json', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(path.join(tmp, 'infra-kit.json'), VALID_JSON)
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.envManagement.config.name).toBe('my-project')
+      expect(cfg.environments).toEqual(['dev', 'staging'])
+      expect(cfg.taskManager).toBeUndefined()
+      expect(cfg.ide).toBeUndefined()
+    })
+  })
+
+  it('accepts ide and taskManager when provided', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: { provider: 'cursor', config: { mode: 'workspace', workspaceConfigPath: './ws.code-workspace' } },
+          taskManager: { provider: 'jira', config: { baseUrl: 'https://example.atlassian.net', projectId: 123 } },
+        }),
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.ide?.provider).toBe('cursor')
+
+      if (cfg.ide?.provider === 'cursor') {
+        expect(cfg.ide.config.mode).toBe('workspace')
+        expect(cfg.ide.config.workspaceConfigPath).toBe('./ws.code-workspace')
+      }
+
+      expect(cfg.taskManager?.provider).toBe('jira')
+    })
+  })
+
+  it('accepts a worktrees prompt-defaults block', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          worktrees: { openInGithubDesktop: false, openInCmux: true },
+        }),
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.worktrees?.openInGithubDesktop).toBe(false)
+      expect(cfg.worktrees?.openInCmux).toBe(true)
+    })
+  })
+
+  it('lets the user-global config layer supply a worktrees block when the project omits it', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(path.join(tmp, 'infra-kit.json'), VALID_JSON)
+
+      const userGlobalDir = path.join(tmp, '.infra-kit')
+
+      fs.mkdirSync(userGlobalDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(userGlobalDir, 'config.json'),
+        JSON.stringify({ worktrees: { openInGithubDesktop: false, openInCmux: true } }),
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.worktrees?.openInGithubDesktop).toBe(false)
+      expect(cfg.worktrees?.openInCmux).toBe(true)
+    })
+  })
+
+  it('treats an empty optional layer file as {}', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(path.join(tmp, 'infra-kit.json'), VALID_JSON)
+
+      const userGlobalDir = path.join(tmp, '.infra-kit')
+
+      fs.mkdirSync(userGlobalDir, { recursive: true })
+      fs.writeFileSync(path.join(userGlobalDir, 'config.json'), '   \n')
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.envManagement.config.name).toBe('my-project')
+    })
+  })
+
+  it('throws a descriptive error on malformed JSON', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(path.join(tmp, 'infra-kit.json'), '{ not valid json ')
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/Invalid JSON in infra-kit\.json/)
+    })
+  })
+
+  it('rejects ide.cursor mode=workspace without workspaceConfigPath', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: { provider: 'cursor', config: { mode: 'workspace' } },
+        }),
+      )
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/workspaceConfigPath/)
+    })
+  })
+
+  it('throws a plain not-found error when neither infra-kit.json nor a legacy .yml exists', async () => {
+    await withTmpRepo(async () => {
+      await expect(getInfraKitConfig()).rejects.toThrow(/not found/)
+      await expect(getInfraKitConfig()).rejects.not.toThrow(/infra-kit init/)
+    })
+  })
+
+  it('points at `infra-kit init` when a legacy infra-kit.yml exists but infra-kit.json does not', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(path.join(tmp, 'infra-kit.yml'), 'environments:\n  - dev\n')
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/infra-kit init/)
+    })
+  })
+
+  it('ignores a non-loaded infra-kit.example.jsonc sibling', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(path.join(tmp, 'infra-kit.json'), VALID_JSON)
+      // Content that would FAIL schema if it were ever merged into the config.
+      fs.writeFileSync(path.join(tmp, 'infra-kit.example.jsonc'), '{\n  // comment\n  "environments": []\n}\n')
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.environments).toEqual(['dev', 'staging'])
+      expect(cfg.envManagement.config.name).toBe('my-project')
+    })
+  })
+
+  it('ignores a non-loaded config.example.jsonc in the user-global layer', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(path.join(tmp, 'infra-kit.json'), VALID_JSON)
+
+      const userGlobalDir = path.join(tmp, '.infra-kit')
+
+      fs.mkdirSync(userGlobalDir, { recursive: true })
+      // Schema-failing content that must never be merged.
+      fs.writeFileSync(path.join(userGlobalDir, 'config.example.jsonc'), '{\n  // comment\n  "environments": []\n}\n')
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.environments).toEqual(['dev', 'staging'])
+      expect(cfg.envManagement.config.name).toBe('my-project')
+    })
+  })
+
+  it('throws when infra-kit.json is missing', async () => {
+    await withTmpRepo(async () => {
+      await expect(getInfraKitConfig()).rejects.toThrow(/not found/)
+    })
+  })
+
+  it('throws a descriptive error on schema violations', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({ environments: [], envManagement: { provider: 'doppler', config: { name: '' } } }),
+      )
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/Invalid infra-kit\.json/)
+    })
+  })
+
+  it('re-reads the file when mtime changes (long-running MCP scenario)', async () => {
+    await withTmpRepo(async (tmp) => {
+      const jsonPath = path.join(tmp, 'infra-kit.json')
+
+      fs.writeFileSync(jsonPath, VALID_JSON)
+
+      const first = await getInfraKitConfig()
+
+      expect(first.envManagement.config.name).toBe('my-project')
+
+      // Advance mtime past the previous stat to simulate an edit; write new content.
+      const future = new Date(Date.now() + 2_000)
+
+      fs.writeFileSync(jsonPath, ALTERNATE_JSON)
+      fs.utimesSync(jsonPath, future, future)
+
+      const second = await getInfraKitConfig()
+
+      expect(second.envManagement.config.name).toBe('other-project')
+      expect(second.environments).toEqual(['dev'])
+    })
+  })
+
+  it('returns the cached value on repeated calls when mtime is unchanged', async () => {
+    await withTmpRepo(async (tmp) => {
+      const jsonPath = path.join(tmp, 'infra-kit.json')
+
+      fs.writeFileSync(jsonPath, VALID_JSON)
+
+      const a = await getInfraKitConfig()
+      const b = await getInfraKitConfig()
+
+      // Same object reference — no re-parse.
+      expect(a).toBe(b)
+    })
+  })
+})

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

@@ -1,2 +1,8 @@
-export { getInfraKitConfig, getInfraKitConfigPaths, resetInfraKitConfigCache } from './infra-kit-config'
+export {
+  getInfraKitConfig,
+  getInfraKitConfigPaths,
+  infraKitConfigSchema,
+  infraKitOverrideConfigSchema,
+  resetInfraKitConfigCache,
+} from './infra-kit-config'
 export type { InfraKitConfig, InfraKitConfigPaths } from './infra-kit-config'

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

@@ -1,15 +1,14 @@
 import fs from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
-import yaml from 'yaml'
-import { z } from 'zod/v4'
+import { z } from 'zod'
 
 import { getProjectRoot, getRepoName } from 'src/lib/git-utils'
 
-const INFRA_KIT_CONFIG_FILE = 'infra-kit.yml'
+const INFRA_KIT_CONFIG_FILE = 'infra-kit.json'
 
 const USER_CONFIG_DIR_NAME = '.infra-kit'
-const USER_GLOBAL_CONFIG_FILE = 'config.yml'
+const USER_GLOBAL_CONFIG_FILE = 'config.json'
 const USER_PROJECTS_DIR = 'projects'
 
 // envManagement
@@ -62,7 +61,7 @@ const worktreesConfigSchema = z.object({
   openInCmux: z.boolean().optional(),
 })
 
-const infraKitConfigSchema = z.object({
+export const infraKitConfigSchema = z.object({
   environments: z.array(z.string().min(1)).min(1),
   envManagement: envManagementSchema,
   ide: ideSchema.optional(),
@@ -70,7 +69,7 @@ const infraKitConfigSchema = z.object({
   worktrees: worktreesConfigSchema.optional(),
 })
 
-const infraKitOverrideConfigSchema = infraKitConfigSchema.partial()
+export const infraKitOverrideConfigSchema = infraKitConfigSchema.partial()
 
 export type InfraKitConfig = z.infer<typeof infraKitConfigSchema>
 
@@ -79,7 +78,7 @@ export interface InfraKitConfigPaths {
   main: string
   /** User-scope global overrides applied to every project. */
   userGlobal: string
-  /** User-scope per-project overrides — `<userProjectsDir>/<projectName>/infra-kit.yml`. */
+  /** User-scope per-project overrides — `<userProjectsDir>/<projectName>/infra-kit.json`. */
   userProject: string
   /** Repo basename (`path.basename(projectRoot)`) used to namespace the user-project file. */
   projectName: string
@@ -100,9 +99,9 @@ let cached: CacheEntry | null = null
  * @example
  * const paths = await getInfraKitConfigPaths()
  * // {
- * //   main:        '/Users/arthur/projects/api/infra-kit.yml',
- * //   userGlobal:  '/Users/arthur/.infra-kit/config.yml',
- * //   userProject: '/Users/arthur/.infra-kit/projects/api/infra-kit.yml',
+ * //   main:        '/Users/arthur/projects/api/infra-kit.json',
+ * //   userGlobal:  '/Users/arthur/.infra-kit/config.json',
+ * //   userProject: '/Users/arthur/.infra-kit/projects/api/infra-kit.json',
  * //   projectName: 'api',
  * // }
  */
@@ -120,19 +119,19 @@ export const getInfraKitConfigPaths = async (): Promise<InfraKitConfigPaths> =>
 }
 
 /**
- * Read and validate `infra-kit.yml`, with optional override layers shallow-merged
+ * Read and validate `infra-kit.json`, with optional override layers shallow-merged
  * on top in this order (later wins):
- *   1. project `infra-kit.yml`                            — committed source of truth
- *   2. `~/.infra-kit/config.yml`                          — user-global defaults
- *   3. `~/.infra-kit/projects/<repo-name>/infra-kit.yml`  — user-scope per-project overrides
+ *   1. project `infra-kit.json`                            — committed source of truth
+ *   2. `~/.infra-kit/config.json`                          — user-global defaults
+ *   3. `~/.infra-kit/projects/<repo-name>/infra-kit.json`  — user-scope per-project overrides
  *
  * Top-level keys (entire capability sections like `ide`, `envManagement`)
  * replace wholesale. Results are cached per file mtimes so the long-running
  * MCP server picks up edits without a restart.
  *
  * @example
- * // infra-kit.yml:           { environments: ['dev'], envManagement: { provider: 'doppler', config: { name: 'p' } } }
- * // ~/.infra-kit/config.yml: { ide: { provider: 'cursor', config: { mode: 'windows' } } }
+ * // infra-kit.json:           { "environments": ["dev"], "envManagement": { "provider": "doppler", "config": { "name": "p" } } }
+ * // ~/.infra-kit/config.json: { "ide": { "provider": "cursor", "config": { "mode": "windows" } } }
  * const cfg = await getInfraKitConfig()
  * // => { environments: ['dev'], envManagement: {...}, ide: { provider: 'cursor', config: { mode: 'windows' } } }
  */
@@ -145,7 +144,18 @@ export const getInfraKitConfig = async (): Promise<InfraKitConfig> => {
     mainStat = await fs.stat(paths.main)
   } catch {
     cached = null
-    throw new Error(`infra-kit.yml not found at ${paths.main}`)
+
+    // Bridge the YAML→JSON cutover: if a legacy infra-kit.yml is sitting where
+    // the JSON config should be, point the user at the one-shot migration.
+    const legacyYmlPath = paths.main.replace(/\.json$/, '.yml')
+
+    if (await statIfExists(legacyYmlPath)) {
+      throw new Error(
+        `infra-kit.json not found at ${paths.main}. A legacy infra-kit.yml exists — run \`infra-kit init\` to convert it.`,
+      )
+    }
+
+    throw new Error(`infra-kit.json not found at ${paths.main}`)
   }
 
   const [userGlobalStat, userProjectStat] = await Promise.all([
@@ -164,10 +174,10 @@ export const getInfraKitConfig = async (): Promise<InfraKitConfig> => {
   }
 
   const layers: ConfigLayer[] = [
-    { label: 'infra-kit.yml', path: paths.main, required: true },
-    { label: '~/.infra-kit/config.yml', path: paths.userGlobal, required: false },
+    { label: 'infra-kit.json', path: paths.main, required: true },
+    { label: '~/.infra-kit/config.json', path: paths.userGlobal, required: false },
     {
-      label: `~/.infra-kit/projects/${paths.projectName}/infra-kit.yml`,
+      label: `~/.infra-kit/projects/${paths.projectName}/infra-kit.json`,
       path: paths.userProject,
       required: false,
     },
@@ -224,8 +234,8 @@ const statIfExists = async (filePath: string): Promise<Awaited<ReturnType<typeof
  * `fs.readFile` that returns `null` instead of throwing on ENOENT.
  *
  * @example
- * const raw = await readIfExists('/missing.yml') // => null
- * const raw = await readIfExists('/exists.yml')  // => 'environments: [dev]\n'
+ * const raw = await readIfExists('/missing.json') // => null
+ * const raw = await readIfExists('/exists.json')  // => '{ "environments": ["dev"] }\n'
  */
 const readIfExists = async (filePath: string): Promise<string | null> => {
   try {
@@ -261,17 +271,18 @@ interface ConfigLayer {
 }
 
 /**
- * Read a single layer of the merge chain: parse the YAML if the file exists
+ * Read a single layer of the merge chain: parse the JSON if the file exists
  * and validate it against the override schema. Returns `null` if an optional
- * layer is missing; throws if the layer is required or invalid.
+ * layer is missing; throws if the layer is required, malformed, or invalid.
+ * An empty/whitespace-only file is treated as `{}` (JSON.parse would throw).
  *
  * @example
- * await loadLayer({ label: '~/.infra-kit/config.yml', path: '/missing.yml', required: false })
+ * await loadLayer({ label: '~/.infra-kit/config.json', path: '/missing.json', required: false })
  * // => null
  *
  * @example
- * // /home/me/.infra-kit/config.yml: 'ide:\n  provider: cursor\n  config: { mode: windows }'
- * await loadLayer({ label: '~/.infra-kit/config.yml', path: '/home/me/.infra-kit/config.yml', required: false })
+ * // /home/me/.infra-kit/config.json: '{ "ide": { "provider": "cursor", "config": { "mode": "windows" } } }'
+ * await loadLayer({ label: '~/.infra-kit/config.json', path: '/home/me/.infra-kit/config.json', required: false })
  * // => { ide: { provider: 'cursor', config: { mode: 'windows' } } }
  */
 const loadLayer = async (layer: ConfigLayer): Promise<Record<string, unknown> | null> => {
@@ -285,7 +296,14 @@ const loadLayer = async (layer: ConfigLayer): Promise<Record<string, unknown> |
     return null
   }
 
-  const parsedRaw = yaml.parse(raw) ?? {}
+  let parsedRaw: unknown
+
+  try {
+    parsedRaw = raw.trim() === '' ? {} : JSON.parse(raw)
+  } catch (err) {
+    throw new Error(`Invalid JSON in ${layer.label} at ${layer.path}: ${(err as Error).message}`)
+  }
+
   const result = infraKitOverrideConfigSchema.safeParse(parsedRaw)
 
   if (!result.success) {

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(),
+})