@tsed/cli 7.0.0-alpha.9 → 7.0.0-beta.10

package/lib/esm/commands/init/config/InitSchema.js

@@ -0,0 +1,337 @@
+import { PackageManager, PackageManagersModule } from "@tsed/cli-core";
+import { inject } from "@tsed/di";
+import { s } from "@tsed/schema";
+import { DEFAULT_TSED_TAGS } from "../../../constants/index.js";
+import { ArchitectureConvention, PlatformType, ProjectConvention } from "../../../interfaces/index.js";
+import { RuntimesModule } from "../../../runtimes/RuntimesModule.js";
+import { FeatureType } from "../../init/config/FeaturesPrompt.js";
+export const InitSchema = () => {
+    const availablePackageManagers = inject(PackageManagersModule).list();
+    const availableRuntimes = inject(RuntimesModule).list();
+    return s
+        .object({
+        root: s.string().description("Current working directory to initialize Ts.ED project").default("."),
+        projectName: s
+            .string()
+            .optional()
+            .prompt("What is your project name")
+            .when((ctx) => ctx.root !== ".")
+            .description("Set the project name. By default, the project is the same as the name directory.")
+            .opt("-n, --project-name <projectName>"),
+        platform: s
+            .enums(PlatformType)
+            .default(PlatformType.EXPRESS)
+            .prompt("Choose the target Framework:")
+            .choices([
+            {
+                label: "Express.js",
+                value: PlatformType.EXPRESS,
+                checked: (options) => options.platform === PlatformType.EXPRESS || !options.platform // todo maybe it can be infered by default() and item value()
+            },
+            {
+                label: "Koa.js",
+                value: PlatformType.KOA,
+                checked: (options) => options.platform === PlatformType.KOA || !options.platform
+            },
+            {
+                label: "Fastify.js (beta)",
+                value: PlatformType.KOA,
+                checked: (options) => options.platform === PlatformType.KOA || !options.platform
+            }
+        ])
+            .description("Set the default platform for Ts.ED (Express.js, Koa.js or Fastify.js)")
+            .opt("-p, --platform <platform>"),
+        architecture: s
+            .string()
+            .enum(ArchitectureConvention)
+            .default(ArchitectureConvention.DEFAULT)
+            .prompt("Choose the architecture for your project:")
+            .description("Architecture convention for tree directory")
+            .choices([
+            {
+                label: "Ts.ED",
+                value: ArchitectureConvention.DEFAULT
+            },
+            {
+                label: "Feature",
+                value: ArchitectureConvention.FEATURE
+            }
+        ])
+            .opt("-a, --arch <architecture>"),
+        convention: s
+            .enums(ProjectConvention)
+            .default(ProjectConvention.DEFAULT)
+            .prompt("Choose the file naming convention:")
+            .description("Set the default file naming convention (Ts.ED, Angular).")
+            .choices([
+            {
+                label: "Ts.ED",
+                value: ProjectConvention.DEFAULT
+            },
+            {
+                label: "Angular",
+                value: ProjectConvention.ANGULAR
+            }
+        ])
+            .opt("-c, --convention <convention>"),
+        features: s
+            .array()
+            .items(s.enums(FeatureType))
+            .prompt("Choose the features needed for your project")
+            .description("List of features to enable (swagger, graphql, prisma, etc.).")
+            .choices([
+            {
+                label: "Commands",
+                value: FeatureType.COMMANDS
+            },
+            {
+                label: "Configuration sources",
+                value: FeatureType.CONFIG,
+                items: [
+                    {
+                        label: "Envs",
+                        value: FeatureType.CONFIG_ENVS
+                    },
+                    {
+                        label: "Dotenv",
+                        value: FeatureType.CONFIG_DOTENV
+                    },
+                    {
+                        label: "JSON",
+                        value: FeatureType.CONFIG_JSON
+                    },
+                    {
+                        label: "YAML",
+                        value: FeatureType.CONFIG_YAML
+                    },
+                    {
+                        label: "AWS Secrets Manager (Premium)",
+                        value: FeatureType.CONFIG_AWS_SECRETS
+                    },
+                    {
+                        label: "IORedis (Premium)",
+                        value: FeatureType.CONFIG_IOREDIS
+                    },
+                    {
+                        label: "MongoDB (Premium)",
+                        value: FeatureType.CONFIG_MONGO
+                    },
+                    {
+                        label: "Vault (Premium)",
+                        value: FeatureType.CONFIG_VAULT
+                    },
+                    {
+                        label: "Postgres (Premium)",
+                        value: FeatureType.CONFIG_POSTGRES
+                    }
+                ]
+            },
+            {
+                label: "ORM",
+                value: FeatureType.ORM,
+                items: [
+                    {
+                        label: "Prisma",
+                        value: FeatureType.PRISMA
+                    },
+                    {
+                        label: "Mongoose",
+                        value: FeatureType.MONGOOSE
+                    },
+                    {
+                        label: "TypeORM",
+                        value: FeatureType.TYPEORM,
+                        items: [
+                            {
+                                label: "MySQL",
+                                value: FeatureType.TYPEORM_MYSQL
+                            },
+                            {
+                                label: "MariaDB",
+                                value: FeatureType.TYPEORM_MARIADB
+                            },
+                            {
+                                label: "Postgres",
+                                value: FeatureType.TYPEORM_POSTGRES
+                            },
+                            {
+                                label: "CockRoachDB",
+                                value: FeatureType.TYPEORM_COCKROACHDB
+                            },
+                            {
+                                label: "SQLite",
+                                value: FeatureType.TYPEORM_SQLITE
+                            },
+                            {
+                                label: "Better SQLite3",
+                                value: FeatureType.TYPEORM_BETTER_SQLITE3
+                            },
+                            {
+                                label: "Cordova",
+                                value: FeatureType.TYPEORM_CORDOVA
+                            },
+                            {
+                                label: "NativeScript",
+                                value: FeatureType.TYPEORM_NATIVESCRIPT
+                            },
+                            {
+                                label: "Oracle",
+                                value: FeatureType.TYPEORM_ORACLE
+                            },
+                            {
+                                label: "MsSQL",
+                                value: FeatureType.TYPEORM_MSSQL
+                            },
+                            {
+                                label: "MongoDB",
+                                value: FeatureType.TYPEORM_MONGODB
+                            },
+                            {
+                                label: "SQL.js",
+                                value: FeatureType.TYPEORM_SQLJS
+                            },
+                            {
+                                label: "ReactNative",
+                                value: FeatureType.TYPEORM_REACTNATIVE
+                            },
+                            {
+                                label: "Expo",
+                                value: FeatureType.TYPEORM_EXPO
+                            }
+                        ]
+                    }
+                ]
+            },
+            {
+                label: "Documentation",
+                value: "doc",
+                items: [
+                    {
+                        label: "Swagger",
+                        value: "doc:swagger"
+                    },
+                    {
+                        label: "Scalar",
+                        value: "doc:scalar"
+                    }
+                ]
+            },
+            {
+                label: "TypeGraphQL",
+                value: "graphql",
+                items: []
+            },
+            {
+                label: "Linter",
+                value: FeatureType.LINTER,
+                items: [
+                    {
+                        label: "EsLint",
+                        value: FeatureType.ESLINT
+                    },
+                    {
+                        label: "Prettier",
+                        value: FeatureType.PRETTIER
+                    },
+                    {
+                        label: "Lint on commit",
+                        value: FeatureType.LINT_STAGED
+                    }
+                ]
+            },
+            {
+                label: "OpenID Connect provider",
+                value: FeatureType.OIDC,
+                items: []
+            },
+            {
+                label: "Passport.js",
+                value: FeatureType.PASSPORTJS,
+                items: []
+            },
+            {
+                label: "Socket.io",
+                value: FeatureType.SOCKETIO,
+                items: []
+            },
+            {
+                label: "Testing",
+                value: FeatureType.TESTING,
+                items: [
+                    {
+                        label: "Vitest",
+                        value: FeatureType.VITEST
+                    },
+                    {
+                        label: "Jest (unstable with ESM)",
+                        value: FeatureType.JEST
+                    }
+                ]
+            }
+        ])
+            .opt("--features <features...>"),
+        runtime: s
+            .enums(availableRuntimes)
+            .prompt("Choose the runtime:")
+            .choices([
+            {
+                label: "Node.js + SWC",
+                value: "node"
+            },
+            {
+                label: "Node.js + Babel",
+                value: "babel"
+            },
+            {
+                label: "Node.js + Webpack",
+                value: "webpack"
+            },
+            {
+                label: "Bun",
+                value: "bun"
+            }
+        ].filter((o) => availableRuntimes.includes(o.value)))
+            .default("node")
+            .description("Runtime (node, bun, ...).")
+            .opt("--runtime <runtime>"),
+        packageManager: s
+            .enums(availablePackageManagers)
+            .prompt("Choose the package manager:")
+            .when((answers) => answers.runtime !== "bun")
+            .default(PackageManager.NPM)
+            .choices([
+            {
+                label: "NPM",
+                value: PackageManager.NPM
+            },
+            {
+                label: "Yarn Berry",
+                value: PackageManager.YARN_BERRY
+            },
+            {
+                label: "PNPM",
+                value: PackageManager.PNPM
+            },
+            {
+                label: "Bun.js",
+                value: PackageManager.BUN
+            }
+        ].filter((o) => availablePackageManagers.includes(o.value)))
+            .description("Package manager (npm, pnpm, yarn, bun).")
+            .opt("-m, --package-manager <packageManager>"),
+        GH_TOKEN: s
+            .string()
+            .optional()
+            .description("GitHub token to install premium plugins. For example config:aws_secrets:premium or all features endings by `:premium` needs a GH_TOKEN")
+            .opt("--gh-token <ghToken>"),
+        tsedVersion: s
+            .string()
+            .optional()
+            .default(DEFAULT_TSED_TAGS)
+            .description("Use a specific version of Ts.ED (format: x.x.x).")
+            .opt("-t, --tsed-version <version>"),
+        file: s.string().optional().description("Location of a file in which the features are defined.").opt("-f, --file <file>"),
+        skipPrompt: s.boolean().optional().default(false).description("Skip the prompt installation").opt("-s, --skip-prompt")
+    })
+        .unknown();
+};

