@kubb/cli 4.11.3 → 4.12.1

package/src/loggers/githubActionsLogger.ts

@@ -0,0 +1,310 @@
+import { type Config, defineLogger, LogLevel } from '@kubb/core'
+import { execa } from 'execa'
+import pc from 'picocolors'
+
+/**
+ * GitHub Actions adapter for CI environments
+ * Uses ::group:: and ::endgroup:: annotations for collapsible sections
+ */
+export const githubActionsLogger = defineLogger({
+  name: 'github-actions',
+  install(context, options) {
+    const logLevel = options?.logLevel || LogLevel.info
+    let currentConfigs: Array<Config> = []
+
+    function getMessage(message: string): string {
+      if (logLevel >= LogLevel.verbose) {
+        const timestamp = new Date().toLocaleTimeString('en-US', {
+          hour12: false,
+          hour: '2-digit',
+          minute: '2-digit',
+          second: '2-digit',
+        })
+
+        return [pc.dim(`[${timestamp}]`), message].join(' ')
+      }
+
+      return message
+    }
+
+    function openGroup(name: string) {
+      console.log(`::group::${name}`)
+    }
+
+    function closeGroup(_name: string) {
+      console.log('::endgroup::')
+    }
+
+    context.on('info', (message, info = '') => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage([pc.blue('ℹ'), message, pc.dim(info)].join(' '))
+
+      console.log(text)
+    })
+
+    context.on('success', (message, info = '') => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage([pc.blue('✓'), message, logLevel >= LogLevel.info ? pc.dim(info) : undefined].filter(Boolean).join(' '))
+
+      console.log(text)
+    })
+
+    context.on('warn', (message, info = '') => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage([pc.yellow('⚠'), message, logLevel >= LogLevel.info ? pc.dim(info) : undefined].filter(Boolean).join(' '))
+
+      console.warn(`::warning::${text}`)
+    })
+
+    context.on('error', (error) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+      const message = error.message || String(error)
+      console.error(`::error::${message}`)
+    })
+
+    context.on('lifecycle:start', (version) => {
+      console.log(pc.yellow(`Kubb ${version} 🧩`))
+    })
+
+    context.on('config:start', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Configuration started')
+
+      openGroup('Configuration')
+
+      console.log(text)
+    })
+
+    context.on('config:end', (configs) => {
+      currentConfigs = configs
+
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Configuration completed')
+
+      console.log(text)
+
+      closeGroup('Configuration')
+    })
+
+    context.on('generation:start', (config) => {
+      const text = config.name ? `Generation for ${pc.bold(config.name)}` : 'Generation'
+
+      if (currentConfigs.length > 1) {
+        openGroup(text)
+      }
+
+      if (currentConfigs.length === 1) {
+        console.log(getMessage(text))
+      }
+    })
+
+    context.on('plugin:start', (plugin) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+      const text = getMessage(`Generating ${pc.bold(plugin.name)}`)
+
+      if (currentConfigs.length === 1) {
+        openGroup(`Plugin: ${plugin.name}`)
+      }
+
+      console.log(text)
+    })
+
+    context.on('plugin:end', (plugin, duration) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+      const durationStr = duration >= 1000 ? `${(duration / 1000).toFixed(2)}s` : `${duration}ms`
+      const text = getMessage(`${pc.bold(plugin.name)} completed in ${pc.green(durationStr)}`)
+
+      console.log(text)
+      if (currentConfigs.length > 1) {
+        console.log(' ')
+      }
+
+      if (currentConfigs.length === 1) {
+        closeGroup(`Plugin: ${plugin.name}`)
+      }
+    })
+
+    context.on('files:processing:start', (files) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+      if (currentConfigs.length === 1) {
+        openGroup('File Generation')
+      }
+      const text = getMessage(`Writing ${files.length} files`)
+
+      console.log(text)
+    })
+
+    context.on('files:processing:end', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+      const text = getMessage('Files written successfully')
+
+      console.log(text)
+
+      if (currentConfigs.length === 1) {
+        closeGroup('File Generation')
+      }
+    })
+
+    context.on('generation:end', (config) => {
+      const text = getMessage(config.name ? `${pc.blue('✓')} Generation completed for ${pc.dim(config.name)}` : `${pc.blue('✓')} Generation completed`)
+
+      console.log(text)
+    })
+
+    context.on('hook:execute', async ({ command, args }, cb) => {
+      try {
+        const result = await execa(command, args, {
+          detached: true,
+          stripFinalNewline: true,
+        })
+
+        await context.emit('debug', {
+          date: new Date(),
+          logs: [result.stdout],
+        })
+
+        console.log(result.stdout)
+
+        cb()
+      } catch (err) {
+        const error = new Error('Hook execute failed')
+        error.cause = err
+
+        await context.emit('debug', {
+          date: new Date(),
+          logs: [(err as any).stdout],
+        })
+
+        await context.emit('error', error)
+      }
+    })
+
+    context.on('format:start', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Format started')
+
+      if (currentConfigs.length === 1) {
+        openGroup('Formatting')
+      }
+
+      console.log(text)
+    })
+
+    context.on('format:end', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Format completed')
+
+      console.log(text)
+
+      if (currentConfigs.length === 1) {
+        closeGroup('Formatting')
+      }
+    })
+
+    context.on('lint:start', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Lint started')
+
+      if (currentConfigs.length === 1) {
+        openGroup('Linting')
+      }
+
+      console.log(text)
+    })
+
+    context.on('lint:end', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Lint completed')
+
+      console.log(text)
+
+      if (currentConfigs.length === 1) {
+        closeGroup('Linting')
+      }
+    })
+
+    context.on('hook:start', (command) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage(`Hook ${pc.dim(command)} started`)
+
+      if (currentConfigs.length === 1) {
+        openGroup(`Hook ${command}`)
+      }
+
+      console.log(text)
+    })
+
+    context.on('hook:end', (command) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage(`Hook ${pc.dim(command)} completed`)
+
+      console.log(text)
+
+      if (currentConfigs.length === 1) {
+        closeGroup(`Hook ${command}`)
+      }
+    })
+
+    context.on('generation:summary', (config, { status, failedPlugins }) => {
+      const pluginsCount = config.plugins?.length || 0
+      const successCount = pluginsCount - failedPlugins.size
+
+      if (currentConfigs.length > 1) {
+        console.log(' ')
+      }
+
+      console.log(
+        status === 'success'
+          ? `Kubb Summary: ${pc.blue('✓')} ${`${successCount} successful`}, ${pluginsCount} total`
+          : `Kubb Summary: ${pc.blue('✓')} ${`${successCount} successful`}, ✗ ${`${failedPlugins.size} failed`}, ${pluginsCount} total`,
+      )
+
+      if (currentConfigs.length > 1) {
+        closeGroup(config.name ? `Generation for ${pc.bold(config.name)}` : 'Generation')
+      }
+    })
+  },
+})

