@kubb/cli 5.0.0-beta.4 → 5.0.0-beta.40

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

package/src/utils/runHook.ts

@@ -1,91 +0,0 @@
-import type { AsyncEventEmitter } from '@internals/utils'
-import { toError } from '@internals/utils'
-import type { KubbHooks } from '@kubb/core'
-import { NonZeroExitError, x } from 'tinyexec'
-
-type HookOutputSink = {
-  /** Called for each streamed stdout line while the hook runs (optional). */
-  onLine?: (line: string) => void
-  /** Called on stderr after failure (optional). */
-  onStderr?: (text: string) => void
-  /** Called on stdout after failure (optional). */
-  onStdout?: (text: string) => void
-}
-
-type RunHookOptions = {
-  id: string
-  command: string
-  args?: readonly string[]
-  commandWithArgs: string
-  context: AsyncEventEmitter<KubbHooks>
-  /** When true the process output is streamed line-by-line via onLine. */
-  stream?: boolean
-  sink?: HookOutputSink
-}
-
-/**
- * Executes a hook command, emits debug and completion events, and forwards output to an optional sink.
- */
-export async function runHook({ id, command, args, commandWithArgs, context, stream = false, sink }: RunHookOptions): Promise<void> {
-  try {
-    const proc = x(command, [...(args ?? [])], {
-      nodeOptions: { detached: process.platform !== 'win32' },
-      throwOnError: true,
-    })
-
-    if (stream && sink?.onLine) {
-      for await (const line of proc) {
-        sink.onLine(line)
-      }
-    }
-
-    const result = await proc
-
-    await context.emit('kubb:debug', {
-      date: new Date(),
-      logs: [result.stdout.trimEnd()],
-    })
-
-    await context.emit('kubb:hook:end', {
-      command,
-      args,
-      id,
-      success: true,
-      error: null,
-    })
-  } catch (err) {
-    if (!(err instanceof NonZeroExitError)) {
-      await context.emit('kubb:hook:end', {
-        command,
-        args,
-        id,
-        success: false,
-        error: toError(err),
-      })
-      await context.emit('kubb:error', { error: toError(err) })
-      return
-    }
-
-    const stderr = err.output?.stderr ?? ''
-    const stdout = err.output?.stdout ?? ''
-
-    await context.emit('kubb:debug', {
-      date: new Date(),
-      logs: [stdout, stderr].filter(Boolean),
-    })
-
-    if (stderr) sink?.onStderr?.(stderr)
-    if (stdout) sink?.onStdout?.(stdout)
-
-    const errorMessage = new Error(`Hook execute failed: ${commandWithArgs}`)
-
-    await context.emit('kubb:hook:end', {
-      command,
-      args,
-      id,
-      success: false,
-      error: errorMessage,
-    })
-    await context.emit('kubb:error', { error: errorMessage })
-  }
-}

package/src/utils/telemetry.ts

