@amritk/mjst 0.5.0 → 0.6.0

package/dist/combine-files.d.ts

@@ -0,0 +1,13 @@
+import type { GeneratedFile } from '@amritk/generate-parsers';
+/**
+ * Merges the per-schema {@link GeneratedFile}s into a single self-contained
+ * TypeScript module. Each generated file imports its sibling definitions via
+ * relative paths; since everything now lives in one file those imports are
+ * dropped, while any external (package) imports are hoisted to the top and
+ * deduplicated. The `index.ts` barrel is skipped because it only re-exports the
+ * declarations that are already inlined here.
+ *
+ * Intended for types-only output, where files contain only type definitions and
+ * type-only relative imports (no runtime helpers).
+ */
+export declare const combineGeneratedFiles: (files: readonly GeneratedFile[]) => string;

package/dist/parse-cli-args.d.ts

@@ -1,7 +1,9 @@
 import type { CliConfig } from './cli-config';
 /**
  * Parses command-line arguments into a partial CLI config.
- * Supports --schema, --outDir, and --types-only flags with either `--flag value` or `--flag=value` syntax.
- * Only returns the flags that were explicitly provided so we can layer them on top of config file values.
+ * Every flag accepts both kebab-case and camelCase (e.g. `--out-dir` and `--outDir`)
+ * and supports either `--flag value` or `--flag=value` syntax. Boolean flags toggle
+ * on by presence and accept `--flag=false` to opt out. Only flags that were explicitly
+ * provided are returned so they can be layered on top of config file values.
  */
 export declare const parseCliArgs: (args: readonly string[]) => Partial<CliConfig>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/mjst",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "type": "module",
   "license": "MIT",
