@tsed/cli 7.0.0-beta.2 → 7.0.0-beta.4

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,3 @@
+import { projectInfoResource } from "./projectInfoResource.js";
+import { serverInfoResource } from "./serverInfoResource.js";
+export default [serverInfoResource, projectInfoResource];

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", "skipPrompts", "file"));
+};

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
+            }
+        };
+    }
+});

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,7 @@
+import { projectInfoResource } from "../resources/projectInfoResource.js";
+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, projectInfoResource, listTemplatesTool, getTemplateTool, generateTool, initProjectTool];

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

@@ -0,0 +1,65 @@
+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 (sans Listr/logs).",
+    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
+        };
+        cliService.load();
+        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

@@ -16,7 +16,8 @@ export class RunCmd {
         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,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";
@@ -7,6 +8,8 @@ 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";

package/lib/esm/services/CliProjectService.js

@@ -34,8 +34,10 @@ export class CliProjectService {
         this.project = new ProjectClient({
             rootDir: this.rootDir
         });
-        const files = fs.globSync(["!**/node_modules/**", join(this.rootDir, "**/*.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,14 +1,14 @@
 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.fs = inject(CliFs);
-        this.renderedFiles = [];
     }
+    // readonly renderedFiles: TemplateRenderReturnType[] = [];
     #customTemplates;
     get rootDir() {
         return constant("project.rootDir", "");
@@ -113,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;
     }
 }

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,9 +9,6 @@ export default defineTemplate({
     outputDir: ".",
     hidden: true,
     preserveCase: true,
-    prompts() {
-        return [];
-    },
     render(_, context) {
         const barrels = $alter("$alterBarrels", {
             directory: [