servcraft 0.3.1 → 0.4.3

package/dist/cli/index.js

@@ -7,7 +7,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/cli/index.ts
-import { Command as Command11 } from "commander";
+import { Command as Command13 } from "commander";
 
 // src/cli/commands/init.ts
 import { Command } from "commander";
@@ -1205,7 +1205,7 @@ declare module 'fastify' {
 
 // src/cli/commands/generate.ts
 import { Command as Command2 } from "commander";
-import path4 from "path";
+import path5 from "path";
 import ora2 from "ora";
 import inquirer2 from "inquirer";
 import chalk5 from "chalk";
@@ -1434,11 +1434,11 @@ function displayError(error2) {
 }
 function validateProject() {
   try {
-    const fs12 = __require("fs");
-    if (!fs12.existsSync("package.json")) {
+    const fs14 = __require("fs");
+    if (!fs14.existsSync("package.json")) {
       return ErrorTypes.NOT_IN_PROJECT();
     }
-    const packageJson = JSON.parse(fs12.readFileSync("package.json", "utf-8"));
+    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`,
@@ -2489,6 +2489,39 @@ describe('${pascalName} Integration Tests', () => {
 `;
 }
 
+// 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();
@@ -2521,60 +2554,70 @@ 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 = path4.join(getModulesDir(), kebabName);
+    const moduleDir = path5.join(getModulesDir(), kebabName);
     if (await fileExists(moduleDir)) {
       spinner.stop();
       error(`Module "${kebabName}" already exists`);
       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(path4.join(moduleDir, file.name), file.content);
+      await writeFile(path5.join(moduleDir, file.name), file.content);
     }
     if (options.withTests) {
-      const testDir = path4.join(moduleDir, "__tests__");
+      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(
-        path4.join(testDir, `${kebabName}.controller.test.ts`),
-        controllerTestTemplate(kebabName, pascalName, camelName)
+        path5.join(testDir, `${kebabName}.controller.test.ts`),
+        controllerTestTpl(kebabName, pascalName, camelName)
       );
       await writeFile(
-        path4.join(testDir, `${kebabName}.service.test.ts`),
-        serviceTestTemplate(kebabName, pascalName, camelName)
+        path5.join(testDir, `${kebabName}.service.test.ts`),
+        serviceTestTpl(kebabName, pascalName, camelName)
       );
       await writeFile(
-        path4.join(testDir, `${kebabName}.integration.test.ts`),
-        integrationTestTemplate(kebabName, pascalName, camelName)
+        path5.join(testDir, `${kebabName}.integration.test.ts`),
+        integrationTestTpl(kebabName, pascalName, camelName)
       );
     }
     spinner.succeed(`Module "${pascalName}" generated successfully!`);
@@ -2632,8 +2675,8 @@ generateCommand.command("controller <name>").alias("c").description("Generate a
     const pascalName = toPascalCase(name);
     const camelName = toCamelCase(name);
     const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = path4.join(getModulesDir(), moduleName);
-    const filePath = path4.join(moduleDir, `${kebabName}.controller.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.controller.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       displayError(ErrorTypes.FILE_ALREADY_EXISTS(`${kebabName}.controller.ts`));
@@ -2656,8 +2699,8 @@ generateCommand.command("service <name>").alias("s").description("Generate a ser
     const pascalName = toPascalCase(name);
     const camelName = toCamelCase(name);
     const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = path4.join(getModulesDir(), moduleName);
-    const filePath = path4.join(moduleDir, `${kebabName}.service.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.service.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Service "${kebabName}" already exists`);
@@ -2681,8 +2724,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 = path4.join(getModulesDir(), moduleName);
-    const filePath = path4.join(moduleDir, `${kebabName}.repository.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.repository.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Repository "${kebabName}" already exists`);
@@ -2704,8 +2747,8 @@ generateCommand.command("types <name>").alias("t").description("Generate types/i
     const kebabName = toKebabCase(name);
     const pascalName = toPascalCase(name);
     const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = path4.join(getModulesDir(), moduleName);
-    const filePath = path4.join(moduleDir, `${kebabName}.types.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.types.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Types file "${kebabName}.types.ts" already exists`);
@@ -2728,8 +2771,8 @@ generateCommand.command("schema <name>").alias("v").description("Generate valida
     const pascalName = toPascalCase(name);
     const camelName = toCamelCase(name);
     const moduleName = options.module ? toKebabCase(options.module) : kebabName;
-    const moduleDir = path4.join(getModulesDir(), moduleName);
-    const filePath = path4.join(moduleDir, `${kebabName}.schemas.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.schemas.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Schemas file "${kebabName}.schemas.ts" already exists`);
@@ -2753,8 +2796,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 = path4.join(getModulesDir(), moduleName);
-    const filePath = path4.join(moduleDir, `${kebabName}.routes.ts`);
+    const moduleDir = path5.join(getModulesDir(), moduleName);
+    const filePath = path5.join(moduleDir, `${kebabName}.routes.ts`);
     if (await fileExists(filePath)) {
       spinner.stop();
       error(`Routes file "${kebabName}.routes.ts" already exists`);
@@ -2842,21 +2885,21 @@ async function promptForFields() {
 
 // src/cli/commands/add-module.ts
 import { Command as Command3 } from "commander";
-import path7 from "path";
+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
-import * as fs3 from "fs/promises";
-import * as path5 from "path";
+import * as fs4 from "fs/promises";
+import * as path6 from "path";
 import { existsSync } from "fs";
 var EnvManager = class {
   envPath;
   envExamplePath;
   constructor(projectRoot) {
-    this.envPath = path5.join(projectRoot, ".env");
-    this.envExamplePath = path5.join(projectRoot, ".env.example");
+    this.envPath = path6.join(projectRoot, ".env");
+    this.envExamplePath = path6.join(projectRoot, ".env.example");
   }
   /**
    * Add environment variables to .env file
@@ -2867,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;
     }
@@ -2896,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);
     }
@@ -2908,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;
@@ -2932,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
@@ -3506,34 +3549,34 @@ var EnvManager = class {
 };
 
 // src/cli/utils/template-manager.ts
-import * as fs4 from "fs/promises";
-import * as path6 from "path";
+import * as fs5 from "fs/promises";
+import * as path7 from "path";
 import { createHash } from "crypto";
 import { existsSync as existsSync2 } from "fs";
 var TemplateManager = class {
   templatesDir;
   manifestsDir;
   constructor(projectRoot) {
-    this.templatesDir = path6.join(projectRoot, ".servcraft", "templates");
-    this.manifestsDir = path6.join(projectRoot, ".servcraft", "manifests");
+    this.templatesDir = path7.join(projectRoot, ".servcraft", "templates");
+    this.manifestsDir = path7.join(projectRoot, ".servcraft", "manifests");
   }
   /**
    * 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
    */
   async saveTemplate(moduleName, files) {
     await this.initialize();
-    const moduleTemplateDir = path6.join(this.templatesDir, moduleName);
-    await fs4.mkdir(moduleTemplateDir, { recursive: true });
+    const moduleTemplateDir = path7.join(this.templatesDir, moduleName);
+    await fs5.mkdir(moduleTemplateDir, { recursive: true });
     for (const [fileName, content] of Object.entries(files)) {
-      const filePath = path6.join(moduleTemplateDir, fileName);
-      await fs4.writeFile(filePath, content, "utf-8");
+      const filePath = path7.join(moduleTemplateDir, fileName);
+      await fs5.writeFile(filePath, content, "utf-8");
     }
   }
   /**
@@ -3541,8 +3584,8 @@ var TemplateManager = class {
    */
   async getTemplate(moduleName, fileName) {
     try {
-      const filePath = path6.join(this.templatesDir, moduleName, fileName);
-      return await fs4.readFile(filePath, "utf-8");
+      const filePath = path7.join(this.templatesDir, moduleName, fileName);
+      return await fs5.readFile(filePath, "utf-8");
     } catch {
       return null;
     }
@@ -3566,16 +3609,16 @@ var TemplateManager = class {
       installedAt: /* @__PURE__ */ new Date(),
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const manifestPath = path6.join(this.manifestsDir, `${moduleName}.json`);
-    await fs4.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    const manifestPath = path7.join(this.manifestsDir, `${moduleName}.json`);
+    await fs5.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   }
   /**
    * Get module manifest
    */
   async getManifest(moduleName) {
     try {
-      const manifestPath = path6.join(this.manifestsDir, `${moduleName}.json`);
-      const content = await fs4.readFile(manifestPath, "utf-8");
+      const manifestPath = path7.join(this.manifestsDir, `${moduleName}.json`);
+      const content = await fs5.readFile(manifestPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -3603,7 +3646,7 @@ var TemplateManager = class {
     }
     const results = [];
     for (const [fileName, fileInfo] of Object.entries(manifest.files)) {
-      const filePath = path6.join(moduleDir, fileName);
+      const filePath = path7.join(moduleDir, fileName);
       if (!existsSync2(filePath)) {
         results.push({
           fileName,
@@ -3613,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,
@@ -3629,7 +3672,7 @@ var TemplateManager = class {
    */
   async createBackup(moduleName, moduleDir) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
-    const backupDir = path6.join(path6.dirname(moduleDir), `${moduleName}.backup-${timestamp}`);
+    const backupDir = path7.join(path7.dirname(moduleDir), `${moduleName}.backup-${timestamp}`);
     await this.copyDirectory(moduleDir, backupDir);
     return backupDir;
   }
@@ -3637,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 = path6.join(src, entry.name);
-      const destPath = path6.join(dest, entry.name);
+      const srcPath = path7.join(src, entry.name);
+      const destPath = path7.join(dest, entry.name);
       if (entry.isDirectory()) {
         await this.copyDirectory(srcPath, destPath);
       } else {
-        await fs4.copyFile(srcPath, destPath);
+        await fs5.copyFile(srcPath, destPath);
       }
     }
   }
@@ -3742,8 +3785,8 @@ var TemplateManager = class {
     }
     manifest.files = fileHashes;
     manifest.updatedAt = /* @__PURE__ */ new Date();
-    const manifestPath = path6.join(this.manifestsDir, `${moduleName}.json`);
-    await fs4.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    const manifestPath = path7.join(this.manifestsDir, `${moduleName}.json`);
+    await fs5.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   }
 };
 
@@ -4100,7 +4143,7 @@ var addModuleCommand = new Command3("add").description("Add a pre-built module t
     }
     const spinner = ora3(`Adding ${module.name} module...`).start();
     try {
-      const moduleDir = path7.join(getModulesDir(), moduleName);
+      const moduleDir = path8.join(getModulesDir(), moduleName);
       const templateManager = new TemplateManager(process.cwd());
       const moduleExists = await fileExists(moduleDir);
       if (moduleExists) {
@@ -4133,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 +4287,7 @@ export * from './auth.schemas.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path7.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateUsersModule(dir) {
@@ -4284,7 +4327,7 @@ export * from './user.schemas.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path7.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateEmailModule(dir) {
@@ -4341,7 +4384,7 @@ export { EmailService, emailService } from './email.service.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path7.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateAuditModule(dir) {
@@ -4385,7 +4428,7 @@ export { AuditService, auditService } from './audit.service.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path7.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateUploadModule(dir) {
@@ -4411,7 +4454,7 @@ export interface UploadOptions {
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path7.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateCacheModule(dir) {
@@ -4457,7 +4500,7 @@ export { CacheService, cacheService } from './cache.service.js';
 `
   };
   for (const [name, content] of Object.entries(files)) {
-    await writeFile(path7.join(dir, name), content);
+    await writeFile(path8.join(dir, name), content);
   }
 }
 async function generateGenericModule(dir, name) {
@@ -4471,22 +4514,22 @@ export interface ${name.charAt(0).toUpperCase() + name.slice(1)}Data {
 `
   };
   for (const [fileName, content] of Object.entries(files)) {
-    await writeFile(path7.join(dir, fileName), content);
+    await writeFile(path8.join(dir, fileName), content);
   }
 }
 async function findServercraftModules() {
-  const scriptDir = path7.dirname(new URL(import.meta.url).pathname);
+  const scriptDir = path8.dirname(new URL(import.meta.url).pathname);
   const possiblePaths = [
     // Local node_modules (when servcraft is a dependency)
-    path7.join(process.cwd(), "node_modules", "servcraft", "src", "modules"),
+    path8.join(process.cwd(), "node_modules", "servcraft", "src", "modules"),
     // From dist/cli/index.js -> src/modules (npx or global install)
-    path7.resolve(scriptDir, "..", "..", "src", "modules"),
+    path8.resolve(scriptDir, "..", "..", "src", "modules"),
     // From src/cli/commands/add-module.ts -> src/modules (development)
-    path7.resolve(scriptDir, "..", "..", "modules")
+    path8.resolve(scriptDir, "..", "..", "modules")
   ];
   for (const p of possiblePaths) {
     try {
-      const stats = await fs5.stat(p);
+      const stats = await fs6.stat(p);
       if (stats.isDirectory()) {
         return p;
       }
@@ -4506,7 +4549,7 @@ async function generateModuleFiles(moduleName, moduleDir) {
   const sourceDirName = moduleNameMap[moduleName] || moduleName;
   const servercraftModulesDir = await findServercraftModules();
   if (servercraftModulesDir) {
-    const sourceModuleDir = path7.join(servercraftModulesDir, sourceDirName);
+    const sourceModuleDir = path8.join(servercraftModulesDir, sourceDirName);
     if (await fileExists(sourceModuleDir)) {
       await copyModuleFromSource(sourceModuleDir, moduleDir);
       return;
@@ -4536,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 = path7.join(sourceDir, entry.name);
-    const targetPath = path7.join(targetDir, entry.name);
+    const sourcePath = path8.join(sourceDir, entry.name);
+    const targetPath = path8.join(targetDir, entry.name);
     if (entry.isDirectory()) {
-      await fs5.mkdir(targetPath, { recursive: true });
+      await 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 = path7.join(moduleDir, entry);
-    const stat2 = await fs5.stat(filePath);
+    const filePath = path8.join(moduleDir, entry);
+    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;
     }
   }
@@ -4570,8 +4613,8 @@ async function showDiffForModule(templateManager, moduleName, moduleDir) {
     if (file.isModified) {
       console.log(chalk7.yellow(`
 \u{1F4C4} ${file.fileName}:`));
-      const currentPath = path7.join(moduleDir, file.fileName);
-      const currentContent = await fs5.readFile(currentPath, "utf-8");
+      const currentPath = path8.join(moduleDir, file.fileName);
+      const currentContent = await fs6.readFile(currentPath, "utf-8");
       const originalContent = await templateManager.getTemplate(moduleName, file.fileName);
       if (originalContent) {
         const diff = templateManager.generateDiff(originalContent, currentContent);
@@ -4583,11 +4626,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 = path7.join(templateManager["templatesDir"], moduleName);
+  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(path7.join(templateDir, entry), "utf-8");
+      const content = await fs6.readFile(path8.join(templateDir, entry), "utf-8");
       newFiles[entry] = content;
     }
   } catch {
@@ -4605,7 +4648,7 @@ async function performSmartMerge(templateManager, moduleName, moduleDir, _displa
   };
   for (const fileInfo of modifiedFiles) {
     const fileName = fileInfo.fileName;
-    const filePath = path7.join(moduleDir, fileName);
+    const filePath = path8.join(moduleDir, fileName);
     const newContent = newFiles[fileName];
     if (!newContent) {
       continue;
@@ -4618,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(
@@ -4642,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);
@@ -4663,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++;
       }
     }
@@ -4768,14 +4811,14 @@ dbCommand.command("status").description("Show migration status").action(async ()
 
 // src/cli/commands/docs.ts
 import { Command as Command5 } from "commander";
-import path9 from "path";
-import fs7 from "fs/promises";
+import path10 from "path";
+import fs8 from "fs/promises";
 import ora6 from "ora";
 import chalk9 from "chalk";
 
 // src/cli/utils/docs-generator.ts
-import fs6 from "fs/promises";
-import path8 from "path";
+import fs7 from "fs/promises";
+import path9 from "path";
 import ora5 from "ora";
 
 // src/core/server.ts
@@ -5496,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;
 }
@@ -5737,7 +5780,18 @@ function getSkip(params) {
 }
 
 // src/modules/user/user.repository.ts
-import { UserRole, UserStatus } from "@prisma/client";
+var UserRole = {
+  USER: "USER",
+  MODERATOR: "MODERATOR",
+  ADMIN: "ADMIN",
+  SUPER_ADMIN: "SUPER_ADMIN"
+};
+var UserStatus = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE",
+  SUSPENDED: "SUSPENDED",
+  BANNED: "BANNED"
+};
 var UserRepository = class {
   /**
    * Find user by ID
@@ -6333,9 +6387,9 @@ async function generateDocs(outputPath = "openapi.json", silent = false) {
     await registerUserModule(app, authService);
     await app.ready();
     const spec = app.swagger();
-    const absoluteOutput = path8.resolve(outputPath);
-    await fs6.mkdir(path8.dirname(absoluteOutput), { recursive: true });
-    await fs6.writeFile(absoluteOutput, JSON.stringify(spec, null, 2), "utf8");
+    const absoluteOutput = path9.resolve(outputPath);
+    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;
@@ -6351,10 +6405,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:");
@@ -6379,14 +6433,14 @@ docsCommand.command("export").description("Export documentation to Postman, Inso
   const spinner = ora6("Exporting documentation...").start();
   try {
     const projectRoot = getProjectRoot();
-    const specPath = path9.join(projectRoot, "openapi.json");
+    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;
@@ -6406,8 +6460,8 @@ docsCommand.command("export").description("Export documentation to Postman, Inso
       default:
         throw new Error(`Unknown format: ${options.format}`);
     }
-    const outPath = path9.join(projectRoot, options.output || defaultName);
-    await fs7.writeFile(outPath, output);
+    const outPath = path10.join(projectRoot, options.output || defaultName);
+    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");
@@ -6420,13 +6474,13 @@ docsCommand.command("export").description("Export documentation to Postman, Inso
 docsCommand.command("status").description("Show documentation status").action(async () => {
   const projectRoot = getProjectRoot();
   console.log(chalk9.bold("\n\u{1F4CA} Documentation Status\n"));
-  const specPath = path9.join(projectRoot, "openapi.json");
+  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`);
@@ -6538,7 +6592,7 @@ function formatDate(date) {
 // src/cli/commands/list.ts
 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: {
@@ -6653,7 +6707,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 [];
@@ -6762,10 +6816,10 @@ var listCommand = new Command6("list").alias("ls").description("List available a
 
 // src/cli/commands/remove.ts
 import { Command as Command7 } from "commander";
-import path10 from "path";
+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";
 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();
@@ -6774,9 +6828,9 @@ var removeCommand = new Command7("remove").alias("rm").description("Remove an in
     return;
   }
   console.log(chalk11.bold.cyan("\n\u{1F5D1}\uFE0F  ServCraft Module Removal\n"));
-  const moduleDir = path10.join(getModulesDir(), moduleName);
+  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 ServCraftError(`Module "${moduleName}" is not installed`, [
@@ -6786,7 +6840,7 @@ var removeCommand = new Command7("remove").alias("rm").description("Remove an in
       );
       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:`));
@@ -6807,7 +6861,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)`);
@@ -6833,7 +6887,7 @@ var removeCommand = new Command7("remove").alias("rm").description("Remove an in
 // src/cli/commands/doctor.ts
 import { Command as Command8 } from "commander";
 import chalk12 from "chalk";
-import fs10 from "fs/promises";
+import fs11 from "fs/promises";
 async function checkNodeVersion() {
   const version = process.version;
   const major = parseInt(version.slice(1).split(".")[0] || "0", 10);
@@ -6850,7 +6904,7 @@ async function checkNodeVersion() {
 async function checkPackageJson() {
   const checks = [];
   try {
-    const content = await fs10.readFile("package.json", "utf-8");
+    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) {
@@ -6878,7 +6932,7 @@ async function checkDirectories() {
   const dirs = ["src", "node_modules", ".git", ".env"];
   for (const dir of dirs) {
     try {
-      await fs10.access(dir);
+      await fs11.access(dir);
       checks.push({ name: dir, status: "pass", message: "Exists" });
     } catch {
       const isCritical = dir === "src" || dir === "node_modules";
@@ -6927,12 +6981,12 @@ ${chalk12.green(pass + " passed")} | ${chalk12.yellow(warn2 + " warnings")} | ${
 // 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 fs12 from "fs/promises";
+import path12 from "path";
 import { fileURLToPath } from "url";
 import inquirer5 from "inquirer";
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path11.dirname(__filename2);
+var __dirname2 = path12.dirname(__filename2);
 var AVAILABLE_MODULES3 = [
   "auth",
   "users",
@@ -6960,7 +7014,7 @@ var AVAILABLE_MODULES3 = [
 async function getInstalledModules2() {
   try {
     const modulesDir = getModulesDir();
-    const entries = await fs11.readdir(modulesDir, { withFileTypes: true });
+    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 {
@@ -6968,16 +7022,16 @@ async function getInstalledModules2() {
   }
 }
 async function copyModuleFiles(moduleName, _projectRoot) {
-  const cliRoot = path11.resolve(__dirname2, "../../../");
-  const sourceModulePath = path11.join(cliRoot, "src", "modules", moduleName);
+  const cliRoot = path12.resolve(__dirname2, "../../../");
+  const sourceModulePath = path12.join(cliRoot, "src", "modules", moduleName);
   const targetModulesDir = getModulesDir();
-  const targetModulePath = path11.join(targetModulesDir, moduleName);
+  const targetModulePath = path12.join(targetModulesDir, moduleName);
   try {
-    await fs11.access(sourceModulePath);
+    await fs12.access(sourceModulePath);
   } catch {
     throw new Error(`Module source not found: ${moduleName}`);
   }
-  await fs11.cp(sourceModulePath, targetModulePath, { recursive: true });
+  await fs12.cp(sourceModulePath, targetModulePath, { recursive: true });
 }
 async function updateModule(moduleName, options) {
   const projectError = validateProject();
@@ -7253,8 +7307,275 @@ var completionCommand = new Command10("completion").description("Generate shell
   }
 });
 
+// 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 Command11();
+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);
@@ -7266,5 +7587,7 @@ program.addCommand(removeCommand);
 program.addCommand(doctorCommand);
 program.addCommand(updateCommand);
 program.addCommand(completionCommand);
+program.addCommand(scaffoldCommand);
+program.addCommand(templatesCommand);
 program.parse();
 //# sourceMappingURL=index.js.map