package/lib/esm/commands/init/prompts/getFeaturesPrompt.js

@@ -1,5 +1,5 @@
 import { cleanObject, isFunction } from "@tsed/core";
-import { FeaturesMap, FeaturesPrompt, FrameworksPrompt } from "../config/FeaturesPrompt.js";
+import { FeaturesMap, FeaturesPrompt } from "../config/FeaturesPrompt.js";
 function mapChoices(item, options) {
     return item.choices.map((choice) => {
         const { checked } = FeaturesMap[choice];

package/lib/esm/commands/mcp/McpCommand.js

@@ -0,0 +1,15 @@
+import { command } from "@tsed/cli-core";
+import { MCP_SERVER } from "@tsed/cli-mcp";
+import { inject } from "@tsed/di";
+import { s } from "@tsed/schema";
+const McpSchema = s.object({
+    http: s.boolean().default(false).description("Run MCP using HTTP server").opt("--http")
+});
+export const McpCommand = command({
+    name: "mcp",
+    description: "Run a MCP server",
+    inputSchema: McpSchema,
+    handler(data) {
+        return inject(MCP_SERVER).connect(data.http ? "streamable-http" : "stdio");
+    }
+}).token();

package/lib/esm/commands/mcp/resources/index.js

@@ -0,0 +1,4 @@
+import { initOptionsResource } from "./initOptionsResource.js";
+import { projectInfoResource } from "./projectInfoResource.js";
+import { serverInfoResource } from "./serverInfoResource.js";
+export default [serverInfoResource, projectInfoResource, initOptionsResource];

package/lib/esm/commands/mcp/resources/initOptionsResource.js

@@ -0,0 +1,93 @@
+import { defineResource } from "@tsed/cli-mcp";
+import { InitMCPSchema } from "../schema/InitMCPSchema.js";
+function stripCliFlags(payload) {
+    if (Array.isArray(payload)) {
+        return payload.map(stripCliFlags);
+    }
+    if (payload && typeof payload === "object") {
+        return Object.entries(payload).reduce((acc, [key, value]) => {
+            if (key === "x-opt") {
+                return acc;
+            }
+            acc[key] = stripCliFlags(value);
+            return acc;
+        }, {});
+    }
+    return payload;
+}
+function buildSection(key, property) {
+    const title = property["x-label"] || "";
+    if (!title) {
+        return "";
+    }
+    const choices = property["x-choices"] || property["items"]?.["x-choices"] || property["enum"] || [];
+    if (!choices.length) {
+        return `${title}?\n`;
+    }
+    const lines = [title + (property.type === "array" ? "(multiple choices possible)" : "")];
+    const loop = (items, indent) => {
+        if (!Array.isArray(items)) {
+            return;
+        }
+        for (const entry of items) {
+            const label = entry.label || entry.value;
+            if (!label) {
+                continue;
+            }
+            lines.push(`${" ".repeat(indent)}- ${label}`);
+            if (entry.items?.length) {
+                loop(entry.items, indent + 4);
+            }
+        }
+    };
+    loop(choices, 4);
+    lines.push("");
+    const xSchemaPath = `#/schema.properties.${key}`;
+    if (property["x-choices"] || property["items"]?.["x-choices"]) {
+        const xChoicesPath = property.type === "array" ? `${xSchemaPath}.items.x-choices` : `${xSchemaPath}.x-choices`;
+        lines.push(`> LLM note only: labels/values mapping is here \`${xChoicesPath}\` and schema is here \`${xSchemaPath}\``);
+        lines.push("");
+    }
+    else {
+        lines.push(`> LLM note only: schema is here \`${xSchemaPath}\``);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function buildInstructions(schema) {
+    const properties = schema.properties || {};
+    return Object.entries(properties)
+        .map(([key, definition], index) => {
+        const property = definition;
+        const result = buildSection(key, property);
+        return result ? `${index + 1}) ${result}` : property;
+    })
+        .join("\n");
+}
+export const initOptionsResource = defineResource({
+    name: "init-options",
+    uri: "tsed://init/options",
+    title: "Inspect Ts.ED init options",
+    description: "Returns curated Ts.ED init instructions plus the machine-readable schema so assistants can gather user preferences then call `init-project`. Show humans only the labels; use the provided mapping to translate back to enum values.",
+    mimeType: "application/json",
+    async handler(uri) {
+        const rawSchema = InitMCPSchema().omit("cwd", "tsedVersion").toJSON({
+            useAlias: false,
+            customKeys: true
+        });
+        const schema = stripCliFlags(rawSchema);
+        const payload = {
+            instructions: buildInstructions(schema),
+            schema
+        };
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(payload, null, 2)
+                }
+            ]
+        };
+    }
+});

package/lib/esm/commands/mcp/resources/projectInfoResource.js

@@ -0,0 +1,43 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, normalize, resolve } from "node:path";
+import { ProjectPackageJson } from "@tsed/cli-core";
+import { defineResource, defineTool } from "@tsed/cli-mcp";
+import { constant, inject } from "@tsed/di";
+import { array, object, s, string } from "@tsed/schema";
+import { ProjectPreferenceSchema } from "../schema/ProjectPreferencesSchema.js";
+function resolveCwd(cwd) {
+    const projectPackage = inject(ProjectPackageJson);
+    const base = cwd || projectPackage.cwd || process.cwd();
+    const abs = isAbsolute(base) ? base : resolve(process.cwd(), base);
+    return normalize(abs);
+}
+export const projectInfoResource = defineResource({
+    name: "project-info",
+    uri: "tsed://project/info",
+    title: "Inspect project information",
+    description: "Read project information like cwd, package.json, preferences and if it's an initialised Ts.ED",
+    mimeType: "application/json",
+    async handler(uri) {
+        const projectPackage = inject(ProjectPackageJson);
+        const info = {
+            cwd: projectPackage.cwd,
+            pkg: projectPackage.toJSON(),
+            isInitialized: !!projectPackage.preferences?.packageManager,
+            preferences: {
+                convention: projectPackage.preferences.convention,
+                packageManager: projectPackage.preferences.packageManager,
+                platform: projectPackage.preferences.platform,
+                runtime: projectPackage.preferences.runtime
+            }
+        };
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(info, null, 2)
+                }
+            ]
+        };
+    }
+});

