@tsed/cli-mcp 7.5.0 → 7.5.1

package/lib/types/fn/defineTool.d.ts

@@ -125,8 +125,8 @@ export declare function defineTool<Input, Output = undefined>(options: ToolProps
             message: any;
         };
     }>;
-    description?: string | undefined;
     _meta?: Record<string, unknown> | undefined;
+    description?: string | undefined;
     annotations?: import("@modelcontextprotocol/sdk/types.js").ToolAnnotations;
     title?: string | undefined;
 } | {
@@ -235,8 +235,8 @@ export declare function defineTool<Input, Output = undefined>(options: ToolProps
             message: any;
         };
     }>;
-    description?: string | undefined;
     _meta?: Record<string, unknown> | undefined;
+    description?: string | undefined;
     annotations?: import("@modelcontextprotocol/sdk/types.js").ToolAnnotations;
     title?: string | undefined;
     token: Type | AbstractType<any>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tsed/cli-mcp",
   "description": "MCP CLI for Ts.ED.",
-  "version": "7.5.0",
+  "version": "7.5.1",
   "type": "module",
   "main": "./lib/esm/index.js",
   "source": "./src/index.ts",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": ">=1.26.0",
-    "@tsed/cli-core": "7.5.0",
+    "@tsed/cli-core": "7.5.1",
     "@tsed/core": ">=8.21.0",
     "@tsed/di": ">=8.21.0",
     "@tsed/hooks": ">=8.21.0",
@@ -62,6 +62,7 @@
     "create-frame": "^1.0.0",
     "fs-extra": "^11.2.0",
     "globby": "^14.0.2",
+    "json-schema-to-zod": "^2.8.1",
     "read-pkg-up": "^11.0.0",
     "rxjs": "^7.8.1",
     "semver": "^7.6.3",
@@ -73,7 +74,7 @@
     "@swc-node/register": "^1.10.9",
     "@swc/core": "1.7.26",
     "@swc/helpers": "^0.5.13",
-    "@tsed/typescript": "7.5.0",
+    "@tsed/typescript": "7.5.1",
     "@types/change-case": "^2.3.1",
     "@types/consolidate": "0.14.4",
     "cross-env": "7.0.3",

package/lib/esm/utils/json-schema-to-zod/Types.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/utils/json-schema-to-zod/cli.js

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-import { mkdirSync, writeFileSync } from "fs";
-import { dirname } from "path";
-import { jsonSchemaToZod } from "./jsonSchemaToZod.js";
-import { parseArgs, parseOrReadJSON, readPipe } from "./utils/cliTools.js";
-const params = {
-    input: {
-        shorthand: "i",
-        value: "string",
-        required: process.stdin.isTTY && "input is required when no JSON or file path is piped",
-        description: "JSON or a source file path. Required if no data is piped."
-    },
-    output: {
-        shorthand: "o",
-        value: "string",
-        description: "A file path to write to. If not supplied stdout will be used."
-    },
-    name: {
-        shorthand: "n",
-        value: "string",
-        description: "The name of the schema in the output."
-    },
-    depth: {
-        shorthand: "d",
-        value: "number",
-        description: "Maximum depth of recursion before falling back to z.any(). Defaults to 0."
-    },
-    module: {
-        shorthand: "m",
-        value: ["esm", "cjs", "none"],
-        description: "Module syntax; 'esm', 'cjs' or 'none'. Defaults to 'esm'."
-    },
-    type: {
-        shorthand: "t",
-        value: "string",
-        description: "The name of the (optional) inferred type export."
-    },
-    noImport: {
-        shorthand: "ni",
-        description: "Removes the `import { z } from 'zod';` or equivalent from the output."
-    },
-    withJsdocs: {
-        shorthand: "wj",
-        description: "Generate jsdocs off of the description property."
-    },
-    zodVersion: {
-        shorthand: "zv",
-        value: "number",
-        description: "Target Zod version: 3 or 4. Defaults to 4."
-    }
-};
-async function main() {
-    const args = parseArgs(params, process.argv, true);
-    const input = args.input || (await readPipe());
-    const jsonSchema = parseOrReadJSON(input);
-    const zodVersion = (args.zodVersion === 3 ? 3 : 4);
-    const zodSchema = jsonSchemaToZod(jsonSchema, {
-        name: args.name,
-        depth: args.depth,
-        module: args.module || "esm",
-        noImport: args.noImport,
-        type: args.type,
-        withJsdocs: args.withJsdocs,
-        zodVersion
-    });
-    if (args.output) {
-        mkdirSync(dirname(args.output), { recursive: true });
-        writeFileSync(args.output, zodSchema);
-    }
-    else {
-        console.log(zodSchema);
-    }
-}
-void main();

