@kubb/cli 5.0.0-beta.1 → 5.0.0-beta.11

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))
-  }
-}

package/src/runners/validate.ts

@@ -1,39 +0,0 @@
-import process from 'node:process'
-import { getErrorMessage } from '@internals/utils'
-import { parseDocument, validateDocument } from '@kubb/adapter-oas'
-import { buildTelemetryEvent, sendTelemetry } from '../utils/telemetry.ts'
-
-type ValidateOptions = {
-  input: string
-  version: string
-}
-
-export async function runValidate({ input, version }: ValidateOptions): Promise<void> {
-  const hrStart = process.hrtime()
-  try {
-    const document = await parseDocument(input)
-    await validateDocument(document, { throwOnError: true })
-
-    await sendTelemetry(
-      buildTelemetryEvent({
-        command: 'validate',
-        kubbVersion: version,
-        hrStart,
-        status: 'success',
-      }),
-    )
-    console.log('✅ Validation success')
-  } catch (error) {
-    await sendTelemetry(
-      buildTelemetryEvent({
-        command: 'validate',
-        kubbVersion: version,
-        hrStart,
-        status: 'failed',
-      }),
-    )
-    console.error('❌ Validation failed')
-    console.error(getErrorMessage(error))
-    process.exit(1)
-  }
-}

package/src/types.ts

@@ -1,11 +0,0 @@
-export type QuiteFlag = '--help' | '-h' | '--version' | '-v'
-
-export type GenerateFlag = '--config' | '-c' | '--log-level' | '-l' | '--watch' | '-w' | '--debug' | '-d' | '--verbose' | '-v' | '--silent' | '-s'
-
-export type ValidateFlag = '--input' | '-i'
-
-export type InitFlag = '--yes' | '-y'
-
-export type AgentStartFlag = '--config' | '-c' | '--port' | '-p' | '--host' | '--allow-write' | '--allow-all'
-
-export type Arg = QuiteFlag | GenerateFlag | ValidateFlag | InitFlag | AgentStartFlag

package/src/utils/Writables.ts

@@ -1,17 +0,0 @@
-import type { WritableOptions } from 'node:stream'
-import { Writable } from 'node:stream'
-import { styleText } from 'node:util'
-import type * as clack from '@clack/prompts'
-
-export class ClackWritable extends Writable {
-  taskLog: ReturnType<typeof clack.taskLog>
-  constructor(taskLog: ReturnType<typeof clack.taskLog>, opts?: WritableOptions) {
-    super(opts)
-
-    this.taskLog = taskLog
-  }
-  _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
-    this.taskLog.message(`${styleText('dim', chunk.toString())}`)
-    callback()
-  }
-}

package/src/utils/executeHooks.ts

@@ -1,45 +0,0 @@
-import { createHash } from 'node:crypto'
-import { styleText } from 'node:util'
-import type { AsyncEventEmitter } from '@internals/utils'
-import { tokenize } from '@internals/utils'
-import type { Config, KubbHookEndContext, KubbHooks } from '@kubb/core'
-
-type ExecutingHooksProps = {
-  configHooks: NonNullable<Config['hooks']>
-  hooks: AsyncEventEmitter<KubbHooks>
-}
-
-export async function executeHooks({ configHooks, hooks }: ExecutingHooksProps): 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 = createHash('sha256').update(command).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: KubbHookEndContext) => {
-        if (ctx.id !== hookId) return
-        hooks.off('kubb:hook:end', handler)
-        if (!ctx.success) {
-          reject(ctx.error ?? new Error(`Hook failed: ${command}`))
-          return
-        }
-        hooks
-          .emit('kubb:success', { message: `${styleText('dim', command)} successfully executed` })
-          .then(resolve)
-          .catch(reject)
-      }
-      hooks.on('kubb:hook:end', handler)
-    })
-
-    await hooks.emit('kubb:hook:start', { id: hookId, command: cmd, args })
-    await hookEndPromise
-  }
-}

package/src/utils/flags.ts

@@ -1,9 +0,0 @@
-/**
- * Type guard that confirms `value` is a member of `set`. Avoids type assertions with `Set<T extends string>`.
- */
-export function isFlag<T extends string>(set: ReadonlySet<T>, value: string): value is T {
-  for (const flag of set) {
-    if (flag === value) return true
-  }
-  return false
-}

package/src/utils/getConfig.ts

@@ -1,10 +0,0 @@
-import type { CLIOptions, Config, PossibleConfig } from '@kubb/core'
-
-type ConfigInput = PossibleConfig<CLIOptions>
-
-export async function getConfigs(config: ConfigInput, args: CLIOptions): Promise<Array<Config>> {
-  const resolved = await (typeof config === 'function' ? config(args as CLIOptions) : config)
-  const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
-
-  return userConfigs.map((item) => ({ ...item, plugins: item.plugins ?? [] }) as Config)
-}

package/src/utils/getCosmiConfig.ts

