@tsed/cli 7.0.0-beta.1 → 7.0.0-beta.3

package/lib/esm/bin/tsed-mcp.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import "@swc-node/register/esm-register";
+import { register } from "node:module";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { CLIMCPServer } from "@tsed/cli-mcp";
+const EXT = process.env.CLI_MODE === "ts" ? "ts" : "js";
+register(pathToFileURL(join(import.meta.dirname, `../loaders/alias.hook.${EXT}`)), {
+    parentURL: import.meta.dirname,
+    data: {
+        "@tsed/core": import.meta.resolve("@tsed/core"),
+        "@tsed/di": import.meta.resolve("@tsed/di"),
+        "@tsed/schema": import.meta.resolve("@tsed/schema"),
+        "@tsed/cli-core": import.meta.resolve("@tsed/cli-core"),
+        "@tsed/cli": import.meta.resolve("@tsed/cli")
+    },
+    transferList: []
+});
+const { tools, resources, PKG, TEMPLATE_DIR, ArchitectureConvention, ProjectConvention } = await import("../index.js");
+CLIMCPServer.bootstrap({
+    name: "tsed",
+    version: PKG.version,
+    pkg: PKG,
+    templateDir: TEMPLATE_DIR,
+    tools,
+    resources,
+    mcp: {
+        mode: process.env.args?.includes("--http") || process.env.USE_MCP_HTTP ? "streamable-http" : "stdio"
+    },
+    defaultProjectPreferences() {
+        return {
+            convention: ProjectConvention.DEFAULT,
+            architecture: ArchitectureConvention.DEFAULT
+        };
+    },
+    project: {
+        reinstallAfterRun: true
+    }
+}).catch((error) => {
+    console.error(error);
+    process.exit(-1);
+});

package/lib/esm/commands/init/InitCmd.js

@@ -17,7 +17,7 @@ import { BunRuntime } from "../../runtimes/supports/BunRuntime.js";
 import { NodeRuntime } from "../../runtimes/supports/NodeRuntime.js";
 import { CliProjectService } from "../../services/CliProjectService.js";
 import { FeaturesMap, FeatureType } from "./config/FeaturesPrompt.js";
