@kubb/cli 4.33.0 → 4.33.1

package/src/cli/adapters/nodeAdapter.ts

@@ -1,159 +0,0 @@
-import { parseArgs, styleText } from 'node:util'
-import { renderHelp } from '../help.ts'
-import type { CommandDefinition, OptionType, ParsedArgs, RunOptions } from '../types.ts'
-import { defineCLIAdapter } from '../types.ts'
-
-type ParseOption = { type: OptionType; short?: string; default?: string | boolean }
-type ParseOptions = Record<string, ParseOption>
-
-function buildParseOptions(def: CommandDefinition): ParseOptions {
-  const result: ParseOptions = {
-    help: { type: 'boolean', short: 'h' },
-  }
-
-  for (const [name, opt] of Object.entries(def.options ?? {})) {
-    result[name] = {
-      type: opt.type,
-      ...(opt.short ? { short: opt.short } : {}),
-      ...(opt.default !== undefined ? { default: opt.default } : {}),
-    }
-  }
-
-  return result
-}
-
-async function runCommand(def: CommandDefinition, argv: string[], parentName?: string): Promise<void> {
-  const parseOptions = buildParseOptions(def)
-
-  let parsed: ParsedArgs
-  try {
-    const result = parseArgs({
-      args: argv,
-      options: parseOptions,
-      allowPositionals: true,
-      strict: false,
-    })
-    parsed = { values: result.values as ParsedArgs['values'], positionals: result.positionals }
-  } catch {
-    renderHelp(def, parentName)
-    process.exit(1)
-  }
-
-  if (parsed.values['help']) {
-    renderHelp(def, parentName)
-    process.exit(0)
-  }
-
-  // Validate required options before running the command
-  for (const [name, opt] of Object.entries(def.options ?? {})) {
-    if (opt.required && parsed.values[name] === undefined) {
-      console.error(styleText('red', `Error: --${name} is required`))
-      renderHelp(def, parentName)
-      process.exit(1)
-    }
-  }
-
-  if (!def.run) {
-    renderHelp(def, parentName)
-    process.exit(0)
-  }
-
-  try {
-    await def.run(parsed)
-  } catch (err) {
-    console.error(styleText('red', `Error: ${err instanceof Error ? err.message : String(err)}`))
-    renderHelp(def, parentName)
-    process.exit(1)
-  }
-}
-
-function printRootHelp(programName: string, version: string, defs: CommandDefinition[]): void {
-  console.log(`\n${styleText('bold', 'Usage:')} ${programName} <command> [options]\n`)
-  console.log(`  Kubb generation — v${version}\n`)
-  console.log(styleText('bold', 'Commands:'))
-  for (const def of defs) {
-    console.log(`  ${styleText('cyan', def.name.padEnd(16))}${def.description}`)
-  }
-  console.log()
-  console.log(styleText('bold', 'Options:'))
-  console.log(`  ${styleText('cyan', '-v, --version'.padEnd(30))}Show version number`)
-  console.log(`  ${styleText('cyan', '-h, --help'.padEnd(30))}Show help`)
-  console.log()
-  console.log(`Run ${styleText('cyan', `${programName} <command> --help`)} for command-specific help.\n`)
-}
-
-/** CLI adapter using `node:util parseArgs`. No external dependencies. */
-export const nodeAdapter = defineCLIAdapter({
-  renderHelp(def: CommandDefinition, parentName?: string): void {
-    renderHelp(def, parentName)
-  },
-
-  async run(defs: CommandDefinition[], argv: string[], opts: RunOptions): Promise<void> {
-    const { programName, defaultCommandName, version } = opts
-
-    const args = argv.length >= 2 && argv[0]?.includes('node') ? argv.slice(2) : argv
-
-    if (args[0] === '--version' || args[0] === '-v') {
-      console.log(version)
-      process.exit(0)
-    }
-
-    if (args[0] === '--help' || args[0] === '-h') {
-      printRootHelp(programName, version, defs)
-      process.exit(0)
-    }
-
-    if (args.length === 0) {
-      const defaultDef = defs.find((d) => d.name === defaultCommandName)
-      if (defaultDef?.run) {
-        await runCommand(defaultDef, [], programName)
-      } else {
-        printRootHelp(programName, version, defs)
-      }
-      return
-    }
-
-    const [first, ...rest] = args
-    const isKnownSubcommand = defs.some((d) => d.name === first)
-
-    let def: CommandDefinition | undefined
-    let commandArgv: string[]
-    let parentName: string | undefined
-
-    if (isKnownSubcommand) {
-      def = defs.find((d) => d.name === first)
-      commandArgv = rest
-      parentName = programName
-    } else {
-      def = defs.find((d) => d.name === defaultCommandName)
-      commandArgv = args
-      parentName = programName
-    }
-
-    if (!def) {
-      console.error(`Unknown command: ${first}`)
-      printRootHelp(programName, version, defs)
-      process.exit(1)
-    }
-
-    if (def.subCommands?.length) {
-      const [subName, ...subRest] = commandArgv
-      const subDef = def.subCommands.find((s) => s.name === subName)
-
-      if (subName === '--help' || subName === '-h') {
-        renderHelp(def, parentName)
-        process.exit(0)
-      }
-
-      if (!subDef) {
-        renderHelp(def, parentName)
-        process.exit(subName ? 1 : 0)
-      }
-
-      await runCommand(subDef, subRest, `${parentName} ${def.name}`)
-      return
-    }
-
-    await runCommand(def, commandArgv, parentName)
-  },
-})

