@kubb/plugin-mcp 5.0.0-alpha.29 → 5.0.0-alpha.30

package/src/generators/serverGeneratorLegacy.tsx

@@ -1,7 +1,6 @@
 import path from 'node:path'
-import { caseParams, transform } from '@kubb/ast'
+import { caseParams } from '@kubb/ast'
 import { defineGenerator } from '@kubb/core'
-import type { PluginZod } from '@kubb/plugin-zod'
 import { pluginZodName } from '@kubb/plugin-zod'
 import { File } from '@kubb/react-fabric'
 import { Server } from '../components/Server.tsx'
@@ -16,12 +15,11 @@ import type { PluginMcp } from '../types.ts'
  */
 export const serverGeneratorLegacy = defineGenerator<PluginMcp>({
   name: 'operations',
-  type: 'react',
-  Operations({ nodes, adapter, options, config, driver, resolver, plugin }) {
+  operations(nodes, options) {
+    const { adapter, config, resolver, plugin, driver, root } = this
     const { output, paramsCasing, group } = options
-    const root = path.resolve(config.root, config.output.path)
 
-    const pluginZod = driver.getPlugin<PluginZod>(pluginZodName)
+    const pluginZod = driver.getPlugin(pluginZodName)
 
     if (!pluginZod?.resolver) {
       return
@@ -43,18 +41,14 @@ export const serverGeneratorLegacy = defineGenerator<PluginMcp>({
     }
 
     const operationsMapped = nodes.map((node) => {
-      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
-      const casedParams = caseParams(transformedNode.parameters, paramsCasing)
+      const casedParams = caseParams(node.parameters, paramsCasing)
       const queryParams = casedParams.filter((p) => p.in === 'query')
       const headerParams = casedParams.filter((p) => p.in === 'header')
 
-      const mcpFile = resolver.resolveFile(
-        { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
-        { root, output, group },
-      )
+      const mcpFile = resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group })
 
       const zodFile = pluginZod?.resolver.resolveFile(
-        { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
         {
           root,
           output: pluginZod?.options?.output ?? output,
@@ -62,21 +56,21 @@ export const serverGeneratorLegacy = defineGenerator<PluginMcp>({
         },
       )
 
-      const requestName = transformedNode.requestBody?.schema ? pluginZod?.resolver.resolveDataName(transformedNode) : undefined
-      const responseName = pluginZod?.resolver.resolveResponseName(transformedNode)
+      const requestName = node.requestBody?.schema ? pluginZod?.resolver.resolveDataName(node) : undefined
+      const responseName = pluginZod?.resolver.resolveResponseName(node)
 
-      const zodQueryParams = queryParams.length ? pluginZod?.resolver.resolveQueryParamsName(transformedNode, queryParams[0]!) : undefined
+      const zodQueryParams = queryParams.length ? pluginZod?.resolver.resolveQueryParamsName(node, queryParams[0]!) : undefined
 
-      const zodHeaderParams = headerParams.length ? pluginZod?.resolver.resolveHeaderParamsName(transformedNode, headerParams[0]!) : undefined
+      const zodHeaderParams = headerParams.length ? pluginZod?.resolver.resolveHeaderParamsName(node, headerParams[0]!) : undefined
 
       return {
         tool: {
-          name: transformedNode.operationId,
-          title: transformedNode.summary || undefined,
-          description: transformedNode.description || `Make a ${transformedNode.method.toUpperCase()} request to ${transformedNode.path}`,
+          name: node.operationId,
+          title: node.summary || undefined,
+          description: node.description || `Make a ${node.method.toUpperCase()} request to ${node.path}`,
         },
         mcp: {
-          name: resolver.resolveName(transformedNode.operationId),
+          name: resolver.resolveName(node.operationId),
           file: mcpFile,
         },
         zod: {
@@ -87,7 +81,7 @@ export const serverGeneratorLegacy = defineGenerator<PluginMcp>({
           responseName,
           file: zodFile,
         },
-        node: transformedNode,
+        node: node,
       }
     })
 

package/src/plugin.ts

@@ -1,14 +1,13 @@
 import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { walk } from '@kubb/ast'
-import type { OperationNode } from '@kubb/ast/types'
-import { createPlugin, type Group, getBarrelFiles, getPreset, runGeneratorOperation, runGeneratorOperations, runGeneratorSchema } from '@kubb/core'
-import { type PluginClient, pluginClientName } from '@kubb/plugin-client'
+import { createPlugin, type Group, getPreset, mergeGenerators } 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 type { PluginMcp } from './types.ts'
 
@@ -40,8 +39,12 @@ export const pluginMcp = createPlugin<PluginMcp>((options) => {
     generators: userGenerators,
   })
 
+  const generators = preset.generators ?? []
+  const mergedGenerator = mergeGenerators(generators)
+
   return {
     name: pluginMcpName,
+    version,
     get resolver() {
       return preset.resolver
     },
@@ -51,6 +54,9 @@ export const pluginMcp = createPlugin<PluginMcp>((options) => {
     get options() {
       return {
         output,
+        exclude,
+        include,
+        override,
         group: group
           ? ({
               ...group,
@@ -78,21 +84,25 @@ export const pluginMcp = createPlugin<PluginMcp>((options) => {
       }
     },
     pre: [pluginTsName, pluginZodName].filter(Boolean),
-    async install() {
-      const { config, fabric, plugin, adapter, rootNode, driver } = this
-      const root = path.resolve(config.root, config.output.path)
-      const resolver = preset.resolver
-
-      if (!adapter) {
-        throw new Error('Plugin cannot work without adapter being set')
-      }
+    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
 
-      const baseURL = adapter.rootNode?.meta?.baseURL
+      const baseURL = adapter?.rootNode?.meta?.baseURL
       if (baseURL) {
         this.plugin.options.client.baseURL = this.plugin.options.client.baseURL || baseURL
       }
 
-      const hasClientPlugin = !!driver.getPlugin<PluginClient>(pluginClientName)
+      const hasClientPlugin = !!driver.getPlugin(pluginClientName)
 
       if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) {
         await this.addFile({
@@ -128,37 +138,7 @@ export const pluginMcp = createPlugin<PluginMcp>((options) => {
         })
       }
 
-      const collectedOperations: Array<OperationNode> = []
-      const generatorContext = { generators: preset.generators, plugin, resolver, exclude, include, override, fabric, adapter, config, driver }
-
-      await walk(rootNode, {
-        depth: 'shallow',
-        async schema(schemaNode) {
-          await runGeneratorSchema(schemaNode, generatorContext)
-        },
-        async operation(operationNode) {
-          const baseOptions = resolver.resolveOptions(operationNode, { options: plugin.options, exclude, include, override })
-
-          if (baseOptions !== null) {
-            collectedOperations.push(operationNode)
-          }
-
-          await runGeneratorOperation(operationNode, generatorContext)
-        },
-      })
-
-      await runGeneratorOperations(collectedOperations, generatorContext)
-
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
+      await this.openInStudio({ ast: true })
     },
   }
 })

package/src/types.ts

@@ -83,6 +83,9 @@ export type Options = {
 
 type ResolvedOptions = {
   output: Output
+  exclude: Array<Exclude>
+  include: Array<Include> | undefined
+  override: Array<Override<ResolvedOptions>>
   group: Group | undefined
   client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>
   paramsCasing: Options['paramsCasing']
@@ -90,3 +93,11 @@ type ResolvedOptions = {
 }
 
 export type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, never, ResolvePathOptions, ResolverMcp>
+
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-mcp': PluginMcp
+    }
+  }
+}