@kubb/mcp 5.0.0-alpha.9 → 5.0.0-beta.10

package/src/tools/generate.ts

@@ -1,213 +1,146 @@
-import { AsyncEventEmitter } from '@internals/utils'
-import { type Config, type KubbEvents, safeBuild, setup } from '@kubb/core'
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.d.ts'
-import type { z } from 'zod'
-import type { generateSchema } from '../schemas/generateSchema.ts'
+import { AsyncEventEmitter, toError } from '@internals/utils'
+import { type Config, createKubb, type KubbHooks } from '@kubb/core'
+import { defineTool } from 'tmcp/tool'
+import { tool } from 'tmcp/utils'
+import type * as v from 'valibot'
+import { generateSchema } from '../schemas/generateSchema.ts'
 import { NotifyTypes } from '../types.ts'
 import { loadUserConfig } from '../utils/loadUserConfig.ts'
 import { resolveCwd } from '../utils/resolveCwd.ts'
 import { resolveUserConfig } from '../utils/resolveUserConfig.ts'
 
-interface NotificationHandler {
-  sendNotification(method: string, params: unknown): Promise<void>
-}
-
-/**
- * Build tool that generates code from OpenAPI specs using Kubb.
- * Sends real-time notifications of build progress and events.
- */
-export async function generate(schema: z.infer<typeof generateSchema>, handler: NotificationHandler): Promise<CallToolResult> {
-  const { config: configPath, input, output, logLevel } = schema
-
-  try {
-    const events = new AsyncEventEmitter<KubbEvents>()
-    const messages: string[] = []
-
-    // Helper to send notifications
-    const notify = async (type: string, message: string, data?: Record<string, unknown>) => {
-      messages.push(`${type}: ${message}`)
-
-      await handler.sendNotification('kubb/progress', {
-        type,
-        message,
-        timestamp: new Date().toISOString(),
-        ...data,
-      })
-    }
+export const generateTool = defineTool(
+  {
+    name: 'generate',
+    description: 'Generate OpenAPI spec helpers using Kubb configuration',
+    schema: generateSchema,
+  },
+  async function generate(schema: v.InferInput<typeof generateSchema>) {
+    const { config: configPath, input, output, logLevel } = schema
 
-    // Capture events for output and send notifications
-    events.on('info', async (message: string) => {
-      await notify(NotifyTypes.INFO, message)
-    })
+    try {
+      const hooks = new AsyncEventEmitter<KubbHooks>()
+      const messages: string[] = []
 
-    events.on('success', async (message: string) => {
-      await notify(NotifyTypes.SUCCESS, message)
-    })
+      const notify = async (type: string, message: string, _data?: Record<string, unknown>) => {
+        messages.push(`${type}: ${message}`)
+      }
 
-    events.on('error', async (error: Error) => {
-      await notify(NotifyTypes.ERROR, error.message, { stack: error.stack })
-    })
+      hooks.on('kubb:info', async ({ message }: { message: string }) => {
+        await notify(NotifyTypes.INFO, message)
+      })
 
-    events.on('warn', async (message: string) => {
-      await notify(NotifyTypes.WARN, message)
-    })
+      hooks.on('kubb:success', async ({ message }: { message: string }) => {
+        await notify(NotifyTypes.SUCCESS, message)
+      })
 
-    // Plugin lifecycle events
-    events.on('plugin:start', async ({ name }: { name: string }) => {
-      await notify(NotifyTypes.PLUGIN_START, `Plugin starting: ${name}`)
-    })
+      hooks.on('kubb:error', async ({ error }: { error: Error }) => {
+        await notify(NotifyTypes.ERROR, error.message)
+      })
 
-    events.on('plugin:end', async ({ name, duration }: { name: string; duration?: number }) => {
-      await notify(NotifyTypes.PLUGIN_END, `Plugin finished: ${name}`, { duration })
-    })
+      hooks.on('kubb:warn', async ({ message }: { message: string }) => {
+        await notify(NotifyTypes.WARN, message)
+      })
 
-    // File processing events
-    events.on('files:processing:start', async () => {
-      await notify(NotifyTypes.FILES_START, 'Starting file processing')
-    })
+      hooks.on('kubb:plugin:start', async ({ plugin }) => {
+        await notify(NotifyTypes.PLUGIN_START, `Plugin starting: ${plugin.name}`)
+      })
 
-    events.on('file:processing:update', async ({ file }: { file: { name: string } }) => {
-      await notify(NotifyTypes.FILE_UPDATE, `Processing file: ${file.name}`)
-    })
+      hooks.on('kubb:plugin:end', async ({ plugin, duration }) => {
+        await notify(NotifyTypes.PLUGIN_END, `Plugin finished: ${plugin.name}`, { duration })
+      })
 
-    events.on('files:processing:end', async () => {
-      await notify(NotifyTypes.FILES_END, 'File processing complete')
-    })
+      hooks.on('kubb:files:processing:start', async () => {
+        await notify(NotifyTypes.FILES_START, 'Starting file processing')
+      })
 
-    // Generation events
-    events.on('generation:start', async () => {
-      await notify(NotifyTypes.GENERATION_START, 'Generation started')
-    })
+      hooks.on('kubb:file:processing:update', async ({ file }: { file: { name: string } }) => {
+        await notify(NotifyTypes.FILE_UPDATE, `Processing file: ${file.name}`)
+      })
 
-    events.on('generation:end', async () => {
-      await notify(NotifyTypes.GENERATION_END, 'Generation ended')
-    })
+      hooks.on('kubb:files:processing:end', async () => {
+        await notify(NotifyTypes.FILES_END, 'File processing complete')
+      })
 
-    // Load and process configuration
-    let userConfig: Config
-    let cwd: string
+      hooks.on('kubb:generation:start', async () => {
+        await notify(NotifyTypes.GENERATION_START, 'Generation started')
+      })
 
-    try {
-      const configResult = await loadUserConfig(configPath, { notify })
-      userConfig = configResult.userConfig
-      cwd = configResult.cwd
+      hooks.on('kubb:generation:end', async () => {
+        await notify(NotifyTypes.GENERATION_END, 'Generation ended')
+      })
 
-      if (Array.isArray(userConfig) && userConfig.length) {
-        throw new Error('Array type in kubb.config.ts is not supported in this tool. Please provide a single configuration object.')
+      let userConfig: Config
+      let cwd: string
+
+      try {
+        const configResult = await loadUserConfig(configPath, { notify })
+        userConfig = configResult.userConfig
+        cwd = configResult.cwd
+
+        if (Array.isArray(userConfig)) {
+          throw new Error('Array type in kubb.config.ts is not supported in this tool. Please provide a single configuration object.')
+        }
+
+        userConfig = await resolveUserConfig(userConfig, {
+          configPath,
+          logLevel,
+        })
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        await notify(NotifyTypes.CONFIG_ERROR, errorMessage)
+        return tool.error(errorMessage)
       }
 
-      userConfig = await resolveUserConfig(userConfig, { configPath, logLevel })
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error)
-      await notify(NotifyTypes.CONFIG_ERROR, errorMessage)
-      return {
-        content: [
-          {
-            type: 'text',
-            text: errorMessage,
-          },
-        ],
-        isError: true,
+      const inputPath = input ?? (userConfig.input && 'path' in userConfig.input ? userConfig.input.path : undefined)
+
+      const config: Config = {
+        ...userConfig,
+        root: resolveCwd(userConfig, cwd),
+        input: inputPath
+          ? {
+              ...userConfig.input,
+              path: inputPath,
+            }
+          : userConfig.input,
+        output: output
+          ? {
+              ...userConfig.output,
+              path: output,
+            }
+          : userConfig.output,
       }
-    }
 
-    const inputPath = input ?? ('path' in userConfig.input ? userConfig.input.path : undefined)
-
-    // Override config with CLI options
-    const config: Config = {
-      ...userConfig,
-      root: resolveCwd(userConfig, cwd),
-      input: inputPath
-        ? {
-            ...userConfig.input,
-            path: inputPath,
-          }
-        : userConfig.input,
-      output: output
-        ? {
-            ...userConfig.output,
-            path: output,
-          }
-        : userConfig.output,
-    }
+      await notify(NotifyTypes.CONFIG_READY, 'Configuration ready')
+      await notify(NotifyTypes.SETUP_START, 'Setting up Kubb')
 
-    await notify(NotifyTypes.CONFIG_READY, 'Configuration ready', {
-      root: config.root,
-    })
-
-    // Setup and build
-    await notify(NotifyTypes.SETUP_START, 'Setting up Kubb')
-
-    const { fabric, driver, sources } = await setup({
-      config,
-      events,
-    })
-    await notify(NotifyTypes.SETUP_END, 'Kubb setup complete')
-
-    await notify(NotifyTypes.BUILD_START, 'Starting build')
-    const { files, failedPlugins, error } = await safeBuild(
-      {
-        config,
-        events,
-      },
-      { driver, fabric, events, sources },
-    )
-    await notify(NotifyTypes.BUILD_END, `Build complete - Generated ${files.length} files`)
-
-    if (error || failedPlugins.size > 0) {
-      const allErrors: Error[] = [
-        error,
-        ...Array.from(failedPlugins)
-          .filter((it) => it.error)
-          .map((it) => it.error),
-      ].filter(Boolean)
-
-      await notify(NotifyTypes.BUILD_FAILED, `Build failed with ${allErrors.length} error(s)`, {
-        errorCount: allErrors.length,
-        errors: allErrors.map((err) => err.message),
-      })
+      const kubb = createKubb(config, { hooks })
+      await kubb.setup()
+      await notify(NotifyTypes.SETUP_END, 'Kubb setup complete')
 
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `Build failed:\n${allErrors.map((err) => err.message).join('\n')}\n\n${messages.join('\n')}`,
-          },
-        ],
-        isError: true,
+      await notify(NotifyTypes.BUILD_START, 'Starting build')
+      const { files, failedPlugins, error } = await kubb.safeBuild()
+      await notify(NotifyTypes.BUILD_END, `Build complete - Generated ${files.length} files`)
+
+      if (error || failedPlugins.size > 0) {
+        const allErrors: Error[] = [
+          error,
+          ...Array.from(failedPlugins)
+            .filter((it) => it.error)
+            .map((it) => it.error),
+        ].filter(Boolean)
+
+        await notify(NotifyTypes.BUILD_FAILED, `Build failed with ${allErrors.length} error(s)`)
+
+        return tool.error(`Build failed:\n${allErrors.map((err) => err.message).join('\n')}\n\n${messages.join('\n')}`)
       }
-    }
 
-    await notify(NotifyTypes.BUILD_SUCCESS, `Build completed successfully - Generated ${files.length} files`, {
-      filesCount: files.length,
-    })
-
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Build completed successfully!\n\nGenerated ${files.length} files\n\n${messages.join('\n')}`,
-        },
-      ],
-    }
-  } catch (caughtError) {
-    const error = caughtError as Error
-
-    await handler.sendNotification('kubb/progress', {
-      type: NotifyTypes.FATAL_ERROR,
-      message: error.message,
-      stack: error.stack,
-      timestamp: new Date().toISOString(),
-    })
-
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Build error: ${error.message}\n${error.stack || ''}`,
-        },
-      ],
-      isError: true,
+      await notify(NotifyTypes.BUILD_SUCCESS, `Build completed successfully - Generated ${files.length} files`)
+
+      return tool.text(`Build completed successfully!\n\nGenerated ${files.length} files\n\n${messages.join('\n')}`)
+    } catch (caughtError) {
+      const error = toError(caughtError)
+      return tool.error(`Build error: ${error.message}\n${error.stack ?? ''}`)
     }
-  }
-}
+  },
+)

