@kubb/mcp 5.0.0-beta.1 → 5.0.0-beta.100

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,17 +1,15 @@
 {
   "name": "@kubb/mcp",
-  "version": "5.0.0-beta.1",
-  "description": "Model Context Protocol (MCP) server for Kubb, enabling AI assistants to generate code from OpenAPI specifications.",
+  "version": "5.0.0-beta.100",
+  "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",
-    "code-generation",
     "codegen",
     "kubb",
     "llm",
     "mcp",
+    "meta-framework",
     "model-context-protocol",
-    "openapi",
-    "swagger",
     "typescript"
   ],
   "license": "MIT",
@@ -25,7 +23,6 @@
     "kubb-mcp": "bin/kubb-mcp.cjs"
   },
   "files": [
-    "src",
     "dist",
     "bin",
     "!/**/**.test.**",
@@ -49,38 +46,35 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "unrun": "^0.2.37",
-    "zod": "^4.3.6",
-    "@kubb/core": "5.0.0-beta.1"
+    "@tmcp/adapter-valibot": "^0.1.6",
+    "@tmcp/transport-stdio": "^0.4.3",
+    "tmcp": "^1.19.4",
+    "valibot": "^1.4.2",
+    "@kubb/core": "5.0.0-beta.100",
+    "@kubb/adapter-oas": "5.0.0-beta.100"
   },
   "devDependencies": {
     "@internals/utils": "0.0.0",
-    "@kubb/renderer-jsx": "5.0.0-beta.1"
+    "@kubb/renderer-jsx": "5.0.0-beta.100",
+    "@internals/shared": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.1"
+    "@kubb/renderer-jsx": "5.0.0-beta.100"
   },
-  "size-limit": [
-    {
-      "path": "./dist/*.js",
-      "limit": "510 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,5 +0,0 @@
-import { startServer } from './server.ts'
-
-export async function run(_argv?: string[]): Promise<void> {
-  await startServer()
-}

package/src/schemas/generateSchema.ts

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

package/src/server.ts

@@ -1,48 +0,0 @@
-import process from 'node:process'
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
-import { version } from '../package.json'
-import { generateSchema } from './schemas/generateSchema.ts'
-import { generate } from './tools/generate.ts'
-
-/**
- * Kubb MCP Server
- *
- * Provides tools for building OpenAPI specifications using Kubb.
- */
-export async function startServer() {
-  try {
-    const transport = new StdioServerTransport()
-    const server = new McpServer({
-      name: 'Kubb',
-      version,
-    })
-
-    // Build tool - runs Kubb build using @kubb/core
-    // Wrapped to pass notification handler for real-time progress updates
-    server.tool('generate', 'Generate OpenAPI spec helpers using Kubb configuration', generateSchema.shape, async (args) => {
-      // Create notification handler that sends events back to the client
-      const notificationHandler = {
-        sendNotification: async (method: string, params: any) => {
-          try {
-            await transport.send({
-              jsonrpc: '2.0',
-              method,
-              params,
-            })
-          } catch (error) {
-            console.error('Failed to send notification:', error)
-          }
-        },
-      }
-
-      // Call build tool with notification handler
-      return generate(args, notificationHandler)
-    })
-
-    await server.connect(transport)
-  } catch (error) {
-    console.error('Failed to start MCP server:', error)
-    process.exit(1)
-  }
-}

package/src/tools/generate.ts

@@ -1,210 +0,0 @@
-import { AsyncEventEmitter } from '@internals/utils'
-import { type Config, createKubb, type KubbHooks } 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 { 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 hooks = new AsyncEventEmitter<KubbHooks>()
-    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,
-      })
-    }
-
-    // Capture events for output and send notifications
-    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, { stack: error.stack })
-    })
-
-    hooks.on('kubb:warn', async ({ message }: { message: string }) => {
-      await notify(NotifyTypes.WARN, message)
-    })
-
-    // Plugin lifecycle events
-    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,
-      })
-    })
-
-    // File processing events
-    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')
-    })
-
-    // Generation events
-    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')
-    })
-
-    // Load and process configuration
-    let userConfig: Config
-    let cwd: string
-
-    try {
-      const configResult = await loadUserConfig(configPath, { notify })
-      userConfig = configResult.userConfig
-      cwd = configResult.cwd
-
-      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.')
-      }
-
-      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 ?? ('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', {
-      root: config.root,
-    })
-
-    // Setup and build
-    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)`, {
-        errorCount: allErrors.length,
-        errors: allErrors.map((err) => err.message),
-      })
-
-      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_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,
-    }
-  }
-}

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,77 +0,0 @@
-import { existsSync } from 'node:fs'
-import path from 'node:path'
-import type { Config } from '@kubb/core'
-import { unrun } from 'unrun'
-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 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 { module } = await unrun({ path: filePath })
-  loadedModules.set(filePath, module)
-  return module
-}
-
-export async function loadUserConfig(configPath: string | undefined, { notify }: { notify: NotifyFunction }): Promise<{ userConfig: Config; cwd: string }> {
-  let userConfig: Config | undefined
-  let 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)
-    }
-    cwd = path.dirname(resolvedConfigPath)
-
-    try {
-      userConfig = (await loadModule(resolvedConfigPath)) as Config
-      await notify(NotifyTypes.CONFIG_LOADED, `Loaded config from ${resolvedConfigPath}`)
-    } 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 {
-    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 {
-        userConfig = (await loadModule(configFilePath)) as Config
-        await notify(NotifyTypes.CONFIG_LOADED, `Loaded ${configFileName} from current directory`)
-        break
-      } catch {
-        // Continue trying next config file
-      }
-    }
-
-    if (!userConfig) {
-      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(', ')}`)
-    }
-  }
-
-  return { userConfig: userConfig!, cwd }
-}

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,28 +0,0 @@
-import { isPromise } from '@internals/utils'
-import type { CLIOptions, Config } 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(config: Config, options: ResolveUserConfigOptions): Promise<Config> {
-  let kubbUserConfig = Promise.resolve(config) as Promise<Config>
-
-  if (typeof config === 'function') {
-    const possiblePromise = (config 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
-}