package/src/cli/help.ts

@@ -1,36 +0,0 @@
-import { styleText } from 'node:util'
-import { getCommandSchema } from './schema.ts'
-import type { CommandDefinition, OptionSchema } from './types.ts'
-
-/** Prints formatted help output for a command using its `CommandDefinition`. */
-export function renderHelp(def: CommandDefinition, parentName?: string): void {
-  const schema = getCommandSchema([def])[0]!
-
-  const programName = parentName ? `${parentName} ${schema.name}` : schema.name
-
-  const argsPart = schema.arguments?.length ? ` ${schema.arguments.join(' ')}` : ''
-  const subCmdPart = schema.subCommands.length ? ' <command>' : ''
-  console.log(`\n${styleText('bold', 'Usage:')} ${programName}${argsPart}${subCmdPart} [options]\n`)
-
-  if (schema.description) {
-    console.log(`  ${schema.description}\n`)
-  }
-
-  if (schema.subCommands.length) {
-    console.log(styleText('bold', 'Commands:'))
-    for (const sub of schema.subCommands) {
-      console.log(`  ${styleText('cyan', sub.name.padEnd(16))}${sub.description}`)
-    }
-    console.log()
-  }
-
-  const options: OptionSchema[] = [...schema.options, { name: 'help', flags: '-h, --help', type: 'boolean' as const, description: 'Show help' }]
-
-  console.log(styleText('bold', 'Options:'))
-  for (const opt of options) {
-    const flags = styleText('cyan', opt.flags.padEnd(30))
-    const defaultPart = opt.default !== undefined ? styleText('dim', ` (default: ${opt.default})`) : ''
-    console.log(`  ${flags}${opt.description}${defaultPart}`)
-  }
-  console.log()
-}

package/src/cli/index.ts

@@ -1,16 +0,0 @@
-export { nodeAdapter } from './adapters/nodeAdapter.ts'
-export { createCLI } from './parse.ts'
-export { getCommandSchema } from './schema.ts'
-export type {
-  BooleanOption,
-  CLIAdapter,
-  CommandDefinition,
-  CommandSchema,
-  OptionDefinition,
-  OptionSchema,
-  OptionType,
-  ParsedArgs,
-  RunOptions,
-  StringOption,
-} from './types.ts'
-export { defineCLIAdapter, defineCommand } from './types.ts'

package/src/cli/parse.ts

@@ -1,18 +0,0 @@
-import { nodeAdapter } from './adapters/nodeAdapter.ts'
-import type { CLIAdapter, CommandDefinition, RunOptions } from './types.ts'
-
-/**
- * Create a CLI runner bound to a specific adapter.
- * Defaults to the built-in `nodeAdapter` (Node.js `node:util parseArgs`).
- */
-export function createCLI(options?: { adapter?: CLIAdapter }): {
-  run(commands: CommandDefinition[], argv: string[], opts: RunOptions): Promise<void>
-} {
-  const adapter = options?.adapter ?? nodeAdapter
-
-  return {
-    run(commands, argv, opts) {
-      return adapter.run(commands, argv, opts)
-    },
-  }
-}

package/src/cli/schema.ts

