@forinda/kickjs-cli 1.1.2 → 1.2.0

package/dist/cli.js

@@ -5,7 +5,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/cli.ts
 import { Command } from "commander";
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname3, join as join16 } from "path";
+import { dirname as dirname3, join as join18 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/init.ts
@@ -61,13 +61,15 @@ async function initProject(options) {
   };
   if (template !== "minimal") {
     baseDeps["@forinda/kickjs-swagger"] = KICKJS_VERSION;
+    baseDeps["@forinda/kickjs-devtools"] = KICKJS_VERSION;
   }
   if (template === "graphql") {
     baseDeps["@forinda/kickjs-graphql"] = KICKJS_VERSION;
     baseDeps["graphql"] = "^16.11.0";
   }
-  if (template === "microservice") {
+  if (template === "cqrs") {
     baseDeps["@forinda/kickjs-queue"] = KICKJS_VERSION;
+    baseDeps["@forinda/kickjs-ws"] = KICKJS_VERSION;
     baseDeps["@forinda/kickjs-otel"] = KICKJS_VERSION;
   }
   if (template === "ddd") {
@@ -166,12 +168,45 @@ export default defineConfig({
     printWidth: 100,
     tabWidth: 2
   }, null, 2));
+  await writeFileSafe(join(dir, ".editorconfig"), `# https://editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+`);
   await writeFileSafe(join(dir, ".gitignore"), `node_modules/
 dist/
 .env
 coverage/
 .DS_Store
 *.tsbuildinfo
+`);
+  await writeFileSafe(join(dir, ".gitattributes"), `# Auto-detect text files and normalise line endings to LF
+* text=auto eol=lf
+
+# Explicitly mark generated / binary files
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.woff binary
+*.woff2 binary
+*.ttf binary
+*.eot binary
+
+# Lock files \u2014 treat as generated
+pnpm-lock.yaml -diff linguist-generated
+yarn.lock -diff linguist-generated
+package-lock.json -diff linguist-generated
 `);
   await writeFileSafe(join(dir, ".env"), `PORT=3000
 NODE_ENV=development
@@ -275,19 +310,36 @@ export default defineConfig({
     rest: "kick g module user",
     graphql: "kick g resolver user",
     ddd: "kick g module user --repo drizzle",
-    microservice: "kick g module user && kick g job email",
+    cqrs: "kick g module user --pattern cqrs",
     minimal: "# add your routes to src/index.ts"
   };
   console.log(`    ${genHint[template] ?? genHint.rest}`);
   console.log("    kick dev");
   console.log();
   console.log("  Commands:");
-  console.log("    kick dev         Start dev server with Vite HMR");
-  console.log("    kick build       Production build via Vite");
-  console.log("    kick start       Run production build");
-  console.log(`    kick g module X  Generate a DDD module`);
-  if (template === "graphql") console.log("    kick g resolver X  Generate a GraphQL resolver");
-  if (template === "microservice") console.log("    kick g job X       Generate a queue job processor");
+  console.log("    kick dev                  Start dev server with Vite HMR");
+  console.log("    kick build                Production build via Vite");
+  console.log("    kick start                Run production build");
+  console.log();
+  console.log("  Generators:");
+  console.log("    kick g module <name>      Full DDD module (controller, DTOs, use-cases, repo)");
+  console.log("    kick g scaffold <n> <f..> CRUD module from field definitions");
+  console.log("    kick g controller <name>  Standalone controller");
+  console.log("    kick g service <name>     @Service() class");
+  console.log("    kick g middleware <name>   Express middleware");
+  console.log("    kick g guard <name>       Route guard (auth, roles, etc.)");
+  console.log("    kick g adapter <name>     AppAdapter with lifecycle hooks");
+  console.log("    kick g dto <name>         Zod DTO schema");
+  if (template === "graphql") console.log("    kick g resolver <name>    GraphQL resolver");
+  if (template === "cqrs") console.log("    kick g job <name>         Queue job processor");
+  console.log("    kick g config             Generate kick.config.ts");
+  console.log();
+  console.log("  Add packages:");
+  console.log("    kick add <pkg>            Install a KickJS package + peers");
+  console.log("    kick add --list           Show all available packages");
+  console.log();
+  console.log("  Available: auth, swagger, graphql, drizzle, prisma, ws,");
+  console.log("             cron, queue, mailer, otel, multi-tenant, notifications, testing");
   console.log();
 }
 __name(initProject, "initProject");
@@ -315,12 +367,13 @@ bootstrap({
   ],
 })
 `;
-    case "microservice":
+    case "cqrs":
       return `import 'reflect-metadata'
 import { bootstrap } from '@forinda/kickjs-http'
 import { DevToolsAdapter } from '@forinda/kickjs-devtools'
 import { SwaggerAdapter } from '@forinda/kickjs-swagger'
 import { OtelAdapter } from '@forinda/kickjs-otel'
+// import { WsAdapter } from '@forinda/kickjs-ws'
 // import { QueueAdapter, BullMQProvider } from '@forinda/kickjs-queue'
 import { modules } from './modules'
 
@@ -332,6 +385,8 @@ bootstrap({
     new SwaggerAdapter({
       info: { title: '${name}', version: '${cliPkg.version}' },
     }),
+    // Uncomment for WebSocket support:
+    // new WsAdapter(),
     // Uncomment when Redis is available:
     // new QueueAdapter({
     //   provider: new BullMQProvider({ host: 'localhost', port: 6379 }),
@@ -403,7 +458,7 @@ async function confirm(question, defaultYes = true) {
 }
 __name(confirm, "confirm");
 function registerInitCommand(program) {
-  program.command("new [name]").alias("init").description('Create a new KickJS project (use "." for current directory)').option("-d, --directory <dir>", "Target directory (defaults to project name)").option("--pm <manager>", "Package manager: pnpm | npm | yarn").option("--git", "Initialize git repository").option("--no-git", "Skip git initialization").option("--install", "Install dependencies after scaffolding").option("--no-install", "Skip dependency installation").option("-f, --force", "Remove existing files without prompting").option("-t, --template <type>", "Project template: rest | graphql | ddd | microservice | minimal").action(async (name, opts) => {
+  program.command("new [name]").alias("init").description('Create a new KickJS project (use "." for current directory)').option("-d, --directory <dir>", "Target directory (defaults to project name)").option("--pm <manager>", "Package manager: pnpm | npm | yarn").option("--git", "Initialize git repository").option("--no-git", "Skip git initialization").option("--install", "Install dependencies after scaffolding").option("--no-install", "Skip dependency installation").option("-f, --force", "Remove existing files without prompting").option("-t, --template <type>", "Project template: rest | graphql | ddd | cqrs | minimal").action(async (name, opts) => {
     console.log();
     if (!name) {
       name = await ask("Project name", "my-api");
@@ -451,14 +506,14 @@ function registerInitCommand(program) {
         "REST API (Express + Swagger)",
         "GraphQL API (GraphQL + GraphiQL)",
         "DDD (Domain-Driven Design modules)",
-        "Microservice (REST + Queue worker)",
+        "CQRS (Commands, Queries, Events + WS/Queue)",
         "Minimal (bare Express)"
       ], 0);
       const templateMap = {
         "REST API (Express + Swagger)": "rest",
         "GraphQL API (GraphQL + GraphiQL)": "graphql",
         "DDD (Domain-Driven Design modules)": "ddd",
-        "Microservice (REST + Queue worker)": "microservice",
+        "CQRS (Commands, Queries, Events + WS/Queue)": "cqrs",
         "Minimal (bare Express)": "minimal"
       };
       template = templateMap[template] ?? "rest";
@@ -496,10 +551,11 @@ function registerInitCommand(program) {
 __name(registerInitCommand, "registerInitCommand");
 
 // src/commands/generate.ts
-import { resolve as resolve2 } from "path";
+import { resolve as resolve4 } from "path";
 
 // src/generators/module.ts
 import { join as join2 } from "path";
+import { createInterface as createInterface2 } from "readline";
 
 // src/utils/naming.ts
 function toPascalCase(name) {
@@ -536,9 +592,25 @@ __name(pluralizePascal, "pluralizePascal");
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 
 // src/generators/templates/module-index.ts
+function repoMaps(pascal, kebab, repo) {
+  const repoClassMap = {
+    inmemory: `InMemory${pascal}Repository`,
+    drizzle: `Drizzle${pascal}Repository`,
+    prisma: `Prisma${pascal}Repository`
+  };
+  const repoFileMap = {
+    inmemory: `in-memory-${kebab}`,
+    drizzle: `drizzle-${kebab}`,
+    prisma: `prisma-${kebab}`
+  };
+  return {
+    repoClass: repoClassMap[repo] ?? repoClassMap.inmemory,
+    repoFile: repoFileMap[repo] ?? repoFileMap.inmemory
+  };
+}
+__name(repoMaps, "repoMaps");
 function generateModuleIndex(pascal, kebab, plural, repo) {
-  const repoClass = repo === "inmemory" ? `InMemory${pascal}Repository` : `Drizzle${pascal}Repository`;
-  const repoFile = repo === "inmemory" ? `in-memory-${kebab}` : `drizzle-${kebab}`;
+  const { repoClass, repoFile } = repoMaps(pascal, kebab, repo);
   return `/**
  * ${pascal} Module
  *
@@ -591,6 +663,65 @@ export class ${pascal}Module implements AppModule {
 `;
 }
 __name(generateModuleIndex, "generateModuleIndex");
+function generateRestModuleIndex(pascal, kebab, plural, repo) {
+  const { repoClass, repoFile } = repoMaps(pascal, kebab, repo);
+  return `/**
+ * ${pascal} Module
+ *
+ * REST module with a flat folder structure.
+ * Controller delegates to service, service wraps the repository.
+ *
+ * Structure:
+ *   ${kebab}.controller.ts  \u2014 HTTP routes (CRUD)
+ *   ${kebab}.service.ts     \u2014 Business logic
+ *   ${kebab}.repository.ts  \u2014 Repository interface
+ *   ${repoFile}.repository.ts \u2014 Repository implementation
+ *   dtos/                   \u2014 Request/response schemas
+ */
+import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs-core'
+import { buildRoutes } from '@forinda/kickjs-http'
+import { ${pascal.toUpperCase()}_REPOSITORY } from './${kebab}.repository'
+import { ${repoClass} } from './${repoFile}.repository'
+import { ${pascal}Controller } from './${kebab}.controller'
+
+// Eagerly load decorated classes so @Service()/@Repository() decorators register in the DI container
+import.meta.glob(['./**/*.service.ts', './**/*.repository.ts', '!./**/*.test.ts'], { eager: true })
+
+export class ${pascal}Module implements AppModule {
+  register(container: Container): void {
+    container.registerFactory(${pascal.toUpperCase()}_REPOSITORY, () =>
+      container.resolve(${repoClass}),
+    )
+  }
+
+  routes(): ModuleRoutes {
+    return {
+      path: '/${plural}',
+      router: buildRoutes(${pascal}Controller),
+      controller: ${pascal}Controller,
+    }
+  }
+}
+`;
+}
+__name(generateRestModuleIndex, "generateRestModuleIndex");
+function generateMinimalModuleIndex(pascal, kebab, plural) {
+  return `import { type AppModule, type ModuleRoutes } from '@forinda/kickjs-core'
+import { buildRoutes } from '@forinda/kickjs-http'
+import { ${pascal}Controller } from './${kebab}.controller'
+
+export class ${pascal}Module implements AppModule {
+  routes(): ModuleRoutes {
+    return {
+      path: '/${plural}',
+      router: buildRoutes(${pascal}Controller),
+      controller: ${pascal}Controller,
+    }
+  }
+}
+`;
+}
+__name(generateMinimalModuleIndex, "generateMinimalModuleIndex");
 
 // src/generators/templates/controller.ts
 function generateController(pascal, kebab, plural, pluralPascal) {
@@ -656,6 +787,62 @@ export class ${pascal}Controller {
 `;
 }
 __name(generateController, "generateController");
+function generateRestController(pascal, kebab, plural, pluralPascal) {
+  const camel = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  return `import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams } from '@forinda/kickjs-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+import { ApiTags } from '@forinda/kickjs-swagger'
+import { ${pascal}Service } from './${kebab}.service'
+import { create${pascal}Schema } from './dtos/create-${kebab}.dto'
+import { update${pascal}Schema } from './dtos/update-${kebab}.dto'
+import { ${pascal.toUpperCase()}_QUERY_CONFIG } from './${kebab}.constants'
+
+@Controller()
+export class ${pascal}Controller {
+  @Autowired() private ${camel}Service!: ${pascal}Service
+
+  @Get('/')
+  @ApiTags('${pascal}')
+  @ApiQueryParams(${pascal.toUpperCase()}_QUERY_CONFIG)
+  async list(ctx: RequestContext) {
+    return ctx.paginate(
+      (parsed) => this.${camel}Service.findPaginated(parsed),
+      ${pascal.toUpperCase()}_QUERY_CONFIG,
+    )
+  }
+
+  @Get('/:id')
+  @ApiTags('${pascal}')
+  async getById(ctx: RequestContext) {
+    const result = await this.${camel}Service.findById(ctx.params.id)
+    if (!result) return ctx.notFound('${pascal} not found')
+    ctx.json(result)
+  }
+
+  @Post('/', { body: create${pascal}Schema, name: 'Create${pascal}' })
+  @ApiTags('${pascal}')
+  async create(ctx: RequestContext) {
+    const result = await this.${camel}Service.create(ctx.body)
+    ctx.created(result)
+  }
+
+  @Put('/:id', { body: update${pascal}Schema, name: 'Update${pascal}' })
+  @ApiTags('${pascal}')
+  async update(ctx: RequestContext) {
+    const result = await this.${camel}Service.update(ctx.params.id, ctx.body)
+    ctx.json(result)
+  }
+
+  @Delete('/:id')
+  @ApiTags('${pascal}')
+  async remove(ctx: RequestContext) {
+    await this.${camel}Service.delete(ctx.params.id)
+    ctx.noContent()
+  }
+}
+`;
+}
+__name(generateRestController, "generateRestController");
 
 // src/generators/templates/constants.ts
 function generateConstants(pascal) {
@@ -819,20 +1006,19 @@ export class Delete${pascal}UseCase {
 __name(generateUseCases, "generateUseCases");
 
 // src/generators/templates/repository.ts
-function generateRepositoryInterface(pascal, kebab) {
+function generateRepositoryInterface(pascal, kebab, dtoPrefix = "../../application/dtos") {
   return `/**
  * ${pascal} Repository Interface
  *
- * Domain layer \u2014 defines the contract for data access.
- * The interface lives in the domain layer; implementations live in infrastructure.
- * This inversion of dependencies keeps the domain pure and testable.
+ * Defines the contract for data access.
+ * The interface declares what operations are available;
+ * implementations (in-memory, Drizzle, Prisma) fulfill the contract.
  *
- * To swap implementations (e.g. in-memory -> Drizzle -> Prisma),
- * change the factory in the module's register() method.
+ * To swap implementations, change the factory in the module's register() method.
  */
-import type { ${pascal}ResponseDTO } from '../../application/dtos/${kebab}-response.dto'
-import type { Create${pascal}DTO } from '../../application/dtos/create-${kebab}.dto'
-import type { Update${pascal}DTO } from '../../application/dtos/update-${kebab}.dto'
+import type { ${pascal}ResponseDTO } from '${dtoPrefix}/${kebab}-response.dto'
+import type { Create${pascal}DTO } from '${dtoPrefix}/create-${kebab}.dto'
+import type { Update${pascal}DTO } from '${dtoPrefix}/update-${kebab}.dto'
 import type { ParsedQuery } from '@forinda/kickjs-http'
 
 export interface I${pascal}Repository {
@@ -848,11 +1034,11 @@ export const ${pascal.toUpperCase()}_REPOSITORY = Symbol('I${pascal}Repository')
 `;
 }
 __name(generateRepositoryInterface, "generateRepositoryInterface");
-function generateInMemoryRepository(pascal, kebab) {
+function generateInMemoryRepository(pascal, kebab, repoPrefix = "../../domain/repositories", dtoPrefix = "../../application/dtos") {
   return `/**
  * In-Memory ${pascal} Repository
  *
- * Infrastructure layer \u2014 implements the repository interface using a Map.
+ * Implements the repository interface using a Map.
  * Useful for prototyping and testing. Replace with a database implementation
  * (Drizzle, Prisma, etc.) for production use.
  *
@@ -861,10 +1047,10 @@ function generateInMemoryRepository(pascal, kebab) {
 import { randomUUID } from 'node:crypto'
 import { Repository, HttpException } from '@forinda/kickjs-core'
 import type { ParsedQuery } from '@forinda/kickjs-http'
-import type { I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
-import type { ${pascal}ResponseDTO } from '../../application/dtos/${kebab}-response.dto'
-import type { Create${pascal}DTO } from '../../application/dtos/create-${kebab}.dto'
-import type { Update${pascal}DTO } from '../../application/dtos/update-${kebab}.dto'
+import type { I${pascal}Repository } from '${repoPrefix}/${kebab}.repository'
+import type { ${pascal}ResponseDTO } from '${dtoPrefix}/${kebab}-response.dto'
+import type { Create${pascal}DTO } from '${dtoPrefix}/create-${kebab}.dto'
+import type { Update${pascal}DTO } from '${dtoPrefix}/update-${kebab}.dto'
 
 @Repository()
 export class InMemory${pascal}Repository implements I${pascal}Repository {
@@ -912,6 +1098,162 @@ export class InMemory${pascal}Repository implements I${pascal}Repository {
 `;
 }
 __name(generateInMemoryRepository, "generateInMemoryRepository");
+function generateDrizzleRepository(pascal, kebab, repoPrefix = "../../domain/repositories", dtoPrefix = "../../application/dtos") {
+  return `/**
+ * Drizzle ${pascal} Repository
+ *
+ * Implements the repository interface using Drizzle ORM.
+ * Requires a Drizzle database instance injected via the DI container.
+ *
+ * TODO: Update the schema import to match your Drizzle schema file.
+ * TODO: Replace 'db' injection token with your actual database token.
+ *
+ * @Repository() registers this class in the DI container as a singleton.
+ */
+import { eq, sql } from 'drizzle-orm'
+import { Repository, HttpException, Autowired } from '@forinda/kickjs-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+import type { I${pascal}Repository } from '${repoPrefix}/${kebab}.repository'
+import type { ${pascal}ResponseDTO } from '${dtoPrefix}/${kebab}-response.dto'
+import type { Create${pascal}DTO } from '${dtoPrefix}/create-${kebab}.dto'
+import type { Update${pascal}DTO } from '${dtoPrefix}/update-${kebab}.dto'
+
+// TODO: Import your Drizzle schema table \u2014 e.g.:
+// import { ${kebab}s } from '@/db/schema'
+
+// TODO: Import your Drizzle DB injection token \u2014 e.g.:
+// import { DRIZZLE_DB } from '@/db/drizzle.provider'
+
+@Repository()
+export class Drizzle${pascal}Repository implements I${pascal}Repository {
+  // TODO: Uncomment and configure your Drizzle DB injection:
+  // @Autowired(DRIZZLE_DB) private db!: DrizzleDB
+
+  async findById(id: string): Promise<${pascal}ResponseDTO | null> {
+    // TODO: Implement with Drizzle
+    // const [row] = await this.db.select().from(${kebab}s).where(eq(${kebab}s.id, id))
+    // return row ?? null
+    throw new Error('Drizzle ${pascal} repository not yet implemented \u2014 update schema imports and queries')
+  }
+
+  async findAll(): Promise<${pascal}ResponseDTO[]> {
+    // TODO: Implement with Drizzle
+    // return this.db.select().from(${kebab}s)
+    throw new Error('Drizzle ${pascal} repository not yet implemented')
+  }
+
+  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${pascal}ResponseDTO[]; total: number }> {
+    // TODO: Implement with Drizzle
+    // const data = await this.db.select().from(${kebab}s)
+    //   .limit(parsed.pagination.limit)
+    //   .offset(parsed.pagination.offset)
+    // const [{ count }] = await this.db.select({ count: sql\`count(*)\` }).from(${kebab}s)
+    // return { data, total: Number(count) }
+    throw new Error('Drizzle ${pascal} repository not yet implemented')
+  }
+
+  async create(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    // TODO: Implement with Drizzle
+    // const [row] = await this.db.insert(${kebab}s).values(dto).returning()
+    // return row
+    throw new Error('Drizzle ${pascal} repository not yet implemented')
+  }
+
+  async update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    // TODO: Implement with Drizzle
+    // const [row] = await this.db.update(${kebab}s).set(dto).where(eq(${kebab}s.id, id)).returning()
+    // if (!row) throw HttpException.notFound('${pascal} not found')
+    // return row
+    throw new Error('Drizzle ${pascal} repository not yet implemented')
+  }
+
+  async delete(id: string): Promise<void> {
+    // TODO: Implement with Drizzle
+    // const result = await this.db.delete(${kebab}s).where(eq(${kebab}s.id, id))
+    // if (!result.rowCount) throw HttpException.notFound('${pascal} not found')
+    throw new Error('Drizzle ${pascal} repository not yet implemented')
+  }
+}
+`;
+}
+__name(generateDrizzleRepository, "generateDrizzleRepository");
+function generatePrismaRepository(pascal, kebab, repoPrefix = "../../domain/repositories", dtoPrefix = "../../application/dtos") {
+  const camel = kebab.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+  return `/**
+ * Prisma ${pascal} Repository
+ *
+ * Implements the repository interface using Prisma Client.
+ * Requires a PrismaClient instance injected via the DI container.
+ *
+ * TODO: Ensure your Prisma schema has a '${pascal}' model defined.
+ * TODO: Replace 'PRISMA_CLIENT' with your actual Prisma injection token.
+ *
+ * @Repository() registers this class in the DI container as a singleton.
+ */
+import { Repository, HttpException, Autowired } from '@forinda/kickjs-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+import type { I${pascal}Repository } from '${repoPrefix}/${kebab}.repository'
+import type { ${pascal}ResponseDTO } from '${dtoPrefix}/${kebab}-response.dto'
+import type { Create${pascal}DTO } from '${dtoPrefix}/create-${kebab}.dto'
+import type { Update${pascal}DTO } from '${dtoPrefix}/update-${kebab}.dto'
+
+// TODO: Import your Prisma injection token \u2014 e.g.:
+// import { PRISMA_CLIENT } from '@/db/prisma.provider'
+// import type { PrismaClient } from '@prisma/client'
+
+@Repository()
+export class Prisma${pascal}Repository implements I${pascal}Repository {
+  // TODO: Uncomment and configure your Prisma injection:
+  // @Autowired(PRISMA_CLIENT) private prisma!: PrismaClient
+
+  async findById(id: string): Promise<${pascal}ResponseDTO | null> {
+    // TODO: Implement with Prisma
+    // return this.prisma.${camel}.findUnique({ where: { id } })
+    throw new Error('Prisma ${pascal} repository not yet implemented \u2014 update Prisma imports and queries')
+  }
+
+  async findAll(): Promise<${pascal}ResponseDTO[]> {
+    // TODO: Implement with Prisma
+    // return this.prisma.${camel}.findMany()
+    throw new Error('Prisma ${pascal} repository not yet implemented')
+  }
+
+  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${pascal}ResponseDTO[]; total: number }> {
+    // TODO: Implement with Prisma
+    // const [data, total] = await Promise.all([
+    //   this.prisma.${camel}.findMany({
+    //     skip: parsed.pagination.offset,
+    //     take: parsed.pagination.limit,
+    //   }),
+    //   this.prisma.${camel}.count(),
+    // ])
+    // return { data, total }
+    throw new Error('Prisma ${pascal} repository not yet implemented')
+  }
+
+  async create(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    // TODO: Implement with Prisma
+    // return this.prisma.${camel}.create({ data: dto })
+    throw new Error('Prisma ${pascal} repository not yet implemented')
+  }
+
+  async update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    // TODO: Implement with Prisma
+    // const row = await this.prisma.${camel}.update({ where: { id }, data: dto })
+    // if (!row) throw HttpException.notFound('${pascal} not found')
+    // return row
+    throw new Error('Prisma ${pascal} repository not yet implemented')
+  }
+
+  async delete(id: string): Promise<void> {
+    // TODO: Implement with Prisma
+    // await this.prisma.${camel}.delete({ where: { id } })
+    throw new Error('Prisma ${pascal} repository not yet implemented')
+  }
+}
+`;
+}
+__name(generatePrismaRepository, "generatePrismaRepository");
 
 // src/generators/templates/domain.ts
 function generateDomainService(pascal, kebab) {
@@ -1110,9 +1452,9 @@ describe('${pascal}Controller', () => {
 `;
 }
 __name(generateControllerTest, "generateControllerTest");
-function generateRepositoryTest(pascal, kebab, plural) {
+function generateRepositoryTest(pascal, kebab, plural, repoImport = `../infrastructure/repositories/in-memory-${kebab}.repository`) {
   return `import { describe, it, expect, beforeEach } from 'vitest'
-import { InMemory${pascal}Repository } from '../infrastructure/repositories/in-memory-${kebab}.repository'
+import { InMemory${pascal}Repository } from '${repoImport}'
 
 describe('InMemory${pascal}Repository', () => {
   let repo: InMemory${pascal}Repository
@@ -1156,42 +1498,574 @@ describe('InMemory${pascal}Repository', () => {
       pagination: { page: 1, limit: 2, offset: 0 },
     })
 
-    expect(result.data).toHaveLength(2)
-    expect(result.total).toBe(3)
-  })
-
-  it('should update a ${kebab}', async () => {
-    const created = await repo.create({ name: 'Original' })
-    const updated = await repo.update(created.id, { name: 'Updated' })
-    expect(updated.name).toBe('Updated')
-  })
+    expect(result.data).toHaveLength(2)
+    expect(result.total).toBe(3)
+  })
+
+  it('should update a ${kebab}', async () => {
+    const created = await repo.create({ name: 'Original' })
+    const updated = await repo.update(created.id, { name: 'Updated' })
+    expect(updated.name).toBe('Updated')
+  })
+
+  it('should delete a ${kebab}', async () => {
+    const created = await repo.create({ name: 'To Delete' })
+    await repo.delete(created.id)
+    const found = await repo.findById(created.id)
+    expect(found).toBeNull()
+  })
+})
+`;
+}
+__name(generateRepositoryTest, "generateRepositoryTest");
+
+// src/generators/templates/rest-service.ts
+function generateRestService(pascal, kebab) {
+  return `import { Service, Inject, HttpException } from '@forinda/kickjs-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from './${kebab}.repository'
+import type { ${pascal}ResponseDTO } from './dtos/${kebab}-response.dto'
+import type { Create${pascal}DTO } from './dtos/create-${kebab}.dto'
+import type { Update${pascal}DTO } from './dtos/update-${kebab}.dto'
+
+@Service()
+export class ${pascal}Service {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+  ) {}
+
+  async findById(id: string): Promise<${pascal}ResponseDTO | null> {
+    return this.repo.findById(id)
+  }
+
+  async findAll(): Promise<${pascal}ResponseDTO[]> {
+    return this.repo.findAll()
+  }
+
+  async findPaginated(parsed: ParsedQuery) {
+    return this.repo.findPaginated(parsed)
+  }
+
+  async create(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    return this.repo.create(dto)
+  }
+
+  async update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    return this.repo.update(id, dto)
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.repo.delete(id)
+  }
+}
+`;
+}
+__name(generateRestService, "generateRestService");
+function generateRestConstants(pascal) {
+  return `import type { QueryFieldConfig } from '@forinda/kickjs-http'
+
+export const ${pascal.toUpperCase()}_QUERY_CONFIG: QueryFieldConfig = {
+  filterable: ['name'],
+  sortable: ['name', 'createdAt'],
+  searchable: ['name'],
+}
+`;
+}
+__name(generateRestConstants, "generateRestConstants");
+
+// src/generators/templates/cqrs.ts
+function generateCqrsModuleIndex(pascal, kebab, plural, repo) {
+  const repoClassMap = {
+    inmemory: `InMemory${pascal}Repository`,
+    drizzle: `Drizzle${pascal}Repository`,
+    prisma: `Prisma${pascal}Repository`
+  };
+  const repoFileMap = {
+    inmemory: `in-memory-${kebab}`,
+    drizzle: `drizzle-${kebab}`,
+    prisma: `prisma-${kebab}`
+  };
+  const repoClass = repoClassMap[repo] ?? repoClassMap.inmemory;
+  const repoFile = repoFileMap[repo] ?? repoFileMap.inmemory;
+  return `/**
+ * ${pascal} Module \u2014 CQRS Pattern
+ *
+ * Separates read (queries) and write (commands) operations.
+ * Events are emitted after state changes and can be handled via
+ * WebSocket broadcasts, queue jobs, or ETL pipelines.
+ *
+ * Structure:
+ *   commands/       \u2014 Write operations (create, update, delete)
+ *   queries/        \u2014 Read operations (get, list)
+ *   events/         \u2014 Domain events + handlers (WS broadcast, queue dispatch)
+ *   dtos/           \u2014 Request/response schemas
+ */
+import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs-core'
+import { buildRoutes } from '@forinda/kickjs-http'
+import { ${pascal.toUpperCase()}_REPOSITORY } from './${kebab}.repository'
+import { ${repoClass} } from './${repoFile}.repository'
+import { ${pascal}Controller } from './${kebab}.controller'
+
+// Eagerly load decorated classes
+import.meta.glob(
+  [
+    './commands/**/*.ts',
+    './queries/**/*.ts',
+    './events/**/*.ts',
+    '!./**/*.test.ts',
+  ],
+  { eager: true },
+)
+
+export class ${pascal}Module implements AppModule {
+  register(container: Container): void {
+    container.registerFactory(${pascal.toUpperCase()}_REPOSITORY, () =>
+      container.resolve(${repoClass}),
+    )
+  }
+
+  routes(): ModuleRoutes {
+    return {
+      path: '/${plural}',
+      router: buildRoutes(${pascal}Controller),
+      controller: ${pascal}Controller,
+    }
+  }
+}
+`;
+}
+__name(generateCqrsModuleIndex, "generateCqrsModuleIndex");
+function generateCqrsController(pascal, kebab, plural, pluralPascal) {
+  const camel = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  return `import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams } from '@forinda/kickjs-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+import { ApiTags } from '@forinda/kickjs-swagger'
+import { Create${pascal}Command } from './commands/create-${kebab}.command'
+import { Update${pascal}Command } from './commands/update-${kebab}.command'
+import { Delete${pascal}Command } from './commands/delete-${kebab}.command'
+import { Get${pascal}Query } from './queries/get-${kebab}.query'
+import { List${pluralPascal}Query } from './queries/list-${plural}.query'
+import { create${pascal}Schema } from './dtos/create-${kebab}.dto'
+import { update${pascal}Schema } from './dtos/update-${kebab}.dto'
+import { ${pascal.toUpperCase()}_QUERY_CONFIG } from './${kebab}.constants'
+
+@Controller()
+export class ${pascal}Controller {
+  @Autowired() private create${pascal}Command!: Create${pascal}Command
+  @Autowired() private update${pascal}Command!: Update${pascal}Command
+  @Autowired() private delete${pascal}Command!: Delete${pascal}Command
+  @Autowired() private get${pascal}Query!: Get${pascal}Query
+  @Autowired() private list${pluralPascal}Query!: List${pluralPascal}Query
+
+  @Get('/')
+  @ApiTags('${pascal}')
+  @ApiQueryParams(${pascal.toUpperCase()}_QUERY_CONFIG)
+  async list(ctx: RequestContext) {
+    return ctx.paginate(
+      (parsed) => this.list${pluralPascal}Query.execute(parsed),
+      ${pascal.toUpperCase()}_QUERY_CONFIG,
+    )
+  }
+
+  @Get('/:id')
+  @ApiTags('${pascal}')
+  async getById(ctx: RequestContext) {
+    const result = await this.get${pascal}Query.execute(ctx.params.id)
+    if (!result) return ctx.notFound('${pascal} not found')
+    ctx.json(result)
+  }
+
+  @Post('/', { body: create${pascal}Schema, name: 'Create${pascal}' })
+  @ApiTags('${pascal}')
+  async create(ctx: RequestContext) {
+    const result = await this.create${pascal}Command.execute(ctx.body)
+    ctx.created(result)
+  }
+
+  @Put('/:id', { body: update${pascal}Schema, name: 'Update${pascal}' })
+  @ApiTags('${pascal}')
+  async update(ctx: RequestContext) {
+    const result = await this.update${pascal}Command.execute(ctx.params.id, ctx.body)
+    ctx.json(result)
+  }
+
+  @Delete('/:id')
+  @ApiTags('${pascal}')
+  async remove(ctx: RequestContext) {
+    await this.delete${pascal}Command.execute(ctx.params.id)
+    ctx.noContent()
+  }
+}
+`;
+}
+__name(generateCqrsController, "generateCqrsController");
+function generateCqrsCommands(pascal, kebab) {
+  return [
+    {
+      file: `create-${kebab}.command.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../${kebab}.repository'
+import type { Create${pascal}DTO } from '../dtos/create-${kebab}.dto'
+import type { ${pascal}ResponseDTO } from '../dtos/${kebab}-response.dto'
+import { ${pascal}Events } from '../events/${kebab}.events'
+
+@Service()
+export class Create${pascal}Command {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+    @Inject(${pascal}Events) private readonly events: ${pascal}Events,
+  ) {}
+
+  async execute(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    const result = await this.repo.create(dto)
+    this.events.emit('${kebab}.created', result)
+    return result
+  }
+}
+`
+    },
+    {
+      file: `update-${kebab}.command.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../${kebab}.repository'
+import type { Update${pascal}DTO } from '../dtos/update-${kebab}.dto'
+import type { ${pascal}ResponseDTO } from '../dtos/${kebab}-response.dto'
+import { ${pascal}Events } from '../events/${kebab}.events'
+
+@Service()
+export class Update${pascal}Command {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+    @Inject(${pascal}Events) private readonly events: ${pascal}Events,
+  ) {}
+
+  async execute(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    const result = await this.repo.update(id, dto)
+    this.events.emit('${kebab}.updated', result)
+    return result
+  }
+}
+`
+    },
+    {
+      file: `delete-${kebab}.command.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../${kebab}.repository'
+import { ${pascal}Events } from '../events/${kebab}.events'
+
+@Service()
+export class Delete${pascal}Command {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+    @Inject(${pascal}Events) private readonly events: ${pascal}Events,
+  ) {}
+
+  async execute(id: string): Promise<void> {
+    await this.repo.delete(id)
+    this.events.emit('${kebab}.deleted', { id })
+  }
+}
+`
+    }
+  ];
+}
+__name(generateCqrsCommands, "generateCqrsCommands");
+function generateCqrsQueries(pascal, kebab, plural, pluralPascal) {
+  return [
+    {
+      file: `get-${kebab}.query.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../${kebab}.repository'
+import type { ${pascal}ResponseDTO } from '../dtos/${kebab}-response.dto'
+
+@Service()
+export class Get${pascal}Query {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+  ) {}
+
+  async execute(id: string): Promise<${pascal}ResponseDTO | null> {
+    return this.repo.findById(id)
+  }
+}
+`
+    },
+    {
+      file: `list-${plural}.query.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../${kebab}.repository'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+
+@Service()
+export class List${pluralPascal}Query {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+  ) {}
+
+  async execute(parsed: ParsedQuery) {
+    return this.repo.findPaginated(parsed)
+  }
+}
+`
+    }
+  ];
+}
+__name(generateCqrsQueries, "generateCqrsQueries");
+function generateCqrsEvents(pascal, kebab) {
+  return [
+    {
+      file: `${kebab}.events.ts`,
+      content: `import { Service } from '@forinda/kickjs-core'
+import { EventEmitter } from 'node:events'
+import type { ${pascal}ResponseDTO } from '../dtos/${kebab}-response.dto'
+
+/**
+ * ${pascal} domain event types.
+ *
+ * These events are emitted by commands after state changes.
+ * Subscribe to them in event handlers for side effects:
+ *   - WebSocket broadcasts (real-time UI updates)
+ *   - Queue jobs (async processing, ETL pipelines)
+ *   - Audit logging
+ *   - Cache invalidation
+ */
+export interface ${pascal}EventMap {
+  '${kebab}.created': ${pascal}ResponseDTO
+  '${kebab}.updated': ${pascal}ResponseDTO
+  '${kebab}.deleted': { id: string }
+}
+
+@Service()
+export class ${pascal}Events {
+  private emitter = new EventEmitter()
+
+  emit<K extends keyof ${pascal}EventMap>(event: K, data: ${pascal}EventMap[K]): void {
+    this.emitter.emit(event, data)
+  }
+
+  on<K extends keyof ${pascal}EventMap>(event: K, handler: (data: ${pascal}EventMap[K]) => void): void {
+    this.emitter.on(event, handler)
+  }
+
+  off<K extends keyof ${pascal}EventMap>(event: K, handler: (data: ${pascal}EventMap[K]) => void): void {
+    this.emitter.off(event, handler)
+  }
+}
+`
+    },
+    {
+      file: `on-${kebab}-change.handler.ts`,
+      content: `import { Service, Autowired } from '@forinda/kickjs-core'
+import { ${pascal}Events } from './${kebab}.events'
+
+/**
+ * ${pascal} Change Event Handler
+ *
+ * Reacts to domain events emitted by commands.
+ * Wire up side effects here:
+ *
+ * 1. WebSocket broadcast \u2014 notify connected clients in real-time
+ *    import { WsGateway } from '@forinda/kickjs-ws'
+ *    this.ws.broadcast('${kebab}-channel', { event, data })
+ *
+ * 2. Queue dispatch \u2014 offload heavy processing to background workers
+ *    import { QueueService } from '@forinda/kickjs-queue'
+ *    this.queue.add('${kebab}-etl', { action: event, payload: data })
+ *
+ * 3. ETL pipeline \u2014 transform and load data to external systems
+ *    await this.etlPipeline.process(data)
+ */
+@Service()
+export class On${pascal}ChangeHandler {
+  @Autowired() private events!: ${pascal}Events
+
+  // Uncomment to inject WebSocket and Queue services:
+  // @Autowired() private ws!: WsGateway
+  // @Autowired() private queue!: QueueService
+
+  onInit(): void {
+    this.events.on('${kebab}.created', (data) => {
+      console.log('[${pascal}] Created:', data.id)
+      // TODO: Broadcast via WebSocket
+      // this.ws.broadcast('${kebab}-channel', { event: '${kebab}.created', data })
+      // TODO: Dispatch to queue for async processing / ETL
+      // this.queue.add('${kebab}-etl', { action: 'create', payload: data })
+    })
+
+    this.events.on('${kebab}.updated', (data) => {
+      console.log('[${pascal}] Updated:', data.id)
+      // TODO: Broadcast via WebSocket
+      // this.ws.broadcast('${kebab}-channel', { event: '${kebab}.updated', data })
+    })
 
-  it('should delete a ${kebab}', async () => {
-    const created = await repo.create({ name: 'To Delete' })
-    await repo.delete(created.id)
-    const found = await repo.findById(created.id)
-    expect(found).toBeNull()
-  })
-})
-`;
+    this.events.on('${kebab}.deleted', (data) => {
+      console.log('[${pascal}] Deleted:', data.id)
+      // TODO: Broadcast via WebSocket
+      // this.ws.broadcast('${kebab}-channel', { event: '${kebab}.deleted', data })
+    })
+  }
 }
-__name(generateRepositoryTest, "generateRepositoryTest");
+`
+    }
+  ];
+}
+__name(generateCqrsEvents, "generateCqrsEvents");
 
 // src/generators/module.ts
