opticore-feature-component 1.0.8 → 1.1.1

package/dist/cli.cjs

@@ -0,0 +1,3062 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/registerFeatureCommand.ts
+var registerFeatureCommand_exports = {};
+__export(registerFeatureCommand_exports, {
+  handleFeatureCliError: () => handleFeatureCliError,
+  registerFeatureCommand: () => registerFeatureCommand
+});
+module.exports = __toCommonJS(registerFeatureCommand_exports);
+var import_chalk2 = __toESM(require("chalk"), 1);
+
+// src/core/core.ts
+var import_process2 = __toESM(require("process"), 1);
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_path9 = __toESM(require("path"), 1);
+var import_prompts9 = require("@clack/prompts");
+
+// src/utils/welcomeMessage.utils.ts
+var import_cfonts = __toESM(require("cfonts"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
+function UWelcomeMessage() {
+  import_cfonts.default.say("OpticoreJS", {
+    font: "block",
+    align: "left",
+    colors: ["#D4E4FF", "#427ff5"],
+    background: "transparent",
+    letterSpacing: 1,
+    lineHeight: 1,
+    space: true,
+    maxLength: "0"
+  });
+  const blue = import_chalk.default.bold.hex("#427ff5");
+  const name = import_chalk.default.bold.hex("#003A9F");
+  const dim = import_chalk.default.bold.hex("#D4E4FF");
+  const subTitle = `          ${blue("")}   ${name("         OPTICORE  F E A T U R E   M O D U L E")}
+        ${blue("")}       ${dim(" Create \xB7 Structure \xB7 Scaffold \xB7 Generate \xB7 Organize  ")}   ${blue("")}
+        ${blue("")}`;
+  const FOOTER = `
+   ${import_chalk.default.bold.dim("Documentation")}  ${import_chalk.default.underline.cyan("https://github.com/guyzoum77/opticore-feature-cli")}
+`;
+  console.log(subTitle);
+  console.log(FOOTER);
+}
+
+// src/utils/choiceFeatureCleanModule.ts
+var import_ansi_colors2 = __toESM(require("ansi-colors"), 1);
+var import_prompts2 = require("@clack/prompts");
+
+// src/utils/prompt.utils.ts
+var import_prompts = require("@clack/prompts");
+var import_ansi_colors = __toESM(require("ansi-colors"), 1);
+
+// src/utils/fsModule.utils.ts
+var import_fs = __toESM(require("fs"), 1);
+var UFsModule = class {
+  static createDirectoryRecursively(dirPath) {
+    try {
+      import_fs.default.mkdirSync(dirPath, { recursive: true });
+    } catch (e) {
+      console.error(e.message);
+    }
+  }
+  static createFile(filePath, fileContent) {
+    try {
+      import_fs.default.writeFileSync(filePath, fileContent);
+    } catch (e) {
+      console.error(e.message);
+    }
+  }
+  static removeDir(directory, recursive, force) {
+    try {
+      if (import_fs.default.existsSync(directory)) {
+        import_fs.default.rmSync(directory, { recursive, force });
+      }
+    } catch (e) {
+      console.error(`Error removing folder: ${e.message}`, e);
+      process.exit(0);
+    }
+  }
+};
+
+// src/utils/prompt.utils.ts
+var import_opticore_logger = require("opticore-logger");
+var import_opticore_http_response = require("opticore-http-response");
+var UPrompt = class {
+  static logger = new import_opticore_logger.LoggerCore();
+  static async text(message, placeholder, validate) {
+    return await (0, import_prompts.text)(
+      {
+        message,
+        placeholder,
+        validate
+      }
+    );
+  }
+  static async confirm(message, defaultValue = true) {
+    return await (0, import_prompts.confirm)({
+      message,
+      initialValue: defaultValue
+    });
+  }
+  static cancelOperation(controllerPath) {
+    console.log(`${import_ansi_colors.default.bgRed(`${import_ansi_colors.default.white("Operation cancelled.")}`)}`);
+    if (controllerPath) {
+      try {
+        UFsModule.removeDir(controllerPath, true, true);
+        this.logger.info({
+          title: "DIR_REMOVED",
+          message: `Removed controller directory: ${controllerPath}`
+        });
+      } catch (error) {
+        this.logger.error({
+          errorType: error.name,
+          httpCodeValue: import_opticore_http_response.HttpStatusCode.INTERNAL_SERVER_ERROR,
+          message: error.message,
+          stackTrace: error.stack,
+          title: "FAILED_TO_REMOVE_CONTROLLER_DIR"
+        });
+      }
+    }
+    process.exit(0);
+  }
+  static async select(message, defaultValue, options) {
+    const optSelected = await (0, import_prompts.select)({
+      message,
+      initialValue: defaultValue,
+      options
+    });
+    if ((0, import_prompts.isCancel)(optSelected)) {
+      return optSelected;
+    }
+    return optSelected[0];
+  }
+};
+
+// src/utils/choiceFeatureCleanModule.ts
+async function choiceFeatureCleanModule() {
+  const featureSelected = await UPrompt.select(
+    "Please choose the creation principle for your feature :",
+    ["opticore_principle"],
+    [
+      { label: "OptiCoreJs CLEAN Module", value: ["opticore_clean_module"], hint: "recommended" },
+      { label: "MVC Architecture", value: ["mvc_architecture"] },
+      { label: "Layered Architecture", value: ["layered_architecture"] },
+      { label: "Build your own architecture", value: ["custom_feature"] }
+    ]
+  );
+  if ((0, import_prompts2.isCancel)(featureSelected)) {
+    console.log(`${import_ansi_colors2.default.bgRed(`${import_ansi_colors2.default.white("Operation cancelled.")}`)}`);
+    process.exit(0);
+  } else {
+    return featureSelected;
+  }
+}
+
+// src/utils/customFeatureInfo.utils.ts
+var import_ansi_colors3 = __toESM(require("ansi-colors"), 1);
+function UCustomFeatureInfo(choice) {
+  console.log(
+    `
+You have chosen : ${choice === "opticore_clean_module" ? import_ansi_colors3.default.cyan("OptiCoreJs CLEAN Module") : import_ansi_colors3.default.cyan("Custom feature")} 
+`
+  );
+  const I = (s) => import_ansi_colors3.default.yellow(s);
+  const A = (s) => import_ansi_colors3.default.cyan(s);
+  const D = (s) => import_ansi_colors3.default.yellowBright(s);
+  const E = (s) => import_ansi_colors3.default.white(s);
+  const st = (s) => import_ansi_colors3.default.gray(s);
+  const diagram = [
+    `   ` + I(`INFRASTRUCTURE`),
+    `      ` + I(`controllers \xB7 repositories \xB7 routes`),
+    `      ` + I(`presenters \xB7 routes`),
+    ``,
+    `   ` + A(`APPLICATION`),
+    `   ` + A(`ports \xB7 interfaces \xB7 dtos \xB7 use-cases`),
+    ``,
+    `   ` + D(`DOMAIN`),
+    `     ` + D(`events \xB7 exceptions`),
+    ``,
+    `   ` + E(`ENTITIES`),
+    `       ` + E(`core \xB7 no external deps`),
+    ``,
+    `    ` + import_ansi_colors3.default.dim(`Dependency direction : outer layers depend on inner layers`),
+    ``
+  ];
+  console.log(diagram.join(`
+`));
+}
+
+// src/services/featureName.service.ts
+var _featureName = async () => {
+  return await UPrompt.text(
+    "Enter feature's name :",
+    "login",
+    (value) => {
+      let pattern = new RegExp("^[a-z][A-Za-z_-]+$");
+      if (!value) {
+        return "Please enter a feature's name.";
+      }
+      if (!pattern.test(value)) {
+        return "Please enter a valide feature's name.";
+      }
+    }
+  );
+};
+
+// src/services/base.service.ts
+var import_path = __toESM(require("path"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_ansi_colors4 = __toESM(require("ansi-colors"), 1);
+var import_process = __toESM(require("process"), 1);
+var BaseService = class {
+  static _isSubdirectoryExists(subdirectory) {
+    const subdirectoryString = typeof subdirectory === "symbol" ? subdirectory.toString() : String(subdirectory);
+    const subdirectoryPath = import_path.default.join(import_process.default.cwd(), "src", "features", subdirectoryString);
+    try {
+      const stats = import_node_fs.default.statSync(subdirectoryPath);
+      return stats.isDirectory();
+    } catch (error) {
+      return false;
+    }
+  }
+  static _featureFounded(feature) {
+    console.log(`${import_ansi_colors4.default.bgCyan(`${import_ansi_colors4.default.white(`${import_ansi_colors4.default.bold(`feature ${feature} is already exists.`)}`)}`)}`);
+    import_process.default.exit(0);
+  }
+  static _checkFeatureDir() {
+    console.error(`${import_ansi_colors4.default.bgRed(`${import_ansi_colors4.default.white("Check if directory src/features exists, and try again.")}`)}`);
+    import_process.default.exit();
+  }
+  static _dirFounded(feature) {
+    console.error(`${import_ansi_colors4.default.bgRed(`${import_ansi_colors4.default.white(`The ${import_ansi_colors4.default.bgCyan(`${import_ansi_colors4.default.bold(`feature ${feature} is already exists.`)}`)}`)}`)}`);
+    import_process.default.exit();
+  }
+  static _cancelOperation(controllerPath) {
+    console.log(`${import_ansi_colors4.default.bgRed(`${import_ansi_colors4.default.white("Operation cancelled.")}`)}`);
+    UFsModule.removeDir(controllerPath, true, true);
+    import_process.default.exit(0);
+  }
+  static async _createFeatureModuleDir(featureDir, feature) {
+    let ora = (await import("ora")).default;
+    const spinner = ora("Feature's name creation...").start();
+    UFsModule.createDirectoryRecursively(featureDir);
+    spinner.succeed(`Your feature"s name ${import_ansi_colors4.default.bgCyan(import_ansi_colors4.default.white(`${feature}`))} has been created successfully. 
+`);
+    return { featureDir, feature };
+  }
+  static async _createApplicationDirComponent(feature) {
+    let application = "";
+    application = `${feature}/application`;
+    UFsModule.createDirectoryRecursively(application);
+    return application;
+  }
+  static async _createDomainDirComponent(feature) {
+    let domain = "";
+    domain = `${feature}/domain`;
+    UFsModule.createDirectoryRecursively(domain);
+    return domain;
+  }
+  static async _createInfraDirComponent(feature) {
+    let infrastructure = "";
+    infrastructure = `${feature}/infrastructure`;
+    UFsModule.createDirectoryRecursively(infrastructure);
+    return infrastructure;
+  }
+  static async _createPersistenceDirComponent(feature) {
+    let persistence = "";
+    persistence = `${feature}/persistence`;
+    UFsModule.createDirectoryRecursively(persistence);
+    return persistence;
+  }
+};
+
+// src/services/controllerType.service.ts
+async function _controllerType(messageText, defaultValue, options) {
+  return await UPrompt.select(
+    messageText,
+    [defaultValue],
+    options
+  );
+}
+
+// src/core/components/application/createController.application.ts
+var import_prompts5 = require("@clack/prompts");
+
+// src/core/domains/constants/cleanType.constant.ts
+var CCleanType = {
+  "clean_component_by_step": "clean_component_by_step",
+  "full_clean_component": "full_clean_component",
+  "simple_component": "simple_component"
+};
+
+// src/templates/simpleComponent/simpleComponent.template.ts
+var import_path3 = __toESM(require("path"), 1);
+var import_ansi_colors6 = __toESM(require("ansi-colors"), 1);
+
+// src/utils/featureComponentGenerator.utils.ts
+var import_path2 = __toESM(require("path"), 1);
+var import_ansi_colors5 = __toESM(require("ansi-colors"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
+var import_prompts3 = require("@clack/prompts");
+var import_opticore_logger2 = require("opticore-logger");
+
+// src/templates/cleanComponents/controller.template.ts
+var generateControllerTemplate = (controllerName, featureName, methods) => {
+  const capitalized = capitalize(featureName);
+  const useCaseName = `${capitalized}UseCase`;
+  const presenterName = `${capitalized}Presenter`;
+  const methodsCode = methods.map((method) => generateMethod(method, featureName, capitalized)).join("\n");
+  const errorHandler = errorHandlerAppend(capitalized);
+  return `import { Request, Response } from "express";
+import { ResponseHandler, HttpStatusCode, IResponseHandlerSuccessData } from "opticore-http-response";
+import { ${useCaseName} } from "../../../application/use-cases/${featureName}.usecase";
+import { ${presenterName} } from "../presenters/${featureName}.presenter";
+import { ${capitalized}Repository } from "../repositories/${featureName}.repository";
+
+/**
+ * ${controllerName} \u2014 HTTP Controller (Infrastructure Layer)
+ */
+export class ${controllerName} {
+    private static buildUseCase(): ${useCaseName} {
+        const repository = new ${capitalized}Repository();
+        return new ${useCaseName}(repository);
+    }
+
+    private static buildPresenter(): ${presenterName} {
+        return new ${presenterName}();
+    }
+
+${methodsCode}
+${errorHandler}
+}
+`;
+};
+var generateMethod = (method, featureName, capitalized) => {
+  const lower = method.toLowerCase();
+  if (lower.includes("findall") || lower.includes("getall")) {
+    return generateFindAllMethod(method, featureName, capitalized);
+  }
+  if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) {
+    return generateFindByIdMethod(method, featureName, capitalized);
+  }
+  if (lower.includes("create") || lower.includes("add")) {
+    return generateCreateMethod(method, featureName, capitalized);
+  }
+  if (lower.includes("update") || lower.includes("edit")) {
+    return generateUpdateMethod(method, featureName, capitalized);
+  }
+  if (lower.includes("delete") || lower.includes("remove")) {
+    return generateDeleteMethod(method, featureName, capitalized);
+  }
+  return `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const useCase = ${capitalized}Controller.buildUseCase();
+            const presenter = ${capitalized}Controller.buildPresenter();
+            // TODO: Implement ${method} logic
+            // const result = await useCase.${method}(...);
+            return ResponseHandler.success(presenter.presentOne({} as any), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+};
+var generateFindAllMethod = (method, featureName, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const useCase = ${capitalized}Controller.buildUseCase();
+            const presenter = ${capitalized}Controller.buildPresenter();
+
+            const results = await useCase.findAll();
+            return ResponseHandler.success(presenter.presentMany(results), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateFindByIdMethod = (method, featureName, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const useCase = ${capitalized}Controller.buildUseCase();
+            const presenter = ${capitalized}Controller.buildPresenter();
+
+            const result = await useCase.findById(id);
+            if (!result) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(presenter.presentOne(result), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateCreateMethod = (method, featureName, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const dto = req.body; // TODO: Validate with your validation layer
+            const useCase = ${capitalized}Controller.buildUseCase();
+            const presenter = ${capitalized}Controller.buildPresenter();
+
+            const result = await useCase.create(dto);
+            return ResponseHandler.success(presenter.presentOne(result), "created", HttpStatusCode.CREATED);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateUpdateMethod = (method, featureName, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const dto = { ...req.body, id }; // TODO: Validate with your validation layer
+            const useCase = ${capitalized}Controller.buildUseCase();
+            const presenter = ${capitalized}Controller.buildPresenter();
+
+            const result = await useCase.update(dto);
+            if (!result) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(presenter.presentOne(result), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateDeleteMethod = (method, featureName, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const useCase = ${capitalized}Controller.buildUseCase();
+
+            const deleted = await useCase.delete(id);
+            if (!deleted) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(null, "deleted", HttpStatusCode.NO_CONTENT);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var errorHandlerAppend = (capitalized) => `
+    private static handleError(error: unknown) {
+        const message = error instanceof Error 
+            ? error.message 
+            : "Internal server error";
+        return ResponseHandler.error(message, HttpStatusCode.INTERNAL_SERVER_ERROR);
+    }
+`;
+var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/entity.template.ts
+var generateEntityTemplate = (entityName, featureName) => {
+  const capitalized = capitalize2(featureName);
+  return `/**
+ * ${entityName} \u2014 Domain Entity
+ * Represents the core business object for the "${featureName}" feature.
+ * No framework dependency, pure business logic only.
+ */
+export class ${entityName} {
+    private readonly _id: string;
+    private _createdAt: Date;
+    private _updatedAt: Date;
+
+    constructor(
+        id: string,
+        // TODO: Add your business properties here
+        createdAt?: Date,
+        updatedAt?: Date,
+    ) {
+        this._id = id;
+        this._createdAt = createdAt ?? new Date();
+        this._updatedAt = updatedAt ?? new Date();
+
+        this.validate();
+    }
+
+    get id(): string {
+        return this._id;
+    }
+
+    get createdAt(): Date {
+        return this._createdAt;
+    }
+
+    get updatedAt(): Date {
+        return this._updatedAt;
+    }
+
+    /**
+     * Marks the entity as updated.
+     * Call this whenever a business mutation occurs.
+     */
+    public touch(): void {
+        this._updatedAt = new Date();
+    }
+
+    /**
+     * Returns a plain object snapshot of the entity.
+     * Useful for persistence or presentation mapping.
+     */
+    public toSnapshot(): Record<string, unknown> {
+        return {
+            id: this._id,
+            createdAt: this._createdAt,
+            updatedAt: this._updatedAt,
+        };
+    }
+
+    private validate(): void {
+        if (!this._id || this._id.trim().length === 0) {
+            throw new Error(\`[${entityName}] id must not be empty.\`);
+        }
+        // TODO: Add your domain invariant checks here
+    }
+}
+`;
+};
+var capitalize2 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/repositoryInterface.template.ts
+var generateRepositoryInterfaceTemplate = (interfaceName, featureName) => {
+  const entityName = `${capitalize3(featureName)}Entity`;
+  const entityImport = `../../../domain/entities/${featureName}.entity`;
+  return `import { ${entityName} } from "${entityImport}";
+
+/**
+ * ${interfaceName} \u2014 Repository Port (Application Layer)
+ *
+ * Defines the persistence contract. The infrastructure layer must implement this.
+ * The application layer depends on this abstraction \u2014 never on a concrete ORM or DB.
+ */
+export interface ${interfaceName} {
+
+    /**
+     * Returns all ${featureName} entities.
+     */
+    findAll(): Promise<${entityName}[]>;
+
+    /**
+     * Finds a single ${featureName} by its unique identifier.
+     * Returns null if not found (avoid throwing for "not found" in repositories).
+     */
+    findById(id: string): Promise<${entityName} | null>;
+
+    /**
+     * Persists a new ${featureName} entity.
+     * Returns the created entity (with generated id if applicable).
+     */
+    create(entity: ${entityName}): Promise<${entityName}>;
+
+    /**
+     * Persists changes to an existing ${featureName} entity.
+     * Returns the updated entity, or null if not found.
+     */
+    update(entity: ${entityName}): Promise<${entityName} | null>;
+
+    /**
+     * Removes a ${featureName} entity by id.
+     * Returns true if deleted, false if not found.
+     */
+    delete(id: string): Promise<boolean>;
+}
+`;
+};
+var capitalize3 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/repositoryImpl.template.ts
+var generateRepositoryImplTemplate = (featureName, interfaceImportPath) => {
+  const capitalized = capitalize4(featureName);
+  const implName = `${capitalized}Repository`;
+  const interfaceName = `I${capitalized}Repository`;
+  const entityName = `${capitalized}Entity`;
+  const entityImport = `../../../domain/entities/${featureName}.entity`;
+  return `import { ${interfaceName} } from "${interfaceImportPath}";
+import { ${entityName} } from "${entityImport}";
+
+/**
+ * ${implName} \u2014 Repository Implementation (Infrastructure Layer)
+ *
+ * Provides the actual persistence logic for ${featureName}.
+ * Replace the in-memory store below with your ORM (TypeORM, Prisma, Mongoose, etc.).
+ * This class depends on the ${interfaceName} contract defined in the application layer.
+ */
+export class ${implName} implements ${interfaceName} {
+
+    /**
+     * TODO: Inject your database client / ORM model here via the constructor.
+     * Example with TypeORM: constructor(private readonly repo: Repository<${capitalized}Model>) {}
+     *
+     * Example with Prisma: constructor(private readonly prisma: PrismaClient) {}
+     */
+
+    /**
+     * In-memory store (replace with real persistence)
+     */
+    private store: Map<string, ${entityName}> = new Map();
+
+    async findAll(): Promise<${entityName}[]> {
+        // TODO: Replace with your ORM query
+        // Example (TypeORM): return this.repo.find();
+        // Example (Prisma):  const rows = await this.prisma.${featureName}.findMany();
+        //                    return rows.map(row => this.toDomain(row));
+        return Array.from(this.store.values());
+    }
+
+    async findById(id: string): Promise<${entityName} | null> {
+        // TODO: Replace with your ORM query
+        // Example (TypeORM): return this.repo.findOneBy({ id }) ?? null;
+        // Example (Prisma):  const row = await this.prisma.${featureName}.findUnique({ where: { id } });
+        //                    return row ? this.toDomain(row) : null;
+        return this.store.get(id) ?? null;
+    }
+
+    async create(entity: ${entityName}): Promise<${entityName}> {
+        // TODO: Replace with your ORM save
+        // Example (TypeORM): const model = this.repo.create(this.toPersistence(entity));
+        //                    return this.toDomain(await this.repo.save(model));
+        // Example (Prisma):  const row = await this.prisma.${featureName}.create({ data: this.toPersistence(entity) });
+        //                    return this.toDomain(row);
+        this.store.set(entity.id, entity);
+        return entity;
+    }
+
+    async update(entity: ${entityName}): Promise<${entityName} | null> {
+        // TODO: Replace with your ORM update
+        if (!this.store.has(entity.id)) return null;
+        this.store.set(entity.id, entity);
+        return entity;
+    }
+
+    async delete(id: string): Promise<boolean> {
+        // TODO: Replace with your ORM delete
+        // Example (TypeORM): const result = await this.repo.delete(id);
+        //                    return (result.affected ?? 0) > 0;
+        return this.store.delete(id);
+    }
+
+
+    /**
+     * Maps an ORM/DB row to a domain entity.
+     * TODO: Adapt field mapping to your actual persistence model.
+     */
+    private toDomain(row: any): ${entityName} {
+        return new ${entityName}(
+            row.id,
+            // TODO: Map your ORM fields here
+            row.createdAt,
+            row.updatedAt,
+        );
+    }
+
+    /**
+     * Maps a domain entity to an ORM/DB-friendly plain object.
+     * TODO: Adapt to your schema.
+     */
+    private toPersistence(entity: ${entityName}): Record<string, unknown> {
+        return {
+            id: entity.id,
+            // TODO: Map your domain fields here
+            createdAt: entity.createdAt,
+            updatedAt: entity.updatedAt,
+        };
+    }
+}
+`;
+};
+var capitalize4 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/useCase.template.ts
+var generateUseCaseTemplate = (useCaseName, featureName) => {
+  const capitalized = capitalize5(featureName);
+  const interfaceName = `I${capitalized}Repository`;
+  const entityName = `${capitalized}Entity`;
+  return `import { ${interfaceName} } from "../ports/repositories/${featureName}.repository.interface";
+import { ${entityName} } from "../../domain/entities/${featureName}.entity";
+import {
+    Create${capitalized}Dto,
+    Update${capitalized}Dto,
+    ${capitalized}ResponseDto,
+    ${capitalized}DtoMapper,
+} from "../dtos/${featureName}.dto";
+
+/**
+ * ${useCaseName} \u2014 Application Use Case
+ *
+ * Orchestrates business operations for the "${featureName}" feature.
+ * It depends ONLY on the repository port (interface), never on a concrete implementation.
+ * The concrete repository is injected at the infrastructure level (DI container or manual wiring).
+ */
+export class ${useCaseName} {
+
+    constructor(private readonly repository: ${interfaceName}) {}
+
+    async findAll(): Promise<${capitalized}ResponseDto[]> {
+        const entities = await this.repository.findAll();
+        return ${capitalized}DtoMapper.toResponseList(entities);
+    }
+
+    async findById(id: string): Promise<${capitalized}ResponseDto | null> {
+        const entity = await this.repository.findById(id);
+        if (!entity) {
+            return null;
+        }
+        return ${capitalized}DtoMapper.toResponse(entity);
+    }
+
+    async create(dto: Create${capitalized}Dto): Promise<${capitalized}ResponseDto> {
+        // TODO: Map DTO to domain entity. Generate id using your preferred strategy (uuid, etc.)
+        const id = crypto.randomUUID();
+        const entity = new ${entityName}(
+            id,
+            // TODO: Pass your domain fields from dto
+        );
+
+        const saved = await this.repository.create(entity);
+        return ${capitalized}DtoMapper.toResponse(saved);
+    }
+
+    async update(dto: Update${capitalized}Dto): Promise<${capitalized}ResponseDto | null> {
+        const existing = await this.repository.findById(dto.id);
+        if (!existing) { 
+            return null;
+        }
+
+        // TODO: Apply the update to the domain entity
+        // existing.updateName(dto.name);
+        existing.touch();
+
+        const updated = await this.repository.update(existing);
+        if (!updated) { 
+            return null;
+        }
+        return ${capitalized}DtoMapper.toResponse(updated);
+    }
+
+    async delete(id: string): Promise<boolean> {
+        return this.repository.delete(id);
+    }
+}
+`;
+};
+var capitalize5 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/dto.template.ts
+var generateDtoTemplate = (featureName) => {
+  const capitalized = capitalize6(featureName);
+  return `/**
+ * ${capitalized}Dto \u2014 Data Transfer Objects (Application Layer)
+ *
+ * DTOs define the shape of data entering and leaving use cases.
+ * They decouple the domain model from HTTP requests/responses.
+ * Validation is handled at the infrastructure layer (e.g., in the controller).
+ */
+
+
+export interface Create${capitalized}Dto {
+    // TODO: Define the fields required to create a ${featureName}
+    // Example:
+    // name: string;
+    // email: string;
+}
+
+export interface Update${capitalized}Dto {
+    id: string;
+    // TODO: Define the fields allowed to be updated. All fields should be optional (partial update pattern)
+    // Example: name?: string;
+}
+
+export interface ${capitalized}ResponseDto {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    // TODO: Mirror the fields you expose to clients. Avoid leaking internal domain model details (e.g., private fields, passwords)
+}
+
+import { ${capitalized}Entity } from "../../domain/entities/${featureName}.entity";
+
+export class ${capitalized}DtoMapper {
+
+    /**
+     * Maps a domain entity to a safe response DTO.
+     * Use this in your presenter or use case output.
+     */
+    static toResponse(entity: ${capitalized}Entity): ${capitalized}ResponseDto {
+        return {
+            id: entity.id,
+            createdAt: entity.createdAt,
+            updatedAt: entity.updatedAt,
+            // TODO: Map your additional fields here
+        };
+    }
+
+    /**
+     * Maps an array of entities to response DTOs.
+     */
+    static toResponseList(entities: ${capitalized}Entity[]): ${capitalized}ResponseDto[] {
+        return entities.map((entity) => this.toResponse(entity));
+    }
+}
+`;
+};
+var capitalize6 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/presenter.template.ts
+var generatePresenterInterfaceTemplate = (featureName) => {
+  const capitalized = capitalize7(featureName);
+  const interfaceName = `I${capitalized}Presenter`;
+  return `import { ${capitalized}ResponseDto } from "../../dtos/${featureName}.dto";
+
+/**
+ * ${interfaceName} \u2014 Presenter Port (Application Layer)
+ *
+ * Defines how a use case result is formatted for the client.
+ * The infrastructure layer provides the concrete implementation
+ * (e.g., JSON serialization, HTTP envelopes, pagination wrappers).
+ */
+export interface ${interfaceName} {
+
+    /**
+     * Formats a single ${featureName} response.
+     */
+    presentOne(data: ${capitalized}ResponseDto): unknown;
+
+    /**
+     * Formats a list of ${featureName} responses.
+     */
+    presentMany(data: ${capitalized}ResponseDto[]): unknown;
+
+    /**
+     * Formats a "not found" response.
+     */
+    presentNotFound(id?: string): unknown;
+}
+`;
+};
+var generatePresenterImplTemplate = (featureName) => {
+  const capitalized = capitalize7(featureName);
+  const implName = `${capitalized}Presenter`;
+  const interfaceName = `I${capitalized}Presenter`;
+  return `import { ${interfaceName} } from "../../../application/ports/presenters/${featureName}.presenter.interface";
+import { ${capitalized}ResponseDto } from "../../../application/dtos/${featureName}.dto";
+
+/**
+ * ${implName} \u2014 Presenter Implementation (Infrastructure Layer)
+ *
+ * Formats use case output into a client-facing structure.
+ * Keeps HTTP/JSON concerns OUT of the domain and application layers.
+ */
+export class ${implName} implements ${interfaceName} {
+
+    presentOne(data: ${capitalized}ResponseDto): unknown {
+        return {
+            success: true,
+            data,
+        };
+    }
+
+    presentMany(data: ${capitalized}ResponseDto[]): unknown {
+        return {
+            success: true,
+            count: data.length,
+            data,
+        };
+    }
+
+    presentNotFound(id?: string): unknown {
+        return {
+            success: false,
+            message: id
+                ? \`${capitalized} with id "\${id}" was not found.\`
+                : \`${capitalized} not found.\`,
+        };
+    }
+}
+`;
+};
+var capitalize7 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/router.template.ts
+var resolveRoute = (methodName, featureName) => {
+  const lower = methodName.toLowerCase();
+  if (lower.includes("findall") || lower.includes("getall")) return { httpMethod: "get", path: `/${featureName}` };
+  if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) return { httpMethod: "get", path: `/${featureName}/:id` };
+  if (lower.includes("create") || lower.includes("add")) return { httpMethod: "post", path: `/${featureName}` };
+  if (lower.includes("update") || lower.includes("edit")) return { httpMethod: "put", path: `/${featureName}/:id` };
+  if (lower.includes("delete") || lower.includes("remove")) return { httpMethod: "delete", path: `/${featureName}/:id` };
+  return { httpMethod: "get", path: `/${featureName}/${lower}` };
+};
+var generateRouterHandlerTemplate = (featureName, controllerMethods) => {
+  const capitalized = capitalize8(featureName);
+  const handlerName = `${capitalized}HandlerRouter`;
+  const controllerName = `${capitalized}Controller`;
+  const routesCode = (controllerMethods || []).map((method) => {
+    const { httpMethod, path: path10 } = resolveRoute(method, featureName);
+    return `{
+    path: \`${path10}\`,
+    method: "${httpMethod}",
+    middlewares: [],
+    handler: async (ctx: ICustomContext) => await ${controllerName}.${method}(ctx.req, ctx.res)
+}`;
+  }).join(",\n");
+  return `import { OpticoreRoutingFactory, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+import { ${controllerName} } from "../adapters/controllers/${featureName}.controller";
+
+export const ${handlerName}: () => IMultipleRouteDefinition = () => {
+    return OpticoreRoutingFactory.routes(
+        ${controllerName},
+        [
+            ${routesCode.replace(/\n/g, "\n            ")}
+        ]
+    );
+};
+`;
+};
+var generateRouterTemplate = (featureName) => {
+  const capitalized = capitalize8(featureName);
+  const handlerName = `${capitalized}HandlerRouter`;
+  const routerName = `${capitalized}Router`;
+  return `import { ${handlerName} } from "./${featureName}.router.handler";
+import { TFeatureRoutes } from "opticore-router";
+
+export const ${routerName}: TFeatureRoutes = {
+    routes: [
+        {
+            path: ${handlerName}().path,
+            handler: ${handlerName}().handler
+        }
+    ]
+};
+`;
+};
+var capitalize8 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/event.template.ts
+var generateEventTemplate = (featureName) => {
+  const capitalized = capitalize9(featureName);
+  return `/**
+ * ${capitalized}Event \u2014 Domain Events
+ *
+ * Domain events capture facts that happened in the domain.
+ * They are immutable, named in the past tense, and carry the data
+ * that was relevant at the moment the event occurred.
+ *
+ * Use cases:
+ *  - Trigger side effects (send email, notify another bounded context)
+ *  - Feed an event bus / message broker (RabbitMQ, Kafka, etc.)
+ *  - Build an audit log or event sourcing stream
+ */
+ 
+
+/**
+ * Unique event identifier (uuid)
+ * When the event occurred
+ * The aggregate that emitted this event
+ */ 
+export interface IDomainEvent {
+    readonly eventId: string;
+    readonly occurredAt: Date;
+    readonly aggregateId: string;
+}
+
+/**
+ * Concrete events for the "${featureName}" feature
+ */
+export class ${capitalized}CreatedEvent implements IDomainEvent {
+    readonly eventId: string;
+    readonly occurredAt: Date;
+    readonly aggregateId: string;
+
+    constructor(
+        aggregateId: string,
+        // TODO: Add the fields that describe what was created
+    ) {
+        this.eventId = crypto.randomUUID();
+        this.occurredAt = new Date();
+        this.aggregateId = aggregateId;
+    }
+}
+
+export class ${capitalized}UpdatedEvent implements IDomainEvent {
+    readonly eventId: string;
+    readonly occurredAt: Date;
+    readonly aggregateId: string;
+
+    constructor(
+        aggregateId: string,
+        // TODO: Add the fields that changed
+    ) {
+        this.eventId = crypto.randomUUID();
+        this.occurredAt = new Date();
+        this.aggregateId = aggregateId;
+    }
+}
+
+export class ${capitalized}DeletedEvent implements IDomainEvent {
+    readonly eventId: string;
+    readonly occurredAt: Date;
+    readonly aggregateId: string;
+
+    constructor(aggregateId: string) {
+        this.eventId = crypto.randomUUID();
+        this.occurredAt = new Date();
+        this.aggregateId = aggregateId;
+    }
+}
+`;
+};
+var capitalize9 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/exception.template.ts
+var generateExceptionTemplate = (featureName) => {
+  const capitalized = capitalize10(featureName);
+  return `/**
+ * ${capitalized}Exception \u2014 Domain Exceptions
+ *
+ * Domain exceptions represent violations of business rules specific to "${featureName}".
+ * They are thrown inside the domain or use case layer and caught at the infrastructure
+ * layer (controller) to be translated into appropriate HTTP responses.
+ *
+ * Rule: never import HTTP status codes or Express here \u2014 this is pure domain logic.
+ */
+
+export class ${capitalized}DomainException extends Error {
+    /** Machine-readable error code for programmatic handling */
+    readonly code: string;
+
+    constructor(message: string, code: string) {
+        super(message);
+        this.name = "${capitalized}DomainException";
+        this.code = code;
+
+        // Maintains proper prototype chain in TypeScript
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+
+
+/**
+ * Thrown when a ${featureName} cannot be found by its identifier.
+ * The controller should translate this to HTTP 404.
+ */
+export class ${capitalized}NotFoundException extends ${capitalized}DomainException {
+    constructor(id: string) {
+        super(
+            \`${capitalized} with id "\${id}" does not exist.\`,
+            "${featureName.toUpperCase()}_NOT_FOUND",
+        );
+        this.name = "${capitalized}NotFoundException";
+    }
+}
+
+/**
+ * Thrown when an operation violates a uniqueness constraint.
+ * The controller should translate this to HTTP 409.
+ */
+export class ${capitalized}AlreadyExistsException extends ${capitalized}DomainException {
+    constructor(field: string, value: string) {
+        super(
+            \`A ${featureName} with \${field} "\${value}" already exists.\`,
+            "${featureName.toUpperCase()}_ALREADY_EXISTS",
+        );
+        this.name = "${capitalized}AlreadyExistsException";
+    }
+}
+
+/**
+ * Thrown when the provided data violates a business invariant.
+ * The controller should translate this to HTTP 422.
+ */
+export class ${capitalized}InvalidDataException extends ${capitalized}DomainException {
+    constructor(reason: string) {
+        super(
+            \`Invalid ${featureName} data: \${reason}\`,
+            "${featureName.toUpperCase()}_INVALID_DATA",
+        );
+        this.name = "${capitalized}InvalidDataException";
+    }
+}
+
+/**
+ * Type guard to check if an unknown error is a ${capitalized}DomainException.
+ * Use this in your controller's catch block to map domain errors to HTTP responses.
+ *
+ * @example
+ * try {
+ *   await useCase.create(dto);
+ * } catch (error) {
+ *   if (is${capitalized}DomainException(error)) {
+ *     switch (error.code) {
+ *       case "${featureName.toUpperCase()}_NOT_FOUND":     return res.status(404).json(...);
+ *       case "${featureName.toUpperCase()}_ALREADY_EXISTS": return res.status(409).json(...);
+ *       case "${featureName.toUpperCase()}_INVALID_DATA":   return res.status(422).json(...);
+ *     }
+ *   }
+ *   // Unknown error \u2014 rethrow or return 500
+ *   throw error;
+ * }
+ */
+export const is${capitalized}DomainException = (error: unknown): error is ${capitalized}DomainException =>
+    error instanceof ${capitalized}DomainException;
+`;
+};
+var capitalize10 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/cleanComponents/service.template.ts
+var generateServiceTemplate = (featureName) => {
+  const capitalized = capitalize11(featureName);
+  return `import { ${capitalized}ResponseDto } from "../../dtos/${featureName}.dto";
+
+/**
+ * I${capitalized}Service \u2014 Application Service Port
+ *
+ * Application services handle orchestration logic that sits ABOVE a single use case
+ * but BELOW the HTTP layer. They are the right place for:
+ *
+ *  - Cross-use-case workflows (e.g. "create + notify + log in one transaction")
+ *  - Business rules that span multiple aggregates
+ *  - Coordination with external systems (email, payment, 3rd-party APIs)
+ *    whose contracts are defined here as abstractions
+ *
+ * The infrastructure layer provides the concrete implementation.
+ * Use cases depend on this interface \u2014 never on the concrete class.
+ */
+export interface I${capitalized}Service {
+
+    /**
+     * Full creation workflow for a ${featureName}.
+     * May involve validation, persistence, event publishing, notifications, etc.
+     *
+     * @param data - Raw input (already validated by the controller)
+     * @returns The created ${featureName} as a response DTO
+     */
+    handleCreate(data: Record<string, unknown>): Promise<${capitalized}ResponseDto>;
+
+    /**
+     * Full update workflow for a ${featureName}.
+     *
+     * @param id  - Identifier of the ${featureName} to update
+     * @param data - Fields to update
+     * @returns The updated ${featureName}, or null if not found
+     */
+    handleUpdate(id: string, data: Record<string, unknown>): Promise<${capitalized}ResponseDto | null>;
+
+    /**
+     * Full deletion workflow for a ${featureName}.
+     * May involve cleanup tasks (remove related files, revoke tokens, etc.)
+     *
+     * @param id - Identifier of the ${featureName} to delete
+     * @returns true if deleted, false if not found
+     */
+    handleDelete(id: string): Promise<boolean>;
+
+    // TODO: Add feature-specific service methods below
+    // Example:
+    // sendWelcomeNotification(id: string): Promise<void>;
+    // exportToCsv(filters: Record<string, unknown>): Promise<Buffer>;
+}
+`;
+};
+var capitalize11 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/simpleComponent/model.template.ts
+var generateModelTemplate = (featureName) => {
+  const capitalized = capitalize12(featureName);
+  const modelName = `${capitalized}Model`;
+  return `/**
+ * ${modelName} \u2014 Data Model
+ * Plain data structure for the "${featureName}" feature.
+ */
+export class ${modelName} {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+
+    constructor(
+        id: string,
+        // TODO: Add your model properties here
+        createdAt?: Date,
+        updatedAt?: Date,
+    ) {
+        this.id = id;
+        this.createdAt = createdAt ?? new Date();
+        this.updatedAt = updatedAt ?? new Date();
+    }
+}
+`;
+};
+var capitalize12 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/simpleComponent/simpleRepository.template.ts
+var generateSimpleRepositoryTemplate = (featureName) => {
+  const capitalized = capitalize13(featureName);
+  const repoName = `${capitalized}Repository`;
+  const modelName = `${capitalized}Model`;
+  return `import { ${modelName} } from "../models/${featureName}.model";
+
+export class ${repoName} {
+    private store: Map<string, ${modelName}> = new Map();
+
+    async findAll(): Promise<${modelName}[]> {
+        // TODO: Replace with your ORM query
+        return Array.from(this.store.values());
+    }
+
+    async findById(id: string): Promise<${modelName} | null> {
+        // TODO: Replace with your ORM query
+        return this.store.get(id) ?? null;
+    }
+
+    async create(model: ${modelName}): Promise<${modelName}> {
+        // TODO: Replace with your ORM save
+        this.store.set(model.id, model);
+        return model;
+    }
+
+    async update(model: ${modelName}): Promise<${modelName} | null> {
+        // TODO: Replace with your ORM update
+        if (!this.store.has(model.id)) return null;
+        this.store.set(model.id, model);
+        return model;
+    }
+
+    async delete(id: string): Promise<boolean> {
+        // TODO: Replace with your ORM delete
+        return this.store.delete(id);
+    }
+}
+`;
+};
+var capitalize13 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/simpleComponent/simpleService.template.ts
+var generateSimpleServiceTemplate = (featureName) => {
+  const capitalized = capitalize14(featureName);
+  const serviceName = `${capitalized}Service`;
+  const repoName = `${capitalized}Repository`;
+  const modelName = `${capitalized}Model`;
+  return `import { ${repoName} } from "../repositories/${featureName}.repository";
+import { ${modelName} } from "../models/${featureName}.model";
+
+export class ${serviceName} {
+    private readonly repository: ${repoName};
+
+    constructor() {
+        this.repository = new ${repoName}();
+    }
+
+    async findAll(): Promise<${modelName}[]> {
+        return this.repository.findAll();
+    }
+
+    async findById(id: string): Promise<${modelName} | null> {
+        return this.repository.findById(id);
+    }
+
+    async create(data: Record<string, unknown>): Promise<${modelName}> {
+        const model = new ${modelName}(String(Date.now()));
+        // TODO: Map data fields onto model
+        return this.repository.create(model);
+    }
+
+    async update(id: string, data: Record<string, unknown>): Promise<${modelName} | null> {
+        const existing = await this.repository.findById(id);
+        if (!existing) { 
+            return null;
+        }
+        // TODO: Apply data fields onto existing model
+        return this.repository.update(existing);
+    }
+
+    async delete(id: string): Promise<boolean> {
+        return this.repository.delete(id);
+    }
+}
+`;
+};
+var capitalize14 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/simpleComponent/simpleController.template.ts
+var generateSimpleControllerTemplate = (controllerName, featureName, methods) => {
+  const capitalized = capitalize15(featureName);
+  const serviceName = `${capitalized}Service`;
+  const methodsCode = methods.map((method) => generateMethod2(method, capitalized, serviceName)).join("\n");
+  return `import { Request, Response } from "express";
+import { ResponseHandler, HttpStatusCode, IResponseHandlerSuccessData } from "opticore-http-response";
+import { ${serviceName} } from "../services/${featureName}.service";
+
+export class ${controllerName} {
+    private static buildService(): ${serviceName} {
+        return new ${serviceName}();
+    }
+
+${methodsCode}
+    private static handleError(error: unknown) {
+        const message = error instanceof Error ? error.message : "Internal server error";
+        return ResponseHandler.error(message, HttpStatusCode.INTERNAL_SERVER_ERROR);
+    }
+}
+`;
+};
+var generateMethod2 = (method, capitalized, serviceName) => {
+  const lower = method.toLowerCase();
+  if (lower.includes("findall") || lower.includes("getall")) {
+    return generateFindAllMethod2(method, capitalized);
+  }
+  if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) {
+    return generateFindByIdMethod2(method, capitalized);
+  }
+  if (lower.includes("create") || lower.includes("add")) {
+    return generateCreateMethod2(method, capitalized);
+  }
+  if (lower.includes("update") || lower.includes("edit")) {
+    return generateUpdateMethod2(method, capitalized);
+  }
+  if (lower.includes("delete") || lower.includes("remove")) {
+    return generateDeleteMethod2(method, capitalized);
+  }
+  return `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const service = ${capitalized}Controller.buildService();
+            // TODO: Implement ${method} logic
+            return ResponseHandler.success({}, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+};
+var generateFindAllMethod2 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const service = ${capitalized}Controller.buildService();
+            const results = await service.findAll();
+            return ResponseHandler.success(results, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateFindByIdMethod2 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const service = ${capitalized}Controller.buildService();
+            const result = await service.findById(id);
+            if (!result) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(result, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateCreateMethod2 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const service = ${capitalized}Controller.buildService();
+            const result = await service.create(req.body);
+            return ResponseHandler.success(result, "created", HttpStatusCode.CREATED);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateUpdateMethod2 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const service = ${capitalized}Controller.buildService();
+            const result = await service.update(id, req.body);
+            if (!result) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(result, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateDeleteMethod2 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const service = ${capitalized}Controller.buildService();
+            const deleted = await service.delete(id);
+            if (!deleted) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(null, "deleted", HttpStatusCode.NO_CONTENT);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var capitalize15 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/templates/simpleComponent/simpleRouter.template.ts
+var resolveRoute2 = (methodName, featureName) => {
+  const lower = methodName.toLowerCase();
+  if (lower.includes("findall") || lower.includes("getall")) {
+    return { httpMethod: "get", path: `/${featureName}` };
+  }
+  if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) {
+    return { httpMethod: "get", path: `/${featureName}/:id` };
+  }
+  if (lower.includes("create") || lower.includes("add")) {
+    return { httpMethod: "post", path: `/${featureName}` };
+  }
+  if (lower.includes("update") || lower.includes("edit")) {
+    return { httpMethod: "put", path: `/${featureName}/:id` };
+  }
+  if (lower.includes("delete") || lower.includes("remove")) {
+    return { httpMethod: "delete", path: `/${featureName}/:id` };
+  }
+  return { httpMethod: "get", path: `/${featureName}/${lower}` };
+};
+var generateSimpleRouterHandlerTemplate = (featureName, controllerMethods) => {
+  const capitalized = capitalize16(featureName);
+  const handlerName = `${capitalized}HandlerRouter`;
+  const controllerName = `${capitalized}Controller`;
+  const routesCode = (controllerMethods || []).map((method) => {
+    const { httpMethod, path: path10 } = resolveRoute2(method, featureName);
+    return `{
+    path: \`${path10}\`,
+    method: "${httpMethod}",
+    middlewares: [],
+    handler: async (ctx: ICustomContext) => await ${controllerName}.${method}(ctx.req, ctx.res)
+}`;
+  }).join(",\n");
+  return `import { OpticoreRoutingFactory, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+import { ${controllerName} } from "../controllers/${featureName}.controller";
+
+export const ${handlerName}: () => IMultipleRouteDefinition = () => {
+    return OpticoreRoutingFactory.routes(
+        ${controllerName},
+        [
+            ${routesCode.replace(/\n/g, "\n            ")}
+        ]
+    );
+};
+`;
+};
+var generateSimpleRouterTemplate = (featureName) => {
+  const capitalized = capitalize16(featureName);
+  const handlerName = `${capitalized}HandlerRouter`;
+  const routerName = `${capitalized}Router`;
+  return `import { ${handlerName} } from "./${featureName}.router.handler";
+import { TFeatureRoutes } from "opticore-router";
+
+export const ${routerName}: TFeatureRoutes = {
+    routes: [
+        {
+            path: ${handlerName}().path,
+            handler: ${handlerName}().handler
+        }
+    ]
+};
+`;
+};
+var capitalize16 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/utils/featureComponentGenerator.utils.ts
+var FeatureComponentGeneratorUtils = class {
+  static logger = new import_opticore_logger2.LoggerCore();
+  static REGISTER_ROUTER_PATH = import_path2.default.join(process.cwd(), "src/app/router/register.router.ts");
+  static structure = "clean";
+  static setStructure(s) {
+    this.structure = s;
+  }
+  /**
+   * Registers a custom module router in register.router.ts.
+   * Must be preceded by setStructure("custom").
+   */
+  static async registerModuleRouter(moduleName) {
+    await this.updateRegisterRouter(moduleName);
+    this.structure = "clean";
+  }
+  /**
+   * Creates the domain entity file.
+   */
+  static async createEntity(featureName, entityDir) {
+    const entityName = `${this.capitalize(featureName)}Entity`;
+    const filePath = import_path2.default.join(entityDir, `${featureName}.entity.ts`);
+    UFsModule.createFile(filePath, generateEntityTemplate(entityName, featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 Entity created: ${filePath}`));
+  }
+  /**
+   * Creates the domain event file.
+   */
+  static async createEvent(featureName, eventDir) {
+    const filePath = import_path2.default.join(eventDir, `${featureName}.event.ts`);
+    UFsModule.createFile(filePath, generateEventTemplate(featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 Event created: ${filePath}`));
+  }
+  /**
+   * Creates the domain exception file.
+   */
+  static async createException(featureName, exceptionDir) {
+    const filePath = import_path2.default.join(exceptionDir, `${featureName}.exception.ts`);
+    UFsModule.createFile(filePath, generateExceptionTemplate(featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 Exception created: ${filePath}`));
+  }
+  /**
+   * Creates the repository port interface.
+   */
+  static async createRepositoryInterface(featureName, interfaceDir) {
+    const interfaceName = `I${this.capitalize(featureName)}Repository`;
+    const filePath = import_path2.default.join(interfaceDir, `${featureName}.repository.interface.ts`);
+    UFsModule.createFile(filePath, generateRepositoryInterfaceTemplate(interfaceName, featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 Repository interface created: ${filePath}`));
+  }
+  /**
+   * Creates the presenter port interface.
+   */
+  static async createPresenterInterface(featureName, presenterInterfaceDir) {
+    const filePath = import_path2.default.join(presenterInterfaceDir, `${featureName}.presenter.interface.ts`);
+    UFsModule.createFile(filePath, generatePresenterInterfaceTemplate(featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 Presenter interface created: ${filePath}`));
+  }
+  /**
+   * Creates the application service port interface.
+   */
+  static async createService(featureName, serviceDir) {
+    const filePath = import_path2.default.join(serviceDir, `${featureName}.service.ts`);
+    UFsModule.createFile(filePath, generateServiceTemplate(featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 Service interface created: ${filePath}`));
+  }
+  /**
+   * Creates the DTO file (input + output shapes + mapper).
+   */
+  static async createDto(featureName, dtoDir) {
+    const filePath = import_path2.default.join(dtoDir, `${featureName}.dto.ts`);
+    UFsModule.createFile(filePath, generateDtoTemplate(featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 DTO created: ${filePath}`));
+  }
+  /**
+   * Creates the use case file.
+   */
+  static async createUseCase(featureName, useCaseDir) {
+    const useCaseName = `${this.capitalize(featureName)}UseCase`;
+    const filePath = import_path2.default.join(useCaseDir, `${featureName}.usecase.ts`);
+    UFsModule.createFile(filePath, generateUseCaseTemplate(useCaseName, featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 UseCase created: ${filePath}`));
+  }
+  /**
+   * Creates the concrete repository implementation.
+   */
+  static async createRepositoryImpl(featureName, repositoryImplDir) {
+    const interfaceImportPath = `../../../application/ports/repositories/${featureName}.repository.interface`;
+    const filePath = import_path2.default.join(repositoryImplDir, `${featureName}.repository.ts`);
+    UFsModule.createFile(filePath, generateRepositoryImplTemplate(featureName, interfaceImportPath));
+    console.log(import_ansi_colors5.default.green(`\u2714 Repository implementation created: ${filePath}`));
+  }
+  /**
+   * Creates the concrete presenter implementation.
+   */
+  static async createPresenterImpl(featureName, presenterImplDir) {
+    const filePath = import_path2.default.join(presenterImplDir, `${featureName}.presenter.ts`);
+    UFsModule.createFile(filePath, generatePresenterImplTemplate(featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 Presenter implementation created: ${filePath}`));
+  }
+  /**
+   * Creates the HTTP controller.
+   * Prompts the user for method names, then generates the file.
+   *
+   * @returns The controller class name and the list of chosen methods.
+   */
+  static async createController(featureName, controllerDir) {
+    const controllerName = `${this.capitalize(featureName)}Controller`;
+    const filePath = import_path2.default.join(controllerDir, `${featureName}.controller.ts`);
+    const wantsMethods = await UPrompt.confirm("Do you want to add methods to the controller?");
+    let methods = [];
+    let content;
+    if (wantsMethods && !(0, import_prompts3.isCancel)(wantsMethods)) {
+      const methodsText = await UPrompt.text(
+        "Enter the method names (comma separated):",
+        "create, findAll, findById, update, delete",
+        (v) => v ? void 0 : "You must enter at least one method."
+      );
+      if (!(0, import_prompts3.isCancel)(methodsText)) {
+        methods = methodsText.split(",").map((m) => m.trim()).filter(Boolean);
+      }
+      content = generateControllerTemplate(controllerName, featureName, methods);
+    } else {
+      content = `import { Request, Response } from "express";
+
+export class ${controllerName} {}
+`;
+    }
+    UFsModule.createFile(filePath, content);
+    console.log(import_ansi_colors5.default.green(`\u2714 Controller created: ${filePath}`));
+    return { controllerName, methods };
+  }
+  /**
+   * Creates the data model file (simple component).
+   */
+  static async createModel(featureName, modelDir) {
+    const filePath = import_path2.default.join(modelDir, `${featureName}.model.ts`);
+    UFsModule.createFile(filePath, generateModelTemplate(featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 Model created: ${filePath}`));
+  }
+  /**
+   * Creates the simple repository (no interface, uses the model directly).
+   */
+  static async createSimpleRepository(featureName, repositoryDir) {
+    const filePath = import_path2.default.join(repositoryDir, `${featureName}.repository.ts`);
+    UFsModule.createFile(filePath, generateSimpleRepositoryTemplate(featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 Repository created: ${filePath}`));
+  }
+  /**
+   * Creates the simple concrete service (no interface, wires the repository).
+   */
+  static async createSimpleService(featureName, serviceDir) {
+    const filePath = import_path2.default.join(serviceDir, `${featureName}.service.ts`);
+    UFsModule.createFile(filePath, generateSimpleServiceTemplate(featureName));
+    console.log(import_ansi_colors5.default.green(`\u2714 Service created: ${filePath}`));
+  }
+  /**
+   * Creates the simple controller (delegates to service, no use-case/presenter).
+   */
+  static async createSimpleController(featureName, controllerDir) {
+    const controllerName = `${this.capitalize(featureName)}Controller`;
+    const filePath = import_path2.default.join(controllerDir, `${featureName}.controller.ts`);
+    const wantsMethods = await UPrompt.confirm("Do you want to add methods to the controller?");
+    let methods = [];
+    let content;
+    if (wantsMethods && !(0, import_prompts3.isCancel)(wantsMethods)) {
+      const methodsText = await UPrompt.text(
+        "Enter the method names (comma separated):",
+        "create, findAll, findById, update, delete",
+        (v) => v ? void 0 : "You must enter at least one method."
+      );
+      if (!(0, import_prompts3.isCancel)(methodsText)) {
+        methods = methodsText.split(",").map((m) => m.trim()).filter(Boolean);
+      }
+      content = generateSimpleControllerTemplate(controllerName, featureName, methods);
+    } else {
+      content = `import { Request, Response } from "express";
+
+export class ${controllerName} {}
+`;
+    }
+    UFsModule.createFile(filePath, content);
+    console.log(import_ansi_colors5.default.green(`\u2714 Controller created: ${filePath}`));
+    return { controllerName, methods };
+  }
+  /**
+   * Creates the route handler (HTTP verb + path → controller method bindings).
+   *
+   */
+  static async createRouterHandler(featureName, routerHandlerDir, controllerMethods) {
+    const filePath = import_path2.default.join(routerHandlerDir, `${featureName}.router.handler.ts`);
+    const content = this.structure === "simple" ? generateSimpleRouterHandlerTemplate(featureName, controllerMethods) : generateRouterHandlerTemplate(featureName, controllerMethods);
+    UFsModule.createFile(filePath, content);
+    console.log(import_ansi_colors5.default.green(`\u2714 Router Handler created: ${filePath}`));
+  }
+  /**
+   * Creates the feature router and registers it in register.router.ts.
+   *
+   */
+  static async createRouter(featureName, routerDir) {
+    const filePath = import_path2.default.join(routerDir, `${featureName}.router.ts`);
+    const content = this.structure === "simple" ? generateSimpleRouterTemplate(featureName) : generateRouterTemplate(featureName);
+    UFsModule.createFile(filePath, content);
+    await this.updateRegisterRouter(featureName);
+    console.log(import_ansi_colors5.default.green(`\u2714 Router created: ${filePath}`));
+  }
+  static capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  /**
+   * Appends an import and registers the new router in register.router.ts.
+   */
+  static async updateRegisterRouter(featureName) {
+    const routerName = `${this.capitalize(featureName)}Router`;
+    const routerPath = this.structure === "simple" || this.structure === "mvc" || this.structure === "layered" ? `../../features/${featureName}/routes/${featureName}.router` : this.structure === "custom" ? `../../features/${featureName}/${featureName}.router` : `../../features/${featureName}/infrastructure/routes/${featureName}.router`;
+    const importStatement = `import { ${routerName} } from "${routerPath}"`;
+    try {
+      if (!import_fs2.default.existsSync(this.REGISTER_ROUTER_PATH)) {
+        console.log(
+          import_ansi_colors5.default.yellow(`\u26A0  register.router.ts not found at ${this.REGISTER_ROUTER_PATH}, skipping auto-registration.`)
+        );
+        return;
+      }
+      let content = import_fs2.default.readFileSync(this.REGISTER_ROUTER_PATH, "utf-8");
+      if (content.includes(`import { ${routerName} } from`)) {
+        console.log(import_ansi_colors5.default.cyan(`\u2139  ${routerName} is already registered.`));
+        return;
+      }
+      const lines = content.split("\n");
+      let lastImportIndex = -1;
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim().startsWith("import ")) lastImportIndex = i;
+      }
+      if (lastImportIndex !== -1) {
+        lines.splice(lastImportIndex + 1, 0, importStatement);
+        content = lines.join("\n");
+      } else {
+        content = importStatement + "\n" + content;
+      }
+      const ARRAY_OPEN = "registered([";
+      const ARRAY_CLOSE = "]);";
+      const startIdx = content.indexOf(ARRAY_OPEN);
+      if (startIdx === -1) {
+        console.log(import_ansi_colors5.default.yellow(`\u26A0  Could not find 'registered([' in register.router.ts.`));
+        return;
+      }
+      const endIdx = content.indexOf(ARRAY_CLOSE, startIdx + ARRAY_OPEN.length);
+      if (endIdx === -1) {
+        console.log(import_ansi_colors5.default.yellow(`\u26A0  Could not find matching ']);' in register.router.ts.`));
+        return;
+      }
+      const arrayContent = content.substring(startIdx + ARRAY_OPEN.length, endIdx);
+      const existingRoutes = arrayContent.split("\n").map((l) => l.trim().replace(/,+$/, "")).filter(Boolean);
+      if (!existingRoutes.includes(routerName)) {
+        existingRoutes.push(routerName);
+      }
+      const indentedRoutes = existingRoutes.map((r) => `        ${r},`).join("\n");
+      const newContent = content.substring(0, startIdx + ARRAY_OPEN.length) + `
+${indentedRoutes}
+    ` + content.substring(endIdx);
+      import_fs2.default.writeFileSync(this.REGISTER_ROUTER_PATH, newContent, "utf-8");
+      console.log(import_ansi_colors5.default.green(`\u2714 register.router.ts updated with ${routerName}.`));
+    } catch (error) {
+      console.error(import_ansi_colors5.default.red(`\u2718 Failed to update register.router.ts: ${error.message}`));
+    }
+  }
+};
+
+// src/templates/simpleComponent/simpleComponent.template.ts
+var simpleComponentTemplate = async (featureName) => {
+  FeatureComponentGeneratorUtils.setStructure("simple");
+  const basePath = import_path3.default.join("src", "features", featureName);
+  const dirs = [
+    import_path3.default.join(basePath, "routes"),
+    import_path3.default.join(basePath, "controllers"),
+    import_path3.default.join(basePath, "services"),
+    import_path3.default.join(basePath, "repositories"),
+    import_path3.default.join(basePath, "models")
+  ];
+  dirs.forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+  const paths = {
+    modelsDir: import_path3.default.join(basePath, "models"),
+    repositoriesDir: import_path3.default.join(basePath, "repositories"),
+    servicesDir: import_path3.default.join(basePath, "services"),
+    controllersDir: import_path3.default.join(basePath, "controllers"),
+    routesDir: import_path3.default.join(basePath, "routes")
+  };
+  await FeatureComponentGeneratorUtils.createModel(featureName, paths.modelsDir);
+  await FeatureComponentGeneratorUtils.createSimpleRepository(featureName, paths.repositoriesDir);
+  await FeatureComponentGeneratorUtils.createSimpleService(featureName, paths.servicesDir);
+  const controller = await FeatureComponentGeneratorUtils.createSimpleController(
+    featureName,
+    paths.controllersDir
+  );
+  await FeatureComponentGeneratorUtils.createRouterHandler(featureName, paths.routesDir, controller.methods);
+  await FeatureComponentGeneratorUtils.createRouter(featureName, paths.routesDir);
+  console.log(
+    import_ansi_colors6.default.bgGreen(
+      import_ansi_colors6.default.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with Simple Component!
+`)
+    )
+  );
+};
+
+// src/templates/fullCleanComponent/fullCleanComponent.template.ts
+var import_path4 = __toESM(require("path"), 1);
+var import_ansi_colors7 = __toESM(require("ansi-colors"), 1);
+var fullCleanComponentTemplate = async (featureName) => {
+  const basePath = import_path4.default.join("src", "features", featureName);
+  const dirs = [
+    import_path4.default.join(basePath, "domain", "entities"),
+    import_path4.default.join(basePath, "domain", "events"),
+    import_path4.default.join(basePath, "domain", "exceptions"),
+    import_path4.default.join(basePath, "application", "use-cases"),
+    import_path4.default.join(basePath, "application", "dtos"),
+    import_path4.default.join(basePath, "application", "ports", "repositories"),
+    import_path4.default.join(basePath, "application", "ports", "presenters"),
+    import_path4.default.join(basePath, "application", "ports", "services"),
+    import_path4.default.join(basePath, "infrastructure", "adapters", "controllers"),
+    import_path4.default.join(basePath, "infrastructure", "adapters", "repositories"),
+    import_path4.default.join(basePath, "infrastructure", "adapters", "presenters"),
+    import_path4.default.join(basePath, "infrastructure", "routes")
+  ];
+  dirs.forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+  const paths = {
+    entityDir: import_path4.default.join(basePath, "domain", "entities"),
+    eventDir: import_path4.default.join(basePath, "domain", "events"),
+    exceptionDir: import_path4.default.join(basePath, "domain", "exceptions"),
+    repositoryInterfaceDir: import_path4.default.join(basePath, "application", "ports", "repositories"),
+    presenterInterfaceDir: import_path4.default.join(basePath, "application", "ports", "presenters"),
+    serviceDir: import_path4.default.join(basePath, "application", "ports", "services"),
+    dtoDir: import_path4.default.join(basePath, "application", "dtos"),
+    useCaseDir: import_path4.default.join(basePath, "application", "use-cases"),
+    repositoryImplDir: import_path4.default.join(basePath, "infrastructure", "adapters", "repositories"),
+    presenterImplDir: import_path4.default.join(basePath, "infrastructure", "adapters", "presenters"),
+    controllerDir: import_path4.default.join(basePath, "infrastructure", "adapters", "controllers"),
+    routerDir: import_path4.default.join(basePath, "infrastructure", "routes")
+  };
+  await FeatureComponentGeneratorUtils.createEntity(featureName, paths.entityDir);
+  await FeatureComponentGeneratorUtils.createEvent(featureName, paths.eventDir);
+  await FeatureComponentGeneratorUtils.createException(featureName, paths.exceptionDir);
+  await FeatureComponentGeneratorUtils.createRepositoryInterface(featureName, paths.repositoryInterfaceDir);
+  await FeatureComponentGeneratorUtils.createPresenterInterface(featureName, paths.presenterInterfaceDir);
+  await FeatureComponentGeneratorUtils.createService(featureName, paths.serviceDir);
+  await FeatureComponentGeneratorUtils.createDto(featureName, paths.dtoDir);
+  await FeatureComponentGeneratorUtils.createUseCase(featureName, paths.useCaseDir);
+  await FeatureComponentGeneratorUtils.createRepositoryImpl(featureName, paths.repositoryImplDir);
+  await FeatureComponentGeneratorUtils.createPresenterImpl(featureName, paths.presenterImplDir);
+  const controller = await FeatureComponentGeneratorUtils.createController(
+    featureName,
+    paths.controllerDir
+  );
+  await FeatureComponentGeneratorUtils.createRouterHandler(featureName, paths.routerDir, controller.methods);
+  await FeatureComponentGeneratorUtils.createRouter(featureName, paths.routerDir);
+  console.log(
+    import_ansi_colors7.default.bgGreen(
+      import_ansi_colors7.default.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with Clean Architecture!
+`)
+    )
+  );
+};
+
+// src/templates/cleanComponentByStep/cleanComponentByStep.template.ts
+var import_path5 = __toESM(require("path"), 1);
+var import_ansi_colors8 = __toESM(require("ansi-colors"), 1);
+var import_prompts4 = require("@clack/prompts");
+var cleanComponentByStepTemplate = async (featureName) => {
+  const base = import_path5.default.join("src", "features", featureName);
+  let created = 0;
+  let controller = { controllerName: "", methods: [] };
+  const ask = async (label) => {
+    const answer = await UPrompt.confirm(label, false);
+    if ((0, import_prompts4.isCancel)(answer)) {
+      UFsModule.removeDir(base, true, true);
+      process.exit(0);
+    }
+    return answer;
+  };
+  const track = () => {
+    created++;
+  };
+  console.log(import_ansi_colors8.default.bold(import_ansi_colors8.default.cyan("\n Domain ")));
+  const mkDir = (dir) => {
+    UFsModule.createDirectoryRecursively(dir);
+    return dir;
+  };
+  if (await ask(`Entity  -  ${featureName}.entity.ts`)) {
+    await FeatureComponentGeneratorUtils.createEntity(featureName, mkDir(import_path5.default.join(base, "domain", "entities")));
+    track();
+  }
+  if (await ask(`Event  -  ${featureName}.event.ts`)) {
+    await FeatureComponentGeneratorUtils.createEvent(featureName, mkDir(import_path5.default.join(base, "domain", "events")));
+    track();
+  }
+  if (await ask(`Exception  -  ${featureName}.exception.ts`)) {
+    await FeatureComponentGeneratorUtils.createException(featureName, mkDir(import_path5.default.join(base, "domain", "exceptions")));
+    track();
+  }
+  console.log(import_ansi_colors8.default.bold(import_ansi_colors8.default.cyan("\n Application ")));
+  if (await ask(`Repo Interface  -  ${featureName}.repository.interface.ts`)) {
+    await FeatureComponentGeneratorUtils.createRepositoryInterface(featureName, mkDir(import_path5.default.join(base, "application", "ports", "repositories")));
+    track();
+  }
+  if (await ask(`Presenter Port  -  ${featureName}.presenter.interface.ts`)) {
+    await FeatureComponentGeneratorUtils.createPresenterInterface(featureName, mkDir(import_path5.default.join(base, "application", "ports", "presenters")));
+    track();
+  }
+  if (await ask(`Service Port  -  ${featureName}.service.ts`)) {
+    await FeatureComponentGeneratorUtils.createService(featureName, mkDir(import_path5.default.join(base, "application", "ports", "services")));
+    track();
+  }
+  if (await ask(`DTO  -  ${featureName}.dto.ts`)) {
+    await FeatureComponentGeneratorUtils.createDto(featureName, mkDir(import_path5.default.join(base, "application", "dtos")));
+    track();
+  }
+  if (await ask(`Use Case  -  ${featureName}.usecase.ts`)) {
+    await FeatureComponentGeneratorUtils.createUseCase(featureName, mkDir(import_path5.default.join(base, "application", "use-cases")));
+    track();
+  }
+  console.log(import_ansi_colors8.default.bold(import_ansi_colors8.default.cyan("\n Infrastructure ")));
+  if (await ask(`Repo Impl  -  ${featureName}.repository.ts`)) {
+    await FeatureComponentGeneratorUtils.createRepositoryImpl(featureName, mkDir(import_path5.default.join(base, "infrastructure", "adapters", "repositories")));
+    track();
+  }
+  if (await ask(`Presenter Impl  -  ${featureName}.presenter.ts`)) {
+    await FeatureComponentGeneratorUtils.createPresenterImpl(featureName, mkDir(import_path5.default.join(base, "infrastructure", "adapters", "presenters")));
+    track();
+  }
+  if (await ask(`Controller  -  ${featureName}.controller.ts`)) {
+    controller = await FeatureComponentGeneratorUtils.createController(featureName, mkDir(import_path5.default.join(base, "infrastructure", "adapters", "controllers")));
+    track();
+  }
+  if (await ask(`Router Handler  -  ${featureName}.router.handler.ts`)) {
+    await FeatureComponentGeneratorUtils.createRouterHandler(featureName, mkDir(import_path5.default.join(base, "infrastructure", "routes")), controller.methods);
+    track();
+  }
+  if (await ask(`Router  -  ${featureName}.router.ts`)) {
+    await FeatureComponentGeneratorUtils.createRouter(featureName, mkDir(import_path5.default.join(base, "infrastructure", "routes")));
+    track();
+  }
+  if (created === 0) {
+    console.log(import_ansi_colors8.default.yellow(`
+\u26A0 No files were created for feature "${featureName}".`));
+  } else {
+    console.log(
+      import_ansi_colors8.default.bgGreen(import_ansi_colors8.default.white(`
+\u{1F389}  Feature "${featureName}" \u2014 ${created} file(s) created step by step.
+`))
+    );
+  }
+};
+
+// src/core/components/application/createController.application.ts
+var createComponentApplication = async (featureDirectory, featureName) => {
+  const askComponentType = await _controllerType(
+    "Choose a type of component :",
+    CCleanType.full_clean_component,
+    [
+      { label: "Simple component", value: [CCleanType.simple_component] },
+      { label: "CLEAN Architecture component by step", value: [CCleanType.clean_component_by_step] },
+      { label: "Full CLEAN Architecture component", value: [CCleanType.full_clean_component] }
+    ]
+  );
+  if ((0, import_prompts5.isCancel)(askComponentType) === true || askComponentType === void 0) {
+    BaseService._cancelOperation(featureDirectory);
+  } else {
+    switch (askComponentType) {
+      case CCleanType.simple_component:
+        await simpleComponentTemplate(featureName);
+        break;
+      case CCleanType.clean_component_by_step:
+        await cleanComponentByStepTemplate(featureName);
+        break;
+      case CCleanType.full_clean_component:
+        await fullCleanComponentTemplate(featureName);
+        break;
+    }
+  }
+};
+
+// src/templates/customModule/buildYourOwnArchitectureScaffold.template.ts
+var import_path6 = __toESM(require("path"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
+var import_ansi_colors9 = __toESM(require("ansi-colors"), 1);
+var import_prompts6 = require("@clack/prompts");
+
+// src/core/domains/constants/resolveRoute.constant.ts
+var CResolveRoute = (methodName, moduleName) => {
+  const lower = methodName.toLowerCase();
+  if (lower.includes("findall") || lower.includes("getall")) return { httpMethod: "get", path: `/${moduleName}` };
+  if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) return { httpMethod: "get", path: `/${moduleName}/:id` };
+  if (lower.includes("create") || lower.includes("add")) return { httpMethod: "post", path: `/${moduleName}` };
+  if (lower.includes("update") || lower.includes("edit")) return { httpMethod: "put", path: `/${moduleName}/:id` };
+  if (lower.includes("delete") || lower.includes("remove")) return { httpMethod: "delete", path: `/${moduleName}/:id` };
+  return { httpMethod: "get", path: `/${moduleName}/${lower}` };
+};
+
+// src/templates/customModule/buildYourOwnArchitecture.template.ts
+var capitalize17 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+var generateBuildYourOwnControllerTemplate = (fileName, methods) => {
+  const controllerName = `${capitalize17(fileName)}Controller`;
+  const body = methods.length === 0 ? `    // TODO: add your handler methods here` : methods.map((method) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            // TODO: implement ${method}
+            return ResponseHandler.success({}, "success", HttpStatusCode.OK);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : "Internal server error";
+            return ResponseHandler.error(message, HttpStatusCode.INTERNAL_SERVER_ERROR);
+        }
+    }`).join("\n");
+  return `import { Request, Response } from "opticore-express";
+import { ResponseHandler, HttpStatusCode, IResponseHandlerSuccessData } from "opticore-http-response";
+
+export class ${controllerName} {
+${body}
+}`.trimEnd() + "\n";
+};
+var generateBuildYourOwnServiceClassTemplate = (fileName, methods) => {
+  const serviceName = `${capitalize17(fileName)}Service`;
+  const body = methods.length === 0 ? `    // TODO: add your service methods here` : methods.map((method) => `
+    async ${method}(): Promise<unknown> {
+        // TODO: implement ${method}
+        throw new Error("Not implemented");
+    }`).join("\n");
+  return `export class ${serviceName} {
+${body}
+}`.trimEnd() + "\n";
+};
+var generateBuildYourOwnServiceFunctionTemplate = (fileName) => {
+  const functionName = `${fileName}Service`;
+  return `export async function ${functionName}(): Promise<unknown> {
+    // TODO: implement ${functionName}
+    throw new Error("Not implemented");
+}`.trimEnd() + "\n";
+};
+var generateBuildYourOwnDtoTemplate = (fileName, fields) => {
+  const dtoName = `${capitalize17(fileName)}Dto`;
+  const body = fields.length === 0 ? `    // TODO: define the fields of this DTO` : fields.map((field) => `    ${field.name}: ${field.type};`).join("\n");
+  return `export interface ${dtoName} {
+${body}
+}`.trimEnd() + "\n";
+};
+var generateBuildYourOwnEntityTemplate = (fileName, properties) => {
+  const entityName = `${capitalize17(fileName)}Entity`;
+  const ctorParams = properties.length === 0 ? `        // TODO: define the properties of this entity` : properties.map((prop) => `        public readonly ${prop.name}: ${prop.type},`).join("\n");
+  return `export class ${entityName} {
+    constructor(
+${ctorParams}
+    ) {}
+}`.trimEnd() + "\n";
+};
+var generateBuildYourOwnRepositoryTemplate = (fileName, methods) => {
+  const repositoryName = `${capitalize17(fileName)}Repository`;
+  const body = methods.length === 0 ? `    // TODO: define the actions this repository can perform` : methods.map((method) => `    async ${method}(): Promise<unknown> { throw new Error("Not implemented"); }`).join("\n");
+  return `export class ${repositoryName} {
+    // TODO: inject your data source (ORM, DB client, etc.)
+${body}
+}`.trimEnd() + "\n";
+};
+var generateBuildYourOwnRouteTemplate = (fileName, actions) => {
+  const capitalized = capitalize17(fileName);
+  const handlerName = `${capitalized}HandlerRouter`;
+  const controllerName = `${capitalized}Controller`;
+  const routes = actions.map((action) => {
+    const { httpMethod, path: path10 } = CResolveRoute(action, fileName);
+    return { httpMethod, path: path10, action };
+  });
+  const body = routes.length === 0 ? `        // TODO: define the routes for this module` : routes.map((route) => `{
+    path: "${route.path}",
+    method: "${route.httpMethod}",
+    middlewares: [],
+    handler: async (ctx: ICustomContext) => await ${controllerName}.${route.action}(ctx.req, ctx.res)
+}`).join(",\n").replace(/\n/g, "\n            ");
+  return `import { OpticoreRoutingFactory, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+// TODO: adjust this import if "${controllerName}" lives in a different folder
+import { ${controllerName} } from "./${fileName}.controller";
+
+export const ${handlerName}: () => IMultipleRouteDefinition = () => {
+    return OpticoreRoutingFactory.routes(
+        ${controllerName},
+        [
+            ${body}
+        ]
+    );
+};`.trimEnd() + "\n";
+};
+
+// src/templates/customModule/buildYourOwnArchitectureScaffold.template.ts
+var ok = (msg) => {
+  console.log(import_ansi_colors9.default.green(`\u2714 ${msg}`));
+};
+var info = (msg) => {
+  console.log(import_ansi_colors9.default.cyan(`\u2139  ${msg}`));
+};
+var NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+var askName = async (message, placeholder) => {
+  const raw = await UPrompt.text(message, placeholder, (value) => {
+    if (!value) {
+      return "Please enter a name.";
+    }
+    if (!NAME_PATTERN.test(value)) {
+      return "Use letters, numbers, - or _, starting with a letter.";
+    }
+  });
+  if ((0, import_prompts6.isCancel)(raw)) {
+    return void 0;
+  }
+  return raw;
+};
+var askCommaSeparatedList = async (message, placeholder) => {
+  const raw = await UPrompt.text(message, placeholder, () => void 0);
+  if ((0, import_prompts6.isCancel)(raw) || !raw) return [];
+  return raw.split(",").map((v) => v.trim()).filter(Boolean);
+};
+var parseFieldDefinitions = (raw) => raw.map((entry) => {
+  const [name, type] = entry.split(":").map((v) => v.trim());
+  return { name: name || entry, type: type || "string" };
+});
+var renderTree = (node, prefix = "") => {
+  const lines = [];
+  const children = node.children ?? [];
+  children.forEach((child, index) => {
+    const isLast = index === children.length - 1;
+    const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    lines.push(`${prefix}${branch}${child.name}${child.type === "dir" ? "/" : ""}`);
+    if (child.type === "dir") {
+      const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
+      lines.push(...renderTree(child, nextPrefix));
+    }
+  });
+  return lines;
+};
+var printTree = (root) => {
+  console.log(import_ansi_colors9.default.yellow(`${root.name}/`));
+  renderTree(root).forEach((line) => console.log(import_ansi_colors9.default.yellow(line)));
+};
+async function handleFileCreation(dirPath) {
+  const fileType = await UPrompt.select(
+    "What type of file do you want to create?",
+    ["controller"],
+    [
+      { label: "Controller", value: ["controller"] },
+      { label: "Service", value: ["service"] },
+      { label: "DTO", value: ["dto"] },
+      { label: "Entity", value: ["entity"] },
+      { label: "Repository", value: ["repository"] },
+      { label: "Route", value: ["route"] }
+    ]
+  );
+  if ((0, import_prompts6.isCancel)(fileType)) return void 0;
+  const baseName = await askName(`Enter the name of this ${fileType} (without extension):`, "user");
+  if (!baseName) return void 0;
+  let fileName;
+  let content;
+  switch (fileType) {
+    case "controller": {
+      const wantsMethods = await UPrompt.confirm("Do you want to create methods for this controller?");
+      let methods = [];
+      if (wantsMethods === true) {
+        methods = await askCommaSeparatedList(
+          "Enter the method names (comma separated):",
+          "create, findAll, findById, update, delete"
+        );
+      }
+      fileName = `${baseName}.controller.ts`;
+      content = generateBuildYourOwnControllerTemplate(baseName, methods);
+      break;
+    }
+    case "service": {
+      const kind = await UPrompt.select(
+        "Do you want a class with methods, or a service that is just a function?",
+        ["class"],
+        [
+          { label: "Class with methods", value: ["class"] },
+          { label: "Single function", value: ["function"] }
+        ]
+      );
+      if ((0, import_prompts6.isCancel)(kind)) return void 0;
+      fileName = `${baseName}.service.ts`;
+      if (kind === "class") {
+        const methods = await askCommaSeparatedList(
+          "Enter the method names (comma separated):",
+          "findAll, findById, create, update, delete"
+        );
+        content = generateBuildYourOwnServiceClassTemplate(baseName, methods);
+      } else {
+        content = generateBuildYourOwnServiceFunctionTemplate(baseName);
+      }
+      break;
+    }
+    case "dto": {
+      const raw = await askCommaSeparatedList(
+        "Enter the DTO fields as name:type pairs, comma separated:",
+        "name:string, email:string"
+      );
+      fileName = `${baseName}.dto.ts`;
+      content = generateBuildYourOwnDtoTemplate(baseName, parseFieldDefinitions(raw));
+      break;
+    }
+    case "entity": {
+      const raw = await askCommaSeparatedList(
+        "Enter the entity properties as name:type pairs, comma separated:",
+        "id:string, name:string, createdAt:Date"
+      );
+      fileName = `${baseName}.entity.ts`;
+      content = generateBuildYourOwnEntityTemplate(baseName, parseFieldDefinitions(raw));
+      break;
+    }
+    case "repository": {
+      const methods = await askCommaSeparatedList(
+        "Enter the actions this repository should perform (comma separated):",
+        "findAll, findById, save, update, delete"
+      );
+      fileName = `${baseName}.repository.ts`;
+      content = generateBuildYourOwnRepositoryTemplate(baseName, methods);
+      break;
+    }
+    case "route": {
+      const actions = await askCommaSeparatedList(
+        "Enter the actions to expose as routes (comma separated):",
+        "findAll, findById, create, update, delete"
+      );
+      fileName = `${baseName}.route.ts`;
+      content = generateBuildYourOwnRouteTemplate(baseName, actions);
+      break;
+    }
+  }
+  const filePath = import_path6.default.join(dirPath, fileName);
+  UFsModule.createFile(filePath, content);
+  ok(fileName);
+  return { name: fileName, type: "file" };
+}
+async function handleDirectory(dirPath, node) {
+  let keepGoing = true;
+  while (keepGoing) {
+    const choice = await UPrompt.select(
+      `Inside "${node.name}", do you want to create a file or a folder?`,
+      ["file"],
+      [
+        { label: "File", value: ["file"] },
+        { label: "Folder", value: ["folder"] }
+      ]
+    );
+    if ((0, import_prompts6.isCancel)(choice)) return;
+    if (choice === "folder") {
+      const folderName = await askName("Enter the folder name:", "core");
+      if (!folderName) return;
+      const subDir = import_path6.default.join(dirPath, folderName);
+      UFsModule.createDirectoryRecursively(subDir);
+      const subNode = { name: folderName, type: "dir", children: [] };
+      node.children.push(subNode);
+      ok(`${folderName}/`);
+      await handleDirectory(subDir, subNode);
+    } else {
+      const fileNode = await handleFileCreation(dirPath);
+      if (fileNode) {
+        node.children.push(fileNode);
+      }
+    }
+    info(`Current structure of "${node.name}":`);
+    printTree(node);
+    const wantsContinue = await UPrompt.confirm(`Continue creating files/folders inside "${node.name}"?`);
+    if ((0, import_prompts6.isCancel)(wantsContinue) || wantsContinue !== true) {
+      keepGoing = false;
+    }
+  }
+}
+var buildYourOwnArchitectureScaffoldTemplate = async () => {
+  const featuresDir = import_path6.default.join(process.cwd(), "src", "features");
+  const forest = [];
+  let creatingNewRoot = true;
+  while (creatingNewRoot) {
+    const rootName = await askName("Enter the name of the root folder for your architecture:", "myArchitecture");
+    if (!rootName) {
+      console.log(import_ansi_colors9.default.bgRed(import_ansi_colors9.default.white("Operation cancelled.")));
+      process.exit(0);
+    }
+    const rootDir = import_path6.default.join(featuresDir, rootName);
+    if (import_fs3.default.existsSync(rootDir)) {
+      info(`Folder "${rootName}" already exists, new files/folders will be added inside it.`);
+    }
+    UFsModule.createDirectoryRecursively(rootDir);
+    const rootNode = { name: rootName, type: "dir", children: [] };
+    forest.push(rootNode);
+    await handleDirectory(rootDir, rootNode);
+    const wantsNewRoot = await UPrompt.confirm(
+      "Do you want to create a new folder at the root of your architecture?",
+      false
+    );
+    if ((0, import_prompts6.isCancel)(wantsNewRoot) || wantsNewRoot !== true) {
+      console.log(import_ansi_colors9.default.cyan("En disant non, ce sera la fin de la cr\xE9ation de votre propre architecture."));
+      creatingNewRoot = false;
+    }
+  }
+  console.log(`
+${import_ansi_colors9.default.bgGreen(import_ansi_colors9.default.white("\n\u{1F389}  Your custom architecture has been created!\n"))}`);
+  forest.forEach((root) => printTree(root));
+};
+
+// src/templates/mvcModule/mvcModuleScaffold.template.ts
+var import_path7 = __toESM(require("path"), 1);
+var import_ansi_colors10 = __toESM(require("ansi-colors"), 1);
+var import_prompts7 = require("@clack/prompts");
+
+// src/templates/mvcModule/mvcModule.template.ts
+var capitalize18 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+var generateMvcModelTemplate = (featureName) => {
+  const capitalized = capitalize18(featureName);
+  const modelName = `${capitalized}Model`;
+  return `/**
+ * ${modelName} \u2014 Model
+ * Owns both the data shape and the data-access logic for "${featureName}".
+ */
+export class ${modelName} {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+
+    constructor(
+        id: string,
+        // TODO: add your model properties here
+        createdAt?: Date,
+        updatedAt?: Date,
+    ) {
+        this.id = id;
+        this.createdAt = createdAt ?? new Date();
+        this.updatedAt = updatedAt ?? new Date();
+    }
+
+    private static store: Map<string, ${modelName}> = new Map();
+
+    static async findAll(): Promise<${modelName}[]> {
+        // TODO: Replace with your ORM query
+        return Array.from(this.store.values());
+    }
+
+    static async findById(id: string): Promise<${modelName} | null> {
+        // TODO: Replace with your ORM query
+        return this.store.get(id) ?? null;
+    }
+
+    static async create(data: Record<string, unknown>): Promise<${modelName}> {
+        const model = new ${modelName}(String(Date.now()));
+        // TODO: Map data fields onto model
+        this.store.set(model.id, model);
+        return model;
+    }
+
+    static async update(id: string, data: Record<string, unknown>): Promise<${modelName} | null> {
+        const existing = this.store.get(id);
+        if (!existing) return null;
+        // TODO: Apply data fields onto existing model
+        existing.updatedAt = new Date();
+        this.store.set(id, existing);
+        return existing;
+    }
+
+    static async delete(id: string): Promise<boolean> {
+        // TODO: Replace with your ORM delete
+        return this.store.delete(id);
+    }
+}
+`;
+};
+var generateMvcViewTemplate = (featureName) => {
+  const capitalized = capitalize18(featureName);
+  const modelName = `${capitalized}Model`;
+  const viewName = `${capitalized}View`;
+  return `import { ${modelName} } from "../models/${featureName}.model";
+
+/**
+ * ${viewName} \u2014 View
+ * Shapes "${featureName}" data before it is sent back as JSON.
+ */
+export class ${viewName} {
+    static toJSON(model: ${modelName}): Record<string, unknown> {
+        return {
+            id: model.id,
+            createdAt: model.createdAt,
+            updatedAt: model.updatedAt,
+            // TODO: expose the fields API consumers should see (and only those)
+        };
+    }
+
+    static toJSONList(models: ${modelName}[]): Record<string, unknown>[] {
+        return models.map((model: ${modelName}): Record<string, unknown> => this.toJSON(model));
+    }
+}
+`;
+};
+var generateMvcControllerTemplate = (controllerName, featureName, methods) => {
+  const capitalized = capitalize18(featureName);
+  const modelName = `${capitalized}Model`;
+  const viewName = `${capitalized}View`;
+  const methodsCode = methods.map((method) => generateMethod3(method, capitalized, modelName, viewName)).join("\n");
+  return `import { Request, Response } from "opticore-express";
+import { ResponseHandler, HttpStatusCode, IResponseHandlerSuccessData } from "opticore-http-response";
+import { ${modelName} } from "../models/${featureName}.model";
+import { ${viewName} } from "../views/${featureName}.view";
+
+export class ${controllerName} {
+${methodsCode}
+    private static handleError(error: unknown) {
+        const message = error instanceof Error ? error.message : "Internal server error";
+        return ResponseHandler.error(message, HttpStatusCode.INTERNAL_SERVER_ERROR);
+    }
+}
+`;
+};
+var generateMethod3 = (method, capitalized, modelName, viewName) => {
+  const lower = method.toLowerCase();
+  if (lower.includes("findall") || lower.includes("getall")) {
+    return generateFindAllMethod3(method, capitalized, modelName, viewName);
+  }
+  if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) {
+    return generateFindByIdMethod3(method, capitalized, modelName, viewName);
+  }
+  if (lower.includes("create") || lower.includes("add")) {
+    return generateCreateMethod3(method, capitalized, modelName, viewName);
+  }
+  if (lower.includes("update") || lower.includes("edit")) {
+    return generateUpdateMethod3(method, capitalized, modelName, viewName);
+  }
+  if (lower.includes("delete") || lower.includes("remove")) {
+    return generateDeleteMethod3(method, capitalized, modelName);
+  }
+  return `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            // TODO: Implement ${method} logic
+            return ResponseHandler.success({}, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+};
+var generateFindAllMethod3 = (method, capitalized, modelName, viewName) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const models = await ${modelName}.findAll();
+            return ResponseHandler.success(${viewName}.toJSONList(models), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateFindByIdMethod3 = (method, capitalized, modelName, viewName) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const model = await ${modelName}.findById(id);
+            if (!model) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(${viewName}.toJSON(model), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateCreateMethod3 = (method, capitalized, modelName, viewName) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const model = await ${modelName}.create(req.body);
+            return ResponseHandler.success(${viewName}.toJSON(model), "created", HttpStatusCode.CREATED);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateUpdateMethod3 = (method, capitalized, modelName, viewName) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const model = await ${modelName}.update(id, req.body);
+            if (!model) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(${viewName}.toJSON(model), "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateDeleteMethod3 = (method, capitalized, modelName) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const deleted = await ${modelName}.delete(id);
+            if (!deleted) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(null, "deleted", HttpStatusCode.NO_CONTENT);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateMvcRouterHandlerTemplate = (featureName, controllerMethods) => {
+  const capitalized = capitalize18(featureName);
+  const handlerName = `${capitalized}HandlerRouter`;
+  const controllerName = `${capitalized}Controller`;
+  const routesCode = (controllerMethods || []).map((method) => {
+    const { httpMethod, path: path10 } = resolveRoute3(method, featureName);
+    return `{
+    path: \`${path10}\`,
+    method: "${httpMethod}",
+    middlewares: [],
+    handler: async (ctx: ICustomContext) => await ${controllerName}.${method}(ctx.req, ctx.res)
+}`;
+  }).join(",\n");
+  return `import { OpticoreRoutingFactory, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+import { ${controllerName} } from "../controllers/${featureName}.controller";
+
+export const ${handlerName}: () => IMultipleRouteDefinition = () => {
+    return OpticoreRoutingFactory.routes(
+        ${controllerName},
+        [
+            ${routesCode.replace(/\n/g, "\n            ")}
+        ]
+    );
+};
+`;
+};
+var generateMvcRouterTemplate = (featureName) => {
+  const capitalized = capitalize18(featureName);
+  const handlerName = `${capitalized}HandlerRouter`;
+  const routerName = `${capitalized}Router`;
+  return `import { ${handlerName} } from "./${featureName}.router.handler";
+import { TFeatureRoutes } from "opticore-router";
+
+export const ${routerName}: TFeatureRoutes = {
+    routes: [
+        {
+            path: ${handlerName}().path,
+            handler: ${handlerName}().handler
+        }
+    ]
+};
+`;
+};
+var resolveRoute3 = (methodName, featureName) => {
+  const lower = methodName.toLowerCase();
+  if (lower.includes("findall") || lower.includes("getall")) {
+    return { httpMethod: "get", path: `/${featureName}` };
+  }
+  if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) {
+    return { httpMethod: "get", path: `/${featureName}/:id` };
+  }
+  if (lower.includes("create") || lower.includes("add")) {
+    return { httpMethod: "post", path: `/${featureName}` };
+  }
+  if (lower.includes("update") || lower.includes("edit")) {
+    return { httpMethod: "put", path: `/${featureName}/:id` };
+  }
+  if (lower.includes("delete") || lower.includes("remove")) {
+    return { httpMethod: "delete", path: `/${featureName}/:id` };
+  }
+  return { httpMethod: "get", path: `/${featureName}/${lower}` };
+};
+
+// src/templates/mvcModule/mvcModuleScaffold.template.ts
+var capitalize19 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+var mvcModuleTemplate = async (featureName) => {
+  FeatureComponentGeneratorUtils.setStructure("mvc");
+  const basePath = import_path7.default.join("src", "features", featureName);
+  const paths = {
+    modelsDir: import_path7.default.join(basePath, "models"),
+    viewsDir: import_path7.default.join(basePath, "views"),
+    controllersDir: import_path7.default.join(basePath, "controllers"),
+    routesDir: import_path7.default.join(basePath, "routes")
+  };
+  Object.values(paths).forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+  const controllerName = `${capitalize19(featureName)}Controller`;
+  UFsModule.createFile(import_path7.default.join(paths.modelsDir, `${featureName}.model.ts`), generateMvcModelTemplate(featureName));
+  console.log(import_ansi_colors10.default.green(`\u2714 Model created: ${import_path7.default.join(paths.modelsDir, `${featureName}.model.ts`)}`));
+  UFsModule.createFile(import_path7.default.join(paths.viewsDir, `${featureName}.view.ts`), generateMvcViewTemplate(featureName));
+  console.log(import_ansi_colors10.default.green(`\u2714 View created: ${import_path7.default.join(paths.viewsDir, `${featureName}.view.ts`)}`));
+  const wantsMethods = await UPrompt.confirm("Do you want to add methods to the controller?");
+  let methods = [];
+  let controllerContent;
+  if (wantsMethods && !(0, import_prompts7.isCancel)(wantsMethods)) {
+    const methodsText = await UPrompt.text(
+      "Enter the method names (comma separated):",
+      "create, findAll, findById, update, delete",
+      (v) => v ? void 0 : "You must enter at least one method."
+    );
+    if (!(0, import_prompts7.isCancel)(methodsText)) {
+      methods = methodsText.split(",").map((m) => m.trim()).filter(Boolean);
+    }
+    controllerContent = generateMvcControllerTemplate(controllerName, featureName, methods);
+  } else {
+    controllerContent = `import { Request, Response } from "opticore-express";
+
+export class ${controllerName} {}
+`;
+  }
+  const controllerPath = import_path7.default.join(paths.controllersDir, `${featureName}.controller.ts`);
+  UFsModule.createFile(controllerPath, controllerContent);
+  console.log(import_ansi_colors10.default.green(`\u2714 Controller created: ${controllerPath}`));
+  UFsModule.createFile(
+    import_path7.default.join(paths.routesDir, `${featureName}.router.handler.ts`),
+    generateMvcRouterHandlerTemplate(featureName, methods)
+  );
+  console.log(import_ansi_colors10.default.green(`\u2714 Router Handler created: ${import_path7.default.join(paths.routesDir, `${featureName}.router.handler.ts`)}`));
+  UFsModule.createFile(
+    import_path7.default.join(paths.routesDir, `${featureName}.router.ts`),
+    generateMvcRouterTemplate(featureName)
+  );
+  await FeatureComponentGeneratorUtils.registerModuleRouter(featureName);
+  console.log(import_ansi_colors10.default.green(`\u2714 Router created: ${import_path7.default.join(paths.routesDir, `${featureName}.router.ts`)}`));
+  console.log(
+    import_ansi_colors10.default.bgGreen(
+      import_ansi_colors10.default.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with MVC architecture!
+`)
+    )
+  );
+};
+
+// src/templates/layeredModule/layeredModuleScaffold.template.ts
+var import_path8 = __toESM(require("path"), 1);
+var import_ansi_colors11 = __toESM(require("ansi-colors"), 1);
+var import_prompts8 = require("@clack/prompts");
+
+// src/templates/layeredModule/layeredModule.template.ts
+var capitalize20 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+var generateLayeredEntityTemplate = (featureName) => {
+  const capitalized = capitalize20(featureName);
+  const entityName = `${capitalized}Entity`;
+  return `/**
+ * ${entityName} \u2014 Entity
+ * Plain data structure for the "${featureName}" domain. No data-access logic here.
+ */
+export class ${entityName} {
+    constructor(
+        public readonly id: string,
+        // TODO: add your entity fields here
+        public readonly createdAt: Date = new Date(),
+        public readonly updatedAt: Date = new Date(),
+    ) {}
+}
+`;
+};
+var generateLayeredDtoTemplate = (featureName) => {
+  const capitalized = capitalize20(featureName);
+  const entityName = `${capitalized}Entity`;
+  return `import { ${entityName} } from "../entities/${featureName}.entity";
+
+export interface Create${capitalized}Dto {
+    // TODO: define the fields required to create a ${featureName}
+}
+
+export interface Update${capitalized}Dto {
+    // TODO: define the fields that can be updated
+}
+
+export interface ${capitalized}ResponseDto {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    // TODO: define the fields exposed to API consumers
+}
+
+export const to${capitalized}ResponseDto = (entity: ${entityName}): ${capitalized}ResponseDto => ({
+    id: entity.id,
+    createdAt: entity.createdAt,
+    updatedAt: entity.updatedAt,
+});
+`;
+};
+var generateLayeredRepositoryTemplate = (featureName) => {
+  const capitalized = capitalize20(featureName);
+  const entityName = `${capitalized}Entity`;
+  const repoName = `${capitalized}Repository`;
+  return `import { ${entityName} } from "../entities/${featureName}.entity";
+
+export class ${repoName} {
+    private store: Map<string, ${entityName}> = new Map();
+
+    async findAll(): Promise<${entityName}[]> {
+        // TODO: Replace with your ORM query
+        return Array.from(this.store.values());
+    }
+
+    async findById(id: string): Promise<${entityName} | null> {
+        // TODO: Replace with your ORM query
+        return this.store.get(id) ?? null;
+    }
+
+    async create(entity: ${entityName}): Promise<${entityName}> {
+        // TODO: Replace with your ORM save
+        this.store.set(entity.id, entity);
+        return entity;
+    }
+
+    async update(entity: ${entityName}): Promise<${entityName} | null> {
+        // TODO: Replace with your ORM update
+        if (!this.store.has(entity.id)) return null;
+        this.store.set(entity.id, entity);
+        return entity;
+    }
+
+    async delete(id: string): Promise<boolean> {
+        // TODO: Replace with your ORM delete
+        return this.store.delete(id);
+    }
+}
+`;
+};
+var generateLayeredServiceTemplate = (featureName) => {
+  const capitalized = capitalize20(featureName);
+  const entityName = `${capitalized}Entity`;
+  const repoName = `${capitalized}Repository`;
+  const serviceName = `${capitalized}Service`;
+  return `import { ${repoName} } from "../repositories/${featureName}.repository";
+import { ${entityName} } from "../entities/${featureName}.entity";
+import { Create${capitalized}Dto, Update${capitalized}Dto, ${capitalized}ResponseDto, to${capitalized}ResponseDto } from "../dto/${featureName}.dto";
+
+export class ${serviceName} {
+    private readonly repository: ${repoName};
+
+    constructor() {
+        this.repository = new ${repoName}();
+    }
+
+    async findAll(): Promise<${capitalized}ResponseDto[]> {
+        const entities = await this.repository.findAll();
+        return entities.map(to${capitalized}ResponseDto);
+    }
+
+    async findById(id: string): Promise<${capitalized}ResponseDto | null> {
+        const entity = await this.repository.findById(id);
+        return entity ? to${capitalized}ResponseDto(entity) : null;
+    }
+
+    async create(data: Create${capitalized}Dto): Promise<${capitalized}ResponseDto> {
+        const entity = new ${entityName}(String(Date.now()));
+        // TODO: Map data fields onto entity
+        const created = await this.repository.create(entity);
+        return to${capitalized}ResponseDto(created);
+    }
+
+    async update(id: string, data: Update${capitalized}Dto): Promise<${capitalized}ResponseDto | null> {
+        const existing = await this.repository.findById(id);
+        if (!existing) {
+            return null;
+        }
+        // TODO: Apply data fields onto existing entity
+        const updated = await this.repository.update(existing);
+        return updated ? to${capitalized}ResponseDto(updated) : null;
+    }
+
+    async delete(id: string): Promise<boolean> {
+        return this.repository.delete(id);
+    }
+}
+`;
+};
+var generateLayeredControllerTemplate = (controllerName, featureName, methods) => {
+  const capitalized = capitalize20(featureName);
+  const serviceName = `${capitalized}Service`;
+  const methodsCode = methods.map((method) => generateMethod4(method, capitalized, serviceName)).join("\n");
+  return `import { Request, Response } from "opticore-express";
+import { ResponseHandler, HttpStatusCode, IResponseHandlerSuccessData } from "opticore-http-response";
+import { ${serviceName} } from "../services/${featureName}.service";
+
+export class ${controllerName} {
+    private static buildService(): ${serviceName} {
+        return new ${serviceName}();
+    }
+
+${methodsCode}
+    private static handleError(error: unknown) {
+        const message = error instanceof Error ? error.message : "Internal server error";
+        return ResponseHandler.error(message, HttpStatusCode.INTERNAL_SERVER_ERROR);
+    }
+}
+`;
+};
+var generateMethod4 = (method, capitalized, serviceName) => {
+  const lower = method.toLowerCase();
+  if (lower.includes("findall") || lower.includes("getall")) return generateFindAllMethod4(method, capitalized);
+  if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) return generateFindByIdMethod4(method, capitalized);
+  if (lower.includes("create") || lower.includes("add")) return generateCreateMethod4(method, capitalized);
+  if (lower.includes("update") || lower.includes("edit")) return generateUpdateMethod4(method, capitalized);
+  if (lower.includes("delete") || lower.includes("remove")) return generateDeleteMethod4(method, capitalized);
+  return `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const service = ${capitalized}Controller.buildService();
+            // TODO: Implement ${method} logic
+            return ResponseHandler.success({}, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+};
+var generateFindAllMethod4 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const service = ${capitalized}Controller.buildService();
+            const results = await service.findAll();
+            return ResponseHandler.success(results, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateFindByIdMethod4 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const service = ${capitalized}Controller.buildService();
+            const result = await service.findById(id);
+            if (!result) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(result, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateCreateMethod4 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const service = ${capitalized}Controller.buildService();
+            const result = await service.create(req.body);
+            return ResponseHandler.success(result, "created", HttpStatusCode.CREATED);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateUpdateMethod4 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const service = ${capitalized}Controller.buildService();
+            const result = await service.update(id, req.body);
+            if (!result) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(result, "success", HttpStatusCode.OK);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateDeleteMethod4 = (method, capitalized) => `
+    static async ${method}(req: Request, res: Response): Promise<IResponseHandlerSuccessData | ReturnType<typeof ResponseHandler.error>> {
+        try {
+            const { id } = req.params;
+            const service = ${capitalized}Controller.buildService();
+            const deleted = await service.delete(id);
+            if (!deleted) {
+                return ResponseHandler.error(\`Not found: \${id}\`, HttpStatusCode.NOT_FOUND);
+            }
+            return ResponseHandler.success(null, "deleted", HttpStatusCode.NO_CONTENT);
+        } catch (error) {
+            return ${capitalized}Controller.handleError(error);
+        }
+    }
+`;
+var generateLayeredRouterHandlerTemplate = (featureName, controllerMethods) => {
+  const capitalized = capitalize20(featureName);
+  const handlerName = `${capitalized}HandlerRouter`;
+  const controllerName = `${capitalized}Controller`;
+  const routesCode = (controllerMethods || []).map((method) => {
+    const { httpMethod, path: path10 } = resolveRoute4(method, featureName);
+    return `{
+    path: \`${path10}\`,
+    method: "${httpMethod}",
+    middlewares: [],
+    handler: async (ctx: ICustomContext) => await ${controllerName}.${method}(ctx.req, ctx.res)
+}`;
+  }).join(",\n");
+  return `import { OpticoreRoutingFactory, ICustomContext, IMultipleRouteDefinition } from "opticore-router";
+import { ${controllerName} } from "../controllers/${featureName}.controller";
+
+export const ${handlerName}: () => IMultipleRouteDefinition = () => {
+    return OpticoreRoutingFactory.routes(
+        ${controllerName},
+        [
+            ${routesCode.replace(/\n/g, "\n            ")}
+        ]
+    );
+};
+`;
+};
+var generateLayeredRouterTemplate = (featureName) => {
+  const capitalized = capitalize20(featureName);
+  const handlerName = `${capitalized}HandlerRouter`;
+  const routerName = `${capitalized}Router`;
+  return `import { ${handlerName} } from "./${featureName}.router.handler";
+import { TFeatureRoutes } from "opticore-router";
+
+export const ${routerName}: TFeatureRoutes = {
+    routes: [
+        {
+            path: ${handlerName}().path,
+            handler: ${handlerName}().handler
+        }
+    ]
+};
+`;
+};
+var resolveRoute4 = (methodName, featureName) => {
+  const lower = methodName.toLowerCase();
+  if (lower.includes("findall") || lower.includes("getall")) return { httpMethod: "get", path: `/${featureName}` };
+  if (lower.includes("findbyid") || lower.includes("getbyid") || lower.includes("getone")) return { httpMethod: "get", path: `/${featureName}/:id` };
+  if (lower.includes("create") || lower.includes("add")) return { httpMethod: "post", path: `/${featureName}` };
+  if (lower.includes("update") || lower.includes("edit")) return { httpMethod: "put", path: `/${featureName}/:id` };
+  if (lower.includes("delete") || lower.includes("remove")) return { httpMethod: "delete", path: `/${featureName}/:id` };
+  return { httpMethod: "get", path: `/${featureName}/${lower}` };
+};
+
+// src/templates/layeredModule/layeredModuleScaffold.template.ts
+var capitalize21 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+var layeredModuleTemplate = async (featureName) => {
+  FeatureComponentGeneratorUtils.setStructure("layered");
+  const basePath = import_path8.default.join("src", "features", featureName);
+  const paths = {
+    entitiesDir: import_path8.default.join(basePath, "entities"),
+    dtoDir: import_path8.default.join(basePath, "dto"),
+    repositoriesDir: import_path8.default.join(basePath, "repositories"),
+    servicesDir: import_path8.default.join(basePath, "services"),
+    controllersDir: import_path8.default.join(basePath, "controllers"),
+    routesDir: import_path8.default.join(basePath, "routes")
+  };
+  Object.values(paths).forEach((dir) => UFsModule.createDirectoryRecursively(dir));
+  const controllerName = `${capitalize21(featureName)}Controller`;
+  UFsModule.createFile(import_path8.default.join(paths.entitiesDir, `${featureName}.entity.ts`), generateLayeredEntityTemplate(featureName));
+  console.log(import_ansi_colors11.default.green(`\u2714 Entity created: ${import_path8.default.join(paths.entitiesDir, `${featureName}.entity.ts`)}`));
+  UFsModule.createFile(import_path8.default.join(paths.dtoDir, `${featureName}.dto.ts`), generateLayeredDtoTemplate(featureName));
+  console.log(import_ansi_colors11.default.green(`\u2714 DTO created: ${import_path8.default.join(paths.dtoDir, `${featureName}.dto.ts`)}`));
+  UFsModule.createFile(import_path8.default.join(paths.repositoriesDir, `${featureName}.repository.ts`), generateLayeredRepositoryTemplate(featureName));
+  console.log(import_ansi_colors11.default.green(`\u2714 Repository created: ${import_path8.default.join(paths.repositoriesDir, `${featureName}.repository.ts`)}`));
+  UFsModule.createFile(import_path8.default.join(paths.servicesDir, `${featureName}.service.ts`), generateLayeredServiceTemplate(featureName));
+  console.log(import_ansi_colors11.default.green(`\u2714 Service created: ${import_path8.default.join(paths.servicesDir, `${featureName}.service.ts`)}`));
+  const wantsMethods = await UPrompt.confirm("Do you want to add methods to the controller?");
+  let methods = [];
+  let controllerContent;
+  if (wantsMethods && !(0, import_prompts8.isCancel)(wantsMethods)) {
+    const methodsText = await UPrompt.text(
+      "Enter the method names (comma separated):",
+      "create, findAll, findById, update, delete",
+      (v) => v ? void 0 : "You must enter at least one method."
+    );
+    if (!(0, import_prompts8.isCancel)(methodsText)) {
+      methods = methodsText.split(",").map((m) => m.trim()).filter(Boolean);
+    }
+    controllerContent = generateLayeredControllerTemplate(controllerName, featureName, methods);
+  } else {
+    controllerContent = `import { Request, Response } from "opticore-express";
+
+export class ${controllerName} {}
+`;
+  }
+  const controllerPath = import_path8.default.join(paths.controllersDir, `${featureName}.controller.ts`);
+  UFsModule.createFile(controllerPath, controllerContent);
+  console.log(import_ansi_colors11.default.green(`\u2714 Controller created: ${controllerPath}`));
+  UFsModule.createFile(
+    import_path8.default.join(paths.routesDir, `${featureName}.router.handler.ts`),
+    generateLayeredRouterHandlerTemplate(featureName, methods)
+  );
+  console.log(import_ansi_colors11.default.green(`\u2714 Router Handler created: ${import_path8.default.join(paths.routesDir, `${featureName}.router.handler.ts`)}`));
+  UFsModule.createFile(
+    import_path8.default.join(paths.routesDir, `${featureName}.router.ts`),
+    generateLayeredRouterTemplate(featureName)
+  );
+  await FeatureComponentGeneratorUtils.registerModuleRouter(featureName);
+  console.log(import_ansi_colors11.default.green(`\u2714 Router created: ${import_path8.default.join(paths.routesDir, `${featureName}.router.ts`)}`));
+  console.log(
+    import_ansi_colors11.default.bgGreen(
+      import_ansi_colors11.default.white(`
+\u{1F389}  Feature "${featureName}" scaffolded with Layered architecture!
+`)
+    )
+  );
+};
+
+// src/core/core.ts
+async function runFeatureCommand() {
+  UWelcomeMessage();
+  const featureChoice = await choiceFeatureCleanModule();
+  if (featureChoice === "custom_feature") {
+    await buildYourOwnArchitectureScaffoldTemplate();
+    return;
+  }
+  if (featureChoice === "mvc_architecture" || featureChoice === "layered_architecture") {
+    const featureName2 = await _featureName();
+    const directory2 = import_path9.default.join(import_process2.default.cwd(), "src", "features");
+    const featureDirectory2 = import_path9.default.join(directory2, featureName2.toString());
+    if (BaseService._isSubdirectoryExists(featureName2)) {
+      BaseService._featureFounded(featureName2);
+    }
+    if ((0, import_prompts9.isCancel)(featureName2)) {
+      BaseService._cancelOperation(featureDirectory2);
+      return;
+    }
+    if (!import_node_fs2.default.existsSync(directory2)) {
+      BaseService._checkFeatureDir();
+      return;
+    }
+    if (featureChoice === "mvc_architecture") {
+      await mvcModuleTemplate(featureName2.toString());
+    } else {
+      await layeredModuleTemplate(featureName2.toString());
+    }
+    return;
+  }
+  if (!featureChoice || featureChoice !== "opticore_clean_module") {
+    import_process2.default.exit(0);
+  }
+  UCustomFeatureInfo(featureChoice);
+  const featureName = await _featureName();
+  const directory = import_path9.default.join(import_process2.default.cwd(), "src", "features");
+  const featureDirectory = import_path9.default.join(directory, featureName.toString());
+  const featureCleanModule = BaseService._isSubdirectoryExists(featureName);
+  if (featureCleanModule) {
+    BaseService._featureFounded(featureName);
+  }
+  if ((0, import_prompts9.isCancel)(featureName)) {
+    BaseService._cancelOperation(featureDirectory);
+  } else {
+    try {
+      if (import_node_fs2.default.existsSync(directory)) {
+        await createComponentApplication(featureDirectory, featureName);
+      } else {
+        BaseService._checkFeatureDir();
+      }
+    } catch (err) {
+      console.error(err.message);
+      import_process2.default.exit();
+    }
+  }
+}
+
+// src/cli/registerFeatureCommand.ts
+function handleFeatureCliError(err) {
+  const msg = err instanceof Error ? err.message : "An unexpected error occurred";
+  console.error("");
+  console.error(
+    import_chalk2.default.bgRed.white.bold("  ERROR  ") + import_chalk2.default.red(` ${msg}`)
+  );
+  console.error("");
+  process.exit(1);
+}
+function registerFeatureCommand(program) {
+  return program.command("feature").description(import_chalk2.default.dim("Interactively scaffold a new feature module (clean/MVC/layered/custom architecture)")).action(async () => {
+    try {
+      await runFeatureCommand();
+    } catch (e) {
+      handleFeatureCliError(e);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleFeatureCliError,
+  registerFeatureCommand
+});