package/lib/esm/commands/mcp/resources/serverInfoResource.js

@@ -0,0 +1,40 @@
+import { ProjectPackageJson } from "@tsed/cli-core";
+import { defineResource } from "@tsed/cli-mcp";
+import { constant, inject } from "@tsed/di";
+async function getMcpVersion() {
+    try {
+        // best effort: resolve MCP SDK version via package.json resolution
+        const mcpPkg = await import("@modelcontextprotocol/sdk/package.json", { with: { type: "json" } }).catch(() => undefined);
+        return mcpPkg?.version;
+    }
+    catch {
+        // ignore
+    }
+}
+export const serverInfoResource = defineResource({
+    name: "server-info",
+    uri: "tsed://server/info",
+    title: "Server information",
+    description: "Process and environment information for the Ts.ED MCP server.",
+    mimeType: "application/json",
+    async handler(uri) {
+        const projectPackage = inject(ProjectPackageJson);
+        const info = {
+            pid: process.pid,
+            serverCwd: process.cwd(),
+            projectCwd: inject(ProjectPackageJson).cwd,
+            tsedCliVersion: constant("version"),
+            mcpSdkVersion: await getMcpVersion(),
+            projectExists: !!projectPackage.preferences?.packageManager
+        };
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(info, null, 2)
+                }
+            ]
+        };
+    }
+});