package/src/loggers/index.ts

@@ -0,0 +1,5 @@
+export { clackLogger } from './clackLogger.ts'
+export { fileSystemLogger } from './fileSystemLogger.ts'
+export { githubActionsLogger } from './githubActionsLogger.ts'
+export { plainLogger } from './plainLogger.ts'
+export type { LoggerType } from './types.ts'

package/src/loggers/plainLogger.ts

@@ -0,0 +1,274 @@
+import { relative } from 'node:path'
+import { defineLogger, LogLevel } from '@kubb/core'
+import { execa } from 'execa'
+import { getSummary } from '../utils/getSummary.ts'
+
+/**
+ * Plain console adapter for non-TTY environments
+ * Simple console.log output with indentation
+ */
+export const plainLogger = defineLogger({
+  name: 'plain',
+  install(context, options) {
+    const logLevel = options?.logLevel || 3
+
+    function getMessage(message: string): string {
+      if (logLevel >= LogLevel.verbose) {
+        const timestamp = new Date().toLocaleTimeString('en-US', {
+          hour12: false,
+          hour: '2-digit',
+          minute: '2-digit',
+          second: '2-digit',
+        })
+
+        return [`[${timestamp}]`, message].join(' ')
+      }
+
+      return message
+    }
+
+    context.on('info', (message, info) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage(['ℹ', message, info].join(' '))
+
+      console.log(text)
+    })
+
+    context.on('success', (message, info = '') => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage(['✓', message, logLevel >= LogLevel.info ? info : undefined].filter(Boolean).join(' '))
+
+      console.log(text)
+    })
+
+    context.on('warn', (message, info) => {
+      if (logLevel < LogLevel.warn) {
+        return
+      }
+
+      const text = getMessage(['⚠', message, logLevel >= LogLevel.info ? info : undefined].filter(Boolean).join(' '))
+
+      console.log(text)
+    })
+
+    context.on('error', (error) => {
+      const caused = error.cause as Error
+
+      const text = getMessage(['✗', error.message].join(' '))
+
+      console.log(text)
+
+      // Show stack trace in debug mode (first 3 frames)
+      if (logLevel >= LogLevel.debug && error.stack) {
+        const frames = error.stack.split('\n').slice(1, 4)
+        for (const frame of frames) {
+          console.log(getMessage(frame.trim()))
+        }
+
+        if (caused?.stack) {
+          console.log(`└─ caused by ${caused.message}`)
+
+          const frames = caused.stack.split('\n').slice(1, 4)
+          for (const frame of frames) {
+            console.log(getMessage(`    ${frame.trim()}`))
+          }
+        }
+      }
+    })
+
+    context.on('lifecycle:start', () => {
+      console.log('Kubb CLI 🧩')
+    })
+
+    context.on('config:start', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Configuration started')
+
+      console.log(text)
+    })
+
+    context.on('config:end', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Configuration completed')
+
+      console.log(text)
+    })
+
+    context.on('generation:start', () => {
+      const text = getMessage('Configuration started')
+
+      console.log(text)
+    })
+
+    context.on('plugin:start', (plugin) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+      const text = getMessage(`Generating ${plugin.name}`)
+
+      console.log(text)
+    })
+
+    context.on('plugin:end', (plugin, duration) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const durationStr = duration >= 1000 ? `${(duration / 1000).toFixed(2)}s` : `${duration}ms`
+      const text = getMessage(`${plugin.name} completed in ${durationStr}`)
+
+      console.log(text)
+    })
+
+    context.on('files:processing:start', (files) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage(`Writing ${files.length} files`)
+
+      console.log(text)
+    })
+
+    context.on('file:processing:update', ({ file, config }) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage(`Writing ${relative(config.root, file.path)}`)
+
+      console.log(text)
+    })
+
+    context.on('files:processing:end', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Files written successfully')
+
+      console.log(text)
+    })
+
+    context.on('generation:end', (config) => {
+      const text = getMessage(config.name ? `Generation completed for ${config.name}` : 'Generation completed')
+
+      console.log(text)
+    })
+
+    context.on('hook:execute', async ({ command, args }, cb) => {
+      try {
+        const result = await execa(command, args, {
+          detached: true,
+          stripFinalNewline: true,
+        })
+
+        await context.emit('debug', {
+          date: new Date(),
+          logs: [result.stdout],
+        })
+
+        console.log(result.stdout)
+
+        cb()
+      } catch (err) {
+        const error = new Error('Hook execute failed')
+        error.cause = err
+
+        await context.emit('debug', {
+          date: new Date(),
+          logs: [(err as any).stdout],
+        })
+
+        await context.emit('error', error)
+      }
+    })
+
+    context.on('format:start', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Format started')
+
+      console.log(text)
+    })
+
+    context.on('format:end', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Format completed')
+
+      console.log(text)
+    })
+
+    context.on('lint:start', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Lint started')
+
+      console.log(text)
+    })
+
+    context.on('lint:end', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Lint completed')
+
+      console.log(text)
+    })
+
+    context.on('hook:start', (command) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage(`Hook ${command} started`)
+
+      console.log(text)
+    })
+
+    context.on('hook:end', (command) => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage(`Hook ${command} completed`)
+
+      console.log(text)
+    })
+
+    context.on('generation:summary', (config, { pluginTimings, status, hrStart, failedPlugins, filesCreated }) => {
+      const summary = getSummary({
+        failedPlugins,
+        filesCreated,
+        config,
+        status,
+        hrStart,
+        pluginTimings: logLevel >= LogLevel.verbose ? pluginTimings : undefined,
+      })
+
+      console.log('---------------------------')
+      console.log(summary.join('\n'))
+      console.log('---------------------------')
+    })
+  },
+})

