@kubb/mcp 5.0.0-beta.63 → 5.0.0-beta.64

package/src/tools/init.ts

@@ -1,41 +0,0 @@
-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'
-
-/**
- * Resolves a comma-separated plugin flag into the matching known plugin options.
- * Unrecognized names are dropped, and a missing flag yields an empty list.
- */
-export function resolvePlugins(pluginsFlag: string | undefined): Array<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

@@ -1,28 +0,0 @@
-import { Diagnostics } from '@kubb/core'
-import { defineTool } from 'tmcp/tool'
-import { tool } from 'tmcp/utils'
-import { validateSchema } from '../schemas/validateSchema.ts'
-import { formatDiagnostics } from '../utils.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) {
-      const serialized = Diagnostics.serialize(Diagnostics.from(err))
-      return tool.error(`Validation failed:\n${formatDiagnostics([serialized])}\n\n\`\`\`json\n${JSON.stringify(serialized, null, 2)}\n\`\`\``)
-    }
-  },
-)

package/src/utils.ts

@@ -1,152 +0,0 @@
-import { existsSync } from 'node:fs'
-import path from 'node:path'
-import { createModuleLoader } from '@internals/shared'
-import { isPromise } from '@internals/utils'
-import type { CLIOptions, Config, PossibleConfig, SerializedDiagnostic } from '@kubb/core'
-import { ALLOWED_CONFIG_EXTENSIONS, NotifyTypes } from './constants.ts'
-
-/**
- * Renders serialized diagnostics as a plain-text block for an AI assistant. Each entry
- * keeps the stable `code`, the source pointer, the suggested fix, and the docs link, so
- * the agent can act on the problem rather than parsing a bare message. No ANSI styling,
- * unlike the CLI renderer.
- */
-export function formatDiagnostics(diagnostics: ReadonlyArray<SerializedDiagnostic>): string {
-  return diagnostics.map((diagnostic) => formatDiagnostic(diagnostic)).join('\n\n')
-}
-
-function formatDiagnostic(diagnostic: SerializedDiagnostic): string {
-  const { code, severity, message, location, help, plugin, docsUrl } = diagnostic
-  const rule = plugin ? `${plugin}(${code})` : code
-  const lines = [`${severity} ${rule}: ${message}`]
-
-  if (location && 'pointer' in location) {
-    lines.push(`  at ${location.pointer}`)
-  }
-  if (help) {
-    lines.push(`  help: ${help}`)
-  }
-  if (docsUrl) {
-    lines.push(`  docs: ${docsUrl}`)
-  }
-
-  return lines.join('\n')
-}
-
-type NotifyFunction = (type: string, message: string, data?: Record<string, unknown>) => Promise<void>
-
-const loader = createModuleLoader()
-
-const loadedModules = new Map<string, unknown>()
-
-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 loader.load(filePath, { default: true })
-  loadedModules.set(filePath, mod)
-  return mod
-}
-
-/**
- * Loads the user's Kubb config and returns it with the directory it was found in.
- *
- * When `configPath` is given it must use an allowed extension and resolve inside
- * the current working directory, otherwise loading throws. When omitted, the
- * known `kubb.config.*` file names are tried in the current directory. Every
- * outcome is reported through `notify` before the function returns or throws.
- */
-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 {
-      const userConfig = (await loadModule(resolvedConfigPath)) as Config
-      await notify(NotifyTypes.CONFIG_LOADED, `Loaded config from ${resolvedConfigPath}`)
-      return { userConfig, cwd }
-    } catch (error) {
-      const msg = `Failed to load config: ${error instanceof Error ? error.message : String(error)}`
-      await notify(NotifyTypes.CONFIG_ERROR, msg)
-      throw new Error(msg)
-    }
-  }
-
-  const cwd = process.cwd()
-  const configFileNames = ['kubb.config.ts', 'kubb.config.mts', 'kubb.config.cts', 'kubb.config.js', 'kubb.config.cjs']
-
-  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)}`)
-    }
-  }
-
-  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(', ')}`)
-}
-
-/**
- * Determine the root directory based on userConfig.root and resolvedConfigDir
- * 1. If userConfig.root exists and is absolute, use it as-is
- * 2. If userConfig.root exists and is relative, resolve it relative to config directory
- * 3. Otherwise, use the config directory as root
- */
-export function resolveCwd(userConfig: Config, cwd: string): string {
-  if (userConfig.root) {
-    if (path.isAbsolute(userConfig.root)) {
-      return userConfig.root
-    }
-
-    return path.resolve(cwd, userConfig.root)
-  }
-
-  return cwd
-}
-
-/**
- * Inputs forwarded to a config when it is defined as a function.
- */
-export type ResolveUserConfigOptions = {
-  /**
-   * Path of the loaded config, passed through to the config function as `config`.
-   */
-  configPath?: string
-  /**
-   * Log level passed through to the config function.
-   */
-  logLevel?: string
-}
-
-/**
- * Normalizes a possible config into a single resolved `Config`.
- *
- * Calls the config when it is a function, awaits it when it is a promise, and
- * picks the first entry when it resolves to an array.
- */
-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
-}