@kubb/plugin-mcp 5.0.0-alpha.9 → 5.0.0-beta.100

package/src/components/Server.tsx

@@ -1,174 +0,0 @@
-import { camelCase, isValidVarName } from '@internals/utils'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import type { SchemaObject } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { isOptional } from '@kubb/plugin-oas/utils'
-import { Const, File, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-
-type Props = {
-  name: string
-  serverName: string
-  serverVersion: string
-  paramsCasing?: 'camelcase'
-  operations: Array<{
-    tool: {
-      name: string
-      title?: string
-      description: string
-    }
-    mcp: {
-      name: string
-      file: KubbFile.File
-    }
-    zod: {
-      name: string
-      file: KubbFile.File
-      schemas: OperationSchemas
-    }
-    type: {
-      schemas: OperationSchemas
-    }
-  }>
-}
-
-type GetParamsProps = {
-  schemas: OperationSchemas
-  paramsCasing?: 'camelcase'
-}
-
-function zodExprFromOasSchema(schema: SchemaObject): string {
-  const types = Array.isArray(schema.type) ? schema.type : [schema.type]
-  const baseType = types.find((t) => t && t !== 'null')
-  const isNullableType = types.includes('null')
-
-  let expr: string
-  switch (baseType) {
-    case 'integer':
-      expr = 'z.coerce.number()'
-      break
-    case 'number':
-      expr = 'z.number()'
-      break
-    case 'boolean':
-      expr = 'z.boolean()'
-      break
-    case 'array':
-      expr = 'z.array(z.unknown())'
-      break
-    default:
-      expr = 'z.string()'
-  }
-
-  if (isNullableType) {
-    expr = `${expr}.nullable()`
-  }
-
-  return expr
-}
-
-function getParams({ schemas, paramsCasing }: GetParamsProps) {
-  const pathParamProperties = schemas.pathParams?.schema?.properties ?? {}
-  const requiredFields = Array.isArray(schemas.pathParams?.schema?.required) ? schemas.pathParams.schema.required : []
-
-  const pathParamEntries = Object.entries(pathParamProperties).reduce<Record<string, { value: string; optional: boolean }>>(
-    (acc, [originalKey, propSchema]) => {
-      const key = paramsCasing === 'camelcase' || !isValidVarName(originalKey) ? camelCase(originalKey) : originalKey
-      acc[key] = {
-        value: zodExprFromOasSchema(propSchema as SchemaObject),
-        optional: !requiredFields.includes(originalKey),
-      }
-      return acc
-    },
-    {},
-  )
-
-  return FunctionParams.factory({
-    data: {
-      mode: 'object',
-      children: {
-        ...pathParamEntries,
-        data: schemas.request?.name
-          ? {
-              value: schemas.request?.name,
-              optional: isOptional(schemas.request?.schema),
-            }
-          : undefined,
-        params: schemas.queryParams?.name
-          ? {
-              value: schemas.queryParams?.name,
-              optional: isOptional(schemas.queryParams?.schema),
-            }
-          : undefined,
-        headers: schemas.headerParams?.name
-          ? {
-              value: schemas.headerParams?.name,
-              optional: isOptional(schemas.headerParams?.schema),
-            }
-          : undefined,
-      },
-    },
-  })
-}
-
-export function Server({ name, serverName, serverVersion, paramsCasing, operations }: Props): FabricReactNode {
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Const name={'server'} export>
-        {`
-          new McpServer({
-  name: '${serverName}',
-  version: '${serverVersion}',
-})
-          `}
-      </Const>
-
-      {operations
-        .map(({ tool, mcp, zod }) => {
-          const paramsClient = getParams({ schemas: zod.schemas, paramsCasing })
-          const outputSchema = zod.schemas.response?.name
-
-          const config = [
-            tool.title ? `title: ${JSON.stringify(tool.title)}` : null,
-            `description: ${JSON.stringify(tool.description)}`,
-            outputSchema ? `outputSchema: { data: ${outputSchema} }` : null,
-          ]
-            .filter(Boolean)
-            .join(',\n  ')
-
-          if (zod.schemas.request?.name || zod.schemas.headerParams?.name || zod.schemas.queryParams?.name || zod.schemas.pathParams?.name) {
-            return `
-server.registerTool(${JSON.stringify(tool.name)}, {
-  ${config},
-  inputSchema: ${paramsClient.toObjectValue()},
-}, async (${paramsClient.toObject()}) => {
-  return ${mcp.name}(${paramsClient.toObject()})
-})
-          `
-          }
-
-          return `
-server.registerTool(${JSON.stringify(tool.name)}, {
-  ${config},
-}, async () => {
-  return ${mcp.name}(${paramsClient.toObject()})
-})
-          `
-        })
-        .filter(Boolean)}
-
-      {`
-export async function startServer() {
-  try {
-    const transport = new StdioServerTransport()
-    await server.connect(transport)
-
-  } catch (error) {
-    console.error('Failed to start server:', error)
-    process.exit(1)
-  }
-}
-`}
-    </File.Source>
-  )
-}

