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

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

@@ -0,0 +1,47 @@
+import { defineTool } from "@tsed/cli-mcp";
+import { inject } from "@tsed/di";
+import { s } from "@tsed/schema";
+import { CliTemplatesService } from "../../../services/CliTemplatesService.js";
+import { resolveSchema } from "../../../utils/resolveSchema.js";
+export const getTemplateTool = defineTool({
+    name: "get-template",
+    title: "Get template",
+    description: "Return full information for a template including its JSON schema (if provided).",
+    inputSchema: s.object({
+        id: s.string().required().description("Template id (e.g., 'controller', 'service')")
+    }),
+    outputSchema: s.object({
+        id: s.string().description("Template id"),
+        label: s.string().description("Template label"),
+        description: s.string().optional().description("Template description"),
+        schema: s
+            .object()
+            .optional()
+            .description("Additional properties to provide to generate-file tool for this template (beyond the global 'id' and 'name' fields)")
+    }),
+    async handler(args) {
+        const { id } = args;
+        const templates = inject(CliTemplatesService);
+        const tpl = templates.get(id);
+        if (!tpl) {
+            return {
+                content: [],
+                isError: true,
+                structuredContent: {
+                    code: "E_TEMPLATE_UNKNOWN",
+                    message: `Unknown template id '${id}'.`,
+                    suggestion: "Use 'list-templates' to discover available template types."
+                }
+            };
+        }
+        return {
+            content: [],
+            structuredContent: {
+                id: tpl.id,
+                label: tpl.label,
+                description: tpl.description,
+                schema: await resolveSchema(tpl.schema)
+            }
+        };
+    }
+});

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

@@ -0,0 +1,6 @@
+import { generateTool } from "./generateTool.js";
+import { getTemplateTool } from "./getTemplateTool.js";
+import { initProjectTool } from "./initProjectTool.js";
+import { listTemplatesTool } from "./listTemplatesTool.js";
+import { setWorkspaceTool } from "./setWorkspaceTool.js";
+export default [setWorkspaceTool, listTemplatesTool, getTemplateTool, generateTool, initProjectTool];

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

@@ -0,0 +1,64 @@
+import { CliService, ProjectPackageJson } from "@tsed/cli-core";
+import { defineTool } from "@tsed/cli-mcp";
+import { context, inject } from "@tsed/di";
+import { s } from "@tsed/schema";
+import { CliTemplatesService } from "../../../services/CliTemplatesService.js";
+import { InitMCPSchema } from "../schema/InitMCPSchema.js";
+export const initProjectTool = defineTool({
+    name: "init-project",
+    title: "Initialize Ts.ED project",
+    description: "Initialize a new Ts.ED project in the current workspace. Fetch `tsed://init/options`, ask the user which platform, features, and other options they want, then pass the selected values here along with `cwd`.",
+    inputSchema: InitMCPSchema,
+    outputSchema: s.object({
+        files: s.array().items(s.string()).description("List of generated files."),
+        count: s.number().description("Number of files generated."),
+        projectName: s.string().optional().description("Resolved project name."),
+        cwd: s.string().optional().description("Resolved workspace directory in which the project was initialized."),
+        logs: s.array().items(s.string()).optional().description("Execution logs"),
+        warnings: s.array().items(s.string()).optional().description("Non blocking warnings")
+    }),
+    async handler(input) {
+        const cliService = inject(CliService);
+        const projectPackage = inject(ProjectPackageJson);
+        const templates = inject(CliTemplatesService);
+        projectPackage.setCWD(input.cwd);
+        // If the current workspace already looks initialized, block to prevent accidental re-init
+        if (projectPackage.preferences?.packageManager) {
+            return {
+                content: [],
+                isError: true,
+                structuredContent: {
+                    code: "E_PROJECT_ALREADY_INITIALIZED",
+                    message: "This workspace already appears to be an initialized Ts.ED project.",
+                    suggestion: "Use 'generate-file' to add new files, or call 'set-workspace' with a different folder to initialize a new project."
+                }
+            };
+        }
+        const warnings = [];
+        // Build options and map context (skip prompts by default)
+        const initialOptions = {
+            skipPrompt: true,
+            ...input
+        };
+        await cliService.exec("init", initialOptions, context());
+        // Collect rendered files from templates service (same pattern as generateTool)
+        const rendered = templates.getRenderedFiles();
+        const files = rendered.map((f) => f.outputPath);
+        const logs = [
+            `init:root:${projectPackage.cwd ?? "."}`,
+            `init:platform:${projectPackage.preferences.platform}`,
+            `files:${files.length}`
+        ];
+        return {
+            content: [],
+            structuredContent: {
+                files,
+                count: files.length,
+                projectName: projectPackage.name,
+                cwd: projectPackage.cwd,
+                logs,
+                warnings: warnings.length ? warnings : undefined
+            }
+        };
+    }
+});

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