package/lib/esm/commands/mcp/schema/InitMCPSchema.js

@@ -0,0 +1,9 @@
+import { s } from "@tsed/schema";
+import { InitSchema } from "../../init/config/InitSchema.js";
+export const InitMCPSchema = () => {
+    return s
+        .object({
+        cwd: s.string().required().description("Current working directory to initialize Ts.ED project")
+    })
+        .merge(InitSchema().omit("root", "skipPrompt", "file", "GH_TOKEN"));
+};

package/lib/esm/commands/mcp/schema/ProjectPreferencesSchema.js

@@ -0,0 +1,16 @@
+import { PackageManager } from "@tsed/cli-core";
+import { s } from "@tsed/schema";
+import { PlatformType } from "../../../interfaces/PlatformType.js";
+import { ProjectConvention } from "../../../interfaces/ProjectConvention.js";
+export const ProjectPreferenceSchema = s
+    .object({
+    convention: s.string().enum(ProjectConvention).description("Project convention (Ts.ED or Angular style)"),
+    packageManager: s.string().enum(PackageManager).description("Used project manager to install dependencies"),
+    runtime: s
+        .string()
+        .enum("node", "babel", "swc", "webpack", "bun")
+        .description("The javascript runtime used to start application (node, node + webpack, node + swc, node + babel, bun)"),
+    platform: s.string().enum(PlatformType).description("Node.js framework used to run server (Express, Koa, Fastify)")
+})
+    .optional()
+    .description("Resolved project preferences");

