servcraft 0.2.0 → 0.4.2

package/dist/cli/index.js

@@ -1,221 +1,17 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// node_modules/tsup/assets/esm_shims.js
-import path from "path";
-import { fileURLToPath } from "url";
-var init_esm_shims = __esm({
-  "node_modules/tsup/assets/esm_shims.js"() {
-    "use strict";
-  }
-});
-
-// src/cli/utils/error-handler.ts
-var error_handler_exports = {};
-__export(error_handler_exports, {
-  ErrorTypes: () => ErrorTypes,
-  ServCraftError: () => ServCraftError,
-  displayError: () => displayError,
-  handleSystemError: () => handleSystemError,
-  validateProject: () => validateProject
-});
-import chalk4 from "chalk";
-function displayError(error2) {
-  console.error("\n" + chalk4.red.bold("\u2717 Error: ") + chalk4.red(error2.message));
-  if (error2 instanceof ServCraftError) {
-    if (error2.suggestions.length > 0) {
-      console.log("\n" + chalk4.yellow.bold("\u{1F4A1} Suggestions:"));
-      error2.suggestions.forEach((suggestion) => {
-        console.log(chalk4.yellow("  \u2022 ") + suggestion);
-      });
-    }
-    if (error2.docsLink) {
-      console.log("\n" + chalk4.blue.bold("\u{1F4DA} Documentation: ") + chalk4.blue.underline(error2.docsLink));
-    }
-  }
-  console.log();
-}
-function handleSystemError(err) {
-  switch (err.code) {
-    case "ENOENT":
-      return new ServCraftError(
-        `File or directory not found: ${err.path}`,
-        [`Check if the path exists`, `Create the directory first`]
-      );
-    case "EACCES":
-    case "EPERM":
-      return new ServCraftError(
-        `Permission denied: ${err.path}`,
-        [
-          `Check file permissions`,
-          `Try running with elevated privileges (not recommended)`,
-          `Change ownership of the directory`
-        ]
-      );
-    case "EEXIST":
-      return new ServCraftError(
-        `File or directory already exists: ${err.path}`,
-        [`Use a different name`, `Remove the existing file first`, `Use ${chalk4.cyan("--force")} to overwrite`]
-      );
-    case "ENOTDIR":
-      return new ServCraftError(
-        `Not a directory: ${err.path}`,
-        [`Check the path`, `A file exists where a directory is expected`]
-      );
-    case "EISDIR":
-      return new ServCraftError(
-        `Is a directory: ${err.path}`,
-        [`Cannot perform this operation on a directory`, `Did you mean to target a file?`]
-      );
-    default:
-      return new ServCraftError(
-        err.message,
-        [`Check system error code: ${err.code}`, `Review the error details above`]
-      );
-  }
-}
-function validateProject() {
-  try {
-    const fs10 = __require("fs");
-    const path12 = __require("path");
-    if (!fs10.existsSync("package.json")) {
-      return ErrorTypes.NOT_IN_PROJECT();
-    }
-    const packageJson = JSON.parse(fs10.readFileSync("package.json", "utf-8"));
-    if (!packageJson.dependencies?.fastify) {
-      return new ServCraftError(
-        "This does not appear to be a ServCraft project",
-        [
-          `ServCraft projects require Fastify`,
-          `Run ${chalk4.cyan("servcraft init")} to create a new project`
-        ]
-      );
-    }
-    return null;
-  } catch (err) {
-    return new ServCraftError(
-      "Failed to validate project",
-      [`Ensure you are in the project root directory`, `Check if ${chalk4.yellow("package.json")} is valid`]
-    );
-  }
-}
-var ServCraftError, ErrorTypes;
-var init_error_handler = __esm({
-  "src/cli/utils/error-handler.ts"() {
-    "use strict";
-    init_esm_shims();
-    ServCraftError = class extends Error {
-      suggestions;
-      docsLink;
-      constructor(message, suggestions = [], docsLink) {
-        super(message);
-        this.name = "ServCraftError";
-        this.suggestions = suggestions;
-        this.docsLink = docsLink;
-      }
-    };
-    ErrorTypes = {
-      MODULE_NOT_FOUND: (moduleName) => new ServCraftError(
-        `Module "${moduleName}" not found`,
-        [
-          `Run ${chalk4.cyan("servcraft list")} to see available modules`,
-          `Check the spelling of the module name`,
-          `Visit ${chalk4.blue("https://github.com/Le-Sourcier/servcraft#modules")} for module list`
-        ],
-        "https://github.com/Le-Sourcier/servcraft#add-pre-built-modules"
-      ),
-      MODULE_ALREADY_EXISTS: (moduleName) => new ServCraftError(
-        `Module "${moduleName}" already exists`,
-        [
-          `Use ${chalk4.cyan("servcraft add " + moduleName + " --force")} to overwrite`,
-          `Use ${chalk4.cyan("servcraft add " + moduleName + " --update")} to update`,
-          `Use ${chalk4.cyan("servcraft add " + moduleName + " --skip-existing")} to skip`
-        ]
-      ),
-      NOT_IN_PROJECT: () => new ServCraftError(
-        "Not in a ServCraft project directory",
-        [
-          `Run ${chalk4.cyan("servcraft init")} to create a new project`,
-          `Navigate to your ServCraft project directory`,
-          `Check if ${chalk4.yellow("package.json")} exists`
-        ],
-        "https://github.com/Le-Sourcier/servcraft#initialize-project"
-      ),
-      FILE_ALREADY_EXISTS: (fileName) => new ServCraftError(
-        `File "${fileName}" already exists`,
-        [
-          `Use ${chalk4.cyan("--force")} flag to overwrite`,
-          `Choose a different name`,
-          `Delete the existing file first`
-        ]
-      ),
-      INVALID_DATABASE: (database) => new ServCraftError(
-        `Invalid database type: "${database}"`,
-        [
-          `Valid options: ${chalk4.cyan("postgresql, mysql, sqlite, mongodb, none")}`,
-          `Use ${chalk4.cyan("servcraft init --db postgresql")} for PostgreSQL`
-        ]
-      ),
-      INVALID_VALIDATOR: (validator) => new ServCraftError(
-        `Invalid validator type: "${validator}"`,
-        [`Valid options: ${chalk4.cyan("zod, joi, yup")}`, `Default is ${chalk4.cyan("zod")}`]
-      ),
-      MISSING_DEPENDENCY: (dependency, command) => new ServCraftError(
-        `Missing dependency: "${dependency}"`,
-        [`Run ${chalk4.cyan(command)} to install`, `Check your ${chalk4.yellow("package.json")}`]
-      ),
-      INVALID_FIELD_FORMAT: (field) => new ServCraftError(
-        `Invalid field format: "${field}"`,
-        [
-          `Expected format: ${chalk4.cyan("name:type")}`,
-          `Example: ${chalk4.cyan("name:string age:number isActive:boolean")}`,
-          `Supported types: string, number, boolean, date`
-        ]
-      ),
-      GIT_NOT_INITIALIZED: () => new ServCraftError(
-        "Git repository not initialized",
-        [
-          `Run ${chalk4.cyan("git init")} to initialize git`,
-          `This is required for some ServCraft features`
-        ]
-      )
-    };
-  }
-});
 
 // src/cli/index.ts
-init_esm_shims();
-import { Command as Command9 } from "commander";
+import { Command as Command13 } from "commander";
 
 // src/cli/commands/init.ts
-init_esm_shims();
 import { Command } from "commander";