package/src/tools/init.ts

@@ -0,0 +1,37 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+import { availablePlugins, generateConfigFile, KUBB_CONFIG_FILENAME, type PluginOption } from '@internals/shared'
+import { defineTool } from 'tmcp/tool'
+import { tool } from 'tmcp/utils'
+import { initSchema } from '../schemas/initSchema.ts'
+
+export function resolvePlugins(pluginsFlag: string | undefined): PluginOption[] {
+  if (!pluginsFlag) {
+    return []
+  }
+  const requested = pluginsFlag
+    .split(',')
+    .map((v) => v.trim())
+    .filter(Boolean)
+  return availablePlugins.filter((p) => requested.includes(p.value))
+}
+
+export const initTool = defineTool(
+  {
+    name: 'init',
+    description: 'Scaffold a kubb.config.ts in the current directory (non-interactive). Does not install packages.',
+    schema: initSchema,
+  },
+  async ({ input = './openapi.yaml', output = './src/gen', plugins }) => {
+    const selected = resolvePlugins(plugins)
+    const content = generateConfigFile({ selectedPlugins: selected, inputPath: input, outputPath: output })
+    const dest = path.join(process.cwd(), KUBB_CONFIG_FILENAME)
+    if (fs.existsSync(dest)) {
+      return tool.error(`${KUBB_CONFIG_FILENAME} already exists at ${dest}. Delete it first before running init again.`)
+    }
+    fs.writeFileSync(dest, content, 'utf-8')
+    const packageList = ['kubb', ...selected.map((p) => p.packageName)].join(' ')
+    return tool.text(`Created kubb.config.ts\n\nInstall packages:\n  npm install ${packageList}\n\nThen run:\n  npx kubb generate`)
+  },
+)

