@kubb/plugin-mcp 5.0.0-alpha.33 → 5.0.0-alpha.35

package/src/plugin.ts

@@ -1,20 +1,22 @@
 import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { createFile, createSource, createText } from '@kubb/ast'
-import { createPlugin, type Group, getPreset, mergeGenerators } from '@kubb/core'
+
+import { ast, definePlugin, type Group } 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 { version } from '../package.json'
-import { presets } from './presets.ts'
+import { mcpGenerator } from './generators/mcpGenerator.tsx'
+import { serverGenerator } from './generators/serverGenerator.tsx'
+import { serverGeneratorLegacy } from './generators/serverGeneratorLegacy.tsx'
+import { resolverMcp } from './resolvers/resolverMcp.ts'
 import type { PluginMcp } from './types.ts'
 
 export const pluginMcpName = 'plugin-mcp' satisfies PluginMcp['name']
 
-export const pluginMcp = createPlugin<PluginMcp>((options) => {
+export const pluginMcp = definePlugin<PluginMcp>((options) => {
   const {
     output = { path: 'mcp', barrelType: 'named' },
     group,
@@ -23,127 +25,100 @@ export const pluginMcp = createPlugin<PluginMcp>((options) => {
     override = [],
     paramsCasing,
     client,
-    compatibilityPreset = 'default',
     resolver: userResolver,
     transformer: userTransformer,
     generators: userGenerators = [],
+    compatibilityPreset = 'default',
   } = options
 
+  const defaultServerGenerator = compatibilityPreset === 'kubbV4' ? serverGeneratorLegacy : serverGenerator
+
   const clientName = client?.client ?? 'axios'
   const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : undefined)
 
-  const preset = getPreset({
-    preset: compatibilityPreset,
-    presets,
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators,
-  })
-
-  const generators = preset.generators ?? []
-  const mergedGenerator = mergeGenerators(generators)
+  const groupConfig = group
+    ? ({
+        ...group,
+        name: group.name
+          ? group.name
+          : (ctx: { group: string }) => {
+              if (group.type === 'path') {
+                return `${ctx.group.split('/')[1]}`
+              }
+              return `${camelCase(ctx.group)}Requests`
+            },
+      } satisfies Group)
+    : undefined
 
   return {
     name: pluginMcpName,
-    version,
-    get resolver() {
-      return preset.resolver
-    },
-    get transformer() {
-      return preset.transformer
-    },
-    get options() {
-      return {
-        output,
-        exclude,
-        include,
-        override,
-        group: group
-          ? ({
-              ...group,
-              name: group.name
-                ? group.name
-                : (ctx: { group: string }) => {
-                    if (group.type === 'path') {
-                      return `${ctx.group.split('/')[1]}`
-                    }
-                    return `${camelCase(ctx.group)}Requests`
-                  },
-            } satisfies Group)
-          : undefined,
-        paramsCasing,
-        client: {
-          client: clientName,
-          clientType: client?.clientType ?? 'function',
-          importPath: clientImportPath,
-          dataReturnType: client?.dataReturnType ?? 'data',
-          bundle: client?.bundle,
-          baseURL: client?.baseURL,
-          paramsCasing: client?.paramsCasing,
-        },
-        resolver: preset.resolver,
-      }
-    },
-    pre: [pluginTsName, pluginZodName].filter(Boolean),
-    async schema(node, options) {
-      return mergedGenerator.schema?.call(this, node, options)
-    },
-    async operation(node, options) {
-      return mergedGenerator.operation?.call(this, node, options)
-    },
-    async operations(nodes, options) {
-      return mergedGenerator.operations?.call(this, nodes, options)
-    },
-    async buildStart() {
-      const { adapter, driver } = this
-      const root = this.root
+    options,
+    dependencies: [pluginTsName, pluginZodName],
+    hooks: {
+      'kubb:plugin:setup'(ctx) {
+        const resolver = userResolver ? { ...resolverMcp, ...userResolver } : resolverMcp
 
-      const baseURL = adapter?.inputNode?.meta?.baseURL
-      if (baseURL) {
-        this.plugin.options.client.baseURL = this.plugin.options.client.baseURL || baseURL
-      }
+        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(defaultServerGenerator)
+        for (const gen of userGenerators) {
+          ctx.addGenerator(gen)
+        }
 
-      const hasClientPlugin = !!driver.getPlugin(pluginClientName)
+        const root = path.resolve(ctx.config.root, ctx.config.output.path)
+        const hasClientPlugin = ctx.config.plugins?.some((p) => p.name === pluginClientName)
 
-      if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) {
-        await this.addFile(
-          createFile({
+        if (client?.bundle && !hasClientPlugin && !clientImportPath) {
+          ctx.injectFile({
             baseName: 'fetch.ts',
             path: path.resolve(root, '.kubb/fetch.ts'),
             sources: [
-              createSource({
+              ast.createSource({
                 name: 'fetch',
-                nodes: [createText(this.plugin.options.client.client === 'fetch' ? fetchClientSource : axiosClientSource)],
+                nodes: [ast.createText(clientName === 'fetch' ? fetchClientSource : axiosClientSource)],
                 isExportable: true,
                 isIndexable: true,
               }),
             ],
-            imports: [],
-            exports: [],
-          }),
-        )
-      }
+          })
+        }
 
-      if (!hasClientPlugin) {
-        await this.addFile(
-          createFile({
+        if (!hasClientPlugin) {
+          ctx.injectFile({
             baseName: 'config.ts',
             path: path.resolve(root, '.kubb/config.ts'),
             sources: [
-              createSource({
+              ast.createSource({
                 name: 'config',
-                nodes: [createText(configSource)],
+                nodes: [ast.createText(configSource)],
                 isExportable: false,
                 isIndexable: false,
               }),
             ],
-            imports: [],
-            exports: [],
-          }),
-        )
-      }
-
-      await this.openInStudio({ ast: true })
+          })
+        }
+      },
     },
   }
 })

package/src/types.ts

@@ -1,5 +1,5 @@
-import type { Visitor } from '@kubb/ast/types'
 import type {
+  ast,
   CompatibilityPreset,
   Exclude,
   Generator,
@@ -74,7 +74,7 @@ export type Options = {
    * A single AST visitor applied before printing.
    * When a visitor method returns `null` or `undefined`, the preset transformer's result is used instead.
    */
-  transformer?: Visitor
+  transformer?: ast.Visitor
   /**
    * Define some generators next to the default MCP generators.
    */

package/src/utils.ts

@@ -1,14 +1,14 @@
 import { camelCase } from '@internals/utils'
-import type { OperationNode, SchemaNode, StatusCode } from '@kubb/ast/types'
+import type { ast } from '@kubb/core'
 
 /**
  * Find the first 2xx response status code from an operation's responses.
  */
-export function findSuccessStatusCode(responses: Array<{ statusCode: number | string }>): StatusCode | undefined {
+export function findSuccessStatusCode(responses: Array<{ statusCode: number | string }>): ast.StatusCode | undefined {
   for (const res of responses) {
     const code = Number(res.statusCode)
     if (code >= 200 && code < 300) {
-      return res.statusCode as StatusCode
+      return res.statusCode as ast.StatusCode
     }
   }
   return undefined
@@ -34,7 +34,7 @@ export function zodGroupExpr(entry: string | Array<ZodParam>): string {
 /**
  * Build JSDoc comment lines from an OperationNode.
  */
-export function getComments(node: OperationNode): Array<string> {
+export function getComments(node: ast.OperationNode): Array<string> {
   return [
     node.description && `@description ${node.description}`,
     node.summary && `@summary ${node.summary}`,
@@ -70,9 +70,25 @@ export function getParamsMapping(params: Array<{ name: string }>): Record<string
  * 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: SchemaNode): string {
+export function zodExprFromSchemaNode(schema: ast.SchemaNode): string {
   let expr: string
   switch (schema.type) {
+    case 'enum': {
+      // namedEnumValues takes priority over enumValues
+      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')) {
+        expr = `z.enum([${rawValues.map((v) => JSON.stringify(v)).join(', ')}])`
+      } else if (rawValues.length > 0) {
+        const literals = rawValues.map((v) => `z.literal(${JSON.stringify(v)})`)
+        expr = literals.length === 1 ? literals[0]! : `z.union([${literals.join(', ')}])`
+      } else {
+        expr = 'z.string()'
+      }
+      break
+    }
     case 'integer':
       expr = 'z.coerce.number()'
       break

package/src/presets.ts

@@ -1,25 +0,0 @@
-import { definePresets } from '@kubb/core'
-import { mcpGenerator } from './generators/mcpGenerator.tsx'
-import { serverGenerator } from './generators/serverGenerator.tsx'
-import { serverGeneratorLegacy } from './generators/serverGeneratorLegacy.tsx'
-import { resolverMcp } from './resolvers/resolverMcp.ts'
-import type { ResolverMcp } from './types.ts'
-
-/**
- * Built-in preset registry for `@kubb/plugin-mcp`.
- *
- * - `default` — v5 naming with individual zod schemas and per-status responses.
- * - `kubbV4`  — legacy naming with grouped zod schemas and combined responses.
- */
-export const presets = definePresets<ResolverMcp>({
-  default: {
-    name: 'default',
-    resolver: resolverMcp,
-    generators: [mcpGenerator, serverGenerator],
-  },
-  kubbV4: {
-    name: 'kubbV4',
-    resolver: resolverMcp,
-    generators: [mcpGenerator, serverGeneratorLegacy],
-  },
-})