@kubb/mcp 5.0.0-beta.9 → 5.0.0-beta.91

package/dist/rolldown-runtime-G2anUtha.js

@@ -0,0 +1,30 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __toESM as i, __name as n, __require as r, __commonJSMin as t };

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@kubb/mcp",
-  "version": "5.0.0-beta.9",
-  "description": "MCP server for Kubb. Exposes code generation as a tool over the Model Context Protocol so AI assistants like Claude, Cursor, and other MCP-compatible clients can generate TypeScript types, clients, and more from OpenAPI specs.",
+  "version": "5.0.0-beta.91",
+  "description": "MCP server for Kubb. Exposes code generation as a tool over the Model Context Protocol so AI assistants like Claude, Cursor, and other MCP-compatible clients can generate TypeScript types, clients, and more.",
   "keywords": [
     "ai",
     "codegen",
     "kubb",
     "llm",
     "mcp",
+    "meta-framework",
     "model-context-protocol",
-    "openapi",
     "typescript"
   ],
   "license": "MIT",
@@ -23,7 +23,6 @@
     "kubb-mcp": "bin/kubb-mcp.cjs"
   },
   "files": [
-    "src",
     "dist",
     "bin",
     "!/**/**.test.**",
@@ -47,44 +46,35 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@remix-run/node-fetch-server": "^0.13.1",
-    "@tmcp/adapter-valibot": "^0.1.5",
-    "@tmcp/transport-http": "^0.8.5",
-    "@tmcp/transport-stdio": "^0.4.2",
-    "jiti": "^2.7.0",
-    "tmcp": "^1.19.3",
-    "valibot": "^1.4.0",
-    "@kubb/adapter-oas": "5.0.0-beta.9",
-    "@kubb/core": "5.0.0-beta.9"
+    "@tmcp/adapter-valibot": "^0.1.6",
+    "@tmcp/transport-stdio": "^0.4.3",
+    "tmcp": "^1.19.4",
+    "valibot": "^1.4.2",
+    "@kubb/adapter-oas": "5.0.0-beta.91",
+    "@kubb/core": "5.0.0-beta.91"
   },
   "devDependencies": {
     "@internals/shared": "0.0.0",
-    "@internals/utils": "0.0.0",
-    "@kubb/renderer-jsx": "5.0.0-beta.9"
+    "@kubb/renderer-jsx": "5.0.0-beta.91",
+    "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.9"
+    "@kubb/renderer-jsx": "5.0.0-beta.91"
   },
-  "size-limit": [
-    {
-      "path": "./dist/*.js",
-      "limit": "600 KiB",
-      "gzip": true
-    }
-  ],
   "engines": {
     "node": ">=22"
   },
+  "inlinedDependencies": {
+    "jiti": "2.7.0"
+  },
   "scripts": {
-    "build": "tsdown && size-limit",
-    "start:mcp": "bun --watch ./src/server.ts",
+    "build": "tsdown",
+    "clean": "node -e \"require('node:fs').rmSync('./dist', {recursive:true,force:true})\"",
     "debug:mcp": "npx -y @modelcontextprotocol/inspector node ./bin/kubb-mcp.cjs",
-    "clean": "npx rimraf ./dist",
     "lint": "oxlint .",
     "lint:fix": "oxlint --fix .",
-    "release": "pnpm publish --no-git-check",
-    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
     "start": "tsdown --watch",
+    "start:mcp": "bun --watch ./src/server.ts",
     "test": "vitest --passWithNoTests",
     "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
   }

package/dist/chunk--u3MIqq1.js

@@ -1,8 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-//#endregion
-export { __name as t };

package/src/constants.ts

@@ -1 +0,0 @@
-export const ALLOWED_CONFIG_EXTENSIONS = new Set(['.ts', '.mts', '.cts', '.js', '.mjs', '.cjs'])

package/src/index.ts

@@ -1,8 +0,0 @@
-import { startServer } from './server.ts'
-
-export { createMcpServer } from './server.ts'
-export type { ServerOptions } from './server.ts'
-
-export async function run(_argv?: string[], options?: import('./server.ts').ServerOptions): Promise<void> {
-  await startServer(options)
-}