@@ -42,10 +42,10 @@
     "generate-readme": "bun run ./scripts/generate-readme.ts"
   },
   "dependencies": {
-    "@amritk/adapters": "0.2.0",
-    "@amritk/generate-parsers": "0.4.0",
+    "@amritk/adapters": "0.2.2",
+    "@amritk/generate-parsers": "0.5.0",
     "@amritk/generate-markdown": "0.2.1",
-    "@amritk/helpers": "0.4.0"
+    "@amritk/helpers": "0.5.0"
   },
   "devDependencies": {
     "json-schema-typed": "^8.0.1"

package/src/cli-config.ts

@@ -6,7 +6,15 @@ import type { SourceFormat } from '@amritk/adapters/source-format'
  */
 export type CliConfig = {
   /** Path to the schema to process — a JSON Schema file, or a JS/TS module when `input` is set. */
-  readonly schema: string
+  readonly schema?: string
+  /**
+   * Path to a directory of JSON Schema files. When set, the CLI walks the directory
+   * recursively, generates parsers for every `*.json` schema it finds, and mirrors the
+   * directory layout under `outDir`. A single shared `_helpers/` directory is emitted at
+   * the root of `outDir` (in embedded mode) and every nested parser imports from it.
+   * Mutually exclusive with `schema`; when both are present `schemaDir` wins.
+   */
+  readonly schemaDir?: string
   /**
    * The source format of the schema. Defaults to `'json'` (a plain JSON Schema file).
    * Any other format loads `schema` as a module and converts it via the matching adapter.
@@ -17,8 +25,13 @@ export type CliConfig = {
    * Defaults to the default export, or the sole named export when there is exactly one.
    */
   readonly export?: string
-  /** Output directory for generated TypeScript files. */
-  readonly outDir: string
+  /** Output directory for generated TypeScript files. Mutually exclusive with `outFile`. */
+  readonly outDir?: string
+  /**
+   * Output everything to a single TypeScript file instead of a directory of files.
+   * Mutually exclusive with `outDir`. Currently supported only with `typesOnly`.
+   */
+  readonly outFile?: string
   /**
    * When true, only generate TypeScript type definitions without parser functions.
    * Useful when you only need the type shapes and do not need runtime validation.
@@ -50,4 +63,9 @@ export type CliConfig = {
    * resolves from outDir, otherwise falls back to `'embedded'`.
    */
   readonly helpers?: 'package' | 'embedded'
+  /**
+   * When true, every property, array, and record in the generated type
+   * definitions is emitted as `readonly`, producing deeply immutable types.
+   */
+  readonly readonly?: boolean
 }

package/src/cli.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { execFile } from 'node:child_process'
-import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises'
-import { dirname, join, resolve } from 'node:path'
+import { mkdir, readdir, readFile, unlink, writeFile } from 'node:fs/promises'
+import { basename, dirname, join, relative, resolve, sep } from 'node:path'
 import { promisify } from 'node:util'
 import { getAdapter } from '@amritk/adapters/get-adapter'
 import { buildSchema } from '@amritk/generate-parsers'
@@ -10,6 +10,8 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
 
 const execFileAsync = promisify(execFile)
 
+import type { CliConfig } from './cli-config'
+import { combineGeneratedFiles } from './combine-files'
 import { detectHelpersMode } from './detect-helpers-mode'
 import { loadConfig } from './load-config'
 import { loadSchemaModule } from './load-schema-module'
@@ -35,42 +37,93 @@ const extractConfigPath = (args: readonly string[]): string | undefined => {
   return undefined
 }
 
-const run = async (): Promise<void> => {
-  // Skip the first two args (node executable and script path)
-  const args = process.argv.slice(2)
+/** Reads a JSON Schema off disk, or loads a module and converts it via its adapter. */
+const loadSchema = async (config: Partial<CliConfig>, schemaPath: string): Promise<unknown> => {
+  const inputFormat = config.input ?? 'json'
 
-  const configPath = extractConfigPath(args)
+  if (inputFormat === 'json') {
+    return JSON.parse(await readFile(schemaPath, 'utf-8'))
+  }
 
-  // Start with config file values if provided, then overlay CLI flags on top
-  const fileConfig = configPath ? await loadConfig(configPath) : {}
-  const cliConfig = parseCliArgs(args)
-  const config = { ...fileConfig, ...cliConfig }
+  console.log(`Input format: ${inputFormat}`)
+  const source = await loadSchemaModule(schemaPath, config.export)
+  return getAdapter(inputFormat).toJSONSchema(source)
+}
 
-  if (!config.schema) {
-    console.error('Error: --schema is required. Provide a path to a JSON Schema file.')
-    process.exit(1)
+/** Writes a generated file, creating any parent directories the filename implies. */
+const writeGeneratedFile = async (baseDir: string, filename: string, content: string): Promise<void> => {
+  const filePath = join(baseDir, filename)
+  await mkdir(dirname(filePath), { recursive: true })
+  await writeFile(filePath, content, 'utf-8')
+}
+
+/**
+ * Compiles the generated `.ts` files to `.js`/`.d.ts` with a temporary tsconfig,
+ * then removes the intermediate sources. `tsFiles` are paths relative to `outputDir`.
+ */
+const buildOutput = async (outputDir: string, tsFiles: readonly string[], typesOnly?: boolean): Promise<void> => {
+  // Write a minimal tsconfig so tsc can compile the generated files without
+  // inheriting settings like allowImportingTsExtensions that block emission.
+  // In 'package' mode tsc finds @amritk/helpers via the consumer's node_modules.
+  // In 'embedded' mode the helpers live under ./_helpers and need no resolution.
+  const tsconfigContent = JSON.stringify(
+    {
+      compilerOptions: {
+        target: 'ESNext',
+        module: 'ESNext',
+        moduleResolution: 'bundler',
+        declaration: true,
+        emitDeclarationOnly: typesOnly,
+        skipLibCheck: true,
+      },
+      include: tsFiles.map((file) => `./${file}`),
+    },
+    null,
+    2,
+  )
+
+  const tsconfigPath = join(outputDir, '.tsconfig-mjst-build.json')
+  await writeFile(tsconfigPath, tsconfigContent, 'utf-8')
+
+  try {
+    await execFileAsync('npx', ['tsc', '--project', tsconfigPath])
+  } catch {
+    throw new Error('TypeScript compilation failed. Check the generated files for errors.')
+  } finally {
+    await unlink(tsconfigPath)
   }
 
-  if (!config.outDir) {
-    console.error('Error: --outDir is required. Provide an output directory for generated files.')
-    process.exit(1)
+  // Remove the intermediate .ts files now that .js and .d.ts have been produced
+  for (const file of tsFiles) {
+    await unlink(join(outputDir, file))
+    console.log(`Built: ${file.replace(/\.ts$/, '.js')}`)
+    console.log(`Built: ${file.replace(/\.ts$/, '.d.ts')}`)
   }
 
-  const schemaPath = resolve(config.schema)
-  const inputFormat = config.input ?? 'json'
+  console.log(`\nTotal files built: ${tsFiles.length * 2}`)
+}
 
-  // 'json' is read straight off disk; every other format loads the schema as a
-  // module and runs it through its adapter to produce a JSON Schema.
-  let schema: unknown
-  if (inputFormat === 'json') {
-    schema = JSON.parse(await readFile(schemaPath, 'utf-8'))
-  } else {
-    console.log(`Input format: ${inputFormat}`)
-    const source = await loadSchemaModule(schemaPath, config.export)
-    schema = await getAdapter(inputFormat).toJSONSchema(source)
+/** Recursively collects every `*.json` file under `dir`, returning absolute paths. */
+const findJsonSchemas = async (dir: string): Promise<string[]> => {
+  const entries = await readdir(dir, { withFileTypes: true })
+  const results: string[] = []
+
+  for (const entry of entries) {
+    const full = join(dir, entry.name)
+    if (entry.isDirectory()) {
+      results.push(...(await findJsonSchemas(full)))
+    } else if (entry.isFile() && entry.name.endsWith('.json')) {
+      results.push(full)
+    }
   }
 
-  const outputDir = resolve(config.outDir)
+  return results
+}
+
+/** Generates parsers for a single schema (the original one-schema-in, one-outDir-out flow). */
+const runSingle = async (config: Partial<CliConfig>, schemaPath: string, outputDir: string): Promise<void> => {
+  const schema = await loadSchema(config, schemaPath)
+
   await mkdir(outputDir, { recursive: true })
 
   const helpersMode = config.helpers ?? detectHelpersMode(outputDir)
@@ -87,63 +140,199 @@ const run = async (): Promise<void> => {
     config.logWarnings,
     config.strict,
     helpersMode,
+    undefined,
+    config.readonly,
   )
 
   for (const file of files) {
-    const filePath = join(outputDir, file.filename)
-    // Create subdirectories if the filename contains a path
-    await mkdir(dirname(filePath), { recursive: true })
-    await writeFile(filePath, file.content, 'utf-8')
+    await writeGeneratedFile(outputDir, file.filename, file.content)
     console.log(`Generated: ${file.filename}`)
   }
 
   if (config.build) {
-    // Write a minimal tsconfig so tsc can compile the generated files without
-    // inheriting settings like allowImportingTsExtensions that block emission.
-    // In 'package' mode tsc finds @amritk/helpers via the consumer's node_modules.
-    // In 'embedded' mode the helpers live under ./_helpers and need no resolution.
-    const tsconfigContent = JSON.stringify(
-      {
-        compilerOptions: {
-          target: 'ESNext',
-          module: 'ESNext',
-          moduleResolution: 'bundler',
-          declaration: true,
-          emitDeclarationOnly: config.typesOnly,
-          skipLibCheck: true,
-        },
-        include: ['./**/*.ts'],
-      },
-      null,
-      2,
+    await buildOutput(
+      outputDir,
+      files.map((f) => f.filename),
+      config.typesOnly,
     )
+  } else {
+    console.log(`\nTotal files generated: ${files.length}`)
+  }
+}
+
+/**
+ * Generates a single self-contained file from one schema, concatenating every
+ * generated definition (and dropping the cross-file imports that are no longer
+ * needed) into `outFilePath`. Currently used for types-only output.
+ */
+const runSingleFile = async (config: Partial<CliConfig>, schemaPath: string, outFilePath: string): Promise<void> => {
+  const schema = await loadSchema(config, schemaPath)
+  const outputDir = dirname(outFilePath)
+  await mkdir(outputDir, { recursive: true })
 
-    const tsconfigPath = join(outputDir, '.tsconfig-mjst-build.json')
-    await writeFile(tsconfigPath, tsconfigContent, 'utf-8')
+  const rootTypeName = deriveRootTypeName(schema)
+  console.log(`Root type: ${rootTypeName}`)
 
-    try {
-      await execFileAsync('npx', ['tsc', '--project', tsconfigPath])
-    } catch {
-      throw new Error('TypeScript compilation failed. Check the generated files for errors.')
-    } finally {
-      await unlink(tsconfigPath)
-    }
+  const files = await buildSchema(
+    schema as JSONSchema,
+    rootTypeName,
+    undefined,
+    config.typesOnly,
+    config.logWarnings,
+    config.strict,
+    config.helpers ?? 'package',
+    undefined,
+    config.readonly,
+  )
+
+  await writeFile(outFilePath, combineGeneratedFiles(files), 'utf-8')
+  console.log(`Generated: ${relative(process.cwd(), outFilePath)}`)
+
+  if (config.build) {
+    await buildOutput(outputDir, [basename(outFilePath)], config.typesOnly)
+  } else {
+    console.log(`\nTotal files generated: 1`)
+  }
+}
+
+/**
+ * Generates parsers for every JSON Schema under `schemaDir`, mirroring the directory
+ * layout into `outDir`. Each schema's output lands in its own subdirectory (so files
+ * from different schemas never collide) and the runtime helpers are emitted once into a
+ * shared `outDir/_helpers/` that every nested parser imports from.
+ */
+const runRecursive = async (config: Partial<CliConfig>, schemaDir: string, outputDir: string): Promise<void> => {
+  if (config.input && config.input !== 'json') {
+    console.error("Error: --schemaDir only supports JSON Schema files; remove --input or set it to 'json'.")
+    process.exit(1)
+  }
+
+  const schemaFiles = await findJsonSchemas(schemaDir)
+
+  if (schemaFiles.length === 0) {
+    console.error(`Error: no .json schema files found under ${schemaDir}.`)
+    process.exit(1)
+  }
+
+  await mkdir(outputDir, { recursive: true })
+
+  const helpersMode = config.helpers ?? detectHelpersMode(outputDir)
+  console.log(`Helpers mode: ${helpersMode}${config.helpers ? ' (explicit)' : ' (auto-detected)'}`)
+
+  // Helper sources are identical across schemas, so collect them by filename and
+  // write the deduplicated set once at the output root.
+  const sharedHelpers = new Map<string, string>()
+  const writtenTsFiles: string[] = []
+
+  for (const schemaFile of schemaFiles) {
+    const relPath = relative(schemaDir, schemaFile)
+    const relNoExt = relPath.slice(0, -'.json'.length)
+    const schemaSubDir = join(outputDir, relNoExt)
+    // Depth of the schema's output subdirectory, used to build the relative import
+    // path back to the shared `_helpers/` at the output root (../, ../../, ...).
+    const depth = relNoExt.split(sep).filter(Boolean).length
+    const helpersImportPrefix = '../'.repeat(depth)
+
+    const schema = await loadSchema(config, schemaFile)
+    const rootTypeName = deriveRootTypeName(schema)
+    console.log(`\n${relPath} → ${relNoExt}/ (root type: ${rootTypeName})`)
+
+    const files = await buildSchema(
+      schema as JSONSchema,
+      rootTypeName,
+      undefined,
+      config.typesOnly,
+      config.logWarnings,
+      config.strict,
+      helpersMode,
+      helpersImportPrefix,
+      config.readonly,
+    )
 
-    // Remove the intermediate .ts files now that .js and .d.ts have been produced
     for (const file of files) {
-      await unlink(join(outputDir, file.filename))
-      const jsFilename = file.filename.replace(/\.ts$/, '.js')
-      const dtsFilename = file.filename.replace(/\.ts$/, '.d.ts')
-      console.log(`Built: ${jsFilename}`)
-      console.log(`Built: ${dtsFilename}`)
+      if (file.filename.startsWith('_helpers/')) {
+        sharedHelpers.set(file.filename, file.content)
+        continue
+      }
+
+      await writeGeneratedFile(schemaSubDir, file.filename, file.content)
+      const relativeFilename = join(relNoExt, file.filename)
+      writtenTsFiles.push(relativeFilename)
+      console.log(`Generated: ${relativeFilename}`)
     }
+  }
+
+  for (const [filename, content] of sharedHelpers) {
+    await writeGeneratedFile(outputDir, filename, content)
+    writtenTsFiles.push(filename)
+    console.log(`Generated: ${filename}`)
+  }
 
-    console.log(`\nTotal files built: ${files.length * 2}`)
+  if (config.build) {
+    await buildOutput(outputDir, writtenTsFiles, config.typesOnly)
   } else {
-    console.log(`\nTotal files generated: ${files.length}`)
+    console.log(`\nTotal files generated: ${writtenTsFiles.length}`)
   }
 }
 
+const run = async (): Promise<void> => {
+  // Skip the first two args (node executable and script path)
+  const args = process.argv.slice(2)
+
+  const configPath = extractConfigPath(args)
+
+  // Start with config file values if provided, then overlay CLI flags on top
+  const fileConfig = configPath ? await loadConfig(configPath) : {}
+  const cliConfig = parseCliArgs(args)
+  const config = { ...fileConfig, ...cliConfig }
+
+  if (config.outDir && config.outFile) {
+    console.error('Error: provide only one of --out-dir or --out-file, not both.')
+    process.exit(1)
+  }
+
+  // Single-file output is the alternative to a directory of files.
+  if (config.outFile) {
+    if (!config.typesOnly) {
+      console.error('Error: --out-file currently supports only --types-only output. Add --types-only or use --out-dir.')
+      process.exit(1)
+    }
+
+    if (config.schemaDir) {
+      console.error('Error: --out-file cannot be combined with --schema-dir; use --out-dir for recursive output.')
+      process.exit(1)
+    }
+
+    if (!config.schema) {
+      console.error('Error: --schema is required. Provide a path to a JSON Schema.')
+      process.exit(1)
+    }
+
+    await runSingleFile(config, resolve(config.schema), resolve(config.outFile))
+    return
+  }
+
+  if (!config.outDir) {
+    console.error('Error: --out-dir or --out-file is required. Provide an output destination for generated files.')
+    process.exit(1)
+  }
+
+  const outputDir = resolve(config.outDir)
+
+  // schemaDir activates recursive mode and takes precedence over a single schema.
+  if (config.schemaDir) {
+    await runRecursive(config, resolve(config.schemaDir), outputDir)
+    return
+  }
+
+  if (!config.schema) {
+    console.error('Error: --schema (or --schemaDir) is required. Provide a path to a JSON Schema.')
+    process.exit(1)
+  }
+
+  await runSingle(config, resolve(config.schema), outputDir)
+}
+
 run().catch((error: unknown) => {
   console.error(error instanceof Error ? error.message : error)
   process.exit(1)

package/src/combine-files.test.ts

@@ -0,0 +1,49 @@
+import type { GeneratedFile } from '@amritk/generate-parsers'
+import { describe, expect, it } from 'vitest'
+
+import { combineGeneratedFiles } from './combine-files'
+
+describe('combineGeneratedFiles', () => {
+  it('drops relative imports and the index barrel, inlining every definition', () => {
+    const files: GeneratedFile[] = [
+      {
+        filename: 'document.ts',
+        content: "import type { Person } from './person';\n\nexport type Document = {\n  owner?: Person;\n};",
+      },
+      {
+        filename: 'person.ts',
+        content: 'export type Person = {\n  name: string;\n};',
+      },
+      {
+        filename: 'index.ts',
+        content: "export type { Document } from './document';\nexport type { Person } from './person';\n",
+      },
+    ]
+
+    const result = combineGeneratedFiles(files)
+
+    expect(result).not.toContain('import')
+    expect(result).not.toContain('./document')
+    expect(result).toContain('export type Document =')
+    expect(result).toContain('export type Person =')
+  })
+
+  it('hoists and deduplicates external (non-relative) imports', () => {
+    const files: GeneratedFile[] = [
+      {
+        filename: 'a.ts',
+        content: "import { isObject } from '@amritk/helpers/is-object';\n\nexport const a = isObject;",
+      },
+      {
+        filename: 'b.ts',
+        content: "import { isObject } from '@amritk/helpers/is-object';\n\nexport const b = isObject;",
+      },
+    ]
+
+    const result = combineGeneratedFiles(files)
+    const importCount = result.split('\n').filter((line) => line.startsWith('import')).length
+
+    expect(importCount).toBe(1)
+    expect(result).toContain("import { isObject } from '@amritk/helpers/is-object';")
+  })
+})

package/src/combine-files.ts

@@ -0,0 +1,43 @@
+import type { GeneratedFile } from '@amritk/generate-parsers'
+
+// Require whitespace after `import` so a property literally named `import` (e.g.
+// `import?: string`) is not mistaken for an import statement.
+const IMPORT_RE = /^import\s/
+const RELATIVE_IMPORT_RE = /\bfrom\s+['"]\.\.?\//
+
+/**
+ * Merges the per-schema {@link GeneratedFile}s into a single self-contained
+ * TypeScript module. Each generated file imports its sibling definitions via
+ * relative paths; since everything now lives in one file those imports are
+ * dropped, while any external (package) imports are hoisted to the top and
+ * deduplicated. The `index.ts` barrel is skipped because it only re-exports the
+ * declarations that are already inlined here.
+ *
+ * Intended for types-only output, where files contain only type definitions and
+ * type-only relative imports (no runtime helpers).
+ */
+export const combineGeneratedFiles = (files: readonly GeneratedFile[]): string => {
+  const externalImports = new Set<string>()
+  const bodies: string[] = []
+
+  for (const file of files) {
+    if (file.filename === 'index.ts') continue
+
+    const bodyLines: string[] = []
+    for (const line of file.content.split('\n')) {
+      if (IMPORT_RE.test(line.trimStart())) {
+        // Relative imports point at sibling files that are now inlined — drop them.
+        if (RELATIVE_IMPORT_RE.test(line)) continue
+        externalImports.add(line.trim())
+        continue
+      }
+      bodyLines.push(line)
+    }
+
+    const body = bodyLines.join('\n').trim()
+    if (body) bodies.push(body)
+  }
+
+  const importBlock = [...externalImports].sort().join('\n')
+  return [importBlock, bodies.join('\n\n')].filter(Boolean).join('\n\n') + '\n'
+}

package/src/load-config.test.ts

@@ -58,6 +58,15 @@ describe('load-config', () => {
     expect(result).toEqual({ schema: 's.json', outDir: 'o', strict: true })
   })
 
+  it('loads schemaDir from a config file', async () => {
+    const configPath = join(tmpdir(), `test-config-${Date.now()}.json`)
+    await writeFile(configPath, JSON.stringify({ schemaDir: './schemas', outDir: 'output' }))
+
+    const result = await loadConfig(configPath)
+
+    expect(result).toEqual({ schemaDir: './schemas', outDir: 'output' })
+  })
+
   it('ignores non-boolean strict value', async () => {
     const configPath = join(tmpdir(), `test-config-${Date.now()}.json`)
     await writeFile(configPath, JSON.stringify({ schema: 's.json', strict: 'yes' }))

package/src/load-config.ts

@@ -26,12 +26,15 @@ export const loadConfig = async (configPath: string): Promise<Partial<CliConfig>
 
   return {
     ...(typeof obj['schema'] === 'string' && { schema: obj['schema'] }),
+    ...(typeof obj['schemaDir'] === 'string' && { schemaDir: obj['schemaDir'] }),
     ...(typeof obj['outDir'] === 'string' && { outDir: obj['outDir'] }),
+    ...(typeof obj['outFile'] === 'string' && { outFile: obj['outFile'] }),
     ...(isSourceFormat(obj['input']) && { input: obj['input'] }),
     ...(typeof obj['export'] === 'string' && { export: obj['export'] }),
     ...(typeof obj['typesOnly'] === 'boolean' && { typesOnly: obj['typesOnly'] }),
     ...(typeof obj['build'] === 'boolean' && { build: obj['build'] }),
     ...(typeof obj['logWarnings'] === 'boolean' && { logWarnings: obj['logWarnings'] }),
     ...(typeof obj['strict'] === 'boolean' && { strict: obj['strict'] }),
+    ...(typeof obj['readonly'] === 'boolean' && { readonly: obj['readonly'] }),
   }
 }

package/src/parse-cli-args.test.ts

@@ -43,6 +43,26 @@ describe('parse-cli-args', () => {
     })
   })
 
+  it('parses --schemaDir with space-separated and equals syntax', () => {
+    expect(parseCliArgs(['--schemaDir', './schemas', '--outDir', 'dist'])).toEqual({
+      schemaDir: './schemas',
+      outDir: 'dist',
+    })
+    expect(parseCliArgs(['--schemaDir=./schemas', '--outDir=dist'])).toEqual({
+      schemaDir: './schemas',
+      outDir: 'dist',
+    })
+  })
+
+  it('keeps --schema and --schemaDir distinct', () => {
+    const result = parseCliArgs(['--schema', 'a.json', '--schemaDir', './schemas'])
+
+    expect(result).toEqual({
+      schema: 'a.json',
+      schemaDir: './schemas',
+    })
+  })
+
   it('handles only --outDir without --schema', () => {
     const result = parseCliArgs(['--outDir', 'output'])
 
@@ -223,4 +243,32 @@ describe('parse-cli-args', () => {
     const result = parseCliArgs(['--helpers=foo', '--schema', 's.json'])
     expect(result).toEqual({ schema: 's.json' })
   })
+
+  it('accepts kebab-case flag names', () => {
+    const result = parseCliArgs(['--schema-dir', './schemas', '--out-dir', 'dist'])
+
+    expect(result).toEqual({
+      schemaDir: './schemas',
+      outDir: 'dist',
+    })
+  })
+
+  it('treats kebab-case and camelCase variants as equivalent', () => {
+    const kebab = parseCliArgs(['--out-dir', 'dist', '--types-only', '--log-warnings'])
+    const camel = parseCliArgs(['--outDir', 'dist', '--typesOnly', '--logWarnings'])
+
+    expect(kebab).toEqual(camel)
+    expect(camel).toEqual({ outDir: 'dist', typesOnly: true, logWarnings: true })
+  })
+
+  it('parses --out-file with space-separated and equals syntax', () => {
+    expect(parseCliArgs(['--out-file', './out/schema.ts'])).toEqual({ outFile: './out/schema.ts' })
+    expect(parseCliArgs(['--outFile=./out/schema.ts'])).toEqual({ outFile: './out/schema.ts' })
+  })
+
+  it('parses --readonly boolean flag and its equals forms', () => {
+    expect(parseCliArgs(['--readonly'])).toEqual({ readonly: true })
+    expect(parseCliArgs(['--readonly=true'])).toEqual({ readonly: true })
+    expect(parseCliArgs(['--readonly=false'])).toEqual({ readonly: false })
+  })
 })