@@ -0,0 +1,37 @@
+import { defineTool } from "@tsed/cli-mcp";
+import { inject } from "@tsed/di";
+import { array, object, string } from "@tsed/schema";
+import { CliTemplatesService } from "../../../services/CliTemplatesService.js";
+import { summarizeSchema } from "../../../utils/summarizeSchema.js";
+export const listTemplatesTool = defineTool({
+    name: "list-templates",
+    title: "List templates",
+    description: "List available Ts.ED templates for generation (tsed generate). Optionally filter by type substring.",
+    inputSchema: object({
+        search: string().description("Filter by template id/label substring (case-insensitive).")
+    }),
+    outputSchema: object({
+        items: array().items(object({
+            id: string(),
+            label: string().optional(),
+            description: string().optional(),
+            required: array().items(string()).optional(),
+            properties: object().optional()
+        }))
+    }),
+    async handler(args) {
+        const { search } = args || {};
+        const templates = inject(CliTemplatesService);
+        return {
+            content: [],
+            structuredContent: {
+                items: templates.find(search).map((tpl) => ({
+                    id: tpl.id,
+                    label: tpl.label,
+                    description: tpl.description,
+                    ...summarizeSchema(tpl)
+                }))
+            }
+        };
+    }
+});

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

@@ -0,0 +1,64 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, normalize, resolve } from "node:path";
+import { CliFs, PackageManager, ProjectPackageJson } from "@tsed/cli-core";
+import { defineTool } from "@tsed/cli-mcp";
+import { inject } from "@tsed/di";
+import { s } from "@tsed/schema";
+import { ProjectPreferenceSchema } from "../schema/ProjectPreferencesSchema.js";
+function normalizeCwd(input) {
+    const abs = isAbsolute(input) ? input : resolve(process.cwd(), input);
+    return normalize(abs);
+}
+/**
+ * Simplified behavior per MVP:
+ * - If the provided cwd exists: set it, resolve the nearest package.json root via ProjectPackageJson, return that resolved cwd.
+ * - If the provided cwd does not exist: do not create anything; return an error suggesting to confirm creation and run init-project.
+ */
+export const setWorkspaceTool = defineTool({
+    name: "set-workspace",
+    title: "Set workspace",
+    description: "Define the workspace (current working directory) for subsequent operations. Mirrors the -r option of tsed CLI. If the path exists, returns the resolved project root (nearest package.json). If it doesn't, asks to confirm creation and use init-project.",
+    inputSchema: s.object({
+        cwd: s.string().required().description("Absolute or relative path to use as workspace root.")
+    }),
+    outputSchema: s.object({
+        cwd: s.string().description("Resolved project root (nearest package.json directory or the provided path)."),
+        packageJson: s.object().optional().description("Resolved package json"),
+        preferences: ProjectPreferenceSchema
+    }),
+    async handler(args) {
+        const { cwd: raw } = args;
+        const cwd = normalizeCwd(raw);
+        const fs = inject(CliFs);
+        const projectPackage = inject(ProjectPackageJson);
+        if (fs.exists(cwd)) {
+            // Set the base CWD for the CLI services (this resolves to nearest package.json)
+            projectPackage.setCWD(cwd);
+            // Resolved project root
+            const resolved = projectPackage.cwd;
+            return {
+                content: [],
+                structuredContent: {
+                    cwd: resolved,
+                    pkg: projectPackage.toJSON(),
+                    preferences: {
+                        convention: projectPackage.preferences.convention,
+                        packageManager: projectPackage.preferences.packageManager,
+                        platform: projectPackage.preferences.platform,
+                        runtime: projectPackage.preferences.runtime
+                    }
+                }
+            };
+        }
+        return {
+            content: [],
+            isError: true,
+            structuredContent: {
+                cwd,
+                code: "E_CWD_NOT_FOUND",
+                message: `Directory '${cwd}' does not exist.`,
+                suggestion: "Confirm you want to create this folder, then call 'init-project' with { cwd: '<path>', ... } to scaffold a new Ts.ED project."
+            }
+        };
+    }
+});