@@ -1,80 +0,0 @@
-import type { Config } from '@kubb/core'
-import { cosmiconfig } from 'cosmiconfig'
-import { unrun } from 'unrun'
-
-type CosmiconfigResult = {
-  filepath: string
-  isEmpty?: boolean
-  config: Config
-}
-
-const unrunInputOptions = {
-  transform: {
-    jsx: {
-      runtime: 'automatic' as const,
-      importSource: '@kubb/renderer-jsx',
-    },
-  },
-}
-
-const tsLoader = async (configFile: string) => {
-  const { module } = await unrun({
-    path: configFile,
-    inputOptions: unrunInputOptions,
-  })
-  return module
-}
-
-export async function getCosmiConfig(moduleName: string, config?: string): Promise<CosmiconfigResult> {
-  let result: CosmiconfigResult
-  const searchPlaces = [
-    'package.json',
-    `.${moduleName}rc`,
-    `.${moduleName}rc.json`,
-    `.${moduleName}rc.yaml`,
-    `.${moduleName}rc.yml`,
-
-    `.${moduleName}rc.ts`,
-    `.${moduleName}rc.mts`,
-    `.${moduleName}rc.cts`,
-    `.${moduleName}rc.js`,
-    `.${moduleName}rc.mjs`,
-    `.${moduleName}rc.cjs`,
-
-    `${moduleName}.config.ts`,
-    `${moduleName}.config.mts`,
-    `${moduleName}.config.cts`,
-    `${moduleName}.config.js`,
-    `${moduleName}.config.mjs`,
-    `${moduleName}.config.cjs`,
-  ]
-  const explorer = cosmiconfig(moduleName, {
-    cache: false,
-    searchPlaces: [
-      ...searchPlaces.map((searchPlace) => {
-        return `.config/${searchPlace}`
-      }),
-      ...searchPlaces.map((searchPlace) => {
-        return `configs/${searchPlace}`
-      }),
-      ...searchPlaces,
-    ],
-    loaders: {
-      '.ts': tsLoader,
-      '.mts': tsLoader,
-      '.cts': tsLoader,
-    },
-  })
-
-  try {
-    result = config ? ((await explorer.load(config)) as CosmiconfigResult) : ((await explorer.search()) as CosmiconfigResult)
-  } catch (error) {
-    throw new Error('Config failed loading', { cause: error })
-  }
-
-  if (result?.isEmpty || !result || !result.config) {
-    throw new Error('Config not defined, create a kubb.config.js or pass through your config with the option --config')
-  }
-
-  return result as CosmiconfigResult
-}

package/src/utils/getSummary.ts

@@ -1,68 +0,0 @@
-import path from 'node:path'
-import { styleText } from 'node:util'
-import { formatHrtime, randomCliColor } from '@internals/utils'
-import type { Config, Plugin } from '@kubb/core'
-import { SUMMARY_MAX_BAR_LENGTH, SUMMARY_TIME_SCALE_DIVISOR } from '../constants.ts'
-
-type SummaryProps = {
-  failedPlugins: Set<{ plugin: Plugin; error: Error }>
-  status: 'success' | 'failed'
-  hrStart: [number, number]
-  filesCreated: number
-  config: Config
-  pluginTimings?: Map<string, number>
-}
-
-export function getSummary({ failedPlugins, filesCreated, status, hrStart, config, pluginTimings }: SummaryProps): string[] {
-  const duration = formatHrtime(hrStart)
-
-  const pluginsCount = config.plugins?.length ?? 0
-  const successCount = pluginsCount - failedPlugins.size
-
-  const meta = {
-    plugins:
-      status === 'success'
-        ? `${styleText('green', `${successCount} successful`)}, ${pluginsCount} total`
-        : `${styleText('green', `${successCount} successful`)}, ${styleText('red', `${failedPlugins.size} failed`)}, ${pluginsCount} total`,
-    pluginsFailed: status === 'failed' ? [...failedPlugins].map(({ plugin }) => randomCliColor(plugin.name)).join(', ') : undefined,
-    filesCreated,
-    time: styleText('green', duration),
-    output: path.resolve(config.root, config.output.path),
-  } as const
-
-  const labels = {
-    plugins: 'Plugins:',
-    failed: 'Failed:',
-    generated: 'Generated:',
-    pluginTimings: 'Plugin Timings:',
-    output: 'Output:',
-  }
-  const maxLength = Math.max(0, ...[...Object.values(labels), ...(pluginTimings ? Array.from(pluginTimings.keys()) : [])].map((s) => s.length))
-
-  const summaryLines: string[] = []
-  summaryLines.push(`${labels.plugins.padEnd(maxLength + 2)} ${meta.plugins}`)
-
-  if (meta.pluginsFailed) {
-    summaryLines.push(`${labels.failed.padEnd(maxLength + 2)} ${meta.pluginsFailed}`)
-  }
-
-  summaryLines.push(`${labels.generated.padEnd(maxLength + 2)} ${meta.filesCreated} files in ${meta.time}`)
-
-  if (pluginTimings && pluginTimings.size > 0) {
-    const sortedTimings = Array.from(pluginTimings.entries()).sort((a, b) => b[1] - a[1])
-
-    summaryLines.push(`${labels.pluginTimings}`)
-
-    sortedTimings.forEach(([name, time]) => {
-      const timeStr = time >= 1000 ? `${(time / 1000).toFixed(2)}s` : `${Math.round(time)}ms`
-      const barLength = Math.min(Math.ceil(time / SUMMARY_TIME_SCALE_DIVISOR), SUMMARY_MAX_BAR_LENGTH)
-      const bar = styleText('dim', '█'.repeat(barLength))
-
-      summaryLines.push(`${styleText('dim', '•')} ${name.padEnd(maxLength + 1)}${bar} ${timeStr}`)
-    })
-  }
-
-  summaryLines.push(`${labels.output.padEnd(maxLength + 2)} ${meta.output}`)
-
-  return summaryLines
-}