servcraft 0.1.6 → 0.2.0

package/dist/cli/index.js

@@ -1,21 +1,316 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/cli/utils/error-handler.ts
+var error_handler_exports = {};
+__export(error_handler_exports, {
+  ErrorTypes: () => ErrorTypes,
+  ServCraftError: () => ServCraftError,
+  displayError: () => displayError,
+  handleSystemError: () => handleSystemError,
+  validateProject: () => validateProject
+});
+import chalk4 from "chalk";
+function displayError(error2) {
+  console.error("\n" + chalk4.red.bold("\u2717 Error: ") + chalk4.red(error2.message));
+  if (error2 instanceof ServCraftError) {
+    if (error2.suggestions.length > 0) {
+      console.log("\n" + chalk4.yellow.bold("\u{1F4A1} Suggestions:"));
+      error2.suggestions.forEach((suggestion) => {
+        console.log(chalk4.yellow("  \u2022 ") + suggestion);
+      });
+    }
+    if (error2.docsLink) {
+      console.log("\n" + chalk4.blue.bold("\u{1F4DA} Documentation: ") + chalk4.blue.underline(error2.docsLink));
+    }
+  }
+  console.log();
+}
+function handleSystemError(err) {
+  switch (err.code) {
+    case "ENOENT":
+      return new ServCraftError(
+        `File or directory not found: ${err.path}`,
+        [`Check if the path exists`, `Create the directory first`]
+      );
+    case "EACCES":
+    case "EPERM":
+      return new ServCraftError(
+        `Permission denied: ${err.path}`,
+        [
+          `Check file permissions`,
+          `Try running with elevated privileges (not recommended)`,
+          `Change ownership of the directory`
+        ]
+      );
+    case "EEXIST":
+      return new ServCraftError(
+        `File or directory already exists: ${err.path}`,
+        [`Use a different name`, `Remove the existing file first`, `Use ${chalk4.cyan("--force")} to overwrite`]
+      );
+    case "ENOTDIR":
+      return new ServCraftError(
+        `Not a directory: ${err.path}`,
+        [`Check the path`, `A file exists where a directory is expected`]
+      );
+    case "EISDIR":
+      return new ServCraftError(
+        `Is a directory: ${err.path}`,
+        [`Cannot perform this operation on a directory`, `Did you mean to target a file?`]
+      );
+    default:
+      return new ServCraftError(
+        err.message,
+        [`Check system error code: ${err.code}`, `Review the error details above`]
+      );
+  }
+}
+function validateProject() {
+  try {
+    const fs10 = __require("fs");
+    const path12 = __require("path");
+    if (!fs10.existsSync("package.json")) {
+      return ErrorTypes.NOT_IN_PROJECT();
+    }
+    const packageJson = JSON.parse(fs10.readFileSync("package.json", "utf-8"));
+    if (!packageJson.dependencies?.fastify) {
+      return new ServCraftError(
+        "This does not appear to be a ServCraft project",
+        [
+          `ServCraft projects require Fastify`,
+          `Run ${chalk4.cyan("servcraft init")} to create a new project`
+        ]
+      );
+    }
+    return null;
+  } catch (err) {
+    return new ServCraftError(
+      "Failed to validate project",
+      [`Ensure you are in the project root directory`, `Check if ${chalk4.yellow("package.json")} is valid`]
+    );
+  }
+}
+var ServCraftError, ErrorTypes;
+var init_error_handler = __esm({
+  "src/cli/utils/error-handler.ts"() {
+    "use strict";
+    init_esm_shims();
+    ServCraftError = class extends Error {
+      suggestions;
+      docsLink;
+      constructor(message, suggestions = [], docsLink) {
+        super(message);
+        this.name = "ServCraftError";
+        this.suggestions = suggestions;
+        this.docsLink = docsLink;
+      }
+    };
+    ErrorTypes = {
+      MODULE_NOT_FOUND: (moduleName) => new ServCraftError(
+        `Module "${moduleName}" not found`,
+        [
+          `Run ${chalk4.cyan("servcraft list")} to see available modules`,
+          `Check the spelling of the module name`,
+          `Visit ${chalk4.blue("https://github.com/Le-Sourcier/servcraft#modules")} for module list`
+        ],
+        "https://github.com/Le-Sourcier/servcraft#add-pre-built-modules"
+      ),
+      MODULE_ALREADY_EXISTS: (moduleName) => new ServCraftError(
+        `Module "${moduleName}" already exists`,
+        [
+          `Use ${chalk4.cyan("servcraft add " + moduleName + " --force")} to overwrite`,
+          `Use ${chalk4.cyan("servcraft add " + moduleName + " --update")} to update`,
+          `Use ${chalk4.cyan("servcraft add " + moduleName + " --skip-existing")} to skip`
+        ]
+      ),
+      NOT_IN_PROJECT: () => new ServCraftError(
+        "Not in a ServCraft project directory",
+        [
+          `Run ${chalk4.cyan("servcraft init")} to create a new project`,
+          `Navigate to your ServCraft project directory`,
+          `Check if ${chalk4.yellow("package.json")} exists`
+        ],
+        "https://github.com/Le-Sourcier/servcraft#initialize-project"
+      ),
+      FILE_ALREADY_EXISTS: (fileName) => new ServCraftError(
+        `File "${fileName}" already exists`,
+        [
+          `Use ${chalk4.cyan("--force")} flag to overwrite`,
+          `Choose a different name`,
+          `Delete the existing file first`
+        ]
+      ),
+      INVALID_DATABASE: (database) => new ServCraftError(
+        `Invalid database type: "${database}"`,
+        [
+          `Valid options: ${chalk4.cyan("postgresql, mysql, sqlite, mongodb, none")}`,
+          `Use ${chalk4.cyan("servcraft init --db postgresql")} for PostgreSQL`
+        ]
+      ),
+      INVALID_VALIDATOR: (validator) => new ServCraftError(
+        `Invalid validator type: "${validator}"`,
+        [`Valid options: ${chalk4.cyan("zod, joi, yup")}`, `Default is ${chalk4.cyan("zod")}`]
+      ),
+      MISSING_DEPENDENCY: (dependency, command) => new ServCraftError(
+        `Missing dependency: "${dependency}"`,
+        [`Run ${chalk4.cyan(command)} to install`, `Check your ${chalk4.yellow("package.json")}`]
+      ),
+      INVALID_FIELD_FORMAT: (field) => new ServCraftError(
+        `Invalid field format: "${field}"`,
+        [
+          `Expected format: ${chalk4.cyan("name:type")}`,
+          `Example: ${chalk4.cyan("name:string age:number isActive:boolean")}`,
+          `Supported types: string, number, boolean, date`
+        ]
+      ),
+      GIT_NOT_INITIALIZED: () => new ServCraftError(
+        "Git repository not initialized",
+        [
+          `Run ${chalk4.cyan("git init")} to initialize git`,
+          `This is required for some ServCraft features`
+        ]
+      )
+    };
+  }
+});
 
 // src/cli/index.ts
-import { Command as Command5 } from "commander";
+init_esm_shims();
+import { Command as Command9 } from "commander";
 
 // src/cli/commands/init.ts
+init_esm_shims();
 import { Command } from "commander";
-import path2 from "path";
+import path4 from "path";
 import fs2 from "fs/promises";
 import ora from "ora";
 import inquirer from "inquirer";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import { execSync } from "child_process";
 
 // src/cli/utils/helpers.ts
+init_esm_shims();
 import fs from "fs/promises";
-import path from "path";
+import path3 from "path";
+import chalk2 from "chalk";
+
+// src/cli/utils/dry-run.ts
+init_esm_shims();
 import chalk from "chalk";
