@kubb/plugin-mcp 0.0.0-canary-20250414193247

package/src/generators/serverGenerator.tsx

@@ -0,0 +1,93 @@
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
+import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
+import { File, useApp } from '@kubb/react'
+import { Server } from '../components/Server'
+import type { PluginMcp } from '../types'
+import { pluginZodName } from '@kubb/plugin-zod'
+import { pluginTsName } from '@kubb/plugin-ts'
+
+export const serverGenerator = createReactGenerator<PluginMcp>({
+  name: 'operations',
+  Operations({ operations, options }) {
+    const { pluginManager, plugin } = useApp<PluginMcp>()
+    const oas = useOas()
+    const { getFile, getName, getSchemas } = useOperationManager()
+
+    const name = 'server'
+    const file = pluginManager.getFile({ name, extname: '.ts', pluginKey: plugin.key })
+
+    const jsonFile = pluginManager.getFile({ name: '.mcp', extname: '.json', pluginKey: plugin.key })
+
+    const operationsMapped = operations.map((operation) => {
+      return {
+        operationId: operation.getOperationId(),
+        description: operation.getDescription(),
+        mcp: {
+          name: getName(operation, {
+            type: 'function',
+            suffix: 'handler',
+          }),
+          file: getFile(operation),
+        },
+        zod: {
+          name: getName(operation, {
+            type: 'function',
+            pluginKey: [pluginZodName],
+          }),
+          schemas: getSchemas(operation, { pluginKey: [pluginZodName], type: 'function' }),
+          file: getFile(operation, { pluginKey: [pluginZodName] }),
+        },
+        type: {
+          schemas: getSchemas(operation, { pluginKey: [pluginTsName], type: 'type' }),
+        },
+      }
+    })
+
+    const imports = operationsMapped.flatMap(({ mcp, zod }) => {
+      return [
+        <File.Import key={mcp.name} name={[mcp.name]} root={file.path} path={mcp.file.path} />,
+        <File.Import
+          key={zod.name}
+          name={[zod.schemas.request?.name, zod.schemas.pathParams?.name, zod.schemas.queryParams?.name, zod.schemas.headerParams?.name].filter(Boolean)}
+          root={file.path}
+          path={zod.file.path}
+        />,
+      ]
+    })
+
+    return (
+      <>
+        <File
+          baseName={file.baseName}
+          path={file.path}
+          meta={file.meta}
+          banner={getBanner({ oas, output: options.output, config: pluginManager.config })}
+          footer={getFooter({ oas, output: options.output })}
+        >
+          <File.Import name={['McpServer']} path={'@modelcontextprotocol/sdk/server/mcp'} />
+          <File.Import name={['StdioServerTransport']} path={'@modelcontextprotocol/sdk/server/stdio'} />
+
+          {imports}
+          <Server name={name} serverName={oas.api.info?.title} serverVersion={oas.getVersion()} operations={operationsMapped} />
+        </File>
+
+        <File baseName={jsonFile.baseName} path={jsonFile.path} meta={jsonFile.meta}>
+          <File.Source name={name}>
+            {`
+          {
+            "mcpServers": {
+              "${oas.api.info?.title || 'server'}": {
+                "type": "stdio",
+                "command": "npx",
+                "args": ["tsx", "${file.path}"]
+              }
+            }
+          }
+          `}
+          </File.Source>
+        </File>
+      </>
+    )
+  },
+})

package/src/index.ts

@@ -0,0 +1,2 @@
+export { pluginMcp, pluginMcpName } from './plugin.ts'
+export type { PluginMcp } from './types.ts'

package/src/plugin.ts

