servcraft 0.1.0 → 0.1.1

package/dist/cli/index.cjs

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli/index.ts
-var import_commander6 = require("commander");
+var import_commander5 = require("commander");
 
 // src/cli/commands/init.ts
 var import_commander = require("commander");
@@ -96,159 +96,183 @@ function getModulesDir() {
 }
 
 // src/cli/commands/init.ts
-var initCommand = new import_commander.Command("init").alias("new").description("Initialize a new Servcraft project").argument("[name]", "Project name").option("-y, --yes", "Skip prompts and use defaults").option("--ts, --typescript", "Use TypeScript (default)").option("--js, --javascript", "Use JavaScript").option("--db <database>", "Database type (postgresql, mysql, sqlite, mongodb, none)").action(async (name, cmdOptions) => {
-  console.log(import_chalk2.default.blue(`
+var initCommand = new import_commander.Command("init").alias("new").description("Initialize a new Servcraft project").argument("[name]", "Project name").option("-y, --yes", "Skip prompts and use defaults").option("--ts, --typescript", "Use TypeScript (default)").option("--js, --javascript", "Use JavaScript").option("--db <database>", "Database type (postgresql, mysql, sqlite, mongodb, none)").action(
+  async (name, cmdOptions) => {
+    console.log(
+      import_chalk2.default.blue(`
 \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
 \u2551                                           \u2551
 \u2551   ${import_chalk2.default.bold("\u{1F680} Servcraft Project Generator")}          \u2551
 \u2551                                           \u2551
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
-`));
-  let options;
-  if (cmdOptions?.yes) {
-    options = {
-      name: name || "my-servcraft-app",
-      language: cmdOptions.javascript ? "javascript" : "typescript",
-      database: cmdOptions.db || "postgresql",
-      validator: "zod",
-      features: ["auth", "users", "email"]
-    };
-  } else {
-    const answers = await import_inquirer.default.prompt([
-      {
-        type: "input",
-        name: "name",
-        message: "Project name:",
-        default: name || "my-servcraft-app",
-        validate: (input) => {
-          if (!/^[a-z0-9-_]+$/i.test(input)) {
-            return "Project name can only contain letters, numbers, hyphens, and underscores";
+`)
+    );
+    let options;
+    if (cmdOptions?.yes) {
+      const db = cmdOptions.db || "postgresql";
+      options = {
+        name: name || "my-servcraft-app",
+        language: cmdOptions.javascript ? "javascript" : "typescript",
+        database: db,
+        orm: db === "mongodb" ? "mongoose" : db === "none" ? "none" : "prisma",
+        validator: "zod",
+        features: ["auth", "users", "email"]
+      };
+    } else {
+      const answers = await import_inquirer.default.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "Project name:",
+          default: name || "my-servcraft-app",
+          validate: (input) => {
+            if (!/^[a-z0-9-_]+$/i.test(input)) {
+              return "Project name can only contain letters, numbers, hyphens, and underscores";
+            }
+            return true;
           }
-          return true;
+        },
+        {
+          type: "list",
+          name: "language",
+          message: "Select language:",
+          choices: [
+            { name: "TypeScript (Recommended)", value: "typescript" },
+            { name: "JavaScript", value: "javascript" }
+          ],
+          default: "typescript"
+        },
+        {
+          type: "list",
+          name: "database",
+          message: "Select database:",
+          choices: [
+            { name: "PostgreSQL (Recommended for SQL)", value: "postgresql" },
+            { name: "MySQL", value: "mysql" },
+            { name: "SQLite (Development)", value: "sqlite" },
+            { name: "MongoDB (NoSQL)", value: "mongodb" },
+            { name: "None (Add later)", value: "none" }
+          ],
+          default: "postgresql"
+        },
+        {
+          type: "list",
+          name: "validator",
+          message: "Select validation library:",
+          choices: [
+            { name: "Zod (Recommended - TypeScript-first)", value: "zod" },
+            { name: "Joi (Battle-tested, feature-rich)", value: "joi" },
+            { name: "Yup (Inspired by Joi, lighter)", value: "yup" }
+          ],
+          default: "zod"
+        },
+        {
+          type: "checkbox",
+          name: "features",
+          message: "Select features to include:",
+          choices: [
+            { name: "Authentication (JWT)", value: "auth", checked: true },
+            { name: "User Management", value: "users", checked: true },
+            { name: "Email Service", value: "email", checked: true },
+            { name: "Audit Logs", value: "audit", checked: false },
+            { name: "File Upload", value: "upload", checked: false },
+            { name: "Redis Cache", value: "redis", checked: false }
+          ]
         }
-      },
-      {
-        type: "list",
-        name: "language",
-        message: "Select language:",
-        choices: [
-          { name: "TypeScript (Recommended)", value: "typescript" },
-          { name: "JavaScript", value: "javascript" }
-        ],
-        default: "typescript"
-      },
-      {
-        type: "list",
-        name: "database",
-        message: "Select database:",
-        choices: [
-          { name: "PostgreSQL (Recommended)", value: "postgresql" },
-          { name: "MySQL", value: "mysql" },
-          { name: "SQLite (Development)", value: "sqlite" },
-          { name: "MongoDB", value: "mongodb" },
-          { name: "None (Add later)", value: "none" }
-        ],
-        default: "postgresql"
-      },
-      {
-        type: "list",
-        name: "validator",
-        message: "Select validation library:",
-        choices: [
-          { name: "Zod (Recommended - TypeScript-first)", value: "zod" },
-          { name: "Joi (Battle-tested, feature-rich)", value: "joi" },
-          { name: "Yup (Inspired by Joi, lighter)", value: "yup" }
-        ],
-        default: "zod"
-      },
-      {
-        type: "checkbox",
-        name: "features",
-        message: "Select features to include:",
-        choices: [
-          { name: "Authentication (JWT)", value: "auth", checked: true },
-          { name: "User Management", value: "users", checked: true },
-          { name: "Email Service", value: "email", checked: true },
-          { name: "Audit Logs", value: "audit", checked: false },
-          { name: "File Upload", value: "upload", checked: false },
-          { name: "Redis Cache", value: "redis", checked: false }
-        ]
-      }
-    ]);
-    options = answers;
-  }
-  const projectDir = import_path2.default.resolve(process.cwd(), options.name);
-  const spinner = (0, import_ora.default)("Creating project...").start();
-  try {
-    try {
-      await import_promises2.default.access(projectDir);
-      spinner.stop();
-      error(`Directory "${options.name}" already exists`);
-      return;
-    } catch {
-    }
-    await ensureDir(projectDir);
-    spinner.text = "Generating project files...";
-    const packageJson = generatePackageJson(options);
-    await writeFile(import_path2.default.join(projectDir, "package.json"), JSON.stringify(packageJson, null, 2));
-    if (options.language === "typescript") {
-      await writeFile(import_path2.default.join(projectDir, "tsconfig.json"), generateTsConfig());
-      await writeFile(import_path2.default.join(projectDir, "tsup.config.ts"), generateTsupConfig());
-    } else {
-      await writeFile(import_path2.default.join(projectDir, "jsconfig.json"), generateJsConfig());
-    }
-    await writeFile(import_path2.default.join(projectDir, ".env.example"), generateEnvExample(options));
-    await writeFile(import_path2.default.join(projectDir, ".env"), generateEnvExample(options));
-    await writeFile(import_path2.default.join(projectDir, ".gitignore"), generateGitignore());
-    await writeFile(import_path2.default.join(projectDir, "Dockerfile"), generateDockerfile(options));
-    await writeFile(import_path2.default.join(projectDir, "docker-compose.yml"), generateDockerCompose(options));
-    const ext = options.language === "typescript" ? "ts" : "js";
-    const dirs = [
-      "src/core",
-      "src/config",
-      "src/modules",
-      "src/middleware",
-      "src/utils",
-      "src/types",
-      "tests/unit",
-      "tests/integration"
-    ];
-    if (options.database !== "none" && options.database !== "mongodb") {
-      dirs.push("prisma");
-    }
-    for (const dir of dirs) {
-      await ensureDir(import_path2.default.join(projectDir, dir));
+      ]);
+      const db = answers.database;
+      options = {
+        ...answers,
+        orm: db === "mongodb" ? "mongoose" : db === "none" ? "none" : "prisma"
+      };
     }
