@kubb/cli 5.0.0-beta.63 → 5.0.0-beta.64

package/src/runners/generate/utils.ts

@@ -1,235 +0,0 @@
-import { hash } from 'node:crypto'
-import { styleText } from 'node:util'
-import { createModuleLoader } from '@internals/shared'
-import type { AsyncEventEmitter } from '@internals/utils'
-import { toError } from '@internals/utils'
-import type { CLIOptions, Config, KubbHooks, PossibleConfig } from '@kubb/core'
-import { cosmiconfig } from 'cosmiconfig'
-import { NonZeroExitError, x } from 'tinyexec'
-import { WATCHER_IGNORED_PATHS } from '../../constants.ts'
-
-type CosmiconfigResult = {
-  filepath: string
-  isEmpty?: boolean
-  config: PossibleConfig<CLIOptions>
-}
-
-const loader = createModuleLoader()
-
-const tsLoader = (configFile: string) => loader.load(configFile, { default: true })
-
-const MODULE_NAME = 'kubb'
-
-const BASE_SEARCH_PLACES = [
-  'package.json',
-  `.${MODULE_NAME}rc`,
-  `.${MODULE_NAME}rc.json`,
-  `.${MODULE_NAME}rc.yaml`,
-  `.${MODULE_NAME}rc.yml`,
-  `.${MODULE_NAME}rc.ts`,
-  `.${MODULE_NAME}rc.mts`,
-  `.${MODULE_NAME}rc.cts`,
-  `.${MODULE_NAME}rc.js`,
-  `.${MODULE_NAME}rc.mjs`,
-  `.${MODULE_NAME}rc.cjs`,
-  `${MODULE_NAME}.config.ts`,
-  `${MODULE_NAME}.config.mts`,
-  `${MODULE_NAME}.config.cts`,
-  `${MODULE_NAME}.config.js`,
-  `${MODULE_NAME}.config.mjs`,
-  `${MODULE_NAME}.config.cjs`,
-]
-
-const SEARCH_PLACES = ['', '.config/', 'configs/'].flatMap((prefix) => BASE_SEARCH_PLACES.map((p) => `${prefix}${p}`))
-
-async function getCosmiConfig(configFile?: string): Promise<CosmiconfigResult> {
-  const explorer = cosmiconfig(MODULE_NAME, {
-    cache: false,
-    searchPlaces: SEARCH_PLACES,
-    loaders: { '.ts': tsLoader, '.mts': tsLoader, '.cts': tsLoader },
-  })
-
-  let result: CosmiconfigResult
-  try {
-    result = (configFile ? await explorer.load(configFile) : await explorer.search()) as CosmiconfigResult
-  } catch (error) {
-    throw new Error('Config failed loading', { cause: error })
-  }
-
-  if (!result?.config || result.isEmpty) {
-    throw new Error('Config not defined, create a kubb.config.js or pass through your config with the option --config')
-  }
-
-  return result
-}
-
-type GetConfigsOptions = {
-  /**
-   * Explicit path to the Kubb config file. When omitted, cosmiconfig searches from the current directory.
-   */
-  configPath?: string
-  /**
-   * Optional OpenAPI input path that overrides `config.input.path` for this run.
-   */
-  input?: string
-  /**
-   * Watch flag forwarded to the user's `defineConfig` function.
-   */
-  watch?: boolean
-  /**
-   * Log level forwarded to the user's `defineConfig` function.
-   */
-  logLevel?: CLIOptions['logLevel']
-}
-
-type GetConfigsResult = {
-  /**
-   * Absolute path to the resolved config file.
-   */
-  configPath: string
-  /**
-   * Resolved and normalized array of Kubb configs, each guaranteed to have a `plugins` array.
-   */
-  configs: Array<Config>
-}
-
-/**
- * Discovers the Kubb config via cosmiconfig and resolves it into a normalized array of configs.
- * Every config in the result is guaranteed to have a `plugins` array.
- */
-export async function getConfigs({ configPath, input, watch, logLevel }: GetConfigsOptions): Promise<GetConfigsResult> {
-  const result = await getCosmiConfig(configPath)
-  const cli: CLIOptions = { config: configPath, input, watch, logLevel }
-  const resolved = await (typeof result.config === 'function' ? result.config(cli) : result.config)
-  const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
-
-  return {
-    configPath: result.filepath,
-    configs: userConfigs.map((item) => ({ ...item, plugins: item.plugins ?? [] }) as Config),
-  }
-}
-
-type ExecuteHooksOptions = {
-  configHooks: NonNullable<Config['hooks']>
-  hooks: AsyncEventEmitter<KubbHooks>
-}
-
-/**
- * Tokenizes a shell command string, respecting single and double quotes.
- *
- * @example
- * ```ts
- * tokenize('git commit -m "initial commit"')
- * // → ['git', 'commit', '-m', 'initial commit']
- * ```
- */
-function tokenize(command: string): Array<string> {
-  return (command.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g) ?? []).map((token) => token.replace(/^["']|["']$/g, ''))
-}
-
-/**
- * Runs the `done` hooks defined in a Kubb config in sequence.
- */
-export async function executeHooks({ configHooks, hooks }: ExecuteHooksOptions): Promise<void> {
-  const commands = Array.isArray(configHooks.done) ? configHooks.done : [configHooks.done].filter(Boolean)
-
-  for (const command of commands) {
-    const [cmd, ...args] = tokenize(command)
-    if (!cmd) continue
-
-    const hookId = hash('sha256', command, 'hex')
-    const commandWithArgs = [cmd, ...args].join(' ')
-
-    await hooks.emit('kubb:hook:start', { id: hookId, command: cmd, args })
-    await runHook({ id: hookId, command: cmd, args, commandWithArgs, hooks })
-  }
-}
-
-type RunHookOptions = {
-  id: string
-  command: string
-  args?: ReadonlyArray<string>
-  commandWithArgs: string
-  hooks: AsyncEventEmitter<KubbHooks>
-}
-
-/**
- * Spawns a hook command and reports its outcome through `kubb:hook:end`.
- * A non-zero exit signals failure via `kubb:hook:end` rather than throwing, so the caller can turn
- * it into a diagnostic. Other spawn errors do the same. Output is streamed through `kubb:hook:line`
- * only while a listener is attached.
- */
-export async function runHook({ id, command, args, commandWithArgs, hooks }: RunHookOptions): Promise<void> {
-  const emitEnd = (success: boolean, error: Error | null, output?: { stdout?: string; stderr?: string }) =>
-    hooks.emit('kubb:hook:end', { command, args, id, success, error, ...output })
-
-  // Only stream line-by-line when a logger is listening, so the non-streaming plain
-  // logger doesn't pay to iterate the subprocess output.
-  const stream = hooks.listenerCount('kubb:hook:line') > 0
-
-  try {
-    const proc = x(command, [...(args ?? [])], {
-      nodeOptions: { detached: process.platform !== 'win32' },
-      throwOnError: true,
-    })
-
-    if (stream) {
-      for await (const line of proc) {
-        await hooks.emit('kubb:hook:line', { id, line })
-      }
-    }
-
-    await proc
-    await hooks.emit('kubb:success', { message: `${styleText('dim', commandWithArgs)} successfully executed` })
-    await emitEnd(true, null)
-  } catch (err) {
-    if (!(err instanceof NonZeroExitError)) {
-      const error = toError(err)
-      await emitEnd(false, error)
-      return
-    }
-
-    const stderr = err.output?.stderr ?? ''
-    const stdout = err.output?.stdout ?? ''
-
-    const error = new Error(`Hook execute failed: ${commandWithArgs}`)
-    // Signal the failure via `kubb:hook:end` only, carrying the captured output so the logger can
-    // render it. The caller turns this into a coded diagnostic and emits that through
-    // `Diagnostics.emit`, so emitting `kubb:error` here would render it twice.
-    await emitEnd(false, error, { stdout, stderr })
-  }
-}
-
-type WatcherLog = {
-  info: (message: string) => void
-  error: (message: string) => void
-}
-
-/**
- * Starts a file watcher on the given paths and calls `cb` on any change.
- * Ignores `.git` and `node_modules` directories.
- */
-export async function startWatcher(
-  path: Array<string>,
-  cb: (path: Array<string>) => Promise<void>,
-  log: WatcherLog = { info: console.log, error: console.log },
-): Promise<void> {
-  const { watch } = await import('chokidar')
-  const watcher = watch(path, { ignorePermissionErrors: true, ignored: WATCHER_IGNORED_PATHS })
-
-  process.once('SIGINT', () => {
-    watcher.close()
-  })
-  process.once('SIGTERM', () => {
-    watcher.close()
-  })
-
-  watcher.on('all', async (type, file) => {
-    log.info(styleText('yellow', styleText('bold', `Change detected: ${type} ${file}`)))
-    try {
-      await cb(path)
-    } catch (_e) {
-      log.error(styleText('red', 'Watcher failed'))
-    }
-  })
-}

package/src/runners/init/run.ts

@@ -1,210 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import process from 'node:process'
-import { styleText } from 'node:util'
-import * as clack from '@clack/prompts'
-import { detectPackageManager } from '@internals/utils'
-import { availablePlugins, generateConfigFile, initDefaults, KUBB_CONFIG_FILENAME, type PluginOption } from '@internals/shared'
-import { hasPackageJson, initPackageJson, installPackages } from './utils.ts'
-
-function cancelAndExit(message = 'Operation canceled.'): never {
-  clack.cancel(message)
-  process.exit(0)
-}
-
-type InitOptions = {
-  /**
-   * When `true`, skips all interactive prompts and uses default values.
-   */
-  yes: boolean
-  /**
-   * Current `@kubb/cli` version string, shown in the closing outro.
-   */
-  version: string
-  /**
-   * Input path flag value from `--input`. When provided, skips the input prompt.
-   */
-  input?: string
-  /**
-   * Output directory flag value from `--output`. When provided, skips the output prompt.
-   */
-  output?: string
-  /**
-   * Comma-separated plugin list from `--plugins`, e.g. `'plugin-ts,plugin-zod'`. When provided, skips the plugin selection prompt.
-   */
-  plugins?: string
-}
-
-/**
- * Runs the interactive Kubb scaffolding wizard.
- * Detects the package manager, prompts for input/output paths and plugins, installs packages, and writes `kubb.config.ts`.
- * Pass `yes: true` to skip all prompts and use defaults.
- */
-export async function run({ yes, version, input: inputFlag, output: outputFlag, plugins: pluginsFlag }: InitOptions): Promise<void> {
-  const cwd = process.cwd()
-
-  clack.intro(styleText('bgCyan', styleText('black', ' Kubb Init ')))
-
-  /**
-   * Returns `flag` when provided, the `defaultValue` when `yes` is set,
-   * or calls `prompt()` for interactive input. Exits on cancellation.
-   */
-  async function resolveOrPrompt<T>(flag: T | undefined, defaultValue: T, logLabel: string, prompt: () => Promise<T | symbol>): Promise<T> {
-    if (flag !== undefined) {
-      clack.log.info(`${logLabel}: ${styleText('cyan', String(flag))}`)
-      return flag
-    }
-    if (yes) {
-      clack.log.info(`${logLabel}: ${styleText('cyan', String(defaultValue))}`)
-      return defaultValue
-    }
-    const result = await prompt()
-    if (clack.isCancel(result)) cancelAndExit()
-    return result as T
-  }
-
-  try {
-    // Check/create package.json, detect package manager once after the block
-    if (!hasPackageJson(cwd)) {
-      if (!yes) {
-        const shouldInit = await clack.confirm({
-          message: 'No package.json found. Would you like to create one?',
-          initialValue: true,
-        })
-
-        if (clack.isCancel(shouldInit) || !shouldInit) {
-          cancelAndExit()
-        }
-      }
-
-      const packageManager = detectPackageManager(cwd)
-      const spinner = clack.spinner()
-      spinner.start(`Initializing package.json with ${packageManager.name}`)
-      await initPackageJson(cwd, packageManager)
-      spinner.stop(`Created package.json with ${packageManager.name}`)
-    }
-
-    const packageManager = detectPackageManager(cwd)
-    if (hasPackageJson(cwd)) {
-      clack.log.info(`Detected package manager: ${styleText('cyan', packageManager.name)}`)
-    }
-
-    // Prompt for OpenAPI spec path
-    const inputPath = await resolveOrPrompt(inputFlag, initDefaults.inputPath, 'Using input path', () =>
-      clack.text({
-        message: 'Where is your OpenAPI specification located?',
-        placeholder: initDefaults.inputPath,
-        defaultValue: initDefaults.inputPath,
-        validate: (value) => {
-          if (!value) return 'Input path is required'
-        },
-      }),
-    )
-
-    // Prompt for output directory
-    const outputPath = await resolveOrPrompt(outputFlag, initDefaults.outputPath, 'Using output path', () =>
-      clack.text({
-        message: 'Where should the generated files be output?',
-        placeholder: initDefaults.outputPath,
-        defaultValue: initDefaults.outputPath,
-        validate: (value) => {
-          if (!value) return 'Output path is required'
-        },
-      }),
-    )
-
-    // Plugin selection
-    const defaultPlugins = availablePlugins.filter((p) => (initDefaults.plugins as ReadonlyArray<string>).includes(p.value))
-    const pluginLabel = (plugins: Array<PluginOption>) => styleText('cyan', plugins.map((p) => p.label).join(', '))
-
-    const selectedPlugins: Array<PluginOption> = await (async () => {
-      if (pluginsFlag) {
-        const requested = pluginsFlag
-          .split(',')
-          .map((v) => v.trim())
-          .filter(Boolean)
-        const plugins = availablePlugins.filter((p) => requested.includes(p.value))
-        if (plugins.length === 0) {
-          clack.log.warn(`No valid plugins found in --plugins value; falling back to default: ${pluginLabel(defaultPlugins)}`)
-          return defaultPlugins
-        }
-        clack.log.info(`Using plugins: ${pluginLabel(plugins)}`)
-        return plugins
-      }
-      if (yes) {
-        clack.log.info(`Using plugins: ${pluginLabel(defaultPlugins)}`)
-        return defaultPlugins
-      }
-      const values = await clack.multiselect({
-        message: 'Select plugins to use:',
-        options: availablePlugins.map(({ value, label, hint }) => ({ value, label, hint })),
-        initialValues: [...initDefaults.plugins],
-        required: true,
-      })
-      if (clack.isCancel(values)) cancelAndExit()
-      return availablePlugins.filter((p) => (values as Array<string>).includes(p.value))
-    })()
-
-    // Install packages
-    const packagesToInstall = ['kubb', ...selectedPlugins.map((p) => p.packageName)]
-
-    const spinner = clack.spinner()
-    spinner.start(`Installing ${packagesToInstall.length} packages with ${packageManager.name}`)
-
-    try {
-      await installPackages(packagesToInstall, packageManager, cwd)
-      spinner.stop(`Installed ${packagesToInstall.length} packages`)
-    } catch (error) {
-      spinner.stop('Installation failed')
-      throw error
-    }
-
-    // Generate config file
-    const configSpinner = clack.spinner()
-    configSpinner.start(`Creating ${KUBB_CONFIG_FILENAME}`)
-
-    const configContent = generateConfigFile({ selectedPlugins, inputPath, outputPath })
-    const configPath = path.join(cwd, KUBB_CONFIG_FILENAME)
-
-    if (fs.existsSync(configPath)) {
-      configSpinner.stop(`${KUBB_CONFIG_FILENAME} already exists`)
-
-      if (!yes) {
-        const shouldOverwrite = await clack.confirm({
-          message: `${KUBB_CONFIG_FILENAME} already exists. Overwrite?`,
-          initialValue: false,
-        })
-
-        if (clack.isCancel(shouldOverwrite) || !shouldOverwrite) {
-          cancelAndExit('Keeping existing configuration. Packages have been installed.')
-        }
-      }
-
-      configSpinner.start(`Overwriting ${KUBB_CONFIG_FILENAME}`)
-    }
-
-    await fs.promises.writeFile(configPath, configContent, 'utf-8')
-
-    configSpinner.stop(`Created ${KUBB_CONFIG_FILENAME}`)
-
-    clack.outro(
-      styleText('green', '✓ All set!') +
-        '\n\n' +
-        styleText('dim', 'Next steps:') +
-        '\n' +
-        styleText('cyan', `  1. Make sure your OpenAPI spec is at: ${inputPath}`) +
-        '\n' +
-        styleText('cyan', '  2. Generate code with: npx kubb generate') +
-        '\n' +
-        styleText('cyan', `  3. Find generated files in: ${outputPath}`) +
-        '\n\n' +
-        styleText('dim', `Using ${packageManager.name} • Kubb v${version}`),
-    )
-  } catch (error) {
-    clack.log.error(styleText('red', 'An error occurred during initialization'))
-    if (error instanceof Error) {
-      clack.log.error(error.message)
-    }
-    process.exit(1)
-  }
-}

package/src/runners/init/utils.ts

@@ -1,39 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import process from 'node:process'
-import type { PackageManagerInfo, PackageManagerName } from '@internals/utils'
-import { x } from 'tinyexec'
-
-/**
- * Returns `true` when a `package.json` exists at `cwd`.
- */
-export function hasPackageJson(cwd: string = process.cwd()): boolean {
-  return fs.existsSync(path.join(cwd, 'package.json'))
-}
-
-/**
- * Initializes a new `package.json` at `cwd` using the detected package manager.
- */
-export async function initPackageJson(cwd: string, packageManager: PackageManagerInfo): Promise<void> {
-  const commands: Record<PackageManagerName, Array<string>> = {
-    npm: ['init', '-y'],
-    pnpm: ['init'],
-    yarn: ['init', '-y'],
-    bun: ['init', '-y'],
-  }
-
-  await x(packageManager.name, commands[packageManager.name], {
-    nodeOptions: { cwd, stdio: 'inherit' },
-    throwOnError: true,
-  })
-}
-
-/**
- * Installs the given packages at `cwd` using the detected package manager.
- */
-export async function installPackages(packages: Array<string>, packageManager: PackageManagerInfo, cwd: string = process.cwd()): Promise<void> {
-  await x(packageManager.name, [...packageManager.installCommand, ...packages], {
-    nodeOptions: { cwd, stdio: 'inherit' },
-    throwOnError: true,
-  })
-}

package/src/runners/mcp/run.ts

@@ -1,42 +0,0 @@
-import process from 'node:process'
-import { styleText } from 'node:util'
-import { getErrorMessage } from '@internals/utils'
-import { Telemetry } from '../../Telemetry.ts'
-import type * as McpModule from '@kubb/mcp'
-
-type McpOptions = {
-  /**
-   * Current `@kubb/cli` version string, used for the telemetry payload.
-   */
-  version: string
-  /**
-   * TCP port for the HTTP MCP server. When `undefined`, the server uses stdio transport.
-   */
-  port?: string
-  /**
-   * Hostname to bind to when running in HTTP mode.
-   *
-   * @default 'localhost'
-   */
-  host?: string
-}
-
-/**
- * Starts the `@kubb/mcp` server and reports the outcome to telemetry.
- *
- * Runs over HTTP when `port` is set, otherwise over stdio.
- */
-export async function run({ version, port, host }: McpOptions): Promise<void> {
-  const { run: startMcpServer } = (await import('@kubb/mcp')) as typeof McpModule
-  const hrStart = process.hrtime()
-  const report = (status: 'success' | 'failed') => Telemetry.send(Telemetry.build({ command: 'mcp', kubbVersion: version, hrStart, status }))
-  try {
-    console.log(styleText('cyan', '⏳ Starting MCP server...'))
-    console.warn(styleText('yellow', 'This feature is still under development, use with caution'))
-    await startMcpServer(undefined, { port: port !== undefined ? Number(port) : undefined, host })
-    await report('success')
-  } catch (error) {
-    await report('failed')
-    console.error(getErrorMessage(error))
-  }
-}

package/src/runners/validate/run.ts

@@ -1,63 +0,0 @@
-import process from 'node:process'
-import { styleText } from 'node:util'
-import { getErrorMessage } from '@internals/utils'
-import { Telemetry } from '../../Telemetry.ts'
-
-type ValidateOptions = {
-  /**
-   * Path or URL to the OpenAPI/Swagger file to validate.
-   */
-  input: string
-  /**
-   * Current `@kubb/cli` version string, used for the telemetry payload.
-   */
-  version: string
-}
-
-type ValidateModule = typeof import('@kubb/adapter-oas')
-type ValidateDependencies = {
-  /**
-   * Loads `@kubb/adapter-oas`. Injected so tests can substitute a mock.
-   */
-  loadValidateModule: () => Promise<ValidateModule>
-}
-
-/**
- * Dynamically loads `@kubb/adapter-oas` for OpenAPI validation.
- */
-export function loadValidateModule(): Promise<ValidateModule> {
-  return import('@kubb/adapter-oas') as Promise<ValidateModule>
-}
-
-/**
- * Validates an OpenAPI/Swagger file at `input` using `@kubb/adapter-oas`.
- * Exits the process with code 1 on validation failure or missing dependency.
- */
-export async function run({ input, version }: ValidateOptions, dependencies: ValidateDependencies = { loadValidateModule }): Promise<void> {
-  const hrStart = process.hrtime()
-  const report = (status: 'success' | 'failed') => Telemetry.send(Telemetry.build({ command: 'validate', kubbVersion: version, hrStart, status }))
-  try {
-    const { adapterOas } = await dependencies.loadValidateModule()
-    const adapter = adapterOas()
-    if (!adapter.validate) {
-      throw new Error('The loaded adapter does not support validation.')
-    }
-    await adapter.validate(input, { throwOnError: true })
-    await report('success')
-    console.log('✅ Validation success')
-  } catch (error) {
-    await report('failed')
-    if (error instanceof Error && /@kubb\/adapter-oas/.test(error.message)) {
-      console.error(styleText('red', 'The @kubb/adapter-oas package is not installed.'))
-      console.error('')
-      console.error('Install it with:')
-      console.error(styleText('cyan', '  npm install @kubb/adapter-oas'))
-      console.error(styleText('cyan', '  # or'))
-      console.error(styleText('cyan', '  pnpm install @kubb/adapter-oas'))
-      console.error('')
-    }
-    console.error('❌ Validation failed')
-    console.error(getErrorMessage(error))
-    process.exit(1)
-  }
-}