@@ -0,0 +1,120 @@
+import path from 'node:path'
+
+import { FileManager, type Group, PluginManager, createPlugin } from '@kubb/core'
+import { camelCase } from '@kubb/core/transformers'
+import { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
+import { pluginTsName } from '@kubb/plugin-ts'
+
+import type { Plugin } from '@kubb/core'
+import type { PluginOas as SwaggerPluginOptions } from '@kubb/plugin-oas'
+import { mcpGenerator, serverGenerator } from './generators'
+import type { PluginMcp } from './types.ts'
+import { pluginZodName } from '@kubb/plugin-zod'
+
+export const pluginMcpName = 'plugin-mcp' satisfies PluginMcp['name']
+
+export const pluginMcp = createPlugin<PluginMcp>((options) => {
+  const {
+    output = { path: 'mcp', barrelType: 'named' },
+    group,
+    exclude = [],
+    include,
+    override = [],
+    transformers = {},
+    generators = [mcpGenerator, serverGenerator].filter(Boolean),
+    contentType,
+  } = options
+
+  return {
+    name: pluginMcpName,
+    options: {
+      output,
+      group,
+      client: {
+        importPath: '@kubb/plugin-client/clients/axios',
+        dataReturnType: 'data',
+        ...options.client,
+      },
+    },
+    pre: [pluginOasName, pluginTsName, pluginZodName].filter(Boolean),
+    resolvePath(baseName, pathMode, options) {
+      const root = path.resolve(this.config.root, this.config.output.path)
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
+
+      if (mode === 'single') {
+        /**
+         * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
+         * Other plugins then need to call addOrAppend instead of just add from the fileManager class
+         */
+        return path.resolve(root, output.path)
+      }
+
+      if (group && (options?.group?.path || options?.group?.tag)) {
+        const groupName: Group['name'] = group?.name
+          ? group.name
+          : (ctx) => {
+              if (group?.type === 'path') {
+                return `${ctx.group.split('/')[1]}`
+              }
+              return `${camelCase(ctx.group)}Requests`
+            }
+
+        return path.resolve(
+          root,
+          output.path,
+          groupName({
+            group: group.type === 'path' ? options.group.path! : options.group.tag!,
+          }),
+          baseName,
+        )
+      }
+
+      return path.resolve(root, output.path, baseName)
+    },
+    resolveName(name, type) {
+      const resolvedName = camelCase(name, {
+        isFile: type === 'file',
+      })
+
+      if (type) {
+        return transformers?.name?.(resolvedName, type) || resolvedName
+      }
+
+      return resolvedName
+    },
+    async buildStart() {
+      const [swaggerPlugin]: [Plugin<SwaggerPluginOptions>] = PluginManager.getDependedPlugins<SwaggerPluginOptions>(this.plugins, [pluginOasName])
+
+      const oas = await swaggerPlugin.context.getOas()
+      const root = path.resolve(this.config.root, this.config.output.path)
+      const mode = FileManager.getMode(path.resolve(root, output.path))
+
+      const operationGenerator = new OperationGenerator(this.plugin.options, {
+        oas,
+        pluginManager: this.pluginManager,
+        plugin: this.plugin,
+        contentType,
+        exclude,
+        include,
+        override,
+        mode,
+      })
+
+      const files = await operationGenerator.build(...generators)
+      await this.addFile(...files)
+
+      const barrelFiles = await this.fileManager.getBarrelFiles({
+        type: output.barrelType ?? 'named',
+        root,
+        output,
+        files: this.fileManager.files,
+        meta: {
+          pluginKey: this.plugin.key,
+        },
+        logger: this.logger,
+      })
+
+      await this.addFile(...barrelFiles)
+    },
+  }
+})

package/src/types.ts

@@ -0,0 +1,54 @@
+import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+
+import type { Oas, contentType } from '@kubb/oas'
+import type { Exclude, Include, Override, ResolvePathOptions, Generator } from '@kubb/plugin-oas'
+import type { PluginClient } from '@kubb/plugin-client'
+
+export type Options = {
+  /**
+   * Specify the export location for the files and define the behavior of the output
+   * @default { path: 'mcp', barrelType: 'named' }
+   */
+  output?: Output<Oas>
+  /**
+   * Define which contentType should be used.
+   * By default, the first JSON valid mediaType will be used
+   */
+  contentType?: contentType
+  client?: Pick<PluginClient['options'], 'dataReturnType' | 'importPath' | 'baseURL'>
+
+  /**
+   * Group the mcp requests based on the provided name.
+   */
+  group?: Group
+  /**
+   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+   */
+  exclude?: Array<Exclude>
+  /**
+   * Array containing include parameters to include tags/operations/methods/paths.
+   */
+  include?: Array<Include>
+  /**
+   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+   */
+  override?: Array<Override<ResolvedOptions>>
+  transformers?: {
+    /**
+     * Customize the names based on the type that is provided by the plugin.
+     */
+    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
+  }
+  /**
+   * Define some generators next to the Mcp generators.
+   */
+  generators?: Array<Generator<PluginMcp>>
+}
+
+type ResolvedOptions = {
+  output: Output<Oas>
+  group: Options['group']
+  client: Required<Omit<NonNullable<PluginMcp['options']['client']>, 'baseURL'>> & { baseURL?: string }
+}
+
+export type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, never, ResolvePathOptions>