package/lib/esm/utils/json-schema-to-zod/index.js

@@ -1,25 +0,0 @@
-export * from "./jsonSchemaToZod.js";
-export * from "./parsers/parseAllOf.js";
-export * from "./parsers/parseAnyOf.js";
-export * from "./parsers/parseArray.js";
-export * from "./parsers/parseBoolean.js";
-export * from "./parsers/parseConst.js";
-export * from "./parsers/parseDefault.js";
-export * from "./parsers/parseEnum.js";
-export * from "./parsers/parseIfThenElse.js";
-export * from "./parsers/parseMultipleType.js";
-export * from "./parsers/parseNot.js";
-export * from "./parsers/parseNull.js";
-export * from "./parsers/parseNullable.js";
-export * from "./parsers/parseNumber.js";
-export * from "./parsers/parseObject.js";
-export * from "./parsers/parseOneOf.js";
-export * from "./parsers/parseSchema.js";
-export * from "./parsers/parseString.js";
-export * from "./Types.js";
-export * from "./utils/half.js";
-export * from "./utils/jsdocs.js";
-export * from "./utils/omit.js";
-export * from "./utils/withMessage.js";
-import { jsonSchemaToZod } from "./jsonSchemaToZod.js";
-export default jsonSchemaToZod;

package/lib/esm/utils/json-schema-to-zod/jsonSchemaToZod.js

@@ -1,43 +0,0 @@
-import { parseSchema } from "./parsers/parseSchema.js";
-import { expandJsdocs } from "./utils/jsdocs.js";
-export const jsonSchemaToZod = (schema, { module, name, type, noImport, zodVersion = 4, ...rest } = {}) => {
-    if (type && (!name || module !== "esm")) {
-        throw new Error("Option `type` requires `name` to be set and `module` to be `esm`");
-    }
-    let result = parseSchema(schema, {
-        module,
-        name,
-        path: [],
-        seen: new Map(),
-        zodVersion,
-        ...rest
-    });
-    const jsdocs = rest.withJsdocs && typeof schema !== "boolean" && schema.description ? expandJsdocs(schema.description) : "";
-    if (module === "cjs") {
-        result = `${jsdocs}module.exports = ${name ? `{ ${JSON.stringify(name)}: ${result} }` : result}
-`;
-        if (!noImport) {
-            result = `${jsdocs}const { z } = require("zod")
-
-${result}`;
-        }
-    }
-    else if (module === "esm") {
-        result = `${jsdocs}export ${name ? `const ${name} =` : `default`} ${result}
-`;
-        if (!noImport) {
-            result = `import { z } from "zod"
-
-${result}`;
-        }
-    }
-    else if (name) {
-        result = `${jsdocs}const ${name} = ${result}`;
-    }
-    if (type && name) {
-        let typeName = typeof type === "string" ? type : `${name[0].toUpperCase()}${name.substring(1)}`;
-        result += `export type ${typeName} = z.infer<typeof ${name}>
-`;
-    }
-    return result;
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseAllOf.js

@@ -1,37 +0,0 @@
-import { half } from "../utils/half.js";
-import { parseSchema } from "./parseSchema.js";
-const originalIndex = Symbol("Original index");
-const ensureOriginalIndex = (arr) => {
-    let newArr = [];
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        if (typeof item === "boolean") {
-            newArr.push(item ? { [originalIndex]: i } : { [originalIndex]: i, not: {} });
-        }
-        else if (originalIndex in item) {
-            return arr;
-        }
-        else {
-            newArr.push({ ...item, [originalIndex]: i });
-        }
-    }
-    return newArr;
-};
-export function parseAllOf(schema, refs) {
-    if (schema.allOf.length === 0) {
-        return "z.never()";
-    }
-    else if (schema.allOf.length === 1) {
-        const item = schema.allOf[0];
-        return parseSchema(item, {
-            ...refs,
-            path: [...refs.path, "allOf", item[originalIndex]]
-        });
-    }
-    else {
-        const [left, right] = half(ensureOriginalIndex(schema.allOf));
-        return `z.intersection(${parseAllOf({ allOf: left }, refs)}, ${parseAllOf({
-            allOf: right
-        }, refs)})`;
-    }
-}