package/src/components/index.ts

@@ -1 +0,0 @@
-export { Server } from './Server.tsx'

package/src/generators/index.ts

@@ -1,2 +0,0 @@
-export { mcpGenerator } from './mcpGenerator.tsx'
-export { serverGenerator } from './serverGenerator.tsx'

package/src/generators/mcpGenerator.tsx

@@ -1,110 +0,0 @@
-import path from 'node:path'
-import { Client } from '@kubb/plugin-client/components'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { File } from '@kubb/react-fabric'
-import type { PluginMcp } from '../types'
-
-export const mcpGenerator = createReactGenerator<PluginMcp>({
-  name: 'mcp',
-  Operation({ config, operation, generator, plugin }) {
-    const { options } = plugin
-    const oas = useOas()
-
-    const { getSchemas, getName, getFile } = useOperationManager(generator)
-
-    const mcp = {
-      name: getName(operation, { type: 'function', suffix: 'handler' }),
-      file: getFile(operation),
-    }
-
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
-    }
-
-    return (
-      <File
-        baseName={mcp.file.baseName}
-        path={mcp.file.path}
-        meta={mcp.file.meta}
-        banner={getBanner({ oas, output: options.output })}
-        footer={getFooter({ oas, output: options.output })}
-      >
-        {options.client.importPath ? (
-          <>
-            <File.Import name={'fetch'} path={options.client.importPath} />
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={options.client.importPath} isTypeOnly />
-            {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
-          </>
-        ) : (
-          <>
-            <File.Import name={['fetch']} root={mcp.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
-            <File.Import
-              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={mcp.file.path}
-              path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
-              isTypeOnly
-            />
-            {options.client.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={mcp.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} isTypeOnly />
-            )}
-          </>
-        )}
-        <File.Import name={['buildFormData']} root={mcp.file.path} path={path.resolve(config.root, config.output.path, '.kubb/config.ts')} />
-        <File.Import name={['CallToolResult']} path={'@modelcontextprotocol/sdk/types'} isTypeOnly />
-        <File.Import
-          name={[
-            type.schemas.request?.name,
-            type.schemas.response.name,
-            type.schemas.pathParams?.name,
-            type.schemas.queryParams?.name,
-            type.schemas.headerParams?.name,
-            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
-          ].filter(Boolean)}
-          root={mcp.file.path}
-          path={type.file.path}
-          isTypeOnly
-        />
-
-        <Client
-          name={mcp.name}
-          isConfigurable={false}
-          returnType={'Promise<CallToolResult>'}
-          baseURL={options.client.baseURL}
-          operation={operation}
-          typeSchemas={type.schemas}
-          zodSchemas={undefined}
-          dataReturnType={options.client.dataReturnType || 'data'}
-          paramsType={'object'}
-          paramsCasing={options.client?.paramsCasing || options.paramsCasing}
-          pathParamsType={'object'}
-          parser={'client'}
-        >
-          {options.client.dataReturnType === 'data' &&
-            `return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(res.data)
-              }
-            ],
-            structuredContent: { data: res.data }
-           }`}
-          {options.client.dataReturnType === 'full' &&
-            `return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(res)
-              }
-            ],
-            structuredContent: { data: res.data }
-           }`}
-        </Client>
-      </File>
-    )
-  },
-})

package/src/generators/serverGenerator.tsx