-    await writeFile(
-      import_path2.default.join(projectDir, `src/index.${ext}`),
-      generateEntryFile(options)
-    );
-    await writeFile(
-      import_path2.default.join(projectDir, `src/core/server.${ext}`),
-      generateServerFile(options)
-    );
-    await writeFile(
-      import_path2.default.join(projectDir, `src/core/logger.${ext}`),
-      generateLoggerFile(options)
-    );
-    if (options.database !== "none" && options.database !== "mongodb") {
+    const projectDir = import_path2.default.resolve(process.cwd(), options.name);
+    const spinner = (0, import_ora.default)("Creating project...").start();
+    try {
+      try {
+        await import_promises2.default.access(projectDir);
+        spinner.stop();
+        error(`Directory "${options.name}" already exists`);
+        return;
+      } catch {
+      }
+      await ensureDir(projectDir);
+      spinner.text = "Generating project files...";
+      const packageJson = generatePackageJson(options);
       await writeFile(
-        import_path2.default.join(projectDir, "prisma/schema.prisma"),
-        generatePrismaSchema(options)
+        import_path2.default.join(projectDir, "package.json"),
+        JSON.stringify(packageJson, null, 2)
       );
-    }
-    spinner.succeed("Project files generated!");
-    const installSpinner = (0, import_ora.default)("Installing dependencies...").start();
-    try {
-      (0, import_child_process.execSync)("npm install", { cwd: projectDir, stdio: "pipe" });
-      installSpinner.succeed("Dependencies installed!");
-    } catch {
-      installSpinner.warn("Failed to install dependencies automatically");
-      warn('  Run "npm install" manually in the project directory');
-    }
-    console.log("\n" + import_chalk2.default.green("\u2728 Project created successfully!"));
-    console.log("\n" + import_chalk2.default.bold("\u{1F4C1} Project structure:"));
-    console.log(`
+      if (options.language === "typescript") {
+        await writeFile(import_path2.default.join(projectDir, "tsconfig.json"), generateTsConfig());
+        await writeFile(import_path2.default.join(projectDir, "tsup.config.ts"), generateTsupConfig());
+      } else {
+        await writeFile(import_path2.default.join(projectDir, "jsconfig.json"), generateJsConfig());
+      }
+      await writeFile(import_path2.default.join(projectDir, ".env.example"), generateEnvExample(options));
+      await writeFile(import_path2.default.join(projectDir, ".env"), generateEnvExample(options));
+      await writeFile(import_path2.default.join(projectDir, ".gitignore"), generateGitignore());
+      await writeFile(import_path2.default.join(projectDir, "Dockerfile"), generateDockerfile(options));
+      await writeFile(
+        import_path2.default.join(projectDir, "docker-compose.yml"),
+        generateDockerCompose(options)
+      );
+      const ext = options.language === "typescript" ? "ts" : "js";
+      const dirs = [
+        "src/core",
+        "src/config",
+        "src/modules",
+        "src/middleware",
+        "src/utils",
+        "src/types",
+        "tests/unit",
+        "tests/integration"
+      ];
+      if (options.orm === "prisma") {
+        dirs.push("prisma");
+      }
+      if (options.orm === "mongoose") {
+        dirs.push("src/database/models");
+      }
+      for (const dir of dirs) {
+        await ensureDir(import_path2.default.join(projectDir, dir));
+      }
+      await writeFile(import_path2.default.join(projectDir, `src/index.${ext}`), generateEntryFile(options));
+      await writeFile(
+        import_path2.default.join(projectDir, `src/core/server.${ext}`),
+        generateServerFile(options)
+      );
+      await writeFile(
+        import_path2.default.join(projectDir, `src/core/logger.${ext}`),
+        generateLoggerFile(options)
+      );
+      if (options.orm === "prisma") {
+        await writeFile(
+          import_path2.default.join(projectDir, "prisma/schema.prisma"),
+          generatePrismaSchema(options)
+        );
+      } else if (options.orm === "mongoose") {
+        await writeFile(
+          import_path2.default.join(projectDir, `src/database/connection.${ext}`),
+          generateMongooseConnection(options)
+        );
+        await writeFile(
+          import_path2.default.join(projectDir, `src/database/models/user.model.${ext}`),
+          generateMongooseUserModel(options)
+        );
+      }
+      spinner.succeed("Project files generated!");
+      const installSpinner = (0, import_ora.default)("Installing dependencies...").start();
+      try {
+        (0, import_child_process.execSync)("npm install", { cwd: projectDir, stdio: "pipe" });
+        installSpinner.succeed("Dependencies installed!");
+      } catch {
+        installSpinner.warn("Failed to install dependencies automatically");
+        warn('  Run "npm install" manually in the project directory');
+      }
+      console.log("\n" + import_chalk2.default.green("\u2728 Project created successfully!"));
+      console.log("\n" + import_chalk2.default.bold("\u{1F4C1} Project structure:"));
+      console.log(`
   ${options.name}/
   \u251C\u2500\u2500 src/
   \u2502   \u251C\u2500\u2500 core/           # Core server, logger
@@ -262,24 +286,25 @@ var initCommand = new import_commander.Command("init").alias("new").description(
   \u251C\u2500\u2500 docker-compose.yml
   \u2514\u2500\u2500 package.json
 `);
-    console.log(import_chalk2.default.bold("\u{1F680} Get started:"));
-    console.log(`
+      console.log(import_chalk2.default.bold("\u{1F680} Get started:"));
+      console.log(`
   ${import_chalk2.default.cyan(`cd ${options.name}`)}
   ${options.database !== "none" ? import_chalk2.default.cyan("npm run db:push        # Setup database") : ""}
   ${import_chalk2.default.cyan("npm run dev            # Start development server")}
 `);
-    console.log(import_chalk2.default.bold("\u{1F4DA} Available commands:"));
-    console.log(`
+      console.log(import_chalk2.default.bold("\u{1F4DA} Available commands:"));
+      console.log(`
   ${import_chalk2.default.yellow("servcraft generate module <name>")}    Generate a new module
   ${import_chalk2.default.yellow("servcraft generate controller <name>")} Generate a controller
   ${import_chalk2.default.yellow("servcraft generate service <name>")}    Generate a service
   ${import_chalk2.default.yellow("servcraft add auth")}                   Add authentication module
 `);
-  } catch (err) {
-    spinner.fail("Failed to create project");
-    error(err instanceof Error ? err.message : String(err));
+    } catch (err) {
+      spinner.fail("Failed to create project");
+      error(err instanceof Error ? err.message : String(err));
+    }
   }
-});
+);
 function generatePackageJson(options) {
   const isTS = options.language === "typescript";
   const pkg = {
@@ -329,7 +354,7 @@ function generatePackageJson(options) {
     pkg.devDependencies["@types/node"] = "^22.10.1";
     pkg.devDependencies["@types/bcryptjs"] = "^2.4.6";
   }
-  if (options.database !== "none" && options.database !== "mongodb") {
+  if (options.orm === "prisma") {
     pkg.dependencies["@prisma/client"] = "^5.22.0";
     pkg.devDependencies.prisma = "^5.22.0";
     pkg.scripts["db:generate"] = "prisma generate";
@@ -337,8 +362,11 @@ function generatePackageJson(options) {
     pkg.scripts["db:push"] = "prisma db push";
     pkg.scripts["db:studio"] = "prisma studio";
   }
-  if (options.database === "mongodb") {
+  if (options.orm === "mongoose") {
     pkg.dependencies.mongoose = "^8.8.4";
+    if (isTS) {
+      pkg.devDependencies["@types/mongoose"] = "^5.11.97";
+    }
   }
   if (options.features.includes("email")) {
     pkg.dependencies.nodemailer = "^6.9.15";
@@ -353,37 +381,45 @@ function generatePackageJson(options) {
   return pkg;
 }
 function generateTsConfig() {
-  return JSON.stringify({
-    compilerOptions: {
-      target: "ES2022",
-      module: "NodeNext",
-      moduleResolution: "NodeNext",
-      lib: ["ES2022"],
-      outDir: "./dist",
-      rootDir: "./src",
-      strict: true,
-      esModuleInterop: true,
-      skipLibCheck: true,
-      forceConsistentCasingInFileNames: true,
-      resolveJsonModule: true,
-      declaration: true,
-      sourceMap: true
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        lib: ["ES2022"],
+        outDir: "./dist",
+        rootDir: "./src",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        resolveJsonModule: true,
+        declaration: true,
+        sourceMap: true
+      },
+      include: ["src/**/*"],
+      exclude: ["node_modules", "dist"]
     },
-    include: ["src/**/*"],
-    exclude: ["node_modules", "dist"]
-  }, null, 2);
+    null,
+    2
+  );
 }
 function generateJsConfig() {
-  return JSON.stringify({
-    compilerOptions: {
-      module: "NodeNext",
-      moduleResolution: "NodeNext",
-      target: "ES2022",
-      checkJs: true
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        target: "ES2022",
+        checkJs: true
+      },
+      include: ["src/**/*"],
+      exclude: ["node_modules"]
     },
-    include: ["src/**/*"],
-    exclude: ["node_modules"]
-  }, null, 2);
+    null,
+    2
+  );
 }
 function generateTsupConfig() {
   return `import { defineConfig } from 'tsup';
@@ -399,7 +435,7 @@ export default defineConfig({
 `;
 }
 function generateEnvExample(options) {
-  let env2 = `# Server
+  let env = `# Server
 NODE_ENV=development
 PORT=3000
 HOST=0.0.0.0
@@ -417,31 +453,31 @@ RATE_LIMIT_MAX=100
 LOG_LEVEL=info
 `;
   if (options.database === "postgresql") {
-    env2 += `
+    env += `
 # Database (PostgreSQL)
 DATABASE_PROVIDER=postgresql
 DATABASE_URL="postgresql://user:password@localhost:5432/mydb?schema=public"
 `;
   } else if (options.database === "mysql") {
-    env2 += `
+    env += `
 # Database (MySQL)
 DATABASE_PROVIDER=mysql
 DATABASE_URL="mysql://user:password@localhost:3306/mydb"
 `;
   } else if (options.database === "sqlite") {
-    env2 += `
+    env += `
 # Database (SQLite)
 DATABASE_PROVIDER=sqlite
 DATABASE_URL="file:./dev.db"
 `;
   } else if (options.database === "mongodb") {
-    env2 += `
+    env += `
 # Database (MongoDB)
 MONGODB_URI="mongodb://localhost:27017/mydb"
 `;
   }
   if (options.features.includes("email")) {
-    env2 += `
+    env += `
 # Email
 SMTP_HOST=smtp.example.com
 SMTP_PORT=587
@@ -451,12 +487,12 @@ SMTP_FROM="App <noreply@example.com>"
 `;
   }
   if (options.features.includes("redis")) {
-    env2 += `
+    env += `
 # Redis
 REDIS_URL=redis://localhost:6379
 `;
   }
-  return env2;
+  return env;
 }
 function generateGitignore() {
   return `node_modules/
@@ -528,6 +564,23 @@ volumes:
 
 volumes:
   mysql-data:
+`;
+  } else if (options.database === "mongodb") {
+    compose += `      - MONGODB_URI=mongodb://mongodb:27017/mydb
+    depends_on:
+      - mongodb
+
+  mongodb:
+    image: mongo:7
+    environment:
+      MONGO_INITDB_DATABASE: mydb
+    ports:
+      - "27017:27017"
+    volumes:
+      - mongodb-data:/data/db
+
+volumes:
+  mongodb-data:
 `;
   }
   if (options.features.includes("redis")) {
@@ -639,11 +692,112 @@ ${isTS ? "export const logger: Logger" : "const logger"} = pino({
 ${isTS ? "" : "module.exports = { logger };"}
 `;
 }
+function generateMongooseConnection(options) {
+  const isTS = options.language === "typescript";
+  return `${isTS ? "import mongoose from 'mongoose';\nimport { logger } from '../core/logger.js';" : "const mongoose = require('mongoose');\nconst { logger } = require('../core/logger.js');"}
+
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/mydb';
+
+${isTS ? "export async function connectDatabase(): Promise<typeof mongoose>" : "async function connectDatabase()"} {
+  try {
+    const conn = await mongoose.connect(MONGODB_URI);
+    logger.info(\`MongoDB connected: \${conn.connection.host}\`);
+    return conn;
+  } catch (error) {
+    logger.error({ err: error }, 'MongoDB connection failed');
+    process.exit(1);
+  }
+}
+
+${isTS ? "export async function disconnectDatabase(): Promise<void>" : "async function disconnectDatabase()"} {
+  try {
+    await mongoose.disconnect();
+    logger.info('MongoDB disconnected');
+  } catch (error) {
+    logger.error({ err: error }, 'MongoDB disconnect failed');
+  }
+}
+
+${isTS ? "export { mongoose };" : "module.exports = { connectDatabase, disconnectDatabase, mongoose };"}
+`;
+}
+function generateMongooseUserModel(options) {
+  const isTS = options.language === "typescript";
+  return `${isTS ? "import mongoose, { Schema, Document } from 'mongoose';\nimport bcrypt from 'bcryptjs';" : "const mongoose = require('mongoose');\nconst bcrypt = require('bcryptjs');\nconst { Schema } = mongoose;"}
+
+${isTS ? `export interface IUser extends Document {
+  email: string;
+  password: string;
+  name?: string;
+  role: 'user' | 'admin';
+  status: 'active' | 'inactive' | 'suspended';
+  emailVerified: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+  comparePassword(candidatePassword: string): Promise<boolean>;
+}` : ""}
+
+const userSchema = new Schema${isTS ? "<IUser>" : ""}({
+  email: {
+    type: String,
+    required: true,
+    unique: true,
+    lowercase: true,
+    trim: true,
+  },
+  password: {
+    type: String,
+    required: true,
+    minlength: 8,
+  },
+  name: {
+    type: String,
+    trim: true,
+  },
+  role: {
+    type: String,
+    enum: ['user', 'admin'],
+    default: 'user',
+  },
+  status: {
+    type: String,
+    enum: ['active', 'inactive', 'suspended'],
+    default: 'active',
+  },
+  emailVerified: {
+    type: Boolean,
+    default: false,
+  },
+}, {
+  timestamps: true,
+});
+
+// Hash password before saving
+userSchema.pre('save', async function(next) {
+  if (!this.isModified('password')) return next();
+
+  try {
+    const salt = await bcrypt.genSalt(10);
+    this.password = await bcrypt.hash(this.password, salt);
+    next();
+  } catch (error${isTS ? ": any" : ""}) {
+    next(error);
+  }
+});
+
+// Compare password method
+userSchema.methods.comparePassword = async function(candidatePassword${isTS ? ": string" : ""})${isTS ? ": Promise<boolean>" : ""} {
+  return bcrypt.compare(candidatePassword, this.password);
+};
+
+${isTS ? "export const User = mongoose.model<IUser>('User', userSchema);" : "const User = mongoose.model('User', userSchema);\nmodule.exports = { User };"}
+`;
+}
 
 // src/cli/commands/generate.ts
 var import_commander2 = require("commander");
-var import_path4 = __toESM(require("path"), 1);
-var import_ora3 = __toESM(require("ora"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_ora2 = __toESM(require("ora"), 1);
 var import_inquirer2 = __toESM(require("inquirer"), 1);
 
 // src/cli/utils/field-parser.ts
@@ -1081,23 +1235,11 @@ export type ${pascalName}QueryInput = z.infer<typeof ${camelName}QuerySchema>;
 }
 
 // src/cli/templates/routes.ts
-function routesTemplate(name, pascalName, camelName, pluralName, fields = []) {
-  const serializedFields = JSON.stringify(fields, null, 2);
+function routesTemplate(name, pascalName, camelName, pluralName) {
   return `import type { FastifyInstance } from 'fastify';
 import type { ${pascalName}Controller } from './${name}.controller.js';
 import type { AuthService } from '../auth/auth.service.js';
 import { createAuthMiddleware, createRoleMiddleware } from '../auth/auth.middleware.js';
-import { generateRouteSchema } from '../swagger/schema-builder.js';
-import type { FieldDefinition } from '../cli/utils/field-parser.js';
-
-const ${camelName}Fields: FieldDefinition[] = ${serializedFields};
-const ${camelName}Schemas = {
-  list: generateRouteSchema('${pascalName}', ${camelName}Fields, 'list'),
-  get: generateRouteSchema('${pascalName}', ${camelName}Fields, 'get'),
-  create: generateRouteSchema('${pascalName}', ${camelName}Fields, 'create'),
-  update: generateRouteSchema('${pascalName}', ${camelName}Fields, 'update'),
-  delete: generateRouteSchema('${pascalName}', ${camelName}Fields, 'delete'),
-};
 
 export function register${pascalName}Routes(
   app: FastifyInstance,
@@ -1113,31 +1255,31 @@ export function register${pascalName}Routes(
   // Protected routes
   app.get(
     '/${pluralName}',
-    { preHandler: [authenticate], ...${camelName}Schemas.list },
+    { preHandler: [authenticate] },
     controller.list.bind(controller)
   );
 
   app.get(
     '/${pluralName}/:id',
-    { preHandler: [authenticate], ...${camelName}Schemas.get },
+    { preHandler: [authenticate] },
     controller.getById.bind(controller)
   );
 
   app.post(
     '/${pluralName}',
-    { preHandler: [authenticate], ...${camelName}Schemas.create },
+    { preHandler: [authenticate] },
     controller.create.bind(controller)
   );
 
   app.patch(
     '/${pluralName}/:id',
-    { preHandler: [authenticate], ...${camelName}Schemas.update },
+    { preHandler: [authenticate] },
     controller.update.bind(controller)
   );
 
   app.delete(
     '/${pluralName}/:id',
-    { preHandler: [authenticate, isAdmin], ...${camelName}Schemas.delete },
+    { preHandler: [authenticate, isAdmin] },
     controller.delete.bind(controller)
   );
 }
@@ -1488,1735 +1630,74 @@ ${indexLines.join("\n")}
 `;
 }
 
-// src/cli/utils/docs-generator.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_path3 = __toESM(require("path"), 1);
-var import_ora2 = __toESM(require("ora"), 1);
-
-// src/core/server.ts
-var import_fastify = __toESM(require("fastify"), 1);
-
-// src/core/logger.ts
-var import_pino = __toESM(require("pino"), 1);
-var defaultConfig = {
-  level: process.env.LOG_LEVEL || "info",
-  pretty: process.env.NODE_ENV !== "production",
-  name: "servcraft"
-};
-function createLogger(config2 = {}) {
-  const mergedConfig = { ...defaultConfig, ...config2 };
-  const transport = mergedConfig.pretty ? {
-    target: "pino-pretty",
-    options: {
-      colorize: true,
-      translateTime: "SYS:standard",
-      ignore: "pid,hostname"
-    }
-  } : void 0;
-  return (0, import_pino.default)({
-    name: mergedConfig.name,
-    level: mergedConfig.level,
-    transport,
-    formatters: {
-      level: (label) => ({ level: label })
-    },
-    timestamp: import_pino.default.stdTimeFunctions.isoTime
-  });
-}
-var logger = createLogger();
-
-// src/core/server.ts
-var defaultConfig2 = {
-  port: parseInt(process.env.PORT || "3000", 10),
-  host: process.env.HOST || "0.0.0.0",
-  trustProxy: true,
-  bodyLimit: 1048576,
-  // 1MB
-  requestTimeout: 3e4
-  // 30s
-};
-var Server = class {
-  app;
-  config;
-  logger;
-  isShuttingDown = false;
-  constructor(config2 = {}) {
-    this.config = { ...defaultConfig2, ...config2 };
-    this.logger = this.config.logger || logger;
-    const fastifyOptions = {
-      logger: this.logger,
-      trustProxy: this.config.trustProxy,
-      bodyLimit: this.config.bodyLimit,
-      requestTimeout: this.config.requestTimeout
-    };
-    this.app = (0, import_fastify.default)(fastifyOptions);
-    this.setupHealthCheck();
-    this.setupGracefulShutdown();
-  }
-  get instance() {
-    return this.app;
-  }
-  setupHealthCheck() {
-    this.app.get("/health", async (_request, reply) => {
-      const healthcheck = {
-        status: "ok",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        uptime: process.uptime(),
-        memory: process.memoryUsage(),
-        version: process.env.npm_package_version || "0.1.0"
-      };
-      return reply.status(200).send(healthcheck);
-    });
-    this.app.get("/ready", async (_request, reply) => {
-      if (this.isShuttingDown) {
-        return reply.status(503).send({ status: "shutting_down" });
-      }
-      return reply.status(200).send({ status: "ready" });
-    });
-  }
-  setupGracefulShutdown() {
-    const signals = ["SIGINT", "SIGTERM", "SIGQUIT"];
-    signals.forEach((signal) => {
-      process.on(signal, async () => {
-        this.logger.info(`Received ${signal}, starting graceful shutdown...`);
-        await this.shutdown();
-      });
-    });
-    process.on("uncaughtException", async (error2) => {
-      this.logger.error({ err: error2 }, "Uncaught exception");
-      await this.shutdown(1);
-    });
-    process.on("unhandledRejection", async (reason) => {
-      this.logger.error({ err: reason }, "Unhandled rejection");
-      await this.shutdown(1);
-    });
+// src/cli/commands/generate.ts
+var generateCommand = new import_commander2.Command("generate").alias("g").description("Generate resources (module, controller, service, etc.)");
+generateCommand.command("module <name> [fields...]").alias("m").description(
+  "Generate a complete module with controller, service, repository, types, schemas, and routes"
+).option("--no-routes", "Skip routes generation").option("--no-repository", "Skip repository generation").option("--prisma", "Generate Prisma model suggestion").option("--validator <type>", "Validator type: zod, joi, yup", "zod").option("-i, --interactive", "Interactive mode to define fields").action(async (name, fieldsArgs, options) => {
+  let fields = [];
+  if (options.interactive) {
+    fields = await promptForFields();
+  } else if (fieldsArgs.length > 0) {
+    fields = parseFields(fieldsArgs.join(" "));
   }
-  async shutdown(exitCode = 0) {
-    if (this.isShuttingDown) {
+  const spinner = (0, import_ora2.default)("Generating module...").start();
+  try {
+    const kebabName = toKebabCase(name);
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const pluralName = pluralize(kebabName);
+    const tableName = pluralize(kebabName.replace(/-/g, "_"));
+    const validatorType = options.validator || "zod";
+    const moduleDir = import_path3.default.join(getModulesDir(), kebabName);
+    if (await fileExists(moduleDir)) {
+      spinner.stop();
+      error(`Module "${kebabName}" already exists`);
       return;
     }
-    this.isShuttingDown = true;
-    this.logger.info("Graceful shutdown initiated...");
-    const shutdownTimeout = setTimeout(() => {
-      this.logger.error("Graceful shutdown timeout, forcing exit");
-      process.exit(1);
-    }, 3e4);
-    try {
-      await this.app.close();
-      this.logger.info("Server closed successfully");
-      clearTimeout(shutdownTimeout);
-      process.exit(exitCode);
-    } catch (error2) {
-      this.logger.error({ err: error2 }, "Error during shutdown");
-      clearTimeout(shutdownTimeout);
-      process.exit(1);
+    const hasFields = fields.length > 0;
+    const files = [
+      {
+        name: `${kebabName}.types.ts`,
+        content: hasFields ? dynamicTypesTemplate(kebabName, pascalName, fields) : typesTemplate(kebabName, pascalName)
+      },
+      {
+        name: `${kebabName}.schemas.ts`,
+        content: hasFields ? dynamicSchemasTemplate(kebabName, pascalName, camelName, fields, validatorType) : schemasTemplate(kebabName, pascalName, camelName)
+      },
+      {
+        name: `${kebabName}.service.ts`,
+        content: serviceTemplate(kebabName, pascalName, camelName)
+      },
+      {
+        name: `${kebabName}.controller.ts`,
+        content: controllerTemplate(kebabName, pascalName, camelName)
+      },
+      { name: "index.ts", content: moduleIndexTemplate(kebabName, pascalName, camelName) }
+    ];
+    if (options.repository !== false) {
+      files.push({
+        name: `${kebabName}.repository.ts`,
+        content: repositoryTemplate(kebabName, pascalName, camelName, pluralName)
+      });
     }
-  }
-  async start() {
-    try {
-      await this.app.listen({
-        port: this.config.port,
-        host: this.config.host
+    if (options.routes !== false) {
+      files.push({
+        name: `${kebabName}.routes.ts`,
+        content: routesTemplate(kebabName, pascalName, camelName, pluralName)
       });
-      this.logger.info(`Server listening on ${this.config.host}:${this.config.port}`);
-    } catch (error2) {
-      this.logger.error({ err: error2 }, "Failed to start server");
-      throw error2;
     }
-  }
-};
-function createServer(config2 = {}) {
-  return new Server(config2);
-}
-
-// src/utils/errors.ts
-var AppError = class _AppError extends Error {
-  statusCode;
-  isOperational;
-  errors;
-  constructor(message, statusCode = 500, isOperational = true, errors) {
-    super(message);
-    this.statusCode = statusCode;
-    this.isOperational = isOperational;
-    this.errors = errors;
-    Object.setPrototypeOf(this, _AppError.prototype);
-    Error.captureStackTrace(this, this.constructor);
-  }
-};
-var NotFoundError = class extends AppError {
-  constructor(resource = "Resource") {
-    super(`${resource} not found`, 404);
-  }
-};
-var UnauthorizedError = class extends AppError {
-  constructor(message = "Unauthorized") {
-    super(message, 401);
-  }
-};
-var ForbiddenError = class extends AppError {
-  constructor(message = "Forbidden") {
-    super(message, 403);
-  }
-};
-var BadRequestError = class extends AppError {
-  constructor(message = "Bad request", errors) {
-    super(message, 400, true, errors);
-  }
-};
-var ConflictError = class extends AppError {
-  constructor(message = "Resource already exists") {
-    super(message, 409);
-  }
-};
-var ValidationError = class extends AppError {
-  constructor(errors) {
-    super("Validation failed", 422, true, errors);
-  }
-};
-function isAppError(error2) {
-  return error2 instanceof AppError;
-}
-
-// src/config/env.ts
-var import_zod = require("zod");
-var import_dotenv = __toESM(require("dotenv"), 1);
-import_dotenv.default.config();
-var envSchema = import_zod.z.object({
-  // Server
-  NODE_ENV: import_zod.z.enum(["development", "staging", "production", "test"]).default("development"),
-  PORT: import_zod.z.string().transform(Number).default("3000"),
-  HOST: import_zod.z.string().default("0.0.0.0"),
-  // Database
-  DATABASE_URL: import_zod.z.string().optional(),
-  // JWT
-  JWT_SECRET: import_zod.z.string().min(32).optional(),
-  JWT_ACCESS_EXPIRES_IN: import_zod.z.string().default("15m"),
-  JWT_REFRESH_EXPIRES_IN: import_zod.z.string().default("7d"),
-  // Security
-  CORS_ORIGIN: import_zod.z.string().default("*"),
-  RATE_LIMIT_MAX: import_zod.z.string().transform(Number).default("100"),
-  RATE_LIMIT_WINDOW_MS: import_zod.z.string().transform(Number).default("60000"),
-  // Email
-  SMTP_HOST: import_zod.z.string().optional(),
-  SMTP_PORT: import_zod.z.string().transform(Number).optional(),
-  SMTP_USER: import_zod.z.string().optional(),
-  SMTP_PASS: import_zod.z.string().optional(),
-  SMTP_FROM: import_zod.z.string().optional(),
-  // Redis (optional)
-  REDIS_URL: import_zod.z.string().optional(),
-  // Swagger/OpenAPI
-  SWAGGER_ENABLED: import_zod.z.union([import_zod.z.literal("true"), import_zod.z.literal("false")]).default("true").transform((val) => val === "true"),
-  SWAGGER_ROUTE: import_zod.z.string().default("/docs"),
-  SWAGGER_TITLE: import_zod.z.string().default("Servcraft API"),
-  SWAGGER_DESCRIPTION: import_zod.z.string().default("API documentation"),
-  SWAGGER_VERSION: import_zod.z.string().default("1.0.0"),
-  // Logging
-  LOG_LEVEL: import_zod.z.enum(["fatal", "error", "warn", "info", "debug", "trace"]).default("info")
-});
-function validateEnv() {
-  const parsed = envSchema.safeParse(process.env);
-  if (!parsed.success) {
-    logger.error({ errors: parsed.error.flatten().fieldErrors }, "Invalid environment variables");
-    throw new Error("Invalid environment variables");
-  }
-  return parsed.data;
-}
-var env = validateEnv();
-function isProduction() {
-  return env.NODE_ENV === "production";
-}
-
-// src/config/index.ts
-function parseCorsOrigin(origin) {
-  if (origin === "*") return "*";
-  if (origin.includes(",")) {
-    return origin.split(",").map((o) => o.trim());
-  }
-  return origin;
-}
-function createConfig() {
-  return {
-    env,
-    server: {
-      port: env.PORT,
-      host: env.HOST
-    },
-    jwt: {
-      secret: env.JWT_SECRET || "change-me-in-production-please-32chars",
-      accessExpiresIn: env.JWT_ACCESS_EXPIRES_IN,
-      refreshExpiresIn: env.JWT_REFRESH_EXPIRES_IN
-    },
-    security: {
-      corsOrigin: parseCorsOrigin(env.CORS_ORIGIN),
-      rateLimit: {
-        max: env.RATE_LIMIT_MAX,
-        windowMs: env.RATE_LIMIT_WINDOW_MS
-      }
-    },
-    email: {
-      host: env.SMTP_HOST,
-      port: env.SMTP_PORT,
-      user: env.SMTP_USER,
-      pass: env.SMTP_PASS,
-      from: env.SMTP_FROM
-    },
-    database: {
-      url: env.DATABASE_URL
-    },
-    redis: {
-      url: env.REDIS_URL
-    },
-    swagger: {
-      enabled: env.SWAGGER_ENABLED,
-      route: env.SWAGGER_ROUTE,
-      title: env.SWAGGER_TITLE,
-      description: env.SWAGGER_DESCRIPTION,
-      version: env.SWAGGER_VERSION
+    for (const file of files) {
+      await writeFile(import_path3.default.join(moduleDir, file.name), file.content);
     }
-  };
-}
-var config = createConfig();
-
-// src/middleware/error-handler.ts
-function registerErrorHandler(app) {
-  app.setErrorHandler(
-    (error2, request, reply) => {
-      logger.error(
-        {
-          err: error2,
-          requestId: request.id,
-          method: request.method,
-          url: request.url
-        },
-        "Request error"
-      );
-      if (isAppError(error2)) {
-        return reply.status(error2.statusCode).send({
-          success: false,
-          message: error2.message,
-          errors: error2.errors,
-          ...isProduction() ? {} : { stack: error2.stack }
-        });
-      }
-      if ("validation" in error2 && error2.validation) {
-        const errors = {};
-        for (const err of error2.validation) {
-          const field = err.instancePath?.replace("/", "") || "body";
-          if (!errors[field]) {
-            errors[field] = [];
-          }
-          errors[field].push(err.message || "Invalid value");
-        }
-        return reply.status(400).send({
-          success: false,
-          message: "Validation failed",
-          errors
-        });
-      }
-      if ("statusCode" in error2 && typeof error2.statusCode === "number") {
-        return reply.status(error2.statusCode).send({
-          success: false,
-          message: error2.message,
-          ...isProduction() ? {} : { stack: error2.stack }
-        });
-      }
-      return reply.status(500).send({
-        success: false,
-        message: isProduction() ? "Internal server error" : error2.message,
-        ...isProduction() ? {} : { stack: error2.stack }
-      });
-    }
-  );
-  app.setNotFoundHandler((request, reply) => {
-    return reply.status(404).send({
-      success: false,
-      message: `Route ${request.method} ${request.url} not found`
-    });
-  });
-}
-
-// src/middleware/security.ts
-var import_helmet = __toESM(require("@fastify/helmet"), 1);
-var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_rate_limit = __toESM(require("@fastify/rate-limit"), 1);
-var defaultOptions = {
-  helmet: true,
-  cors: true,
-  rateLimit: true
-};
-async function registerSecurity(app, options = {}) {
-  const opts = { ...defaultOptions, ...options };
-  if (opts.helmet) {
-    await app.register(import_helmet.default, {
-      contentSecurityPolicy: {
-        directives: {
-          defaultSrc: ["'self'"],
-          styleSrc: ["'self'", "'unsafe-inline'"],
-          scriptSrc: ["'self'"],
-          imgSrc: ["'self'", "data:", "https:"]
-        }
-      },
-      crossOriginEmbedderPolicy: false
-    });
-    logger.debug("Helmet security headers enabled");
-  }
-  if (opts.cors) {
-    await app.register(import_cors.default, {
-      origin: config.security.corsOrigin,
-      credentials: true,
-      methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
-      allowedHeaders: ["Content-Type", "Authorization", "X-Requested-With"],
-      exposedHeaders: ["X-Total-Count", "X-Page", "X-Limit"],
-      maxAge: 86400
-      // 24 hours
-    });
-    logger.debug({ origin: config.security.corsOrigin }, "CORS enabled");
-  }
-  if (opts.rateLimit) {
-    await app.register(import_rate_limit.default, {
-      max: config.security.rateLimit.max,
-      timeWindow: config.security.rateLimit.windowMs,
-      errorResponseBuilder: (_request, context) => ({
-        success: false,
-        message: "Too many requests, please try again later",
-        retryAfter: context.after
-      }),
-      keyGenerator: (request) => {
-        return request.headers["x-forwarded-for"]?.toString().split(",")[0] || request.ip || "unknown";
-      }
-    });
-    logger.debug(
-      {
-        max: config.security.rateLimit.max,
-        windowMs: config.security.rateLimit.windowMs
-      },
-      "Rate limiting enabled"
-    );
-  }
-}
-
-// src/modules/swagger/swagger.service.ts
-var import_swagger = __toESM(require("@fastify/swagger"), 1);
-var import_swagger_ui = __toESM(require("@fastify/swagger-ui"), 1);
-var defaultConfig3 = {
-  enabled: true,
-  route: "/docs",
-  title: "Servcraft API",
-  description: "API documentation generated by Servcraft",
-  version: "1.0.0",
-  tags: [
-    { name: "Auth", description: "Authentication endpoints" },
-    { name: "Users", description: "User management endpoints" },
-    { name: "Health", description: "Health check endpoints" }
-  ]
-};
-async function registerSwagger(app, customConfig) {
-  const swaggerConfig = { ...defaultConfig3, ...customConfig };
-  if (swaggerConfig.enabled === false) {
-    logger.info("Swagger documentation disabled");
-    return;
-  }
-  await app.register(import_swagger.default, {
-    openapi: {
-      openapi: "3.0.3",
-      info: {
-        title: swaggerConfig.title,
-        description: swaggerConfig.description,
-        version: swaggerConfig.version,
-        contact: swaggerConfig.contact,
-        license: swaggerConfig.license
-      },
-      servers: swaggerConfig.servers || [
-        {
-          url: `http://localhost:${config.server.port}`,
-          description: "Development server"
-        }
-      ],
-      tags: swaggerConfig.tags,
-      components: {
-        securitySchemes: {
-          bearerAuth: {
-            type: "http",
-            scheme: "bearer",
-            bearerFormat: "JWT",
-            description: "Enter your JWT token"
-          }
-        }
-      }
-    }
-  });
-  await app.register(import_swagger_ui.default, {
-    routePrefix: swaggerConfig.route || "/docs",
-    uiConfig: {
-      docExpansion: "list",
-      deepLinking: true,
-      displayRequestDuration: true,
-      filter: true,
-      showExtensions: true,
-      showCommonExtensions: true
-    },
-    staticCSP: true,
-    transformStaticCSP: (header) => header
-  });
-  logger.info("Swagger documentation registered at /docs");
-}
-var commonResponses = {
-  success: {
-    type: "object",
-    properties: {
-      success: { type: "boolean", example: true },
-      data: { type: "object" }
-    }
-  },
-  error: {
-    type: "object",
-    properties: {
-      success: { type: "boolean", example: false },
-      message: { type: "string" },
-      errors: {
-        type: "object",
-        additionalProperties: {
-          type: "array",
-          items: { type: "string" }
-        }
-      }
-    }
-  },
-  unauthorized: {
-    type: "object",
-    properties: {
-      success: { type: "boolean", example: false },
-      message: { type: "string", example: "Unauthorized" }
-    }
-  },
-  notFound: {
-    type: "object",
-    properties: {
-      success: { type: "boolean", example: false },
-      message: { type: "string", example: "Resource not found" }
-    }
-  },
-  paginated: {
-    type: "object",
-    properties: {
-      success: { type: "boolean", example: true },
-      data: {
-        type: "object",
-        properties: {
-          data: { type: "array", items: { type: "object" } },
-          meta: {
-            type: "object",
-            properties: {
-              total: { type: "number" },
-              page: { type: "number" },
-              limit: { type: "number" },
-              totalPages: { type: "number" },
-              hasNextPage: { type: "boolean" },
-              hasPrevPage: { type: "boolean" }
-            }
-          }
-        }
-      }
-    }
-  }
-};
-var paginationQuery = {
-  type: "object",
-  properties: {
-    page: { type: "integer", minimum: 1, default: 1, description: "Page number" },
-    limit: { type: "integer", minimum: 1, maximum: 100, default: 20, description: "Items per page" },
-    sortBy: { type: "string", description: "Field to sort by" },
-    sortOrder: { type: "string", enum: ["asc", "desc"], default: "asc", description: "Sort order" },
-    search: { type: "string", description: "Search query" }
-  }
-};
-var idParam = {
-  type: "object",
-  properties: {
-    id: { type: "string", format: "uuid", description: "Resource ID" }
-  },
-  required: ["id"]
-};
-
-// src/modules/auth/index.ts
-var import_jwt = __toESM(require("@fastify/jwt"), 1);
-var import_cookie = __toESM(require("@fastify/cookie"), 1);
-
-// src/modules/auth/auth.service.ts
-var import_bcryptjs = __toESM(require("bcryptjs"), 1);
-var tokenBlacklist = /* @__PURE__ */ new Set();
-var AuthService = class {
-  app;
-  SALT_ROUNDS = 12;
-  constructor(app) {
-    this.app = app;
-  }
-  async hashPassword(password) {
-    return import_bcryptjs.default.hash(password, this.SALT_ROUNDS);
-  }
-  async verifyPassword(password, hash) {
-    return import_bcryptjs.default.compare(password, hash);
-  }
-  generateTokenPair(user) {
-    const accessPayload = {
-      sub: user.id,
-      email: user.email,
-      role: user.role,
-      type: "access"
-    };
-    const refreshPayload = {
-      sub: user.id,
-      email: user.email,
-      role: user.role,
-      type: "refresh"
-    };
-    const accessToken = this.app.jwt.sign(accessPayload, {
-      expiresIn: config.jwt.accessExpiresIn
-    });
-    const refreshToken = this.app.jwt.sign(refreshPayload, {
-      expiresIn: config.jwt.refreshExpiresIn
-    });
-    const expiresIn = this.parseExpiration(config.jwt.accessExpiresIn);
-    return { accessToken, refreshToken, expiresIn };
-  }
-  parseExpiration(expiration) {
-    const match = expiration.match(/^(\d+)([smhd])$/);
-    if (!match) return 900;
-    const value = parseInt(match[1] || "0", 10);
-    const unit = match[2];
-    switch (unit) {
-      case "s":
-        return value;
-      case "m":
-        return value * 60;
-      case "h":
-        return value * 3600;
-      case "d":
-        return value * 86400;
-      default:
-        return 900;
-    }
-  }
-  async verifyAccessToken(token) {
-    try {
-      if (this.isTokenBlacklisted(token)) {
-        throw new UnauthorizedError("Token has been revoked");
-      }
-      const payload = this.app.jwt.verify(token);
-      if (payload.type !== "access") {
-        throw new UnauthorizedError("Invalid token type");
-      }
-      return payload;
-    } catch (error2) {
-      if (error2 instanceof UnauthorizedError) throw error2;
-      logger.debug({ err: error2 }, "Token verification failed");
-      throw new UnauthorizedError("Invalid or expired token");
-    }
-  }
-  async verifyRefreshToken(token) {
-    try {
-      if (this.isTokenBlacklisted(token)) {
-        throw new UnauthorizedError("Token has been revoked");
-      }
-      const payload = this.app.jwt.verify(token);
-      if (payload.type !== "refresh") {
-        throw new UnauthorizedError("Invalid token type");
-      }
-      return payload;
-    } catch (error2) {
-      if (error2 instanceof UnauthorizedError) throw error2;
-      logger.debug({ err: error2 }, "Refresh token verification failed");
-      throw new UnauthorizedError("Invalid or expired refresh token");
-    }
-  }
-  blacklistToken(token) {
-    tokenBlacklist.add(token);
-    logger.debug("Token blacklisted");
-  }
-  isTokenBlacklisted(token) {
-    return tokenBlacklist.has(token);
-  }
-  // Clear expired tokens from blacklist periodically
-  cleanupBlacklist() {
-    tokenBlacklist.clear();
-    logger.debug("Token blacklist cleared");
-  }
-};
-function createAuthService(app) {
-  return new AuthService(app);
-}
-
-// src/modules/auth/schemas.ts
-var import_zod2 = require("zod");
-var loginSchema = import_zod2.z.object({
-  email: import_zod2.z.string().email("Invalid email address"),
-  password: import_zod2.z.string().min(1, "Password is required")
-});
-var registerSchema = import_zod2.z.object({
-  email: import_zod2.z.string().email("Invalid email address"),
-  password: import_zod2.z.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number"),
-  name: import_zod2.z.string().min(2, "Name must be at least 2 characters").optional()
-});
-var refreshTokenSchema = import_zod2.z.object({
-  refreshToken: import_zod2.z.string().min(1, "Refresh token is required")
-});
-var passwordResetRequestSchema = import_zod2.z.object({
-  email: import_zod2.z.string().email("Invalid email address")
-});
-var passwordResetConfirmSchema = import_zod2.z.object({
-  token: import_zod2.z.string().min(1, "Token is required"),
-  password: import_zod2.z.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number")
-});
-var changePasswordSchema = import_zod2.z.object({
-  currentPassword: import_zod2.z.string().min(1, "Current password is required"),
-  newPassword: import_zod2.z.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number")
-});
-
-// src/utils/response.ts
-function success3(reply, data, statusCode = 200) {
-  const response = {
-    success: true,
-    data
-  };
-  return reply.status(statusCode).send(response);
-}
-function created(reply, data) {
-  return success3(reply, data, 201);
-}
-function noContent(reply) {
-  return reply.status(204).send();
-}
-
-// src/modules/validation/validator.ts
-var import_zod3 = require("zod");
-function validateBody(schema, data) {
-  const result = schema.safeParse(data);
-  if (!result.success) {
-    throw new ValidationError(formatZodErrors(result.error));
-  }
-  return result.data;
-}
-function validateQuery(schema, data) {
-  const result = schema.safeParse(data);
-  if (!result.success) {
-    throw new ValidationError(formatZodErrors(result.error));
-  }
-  return result.data;
-}
-function formatZodErrors(error2) {
-  const errors = {};
-  for (const issue of error2.issues) {
-    const path6 = issue.path.join(".") || "root";
-    if (!errors[path6]) {
-      errors[path6] = [];
-    }
-    errors[path6].push(issue.message);
-  }
-  return errors;
-}
-var idParamSchema = import_zod3.z.object({
-  id: import_zod3.z.string().uuid("Invalid ID format")
-});
-var paginationSchema = import_zod3.z.object({
-  page: import_zod3.z.string().transform(Number).optional().default("1"),
-  limit: import_zod3.z.string().transform(Number).optional().default("20"),
-  sortBy: import_zod3.z.string().optional(),
-  sortOrder: import_zod3.z.enum(["asc", "desc"]).optional().default("asc")
-});
-var searchSchema = import_zod3.z.object({
-  q: import_zod3.z.string().min(1, "Search query is required").optional(),
-  search: import_zod3.z.string().min(1).optional()
-});
-var emailSchema = import_zod3.z.string().email("Invalid email address");
-var passwordSchema = import_zod3.z.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number").regex(/[^A-Za-z0-9]/, "Password must contain at least one special character");
-var urlSchema = import_zod3.z.string().url("Invalid URL format");
-var phoneSchema = import_zod3.z.string().regex(
-  /^\+?[1-9]\d{1,14}$/,
-  "Invalid phone number format"
-);
-var dateSchema = import_zod3.z.coerce.date();
-var futureDateSchema = import_zod3.z.coerce.date().refine(
-  (date) => date > /* @__PURE__ */ new Date(),
-  "Date must be in the future"
-);
-var pastDateSchema = import_zod3.z.coerce.date().refine(
-  (date) => date < /* @__PURE__ */ new Date(),
-  "Date must be in the past"
-);
-
-// src/modules/auth/auth.controller.ts
-var AuthController = class {
-  constructor(authService, userService) {
-    this.authService = authService;
-    this.userService = userService;
-  }
-  async register(request, reply) {
-    const data = validateBody(registerSchema, request.body);
-    const existingUser = await this.userService.findByEmail(data.email);
-    if (existingUser) {
-      throw new BadRequestError("Email already registered");
-    }
-    const hashedPassword = await this.authService.hashPassword(data.password);
-    const user = await this.userService.create({
-      email: data.email,
-      password: hashedPassword,
-      name: data.name
-    });
-    const tokens = this.authService.generateTokenPair({
-      id: user.id,
-      email: user.email,
-      role: user.role
-    });
-    created(reply, {
-      user: {
-        id: user.id,
-        email: user.email,
-        name: user.name,
-        role: user.role
-      },
-      ...tokens
-    });
-  }
-  async login(request, reply) {
-    const data = validateBody(loginSchema, request.body);
-    const user = await this.userService.findByEmail(data.email);
-    if (!user) {
-      throw new UnauthorizedError("Invalid credentials");
-    }
-    if (user.status !== "active") {
-      throw new UnauthorizedError("Account is not active");
-    }
-    const isValidPassword = await this.authService.verifyPassword(data.password, user.password);
-    if (!isValidPassword) {
-      throw new UnauthorizedError("Invalid credentials");
-    }
-    await this.userService.updateLastLogin(user.id);
-    const tokens = this.authService.generateTokenPair({
-      id: user.id,
-      email: user.email,
-      role: user.role
-    });
-    success3(reply, {
-      user: {
-        id: user.id,
-        email: user.email,
-        name: user.name,
-        role: user.role
-      },
-      ...tokens
-    });
-  }
-  async refresh(request, reply) {
-    const data = validateBody(refreshTokenSchema, request.body);
-    const payload = await this.authService.verifyRefreshToken(data.refreshToken);
-    const user = await this.userService.findById(payload.sub);
-    if (!user || user.status !== "active") {
-      throw new UnauthorizedError("User not found or inactive");
-    }
-    this.authService.blacklistToken(data.refreshToken);
-    const tokens = this.authService.generateTokenPair({
-      id: user.id,
-      email: user.email,
-      role: user.role
-    });
-    success3(reply, tokens);
-  }
-  async logout(request, reply) {
-    const authHeader = request.headers.authorization;
-    if (authHeader?.startsWith("Bearer ")) {
-      const token = authHeader.substring(7);
-      this.authService.blacklistToken(token);
-    }
-    success3(reply, { message: "Logged out successfully" });
-  }
-  async me(request, reply) {
-    const authRequest = request;
-    const user = await this.userService.findById(authRequest.user.id);
-    if (!user) {
-      throw new UnauthorizedError("User not found");
-    }
-    success3(reply, {
-      id: user.id,
-      email: user.email,
-      name: user.name,
-      role: user.role,
-      status: user.status,
-      createdAt: user.createdAt
-    });
-  }
-  async changePassword(request, reply) {
-    const authRequest = request;
-    const data = validateBody(changePasswordSchema, request.body);
-    const user = await this.userService.findById(authRequest.user.id);
-    if (!user) {
-      throw new UnauthorizedError("User not found");
-    }
-    const isValidPassword = await this.authService.verifyPassword(
-      data.currentPassword,
-      user.password
-    );
-    if (!isValidPassword) {
-      throw new BadRequestError("Current password is incorrect");
-    }
-    const hashedPassword = await this.authService.hashPassword(data.newPassword);
-    await this.userService.updatePassword(user.id, hashedPassword);
-    success3(reply, { message: "Password changed successfully" });
-  }
-};
-function createAuthController(authService, userService) {
-  return new AuthController(authService, userService);
-}
-
-// src/modules/auth/auth.middleware.ts
-function createAuthMiddleware(authService) {
-  return async function authenticate(request, reply) {
-    const authHeader = request.headers.authorization;
-    if (!authHeader || !authHeader.startsWith("Bearer ")) {
-      throw new UnauthorizedError("Missing or invalid authorization header");
-    }
-    const token = authHeader.substring(7);
-    const payload = await authService.verifyAccessToken(token);
-    request.user = {
-      id: payload.sub,
-      email: payload.email,
-      role: payload.role
-    };
-  };
-}
-function createRoleMiddleware(allowedRoles) {
-  return async function authorize(request, _reply) {
-    const user = request.user;
-    if (!user) {
-      throw new UnauthorizedError("Authentication required");
-    }
-    if (!allowedRoles.includes(user.role)) {
-      throw new ForbiddenError("Insufficient permissions");
-    }
-  };
-}
-
-// src/modules/auth/auth.routes.ts
-var credentialsBody = {
-  type: "object",
-  required: ["email", "password"],
-  properties: {
-    email: { type: "string", format: "email" },
-    password: { type: "string", minLength: 8 }
-  }
-};
-var changePasswordBody = {
-  type: "object",
-  required: ["currentPassword", "newPassword"],
-  properties: {
-    currentPassword: { type: "string", minLength: 8 },
-    newPassword: { type: "string", minLength: 8 }
-  }
-};
-function registerAuthRoutes(app, controller, authService) {
-  const authenticate = createAuthMiddleware(authService);
-  app.post("/auth/register", {
-    schema: {
-      tags: ["Auth"],
-      summary: "Register a new user",
-      body: credentialsBody,
-      response: {
-        201: commonResponses.success,
-        400: commonResponses.error,
-        409: commonResponses.error
-      }
-    },
-    handler: controller.register.bind(controller)
-  });
-  app.post("/auth/login", {
-    schema: {
-      tags: ["Auth"],
-      summary: "Login and obtain tokens",
-      body: credentialsBody,
-      response: {
-        200: commonResponses.success,
-        400: commonResponses.error,
-        401: commonResponses.unauthorized
-      }
-    },
-    handler: controller.login.bind(controller)
-  });
-  app.post("/auth/refresh", {
-    schema: {
-      tags: ["Auth"],
-      summary: "Refresh access token",
-      body: {
-        type: "object",
-        required: ["refreshToken"],
-        properties: {
-          refreshToken: { type: "string" }
-        }
-      },
-      response: {
-        200: commonResponses.success,
-        401: commonResponses.unauthorized
-      }
-    },
-    handler: controller.refresh.bind(controller)
-  });
-  app.post("/auth/logout", {
-    preHandler: [authenticate],
-    schema: {
-      tags: ["Auth"],
-      summary: "Logout current user",
-      security: [{ bearerAuth: [] }],
-      response: {
-        200: commonResponses.success,
-        401: commonResponses.unauthorized
-      }
-    },
-    handler: controller.logout.bind(controller)
-  });
-  app.get("/auth/me", {
-    preHandler: [authenticate],
-    schema: {
-      tags: ["Auth"],
-      summary: "Get current user profile",
-      security: [{ bearerAuth: [] }],
-      response: {
-        200: commonResponses.success,
-        401: commonResponses.unauthorized
-      }
-    },
-    handler: controller.me.bind(controller)
-  });
-  app.post("/auth/change-password", {
-    preHandler: [authenticate],
-    schema: {
-      tags: ["Auth"],
-      summary: "Change current user password",
-      security: [{ bearerAuth: [] }],
-      body: changePasswordBody,
-      response: {
-        200: commonResponses.success,
-        400: commonResponses.error,
-        401: commonResponses.unauthorized
-      }
-    },
-    handler: controller.changePassword.bind(controller)
-  });
-}
-
-// src/modules/user/user.repository.ts
-var import_crypto = require("crypto");
-
-// src/utils/pagination.ts
-var DEFAULT_PAGE = 1;
-var DEFAULT_LIMIT = 20;
-var MAX_LIMIT = 100;
-function parsePaginationParams(query) {
-  const page = Math.max(1, parseInt(String(query.page || DEFAULT_PAGE), 10));
-  const limit = Math.min(MAX_LIMIT, Math.max(1, parseInt(String(query.limit || DEFAULT_LIMIT), 10)));
-  const sortBy = typeof query.sortBy === "string" ? query.sortBy : void 0;
-  const sortOrder = query.sortOrder === "desc" ? "desc" : "asc";
-  return { page, limit, sortBy, sortOrder };
-}
-function createPaginatedResult(data, total, params) {
-  const totalPages = Math.ceil(total / params.limit);
-  return {
-    data,
-    meta: {
-      total,
-      page: params.page,
-      limit: params.limit,
-      totalPages,
-      hasNextPage: params.page < totalPages,
-      hasPrevPage: params.page > 1
-    }
-  };
-}
-function getSkip(params) {
-  return (params.page - 1) * params.limit;
-}
-
-// src/modules/user/user.repository.ts
-var users = /* @__PURE__ */ new Map();
-var UserRepository = class {
-  async findById(id) {
-    return users.get(id) || null;
-  }
-  async findByEmail(email) {
-    for (const user of users.values()) {
-      if (user.email.toLowerCase() === email.toLowerCase()) {
-        return user;
-      }
-    }
-    return null;
-  }
-  async findMany(params, filters) {
-    let filteredUsers = Array.from(users.values());
-    if (filters) {
-      if (filters.status) {
-        filteredUsers = filteredUsers.filter((u) => u.status === filters.status);
-      }
-      if (filters.role) {
-        filteredUsers = filteredUsers.filter((u) => u.role === filters.role);
-      }
-      if (filters.emailVerified !== void 0) {
-        filteredUsers = filteredUsers.filter((u) => u.emailVerified === filters.emailVerified);
-      }
-      if (filters.search) {
-        const search = filters.search.toLowerCase();
-        filteredUsers = filteredUsers.filter(
-          (u) => u.email.toLowerCase().includes(search) || u.name?.toLowerCase().includes(search)
-        );
-      }
-    }
-    if (params.sortBy) {
-      const sortKey = params.sortBy;
-      filteredUsers.sort((a, b) => {
-        const aVal = a[sortKey];
-        const bVal = b[sortKey];
-        if (aVal === void 0 || bVal === void 0) return 0;
-        if (aVal < bVal) return params.sortOrder === "desc" ? 1 : -1;
-        if (aVal > bVal) return params.sortOrder === "desc" ? -1 : 1;
-        return 0;
-      });
-    }
-    const total = filteredUsers.length;
-    const skip = getSkip(params);
-    const data = filteredUsers.slice(skip, skip + params.limit);
-    return createPaginatedResult(data, total, params);
-  }
-  async create(data) {
-    const now = /* @__PURE__ */ new Date();
-    const user = {
-      id: (0, import_crypto.randomUUID)(),
-      email: data.email,
-      password: data.password,
-      name: data.name,
-      role: data.role || "user",
-      status: "active",
-      emailVerified: false,
-      createdAt: now,
-      updatedAt: now
-    };
-    users.set(user.id, user);
-    return user;
-  }
-  async update(id, data) {
-    const user = users.get(id);
-    if (!user) return null;
-    const updatedUser = {
-      ...user,
-      ...data,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    users.set(id, updatedUser);
-    return updatedUser;
-  }
-  async updatePassword(id, password) {
-    const user = users.get(id);
-    if (!user) return null;
-    const updatedUser = {
-      ...user,
-      password,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    users.set(id, updatedUser);
-    return updatedUser;
-  }
-  async updateLastLogin(id) {
-    const user = users.get(id);
-    if (!user) return null;
-    const updatedUser = {
-      ...user,
-      lastLoginAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    users.set(id, updatedUser);
-    return updatedUser;
-  }
-  async delete(id) {
-    return users.delete(id);
-  }
-  async count(filters) {
-    let count = 0;
-    for (const user of users.values()) {
-      if (filters) {
-        if (filters.status && user.status !== filters.status) continue;
-        if (filters.role && user.role !== filters.role) continue;
-        if (filters.emailVerified !== void 0 && user.emailVerified !== filters.emailVerified)
-          continue;
-      }
-      count++;
-    }
-    return count;
-  }
-  // Helper to clear all users (for testing)
-  async clear() {
-    users.clear();
-  }
-};
-function createUserRepository() {
-  return new UserRepository();
-}
-
-// src/modules/user/types.ts
-var DEFAULT_ROLE_PERMISSIONS = {
-  user: ["profile:read", "profile:update"],
-  moderator: [
-    "profile:read",
-    "profile:update",
-    "users:read",
-    "content:read",
-    "content:update",
-    "content:delete"
-  ],
-  admin: [
-    "profile:read",
-    "profile:update",
-    "users:read",
-    "users:update",
-    "users:delete",
-    "content:manage",
-    "settings:read"
-  ],
-  super_admin: ["*:manage"]
-  // All permissions
-};
-
-// src/modules/user/user.service.ts
-var UserService = class {
-  constructor(repository) {
-    this.repository = repository;
-  }
-  async findById(id) {
-    return this.repository.findById(id);
-  }
-  async findByEmail(email) {
-    return this.repository.findByEmail(email);
-  }
-  async findMany(params, filters) {
-    const result = await this.repository.findMany(params, filters);
-    return {
-      ...result,
-      data: result.data.map(({ password, ...user }) => user)
-    };
-  }
-  async create(data) {
-    const existing = await this.repository.findByEmail(data.email);
-    if (existing) {
-      throw new ConflictError("User with this email already exists");
-    }
-    const user = await this.repository.create(data);
-    logger.info({ userId: user.id, email: user.email }, "User created");
-    return user;
-  }
-  async update(id, data) {
-    const user = await this.repository.findById(id);
-    if (!user) {
-      throw new NotFoundError("User");
-    }
-    if (data.email && data.email !== user.email) {
-      const existing = await this.repository.findByEmail(data.email);
-      if (existing) {
-        throw new ConflictError("Email already in use");
-      }
-    }
-    const updatedUser = await this.repository.update(id, data);
-    if (!updatedUser) {
-      throw new NotFoundError("User");
-    }
-    logger.info({ userId: id }, "User updated");
-    return updatedUser;
-  }
-  async updatePassword(id, hashedPassword) {
-    const user = await this.repository.updatePassword(id, hashedPassword);
-    if (!user) {
-      throw new NotFoundError("User");
-    }
-    logger.info({ userId: id }, "User password updated");
-    return user;
-  }
-  async updateLastLogin(id) {
-    const user = await this.repository.updateLastLogin(id);
-    if (!user) {
-      throw new NotFoundError("User");
-    }
-    return user;
-  }
-  async delete(id) {
-    const user = await this.repository.findById(id);
-    if (!user) {
-      throw new NotFoundError("User");
-    }
-    await this.repository.delete(id);
-    logger.info({ userId: id }, "User deleted");
-  }
-  async suspend(id) {
-    return this.update(id, { status: "suspended" });
-  }
-  async ban(id) {
-    return this.update(id, { status: "banned" });
-  }
-  async activate(id) {
-    return this.update(id, { status: "active" });
-  }
-  async verifyEmail(id) {
-    return this.update(id, { emailVerified: true });
-  }
-  async changeRole(id, role) {
-    return this.update(id, { role });
-  }
-  // RBAC helpers
-  hasPermission(role, permission) {
-    const permissions = DEFAULT_ROLE_PERMISSIONS[role] || [];
-    if (permissions.includes("*:manage")) {
-      return true;
-    }
-    if (permissions.includes(permission)) {
-      return true;
-    }
-    const [resource, action] = permission.split(":");
-    const managePermission = `${resource}:manage`;
-    if (permissions.includes(managePermission)) {
-      return true;
-    }
-    return false;
-  }
-  getPermissions(role) {
-    return DEFAULT_ROLE_PERMISSIONS[role] || [];
-  }
-};
-function createUserService(repository) {
-  return new UserService(repository || createUserRepository());
-}
-
-// src/modules/auth/index.ts
-async function registerAuthModule(app) {
-  await app.register(import_jwt.default, {
-    secret: config.jwt.secret,
-    sign: {
-      algorithm: "HS256"
-    }
-  });
-  await app.register(import_cookie.default, {
-    secret: config.jwt.secret,
-    hook: "onRequest"
-  });
-  const authService = createAuthService(app);
-  const userService = createUserService();
-  const authController = createAuthController(authService, userService);
-  registerAuthRoutes(app, authController, authService);
-  logger.info("Auth module registered");
-  return authService;
-}
-
-// src/modules/user/schemas.ts
-var import_zod4 = require("zod");
-var userStatusEnum = import_zod4.z.enum(["active", "inactive", "suspended", "banned"]);
-var userRoleEnum = import_zod4.z.enum(["user", "admin", "moderator", "super_admin"]);
-var createUserSchema = import_zod4.z.object({
-  email: import_zod4.z.string().email("Invalid email address"),
-  password: import_zod4.z.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number"),
-  name: import_zod4.z.string().min(2, "Name must be at least 2 characters").optional(),
-  role: userRoleEnum.optional().default("user")
-});
-var updateUserSchema = import_zod4.z.object({
-  email: import_zod4.z.string().email("Invalid email address").optional(),
-  name: import_zod4.z.string().min(2, "Name must be at least 2 characters").optional(),
-  role: userRoleEnum.optional(),
-  status: userStatusEnum.optional(),
-  emailVerified: import_zod4.z.boolean().optional(),
-  metadata: import_zod4.z.record(import_zod4.z.unknown()).optional()
-});
-var updateProfileSchema = import_zod4.z.object({
-  name: import_zod4.z.string().min(2, "Name must be at least 2 characters").optional(),
-  metadata: import_zod4.z.record(import_zod4.z.unknown()).optional()
-});
-var userQuerySchema = import_zod4.z.object({
-  page: import_zod4.z.string().transform(Number).optional(),
-  limit: import_zod4.z.string().transform(Number).optional(),
-  sortBy: import_zod4.z.string().optional(),
-  sortOrder: import_zod4.z.enum(["asc", "desc"]).optional(),
-  status: userStatusEnum.optional(),
-  role: userRoleEnum.optional(),
-  search: import_zod4.z.string().optional(),
-  emailVerified: import_zod4.z.string().transform((val) => val === "true").optional()
-});
-
-// src/modules/user/user.controller.ts
-var UserController = class {
-  constructor(userService) {
-    this.userService = userService;
-  }
-  async list(request, reply) {
-    const query = validateQuery(userQuerySchema, request.query);
-    const pagination = parsePaginationParams(query);
-    const filters = {
-      status: query.status,
-      role: query.role,
-      search: query.search,
-      emailVerified: query.emailVerified
-    };
-    const result = await this.userService.findMany(pagination, filters);
-    success3(reply, result);
-  }
-  async getById(request, reply) {
-    const user = await this.userService.findById(request.params.id);
-    if (!user) {
-      return reply.status(404).send({
-        success: false,
-        message: "User not found"
-      });
-    }
-    const { password, ...userData } = user;
-    success3(reply, userData);
-  }
-  async update(request, reply) {
-    const data = validateBody(updateUserSchema, request.body);
-    const user = await this.userService.update(request.params.id, data);
-    const { password, ...userData } = user;
-    success3(reply, userData);
-  }
-  async delete(request, reply) {
-    const authRequest = request;
-    if (authRequest.user.id === request.params.id) {
-      throw new ForbiddenError("Cannot delete your own account");
-    }
-    await this.userService.delete(request.params.id);
-    noContent(reply);
-  }
-  async suspend(request, reply) {
-    const authRequest = request;
-    if (authRequest.user.id === request.params.id) {
-      throw new ForbiddenError("Cannot suspend your own account");
-    }
-    const user = await this.userService.suspend(request.params.id);
-    const { password, ...userData } = user;
-    success3(reply, userData);
-  }
-  async ban(request, reply) {
-    const authRequest = request;
-    if (authRequest.user.id === request.params.id) {
-      throw new ForbiddenError("Cannot ban your own account");
-    }
-    const user = await this.userService.ban(request.params.id);
-    const { password, ...userData } = user;
-    success3(reply, userData);
-  }
-  async activate(request, reply) {
-    const user = await this.userService.activate(request.params.id);
-    const { password, ...userData } = user;
-    success3(reply, userData);
-  }
-  // Profile routes (for authenticated user)
-  async getProfile(request, reply) {
-    const authRequest = request;
-    const user = await this.userService.findById(authRequest.user.id);
-    if (!user) {
-      return reply.status(404).send({
-        success: false,
-        message: "User not found"
-      });
-    }
-    const { password, ...userData } = user;
-    success3(reply, userData);
-  }
-  async updateProfile(request, reply) {
-    const authRequest = request;
-    const data = validateBody(updateProfileSchema, request.body);
-    const user = await this.userService.update(authRequest.user.id, data);
-    const { password, ...userData } = user;
-    success3(reply, userData);
-  }
-};
-function createUserController(userService) {
-  return new UserController(userService);
-}
-
-// src/modules/user/user.routes.ts
-var userTag = "Users";
-var userResponse = {
-  type: "object",
-  properties: {
-    success: { type: "boolean", example: true },
-    data: { type: "object" }
-  }
-};
-function registerUserRoutes(app, controller, authService) {
-  const authenticate = createAuthMiddleware(authService);
-  const isAdmin = createRoleMiddleware(["admin", "super_admin"]);
-  const isModerator = createRoleMiddleware(["moderator", "admin", "super_admin"]);
-  app.get(
-    "/profile",
-    {
-      preHandler: [authenticate],
-      schema: {
-        tags: [userTag],
-        summary: "Get current user profile",
-        security: [{ bearerAuth: [] }],
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized
-        }
-      }
-    },
-    controller.getProfile.bind(controller)
-  );
-  app.patch(
-    "/profile",
-    {
-      preHandler: [authenticate],
-      schema: {
-        tags: [userTag],
-        summary: "Update current user profile",
-        security: [{ bearerAuth: [] }],
-        body: { type: "object" },
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          400: commonResponses.error
-        }
-      }
-    },
-    controller.updateProfile.bind(controller)
-  );
-  app.get(
-    "/users",
-    {
-      preHandler: [authenticate, isModerator],
-      schema: {
-        tags: [userTag],
-        summary: "List users",
-        security: [{ bearerAuth: [] }],
-        querystring: {
-          ...paginationQuery,
-          properties: {
-            ...paginationQuery.properties,
-            status: { type: "string", enum: ["active", "inactive", "suspended", "banned"] },
-            role: { type: "string", enum: ["user", "admin", "moderator", "super_admin"] },
-            search: { type: "string" },
-            emailVerified: { type: "boolean" }
-          }
-        },
-        response: {
-          200: commonResponses.paginated,
-          401: commonResponses.unauthorized
-        }
-      }
-    },
-    controller.list.bind(controller)
-  );
-  app.get(
-    "/users/:id",
-    {
-      preHandler: [authenticate, isModerator],
-      schema: {
-        tags: [userTag],
-        summary: "Get user by id",
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound
-        }
-      }
-    },
-    controller.getById.bind(controller)
-  );
-  app.patch(
-    "/users/:id",
-    {
-      preHandler: [authenticate, isAdmin],
-      schema: {
-        tags: [userTag],
-        summary: "Update user",
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        body: { type: "object" },
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound
-        }
-      }
-    },
-    controller.update.bind(controller)
-  );
-  app.delete(
-    "/users/:id",
-    {
-      preHandler: [authenticate, isAdmin],
-      schema: {
-        tags: [userTag],
-        summary: "Delete user",
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        response: {
-          204: { description: "User deleted" },
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound
-        }
-      }
-    },
-    controller.delete.bind(controller)
-  );
-  app.post(
-    "/users/:id/suspend",
-    {
-      preHandler: [authenticate, isAdmin],
-      schema: {
-        tags: [userTag],
-        summary: "Suspend user",
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound
-        }
-      }
-    },
-    controller.suspend.bind(controller)
-  );
-  app.post(
-    "/users/:id/ban",
-    {
-      preHandler: [authenticate, isAdmin],
-      schema: {
-        tags: [userTag],
-        summary: "Ban user",
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound
-        }
-      }
-    },
-    controller.ban.bind(controller)
-  );
-  app.post(
-    "/users/:id/activate",
-    {
-      preHandler: [authenticate, isAdmin],
-      schema: {
-        tags: [userTag],
-        summary: "Activate user",
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound
-        }
-      }
-    },
-    controller.activate.bind(controller)
-  );
-}
-
-// src/modules/user/index.ts
-async function registerUserModule(app, authService) {
-  const repository = createUserRepository();
-  const userService = createUserService(repository);
-  const userController = createUserController(userService);
-  registerUserRoutes(app, userController, authService);
-  logger.info("User module registered");
-}
-
-// src/cli/utils/docs-generator.ts
-async function generateDocs(outputPath = "openapi.json", silent = false) {
-  const spinner = silent ? null : (0, import_ora2.default)("Generating OpenAPI documentation...").start();
-  try {
-    const server = createServer({
-      port: config.server.port,
-      host: config.server.host
-    });
-    const app = server.instance;
-    registerErrorHandler(app);
-    await registerSecurity(app);
-    await registerSwagger(app, {
-      enabled: true,
-      route: config.swagger.route,
-      title: config.swagger.title,
-      description: config.swagger.description,
-      version: config.swagger.version
-    });
-    const authService = await registerAuthModule(app);
-    await registerUserModule(app, authService);
-    await app.ready();
-    const spec = app.swagger();
-    const absoluteOutput = import_path3.default.resolve(outputPath);
-    await import_promises3.default.mkdir(import_path3.default.dirname(absoluteOutput), { recursive: true });
-    await import_promises3.default.writeFile(absoluteOutput, JSON.stringify(spec, null, 2), "utf8");
-    spinner?.succeed(`OpenAPI spec generated at ${absoluteOutput}`);
-    await app.close();
-    return absoluteOutput;
-  } catch (error2) {
-    spinner?.fail("Failed to generate OpenAPI documentation");
-    throw error2;
-  }
-}
-
-// src/cli/commands/generate.ts
-var generateCommand = new import_commander2.Command("generate").alias("g").description("Generate resources (module, controller, service, etc.)");
-generateCommand.command("module <name> [fields...]").alias("m").description("Generate a complete module with controller, service, repository, types, schemas, and routes").option("--no-routes", "Skip routes generation").option("--no-repository", "Skip repository generation").option("--prisma", "Generate Prisma model suggestion").option("--validator <type>", "Validator type: zod, joi, yup", "zod").option("-i, --interactive", "Interactive mode to define fields").action(async (name, fieldsArgs, options) => {
-  let fields = [];
-  if (options.interactive) {
-    fields = await promptForFields();
-  } else if (fieldsArgs.length > 0) {
-    fields = parseFields(fieldsArgs.join(" "));
-  }
-  const spinner = (0, import_ora3.default)("Generating module...").start();
-  try {
-    const kebabName = toKebabCase(name);
-    const pascalName = toPascalCase(name);
-    const camelName = toCamelCase(name);
-    const pluralName = pluralize(kebabName);
-    const tableName = pluralize(kebabName.replace(/-/g, "_"));
-    const validatorType = options.validator || "zod";
-    const moduleDir = import_path4.default.join(getModulesDir(), kebabName);
-    if (await fileExists(moduleDir)) {
-      spinner.stop();
-      error(`Module "${kebabName}" already exists`);
-      return;
-    }
-    const hasFields = fields.length > 0;
-    const files = [
-      {
-        name: `${kebabName}.types.ts`,
-        content: hasFields ? dynamicTypesTemplate(kebabName, pascalName, fields) : typesTemplate(kebabName, pascalName)
-      },
-      {
-        name: `${kebabName}.schemas.ts`,
-        content: hasFields ? dynamicSchemasTemplate(kebabName, pascalName, camelName, fields, validatorType) : schemasTemplate(kebabName, pascalName, camelName)
-      },
-      { name: `${kebabName}.service.ts`, content: serviceTemplate(kebabName, pascalName, camelName) },
-      { name: `${kebabName}.controller.ts`, content: controllerTemplate(kebabName, pascalName, camelName) },
-      { name: "index.ts", content: moduleIndexTemplate(kebabName, pascalName, camelName) }
-    ];
-    if (options.repository !== false) {
-      files.push({
-        name: `${kebabName}.repository.ts`,
-        content: repositoryTemplate(kebabName, pascalName, camelName, pluralName)
-      });
-    }
-    if (options.routes !== false) {
-      files.push({
-        name: `${kebabName}.routes.ts`,
-        content: routesTemplate(kebabName, pascalName, camelName, pluralName, fields)
-      });
-    }
-    for (const file of files) {
-      await writeFile(import_path4.default.join(moduleDir, file.name), file.content);
-    }
-    spinner.succeed(`Module "${pascalName}" generated successfully!`);
-    if (options.prisma || hasFields) {
-      console.log("\n" + "\u2500".repeat(50));
-      info("Prisma model suggestion:");
-      if (hasFields) {
-        console.log(dynamicPrismaTemplate(pascalName, tableName, fields));
-      } else {
-        console.log(prismaModelTemplate(kebabName, pascalName, tableName));
+    spinner.succeed(`Module "${pascalName}" generated successfully!`);
+    if (options.prisma || hasFields) {
+      console.log("\n" + "\u2500".repeat(50));
+      info("Prisma model suggestion:");
+      if (hasFields) {
+        console.log(dynamicPrismaTemplate(pascalName, tableName, fields));
+      } else {
+        console.log(prismaModelTemplate(kebabName, pascalName, tableName));
       }
     }
     if (hasFields) {
@@ -3245,31 +1726,20 @@ generateCommand.command("module <name> [fields...]").alias("m").description("Gen
       info(`  ${hasFields ? "3" : "4"}. Add the Prisma model to schema.prisma`);
       info(`  ${hasFields ? "4" : "5"}. Run: npm run db:migrate`);
     }
-    const { generateDocsNow } = await import_inquirer2.default.prompt([
-      {
-        type: "confirm",
-        name: "generateDocsNow",
-        message: "Generate Swagger/OpenAPI documentation now?",
-        default: true
-      }
-    ]);
-    if (generateDocsNow) {
-      await generateDocs("openapi.json", true);
-    }
   } catch (err) {
     spinner.fail("Failed to generate module");
     error(err instanceof Error ? err.message : String(err));
   }
 });
 generateCommand.command("controller <name>").alias("c").description("Generate a controller").option("-m, --module <module>", "Target module name").action(async (name, options) => {
-  const spinner = (0, import_ora3.default)("Generating controller...").start();
+  const spinner = (0, import_ora2.default)("Generating controller...").start();
   try {
     const kebabName = toKebabCase(name);
     const pascalName = toPascalCase(name);
     const camelName = toCamelCase(name);
     const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = import_path4.default.join(getModulesDir(), moduleName);
-    const filePath = import_path4.default.join(moduleDir, `${kebabName}.controller.ts`);
+    const moduleDir = import_path3.default.join(getModulesDir(), moduleName);
+    const filePath = import_path3.default.join(moduleDir, `${kebabName}.controller.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Controller "${kebabName}" already exists`);
@@ -3284,14 +1754,14 @@ generateCommand.command("controller <name>").alias("c").description("Generate a
   }
 });
 generateCommand.command("service <name>").alias("s").description("Generate a service").option("-m, --module <module>", "Target module name").action(async (name, options) => {
-  const spinner = (0, import_ora3.default)("Generating service...").start();
+  const spinner = (0, import_ora2.default)("Generating service...").start();
   try {
     const kebabName = toKebabCase(name);
     const pascalName = toPascalCase(name);
     const camelName = toCamelCase(name);
     const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = import_path4.default.join(getModulesDir(), moduleName);
-    const filePath = import_path4.default.join(moduleDir, `${kebabName}.service.ts`);
+    const moduleDir = import_path3.default.join(getModulesDir(), moduleName);
+    const filePath = import_path3.default.join(moduleDir, `${kebabName}.service.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Service "${kebabName}" already exists`);
@@ -3306,15 +1776,15 @@ generateCommand.command("service <name>").alias("s").description("Generate a ser
   }
 });
 generateCommand.command("repository <name>").alias("r").description("Generate a repository").option("-m, --module <module>", "Target module name").action(async (name, options) => {
-  const spinner = (0, import_ora3.default)("Generating repository...").start();
+  const spinner = (0, import_ora2.default)("Generating repository...").start();
   try {
     const kebabName = toKebabCase(name);
     const pascalName = toPascalCase(name);
     const camelName = toCamelCase(name);
     const pluralName = pluralize(kebabName);
     const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = import_path4.default.join(getModulesDir(), moduleName);
-    const filePath = import_path4.default.join(moduleDir, `${kebabName}.repository.ts`);
+    const moduleDir = import_path3.default.join(getModulesDir(), moduleName);
+    const filePath = import_path3.default.join(moduleDir, `${kebabName}.repository.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Repository "${kebabName}" already exists`);
@@ -3329,157 +1799,1261 @@ generateCommand.command("repository <name>").alias("r").description("Generate a
   }
 });
 generateCommand.command("types <name>").alias("t").description("Generate types/interfaces").option("-m, --module <module>", "Target module name").action(async (name, options) => {
-  const spinner = (0, import_ora3.default)("Generating types...").start();
+  const spinner = (0, import_ora2.default)("Generating types...").start();
   try {
     const kebabName = toKebabCase(name);
     const pascalName = toPascalCase(name);
     const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = import_path4.default.join(getModulesDir(), moduleName);
-    const filePath = import_path4.default.join(moduleDir, `${kebabName}.types.ts`);
+    const moduleDir = import_path3.default.join(getModulesDir(), moduleName);
+    const filePath = import_path3.default.join(moduleDir, `${kebabName}.types.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Types file "${kebabName}.types.ts" already exists`);
       return;
     }
-    await writeFile(filePath, typesTemplate(kebabName, pascalName));
-    spinner.succeed(`Types for "${pascalName}" generated!`);
-    success(`  src/modules/${moduleName}/${kebabName}.types.ts`);
-  } catch (err) {
-    spinner.fail("Failed to generate types");
-    error(err instanceof Error ? err.message : String(err));
+    await writeFile(filePath, typesTemplate(kebabName, pascalName));
+    spinner.succeed(`Types for "${pascalName}" generated!`);
+    success(`  src/modules/${moduleName}/${kebabName}.types.ts`);
+  } catch (err) {
+    spinner.fail("Failed to generate types");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+generateCommand.command("schema <name>").alias("v").description("Generate validation schemas").option("-m, --module <module>", "Target module name").action(async (name, options) => {
+  const spinner = (0, import_ora2.default)("Generating schemas...").start();
+  try {
+    const kebabName = toKebabCase(name);
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const moduleName = options.module ? toKebabCase(options.module) : kebabName;
+    const moduleDir = import_path3.default.join(getModulesDir(), moduleName);
+    const filePath = import_path3.default.join(moduleDir, `${kebabName}.schemas.ts`);
+    if (await fileExists(filePath)) {
+      spinner.stop();
+      error(`Schemas file "${kebabName}.schemas.ts" already exists`);
+      return;
+    }
+    await writeFile(filePath, schemasTemplate(kebabName, pascalName, camelName));
+    spinner.succeed(`Schemas for "${pascalName}" generated!`);
+    success(`  src/modules/${moduleName}/${kebabName}.schemas.ts`);
+  } catch (err) {
+    spinner.fail("Failed to generate schemas");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+generateCommand.command("routes <name>").description("Generate routes").option("-m, --module <module>", "Target module name").action(async (name, options) => {
+  const spinner = (0, import_ora2.default)("Generating routes...").start();
+  try {
+    const kebabName = toKebabCase(name);
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const pluralName = pluralize(kebabName);
+    const moduleName = options.module ? toKebabCase(options.module) : kebabName;
+    const moduleDir = import_path3.default.join(getModulesDir(), moduleName);
+    const filePath = import_path3.default.join(moduleDir, `${kebabName}.routes.ts`);
+    if (await fileExists(filePath)) {
+      spinner.stop();
+      error(`Routes file "${kebabName}.routes.ts" already exists`);
+      return;
+    }
+    await writeFile(filePath, routesTemplate(kebabName, pascalName, camelName, pluralName));
+    spinner.succeed(`Routes for "${pascalName}" generated!`);
+    success(`  src/modules/${moduleName}/${kebabName}.routes.ts`);
+  } catch (err) {
+    spinner.fail("Failed to generate routes");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+async function promptForFields() {
+  const fields = [];
+  console.log("\n\u{1F4DD} Define your model fields (press Enter with empty name to finish)\n");
+  const fieldTypes = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "datetime",
+    "text",
+    "email",
+    "url",
+    "uuid",
+    "int",
+    "float",
+    "decimal",
+    "json"
+  ];
+  let addMore = true;
+  while (addMore) {
+    const answers = await import_inquirer2.default.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "Field name (empty to finish):"
+      }
+    ]);
+    if (!answers.name) {
+      addMore = false;
+      continue;
+    }
+    const fieldDetails = await import_inquirer2.default.prompt([
+      {
+        type: "list",
+        name: "type",
+        message: `Type for "${answers.name}":`,
+        choices: fieldTypes,
+        default: "string"
+      },
+      {
+        type: "confirm",
+        name: "isOptional",
+        message: "Is optional?",
+        default: false
+      },
+      {
+        type: "confirm",
+        name: "isUnique",
+        message: "Is unique?",
+        default: false
+      },
+      {
+        type: "confirm",
+        name: "isArray",
+        message: "Is array?",
+        default: false
+      }
+    ]);
+    fields.push({
+      name: answers.name,
+      type: fieldDetails.type,
+      isOptional: fieldDetails.isOptional,
+      isUnique: fieldDetails.isUnique,
+      isArray: fieldDetails.isArray
+    });
+    console.log(`  \u2713 Added: ${answers.name}: ${fieldDetails.type}
+`);
+  }
+  return fields;
+}
+
+// src/cli/commands/add-module.ts
+var import_commander3 = require("commander");
+var import_path4 = __toESM(require("path"), 1);
+var import_ora3 = __toESM(require("ora"), 1);
+var import_chalk4 = __toESM(require("chalk"), 1);
+var fs5 = __toESM(require("fs/promises"), 1);
+
+// src/cli/utils/env-manager.ts
+var fs3 = __toESM(require("fs/promises"), 1);
+var path4 = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var EnvManager = class {
+  envPath;
+  envExamplePath;
+  constructor(projectRoot) {
+    this.envPath = path4.join(projectRoot, ".env");
+    this.envExamplePath = path4.join(projectRoot, ".env.example");
+  }
+  /**
+   * Add environment variables to .env file
+   */
+  async addVariables(sections) {
+    const added = [];
+    const skipped = [];
+    let created = false;
+    let envContent = "";
+    if ((0, import_fs.existsSync)(this.envPath)) {
+      envContent = await fs3.readFile(this.envPath, "utf-8");
+    } else {
+      created = true;
+    }
+    const existingKeys = this.parseExistingKeys(envContent);
+    let newContent = envContent;
+    if (newContent && !newContent.endsWith("\n\n")) {
+      newContent += "\n\n";
+    }
+    for (const section of sections) {
+      newContent += `# ${section.title}
+`;
+      for (const variable of section.variables) {
+        if (existingKeys.has(variable.key)) {
+          skipped.push(variable.key);
+          continue;
+        }
+        if (variable.comment) {
+          newContent += `# ${variable.comment}
+`;
+        }
+        const value = variable.value || "";
+        const prefix = variable.required ? "" : "# ";
+        newContent += `${prefix}${variable.key}=${value}
+`;
+        added.push(variable.key);
+      }
+      newContent += "\n";
+    }
+    await fs3.writeFile(this.envPath, newContent, "utf-8");
+    if ((0, import_fs.existsSync)(this.envExamplePath)) {
+      await this.updateEnvExample(sections);
+    }
+    return { added, skipped, created };
+  }
+  /**
+   * Update .env.example file
+   */
+  async updateEnvExample(sections) {
+    let exampleContent = "";
+    if ((0, import_fs.existsSync)(this.envExamplePath)) {
+      exampleContent = await fs3.readFile(this.envExamplePath, "utf-8");
+    }
+    const existingKeys = this.parseExistingKeys(exampleContent);
+    let newContent = exampleContent;
+    if (newContent && !newContent.endsWith("\n\n")) {
+      newContent += "\n\n";
+    }
+    for (const section of sections) {
+      newContent += `# ${section.title}
+`;
+      for (const variable of section.variables) {
+        if (existingKeys.has(variable.key)) {
+          continue;
+        }
+        if (variable.comment) {
+          newContent += `# ${variable.comment}
+`;
+        }
+        const placeholder = this.getPlaceholder(variable.key);
+        newContent += `${variable.key}=${placeholder}
+`;
+      }
+      newContent += "\n";
+    }
+    await fs3.writeFile(this.envExamplePath, newContent, "utf-8");
+  }
+  /**
+   * Parse existing environment variable keys
+   */
+  parseExistingKeys(content) {
+    const keys = /* @__PURE__ */ new Set();
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        continue;
+      }
+      const match = trimmed.match(/^#?\s*([A-Z_][A-Z0-9_]*)\s*=/);
+      if (match && match[1]) {
+        keys.add(match[1]);
+      }
+    }
+    return keys;
+  }
+  /**
+   * Get placeholder value for .env.example
+   */
+  getPlaceholder(key) {
+    if (key.includes("SECRET") || key.includes("KEY") || key.includes("PASSWORD")) {
+      return "your-secret-key-here";
+    }
+    if (key.includes("HOST")) {
+      return "localhost";
+    }
+    if (key.includes("PORT")) {
+      return "3000";
+    }
+    if (key.includes("URL")) {
+      return "http://localhost:3000";
+    }
+    if (key.includes("EMAIL")) {
+      return "user@example.com";
+    }
+    if (key.includes("REDIS")) {
+      return "redis://localhost:6379";
+    }
+    if (key.includes("DATABASE")) {
+      return "postgresql://user:pass@localhost:5432/db";
+    }
+    if (key.includes("NODE")) {
+      return "http://localhost:9200";
+    }
+    return "";
+  }
+  /**
+   * Get environment variables for a specific module
+   */
+  static getModuleEnvVariables(moduleName) {
+    const moduleEnvMap = {
+      "rate-limit": [
+        {
+          title: "Rate Limiting Configuration",
+          variables: [
+            {
+              key: "RATE_LIMIT_ENABLED",
+              value: "true",
+              comment: "Enable rate limiting",
+              required: true
+            },
+            {
+              key: "RATE_LIMIT_REDIS_URL",
+              value: "redis://localhost:6379",
+              comment: "Redis URL for distributed rate limiting (optional, uses in-memory if not set)",
+              required: false
+            }
+          ]
+        }
+      ],
+      webhook: [
+        {
+          title: "Webhook Configuration",
+          variables: [
+            {
+              key: "WEBHOOK_TIMEOUT",
+              value: "10000",
+              comment: "Webhook request timeout in milliseconds",
+              required: true
+            },
+            {
+              key: "WEBHOOK_MAX_RETRIES",
+              value: "5",
+              comment: "Maximum number of retry attempts",
+              required: true
+            },
+            {
+              key: "WEBHOOK_SIGNATURE_ENABLED",
+              value: "true",
+              comment: "Enable HMAC signature verification",
+              required: true
+            }
+          ]
+        }
+      ],
+      queue: [
+        {
+          title: "Queue/Jobs Configuration",
+          variables: [
+            {
+              key: "REDIS_HOST",
+              value: "localhost",
+              comment: "Redis host for Bull queue",
+              required: true
+            },
+            {
+              key: "REDIS_PORT",
+              value: "6379",
+              comment: "Redis port",
+              required: true
+            },
+            {
+              key: "REDIS_PASSWORD",
+              value: "",
+              comment: "Redis password (optional)",
+              required: false
+            },
+            {
+              key: "QUEUE_METRICS_ENABLED",
+              value: "true",
+              comment: "Enable queue metrics collection",
+              required: true
+            }
+          ]
+        }
+      ],
+      websocket: [
+        {
+          title: "WebSocket Configuration",
+          variables: [
+            {
+              key: "WEBSOCKET_PORT",
+              value: "3001",
+              comment: "WebSocket server port",
+              required: true
+            },
+            {
+              key: "WEBSOCKET_CORS_ORIGIN",
+              value: "http://localhost:3000",
+              comment: "CORS origin for WebSocket",
+              required: true
+            },
+            {
+              key: "WEBSOCKET_REDIS_URL",
+              value: "redis://localhost:6379",
+              comment: "Redis URL for Socket.io adapter (optional, for multi-instance)",
+              required: false
+            }
+          ]
+        }
+      ],
+      search: [
+        {
+          title: "Search Configuration (Elasticsearch)",
+          variables: [
+            {
+              key: "SEARCH_ENGINE",
+              value: "memory",
+              comment: "Search engine: elasticsearch, meilisearch, or memory",
+              required: true
+            },
+            {
+              key: "ELASTICSEARCH_NODE",
+              value: "http://localhost:9200",
+              comment: "Elasticsearch node URL",
+              required: false
+            },
+            {
+              key: "ELASTICSEARCH_USERNAME",
+              value: "",
+              comment: "Elasticsearch username (optional)",
+              required: false
+            },
+            {
+              key: "ELASTICSEARCH_PASSWORD",
+              value: "",
+              comment: "Elasticsearch password (optional)",
+              required: false
+            }
+          ]
+        },
+        {
+          title: "Search Configuration (Meilisearch)",
+          variables: [
+            {
+              key: "MEILISEARCH_HOST",
+              value: "http://localhost:7700",
+              comment: "Meilisearch host URL",
+              required: false
+            },
+            {
+              key: "MEILISEARCH_API_KEY",
+              value: "",
+              comment: "Meilisearch API key (optional)",
+              required: false
+            }
+          ]
+        }
+      ],
+      i18n: [
+        {
+          title: "i18n/Localization Configuration",
+          variables: [
+            {
+              key: "DEFAULT_LOCALE",
+              value: "en",
+              comment: "Default locale/language",
+              required: true
+            },
+            {
+              key: "SUPPORTED_LOCALES",
+              value: "en,fr,es,de,ar,zh,ja",
+              comment: "Comma-separated list of supported locales",
+              required: true
+            },
+            {
+              key: "TRANSLATIONS_DIR",
+              value: "./locales",
+              comment: "Directory for translation files",
+              required: true
+            },
+            {
+              key: "I18N_CACHE_ENABLED",
+              value: "true",
+              comment: "Enable translation caching",
+              required: true
+            }
+          ]
+        }
+      ],
+      cache: [
+        {
+          title: "Cache Configuration",
+          variables: [
+            {
+              key: "CACHE_PROVIDER",
+              value: "redis",
+              comment: "Cache provider: redis or memory",
+              required: true
+            },
+            {
+              key: "CACHE_REDIS_URL",
+              value: "redis://localhost:6379",
+              comment: "Redis URL for cache",
+              required: false
+            },
+            {
+              key: "CACHE_TTL",
+              value: "3600",
+              comment: "Default cache TTL in seconds",
+              required: true
+            }
+          ]
+        }
+      ],
+      mfa: [
+        {
+          title: "MFA/TOTP Configuration",
+          variables: [
+            {
+              key: "MFA_ISSUER",
+              value: "MyApp",
+              comment: "MFA issuer name shown in authenticator apps",
+              required: true
+            },
+            {
+              key: "MFA_ALGORITHM",
+              value: "SHA1",
+              comment: "TOTP algorithm: SHA1, SHA256, or SHA512",
+              required: true
+            }
+          ]
+        }
+      ],
+      oauth: [
+        {
+          title: "OAuth Configuration",
+          variables: [
+            {
+              key: "OAUTH_GOOGLE_CLIENT_ID",
+              value: "",
+              comment: "Google OAuth client ID",
+              required: false
+            },
+            {
+              key: "OAUTH_GOOGLE_CLIENT_SECRET",
+              value: "",
+              comment: "Google OAuth client secret",
+              required: false
+            },
+            {
+              key: "OAUTH_GITHUB_CLIENT_ID",
+              value: "",
+              comment: "GitHub OAuth client ID",
+              required: false
+            },
+            {
+              key: "OAUTH_GITHUB_CLIENT_SECRET",
+              value: "",
+              comment: "GitHub OAuth client secret",
+              required: false
+            },
+            {
+              key: "OAUTH_REDIRECT_URL",
+              value: "http://localhost:3000/auth/callback",
+              comment: "OAuth callback URL",
+              required: true
+            }
+          ]
+        }
+      ],
+      payment: [
+        {
+          title: "Payment Configuration",
+          variables: [
+            {
+              key: "STRIPE_SECRET_KEY",
+              value: "",
+              comment: "Stripe secret key",
+              required: false
+            },
+            {
+              key: "STRIPE_PUBLISHABLE_KEY",
+              value: "",
+              comment: "Stripe publishable key",
+              required: false
+            },
+            {
+              key: "PAYPAL_CLIENT_ID",
+              value: "",
+              comment: "PayPal client ID",
+              required: false
+            },
+            {
+              key: "PAYPAL_CLIENT_SECRET",
+              value: "",
+              comment: "PayPal client secret",
+              required: false
+            },
+            {
+              key: "PAYPAL_MODE",
+              value: "sandbox",
+              comment: "PayPal mode: sandbox or live",
+              required: false
+            }
+          ]
+        }
+      ],
+      "feature-flag": [
+        {
+          title: "Feature Flags Configuration",
+          variables: [
+            {
+              key: "FEATURE_FLAGS_ENABLED",
+              value: "true",
+              comment: "Enable feature flags",
+              required: true
+            },
+            {
+              key: "FEATURE_FLAGS_ENVIRONMENT",
+              value: "development",
+              comment: "Feature flags environment: development, staging, production, test",
+              required: true
+            },
+            {
+              key: "FEATURE_FLAGS_ANALYTICS",
+              value: "true",
+              comment: "Enable feature flag analytics",
+              required: true
+            },
+            {
+              key: "FEATURE_FLAGS_CACHE_TTL",
+              value: "300",
+              comment: "Cache TTL in seconds",
+              required: true
+            }
+          ]
+        }
+      ],
+      upload: [
+        {
+          title: "File Upload Configuration",
+          variables: [
+            {
+              key: "UPLOAD_PROVIDER",
+              value: "local",
+              comment: "Upload provider: local, s3, cloudinary",
+              required: true
+            },
+            {
+              key: "UPLOAD_MAX_SIZE",
+              value: "10485760",
+              comment: "Max upload size in bytes (10MB)",
+              required: true
+            },
+            {
+              key: "UPLOAD_DIR",
+              value: "./uploads",
+              comment: "Local upload directory",
+              required: true
+            },
+            {
+              key: "AWS_ACCESS_KEY_ID",
+              value: "",
+              comment: "AWS access key for S3",
+              required: false
+            },
+            {
+              key: "AWS_SECRET_ACCESS_KEY",
+              value: "",
+              comment: "AWS secret key for S3",
+              required: false
+            },
+            {
+              key: "AWS_S3_BUCKET",
+              value: "",
+              comment: "S3 bucket name",
+              required: false
+            }
+          ]
+        }
+      ],
+      notification: [
+        {
+          title: "Notification Configuration",
+          variables: [
+            {
+              key: "NOTIFICATION_EMAIL_ENABLED",
+              value: "true",
+              comment: "Enable email notifications",
+              required: true
+            },
+            {
+              key: "NOTIFICATION_SMS_ENABLED",
+              value: "false",
+              comment: "Enable SMS notifications",
+              required: false
+            },
+            {
+              key: "NOTIFICATION_PUSH_ENABLED",
+              value: "false",
+              comment: "Enable push notifications",
+              required: false
+            },
+            {
+              key: "TWILIO_ACCOUNT_SID",
+              value: "",
+              comment: "Twilio account SID for SMS",
+              required: false
+            },
+            {
+              key: "TWILIO_AUTH_TOKEN",
+              value: "",
+              comment: "Twilio auth token",
+              required: false
+            }
+          ]
+        }
+      ],
+      analytics: [
+        {
+          title: "Analytics/Metrics Configuration",
+          variables: [
+            {
+              key: "ANALYTICS_ENABLED",
+              value: "true",
+              comment: "Enable analytics and metrics collection",
+              required: true
+            },
+            {
+              key: "ANALYTICS_PREFIX",
+              value: "app",
+              comment: "Metrics prefix",
+              required: true
+            },
+            {
+              key: "PROMETHEUS_ENABLED",
+              value: "true",
+              comment: "Enable Prometheus metrics endpoint",
+              required: true
+            },
+            {
+              key: "METRICS_FLUSH_INTERVAL",
+              value: "60000",
+              comment: "Metrics flush interval in milliseconds",
+              required: true
+            }
+          ]
+        }
+      ],
+      "media-processing": [
+        {
+          title: "Media Processing Configuration",
+          variables: [
+            {
+              key: "FFMPEG_PATH",
+              value: "ffmpeg",
+              comment: "Path to FFmpeg binary",
+              required: true
+            },
+            {
+              key: "FFPROBE_PATH",
+              value: "ffprobe",
+              comment: "Path to FFprobe binary",
+              required: true
+            },
+            {
+              key: "MEDIA_TEMP_DIR",
+              value: "./temp/media",
+              comment: "Temporary directory for media processing",
+              required: true
+            },
+            {
+              key: "MEDIA_MAX_CONCURRENT",
+              value: "3",
+              comment: "Maximum concurrent processing jobs",
+              required: true
+            },
+            {
+              key: "MEDIA_GPU_ACCELERATION",
+              value: "false",
+              comment: "Enable GPU acceleration (requires NVIDIA GPU)",
+              required: false
+            }
+          ]
+        }
+      ],
+      "api-versioning": [
+        {
+          title: "API Versioning Configuration",
+          variables: [
+            {
+              key: "API_VERSION_STRATEGY",
+              value: "url",
+              comment: "Versioning strategy: url, header, query, accept-header",
+              required: true
+            },
+            {
+              key: "API_DEFAULT_VERSION",
+              value: "v1",
+              comment: "Default API version",
+              required: true
+            },
+            {
+              key: "API_VERSION_HEADER",
+              value: "X-API-Version",
+              comment: "Header name for version (if strategy is header)",
+              required: false
+            },
+            {
+              key: "API_VERSION_STRICT",
+              value: "true",
+              comment: "Strict mode - reject unknown versions",
+              required: true
+            },
+            {
+              key: "API_DEPRECATION_WARNINGS",
+              value: "true",
+              comment: "Show deprecation warnings in headers",
+              required: true
+            }
+          ]
+        }
+      ]
+    };
+    return moduleEnvMap[moduleName] || [];
+  }
+};
+
+// src/cli/utils/template-manager.ts
+var fs4 = __toESM(require("fs/promises"), 1);
+var path5 = __toESM(require("path"), 1);
+var import_crypto = require("crypto");
+var import_fs2 = require("fs");
+var TemplateManager = class {
+  templatesDir;
+  manifestsDir;
+  constructor(projectRoot) {
+    this.templatesDir = path5.join(projectRoot, ".servcraft", "templates");
+    this.manifestsDir = path5.join(projectRoot, ".servcraft", "manifests");
+  }
+  /**
+   * Initialize template system
+   */
+  async initialize() {
+    await fs4.mkdir(this.templatesDir, { recursive: true });
+    await fs4.mkdir(this.manifestsDir, { recursive: true });
+  }
+  /**
+   * Save module template
+   */
+  async saveTemplate(moduleName, files) {
+    await this.initialize();
+    const moduleTemplateDir = path5.join(this.templatesDir, moduleName);
+    await fs4.mkdir(moduleTemplateDir, { recursive: true });
+    for (const [fileName, content] of Object.entries(files)) {
+      const filePath = path5.join(moduleTemplateDir, fileName);
+      await fs4.writeFile(filePath, content, "utf-8");
+    }
+  }
+  /**
+   * Get template content
+   */
+  async getTemplate(moduleName, fileName) {
+    try {
+      const filePath = path5.join(this.templatesDir, moduleName, fileName);
+      return await fs4.readFile(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Save module manifest
+   */
+  async saveManifest(moduleName, files) {
+    await this.initialize();
+    const fileHashes = {};
+    for (const [fileName, content] of Object.entries(files)) {
+      fileHashes[fileName] = {
+        hash: this.hashContent(content),
+        path: `src/modules/${moduleName}/${fileName}`
+      };
+    }
+    const manifest = {
+      name: moduleName,
+      version: "1.0.0",
+      files: fileHashes,
+      installedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const manifestPath = path5.join(this.manifestsDir, `${moduleName}.json`);
+    await fs4.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  }
+  /**
+   * Get module manifest
+   */
+  async getManifest(moduleName) {
+    try {
+      const manifestPath = path5.join(this.manifestsDir, `${moduleName}.json`);
+      const content = await fs4.readFile(manifestPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
   }
-});
-generateCommand.command("schema <name>").alias("v").description("Generate validation schemas").option("-m, --module <module>", "Target module name").action(async (name, options) => {
-  const spinner = (0, import_ora3.default)("Generating schemas...").start();
-  try {
-    const kebabName = toKebabCase(name);
-    const pascalName = toPascalCase(name);
-    const camelName = toCamelCase(name);
-    const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = import_path4.default.join(getModulesDir(), moduleName);
-    const filePath = import_path4.default.join(moduleDir, `${kebabName}.schemas.ts`);
-    if (await fileExists(filePath)) {
-      spinner.stop();
-      error(`Schemas file "${kebabName}.schemas.ts" already exists`);
-      return;
+  /**
+   * Check if file has been modified by user
+   */
+  async isFileModified(moduleName, fileName, currentContent) {
+    const manifest = await this.getManifest(moduleName);
+    if (!manifest || !manifest.files[fileName]) {
+      return false;
+    }
+    const originalHash = manifest.files[fileName].hash;
+    const currentHash = this.hashContent(currentContent);
+    return originalHash !== currentHash;
+  }
+  /**
+   * Get all modified files in a module
+   */
+  async getModifiedFiles(moduleName, moduleDir) {
+    const manifest = await this.getManifest(moduleName);
+    if (!manifest) {
+      return [];
+    }
+    const results = [];
+    for (const [fileName, fileInfo] of Object.entries(manifest.files)) {
+      const filePath = path5.join(moduleDir, fileName);
+      if (!(0, import_fs2.existsSync)(filePath)) {
+        results.push({
+          fileName,
+          isModified: true,
+          originalHash: fileInfo.hash,
+          currentHash: ""
+        });
+        continue;
+      }
+      const currentContent = await fs4.readFile(filePath, "utf-8");
+      const currentHash = this.hashContent(currentContent);
+      results.push({
+        fileName,
+        isModified: fileInfo.hash !== currentHash,
+        originalHash: fileInfo.hash,
+        currentHash
+      });
+    }
+    return results;
+  }
+  /**
+   * Create backup of module
+   */
+  async createBackup(moduleName, moduleDir) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
+    const backupDir = path5.join(path5.dirname(moduleDir), `${moduleName}.backup-${timestamp}`);
+    await this.copyDirectory(moduleDir, backupDir);
+    return backupDir;
+  }
+  /**
+   * Copy directory recursively
+   */
+  async copyDirectory(src, dest) {
+    await fs4.mkdir(dest, { recursive: true });
+    const entries = await fs4.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path5.join(src, entry.name);
+      const destPath = path5.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        await this.copyDirectory(srcPath, destPath);
+      } else {
+        await fs4.copyFile(srcPath, destPath);
+      }
     }
-    await writeFile(filePath, schemasTemplate(kebabName, pascalName, camelName));
-    spinner.succeed(`Schemas for "${pascalName}" generated!`);
-    success(`  src/modules/${moduleName}/${kebabName}.schemas.ts`);
-  } catch (err) {
-    spinner.fail("Failed to generate schemas");
-    error(err instanceof Error ? err.message : String(err));
   }
-});
-generateCommand.command("routes <name>").description("Generate routes").option("-m, --module <module>", "Target module name").action(async (name, options) => {
-  const spinner = (0, import_ora3.default)("Generating routes...").start();
-  try {
-    const kebabName = toKebabCase(name);
-    const pascalName = toPascalCase(name);
-    const camelName = toCamelCase(name);
-    const pluralName = pluralize(kebabName);
-    const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = import_path4.default.join(getModulesDir(), moduleName);
-    const filePath = import_path4.default.join(moduleDir, `${kebabName}.routes.ts`);
-    if (await fileExists(filePath)) {
-      spinner.stop();
-      error(`Routes file "${kebabName}.routes.ts" already exists`);
+  /**
+   * Perform 3-way merge
+   */
+  async mergeFiles(original, modified, incoming) {
+    const conflicts = [];
+    let hasConflicts = false;
+    const originalLines = original.split("\n");
+    const modifiedLines = modified.split("\n");
+    const incomingLines = incoming.split("\n");
+    const merged = [];
+    const maxLength = Math.max(originalLines.length, modifiedLines.length, incomingLines.length);
+    for (let i = 0; i < maxLength; i++) {
+      const origLine = originalLines[i] || "";
+      const modLine = modifiedLines[i] || "";
+      const incLine = incomingLines[i] || "";
+      if (modLine === origLine) {
+        merged.push(incLine);
+      } else if (incLine === origLine) {
+        merged.push(modLine);
+      } else if (modLine === incLine) {
+        merged.push(modLine);
+      } else {
+        hasConflicts = true;
+        conflicts.push(`Line ${i + 1}: User and template both modified`);
+        merged.push(`<<<<<<< YOUR VERSION`);
+        merged.push(modLine);
+        merged.push(`=======`);
+        merged.push(incLine);
+        merged.push(`>>>>>>> NEW VERSION`);
+      }
+    }
+    return {
+      merged: merged.join("\n"),
+      hasConflicts,
+      conflicts
+    };
+  }
+  /**
+   * Generate diff between two files
+   */
+  generateDiff(original, modified) {
+    const originalLines = original.split("\n");
+    const modifiedLines = modified.split("\n");
+    const diff = [];
+    diff.push("--- Original");
+    diff.push("+++ Modified");
+    diff.push("");
+    const maxLength = Math.max(originalLines.length, modifiedLines.length);
+    for (let i = 0; i < maxLength; i++) {
+      const origLine = originalLines[i];
+      const modLine = modifiedLines[i];
+      if (origLine !== modLine) {
+        if (origLine !== void 0) {
+          diff.push(`- ${origLine}`);
+        }
+        if (modLine !== void 0) {
+          diff.push(`+ ${modLine}`);
+        }
+      }
+    }
+    return diff.join("\n");
+  }
+  /**
+   * Hash content for change detection
+   */
+  hashContent(content) {
+    return (0, import_crypto.createHash)("md5").update(content).digest("hex");
+  }
+  /**
+   * Check if module is installed
+   */
+  async isModuleInstalled(moduleName) {
+    const manifest = await this.getManifest(moduleName);
+    return manifest !== null;
+  }
+  /**
+   * Update manifest after merge
+   */
+  async updateManifest(moduleName, files) {
+    const manifest = await this.getManifest(moduleName);
+    if (!manifest) {
+      await this.saveManifest(moduleName, files);
       return;
     }
-    await writeFile(filePath, routesTemplate(kebabName, pascalName, camelName, pluralName));
-    spinner.succeed(`Routes for "${pascalName}" generated!`);
-    success(`  src/modules/${moduleName}/${kebabName}.routes.ts`);
-  } catch (err) {
-    spinner.fail("Failed to generate routes");
-    error(err instanceof Error ? err.message : String(err));
+    const fileHashes = {};
+    for (const [fileName, content] of Object.entries(files)) {
+      fileHashes[fileName] = {
+        hash: this.hashContent(content),
+        path: `src/modules/${moduleName}/${fileName}`
+      };
+    }
+    manifest.files = fileHashes;
+    manifest.updatedAt = /* @__PURE__ */ new Date();
+    const manifestPath = path5.join(this.manifestsDir, `${moduleName}.json`);
+    await fs4.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   }
-});
-async function promptForFields() {
-  const fields = [];
-  console.log("\n\u{1F4DD} Define your model fields (press Enter with empty name to finish)\n");
-  const fieldTypes = [
-    "string",
-    "number",
-    "boolean",
-    "date",
-    "datetime",
-    "text",
-    "email",
-    "url",
-    "uuid",
-    "int",
-    "float",
-    "decimal",
-    "json"
-  ];
-  let addMore = true;
-  while (addMore) {
-    const answers = await import_inquirer2.default.prompt([
+};
+
+// src/cli/utils/interactive-prompt.ts
+var import_inquirer3 = __toESM(require("inquirer"), 1);
+var import_chalk3 = __toESM(require("chalk"), 1);
+var InteractivePrompt = class {
+  /**
+   * Ask what to do when module already exists
+   */
+  static async askModuleExists(moduleName, hasModifications) {
+    console.log(import_chalk3.default.yellow(`
+\u26A0\uFE0F  Module "${moduleName}" already exists`));
+    if (hasModifications) {
+      console.log(import_chalk3.default.yellow("   Some files have been modified by you.\n"));
+    }
+    const { action } = await import_inquirer3.default.prompt([
       {
-        type: "input",
-        name: "name",
-        message: "Field name (empty to finish):"
+        type: "list",
+        name: "action",
+        message: "What would you like to do?",
+        choices: [
+          {
+            name: "\u2713 Skip (keep existing files, recommended if you made custom changes)",
+            value: "skip"
+          },
+          {
+            name: "\u21BB Update (merge new features, preserve your customizations)",
+            value: "update"
+          },
+          {
+            name: "\u26A0  Overwrite (replace all files, will lose your changes)",
+            value: "overwrite"
+          },
+          {
+            name: "\u{1F4CB} Show diff (see what changed)",
+            value: "diff"
+          },
+          {
+            name: "\u{1F4BE} Backup & overwrite (save backup then replace)",
+            value: "backup-overwrite"
+          }
+        ],
+        default: "skip"
       }
     ]);
-    if (!answers.name) {
-      addMore = false;
-      continue;
-    }
-    const fieldDetails = await import_inquirer2.default.prompt([
+    return { action };
+  }
+  /**
+   * Ask what to do with a specific file
+   */
+  static async askFileAction(fileName, isModified, yourLines, newLines) {
+    console.log(import_chalk3.default.cyan(`
+\u{1F4C1} ${fileName}`));
+    console.log(
+      import_chalk3.default.gray(`   Your version: ${yourLines} lines${isModified ? " (modified)" : ""}`)
+    );
+    console.log(import_chalk3.default.gray(`   New version: ${newLines} lines
+`));
+    const { action } = await import_inquirer3.default.prompt([
       {
         type: "list",
-        name: "type",
-        message: `Type for "${answers.name}":`,
-        choices: fieldTypes,
-        default: "string"
-      },
-      {
-        type: "confirm",
-        name: "isOptional",
-        message: "Is optional?",
-        default: false
-      },
-      {
-        type: "confirm",
-        name: "isUnique",
-        message: "Is unique?",
-        default: false
-      },
+        name: "action",
+        message: "Action for this file:",
+        choices: [
+          {
+            name: "[M]erge - Smart merge, preserve your changes",
+            value: "merge"
+          },
+          {
+            name: "[K]eep - Keep your version (skip update)",
+            value: "keep"
+          },
+          {
+            name: "[O]verwrite - Use new version",
+            value: "overwrite"
+          },
+          {
+            name: "[D]iff - Show differences",
+            value: "diff"
+          },
+          {
+            name: "[S]kip - Skip this file",
+            value: "skip"
+          }
+        ],
+        default: isModified ? "merge" : "overwrite"
+      }
+    ]);
+    return { action };
+  }
+  /**
+   * Confirm action
+   */
+  static async confirm(message, defaultValue = false) {
+    const { confirmed } = await import_inquirer3.default.prompt([
       {
         type: "confirm",
-        name: "isArray",
-        message: "Is array?",
-        default: false
+        name: "confirmed",
+        message,
+        default: defaultValue
       }
     ]);
-    fields.push({
-      name: answers.name,
-      type: fieldDetails.type,
-      isOptional: fieldDetails.isOptional,
-      isUnique: fieldDetails.isUnique,
-      isArray: fieldDetails.isArray
+    return confirmed;
+  }
+  /**
+   * Display diff and ask to continue
+   */
+  static async showDiffAndAsk(diff) {
+    console.log(import_chalk3.default.cyan("\n\u{1F4CA} Differences:\n"));
+    console.log(diff);
+    return await this.confirm("\nDo you want to proceed with this change?", true);
+  }
+  /**
+   * Display merge conflicts
+   */
+  static displayConflicts(conflicts) {
+    console.log(import_chalk3.default.red("\n\u26A0\uFE0F  Merge Conflicts Detected:\n"));
+    conflicts.forEach((conflict, i) => {
+      console.log(import_chalk3.default.yellow(`   ${i + 1}. ${conflict}`));
     });
-    console.log(`  \u2713 Added: ${answers.name}: ${fieldDetails.type}
-`);
+    console.log(import_chalk3.default.gray("\n   Conflict markers have been added to the file:"));
+    console.log(import_chalk3.default.gray("   <<<<<<< YOUR VERSION"));
+    console.log(import_chalk3.default.gray("   ... your code ..."));
+    console.log(import_chalk3.default.gray("   ======="));
+    console.log(import_chalk3.default.gray("   ... new code ..."));
+    console.log(import_chalk3.default.gray("   >>>>>>> NEW VERSION\n"));
+  }
+  /**
+   * Show backup location
+   */
+  static showBackupCreated(backupPath) {
+    console.log(import_chalk3.default.green(`
+\u2713 Backup created: ${import_chalk3.default.cyan(backupPath)}`));
+  }
+  /**
+   * Show merge summary
+   */
+  static showMergeSummary(stats) {
+    console.log(import_chalk3.default.bold("\n\u{1F4CA} Merge Summary:\n"));
+    if (stats.merged > 0) {
+      console.log(import_chalk3.default.green(`   \u2713 Merged: ${stats.merged} file(s)`));
+    }
+    if (stats.kept > 0) {
+      console.log(import_chalk3.default.blue(`   \u2192 Kept: ${stats.kept} file(s)`));
+    }
+    if (stats.overwritten > 0) {
+      console.log(import_chalk3.default.yellow(`   \u26A0 Overwritten: ${stats.overwritten} file(s)`));
+    }
+    if (stats.conflicts > 0) {
+      console.log(import_chalk3.default.red(`   \u26A0 Conflicts: ${stats.conflicts} file(s)`));
+      console.log(import_chalk3.default.gray("\n   Please resolve conflicts manually before committing.\n"));
+    }
+  }
+  /**
+   * Ask for batch action on all files
+   */
+  static async askBatchAction() {
+    const { action } = await import_inquirer3.default.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "Multiple files found. Choose action:",
+        choices: [
+          {
+            name: "Ask for each file individually (recommended)",
+            value: "individual"
+          },
+          {
+            name: "Merge all files automatically",
+            value: "merge-all"
+          },
+          {
+            name: "Keep all existing files (skip update)",
+            value: "keep-all"
+          },
+          {
+            name: "Overwrite all files with new versions",
+            value: "overwrite-all"
+          }
+        ],
+        default: "individual"
+      }
+    ]);
+    return action;
   }
-  return fields;
-}
+};
 
 // src/cli/commands/add-module.ts
-var import_commander3 = require("commander");
-var import_path5 = __toESM(require("path"), 1);
-var import_ora4 = __toESM(require("ora"), 1);
-var import_chalk3 = __toESM(require("chalk"), 1);
 var AVAILABLE_MODULES = {
   auth: {
     name: "Authentication",
     description: "JWT authentication with access/refresh tokens",
-    files: ["auth.service", "auth.controller", "auth.routes", "auth.middleware", "auth.schemas", "auth.types", "index"]
+    files: [
+      "auth.service",
+      "auth.controller",
+      "auth.routes",
+      "auth.middleware",
+      "auth.schemas",
+      "auth.types",
+      "index"
+    ]
   },
   users: {
     name: "User Management",
     description: "User CRUD with RBAC (roles & permissions)",
-    files: ["user.service", "user.controller", "user.repository", "user.routes", "user.schemas", "user.types", "index"]
+    files: [
+      "user.service",
+      "user.controller",
+      "user.repository",
+      "user.routes",
+      "user.schemas",
+      "user.types",
+      "index"
+    ]
   },
   email: {
     name: "Email Service",
@@ -3491,91 +3065,222 @@ var AVAILABLE_MODULES = {
     description: "Activity logging and audit trail",
     files: ["audit.service", "audit.types", "index"]
   },
-  upload: {
-    name: "File Upload",
-    description: "File upload with local/S3 storage",
-    files: ["upload.service", "upload.controller", "upload.routes", "upload.types", "index"]
-  },
   cache: {
     name: "Redis Cache",
-    description: "Redis caching service",
+    description: "Redis caching with TTL & invalidation",
     files: ["cache.service", "cache.types", "index"]
   },
-  notifications: {
+  upload: {
+    name: "File Upload",
+    description: "File upload with local/S3/Cloudinary storage",
+    files: ["upload.service", "upload.routes", "upload.types", "index"]
+  },
+  mfa: {
+    name: "MFA/TOTP",
+    description: "Two-factor authentication with QR codes",
+    files: ["mfa.service", "mfa.routes", "totp.ts", "types.ts", "index"]
+  },
+  oauth: {
+    name: "OAuth",
+    description: "Social login (Google, GitHub, Facebook, Twitter, Apple)",
+    files: ["oauth.service", "oauth.routes", "providers", "types.ts", "index"]
+  },
+  payment: {
+    name: "Payments",
+    description: "Payment processing (Stripe, PayPal, Mobile Money)",
+    files: ["payment.service", "payment.routes", "providers", "types.ts", "index"]
+  },
+  notification: {
     name: "Notifications",
-    description: "In-app and push notifications",
-    files: ["notification.service", "notification.types", "index"]
+    description: "Email, SMS, Push notifications",
+    files: ["notification.service", "types.ts", "index"]
+  },
+  "rate-limit": {
+    name: "Rate Limiting",
+    description: "Advanced rate limiting with multiple algorithms",
+    files: [
+      "rate-limit.service",
+      "rate-limit.middleware",
+      "rate-limit.routes",
+      "stores",
+      "types.ts",
+      "index"
+    ]
+  },
+  webhook: {
+    name: "Webhooks",
+    description: "Outgoing webhooks with HMAC signatures & retry",
+    files: ["webhook.service", "webhook.routes", "signature.ts", "retry.ts", "types.ts", "index"]
+  },
+  queue: {
+    name: "Queue/Jobs",
+    description: "Background jobs with Bull/BullMQ & cron scheduling",
+    files: ["queue.service", "cron.ts", "workers.ts", "routes.ts", "types.ts", "index"]
+  },
+  websocket: {
+    name: "WebSockets",
+    description: "Real-time communication with Socket.io",
+    files: ["websocket.service", "features.ts", "middlewares.ts", "types.ts", "index"]
+  },
+  search: {
+    name: "Search",
+    description: "Full-text search with Elasticsearch/Meilisearch",
+    files: ["search.service", "adapters", "types.ts", "index"]
   },
-  settings: {
-    name: "Settings",
-    description: "Application settings management",
-    files: ["settings.service", "settings.controller", "settings.routes", "settings.types", "index"]
+  i18n: {
+    name: "i18n/Localization",
+    description: "Multi-language support with 7+ locales",
+    files: ["i18n.service", "i18n.middleware", "i18n.routes", "types.ts", "index"]
+  },
+  "feature-flag": {
+    name: "Feature Flags",
+    description: "A/B testing & progressive rollout",
+    files: ["feature-flag.service", "feature-flag.routes", "types.ts", "index"]
+  },
+  analytics: {
+    name: "Analytics/Metrics",
+    description: "Prometheus metrics & event tracking",
+    files: ["analytics.service", "analytics.routes", "types.ts", "index"]
+  },
+  "media-processing": {
+    name: "Media Processing",
+    description: "Image/video processing with FFmpeg",
+    files: ["media-processing.service", "media-processing.routes", "types.ts", "index"]
+  },
+  "api-versioning": {
+    name: "API Versioning",
+    description: "Multiple API versions support",
+    files: [
+      "versioning.service",
+      "versioning.middleware",
+      "versioning.routes",
+      "types.ts",
+      "index"
+    ]
   }
 };
-var addModuleCommand = new import_commander3.Command("add").description("Add a pre-built module to your project").argument("[module]", "Module to add (auth, users, email, audit, upload, cache, notifications, settings)").option("-l, --list", "List available modules").action(async (moduleName, options) => {
-  if (options?.list || !moduleName) {
-    console.log(import_chalk3.default.bold("\n\u{1F4E6} Available Modules:\n"));
-    for (const [key, mod] of Object.entries(AVAILABLE_MODULES)) {
-      console.log(`  ${import_chalk3.default.cyan(key.padEnd(15))} ${mod.name}`);
-      console.log(`  ${" ".repeat(15)} ${import_chalk3.default.gray(mod.description)}
+var addModuleCommand = new import_commander3.Command("add").description("Add a pre-built module to your project").argument(
+  "[module]",
+  "Module to add (auth, users, email, audit, upload, cache, notifications, settings)"
+).option("-l, --list", "List available modules").option("-f, --force", "Force overwrite existing module").option("-u, --update", "Update existing module (smart merge)").option("--skip-existing", "Skip if module already exists").action(
+  async (moduleName, options) => {
+    if (options?.list || !moduleName) {
+      console.log(import_chalk4.default.bold("\n\u{1F4E6} Available Modules:\n"));
+      for (const [key, mod] of Object.entries(AVAILABLE_MODULES)) {
+        console.log(`  ${import_chalk4.default.cyan(key.padEnd(15))} ${mod.name}`);
+        console.log(`  ${" ".repeat(15)} ${import_chalk4.default.gray(mod.description)}
 `);
-    }
-    console.log(import_chalk3.default.bold("Usage:"));
-    console.log(`  ${import_chalk3.default.yellow("servcraft add auth")}      Add authentication module`);
-    console.log(`  ${import_chalk3.default.yellow("servcraft add users")}     Add user management module`);
-    console.log(`  ${import_chalk3.default.yellow("servcraft add email")}     Add email service module
+      }
+      console.log(import_chalk4.default.bold("Usage:"));
+      console.log(`  ${import_chalk4.default.yellow("servcraft add auth")}      Add authentication module`);
+      console.log(`  ${import_chalk4.default.yellow("servcraft add users")}     Add user management module`);
+      console.log(`  ${import_chalk4.default.yellow("servcraft add email")}     Add email service module
 `);
-    return;
-  }
-  const module2 = AVAILABLE_MODULES[moduleName];
-  if (!module2) {
-    error(`Unknown module: ${moduleName}`);
-    info('Run "servcraft add --list" to see available modules');
-    return;
-  }
-  const spinner = (0, import_ora4.default)(`Adding ${module2.name} module...`).start();
-  try {
-    const moduleDir = import_path5.default.join(getModulesDir(), moduleName);
-    if (await fileExists(moduleDir)) {
-      spinner.stop();
-      warn(`Module "${moduleName}" already exists`);
       return;
     }
-    await ensureDir(moduleDir);
-    switch (moduleName) {
-      case "auth":
-        await generateAuthModule(moduleDir);
-        break;
-      case "users":
-        await generateUsersModule(moduleDir);
-        break;
-      case "email":
-        await generateEmailModule(moduleDir);
-        break;
-      case "audit":
-        await generateAuditModule(moduleDir);
-        break;
-      case "upload":
-        await generateUploadModule(moduleDir);
-        break;
-      case "cache":
-        await generateCacheModule(moduleDir);
-        break;
-      default:
-        await generateGenericModule(moduleDir, moduleName);
-    }
-    spinner.succeed(`${module2.name} module added successfully!`);
-    console.log("\n\u{1F4C1} Files created:");
-    module2.files.forEach((f) => success(`  src/modules/${moduleName}/${f}.ts`));
-    console.log("\n\u{1F4CC} Next steps:");
-    info("  1. Register the module in your main app file");
-    info("  2. Configure any required environment variables");
-    info("  3. Run database migrations if needed");
-  } catch (err) {
-    spinner.fail("Failed to add module");
-    error(err instanceof Error ? err.message : String(err));
+    const module2 = AVAILABLE_MODULES[moduleName];
+    if (!module2) {
+      error(`Unknown module: ${moduleName}`);
+      info('Run "servcraft add --list" to see available modules');
+      return;
+    }
+    const spinner = (0, import_ora3.default)(`Adding ${module2.name} module...`).start();
+    try {
+      const moduleDir = import_path4.default.join(getModulesDir(), moduleName);
+      const templateManager = new TemplateManager(process.cwd());
+      const moduleExists = await fileExists(moduleDir);
+      if (moduleExists) {
+        spinner.stop();
+        if (options?.skipExisting) {
+          info(`Module "${moduleName}" already exists, skipping...`);
+          return;
+        }
+        const modifiedFiles = await templateManager.getModifiedFiles(moduleName, moduleDir);
+        const hasModifications = modifiedFiles.some((f) => f.isModified);
+        let action;
+        if (options?.force) {
+          action = "overwrite";
+        } else if (options?.update) {
+          action = "update";
+        } else {
+          const choice = await InteractivePrompt.askModuleExists(moduleName, hasModifications);
+          action = choice.action;
+        }
+        if (action === "skip") {
+          info("Keeping existing module");
+          return;
+        }
+        if (action === "diff") {
+          await showDiffForModule(templateManager, moduleName, moduleDir);
+          return;
+        }
+        if (action === "backup-overwrite" || action === "overwrite") {
+          if (action === "backup-overwrite") {
+            const backupPath = await templateManager.createBackup(moduleName, moduleDir);
+            InteractivePrompt.showBackupCreated(backupPath);
+          }
+          await fs5.rm(moduleDir, { recursive: true, force: true });
+          await ensureDir(moduleDir);
+          await generateModuleFiles(moduleName, moduleDir);
+          const files = await getModuleFiles(moduleName, moduleDir);
+          await templateManager.saveTemplate(moduleName, files);
+          await templateManager.saveManifest(moduleName, files);
+          spinner.succeed(
+            `${module2.name} module ${action === "backup-overwrite" ? "backed up and " : ""}overwritten!`
+          );
+        } else if (action === "update") {
+          await performSmartMerge(templateManager, moduleName, moduleDir, module2.name);
+        }
+      } else {
+        await ensureDir(moduleDir);
+        await generateModuleFiles(moduleName, moduleDir);
+        const files = await getModuleFiles(moduleName, moduleDir);
+        await templateManager.saveTemplate(moduleName, files);
+        await templateManager.saveManifest(moduleName, files);
+        spinner.succeed(`${module2.name} module added successfully!`);
+      }
+      if (!moduleExists) {
+        console.log("\n\u{1F4C1} Files created:");
+        module2.files.forEach((f) => success(`  src/modules/${moduleName}/${f}.ts`));
+      }
+      const envManager = new EnvManager(process.cwd());
+      const envSections = EnvManager.getModuleEnvVariables(moduleName);
+      if (envSections.length > 0) {
+        const envSpinner = (0, import_ora3.default)("Updating environment variables...").start();
+        try {
+          const result = await envManager.addVariables(envSections);
+          envSpinner.succeed("Environment variables updated!");
+          if (result.created) {
+            info("\n\u{1F4DD} Created new .env file");
+          }
+          if (result.added.length > 0) {
+            console.log(import_chalk4.default.bold("\n\u2705 Added to .env:"));
+            result.added.forEach((key) => success(`  ${key}`));
+          }
+          if (result.skipped.length > 0) {
+            console.log(import_chalk4.default.bold("\n\u23ED\uFE0F  Already in .env (skipped):"));
+            result.skipped.forEach((key) => info(`  ${key}`));
+          }
+          const requiredVars = envSections.flatMap((section) => section.variables).filter((v) => v.required && !v.value).map((v) => v.key);
+          if (requiredVars.length > 0) {
+            console.log(import_chalk4.default.bold("\n\u26A0\uFE0F  Required configuration:"));
+            requiredVars.forEach((key) => warn(`  ${key} - Please configure this variable`));
+          }
+        } catch (err) {
+          envSpinner.fail("Failed to update environment variables");
+          error(err instanceof Error ? err.message : String(err));
+        }
+      }
+      console.log("\n\u{1F4CC} Next steps:");
+      info("  1. Configure environment variables in .env (if needed)");
+      info("  2. Register the module in your main app file");
+      info("  3. Run database migrations if needed");
+    } catch (err) {
+      spinner.fail("Failed to add module");
+      error(err instanceof Error ? err.message : String(err));
+    }
   }
-});
+);
 async function generateAuthModule(dir) {
   const files = {
     "auth.types.ts": `export interface JwtPayload {
@@ -3620,7 +3325,7 @@ export * from './auth.schemas.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(import_path5.default.join(dir, name), content);
+    await writeFile(import_path4.default.join(dir, name), content);
   }
 }
 async function generateUsersModule(dir) {
@@ -3660,7 +3365,7 @@ export * from './user.schemas.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(import_path5.default.join(dir, name), content);
+    await writeFile(import_path4.default.join(dir, name), content);
   }
 }
 async function generateEmailModule(dir) {
@@ -3717,7 +3422,7 @@ export { EmailService, emailService } from './email.service.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(import_path5.default.join(dir, name), content);
+    await writeFile(import_path4.default.join(dir, name), content);
   }
 }
 async function generateAuditModule(dir) {
@@ -3761,7 +3466,7 @@ export { AuditService, auditService } from './audit.service.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(import_path5.default.join(dir, name), content);
+    await writeFile(import_path4.default.join(dir, name), content);
   }
 }
 async function generateUploadModule(dir) {
@@ -3787,7 +3492,7 @@ export interface UploadOptions {
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(import_path5.default.join(dir, name), content);
+    await writeFile(import_path4.default.join(dir, name), content);
   }
 }
 async function generateCacheModule(dir) {
@@ -3833,7 +3538,7 @@ export { CacheService, cacheService } from './cache.service.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(import_path5.default.join(dir, name), content);
+    await writeFile(import_path4.default.join(dir, name), content);
   }
 }
 async function generateGenericModule(dir, name) {
@@ -3847,18 +3552,184 @@ export interface ${name.charAt(0).toUpperCase() + name.slice(1)}Data {
 `
   };
   for (const [fileName, content] of Object.entries(files)) {
-    await writeFile(import_path5.default.join(dir, fileName), content);
+    await writeFile(import_path4.default.join(dir, fileName), content);
+  }
+}
+async function generateModuleFiles(moduleName, moduleDir) {
+  const sourceModuleDir = import_path4.default.join(process.cwd(), "src", "modules", moduleName);
+  if (await fileExists(sourceModuleDir)) {
+    await copyModuleFromSource(sourceModuleDir, moduleDir);
+    return;
+  }
+  switch (moduleName) {
+    case "auth":
+      await generateAuthModule(moduleDir);
+      break;
+    case "users":
+      await generateUsersModule(moduleDir);
+      break;
+    case "email":
+      await generateEmailModule(moduleDir);
+      break;
+    case "audit":
+      await generateAuditModule(moduleDir);
+      break;
+    case "upload":
+      await generateUploadModule(moduleDir);
+      break;
+    case "cache":
+      await generateCacheModule(moduleDir);
+      break;
+    default:
+      await generateGenericModule(moduleDir, moduleName);
+  }
+}
+async function copyModuleFromSource(sourceDir, targetDir) {
+  const entries = await fs5.readdir(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = import_path4.default.join(sourceDir, entry.name);
+    const targetPath = import_path4.default.join(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      await fs5.mkdir(targetPath, { recursive: true });
+      await copyModuleFromSource(sourcePath, targetPath);
+    } else {
+      await fs5.copyFile(sourcePath, targetPath);
+    }
+  }
+}
+async function getModuleFiles(moduleName, moduleDir) {
+  const files = {};
+  const entries = await fs5.readdir(moduleDir);
+  for (const entry of entries) {
+    const filePath = import_path4.default.join(moduleDir, entry);
+    const stat2 = await fs5.stat(filePath);
+    if (stat2.isFile() && entry.endsWith(".ts")) {
+      const content = await fs5.readFile(filePath, "utf-8");
+      files[entry] = content;
+    }
+  }
+  return files;
+}
+async function showDiffForModule(templateManager, moduleName, moduleDir) {
+  const modifiedFiles = await templateManager.getModifiedFiles(moduleName, moduleDir);
+  console.log(import_chalk4.default.cyan(`
+\u{1F4CA} Changes in module "${moduleName}":
+`));
+  for (const file of modifiedFiles) {
+    if (file.isModified) {
+      console.log(import_chalk4.default.yellow(`
+\u{1F4C4} ${file.fileName}:`));
+      const currentPath = import_path4.default.join(moduleDir, file.fileName);
+      const currentContent = await fs5.readFile(currentPath, "utf-8");
+      const originalContent = await templateManager.getTemplate(moduleName, file.fileName);
+      if (originalContent) {
+        const diff = templateManager.generateDiff(originalContent, currentContent);
+        console.log(diff);
+      }
+    }
+  }
+}
+async function performSmartMerge(templateManager, moduleName, moduleDir, _displayName) {
+  const spinner = (0, import_ora3.default)("Analyzing files for merge...").start();
+  const newFiles = {};
+  const templateDir = import_path4.default.join(templateManager["templatesDir"], moduleName);
+  try {
+    const entries = await fs5.readdir(templateDir);
+    for (const entry of entries) {
+      const content = await fs5.readFile(import_path4.default.join(templateDir, entry), "utf-8");
+      newFiles[entry] = content;
+    }
+  } catch {
+    spinner.fail("Could not find template files");
+    return;
+  }
+  const modifiedFiles = await templateManager.getModifiedFiles(moduleName, moduleDir);
+  spinner.stop();
+  const batchAction = await InteractivePrompt.askBatchAction();
+  const stats = {
+    merged: 0,
+    kept: 0,
+    overwritten: 0,
+    conflicts: 0
+  };
+  for (const fileInfo of modifiedFiles) {
+    const fileName = fileInfo.fileName;
+    const filePath = import_path4.default.join(moduleDir, fileName);
+    const newContent = newFiles[fileName];
+    if (!newContent) {
+      continue;
+    }
+    let fileAction;
+    if (batchAction === "merge-all") {
+      fileAction = "merge";
+    } else if (batchAction === "keep-all") {
+      fileAction = "keep";
+    } else if (batchAction === "overwrite-all") {
+      fileAction = "overwrite";
+    } else {
+      const currentContent = await fs5.readFile(filePath, "utf-8");
+      const yourLines = currentContent.split("\n").length;
+      const newLines = newContent.split("\n").length;
+      const choice = await InteractivePrompt.askFileAction(
+        fileName,
+        fileInfo.isModified,
+        yourLines,
+        newLines
+      );
+      fileAction = choice.action;
+      if (fileAction === "diff") {
+        const originalContent = await templateManager.getTemplate(moduleName, fileName);
+        if (originalContent) {
+          const diff = templateManager.generateDiff(originalContent, currentContent);
+          const proceed = await InteractivePrompt.showDiffAndAsk(diff);
+          fileAction = proceed ? "merge" : "keep";
+        }
+      }
+    }
+    if (fileAction === "keep" || fileAction === "skip") {
+      stats.kept++;
+      continue;
+    }
+    if (fileAction === "overwrite") {
+      await fs5.writeFile(filePath, newContent, "utf-8");
+      stats.overwritten++;
+      continue;
+    }
+    if (fileAction === "merge") {
+      const originalContent = await templateManager.getTemplate(moduleName, fileName);
+      const currentContent = await fs5.readFile(filePath, "utf-8");
+      if (originalContent) {
+        const mergeResult = await templateManager.mergeFiles(
+          originalContent,
+          currentContent,
+          newContent
+        );
+        await fs5.writeFile(filePath, mergeResult.merged, "utf-8");
+        if (mergeResult.hasConflicts) {
+          stats.conflicts++;
+          InteractivePrompt.displayConflicts(mergeResult.conflicts);
+        } else {
+          stats.merged++;
+        }
+      } else {
+        await fs5.writeFile(filePath, newContent, "utf-8");
+        stats.overwritten++;
+      }
+    }
   }
+  const files = await getModuleFiles(moduleName, moduleDir);
+  await templateManager.updateManifest(moduleName, files);
+  InteractivePrompt.showMergeSummary(stats);
 }
 
 // src/cli/commands/db.ts
 var import_commander4 = require("commander");
 var import_child_process2 = require("child_process");
-var import_ora5 = __toESM(require("ora"), 1);
-var import_chalk4 = __toESM(require("chalk"), 1);
+var import_ora4 = __toESM(require("ora"), 1);
+var import_chalk5 = __toESM(require("chalk"), 1);
 var dbCommand = new import_commander4.Command("db").description("Database management commands");
 dbCommand.command("migrate").description("Run database migrations").option("-n, --name <name>", "Migration name").action(async (options) => {
-  const spinner = (0, import_ora5.default)("Running migrations...").start();
+  const spinner = (0, import_ora4.default)("Running migrations...").start();
   try {
     const cmd = options.name ? `npx prisma migrate dev --name ${options.name}` : "npx prisma migrate dev";
     (0, import_child_process2.execSync)(cmd, { stdio: "inherit" });
@@ -3869,7 +3740,7 @@ dbCommand.command("migrate").description("Run database migrations").option("-n,
   }
 });
 dbCommand.command("push").description("Push schema changes to database (no migration)").action(async () => {
-  const spinner = (0, import_ora5.default)("Pushing schema...").start();
+  const spinner = (0, import_ora4.default)("Pushing schema...").start();
   try {
     (0, import_child_process2.execSync)("npx prisma db push", { stdio: "inherit" });
     spinner.succeed("Schema pushed successfully!");
@@ -3879,7 +3750,7 @@ dbCommand.command("push").description("Push schema changes to database (no migra
   }
 });
 dbCommand.command("generate").description("Generate Prisma client").action(async () => {
-  const spinner = (0, import_ora5.default)("Generating Prisma client...").start();
+  const spinner = (0, import_ora4.default)("Generating Prisma client...").start();
   try {
     (0, import_child_process2.execSync)("npx prisma generate", { stdio: "inherit" });
     spinner.succeed("Prisma client generated!");
@@ -3901,7 +3772,7 @@ dbCommand.command("studio").description("Open Prisma Studio").action(async () =>
   });
 });
 dbCommand.command("seed").description("Run database seed").action(async () => {
-  const spinner = (0, import_ora5.default)("Seeding database...").start();
+  const spinner = (0, import_ora4.default)("Seeding database...").start();
   try {
     (0, import_child_process2.execSync)("npx prisma db seed", { stdio: "inherit" });
     spinner.succeed("Database seeded!");
@@ -3912,7 +3783,7 @@ dbCommand.command("seed").description("Run database seed").action(async () => {
 });
 dbCommand.command("reset").description("Reset database (drop all data and re-run migrations)").option("-f, --force", "Skip confirmation").action(async (options) => {
   if (!options.force) {
-    console.log(import_chalk4.default.yellow("\n\u26A0\uFE0F  WARNING: This will delete all data in your database!\n"));
+    console.log(import_chalk5.default.yellow("\n\u26A0\uFE0F  WARNING: This will delete all data in your database!\n"));
     const readline = await import("readline");
     const rl = readline.createInterface({
       input: process.stdin,
@@ -3927,7 +3798,7 @@ dbCommand.command("reset").description("Reset database (drop all data and re-run
       return;
     }
   }
-  const spinner = (0, import_ora5.default)("Resetting database...").start();
+  const spinner = (0, import_ora4.default)("Resetting database...").start();
   try {
     (0, import_child_process2.execSync)("npx prisma migrate reset --force", { stdio: "inherit" });
     spinner.succeed("Database reset completed!");
@@ -3939,30 +3810,17 @@ dbCommand.command("reset").description("Reset database (drop all data and re-run
 dbCommand.command("status").description("Show migration status").action(async () => {
   try {
     (0, import_child_process2.execSync)("npx prisma migrate status", { stdio: "inherit" });
-  } catch (err) {
+  } catch {
     error("Failed to get migration status");
   }
 });
 
-// src/cli/commands/docs.ts
-var import_commander5 = require("commander");
-var docsCommand = new import_commander5.Command("docs").description("Generate Swagger/OpenAPI documentation").option("-o, --output <path>", "Output file path", "openapi.json").action(async (options) => {
-  try {
-    const outputPath = await generateDocs(options.output);
-    success(`Documentation written to ${outputPath}`);
-  } catch (err) {
-    error(err instanceof Error ? err.message : String(err));
-    process.exitCode = 1;
-  }
-});
-
 // src/cli/index.ts
-var program = new import_commander6.Command();
+var program = new import_commander5.Command();
 program.name("servcraft").description("Servcraft - A modular Node.js backend framework CLI").version("0.1.0");
 program.addCommand(initCommand);
 program.addCommand(generateCommand);
 program.addCommand(addModuleCommand);
 program.addCommand(dbCommand);
-program.addCommand(docsCommand);
 program.parse();
 //# sourceMappingURL=index.cjs.map