package/lib/esm/commands/mcp/tools/generateTool.js

@@ -0,0 +1,105 @@
+import { ProjectPackageJson, validate } from "@tsed/cli-core";
+import { defineTool } from "@tsed/cli-mcp";
+import { inject } from "@tsed/di";
+import { array, number, object, string } from "@tsed/schema";
+import { CliProjectService } from "../../../services/CliProjectService.js";
+import { CliTemplatesService } from "../../../services/CliTemplatesService.js";
+import { mapDefaultTemplateOptions } from "../../../services/mappers/mapDefaultTemplateOptions.js";
+export const generateTool = defineTool({
+    name: "generate-file",
+    title: "Generate file",
+    description: "Generate a new Ts.ED provider class depending on the given parameters.",
+    inputSchema: object({
+        id: string().required().description("The template id of the file to generate (e.g., 'controller', 'service', 'model')."),
+        name: string().required().description("The name of the class to generate."),
+        properties: object()
+            .unknown()
+            .optional()
+            .description("Additional properties to generate file depending on the given template id. For example controller accept extra properties. Run 'list-templates' and/or 'get-template' to discover extra properties available for the template.")
+            .default({})
+    }),
+    outputSchema: object({
+        files: array().items(string()).description("List of generated files."),
+        count: number().description("Number of files generated."),
+        symbolPath: string().optional().description("Main generated symbol path"),
+        logs: array().items(string()).optional().description("Execution logs"),
+        warnings: array().items(string()).optional().description("Non blocking warnings")
+    }),
+    async handler({ id, name, properties }) {
+        const projectService = inject(CliProjectService);
+        const templates = inject(CliTemplatesService);
+        const projectPackage = inject(ProjectPackageJson);
+        // Pre-checks
+        const warnings = [];
+        if (!projectPackage.cwd) {
+            return {
+                content: [],
+                isError: true,
+                structuredContent: {
+                    code: "E_CWD_NOT_SET",
+                    message: "Workspace is not set. Call set-workspace first to define the project root.",
+                    suggestion: "Call 'set-workspace' with the project directory, then retry 'generate-file'."
+                }
+            };
+        }
+        if (!projectPackage.preferences?.packageManager) {
+            return {
+                content: [],
+                isError: true,
+                structuredContent: {
+                    code: "E_PROJECT_NOT_INITIALIZED",
+                    message: "The target directory does not appear to be an initialized Ts.ED project.",
+                    suggestion: "Run 'init-project' to initialize a Ts.ED project in this workspace before generating files, or use 'set-workspace' to configure the tool to point to the appropriate working directory."
+                }
+            };
+        }
+        const ctx = mapDefaultTemplateOptions({ ...properties, type: id, name });
+        const { type } = ctx;
+        // Validate template exists
+        const template = inject(CliTemplatesService).get(type);
+        if (!template) {
+            return {
+                content: [],
+                isError: true,
+                structuredContent: {
+                    code: "E_TEMPLATE_UNKNOWN",
+                    message: `Unknown template type '${type}'.`,
+                    suggestion: "Use 'list-templates' to discover available template types."
+                }
+            };
+        }
+        // validate the schema of the resolved template
+        if (template.schema && properties) {
+            const { isValid, errors } = validate(properties, template.schema);
+            if (!isValid) {
+                return {
+                    content: [],
+                    isError: true,
+                    structuredContent: {
+                        code: "E_ARGS_INVALID",
+                        message: `Invalid arguments for template '${type}'.`,
+                        suggestion: "Call 'get-template' to inspect required fields and formats, then retry.",
+                        details: { errors }
+                    }
+                };
+            }
+        }
+        await projectService.createFromTemplate(type, ctx);
+        await projectService.transformFiles(ctx);
+        const rendered = templates.getRenderedFiles();
+        const files = rendered.map((f) => f.outputPath);
+        const count = files.length;
+        const symbolPath = ctx.symbolPath || rendered[0]?.symbolPath || rendered[0]?.outputPath;
+        const logs = [`createFromTemplate:${type}`, `transformFiles:done`, `files:${count}`];
+        return {
+            content: [],
+            structuredContent: {
+                files,
+                count,
+                symbolPath,
+                logs,
+                warnings: warnings.length ? warnings : undefined
+            }
+        };
+    }
+});