@kubb/plugin-mcp 5.0.0-beta.42 → 5.0.0-beta.64

package/src/plugin.ts

@@ -1,142 +0,0 @@
-import path from 'node:path'
-import { createGroupConfig } from '@internals/shared'
-
-import { ast, definePlugin } from '@kubb/core'
-import { pluginClientName } from '@kubb/plugin-client'
-import { source as axiosClientSource } from '@kubb/plugin-client/templates/clients/axios.source'
-import { source as fetchClientSource } from '@kubb/plugin-client/templates/clients/fetch.source'
-import { source as configSource } from '@kubb/plugin-client/templates/config.source'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { mcpGenerator } from './generators/mcpGenerator.tsx'
-import { serverGenerator } from './generators/serverGenerator.tsx'
-import { resolverMcp } from './resolvers/resolverMcp.ts'
-import type { PluginMcp } from './types.ts'
-
-/**
- * Canonical plugin name for `@kubb/plugin-mcp`. Used for driver lookups and
- * cross-plugin dependency references.
- */
-export const pluginMcpName = 'plugin-mcp' satisfies PluginMcp['name']
-
-/**
- * Generates a Model Context Protocol (MCP) server from an OpenAPI spec. Every
- * operation becomes a typed MCP tool that AI assistants (Claude Desktop, Claude
- * Code, MCP-compatible clients) can call directly.
- *
- * @example
- * ```ts
- * import { defineConfig } from 'kubb'
- * import { pluginTs } from '@kubb/plugin-ts'
- * import { pluginClient } from '@kubb/plugin-client'
- * import { pluginZod } from '@kubb/plugin-zod'
- * import { pluginMcp } from '@kubb/plugin-mcp'
- *
- * export default defineConfig({
- *   input: { path: './petStore.yaml' },
- *   output: { path: './src/gen' },
- *   plugins: [
- *     pluginTs(),
- *     pluginClient(),
- *     pluginZod(),
- *     pluginMcp({
- *       output: { path: './mcp' },
- *       client: { baseURL: 'https://petstore.swagger.io/v2' },
- *     }),
- *   ],
- * })
- * ```
- */
-export const pluginMcp = definePlugin<PluginMcp>((options) => {
-  const {
-    output = { path: 'mcp', barrelType: 'named' },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    paramsCasing,
-    client,
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators = [],
-  } = options
-
-  const clientName = client?.client ?? 'axios'
-  const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : undefined)
-
-  const groupConfig = createGroupConfig(group, { suffix: 'Requests' })
-
-  return {
-    name: pluginMcpName,
-    options,
-    dependencies: [pluginTsName, pluginZodName],
-    hooks: {
-      'kubb:plugin:setup'(ctx) {
-        const resolver = userResolver ? { ...resolverMcp, ...userResolver } : resolverMcp
-
-        ctx.setOptions({
-          output,
-          exclude,
-          include,
-          override,
-          group: groupConfig,
-          paramsCasing,
-          client: {
-            client: clientName,
-            clientType: client?.clientType ?? 'function',
-            importPath: clientImportPath,
-            dataReturnType: client?.dataReturnType ?? 'data',
-            bundle: client?.bundle,
-            baseURL: client?.baseURL,
-            paramsCasing: client?.paramsCasing,
-          },
-          resolver,
-        })
-        ctx.setResolver(resolver)
-        if (userTransformer) {
-          ctx.setTransformer(userTransformer)
-        }
-        ctx.addGenerator(mcpGenerator)
-        ctx.addGenerator(serverGenerator)
-        for (const gen of userGenerators) {
-          ctx.addGenerator(gen)
-        }
-
-        const root = path.resolve(ctx.config.root, ctx.config.output.path)
-        const hasClientPlugin = ctx.config.plugins?.some((p) => p.name === pluginClientName)
-
-        if (client?.bundle && !hasClientPlugin && !clientImportPath) {
-          ctx.injectFile({
-            baseName: 'client.ts',
-            path: path.resolve(root, '.kubb/client.ts'),
-            sources: [
-              ast.createSource({
-                name: 'client',
-                nodes: [ast.createText(clientName === 'fetch' ? fetchClientSource : axiosClientSource)],
-                isExportable: true,
-                isIndexable: true,
-              }),
-            ],
-          })
-        }
-
-        if (!hasClientPlugin) {
-          ctx.injectFile({
-            baseName: 'config.ts',
-            path: path.resolve(root, '.kubb/config.ts'),
-            sources: [
-              ast.createSource({
-                name: 'config',
-                nodes: [ast.createText(configSource)],
-                isExportable: false,
-                isIndexable: false,
-              }),
-            ],
-          })
-        }
-      },
-    },
-  }
-})
-
-export default pluginMcp

package/src/resolvers/resolverMcp.ts

@@ -1,35 +0,0 @@
-import { camelCase } from '@internals/utils'
-import { defineResolver } from '@kubb/core'
-import type { PluginMcp } from '../types.ts'
-
-/**
- * Default resolver used by `@kubb/plugin-mcp`. Decides the names and file
- * paths for every generated MCP tool handler. Function names get a `Handler`
- * suffix so an operation `addPet` becomes `addPetHandler`.
- *
- * @example Resolve a handler name
- * ```ts
- * import { resolverMcp } from '@kubb/plugin-mcp'
- *
- * resolverMcp.default('addPet', 'function') // 'addPetHandler'
- * ```
- */
-export const resolverMcp = defineResolver<PluginMcp>(() => ({
-  name: 'default',
-  pluginName: 'plugin-mcp',
-  default(name, type) {
-    if (type === 'file') {
-      return camelCase(name, { isFile: true })
-    }
-    return camelCase(name, { suffix: 'handler' })
-  },
-  resolveName(name) {
-    return this.default(name, 'function')
-  },
-  resolvePathName(name, type) {
-    return this.default(name, type)
-  },
-  resolveHandlerName(node) {
-    return this.resolveName(node.operationId)
-  },
-}))

