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

package/dist/index.js

@@ -1,8 +1,9 @@
 import "./chunk-C0LytTxp.js";
 import path from "node:path";
 import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
+import { caseParams, createOperationParams } from "@kubb/ast/utils";
 import { functionPrinter, pluginTsName } from "@kubb/plugin-ts";
-import { Const, File, Function, jsxRendererSync } from "@kubb/renderer-jsx";
+import { Const, File, Function, jsxRenderer } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 import { pluginZodName } from "@kubb/plugin-zod";
 import { pluginClientName } from "@kubb/plugin-client";
@@ -20,36 +21,45 @@ import { source as source$2 } from "@kubb/plugin-client/templates/config.source"
 function toCamelOrPascal(text, pascal) {
 	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
 		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
 *
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
+//#endregion
+//#region ../../internals/utils/src/fs.ts
 /**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
 *
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
 }
 //#endregion
 //#region ../../internals/utils/src/reserved.ts
@@ -155,99 +165,80 @@ function isValidVarName(name) {
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
 //#endregion
-//#region ../../internals/utils/src/urlPath.ts
+//#region ../../internals/utils/src/url.ts
+function transformParam(raw, casing) {
+	const param = isValidVarName(raw) ? raw : camelCase(raw);
+	return casing === "camelcase" ? camelCase(param) : param;
+}
+function toParamsObject(path, { replacer, casing } = {}) {
+	const params = {};
+	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
+		const param = transformParam(match[1], casing);
+		const key = replacer ? replacer(param) : param;
+		params[key] = key;
+	}
+	return Object.keys(params).length > 0 ? params : null;
+}
 /**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
-*
-* @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
+* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
 */
-var URLPath = class {
+var Url = class Url {
 	/**
-	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-	*/
-	path;
-	#options;
-	constructor(path, options = {}) {
-		this.path = path;
-		this.#options = options;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
-	* ```
+	* Url.canParse('https://petstore.swagger.io/v2') // true
+	* Url.canParse('/pet/{petId}')                   // false
 	*/
-	get URL() {
-		return this.toURLPath();
+	static canParse(url, base) {
+		return URL.canParse(url, base);
 	}
-	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+	/**
+	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
 	*
 	* @example
-	* ```ts
-	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-	* new URLPath('/pet/{petId}').isURL                       // false
-	* ```
+	* Url.toPath('/pet/{petId}') // '/pet/:petId'
 	*/
-	get isURL() {
-		try {
-			return !!new URL(this.path).href;
-		} catch {
-			return false;
-		}
+	static toPath(path) {
+		return path.replace(/\{([^}]+)\}/g, ":$1");
 	}
 	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
+	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
+	* `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
+	* and `casing` controls parameter identifier casing.
 	*
 	* @example
-	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-	*/
-	get template() {
-		return this.toTemplateString();
-	}
-	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').object
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	* ```
+	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
 	*/
-	get object() {
-		return this.toObject();
+	static toTemplateString(path, { prefix, replacer, casing } = {}) {
+		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = transformParam(part, casing);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
 	}
-	/** Returns a map of path parameter names, or `null` when the path has no parameters.
+	/**
+	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
+	* expression when `stringify` is set.
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // null
-	* ```
-	*/
-	get params() {
-		return this.toParamsObject();
-	}
-	#transformParam(raw) {
-		const param = isValidVarName(raw) ? raw : camelCase(raw);
-		return this.#options.casing === "camelcase" ? camelCase(param) : param;
-	}
-	/**
-	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+	* Url.toObject('/pet/{petId}')
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
 	*/
-	#eachParam(fn) {
-		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-			const raw = match[1];
-			fn(raw, this.#transformParam(raw));
-		}
-	}
-	toObject({ type = "path", replacer, stringify } = {}) {
+	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
 		const object = {
-			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.toParamsObject()
+			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, {
+				replacer,
+				casing
+			}),
+			params: toParamsObject(path, {
+				replacer,
+				casing
+			})
 		};
 		if (stringify) {
 			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
@@ -256,57 +247,13 @@ var URLPath = class {
 		}
 		return object;
 	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	* An optional `replacer` can transform each extracted parameter name before interpolation.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-	*/
-	toTemplateString({ prefix, replacer } = {}) {
-		const result = this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("");
-		return `\`${prefix ?? ""}${result}\``;
-	}
-	/**
-	* Extracts all `{param}` segments from the path and returns them as a key-value map.
-	* An optional `replacer` transforms each parameter name in both key and value positions.
-	* Returns `undefined` when no path parameters are found.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').toParamsObject()
-	* // { petId: 'petId', tagId: 'tagId' }
-	* ```
-	*/
-	toParamsObject(replacer) {
-		const params = {};
-		this.#eachParam((_raw, param) => {
-			const key = replacer ? replacer(param) : param;
-			params[key] = key;
-		});
-		return Object.keys(params).length > 0 ? params : null;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-	* ```
-	*/
-	toURLPath() {
-		return this.path.replace(/\{([^}]+)\}/g, ":$1");
-	}
 };
 //#endregion
 //#region ../../internals/shared/src/operation.ts
 function getOperationLink(node, link) {
 	if (!link) return null;
 	if (typeof link === "function") return link(node) ?? null;
-	if (link === "urlPath") return node.path ? `{@link ${new URLPath(node.path).URL}}` : null;
+	if (link === "urlPath") return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
 	return node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : null;
 }
 function buildOperationComments(node, options = {}) {
@@ -327,7 +274,7 @@ function buildOperationComments(node, options = {}) {
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
 function getOperationParameters(node, options = {}) {
-	const params = ast.caseParams(node.parameters, options.paramsCasing);
+	const params = caseParams(node.parameters, options.paramsCasing);
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -396,26 +343,24 @@ function findSuccessStatusCode(responses) {
 * shared default naming so every plugin groups output consistently:
 *
 * - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
-* - other groups use `${camelCase(group)}${suffix}` (e.g. `petController`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
 *
 * A user-provided `group.name` always wins over the default namer, so callers stay in
 * control of their output folders. Returns `null` when grouping is disabled, matching the
 * per-plugin convention.
 *
 * @param group - The user-supplied group option, or `undefined` to disable grouping.
-* @param options.suffix - Appended to non-`path` group names, e.g. `'Controller'` or `'Requests'`.
 *
 * @example
 * ```ts
-* createGroupConfig(group, { suffix: 'Controller' }) // plugin-ts, plugin-client, …
-* createGroupConfig(group, { suffix: 'Requests' })   // plugin-cypress, plugin-mcp
+* createGroupConfig(group) // shared across every plugin
 * ```
 */
-function createGroupConfig(group, options) {
+function createGroupConfig(group) {
 	if (!group) return null;
 	const defaultName = (ctx) => {
 		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return `${camelCase(ctx.group)}${options.suffix}`;
+		return camelCase(ctx.group);
 	};
 	return {
 		...group,
@@ -452,7 +397,6 @@ function buildRemappingCode(mapping, varName, sourceName) {
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasing }) {
 	if (!ast.isHttpOperationNode(node)) return null;
-	const urlPath = new URLPath(node.path);
 	const contentType = node.requestBody?.content?.[0]?.contentType;
 	const isFormData = contentType === "multipart/form-data";
 	const { query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing });
@@ -465,7 +409,7 @@ function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasin
 		`ResponseErrorConfig<${errorResponses.length > 0 ? errorResponses.join(" | ") : "Error"}>`,
 		requestName || "unknown"
 	].filter(Boolean);
-	const paramsNode = ast.createOperationParams(node, {
+	const paramsNode = createOperationParams(node, {
 		paramsType: "object",
 		pathParamsType: "inline",
 		resolver,
@@ -480,28 +424,20 @@ function McpHandler({ name, node, resolver, baseURL, dataReturnType, paramsCasin
 	const headers = [headerParams.length ? headerParamsMapping ? "...mappedHeaders" : "...headers" : null, contentTypeHeader].filter(Boolean);
 	const fetchConfig = [];
 	fetchConfig.push(`method: ${JSON.stringify(node.method.toUpperCase())}`);
-	fetchConfig.push(`url: ${urlPath.template}`);
+	fetchConfig.push(`url: ${Url.toTemplateString(node.path)}`);
 	if (baseURL) fetchConfig.push(`baseURL: \`${baseURL}\``);
 	if (queryParams.length) fetchConfig.push(queryParamsMapping ? "params: mappedParams" : "params");
 	if (requestName) fetchConfig.push(`data: ${isFormData ? "formData as FormData" : "requestData"}`);
 	if (headers.length) fetchConfig.push(`headers: { ${headers.join(", ")} }`);
-	const callToolResult = dataReturnType === "data" ? `return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(res.data)
-              }
-            ],
-            structuredContent: { data: res.data }
-           }` : `return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(res)
-              }
-            ],
-            structuredContent: { data: res.data }
-           }`;
+	const callToolResult = `return {
+  content: [
+    {
+      type: 'text',
+      text: JSON.stringify(${dataReturnType === "data" ? "res.data" : "res"})
+    }
+  ],
+  structuredContent: { data: res.data }
+}`;
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -575,7 +511,7 @@ function zodExprFromSchemaNode(schema) {
 }
 //#endregion
 //#region src/components/Server.tsx
-const keysPrinter = functionPrinter({ mode: "keys" });
+const keysPrinter = functionPrinter({ mode: "call" });
 function Server({ name, serverName, serverVersion, paramsCasing, operations }) {
 	const registrations = operations.map(({ tool, mcp, zod, node }) => {
 		const { path: pathParams } = getOperationParameters(node, { paramsCasing });
@@ -602,10 +538,11 @@ function Server({ name, serverName, serverVersion, paramsCasing, operations }) {
 		});
 		otherEntries.sort((a, b) => a.key.localeCompare(b.key));
 		const entries = [...pathEntries, ...otherEntries];
-		const paramsNode = entries.length ? ast.createFunctionParameters({ params: [ast.createParameterGroup({ properties: entries.map((e) => ast.createFunctionParameter({
-			name: e.key,
+		const paramsNode = entries.length ? ast.factory.createFunctionParameters({ params: [{
+			kind: "FunctionParameter",
+			name: ast.factory.createObjectBindingPattern({ elements: entries.map((e) => ({ name: e.key })) }),
 			optional: false
-		})) })] }) : null;
+		}] }) : null;
 		const destructured = paramsNode ? keysPrinter.print(paramsNode) ?? "" : "";
 		const inputSchema = entries.length ? `{ ${entries.map((e) => `${e.key}: ${e.value}`).join(", ")} }` : null;
 		const outputSchema = zod.responseName;
@@ -676,7 +613,7 @@ return server`
 */
 const mcpGenerator = defineGenerator({
 	name: "mcp",
-	renderer: jsxRendererSync,
+	renderer: jsxRenderer,
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { resolver, driver, root } = ctx;
@@ -806,7 +743,7 @@ const mcpGenerator = defineGenerator({
 */
 const serverGenerator = defineGenerator({
 	name: "operations",
-	renderer: jsxRendererSync,
+	renderer: jsxRenderer,
 	operations(nodes, ctx) {
 		const { config, resolver, plugin, driver, root } = ctx;
 		const { output, paramsCasing, group } = ctx.options;
@@ -974,7 +911,7 @@ const resolverMcp = defineResolver(() => ({
 	name: "default",
 	pluginName: "plugin-mcp",
 	default(name, type) {
-		if (type === "file") return camelCase(name, { isFile: true });
+		if (type === "file") return toFilePath(name);
 		return camelCase(name, { suffix: "handler" });
 	},
 	resolveName(name) {
@@ -1025,11 +962,11 @@ const pluginMcpName = "plugin-mcp";
 const pluginMcp = definePlugin((options) => {
 	const { output = {
 		path: "mcp",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], paramsCasing, client, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], paramsCasing, client, resolver: userResolver, macros: userMacros, generators: userGenerators = [] } = options;
 	const clientName = client?.client ?? "axios";
 	const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : void 0);
-	const groupConfig = createGroupConfig(group, { suffix: "Requests" });
+	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginMcpName,
 		options,
@@ -1058,7 +995,7 @@ const pluginMcp = definePlugin((options) => {
 				resolver
 			});
 			ctx.setResolver(resolver);
-			if (userTransformer) ctx.setTransformer(userTransformer);
+			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(mcpGenerator);
 			ctx.addGenerator(serverGenerator);
 			for (const gen of userGenerators) ctx.addGenerator(gen);
@@ -1067,9 +1004,9 @@ const pluginMcp = definePlugin((options) => {
 			if (client?.bundle && !hasClientPlugin && !clientImportPath) ctx.injectFile({
 				baseName: "client.ts",
 				path: path.resolve(root, ".kubb/client.ts"),
-				sources: [ast.createSource({
+				sources: [ast.factory.createSource({
 					name: "client",
-					nodes: [ast.createText(clientName === "fetch" ? source$1 : source)],
+					nodes: [ast.factory.createText(clientName === "fetch" ? source$1 : source)],
 					isExportable: true,
 					isIndexable: true
 				})]
@@ -1077,9 +1014,9 @@ const pluginMcp = definePlugin((options) => {
 			if (!hasClientPlugin) ctx.injectFile({
 				baseName: "config.ts",
 				path: path.resolve(root, ".kubb/config.ts"),
-				sources: [ast.createSource({
+				sources: [ast.factory.createSource({
 					name: "config",
-					nodes: [ast.createText(source$2)],
+					nodes: [ast.factory.createText(source$2)],
 					isExportable: false,
 					isIndexable: false
 				})]