@@ -1,273 +0,0 @@
-import { randomBytes } from 'node:crypto'
-import os from 'node:os'
-import process from 'node:process'
-import { executeIfOnline, isCIEnvironment } from '@internals/utils'
-import { OTLP_ENDPOINT } from '../constants.ts'
-
-// OpenTelemetry OTLP JSON types
-// https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/trace/v1/trace.proto
-// https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/common/v1/common.proto
-
-type OtlpStringValue = { stringValue: string }
-type OtlpBoolValue = { boolValue: boolean }
-type OtlpIntValue = { intValue: number }
-type OtlpDoubleValue = { doubleValue: number }
-type OtlpBytesValue = { bytesValue: string }
-type OtlpArrayValue = { arrayValue: { values: OtlpAnyValue[] } }
-type OtlpKvListValue = { kvlistValue: { values: OtlpKeyValue[] } }
-
-type OtlpAnyValue = OtlpStringValue | OtlpBoolValue | OtlpIntValue | OtlpDoubleValue | OtlpBytesValue | OtlpArrayValue | OtlpKvListValue
-
-type OtlpKeyValue = {
-  key: string
-  value: OtlpAnyValue
-}
-
-type OtlpResource = {
-  attributes: OtlpKeyValue[]
-  droppedAttributesCount?: number
-}
-
-type OtlpInstrumentationScope = {
-  name: string
-  version?: string
-  attributes?: OtlpKeyValue[]
-  droppedAttributesCount?: number
-}
-
-/** https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/trace/v1/trace.proto#L103 */
-type OtlpSpanKind = 0 | 1 | 2 | 3 | 4 | 5
-
-/** 0 = STATUS_CODE_UNSET, 1 = STATUS_CODE_OK, 2 = STATUS_CODE_ERROR */
-type OtlpStatusCode = 0 | 1 | 2
-
-type OtlpStatus = {
-  code: OtlpStatusCode
-  message?: string
-}
-
-type OtlpSpan = {
-  traceId: string
-  spanId: string
-  traceState?: string
-  parentSpanId?: string
-  name: string
-  kind: OtlpSpanKind
-  startTimeUnixNano: string
-  endTimeUnixNano: string
-  attributes?: OtlpKeyValue[]
-  droppedAttributesCount?: number
-  events?: OtlpSpanEvent[]
-  droppedEventsCount?: number
-  links?: OtlpSpanLink[]
-  droppedLinksCount?: number
-  status?: OtlpStatus
-}
-
-type OtlpSpanEvent = {
-  timeUnixNano: string
-  name: string
-  attributes?: OtlpKeyValue[]
-  droppedAttributesCount?: number
-}
-
-type OtlpSpanLink = {
-  traceId: string
-  spanId: string
-  traceState?: string
-  attributes?: OtlpKeyValue[]
-  droppedAttributesCount?: number
-}
-
-type OtlpScopeSpans = {
-  scope: OtlpInstrumentationScope
-  spans: OtlpSpan[]
-  schemaUrl?: string
-}
-
-type OtlpResourceSpans = {
-  resource: OtlpResource
-  scopeSpans: OtlpScopeSpans[]
-  schemaUrl?: string
-}
-
-/** Root payload sent to POST /v1/traces */
-type OtlpExportTraceServiceRequest = {
-  resourceSpans: OtlpResourceSpans[]
-}
-
-export type TelemetryPlugin = {
-  name: string
-  options: Record<string, unknown>
-}
-
-type TelemetryEvent = {
-  command: string
-  kubbVersion: string
-  nodeVersion: string
-  platform: string
-  ci: boolean
-  plugins: TelemetryPlugin[]
-  duration: number
-  filesCreated: number
-  status: 'success' | 'failed'
-}
-
-/**
- * Detect whether the current process is running inside a CI environment.
- * Delegates to the canonical isCIEnvironment() from envDetection.
- */
-export function isCi(): boolean {
-  return isCIEnvironment()
-}
-
-/**
- * Check if telemetry is disabled via DO_NOT_TRACK or KUBB_DISABLE_TELEMETRY.
- * Respects the standard DO_NOT_TRACK convention used across development tools.
- */
-export function isTelemetryDisabled(): boolean {
-  return (
-    process.env['DO_NOT_TRACK'] === '1' ||
-    process.env['DO_NOT_TRACK'] === 'true' ||
-    process.env['KUBB_DISABLE_TELEMETRY'] === '1' ||
-    process.env['KUBB_DISABLE_TELEMETRY'] === 'true'
-  )
-}
-
-/**
- * Convert a TelemetryEvent into an OTLP-compatible JSON trace payload.
- * See https://opentelemetry.io/docs/languages/sdk-configuration/otlp-exporter/
- */
-export function buildOtlpPayload(event: TelemetryEvent): OtlpExportTraceServiceRequest {
-  const traceId = randomBytes(16).toString('hex')
-  const spanId = randomBytes(8).toString('hex')
-  const endTimeNs = BigInt(Date.now()) * 1_000_000n
-  const startTimeNs = endTimeNs - BigInt(event.duration) * 1_000_000n
-
-  const attributes: OtlpKeyValue[] = [
-    { key: 'kubb.command', value: { stringValue: event.command } },
-    { key: 'kubb.version', value: { stringValue: event.kubbVersion } },
-    { key: 'kubb.node_version', value: { stringValue: event.nodeVersion } },
-    { key: 'kubb.platform', value: { stringValue: event.platform } },
-    { key: 'kubb.ci', value: { boolValue: event.ci } },
-    { key: 'kubb.files_created', value: { intValue: event.filesCreated } },
-    { key: 'kubb.status', value: { stringValue: event.status } },
-    {
-      key: 'kubb.plugins',
-      value: {
-        arrayValue: {
-          values: event.plugins.map(
-            (p): OtlpKvListValue => ({
-              kvlistValue: {
-                values: [
-                  { key: 'name', value: { stringValue: p.name } },
-                  {
-                    key: 'options',
-                    value: {
-                      stringValue: JSON.stringify({
-                        ...p.options,
-                        usedEnumNames: undefined,
-                      }),
-                    },
-                  },
-                ],
-              },
-            }),
-          ),
-        },
-      },
-    },
-  ]
-
-  return {
-    resourceSpans: [
-      {
-        resource: {
-          attributes: [
-            { key: 'service.name', value: { stringValue: 'kubb-cli' } },
-            {
-              key: 'service.version',
-              value: { stringValue: event.kubbVersion },
-            },
-            { key: 'telemetry.sdk.language', value: { stringValue: 'nodejs' } },
-          ],
-        },
-        scopeSpans: [
-          {
-            scope: { name: 'kubb-cli', version: event.kubbVersion },
-            spans: [
-              {
-                traceId,
-                spanId,
-                name: event.command,
-                kind: 1 satisfies OtlpSpanKind,
-                startTimeUnixNano: String(startTimeNs),
-                endTimeUnixNano: String(endTimeNs),
-                attributes,
-                status: {
-                  code: (event.status === 'success' ? 1 : 2) satisfies OtlpStatusCode,
-                },
-              },
-            ],
-          },
-        ],
-      },
-    ],
-  }
-}
-
-/**
- * Send an anonymous telemetry event to the Kubb OTLP endpoint.
- * Respects DO_NOT_TRACK and KUBB_DISABLE_TELEMETRY environment variables.
- * Fails silently to never interrupt the generation process.
- */
-export async function sendTelemetry(event: TelemetryEvent): Promise<void> {
-  if (isTelemetryDisabled()) {
-    return
-  }
-
-  await executeIfOnline(async () => {
-    try {
-      await fetch(`${OTLP_ENDPOINT}/v1/traces`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Kubb-Telemetry-Version': '1',
-          'Kubb-Telemetry-Source': 'kubb-cli',
-        },
-        body: JSON.stringify(buildOtlpPayload(event)),
-        signal: AbortSignal.timeout(5_000),
-      })
-    } catch (_e) {
-      // Fail silently – telemetry must never break the CLI
-    }
-  })
-}
-
-/**
- * Build an anonymous telemetry payload from a completed generation run.
- * No file paths, OpenAPI specs, or secrets are included.
- */
-export function buildTelemetryEvent(options: {
-  command: 'generate' | 'mcp' | 'validate' | 'agent'
-  kubbVersion: string
-  plugins?: TelemetryPlugin[]
-  hrStart: [number, number]
-  filesCreated?: number
-  status: 'success' | 'failed'
-}): TelemetryEvent {
-  const [seconds, nanoseconds] = process.hrtime(options.hrStart)
-  const duration = Math.round(seconds * 1000 + nanoseconds / 1e6)
-
-  return {
-    command: options.command,
-    kubbVersion: options.kubbVersion,
-    nodeVersion: process.versions.node.split('.')[0] as string,
-    platform: os.platform(),
-    ci: isCi(),
-    plugins: options.plugins ?? [],
-    duration,
-    filesCreated: options.filesCreated ?? 0,
-    status: options.status,
-  }
-}

package/src/utils/watcher.ts

@@ -1,19 +0,0 @@
-import { styleText } from 'node:util'
-import { WATCHER_IGNORED_PATHS } from '../constants.ts'
-
-export async function startWatcher(path: string[], cb: (path: string[]) => Promise<void>): Promise<void> {
-  const { watch } = await import('chokidar')
-  const watcher = watch(path, {
-    ignorePermissionErrors: true,
-    ignored: WATCHER_IGNORED_PATHS,
-  })
-  watcher.on('all', async (type, file) => {
-    console.log(styleText('yellow', styleText('bold', `Change detected: ${type} ${file}`)))
-
-    try {
-      await cb(path)
-    } catch (_e) {
-      console.log(styleText('red', 'Watcher failed'))
-    }
-  })
-}