@@ -1,112 +0,0 @@
-import { usePluginDriver } from '@kubb/core/hooks'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/react-fabric'
-import { Server } from '../components/Server'
-import type { PluginMcp } from '../types'
-
-export const serverGenerator = createReactGenerator<PluginMcp>({
-  name: 'operations',
-  Operations({ operations, generator, plugin }) {
-    const driver = usePluginDriver()
-    const { options } = plugin
-
-    const oas = useOas()
-    const { getFile, getName, getSchemas } = useOperationManager(generator)
-
-    const name = 'server'
-    const file = driver.getFile({ name, extname: '.ts', pluginName: plugin.name })
-
-    const jsonFile = driver.getFile({ name: '.mcp', extname: '.json', pluginName: plugin.name })
-
-    const operationsMapped = operations.map((operation) => {
-      return {
-        tool: {
-          name: operation.getOperationId() || operation.getSummary() || `${operation.method.toUpperCase()} ${operation.path}`,
-          title: operation.getSummary() || undefined,
-          description: operation.getDescription() || `Make a ${operation.method.toUpperCase()} request to ${operation.path}`,
-        },
-        mcp: {
-          name: getName(operation, {
-            type: 'function',
-            suffix: 'handler',
-          }),
-          file: getFile(operation),
-        },
-        zod: {
-          name: getName(operation, {
-            type: 'function',
-            pluginName: pluginZodName,
-          }),
-          schemas: getSchemas(operation, { pluginName: pluginZodName, type: 'function' }),
-          file: getFile(operation, { pluginName: pluginZodName }),
-        },
-        type: {
-          schemas: getSchemas(operation, { pluginName: 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,
-            zod.schemas.response?.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: driver.config })}
-          footer={getFooter({ oas, output: options.output })}
-        >
-          <File.Import name={['McpServer']} path={'@modelcontextprotocol/sdk/server/mcp'} />
-          <File.Import name={['z']} path={'zod'} />
-          <File.Import name={['StdioServerTransport']} path={'@modelcontextprotocol/sdk/server/stdio'} />
-
-          {imports}
-          <Server
-            name={name}
-            serverName={oas.api.info?.title}
-            serverVersion={oas.getVersion()}
-            paramsCasing={options.paramsCasing}
-            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

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

package/src/plugin.ts

@@ -1,170 +0,0 @@
-import path from 'node:path'
-import { camelCase } from '@internals/utils'
-import { createPlugin, type Group, getBarrelFiles, getMode } 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 { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { mcpGenerator, serverGenerator } from './generators'
-import type { PluginMcp } from './types.ts'
-
-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,
-    paramsCasing,
-    client,
-  } = options
-
-  const clientName = client?.client ?? 'axios'
-  const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : undefined)
-
-  return {
-    name: pluginMcpName,
-    options: {
-      output,
-      group,
-      paramsCasing,
-      client: {
-        client: clientName,
-        clientType: client?.clientType ?? 'function',
-        importPath: clientImportPath,
-        dataReturnType: client?.dataReturnType ?? 'data',
-        bundle: client?.bundle,
-        baseURL: client?.baseURL,
-        paramsCasing: client?.paramsCasing,
-      },
-    },
-    pre: [pluginOasName, pluginTsName, pluginZodName].filter(Boolean),
-    resolvePath(baseName, pathMode, options) {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = pathMode ?? 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 install() {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = getMode(path.resolve(root, output.path))
-      const oas = await this.getOas()
-      const baseURL = await this.getBaseURL()
-
-      if (baseURL) {
-        this.plugin.options.client.baseURL = baseURL
-      }
-
-      const hasClientPlugin = !!this.driver.getPluginByName(pluginClientName)
-
-      if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) {
-        // pre add bundled fetch
-        await this.addFile({
-          baseName: 'fetch.ts',
-          path: path.resolve(root, '.kubb/fetch.ts'),
-          sources: [
-            {
-              name: 'fetch',
-              value: this.plugin.options.client.client === 'fetch' ? fetchClientSource : axiosClientSource,
-              isExportable: true,
-              isIndexable: true,
-            },
-          ],
-          imports: [],
-          exports: [],
-        })
-      }
-
-      if (!hasClientPlugin) {
-        await this.addFile({
-          baseName: 'config.ts',
-          path: path.resolve(root, '.kubb/config.ts'),
-          sources: [
-            {
-              name: 'config',
-              value: configSource,
-              isExportable: false,
-              isIndexable: false,
-            },
-          ],
-          imports: [],
-          exports: [],
-        })
-      }
-
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        exclude,
-        include,
-        override,
-        mode,
-      })
-
-      const files = await operationGenerator.build(...generators)
-      await this.upsertFile(...files)
-
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
-    },
-  }
-})

package/src/types.ts

@@ -1,62 +0,0 @@
-import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-
-import type { contentType, Oas } from '@kubb/oas'
-import type { ClientImportPath, PluginClient } from '@kubb/plugin-client'
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
-import type { Generator } from '@kubb/plugin-oas/generators'
-
-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 is used
-   */
-  contentType?: contentType
-  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>
-  /**
-   * Transform parameter names to a specific casing format.
-   * When set to 'camelcase', parameter names in path, query, and header params will be transformed to camelCase.
-   * This should match the paramsCasing setting used in @kubb/plugin-ts.
-   * @default undefined
-   */
-  paramsCasing?: 'camelcase'
-  /**
-   * 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: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>
-  paramsCasing: Options['paramsCasing']
-}
-
-export type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, never, ResolvePathOptions>