package/src/tools/validate.ts

@@ -0,0 +1,25 @@
+import { defineTool } from 'tmcp/tool'
+import { tool } from 'tmcp/utils'
+import { validateSchema } from '../schemas/validateSchema.ts'
+
+export const validateTool = defineTool(
+  {
+    name: 'validate',
+    description: 'Validate an OpenAPI/Swagger specification file or URL',
+    schema: validateSchema,
+  },
+  async ({ input }) => {
+    let mod: typeof import('@kubb/adapter-oas')
+    try {
+      mod = await import('@kubb/adapter-oas')
+    } catch {
+      return tool.error('The validate tool requires @kubb/adapter-oas.\nInstall: npm install @kubb/adapter-oas')
+    }
+    try {
+      await mod.adapterOas().validate(input, { throwOnError: true })
+      return tool.text(`Validation successful: ${input}`)
+    } catch (err) {
+      return tool.error(`Validation failed:\n${err instanceof Error ? err.message : String(err)}`)
+    }
+  },
+)

package/src/utils/loadUserConfig.ts

@@ -1,55 +1,78 @@
+import { existsSync } from 'node:fs'
 import path from 'node:path'
 import type { Config } from '@kubb/core'
-import createJiti from 'jiti'
+import { createJiti } from 'jiti'
+import { ALLOWED_CONFIG_EXTENSIONS } from '../constants.ts'
 import { NotifyTypes } from '../types.ts'
 
 type NotifyFunction = (type: string, message: string, data?: Record<string, unknown>) => Promise<void>
 
 const jiti = createJiti(import.meta.url, {
-  sourceMaps: true,
+  jsx: {
+    runtime: 'automatic',
+    importSource: '@kubb/renderer-jsx',
+  },
+  moduleCache: false,
 })
 