+import path2 from "path";
+var DryRunManager = class _DryRunManager {
+  static instance;
+  enabled = false;
+  operations = [];
+  constructor() {
+  }
+  static getInstance() {
+    if (!_DryRunManager.instance) {
+      _DryRunManager.instance = new _DryRunManager();
+    }
+    return _DryRunManager.instance;
+  }
+  enable() {
+    this.enabled = true;
+    this.operations = [];
+  }
+  disable() {
+    this.enabled = false;
+    this.operations = [];
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  addOperation(operation) {
+    if (this.enabled) {
+      this.operations.push(operation);
+    }
+  }
+  getOperations() {
+    return [...this.operations];
+  }
+  printSummary() {
+    if (!this.enabled || this.operations.length === 0) {
+      return;
+    }
+    console.log(chalk.bold.yellow("\n\u{1F4CB} Dry Run - Preview of changes:\n"));
+    console.log(chalk.gray("No files will be written. Remove --dry-run to apply changes.\n"));
+    const createOps = this.operations.filter((op) => op.type === "create");
+    const modifyOps = this.operations.filter((op) => op.type === "modify");
+    const deleteOps = this.operations.filter((op) => op.type === "delete");
+    if (createOps.length > 0) {
+      console.log(chalk.green.bold(`
+\u2713 Files to be created (${createOps.length}):`));
+      createOps.forEach((op) => {
+        const size = op.content ? `${op.content.length} bytes` : "unknown size";
+        console.log(`  ${chalk.green("+")} ${chalk.cyan(op.path)} ${chalk.gray(`(${size})`)}`);
+      });
+    }
+    if (modifyOps.length > 0) {
+      console.log(chalk.yellow.bold(`
+~ Files to be modified (${modifyOps.length}):`));
+      modifyOps.forEach((op) => {
+        console.log(`  ${chalk.yellow("~")} ${chalk.cyan(op.path)}`);
+      });
+    }
+    if (deleteOps.length > 0) {
+      console.log(chalk.red.bold(`
+- Files to be deleted (${deleteOps.length}):`));
+      deleteOps.forEach((op) => {
+        console.log(`  ${chalk.red("-")} ${chalk.cyan(op.path)}`);
+      });
+    }
+    console.log(chalk.gray("\n" + "\u2500".repeat(60)));
+    console.log(
+      chalk.bold(`  Total operations: ${this.operations.length}`) + chalk.gray(
+        ` (${createOps.length} create, ${modifyOps.length} modify, ${deleteOps.length} delete)`
+      )
+    );
+    console.log(chalk.gray("\u2500".repeat(60)));
+    console.log(chalk.yellow("\n\u26A0 This was a dry run. No files were created or modified."));
+    console.log(chalk.gray("  Remove --dry-run to apply these changes.\n"));
+  }
+  // Helper to format file path relative to cwd
+  relativePath(filePath) {
+    return path2.relative(process.cwd(), filePath);
+  }
+};
+
+// src/cli/utils/helpers.ts
 function toPascalCase(str) {
   return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
 }
@@ -47,39 +342,54 @@ async function ensureDir(dirPath) {
   await fs.mkdir(dirPath, { recursive: true });
 }
 async function writeFile(filePath, content) {
-  await ensureDir(path.dirname(filePath));
+  const dryRun = DryRunManager.getInstance();
+  if (dryRun.isEnabled()) {
+    dryRun.addOperation({
+      type: "create",
+      path: dryRun.relativePath(filePath),
+      content,
+      size: content.length
+    });
+    return;
+  }
+  await ensureDir(path3.dirname(filePath));
   await fs.writeFile(filePath, content, "utf-8");
 }
 function success(message) {
-  console.log(chalk.green("\u2713"), message);
+  console.log(chalk2.green("\u2713"), message);
 }
 function error(message) {
-  console.error(chalk.red("\u2717"), message);
+  console.error(chalk2.red("\u2717"), message);
 }
 function warn(message) {
-  console.log(chalk.yellow("\u26A0"), message);
+  console.log(chalk2.yellow("\u26A0"), message);
 }
 function info(message) {
-  console.log(chalk.blue("\u2139"), message);
+  console.log(chalk2.blue("\u2139"), message);
 }
 function getProjectRoot() {
   return process.cwd();
 }
 function getSourceDir() {
-  return path.join(getProjectRoot(), "src");
+  return path3.join(getProjectRoot(), "src");
 }
 function getModulesDir() {
-  return path.join(getSourceDir(), "modules");
+  return path3.join(getSourceDir(), "modules");
 }
 
 // src/cli/commands/init.ts
-var initCommand = new 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(
+var initCommand = new 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("--esm", "Use ES Modules (import/export) - default").option("--cjs, --commonjs", "Use CommonJS (require/module.exports)").option("--db <database>", "Database type (postgresql, mysql, sqlite, mongodb, none)").option("--dry-run", "Preview changes without writing files").action(
   async (name, cmdOptions) => {
+    const dryRun = DryRunManager.getInstance();
+    if (cmdOptions?.dryRun) {
+      dryRun.enable();
+      console.log(chalk3.yellow("\n\u26A0 DRY RUN MODE - No files will be written\n"));
+    }
     console.log(
-      chalk2.blue(`
+      chalk3.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   ${chalk2.bold("\u{1F680} Servcraft Project Generator")}          \u2551
+\u2551   ${chalk3.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
 `)
@@ -90,6 +400,7 @@ var initCommand = new Command("init").alias("new").description("Initialize a new
       options = {
         name: name || "my-servcraft-app",
         language: cmdOptions.javascript ? "javascript" : "typescript",
+        moduleSystem: cmdOptions.commonjs ? "commonjs" : "esm",
         database: db,
         orm: db === "mongodb" ? "mongoose" : db === "none" ? "none" : "prisma",
         validator: "zod",
@@ -119,6 +430,16 @@ var initCommand = new Command("init").alias("new").description("Initialize a new
           ],
           default: "typescript"
         },
+        {
+          type: "list",
+          name: "moduleSystem",
+          message: "Select module system:",
+          choices: [
+            { name: "ESM (import/export) - Recommended", value: "esm" },
+            { name: "CommonJS (require/module.exports)", value: "commonjs" }
+          ],
+          default: "esm"
+        },
         {
           type: "list",
           name: "database",
@@ -163,7 +484,7 @@ var initCommand = new Command("init").alias("new").description("Initialize a new
         orm: db === "mongodb" ? "mongoose" : db === "none" ? "none" : "prisma"
       };
     }
-    const projectDir = path2.resolve(process.cwd(), options.name);
+    const projectDir = path4.resolve(process.cwd(), options.name);
     const spinner = ora("Creating project...").start();
     try {
       try {
@@ -177,24 +498,24 @@ var initCommand = new Command("init").alias("new").description("Initialize a new
       spinner.text = "Generating project files...";
       const packageJson = generatePackageJson(options);
       await writeFile(
-        path2.join(projectDir, "package.json"),
+        path4.join(projectDir, "package.json"),
         JSON.stringify(packageJson, null, 2)
       );
       if (options.language === "typescript") {
-        await writeFile(path2.join(projectDir, "tsconfig.json"), generateTsConfig());
-        await writeFile(path2.join(projectDir, "tsup.config.ts"), generateTsupConfig());
+        await writeFile(path4.join(projectDir, "tsconfig.json"), generateTsConfig(options));
+        await writeFile(path4.join(projectDir, "tsup.config.ts"), generateTsupConfig(options));
       } else {
-        await writeFile(path2.join(projectDir, "jsconfig.json"), generateJsConfig());
+        await writeFile(path4.join(projectDir, "jsconfig.json"), generateJsConfig(options));
       }
-      await writeFile(path2.join(projectDir, ".env.example"), generateEnvExample(options));
-      await writeFile(path2.join(projectDir, ".env"), generateEnvExample(options));
-      await writeFile(path2.join(projectDir, ".gitignore"), generateGitignore());
-      await writeFile(path2.join(projectDir, "Dockerfile"), generateDockerfile(options));
+      await writeFile(path4.join(projectDir, ".env.example"), generateEnvExample(options));
+      await writeFile(path4.join(projectDir, ".env"), generateEnvExample(options));
+      await writeFile(path4.join(projectDir, ".gitignore"), generateGitignore());
+      await writeFile(path4.join(projectDir, "Dockerfile"), generateDockerfile(options));
       await writeFile(
-        path2.join(projectDir, "docker-compose.yml"),
+        path4.join(projectDir, "docker-compose.yml"),
         generateDockerCompose(options)
       );
-      const ext = options.language === "typescript" ? "ts" : "js";
+      const ext = options.language === "typescript" ? "ts" : options.moduleSystem === "esm" ? "js" : "cjs";
       const dirs = [
         "src/core",
         "src/config",
@@ -212,43 +533,63 @@ var initCommand = new Command("init").alias("new").description("Initialize a new
         dirs.push("src/database/models");
       }
       for (const dir of dirs) {
-        await ensureDir(path2.join(projectDir, dir));
+        await ensureDir(path4.join(projectDir, dir));
       }
-      await writeFile(path2.join(projectDir, `src/index.${ext}`), generateEntryFile(options));
+      await writeFile(path4.join(projectDir, `src/index.${ext}`), generateEntryFile(options));
       await writeFile(
-        path2.join(projectDir, `src/core/server.${ext}`),
+        path4.join(projectDir, `src/core/server.${ext}`),
         generateServerFile(options)
       );
       await writeFile(
-        path2.join(projectDir, `src/core/logger.${ext}`),
+        path4.join(projectDir, `src/core/logger.${ext}`),
         generateLoggerFile(options)
       );
+      await writeFile(
+        path4.join(projectDir, `src/config/index.${ext}`),
+        generateConfigFile(options)
+      );
+      await writeFile(
+        path4.join(projectDir, `src/middleware/index.${ext}`),
+        generateMiddlewareFile(options)
+      );
+      await writeFile(
+        path4.join(projectDir, `src/utils/index.${ext}`),
+        generateUtilsFile(options)
+      );
+      await writeFile(
+        path4.join(projectDir, `src/types/index.${ext}`),
+        generateTypesFile(options)
+      );
       if (options.orm === "prisma") {
         await writeFile(
-          path2.join(projectDir, "prisma/schema.prisma"),
+          path4.join(projectDir, "prisma/schema.prisma"),
           generatePrismaSchema(options)
         );
       } else if (options.orm === "mongoose") {
         await writeFile(
-          path2.join(projectDir, `src/database/connection.${ext}`),
+          path4.join(projectDir, `src/database/connection.${ext}`),
           generateMongooseConnection(options)
         );
         await writeFile(
-          path2.join(projectDir, `src/database/models/user.model.${ext}`),
+          path4.join(projectDir, `src/database/models/user.model.${ext}`),
           generateMongooseUserModel(options)
         );
       }
       spinner.succeed("Project files generated!");
-      const installSpinner = ora("Installing dependencies...").start();
-      try {
-        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');
+      if (!cmdOptions?.dryRun) {
+        const installSpinner = ora("Installing dependencies...").start();
+        try {
+          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" + chalk2.green("\u2728 Project created successfully!"));
-      console.log("\n" + chalk2.bold("\u{1F4C1} Project structure:"));
+      if (!cmdOptions?.dryRun) {
+        console.log("\n" + chalk3.green("\u2728 Project created successfully!"));
+      }
+      console.log("\n" + chalk3.bold("\u{1F4C1} Project structure:"));
       console.log(`
   ${options.name}/
   \u251C\u2500\u2500 src/
@@ -263,19 +604,22 @@ var initCommand = new Command("init").alias("new").description("Initialize a new
   \u251C\u2500\u2500 docker-compose.yml
   \u2514\u2500\u2500 package.json
 `);
-      console.log(chalk2.bold("\u{1F680} Get started:"));
+      console.log(chalk3.bold("\u{1F680} Get started:"));
       console.log(`
-  ${chalk2.cyan(`cd ${options.name}`)}
-  ${options.database !== "none" ? chalk2.cyan("npm run db:push        # Setup database") : ""}
-  ${chalk2.cyan("npm run dev            # Start development server")}
+  ${chalk3.cyan(`cd ${options.name}`)}
+  ${options.database !== "none" ? chalk3.cyan("npm run db:push        # Setup database") : ""}
+  ${chalk3.cyan("npm run dev            # Start development server")}
 `);
-      console.log(chalk2.bold("\u{1F4DA} Available commands:"));
+      console.log(chalk3.bold("\u{1F4DA} Available commands:"));
       console.log(`
-  ${chalk2.yellow("servcraft generate module <name>")}    Generate a new module
-  ${chalk2.yellow("servcraft generate controller <name>")} Generate a controller
-  ${chalk2.yellow("servcraft generate service <name>")}    Generate a service
-  ${chalk2.yellow("servcraft add auth")}                   Add authentication module
+  ${chalk3.yellow("servcraft generate module <name>")}    Generate a new module
+  ${chalk3.yellow("servcraft generate controller <name>")} Generate a controller
+  ${chalk3.yellow("servcraft generate service <name>")}    Generate a service
+  ${chalk3.yellow("servcraft add auth")}                   Add authentication module
 `);
+      if (cmdOptions?.dryRun) {
+        dryRun.printSummary();
+      }
     } catch (err) {
       spinner.fail("Failed to create project");
       error(err instanceof Error ? err.message : String(err));
@@ -284,18 +628,35 @@ var initCommand = new Command("init").alias("new").description("Initialize a new
 );
 function generatePackageJson(options) {
   const isTS = options.language === "typescript";
+  const isESM = options.moduleSystem === "esm";
+  let devCommand;
+  if (isTS) {
+    devCommand = "tsx watch src/index.ts";
+  } else if (isESM) {
+    devCommand = "node --watch src/index.js";
+  } else {
+    devCommand = "node --watch src/index.cjs";
+  }
+  let startCommand;
+  if (isTS) {
+    startCommand = isESM ? "node dist/index.js" : "node dist/index.cjs";
+  } else if (isESM) {
+    startCommand = "node src/index.js";
+  } else {
+    startCommand = "node src/index.cjs";
+  }
   const pkg = {
     name: options.name,
     version: "0.1.0",
     description: "A Servcraft application",
-    main: isTS ? "dist/index.js" : "src/index.js",
-    type: "module",
+    main: isTS ? isESM ? "dist/index.js" : "dist/index.cjs" : isESM ? "src/index.js" : "src/index.cjs",
+    ...isESM && { type: "module" },
     scripts: {
-      dev: isTS ? "tsx watch src/index.ts" : "node --watch src/index.js",
+      dev: devCommand,
       build: isTS ? "tsup" : 'echo "No build needed for JS"',
-      start: isTS ? "node dist/index.js" : "node src/index.js",
+      start: startCommand,
       test: "vitest",
-      lint: isTS ? "eslint src --ext .ts" : "eslint src --ext .js"
+      lint: isTS ? "eslint src --ext .ts" : "eslint src --ext .js,.cjs"
     },
     dependencies: {
       fastify: "^4.28.1",
@@ -357,13 +718,14 @@ function generatePackageJson(options) {
   }
   return pkg;
 }
-function generateTsConfig() {
+function generateTsConfig(options) {
+  const isESM = options.moduleSystem === "esm";
   return JSON.stringify(
     {
       compilerOptions: {
         target: "ES2022",
-        module: "NodeNext",
-        moduleResolution: "NodeNext",
+        module: isESM ? "NodeNext" : "CommonJS",
+        moduleResolution: isESM ? "NodeNext" : "Node",
         lib: ["ES2022"],
         outDir: "./dist",
         rootDir: "./src",
@@ -382,12 +744,13 @@ function generateTsConfig() {
     2
   );
 }
-function generateJsConfig() {
+function generateJsConfig(options) {
+  const isESM = options.moduleSystem === "esm";
   return JSON.stringify(
     {
       compilerOptions: {
-        module: "NodeNext",
-        moduleResolution: "NodeNext",
+        module: isESM ? "NodeNext" : "CommonJS",
+        moduleResolution: isESM ? "NodeNext" : "Node",
         target: "ES2022",
         checkJs: true
       },
@@ -398,12 +761,13 @@ function generateJsConfig() {
     2
   );
 }
-function generateTsupConfig() {
+function generateTsupConfig(options) {
+  const isESM = options.moduleSystem === "esm";
   return `import { defineConfig } from 'tsup';
 
 export default defineConfig({
   entry: ['src/index.ts'],
-  format: ['esm'],
+  format: ['${isESM ? "esm" : "cjs"}'],
   dts: true,
   clean: true,
   sourcemap: true,
@@ -412,7 +776,7 @@ export default defineConfig({
 `;
 }
 function generateEnvExample(options) {
-  let env = `# Server
+  let env2 = `# Server
 NODE_ENV=development
 PORT=3000
 HOST=0.0.0.0
@@ -430,31 +794,31 @@ RATE_LIMIT_MAX=100
 LOG_LEVEL=info
 `;
   if (options.database === "postgresql") {
-    env += `
+    env2 += `
 # Database (PostgreSQL)
 DATABASE_PROVIDER=postgresql
 DATABASE_URL="postgresql://user:password@localhost:5432/mydb?schema=public"
 `;
   } else if (options.database === "mysql") {
-    env += `
+    env2 += `
 # Database (MySQL)
 DATABASE_PROVIDER=mysql
 DATABASE_URL="mysql://user:password@localhost:3306/mydb"
 `;
   } else if (options.database === "sqlite") {
-    env += `
+    env2 += `
 # Database (SQLite)
 DATABASE_PROVIDER=sqlite
 DATABASE_URL="file:./dev.db"
 `;
   } else if (options.database === "mongodb") {
-    env += `
+    env2 += `
 # Database (MongoDB)
 MONGODB_URI="mongodb://localhost:27017/mydb"
 `;
   }
   if (options.features.includes("email")) {
-    env += `
+    env2 += `
 # Email
 SMTP_HOST=smtp.example.com
 SMTP_PORT=587
@@ -464,12 +828,12 @@ SMTP_FROM="App <noreply@example.com>"
 `;
   }
   if (options.features.includes("redis")) {
-    env += `
+    env2 += `
 # Redis
 REDIS_URL=redis://localhost:6379
 `;
   }
-  return env;
+  return env2;
 }
 function generateGitignore() {
   return `node_modules/
@@ -598,7 +962,12 @@ model User {
 }
 function generateEntryFile(options) {
   const isTS = options.language === "typescript";
-  return `${isTS ? "import 'dotenv/config';\nimport { createServer } from './core/server.js';\nimport { logger } from './core/logger.js';" : "require('dotenv').config();\nconst { createServer } = require('./core/server.js');\nconst { logger } = require('./core/logger.js');"}
+  const isESM = options.moduleSystem === "esm";
+  const fileExt = isTS ? "js" : isESM ? "js" : "cjs";
+  if (isESM || isTS) {
+    return `import 'dotenv/config';
+import { createServer } from './core/server.${fileExt}';
+import { logger } from './core/logger.${fileExt}';
 
 async function main()${isTS ? ": Promise<void>" : ""} {
   const server = createServer();
@@ -613,16 +982,31 @@ async function main()${isTS ? ": Promise<void>" : ""} {
 
 main();
 `;
+  } else {
+    return `require('dotenv').config();
+const { createServer } = require('./core/server.cjs');
+const { logger } = require('./core/logger.cjs');
+
+async function main() {
+  const server = createServer();
+
+  try {
+    await server.start();
+  } catch (error) {
+    logger.error({ err: error }, 'Failed to start server');
+    process.exit(1);
+  }
+}
+
+main();
+`;
+  }
 }
 function generateServerFile(options) {
   const isTS = options.language === "typescript";
-  return `${isTS ? `import Fastify from 'fastify';
-import type { FastifyInstance } from 'fastify';
-import { logger } from './logger.js';` : `const Fastify = require('fastify');
-const { logger } = require('./logger.js');`}
-
-${isTS ? "export function createServer(): { instance: FastifyInstance; start: () => Promise<void> }" : "function createServer()"} {
-  const app = Fastify({ logger });
+  const isESM = options.moduleSystem === "esm";
+  const fileExt = isTS ? "js" : isESM ? "js" : "cjs";
+  const serverBody = `  const app = Fastify({ logger });
 
   // Health check
   app.get('/health', async () => ({
@@ -649,33 +1033,58 @@ ${isTS ? "export function createServer(): { instance: FastifyInstance; start: ()
       logger.info(\`Server listening on \${host}:\${port}\`);
     },
   };
-}
+}`;
+  if (isESM || isTS) {
+    return `import Fastify from 'fastify';
+${isTS ? "import type { FastifyInstance } from 'fastify';" : ""}
+import { logger } from './logger.${fileExt}';
+
+${isTS ? "export function createServer(): { instance: FastifyInstance; start: () => Promise<void> }" : "export function createServer()"} {
+${serverBody}
+`;
+  } else {
+    return `const Fastify = require('fastify');
+const { logger } = require('./logger.cjs');
+
+function createServer() {
+${serverBody}
 
-${isTS ? "" : "module.exports = { createServer };"}
+module.exports = { createServer };
 `;
+  }
 }
 function generateLoggerFile(options) {
   const isTS = options.language === "typescript";
-  return `${isTS ? "import pino from 'pino';\nimport type { Logger } from 'pino';" : "const pino = require('pino');"}
-
-${isTS ? "export const logger: Logger" : "const logger"} = pino({
+  const isESM = options.moduleSystem === "esm";
+  const loggerBody = `pino({
   level: process.env.LOG_LEVEL || 'info',
   transport: process.env.NODE_ENV !== 'production' ? {
     target: 'pino-pretty',
     options: { colorize: true },
   } : undefined,
-});
+})`;
+  if (isESM || isTS) {
+    return `import pino from 'pino';
+${isTS ? "import type { Logger } from 'pino';" : ""}
+
+export const logger${isTS ? ": Logger" : ""} = ${loggerBody};
+`;
+  } else {
+    return `const pino = require('pino');
+
+const logger = ${loggerBody};
 
-${isTS ? "" : "module.exports = { logger };"}
+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';
+  const isESM = options.moduleSystem === "esm";
+  const fileExt = isTS ? "js" : isESM ? "js" : "cjs";
+  const connectionBody = `const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/mydb';
 
-${isTS ? "export async function connectDatabase(): Promise<typeof mongoose>" : "async function connectDatabase()"} {
+async function connectDatabase()${isTS ? ": Promise<typeof mongoose>" : ""} {
   try {
     const conn = await mongoose.connect(MONGODB_URI);
     logger.info(\`MongoDB connected: \${conn.connection.host}\`);
@@ -686,35 +1095,36 @@ ${isTS ? "export async function connectDatabase(): Promise<typeof mongoose>" : "
   }
 }
 
-${isTS ? "export async function disconnectDatabase(): Promise<void>" : "async function disconnectDatabase()"} {
+async function disconnectDatabase()${isTS ? ": Promise<void>" : ""} {
   try {
     await mongoose.disconnect();
     logger.info('MongoDB disconnected');
   } catch (error) {
     logger.error({ err: error }, 'MongoDB disconnect failed');
   }
-}
+}`;
+  if (isESM || isTS) {
+    return `import mongoose from 'mongoose';
+import { logger } from '../core/logger.${fileExt}';
+
+${connectionBody}
+
+export { connectDatabase, disconnectDatabase, mongoose };
+`;
+  } else {
+    return `const mongoose = require('mongoose');
+const { logger } = require('../core/logger.cjs');
 
-${isTS ? "export { mongoose };" : "module.exports = { connectDatabase, disconnectDatabase, mongoose };"}
+${connectionBody}
+
+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>" : ""}({
+  const isESM = options.moduleSystem === "esm";
+  const schemaBody = `const userSchema = new Schema${isTS ? "<IUser>" : ""}({
   email: {
     type: String,
     required: true,
@@ -765,19 +1175,250 @@ userSchema.pre('save', async function(next) {
 // Compare password method
 userSchema.methods.comparePassword = async function(candidatePassword${isTS ? ": string" : ""})${isTS ? ": Promise<boolean>" : ""} {
   return bcrypt.compare(candidatePassword, this.password);
-};
+};`;
+  const tsInterface = 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>;
+}
+` : "";
+  if (isESM || isTS) {
+    return `import mongoose${isTS ? ", { Schema, Document }" : ""} from 'mongoose';
+import bcrypt from 'bcryptjs';
+${!isTS ? "const { Schema } = mongoose;" : ""}
+${tsInterface}
+${schemaBody}
+
+export const User = mongoose.model${isTS ? "<IUser>" : ""}('User', userSchema);
+`;
+  } else {
+    return `const mongoose = require('mongoose');
+const bcrypt = require('bcryptjs');
+const { Schema } = mongoose;
+
+${schemaBody}
+
+const User = mongoose.model('User', userSchema);
+
+module.exports = { User };
+`;
+  }
+}
+function generateConfigFile(options) {
+  const isTS = options.language === "typescript";
+  const isESM = options.moduleSystem === "esm";
+  const configBody = `{
+  env: process.env.NODE_ENV || 'development',
+  port: parseInt(process.env.PORT || '3000', 10),
+  host: process.env.HOST || '0.0.0.0',
+
+  jwt: {
+    secret: process.env.JWT_SECRET || 'your-secret-key',
+    accessExpiresIn: process.env.JWT_ACCESS_EXPIRES_IN || '15m',
+    refreshExpiresIn: process.env.JWT_REFRESH_EXPIRES_IN || '7d',
+  },
+
+  cors: {
+    origin: process.env.CORS_ORIGIN || 'http://localhost:3000',
+  },
+
+  rateLimit: {
+    max: parseInt(process.env.RATE_LIMIT_MAX || '100', 10),
+  },
+
+  log: {
+    level: process.env.LOG_LEVEL || 'info',
+  },
+}${isTS ? " as const" : ""}`;
+  if (isESM || isTS) {
+    return `import 'dotenv/config';
+
+export const config = ${configBody};
+`;
+  } else {
+    return `require('dotenv').config();
+
+const config = ${configBody};
+
+module.exports = { config };
+`;
+  }
+}
+function generateMiddlewareFile(options) {
+  const isTS = options.language === "typescript";
+  const isESM = options.moduleSystem === "esm";
+  const fileExt = isTS ? "js" : isESM ? "js" : "cjs";
+  const middlewareBody = `/**
+ * Error handler middleware
+ */
+function errorHandler(error${isTS ? ": Error" : ""}, request${isTS ? ": FastifyRequest" : ""}, reply${isTS ? ": FastifyReply" : ""})${isTS ? ": void" : ""} {
+  logger.error({ err: error, url: request.url, method: request.method }, 'Request error');
+
+  const statusCode = (error${isTS ? " as any" : ""}).statusCode || 500;
+  const message = statusCode === 500 ? 'Internal Server Error' : error.message;
+
+  reply.status(statusCode).send({
+    success: false,
+    error: message,
+    ...(process.env.NODE_ENV === 'development' && { stack: error.stack }),
+  });
+}
+
+/**
+ * Request logging middleware
+ */
+function requestLogger(request${isTS ? ": FastifyRequest" : ""}, reply${isTS ? ": FastifyReply" : ""}, done${isTS ? ": () => void" : ""})${isTS ? ": void" : ""} {
+  logger.info({ url: request.url, method: request.method, ip: request.ip }, 'Incoming request');
+  done();
+}`;
+  if (isESM || isTS) {
+    return `${isTS ? "import type { FastifyRequest, FastifyReply } from 'fastify';" : ""}
+import { logger } from '../core/logger.${fileExt}';
+
+${middlewareBody}
+
+export { errorHandler, requestLogger };
+`;
+  } else {
+    return `const { logger } = require('../core/logger.cjs');
+
+${middlewareBody}
+
+module.exports = { errorHandler, requestLogger };
+`;
+  }
+}
+function generateUtilsFile(options) {
+  const isTS = options.language === "typescript";
+  const isESM = options.moduleSystem === "esm";
+  const utilsBody = `/**
+ * Standard API response helper
+ */
+function apiResponse${isTS ? "<T>" : ""}(data${isTS ? ": T" : ""}, message = "Success")${isTS ? ": { success: boolean; message: string; data: T }" : ""} {
+  return {
+    success: true,
+    message,
+    data,
+  };
+}
+
+/**
+ * Error response helper
+ */
+function errorResponse(message${isTS ? ": string" : ""}, code${isTS ? "?: string" : ""})${isTS ? ": { success: boolean; error: string; code?: string }" : ""} {
+  return {
+    success: false,
+    error: message,
+    ...(code && { code }),
+  };
+}
+
+/**
+ * Pagination helper
+ */
+function paginate${isTS ? "<T>" : ""}(data${isTS ? ": T[]" : ""}, page${isTS ? ": number" : ""}, limit${isTS ? ": number" : ""}, total${isTS ? ": number" : ""})${isTS ? ": PaginationResult<T>" : ""} {
+  const totalPages = Math.ceil(total / limit);
+
+  return {
+    data,
+    pagination: {
+      page,
+      limit,
+      total,
+      totalPages,
+      hasNextPage: page < totalPages,
+      hasPrevPage: page > 1,
+    },
+  };
+}`;
+  const tsInterface = isTS ? `
+/**
+ * Pagination result type
+ */
+export interface PaginationResult<T> {
+  data: T[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+  };
+}
+` : "";
+  if (isESM || isTS) {
+    return `${tsInterface}
+${utilsBody}
+
+export { apiResponse, errorResponse, paginate };
+`;
+  } else {
+    return `${utilsBody}
+
+module.exports = { apiResponse, errorResponse, paginate };
+`;
+  }
+}
+function generateTypesFile(options) {
+  if (options.language !== "typescript") {
+    return "// Types file - not needed for JavaScript\n";
+  }
+  return `/**
+ * Common type definitions
+ */
+
+export interface ApiResponse<T = unknown> {
+  success: boolean;
+  message?: string;
+  data?: T;
+  error?: string;
+  code?: string;
+}
+
+export interface PaginatedResponse<T> {
+  data: T[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+  };
+}
+
+export interface RequestUser {
+  id: string;
+  email: string;
+  role: string;
+}
 
-${isTS ? "export const User = mongoose.model<IUser>('User', userSchema);" : "const User = mongoose.model('User', userSchema);\nmodule.exports = { User };"}
+declare module 'fastify' {
+  interface FastifyRequest {
+    user?: RequestUser;
+  }
+}
 `;
 }
 
 // src/cli/commands/generate.ts
+init_esm_shims();
 import { Command as Command2 } from "commander";
-import path3 from "path";
+import path5 from "path";
 import ora2 from "ora";
 import inquirer2 from "inquirer";
+import chalk5 from "chalk";
 
 // src/cli/utils/field-parser.ts
+init_esm_shims();
 var tsTypeMap = {
   string: "string",
   number: "number",
@@ -919,7 +1560,11 @@ function parseFields(fieldsStr) {
   return fieldsStr.split(/\s+/).filter(Boolean).map(parseField);
 }
 
+// src/cli/commands/generate.ts
+init_error_handler();
+
 // src/cli/templates/controller.ts
+init_esm_shims();
 function controllerTemplate(name, pascalName, camelName) {
   return `import type { FastifyRequest, FastifyReply } from 'fastify';
 import type { ${pascalName}Service } from './${name}.service.js';
@@ -989,6 +1634,7 @@ export function create${pascalName}Controller(${camelName}Service: ${pascalName}
 }
 
 // src/cli/templates/service.ts
+init_esm_shims();
 function serviceTemplate(name, pascalName, camelName) {
   return `import type { PaginatedResult, PaginationParams } from '../../types/index.js';
 import { NotFoundError, ConflictError } from '../../utils/errors.js';
@@ -1049,6 +1695,7 @@ export function create${pascalName}Service(repository?: ${pascalName}Repository)
 }
 
 // src/cli/templates/repository.ts
+init_esm_shims();
 function repositoryTemplate(name, pascalName, camelName, pluralName) {
   return `import { randomUUID } from 'crypto';
 import type { PaginatedResult, PaginationParams } from '../../types/index.js';
@@ -1155,6 +1802,7 @@ export function create${pascalName}Repository(): ${pascalName}Repository {
 }
 
 // src/cli/templates/types.ts
+init_esm_shims();
 function typesTemplate(name, pascalName) {
   return `import type { BaseEntity } from '../../types/index.js';
 
@@ -1184,6 +1832,7 @@ export interface ${pascalName}Filters {
 }
 
 // src/cli/templates/schemas.ts
+init_esm_shims();
 function schemasTemplate(name, pascalName, camelName) {
   return `import { z } from 'zod';
 
@@ -1212,6 +1861,7 @@ export type ${pascalName}QueryInput = z.infer<typeof ${camelName}QuerySchema>;
 }
 
 // src/cli/templates/routes.ts
+init_esm_shims();
 function routesTemplate(name, pascalName, camelName, pluralName) {
   return `import type { FastifyInstance } from 'fastify';
 import type { ${pascalName}Controller } from './${name}.controller.js';
@@ -1264,6 +1914,7 @@ export function register${pascalName}Routes(
 }
 
 // src/cli/templates/module-index.ts
+init_esm_shims();
 function moduleIndexTemplate(name, pascalName, camelName) {
   return `import type { FastifyInstance } from 'fastify';
 import { logger } from '../../core/logger.js';
@@ -1299,6 +1950,7 @@ export * from './${name}.schemas.js';
 }
 
 // src/cli/templates/prisma-model.ts
+init_esm_shims();
 function prismaModelTemplate(name, pascalName, tableName) {
   return `
 // Add this model to your prisma/schema.prisma file
@@ -1318,6 +1970,7 @@ model ${pascalName} {
 }
 
 // src/cli/templates/dynamic-types.ts
+init_esm_shims();
 function dynamicTypesTemplate(name, pascalName, fields) {
   const fieldLines = fields.map((field) => {
     const tsType = tsTypeMap[field.type];
@@ -1362,6 +2015,7 @@ ${fields.filter((f) => ["string", "enum", "boolean"].includes(f.type)).map((f) =
 }
 
 // src/cli/templates/dynamic-schemas.ts
+init_esm_shims();
 function dynamicSchemasTemplate(name, pascalName, camelName, fields, validator = "zod") {
   switch (validator) {
     case "joi":
@@ -1540,6 +2194,7 @@ function getJsType(field) {
 }
 
 // src/cli/templates/dynamic-prisma.ts
+init_esm_shims();
 function dynamicPrismaTemplate(modelName, tableName, fields) {
   const fieldLines = [];
   for (const field of fields) {
@@ -1608,10 +2263,23 @@ ${indexLines.join("\n")}
 }
 
 // src/cli/commands/generate.ts
+function enableDryRunIfNeeded(options) {
+  const dryRun = DryRunManager.getInstance();
+  if (options.dryRun) {
+    dryRun.enable();
+    console.log(chalk5.yellow("\n\u26A0 DRY RUN MODE - No files will be written\n"));
+  }
+}
+function showDryRunSummary(options) {
+  if (options.dryRun) {
+    DryRunManager.getInstance().printSummary();
+  }
+}
 var generateCommand = new Command2("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) => {
+).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").option("--dry-run", "Preview changes without writing files").action(async (name, fieldsArgs, options) => {
+  enableDryRunIfNeeded(options);
   let fields = [];
   if (options.interactive) {
     fields = await promptForFields();
@@ -1626,7 +2294,7 @@ generateCommand.command("module <name> [fields...]").alias("m").description(
     const pluralName = pluralize(kebabName);
     const tableName = pluralize(kebabName.replace(/-/g, "_"));
     const validatorType = options.validator || "zod";
-    const moduleDir = path3.join(getModulesDir(), kebabName);
+    const moduleDir = path5.join(getModulesDir(), kebabName);
     if (await fileExists(moduleDir)) {
       spinner.stop();
       error(`Module "${kebabName}" already exists`);
@@ -1665,7 +2333,7 @@ generateCommand.command("module <name> [fields...]").alias("m").description(
       });
     }
     for (const file of files) {
-      await writeFile(path3.join(moduleDir, file.name), file.content);
+      await writeFile(path5.join(moduleDir, file.name), file.content);
     }
     spinner.succeed(`Module "${pascalName}" generated successfully!`);
     if (options.prisma || hasFields) {
@@ -1703,42 +2371,46 @@ generateCommand.command("module <name> [fields...]").alias("m").description(
       info(`  ${hasFields ? "3" : "4"}. Add the Prisma model to schema.prisma`);
       info(`  ${hasFields ? "4" : "5"}. Run: npm run db:migrate`);
     }
+    showDryRunSummary(options);
   } 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) => {
+generateCommand.command("controller <name>").alias("c").description("Generate a controller").option("-m, --module <module>", "Target module name").option("--dry-run", "Preview changes without writing files").action(async (name, options) => {
+  enableDryRunIfNeeded(options);
   const spinner = ora2("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 = path3.join(getModulesDir(), moduleName);
-    const filePath = path3.join(moduleDir, `${kebabName}.controller.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.controller.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
-      error(`Controller "${kebabName}" already exists`);
+      displayError(ErrorTypes.FILE_ALREADY_EXISTS(`${kebabName}.controller.ts`));
       return;
     }
     await writeFile(filePath, controllerTemplate(kebabName, pascalName, camelName));
     spinner.succeed(`Controller "${pascalName}Controller" generated!`);
     success(`  src/modules/${moduleName}/${kebabName}.controller.ts`);
+    showDryRunSummary(options);
   } catch (err) {
     spinner.fail("Failed to generate controller");
     error(err instanceof Error ? err.message : String(err));
   }
 });
-generateCommand.command("service <name>").alias("s").description("Generate a service").option("-m, --module <module>", "Target module name").action(async (name, options) => {
+generateCommand.command("service <name>").alias("s").description("Generate a service").option("-m, --module <module>", "Target module name").option("--dry-run", "Preview changes without writing files").action(async (name, options) => {
+  enableDryRunIfNeeded(options);
   const spinner = ora2("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 = path3.join(getModulesDir(), moduleName);
-    const filePath = path3.join(moduleDir, `${kebabName}.service.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.service.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Service "${kebabName}" already exists`);
@@ -1747,12 +2419,14 @@ generateCommand.command("service <name>").alias("s").description("Generate a ser
     await writeFile(filePath, serviceTemplate(kebabName, pascalName, camelName));
     spinner.succeed(`Service "${pascalName}Service" generated!`);
     success(`  src/modules/${moduleName}/${kebabName}.service.ts`);
+    showDryRunSummary(options);
   } catch (err) {
     spinner.fail("Failed to generate service");
     error(err instanceof Error ? err.message : String(err));
   }
 });
-generateCommand.command("repository <name>").alias("r").description("Generate a repository").option("-m, --module <module>", "Target module name").action(async (name, options) => {
+generateCommand.command("repository <name>").alias("r").description("Generate a repository").option("-m, --module <module>", "Target module name").option("--dry-run", "Preview changes without writing files").action(async (name, options) => {
+  enableDryRunIfNeeded(options);
   const spinner = ora2("Generating repository...").start();
   try {
     const kebabName = toKebabCase(name);
@@ -1760,8 +2434,8 @@ generateCommand.command("repository <name>").alias("r").description("Generate a
     const camelName = toCamelCase(name);
     const pluralName = pluralize(kebabName);
     const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = path3.join(getModulesDir(), moduleName);
-    const filePath = path3.join(moduleDir, `${kebabName}.repository.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.repository.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Repository "${kebabName}" already exists`);
@@ -1770,19 +2444,21 @@ generateCommand.command("repository <name>").alias("r").description("Generate a
     await writeFile(filePath, repositoryTemplate(kebabName, pascalName, camelName, pluralName));
     spinner.succeed(`Repository "${pascalName}Repository" generated!`);
     success(`  src/modules/${moduleName}/${kebabName}.repository.ts`);
+    showDryRunSummary(options);
   } catch (err) {
     spinner.fail("Failed to generate repository");
     error(err instanceof Error ? err.message : String(err));
   }
 });
-generateCommand.command("types <name>").alias("t").description("Generate types/interfaces").option("-m, --module <module>", "Target module name").action(async (name, options) => {
+generateCommand.command("types <name>").alias("t").description("Generate types/interfaces").option("-m, --module <module>", "Target module name").option("--dry-run", "Preview changes without writing files").action(async (name, options) => {
+  enableDryRunIfNeeded(options);
   const spinner = ora2("Generating types...").start();
   try {
     const kebabName = toKebabCase(name);
     const pascalName = toPascalCase(name);
     const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = path3.join(getModulesDir(), moduleName);
-    const filePath = path3.join(moduleDir, `${kebabName}.types.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.types.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Types file "${kebabName}.types.ts" already exists`);
@@ -1791,20 +2467,22 @@ generateCommand.command("types <name>").alias("t").description("Generate types/i
     await writeFile(filePath, typesTemplate(kebabName, pascalName));
     spinner.succeed(`Types for "${pascalName}" generated!`);
     success(`  src/modules/${moduleName}/${kebabName}.types.ts`);
+    showDryRunSummary(options);
   } 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) => {
+generateCommand.command("schema <name>").alias("v").description("Generate validation schemas").option("-m, --module <module>", "Target module name").option("--dry-run", "Preview changes without writing files").action(async (name, options) => {
+  enableDryRunIfNeeded(options);
   const spinner = ora2("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 = path3.join(getModulesDir(), moduleName);
-    const filePath = path3.join(moduleDir, `${kebabName}.schemas.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.schemas.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Schemas file "${kebabName}.schemas.ts" already exists`);
@@ -1813,12 +2491,14 @@ generateCommand.command("schema <name>").alias("v").description("Generate valida
     await writeFile(filePath, schemasTemplate(kebabName, pascalName, camelName));
     spinner.succeed(`Schemas for "${pascalName}" generated!`);
     success(`  src/modules/${moduleName}/${kebabName}.schemas.ts`);
+    showDryRunSummary(options);
   } 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) => {
+generateCommand.command("routes <name>").description("Generate routes").option("-m, --module <module>", "Target module name").option("--dry-run", "Preview changes without writing files").action(async (name, options) => {
+  enableDryRunIfNeeded(options);
   const spinner = ora2("Generating routes...").start();
   try {
     const kebabName = toKebabCase(name);
@@ -1826,8 +2506,8 @@ generateCommand.command("routes <name>").description("Generate routes").option("
     const camelName = toCamelCase(name);
     const pluralName = pluralize(kebabName);
     const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = path3.join(getModulesDir(), moduleName);
-    const filePath = path3.join(moduleDir, `${kebabName}.routes.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.routes.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Routes file "${kebabName}.routes.ts" already exists`);
@@ -1836,6 +2516,7 @@ generateCommand.command("routes <name>").description("Generate routes").option("
     await writeFile(filePath, routesTemplate(kebabName, pascalName, camelName, pluralName));
     spinner.succeed(`Routes for "${pascalName}" generated!`);
     success(`  src/modules/${moduleName}/${kebabName}.routes.ts`);
+    showDryRunSummary(options);
   } catch (err) {
     spinner.fail("Failed to generate routes");
     error(err instanceof Error ? err.message : String(err));
@@ -1913,22 +2594,24 @@ async function promptForFields() {
 }
 
 // src/cli/commands/add-module.ts
+init_esm_shims();
 import { Command as Command3 } from "commander";
-import path6 from "path";
+import path8 from "path";
 import ora3 from "ora";
-import chalk4 from "chalk";
+import chalk7 from "chalk";
 import * as fs5 from "fs/promises";
 
 // src/cli/utils/env-manager.ts
+init_esm_shims();
 import * as fs3 from "fs/promises";
-import * as path4 from "path";
+import * as path6 from "path";
 import { existsSync } from "fs";
 var EnvManager = class {
   envPath;
   envExamplePath;
   constructor(projectRoot) {
-    this.envPath = path4.join(projectRoot, ".env");
-    this.envExamplePath = path4.join(projectRoot, ".env.example");
+    this.envPath = path6.join(projectRoot, ".env");
+    this.envExamplePath = path6.join(projectRoot, ".env.example");
   }
   /**
    * Add environment variables to .env file
@@ -1936,12 +2619,12 @@ var EnvManager = class {
   async addVariables(sections) {
     const added = [];
     const skipped = [];
-    let created = false;
+    let created2 = false;
     let envContent = "";
     if (existsSync(this.envPath)) {
       envContent = await fs3.readFile(this.envPath, "utf-8");
     } else {
-      created = true;
+      created2 = true;
     }
     const existingKeys = this.parseExistingKeys(envContent);
     let newContent = envContent;
@@ -1972,7 +2655,7 @@ var EnvManager = class {
     if (existsSync(this.envExamplePath)) {
       await this.updateEnvExample(sections);
     }
-    return { added, skipped, created };
+    return { added, skipped, created: created2 };
   }
   /**
    * Update .env.example file
@@ -2578,16 +3261,17 @@ var EnvManager = class {
 };
 
 // src/cli/utils/template-manager.ts
+init_esm_shims();
 import * as fs4 from "fs/promises";
-import * as path5 from "path";
+import * as path7 from "path";
 import { createHash } from "crypto";
 import { existsSync as existsSync2 } from "fs";
 var TemplateManager = class {
   templatesDir;
   manifestsDir;
   constructor(projectRoot) {
-    this.templatesDir = path5.join(projectRoot, ".servcraft", "templates");
-    this.manifestsDir = path5.join(projectRoot, ".servcraft", "manifests");
+    this.templatesDir = path7.join(projectRoot, ".servcraft", "templates");
+    this.manifestsDir = path7.join(projectRoot, ".servcraft", "manifests");
   }
   /**
    * Initialize template system
@@ -2601,10 +3285,10 @@ var TemplateManager = class {
    */
   async saveTemplate(moduleName, files) {
     await this.initialize();
-    const moduleTemplateDir = path5.join(this.templatesDir, moduleName);
+    const moduleTemplateDir = path7.join(this.templatesDir, moduleName);
     await fs4.mkdir(moduleTemplateDir, { recursive: true });
     for (const [fileName, content] of Object.entries(files)) {
-      const filePath = path5.join(moduleTemplateDir, fileName);
+      const filePath = path7.join(moduleTemplateDir, fileName);
       await fs4.writeFile(filePath, content, "utf-8");
     }
   }
@@ -2613,7 +3297,7 @@ var TemplateManager = class {
    */
   async getTemplate(moduleName, fileName) {
     try {
-      const filePath = path5.join(this.templatesDir, moduleName, fileName);
+      const filePath = path7.join(this.templatesDir, moduleName, fileName);
       return await fs4.readFile(filePath, "utf-8");
     } catch {
       return null;
@@ -2638,7 +3322,7 @@ var TemplateManager = class {
       installedAt: /* @__PURE__ */ new Date(),
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const manifestPath = path5.join(this.manifestsDir, `${moduleName}.json`);
+    const manifestPath = path7.join(this.manifestsDir, `${moduleName}.json`);
     await fs4.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   }
   /**
@@ -2646,7 +3330,7 @@ var TemplateManager = class {
    */
   async getManifest(moduleName) {
     try {
-      const manifestPath = path5.join(this.manifestsDir, `${moduleName}.json`);
+      const manifestPath = path7.join(this.manifestsDir, `${moduleName}.json`);
       const content = await fs4.readFile(manifestPath, "utf-8");
       return JSON.parse(content);
     } catch {
@@ -2675,7 +3359,7 @@ var TemplateManager = class {
     }
     const results = [];
     for (const [fileName, fileInfo] of Object.entries(manifest.files)) {
-      const filePath = path5.join(moduleDir, fileName);
+      const filePath = path7.join(moduleDir, fileName);
       if (!existsSync2(filePath)) {
         results.push({
           fileName,
@@ -2701,7 +3385,7 @@ var TemplateManager = class {
    */
   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}`);
+    const backupDir = path7.join(path7.dirname(moduleDir), `${moduleName}.backup-${timestamp}`);
     await this.copyDirectory(moduleDir, backupDir);
     return backupDir;
   }
@@ -2712,8 +3396,8 @@ var TemplateManager = class {
     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);
+      const srcPath = path7.join(src, entry.name);
+      const destPath = path7.join(dest, entry.name);
       if (entry.isDirectory()) {
         await this.copyDirectory(srcPath, destPath);
       } else {
@@ -2814,23 +3498,24 @@ var TemplateManager = class {
     }
     manifest.files = fileHashes;
     manifest.updatedAt = /* @__PURE__ */ new Date();
-    const manifestPath = path5.join(this.manifestsDir, `${moduleName}.json`);
+    const manifestPath = path7.join(this.manifestsDir, `${moduleName}.json`);
     await fs4.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   }
 };
 
 // src/cli/utils/interactive-prompt.ts
+init_esm_shims();
 import inquirer3 from "inquirer";
-import chalk3 from "chalk";
+import chalk6 from "chalk";
 var InteractivePrompt = class {
   /**
    * Ask what to do when module already exists
    */
   static async askModuleExists(moduleName, hasModifications) {
-    console.log(chalk3.yellow(`
+    console.log(chalk6.yellow(`
 \u26A0\uFE0F  Module "${moduleName}" already exists`));
     if (hasModifications) {
-      console.log(chalk3.yellow("   Some files have been modified by you.\n"));
+      console.log(chalk6.yellow("   Some files have been modified by you.\n"));
     }
     const { action } = await inquirer3.prompt([
       {
@@ -2868,12 +3553,12 @@ var InteractivePrompt = class {
    * Ask what to do with a specific file
    */
   static async askFileAction(fileName, isModified, yourLines, newLines) {
-    console.log(chalk3.cyan(`
+    console.log(chalk6.cyan(`
 \u{1F4C1} ${fileName}`));
     console.log(
-      chalk3.gray(`   Your version: ${yourLines} lines${isModified ? " (modified)" : ""}`)
+      chalk6.gray(`   Your version: ${yourLines} lines${isModified ? " (modified)" : ""}`)
     );
-    console.log(chalk3.gray(`   New version: ${newLines} lines
+    console.log(chalk6.gray(`   New version: ${newLines} lines
 `));
     const { action } = await inquirer3.prompt([
       {
@@ -2925,7 +3610,7 @@ var InteractivePrompt = class {
    * Display diff and ask to continue
    */
   static async showDiffAndAsk(diff) {
-    console.log(chalk3.cyan("\n\u{1F4CA} Differences:\n"));
+    console.log(chalk6.cyan("\n\u{1F4CA} Differences:\n"));
     console.log(diff);
     return await this.confirm("\nDo you want to proceed with this change?", true);
   }
@@ -2933,41 +3618,41 @@ var InteractivePrompt = class {
    * Display merge conflicts
    */
   static displayConflicts(conflicts) {
-    console.log(chalk3.red("\n\u26A0\uFE0F  Merge Conflicts Detected:\n"));
+    console.log(chalk6.red("\n\u26A0\uFE0F  Merge Conflicts Detected:\n"));
     conflicts.forEach((conflict, i) => {
-      console.log(chalk3.yellow(`   ${i + 1}. ${conflict}`));
+      console.log(chalk6.yellow(`   ${i + 1}. ${conflict}`));
     });
-    console.log(chalk3.gray("\n   Conflict markers have been added to the file:"));
-    console.log(chalk3.gray("   <<<<<<< YOUR VERSION"));
-    console.log(chalk3.gray("   ... your code ..."));
-    console.log(chalk3.gray("   ======="));
-    console.log(chalk3.gray("   ... new code ..."));
-    console.log(chalk3.gray("   >>>>>>> NEW VERSION\n"));
+    console.log(chalk6.gray("\n   Conflict markers have been added to the file:"));
+    console.log(chalk6.gray("   <<<<<<< YOUR VERSION"));
+    console.log(chalk6.gray("   ... your code ..."));
+    console.log(chalk6.gray("   ======="));
+    console.log(chalk6.gray("   ... new code ..."));
+    console.log(chalk6.gray("   >>>>>>> NEW VERSION\n"));
   }
   /**
    * Show backup location
    */
   static showBackupCreated(backupPath) {
-    console.log(chalk3.green(`
-\u2713 Backup created: ${chalk3.cyan(backupPath)}`));
+    console.log(chalk6.green(`
+\u2713 Backup created: ${chalk6.cyan(backupPath)}`));
   }
   /**
    * Show merge summary
    */
   static showMergeSummary(stats) {
-    console.log(chalk3.bold("\n\u{1F4CA} Merge Summary:\n"));
+    console.log(chalk6.bold("\n\u{1F4CA} Merge Summary:\n"));
     if (stats.merged > 0) {
-      console.log(chalk3.green(`   \u2713 Merged: ${stats.merged} file(s)`));
+      console.log(chalk6.green(`   \u2713 Merged: ${stats.merged} file(s)`));
     }
     if (stats.kept > 0) {
-      console.log(chalk3.blue(`   \u2192 Kept: ${stats.kept} file(s)`));
+      console.log(chalk6.blue(`   \u2192 Kept: ${stats.kept} file(s)`));
     }
     if (stats.overwritten > 0) {
-      console.log(chalk3.yellow(`   \u26A0 Overwritten: ${stats.overwritten} file(s)`));
+      console.log(chalk6.yellow(`   \u26A0 Overwritten: ${stats.overwritten} file(s)`));
     }
     if (stats.conflicts > 0) {
-      console.log(chalk3.red(`   \u26A0 Conflicts: ${stats.conflicts} file(s)`));
-      console.log(chalk3.gray("\n   Please resolve conflicts manually before committing.\n"));
+      console.log(chalk6.red(`   \u26A0 Conflicts: ${stats.conflicts} file(s)`));
+      console.log(chalk6.gray("\n   Please resolve conflicts manually before committing.\n"));
     }
   }
   /**
@@ -3005,6 +3690,7 @@ var InteractivePrompt = class {
 };
 
 // src/cli/commands/add-module.ts
+init_error_handler();
 var AVAILABLE_MODULES = {
   auth: {
     name: "Authentication",
@@ -3139,31 +3825,40 @@ var AVAILABLE_MODULES = {
 var addModuleCommand = new Command3("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(
+).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").option("--dry-run", "Preview changes without writing files").action(
   async (moduleName, options) => {
     if (options?.list || !moduleName) {
-      console.log(chalk4.bold("\n\u{1F4E6} Available Modules:\n"));
+      console.log(chalk7.bold("\n\u{1F4E6} Available Modules:\n"));
       for (const [key, mod] of Object.entries(AVAILABLE_MODULES)) {
-        console.log(`  ${chalk4.cyan(key.padEnd(15))} ${mod.name}`);
-        console.log(`  ${" ".repeat(15)} ${chalk4.gray(mod.description)}
+        console.log(`  ${chalk7.cyan(key.padEnd(15))} ${mod.name}`);
+        console.log(`  ${" ".repeat(15)} ${chalk7.gray(mod.description)}
 `);
       }
-      console.log(chalk4.bold("Usage:"));
-      console.log(`  ${chalk4.yellow("servcraft add auth")}      Add authentication module`);
-      console.log(`  ${chalk4.yellow("servcraft add users")}     Add user management module`);
-      console.log(`  ${chalk4.yellow("servcraft add email")}     Add email service module
+      console.log(chalk7.bold("Usage:"));
+      console.log(`  ${chalk7.yellow("servcraft add auth")}      Add authentication module`);
+      console.log(`  ${chalk7.yellow("servcraft add users")}     Add user management module`);
+      console.log(`  ${chalk7.yellow("servcraft add email")}     Add email service module
 `);
       return;
     }
+    const dryRun = DryRunManager.getInstance();
+    if (options?.dryRun) {
+      dryRun.enable();
+      console.log(chalk7.yellow("\n\u26A0 DRY RUN MODE - No files will be written\n"));
+    }
     const module = AVAILABLE_MODULES[moduleName];
     if (!module) {
-      error(`Unknown module: ${moduleName}`);
-      info('Run "servcraft add --list" to see available modules');
+      displayError(ErrorTypes.MODULE_NOT_FOUND(moduleName));
+      return;
+    }
+    const projectError = validateProject();
+    if (projectError) {
+      displayError(projectError);
       return;
     }
     const spinner = ora3(`Adding ${module.name} module...`).start();
     try {
-      const moduleDir = path6.join(getModulesDir(), moduleName);
+      const moduleDir = path8.join(getModulesDir(), moduleName);
       const templateManager = new TemplateManager(process.cwd());
       const moduleExists = await fileExists(moduleDir);
       if (moduleExists) {
@@ -3231,16 +3926,16 @@ var addModuleCommand = new Command3("add").description("Add a pre-built module t
             info("\n\u{1F4DD} Created new .env file");
           }
           if (result.added.length > 0) {
-            console.log(chalk4.bold("\n\u2705 Added to .env:"));
+            console.log(chalk7.bold("\n\u2705 Added to .env:"));
             result.added.forEach((key) => success(`  ${key}`));
           }
           if (result.skipped.length > 0) {
-            console.log(chalk4.bold("\n\u23ED\uFE0F  Already in .env (skipped):"));
+            console.log(chalk7.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(chalk4.bold("\n\u26A0\uFE0F  Required configuration:"));
+            console.log(chalk7.bold("\n\u26A0\uFE0F  Required configuration:"));
             requiredVars.forEach((key) => warn(`  ${key} - Please configure this variable`));
           }
         } catch (err) {
@@ -3248,10 +3943,15 @@ var addModuleCommand = new Command3("add").description("Add a pre-built module t
           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");
+      if (!options?.dryRun) {
+        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");
+      }
+      if (options?.dryRun) {
+        dryRun.printSummary();
+      }
     } catch (err) {
       spinner.fail("Failed to add module");
       error(err instanceof Error ? err.message : String(err));
@@ -3302,7 +4002,7 @@ export * from './auth.schemas.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path6.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateUsersModule(dir) {
@@ -3342,7 +4042,7 @@ export * from './user.schemas.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path6.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateEmailModule(dir) {
@@ -3399,7 +4099,7 @@ export { EmailService, emailService } from './email.service.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path6.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateAuditModule(dir) {
@@ -3443,7 +4143,7 @@ export { AuditService, auditService } from './audit.service.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path6.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateUploadModule(dir) {
@@ -3469,7 +4169,7 @@ export interface UploadOptions {
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path6.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateCacheModule(dir) {
@@ -3515,7 +4215,7 @@ export { CacheService, cacheService } from './cache.service.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path6.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateGenericModule(dir, name) {
@@ -3529,18 +4229,18 @@ export interface ${name.charAt(0).toUpperCase() + name.slice(1)}Data {
 `
   };
   for (const [fileName, content] of Object.entries(files)) {
-    await writeFile(path6.join(dir, fileName), content);
+    await writeFile(path8.join(dir, fileName), content);
   }
 }
 async function findServercraftModules() {
-  const scriptDir = path6.dirname(new URL(import.meta.url).pathname);
+  const scriptDir = path8.dirname(new URL(import.meta.url).pathname);
   const possiblePaths = [
     // Local node_modules (when servcraft is a dependency)
-    path6.join(process.cwd(), "node_modules", "servcraft", "src", "modules"),
+    path8.join(process.cwd(), "node_modules", "servcraft", "src", "modules"),
     // From dist/cli/index.js -> src/modules (npx or global install)
-    path6.resolve(scriptDir, "..", "..", "src", "modules"),
+    path8.resolve(scriptDir, "..", "..", "src", "modules"),
     // From src/cli/commands/add-module.ts -> src/modules (development)
-    path6.resolve(scriptDir, "..", "..", "modules")
+    path8.resolve(scriptDir, "..", "..", "modules")
   ];
   for (const p of possiblePaths) {
     try {
@@ -3555,7 +4255,7 @@ async function findServercraftModules() {
 }
 async function generateModuleFiles(moduleName, moduleDir) {
   const moduleNameMap = {
-    "users": "user",
+    users: "user",
     "rate-limit": "rate-limit",
     "feature-flag": "feature-flag",
     "api-versioning": "api-versioning",
@@ -3564,7 +4264,7 @@ async function generateModuleFiles(moduleName, moduleDir) {
   const sourceDirName = moduleNameMap[moduleName] || moduleName;
   const servercraftModulesDir = await findServercraftModules();
   if (servercraftModulesDir) {
-    const sourceModuleDir = path6.join(servercraftModulesDir, sourceDirName);
+    const sourceModuleDir = path8.join(servercraftModulesDir, sourceDirName);
     if (await fileExists(sourceModuleDir)) {
       await copyModuleFromSource(sourceModuleDir, moduleDir);
       return;
@@ -3596,8 +4296,8 @@ async function generateModuleFiles(moduleName, moduleDir) {
 async function copyModuleFromSource(sourceDir, targetDir) {
   const entries = await fs5.readdir(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = path6.join(sourceDir, entry.name);
-    const targetPath = path6.join(targetDir, entry.name);
+    const sourcePath = path8.join(sourceDir, entry.name);
+    const targetPath = path8.join(targetDir, entry.name);
     if (entry.isDirectory()) {
       await fs5.mkdir(targetPath, { recursive: true });
       await copyModuleFromSource(sourcePath, targetPath);
@@ -3610,7 +4310,7 @@ async function getModuleFiles(moduleName, moduleDir) {
   const files = {};
   const entries = await fs5.readdir(moduleDir);
   for (const entry of entries) {
-    const filePath = path6.join(moduleDir, entry);
+    const filePath = path8.join(moduleDir, entry);
     const stat2 = await fs5.stat(filePath);
     if (stat2.isFile() && entry.endsWith(".ts")) {
       const content = await fs5.readFile(filePath, "utf-8");
@@ -3621,14 +4321,14 @@ async function getModuleFiles(moduleName, moduleDir) {
 }
 async function showDiffForModule(templateManager, moduleName, moduleDir) {
   const modifiedFiles = await templateManager.getModifiedFiles(moduleName, moduleDir);
-  console.log(chalk4.cyan(`
+  console.log(chalk7.cyan(`
 \u{1F4CA} Changes in module "${moduleName}":
 `));
   for (const file of modifiedFiles) {
     if (file.isModified) {
-      console.log(chalk4.yellow(`
+      console.log(chalk7.yellow(`
 \u{1F4C4} ${file.fileName}:`));
-      const currentPath = path6.join(moduleDir, file.fileName);
+      const currentPath = path8.join(moduleDir, file.fileName);
       const currentContent = await fs5.readFile(currentPath, "utf-8");
       const originalContent = await templateManager.getTemplate(moduleName, file.fileName);
       if (originalContent) {
@@ -3641,11 +4341,11 @@ async function showDiffForModule(templateManager, moduleName, moduleDir) {
 async function performSmartMerge(templateManager, moduleName, moduleDir, _displayName) {
   const spinner = ora3("Analyzing files for merge...").start();
   const newFiles = {};
-  const templateDir = path6.join(templateManager["templatesDir"], moduleName);
+  const templateDir = path8.join(templateManager["templatesDir"], moduleName);
   try {
     const entries = await fs5.readdir(templateDir);
     for (const entry of entries) {
-      const content = await fs5.readFile(path6.join(templateDir, entry), "utf-8");
+      const content = await fs5.readFile(path8.join(templateDir, entry), "utf-8");
       newFiles[entry] = content;
     }
   } catch {
@@ -3663,7 +4363,7 @@ async function performSmartMerge(templateManager, moduleName, moduleDir, _displa
   };
   for (const fileInfo of modifiedFiles) {
     const fileName = fileInfo.fileName;
-    const filePath = path6.join(moduleDir, fileName);
+    const filePath = path8.join(moduleDir, fileName);
     const newContent = newFiles[fileName];
     if (!newContent) {
       continue;
@@ -3732,10 +4432,11 @@ async function performSmartMerge(templateManager, moduleName, moduleDir, _displa
 }
 
 // src/cli/commands/db.ts
+init_esm_shims();
 import { Command as Command4 } from "commander";
 import { execSync as execSync2, spawn } from "child_process";
 import ora4 from "ora";
-import chalk5 from "chalk";
+import chalk8 from "chalk";
 var dbCommand = new Command4("db").description("Database management commands");
 dbCommand.command("migrate").description("Run database migrations").option("-n, --name <name>", "Migration name").action(async (options) => {
   const spinner = ora4("Running migrations...").start();
@@ -3792,7 +4493,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(chalk5.yellow("\n\u26A0\uFE0F  WARNING: This will delete all data in your database!\n"));
+    console.log(chalk8.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,
@@ -3824,12 +4525,2149 @@ dbCommand.command("status").description("Show migration status").action(async ()
   }
 });
 
+// src/cli/commands/docs.ts
+init_esm_shims();
+import { Command as Command5 } from "commander";
+import path10 from "path";
+import fs7 from "fs/promises";
+import ora6 from "ora";
+import chalk9 from "chalk";
+
+// src/cli/utils/docs-generator.ts
+init_esm_shims();
+import fs6 from "fs/promises";
+import path9 from "path";
+import ora5 from "ora";
+
+// src/core/server.ts
+init_esm_shims();
+import Fastify from "fastify";
+
+// src/core/logger.ts
+init_esm_shims();
+import pino from "pino";
+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 pino({
+    name: mergedConfig.name,
+    level: mergedConfig.level,
+    transport,
+    formatters: {
+      level: (label) => ({ level: label })
+    },
+    timestamp: pino.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 = Fastify(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);
+    });
+  }
+  async shutdown(exitCode = 0) {
+    if (this.isShuttingDown) {
+      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);
+    }
+  }
+  async start() {
+    try {
+      await this.app.listen({
+        port: this.config.port,
+        host: this.config.host
+      });
+      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/middleware/index.ts
+init_esm_shims();
+
+// src/middleware/error-handler.ts
+init_esm_shims();
+
+// src/utils/errors.ts
+init_esm_shims();
+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 _NotFoundError extends AppError {
+  constructor(resource = "Resource") {
+    super(`${resource} not found`, 404);
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+var UnauthorizedError = class _UnauthorizedError extends AppError {
+  constructor(message = "Unauthorized") {
+    super(message, 401);
+    Object.setPrototypeOf(this, _UnauthorizedError.prototype);
+  }
+};
+var ForbiddenError = class _ForbiddenError extends AppError {
+  constructor(message = "Forbidden") {
+    super(message, 403);
+    Object.setPrototypeOf(this, _ForbiddenError.prototype);
+  }
+};
+var BadRequestError = class _BadRequestError extends AppError {
+  constructor(message = "Bad request", errors) {
+    super(message, 400, true, errors);
+    Object.setPrototypeOf(this, _BadRequestError.prototype);
+  }
+};
+var ConflictError = class _ConflictError extends AppError {
+  constructor(message = "Resource already exists") {
+    super(message, 409);
+    Object.setPrototypeOf(this, _ConflictError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends AppError {
+  constructor(errors) {
+    super("Validation failed", 422, true, errors);
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+function isAppError(error2) {
+  return error2 instanceof AppError;
+}
+
+// src/config/index.ts
+init_esm_shims();
+
+// src/config/env.ts
+init_esm_shims();
+import { z } from "zod";
+import dotenv from "dotenv";
+dotenv.config();
+var envSchema = z.object({
+  // Server
+  NODE_ENV: z.enum(["development", "staging", "production", "test"]).default("development"),
+  PORT: z.string().transform(Number).default("3000"),
+  HOST: z.string().default("0.0.0.0"),
+  // Database
+  DATABASE_URL: z.string().optional(),
+  // JWT
+  JWT_SECRET: z.string().min(32).optional(),
+  JWT_ACCESS_EXPIRES_IN: z.string().default("15m"),
+  JWT_REFRESH_EXPIRES_IN: z.string().default("7d"),
+  // Security
+  CORS_ORIGIN: z.string().default("*"),
+  RATE_LIMIT_MAX: z.string().transform(Number).default("100"),
+  RATE_LIMIT_WINDOW_MS: z.string().transform(Number).default("60000"),
+  // Email
+  SMTP_HOST: z.string().optional(),
+  SMTP_PORT: z.string().transform(Number).optional(),
+  SMTP_USER: z.string().optional(),
+  SMTP_PASS: z.string().optional(),
+  SMTP_FROM: z.string().optional(),
+  // Redis (optional)
+  REDIS_URL: z.string().optional(),
+  // Logging
+  LOG_LEVEL: 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
+    }
+  };
+}
+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
+init_esm_shims();
+import helmet from "@fastify/helmet";
+import cors from "@fastify/cors";
+import rateLimit from "@fastify/rate-limit";
+var defaultOptions = {
+  helmet: true,
+  cors: true,
+  rateLimit: true
+};
+async function registerSecurity(app, options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  if (opts.helmet) {
+    await app.register(helmet, {
+      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(cors, {
+      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(rateLimit, {
+      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/index.ts
+init_esm_shims();
+
+// src/modules/swagger/swagger.service.ts
+init_esm_shims();
+import swagger from "@fastify/swagger";
+import swaggerUi from "@fastify/swagger-ui";
+var defaultConfig3 = {
+  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 };
+  await app.register(swagger, {
+    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(swaggerUi, {
+    routePrefix: "/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");
+}
+
+// src/modules/swagger/schema-builder.ts
+init_esm_shims();
+
+// src/modules/auth/index.ts
+init_esm_shims();
+import jwt from "@fastify/jwt";
+import cookie from "@fastify/cookie";
+
+// src/modules/auth/auth.service.ts
+init_esm_shims();
+import bcrypt from "bcryptjs";
+import { Redis } from "ioredis";
+var AuthService = class {
+  app;
+  SALT_ROUNDS = 12;
+  redis = null;
+  BLACKLIST_PREFIX = "auth:blacklist:";
+  BLACKLIST_TTL = 7 * 24 * 60 * 60;
+  // 7 days in seconds
+  constructor(app, redisUrl) {
+    this.app = app;
+    if (redisUrl || process.env.REDIS_URL) {
+      try {
+        this.redis = new Redis(redisUrl || process.env.REDIS_URL || "redis://localhost:6379");
+        this.redis.on("connect", () => {
+          logger.info("Auth service connected to Redis for token blacklist");
+        });
+        this.redis.on("error", (error2) => {
+          logger.error({ err: error2 }, "Redis connection error in Auth service");
+        });
+      } catch (error2) {
+        logger.warn({ err: error2 }, "Failed to connect to Redis, using in-memory blacklist");
+        this.redis = null;
+      }
+    } else {
+      logger.warn(
+        "No REDIS_URL provided, using in-memory token blacklist (not recommended for production)"
+      );
+    }
+  }
+  async hashPassword(password) {
+    return bcrypt.hash(password, this.SALT_ROUNDS);
+  }
+  async verifyPassword(password, hash) {
+    return bcrypt.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 (await 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 (await 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");
+    }
+  }
+  /**
+   * Blacklist a token (JWT revocation)
+   * Uses Redis if available, falls back to in-memory Set
+   */
+  async blacklistToken(token) {
+    if (this.redis) {
+      try {
+        const key = `${this.BLACKLIST_PREFIX}${token}`;
+        await this.redis.setex(key, this.BLACKLIST_TTL, "1");
+        logger.debug("Token blacklisted in Redis");
+      } catch (error2) {
+        logger.error({ err: error2 }, "Failed to blacklist token in Redis");
+        throw new Error("Failed to revoke token");
+      }
+    } else {
+      logger.warn("Using in-memory blacklist - not suitable for multi-instance deployments");
+    }
+  }
+  /**
+   * Check if a token is blacklisted
+   * Uses Redis if available, falls back to always returning false
+   */
+  async isTokenBlacklisted(token) {
+    if (this.redis) {
+      try {
+        const key = `${this.BLACKLIST_PREFIX}${token}`;
+        const result = await this.redis.exists(key);
+        return result === 1;
+      } catch (error2) {
+        logger.error({ err: error2 }, "Failed to check token blacklist in Redis");
+        return false;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get count of blacklisted tokens (Redis only)
+   */
+  async getBlacklistCount() {
+    if (this.redis) {
+      try {
+        const keys = await this.redis.keys(`${this.BLACKLIST_PREFIX}*`);
+        return keys.length;
+      } catch (error2) {
+        logger.error({ err: error2 }, "Failed to get blacklist count from Redis");
+        return 0;
+      }
+    }
+    return 0;
+  }
+  /**
+   * Close Redis connection
+   */
+  async close() {
+    if (this.redis) {
+      await this.redis.quit();
+      logger.info("Auth service Redis connection closed");
+    }
+  }
+  // OAuth support methods - to be implemented with user repository
+  async findUserByEmail(_email) {
+    return null;
+  }
+  async createUserFromOAuth(data) {
+    const user = {
+      id: `oauth_${Date.now()}`,
+      email: data.email,
+      role: "user"
+    };
+    logger.info({ email: data.email }, "Created user from OAuth");
+    return user;
+  }
+  async generateTokensForUser(userId) {
+    const user = {
+      id: userId,
+      email: "",
+      // Would be fetched from database in production
+      role: "user"
+    };
+    return this.generateTokenPair(user);
+  }
+  async verifyPasswordById(userId, _password) {
+    logger.debug({ userId }, "Password verification requested");
+    return false;
+  }
+};
+function createAuthService(app) {
+  return new AuthService(app);
+}
+
+// src/modules/auth/auth.controller.ts
+init_esm_shims();
+
+// src/modules/auth/schemas.ts
+init_esm_shims();
+import { z as z2 } from "zod";
+var loginSchema = z2.object({
+  email: z2.string().email("Invalid email address"),
+  password: z2.string().min(1, "Password is required")
+});
+var registerSchema = z2.object({
+  email: z2.string().email("Invalid email address"),
+  password: z2.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: z2.string().min(2, "Name must be at least 2 characters").optional()
+});
+var refreshTokenSchema = z2.object({
+  refreshToken: z2.string().min(1, "Refresh token is required")
+});
+var passwordResetRequestSchema = z2.object({
+  email: z2.string().email("Invalid email address")
+});
+var passwordResetConfirmSchema = z2.object({
+  token: z2.string().min(1, "Token is required"),
+  password: z2.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 = z2.object({
+  currentPassword: z2.string().min(1, "Current password is required"),
+  newPassword: z2.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
+init_esm_shims();
+function success2(reply, data, statusCode = 200) {
+  const response = {
+    success: true,
+    data
+  };
+  return reply.status(statusCode).send(response);
+}
+function created(reply, data) {
+  return success2(reply, data, 201);
+}
+function noContent(reply) {
+  return reply.status(204).send();
+}
+
+// src/modules/validation/validator.ts
+init_esm_shims();
+import { z as z3 } from "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 path12 = issue.path.join(".") || "root";
+    if (!errors[path12]) {
+      errors[path12] = [];
+    }
+    errors[path12].push(issue.message);
+  }
+  return errors;
+}
+var idParamSchema = z3.object({
+  id: z3.string().uuid("Invalid ID format")
+});
+var paginationSchema = z3.object({
+  page: z3.string().transform(Number).optional().default("1"),
+  limit: z3.string().transform(Number).optional().default("20"),
+  sortBy: z3.string().optional(),
+  sortOrder: z3.enum(["asc", "desc"]).optional().default("asc")
+});
+var searchSchema = z3.object({
+  q: z3.string().min(1, "Search query is required").optional(),
+  search: z3.string().min(1).optional()
+});
+var emailSchema = z3.string().email("Invalid email address");
+var passwordSchema = z3.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 = z3.string().url("Invalid URL format");
+var phoneSchema = z3.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number format");
+var dateSchema = z3.coerce.date();
+var futureDateSchema = z3.coerce.date().refine((date) => date > /* @__PURE__ */ new Date(), "Date must be in the future");
+var pastDateSchema = z3.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
+    });
+    success2(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");
+    }
+    await this.authService.blacklistToken(data.refreshToken);
+    const tokens = this.authService.generateTokenPair({
+      id: user.id,
+      email: user.email,
+      role: user.role
+    });
+    success2(reply, tokens);
+  }
+  async logout(request, reply) {
+    const authHeader = request.headers.authorization;
+    if (authHeader?.startsWith("Bearer ")) {
+      const token = authHeader.substring(7);
+      await this.authService.blacklistToken(token);
+    }
+    success2(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");
+    }
+    success2(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);
+    success2(reply, { message: "Password changed successfully" });
+  }
+};
+function createAuthController(authService, userService) {
+  return new AuthController(authService, userService);
+}
+
+// src/modules/auth/auth.routes.ts
+init_esm_shims();
+
+// src/modules/auth/auth.middleware.ts
+init_esm_shims();
+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
+function registerAuthRoutes(app, controller, authService) {
+  const authenticate = createAuthMiddleware(authService);
+  app.post("/auth/register", controller.register.bind(controller));
+  app.post("/auth/login", controller.login.bind(controller));
+  app.post("/auth/refresh", controller.refresh.bind(controller));
+  app.post("/auth/logout", { preHandler: [authenticate] }, controller.logout.bind(controller));
+  app.get("/auth/me", { preHandler: [authenticate] }, controller.me.bind(controller));
+  app.post(
+    "/auth/change-password",
+    { preHandler: [authenticate] },
+    controller.changePassword.bind(controller)
+  );
+}
+
+// src/modules/user/user.service.ts
+init_esm_shims();
+
+// src/modules/user/user.repository.ts
+init_esm_shims();
+
+// src/database/prisma.ts
+init_esm_shims();
+import { PrismaClient } from "@prisma/client";
+var prismaClientSingleton = () => {
+  return new PrismaClient({
+    log: isProduction() ? ["error"] : ["query", "info", "warn", "error"],
+    errorFormat: isProduction() ? "minimal" : "pretty"
+  });
+};
+var prisma = globalThis.__prisma ?? prismaClientSingleton();
+if (!isProduction()) {
+  globalThis.__prisma = prisma;
+}
+
+// src/utils/pagination.ts
+init_esm_shims();
+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
+import { UserRole, UserStatus } from "@prisma/client";
+var UserRepository = class {
+  /**
+   * Find user by ID
+   */
+  async findById(id) {
+    const user = await prisma.user.findUnique({
+      where: { id }
+    });
+    if (!user) return null;
+    return this.mapPrismaUserToUser(user);
+  }
+  /**
+   * Find user by email (case-insensitive)
+   */
+  async findByEmail(email) {
+    const user = await prisma.user.findUnique({
+      where: { email: email.toLowerCase() }
+    });
+    if (!user) return null;
+    return this.mapPrismaUserToUser(user);
+  }
+  /**
+   * Find multiple users with pagination and filters
+   */
+  async findMany(params, filters) {
+    const where = this.buildWhereClause(filters);
+    const orderBy = this.buildOrderBy(params);
+    const [data, total] = await Promise.all([
+      prisma.user.findMany({
+        where,
+        orderBy,
+        skip: getSkip(params),
+        take: params.limit
+      }),
+      prisma.user.count({ where })
+    ]);
+    const mappedUsers = data.map((user) => this.mapPrismaUserToUser(user));
+    return createPaginatedResult(mappedUsers, total, params);
+  }
+  /**
+   * Create a new user
+   */
+  async create(data) {
+    const user = await prisma.user.create({
+      data: {
+        email: data.email.toLowerCase(),
+        password: data.password,
+        name: data.name,
+        role: this.mapRoleToEnum(data.role || "user"),
+        status: UserStatus.ACTIVE,
+        emailVerified: false
+      }
+    });
+    return this.mapPrismaUserToUser(user);
+  }
+  /**
+   * Update user data
+   */
+  async update(id, data) {
+    try {
+      const user = await prisma.user.update({
+        where: { id },
+        data: {
+          ...data.email && { email: data.email.toLowerCase() },
+          ...data.name !== void 0 && { name: data.name },
+          ...data.role && { role: this.mapRoleToEnum(data.role) },
+          ...data.status && { status: this.mapStatusToEnum(data.status) },
+          ...data.emailVerified !== void 0 && { emailVerified: data.emailVerified },
+          ...data.metadata && { metadata: data.metadata }
+        }
+      });
+      return this.mapPrismaUserToUser(user);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Update user password
+   */
+  async updatePassword(id, password) {
+    try {
+      const user = await prisma.user.update({
+        where: { id },
+        data: { password }
+      });
+      return this.mapPrismaUserToUser(user);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Update last login timestamp
+   */
+  async updateLastLogin(id) {
+    try {
+      const user = await prisma.user.update({
+        where: { id },
+        data: { lastLoginAt: /* @__PURE__ */ new Date() }
+      });
+      return this.mapPrismaUserToUser(user);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Delete user by ID
+   */
+  async delete(id) {
+    try {
+      await prisma.user.delete({
+        where: { id }
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Count users with optional filters
+   */
+  async count(filters) {
+    const where = this.buildWhereClause(filters);
+    return prisma.user.count({ where });
+  }
+  /**
+   * Helper to clear all users (for testing only)
+   * WARNING: This deletes all users from the database
+   */
+  async clear() {
+    await prisma.user.deleteMany();
+  }
+  /**
+   * Build Prisma where clause from filters
+   */
+  buildWhereClause(filters) {
+    if (!filters) return {};
+    return {
+      ...filters.status && { status: this.mapStatusToEnum(filters.status) },
+      ...filters.role && { role: this.mapRoleToEnum(filters.role) },
+      ...filters.emailVerified !== void 0 && { emailVerified: filters.emailVerified },
+      ...filters.search && {
+        OR: [
+          { email: { contains: filters.search, mode: "insensitive" } },
+          { name: { contains: filters.search, mode: "insensitive" } }
+        ]
+      }
+    };
+  }
+  /**
+   * Build Prisma orderBy clause from pagination params
+   */
+  buildOrderBy(params) {
+    if (!params.sortBy) {
+      return { createdAt: "desc" };
+    }
+    return {
+      [params.sortBy]: params.sortOrder || "asc"
+    };
+  }
+  /**
+   * Map Prisma User to application User type
+   */
+  mapPrismaUserToUser(prismaUser) {
+    return {
+      id: prismaUser.id,
+      email: prismaUser.email,
+      password: prismaUser.password,
+      name: prismaUser.name ?? void 0,
+      role: this.mapEnumToRole(prismaUser.role),
+      status: this.mapEnumToStatus(prismaUser.status),
+      emailVerified: prismaUser.emailVerified,
+      lastLoginAt: prismaUser.lastLoginAt ?? void 0,
+      metadata: prismaUser.metadata,
+      createdAt: prismaUser.createdAt,
+      updatedAt: prismaUser.updatedAt
+    };
+  }
+  /**
+   * Map application role to Prisma enum
+   */
+  mapRoleToEnum(role) {
+    const roleMap = {
+      user: UserRole.USER,
+      moderator: UserRole.MODERATOR,
+      admin: UserRole.ADMIN,
+      super_admin: UserRole.SUPER_ADMIN
+    };
+    return roleMap[role] || UserRole.USER;
+  }
+  /**
+   * Map Prisma enum to application role
+   */
+  mapEnumToRole(role) {
+    const roleMap = {
+      [UserRole.USER]: "user",
+      [UserRole.MODERATOR]: "moderator",
+      [UserRole.ADMIN]: "admin",
+      [UserRole.SUPER_ADMIN]: "super_admin"
+    };
+    return roleMap[role];
+  }
+  /**
+   * Map application status to Prisma enum
+   */
+  mapStatusToEnum(status) {
+    const statusMap = {
+      active: UserStatus.ACTIVE,
+      inactive: UserStatus.INACTIVE,
+      suspended: UserStatus.SUSPENDED,
+      banned: UserStatus.BANNED
+    };
+    return statusMap[status] || UserStatus.ACTIVE;
+  }
+  /**
+   * Map Prisma enum to application status
+   */
+  mapEnumToStatus(status) {
+    const statusMap = {
+      [UserStatus.ACTIVE]: "active",
+      [UserStatus.INACTIVE]: "inactive",
+      [UserStatus.SUSPENDED]: "suspended",
+      [UserStatus.BANNED]: "banned"
+    };
+    return statusMap[status];
+  }
+};
+function createUserRepository() {
+  return new UserRepository();
+}
+
+// src/modules/user/types.ts
+init_esm_shims();
+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: _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] = 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/types.ts
+init_esm_shims();
+
+// src/modules/auth/index.ts
+async function registerAuthModule(app) {
+  await app.register(jwt, {
+    secret: config.jwt.secret,
+    sign: {
+      algorithm: "HS256"
+    }
+  });
+  await app.register(cookie, {
+    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");
+}
+
+// src/modules/user/index.ts
+init_esm_shims();
+
+// src/modules/user/user.controller.ts
+init_esm_shims();
+
+// src/modules/user/schemas.ts
+init_esm_shims();
+import { z as z4 } from "zod";
+var userStatusEnum = z4.enum(["active", "inactive", "suspended", "banned"]);
+var userRoleEnum = z4.enum(["user", "admin", "moderator", "super_admin"]);
+var createUserSchema = z4.object({
+  email: z4.string().email("Invalid email address"),
+  password: z4.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: z4.string().min(2, "Name must be at least 2 characters").optional(),
+  role: userRoleEnum.optional().default("user")
+});
+var updateUserSchema = z4.object({
+  email: z4.string().email("Invalid email address").optional(),
+  name: z4.string().min(2, "Name must be at least 2 characters").optional(),
+  role: userRoleEnum.optional(),
+  status: userStatusEnum.optional(),
+  emailVerified: z4.boolean().optional(),
+  metadata: z4.record(z4.unknown()).optional()
+});
+var updateProfileSchema = z4.object({
+  name: z4.string().min(2, "Name must be at least 2 characters").optional(),
+  metadata: z4.record(z4.unknown()).optional()
+});
+var userQuerySchema = z4.object({
+  page: z4.string().transform(Number).optional(),
+  limit: z4.string().transform(Number).optional(),
+  sortBy: z4.string().optional(),
+  sortOrder: z4.enum(["asc", "desc"]).optional(),
+  status: userStatusEnum.optional(),
+  role: userRoleEnum.optional(),
+  search: z4.string().optional(),
+  emailVerified: z4.string().transform((val) => val === "true").optional()
+});
+
+// src/modules/user/user.controller.ts
+function omitPassword(user) {
+  const { password, ...userData } = user;
+  void password;
+  return userData;
+}
+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);
+    success2(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"
+      });
+    }
+    success2(reply, omitPassword(user));
+  }
+  async update(request, reply) {
+    const data = validateBody(updateUserSchema, request.body);
+    const user = await this.userService.update(request.params.id, data);
+    success2(reply, omitPassword(user));
+  }
+  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 userData = omitPassword(user);
+    success2(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 userData = omitPassword(user);
+    success2(reply, userData);
+  }
+  async activate(request, reply) {
+    const user = await this.userService.activate(request.params.id);
+    const userData = omitPassword(user);
+    success2(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 userData = omitPassword(user);
+    success2(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 userData = omitPassword(user);
+    success2(reply, userData);
+  }
+};
+function createUserController(userService) {
+  return new UserController(userService);
+}
+
+// src/modules/user/user.routes.ts
+init_esm_shims();
+var idParamsSchema = {
+  type: "object",
+  properties: {
+    id: { type: "string" }
+  },
+  required: ["id"]
+};
+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] }, controller.getProfile.bind(controller));
+  app.patch("/profile", { preHandler: [authenticate] }, controller.updateProfile.bind(controller));
+  app.get("/users", { preHandler: [authenticate, isModerator] }, controller.list.bind(controller));
+  app.get(
+    "/users/:id",
+    { preHandler: [authenticate, isModerator], schema: { params: idParamsSchema } },
+    async (request, reply) => {
+      return controller.getById(request, reply);
+    }
+  );
+  app.patch(
+    "/users/:id",
+    { preHandler: [authenticate, isAdmin], schema: { params: idParamsSchema } },
+    async (request, reply) => {
+      return controller.update(request, reply);
+    }
+  );
+  app.delete(
+    "/users/:id",
+    { preHandler: [authenticate, isAdmin], schema: { params: idParamsSchema } },
+    async (request, reply) => {
+      return controller.delete(request, reply);
+    }
+  );
+  app.post(
+    "/users/:id/suspend",
+    { preHandler: [authenticate, isAdmin], schema: { params: idParamsSchema } },
+    async (request, reply) => {
+      return controller.suspend(request, reply);
+    }
+  );
+  app.post(
+    "/users/:id/ban",
+    { preHandler: [authenticate, isAdmin], schema: { params: idParamsSchema } },
+    async (request, reply) => {
+      return controller.ban(request, reply);
+    }
+  );
+  app.post(
+    "/users/:id/activate",
+    { preHandler: [authenticate, isAdmin], schema: { params: idParamsSchema } },
+    async (request, reply) => {
+      return controller.activate(request, reply);
+    }
+  );
+}
+
+// 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 : ora5("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, {
+      title: "Servcraft API",
+      description: "API documentation generated by Servcraft",
+      version: "1.0.0"
+    });
+    await registerAuthModule(app);
+    const authService = createAuthService(app);
+    await registerUserModule(app, authService);
+    await app.ready();
+    const spec = app.swagger();
+    const absoluteOutput = path9.resolve(outputPath);
+    await fs6.mkdir(path9.dirname(absoluteOutput), { recursive: true });
+    await fs6.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/docs.ts
+var docsCommand = new Command5("docs").description("API documentation commands");
+docsCommand.command("generate").alias("gen").description("Generate OpenAPI/Swagger documentation").option("-o, --output <file>", "Output file path", "openapi.json").option("-f, --format <format>", "Output format: json, yaml", "json").action(async (options) => {
+  try {
+    const outputPath = await generateDocs(options.output, false);
+    if (options.format === "yaml") {
+      const jsonContent = await fs7.readFile(outputPath, "utf-8");
+      const spec = JSON.parse(jsonContent);
+      const yamlPath = outputPath.replace(".json", ".yaml");
+      await fs7.writeFile(yamlPath, jsonToYaml(spec));
+      success(`YAML documentation generated: ${yamlPath}`);
+    }
+    console.log("\n\u{1F4DA} Documentation URLs:");
+    info("  Swagger UI: http://localhost:3000/docs");
+    info("  OpenAPI JSON: http://localhost:3000/docs/json");
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+docsCommand.option("-o, --output <path>", "Output file path", "openapi.json").action(async (options) => {
+  if (options.output) {
+    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;
+    }
+  }
+});
+docsCommand.command("export").description("Export documentation to Postman, Insomnia, or YAML").option("-f, --format <format>", "Export format: postman, insomnia, yaml", "postman").option("-o, --output <file>", "Output file path").action(async (options) => {
+  const spinner = ora6("Exporting documentation...").start();
+  try {
+    const projectRoot = getProjectRoot();
+    const specPath = path10.join(projectRoot, "openapi.json");
+    try {
+      await fs7.access(specPath);
+    } catch {
+      spinner.text = "Generating OpenAPI spec first...";
+      await generateDocs("openapi.json", true);
+    }
+    const specContent = await fs7.readFile(specPath, "utf-8");
+    const spec = JSON.parse(specContent);
+    let output;
+    let defaultName;
+    switch (options.format) {
+      case "postman":
+        output = JSON.stringify(convertToPostman(spec), null, 2);
+        defaultName = "postman_collection.json";
+        break;
+      case "insomnia":
+        output = JSON.stringify(convertToInsomnia(spec), null, 2);
+        defaultName = "insomnia_collection.json";
+        break;
+      case "yaml":
+        output = jsonToYaml(spec);
+        defaultName = "openapi.yaml";
+        break;
+      default:
+        throw new Error(`Unknown format: ${options.format}`);
+    }
+    const outPath = path10.join(projectRoot, options.output || defaultName);
+    await fs7.writeFile(outPath, output);
+    spinner.succeed(`Exported to: ${options.output || defaultName}`);
+    if (options.format === "postman") {
+      info("\n  Import in Postman: File > Import > Select file");
+    }
+  } catch (err) {
+    spinner.fail("Export failed");
+    error(err instanceof Error ? err.message : String(err));
+  }
+});
+docsCommand.command("status").description("Show documentation status").action(async () => {
+  const projectRoot = getProjectRoot();
+  console.log(chalk9.bold("\n\u{1F4CA} Documentation Status\n"));
+  const specPath = path10.join(projectRoot, "openapi.json");
+  try {
+    const stat2 = await fs7.stat(specPath);
+    success(
+      `openapi.json exists (${formatBytes(stat2.size)}, modified ${formatDate(stat2.mtime)})`
+    );
+    const content = await fs7.readFile(specPath, "utf-8");
+    const spec = JSON.parse(content);
+    const pathCount = Object.keys(spec.paths || {}).length;
+    info(`  ${pathCount} endpoints documented`);
+  } catch {
+    warn('openapi.json not found - run "servcraft docs generate"');
+  }
+  console.log("\n\u{1F4CC} Commands:");
+  info("  servcraft docs generate    Generate OpenAPI spec");
+  info("  servcraft docs export      Export to Postman/Insomnia");
+});
+function jsonToYaml(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  if (obj === null || obj === void 0) return "null";
+  if (typeof obj === "string") {
+    if (obj.includes("\n") || obj.includes(":") || obj.includes("#")) {
+      return `"${obj.replace(/"/g, '\\"')}"`;
+    }
+    return obj || '""';
+  }
+  if (typeof obj === "number" || typeof obj === "boolean") return String(obj);
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    return obj.map((item) => `${spaces}- ${jsonToYaml(item, indent + 1).trimStart()}`).join("\n");
+  }
+  if (typeof obj === "object") {
+    const entries = Object.entries(obj);
+    if (entries.length === 0) return "{}";
+    return entries.map(([key, value]) => {
+      const valueStr = jsonToYaml(value, indent + 1);
+      if (typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0) {
+        return `${spaces}${key}:
+${valueStr}`;
+      }
+      return `${spaces}${key}: ${valueStr}`;
+    }).join("\n");
+  }
+  return String(obj);
+}
+function convertToPostman(spec) {
+  const baseUrl = spec.servers?.[0]?.url || "http://localhost:3000";
+  const items = [];
+  for (const [pathUrl, methods] of Object.entries(spec.paths || {})) {
+    for (const [method, details] of Object.entries(methods)) {
+      items.push({
+        name: details.summary || `${method.toUpperCase()} ${pathUrl}`,
+        request: {
+          method: method.toUpperCase(),
+          header: [
+            { key: "Content-Type", value: "application/json" },
+            { key: "Authorization", value: "Bearer {{token}}" }
+          ],
+          url: {
+            raw: `{{baseUrl}}${pathUrl}`,
+            host: ["{{baseUrl}}"],
+            path: pathUrl.split("/").filter(Boolean)
+          },
+          ...details.requestBody ? { body: { mode: "raw", raw: "{}" } } : {}
+        }
+      });
+    }
+  }
+  return {
+    info: {
+      name: spec.info.title,
+      schema: "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+    },
+    item: items,
+    variable: [
+      { key: "baseUrl", value: baseUrl },
+      { key: "token", value: "" }
+    ]
+  };
+}
+function convertToInsomnia(spec) {
+  const baseUrl = spec.servers?.[0]?.url || "http://localhost:3000";
+  const resources = [
+    { _type: "environment", name: "Base Environment", data: { baseUrl, token: "" } }
+  ];
+  for (const [pathUrl, methods] of Object.entries(spec.paths || {})) {
+    for (const [method, details] of Object.entries(methods)) {
+      resources.push({
+        _type: "request",
+        name: details.summary || `${method.toUpperCase()} ${pathUrl}`,
+        method: method.toUpperCase(),
+        url: `{{ baseUrl }}${pathUrl}`,
+        headers: [
+          { name: "Content-Type", value: "application/json" },
+          { name: "Authorization", value: "Bearer {{ token }}" }
+        ]
+      });
+    }
+  }
+  return { _type: "export", __export_format: 4, resources };
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatDate(date) {
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+
+// src/cli/commands/list.ts
+init_esm_shims();
+import { Command as Command6 } from "commander";
+import chalk10 from "chalk";
+import fs8 from "fs/promises";
+var AVAILABLE_MODULES2 = {
+  // Core
+  auth: {
+    name: "Authentication",
+    description: "JWT authentication with access/refresh tokens",
+    category: "Core"
+  },
+  users: {
+    name: "User Management",
+    description: "User CRUD with RBAC (roles & permissions)",
+    category: "Core"
+  },
+  email: {
+    name: "Email Service",
+    description: "SMTP email with templates (Handlebars)",
+    category: "Core"
+  },
+  // Security
+  mfa: {
+    name: "MFA/TOTP",
+    description: "Two-factor authentication with QR codes",
+    category: "Security"
+  },
+  oauth: {
+    name: "OAuth",
+    description: "Social login (Google, GitHub, Facebook, Twitter, Apple)",
+    category: "Security"
+  },
+  "rate-limit": {
+    name: "Rate Limiting",
+    description: "Advanced rate limiting with multiple algorithms",
+    category: "Security"
+  },
+  // Data & Storage
+  cache: {
+    name: "Redis Cache",
+    description: "Redis caching with TTL & invalidation",
+    category: "Data & Storage"
+  },
+  upload: {
+    name: "File Upload",
+    description: "File upload with local/S3/Cloudinary storage",
+    category: "Data & Storage"
+  },
+  search: {
+    name: "Search",
+    description: "Full-text search with Elasticsearch/Meilisearch",
+    category: "Data & Storage"
+  },
+  // Communication
+  notification: {
+    name: "Notifications",
+    description: "Email, SMS, Push notifications",
+    category: "Communication"
+  },
+  webhook: {
+    name: "Webhooks",
+    description: "Outgoing webhooks with HMAC signatures & retry",
+    category: "Communication"
+  },
+  websocket: {
+    name: "WebSockets",
+    description: "Real-time communication with Socket.io",
+    category: "Communication"
+  },
+  // Background Processing
+  queue: {
+    name: "Queue/Jobs",
+    description: "Background jobs with Bull/BullMQ & cron scheduling",
+    category: "Background Processing"
+  },
+  "media-processing": {
+    name: "Media Processing",
+    description: "Image/video processing with FFmpeg",
+    category: "Background Processing"
+  },
+  // Monitoring & Analytics
+  audit: {
+    name: "Audit Logs",
+    description: "Activity logging and audit trail",
+    category: "Monitoring & Analytics"
+  },
+  analytics: {
+    name: "Analytics/Metrics",
+    description: "Prometheus metrics & event tracking",
+    category: "Monitoring & Analytics"
+  },
+  // Internationalization
+  i18n: {
+    name: "i18n/Localization",
+    description: "Multi-language support with 7+ locales",
+    category: "Internationalization"
+  },
+  // API Management
+  "feature-flag": {
+    name: "Feature Flags",
+    description: "A/B testing & progressive rollout",
+    category: "API Management"
+  },
+  "api-versioning": {
+    name: "API Versioning",
+    description: "Multiple API versions support",
+    category: "API Management"
+  },
+  // Payments
+  payment: {
+    name: "Payments",
+    description: "Payment processing (Stripe, PayPal, Mobile Money)",
+    category: "Payments"
+  }
+};
+async function getInstalledModules() {
+  try {
+    const modulesDir = getModulesDir();
+    const entries = await fs8.readdir(modulesDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function isServercraftProject() {
+  try {
+    getProjectRoot();
+    return true;
+  } catch {
+    return false;
+  }
+}
+var listCommand = new Command6("list").alias("ls").description("List available and installed modules").option("-a, --available", "Show only available modules").option("-i, --installed", "Show only installed modules").option("-c, --category <category>", "Filter by category").option("--json", "Output as JSON").action(
+  async (options) => {
+    const installedModules = await getInstalledModules();
+    const isProject = isServercraftProject();
+    if (options.json) {
+      const output = {
+        available: Object.entries(AVAILABLE_MODULES2).map(([key, mod]) => ({
+          id: key,
+          ...mod,
+          installed: installedModules.includes(key)
+        }))
+      };
+      if (isProject) {
+        output.installed = installedModules;
+      }
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    const byCategory = {};
+    for (const [key, mod] of Object.entries(AVAILABLE_MODULES2)) {
+      if (options.category && mod.category.toLowerCase() !== options.category.toLowerCase()) {
+        continue;
+      }
+      if (!byCategory[mod.category]) {
+        byCategory[mod.category] = [];
+      }
+      byCategory[mod.category].push({
+        id: key,
+        name: mod.name,
+        description: mod.description,
+        installed: installedModules.includes(key)
+      });
+    }
+    if (options.installed) {
+      if (!isProject) {
+        console.log(chalk10.yellow("\n\u26A0 Not in a Servcraft project directory\n"));
+        return;
+      }
+      console.log(chalk10.bold("\n\u{1F4E6} Installed Modules:\n"));
+      if (installedModules.length === 0) {
+        console.log(chalk10.gray("  No modules installed yet.\n"));
+        console.log(`  Run ${chalk10.cyan("servcraft add <module>")} to add a module.
+`);
+        return;
+      }
+      for (const modId of installedModules) {
+        const mod = AVAILABLE_MODULES2[modId];
+        if (mod) {
+          console.log(`  ${chalk10.green("\u2713")} ${chalk10.cyan(modId.padEnd(18))} ${mod.name}`);
+        } else {
+          console.log(
+            `  ${chalk10.green("\u2713")} ${chalk10.cyan(modId.padEnd(18))} ${chalk10.gray("(custom module)")}`
+          );
+        }
+      }
+      console.log(`
+  Total: ${chalk10.bold(installedModules.length)} module(s) installed
+`);
+      return;
+    }
+    console.log(chalk10.bold("\n\u{1F4E6} Available Modules\n"));
+    if (isProject) {
+      console.log(
+        chalk10.gray(`  ${chalk10.green("\u2713")} = installed    ${chalk10.dim("\u25CB")} = not installed
+`)
+      );
+    }
+    for (const [category, modules] of Object.entries(byCategory)) {
+      console.log(chalk10.bold.blue(`  ${category}`));
+      console.log(chalk10.gray("  " + "\u2500".repeat(40)));
+      for (const mod of modules) {
+        const status = isProject ? mod.installed ? chalk10.green("\u2713") : chalk10.dim("\u25CB") : " ";
+        const nameColor = mod.installed ? chalk10.green : chalk10.cyan;
+        console.log(`  ${status} ${nameColor(mod.id.padEnd(18))} ${mod.name}`);
+        console.log(`    ${chalk10.gray(mod.description)}`);
+      }
+      console.log();
+    }
+    const totalAvailable = Object.keys(AVAILABLE_MODULES2).length;
+    const totalInstalled = installedModules.filter((m) => AVAILABLE_MODULES2[m]).length;
+    console.log(chalk10.gray("\u2500".repeat(50)));
+    console.log(
+      `  ${chalk10.bold(totalAvailable)} modules available` + (isProject ? ` | ${chalk10.green.bold(totalInstalled)} installed` : "")
+    );
+    console.log();
+    console.log(chalk10.bold("  Usage:"));
+    console.log(`    ${chalk10.yellow("servcraft add <module>")}      Add a module`);
+    console.log(`    ${chalk10.yellow("servcraft list --installed")}  Show installed only`);
+    console.log(`    ${chalk10.yellow("servcraft list --category Security")}  Filter by category`);
+    console.log();
+  }
+);
+
+// src/cli/commands/remove.ts
+init_esm_shims();
+import { Command as Command7 } from "commander";
+import path11 from "path";
+import ora7 from "ora";
+import chalk11 from "chalk";
+import fs9 from "fs/promises";
+import inquirer4 from "inquirer";
+init_error_handler();
+var removeCommand = new Command7("remove").alias("rm").description("Remove an installed module from your project").argument("<module>", "Module to remove").option("-y, --yes", "Skip confirmation prompt").option("--keep-env", "Keep environment variables").action(async (moduleName, options) => {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+  console.log(chalk11.bold.cyan("\n\u{1F5D1}\uFE0F  ServCraft Module Removal\n"));
+  const moduleDir = path11.join(getModulesDir(), moduleName);
+  try {
+    const exists = await fs9.access(moduleDir).then(() => true).catch(() => false);
+    if (!exists) {
+      displayError(
+        new (init_error_handler(), __toCommonJS(error_handler_exports)).ServCraftError(
+          `Module "${moduleName}" is not installed`,
+          [
+            `Run ${chalk11.cyan("servcraft list --installed")} to see installed modules`,
+            `Check the spelling of the module name`
+          ]
+        )
+      );
+      return;
+    }
+    const files = await fs9.readdir(moduleDir);
+    const fileCount = files.length;
+    if (!options?.yes) {
+      console.log(chalk11.yellow(`\u26A0  This will remove the "${moduleName}" module:`));
+      console.log(chalk11.gray(`   Directory: ${moduleDir}`));
+      console.log(chalk11.gray(`   Files: ${fileCount} file(s)`));
+      console.log();
+      const { confirm } = await inquirer4.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: "Are you sure you want to remove this module?",
+          default: false
+        }
+      ]);
+      if (!confirm) {
+        console.log(chalk11.yellow("\n\u2716 Removal cancelled\n"));
+        return;
+      }
+    }
+    const spinner = ora7("Removing module...").start();
+    await fs9.rm(moduleDir, { recursive: true, force: true });
+    spinner.succeed(`Module "${moduleName}" removed successfully!`);
+    console.log("\n" + chalk11.bold("\u2713 Removed:"));
+    success(`  src/modules/${moduleName}/ (${fileCount} files)`);
+    if (!options?.keepEnv) {
+      console.log("\n" + chalk11.bold("\u{1F4CC} Manual cleanup needed:"));
+      info("  1. Remove environment variables related to this module from .env");
+      info("  2. Remove module imports from your main app file");
+      info("  3. Remove related database migrations if any");
+      info("  4. Update your routes if they reference this module");
+    } else {
+      console.log("\n" + chalk11.bold("\u{1F4CC} Manual cleanup needed:"));
+      info("  1. Environment variables were kept (--keep-env flag)");
+      info("  2. Remove module imports from your main app file");
+      info("  3. Update your routes if they reference this module");
+    }
+    console.log();
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    console.log();
+  }
+});
+
+// src/cli/commands/doctor.ts
+init_esm_shims();
+import { Command as Command8 } from "commander";
+import chalk12 from "chalk";
+var doctorCommand = new Command8("doctor").description("Diagnose project configuration and dependencies").action(async () => {
+  console.log(chalk12.bold.cyan("\nServCraft Doctor - Coming soon!\n"));
+});
+
 // src/cli/index.ts
-var program = new Command5();
+var program = new Command9();
 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.addCommand(listCommand);
+program.addCommand(removeCommand);
+program.addCommand(doctorCommand);
 program.parse();
 //# sourceMappingURL=index.js.map