@@ -1,38 +0,0 @@
-import type { CommandDefinition, CommandSchema, OptionDefinition, OptionSchema } from './types.ts'
-
-/**
- * Serializes `CommandDefinition[]` to a plain, JSON-serializable structure.
- * Use to expose CLI capabilities to AI agents or MCP tools.
- */
-export function getCommandSchema(defs: CommandDefinition[]): CommandSchema[] {
-  return defs.map(serializeCommand)
-}
-
-function serializeCommand(def: CommandDefinition): CommandSchema {
-  return {
-    name: def.name,
-    description: def.description,
-    arguments: def.arguments,
-    options: serializeOptions(def.options ?? {}),
-    subCommands: def.subCommands ? def.subCommands.map(serializeCommand) : [],
-  }
-}
-
-function serializeOptions(options: Record<string, OptionDefinition>): OptionSchema[] {
-  return Object.entries(options).map(([name, opt]) => {
-    const shortPart = opt.short ? `-${opt.short}, ` : ''
-    const valuePart = opt.type === 'string' ? ` <${opt.hint ?? name}>` : ''
-    const flags = `${shortPart}--${name}${valuePart}`
-
-    return {
-      name,
-      flags,
-      type: opt.type,
-      description: opt.description,
-      ...(opt.default !== undefined ? { default: opt.default } : {}),
-      ...(opt.hint ? { hint: opt.hint } : {}),
-      ...(opt.enum ? { enum: opt.enum } : {}),
-      ...(opt.required ? { required: opt.required } : {}),
-    }
-  })
-}

package/src/cli/types.ts

@@ -1,95 +0,0 @@
-type BaseOption = {
-  /** Single-character short alias, e.g. `'c'` for `--config`. */
-  short?: string
-  description: string
-  hint?: string
-  required?: boolean
-  /** Allowed values for string options. Used in help output and AI/MCP tool schemas. */
-  enum?: string[]
-}
-
-export type StringOption = BaseOption & { type: 'string'; default?: string }
-export type BooleanOption = BaseOption & { type: 'boolean'; default?: boolean }
-export type OptionDefinition = StringOption | BooleanOption
-export type OptionType = OptionDefinition['type']
-
-type OptionTypeMap = { string: string; boolean: boolean }
-
-type IsRequired<O extends OptionDefinition> = O['default'] extends string | boolean ? true : O['required'] extends true ? true : false
-
-/** Infers typed values from an options record. Options with a `default` or `required: true` are always defined. */
-type InferValues<O extends Record<string, OptionDefinition>> = {
-  [K in keyof O as IsRequired<O[K]> extends true ? K : never]: OptionTypeMap[O[K]['type']]
-} & {
-  [K in keyof O as IsRequired<O[K]> extends true ? never : K]?: OptionTypeMap[O[K]['type']]
-}
-
-export type ParsedArgs = {
-  values: Record<string, string | boolean | undefined>
-  positionals: string[]
-}
-
-export type CommandDefinition = {
-  name: string
-  description: string
-  /** Positional argument labels shown in usage line, e.g. `['[input]']`. */
-  arguments?: string[]
-  options?: Record<string, OptionDefinition>
-  subCommands?: CommandDefinition[]
-  run?: (args: ParsedArgs) => Promise<void>
-}
-
-/**
- * Returns a `CommandDefinition` with typed `values` in `run()`.
- * The callback receives `values` typed from the declared options — no casts needed.
- */
-export function defineCommand<O extends Record<string, OptionDefinition>>(def: {
-  name: string
-  description: string
-  arguments?: string[]
-  options?: O
-  subCommands?: CommandDefinition[]
-  run?: (args: { values: InferValues<O>; positionals: string[] }) => Promise<void>
-}): CommandDefinition {
-  const { run, ...rest } = def
-  if (!run) return rest
-  return {
-    ...rest,
-    run: (args) => run({ values: args.values as InferValues<O>, positionals: args.positionals }),
-  }
-}
-
-export type RunOptions = {
-  programName: string
-  defaultCommandName: string
-  version: string
-}
-
-export type CLIAdapter = {
-  run(commands: CommandDefinition[], argv: string[], opts: RunOptions): Promise<void>
-  renderHelp(def: CommandDefinition, parentName?: string): void
-}
-
-/** Returns a `CLIAdapter` with type inference. Pass a different adapter to `createCLI` to swap the CLI engine. */
-export function defineCLIAdapter(adapter: CLIAdapter): CLIAdapter {
-  return adapter
-}
-
-export type OptionSchema = {
-  name: string
-  flags: string
-  type: OptionType
-  description: string
-  default?: string | boolean
-  hint?: string
-  required?: boolean
-  enum?: string[]
-}
-
-export type CommandSchema = {
-  name: string
-  description: string
-  arguments?: string[]
-  options: OptionSchema[]
-  subCommands: CommandSchema[]
-}

package/src/utils/envDetection.ts