-/**
- * Load the user configuration from the specified path or current directory
- */
-export async function loadUserConfig(configPath: string | undefined, { notify }: { notify: NotifyFunction }): Promise<{ userConfig: Config; cwd: string }> {
-  let userConfig: Config | undefined
-  let cwd: string
+const loadedModules = new Map<string, unknown>()
 
-  if (configPath) {
-    // Resolve the config path to absolute path and get its directory
-    cwd = path.dirname(path.resolve(configPath))
+async function loadModule(filePath: string): Promise<unknown> {
+  const ext = path.extname(filePath)
+  if (!ALLOWED_CONFIG_EXTENSIONS.has(ext)) {
+    throw new Error(`Invalid config file extension "${ext}". Allowed: ${[...ALLOWED_CONFIG_EXTENSIONS].join(', ')}`)
+  }
+  if (loadedModules.has(filePath)) {
+    return loadedModules.get(filePath)
+  }
+  const mod = await jiti.import(filePath, { default: true })
+  loadedModules.set(filePath, mod)
+  return mod
+}
 
-    // Try to load from path
+export async function loadUserConfig(configPath: string | undefined, { notify }: { notify: NotifyFunction }): Promise<{ userConfig: Config; cwd: string }> {
+  if (configPath) {
+    const ext = path.extname(configPath)
+    if (!ALLOWED_CONFIG_EXTENSIONS.has(ext)) {
+      const msg = `Invalid config file extension "${ext}". Allowed: ${[...ALLOWED_CONFIG_EXTENSIONS].join(', ')}`
+      await notify(NotifyTypes.CONFIG_ERROR, msg)
+      throw new Error(msg)
+    }
+    const base = path.resolve(process.cwd())
+    const resolvedConfigPath = path.resolve(base, configPath)
+    const relative = path.relative(base, resolvedConfigPath)
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+      const msg = 'Invalid config file path: must be within the current working directory'
+      await notify(NotifyTypes.CONFIG_ERROR, msg)
+      throw new Error(msg)
+    }
+    const cwd = path.dirname(resolvedConfigPath)
     try {
-      userConfig = await jiti.import(configPath, { default: true })
-      await notify(NotifyTypes.CONFIG_LOADED, `Loaded config from ${configPath}`)
+      const userConfig = (await loadModule(resolvedConfigPath)) as Config
+      await notify(NotifyTypes.CONFIG_LOADED, `Loaded config from ${resolvedConfigPath}`)
+      return { userConfig, cwd }
     } catch (error) {
-      await notify(NotifyTypes.CONFIG_ERROR, `Failed to load config: ${error instanceof Error ? error.message : String(error)}`)
-      throw new Error(`Failed to load config: ${error instanceof Error ? error.message : String(error)}`)
-    }
-  } else {
-    // Look for kubb.config in current directory with various extensions
-    cwd = process.cwd()
-    const configFileNames = ['kubb.config.ts', 'kubb.config.js', 'kubb.config.cjs']
-
-    for (const configFileName of configFileNames) {
-      try {
-        const configFilePath = path.resolve(process.cwd(), configFileName)
-        userConfig = await jiti.import(configFilePath, { default: true })
-        await notify(NotifyTypes.CONFIG_LOADED, `Loaded ${configFileName} from current directory`)
-        break
-      } catch {
-        // Continue trying next config file
-      }
+      const msg = `Failed to load config: ${error instanceof Error ? error.message : String(error)}`
+      await notify(NotifyTypes.CONFIG_ERROR, msg)
+      throw new Error(msg)
     }
+  }
 
-    if (!userConfig) {
-      await notify(NotifyTypes.CONFIG_ERROR, 'No config file found')
+  const cwd = process.cwd()
+  const configFileNames = ['kubb.config.ts', 'kubb.config.mts', 'kubb.config.cts', 'kubb.config.js', 'kubb.config.cjs']
 
-      throw new Error(`No config file found. Please provide a config path or create one of: ${configFileNames.join(', ')}`)
+  for (const configFileName of configFileNames) {
+    const configFilePath = path.resolve(process.cwd(), configFileName)
+    if (!existsSync(configFilePath)) continue
+    try {
+      const userConfig = (await loadModule(configFilePath)) as Config
+      await notify(NotifyTypes.CONFIG_LOADED, `Loaded ${configFileName} from current directory`)
+      return { userConfig, cwd }
+    } catch (err) {
+      await notify(NotifyTypes.CONFIG_ERROR, `Failed to load ${configFileName}: ${err instanceof Error ? err.message : String(err)}`)
     }
   }
 
-  return { userConfig: userConfig!, cwd }
+  await notify(NotifyTypes.CONFIG_ERROR, 'No config file found')
+  throw new Error(`No config file found. Please provide a config path or create one of: ${configFileNames.join(', ')}`)
 }

package/src/utils/resolveUserConfig.ts

@@ -1,25 +1,13 @@
 import { isPromise } from '@internals/utils'
-import type { CLIOptions, Config, UserConfig } from '@kubb/core'
+import type { CLIOptions, Config, PossibleConfig } from '@kubb/core'
 
 export type ResolveUserConfigOptions = {
   configPath?: string
   logLevel?: string
 }
 
-/**
- * Resolve the config by handling function configs and returning the final configuration
- */
-export async function resolveUserConfig(userConfig: UserConfig, options: ResolveUserConfigOptions): Promise<Config> {
-  let kubbUserConfig = Promise.resolve(userConfig) as Promise<UserConfig>
-
-  if (typeof userConfig === 'function') {
-    const possiblePromise = (userConfig as any)({ logLevel: options.logLevel, config: options.configPath } as CLIOptions)
-    if (isPromise(possiblePromise)) {
-      kubbUserConfig = possiblePromise
-    } else {
-      kubbUserConfig = Promise.resolve(possiblePromise)
-    }
-  }
-
-  return (await kubbUserConfig) as Config
+export async function resolveUserConfig(config: PossibleConfig<CLIOptions>, options: ResolveUserConfigOptions): Promise<Config> {
+  const result = typeof config === 'function' ? config({ logLevel: options.logLevel as CLIOptions['logLevel'], config: options.configPath }) : config
+  const resolved = isPromise(result) ? await result : result
+  return (Array.isArray(resolved) ? resolved[0] : resolved) as Config
 }