servcraft 0.1.7 → 0.3.1

package/dist/cli/index.js

@@ -1,21 +1,110 @@
 #!/usr/bin/env node
+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');
+});
 
 // src/cli/index.ts
-import { Command as Command6 } from "commander";
+import { Command as Command11 } from "commander";
 
 // src/cli/commands/init.ts
 import { Command } from "commander";
-import path2 from "path";
+import path3 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
 import fs from "fs/promises";
-import path from "path";
+import path2 from "path";
+import chalk2 from "chalk";
+
+// src/cli/utils/dry-run.ts
 import chalk from "chalk";
+import path 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 path.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 +136,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(path2.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 path2.join(getProjectRoot(), "src");
 }
 function getModulesDir() {
-  return path.join(getSourceDir(), "modules");
+  return path2.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("--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)").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
 `)
@@ -174,7 +278,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 = path3.resolve(process.cwd(), options.name);
     const spinner = ora("Creating project...").start();
     try {
       try {
@@ -188,21 +292,21 @@ 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"),
+        path3.join(projectDir, "package.json"),
         JSON.stringify(packageJson, null, 2)
       );
       if (options.language === "typescript") {
-        await writeFile(path2.join(projectDir, "tsconfig.json"), generateTsConfig(options));
-        await writeFile(path2.join(projectDir, "tsup.config.ts"), generateTsupConfig(options));
+        await writeFile(path3.join(projectDir, "tsconfig.json"), generateTsConfig(options));
+        await writeFile(path3.join(projectDir, "tsup.config.ts"), generateTsupConfig(options));
       } else {
-        await writeFile(path2.join(projectDir, "jsconfig.json"), generateJsConfig(options));
+        await writeFile(path3.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(path3.join(projectDir, ".env.example"), generateEnvExample(options));
+      await writeFile(path3.join(projectDir, ".env"), generateEnvExample(options));
+      await writeFile(path3.join(projectDir, ".gitignore"), generateGitignore());
+      await writeFile(path3.join(projectDir, "Dockerfile"), generateDockerfile(options));
       await writeFile(
-        path2.join(projectDir, "docker-compose.yml"),
+        path3.join(projectDir, "docker-compose.yml"),
         generateDockerCompose(options)
       );
       const ext = options.language === "typescript" ? "ts" : options.moduleSystem === "esm" ? "js" : "cjs";
@@ -223,59 +327,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(path3.join(projectDir, dir));
       }
-      await writeFile(path2.join(projectDir, `src/index.${ext}`), generateEntryFile(options));
+      await writeFile(path3.join(projectDir, `src/index.${ext}`), generateEntryFile(options));
       await writeFile(
-        path2.join(projectDir, `src/core/server.${ext}`),
+        path3.join(projectDir, `src/core/server.${ext}`),
         generateServerFile(options)
       );
       await writeFile(
-        path2.join(projectDir, `src/core/logger.${ext}`),
+        path3.join(projectDir, `src/core/logger.${ext}`),
         generateLoggerFile(options)
       );
       await writeFile(
-        path2.join(projectDir, `src/config/index.${ext}`),
+        path3.join(projectDir, `src/config/index.${ext}`),
         generateConfigFile(options)
       );
       await writeFile(
-        path2.join(projectDir, `src/middleware/index.${ext}`),
+        path3.join(projectDir, `src/middleware/index.${ext}`),
         generateMiddlewareFile(options)
       );
       await writeFile(
-        path2.join(projectDir, `src/utils/index.${ext}`),
+        path3.join(projectDir, `src/utils/index.${ext}`),
         generateUtilsFile(options)
       );
       await writeFile(
-        path2.join(projectDir, `src/types/index.${ext}`),
+        path3.join(projectDir, `src/types/index.${ext}`),
         generateTypesFile(options)
       );
       if (options.orm === "prisma") {
         await writeFile(
-          path2.join(projectDir, "prisma/schema.prisma"),
+          path3.join(projectDir, "prisma/schema.prisma"),
           generatePrismaSchema(options)
         );
       } else if (options.orm === "mongoose") {
         await writeFile(
-          path2.join(projectDir, `src/database/connection.${ext}`),
+          path3.join(projectDir, `src/database/connection.${ext}`),
           generateMongooseConnection(options)
         );
         await writeFile(
-          path2.join(projectDir, `src/database/models/user.model.${ext}`),
+          path3.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');
+        }
+      }
+      if (!cmdOptions?.dryRun) {
+        console.log("\n" + chalk3.green("\u2728 Project created successfully!"));
       }
-      console.log("\n" + chalk2.green("\u2728 Project created successfully!"));
-      console.log("\n" + chalk2.bold("\u{1F4C1} Project structure:"));
+      console.log("\n" + chalk3.bold("\u{1F4C1} Project structure:"));
       console.log(`
   ${options.name}/
   \u251C\u2500\u2500 src/
@@ -290,19 +398,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));
@@ -1094,9 +1205,10 @@ declare module 'fastify' {
 
 // src/cli/commands/generate.ts
 import { Command as Command2 } from "commander";
-import path3 from "path";
+import path4 from "path";
 import ora2 from "ora";
 import inquirer2 from "inquirer";
+import chalk5 from "chalk";
 
 // src/cli/utils/field-parser.ts
 var tsTypeMap = {
@@ -1240,6 +1352,108 @@ function parseFields(fieldsStr) {
   return fieldsStr.split(/\s+/).filter(Boolean).map(parseField);
 }
 
+// src/cli/utils/error-handler.ts
+import chalk4 from "chalk";
+var ServCraftError = class extends Error {
+  suggestions;
+  docsLink;
+  constructor(message, suggestions = [], docsLink) {
+    super(message);
+    this.name = "ServCraftError";
+    this.suggestions = suggestions;
+    this.docsLink = docsLink;
+  }
+};
+var 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`
+  ])
+};
+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 validateProject() {
+  try {
+    const fs12 = __require("fs");
+    if (!fs12.existsSync("package.json")) {
+      return ErrorTypes.NOT_IN_PROJECT();
+    }
+    const packageJson = JSON.parse(fs12.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 {
+    return new ServCraftError("Failed to validate project", [
+      `Ensure you are in the project root directory`,
+      `Check if ${chalk4.yellow("package.json")} is valid`
+    ]);
+  }
+}
+
 // src/cli/templates/controller.ts
 function controllerTemplate(name, pascalName, camelName) {
   return `import type { FastifyRequest, FastifyReply } from 'fastify';
@@ -1928,11 +2142,371 @@ ${indexLines.join("\n")}
 `;
 }
 
+// src/cli/templates/controller-test.ts
+function controllerTestTemplate(name, pascalName, camelName) {
+  return `import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { build } from '../../app.js';
+import { FastifyInstance } from 'fastify';
+
+describe('${pascalName}Controller', () => {
+  let app: FastifyInstance;
+
+  beforeAll(async () => {
+    app = await build();
+    await app.ready();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  describe('GET /${name}', () => {
+    it('should return list of ${name}', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/${name}',
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(response.json()).toHaveProperty('data');
+    });
+  });
+
+  describe('GET /${name}/:id', () => {
+    it('should return a single ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const response = await app.inject({
+        method: 'GET',
+        url: '/${name}/1',
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(response.json()).toHaveProperty('data');
+    });
+
+    it('should return 404 for non-existent ${camelName}', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/${name}/999999',
+      });
+
+      expect(response.statusCode).toBe(404);
+    });
+  });
+
+  describe('POST /${name}', () => {
+    it('should create a new ${camelName}', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {
+          // TODO: Add required fields
+        },
+      });
+
+      expect(response.statusCode).toBe(201);
+      expect(response.json()).toHaveProperty('data');
+    });
+
+    it('should return 400 for invalid data', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {},
+      });
+
+      expect(response.statusCode).toBe(400);
+    });
+  });
+
+  describe('PUT /${name}/:id', () => {
+    it('should update a ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const response = await app.inject({
+        method: 'PUT',
+        url: '/${name}/1',
+        payload: {
+          // TODO: Add fields to update
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(response.json()).toHaveProperty('data');
+    });
+  });
+
+  describe('DELETE /${name}/:id', () => {
+    it('should delete a ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const response = await app.inject({
+        method: 'DELETE',
+        url: '/${name}/1',
+      });
+
+      expect(response.statusCode).toBe(204);
+    });
+  });
+});
+`;
+}
+
+// src/cli/templates/service-test.ts
+function serviceTestTemplate(name, pascalName, camelName) {
+  return `import { describe, it, expect, beforeEach } from 'vitest';
+import { ${pascalName}Service } from '../${name}.service.js';
+
+describe('${pascalName}Service', () => {
+  let service: ${pascalName}Service;
+
+  beforeEach(() => {
+    service = new ${pascalName}Service();
+  });
+
+  describe('getAll', () => {
+    it('should return all ${name}', async () => {
+      const result = await service.getAll();
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    it('should apply pagination', async () => {
+      const result = await service.getAll({ page: 1, limit: 10 });
+
+      expect(result).toBeDefined();
+      expect(result.length).toBeLessThanOrEqual(10);
+    });
+  });
+
+  describe('getById', () => {
+    it('should return a ${camelName} by id', async () => {
+      // TODO: Create test ${camelName} first
+      const id = '1';
+      const result = await service.getById(id);
+
+      expect(result).toBeDefined();
+      expect(result.id).toBe(id);
+    });
+
+    it('should return null for non-existent id', async () => {
+      const result = await service.getById('999999');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new ${camelName}', async () => {
+      const data = {
+        // TODO: Add required fields
+      };
+
+      const result = await service.create(data);
+
+      expect(result).toBeDefined();
+      expect(result.id).toBeDefined();
+    });
+
+    it('should throw error for invalid data', async () => {
+      await expect(service.create({} as any)).rejects.toThrow();
+    });
+  });
+
+  describe('update', () => {
+    it('should update a ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const id = '1';
+      const updates = {
+        // TODO: Add fields to update
+      };
+
+      const result = await service.update(id, updates);
+
+      expect(result).toBeDefined();
+      expect(result.id).toBe(id);
+    });
+
+    it('should return null for non-existent id', async () => {
+      const result = await service.update('999999', {});
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete a ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const id = '1';
+      const result = await service.delete(id);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for non-existent id', async () => {
+      const result = await service.delete('999999');
+
+      expect(result).toBe(false);
+    });
+  });
+});
+`;
+}
+
+// src/cli/templates/integration-test.ts
+function integrationTestTemplate(name, pascalName, camelName) {
+  return `import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { build } from '../../app.js';
+import { FastifyInstance } from 'fastify';
+import { prisma } from '../../lib/prisma.js';
+
+describe('${pascalName} Integration Tests', () => {
+  let app: FastifyInstance;
+
+  beforeAll(async () => {
+    app = await build();
+    await app.ready();
+  });
+
+  afterAll(async () => {
+    await app.close();
+    await prisma.$disconnect();
+  });
+
+  beforeEach(async () => {
+    // Clean up test data
+    // await prisma.${camelName}.deleteMany();
+  });
+
+  describe('Full CRUD workflow', () => {
+    it('should create, read, update, and delete a ${camelName}', async () => {
+      // Create
+      const createResponse = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {
+          // TODO: Add required fields
+        },
+      });
+
+      expect(createResponse.statusCode).toBe(201);
+      const created = createResponse.json().data;
+      expect(created.id).toBeDefined();
+
+      // Read
+      const readResponse = await app.inject({
+        method: 'GET',
+        url: \`/${name}/\${created.id}\`,
+      });
+
+      expect(readResponse.statusCode).toBe(200);
+      const read = readResponse.json().data;
+      expect(read.id).toBe(created.id);
+
+      // Update
+      const updateResponse = await app.inject({
+        method: 'PUT',
+        url: \`/${name}/\${created.id}\`,
+        payload: {
+          // TODO: Add fields to update
+        },
+      });
+
+      expect(updateResponse.statusCode).toBe(200);
+      const updated = updateResponse.json().data;
+      expect(updated.id).toBe(created.id);
+
+      // Delete
+      const deleteResponse = await app.inject({
+        method: 'DELETE',
+        url: \`/${name}/\${created.id}\`,
+      });
+
+      expect(deleteResponse.statusCode).toBe(204);
+
+      // Verify deletion
+      const verifyResponse = await app.inject({
+        method: 'GET',
+        url: \`/${name}/\${created.id}\`,
+      });
+
+      expect(verifyResponse.statusCode).toBe(404);
+    });
+  });
+
+  describe('List and pagination', () => {
+    it('should list ${name} with pagination', async () => {
+      // Create multiple ${name}
+      const count = 5;
+      for (let i = 0; i < count; i++) {
+        await app.inject({
+          method: 'POST',
+          url: '/${name}',
+          payload: {
+            // TODO: Add required fields
+          },
+        });
+      }
+
+      // Test pagination
+      const response = await app.inject({
+        method: 'GET',
+        url: '/${name}?page=1&limit=3',
+      });
+
+      expect(response.statusCode).toBe(200);
+      const result = response.json();
+      expect(result.data).toBeDefined();
+      expect(result.data.length).toBeLessThanOrEqual(3);
+      expect(result.total).toBeGreaterThanOrEqual(count);
+    });
+  });
+
+  describe('Validation', () => {
+    it('should validate required fields on create', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {},
+      });
+
+      expect(response.statusCode).toBe(400);
+      expect(response.json()).toHaveProperty('error');
+    });
+
+    it('should validate data types', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {
+          // TODO: Add invalid field types
+        },
+      });
+
+      expect(response.statusCode).toBe(400);
+    });
+  });
+});
+`;
+}
+
 // 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("--with-tests", "Generate test files (__tests__ directory)").option("--dry-run", "Preview changes without writing files").action(async (name, fieldsArgs, options) => {
+  enableDryRunIfNeeded(options);
   let fields = [];
   if (options.interactive) {
     fields = await promptForFields();
@@ -1947,7 +2521,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 = path4.join(getModulesDir(), kebabName);
     if (await fileExists(moduleDir)) {
       spinner.stop();
       error(`Module "${kebabName}" already exists`);
@@ -1986,7 +2560,22 @@ generateCommand.command("module <name> [fields...]").alias("m").description(
       });
     }
     for (const file of files) {
-      await writeFile(path3.join(moduleDir, file.name), file.content);
+      await writeFile(path4.join(moduleDir, file.name), file.content);
+    }
+    if (options.withTests) {
+      const testDir = path4.join(moduleDir, "__tests__");
+      await writeFile(
+        path4.join(testDir, `${kebabName}.controller.test.ts`),
+        controllerTestTemplate(kebabName, pascalName, camelName)
+      );
+      await writeFile(
+        path4.join(testDir, `${kebabName}.service.test.ts`),
+        serviceTestTemplate(kebabName, pascalName, camelName)
+      );
+      await writeFile(
+        path4.join(testDir, `${kebabName}.integration.test.ts`),
+        integrationTestTemplate(kebabName, pascalName, camelName)
+      );
     }
     spinner.succeed(`Module "${pascalName}" generated successfully!`);
     if (options.prisma || hasFields) {
@@ -2011,6 +2600,11 @@ generateCommand.command("module <name> [fields...]").alias("m").description(
     }
     console.log("\n\u{1F4C1} Files created:");
     files.forEach((f) => success(`  src/modules/${kebabName}/${f.name}`));
+    if (options.withTests) {
+      success(`  src/modules/${kebabName}/__tests__/${kebabName}.controller.test.ts`);
+      success(`  src/modules/${kebabName}/__tests__/${kebabName}.service.test.ts`);
+      success(`  src/modules/${kebabName}/__tests__/${kebabName}.integration.test.ts`);
+    }
     console.log("\n\u{1F4CC} Next steps:");
     if (!hasFields) {
       info(`  1. Update the types in ${kebabName}.types.ts`);
@@ -2024,42 +2618,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 = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.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 = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.join(moduleDir, `${kebabName}.service.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Service "${kebabName}" already exists`);
@@ -2068,12 +2666,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);
@@ -2081,8 +2681,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 = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.join(moduleDir, `${kebabName}.repository.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Repository "${kebabName}" already exists`);
@@ -2091,19 +2691,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 = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.join(moduleDir, `${kebabName}.types.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Types file "${kebabName}.types.ts" already exists`);
@@ -2112,20 +2714,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 = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.join(moduleDir, `${kebabName}.schemas.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Schemas file "${kebabName}.schemas.ts" already exists`);
@@ -2134,12 +2738,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);
@@ -2147,8 +2753,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 = path4.join(getModulesDir(), moduleName);
+    const filePath = path4.join(moduleDir, `${kebabName}.routes.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Routes file "${kebabName}.routes.ts" already exists`);
@@ -2157,6 +2763,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));
@@ -2235,21 +2842,21 @@ async function promptForFields() {
 
 // src/cli/commands/add-module.ts
 import { Command as Command3 } from "commander";
-import path6 from "path";
+import path7 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
 import * as fs3 from "fs/promises";
-import * as path4 from "path";
+import * as path5 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 = path5.join(projectRoot, ".env");
+    this.envExamplePath = path5.join(projectRoot, ".env.example");
   }
   /**
    * Add environment variables to .env file
@@ -2900,15 +3507,15 @@ var EnvManager = class {
 
 // src/cli/utils/template-manager.ts
 import * as fs4 from "fs/promises";
-import * as path5 from "path";
+import * as path6 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 = path6.join(projectRoot, ".servcraft", "templates");
+    this.manifestsDir = path6.join(projectRoot, ".servcraft", "manifests");
   }
   /**
    * Initialize template system
@@ -2922,10 +3529,10 @@ var TemplateManager = class {
    */
   async saveTemplate(moduleName, files) {
     await this.initialize();
-    const moduleTemplateDir = path5.join(this.templatesDir, moduleName);
+    const moduleTemplateDir = path6.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 = path6.join(moduleTemplateDir, fileName);
       await fs4.writeFile(filePath, content, "utf-8");
     }
   }
@@ -2934,7 +3541,7 @@ var TemplateManager = class {
    */
   async getTemplate(moduleName, fileName) {
     try {
-      const filePath = path5.join(this.templatesDir, moduleName, fileName);
+      const filePath = path6.join(this.templatesDir, moduleName, fileName);
       return await fs4.readFile(filePath, "utf-8");
     } catch {
       return null;
@@ -2959,7 +3566,7 @@ var TemplateManager = class {
       installedAt: /* @__PURE__ */ new Date(),
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const manifestPath = path5.join(this.manifestsDir, `${moduleName}.json`);
+    const manifestPath = path6.join(this.manifestsDir, `${moduleName}.json`);
     await fs4.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   }
   /**
@@ -2967,7 +3574,7 @@ var TemplateManager = class {
    */
   async getManifest(moduleName) {
     try {
-      const manifestPath = path5.join(this.manifestsDir, `${moduleName}.json`);
+      const manifestPath = path6.join(this.manifestsDir, `${moduleName}.json`);
       const content = await fs4.readFile(manifestPath, "utf-8");
       return JSON.parse(content);
     } catch {
@@ -2996,7 +3603,7 @@ var TemplateManager = class {
     }
     const results = [];
     for (const [fileName, fileInfo] of Object.entries(manifest.files)) {
-      const filePath = path5.join(moduleDir, fileName);
+      const filePath = path6.join(moduleDir, fileName);
       if (!existsSync2(filePath)) {
         results.push({
           fileName,
@@ -3022,7 +3629,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 = path6.join(path6.dirname(moduleDir), `${moduleName}.backup-${timestamp}`);
     await this.copyDirectory(moduleDir, backupDir);
     return backupDir;
   }
@@ -3033,8 +3640,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 = path6.join(src, entry.name);
+      const destPath = path6.join(dest, entry.name);
       if (entry.isDirectory()) {
         await this.copyDirectory(srcPath, destPath);
       } else {
@@ -3135,23 +3742,23 @@ var TemplateManager = class {
     }
     manifest.files = fileHashes;
     manifest.updatedAt = /* @__PURE__ */ new Date();
-    const manifestPath = path5.join(this.manifestsDir, `${moduleName}.json`);
+    const manifestPath = path6.join(this.manifestsDir, `${moduleName}.json`);
     await fs4.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   }
 };
 
 // src/cli/utils/interactive-prompt.ts
 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([
       {
@@ -3189,12 +3796,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([
       {
@@ -3246,7 +3853,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);
   }
@@ -3254,41 +3861,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"));
     }
   }
   /**
@@ -3460,31 +4067,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 = path7.join(getModulesDir(), moduleName);
       const templateManager = new TemplateManager(process.cwd());
       const moduleExists = await fileExists(moduleDir);
       if (moduleExists) {
@@ -3552,16 +4168,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) {
@@ -3569,10 +4185,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));
@@ -3623,7 +4244,7 @@ export * from './auth.schemas.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path6.join(dir, name), content);
+    await writeFile(path7.join(dir, name), content);
   }
 }
 async function generateUsersModule(dir) {
@@ -3663,7 +4284,7 @@ export * from './user.schemas.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path6.join(dir, name), content);
+    await writeFile(path7.join(dir, name), content);
   }
 }
 async function generateEmailModule(dir) {
@@ -3720,7 +4341,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(path7.join(dir, name), content);
   }
 }
 async function generateAuditModule(dir) {
@@ -3764,7 +4385,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(path7.join(dir, name), content);
   }
 }
 async function generateUploadModule(dir) {
@@ -3790,7 +4411,7 @@ export interface UploadOptions {
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path6.join(dir, name), content);
+    await writeFile(path7.join(dir, name), content);
   }
 }
 async function generateCacheModule(dir) {
@@ -3836,7 +4457,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(path7.join(dir, name), content);
   }
 }
 async function generateGenericModule(dir, name) {
@@ -3850,18 +4471,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(path7.join(dir, fileName), content);
   }
 }
 async function findServercraftModules() {
-  const scriptDir = path6.dirname(new URL(import.meta.url).pathname);
+  const scriptDir = path7.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"),
+    path7.join(process.cwd(), "node_modules", "servcraft", "src", "modules"),
     // From dist/cli/index.js -> src/modules (npx or global install)
-    path6.resolve(scriptDir, "..", "..", "src", "modules"),
+    path7.resolve(scriptDir, "..", "..", "src", "modules"),
     // From src/cli/commands/add-module.ts -> src/modules (development)
-    path6.resolve(scriptDir, "..", "..", "modules")
+    path7.resolve(scriptDir, "..", "..", "modules")
   ];
   for (const p of possiblePaths) {
     try {
@@ -3885,7 +4506,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 = path7.join(servercraftModulesDir, sourceDirName);
     if (await fileExists(sourceModuleDir)) {
       await copyModuleFromSource(sourceModuleDir, moduleDir);
       return;
@@ -3917,8 +4538,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 = path7.join(sourceDir, entry.name);
+    const targetPath = path7.join(targetDir, entry.name);
     if (entry.isDirectory()) {
       await fs5.mkdir(targetPath, { recursive: true });
       await copyModuleFromSource(sourcePath, targetPath);
@@ -3931,7 +4552,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 = path7.join(moduleDir, entry);
     const stat2 = await fs5.stat(filePath);
     if (stat2.isFile() && entry.endsWith(".ts")) {
       const content = await fs5.readFile(filePath, "utf-8");
@@ -3942,14 +4563,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 = path7.join(moduleDir, file.fileName);
       const currentContent = await fs5.readFile(currentPath, "utf-8");
       const originalContent = await templateManager.getTemplate(moduleName, file.fileName);
       if (originalContent) {
@@ -3962,11 +4583,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 = path7.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(path7.join(templateDir, entry), "utf-8");
       newFiles[entry] = content;
     }
   } catch {
@@ -3984,7 +4605,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 = path7.join(moduleDir, fileName);
     const newContent = newFiles[fileName];
     if (!newContent) {
       continue;
@@ -4056,7 +4677,7 @@ async function performSmartMerge(templateManager, moduleName, moduleDir, _displa
 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();
@@ -4113,7 +4734,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,
@@ -4147,14 +4768,14 @@ dbCommand.command("status").description("Show migration status").action(async ()
 
 // src/cli/commands/docs.ts
 import { Command as Command5 } from "commander";
-import path8 from "path";
+import path9 from "path";
 import fs7 from "fs/promises";
 import ora6 from "ora";
-import chalk6 from "chalk";
+import chalk9 from "chalk";
 
 // src/cli/utils/docs-generator.ts
 import fs6 from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 import ora5 from "ora";
 
 // src/core/server.ts
@@ -4875,11 +5496,11 @@ function validateQuery(schema, data) {
 function formatZodErrors(error2) {
   const errors = {};
   for (const issue of error2.issues) {
-    const path9 = issue.path.join(".") || "root";
-    if (!errors[path9]) {
-      errors[path9] = [];
+    const path12 = issue.path.join(".") || "root";
+    if (!errors[path12]) {
+      errors[path12] = [];
     }
-    errors[path9].push(issue.message);
+    errors[path12].push(issue.message);
   }
   return errors;
 }
@@ -5712,8 +6333,8 @@ async function generateDocs(outputPath = "openapi.json", silent = false) {
     await registerUserModule(app, authService);
     await app.ready();
     const spec = app.swagger();
-    const absoluteOutput = path7.resolve(outputPath);
-    await fs6.mkdir(path7.dirname(absoluteOutput), { recursive: true });
+    const absoluteOutput = path8.resolve(outputPath);
+    await fs6.mkdir(path8.dirname(absoluteOutput), { recursive: true });
     await fs6.writeFile(absoluteOutput, JSON.stringify(spec, null, 2), "utf8");
     spinner?.succeed(`OpenAPI spec generated at ${absoluteOutput}`);
     await app.close();
@@ -5758,7 +6379,7 @@ docsCommand.command("export").description("Export documentation to Postman, Inso
   const spinner = ora6("Exporting documentation...").start();
   try {
     const projectRoot = getProjectRoot();
-    const specPath = path8.join(projectRoot, "openapi.json");
+    const specPath = path9.join(projectRoot, "openapi.json");
     try {
       await fs7.access(specPath);
     } catch {
@@ -5785,7 +6406,7 @@ docsCommand.command("export").description("Export documentation to Postman, Inso
       default:
         throw new Error(`Unknown format: ${options.format}`);
     }
-    const outPath = path8.join(projectRoot, options.output || defaultName);
+    const outPath = path9.join(projectRoot, options.output || defaultName);
     await fs7.writeFile(outPath, output);
     spinner.succeed(`Exported to: ${options.output || defaultName}`);
     if (options.format === "postman") {
@@ -5798,8 +6419,8 @@ docsCommand.command("export").description("Export documentation to Postman, Inso
 });
 docsCommand.command("status").description("Show documentation status").action(async () => {
   const projectRoot = getProjectRoot();
-  console.log(chalk6.bold("\n\u{1F4CA} Documentation Status\n"));
-  const specPath = path8.join(projectRoot, "openapi.json");
+  console.log(chalk9.bold("\n\u{1F4CA} Documentation Status\n"));
+  const specPath = path9.join(projectRoot, "openapi.json");
   try {
     const stat2 = await fs7.stat(specPath);
     success(
@@ -5914,13 +6535,736 @@ function formatDate(date) {
   });
 }
 
+// src/cli/commands/list.ts
+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
+import { Command as Command7 } from "commander";
+import path10 from "path";
+import ora7 from "ora";
+import chalk11 from "chalk";
+import fs9 from "fs/promises";
+import inquirer4 from "inquirer";
+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 = path10.join(getModulesDir(), moduleName);
+  try {
+    const exists = await fs9.access(moduleDir).then(() => true).catch(() => false);
+    if (!exists) {
+      displayError(
+        new 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
+import { Command as Command8 } from "commander";
+import chalk12 from "chalk";
+import fs10 from "fs/promises";
+async function checkNodeVersion() {
+  const version = process.version;
+  const major = parseInt(version.slice(1).split(".")[0] || "0", 10);
+  if (major >= 18) {
+    return { name: "Node.js", status: "pass", message: `${version} \u2713` };
+  }
+  return {
+    name: "Node.js",
+    status: "fail",
+    message: `${version} (< 18)`,
+    suggestion: "Upgrade to Node.js 18+"
+  };
+}
+async function checkPackageJson() {
+  const checks = [];
+  try {
+    const content = await fs10.readFile("package.json", "utf-8");
+    const pkg = JSON.parse(content);
+    checks.push({ name: "package.json", status: "pass", message: "Found" });
+    if (pkg.dependencies?.fastify) {
+      checks.push({ name: "Fastify", status: "pass", message: "Installed" });
+    } else {
+      checks.push({
+        name: "Fastify",
+        status: "fail",
+        message: "Missing",
+        suggestion: "npm install fastify"
+      });
+    }
+  } catch {
+    checks.push({
+      name: "package.json",
+      status: "fail",
+      message: "Not found",
+      suggestion: "Run servcraft init"
+    });
+  }
+  return checks;
+}
+async function checkDirectories() {
+  const checks = [];
+  const dirs = ["src", "node_modules", ".git", ".env"];
+  for (const dir of dirs) {
+    try {
+      await fs10.access(dir);
+      checks.push({ name: dir, status: "pass", message: "Exists" });
+    } catch {
+      const isCritical = dir === "src" || dir === "node_modules";
+      checks.push({
+        name: dir,
+        status: isCritical ? "fail" : "warn",
+        message: "Not found",
+        suggestion: dir === "node_modules" ? "npm install" : dir === ".env" ? "Create .env file" : void 0
+      });
+    }
+  }
+  return checks;
+}
+var doctorCommand = new Command8("doctor").description("Diagnose project configuration and dependencies").action(async () => {
+  console.log(chalk12.bold.cyan("\n\u{1F50D} ServCraft Doctor\n"));
+  const allChecks = [];
+  allChecks.push(await checkNodeVersion());
+  allChecks.push(...await checkPackageJson());
+  allChecks.push(...await checkDirectories());
+  allChecks.forEach((check) => {
+    const icon = check.status === "pass" ? chalk12.green("\u2713") : check.status === "warn" ? chalk12.yellow("\u26A0") : chalk12.red("\u2717");
+    const color = check.status === "pass" ? chalk12.green : check.status === "warn" ? chalk12.yellow : chalk12.red;
+    console.log(`${icon} ${check.name.padEnd(20)} ${color(check.message)}`);
+    if (check.suggestion) {
+      console.log(chalk12.gray(`   \u2192 ${check.suggestion}`));
+    }
+  });
+  const pass = allChecks.filter((c) => c.status === "pass").length;
+  const warn2 = allChecks.filter((c) => c.status === "warn").length;
+  const fail = allChecks.filter((c) => c.status === "fail").length;
+  console.log(chalk12.gray("\n" + "\u2500".repeat(60)));
+  console.log(
+    `
+${chalk12.green(pass + " passed")} | ${chalk12.yellow(warn2 + " warnings")} | ${chalk12.red(fail + " failed")}
+`
+  );
+  if (fail === 0 && warn2 === 0) {
+    console.log(chalk12.green.bold("\u2728 Everything looks good!\n"));
+  } else if (fail > 0) {
+    console.log(chalk12.red.bold("\u2717 Fix critical issues before using ServCraft.\n"));
+  } else {
+    console.log(chalk12.yellow.bold("\u26A0 Some warnings, but should work.\n"));
+  }
+});
+
+// src/cli/commands/update.ts
+import { Command as Command9 } from "commander";
+import chalk13 from "chalk";
+import fs11 from "fs/promises";
+import path11 from "path";
+import { fileURLToPath } from "url";
+import inquirer5 from "inquirer";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path11.dirname(__filename2);
+var AVAILABLE_MODULES3 = [
+  "auth",
+  "users",
+  "email",
+  "mfa",
+  "oauth",
+  "rate-limit",
+  "cache",
+  "upload",
+  "search",
+  "notification",
+  "webhook",
+  "websocket",
+  "queue",
+  "payment",
+  "i18n",
+  "feature-flag",
+  "analytics",
+  "media-processing",
+  "api-versioning",
+  "audit",
+  "swagger",
+  "validation"
+];
+async function getInstalledModules2() {
+  try {
+    const modulesDir = getModulesDir();
+    const entries = await fs11.readdir(modulesDir, { withFileTypes: true });
+    const installedModules = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => AVAILABLE_MODULES3.includes(name));
+    return installedModules;
+  } catch {
+    return [];
+  }
+}
+async function copyModuleFiles(moduleName, _projectRoot) {
+  const cliRoot = path11.resolve(__dirname2, "../../../");
+  const sourceModulePath = path11.join(cliRoot, "src", "modules", moduleName);
+  const targetModulesDir = getModulesDir();
+  const targetModulePath = path11.join(targetModulesDir, moduleName);
+  try {
+    await fs11.access(sourceModulePath);
+  } catch {
+    throw new Error(`Module source not found: ${moduleName}`);
+  }
+  await fs11.cp(sourceModulePath, targetModulePath, { recursive: true });
+}
+async function updateModule(moduleName, options) {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+  const projectRoot = getProjectRoot();
+  const installedModules = await getInstalledModules2();
+  if (!installedModules.includes(moduleName)) {
+    console.log(chalk13.yellow(`
+\u26A0 Module "${moduleName}" is not installed
+`));
+    console.log(
+      chalk13.gray(`Run ${chalk13.cyan(`servcraft add ${moduleName}`)} to install it first.
+`)
+    );
+    return;
+  }
+  if (options.check) {
+    console.log(chalk13.cyan(`
+\u{1F4E6} Checking updates for "${moduleName}"...
+`));
+    console.log(chalk13.gray("Note: Version tracking will be implemented in a future release."));
+    console.log(chalk13.gray("Currently, update will always reinstall the latest version.\n"));
+    return;
+  }
+  const { confirmed } = await inquirer5.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message: `Update "${moduleName}" module? This will overwrite existing files.`,
+      default: false
+    }
+  ]);
+  if (!confirmed) {
+    console.log(chalk13.yellow("\n\u26A0 Update cancelled\n"));
+    return;
+  }
+  console.log(chalk13.cyan(`
+\u{1F504} Updating "${moduleName}" module...
+`));
+  try {
+    await copyModuleFiles(moduleName, projectRoot);
+    console.log(chalk13.green(`\u2714 Module "${moduleName}" updated successfully!
+`));
+    console.log(
+      chalk13.gray("Note: Remember to review any breaking changes in the documentation.\n")
+    );
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      console.error(chalk13.red(`
+\u2717 Failed to update module: ${error2.message}
+`));
+    }
+  }
+}
+async function updateAllModules(options) {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+  const installedModules = await getInstalledModules2();
+  if (installedModules.length === 0) {
+    console.log(chalk13.yellow("\n\u26A0 No modules installed\n"));
+    console.log(chalk13.gray(`Run ${chalk13.cyan("servcraft list")} to see available modules.
+`));
+    return;
+  }
+  if (options.check) {
+    console.log(chalk13.cyan("\n\u{1F4E6} Checking updates for all modules...\n"));
+    console.log(chalk13.bold("Installed modules:"));
+    installedModules.forEach((mod) => {
+      console.log(`  \u2022 ${chalk13.cyan(mod)}`);
+    });
+    console.log();
+    console.log(chalk13.gray("Note: Version tracking will be implemented in a future release."));
+    console.log(chalk13.gray("Currently, update will always reinstall the latest version.\n"));
+    return;
+  }
+  console.log(chalk13.cyan(`
+\u{1F4E6} Found ${installedModules.length} installed module(s):
+`));
+  installedModules.forEach((mod) => {
+    console.log(`  \u2022 ${chalk13.cyan(mod)}`);
+  });
+  console.log();
+  const { confirmed } = await inquirer5.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message: "Update all modules? This will overwrite existing files.",
+      default: false
+    }
+  ]);
+  if (!confirmed) {
+    console.log(chalk13.yellow("\n\u26A0 Update cancelled\n"));
+    return;
+  }
+  console.log(chalk13.cyan("\n\u{1F504} Updating all modules...\n"));
+  const projectRoot = getProjectRoot();
+  let successCount = 0;
+  let failCount = 0;
+  for (const moduleName of installedModules) {
+    try {
+      await copyModuleFiles(moduleName, projectRoot);
+      console.log(chalk13.green(`\u2714 Updated: ${moduleName}`));
+      successCount++;
+    } catch {
+      console.error(chalk13.red(`\u2717 Failed: ${moduleName}`));
+      failCount++;
+    }
+  }
+  console.log();
+  console.log(
+    chalk13.bold(
+      `
+\u2714 Update complete: ${chalk13.green(successCount)} succeeded, ${chalk13.red(failCount)} failed
+`
+    )
+  );
+  if (successCount > 0) {
+    console.log(
+      chalk13.gray("Note: Remember to review any breaking changes in the documentation.\n")
+    );
+  }
+}
+var updateCommand = new Command9("update").description("Update installed modules to latest version").argument("[module]", "Specific module to update").option("--check", "Check for updates without applying").option("-y, --yes", "Skip confirmation prompt").action(async (moduleName, options) => {
+  if (moduleName) {
+    await updateModule(moduleName, { check: options?.check });
+  } else {
+    await updateAllModules({ check: options?.check });
+  }
+});
+
+// src/cli/commands/completion.ts
+import { Command as Command10 } from "commander";
+var bashScript = `
+# servcraft bash completion script
+_servcraft_completions() {
+  local cur prev words cword
+  _init_completion || return
+
+  # Main commands
+  local commands="init add generate list remove doctor update completion docs --version --help"
+
+  # Generate subcommands
+  local generate_subcommands="module controller service repository types schema routes m c s r t"
+
+  case "\${words[1]}" in
+    generate|g)
+      if [[ \${cword} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "\${generate_subcommands}" -- "\${cur}") )
+      fi
+      ;;
+    add|remove|rm|update)
+      if [[ \${cword} -eq 2 ]]; then
+        # Get available modules
+        local modules="auth cache rate-limit notification payment oauth mfa queue websocket upload"
+        COMPREPLY=( $(compgen -W "\${modules}" -- "\${cur}") )
+      fi
+      ;;
+    completion)
+      if [[ \${cword} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "bash zsh" -- "\${cur}") )
+      fi
+      ;;
+    *)
+      if [[ \${cword} -eq 1 ]]; then
+        COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+      fi
+      ;;
+  esac
+}
+
+complete -F _servcraft_completions servcraft
+`;
+var zshScript = `
+#compdef servcraft
+
+_servcraft() {
+  local context state state_descr line
+  typeset -A opt_args
+
+  _arguments -C \\
+    '1: :_servcraft_commands' \\
+    '*::arg:->args'
+
+  case $state in
+    args)
+      case $line[1] in
+        generate|g)
+          _servcraft_generate
+          ;;
+        add|remove|rm|update)
+          _servcraft_modules
+          ;;
+        completion)
+          _arguments '1: :(bash zsh)'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_servcraft_commands() {
+  local commands
+  commands=(
+    'init:Initialize a new ServCraft project'
+    'add:Add a pre-built module to your project'
+    'generate:Generate code files (controller, service, etc.)'
+    'list:List available and installed modules'
+    'remove:Remove an installed module'
+    'doctor:Diagnose project configuration'
+    'update:Update installed modules'
+    'completion:Generate shell completion scripts'
+    'docs:Open documentation'
+    '--version:Show version'
+    '--help:Show help'
+  )
+  _describe 'command' commands
+}
+
+_servcraft_generate() {
+  local subcommands
+  subcommands=(
+    'module:Generate a complete module (controller + service + routes)'
+    'controller:Generate a controller'
+    'service:Generate a service'
+    'repository:Generate a repository'
+    'types:Generate TypeScript types'
+    'schema:Generate validation schema'
+    'routes:Generate routes file'
+    'm:Alias for module'
+    'c:Alias for controller'
+    's:Alias for service'
+    'r:Alias for repository'
+    't:Alias for types'
+  )
+  _describe 'subcommand' subcommands
+}
+
+_servcraft_modules() {
+  local modules
+  modules=(
+    'auth:Authentication & Authorization'
+    'cache:Redis caching'
+    'rate-limit:Rate limiting'
+    'notification:Email/SMS notifications'
+    'payment:Payment integration'
+    'oauth:OAuth providers'
+    'mfa:Multi-factor authentication'
+    'queue:Background jobs'
+    'websocket:WebSocket support'
+    'upload:File upload handling'
+  )
+  _describe 'module' modules
+}
+
+_servcraft "$@"
+`;
+var completionCommand = new Command10("completion").description("Generate shell completion scripts").argument("<shell>", "Shell type (bash or zsh)").action((shell) => {
+  const shellLower = shell.toLowerCase();
+  if (shellLower === "bash") {
+    console.log(bashScript);
+  } else if (shellLower === "zsh") {
+    console.log(zshScript);
+  } else {
+    console.error(`Unsupported shell: ${shell}`);
+    console.error("Supported shells: bash, zsh");
+    process.exit(1);
+  }
+});
+
 // src/cli/index.ts
-var program = new Command6();
+var program = new Command11();
 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.addCommand(updateCommand);
+program.addCommand(completionCommand);
 program.parse();
 //# sourceMappingURL=index.js.map