@kubb/cli 5.0.0-beta.37 → 5.0.0-beta.39

package/src/reporters/cliReporter.ts

@@ -1,89 +0,0 @@
-import { styleText } from 'node:util'
-import { formatMs, randomCliColor } from '@internals/utils'
-import { createReporter, logLevel as logLevelMap } from '@kubb/core'
-import { SUMMARY_MAX_BAR_LENGTH, SUMMARY_TIME_SCALE_DIVISOR } from '../constants.ts'
-import { buildReport, type Report } from './report.ts'
-
-/**
- * Builds the vitest/jest-style summary for one {@link Report}: right-aligned dim labels with
- * `N passed (total)` counts, and a per-plugin `Timings` section when `showTimings`.
- */
-function buildSummaryLines(report: Report, { showTimings }: { showTimings: boolean }): Array<string> {
-  const { status, plugins, counts, filesCreated, durationMs, output, timings } = report
-
-  const rows: Array<[label: string, value: string]> = []
-
-  rows.push([
-    'Plugins',
-    status === 'success'
-      ? `${styleText('green', `${plugins.passed} passed`)} (${plugins.total})`
-      : `${styleText('green', `${plugins.passed} passed`)} | ${styleText('red', `${plugins.failed.length} failed`)} (${plugins.total})`,
-  ])
-
-  if (status === 'failed' && plugins.failed.length > 0) {
-    rows.push(['Failed', plugins.failed.map((name) => randomCliColor(name)).join(', ')])
-  }
-
-  if (counts.errors > 0 || counts.warnings > 0) {
-    const issues = [
-      counts.errors > 0 ? styleText('red', `${counts.errors} ${counts.errors === 1 ? 'error' : 'errors'}`) : undefined,
-      counts.warnings > 0 ? styleText('yellow', `${counts.warnings} ${counts.warnings === 1 ? 'warning' : 'warnings'}`) : undefined,
-    ]
-      .filter(Boolean)
-      .join(' | ')
-    rows.push(['Issues', issues])
-  }
-
-  rows.push(['Files', `${styleText('green', String(filesCreated))} generated`])
-  rows.push(['Duration', styleText('green', formatMs(durationMs))])
-  rows.push(['Output', output])
-
-  const labelWidth = Math.max(...rows.map(([label]) => label.length), timings.length > 0 ? 'Timings'.length : 0)
-  const lines = rows.map(([label, value]) => `${styleText('dim', label.padStart(labelWidth))}  ${value}`)
-
-  if (showTimings && timings.length > 0) {
-    const nameWidth = Math.max(0, ...timings.map((timing) => timing.plugin.length))
-    const indent = ' '.repeat(labelWidth + 2)
-
-    lines.push(styleText('dim', 'Timings'.padStart(labelWidth)))
-    for (const timing of timings) {
-      const timeStr = formatMs(timing.durationMs)
-      const barLength = Math.min(Math.ceil(timing.durationMs / SUMMARY_TIME_SCALE_DIVISOR), SUMMARY_MAX_BAR_LENGTH)
-      const bar = styleText('dim', '█'.repeat(barLength))
-      lines.push(`${indent}${styleText('dim', '•')} ${timing.plugin.padEnd(nameWidth)} ${bar} ${timeStr}`)
-    }
-  }
-
-  return lines
-}
-
-/**
- * Renders the summary as plain `console.log` lines so it works in every CLI (no clack/TTY
- * dependency): a blank line, the config name colored by status, then the summary rows.
- */
-function renderSummary(lines: ReadonlyArray<string>, { title, status }: { title: string; status: 'success' | 'failed' }): void {
-  console.log('')
-  if (title) {
-    console.log(styleText(status === 'failed' ? 'red' : 'green', title))
-  }
-  for (const line of lines) {
-    console.log(line)
-  }
-}
-
-/**
- * The default `cli` reporter. Renders the {@link Report} for each config as it finishes, independent
- * of the live logger view. Suppressed at `silent`; the `verbose` level adds the per-plugin timings.
- */
-export const cliReporter = createReporter({
-  name: 'cli',
-  report(result, { logLevel }) {
-    if (logLevel <= logLevelMap.silent) {
-      return
-    }
-
-    const report = buildReport(result)
-    const lines = buildSummaryLines(report, { showTimings: logLevel >= logLevelMap.verbose })
-    renderSummary(lines, { title: report.name, status: report.status })
-  },
-})

