@kubb/cli 5.0.0-beta.2 → 5.0.0-beta.21

package/src/runners/generate.ts

@@ -1,333 +0,0 @@
-import { createHash } from 'node:crypto'
-import path from 'node:path'
-import process from 'node:process'
-import { styleText } from 'node:util'
-import * as clack from '@clack/prompts'
-import type { AsyncEventEmitter } from '@internals/utils'
-import { AsyncEventEmitter as AsyncEventEmitterClass, detectFormatter, detectLinter, executeIfOnline, formatters, linters, toError } from '@internals/utils'
-import { type CLIOptions, type Config, createKubb, isInputPath, type KubbHooks, logLevel as logLevelMap } from '@kubb/core'
-import { version } from '../../package.json'
-import { KUBB_NPM_PACKAGE_URL } from '../constants.ts'
-import { setupLogger } from '../loggers/utils.ts'
-import { executeHooks } from '../utils/executeHooks.ts'
-import { getConfigs } from '../utils/getConfig.ts'
-import { getCosmiConfig } from '../utils/getCosmiConfig.ts'
-import { buildTelemetryEvent, sendTelemetry } from '../utils/telemetry.ts'
-import { startWatcher } from '../utils/watcher.ts'
-
-type GenerateProps = {
-  input?: string
-  config: Config
-  hooks: AsyncEventEmitter<KubbHooks>
-  logLevel: number
-}
-
-type ToolMap = typeof formatters | typeof linters
-
-type RunToolPassOptions = {
-  toolValue: string
-  detect: () => Promise<string | null>
-  toolMap: ToolMap
-  /** Short noun used in "Auto-detected <toolLabel>:" message, e.g. "formatter" or "linter". */
-  toolLabel: string
-  /** Verb prefix for the success message, e.g. "Formatting" or "Linting". */
-  successPrefix: string
-  noToolMessage: string
-  configName: string | undefined
-  outputPath: string
-  logLevel: number
-  hooks: AsyncEventEmitter<KubbHooks>
-  onStart: () => Promise<void>
-  onEnd: () => Promise<void>
-}
-
-async function runToolPass({
-  toolValue,
-  detect,
-  toolMap,
-  toolLabel,
-  successPrefix,
-  noToolMessage,
-  configName,
-  outputPath,
-  logLevel,
-  hooks,
-  onStart,
-  onEnd,
-}: RunToolPassOptions) {
-  await onStart()
-
-  let resolvedTool = toolValue
-  if (resolvedTool === 'auto') {
-    const detected = await detect()
-    if (!detected) {
-      await hooks.emit('kubb:warn', { message: noToolMessage })
-    } else {
-      resolvedTool = detected
-      await hooks.emit('kubb:info', { message: `Auto-detected ${toolLabel}: ${styleText('dim', resolvedTool)}` })
-    }
-  }
-
-  let toolError: Error | undefined
-
-  if (resolvedTool && resolvedTool !== 'auto' && resolvedTool in toolMap) {
-    const toolConfig = toolMap[resolvedTool as keyof ToolMap]
-
-    try {
-      const hookId = createHash('sha256').update([configName, resolvedTool].filter(Boolean).join('-')).digest('hex')
-
-      // Wire up the hook:end listener BEFORE emitting hook:start to avoid the race condition
-      // where hook:end fires synchronously inside emit('kubb:hook:start') before the listener is registered.
-      const hookEndPromise = new Promise<void>((resolve, reject) => {
-        const handler = (ctx: { id?: string; command: string; args?: readonly string[]; success: boolean; error: Error | null }) => {
-          if (ctx.id !== hookId) return
-          hooks.off('kubb:hook:end', handler)
-          if (!ctx.success) {
-            reject(ctx.error ?? new Error(`${toolConfig.errorMessage}`))
-            return
-          }
-          hooks
-            .emit('kubb:success', {
-              message: [
-                `${successPrefix} with ${styleText('dim', resolvedTool)}`,
-                logLevel >= logLevelMap.info ? `on ${styleText('dim', outputPath)}` : undefined,
-                'successfully',
-              ]
-                .filter(Boolean)
-                .join(' '),
-            })
-            .then(resolve)
-            .catch(reject)
-        }
-        hooks.on('kubb:hook:end', handler)
-      })
-
-      await hooks.emit('kubb:hook:start', {
-        id: hookId,
-        command: toolConfig.command,
-        args: toolConfig.args(outputPath),
-      })
-
-      await hookEndPromise
-    } catch (caughtError) {
-      // Use the actual error from the hook. toolConfig.errorMessage (e.g. "Oxlint not found")
-      // is misleading when the binary was found and ran but exited with a non-zero code.
-      // runHook already emitted kubb:error for binary-not-found cases; here we surface the
-      // real reason (e.g. "Hook execute failed: oxlint --fix …") for non-zero exits.
-      const err = toError(caughtError)
-      await hooks.emit('kubb:error', { error: err })
-      toolError = err
-    }
-  }
-
-  await onEnd()
-
-  if (toolError) {
-    throw toolError
-  }
-}
-
-async function generate(options: GenerateProps): Promise<void> {
-  const { input, hooks, logLevel } = options
-
-  const hrStart = process.hrtime()
-  const inputPath = input ?? ('path' in options.config.input ? options.config.input.path : undefined)
-
-  const config: Config = {
-    ...options.config,
-    input: inputPath
-      ? {
-          ...options.config.input,
-          path: inputPath,
-        }
-      : options.config.input,
-    ...options.config.output,
-  } satisfies Config
-
-  const kubb = createKubb(config, { hooks })
-  await kubb.setup()
-
-  await hooks.emit('kubb:generation:start', { config })
-
-  await hooks.emit('kubb:info', { message: config.name ? `Setup generation ${styleText('bold', config.name)}` : 'Setup generation', info: inputPath })
-
-  await hooks.emit('kubb:info', { message: config.name ? `Build generation ${styleText('bold', config.name)}` : 'Build generation', info: inputPath })
-
-  const { files, failedPlugins, pluginTimings, error, driver } = await kubb.safeBuild()
-
-  await hooks.emit('kubb:info', { message: 'Load summary' })
-
-  // Handle build failures (either from failed plugins or general errors)
-
-  const hasFailures = failedPlugins.size > 0 || error
-  if (hasFailures) {
-    // Collect all errors from failed plugins and general error
-    const allErrors: Error[] = [
-      error,
-      ...Array.from(failedPlugins)
-        .filter((it) => it.error)
-        .map((it) => it.error),
-    ].filter(Boolean)
-
-    for (const err of allErrors) {
-      await hooks.emit('kubb:error', { error: err })
-    }
-
-    await hooks.emit('kubb:generation:end', { config, files, sources: kubb.sources })
-
-    await hooks.emit('kubb:generation:summary', {
-      config,
-      failedPlugins,
-      filesCreated: files.length,
-      status: 'failed',
-      hrStart,
-      pluginTimings: logLevel >= logLevelMap.verbose ? pluginTimings : undefined,
-    })
-
-    await sendTelemetry(
-      buildTelemetryEvent({
-        command: 'generate',
-        kubbVersion: version,
-        plugins: Array.from(driver.plugins.values(), (p) => ({
-          name: p.name,
-          options: p.options as Record<string, unknown>,
-        })),
-        hrStart,
-        filesCreated: files.length,
-        status: 'failed',
-      }),
-    )
-
-    process.exit(1)
-  }
-
-  await hooks.emit('kubb:success', { message: 'Generation successfully', info: inputPath })
-  await hooks.emit('kubb:generation:end', { config, files, sources: kubb.sources })
-
-  const outputPath = path.resolve(config.root, config.output.path)
-
-  if (config.output.format) {
-    await runToolPass({
-      toolValue: config.output.format,
-      detect: detectFormatter,
-      toolMap: formatters,
-      toolLabel: 'formatter',
-      successPrefix: 'Formatting',
-      noToolMessage: 'No formatter found (oxfmt, biome, or prettier). Skipping formatting.',
-      configName: config.name,
-      outputPath,
-      logLevel,
-      hooks,
-      onStart: () => hooks.emit('kubb:format:start'),
-      onEnd: () => hooks.emit('kubb:format:end'),
-    })
-  }
-
-  if (config.output.lint) {
-    await runToolPass({
-      toolValue: config.output.lint,
-      detect: detectLinter,
-      toolMap: linters,
-      toolLabel: 'linter',
-      successPrefix: 'Linting',
-      noToolMessage: 'No linter found (oxlint, biome, or eslint). Skipping linting.',
-      configName: config.name,
-      outputPath,
-      logLevel,
-      hooks,
-      onStart: () => hooks.emit('kubb:lint:start'),
-      onEnd: () => hooks.emit('kubb:lint:end'),
-    })
-  }
-
-  if (config.hooks) {
-    await hooks.emit('kubb:hooks:start')
-    await executeHooks({ configHooks: config.hooks, hooks })
-
-    await hooks.emit('kubb:hooks:end')
-  }
-
-  // Only reached when there are no failures (process.exit(1) is called above otherwise)
-  await hooks.emit('kubb:generation:summary', {
-    config,
-    failedPlugins,
-    filesCreated: files.length,
-    status: 'success',
-    hrStart,
-    pluginTimings,
-  })
-
-  const telemetryEvent = buildTelemetryEvent({
-    command: 'generate',
-    kubbVersion: version,
-    plugins: Array.from(driver.plugins.values(), (p) => ({
-      name: p.name,
-      options: p.options as Record<string, unknown>,
-    })),
-    hrStart,
-    filesCreated: files.length,
-    status: 'success',
-  })
-
-  await sendTelemetry(telemetryEvent)
-}
-
-type GenerateCommandOptions = {
-  input?: string
-  configPath?: string
-  logLevel: string
-  watch: boolean
-}
-
-export async function runGenerateCommand({ input, configPath, logLevel: logLevelKey, watch }: GenerateCommandOptions): Promise<void> {
-  const logLevel = logLevelMap[logLevelKey as keyof typeof logLevelMap] ?? logLevelMap.info
-  const hooks = new AsyncEventEmitterClass<KubbHooks>()
-
-  await setupLogger(hooks, { logLevel })
-
-  await executeIfOnline(async () => {
-    try {
-      const res = await fetch(KUBB_NPM_PACKAGE_URL)
-      const data = (await res.json()) as { version: string }
-      const latestVersion = data.version
-
-      if (latestVersion && version < latestVersion) {
-        await hooks.emit('kubb:version:new', { currentVersion: version, latestVersion })
-      }
-    } catch {
-      // Ignore network errors for version check
-    }
-  })
-
-  try {
-    const result = await getCosmiConfig('kubb', configPath)
-    const configs = await getConfigs(result.config, { input } as CLIOptions)
-
-    await hooks.emit('kubb:config:start')
-    await hooks.emit('kubb:info', { message: 'Config loaded', info: path.relative(process.cwd(), result.filepath) })
-    await hooks.emit('kubb:success', { message: 'Config loaded successfully', info: path.relative(process.cwd(), result.filepath) })
-    await hooks.emit('kubb:config:end', { configs })
-
-    await hooks.emit('kubb:lifecycle:start', { version })
-
-    for (const config of configs) {
-      if (isInputPath(config) && watch) {
-        await startWatcher([input || config.input.path], async (paths) => {
-          // remove to avoid duplicate listeners after each change
-          hooks.removeAll()
-
-          await generate({ input, config, logLevel, hooks })
-
-          clack.log.step(styleText('yellow', `Watching for changes in ${paths.join(' and ')}`))
-        })
-      } else {
-        await generate({ input, config, logLevel, hooks })
-      }
-    }
-
-    await hooks.emit('kubb:lifecycle:end')
-  } catch (error) {
-    await hooks.emit('kubb:error', { error: toError(error) })
-    process.exit(1)
-  }
-}