package/src/loggers/types.ts

@@ -0,0 +1 @@
+export type LoggerType = 'clack' | 'github-actions' | 'plain'

package/src/loggers/utils.ts

@@ -0,0 +1,43 @@
+import type { Logger, LoggerContext, LoggerOptions } from '@kubb/core'
+import { LogLevel } from '@kubb/core'
+import { clackLogger } from './clackLogger.ts'
+import { canUseTTY, isGitHubActions } from './envDetection.ts'
+import { fileSystemLogger } from './fileSystemLogger.ts'
+import { githubActionsLogger } from './githubActionsLogger.ts'
+import { plainLogger } from './plainLogger.ts'
+import type { LoggerType } from './types.ts'
+
+export function detectLogger(): LoggerType {
+  if (isGitHubActions()) {
+    return 'github-actions'
+  }
+  if (canUseTTY()) {
+    return 'clack'
+  }
+  return 'plain'
+}
+
+const logMapper = {
+  clack: clackLogger,
+  plain: plainLogger,
+  'github-actions': githubActionsLogger,
+} as const satisfies Record<LoggerType, Logger>
+
+export async function setupLogger(context: LoggerContext, { logLevel }: LoggerOptions): Promise<void> {
+  const type = detectLogger()
+
+  const logger = logMapper[type] as Logger
+
+  if (!logger) {
+    throw new Error(`Unknown adapter type: ${type}`)
+  }
+
+  // Install primary logger
+  const cleanup = await logger.install(context, { logLevel })
+
+  if (logLevel >= LogLevel.debug) {
+    await fileSystemLogger.install(context, { logLevel })
+  }
+
+  return cleanup
+}