-import path4 from "path";
+import path3 from "path";
 import fs2 from "fs/promises";
 import ora from "ora";
 import inquirer from "inquirer";
@@ -223,15 +19,13 @@ import chalk3 from "chalk";
 import { execSync } from "child_process";
 
 // src/cli/utils/helpers.ts
-init_esm_shims();
 import fs from "fs/promises";
-import path3 from "path";
+import path2 from "path";
 import chalk2 from "chalk";
 
 // src/cli/utils/dry-run.ts
-init_esm_shims();
 import chalk from "chalk";
-import path2 from "path";
+import path from "path";
 var DryRunManager = class _DryRunManager {
   static instance;
   enabled = false;
@@ -306,7 +100,7 @@ var DryRunManager = class _DryRunManager {
   }
   // Helper to format file path relative to cwd
   relativePath(filePath) {
-    return path2.relative(process.cwd(), filePath);
+    return path.relative(process.cwd(), filePath);
   }
 };
 
@@ -352,7 +146,7 @@ async function writeFile(filePath, content) {
     });
     return;
   }
-  await ensureDir(path3.dirname(filePath));
+  await ensureDir(path2.dirname(filePath));
   await fs.writeFile(filePath, content, "utf-8");
 }
 function success(message) {
@@ -371,10 +165,10 @@ function getProjectRoot() {
   return process.cwd();
 }
 function getSourceDir() {
-  return path3.join(getProjectRoot(), "src");
+  return path2.join(getProjectRoot(), "src");
 }
 function getModulesDir() {
-  return path3.join(getSourceDir(), "modules");
+  return path2.join(getSourceDir(), "modules");
 }
 
 // src/cli/commands/init.ts
@@ -484,7 +278,7 @@ var initCommand = new Command("init").alias("new").description("Initialize a new
         orm: db === "mongodb" ? "mongoose" : db === "none" ? "none" : "prisma"
       };
     }