-import { InitFileSchema } from "./config/InitFileSchema.js";
+import { InitSchema } from "./config/InitSchema.js";
 import { mapToContext } from "./mappers/mapToContext.js";
 import { getFeaturesPrompt } from "./prompts/getFeaturesPrompt.js";
 export class InitCmd {
@@ -64,10 +64,10 @@ export class InitCmd {
     }
     async $beforePrompt(initialOptions) {
         if (initialOptions.file) {
-            const file = join(this.packageJson.dir, initialOptions.file);
+            const file = join(this.packageJson.cwd, initialOptions.file);
             return {
                 ...initialOptions,
-                ...(await this.cliLoadFile.loadFile(file, InitFileSchema))
+                ...(await this.cliLoadFile.loadFile(file, InitSchema))
             };
         }
         return initialOptions;
@@ -109,13 +109,13 @@ export class InitCmd {
         };
     }
     async $beforeExec(ctx) {
-        this.fs.ensureDirSync(this.packageJson.dir);
+        this.fs.ensureDirSync(this.packageJson.cwd);
         ctx.projectName && (this.packageJson.name = ctx.projectName);
         ctx.packageManager && this.packageJson.setPreference("packageManager", ctx.packageManager);
         ctx.runtime && this.packageJson.setPreference("runtime", ctx.runtime);
         ctx.architecture && this.packageJson.setPreference("architecture", ctx.architecture);
         ctx.convention && this.packageJson.setPreference("convention", ctx.convention);
-        ctx.platform && this.packageJson.setPreference("platform", ctx.convention);
+        ctx.platform && this.packageJson.setPreference("platform", ctx.platform);
         ctx.GH_TOKEN && this.packageJson.setGhToken(ctx.GH_TOKEN);
         await createTasksRunner([
             {
@@ -213,15 +213,15 @@ export class InitCmd {
         ];
     }
     resolveRootDir(ctx) {
-        const rootDirName = kebabCase(ctx.projectName || basename(this.packageJson.dir));
-        if (this.packageJson.dir.endsWith(rootDirName)) {
+        const rootDirName = kebabCase(ctx.projectName || basename(this.packageJson.cwd));
+        if (this.packageJson.cwd.endsWith(rootDirName)) {
             ctx.projectName = ctx.projectName || rootDirName;
             ctx.root = ".";
             return;
         }
         ctx.projectName = ctx.projectName || rootDirName;
         if (ctx.root && ctx.root !== ".") {
-            this.packageJson.dir = join(this.packageJson.dir, rootDirName);
+            this.packageJson.setCWD(join(this.packageJson.cwd, rootDirName));
             ctx.root = ".";
         }
     }
@@ -230,7 +230,7 @@ export class InitCmd {
         if (ctx.eslint || ctx.testing) {
             const runtime = this.runtimes.get();
             const scripts = {
-                test: [ctx.eslint && runtime.run("test:lint"), ctx.testing && runtime.run("test:coverage")].filter(Boolean).join("&&")
+                test: [ctx.eslint && runtime.run("test:lint"), ctx.testing && runtime.run("test:coverage")].filter(Boolean).join(" && ")
             };
             this.packageJson.addScripts(scripts);
         }

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

@@ -0,0 +1,27 @@
+import { PackageManager } from "@tsed/cli-core";
+import { s } from "@tsed/schema";
+import { ArchitectureConvention, PlatformType, ProjectConvention } from "../../../interfaces/index.js";
+import { FeatureType } from "./FeaturesPrompt.js";
+export const InitSchema = s
+    .object({
+    tsedVersion: s.string().optional().description("The CLI will use the given tsed version to generate the project"),
+    projectName: s.string().optional().description("The project name"),
+    platform: s
+        .string()
+        .enum(PlatformType)
+        .default(PlatformType.EXPRESS)
+        .description("Node.js framework used to run server (Express, Koa, Fastify)"),
+    convention: s
+        .string()
+        .enum(ProjectConvention)
+        .default(ProjectConvention.DEFAULT)
+        .description("Project convention (Ts.ED or Angular style)"),
+    packageManager: s.string().enum(PackageManager).default(PackageManager.NPM).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)"),
+    features: s.array().items(s.string().enum(FeatureType)).required().minItems(1).description("List of feature to create the projet"),
+    skipPrompt: s.boolean().default(false).description("Skip the prompt")
+})
+    .unknown();

package/lib/esm/index.js

@@ -1,5 +1,6 @@
 import "@tsed/logger-std";
 import "./templates/index.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";
@@ -12,6 +13,8 @@ export * from "./constants/index.js";
 export * from "./fn/exec.js";
 export * from "./fn/render.js";
 export * from "./interfaces/index.js";
+export { default as resources } from "./mcp/resources/index.js";
+export { default as tools } from "./mcp/tools/index.js";
 export * from "./pipes/index.js";
 export * from "./runtimes/index.js";
 export * from "./services/CliProjectService.js";

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

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

package/lib/esm/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/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/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/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
+            }
+        };
+    }
+});

package/lib/esm/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/mcp/tools/index.js

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

package/lib/esm/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/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/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,16 +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.renderedFiles = [];
     }
+    // readonly renderedFiles: TemplateRenderReturnType[] = [];
     #customTemplates;
+    get rootDir() {
+        return constant("project.rootDir", "");
+    }
     get srcDir() {
         return join(...[this.rootDir, constant("project.srcDir")].filter(Boolean));
     }
@@ -111,8 +113,15 @@ export class CliTemplatesService {
             }
         }
     }
+    getRenderedFiles() {
+        const $ctx = context();
+        if (!$ctx?.has("renderedFiles")) {
+            $ctx?.set("renderedFiles", []);
+        }
+        return $ctx?.get("renderedFiles") || [];
+    }
     pushRenderResult(renderedFile) {
-        this.renderedFiles.push(renderedFile);
+        this.getRenderedFiles().push(renderedFile);
         return renderedFile;
     }
 }