package/src/reporters/fileReporter.ts

@@ -1,103 +0,0 @@
-import { relative, resolve } from 'node:path'
-import process from 'node:process'
-import { stripVTControlCharacters } from 'node:util'
-import { formatMs, write } from '@internals/utils'
-import { createReporter, type Diagnostic, isProblemDiagnostic } from '@kubb/core'
-import { formatDiagnostic } from '../loggers/diagnostics.ts'
-import { buildReport, type Report } from './report.ts'
-
-/**
- * Builds the `## Summary` section: the same counts the cli and json reporters expose, as a list of
- * `label  value` rows with the labels padded to a common width.
- */
-function buildSummarySection(report: Report): Array<string> {
-  const { status, plugins, counts, filesCreated, durationMs, output } = report
-
-  const rows: Array<[label: string, value: string]> = [
-    ['Status', status],
-    [
-      'Plugins',
-      status === 'success' ? `${plugins.passed} passed (${plugins.total})` : `${plugins.passed} passed | ${plugins.failed.length} failed (${plugins.total})`,
-    ],
-  ]
-
-  if (plugins.failed.length > 0) {
-    rows.push(['Failed', plugins.failed.join(', ')])
-  }
-
-  rows.push(['Issues', `${counts.errors} errors | ${counts.warnings} warnings | ${counts.infos} infos`])
-  rows.push(['Files', `${filesCreated} generated`])
-  rows.push(['Duration', formatMs(durationMs)])
-  rows.push(['Output', output])
-
-  const labelWidth = Math.max(...rows.map(([label]) => label.length))
-  const lines = rows.map(([label, value]) => `  ${label.padEnd(labelWidth)}  ${value}`)
-
-  return ['## Summary', '', ...lines]
-}
-
-/**
- * Builds the `## Problems` section: each problem rendered in the miette block format, blocks
- * separated by a blank line. Returns an empty array when there are no problems, so the caller
- * can drop the heading.
- */
-function buildProblemSection(diagnostics: ReadonlyArray<Diagnostic>): Array<string> {
-  const problems = diagnostics.filter(isProblemDiagnostic)
-  if (problems.length === 0) {
-    return []
-  }
-
-  const blocks = problems.map((diagnostic) => formatDiagnostic(diagnostic).join('\n'))
-  return ['## Problems', '', blocks.join('\n\n')]
-}
-
-/**
- * Builds the `## Timings` section from a {@link Report}: one `plugin   duration` row per record,
- * slowest first with the plugin names left-aligned and the durations right-aligned. Returns an
- * empty array when there are no timings.
- */
-function buildTimingSection(report: Report): Array<string> {
-  const { timings } = report
-  if (timings.length === 0) {
-    return []
-  }
-
-  const nameWidth = Math.max(...timings.map((timing) => timing.plugin.length))
-  const durations = timings.map((timing) => formatMs(timing.durationMs))
-  const durationWidth = Math.max(...durations.map((duration) => duration.length))
-  const rows = timings.map((timing, index) => `  ${timing.plugin.padEnd(nameWidth)}  ${durations[index]!.padStart(durationWidth)}`)
-
-  return ['## Timings', '', ...rows]
-}
-
-/**
- * The `file` reporter. Writes a config's {@link Report} to `.kubb/kubb-<name>-<timestamp>.log` as a
- * plain-text document: a `# <name> — <timestamp>` header, a `## Summary` with the same counts the
- * cli and json reporters expose, a `## Problems` section in the miette block format, and a
- * `## Timings` section. Selected with `--reporter file` (or `reporters: ['file']`), replacing the
- * old `--debug` flag.
- *
- * @note Unlike the streaming logger it replaced, it captures the collected diagnostics once a
- * config finishes, not the live `kubb:info`/`kubb:plugin` event stream. Color is stripped so the
- * file stays plain text even when the run is attached to a TTY.
- */
-export const fileReporter = createReporter({
-  name: 'file',
-  async report(result) {
-    const { diagnostics, config } = result
-    if (diagnostics.length === 0) {
-      return
-    }
-
-    const report = buildReport(result)
-    const header = config.name ? `# ${config.name} — ${new Date().toISOString()}` : `# ${new Date().toISOString()}`
-    const sections = [buildSummarySection(report), buildProblemSection(diagnostics), buildTimingSection(report)].filter((section) => section.length > 0)
-    const content = stripVTControlCharacters([header, ...sections.map((section) => section.join('\n'))].join('\n\n'))
-
-    const baseName = `${['kubb', config.name, Date.now()].filter(Boolean).join('-')}.log`
-    const pathName = resolve(process.cwd(), '.kubb', baseName)
-
-    await write(pathName, `${content}\n`)
-    console.error(`Debug log written to ${relative(process.cwd(), pathName)}`)
-  },
-})