package/lib/esm/utils/json-schema-to-zod/parsers/parseAnyOf.js

@@ -1,11 +0,0 @@
-import { parseSchema } from "./parseSchema.js";
-export const parseAnyOf = (schema, refs) => {
-    return schema.anyOf.length
-        ? schema.anyOf.length === 1
-            ? parseSchema(schema.anyOf[0], {
-                ...refs,
-                path: [...refs.path, "anyOf", 0]
-            })
-            : `z.union([${schema.anyOf.map((schema, i) => parseSchema(schema, { ...refs, path: [...refs.path, "anyOf", i] })).join(", ")}])`
-        : `z.any()`;
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseArray.js

@@ -1,16 +0,0 @@
-import { withMessage } from "../utils/withMessage.js";
-import { parseSchema } from "./parseSchema.js";
-export const parseArray = (schema, refs) => {
-    if (Array.isArray(schema.items)) {
-        return `z.tuple([${schema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
-    }
-    let r = !schema.items
-        ? "z.array(z.any())"
-        : `z.array(${parseSchema(schema.items, {
-            ...refs,
-            path: [...refs.path, "items"]
-        })})`;
-    r += withMessage(schema, "minItems", ({ json }) => [`.min(${json}`, ", ", ")"]);
-    r += withMessage(schema, "maxItems", ({ json }) => [`.max(${json}`, ", ", ")"]);
-    return r;
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseBoolean.js

@@ -1,3 +0,0 @@
-export const parseBoolean = (_schema) => {
-    return "z.boolean()";
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseConst.js

@@ -1,3 +0,0 @@
-export const parseConst = (schema) => {
-    return `z.literal(${JSON.stringify(schema.const)})`;
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseDefault.js

@@ -1,3 +0,0 @@
-export const parseDefault = (_schema) => {
-    return "z.any()";
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseEnum.js

@@ -1,15 +0,0 @@
-export const parseEnum = (schema) => {
-    if (schema.enum.length === 0) {
-        return "z.never()";
-    }
-    else if (schema.enum.length === 1) {
-        // union does not work when there is only one element
-        return `z.literal(${JSON.stringify(schema.enum[0])})`;
-    }
-    else if (schema.enum.every((x) => typeof x === "string")) {
-        return `z.enum([${schema.enum.map((x) => JSON.stringify(x))}])`;
-    }
-    else {
-        return `z.union([${schema.enum.map((x) => `z.literal(${JSON.stringify(x)})`).join(", ")}])`;
-    }
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseIfThenElse.js

@@ -1,20 +0,0 @@
-import { parseSchema } from "./parseSchema.js";
-export const parseIfThenElse = (schema, refs) => {
-    const $if = parseSchema(schema.if, { ...refs, path: [...refs.path, "if"] });
-    const $then = parseSchema(schema.then, {
-        ...refs,
-        path: [...refs.path, "then"]
-    });
-    const $else = parseSchema(schema.else, {
-        ...refs,
-        path: [...refs.path, "else"]
-    });
-    return `z.union([${$then}, ${$else}]).superRefine((value,ctx) => {
-  const result = ${$if}.safeParse(value).success
-    ? ${$then}.safeParse(value)
-    : ${$else}.safeParse(value);
-  if (!result.success) {
-    result.error.errors.forEach((error) => ctx.addIssue(error))
-  }
-})`;
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseMultipleType.js

@@ -1,4 +0,0 @@
-import { parseSchema } from "./parseSchema.js";
-export const parseMultipleType = (schema, refs) => {
-    return `z.union([${schema.type.map((type) => parseSchema({ ...schema, type }, { ...refs, withoutDefaults: true })).join(", ")}])`;
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseNot.js

@@ -1,7 +0,0 @@
-import { parseSchema } from "./parseSchema.js";
-export const parseNot = (schema, refs) => {
-    return `z.any().refine((value) => !${parseSchema(schema.not, {
-        ...refs,
-        path: [...refs.path, "not"]
-    })}.safeParse(value).success, "Invalid input: Should NOT be valid against schema")`;
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseNull.js

@@ -1,3 +0,0 @@
-export const parseNull = (_schema) => {
-    return "z.null()";
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseNullable.js

@@ -1,8 +0,0 @@
-import { omit } from "../utils/omit.js";
-import { parseSchema } from "./parseSchema.js";
-/**
- * For compatibility with open api 3.0 nullable
- */
-export const parseNullable = (schema, refs) => {
-    return `${parseSchema(omit(schema, "nullable"), refs, true)}.nullable()`;
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseNumber.js

@@ -1,46 +0,0 @@
-import { withMessage } from "../utils/withMessage.js";
-export const parseNumber = (schema) => {
-    let r = "z.number()";
-    if (schema.type === "integer") {
-        r += withMessage(schema, "type", () => [".int(", ")"]);
-    }
-    else {
-        r += withMessage(schema, "format", ({ value }) => {
-            if (value === "int64") {
-                return [".int(", ")"];
-            }
-        });
-    }
-    r += withMessage(schema, "multipleOf", ({ value, json }) => {
-        if (value === 1) {
-            if (r.startsWith("z.number().int(")) {
-                return;
-            }
-            return [".int(", ")"];
-        }
-        return [`.multipleOf(${json}`, ", ", ")"];
-    });
-    if (typeof schema.minimum === "number") {
-        if (schema.exclusiveMinimum === true) {
-            r += withMessage(schema, "minimum", ({ json }) => [`.gt(${json}`, ", ", ")"]);
-        }
-        else {
-            r += withMessage(schema, "minimum", ({ json }) => [`.gte(${json}`, ", ", ")"]);
-        }
-    }
-    else if (typeof schema.exclusiveMinimum === "number") {
-        r += withMessage(schema, "exclusiveMinimum", ({ json }) => [`.gt(${json}`, ", ", ")"]);
-    }
-    if (typeof schema.maximum === "number") {
-        if (schema.exclusiveMaximum === true) {
-            r += withMessage(schema, "maximum", ({ json }) => [`.lt(${json}`, ", ", ")"]);
-        }
-        else {
-            r += withMessage(schema, "maximum", ({ json }) => [`.lte(${json}`, ", ", ")"]);
-        }
-    }
-    else if (typeof schema.exclusiveMaximum === "number") {
-        r += withMessage(schema, "exclusiveMaximum", ({ json }) => [`.lt(${json}`, ", ", ")"]);
-    }
-    return r;
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseObject.js

@@ -1,171 +0,0 @@
-import { addJsdocs } from "../utils/jsdocs.js";
-import { parseAllOf } from "./parseAllOf.js";
-import { parseAnyOf } from "./parseAnyOf.js";
-import { parseOneOf } from "./parseOneOf.js";
-import { its, parseSchema } from "./parseSchema.js";
-// Helper for z.record() generation - Zod v4 requires explicit key type
-function emitRecord(valueSchema, refs) {
-    if (refs.zodVersion === 3) {
-        return `z.record(${valueSchema})`;
-    }
-    // Default to v4 syntax
-    return `z.record(z.string(), ${valueSchema})`;
-}
-// Helper for error path in superRefine - Zod v4 uses simplified path
-function emitErrorPath(refs) {
-    if (refs.zodVersion === 3) {
-        return `path: [...ctx.path, key]`;
-    }
-    // Default to v4 syntax
-    return `path: [key]`;
-}
-export function parseObject(objectSchema, refs) {
-    let properties = undefined;
-    if (objectSchema.properties) {
-        if (!Object.keys(objectSchema.properties).length) {
-            properties = "z.object({})";
-        }
-        else {
-            properties = "z.object({ ";
-            properties += Object.keys(objectSchema.properties)
-                .map((key) => {
-                const propSchema = objectSchema.properties[key];
-                let result = `${JSON.stringify(key)}: ${parseSchema(propSchema, {
-                    ...refs,
-                    path: [...refs.path, "properties", key]
-                })}`;
-                if (refs.withJsdocs && typeof propSchema === "object") {
-                    result = addJsdocs(propSchema, result);
-                }
-                const hasDefault = typeof propSchema === "object" && propSchema.default !== undefined;
-                const required = Array.isArray(objectSchema.required)
-                    ? objectSchema.required.includes(key)
-                    : typeof propSchema === "object" && propSchema.required === true;
-                const optional = !hasDefault && !required;
-                return optional ? `${result}.optional()` : result;
-            })
-                .join(", ");
-            properties += " })";
-        }
-    }
-    const additionalProperties = objectSchema.additionalProperties !== undefined
-        ? parseSchema(objectSchema.additionalProperties, {
-            ...refs,
-            path: [...refs.path, "additionalProperties"]
-        })
-        : undefined;
-    let patternProperties = undefined;
-    if (objectSchema.patternProperties) {
-        const parsedPatternProperties = Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => {
-            return [
-                key,
-                parseSchema(value, {
-                    ...refs,
-                    path: [...refs.path, "patternProperties", key]
-                })
-            ];
-        }, {}));
-        patternProperties = "";
-        if (properties) {
-            if (additionalProperties) {
-                patternProperties += `.catchall(z.union([${[...Object.values(parsedPatternProperties), additionalProperties].join(", ")}]))`;
-            }
-            else if (Object.keys(parsedPatternProperties).length > 1) {
-                patternProperties += `.catchall(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
-            }
-            else {
-                patternProperties += `.catchall(${Object.values(parsedPatternProperties)})`;
-            }
-        }
-        else {
-            if (additionalProperties) {
-                patternProperties += emitRecord(`z.union([${[...Object.values(parsedPatternProperties), additionalProperties].join(", ")}])`, refs);
-            }
-            else if (Object.keys(parsedPatternProperties).length > 1) {
-                patternProperties += emitRecord(`z.union([${Object.values(parsedPatternProperties).join(", ")}])`, refs);
-            }
-            else {
-                patternProperties += emitRecord(`${Object.values(parsedPatternProperties)}`, refs);
-            }
-        }
-        patternProperties += ".superRefine((value, ctx) => {\n";
-        patternProperties += "for (const key in value) {\n";
-        if (additionalProperties) {
-            if (objectSchema.properties) {
-                patternProperties += `let evaluated = [${Object.keys(objectSchema.properties)
-                    .map((key) => JSON.stringify(key))
-                    .join(", ")}].includes(key)\n`;
-            }
-            else {
-                patternProperties += `let evaluated = false\n`;
-            }
-        }
-        for (const key in objectSchema.patternProperties) {
-            patternProperties += "if (key.match(new RegExp(" + JSON.stringify(key) + "))) {\n";
-            if (additionalProperties) {
-                patternProperties += "evaluated = true\n";
-            }
-            patternProperties += "const result = " + parsedPatternProperties[key] + ".safeParse(value[key])\n";
-            patternProperties += "if (!result.success) {\n";
-            patternProperties += `ctx.addIssue({
-          ${emitErrorPath(refs)},
-          code: 'custom',
-          message: \`Invalid input: Key matching regex /\${key}/ must match schema\`,
-          params: {
-            issues: result.error.issues
-          }
-        })\n`;
-            patternProperties += "}\n";
-            patternProperties += "}\n";
-        }
-        if (additionalProperties) {
-            patternProperties += "if (!evaluated) {\n";
-            patternProperties += "const result = " + additionalProperties + ".safeParse(value[key])\n";
-            patternProperties += "if (!result.success) {\n";
-            patternProperties += `ctx.addIssue({
-          ${emitErrorPath(refs)},
-          code: 'custom',
-          message: \`Invalid input: must match catchall schema\`,
-          params: {
-            issues: result.error.issues
-          }
-        })\n`;
-            patternProperties += "}\n";
-            patternProperties += "}\n";
-        }
-        patternProperties += "}\n";
-        patternProperties += "})";
-    }
-    let output = properties
-        ? patternProperties
-            ? properties + patternProperties
-            : additionalProperties
-                ? additionalProperties === "z.never()"
-                    ? properties + ".strict()"
-                    : properties + `.catchall(${additionalProperties})`
-                : properties
-        : patternProperties
-            ? patternProperties
-            : additionalProperties
-                ? emitRecord(additionalProperties, refs)
-                : emitRecord("z.any()", refs);
-    if (its.an.anyOf(objectSchema)) {
-        output += `.and(${parseAnyOf({
-            ...objectSchema,
-            anyOf: objectSchema.anyOf.map((x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x)
-        }, refs)})`;
-    }
-    if (its.a.oneOf(objectSchema)) {
-        output += `.and(${parseOneOf({
-            ...objectSchema,
-            oneOf: objectSchema.oneOf.map((x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x)
-        }, refs)})`;
-    }
-    if (its.an.allOf(objectSchema)) {
-        output += `.and(${parseAllOf({
-            ...objectSchema,
-            allOf: objectSchema.allOf.map((x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x)
-        }, refs)})`;
-    }
-    return output;
-}

package/lib/esm/utils/json-schema-to-zod/parsers/parseOneOf.js

@@ -1,34 +0,0 @@
-import { parseSchema } from "./parseSchema.js";
-export const parseOneOf = (schema, refs) => {
-    return schema.oneOf.length
-        ? schema.oneOf.length === 1
-            ? parseSchema(schema.oneOf[0], {
-                ...refs,
-                path: [...refs.path, "oneOf", 0]
-            })
-            : `z.any().superRefine((x, ctx) => {
-    const schemas = [${schema.oneOf
-                .map((schema, i) => parseSchema(schema, {
-                ...refs,
-                path: [...refs.path, "oneOf", i]
-            }))
-                .join(", ")}];
-    const errors = schemas.reduce<z.ZodError[]>(
-      (errors, schema) =>
-        ((result) =>
-          result.error ? [...errors, result.error] : errors)(
-          schema.safeParse(x),
-        ),
-      [],
-    );
-    if (schemas.length - errors.length !== 1) {
-      ctx.addIssue({
-        path: ctx.path,
-        code: "invalid_union",
-        unionErrors: errors,
-        message: "Invalid input: Should pass single schema",
-      });
-    }
-  })`
-        : "z.any()";
-};