@@ -1,34 +0,0 @@
-/**
- * Check if running in GitHub Actions environment
- */
-export function isGitHubActions(): boolean {
-  return !!process.env.GITHUB_ACTIONS
-}
-
-/**
- * Check if running in any CI environment.
- * Covers all major CI systems via their well-known environment variables.
- */
-export function isCIEnvironment(): boolean {
-  return !!(
-    (
-      process.env.CI || // Generic (GitHub Actions, GitLab CI, CircleCI, Travis CI, etc.)
-      process.env.GITHUB_ACTIONS || // GitHub Actions
-      process.env.GITLAB_CI || // GitLab CI
-      process.env.BITBUCKET_BUILD_NUMBER || // Bitbucket Pipelines
-      process.env.JENKINS_URL || // Jenkins
-      process.env.CIRCLECI || // CircleCI
-      process.env.TRAVIS || // Travis CI
-      process.env.TEAMCITY_VERSION || // TeamCity
-      process.env.BUILDKITE || // Buildkite
-      process.env.TF_BUILD
-    ) // Azure Pipelines
-  )
-}
-
-/**
- * Check if TTY is available for interactive output
- */
-export function canUseTTY(): boolean {
-  return !!process.stdout.isTTY && !isCIEnvironment()
-}

package/src/utils/errors.ts

@@ -1,23 +0,0 @@
-/**
- * Coerce an unknown thrown value to an `Error` instance.
- * When the value is already an `Error` it is returned as-is;
- * otherwise a new `Error` is created whose message is `String(value)`.
- */
-export function toError(value: unknown): Error {
-  return value instanceof Error ? value : new Error(String(value))
-}
-
-/**
- * Safely extract a human-readable message from any thrown value.
- */
-export function getErrorMessage(value: unknown): string {
-  return value instanceof Error ? value.message : String(value)
-}
-
-/**
- * Extract the `.cause` property of an `Error` as an `Error | undefined`.
- * Returns `undefined` when the cause is absent or is not an `Error`.
- */
-export function toCause(error: Error): Error | undefined {
-  return error.cause instanceof Error ? error.cause : undefined
-}

package/src/utils/formatMsWithColor.ts

@@ -1,22 +0,0 @@
-import { styleText } from 'node:util'
-import { formatMs } from '@kubb/core/utils'
-
-/**
- * Formats milliseconds with color based on duration thresholds:
- * - Green: <= 500ms
- * - Yellow: > 500ms and <= 1000ms
- * - Red: > 1000ms
- */
-export function formatMsWithColor(ms: number): string {
-  const formatted = formatMs(ms)
-
-  if (ms <= 500) {
-    return styleText('green', formatted)
-  }
-
-  if (ms <= 1000) {
-    return styleText('yellow', formatted)
-  }
-
-  return styleText('red', formatted)
-}

package/src/utils/randomColor.ts

@@ -1,14 +0,0 @@
-import { createHash } from 'node:crypto'
-import { styleText } from 'node:util'
-import { randomColors } from '../constants.ts'
-
-export function randomCliColor(text?: string): string {
-  if (!text) {
-    return ''
-  }
-
-  const index = createHash('sha256').update(text).digest().readUInt32BE(0) % randomColors.length
-  const color = randomColors[index] ?? 'white'
-
-  return styleText(color, text)
-}

package/src/utils/spawnAsync.ts

@@ -1,47 +0,0 @@
-import { spawn } from 'node:child_process'
-
-type SpawnOptions = {
-  cwd?: string
-  env?: NodeJS.ProcessEnv
-  /**
-   * When `true`, spawns a detached background process and resolves immediately.
-   * The child is unref'd so the parent process can exit independently.
-   * Defaults to `false` (foreground — inherits stdio and waits for exit).
-   */
-  detached?: boolean
-}
-
-/**
- * Spawns `cmd args` and returns a promise.
- * - Foreground (default): inherits stdio and resolves when the process exits successfully.
- * - Detached: spawns in its own process group, un-refs the child, and resolves immediately.
- */
-export function spawnAsync(cmd: string, args: string[], options: SpawnOptions = {}): Promise<void> {
-  const { cwd = process.cwd(), env, detached = false } = options
-
-  return new Promise((resolve, reject) => {
-    const child = spawn(cmd, args, {
-      stdio: detached ? 'ignore' : 'inherit',
-      cwd,
-      env,
-      detached,
-    })
-
-    if (detached) {
-      child.unref()
-      resolve()
-      return
-    }
-
-    child.on('close', (code, signal) => {
-      if (code === 0) {
-        resolve()
-      } else if (signal !== null) {
-        reject(new Error(`"${cmd} ${args.join(' ')}" was terminated by signal ${signal}`))
-      } else {
-        reject(new Error(`"${cmd} ${args.join(' ')}" exited with code ${code}`))
-      }
-    })
-    child.on('error', reject)
-  })
-}