package/src/reporters/jsonReporter.ts

@@ -1,15 +0,0 @@
-import process from 'node:process'
-import { createReporter } from '@kubb/core'
-import { buildReport } from './report.ts'
-
-/**
- * The `json` reporter. Writes the {@link Report} for each config to stdout as JSON, for CI tooling.
- * The terminal reporter is suppressed while this is active so stdout stays valid JSON.
- */
-export const jsonReporter = createReporter({
-  name: 'json',
-  report(result) {
-    const report = buildReport(result)
-    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`)
-  },
-})

package/src/reporters/report.ts

@@ -1,84 +0,0 @@
-import { resolve } from 'node:path'
-import { getElapsedMs } from '@internals/utils'
-import { Diagnostics, type GenerationResult, isPerformanceDiagnostic, isProblemDiagnostic, type SerializedDiagnostic } from '@kubb/core'
-
-/**
- * One plugin's elapsed time, derived from a `performance` diagnostic.
- */
-export type ReportTiming = {
-  plugin: string
-  durationMs: number
-}
-
-/**
- * The normalized result of generating one config, shared by every reporter. Each reporter renders
- * the same {@link Report} in its own format (the `cli` summary, the `json` document, the `file`
- * log), so they always agree on the numbers. Build it with {@link buildReport}.
- */
-export type Report = {
-  /**
-   * The config name, or an empty string when it is unnamed.
-   */
-  name: string
-  status: 'success' | 'failed'
-  plugins: {
-    passed: number
-    /**
-     * Names of the plugins that failed.
-     */
-    failed: Array<string>
-    total: number
-  }
-  counts: {
-    errors: number
-    warnings: number
-    infos: number
-  }
-  filesCreated: number
-  /**
-   * Wall-clock time spent generating this config, in milliseconds.
-   */
-  durationMs: number
-  /**
-   * Absolute output directory the files were written to.
-   */
-  output: string
-  /**
-   * Per-plugin durations, slowest first.
-   */
-  timings: Array<ReportTiming>
-  /**
-   * The build problems, serialized to their JSON-safe fields plus a `docsUrl`.
-   */
-  diagnostics: Array<SerializedDiagnostic>
-}
-
-/**
- * Builds the normalized {@link Report} for one config from its {@link GenerationResult}. Splits the
- * diagnostics into problems and per-plugin timings (slowest first) and derives the plugin and issue
- * counts, so every reporter renders the same data.
- */
-export function buildReport(result: GenerationResult): Report {
-  const { config, diagnostics, filesCreated, status, hrStart } = result
-
-  const failed = Diagnostics.failedPlugins(diagnostics)
-  const total = config.plugins?.length ?? 0
-  const counts = Diagnostics.count(diagnostics)
-  const problems = diagnostics.filter(isProblemDiagnostic)
-  const timings = diagnostics
-    .filter(isPerformanceDiagnostic)
-    .sort((a, b) => b.duration - a.duration)
-    .map((diagnostic) => ({ plugin: diagnostic.plugin, durationMs: diagnostic.duration }))
-
-  return {
-    name: config.name ?? '',
-    status,
-    plugins: { passed: total - failed.length, failed, total },
-    counts,
-    filesCreated,
-    durationMs: getElapsedMs(hrStart),
-    output: resolve(config.root, config.output.path),
-    timings,
-    diagnostics: problems.map((diagnostic) => Diagnostics.serialize(diagnostic)),
-  }
-}

package/src/telemetry.ts

@@ -1,280 +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: Array<OtlpAnyValue> } }
-type OtlpKvListValue = { kvlistValue: { values: Array<OtlpKeyValue> } }
-
-type OtlpAnyValue = OtlpStringValue | OtlpBoolValue | OtlpIntValue | OtlpDoubleValue | OtlpBytesValue | OtlpArrayValue | OtlpKvListValue
-
-type OtlpKeyValue = {
-  key: string
-  value: OtlpAnyValue
-}
-
-type OtlpResource = {
-  attributes: Array<OtlpKeyValue>
-  droppedAttributesCount?: number
-}
-
-type OtlpInstrumentationScope = {
-  name: string
-  version?: string
-  attributes?: Array<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?: Array<OtlpKeyValue>
-  droppedAttributesCount?: number
-  events?: Array<OtlpSpanEvent>
-  droppedEventsCount?: number
-  links?: Array<OtlpSpanLink>
-  droppedLinksCount?: number
-  status?: OtlpStatus
-}
-
-type OtlpSpanEvent = {
-  timeUnixNano: string
-  name: string
-  attributes?: Array<OtlpKeyValue>
-  droppedAttributesCount?: number
-}
-
-type OtlpSpanLink = {
-  traceId: string
-  spanId: string
-  traceState?: string
-  attributes?: Array<OtlpKeyValue>
-  droppedAttributesCount?: number
-}
-
-type OtlpScopeSpans = {
-  scope: OtlpInstrumentationScope
-  spans: Array<OtlpSpan>
-  schemaUrl?: string
-}
-
-type OtlpResourceSpans = {
-  resource: OtlpResource
-  scopeSpans: Array<OtlpScopeSpans>
-  schemaUrl?: string
-}
-
-/** Root payload sent to POST /v1/traces */
-type OtlpExportTraceServiceRequest = {
-  resourceSpans: Array<OtlpResourceSpans>
-}
-
-/**
- * Anonymous plugin name and options snapshot sent with each telemetry event.
- */
-export type TelemetryPlugin = {
-  /**
-   * Plugin name as registered in the Kubb config, e.g. `'@kubb/plugin-ts'`.
-   */
-  name: string
-  /**
-   * anonymized plugin options snapshot, values are included but cannot be traced back to the user.
-   */
-  options: Record<string, unknown>
-}
-
-type TelemetryEvent = {
-  command: string
-  kubbVersion: string
-  nodeVersion: string
-  platform: string
-  ci: boolean
-  plugins: Array<TelemetryPlugin>
-  duration: number
-  filesCreated: number
-  status: 'success' | 'failed'
-}
-
-/**
- * Returns `true` when the current process runs inside a CI environment.
- */
-export function isCi(): boolean {
-  return isCIEnvironment()
-}
-
-/**
- * Returns `true` when telemetry is disabled via `DO_NOT_TRACK` or `KUBB_DISABLE_TELEMETRY`.
- */
-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: Array<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?: Array<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,
-  }
-}