-    const projectDir = path4.resolve(process.cwd(), options.name);
+    const projectDir = path3.resolve(process.cwd(), options.name);
     const spinner = ora("Creating project...").start();
     try {
       try {
@@ -498,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(
-        path4.join(projectDir, "package.json"),
+        path3.join(projectDir, "package.json"),
         JSON.stringify(packageJson, null, 2)
       );
       if (options.language === "typescript") {
-        await writeFile(path4.join(projectDir, "tsconfig.json"), generateTsConfig(options));
-        await writeFile(path4.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(path4.join(projectDir, "jsconfig.json"), generateJsConfig(options));
+        await writeFile(path3.join(projectDir, "jsconfig.json"), generateJsConfig(options));
       }
-      await writeFile(path4.join(projectDir, ".env.example"), generateEnvExample(options));
-      await writeFile(path4.join(projectDir, ".env"), generateEnvExample(options));
-      await writeFile(path4.join(projectDir, ".gitignore"), generateGitignore());
-      await writeFile(path4.join(projectDir, "Dockerfile"), generateDockerfile(options));
+      await writeFile(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(
-        path4.join(projectDir, "docker-compose.yml"),
+        path3.join(projectDir, "docker-compose.yml"),
         generateDockerCompose(options)
       );
       const ext = options.language === "typescript" ? "ts" : options.moduleSystem === "esm" ? "js" : "cjs";
@@ -533,45 +327,45 @@ var initCommand = new Command("init").alias("new").description("Initialize a new
         dirs.push("src/database/models");
       }
       for (const dir of dirs) {
-        await ensureDir(path4.join(projectDir, dir));
+        await ensureDir(path3.join(projectDir, dir));
       }
-      await writeFile(path4.join(projectDir, `src/index.${ext}`), generateEntryFile(options));
+      await writeFile(path3.join(projectDir, `src/index.${ext}`), generateEntryFile(options));
       await writeFile(
-        path4.join(projectDir, `src/core/server.${ext}`),
+        path3.join(projectDir, `src/core/server.${ext}`),
         generateServerFile(options)
       );
       await writeFile(
-        path4.join(projectDir, `src/core/logger.${ext}`),
+        path3.join(projectDir, `src/core/logger.${ext}`),
         generateLoggerFile(options)
       );
       await writeFile(
-        path4.join(projectDir, `src/config/index.${ext}`),
+        path3.join(projectDir, `src/config/index.${ext}`),
         generateConfigFile(options)
       );
       await writeFile(
-        path4.join(projectDir, `src/middleware/index.${ext}`),
+        path3.join(projectDir, `src/middleware/index.${ext}`),
         generateMiddlewareFile(options)
       );
       await writeFile(
-        path4.join(projectDir, `src/utils/index.${ext}`),
+        path3.join(projectDir, `src/utils/index.${ext}`),
         generateUtilsFile(options)
       );
       await writeFile(
-        path4.join(projectDir, `src/types/index.${ext}`),
+        path3.join(projectDir, `src/types/index.${ext}`),
         generateTypesFile(options)
       );
       if (options.orm === "prisma") {
         await writeFile(
-          path4.join(projectDir, "prisma/schema.prisma"),
+          path3.join(projectDir, "prisma/schema.prisma"),
           generatePrismaSchema(options)
         );
       } else if (options.orm === "mongoose") {
         await writeFile(
-          path4.join(projectDir, `src/database/connection.${ext}`),
+          path3.join(projectDir, `src/database/connection.${ext}`),
           generateMongooseConnection(options)
         );
         await writeFile(
-          path4.join(projectDir, `src/database/models/user.model.${ext}`),
+          path3.join(projectDir, `src/database/models/user.model.${ext}`),
           generateMongooseUserModel(options)
         );
       }
@@ -1410,7 +1204,6 @@ declare module 'fastify' {
 }
 
 // src/cli/commands/generate.ts
-init_esm_shims();
 import { Command as Command2 } from "commander";
 import path5 from "path";
 import ora2 from "ora";
@@ -1418,7 +1211,6 @@ import inquirer2 from "inquirer";
 import chalk5 from "chalk";
 
 // src/cli/utils/field-parser.ts
-init_esm_shims();
 var tsTypeMap = {
   string: "string",
   number: "number",
@@ -1560,11 +1352,109 @@ function parseFields(fieldsStr) {
   return fieldsStr.split(/\s+/).filter(Boolean).map(parseField);
 }
 
-// src/cli/commands/generate.ts
-init_error_handler();
+// 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 fs14 = __require("fs");
+    if (!fs14.existsSync("package.json")) {
+      return ErrorTypes.NOT_IN_PROJECT();
+    }
+    const packageJson = JSON.parse(fs14.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
-init_esm_shims();
 function controllerTemplate(name, pascalName, camelName) {
   return `import type { FastifyRequest, FastifyReply } from 'fastify';
 import type { ${pascalName}Service } from './${name}.service.js';
@@ -1634,7 +1524,6 @@ export function create${pascalName}Controller(${camelName}Service: ${pascalName}
 }
 
 // src/cli/templates/service.ts
-init_esm_shims();
 function serviceTemplate(name, pascalName, camelName) {
   return `import type { PaginatedResult, PaginationParams } from '../../types/index.js';
 import { NotFoundError, ConflictError } from '../../utils/errors.js';
@@ -1695,7 +1584,6 @@ export function create${pascalName}Service(repository?: ${pascalName}Repository)
 }
 
 // src/cli/templates/repository.ts
-init_esm_shims();
 function repositoryTemplate(name, pascalName, camelName, pluralName) {
   return `import { randomUUID } from 'crypto';
 import type { PaginatedResult, PaginationParams } from '../../types/index.js';
@@ -1802,7 +1690,6 @@ export function create${pascalName}Repository(): ${pascalName}Repository {
 }
 
 // src/cli/templates/types.ts
-init_esm_shims();
 function typesTemplate(name, pascalName) {
   return `import type { BaseEntity } from '../../types/index.js';
 
@@ -1832,7 +1719,6 @@ export interface ${pascalName}Filters {
 }
 
 // src/cli/templates/schemas.ts
-init_esm_shims();
 function schemasTemplate(name, pascalName, camelName) {
   return `import { z } from 'zod';
 
@@ -1861,7 +1747,6 @@ export type ${pascalName}QueryInput = z.infer<typeof ${camelName}QuerySchema>;
 }
 
 // src/cli/templates/routes.ts
-init_esm_shims();
 function routesTemplate(name, pascalName, camelName, pluralName) {
   return `import type { FastifyInstance } from 'fastify';
 import type { ${pascalName}Controller } from './${name}.controller.js';
@@ -1914,7 +1799,6 @@ export function register${pascalName}Routes(
 }
 
 // src/cli/templates/module-index.ts
-init_esm_shims();
 function moduleIndexTemplate(name, pascalName, camelName) {
   return `import type { FastifyInstance } from 'fastify';
 import { logger } from '../../core/logger.js';
@@ -1950,7 +1834,6 @@ export * from './${name}.schemas.js';
 }
 
 // src/cli/templates/prisma-model.ts
-init_esm_shims();
 function prismaModelTemplate(name, pascalName, tableName) {
   return `
 // Add this model to your prisma/schema.prisma file
@@ -1970,7 +1853,6 @@ model ${pascalName} {
 }
 
 // src/cli/templates/dynamic-types.ts
-init_esm_shims();
 function dynamicTypesTemplate(name, pascalName, fields) {
   const fieldLines = fields.map((field) => {
     const tsType = tsTypeMap[field.type];
@@ -2015,7 +1897,6 @@ ${fields.filter((f) => ["string", "enum", "boolean"].includes(f.type)).map((f) =
 }
 
 // src/cli/templates/dynamic-schemas.ts
-init_esm_shims();
 function dynamicSchemasTemplate(name, pascalName, camelName, fields, validator = "zod") {
   switch (validator) {
     case "joi":
@@ -2194,7 +2075,6 @@ function getJsType(field) {
 }
 
 // src/cli/templates/dynamic-prisma.ts
-init_esm_shims();
 function dynamicPrismaTemplate(modelName, tableName, fields) {
   const fieldLines = [];
   for (const field of fields) {
@@ -2262,6 +2142,386 @@ ${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/utils/template-loader.ts
+import fs3 from "fs/promises";
+import path4 from "path";
+async function loadCustomTemplate(templateType) {
+  const projectRoot = getProjectRoot();
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  const locations = [
+    path4.join(projectRoot, ".servcraft", "templates", `${templateType}.ts`),
+    path4.join(homeDir, ".servcraft", "templates", `${templateType}.ts`)
+  ];
+  for (const location of locations) {
+    try {
+      await fs3.access(location);
+      const templateModule = await import(`file://${location}`);
+      const functionName = `${templateType.replace(/-/g, "")}Template`;
+      if (templateModule[functionName]) {
+        return templateModule;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function getTemplate(templateType, builtInTemplate) {
+  const customTemplate = await loadCustomTemplate(templateType);
+  if (customTemplate) {
+    const functionName = `${templateType.replace(/-/g, "")}Template`;
+    return customTemplate[functionName];
+  }
+  return builtInTemplate;
+}
+
 // src/cli/commands/generate.ts
 function enableDryRunIfNeeded(options) {
   const dryRun = DryRunManager.getInstance();
@@ -2278,7 +2538,7 @@ function showDryRunSummary(options) {
 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").option("--dry-run", "Preview changes without writing files").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) {
@@ -2301,40 +2561,65 @@ generateCommand.command("module <name> [fields...]").alias("m").description(
       return;
     }
     const hasFields = fields.length > 0;
+    const controllerTpl = await getTemplate("controller", controllerTemplate);
+    const serviceTpl = await getTemplate("service", serviceTemplate);
+    const repositoryTpl = await getTemplate("repository", repositoryTemplate);
+    const typesTpl = await getTemplate("types", typesTemplate);
+    const schemasTpl = await getTemplate("schemas", schemasTemplate);
+    const routesTpl = await getTemplate("routes", routesTemplate);
+    const moduleIndexTpl = await getTemplate("module-index", moduleIndexTemplate);
     const files = [
       {
         name: `${kebabName}.types.ts`,
-        content: hasFields ? dynamicTypesTemplate(kebabName, pascalName, fields) : typesTemplate(kebabName, pascalName)
+        content: hasFields ? dynamicTypesTemplate(kebabName, pascalName, fields) : typesTpl(kebabName, pascalName)
       },
       {
         name: `${kebabName}.schemas.ts`,
-        content: hasFields ? dynamicSchemasTemplate(kebabName, pascalName, camelName, fields, validatorType) : schemasTemplate(kebabName, pascalName, camelName)
+        content: hasFields ? dynamicSchemasTemplate(kebabName, pascalName, camelName, fields, validatorType) : schemasTpl(kebabName, pascalName, camelName)
       },
       {
         name: `${kebabName}.service.ts`,
-        content: serviceTemplate(kebabName, pascalName, camelName)
+        content: serviceTpl(kebabName, pascalName, camelName)
       },
       {
         name: `${kebabName}.controller.ts`,
-        content: controllerTemplate(kebabName, pascalName, camelName)
+        content: controllerTpl(kebabName, pascalName, camelName)
       },
-      { name: "index.ts", content: moduleIndexTemplate(kebabName, pascalName, camelName) }
+      { name: "index.ts", content: moduleIndexTpl(kebabName, pascalName, camelName) }
     ];
     if (options.repository !== false) {
       files.push({
         name: `${kebabName}.repository.ts`,
-        content: repositoryTemplate(kebabName, pascalName, camelName, pluralName)
+        content: repositoryTpl(kebabName, pascalName, camelName, pluralName)
       });
     }
     if (options.routes !== false) {
       files.push({
         name: `${kebabName}.routes.ts`,
-        content: routesTemplate(kebabName, pascalName, camelName, pluralName)
+        content: routesTpl(kebabName, pascalName, camelName, pluralName)
       });
     }
     for (const file of files) {
       await writeFile(path5.join(moduleDir, file.name), file.content);
     }
+    if (options.withTests) {
+      const testDir = path5.join(moduleDir, "__tests__");
+      const controllerTestTpl = await getTemplate("controller-test", controllerTestTemplate);
+      const serviceTestTpl = await getTemplate("service-test", serviceTestTemplate);
+      const integrationTestTpl = await getTemplate("integration-test", integrationTestTemplate);
+      await writeFile(
+        path5.join(testDir, `${kebabName}.controller.test.ts`),
+        controllerTestTpl(kebabName, pascalName, camelName)
+      );
+      await writeFile(
+        path5.join(testDir, `${kebabName}.service.test.ts`),
+        serviceTestTpl(kebabName, pascalName, camelName)
+      );
+      await writeFile(
+        path5.join(testDir, `${kebabName}.integration.test.ts`),
+        integrationTestTpl(kebabName, pascalName, camelName)
+      );
+    }
     spinner.succeed(`Module "${pascalName}" generated successfully!`);
     if (options.prisma || hasFields) {
       console.log("\n" + "\u2500".repeat(50));
@@ -2358,6 +2643,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`);
@@ -2594,16 +2884,14 @@ async function promptForFields() {
 }
 
 // src/cli/commands/add-module.ts
-init_esm_shims();
 import { Command as Command3 } from "commander";
 import path8 from "path";
 import ora3 from "ora";
 import chalk7 from "chalk";
-import * as fs5 from "fs/promises";
+import * as fs6 from "fs/promises";
 
 // src/cli/utils/env-manager.ts
-init_esm_shims();
-import * as fs3 from "fs/promises";
+import * as fs4 from "fs/promises";
 import * as path6 from "path";
 import { existsSync } from "fs";
 var EnvManager = class {
@@ -2622,7 +2910,7 @@ var EnvManager = class {
     let created2 = false;
     let envContent = "";
     if (existsSync(this.envPath)) {
-      envContent = await fs3.readFile(this.envPath, "utf-8");
+      envContent = await fs4.readFile(this.envPath, "utf-8");
     } else {
       created2 = true;
     }
@@ -2651,7 +2939,7 @@ var EnvManager = class {
       }
       newContent += "\n";
     }
-    await fs3.writeFile(this.envPath, newContent, "utf-8");
+    await fs4.writeFile(this.envPath, newContent, "utf-8");
     if (existsSync(this.envExamplePath)) {
       await this.updateEnvExample(sections);
     }
@@ -2663,7 +2951,7 @@ var EnvManager = class {
   async updateEnvExample(sections) {
     let exampleContent = "";
     if (existsSync(this.envExamplePath)) {
-      exampleContent = await fs3.readFile(this.envExamplePath, "utf-8");
+      exampleContent = await fs4.readFile(this.envExamplePath, "utf-8");
     }
     const existingKeys = this.parseExistingKeys(exampleContent);
     let newContent = exampleContent;
@@ -2687,7 +2975,7 @@ var EnvManager = class {
       }
       newContent += "\n";
     }
-    await fs3.writeFile(this.envExamplePath, newContent, "utf-8");
+    await fs4.writeFile(this.envExamplePath, newContent, "utf-8");
   }
   /**
    * Parse existing environment variable keys
@@ -3261,8 +3549,7 @@ var EnvManager = class {
 };
 
 // src/cli/utils/template-manager.ts
-init_esm_shims();
-import * as fs4 from "fs/promises";
+import * as fs5 from "fs/promises";
 import * as path7 from "path";
 import { createHash } from "crypto";
 import { existsSync as existsSync2 } from "fs";
@@ -3277,8 +3564,8 @@ var TemplateManager = class {
    * Initialize template system
    */
   async initialize() {
-    await fs4.mkdir(this.templatesDir, { recursive: true });
-    await fs4.mkdir(this.manifestsDir, { recursive: true });
+    await fs5.mkdir(this.templatesDir, { recursive: true });
+    await fs5.mkdir(this.manifestsDir, { recursive: true });
   }
   /**
    * Save module template
@@ -3286,10 +3573,10 @@ var TemplateManager = class {
   async saveTemplate(moduleName, files) {
     await this.initialize();
     const moduleTemplateDir = path7.join(this.templatesDir, moduleName);
-    await fs4.mkdir(moduleTemplateDir, { recursive: true });
+    await fs5.mkdir(moduleTemplateDir, { recursive: true });
     for (const [fileName, content] of Object.entries(files)) {
       const filePath = path7.join(moduleTemplateDir, fileName);
-      await fs4.writeFile(filePath, content, "utf-8");
+      await fs5.writeFile(filePath, content, "utf-8");
     }
   }
   /**
@@ -3298,7 +3585,7 @@ var TemplateManager = class {
   async getTemplate(moduleName, fileName) {
     try {
       const filePath = path7.join(this.templatesDir, moduleName, fileName);
-      return await fs4.readFile(filePath, "utf-8");
+      return await fs5.readFile(filePath, "utf-8");
     } catch {
       return null;
     }
@@ -3323,7 +3610,7 @@ var TemplateManager = class {
       updatedAt: /* @__PURE__ */ new Date()
     };
     const manifestPath = path7.join(this.manifestsDir, `${moduleName}.json`);
-    await fs4.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    await fs5.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   }
   /**
    * Get module manifest
@@ -3331,7 +3618,7 @@ var TemplateManager = class {
   async getManifest(moduleName) {
     try {
       const manifestPath = path7.join(this.manifestsDir, `${moduleName}.json`);
-      const content = await fs4.readFile(manifestPath, "utf-8");
+      const content = await fs5.readFile(manifestPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -3369,7 +3656,7 @@ var TemplateManager = class {
         });
         continue;
       }
-      const currentContent = await fs4.readFile(filePath, "utf-8");
+      const currentContent = await fs5.readFile(filePath, "utf-8");
       const currentHash = this.hashContent(currentContent);
       results.push({
         fileName,
@@ -3393,15 +3680,15 @@ var TemplateManager = class {
    * Copy directory recursively
    */
   async copyDirectory(src, dest) {
-    await fs4.mkdir(dest, { recursive: true });
-    const entries = await fs4.readdir(src, { withFileTypes: true });
+    await fs5.mkdir(dest, { recursive: true });
+    const entries = await fs5.readdir(src, { withFileTypes: true });
     for (const entry of entries) {
       const srcPath = path7.join(src, entry.name);
       const destPath = path7.join(dest, entry.name);
       if (entry.isDirectory()) {
         await this.copyDirectory(srcPath, destPath);
       } else {
-        await fs4.copyFile(srcPath, destPath);
+        await fs5.copyFile(srcPath, destPath);
       }
     }
   }
@@ -3499,12 +3786,11 @@ var TemplateManager = class {
     manifest.files = fileHashes;
     manifest.updatedAt = /* @__PURE__ */ new Date();
     const manifestPath = path7.join(this.manifestsDir, `${moduleName}.json`);
-    await fs4.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    await fs5.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   }
 };
 
 // src/cli/utils/interactive-prompt.ts
-init_esm_shims();
 import inquirer3 from "inquirer";
 import chalk6 from "chalk";
 var InteractivePrompt = class {
@@ -3690,7 +3976,6 @@ var InteractivePrompt = class {
 };
 
 // src/cli/commands/add-module.ts
-init_error_handler();
 var AVAILABLE_MODULES = {
   auth: {
     name: "Authentication",
@@ -3891,7 +4176,7 @@ var addModuleCommand = new Command3("add").description("Add a pre-built module t
             const backupPath = await templateManager.createBackup(moduleName, moduleDir);
             InteractivePrompt.showBackupCreated(backupPath);
           }
-          await fs5.rm(moduleDir, { recursive: true, force: true });
+          await fs6.rm(moduleDir, { recursive: true, force: true });
           await ensureDir(moduleDir);
           await generateModuleFiles(moduleName, moduleDir);
           const files = await getModuleFiles(moduleName, moduleDir);
@@ -4244,7 +4529,7 @@ async function findServercraftModules() {
   ];
   for (const p of possiblePaths) {
     try {
-      const stats = await fs5.stat(p);
+      const stats = await fs6.stat(p);
       if (stats.isDirectory()) {
         return p;
       }
@@ -4294,26 +4579,26 @@ async function generateModuleFiles(moduleName, moduleDir) {
   }
 }
 async function copyModuleFromSource(sourceDir, targetDir) {
-  const entries = await fs5.readdir(sourceDir, { withFileTypes: true });
+  const entries = await fs6.readdir(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
     const sourcePath = path8.join(sourceDir, entry.name);
     const targetPath = path8.join(targetDir, entry.name);
     if (entry.isDirectory()) {
-      await fs5.mkdir(targetPath, { recursive: true });
+      await fs6.mkdir(targetPath, { recursive: true });
       await copyModuleFromSource(sourcePath, targetPath);
     } else {
-      await fs5.copyFile(sourcePath, targetPath);
+      await fs6.copyFile(sourcePath, targetPath);
     }
   }
 }
 async function getModuleFiles(moduleName, moduleDir) {
   const files = {};
-  const entries = await fs5.readdir(moduleDir);
+  const entries = await fs6.readdir(moduleDir);
   for (const entry of entries) {
     const filePath = path8.join(moduleDir, entry);
-    const stat2 = await fs5.stat(filePath);
+    const stat2 = await fs6.stat(filePath);
     if (stat2.isFile() && entry.endsWith(".ts")) {
-      const content = await fs5.readFile(filePath, "utf-8");
+      const content = await fs6.readFile(filePath, "utf-8");
       files[entry] = content;
     }
   }
@@ -4329,7 +4614,7 @@ async function showDiffForModule(templateManager, moduleName, moduleDir) {
       console.log(chalk7.yellow(`
 \u{1F4C4} ${file.fileName}:`));
       const currentPath = path8.join(moduleDir, file.fileName);
-      const currentContent = await fs5.readFile(currentPath, "utf-8");
+      const currentContent = await fs6.readFile(currentPath, "utf-8");
       const originalContent = await templateManager.getTemplate(moduleName, file.fileName);
       if (originalContent) {
         const diff = templateManager.generateDiff(originalContent, currentContent);
@@ -4343,9 +4628,9 @@ async function performSmartMerge(templateManager, moduleName, moduleDir, _displa
   const newFiles = {};
   const templateDir = path8.join(templateManager["templatesDir"], moduleName);
   try {
-    const entries = await fs5.readdir(templateDir);
+    const entries = await fs6.readdir(templateDir);
     for (const entry of entries) {
-      const content = await fs5.readFile(path8.join(templateDir, entry), "utf-8");
+      const content = await fs6.readFile(path8.join(templateDir, entry), "utf-8");
       newFiles[entry] = content;
     }
   } catch {
@@ -4376,7 +4661,7 @@ async function performSmartMerge(templateManager, moduleName, moduleDir, _displa
     } else if (batchAction === "overwrite-all") {
       fileAction = "overwrite";
     } else {
-      const currentContent = await fs5.readFile(filePath, "utf-8");
+      const currentContent = await fs6.readFile(filePath, "utf-8");
       const yourLines = currentContent.split("\n").length;
       const newLines = newContent.split("\n").length;
       const choice = await InteractivePrompt.askFileAction(
@@ -4400,20 +4685,20 @@ async function performSmartMerge(templateManager, moduleName, moduleDir, _displa
       continue;
     }
     if (fileAction === "overwrite") {
-      await fs5.writeFile(filePath, newContent, "utf-8");
+      await fs6.writeFile(filePath, newContent, "utf-8");
       stats.overwritten++;
       continue;
     }
     if (fileAction === "merge") {
       const originalContent = await templateManager.getTemplate(moduleName, fileName);
-      const currentContent = await fs5.readFile(filePath, "utf-8");
+      const currentContent = await fs6.readFile(filePath, "utf-8");
       if (originalContent) {
         const mergeResult = await templateManager.mergeFiles(
           originalContent,
           currentContent,
           newContent
         );
-        await fs5.writeFile(filePath, mergeResult.merged, "utf-8");
+        await fs6.writeFile(filePath, mergeResult.merged, "utf-8");
         if (mergeResult.hasConflicts) {
           stats.conflicts++;
           InteractivePrompt.displayConflicts(mergeResult.conflicts);
@@ -4421,7 +4706,7 @@ async function performSmartMerge(templateManager, moduleName, moduleDir, _displa
           stats.merged++;
         }
       } else {
-        await fs5.writeFile(filePath, newContent, "utf-8");
+        await fs6.writeFile(filePath, newContent, "utf-8");
         stats.overwritten++;
       }
     }
@@ -4432,7 +4717,6 @@ async function performSmartMerge(templateManager, moduleName, moduleDir, _displa
 }
 
 // src/cli/commands/db.ts
-init_esm_shims();
 import { Command as Command4 } from "commander";
 import { execSync as execSync2, spawn } from "child_process";
 import ora4 from "ora";
@@ -4526,25 +4810,21 @@ dbCommand.command("status").description("Show migration status").action(async ()
 });
 
 // src/cli/commands/docs.ts
-init_esm_shims();
 import { Command as Command5 } from "commander";
 import path10 from "path";
-import fs7 from "fs/promises";
+import fs8 from "fs/promises";
 import ora6 from "ora";
 import chalk9 from "chalk";
 
 // src/cli/utils/docs-generator.ts
-init_esm_shims();
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 import path9 from "path";
 import ora5 from "ora";
 
 // src/core/server.ts
-init_esm_shims();
 import Fastify from "fastify";
 
 // src/core/logger.ts
-init_esm_shims();
 import pino from "pino";
 var defaultConfig = {
   level: process.env.LOG_LEVEL || "info",
@@ -4677,14 +4957,7 @@ function createServer(config2 = {}) {
   return new Server(config2);
 }
 
-// src/middleware/index.ts
-init_esm_shims();
-
-// src/middleware/error-handler.ts
-init_esm_shims();
-
 // src/utils/errors.ts
-init_esm_shims();
 var AppError = class _AppError extends Error {
   statusCode;
   isOperational;
@@ -4738,11 +5011,7 @@ function isAppError(error2) {
   return error2 instanceof AppError;
 }
 
-// src/config/index.ts
-init_esm_shims();
-
 // src/config/env.ts
-init_esm_shims();
 import { z } from "zod";
 import dotenv from "dotenv";
 dotenv.config();
@@ -4888,7 +5157,6 @@ function registerErrorHandler(app) {
 }
 
 // src/middleware/security.ts
-init_esm_shims();
 import helmet from "@fastify/helmet";
 import cors from "@fastify/cors";
 import rateLimit from "@fastify/rate-limit";
@@ -4948,11 +5216,7 @@ async function registerSecurity(app, options = {}) {
   }
 }
 
-// src/modules/swagger/index.ts
-init_esm_shims();
-
 // src/modules/swagger/swagger.service.ts
-init_esm_shims();
 import swagger from "@fastify/swagger";
 import swaggerUi from "@fastify/swagger-ui";
 var defaultConfig3 = {
@@ -5012,16 +5276,11 @@ async function registerSwagger(app, customConfig) {
   logger.info("Swagger documentation registered at /docs");
 }
 
-// src/modules/swagger/schema-builder.ts
-init_esm_shims();
-
 // src/modules/auth/index.ts
-init_esm_shims();
 import jwt from "@fastify/jwt";
 import cookie from "@fastify/cookie";
 
 // src/modules/auth/auth.service.ts
-init_esm_shims();
 import bcrypt from "bcryptjs";
 import { Redis } from "ioredis";
 var AuthService = class {
@@ -5220,11 +5479,7 @@ function createAuthService(app) {
   return new AuthService(app);
 }
 
-// src/modules/auth/auth.controller.ts
-init_esm_shims();
-
 // src/modules/auth/schemas.ts
-init_esm_shims();
 import { z as z2 } from "zod";
 var loginSchema = z2.object({
   email: z2.string().email("Invalid email address"),
@@ -5251,7 +5506,6 @@ var changePasswordSchema = z2.object({
 });
 
 // src/utils/response.ts
-init_esm_shims();
 function success2(reply, data, statusCode = 200) {
   const response = {
     success: true,
@@ -5267,7 +5521,6 @@ function noContent(reply) {
 }
 
 // src/modules/validation/validator.ts
-init_esm_shims();
 import { z as z3 } from "zod";
 function validateBody(schema, data) {
   const result = schema.safeParse(data);
@@ -5286,11 +5539,11 @@ function validateQuery(schema, data) {
 function formatZodErrors(error2) {
   const errors = {};
   for (const issue of error2.issues) {
-    const path12 = issue.path.join(".") || "root";
-    if (!errors[path12]) {
-      errors[path12] = [];
+    const path15 = issue.path.join(".") || "root";
+    if (!errors[path15]) {
+      errors[path15] = [];
     }
-    errors[path12].push(issue.message);
+    errors[path15].push(issue.message);
   }
   return errors;
 }
@@ -5438,11 +5691,7 @@ function createAuthController(authService, userService) {
   return new AuthController(authService, userService);
 }
 
-// src/modules/auth/auth.routes.ts
-init_esm_shims();
-
 // src/modules/auth/auth.middleware.ts
-init_esm_shims();
 function createAuthMiddleware(authService) {
   return async function authenticate(request, _reply) {
     const authHeader = request.headers.authorization;
@@ -5485,14 +5734,7 @@ function registerAuthRoutes(app, controller, authService) {
   );
 }
 
-// src/modules/user/user.service.ts
-init_esm_shims();
-
-// src/modules/user/user.repository.ts
-init_esm_shims();
-
 // src/database/prisma.ts
-init_esm_shims();
 import { PrismaClient } from "@prisma/client";
 var prismaClientSingleton = () => {
   return new PrismaClient({
@@ -5506,7 +5748,6 @@ if (!isProduction()) {
 }
 
 // src/utils/pagination.ts
-init_esm_shims();
 var DEFAULT_PAGE = 1;
 var DEFAULT_LIMIT = 20;
 var MAX_LIMIT = 100;
@@ -5771,7 +6012,6 @@ function createUserRepository() {
 }
 
 // src/modules/user/types.ts
-init_esm_shims();
 var DEFAULT_ROLE_PERMISSIONS = {
   user: ["profile:read", "profile:update"],
   moderator: [
@@ -5902,9 +6142,6 @@ function createUserService(repository) {
   return new UserService(repository || createUserRepository());
 }
 
-// src/modules/auth/types.ts
-init_esm_shims();
-
 // src/modules/auth/index.ts
 async function registerAuthModule(app) {
   await app.register(jwt, {
@@ -5924,14 +6161,7 @@ async function registerAuthModule(app) {
   logger.info("Auth module registered");
 }
 
-// src/modules/user/index.ts
-init_esm_shims();
-
-// src/modules/user/user.controller.ts
-init_esm_shims();
-
 // src/modules/user/schemas.ts
-init_esm_shims();
 import { z as z4 } from "zod";
 var userStatusEnum = z4.enum(["active", "inactive", "suspended", "banned"]);
 var userRoleEnum = z4.enum(["user", "admin", "moderator", "super_admin"]);
@@ -6058,7 +6288,6 @@ function createUserController(userService) {
 }
 
 // src/modules/user/user.routes.ts
-init_esm_shims();
 var idParamsSchema = {
   type: "object",
   properties: {
@@ -6148,8 +6377,8 @@ async function generateDocs(outputPath = "openapi.json", silent = false) {
     await app.ready();
     const spec = app.swagger();
     const absoluteOutput = path9.resolve(outputPath);
-    await fs6.mkdir(path9.dirname(absoluteOutput), { recursive: true });
-    await fs6.writeFile(absoluteOutput, JSON.stringify(spec, null, 2), "utf8");
+    await fs7.mkdir(path9.dirname(absoluteOutput), { recursive: true });
+    await fs7.writeFile(absoluteOutput, JSON.stringify(spec, null, 2), "utf8");
     spinner?.succeed(`OpenAPI spec generated at ${absoluteOutput}`);
     await app.close();
     return absoluteOutput;
@@ -6165,10 +6394,10 @@ docsCommand.command("generate").alias("gen").description("Generate OpenAPI/Swagg
   try {
     const outputPath = await generateDocs(options.output, false);
     if (options.format === "yaml") {
-      const jsonContent = await fs7.readFile(outputPath, "utf-8");
+      const jsonContent = await fs8.readFile(outputPath, "utf-8");
       const spec = JSON.parse(jsonContent);
       const yamlPath = outputPath.replace(".json", ".yaml");
-      await fs7.writeFile(yamlPath, jsonToYaml(spec));
+      await fs8.writeFile(yamlPath, jsonToYaml(spec));
       success(`YAML documentation generated: ${yamlPath}`);
     }
     console.log("\n\u{1F4DA} Documentation URLs:");
@@ -6195,12 +6424,12 @@ docsCommand.command("export").description("Export documentation to Postman, Inso
     const projectRoot = getProjectRoot();
     const specPath = path10.join(projectRoot, "openapi.json");
     try {
-      await fs7.access(specPath);
+      await fs8.access(specPath);
     } catch {
       spinner.text = "Generating OpenAPI spec first...";
       await generateDocs("openapi.json", true);
     }
-    const specContent = await fs7.readFile(specPath, "utf-8");
+    const specContent = await fs8.readFile(specPath, "utf-8");
     const spec = JSON.parse(specContent);
     let output;
     let defaultName;
@@ -6221,7 +6450,7 @@ docsCommand.command("export").description("Export documentation to Postman, Inso
         throw new Error(`Unknown format: ${options.format}`);
     }
     const outPath = path10.join(projectRoot, options.output || defaultName);
-    await fs7.writeFile(outPath, output);
+    await fs8.writeFile(outPath, output);
     spinner.succeed(`Exported to: ${options.output || defaultName}`);
     if (options.format === "postman") {
       info("\n  Import in Postman: File > Import > Select file");
@@ -6236,11 +6465,11 @@ docsCommand.command("status").description("Show documentation status").action(as
   console.log(chalk9.bold("\n\u{1F4CA} Documentation Status\n"));
   const specPath = path10.join(projectRoot, "openapi.json");
   try {
-    const stat2 = await fs7.stat(specPath);
+    const stat2 = await fs8.stat(specPath);
     success(
       `openapi.json exists (${formatBytes(stat2.size)}, modified ${formatDate(stat2.mtime)})`
     );
-    const content = await fs7.readFile(specPath, "utf-8");
+    const content = await fs8.readFile(specPath, "utf-8");
     const spec = JSON.parse(content);
     const pathCount = Object.keys(spec.paths || {}).length;
     info(`  ${pathCount} endpoints documented`);
@@ -6350,10 +6579,9 @@ function formatDate(date) {
 }
 
 // src/cli/commands/list.ts
-init_esm_shims();
 import { Command as Command6 } from "commander";
 import chalk10 from "chalk";
-import fs8 from "fs/promises";
+import fs9 from "fs/promises";
 var AVAILABLE_MODULES2 = {
   // Core
   auth: {
@@ -6468,7 +6696,7 @@ var AVAILABLE_MODULES2 = {
 async function getInstalledModules() {
   try {
     const modulesDir = getModulesDir();
-    const entries = await fs8.readdir(modulesDir, { withFileTypes: true });
+    const entries = await fs9.readdir(modulesDir, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
@@ -6508,7 +6736,7 @@ var listCommand = new Command6("list").alias("ls").description("List available a
       if (!byCategory[mod.category]) {
         byCategory[mod.category] = [];
       }
-      byCategory[mod.category].push({
+      byCategory[mod.category]?.push({
         id: key,
         name: mod.name,
         description: mod.description,
@@ -6576,14 +6804,12 @@ var listCommand = new Command6("list").alias("ls").description("List available a
 );
 
 // src/cli/commands/remove.ts
-init_esm_shims();
 import { Command as Command7 } from "commander";
 import path11 from "path";
 import ora7 from "ora";
 import chalk11 from "chalk";
-import fs9 from "fs/promises";
+import fs10 from "fs/promises";
 import inquirer4 from "inquirer";
-init_error_handler();
 var removeCommand = new Command7("remove").alias("rm").description("Remove an installed module from your project").argument("<module>", "Module to remove").option("-y, --yes", "Skip confirmation prompt").option("--keep-env", "Keep environment variables").action(async (moduleName, options) => {
   const projectError = validateProject();
   if (projectError) {
@@ -6593,20 +6819,17 @@ var removeCommand = new Command7("remove").alias("rm").description("Remove an in
   console.log(chalk11.bold.cyan("\n\u{1F5D1}\uFE0F  ServCraft Module Removal\n"));
   const moduleDir = path11.join(getModulesDir(), moduleName);
   try {
-    const exists = await fs9.access(moduleDir).then(() => true).catch(() => false);
+    const exists = await fs10.access(moduleDir).then(() => true).catch(() => false);
     if (!exists) {
       displayError(
-        new (init_error_handler(), __toCommonJS(error_handler_exports)).ServCraftError(
-          `Module "${moduleName}" is not installed`,
-          [
-            `Run ${chalk11.cyan("servcraft list --installed")} to see installed modules`,
-            `Check the spelling of the module name`
-          ]
-        )
+        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 files = await fs10.readdir(moduleDir);
     const fileCount = files.length;
     if (!options?.yes) {
       console.log(chalk11.yellow(`\u26A0  This will remove the "${moduleName}" module:`));
@@ -6627,7 +6850,7 @@ var removeCommand = new Command7("remove").alias("rm").description("Remove an in
       }
     }
     const spinner = ora7("Removing module...").start();
-    await fs9.rm(moduleDir, { recursive: true, force: true });
+    await fs10.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)`);
@@ -6651,15 +6874,697 @@ var removeCommand = new Command7("remove").alias("rm").description("Remove an in
 });
 
 // src/cli/commands/doctor.ts
-init_esm_shims();
 import { Command as Command8 } from "commander";
 import chalk12 from "chalk";
+import fs11 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 fs11.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 fs11.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("\nServCraft Doctor - Coming soon!\n"));
+  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 fs12 from "fs/promises";
+import path12 from "path";
+import { fileURLToPath } from "url";
+import inquirer5 from "inquirer";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path12.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 fs12.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 = path12.resolve(__dirname2, "../../../");
+  const sourceModulePath = path12.join(cliRoot, "src", "modules", moduleName);
+  const targetModulesDir = getModulesDir();
+  const targetModulePath = path12.join(targetModulesDir, moduleName);
+  try {
+    await fs12.access(sourceModulePath);
+  } catch {
+    throw new Error(`Module source not found: ${moduleName}`);
+  }
+  await fs12.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/commands/scaffold.ts
+import { Command as Command11 } from "commander";
+import path13 from "path";
+import ora8 from "ora";
+import chalk14 from "chalk";
+var scaffoldCommand = new Command11("scaffold").description("Generate complete CRUD with Prisma model").argument("<name>", "Resource name (e.g., product, user)").option(
+  "--fields <fields>",
+  'Field definitions: "name:string email:string? age:number category:relation"'
+).option("--validator <type>", "Validator type: zod, joi, yup", "zod").option("--dry-run", "Preview changes without writing files").action(
+  async (name, options) => {
+    const dryRun = DryRunManager.getInstance();
+    if (options.dryRun) {
+      dryRun.enable();
+      console.log(chalk14.yellow("\n\u26A0 DRY RUN MODE - No files will be written\n"));
+    }
+    if (!options.fields) {
+      console.log(chalk14.red("\n\u2717 Error: --fields option is required\n"));
+      console.log(chalk14.gray("Example:"));
+      console.log(
+        chalk14.cyan(
+          '  servcraft scaffold product --fields "name:string price:number category:relation"'
+        )
+      );
+      process.exit(1);
+    }
+    const spinner = ora8("Scaffolding resource...").start();
+    try {
+      const fields = parseFields(options.fields || "");
+      if (!fields || fields.length === 0) {
+        spinner.fail("No valid fields provided");
+        console.log(chalk14.gray(`
+Received: ${options.fields}`));
+        console.log(chalk14.gray(`Parsed: ${JSON.stringify(fields)}`));
+        process.exit(1);
+      }
+      const kebabName = toKebabCase(name);
+      const pascalName = toPascalCase(name);
+      const camelName = toCamelCase(name);
+      const pluralName = pluralize(camelName);
+      const tableName = pluralize(kebabName);
+      const modulesDir = getModulesDir();
+      const moduleDir = path13.join(modulesDir, kebabName);
+      const controllerTpl = await getTemplate("controller", controllerTemplate);
+      const serviceTpl = await getTemplate("service", serviceTemplate);
+      const repositoryTpl = await getTemplate("repository", repositoryTemplate);
+      const routesTpl = await getTemplate("routes", routesTemplate);
+      const moduleIndexTpl = await getTemplate("module-index", moduleIndexTemplate);
+      const files = [
+        {
+          name: `${kebabName}.types.ts`,
+          content: dynamicTypesTemplate(kebabName, pascalName, fields)
+        },
+        {
+          name: `${kebabName}.schemas.ts`,
+          content: dynamicSchemasTemplate(
+            kebabName,
+            pascalName,
+            camelName,
+            fields,
+            options.validator || "zod"
+          )
+        },
+        {
+          name: `${kebabName}.service.ts`,
+          content: serviceTpl(kebabName, pascalName, camelName)
+        },
+        {
+          name: `${kebabName}.controller.ts`,
+          content: controllerTpl(kebabName, pascalName, camelName)
+        },
+        {
+          name: "index.ts",
+          content: moduleIndexTpl(kebabName, pascalName, camelName)
+        },
+        {
+          name: `${kebabName}.repository.ts`,
+          content: repositoryTpl(kebabName, pascalName, camelName, pluralName)
+        },
+        {
+          name: `${kebabName}.routes.ts`,
+          content: routesTpl(kebabName, pascalName, camelName, pluralName)
+        }
+      ];
+      for (const file of files) {
+        await writeFile(path13.join(moduleDir, file.name), file.content);
+      }
+      const testDir = path13.join(moduleDir, "__tests__");
+      const controllerTestTpl = await getTemplate("controller-test", controllerTestTemplate);
+      const serviceTestTpl = await getTemplate("service-test", serviceTestTemplate);
+      const integrationTestTpl = await getTemplate("integration-test", integrationTestTemplate);
+      await writeFile(
+        path13.join(testDir, `${kebabName}.controller.test.ts`),
+        controllerTestTpl(kebabName, pascalName, camelName)
+      );
+      await writeFile(
+        path13.join(testDir, `${kebabName}.service.test.ts`),
+        serviceTestTpl(kebabName, pascalName, camelName)
+      );
+      await writeFile(
+        path13.join(testDir, `${kebabName}.integration.test.ts`),
+        integrationTestTpl(kebabName, pascalName, camelName)
+      );
+      spinner.succeed(`Resource "${pascalName}" scaffolded successfully!`);
+      console.log("\n" + "\u2500".repeat(70));
+      info("\u{1F4CB} Prisma model to add to schema.prisma:");
+      console.log(chalk14.gray("\n// Copy this to your schema.prisma file:\n"));
+      console.log(dynamicPrismaTemplate(pascalName, tableName, fields));
+      console.log("\u2500".repeat(70));
+      console.log("\n\u{1F4CB} Fields scaffolded:");
+      fields.forEach((f) => {
+        const opts = [];
+        if (f.isOptional) opts.push("optional");
+        if (f.isArray) opts.push("array");
+        if (f.isUnique) opts.push("unique");
+        if (f.relation) opts.push(`relation: ${f.relation.model}`);
+        const optsStr = opts.length > 0 ? ` (${opts.join(", ")})` : "";
+        success(`  ${f.name}: ${f.type}${optsStr}`);
+      });
+      console.log("\n\u{1F4C1} Files created:");
+      files.forEach((f) => success(`  src/modules/${kebabName}/${f.name}`));
+      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:");
+      info("  1. Add the Prisma model to your schema.prisma file");
+      info("  2. Run: npx prisma db push (or prisma migrate dev)");
+      info("  3. Run: npx prisma generate");
+      info("  4. Register the module routes in your app");
+      info("  5. Update the test files with actual test data");
+      console.log(
+        chalk14.gray("\n\u{1F4A1} Tip: Use --dry-run to preview changes before applying them\n")
+      );
+      if (options.dryRun) {
+        dryRun.printSummary();
+      }
+    } catch (error2) {
+      spinner.fail("Failed to scaffold resource");
+      if (error2 instanceof Error) {
+        console.error(chalk14.red(`
+\u2717 ${error2.message}
+`));
+        console.error(chalk14.gray(error2.stack));
+      }
+      process.exit(1);
+    }
+  }
+);
+
+// src/cli/commands/templates.ts
+import { Command as Command12 } from "commander";
+import chalk15 from "chalk";
+import fs13 from "fs/promises";
+import path14 from "path";
+var TEMPLATE_TYPES = [
+  "controller",
+  "service",
+  "repository",
+  "types",
+  "schemas",
+  "routes",
+  "module-index",
+  "controller-test",
+  "service-test",
+  "integration-test"
+];
+async function initTemplates() {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+  const projectRoot = getProjectRoot();
+  const templatesDir = path14.join(projectRoot, ".servcraft", "templates");
+  try {
+    await fs13.mkdir(templatesDir, { recursive: true });
+    console.log(chalk15.cyan("\n\u{1F4C1} Creating custom template directory...\n"));
+    const exampleController = `// Custom controller template
+// Available variables: name, pascalName, camelName, pluralName
+export function controllerTemplate(name: string, pascalName: string, camelName: string): string {
+  return \`import type { FastifyRequest, FastifyReply } from 'fastify';
+import type { \${pascalName}Service } from './\${name}.service.js';
+
+export class \${pascalName}Controller {
+  constructor(private \${camelName}Service: \${pascalName}Service) {}
+
+  // Add your custom controller methods here
+  async getAll(request: FastifyRequest, reply: FastifyReply) {
+    const data = await this.\${camelName}Service.getAll();
+    return reply.send({ data });
+  }
+}
+\`;
+}
+`;
+    await fs13.writeFile(
+      path14.join(templatesDir, "controller.example.ts"),
+      exampleController,
+      "utf-8"
+    );
+    console.log(chalk15.green("\u2714 Created template directory: .servcraft/templates/"));
+    console.log(chalk15.green("\u2714 Created example template: controller.example.ts\n"));
+    console.log(chalk15.bold("\u{1F4CB} Available template types:\n"));
+    TEMPLATE_TYPES.forEach((type) => {
+      console.log(chalk15.gray(`  \u2022 ${type}.ts`));
+    });
+    console.log(chalk15.yellow("\n\u{1F4A1} To customize a template:"));
+    console.log(chalk15.gray("  1. Copy the example template"));
+    console.log(chalk15.gray("  2. Rename it (remove .example)"));
+    console.log(chalk15.gray("  3. Modify the template code"));
+    console.log(chalk15.gray("  4. Use --template flag when generating\n"));
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      console.error(chalk15.red(`
+\u2717 Failed to initialize templates: ${error2.message}
+`));
+    }
+  }
+}
+async function listTemplates() {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+  const projectRoot = getProjectRoot();
+  const projectTemplatesDir = path14.join(projectRoot, ".servcraft", "templates");
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  const userTemplatesDir = path14.join(homeDir, ".servcraft", "templates");
+  console.log(chalk15.bold.cyan("\n\u{1F4CB} Available Templates\n"));
+  console.log(chalk15.bold("Project templates (.servcraft/templates/):"));
+  try {
+    const files = await fs13.readdir(projectTemplatesDir);
+    const templates = files.filter((f) => f.endsWith(".ts") && !f.endsWith(".example.ts"));
+    if (templates.length > 0) {
+      templates.forEach((t) => {
+        console.log(chalk15.green(`  \u2713 ${t}`));
+      });
+    } else {
+      console.log(chalk15.gray("  (none)"));
+    }
+  } catch {
+    console.log(chalk15.gray("  (directory not found)"));
+  }
+  console.log(chalk15.bold("\nUser templates (~/.servcraft/templates/):"));
+  try {
+    const files = await fs13.readdir(userTemplatesDir);
+    const templates = files.filter((f) => f.endsWith(".ts") && !f.endsWith(".example.ts"));
+    if (templates.length > 0) {
+      templates.forEach((t) => {
+        console.log(chalk15.green(`  \u2713 ${t}`));
+      });
+    } else {
+      console.log(chalk15.gray("  (none)"));
+    }
+  } catch {
+    console.log(chalk15.gray("  (directory not found)"));
+  }
+  console.log(chalk15.bold("\nBuilt-in templates:"));
+  TEMPLATE_TYPES.forEach((t) => {
+    console.log(chalk15.cyan(`  \u2022 ${t}.ts`));
+  });
+  console.log(chalk15.gray('\n\u{1F4A1} Run "servcraft templates init" to create custom templates\n'));
+}
+var templatesCommand = new Command12("templates").description("Manage code generation templates").addCommand(
+  new Command12("init").description("Initialize custom templates directory").action(initTemplates)
+).addCommand(new Command12("list").description("List available templates").action(listTemplates));
+
 // src/cli/index.ts
-var program = new Command9();
+var program = new Command13();
 program.name("servcraft").description("Servcraft - A modular Node.js backend framework CLI").version("0.1.0");
 program.addCommand(initCommand);
 program.addCommand(generateCommand);
@@ -6669,5 +7574,9 @@ program.addCommand(docsCommand);
 program.addCommand(listCommand);
 program.addCommand(removeCommand);
 program.addCommand(doctorCommand);
+program.addCommand(updateCommand);
+program.addCommand(completionCommand);
+program.addCommand(scaffoldCommand);
+program.addCommand(templatesCommand);
 program.parse();
 //# sourceMappingURL=index.js.map