package/src/schemas/generateSchema.ts

@@ -1,13 +0,0 @@
-import * as v from 'valibot'
-
-export const generateSchema = v.object({
-  config: v.optional(
-    v.pipe(v.string(), v.minLength(1), v.description('Path to kubb.config file (supports .ts, .js, .cjs). If not provided, will look for kubb.config.{ts,js,cjs} in current directory')),
-  ),
-  input: v.optional(v.pipe(v.string(), v.minLength(1), v.description('Path to OpenAPI/Swagger spec file (overrides config)'))),
-  output: v.optional(v.pipe(v.string(), v.minLength(1), v.description('Output directory path (overrides config)'))),
-  logLevel: v.optional(
-    v.pipe(v.picklist(['silent', 'error', 'warn', 'info', 'verbose', 'debug']), v.description('Log level for build output')),
-    'info',
-  ),
-})

package/src/schemas/initSchema.ts

@@ -1,7 +0,0 @@
-import * as v from 'valibot'
-
-export const initSchema = v.object({
-  input: v.optional(v.pipe(v.string(), v.minLength(1), v.description('Path to OpenAPI spec (default: ./openapi.yaml)'))),
-  output: v.optional(v.pipe(v.string(), v.minLength(1), v.description('Output directory (default: ./src/gen)'))),
-  plugins: v.optional(v.pipe(v.string(), v.minLength(1), v.description('Comma-separated list of plugins: plugin-ts,plugin-zod,...'))),
-})

package/src/schemas/validateSchema.ts

@@ -1,5 +0,0 @@
-import * as v from 'valibot'
-
-export const validateSchema = v.object({
-  input: v.pipe(v.string(), v.minLength(1), v.description('Path or URL to the OpenAPI/Swagger specification')),
-})

package/src/server.ts

@@ -1,41 +0,0 @@
-import http from 'node:http'
-import { createRequestListener } from '@remix-run/node-fetch-server'
-import { ValibotJsonSchemaAdapter } from '@tmcp/adapter-valibot'
-import { HttpTransport } from '@tmcp/transport-http'
-import { StdioTransport } from '@tmcp/transport-stdio'
-import { McpServer } from 'tmcp'
-import { version } from '../package.json'
-import { generateTool } from './tools/generate.ts'
-import { initTool } from './tools/init.ts'
-import { validateTool } from './tools/validate.ts'
-
-export type ServerOptions = {
-  port?: number
-  host?: string
-}
-
-export function createMcpServer() {
-  const server = new McpServer({ name: 'Kubb', version }, { adapter: new ValibotJsonSchemaAdapter(), capabilities: { tools: {} } })
-  server.tools([generateTool, validateTool, initTool])
-  return server
-}
-
-export async function startServer({ port, host = 'localhost' }: ServerOptions = {}) {
-  const server = createMcpServer()
-
-  if (port === undefined) {
-    new StdioTransport(server).listen()
-    return
-  }
-
-  const transport = new HttpTransport(server, { path: '/mcp' })
-  const httpServer = http.createServer(
-    createRequestListener(async (request) => {
-      const response = await transport.respond(request)
-      return response ?? new Response('Not Found', { status: 404 })
-    }),
-  )
-  httpServer.listen(port, host, () => {
-    console.log(`Kubb MCP server on http://${host}:${port}`)
-  })
-}

package/src/tools/generate.ts