package/src/types.ts

@@ -1,94 +0,0 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
-import type { ClientImportPath, PluginClient } from '@kubb/plugin-client'
-
-/**
- * Resolver for MCP that provides naming methods for handler functions.
- */
-export type ResolverMcp = Resolver & {
-  /**
-   * Resolves the base handler function name for an operation.
-   *
-   * @example Resolving handler function names
-   * `resolver.resolveName('show pet by id') // -> 'showPetByIdHandler'`
-   */
-  resolveName(this: ResolverMcp, name: string): string
-  /**
-   * Resolves the output file name for an MCP module.
-   */
-  resolvePathName(this: ResolverMcp, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
-  /**
-   * Resolves the handler function name for an operation.
-   */
-  resolveHandlerName(this: ResolverMcp, node: ast.OperationNode): string
-}
-
-export type Options = {
-  /**
-   * Where the generated MCP tool handlers are written and how they are exported.
-   *
-   * @default { path: 'mcp', barrel: { type: 'named' } }
-   */
-  output?: Output
-  /**
-   * HTTP client used by each MCP handler to call the underlying API. Mirrors a
-   * subset of `pluginClient` options.
-   */
-  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>
-  /**
-   * Rename parameter properties in the generated handlers. The HTTP layer still
-   * uses the original spec names; Kubb writes the mapping for you.
-   *
-   * @note Must match the value of `paramsCasing` on `@kubb/plugin-ts`.
-   */
-  paramsCasing?: 'camelcase'
-  /**
-   * Split generated files into subfolders based on the operation's tag.
-   */
-  group?: Group
-  /**
-   * Skip operations matching at least one entry in the list.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Restrict generation to operations matching at least one entry in the list.
-   */
-  include?: Array<Include>
-  /**
-   * Apply a different options object to operations matching a pattern.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  /**
-   * Override how handler names and file paths are built. Methods you omit fall
-   * back to the default `resolverMcp`.
-   */
-  resolver?: Partial<ResolverMcp> & ThisType<ResolverMcp>
-  /**
-   * AST visitor applied to each operation node before printing.
-   */
-  transformer?: ast.Visitor
-  /**
-   * Custom generators that run alongside the built-in MCP generators.
-   */
-  generators?: Array<Generator<PluginMcp>>
-}
-
-type ResolvedOptions = {
-  output: Output
-  exclude: Array<Exclude>
-  include: Array<Include> | undefined
-  override: Array<Override<ResolvedOptions>>
-  group: Group | null
-  client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>
-  paramsCasing: Options['paramsCasing']
-  resolver: ResolverMcp
-}
-
-export type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, ResolverMcp>
-
-declare global {
-  namespace Kubb {
-    interface PluginRegistry {
-      'plugin-mcp': PluginMcp
-    }
-  }
-}

package/src/utils.ts

@@ -1,48 +0,0 @@
-import type { ast } from '@kubb/core'
-
-export type ZodParam = {
-  name: string
-  schemaName: string
-}
-
-/**
- * Render a group param value — compose individual schemas into `z.object({ ... })`,
- * or use a schema name string directly.
- */
-export function zodGroupExpr(entry: string | Array<ZodParam>): string {
-  if (typeof entry === 'string') {
-    return entry
-  }
-  const entries = entry.map((p) => `${JSON.stringify(p.name)}: ${p.schemaName}`)
-  return `z.object({ ${entries.join(', ')} })`
-}
-
-/**
- * Convert a SchemaNode type to an inline Zod expression string.
- * Used as fallback when no named zod schema is available for a path parameter.
- */
-export function zodExprFromSchemaNode(schema: ast.SchemaNode): string {
-  const baseExpr = (() => {
-    if (schema.type === 'enum') {
-      const rawValues: Array<string | number | boolean> = schema.namedEnumValues?.length
-        ? schema.namedEnumValues.map((v) => v.value)
-        : (schema.enumValues ?? []).filter((v): v is string | number | boolean => v !== null)
-
-      if (rawValues.length > 0 && rawValues.every((v) => typeof v === 'string')) {
-        return `z.enum([${rawValues.map((v) => JSON.stringify(v)).join(', ')}])`
-      }
-      if (rawValues.length > 0) {
-        const literals = rawValues.map((v) => `z.literal(${JSON.stringify(v)})`)
-        return literals.length === 1 ? literals[0]! : `z.union([${literals.join(', ')}])`
-      }
-      return 'z.string()'
-    }
-    if (schema.type === 'integer') return 'z.coerce.number()'
-    if (schema.type === 'number') return 'z.number()'
-    if (schema.type === 'boolean') return 'z.boolean()'
-    if (schema.type === 'array') return 'z.array(z.unknown())'
-    return 'z.string()'
-  })()
-
-  return schema.nullable ? `${baseExpr}.nullable()` : baseExpr
-}