package/lib/esm/commands/run/RunCmd.js

@@ -1,4 +1,5 @@
 import { CliFs, command, inject, normalizePath, ProjectPackageJson } from "@tsed/cli-core";
+import { logger } from "@tsed/di";
 import { CliRunScript } from "../../services/CliRunScript.js";
 export class RunCmd {
     constructor() {
@@ -10,13 +11,15 @@ export class RunCmd {
         const cmd = "node";
         const args = ["--import", "@swc-node/register/esm-register"];
         const path = normalizePath("src/bin/index.ts");
+        logger().info(`Run ${cmd} ${[...args, path, ctx.command, ...ctx.rawArgs].join(" ")}`);
         await this.runScript.run(cmd, [...args, path, ctx.command, ...ctx.rawArgs], {
             env: process.env
         });
         return [];
     }
 }
-command(RunCmd, {
+command({
+    token: RunCmd,
     name: "run",
     description: "Run a project level command",
     args: {

package/lib/esm/commands/template/CreateTemplateCommand.js

@@ -79,7 +79,8 @@ export class CreateTemplateCommand {
         ];
     }
 }
-command(CreateTemplateCommand, {
+command({
+    token: CreateTemplateCommand,
     name: "template",
     description: "Create a custom template that can be selected in tsed generate command",
     args: {

package/lib/esm/commands/update/UpdateCmd.js

@@ -97,9 +97,8 @@ export class UpdateCmd {
         return version && isGreaterThan(version, this.cliPackage.version) ? version : this.cliPackage.version;
     }
 }
-command(UpdateCmd, {
+command({
+    token: UpdateCmd,
     name: "update",
-    description: "Update all Ts.ED packages used by your project",
-    args: {},
-    options: {}
+    description: "Update all Ts.ED packages used by your project"
 });

package/lib/esm/index.js

@@ -1,11 +1,15 @@
+import "@tsed/logger-std";
 import "./templates/index.js";
-export * from "./Cli.js";
+import "./services/CliStats.js";
 export * from "./commands/add/AddCmd.js";
 export * from "./commands/generate/GenerateCmd.js";
+export { default as commands } from "./commands/index.js";
 export * from "./commands/init/config/FeaturesPrompt.js";
 export * from "./commands/init/config/FeaturesPrompt.js";
 export * from "./commands/init/InitCmd.js";
 export * from "./commands/init/prompts/getFeaturesPrompt.js";
+export { default as resources } from "./commands/mcp/resources/index.js";
+export { default as tools } from "./commands/mcp/tools/index.js";
 export * from "./commands/update/UpdateCmd.js";
 export * from "./constants/index.js";
 export * from "./fn/exec.js";
@@ -17,3 +21,4 @@ export * from "./services/CliProjectService.js";
 export * from "./services/CliTemplatesService.js";
 export * from "./services/ProjectClient.js";
 export * from "./utils/defineTemplate.js";
+export { CliCore } from "@tsed/cli-core";

package/lib/esm/processors/transformConfigFile.js

@@ -6,7 +6,7 @@ export function transformConfigFile(project, data) {
     }
     if (data.config) {
         if (data.configDotenv) {
-            project.addConfigSource("DotenvConfigSource", {
+            project.addConfigSource("DotEnvsConfigSource", {
                 moduleSpecifier: "@tsed/config/dotenv"
             });
         }

package/lib/esm/processors/transformServerFile.js

@@ -49,12 +49,10 @@ export function transformServerFile(project, data) {
         });
         project.addNamespaceImport(sourceFile, isFeature ? "./rest/index.js" : "./controllers/rest/index.js", "rest");
         project.addMountPath(data.route || "/rest", "...Object.values(rest)");
-        if (data.swagger || data.oidc) {
-            sourceFile.addImportDeclaration({
-                moduleSpecifier: isFeature ? "./pages/index.js" : "./controllers/pages/index.js",
-                namespaceImport: "pages"
-            });
-            project.addMountPath("/", "...Object.values(pages)");
-        }
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: isFeature ? "./pages/index.js" : "./controllers/pages/index.js",
+            namespaceImport: "pages"
+        });
+        project.addMountPath("/", "...Object.values(pages)");
     }
 }

package/lib/esm/services/CliProjectService.js

@@ -15,7 +15,9 @@ import { CliTemplatesService } from "./CliTemplatesService.js";
 export class CliProjectService {
     constructor() {
         this.templates = inject(CliTemplatesService);
-        this.rootDir = constant("project.rootDir", process.cwd());
+    }
+    get rootDir() {
+        return constant("project.rootDir", "");
     }
     get srcDir() {
         return join(...[this.rootDir, constant("project.srcDir")].filter(Boolean));
@@ -32,8 +34,10 @@ export class CliProjectService {
         this.project = new ProjectClient({
             rootDir: this.rootDir
         });
-        const files = fs.globSync(["!**/node_modules/**", join(constant("project.rootDir", process.cwd()), "**/*.ts")]);
-        files.forEach((file) => {
+        const files = fs.globSync([join(this.rootDir, "**/*.ts"), "!node_modules", "!node_modules/**", "!**/node_modules/**"]);
+        files
+            .filter((file) => !file.includes("node_modules"))
+            .forEach((file) => {
             this.project.createSourceFile(file, fs.readFileSync(file, "utf8"), {
                 overwrite: true
             });

package/lib/esm/services/CliStats.js

@@ -0,0 +1,45 @@
+import { CliHttpClient, ProjectPackageJson } from "@tsed/cli-core";
+import { constant, inject, injectable } from "@tsed/di";
+import * as os from "os";
+export class CliStats extends CliHttpClient {
+    constructor() {
+        super(...arguments);
+        this.disabled = constant("stats.disabled", false);
+        this.host = constant("stats.url", "https://api.tsed.dev");
+        this.projectPackage = inject(ProjectPackageJson);
+    }
+    sendInit(opts) {
+        if (!this.disabled) {
+            const data = {
+                features: [],
+                is_success: true,
+                ...opts,
+                os: os.type(),
+                convention: this.projectPackage.preferences.convention === "conv_default" ? "tsed" : "angular",
+                platform: this.projectPackage.preferences.platform,
+                package_manager: this.projectPackage.preferences.packageManager,
+                runtime: this.projectPackage.preferences.runtime,
+                channel: opts.channel || "cli",
+                cli_version: constant("version", ""),
+                tsed_version: this.projectPackage.dependencies["@tsed/platform-http"]
+            };
+            return this.post("/rest/cli/stats", {
+                data
+            }).catch((er) => {
+                return null;
+            });
+        }
+    }
+    $onFinish(data, er) {
+        if (data.commandName === "init") {
+            return this.sendInit({
+                channel: "cli",
+                is_success: !er,
+                features: data.features
+            });
+        }
+    }
+    onSuccess(options) { }
+    onError(error, options) { }
+}
+injectable(CliStats);

package/lib/esm/services/CliTemplatesService.js

@@ -1,17 +1,18 @@
 import { join } from "node:path";
 import { CliFs } from "@tsed/cli-core";
-import { constant, inject, injectable, injectMany, logger } from "@tsed/di";
+import { constant, context, inject, injectable, injectMany, logger } from "@tsed/di";
 import { globby } from "globby";
 import { TEMPLATE_DIR } from "../constants/index.js";
 import { mapDefaultTemplateOptions } from "./mappers/mapDefaultTemplateOptions.js";
 export class CliTemplatesService {
     constructor() {
-        this.rootDir = constant("project.rootDir", process.cwd());
         this.fs = inject(CliFs);
-        this.#templates = new Map();
     }
+    // readonly renderedFiles: TemplateRenderReturnType[] = [];
     #customTemplates;
-    #templates;
+    get rootDir() {
+        return constant("project.rootDir", "");
+    }
     get srcDir() {
         return join(...[this.rootDir, constant("project.srcDir")].filter(Boolean));
     }
@@ -89,7 +90,7 @@ export class CliTemplatesService {
                 template.fileName?.replace("{{symbolName}}", opts.symbolName)?.replace("{{srcDir}}", this.srcDir) ||
                 opts.symbolName;
             const outputPath = `${filePath}${template.ext ? "." + template.ext : ""}`;
-            return {
+            return this.pushRenderResult({
                 templateId,
                 content: render,
                 outputPath,
@@ -97,20 +98,31 @@ export class CliTemplatesService {
                 symbolName: opts.symbolName,
                 symbolPath: opts.symbolPath,
                 symbolPathBasename: opts.symbolPathBasename
-            };
+            });
         }
         else {
             const from = data.from || TEMPLATE_DIR;
             const fromPath = join(from, templateId.replace("{{srcDir}}", "src"));
             if (await this.fs.fileExists(fromPath)) {
                 const content = await inject(CliFs).readFile(fromPath);
-                return {
+                return this.pushRenderResult({
                     templateId,
                     content,
                     outputPath: templateId.replace("{{srcDir}}", constant("project.srcDir", ""))
-                };
+                });
             }
         }
     }
+    getRenderedFiles() {
+        const $ctx = context();
+        if (!$ctx?.has("renderedFiles")) {
+            $ctx?.set("renderedFiles", []);
+        }
+        return $ctx?.get("renderedFiles") || [];
+    }
+    pushRenderResult(renderedFile) {
+        this.getRenderedFiles().push(renderedFile);
+        return renderedFile;
+    }
 }
 injectable(CliTemplatesService);

package/lib/esm/templates/agents.template.js

@@ -0,0 +1,17 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+import { CliHttpClient } from "@tsed/cli-core";
+import { inject } from "@tsed/di";
+export default defineTemplate({
+    id: "agents",
+    label: "AGENTS.md",
+    description: "Create AGENTS.md designed for AI project and Ts.ED",
+    fileName: "AGENTS",
+    ext: "md",
+    outputDir: ".",
+    hidden: true,
+    preserveCase: true,
+    async render() {
+        const httpClient = inject(CliHttpClient);
+        return httpClient.get("https://tsed.dev/ai/AGENTS.md");
+    }
+});

package/lib/esm/templates/asyncFactory.template.js

@@ -3,12 +3,13 @@ import { camelCase, pascalCase } from "change-case";
 export default defineTemplate({
     id: "async.factory",
     label: "Async Factory",
+    description: "Generate an async factory token for Ts.ED DI in src/services.",
     fileName: "{{symbolName}}.factory?",
     outputDir: "{{srcDir}}/services",
     render(symbolName) {
         const camelName = camelCase(symbolName);
         const optName = pascalCase(symbolName + "Options");
-        return `import {injectable} from "@tsed/di";
+        return `import {injectable, constant} from "@tsed/di";
 
 interface ${optName} {
   
@@ -17,7 +18,7 @@ interface ${optName} {
 declare global {
   namespace TsED {
     interface Configuration extends Record<string, any> {
-      ${camelName}: Options;
+      ${camelName}: ${optName};
     }
   }
 }    
@@ -33,6 +34,6 @@ export const ${symbolName} = injectable(Symbol.for("${symbolName}"))
   })
   .token();
   
-export type {{symbolName}} = typeof ${symbolName};`;
+export type ${symbolName} = typeof ${symbolName};`;
     }
 });

package/lib/esm/templates/barrels.template.js

@@ -9,16 +9,9 @@ export default defineTemplate({
     outputDir: ".",
     hidden: true,
     preserveCase: true,
-    prompts() {
-        return [];
-    },
     render(_, context) {
         const barrels = $alter("$alterBarrels", {
-            directory: [
-                "./src/controllers/rest",
-                context.commands && "./src/bin/commands",
-                (context.swagger || context.oidc) && "./src/controllers/pages"
-            ].filter(Boolean),
+            directory: ["./src/controllers/rest", context.commands && "./src/bin/commands", "./src/controllers/pages"].filter(Boolean),
             exclude: ["**/__mock__", "**/__mocks__", "**/*.spec.ts"],
             delete: true
         });

package/lib/esm/templates/command.template.js

@@ -3,6 +3,7 @@ import { kebabCase } from "change-case";
 export default defineTemplate({
     id: "command",
     label: "Command",
+    description: "Create a CLI command provider with prompts, context mapping and tasks in src/bin/commands.",
     fileName: "{{symbolName}}.command",
     outputDir: "{{srcDir}}/bin/commands",
     render(symbolName) {

package/lib/esm/templates/controller.template.js

@@ -1,9 +1,16 @@
 import { defineTemplate } from "../utils/defineTemplate.js";
+import { object, string } from "@tsed/schema";
 export default defineTemplate({
     id: "controller",
     label: "Controller",
+    description: "Create a new controller class with a sample GET endpoint in src/controllers.",
     fileName: "{{symbolName}}.controller",
     outputDir: "{{srcDir}}/controllers",
+    // Validation schema specific to this template (do not include global fields `type` and `name`)
+    schema: object({
+        route: string().pattern(/^\//).description("Route starting with '/' (e.g., '/users')"),
+        directory: string().description("Sub-directory under src/controllers")
+    }),
     prompts(context) {
         return [
             {

package/lib/esm/templates/decorator.template.js

@@ -1,9 +1,30 @@
 import { defineTemplate } from "../utils/defineTemplate.js";
+import { s } from "@tsed/schema";
+const choices = [
+    { name: "Class Decorator", value: "class" },
+    { name: "Generic Decorator (class, property)", value: "generic" },
+    { name: "Method Decorator", value: "method" },
+    { name: "Parameter Decorator", value: "param" },
+    { name: "Property Decorator", value: "property" },
+    { name: "Property Decorator (with @Property)", value: "prop" },
+    { name: "Parameters Decorator", value: "parameters" },
+    { name: "Endpoint Decorator", value: "endpoint" },
+    { name: "Middleware Decorator", value: "middleware" }
+];
 export default defineTemplate({
     id: "decorator",
     label: "Decorator",
+    description: "Scaffold a custom decorator with variants (class, generic, method, parameter, property, endpoint, middleware) in src/decorators.",
     fileName: "{{symbolName}}",
     outputDir: "{{srcDir}}/decorators",
+    schema: s.object({
+        templateType: s
+            .string()
+            .enum("class", "generic", "method", "param", "property", "prop", "parameters", "endpoint", "middleware")
+            .customKey("x-choices", choices)
+            .default("class")
+            .description("sub-type of the template to generate the decorator")
+    }),
     prompts(context) {
         return [
             {
@@ -13,17 +34,7 @@ export default defineTemplate({
                 when(state) {
                     return !!(["decorator"].includes(state.type || context.type) || context.templateType);
                 },
-                choices: [
-                    { name: "Class Decorator", value: "class" },
-                    { name: "Generic Decorator (class, property)", value: "generic" },
-                    { name: "Method Decorator", value: "method" },
-                    { name: "Parameter Decorator", value: "param" },
-                    { name: "Property Decorator", value: "property" },
-                    { name: "Property Decorator (with @Property)", value: "prop" },
-                    { name: "Parameters Decorator", value: "parameters" },
-                    { name: "Endpoint Decorator", value: "endpoint" },
-                    { name: "Middleware Decorator", value: "middleware" }
-                ],
+                choices,
                 default: "class"
             }
         ];

package/lib/esm/templates/dockerfile.template.js

@@ -33,6 +33,7 @@ ENV NODE_ENV production`;
 defineTemplate({
     id: "dockerfile.yarn",
     label: "Dockerfile (Yarn classic)",
+    description: "Generate a multi-stage Dockerfile for production builds using Yarn classic.",
     fileName: "Dockerfile",
     outputDir: ".",
     ext: null,
@@ -72,6 +73,7 @@ CMD ["pm2-runtime", "start", "processes.config.cjs", "--env", "production"]
 defineTemplate({
     id: "dockerfile.yarn_berry",
     label: "Dockerfile (Yarn Berry)",
+    description: "Generate a multi-stage Dockerfile for production builds using Yarn Berry (modern Yarn).",
     fileName: "Dockerfile",
     outputDir: ".",
     ext: null,
@@ -114,6 +116,7 @@ CMD ["pm2-runtime", "start", "processes.config.cjs", "--env", "production"]
 defineTemplate({
     id: "dockerfile.npm",
     label: "Dockerfile (NPM)",
+    description: "Generate a multi-stage Dockerfile for production builds using NPM.",
     fileName: "Dockerfile",
     outputDir: ".",
     ext: null,
@@ -152,6 +155,7 @@ CMD ["pm2-runtime", "start", "processes.config.cjs", "--env", "production"]`;
 defineTemplate({
     id: "dockerfile.pnpm",
     label: "Dockerfile (PNPM)",
+    description: "Generate a multi-stage Dockerfile for production builds using PNPM.",
     fileName: "Dockerfile",
     outputDir: ".",
     ext: null,
@@ -191,6 +195,7 @@ CMD ["pm2-runtime", "start", "processes.config.cjs", "--env", "production"]
 defineTemplate({
     id: "dockerfile.bun",
     label: "Dockerfile (Bun)",
+    description: "Generate a multi-stage Dockerfile for production builds using Bun.",
     fileName: "Dockerfile",
     outputDir: ".",
     ext: null,

package/lib/esm/templates/exception-filter.template.js

@@ -2,6 +2,7 @@ import { defineTemplate } from "../utils/defineTemplate.js";
 export default defineTemplate({
     id: "exception-filter",
     label: "Exception Filter",
+    description: "Create an exception filter class annotated with @Catch to handle thrown errors in src/filters.",
     fileName: "{{symbolName}}.exception-filter",
     outputDir: "{{srcDir}}/filters",
     render(symbolName) {