+function promptUser(question) {
+  const rl = createInterface2({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve8) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve8(answer.trim().toLowerCase());
+    });
+  });
+}
+__name(promptUser, "promptUser");
 async function generateModule(options) {
-  const { name, modulesDir, noEntity, noTests, repo = "inmemory", minimal } = options;
+  const { name, modulesDir, noEntity, noTests, repo = "inmemory", force } = options;
+  let pattern = options.pattern ?? "ddd";
+  if (options.minimal) pattern = "minimal";
   const kebab = toKebabCase(name);
   const pascal = toPascalCase(name);
-  const camel = toCamelCase(name);
   const plural = pluralize(kebab);
   const pluralPascal = pluralizePascal(pascal);
   const moduleDir = join2(modulesDir, plural);
   const files = [];
+  let overwriteAll = force ?? false;
   const write = /* @__PURE__ */ __name(async (relativePath, content) => {
     const fullPath = join2(moduleDir, relativePath);
+    if (!overwriteAll && await fileExists(fullPath)) {
+      const answer = await promptUser(`  File already exists: ${relativePath}
+  Overwrite? (y/n/a = yes/no/all) `);
+      if (answer === "a") {
+        overwriteAll = true;
+      } else if (answer !== "y") {
+        console.log(`  Skipped: ${relativePath}`);
+        return;
+      }
+    }
     await writeFileSafe(fullPath, content);
     files.push(fullPath);
   }, "write");
+  const ctx = {
+    kebab,
+    pascal,
+    plural,
+    pluralPascal,
+    moduleDir,
+    repo,
+    noEntity: noEntity ?? false,
+    noTests: noTests ?? false,
+    write,
+    files
+  };
+  switch (pattern) {
+    case "minimal":
+      await generateMinimalFiles(ctx);
+      break;
+    case "rest":
+      await generateRestFiles(ctx);
+      break;
+    case "cqrs":
+      await generateCqrsFiles(ctx);
+      break;
+    case "graphql":
+    case "ddd":
+    default:
+      await generateDddFiles(ctx);
+      break;
+  }
+  await autoRegisterModule(modulesDir, pascal, plural);
+  return files;
+}
+__name(generateModule, "generateModule");
+async function generateMinimalFiles(ctx) {
+  const { pascal, kebab, plural, write } = ctx;
+  await write("index.ts", generateMinimalModuleIndex(pascal, kebab, plural));
+  await write(`${kebab}.controller.ts`, `import { Controller, Get } from '@forinda/kickjs-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+
+@Controller()
+export class ${pascal}Controller {
+  @Get('/')
+  async list(ctx: RequestContext) {
+    ctx.json({ message: '${pascal} list' })
+  }
+}
+`);
+}
+__name(generateMinimalFiles, "generateMinimalFiles");
+async function generateRestFiles(ctx) {
+  const { pascal, kebab, plural, pluralPascal, repo, noTests, write } = ctx;
+  await write("index.ts", generateRestModuleIndex(pascal, kebab, plural, repo));
+  await write(`${kebab}.constants.ts`, generateRestConstants(pascal));
+  await write(`${kebab}.controller.ts`, generateRestController(pascal, kebab, plural, pluralPascal));
+  await write(`${kebab}.service.ts`, generateRestService(pascal, kebab));
+  await write(`dtos/create-${kebab}.dto.ts`, generateCreateDTO(pascal, kebab));
+  await write(`dtos/update-${kebab}.dto.ts`, generateUpdateDTO(pascal, kebab));
+  await write(`dtos/${kebab}-response.dto.ts`, generateResponseDTO(pascal, kebab));
+  await write(`${kebab}.repository.ts`, generateRepositoryInterface(pascal, kebab, "./dtos"));
+  const repoFileMap = {
+    inmemory: `in-memory-${kebab}`,
+    drizzle: `drizzle-${kebab}`,
+    prisma: `prisma-${kebab}`
+  };
+  const repoGeneratorMap = {
+    inmemory: /* @__PURE__ */ __name(() => generateInMemoryRepository(pascal, kebab, ".", "./dtos"), "inmemory"),
+    drizzle: /* @__PURE__ */ __name(() => generateDrizzleRepository(pascal, kebab, ".", "./dtos"), "drizzle"),
+    prisma: /* @__PURE__ */ __name(() => generatePrismaRepository(pascal, kebab, ".", "./dtos"), "prisma")
+  };
+  await write(`${repoFileMap[repo]}.repository.ts`, repoGeneratorMap[repo]());
+  if (!noTests) {
+    await write(`__tests__/${kebab}.controller.test.ts`, generateControllerTest(pascal, kebab, plural));
+    await write(`__tests__/${kebab}.repository.test.ts`, generateRepositoryTest(pascal, kebab, plural, `../${repoFileMap.inmemory}.repository`));
+  }
+}
+__name(generateRestFiles, "generateRestFiles");
+async function generateCqrsFiles(ctx) {
+  const { pascal, kebab, plural, pluralPascal, repo, noTests, write } = ctx;
+  await write("index.ts", generateCqrsModuleIndex(pascal, kebab, plural, repo));
+  await write(`${kebab}.constants.ts`, generateRestConstants(pascal));
+  await write(`${kebab}.controller.ts`, generateCqrsController(pascal, kebab, plural, pluralPascal));
+  await write(`dtos/create-${kebab}.dto.ts`, generateCreateDTO(pascal, kebab));
+  await write(`dtos/update-${kebab}.dto.ts`, generateUpdateDTO(pascal, kebab));
+  await write(`dtos/${kebab}-response.dto.ts`, generateResponseDTO(pascal, kebab));
+  const commands = generateCqrsCommands(pascal, kebab);
+  for (const cmd of commands) {
+    await write(`commands/${cmd.file}`, cmd.content);
+  }
+  const queries = generateCqrsQueries(pascal, kebab, plural, pluralPascal);
+  for (const q of queries) {
+    await write(`queries/${q.file}`, q.content);
+  }
+  const events = generateCqrsEvents(pascal, kebab);
+  for (const e of events) {
+    await write(`events/${e.file}`, e.content);
+  }
+  await write(`${kebab}.repository.ts`, generateRepositoryInterface(pascal, kebab, "./dtos"));
+  const repoFileMap = {
+    inmemory: `in-memory-${kebab}`,
+    drizzle: `drizzle-${kebab}`,
+    prisma: `prisma-${kebab}`
+  };
+  const repoGeneratorMap = {
+    inmemory: /* @__PURE__ */ __name(() => generateInMemoryRepository(pascal, kebab, ".", "./dtos"), "inmemory"),
+    drizzle: /* @__PURE__ */ __name(() => generateDrizzleRepository(pascal, kebab, ".", "./dtos"), "drizzle"),
+    prisma: /* @__PURE__ */ __name(() => generatePrismaRepository(pascal, kebab, ".", "./dtos"), "prisma")
+  };
+  await write(`${repoFileMap[repo]}.repository.ts`, repoGeneratorMap[repo]());
+  if (!noTests) {
+    await write(`__tests__/${kebab}.controller.test.ts`, generateControllerTest(pascal, kebab, plural));
+    await write(`__tests__/${kebab}.repository.test.ts`, generateRepositoryTest(pascal, kebab, plural, `../${repoFileMap.inmemory}.repository`));
+  }
+}
+__name(generateCqrsFiles, "generateCqrsFiles");
+async function generateDddFiles(ctx) {
+  const { pascal, kebab, plural, pluralPascal, repo, noEntity, noTests, write } = ctx;
   await write("index.ts", generateModuleIndex(pascal, kebab, plural, repo));
   await write("constants.ts", generateConstants(pascal));
   await write(`presentation/${kebab}.controller.ts`, generateController(pascal, kebab, plural, pluralPascal));
@@ -1204,10 +2078,18 @@ async function generateModule(options) {
   }
   await write(`domain/repositories/${kebab}.repository.ts`, generateRepositoryInterface(pascal, kebab));
   await write(`domain/services/${kebab}-domain.service.ts`, generateDomainService(pascal, kebab));
-  if (repo === "inmemory") {
-    await write(`infrastructure/repositories/in-memory-${kebab}.repository.ts`, generateInMemoryRepository(pascal, kebab));
-  }
-  if (!noEntity && !minimal) {
+  const repoFileMap = {
+    inmemory: `in-memory-${kebab}`,
+    drizzle: `drizzle-${kebab}`,
+    prisma: `prisma-${kebab}`
+  };
+  const repoGeneratorMap = {
+    inmemory: /* @__PURE__ */ __name(() => generateInMemoryRepository(pascal, kebab), "inmemory"),
+    drizzle: /* @__PURE__ */ __name(() => generateDrizzleRepository(pascal, kebab), "drizzle"),
+    prisma: /* @__PURE__ */ __name(() => generatePrismaRepository(pascal, kebab), "prisma")
+  };
+  await write(`infrastructure/repositories/${repoFileMap[repo]}.repository.ts`, repoGeneratorMap[repo]());
+  if (!noEntity) {
     await write(`domain/entities/${kebab}.entity.ts`, generateEntity(pascal, kebab));
     await write(`domain/value-objects/${kebab}-id.vo.ts`, generateValueObject(pascal, kebab));
   }
@@ -1215,10 +2097,8 @@ async function generateModule(options) {
     await write(`__tests__/${kebab}.controller.test.ts`, generateControllerTest(pascal, kebab, plural));
     await write(`__tests__/${kebab}.repository.test.ts`, generateRepositoryTest(pascal, kebab, plural));
   }
-  await autoRegisterModule(modulesDir, pascal, plural);
-  return files;
 }
-__name(generateModule, "generateModule");
+__name(generateDddFiles, "generateDddFiles");
 async function autoRegisterModule(modulesDir, pascal, plural) {
   const indexPath = join2(modulesDir, "index.ts");
   const exists = await fileExists(indexPath);
@@ -1354,13 +2234,64 @@ export class ${pascal}Adapter implements AppAdapter {
 __name(generateAdapter, "generateAdapter");
 
 // src/generators/middleware.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
+
+// src/utils/resolve-out-dir.ts
+import { resolve as resolve2, join as join4 } from "path";
+var DDD_FOLDER_MAP = {
+  controller: "presentation",
+  service: "domain/services",
+  dto: "application/dtos",
+  guard: "presentation/guards",
+  middleware: "middleware"
+};
+var FLAT_FOLDER_MAP = {
+  controller: "",
+  service: "",
+  dto: "dtos",
+  guard: "guards",
+  middleware: "middleware"
+};
+var CQRS_FOLDER_MAP = {
+  controller: "",
+  service: "",
+  dto: "dtos",
+  guard: "guards",
+  middleware: "middleware",
+  command: "commands",
+  query: "queries",
+  event: "events"
+};
+function resolveOutDir(options) {
+  const { type, outDir, moduleName, modulesDir = "src/modules", defaultDir, pattern = "ddd" } = options;
+  if (outDir) return resolve2(outDir);
+  if (moduleName) {
+    const folderMap = pattern === "ddd" ? DDD_FOLDER_MAP : pattern === "cqrs" ? CQRS_FOLDER_MAP : FLAT_FOLDER_MAP;
+    const kebab = toKebabCase(moduleName);
+    const plural = pluralize(kebab);
+    const subfolder = folderMap[type] ?? "";
+    const base = join4(modulesDir, plural);
+    return resolve2(subfolder ? join4(base, subfolder) : base);
+  }
+  return resolve2(defaultDir);
+}
+__name(resolveOutDir, "resolveOutDir");
+
+// src/generators/middleware.ts
 async function generateMiddleware(options) {
-  const { name, outDir } = options;
+  const { name, moduleName, modulesDir, pattern } = options;
+  const outDir = resolveOutDir({
+    type: "middleware",
+    outDir: options.outDir,
+    moduleName,
+    modulesDir,
+    defaultDir: "src/middleware",
+    pattern
+  });
   const kebab = toKebabCase(name);
   const camel = toCamelCase(name);
   const files = [];
-  const filePath = join4(outDir, `${kebab}.middleware.ts`);
+  const filePath = join5(outDir, `${kebab}.middleware.ts`);
   await writeFileSafe(filePath, `import type { Request, Response, NextFunction } from 'express'
 
 export interface ${toPascalCase(name)}Options {
@@ -1392,14 +2323,22 @@ export function ${camel}(options: ${toPascalCase(name)}Options = {}) {
 __name(generateMiddleware, "generateMiddleware");
 
 // src/generators/guard.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 async function generateGuard(options) {
-  const { name, outDir } = options;
+  const { name, moduleName, modulesDir, pattern } = options;
+  const outDir = resolveOutDir({
+    type: "guard",
+    outDir: options.outDir,
+    moduleName,
+    modulesDir,
+    defaultDir: "src/guards",
+    pattern
+  });
   const kebab = toKebabCase(name);
   const camel = toCamelCase(name);
   const pascal = toPascalCase(name);
   const files = [];
-  const filePath = join5(outDir, `${kebab}.guard.ts`);
+  const filePath = join6(outDir, `${kebab}.guard.ts`);
   await writeFileSafe(filePath, `import { Container, HttpException } from '@forinda/kickjs-core'
 import type { RequestContext } from '@forinda/kickjs-http'
 
@@ -1443,13 +2382,21 @@ export async function ${camel}Guard(ctx: RequestContext, next: () => void): Prom
 __name(generateGuard, "generateGuard");
 
 // src/generators/service.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 async function generateService(options) {
-  const { name, outDir } = options;
+  const { name, moduleName, modulesDir, pattern } = options;
+  const outDir = resolveOutDir({
+    type: "service",
+    outDir: options.outDir,
+    moduleName,
+    modulesDir,
+    defaultDir: "src/services",
+    pattern
+  });
   const kebab = toKebabCase(name);
   const pascal = toPascalCase(name);
   const files = [];
-  const filePath = join6(outDir, `${kebab}.service.ts`);
+  const filePath = join7(outDir, `${kebab}.service.ts`);
   await writeFileSafe(filePath, `import { Service } from '@forinda/kickjs-core'
 
 @Service()
@@ -1466,13 +2413,21 @@ export class ${pascal}Service {
 __name(generateService, "generateService");
 
 // src/generators/controller.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 async function generateController2(options) {
-  const { name, outDir } = options;
+  const { name, moduleName, modulesDir, pattern } = options;
+  const outDir = resolveOutDir({
+    type: "controller",
+    outDir: options.outDir,
+    moduleName,
+    modulesDir,
+    defaultDir: "src/controllers",
+    pattern
+  });
   const kebab = toKebabCase(name);
   const pascal = toPascalCase(name);
   const files = [];
-  const filePath = join7(outDir, `${kebab}.controller.ts`);
+  const filePath = join8(outDir, `${kebab}.controller.ts`);
   await writeFileSafe(filePath, `import { Controller, Get, Post, Autowired } from '@forinda/kickjs-core'
 import type { RequestContext } from '@forinda/kickjs-http'
 
@@ -1497,14 +2452,22 @@ export class ${pascal}Controller {
 __name(generateController2, "generateController");
 
 // src/generators/dto.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 async function generateDto(options) {
-  const { name, outDir } = options;
+  const { name, moduleName, modulesDir, pattern } = options;
+  const outDir = resolveOutDir({
+    type: "dto",
+    outDir: options.outDir,
+    moduleName,
+    modulesDir,
+    defaultDir: "src/dtos",
+    pattern
+  });
   const kebab = toKebabCase(name);
   const pascal = toPascalCase(name);
   const camel = toCamelCase(name);
   const files = [];
-  const filePath = join8(outDir, `${kebab}.dto.ts`);
+  const filePath = join9(outDir, `${kebab}.dto.ts`);
   await writeFileSafe(filePath, `import { z } from 'zod'
 
 export const ${camel}Schema = z.object({
@@ -1520,24 +2483,24 @@ export type ${pascal}DTO = z.infer<typeof ${camel}Schema>
 __name(generateDto, "generateDto");
 
 // src/generators/config.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { existsSync as existsSync2 } from "fs";
-import { createInterface as createInterface2 } from "readline";
+import { createInterface as createInterface3 } from "readline";
 async function confirm2(message) {
-  const rl = createInterface2({
+  const rl = createInterface3({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve6) => {
+  return new Promise((resolve8) => {
     rl.question(`  ${message} (y/N) `, (answer) => {
       rl.close();
-      resolve6(answer.trim().toLowerCase() === "y");
+      resolve8(answer.trim().toLowerCase() === "y");
     });
   });
 }
 __name(confirm2, "confirm");
 async function generateConfig(options) {
-  const filePath = join9(options.outDir, "kick.config.ts");
+  const filePath = join10(options.outDir, "kick.config.ts");
   const modulesDir = options.modulesDir ?? "src/modules";
   const defaultRepo = options.defaultRepo ?? "inmemory";
   if (existsSync2(filePath) && !options.force) {
@@ -1585,7 +2548,7 @@ export default defineConfig({
 __name(generateConfig, "generateConfig");
 
 // src/generators/resolver.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 async function generateResolver(options) {
   const { name, outDir } = options;
   const pascal = toPascalCase(name);
@@ -1593,7 +2556,7 @@ async function generateResolver(options) {
   const camel = toCamelCase(name);
   const files = [];
   const write = /* @__PURE__ */ __name(async (relativePath, content) => {
-    const fullPath = join10(outDir, relativePath);
+    const fullPath = join11(outDir, relativePath);
     await writeFileSafe(fullPath, content);
     files.push(fullPath);
   }, "write");
@@ -1663,7 +2626,7 @@ export const ${camel}TypeDefs = \`
 __name(generateResolver, "generateResolver");
 
 // src/generators/job.ts
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 async function generateJob(options) {
   const { name, outDir } = options;
   const pascal = toPascalCase(name);
@@ -1672,7 +2635,7 @@ async function generateJob(options) {
   const queueName = options.queue ?? `${kebab}-queue`;
   const files = [];
   const write = /* @__PURE__ */ __name(async (relativePath, content) => {
-    const fullPath = join11(outDir, relativePath);
+    const fullPath = join12(outDir, relativePath);
     await writeFileSafe(fullPath, content);
     files.push(fullPath);
   }, "write");
@@ -1715,7 +2678,7 @@ export class ${pascal}Job {
 __name(generateJob, "generateJob");
 
 // src/generators/scaffold.ts
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 var TYPE_MAP = {
   string: {
@@ -1811,10 +2774,10 @@ async function generateScaffold(options) {
   const camel = toCamelCase(name);
   const plural = pluralize(kebab);
   const pluralPascal = pluralizePascal(pascal);
-  const moduleDir = join12(modulesDir, plural);
+  const moduleDir = join13(modulesDir, plural);
   const files = [];
   const write = /* @__PURE__ */ __name(async (relativePath, content) => {
-    const fullPath = join12(moduleDir, relativePath);
+    const fullPath = join13(moduleDir, relativePath);
     await writeFileSafe(fullPath, content);
     files.push(fullPath);
   }, "write");
@@ -2220,7 +3183,7 @@ export class Delete${pascal}UseCase {
 }
 __name(genUseCases, "genUseCases");
 async function autoRegisterModule2(modulesDir, pascal, plural) {
-  const indexPath = join12(modulesDir, "index.ts");
+  const indexPath = join13(modulesDir, "index.ts");
   const exists = await fileExists(indexPath);
   if (!exists) {
     await writeFileSafe(indexPath, `import type { AppModuleClass } from '@forinda/kickjs-core'
@@ -2251,6 +3214,90 @@ export const modules: AppModuleClass[] = [${pascal}Module]
 }
 __name(autoRegisterModule2, "autoRegisterModule");
 
+// src/generators/test.ts
+import { join as join14, resolve as resolve3 } from "path";
+async function generateTest(options) {
+  const { name, moduleName, modulesDir } = options;
+  const kebab = toKebabCase(name);
+  const pascal = toPascalCase(name);
+  const files = [];
+  let outDir;
+  if (options.outDir) {
+    outDir = resolve3(options.outDir);
+  } else if (moduleName) {
+    const modKebab = toKebabCase(moduleName);
+    const modPlural = pluralize(modKebab);
+    const modDir = modulesDir ?? "src/modules";
+    outDir = resolve3(join14(modDir, modPlural, "__tests__"));
+  } else {
+    outDir = resolve3("src/__tests__");
+  }
+  const filePath = join14(outDir, `${kebab}.test.ts`);
+  await writeFileSafe(filePath, `import { describe, it, expect, beforeEach } from 'vitest'
+import { Container } from '@forinda/kickjs-core'
+
+describe('${pascal}', () => {
+  beforeEach(() => {
+    Container.reset()
+  })
+
+  it('should be defined', () => {
+    // TODO: Import and test your class/function here
+    expect(true).toBe(true)
+  })
+
+  it('should handle the happy path', async () => {
+    // TODO: Set up test data and assertions
+    expect(true).toBe(true)
+  })
+
+  it('should handle edge cases', async () => {
+    // TODO: Test error handling, empty inputs, etc.
+    expect(true).toBe(true)
+  })
+})
+`);
+  files.push(filePath);
+  return files;
+}
+__name(generateTest, "generateTest");
+
+// src/config.ts
+import { readFile as readFile4, access as access2 } from "fs/promises";
+import { join as join15 } from "path";
+var CONFIG_FILES = [
+  "kick.config.ts",
+  "kick.config.js",
+  "kick.config.mjs",
+  "kick.config.json"
+];
+async function loadKickConfig(cwd) {
+  for (const filename of CONFIG_FILES) {
+    const filepath = join15(cwd, filename);
+    try {
+      await access2(filepath);
+    } catch {
+      continue;
+    }
+    if (filename.endsWith(".json")) {
+      const content = await readFile4(filepath, "utf-8");
+      return JSON.parse(content);
+    }
+    try {
+      const { pathToFileURL: pathToFileURL2 } = await import("url");
+      const mod = await import(pathToFileURL2(filepath).href);
+      return mod.default ?? mod;
+    } catch (err) {
+      if (filename.endsWith(".ts")) {
+        console.warn(`Warning: Failed to load ${filename}. TypeScript config files require a runtime loader (e.g. tsx, ts-node) or use kick.config.js/.mjs instead.`);
+      }
+      continue;
+    }
+  }
+  return null;
+}
+__name(loadKickConfig, "loadKickConfig");
+
 // src/commands/generate.ts
 function printGenerated(files) {
   const cwd = process.cwd();
@@ -2262,86 +3309,195 @@ function printGenerated(files) {
   console.log();
 }
 __name(printGenerated, "printGenerated");
+var GENERATORS = [
+  {
+    name: "module <name>",
+    description: "Full DDD module (controller, DTOs, use-cases, repo)"
+  },
+  {
+    name: "scaffold <name> <fields...>",
+    description: "CRUD module from field definitions"
+  },
+  {
+    name: "controller <name>",
+    description: "@Controller() class            [-m module]"
+  },
+  {
+    name: "service <name>",
+    description: "@Service() singleton             [-m module]"
+  },
+  {
+    name: "middleware <name>",
+    description: "Express middleware function     [-m module]"
+  },
+  {
+    name: "guard <name>",
+    description: "Route guard (auth, roles, etc.)  [-m module]"
+  },
+  {
+    name: "dto <name>",
+    description: "Zod DTO schema                  [-m module]"
+  },
+  {
+    name: "adapter <name>",
+    description: "AppAdapter with lifecycle hooks (app-level only)"
+  },
+  {
+    name: "test <name>",
+    description: "Vitest test scaffold            [-m module]"
+  },
+  {
+    name: "resolver <name>",
+    description: "GraphQL @Resolver class"
+  },
+  {
+    name: "job <name>",
+    description: "Queue @Job processor"
+  },
+  {
+    name: "config",
+    description: "Generate kick.config.ts"
+  }
+];
+function printGeneratorList() {
+  console.log("\n  Available generators:\n");
+  const maxName = Math.max(...GENERATORS.map((g) => g.name.length));
+  for (const g of GENERATORS) {
+    console.log(`    kick g ${g.name.padEnd(maxName + 2)} ${g.description}`);
+  }
+  console.log();
+}
+__name(printGeneratorList, "printGeneratorList");
 function registerGenerateCommand(program) {
-  const gen = program.command("generate").alias("g").description("Generate code scaffolds");
-  gen.command("module <name>").description("Generate a full DDD module with all layers").option("--no-entity", "Skip entity and value object generation").option("--no-tests", "Skip test file generation").option("--repo <type>", "Repository implementation: inmemory | drizzle", "inmemory").option("--minimal", "Only generate index.ts and controller").option("--modules-dir <dir>", "Modules directory", "src/modules").action(async (name, opts) => {
+  const gen = program.command("generate").alias("g").description("Generate code scaffolds").option("--list", "List all available generators").action((opts) => {
+    if (opts.list) {
+      printGeneratorList();
+    } else {
+      gen.help();
+    }
+  });
+  gen.command("module <name>").description("Generate a module (structure depends on project pattern)").option("--no-entity", "Skip entity and value object generation").option("--no-tests", "Skip test file generation").option("--repo <type>", "Repository implementation: inmemory | drizzle | prisma").option("--pattern <pattern>", "Override project pattern: rest | ddd | cqrs | minimal").option("--minimal", "Shorthand for --pattern minimal").option("--modules-dir <dir>", "Modules directory").option("-f, --force", "Overwrite existing files without prompting").action(async (name, opts) => {
+    const config = await loadKickConfig(process.cwd());
+    const modulesDir = opts.modulesDir ?? config?.modulesDir ?? "src/modules";
+    const repo = opts.repo ?? config?.defaultRepo ?? "inmemory";
+    const pattern = opts.pattern ?? config?.pattern ?? "ddd";
     const files = await generateModule({
       name,
-      modulesDir: resolve2(opts.modulesDir),
+      modulesDir: resolve4(modulesDir),
       noEntity: opts.entity === false,
       noTests: opts.tests === false,
-      repo: opts.repo,
-      minimal: opts.minimal
+      repo,
+      minimal: opts.minimal,
+      force: opts.force,
+      pattern
     });
     printGenerated(files);
   });
   gen.command("adapter <name>").description("Generate an AppAdapter with lifecycle hooks and middleware support").option("-o, --out <dir>", "Output directory", "src/adapters").action(async (name, opts) => {
     const files = await generateAdapter({
       name,
-      outDir: resolve2(opts.out)
+      outDir: resolve4(opts.out)
     });
     printGenerated(files);
   });
-  gen.command("middleware <name>").description("Generate an Express middleware function").option("-o, --out <dir>", "Output directory", "src/middleware").action(async (name, opts) => {
+  gen.command("middleware <name>").description("Generate an Express middleware function\n  Use -m to scope it to a module: kick g middleware auth -m users").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module folder").action(async (name, opts) => {
+    const config = await loadKickConfig(process.cwd());
+    const modulesDir = config?.modulesDir ?? "src/modules";
     const files = await generateMiddleware({
       name,
-      outDir: resolve2(opts.out)
+      outDir: opts.out,
+      moduleName: opts.module,
+      modulesDir,
+      pattern: config?.pattern
     });
     printGenerated(files);
   });
-  gen.command("guard <name>").description("Generate a route guard (auth, roles, etc.)").option("-o, --out <dir>", "Output directory", "src/guards").action(async (name, opts) => {
+  gen.command("guard <name>").description("Generate a route guard (auth, roles, etc.)\n  Use -m to scope it to a module: kick g guard admin -m users").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module folder").action(async (name, opts) => {
+    const config = await loadKickConfig(process.cwd());
+    const modulesDir = config?.modulesDir ?? "src/modules";
     const files = await generateGuard({
       name,
-      outDir: resolve2(opts.out)
+      outDir: opts.out,
+      moduleName: opts.module,
+      modulesDir,
+      pattern: config?.pattern
     });
     printGenerated(files);
   });
-  gen.command("service <name>").description("Generate a @Service() class").option("-o, --out <dir>", "Output directory", "src/services").action(async (name, opts) => {
+  gen.command("service <name>").description("Generate a @Service() class\n  Use -m to scope it to a module: kick g service payment -m orders").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module folder").action(async (name, opts) => {
+    const config = await loadKickConfig(process.cwd());
+    const modulesDir = config?.modulesDir ?? "src/modules";
     const files = await generateService({
       name,
-      outDir: resolve2(opts.out)
+      outDir: opts.out,
+      moduleName: opts.module,
+      modulesDir,
+      pattern: config?.pattern
     });
     printGenerated(files);
   });
-  gen.command("controller <name>").description("Generate a @Controller() class with basic routes").option("-o, --out <dir>", "Output directory", "src/controllers").action(async (name, opts) => {
+  gen.command("controller <name>").description("Generate a @Controller() class with basic routes\n  Use -m to scope it to a module: kick g controller auth -m users").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module folder").action(async (name, opts) => {
+    const config = await loadKickConfig(process.cwd());
+    const modulesDir = config?.modulesDir ?? "src/modules";
     const files = await generateController2({
       name,
-      outDir: resolve2(opts.out)
+      outDir: opts.out,
+      moduleName: opts.module,
+      modulesDir,
+      pattern: config?.pattern
     });
     printGenerated(files);
   });
-  gen.command("dto <name>").description("Generate a Zod DTO schema").option("-o, --out <dir>", "Output directory", "src/dtos").action(async (name, opts) => {
+  gen.command("dto <name>").description("Generate a Zod DTO schema\n  Use -m to scope it to a module: kick g dto create-user -m users").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module folder").action(async (name, opts) => {
+    const config = await loadKickConfig(process.cwd());
+    const modulesDir = config?.modulesDir ?? "src/modules";
     const files = await generateDto({
       name,
-      outDir: resolve2(opts.out)
+      outDir: opts.out,
+      moduleName: opts.module,
+      modulesDir,
+      pattern: config?.pattern
+    });
+    printGenerated(files);
+  });
+  gen.command("test <name>").description("Generate a Vitest test scaffold\n  Use -m to scope it to a module: kick g test user-service -m users").option("-o, --out <dir>", "Output directory (overrides --module)").option("-m, --module <module>", "Place inside a module's __tests__/ folder").action(async (name, opts) => {
+    const config = await loadKickConfig(process.cwd());
+    const modulesDir = config?.modulesDir ?? "src/modules";
+    const files = await generateTest({
+      name,
+      outDir: opts.out,
+      moduleName: opts.module,
+      modulesDir
     });
     printGenerated(files);
   });
   gen.command("resolver <name>").description("Generate a GraphQL @Resolver class with @Query and @Mutation methods").option("-o, --out <dir>", "Output directory", "src/resolvers").action(async (name, opts) => {
     const files = await generateResolver({
       name,
-      outDir: resolve2(opts.out)
+      outDir: resolve4(opts.out)
     });
     printGenerated(files);
   });
   gen.command("job <name>").description("Generate a @Job queue processor with @Process handlers").option("-o, --out <dir>", "Output directory", "src/jobs").option("-q, --queue <name>", "Queue name (default: <name>-queue)").action(async (name, opts) => {
     const files = await generateJob({
       name,
-      outDir: resolve2(opts.out),
+      outDir: resolve4(opts.out),
       queue: opts.queue
     });
     printGenerated(files);
   });
-  gen.command("scaffold <name> [fields...]").description("Generate a full CRUD module from field definitions\n  Example: kick g scaffold Post title:string body:text published:boolean?\n  Types: string, text, number, int, float, boolean, date, email, url, uuid, json, enum:a,b,c\n  Append ? for optional fields: description:text?").option("--no-entity", "Skip entity and value object generation").option("--no-tests", "Skip test file generation").option("--modules-dir <dir>", "Modules directory", "src/modules").action(async (name, rawFields, opts) => {
+  gen.command("scaffold <name> [fields...]").description("Generate a full CRUD module from field definitions\n  Example: kick g scaffold Post title:string body:text published:boolean?\n  Types: string, text, number, int, float, boolean, date, email, url, uuid, json, enum:a,b,c\n  Append ? for optional fields: description:text?").option("--no-entity", "Skip entity and value object generation").option("--no-tests", "Skip test file generation").option("--modules-dir <dir>", "Modules directory").action(async (name, rawFields, opts) => {
     if (rawFields.length === 0) {
       console.error("\n  Error: At least one field is required.\n  Usage: kick g scaffold <name> <field:type> [field:type...]\n  Example: kick g scaffold Post title:string body:text published:boolean\n");
       process.exit(1);
     }
+    const config = await loadKickConfig(process.cwd());
+    const modulesDir = opts.modulesDir ?? config?.modulesDir ?? "src/modules";
     const fields = parseFields(rawFields);
     const files = await generateScaffold({
       name,
       fields,
-      modulesDir: resolve2(opts.modulesDir),
+      modulesDir: resolve4(modulesDir),
       noEntity: opts.entity === false,
       noTests: opts.tests === false
     });
@@ -2352,9 +3508,9 @@ function registerGenerateCommand(program) {
     }
     printGenerated(files);
   });
-  gen.command("config").description("Generate a kick.config.ts at the project root").option("--modules-dir <dir>", "Modules directory path", "src/modules").option("--repo <type>", "Default repository type: inmemory | drizzle", "inmemory").option("-f, --force", "Overwrite existing kick.config.ts without prompting").action(async (opts) => {
+  gen.command("config").description("Generate a kick.config.ts at the project root").option("--modules-dir <dir>", "Modules directory path", "src/modules").option("--repo <type>", "Default repository type: inmemory | drizzle | prisma", "inmemory").option("-f, --force", "Overwrite existing kick.config.ts without prompting").action(async (opts) => {
     const files = await generateConfig({
-      outDir: resolve2("."),
+      outDir: resolve4("."),
       modulesDir: opts.modulesDir,
       defaultRepo: opts.repo,
       force: opts.force
@@ -2366,7 +3522,7 @@ __name(registerGenerateCommand, "registerGenerateCommand");
 
 // src/commands/run.ts
 import { cpSync, existsSync as existsSync3, mkdirSync } from "fs";
-import { resolve as resolve3, join as join14 } from "path";
+import { resolve as resolve5, join as join16 } from "path";
 
 // src/utils/shell.ts
 import { execSync as execSync2 } from "child_process";
@@ -2378,42 +3534,6 @@ function runShellCommand(command, cwd) {
 }
 __name(runShellCommand, "runShellCommand");
 
-// src/config.ts
-import { readFile as readFile4, access as access2 } from "fs/promises";
-import { join as join13 } from "path";
-var CONFIG_FILES = [
-  "kick.config.ts",
-  "kick.config.js",
-  "kick.config.mjs",
-  "kick.config.json"
-];
-async function loadKickConfig(cwd) {
-  for (const filename of CONFIG_FILES) {
-    const filepath = join13(cwd, filename);
-    try {
-      await access2(filepath);
-    } catch {
-      continue;
-    }
-    if (filename.endsWith(".json")) {
-      const content = await readFile4(filepath, "utf-8");
-      return JSON.parse(content);
-    }
-    try {
-      const { pathToFileURL: pathToFileURL2 } = await import("url");
-      const mod = await import(pathToFileURL2(filepath).href);
-      return mod.default ?? mod;
-    } catch (err) {
-      if (filename.endsWith(".ts")) {
-        console.warn(`Warning: Failed to load ${filename}. TypeScript config files require a runtime loader (e.g. tsx, ts-node) or use kick.config.js/.mjs instead.`);
-      }
-      continue;
-    }
-  }
-  return null;
-}
-__name(loadKickConfig, "loadKickConfig");
-
 // src/commands/run.ts
 function registerRunCommands(program) {
   program.command("dev").description("Start development server with Vite HMR (zero-downtime reload)").option("-e, --entry <file>", "Entry file", "src/index.ts").option("-p, --port <port>", "Port number").action((opts) => {
@@ -2440,9 +3560,9 @@ function registerRunCommands(program) {
       console.log("\n  Copying directories to dist...");
       for (const entry of copyDirs) {
         const src = typeof entry === "string" ? entry : entry.src;
-        const dest = typeof entry === "string" ? join14("dist", entry) : entry.dest ?? join14("dist", src);
-        const srcPath = resolve3(src);
-        const destPath = resolve3(dest);
+        const dest = typeof entry === "string" ? join16("dist", entry) : entry.dest ?? join16("dist", src);
+        const srcPath = resolve5(src);
+        const destPath = resolve5(dest);
         if (!existsSync3(srcPath)) {
           console.log(`    \u26A0 Skipped ${src} (not found)`);
           continue;
@@ -2691,7 +3811,7 @@ __name(registerInspectCommand, "registerInspectCommand");
 // src/commands/add.ts
 import { execSync as execSync3 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve6 } from "path";
 var PACKAGE_REGISTRY = {
   // Core (already installed by kick new)
   core: {
@@ -2841,24 +3961,34 @@ var PACKAGE_REGISTRY = {
   }
 };
 function detectPackageManager() {
-  if (existsSync4(resolve4("pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync4(resolve4("yarn.lock"))) return "yarn";
+  if (existsSync4(resolve6("pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync4(resolve6("yarn.lock"))) return "yarn";
   return "npm";
 }
 __name(detectPackageManager, "detectPackageManager");
+function printPackageList() {
+  console.log("\n  Available KickJS packages:\n");
+  const maxName = Math.max(...Object.keys(PACKAGE_REGISTRY).map((k) => k.length));
+  for (const [name, info] of Object.entries(PACKAGE_REGISTRY)) {
+    const padded = name.padEnd(maxName + 2);
+    const peers = info.peers.length ? ` (+ ${info.peers.join(", ")})` : "";
+    console.log(`    ${padded} ${info.description}${peers}`);
+  }
+  console.log("\n  Usage: kick add graphql drizzle otel");
+  console.log("         kick add queue:bullmq");
+  console.log();
+}
+__name(printPackageList, "printPackageList");
+function registerListCommand(program) {
+  program.command("list").alias("ls").description("List all available KickJS packages").action(() => {
+    printPackageList();
+  });
+}
+__name(registerListCommand, "registerListCommand");
 function registerAddCommand(program) {
   program.command("add [packages...]").description("Add KickJS packages with their required dependencies").option("--pm <manager>", "Package manager override").option("-D, --dev", "Install as dev dependency").option("--list", "List all available packages").action(async (packages, opts) => {
     if (opts.list || packages.length === 0) {
-      console.log("\n  Available KickJS packages:\n");
-      const maxName = Math.max(...Object.keys(PACKAGE_REGISTRY).map((k) => k.length));
-      for (const [name, info] of Object.entries(PACKAGE_REGISTRY)) {
-        const padded = name.padEnd(maxName + 2);
-        const peers = info.peers.length ? ` (+ ${info.peers.join(", ")})` : "";
-        console.log(`    ${padded} ${info.description}${peers}`);
-      }
-      console.log("\n  Usage: kick add graphql drizzle otel");
-      console.log("         kick add queue:bullmq");
-      console.log();
+      printPackageList();
       return;
     }
     const pm = opts.pm ?? detectPackageManager();
@@ -2926,14 +4056,14 @@ function registerAddCommand(program) {
 __name(registerAddCommand, "registerAddCommand");
 
 // src/commands/tinker.ts
-import { resolve as resolve5, join as join15 } from "path";
+import { resolve as resolve7, join as join17 } from "path";
 import { existsSync as existsSync5 } from "fs";
 import { pathToFileURL } from "url";
 import { fork } from "child_process";
 function registerTinkerCommand(program) {
   program.command("tinker").description("Interactive REPL with DI container and services loaded").option("-e, --entry <file>", "Entry file to load", "src/index.ts").action(async (opts) => {
     const cwd = process.cwd();
-    const entryPath = resolve5(cwd, opts.entry);
+    const entryPath = resolve7(cwd, opts.entry);
     if (!existsSync5(entryPath)) {
       console.error(`
   Error: ${opts.entry} not found.
@@ -2946,7 +4076,7 @@ function registerTinkerCommand(program) {
       process.exit(1);
     }
     const tinkerScript = generateTinkerScript(entryPath, opts.entry);
-    const tmpFile = join15(cwd, ".kick-tinker.mjs");
+    const tmpFile = join17(cwd, ".kick-tinker.mjs");
     const { writeFileSync, unlinkSync } = await import("fs");
     writeFileSync(tmpFile, tinkerScript, "utf-8");
     try {
@@ -2955,8 +4085,8 @@ function registerTinkerCommand(program) {
         execPath: tsxBin,
         stdio: "inherit"
       });
-      await new Promise((resolve6) => {
-        child.on("exit", () => resolve6());
+      await new Promise((resolve8) => {
+        child.on("exit", () => resolve8());
       });
     } finally {
       try {
@@ -3029,9 +4159,9 @@ __name(generateTinkerScript, "generateTinkerScript");
 function findBin(startDir, name) {
   let dir = startDir;
   while (true) {
-    const candidate = join15(dir, "node_modules", ".bin", name);
+    const candidate = join17(dir, "node_modules", ".bin", name);
     if (existsSync5(candidate)) return candidate;
-    const parent = resolve5(dir, "..");
+    const parent = resolve7(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -3041,7 +4171,7 @@ __name(findBin, "findBin");
 
 // src/cli.ts
 var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
-var pkg = JSON.parse(readFileSync2(join16(__dirname2, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync2(join18(__dirname2, "..", "package.json"), "utf-8"));
 async function main() {
   const program = new Command();
   program.name("kick").description("KickJS \u2014 A production-grade, decorator-driven Node.js framework").version(pkg.version);
@@ -3052,6 +4182,7 @@ async function main() {
   registerInfoCommand(program);
   registerInspectCommand(program);
   registerAddCommand(program);
+  registerListCommand(program);
   registerTinkerCommand(program);
   registerCustomCommands(program, config);
   program.showHelpAfterError();