package/src/runners/init.ts

@@ -1,296 +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 type { PackageManagerInfo } from '@internals/utils'
-import { detectPackageManager } from '@internals/utils'
-import { initDefaults, KUBB_CONFIG_FILENAME, pluginDefaultConfigs } from '../constants.ts'
-import { hasPackageJson, initPackageJson, installPackages } from '../utils/packageManager.ts'
-
-type PluginOption = {
-  value: string
-  label: string
-  hint?: string
-  packageName: string
-  importName: string
-  category: 'types' | 'client' | 'framework' | 'validation' | 'testing' | 'mocks' | 'documentation' | 'ai'
-}
-
-const availablePlugins: PluginOption[] = [
-  {
-    value: 'plugin-ts',
-    label: 'TypeScript',
-    hint: 'Recommended',
-    packageName: '@kubb/plugin-ts',
-    importName: 'pluginTs',
-    category: 'types',
-  },
-  {
-    value: 'plugin-client',
-    label: 'Client (Fetch/Axios)',
-    packageName: '@kubb/plugin-client',
-    importName: 'pluginClient',
-    category: 'client',
-  },
-  {
-    value: 'plugin-react-query',
-    label: 'React Query / TanStack Query',
-    packageName: '@kubb/plugin-react-query',
-    importName: 'pluginReactQuery',
-    category: 'framework',
-  },
-  {
-    value: 'plugin-vue-query',
-    label: 'Vue Query',
-    packageName: '@kubb/plugin-vue-query',
-    importName: 'pluginVueQuery',
-    category: 'framework',
-  },
-  {
-    value: 'plugin-zod',
-    label: 'Zod Schemas',
-    packageName: '@kubb/plugin-zod',
-    importName: 'pluginZod',
-    category: 'validation',
-  },
-  {
-    value: 'plugin-faker',
-    label: 'Faker.js Mocks',
-    packageName: '@kubb/plugin-faker',
-    importName: 'pluginFaker',
-    category: 'mocks',
-  },
-  {
-    value: 'plugin-msw',
-    label: 'MSW Handlers',
-    packageName: '@kubb/plugin-msw',
-    importName: 'pluginMsw',
-    category: 'mocks',
-  },
-  {
-    value: 'plugin-cypress',
-    label: 'Cypress Tests',
-    packageName: '@kubb/plugin-cypress',
-    importName: 'pluginCypress',
-    category: 'testing',
-  },
-  {
-    value: 'plugin-mcp',
-    label: 'MCP Server (AI / Model Context Protocol)',
-    packageName: '@kubb/plugin-mcp',
-    importName: 'pluginMcp',
-    category: 'ai',
-  },
-  {
-    value: 'plugin-redoc',
-    label: 'ReDoc Documentation',
-    packageName: '@kubb/plugin-redoc',
-    importName: 'pluginRedoc',
-    category: 'documentation',
-  },
-]
-
-function generateConfigFile(selectedPlugins: PluginOption[], inputPath: string, outputPath: string): string {
-  const imports = selectedPlugins.map((plugin) => `import { ${plugin.importName} } from '${plugin.packageName}'`).join('\n')
-
-  const pluginConfigs = selectedPlugins
-    .map((plugin) => {
-      const config = (pluginDefaultConfigs as Record<string, string>)[plugin.value] ?? `${plugin.importName}()`
-      return `    ${config},`
-    })
-    .join('\n')
-
-  return `import { defineConfig } from 'kubb'
-${imports}
-
-export default defineConfig({
-  root: '.',
-  input: {
-    path: '${inputPath}',
-  },
-  output: {
-    path: '${outputPath}',
-    clean: true,
-  },
-  plugins: [
-${pluginConfigs}
-  ],
-})
-`
-}
-
-function cancelAndExit(message = 'Operation cancelled.'): never {
-  clack.cancel(message)
-  process.exit(0)
-}
-
-type InitOptions = {
-  yes: boolean
-  version: string
-}
-
-export async function runInit({ yes, version }: InitOptions): Promise<void> {
-  const cwd = process.cwd()
-
-  clack.intro(styleText('bgCyan', styleText('black', ' Kubb Init ')))
-
-  try {
-    // Check/create package.json
-    let packageManager: PackageManagerInfo
-    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()
-        }
-      }
-
-      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}`)
-    } else {
-      packageManager = detectPackageManager(cwd)
-      clack.log.info(`Detected package manager: ${styleText('cyan', packageManager.name)}`)
-    }
-
-    // Prompt for OpenAPI spec path
-    let inputPath: string
-    if (yes) {
-      inputPath = initDefaults.inputPath
-      clack.log.info(`Using input path: ${styleText('cyan', inputPath)}`)
-    } else {
-      const inputPathResult = await clack.text({
-        message: 'Where is your OpenAPI specification located?',
-        placeholder: initDefaults.inputPath,
-        defaultValue: initDefaults.inputPath,
-        validate: (value) => {
-          if (!value) return 'Input path is required'
-        },
-      })
-
-      if (clack.isCancel(inputPathResult)) {
-        cancelAndExit()
-      }
-      inputPath = inputPathResult as string
-    }
-
-    // Prompt for output directory
-    let outputPath: string
-    if (yes) {
-      outputPath = initDefaults.outputPath
-      clack.log.info(`Using output path: ${styleText('cyan', outputPath)}`)
-    } else {
-      const outputPathResult = await 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'
-        },
-      })
-
-      if (clack.isCancel(outputPathResult)) {
-        cancelAndExit()
-      }
-      outputPath = outputPathResult as string
-    }
-
-    // Plugin selection
-    let selectedPlugins: PluginOption[]
-    if (yes) {
-      selectedPlugins = availablePlugins.filter((plugin) => (initDefaults.plugins as readonly string[]).includes(plugin.value))
-      clack.log.info(`Using plugins: ${styleText('cyan', selectedPlugins.map((p) => p.label).join(', '))}`)
-    } else {
-      const selectedPluginValues = await clack.multiselect({
-        message: 'Select plugins to use:',
-        options: availablePlugins.map((plugin) => ({
-          value: plugin.value,
-          label: plugin.label,
-          hint: plugin.hint,
-        })),
-        initialValues: [...initDefaults.plugins],
-        required: true,
-      })
-
-      if (clack.isCancel(selectedPluginValues)) {
-        cancelAndExit()
-      }
-
-      selectedPlugins = availablePlugins.filter((plugin) => (selectedPluginValues as string[]).includes(plugin.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}`)
-    }
-
-    fs.writeFileSync(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', '     Or start a stream server with: npx kubb start') +
-        '\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/mcp.ts

@@ -1,45 +0,0 @@
-import process from 'node:process'
-import { styleText } from 'node:util'
-import { getErrorMessage } from '@internals/utils'
-import type * as McpModule from '@kubb/mcp'
-import { buildTelemetryEvent, sendTelemetry } from '../utils/telemetry.ts'
-
-type McpOptions = {
-  version: string
-}
-
-export async function runMcp({ version }: McpOptions): Promise<void> {
-  let mod: typeof McpModule
-  try {
-    mod = (await import('@kubb/mcp')) as typeof McpModule
-  } catch (_e) {
-    console.error(`Import of '@kubb/mcp' is required to start the MCP server`)
-    process.exit(1)
-  }
-
-  const { run } = mod
-  const hrStart = process.hrtime()
-  try {
-    console.log('⏳ Starting MCP server...')
-    console.warn(styleText('yellow', 'This feature is still under development — use with caution'))
-    run()
-    await sendTelemetry(
-      buildTelemetryEvent({
-        command: 'mcp',
-        kubbVersion: version,
-        hrStart,
-        status: 'success',
-      }),
-    )
-  } catch (error) {
-    await sendTelemetry(
-      buildTelemetryEvent({
-        command: 'mcp',
-        kubbVersion: version,
-        hrStart,
-        status: 'failed',
-      }),
-    )
-    console.error(getErrorMessage(error))
-  }
-}