@@ -1,146 +0,0 @@
-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'
-
-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
-
-    try {
-      const hooks = new AsyncEventEmitter<KubbHooks>()
-      const messages: string[] = []
-
-      const notify = async (type: string, message: string, _data?: Record<string, unknown>) => {
-        messages.push(`${type}: ${message}`)
-      }
-
-      hooks.on('kubb:info', async ({ message }: { message: string }) => {
-        await notify(NotifyTypes.INFO, message)
-      })
-
-      hooks.on('kubb:success', async ({ message }: { message: string }) => {
-        await notify(NotifyTypes.SUCCESS, message)
-      })
-
-      hooks.on('kubb:error', async ({ error }: { error: Error }) => {
-        await notify(NotifyTypes.ERROR, error.message)
-      })
-
-      hooks.on('kubb:warn', async ({ message }: { message: string }) => {
-        await notify(NotifyTypes.WARN, message)
-      })
-
-      hooks.on('kubb:plugin:start', async ({ plugin }) => {
-        await notify(NotifyTypes.PLUGIN_START, `Plugin starting: ${plugin.name}`)
-      })
-
-      hooks.on('kubb:plugin:end', async ({ plugin, duration }) => {
-        await notify(NotifyTypes.PLUGIN_END, `Plugin finished: ${plugin.name}`, { duration })
-      })
-
-      hooks.on('kubb:files:processing:start', async () => {
-        await notify(NotifyTypes.FILES_START, 'Starting file processing')
-      })
-
-      hooks.on('kubb:file:processing:update', async ({ file }: { file: { name: string } }) => {
-        await notify(NotifyTypes.FILE_UPDATE, `Processing file: ${file.name}`)
-      })
-
-      hooks.on('kubb:files:processing:end', async () => {
-        await notify(NotifyTypes.FILES_END, 'File processing complete')
-      })
-
-      hooks.on('kubb:generation:start', async () => {
-        await notify(NotifyTypes.GENERATION_START, 'Generation started')
-      })
-
-      hooks.on('kubb:generation:end', async () => {
-        await notify(NotifyTypes.GENERATION_END, 'Generation ended')
-      })
-
-      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)
-      }
-
-      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,
-      }
-
-      await notify(NotifyTypes.CONFIG_READY, 'Configuration ready')
-      await notify(NotifyTypes.SETUP_START, 'Setting up Kubb')
-
-      const kubb = createKubb(config, { hooks })
-      await kubb.setup()
-      await notify(NotifyTypes.SETUP_END, 'Kubb setup complete')
-
-      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`)
-
-      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

@@ -1,37 +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'
-
-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

@@ -1,25 +0,0 @@
-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/types.ts

@@ -1,23 +0,0 @@
-export const NotifyTypes = {
-  INFO: 'INFO',
-  SUCCESS: 'SUCCESS',
-  ERROR: 'ERROR',
-  WARN: 'WARN',
-  PLUGIN_START: 'PLUGIN_START',
-  PLUGIN_END: 'PLUGIN_END',
-  FILES_START: 'FILES_START',
-  FILE_UPDATE: 'FILE_UPDATE',
-  FILES_END: 'FILES_END',
-  GENERATION_START: 'GENERATION_START',
-  GENERATION_END: 'GENERATION_END',
-  CONFIG_LOADED: 'CONFIG_LOADED',
-  CONFIG_ERROR: 'CONFIG_ERROR',
-  CONFIG_READY: 'CONFIG_READY',
-  SETUP_START: 'SETUP_START',
-  SETUP_END: 'SETUP_END',
-  BUILD_START: 'BUILD_START',
-  BUILD_END: 'BUILD_END',
-  BUILD_FAILED: 'BUILD_FAILED',
-  BUILD_SUCCESS: 'BUILD_SUCCESS',
-  FATAL_ERROR: 'FATAL_ERROR',
-} as const

package/src/utils/loadUserConfig.ts

@@ -1,78 +0,0 @@
-import { existsSync } from 'node:fs'
-import path from 'node:path'
-import type { Config } from '@kubb/core'
-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, {
-  jsx: {
-    runtime: 'automatic',
-    importSource: '@kubb/renderer-jsx',
-  },
-  moduleCache: false,
-})
-
-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 jiti.import(filePath, { default: true })
-  loadedModules.set(filePath, mod)
-  return mod
-}
-
-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(', ')}`)
-}

package/src/utils/resolveCwd.ts

@@ -1,20 +0,0 @@
-import path from 'node:path'
-import type { Config } from '@kubb/core'
-
-/**
- * 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
-}

package/src/utils/resolveUserConfig.ts

@@ -1,13 +0,0 @@
-import { isPromise } from '@internals/utils'
-import type { CLIOptions, Config, PossibleConfig } from '@kubb/core'
-
-export type ResolveUserConfigOptions = {
-  configPath?: string
-  logLevel?: string
-}
-
-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
-}