@forinda/kickjs-cli 5.2.1 → 5.2.3

package/dist/generator-extension-Cp5FUUAw.mjs

@@ -0,0 +1,2687 @@
+/**
+ * @forinda/kickjs-cli v5.2.3
+ *
+ * Copyright (c) Felix Orinda
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import{createRequire as e}from"node:module";import{dirname as t,extname as n,join as r,resolve as i}from"node:path";import{existsSync as a,readFileSync as o}from"node:fs";import{access as s,mkdir as c,readFile as l,writeFile as u}from"node:fs/promises";import*as d from"@clack/prompts";import f from"picocolors";import p from"pluralize";import{execSync as m}from"node:child_process";import{fileURLToPath as h,pathToFileURL as g}from"node:url";let _=!1;function v(e){_=e}const y=new Set([`.ts`,`.tsx`,`.js`,`.jsx`,`.mjs`,`.cjs`,`.json`,`.md`]);async function b(e,r){_||(await c(t(e),{recursive:!0}),await u(e,r,`utf-8`),y.has(n(e))&&await te(e,r).catch(()=>{}))}let x;async function ee(t){if(x!==void 0)return x;try{x=await import(e(r(t,`package.json`)).resolve(`oxfmt`))}catch{x=null}return x}async function te(e,t){let n=await ee(process.cwd());if(!n)return;let r=await ne(e);if(r===null)return;let i=await n.format(e,t,r);i.code!==t&&await u(e,i.code,`utf-8`)}const S=new Map;async function ne(e){let n=t(e),i=n;if(S.has(i))return S.get(i);for(;;){let e=r(n,`.oxfmtrc.json`);if(a(e))try{let t=await l(e,`utf-8`),n=JSON.parse(t);return delete n.$schema,delete n.ignorePatterns,S.set(i,n),n}catch{return S.set(i,null),null}let o=t(n);if(o===n)return S.set(i,null),null;n=o}}async function C(e){try{return await s(e),!0}catch{return!1}}const re={GET:f.green,POST:f.cyan,PUT:f.yellow,PATCH:f.magenta,DELETE:f.red};function ie(e){return(re[e]??f.dim)(e.padEnd(7))}function ae(e){let t=`[${e}]`.padEnd(10);switch(e){case`CRITICAL`:return f.red(t);case`WARNING`:return f.yellow(t);case`INFO`:return f.blue(f.dim(t));default:return t}}f.green(`✓`),f.red(`✖`),f.yellow(`⚠`),f.blue(`ℹ`);function oe(e){d.intro(f.bgCyan(f.black(` ${e} `)))}function se(e){d.outro(e)}function w(e){d.isCancel(e)&&(d.cancel(`Operation cancelled.`),process.exit(0))}async function ce(e){let t=await d.text(e);return w(t),t}async function le(e){let t=await d.select(e);return w(t),t}async function ue(e){let t=await d.multiselect(e);return w(t),t}async function T(e){let t=await d.confirm(e);return w(t),t}function de(){return d.spinner()}const E=d.log;function D(e){return e.replace(/[-_\s]+(.)?/g,(e,t)=>t?t.toUpperCase():``).replace(/^(.)/,e=>e.toUpperCase())}function O(e){let t=D(e);return t.charAt(0).toLowerCase()+t.slice(1)}function k(e){return e.replace(/([a-z])([A-Z])/g,`$1-$2`).replace(/[\s_]+/g,`-`).toLowerCase()}function A(e){return p.plural(e)}function j(e){return p.plural(e)}const fe={inmemory:`in-memory`,drizzle:`Drizzle`,prisma:`Prisma`};function M(e){return e.charAt(0).toUpperCase()+e.slice(1).replace(/-([a-z])/g,(e,t)=>t.toUpperCase())}function pe(e){return e.replace(/([a-z])([A-Z])/g,`$1-$2`).toLowerCase()}function N(e){return fe[e]??M(e)}function P(e,t,n){let r={inmemory:`InMemory${e}Repository`,drizzle:`Drizzle${e}Repository`,prisma:`Prisma${e}Repository`},i={inmemory:`in-memory-${t}`,drizzle:`drizzle-${t}`,prisma:`prisma-${t}`};return{repoClass:r[n]??`${M(n)}${e}Repository`,repoFile:i[n]??`${pe(n)}-${t}`}}function me(e){let{pascal:t,kebab:n,plural:r=``,repo:i}=e,{repoClass:a,repoFile:o}=P(t,n,i);return`/**
+ * ${t} Module
+ *
+ * Self-contained feature module following Domain-Driven Design (DDD).
+ * Registers dependencies in the DI container and declares HTTP routes.
+ *
+ * Structure:
+ *   presentation/    — HTTP controllers (entry points)
+ *   application/     — Use cases (orchestration) and DTOs (validation)
+ *   domain/          — Entities, value objects, repository interfaces, domain services
+ *   infrastructure/  — Repository implementations (currently ${N(i)})
+ */
+import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
+import { buildRoutes } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY } from './domain/repositories/${n}.repository'
+import { ${a} } from './infrastructure/repositories/${o}.repository'
+import { ${t}Controller } from './presentation/${n}.controller'
+
+// Eagerly load decorated classes so @Service()/@Repository() decorators register in the DI container
+import.meta.glob(
+  ['./domain/services/**/*.ts', './application/use-cases/**/*.ts', '!./**/*.test.ts'],
+  { eager: true },
+)
+
+export class ${t}Module implements AppModule {
+  /**
+   * Register module dependencies in the DI container.
+   * Bind repository interface tokens to their implementations here.
+   * Currently wired to ${N(i)}. To swap implementations, change the factory target.
+   */
+  register(container: Container): void {
+    container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
+      container.resolve(${a}),
+    )
+  }
+
+  /**
+   * Declare HTTP routes for this module.
+   * The path is prefixed with the global apiPrefix and version (e.g. /api/v1/${r}).
+   * Passing 'controller' enables automatic OpenAPI spec generation via SwaggerAdapter.
+   */
+  routes(): ModuleRoutes {
+    return {
+      path: '/${r}',
+      router: buildRoutes(${t}Controller),
+      controller: ${t}Controller,
+    }
+  }
+}
+`}function he(e){let{pascal:t,kebab:n,plural:r=``,repo:i}=e,{repoClass:a,repoFile:o}=P(t,n,i);return`/**
+ * ${t} Module
+ *
+ * REST module with a flat folder structure.
+ * Controller delegates to service, service wraps the repository.
+ *
+ * Structure:
+ *   ${n}.controller.ts  — HTTP routes (CRUD)
+ *   ${n}.service.ts     — Business logic
+ *   ${n}.repository.ts  — Repository interface
+ *   ${o}.repository.ts — Repository implementation
+ *   dtos/                   — Request/response schemas
+ */
+import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
+import { buildRoutes } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY } from './${n}.repository'
+import { ${a} } from './${o}.repository'
+import { ${t}Controller } from './${n}.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 ${t}Module implements AppModule {
+  register(container: Container): void {
+    container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
+      container.resolve(${a}),
+    )
+  }
+
+  routes(): ModuleRoutes {
+    return {
+      path: '/${r}',
+      router: buildRoutes(${t}Controller),
+      controller: ${t}Controller,
+    }
+  }
+}
+`}function ge(e){let{pascal:t,kebab:n,plural:r=``}=e;return`import { type AppModule, type ModuleRoutes } from '@forinda/kickjs'
+import { buildRoutes } from '@forinda/kickjs'
+import { ${t}Controller } from './${n}.controller'
+
+export class ${t}Module implements AppModule {
+  routes(): ModuleRoutes {
+    return {
+      path: '/${r}',
+      router: buildRoutes(${t}Controller),
+      controller: ${t}Controller,
+    }
+  }
+}
+`}function _e(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return`import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams, type Ctx } from '@forinda/kickjs'
+import { ApiTags } from '@forinda/kickjs-swagger'
+import { Create${t}UseCase } from '../application/use-cases/create-${n}.use-case'
+import { Get${t}UseCase } from '../application/use-cases/get-${n}.use-case'
+import { List${i}UseCase } from '../application/use-cases/list-${r}.use-case'
+import { Update${t}UseCase } from '../application/use-cases/update-${n}.use-case'
+import { Delete${t}UseCase } from '../application/use-cases/delete-${n}.use-case'
+import { create${t}Schema } from '../application/dtos/create-${n}.dto'
+import { update${t}Schema } from '../application/dtos/update-${n}.dto'
+import { ${t.toUpperCase()}_QUERY_CONFIG } from '../constants'
+
+// Each handler annotates its \`ctx\` with \`Ctx<KickRoutes.${t}Controller['<method>']>\`
+// so \`ctx.params\`, \`ctx.body\`, and \`ctx.query\` are typed end-to-end.
+// The \`KickRoutes\` namespace is generated by \`kick typegen\` (auto-run on
+// \`kick dev\`) — see https://forinda.github.io/kick-js/guide/typegen.
+
+@Controller()
+export class ${t}Controller {
+  @Autowired() private readonly create${t}UseCase!: Create${t}UseCase
+  @Autowired() private readonly get${t}UseCase!: Get${t}UseCase
+  @Autowired() private readonly list${i}UseCase!: List${i}UseCase
+  @Autowired() private readonly update${t}UseCase!: Update${t}UseCase
+  @Autowired() private readonly delete${t}UseCase!: Delete${t}UseCase
+
+  @Get('/')
+  @ApiTags('${t}')
+  @ApiQueryParams(${t.toUpperCase()}_QUERY_CONFIG)
+  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
+    return ctx.paginate(
+      (parsed) => this.list${i}UseCase.execute(parsed),
+      ${t.toUpperCase()}_QUERY_CONFIG,
+    )
+  }
+
+  @Get('/:id')
+  @ApiTags('${t}')
+  async getById(ctx: Ctx<KickRoutes.${t}Controller['getById']>) {
+    const result = await this.get${t}UseCase.execute(ctx.params.id)
+    if (!result) return ctx.notFound('${t} not found')
+    ctx.json(result)
+  }
+
+  @Post('/', { body: create${t}Schema, name: 'Create${t}' })
+  @ApiTags('${t}')
+  async create(ctx: Ctx<KickRoutes.${t}Controller['create']>) {
+    const result = await this.create${t}UseCase.execute(ctx.body)
+    ctx.created(result)
+  }
+
+  @Put('/:id', { body: update${t}Schema, name: 'Update${t}' })
+  @ApiTags('${t}')
+  async update(ctx: Ctx<KickRoutes.${t}Controller['update']>) {
+    const result = await this.update${t}UseCase.execute(ctx.params.id, ctx.body)
+    ctx.json(result)
+  }
+
+  @Delete('/:id')
+  @ApiTags('${t}')
+  async remove(ctx: Ctx<KickRoutes.${t}Controller['remove']>) {
+    await this.delete${t}UseCase.execute(ctx.params.id)
+    ctx.noContent()
+  }
+}
+`}function ve(e){let{pascal:t,kebab:n}=e,r=t.charAt(0).toLowerCase()+t.slice(1);return`import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams, type Ctx } from '@forinda/kickjs'
+import { ApiTags } from '@forinda/kickjs-swagger'
+import { ${t}Service } from './${n}.service'
+import { create${t}Schema } from './dtos/create-${n}.dto'
+import { update${t}Schema } from './dtos/update-${n}.dto'
+import { ${t.toUpperCase()}_QUERY_CONFIG } from './${n}.constants'
+
+// Each handler annotates its \`ctx\` with \`Ctx<KickRoutes.${t}Controller['<method>']>\`
+// so \`ctx.params\`, \`ctx.body\`, and \`ctx.query\` are typed end-to-end.
+// The \`KickRoutes\` namespace is generated by \`kick typegen\` (auto-run on
+// \`kick dev\`) — see https://forinda.github.io/kick-js/guide/typegen.
+
+@Controller()
+export class ${t}Controller {
+  @Autowired() private readonly ${r}Service!: ${t}Service
+
+  @Get('/')
+  @ApiTags('${t}')
+  @ApiQueryParams(${t.toUpperCase()}_QUERY_CONFIG)
+  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
+    return ctx.paginate(
+      (parsed) => this.${r}Service.findPaginated(parsed),
+      ${t.toUpperCase()}_QUERY_CONFIG,
+    )
+  }
+
+  @Get('/:id')
+  @ApiTags('${t}')
+  async getById(ctx: Ctx<KickRoutes.${t}Controller['getById']>) {
+    const result = await this.${r}Service.findById(ctx.params.id)
+    if (!result) return ctx.notFound('${t} not found')
+    ctx.json(result)
+  }
+
+  @Post('/', { body: create${t}Schema, name: 'Create${t}' })
+  @ApiTags('${t}')
+  async create(ctx: Ctx<KickRoutes.${t}Controller['create']>) {
+    const result = await this.${r}Service.create(ctx.body)
+    ctx.created(result)
+  }
+
+  @Put('/:id', { body: update${t}Schema, name: 'Update${t}' })
+  @ApiTags('${t}')
+  async update(ctx: Ctx<KickRoutes.${t}Controller['update']>) {
+    const result = await this.${r}Service.update(ctx.params.id, ctx.body)
+    ctx.json(result)
+  }
+
+  @Delete('/:id')
+  @ApiTags('${t}')
+  async remove(ctx: Ctx<KickRoutes.${t}Controller['remove']>) {
+    await this.${r}Service.delete(ctx.params.id)
+    ctx.noContent()
+  }
+}
+`}function ye(e){let{pascal:t}=e;return`import type { QueryParamsConfig } from '@forinda/kickjs'
+
+export const ${t.toUpperCase()}_QUERY_CONFIG: QueryParamsConfig = {
+  filterable: ['name'],
+  sortable: ['name', 'createdAt'],
+  searchable: ['name'],
+}
+`}function F(e){let{pascal:t}=e;return`import { z } from 'zod'
+
+/**
+ * Create ${t} DTO — Zod schema for validating POST request bodies.
+ * This schema is passed to @Post('/', { body: create${t}Schema }) for automatic validation.
+ * It also generates OpenAPI request body docs when SwaggerAdapter is used.
+ *
+ * Add more fields as needed. Supported Zod types:
+ *   z.string(), z.number(), z.boolean(), z.enum([...]),
+ *   z.array(), z.object(), .optional(), .default(), .transform()
+ */
+export const create${t}Schema = z.object({
+  name: z.string().min(1, 'Name is required').max(200),
+})
+
+export type Create${t}DTO = z.infer<typeof create${t}Schema>
+`}function I(e){let{pascal:t}=e;return`import { z } from 'zod'
+
+export const update${t}Schema = z.object({
+  name: z.string().min(1).max(200).optional(),
+})
+
+export type Update${t}DTO = z.infer<typeof update${t}Schema>
+`}function L(e){let{pascal:t}=e;return`export interface ${t}ResponseDTO {
+  id: string
+  name: string
+  createdAt: string
+  updatedAt: string
+}
+`}function be(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return[{file:`create-${n}.use-case.ts`,content:`/**
+ * Create ${t} Use Case
+ *
+ * Application layer — orchestrates a single business operation.
+ * Use cases are thin: validate input (via DTO), call domain/repo, return response.
+ * Keep business rules in the domain service, not here.
+ */
+import { Service, Inject } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
+import type { Create${t}DTO } from '../dtos/create-${n}.dto'
+import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
+
+@Service()
+export class Create${t}UseCase {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+  ) {}
+
+  async execute(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
+    return this.repo.create(dto)
+  }
+}
+`},{file:`get-${n}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
+import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
+
+@Service()
+export class Get${t}UseCase {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+  ) {}
+
+  async execute(id: string): Promise<${t}ResponseDTO | null> {
+    return this.repo.findById(id)
+  }
+}
+`},{file:`list-${r}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
+import type { ParsedQuery } from '@forinda/kickjs'
+
+@Service()
+export class List${i}UseCase {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+  ) {}
+
+  async execute(parsed: ParsedQuery) {
+    return this.repo.findPaginated(parsed)
+  }
+}
+`},{file:`update-${n}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
+import type { Update${t}DTO } from '../dtos/update-${n}.dto'
+import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
+
+@Service()
+export class Update${t}UseCase {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+  ) {}
+
+  async execute(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
+    return this.repo.update(id, dto)
+  }
+}
+`},{file:`delete-${n}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../../domain/repositories/${n}.repository'
+
+@Service()
+export class Delete${t}UseCase {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+  ) {}
+
+  async execute(id: string): Promise<void> {
+    await this.repo.delete(id)
+  }
+}
+`}]}function R(e){let{pascal:t,kebab:n,dtoPrefix:r=`../../application/dtos`,tokenScope:i=`app`}=e;return`/**
+ * ${t} Repository Interface
+ *
+ * Defines the contract for data access.
+ * The interface declares what operations are available;
+ * implementations (in-memory, Drizzle, Prisma) fulfill the contract.
+ *
+ * To swap implementations, change the factory in the module's register() method.
+ */
+import { createToken } from '@forinda/kickjs'
+import type { ${t}ResponseDTO } from '${r}/${n}-response.dto'
+import type { Create${t}DTO } from '${r}/create-${n}.dto'
+import type { Update${t}DTO } from '${r}/update-${n}.dto'
+import type { ParsedQuery } from '@forinda/kickjs'
+
+export interface I${t}Repository {
+  findById(id: string): Promise<${t}ResponseDTO | null>
+  findAll(): Promise<${t}ResponseDTO[]>
+  findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }>
+  create(dto: Create${t}DTO): Promise<${t}ResponseDTO>
+  update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO>
+  delete(id: string): Promise<void>
+}
+
+/**
+ * Collision-safe DI token bound to \`I${t}Repository\`.
+ * \`container.resolve(${t.toUpperCase()}_REPOSITORY)\` and
+ * \`@Inject(${t.toUpperCase()}_REPOSITORY)\` both return the typed
+ * interface — no manual generic, no \`any\` cast.
+ *
+ * The \`'${i}/'\` prefix matches the project scope so
+ * \`kick-lint\`'s \`token-reserved-prefix\` rule never fires —
+ * adopters must NOT use the reserved \`'kick/'\` namespace.
+ */
+export const ${t.toUpperCase()}_REPOSITORY = createToken<I${t}Repository>('${i}/${t}/repository')
+`}function z(e){let{pascal:t,kebab:n,repoPrefix:r=`../../domain/repositories`,dtoPrefix:i=`../../application/dtos`}=e;return`/**
+ * In-Memory ${t} Repository
+ *
+ * Implements the repository interface using a Map.
+ * Useful for prototyping and testing. Replace with a database implementation
+ * (Drizzle, Prisma, etc.) for production use.
+ *
+ * @Repository() registers this class in the DI container as a singleton.
+ */
+import { randomUUID } from 'node:crypto'
+import { Repository, HttpException } from '@forinda/kickjs'
+import type { ParsedQuery } from '@forinda/kickjs'
+import type { I${t}Repository } from '${r}/${n}.repository'
+import type { ${t}ResponseDTO } from '${i}/${n}-response.dto'
+import type { Create${t}DTO } from '${i}/create-${n}.dto'
+import type { Update${t}DTO } from '${i}/update-${n}.dto'
+
+@Repository()
+export class InMemory${t}Repository implements I${t}Repository {
+  private store = new Map<string, ${t}ResponseDTO>()
+
+  async findById(id: string): Promise<${t}ResponseDTO | null> {
+    return this.store.get(id) ?? null
+  }
+
+  async findAll(): Promise<${t}ResponseDTO[]> {
+    return Array.from(this.store.values())
+  }
+
+  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }> {
+    const all = Array.from(this.store.values())
+    const data = all.slice(parsed.pagination.offset, parsed.pagination.offset + parsed.pagination.limit)
+    return { data, total: all.length }
+  }
+
+  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
+    const now = new Date().toISOString()
+    const entity: ${t}ResponseDTO = {
+      id: randomUUID(),
+      name: dto.name,
+      createdAt: now,
+      updatedAt: now,
+    }
+    this.store.set(entity.id, entity)
+    return entity
+  }
+
+  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
+    const existing = this.store.get(id)
+    if (!existing) throw HttpException.notFound('${t} not found')
+    const updated = { ...existing, ...dto, updatedAt: new Date().toISOString() }
+    this.store.set(id, updated)
+    return updated
+  }
+
+  async delete(id: string): Promise<void> {
+    if (!this.store.has(id)) throw HttpException.notFound('${t} not found')
+    this.store.delete(id)
+  }
+}
+`}function B(e){let{pascal:t,kebab:n,repoType:r=``,repoPrefix:i=`../../domain/repositories`,dtoPrefix:a=`../../application/dtos`}=e,o=r.charAt(0).toUpperCase()+r.slice(1).replace(/-([a-z])/g,(e,t)=>t.toUpperCase());return`/**
+ * ${o} ${t} Repository
+ *
+ * Stub implementation for a custom '${r}' repository.
+ * Implements the repository interface using an in-memory Map as a placeholder.
+ *
+ * TODO: Replace the in-memory Map with your ${r} data-access logic.
+ * See I${t}Repository for the interface contract.
+ *
+ * @Repository() registers this class in the DI container as a singleton.
+ */
+import { randomUUID } from 'node:crypto'
+import { Repository, HttpException } from '@forinda/kickjs'
+import type { ParsedQuery } from '@forinda/kickjs'
+import type { I${t}Repository } from '${i}/${n}.repository'
+import type { ${t}ResponseDTO } from '${a}/${n}-response.dto'
+import type { Create${t}DTO } from '${a}/create-${n}.dto'
+import type { Update${t}DTO } from '${a}/update-${n}.dto'
+
+@Repository()
+export class ${o}${t}Repository implements I${t}Repository {
+  // TODO: Replace with your ${r} client/connection
+  private store = new Map<string, ${t}ResponseDTO>()
+
+  async findById(id: string): Promise<${t}ResponseDTO | null> {
+    // TODO: Implement with ${r}
+    return this.store.get(id) ?? null
+  }
+
+  async findAll(): Promise<${t}ResponseDTO[]> {
+    // TODO: Implement with ${r}
+    return Array.from(this.store.values())
+  }
+
+  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }> {
+    // TODO: Implement with ${r}
+    const all = Array.from(this.store.values())
+    const data = all.slice(parsed.pagination.offset, parsed.pagination.offset + parsed.pagination.limit)
+    return { data, total: all.length }
+  }
+
+  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
+    // TODO: Implement with ${r}
+    const now = new Date().toISOString()
+    const entity: ${t}ResponseDTO = {
+      id: randomUUID(),
+      name: dto.name,
+      createdAt: now,
+      updatedAt: now,
+    }
+    this.store.set(entity.id, entity)
+    return entity
+  }
+
+  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
+    // TODO: Implement with ${r}
+    const existing = this.store.get(id)
+    if (!existing) throw HttpException.notFound('${t} not found')
+    const updated = { ...existing, ...dto, updatedAt: new Date().toISOString() }
+    this.store.set(id, updated)
+    return updated
+  }
+
+  async delete(id: string): Promise<void> {
+    // TODO: Implement with ${r}
+    if (!this.store.has(id)) throw HttpException.notFound('${t} not found')
+    this.store.delete(id)
+  }
+}
+`}function xe(e){let{pascal:t,kebab:n}=e;return`/**
+ * ${t} Domain Service
+ *
+ * Domain layer — contains business rules that don't belong to a single entity.
+ * Use this for cross-entity logic, validation rules, and domain invariants.
+ * Keep it free of HTTP/framework concerns.
+ */
+import { Service, Inject, HttpException } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../repositories/${n}.repository'
+
+@Service()
+export class ${t}DomainService {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+  ) {}
+
+  async ensureExists(id: string): Promise<void> {
+    const entity = await this.repo.findById(id)
+    if (!entity) {
+      throw HttpException.notFound('${t} not found')
+    }
+  }
+}
+`}function Se(e){let{pascal:t,kebab:n}=e;return`/**
+ * ${t} Entity
+ *
+ * Domain layer — the core business object.
+ * Uses a private constructor with static factory methods (create, reconstitute)
+ * to enforce invariants. Properties are accessed via getters to maintain encapsulation.
+ *
+ * Patterns used:
+ *   - Private constructor: prevents direct instantiation
+ *   - create(): factory for new entities (generates ID, sets timestamps)
+ *   - reconstitute(): factory for rebuilding from persistence (no side effects)
+ *   - changeName(): mutation method that enforces business rules
+ */
+import { ${t}Id } from '../value-objects/${n}-id.vo'
+
+interface ${t}Props {
+  id: ${t}Id
+  name: string
+  createdAt: Date
+  updatedAt: Date
+}
+
+export class ${t} {
+  private constructor(private props: ${t}Props) {}
+
+  static create(params: { name: string }): ${t} {
+    const now = new Date()
+    return new ${t}({
+      id: ${t}Id.create(),
+      name: params.name,
+      createdAt: now,
+      updatedAt: now,
+    })
+  }
+
+  static reconstitute(props: ${t}Props): ${t} {
+    return new ${t}(props)
+  }
+
+  get id(): ${t}Id {
+    return this.props.id
+  }
+  get name(): string {
+    return this.props.name
+  }
+  get createdAt(): Date {
+    return this.props.createdAt
+  }
+  get updatedAt(): Date {
+    return this.props.updatedAt
+  }
+
+  changeName(name: string): void {
+    if (!name || name.trim().length === 0) {
+      throw new Error('Name cannot be empty')
+    }
+    this.props.name = name.trim()
+    this.props.updatedAt = new Date()
+  }
+
+  toJSON() {
+    return {
+      id: this.props.id.toString(),
+      name: this.props.name,
+      createdAt: this.props.createdAt.toISOString(),
+      updatedAt: this.props.updatedAt.toISOString(),
+    }
+  }
+}
+`}function Ce(e){let{pascal:t}=e;return`/**
+ * ${t} ID Value Object
+ *
+ * Domain layer — wraps a primitive ID with type safety and validation.
+ * Value objects are immutable and compared by value, not reference.
+ *
+ *   ${t}Id.create()    — generate a new UUID
+ *   ${t}Id.from(id)    — wrap an existing ID string (validates non-empty)
+ *   id.equals(other)  — compare two IDs by value
+ */
+import { randomUUID } from 'node:crypto'
+
+export class ${t}Id {
+  private constructor(private readonly value: string) {}
+
+  static create(): ${t}Id {
+    return new ${t}Id(randomUUID())
+  }
+
+  static from(id: string): ${t}Id {
+    if (!id || id.trim().length === 0) {
+      throw new Error('${t}Id cannot be empty')
+    }
+    return new ${t}Id(id)
+  }
+
+  toString(): string {
+    return this.value
+  }
+
+  equals(other: ${t}Id): boolean {
+    return this.value === other.value
+  }
+}
+`}function V(e){let{pascal:t,kebab:n,plural:r=``}=e;return`import { describe, it, expect, beforeEach } from 'vitest'
+import { Container } from '@forinda/kickjs'
+
+describe('${t}Controller', () => {
+  beforeEach(() => {
+    Container.reset()
+  })
+
+  it('should be defined', () => {
+    expect(true).toBe(true)
+  })
+
+  describe('POST /${r}', () => {
+    it('should create a new ${n}', async () => {
+      // TODO: Set up test module, call create endpoint, assert 201
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('GET /${r}', () => {
+    it('should return paginated ${r}', async () => {
+      // TODO: Set up test module, call list endpoint, assert { data, meta }
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('GET /${r}/:id', () => {
+    it('should return a ${n} by id', async () => {
+      // TODO: Create a ${n}, then fetch by id, assert match
+      expect(true).toBe(true)
+    })
+
+    it('should return 404 for non-existent ${n}', async () => {
+      // TODO: Fetch non-existent id, assert 404
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('PUT /${r}/:id', () => {
+    it('should update an existing ${n}', async () => {
+      // TODO: Create, update, assert changes
+      expect(true).toBe(true)
+    })
+  })
+
+  describe('DELETE /${r}/:id', () => {
+    it('should delete a ${n}', async () => {
+      // TODO: Create, delete, assert gone
+      expect(true).toBe(true)
+    })
+  })
+})
+`}function H(e){let{pascal:t,kebab:n,plural:r=``,repoPrefix:i=`../infrastructure/repositories/in-memory-${n}.repository`}=e;return`import { describe, it, expect, beforeEach } from 'vitest'
+import { InMemory${t}Repository } from '${i}'
+
+describe('InMemory${t}Repository', () => {
+  let repo: InMemory${t}Repository
+
+  beforeEach(() => {
+    repo = new InMemory${t}Repository()
+  })
+
+  it('should create and retrieve a ${n}', async () => {
+    const created = await repo.create({ name: 'Test ${t}' })
+    expect(created).toBeDefined()
+    expect(created.name).toBe('Test ${t}')
+    expect(created.id).toBeDefined()
+
+    const found = await repo.findById(created.id)
+    expect(found).toEqual(created)
+  })
+
+  it('should return null for non-existent id', async () => {
+    const found = await repo.findById('non-existent')
+    expect(found).toBeNull()
+  })
+
+  it('should list all ${r}', async () => {
+    await repo.create({ name: '${t} 1' })
+    await repo.create({ name: '${t} 2' })
+
+    const all = await repo.findAll()
+    expect(all).toHaveLength(2)
+  })
+
+  it('should return paginated results', async () => {
+    await repo.create({ name: '${t} 1' })
+    await repo.create({ name: '${t} 2' })
+    await repo.create({ name: '${t} 3' })
+
+    const result = await repo.findPaginated({
+      filters: [],
+      sort: [],
+      search: '',
+      pagination: { page: 1, limit: 2, offset: 0 },
+    })
+
+    expect(result.data).toHaveLength(2)
+    expect(result.total).toBe(3)
+  })
+
+  it('should update a ${n}', 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 ${n}', async () => {
+    const created = await repo.create({ name: 'To Delete' })
+    await repo.delete(created.id)
+    const found = await repo.findById(created.id)
+    expect(found).toBeNull()
+  })
+})
+`}function we(e){let{pascal:t,kebab:n}=e;return`import { Service, Inject, HttpException } from '@forinda/kickjs'
+import type { ParsedQuery } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from './${n}.repository'
+import type { ${t}ResponseDTO } from './dtos/${n}-response.dto'
+import type { Create${t}DTO } from './dtos/create-${n}.dto'
+import type { Update${t}DTO } from './dtos/update-${n}.dto'
+
+@Service()
+export class ${t}Service {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+  ) {}
+
+  async findById(id: string): Promise<${t}ResponseDTO | null> {
+    return this.repo.findById(id)
+  }
+
+  async findAll(): Promise<${t}ResponseDTO[]> {
+    return this.repo.findAll()
+  }
+
+  async findPaginated(parsed: ParsedQuery) {
+    return this.repo.findPaginated(parsed)
+  }
+
+  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
+    return this.repo.create(dto)
+  }
+
+  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
+    return this.repo.update(id, dto)
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.repo.delete(id)
+  }
+}
+`}function U(e){let{pascal:t}=e;return`import type { QueryFieldConfig } from '@forinda/kickjs'
+
+export const ${t.toUpperCase()}_QUERY_CONFIG: QueryFieldConfig = {
+  filterable: ['name'],
+  sortable: ['name', 'createdAt'],
+  searchable: ['name'],
+}
+`}function Te(e){let{pascal:t,kebab:n,plural:r=``,repo:i}=e,a={inmemory:`InMemory${t}Repository`,drizzle:`Drizzle${t}Repository`,prisma:`Prisma${t}Repository`},o={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},s=a[i]??a.inmemory,c=o[i]??o.inmemory;return`/**
+ * ${t} Module — 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/       — Write operations (create, update, delete)
+ *   queries/        — Read operations (get, list)
+ *   events/         — Domain events + handlers (WS broadcast, queue dispatch)
+ *   dtos/           — Request/response schemas
+ */
+import { Container, type AppModule, type ModuleRoutes } from '@forinda/kickjs'
+import { buildRoutes } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY } from './${n}.repository'
+import { ${s} } from './${c}.repository'
+import { ${t}Controller } from './${n}.controller'
+
+// Eagerly load decorated classes
+import.meta.glob(
+  [
+    './commands/**/*.ts',
+    './queries/**/*.ts',
+    './events/**/*.ts',
+    '!./**/*.test.ts',
+  ],
+  { eager: true },
+)
+
+export class ${t}Module implements AppModule {
+  register(container: Container): void {
+    container.registerFactory(${t.toUpperCase()}_REPOSITORY, () =>
+      container.resolve(${s}),
+    )
+  }
+
+  routes(): ModuleRoutes {
+    return {
+      path: '/${r}',
+      router: buildRoutes(${t}Controller),
+      controller: ${t}Controller,
+    }
+  }
+}
+`}function Ee(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return`import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams, type Ctx } from '@forinda/kickjs'
+import { ApiTags } from '@forinda/kickjs-swagger'
+import { Create${t}Command } from './commands/create-${n}.command'
+import { Update${t}Command } from './commands/update-${n}.command'
+import { Delete${t}Command } from './commands/delete-${n}.command'
+import { Get${t}Query } from './queries/get-${n}.query'
+import { List${i}Query } from './queries/list-${r}.query'
+import { create${t}Schema } from './dtos/create-${n}.dto'
+import { update${t}Schema } from './dtos/update-${n}.dto'
+import { ${t.toUpperCase()}_QUERY_CONFIG } from './${n}.constants'
+
+// Each handler annotates its \`ctx\` with \`Ctx<KickRoutes.${t}Controller['<method>']>\`
+// so \`ctx.params\`, \`ctx.body\`, and \`ctx.query\` are typed end-to-end.
+// The \`KickRoutes\` namespace is generated by \`kick typegen\` (auto-run on
+// \`kick dev\`) — see https://forinda.github.io/kick-js/guide/typegen.
+
+@Controller()
+export class ${t}Controller {
+  @Autowired() private readonly create${t}Command!: Create${t}Command
+  @Autowired() private readonly update${t}Command!: Update${t}Command
+  @Autowired() private readonly delete${t}Command!: Delete${t}Command
+  @Autowired() private readonly get${t}Query!: Get${t}Query
+  @Autowired() private readonly list${i}Query!: List${i}Query
+
+  @Get('/')
+  @ApiTags('${t}')
+  @ApiQueryParams(${t.toUpperCase()}_QUERY_CONFIG)
+  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
+    return ctx.paginate(
+      (parsed) => this.list${i}Query.execute(parsed),
+      ${t.toUpperCase()}_QUERY_CONFIG,
+    )
+  }
+
+  @Get('/:id')
+  @ApiTags('${t}')
+  async getById(ctx: Ctx<KickRoutes.${t}Controller['getById']>) {
+    const result = await this.get${t}Query.execute(ctx.params.id)
+    if (!result) return ctx.notFound('${t} not found')
+    ctx.json(result)
+  }
+
+  @Post('/', { body: create${t}Schema, name: 'Create${t}' })
+  @ApiTags('${t}')
+  async create(ctx: Ctx<KickRoutes.${t}Controller['create']>) {
+    const result = await this.create${t}Command.execute(ctx.body)
+    ctx.created(result)
+  }
+
+  @Put('/:id', { body: update${t}Schema, name: 'Update${t}' })
+  @ApiTags('${t}')
+  async update(ctx: Ctx<KickRoutes.${t}Controller['update']>) {
+    const result = await this.update${t}Command.execute(ctx.params.id, ctx.body)
+    ctx.json(result)
+  }
+
+  @Delete('/:id')
+  @ApiTags('${t}')
+  async remove(ctx: Ctx<KickRoutes.${t}Controller['remove']>) {
+    await this.delete${t}Command.execute(ctx.params.id)
+    ctx.noContent()
+  }
+}
+`}function De(e){let{pascal:t,kebab:n}=e;return[{file:`create-${n}.command.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
+import type { Create${t}DTO } from '../dtos/create-${n}.dto'
+import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
+import { ${t}Events } from '../events/${n}.events'
+
+@Service()
+export class Create${t}Command {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+    @Inject(${t}Events) private readonly events: ${t}Events,
+  ) {}
+
+  async execute(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
+    const result = await this.repo.create(dto)
+    this.events.emit('${n}.created', result)
+    return result
+  }
+}
+`},{file:`update-${n}.command.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
+import type { Update${t}DTO } from '../dtos/update-${n}.dto'
+import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
+import { ${t}Events } from '../events/${n}.events'
+
+@Service()
+export class Update${t}Command {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+    @Inject(${t}Events) private readonly events: ${t}Events,
+  ) {}
+
+  async execute(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
+    const result = await this.repo.update(id, dto)
+    this.events.emit('${n}.updated', result)
+    return result
+  }
+}
+`},{file:`delete-${n}.command.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
+import { ${t}Events } from '../events/${n}.events'
+
+@Service()
+export class Delete${t}Command {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+    @Inject(${t}Events) private readonly events: ${t}Events,
+  ) {}
+
+  async execute(id: string): Promise<void> {
+    await this.repo.delete(id)
+    this.events.emit('${n}.deleted', { id })
+  }
+}
+`}]}function Oe(e){let{pascal:t,kebab:n,plural:r=``,pluralPascal:i=``}=e;return[{file:`get-${n}.query.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
+import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
+
+@Service()
+export class Get${t}Query {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+  ) {}
+
+  async execute(id: string): Promise<${t}ResponseDTO | null> {
+    return this.repo.findById(id)
+  }
+}
+`},{file:`list-${r}.query.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${t.toUpperCase()}_REPOSITORY, type I${t}Repository } from '../${n}.repository'
+import type { ParsedQuery } from '@forinda/kickjs'
+
+@Service()
+export class List${i}Query {
+  constructor(
+    @Inject(${t.toUpperCase()}_REPOSITORY) private readonly repo: I${t}Repository,
+  ) {}
+
+  async execute(parsed: ParsedQuery) {
+    return this.repo.findPaginated(parsed)
+  }
+}
+`}]}function ke(e){let{pascal:t,kebab:n}=e;return[{file:`${n}.events.ts`,content:`import { Service } from '@forinda/kickjs'
+import { EventEmitter } from 'node:events'
+import type { ${t}ResponseDTO } from '../dtos/${n}-response.dto'
+
+/**
+ * ${t} 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 ${t}EventMap {
+  '${n}.created': ${t}ResponseDTO
+  '${n}.updated': ${t}ResponseDTO
+  '${n}.deleted': { id: string }
+}
+
+@Service()
+export class ${t}Events {
+  private emitter = new EventEmitter()
+
+  emit<K extends keyof ${t}EventMap>(event: K, data: ${t}EventMap[K]): void {
+    this.emitter.emit(event, data)
+  }
+
+  on<K extends keyof ${t}EventMap>(event: K, handler: (data: ${t}EventMap[K]) => void): void {
+    this.emitter.on(event, handler)
+  }
+
+  off<K extends keyof ${t}EventMap>(event: K, handler: (data: ${t}EventMap[K]) => void): void {
+    this.emitter.off(event, handler)
+  }
+}
+`},{file:`on-${n}-change.handler.ts`,content:`import { Service, Autowired } from '@forinda/kickjs'
+import { ${t}Events } from './${n}.events'
+
+/**
+ * ${t} Change Event Handler
+ *
+ * Reacts to domain events emitted by commands.
+ * Wire up side effects here:
+ *
+ * 1. WebSocket broadcast — notify connected clients in real-time
+ *    import { WsGateway } from '@forinda/kickjs-ws'
+ *    this.ws.broadcast('${n}-channel', { event, data })
+ *
+ * 2. Queue dispatch — offload heavy processing to background workers
+ *    import { QueueService } from '@forinda/kickjs-queue'
+ *    this.queue.add('${n}-etl', { action: event, payload: data })
+ *
+ * 3. ETL pipeline — transform and load data to external systems
+ *    await this.etlPipeline.process(data)
+ */
+@Service()
+export class On${t}ChangeHandler {
+  @Autowired() private events!: ${t}Events
+
+  // Uncomment to inject WebSocket and Queue services:
+  // @Autowired() private ws!: WsGateway
+  // @Autowired() private queue!: QueueService
+
+  onInit(): void {
+    this.events.on('${n}.created', (data) => {
+      console.log('[${t}] Created:', data.id)
+      // TODO: Broadcast via WebSocket
+      // this.ws.broadcast('${n}-channel', { event: '${n}.created', data })
+      // TODO: Dispatch to queue for async processing / ETL
+      // this.queue.add('${n}-etl', { action: 'create', payload: data })
+    })
+
+    this.events.on('${n}.updated', (data) => {
+      console.log('[${t}] Updated:', data.id)
+      // TODO: Broadcast via WebSocket
+      // this.ws.broadcast('${n}-channel', { event: '${n}.updated', data })
+    })
+
+    this.events.on('${n}.deleted', (data) => {
+      console.log('[${t}] Deleted:', data.id)
+      // TODO: Broadcast via WebSocket
+      // this.ws.broadcast('${n}-channel', { event: '${n}.deleted', data })
+    })
+  }
+}
+`}]}function W(e){let{pascal:t,kebab:n,repoPrefix:r=`../../domain/repositories`,dtoPrefix:i=`../../application/dtos`}=e;return`/**
+ * Drizzle ${t} Repository
+ *
+ * Implements the repository interface using Drizzle ORM.
+ * Uses buildFromColumns() with Column objects for type-safe query building.
+ *
+ * TODO: Update the schema import to match your Drizzle schema file.
+ * TODO: Replace DRIZZLE_DB injection token with your actual database token.
+ *
+ * @Repository() registers this class in the DI container as a singleton.
+ */
+import { eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc, count, sql } from 'drizzle-orm'
+import { Repository, HttpException, Inject } from '@forinda/kickjs'
+import { DRIZZLE_DB, DrizzleQueryAdapter } from '@forinda/kickjs-drizzle'
+import type { ParsedQuery } from '@forinda/kickjs'
+import type { I${t}Repository } from '${r}/${n}.repository'
+import type { ${t}ResponseDTO } from '${i}/${n}-response.dto'
+import type { Create${t}DTO } from '${i}/create-${n}.dto'
+import type { Update${t}DTO } from '${i}/update-${n}.dto'
+import { ${t.toUpperCase()}_QUERY_CONFIG } from '../../constants'
+
+// TODO: Import your Drizzle schema table — e.g.:
+// import { ${n}s } from '@/db/schema'
+
+const queryAdapter = new DrizzleQueryAdapter({
+  eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc,
+})
+
+@Repository()
+export class Drizzle${t}Repository implements I${t}Repository {
+  constructor(@Inject(DRIZZLE_DB) private db: any) {}
+
+  async findById(id: string): Promise<${t}ResponseDTO | null> {
+    // TODO: Implement with Drizzle
+    // const row = this.db.select().from(${n}s).where(eq(${n}s.id, id)).get()
+    // return row ?? null
+    throw new Error('Drizzle ${t} repository not yet implemented — update schema imports and queries')
+  }
+
+  async findAll(): Promise<${t}ResponseDTO[]> {
+    // TODO: Implement with Drizzle
+    // return this.db.select().from(${n}s).all()
+    throw new Error('Drizzle ${t} repository not yet implemented')
+  }
+
+  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }> {
+    // TODO: Use buildFromColumns() with your query config for type-safe filtering
+    // const query = queryAdapter.buildFromColumns(parsed, ${t.toUpperCase()}_QUERY_CONFIG)
+    //
+    // const data = this.db
+    //   .select().from(${n}s).$dynamic()
+    //   .where(query.where).orderBy(...query.orderBy)
+    //   .limit(query.limit).offset(query.offset).all()
+    //
+    // const totalResult = this.db
+    //   .select({ count: count() }).from(${n}s)
+    //   .$dynamic().where(query.where).get()
+    //
+    // return { data, total: totalResult?.count ?? 0 }
+    throw new Error('Drizzle ${t} repository not yet implemented')
+  }
+
+  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
+    // TODO: Implement with Drizzle
+    // return this.db.insert(${n}s).values(dto).returning().get()
+    throw new Error('Drizzle ${t} repository not yet implemented')
+  }
+
+  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
+    // TODO: Implement with Drizzle
+    // const row = this.db.update(${n}s).set(dto).where(eq(${n}s.id, id)).returning().get()
+    // if (!row) throw HttpException.notFound('${t} not found')
+    // return row
+    throw new Error('Drizzle ${t} repository not yet implemented')
+  }
+
+  async delete(id: string): Promise<void> {
+    // TODO: Implement with Drizzle
+    // this.db.delete(${n}s).where(eq(${n}s.id, id)).run()
+    throw new Error('Drizzle ${t} repository not yet implemented')
+  }
+}
+`}function Ae(e){let{pascal:t,kebab:n}=e;return`import type { DrizzleQueryParamsConfig } from '@forinda/kickjs-drizzle'
+// TODO: Import your schema table and reference actual columns for type safety
+// import { ${n}s } from '@/db/schema'
+
+export const ${t.toUpperCase()}_QUERY_CONFIG: DrizzleQueryParamsConfig = {
+  columns: {
+    // Replace with actual Drizzle Column references for type-safe filtering:
+    // name: ${n}s.name,
+    // status: ${n}s.status,
+  },
+  sortable: {
+    // name: ${n}s.name,
+    // createdAt: ${n}s.createdAt,
+  },
+  searchColumns: [
+    // ${n}s.name,
+  ],
+}
+`}function G(e){let{pascal:t,kebab:n,repoPrefix:r=`../../domain/repositories`,dtoPrefix:i=`../../application/dtos`}=e,a=n.replace(/-([a-z])/g,(e,t)=>t.toUpperCase());return`/**
+ * Prisma ${t} Repository
+ *
+ * Implements the repository interface using Prisma Client.
+ * Requires a PrismaClient instance injected via the DI container.
+ *
+ * Ensure your Prisma schema has a '${t}' model defined.
+ *
+ * For full Prisma field-level type safety, replace PrismaModelDelegate with your PrismaClient:
+ *   @Inject(PRISMA_CLIENT) private prisma!: PrismaClient
+ *
+ * @Repository() registers this class in the DI container as a singleton.
+ */
+import { Repository, HttpException, Inject } from '@forinda/kickjs'
+import { PRISMA_CLIENT, type PrismaModelDelegate } from '@forinda/kickjs-prisma'
+import type { ParsedQuery } from '@forinda/kickjs'
+import type { I${t}Repository } from '${r}/${n}.repository'
+import type { ${t}ResponseDTO } from '${i}/${n}-response.dto'
+import type { Create${t}DTO } from '${i}/create-${n}.dto'
+import type { Update${t}DTO } from '${i}/update-${n}.dto'
+
+@Repository()
+export class Prisma${t}Repository implements I${t}Repository {
+  @Inject(PRISMA_CLIENT) private prisma!: { ${a}: PrismaModelDelegate }
+
+  async findById(id: string): Promise<${t}ResponseDTO | null> {
+    return this.prisma.${a}.findUnique({ where: { id } }) as Promise<${t}ResponseDTO | null>
+  }
+
+  async findAll(): Promise<${t}ResponseDTO[]> {
+    return this.prisma.${a}.findMany() as Promise<${t}ResponseDTO[]>
+  }
+
+  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${t}ResponseDTO[]; total: number }> {
+    const [data, total] = await Promise.all([
+      this.prisma.${a}.findMany({
+        skip: parsed.pagination.offset,
+        take: parsed.pagination.limit,
+      }) as Promise<${t}ResponseDTO[]>,
+      this.prisma.${a}.count(),
+    ])
+    return { data, total }
+  }
+
+  async create(dto: Create${t}DTO): Promise<${t}ResponseDTO> {
+    return this.prisma.${a}.create({ data: dto as Record<string, unknown> }) as Promise<${t}ResponseDTO>
+  }
+
+  async update(id: string, dto: Update${t}DTO): Promise<${t}ResponseDTO> {
+    const existing = await this.prisma.${a}.findUnique({ where: { id } })
+    if (!existing) throw HttpException.notFound('${t} not found')
+    return this.prisma.${a}.update({ where: { id }, data: dto as Record<string, unknown> }) as Promise<${t}ResponseDTO>
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.prisma.${a}.deleteMany({ where: { id } })
+  }
+}
+`}function je(e,t,n,r=[]){switch(t){case`cqrs`:{let t=[],i=[];return r.includes(`devtools`)&&(t.push(`import { DevToolsAdapter } from '@forinda/kickjs-devtools'`),i.push(`    DevToolsAdapter(),`)),r.includes(`swagger`)&&(t.push(`import { SwaggerAdapter } from '@forinda/kickjs-swagger'`),i.push(`    SwaggerAdapter({\n      info: { title: '${e}', version: '${n}' },\n    }),`)),`import 'reflect-metadata'
+// Side-effect import — registers the extended env schema with kickjs
+// **before** any controller / service / @Value gets resolved. Without
+// this line ConfigService.get('YOUR_KEY') returns undefined because the
+// cached schema would still be the base shape. See guide/configuration.
+import './config'
+import { bootstrap } from '@forinda/kickjs'
+// import { WsAdapter } from '@forinda/kickjs-ws'
+// import { QueueAdapter, BullMQProvider } from '@forinda/kickjs-queue'
+${t.length?t.join(`
+`)+`
+`:``}import { modules } from './modules'
+
+// Export the app for the Vite plugin (dev mode)
+export const app = await bootstrap({
+  modules,${t.length?`\n  adapters: [\n${i.join(`
+`)}\n    // Uncomment for WebSocket support:\n    // WsAdapter(),\n    // Uncomment when Redis is available:\n    // QueueAdapter({\n    //   provider: new BullMQProvider({ host: 'localhost', port: 6379 }),\n    // }),\n  ],`:`
+  adapters: [
+    // Uncomment for WebSocket support:
+    // WsAdapter(),
+    // Uncomment when Redis is available:
+    // QueueAdapter({
+    //   provider: new BullMQProvider({ host: 'localhost', port: 6379 }),
+    // }),
+  ],`}
+})
+`}case`minimal`:{let t=[],i=[];return r.includes(`swagger`)&&(t.push(`import { SwaggerAdapter } from '@forinda/kickjs-swagger'`),i.push(`    SwaggerAdapter({ info: { title: '${e}', version: '${n}' } }),`)),r.includes(`devtools`)&&(t.push(`import { DevToolsAdapter } from '@forinda/kickjs-devtools'`),i.push(`    DevToolsAdapter(),`)),`import 'reflect-metadata'
+// Side-effect import — registers the extended env schema with kickjs
+// **before** any controller / service / @Value gets resolved. Without
+// this line ConfigService.get('YOUR_KEY') returns undefined because the
+// cached schema would still be the base shape. See guide/configuration.
+import './config'
+import { bootstrap } from '@forinda/kickjs'
+${t.length?t.join(`
+`)+`
+`:``}import { modules } from './modules'
+
+// Export the app for the Vite plugin (dev mode)
+export const app = await bootstrap({ modules${i.length?`,\n  adapters: [\n${i.join(`
+`)}\n  ]`:``} })
+`}default:{let t=[],i=[];return r.includes(`devtools`)&&(t.push(`import { DevToolsAdapter } from '@forinda/kickjs-devtools'`),i.push(`    DevToolsAdapter(),`)),r.includes(`swagger`)&&(t.push(`import { SwaggerAdapter } from '@forinda/kickjs-swagger'`),i.push(`    SwaggerAdapter({\n      info: { title: '${e}', version: '${n}' },\n    }),`)),`import 'reflect-metadata'
+// Side-effect import — registers the extended env schema with kickjs
+// **before** any controller / service / @Value gets resolved. Without
+// this line ConfigService.get('YOUR_KEY') returns undefined because the
+// cached schema would still be the base shape. See guide/configuration.
+import './config'
+import express from 'express'
+import {
+  bootstrap,
+  requestId,
+  requestLogger,
+  helmet,
+  cors,
+} from '@forinda/kickjs'
+${t.length?t.join(`
+`)+`
+`:``}import { modules } from './modules'
+
+// Export the app for the Vite plugin (dev mode)
+export const app = await bootstrap({
+  modules,${i.length?`\n  adapters: [\n${i.join(`
+`)}\n  ],`:``}
+  middleware: [
+    helmet(),
+    cors({ origin: '*' }),
+    requestId(),
+    requestLogger(),
+    express.json(),
+  ],
+})
+`}}}function Me(){return`import type { AppModuleClass } from '@forinda/kickjs'
+import { HelloModule } from './hello/hello.module'
+
+// Remove HelloModule and run: kick g module <name>
+export const modules: AppModuleClass[] = [HelloModule]
+`}function Ne(){return`import { defineEnv, loadEnv } from '@forinda/kickjs/config'
+import { z } from 'zod'
+
+/**
+ * Project environment schema.
+ *
+ * Extend the base schema with your application's variables. The
+ * default export is the contract \`kick typegen\` reads to populate
+ * the global \`KickEnv\` registry — that's what makes \`@Value('FOO')\`
+ * autocomplete and \`process.env.FOO\` typed.
+ *
+ * @example
+ *   DATABASE_URL: z.string().url(),
+ *   JWT_SECRET: z.string().min(32),
+ *   REDIS_URL: z.string().url().optional(),
+ */
+const envSchema = defineEnv((base) =>
+  base.extend({
+    // DATABASE_URL: z.string().url(),
+  }),
+)
+
+/**
+ * IMPORTANT — side effect: register the schema with kickjs's env cache
+ * **at module-load time**. \`ConfigService\` and \`@Value()\` both consume
+ * this cache, and they will fall back to the base schema (or undefined)
+ * if no extended schema has been registered before they're resolved.
+ *
+ * As long as \`src/index.ts\` imports this file (\`import './env'\`) at the
+ * top — before \`bootstrap()\` runs — every controller and service in the
+ * app sees the typed extended values.
+ */
+export const env = loadEnv(envSchema)
+
+export default envSchema
+`}function Pe(){return`import { Service } from '@forinda/kickjs'
+
+@Service()
+export class HelloService {
+  greet(name: string) {
+    return { message: \`Hello \${name} from KickJS!\`, timestamp: new Date().toISOString() }
+  }
+
+  healthCheck() {
+    return { status: 'ok', uptime: process.uptime() }
+  }
+}
+`}function Fe(){return`import { Controller, Get, Autowired, type Ctx } from '@forinda/kickjs'
+import { HelloService } from './hello.service'
+
+// \`Ctx<KickRoutes.HelloController['<method>']>\` is generated by
+// \`kick typegen\` (auto-run on \`kick dev\`). The first run after a fresh
+// scaffold creates \`.kickjs/types/routes.ts\` so this file typechecks.
+// See https://forinda.github.io/kick-js/guide/typegen.
+
+@Controller()
+export class HelloController {
+  @Autowired() private readonly helloService!: HelloService
+
+  @Get('/')
+  index(ctx: Ctx<KickRoutes.HelloController['index']>) {
+    ctx.json(this.helloService.greet('World'))
+  }
+
+  @Get('/health')
+  health(ctx: Ctx<KickRoutes.HelloController['health']>) {
+    ctx.json(this.helloService.healthCheck())
+  }
+}
+`}function Ie(){return`import { type AppModule, type ModuleRoutes, buildRoutes } from '@forinda/kickjs'
+import { HelloController } from './hello.controller'
+
+export class HelloModule implements AppModule {
+  // \`register(container)\` is optional — only implement it when you need
+  // to bind a token to a concrete implementation, e.g.
+  //   register(container) {
+  //     container.registerFactory(USER_REPOSITORY, () => container.resolve(InMemoryUserRepository))
+  //   }
+  // The HelloService uses @Service() so the decorator handles registration.
+
+  routes(): ModuleRoutes {
+    return {
+      path: '/hello',
+      router: buildRoutes(HelloController),
+      controller: HelloController,
+    }
+  }
+}
+`}function Le(e,t=`inmemory`,n=`pnpm`){return`import { defineConfig } from '@forinda/kickjs-cli'
+
+export default defineConfig({
+  pattern: '${e}',
+  // Pinned so \`kick add\` and other dep-installing commands always use the
+  // project's intended package manager, regardless of which lockfile exists.
+  packageManager: '${n}',
+  modules: {
+    dir: 'src/modules',
+    repo: ${[`drizzle`,`inmemory`,`prisma`].includes(t)?`'${t}'`:`{ name: '${t}' }`},
+    pluralize: true,
+  },
+
+  // \`kick typegen\` populates \`.kickjs/types/\` so \`Ctx<KickRoutes.X['method']>\`
+  // resolves to fully-typed params/body/query. Auto-runs on \`kick dev\`.
+  // Set \`schemaValidator: false\` to skip schema-driven body typing entirely.
+  typegen: {
+    schemaValidator: 'zod',
+  },
+
+  commands: [
+    {
+      name: 'test',
+      description: 'Run tests with Vitest',
+      steps: 'npx vitest run',
+    },
+    {
+      name: 'format',
+      description: 'Format code with Prettier',
+      steps: 'npx prettier --write src/',
+    },
+    {
+      name: 'format:check',
+      description: 'Check formatting without writing',
+      steps: 'npx prettier --check src/',
+    },
+    {
+      name: 'ci:check',
+      description: 'Run typecheck + format check',
+      steps: ['npx tsc --noEmit', 'npx prettier --check src/'],
+      aliases: ['verify'],
+    },
+  ],
+})
+`}async function Re(e){let{pascal:t,kebab:n,plural:r,write:i}=e;await i(`${n}.module.ts`,ge({pascal:t,kebab:n,plural:r})),await i(`${n}.controller.ts`,`import { Controller, Get, type Ctx } from '@forinda/kickjs'
+
+// \`Ctx<KickRoutes.${t}Controller['<method>']>\` is generated by
+// \`kick typegen\` (auto-run on \`kick dev\`).
+
+@Controller()
+export class ${t}Controller {
+  @Get('/')
+  async list(ctx: Ctx<KickRoutes.${t}Controller['list']>) {
+    ctx.json({ message: '${t} list' })
+  }
+}
+`)}async function ze(e){let{pascal:t,kebab:n,plural:r,pluralPascal:i,repo:a,noTests:o,prismaClientPath:s,tokenScope:c,write:l}=e;await l(`${n}.module.ts`,he({pascal:t,kebab:n,plural:r,repo:a})),await l(`${n}.constants.ts`,U({pascal:t,kebab:n})),await l(`${n}.controller.ts`,ve({pascal:t,kebab:n,plural:r,pluralPascal:i})),await l(`${n}.service.ts`,we({pascal:t,kebab:n})),await l(`dtos/create-${n}.dto.ts`,F({pascal:t,kebab:n})),await l(`dtos/update-${n}.dto.ts`,I({pascal:t,kebab:n})),await l(`dtos/${n}-response.dto.ts`,L({pascal:t,kebab:n})),await l(`${n}.repository.ts`,R({pascal:t,kebab:n,dtoPrefix:`./dtos`,tokenScope:c}));let u={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},d={inmemory:()=>z({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),drizzle:()=>W({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),prisma:()=>G({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`,prismaClientPath:s})},f=u[a]??`${k(a)}-${n}`,p=d[a]??(()=>B({pascal:t,kebab:n,repoType:a,repoPrefix:`.`,dtoPrefix:`./dtos`}));await l(`${f}.repository.ts`,p()),o||(a!==`inmemory`&&await l(`in-memory-${n}.repository.ts`,z({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`})),await l(`__tests__/${n}.controller.test.ts`,V({pascal:t,kebab:n,plural:r})),await l(`__tests__/${n}.repository.test.ts`,H({pascal:t,kebab:n,plural:r,repoPrefix:`../${u.inmemory??`in-memory-${n}`}.repository`})))}async function Be(e){let{pascal:t,kebab:n,plural:r,pluralPascal:i,repo:a,noTests:o,prismaClientPath:s,tokenScope:c,write:l}=e;await l(`${n}.module.ts`,Te({pascal:t,kebab:n,plural:r,repo:a})),await l(`${n}.constants.ts`,U({pascal:t,kebab:n})),await l(`${n}.controller.ts`,Ee({pascal:t,kebab:n,plural:r,pluralPascal:i})),await l(`dtos/create-${n}.dto.ts`,F({pascal:t,kebab:n})),await l(`dtos/update-${n}.dto.ts`,I({pascal:t,kebab:n})),await l(`dtos/${n}-response.dto.ts`,L({pascal:t,kebab:n}));let u=De({pascal:t,kebab:n});for(let e of u)await l(`commands/${e.file}`,e.content);let d=Oe({pascal:t,kebab:n,plural:r,pluralPascal:i});for(let e of d)await l(`queries/${e.file}`,e.content);let f=ke({pascal:t,kebab:n});for(let e of f)await l(`events/${e.file}`,e.content);await l(`${n}.repository.ts`,R({pascal:t,kebab:n,dtoPrefix:`./dtos`,tokenScope:c}));let p={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},m={inmemory:()=>z({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),drizzle:()=>W({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),prisma:()=>G({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`,prismaClientPath:s})},h=p[a]??`${k(a)}-${n}`,g=m[a]??(()=>B({pascal:t,kebab:n,repoType:a,repoPrefix:`.`,dtoPrefix:`./dtos`}));await l(`${h}.repository.ts`,g()),o||(a!==`inmemory`&&await l(`in-memory-${n}.repository.ts`,z({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`})),await l(`__tests__/${n}.controller.test.ts`,V({pascal:t,kebab:n,plural:r})),await l(`__tests__/${n}.repository.test.ts`,H({pascal:t,kebab:n,plural:r,repoPrefix:`../${p.inmemory??`in-memory-${n}`}.repository`})))}async function Ve(e){let{pascal:t,kebab:n,plural:r,pluralPascal:i,repo:a,noEntity:o,noTests:s,prismaClientPath:c,tokenScope:l,write:u}=e;await u(`${n}.module.ts`,me({pascal:t,kebab:n,plural:r,repo:a})),await u(`constants.ts`,a===`drizzle`?Ae({pascal:t,kebab:n}):ye({pascal:t,kebab:n})),await u(`presentation/${n}.controller.ts`,_e({pascal:t,kebab:n,plural:r,pluralPascal:i})),await u(`application/dtos/create-${n}.dto.ts`,F({pascal:t,kebab:n})),await u(`application/dtos/update-${n}.dto.ts`,I({pascal:t,kebab:n})),await u(`application/dtos/${n}-response.dto.ts`,L({pascal:t,kebab:n}));let d=be({pascal:t,kebab:n,plural:r,pluralPascal:i});for(let e of d)await u(`application/use-cases/${e.file}`,e.content);await u(`domain/repositories/${n}.repository.ts`,R({pascal:t,kebab:n,tokenScope:l})),await u(`domain/services/${n}-domain.service.ts`,xe({pascal:t,kebab:n}));let f={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},p={inmemory:()=>z({pascal:t,kebab:n}),drizzle:()=>W({pascal:t,kebab:n}),prisma:()=>G({pascal:t,kebab:n,prismaClientPath:c})},m=f[a]??`${k(a)}-${n}`,h=p[a]??(()=>B({pascal:t,kebab:n,repoType:a}));await u(`infrastructure/repositories/${m}.repository.ts`,h()),o||(await u(`domain/entities/${n}.entity.ts`,Se({pascal:t,kebab:n})),await u(`domain/value-objects/${n}-id.vo.ts`,Ce({pascal:t,kebab:n}))),s||(a!==`inmemory`&&await u(`infrastructure/repositories/in-memory-${n}.repository.ts`,z({pascal:t,kebab:n})),await u(`__tests__/${n}.controller.test.ts`,V({pascal:t,kebab:n,plural:r})),await u(`__tests__/${n}.repository.test.ts`,H({pascal:t,kebab:n,plural:r})))}function He(e){return e?typeof e==`string`?e:e.name:`inmemory`}async function Ue(e){let{name:t,modulesDir:n,noEntity:i,noTests:a,repo:o=`inmemory`,force:s,dryRun:c}=e,l=e.pluralize!==!1,u=e.pattern??`ddd`;e.minimal&&(u=`minimal`);let d=k(t),p=D(t),m=l?A(d):d,h=l?j(p):p,g=r(n,m),_=[],v=s??!1,y={kebab:d,pascal:p,plural:m,pluralPascal:h,moduleDir:g,repo:o,noEntity:i??!1,noTests:a??!1,prismaClientPath:e.prismaClientPath??`@prisma/client`,tokenScope:e.tokenScope??`app`,write:async(e,t)=>{let n=r(g,e);if(c){_.push(n);return}if(!v&&await C(n)&&!await T({message:`File exists: ${f.dim(e)}. Overwrite?`,initialValue:!1})){E.warn(`Skipped: ${e}`);return}await b(n,t),_.push(n)},files:_};switch(u){case`minimal`:await Re(y);break;case`rest`:await ze(y);break;case`cqrs`:await Be(y);break;default:await Ve(y);break}return c||await We(n,p,m,d),_}async function We(e,t,n,i){let a=r(e,`index.ts`),o=await C(a),s=`./${n}/${i}.module`;if(!o){await b(a,`import type { AppModuleClass } from '@forinda/kickjs'
+import { ${t}Module } from '${s}'
+
+export const modules: AppModuleClass[] = [${t}Module]
+`);return}let c=await l(a,`utf-8`),d=`import { ${t}Module } from '${s}'`;if(!c.includes(`${t}Module`)){let e=c.lastIndexOf(`import `);if(e!==-1){let t=c.indexOf(`
+`,e);c=c.slice(0,t+1)+d+`
+`+c.slice(t+1)}else c=d+`
+`+c;c=c.replace(/(=\s*\[)([\s\S]*?)(])/,(e,n,r,i)=>{let a=r.trim();if(!a)return`${n}${t}Module${i}`;let o=a.endsWith(`,`)?``:`,`;return`${n}${r.trimEnd()}${o} ${t}Module${i}`})}await u(a,c,`utf-8`)}async function Ge(e){let{name:t,outDir:n}=e,i=k(t),a=D(t),o=[],s=r(n,`${i}.adapter.ts`);return await b(s,`import {
+  defineAdapter,
+  type AdapterContext,
+  type AdapterMiddleware,
+  type ContributorRegistrations,
+  type Constructor,
+} from '@forinda/kickjs'
+
+/**
+ * Configuration for the ${a} adapter.
+ *
+ * Adapters typically take a small config object so callers can tune
+ * behaviour at bootstrap time. Keep the shape narrow — anything
+ * derived from the environment should be read inside the build
+ * function via getEnv(), not forced onto the caller.
+ */
+export interface ${a}AdapterConfig {
+  // Add your adapter configuration here, e.g.:
+  // enabled?: boolean
+  // apiKey?: string
+}
+
+/**
+ * ${a} adapter — built via \`defineAdapter()\` so callers get the
+ * factory's call / \`.scoped()\` / \`.async()\` surfaces for free.
+ *
+ * Hooks into the Application lifecycle to add middleware, routes,
+ * Context Contributors, or external service connections.
+ *
+ * Every lifecycle hook below is OPTIONAL. The scaffold emits all of
+ * them so adopters can browse what's available and delete what they
+ * don't need — \`build()\` returning \`{}\` is also valid for an adapter
+ * that only contributes config defaults.
+ *
+ * @example
+ * \`\`\`ts
+ * import { bootstrap } from '@forinda/kickjs'
+ * import { ${a}Adapter } from './adapters/${i}.adapter'
+ *
+ * bootstrap({
+ *   modules,
+ *   adapters: [${a}Adapter({ /* config overrides *\\/ })],
+ * })
+ * \`\`\`
+ */
+export const ${a}Adapter = defineAdapter<${a}AdapterConfig>({
+  name: '${a}Adapter',
+  defaults: {
+    // Default config values go here. The adopter's overrides shallow-merge
+    // on top of these before \`build()\` runs.
+  },
+  build: (_config, { name: _name }) => {
+    // Closures inside \`build()\` are how each adapter instance owns its
+    // own state (database client, Map, timer handle, …). The same
+    // \`_config\` is visible to every hook below.
+
+    return {
+      /**
+       * Express middleware entries the Application mounts at named phases.
+       *
+       * \`phase\` controls where each handler sits in the pipeline:
+       *   'beforeGlobal' | 'afterGlobal' | 'beforeRoutes' | 'afterRoutes'.
+       *
+       * \`path\` (optional) scopes the entry to a path prefix.
+       *
+       * Delete this hook entirely if you don't add middleware.
+       */
+      middleware(): AdapterMiddleware[] {
+        return [
+          // Example: add a custom header to all responses
+          // {
+          //   phase: 'beforeGlobal',
+          //   handler: (_req, res, next) => {
+          //     res.setHeader('X-${a}', 'true')
+          //     next()
+          //   },
+          // },
+          // Example: scope a rate limiter to one path prefix
+          // {
+          //   phase: 'beforeRoutes',
+          //   path: '/api/v1/auth',
+          //   handler: rateLimit({ max: 10 }),
+          // },
+        ]
+      },
+
+      /**
+       * Runs BEFORE global middleware. Mount routes that should bypass the
+       * middleware stack — health checks, docs UI, static assets, OAuth
+       * callbacks. Anything you want reachable even if a global middleware
+       * later in the chain rejects requests.
+       *
+       * Delete this hook if you have no early routes.
+       */
+      beforeMount(_ctx: AdapterContext): void {
+        // Example:
+        // _ctx.app.get('/${i}/status', (_req, res) => res.json({ status: 'ok' }))
+      },
+
+      /**
+       * Fires once per controller class as the router mounts. Use this to
+       * collect route metadata for OpenAPI specs, dependency graphs, route
+       * inventories, devtools dashboards.
+       *
+       * Delete this hook unless your adapter introspects the route registry.
+       */
+      onRouteMount(_controllerClass: Constructor, _mountPath: string): void {
+        // Example (Swagger-style): collect routes for the spec.
+        // openApiSpec.addController(_controllerClass, _mountPath)
+      },
+
+      /**
+       * Runs AFTER modules + routes are wired, BEFORE the server starts.
+       * Right place for late-stage DI registrations or final config validation.
+       *
+       * Delete this hook if there's nothing to wire post-modules.
+       */
+      beforeStart(_ctx: AdapterContext): void {
+        // Example: _ctx.container.registerInstance(MY_TOKEN, new MyService(_config))
+      },
+
+      /**
+       * Runs AFTER the HTTP server is listening. The raw \`http.Server\` is
+       * available on \`ctx.server\` — attach upgrade handlers (Socket.IO,
+       * gRPC, GraphQL subscriptions), warm caches, log a banner.
+       *
+       * Delete this hook if you don't need the running server reference.
+       */
+      afterStart(_ctx: AdapterContext): void {
+        // Example: const io = new Server(_ctx.server)
+      },
+
+      /**
+       * Returns Context Contributors to merge into every route's pipeline
+       * at the \`'adapter'\` precedence level. Per-route handlers can
+       * override the value at the method / class / module level.
+       *
+       * Delete this hook unless your adapter ships typed per-request values
+       * (auth user, tenant, locale, feature flags, geo, etc).
+       */
+      contributors(): ContributorRegistrations {
+        return [
+          // Example:
+          // import { defineHttpContextDecorator } from '@forinda/kickjs'
+          // declare module '@forinda/kickjs' { interface ContextMeta { ${i}: { id: string } } }
+          // const Load${a} = defineHttpContextDecorator({
+          //   key: '${i}',
+          //   resolve: (ctx) => ({ id: ctx.req.headers['x-${i}-id'] as string }),
+          // })
+          // return [Load${a}.registration]
+        ]
+      },
+
+      /**
+       * Runs on graceful shutdown (SIGINT/SIGTERM). Clean up long-lived
+       * resources the adapter owns: close connections, flush buffers,
+       * cancel timers. The framework runs every adapter's \`shutdown\`
+       * concurrently via \`Promise.allSettled\` — one failure won't block
+       * sibling adapters.
+       *
+       * Delete this hook if your adapter holds no resources.
+       */
+      async shutdown(): Promise<void> {
+        // Example: await this.pool.end()
+        // Example: clearInterval(this.heartbeatTimer)
+      },
+    }
+  },
+})
+`),o.push(s),o}const Ke={controller:`presentation`,service:`domain/services`,dto:`application/dtos`,guard:`presentation/guards`,middleware:`middleware`},qe={controller:``,service:``,dto:`dtos`,guard:`guards`,middleware:`middleware`},Je={controller:``,service:``,dto:`dtos`,guard:`guards`,middleware:`middleware`,command:`commands`,query:`queries`,event:`events`};function K(e){let{type:t,outDir:n,moduleName:a,modulesDir:o=`src/modules`,defaultDir:s,pattern:c=`ddd`,shouldPluralize:l=!0}=e;if(n)return i(n);if(a){let e=c===`ddd`?Ke:c===`cqrs`?Je:qe,n=k(a),s=l?A(n):n,u=e[t]??``,d=r(o,s);return i(u?r(d,u):d)}return i(s)}async function Ye(e){let{name:t,moduleName:n,modulesDir:i,pattern:a}=e,o=K({type:`middleware`,outDir:e.outDir,moduleName:n,modulesDir:i,defaultDir:`src/middleware`,pattern:a,shouldPluralize:e.pluralize??!0}),s=k(t),c=O(t),l=[],u=r(o,`${s}.middleware.ts`);return await b(u,`import type { Request, Response, NextFunction } from 'express'
+
+export interface ${D(t)}Options {
+  // Add configuration options here
+}
+
+/**
+ * ${D(t)} middleware.
+ *
+ * Usage in bootstrap:
+ *   middleware: [${c}()]
+ *
+ * Usage with adapter:
+ *   middleware() { return [{ handler: ${c}(), phase: 'afterGlobal' }] }
+ *
+ * Usage with @Middleware decorator:
+ *   @Middleware(${c}())
+ */
+export function ${c}(options: ${D(t)}Options = {}) {
+  return (req: Request, res: Response, next: NextFunction) => {
+    // Implement your middleware logic here
+    next()
+  }
+}
+`),l.push(u),l}async function Xe(e){let{name:t,moduleName:n,modulesDir:i,pattern:a}=e,o=K({type:`guard`,outDir:e.outDir,moduleName:n,modulesDir:i,defaultDir:`src/guards`,pattern:a,shouldPluralize:e.pluralize??!0}),s=k(t),c=O(t),l=D(t),u=[],d=r(o,`${s}.guard.ts`);return await b(d,`import { Container, HttpException } from '@forinda/kickjs'
+import type { RequestContext } from '@forinda/kickjs'
+
+/**
+ * ${l} guard.
+ *
+ * Guards protect routes by checking conditions before the handler runs.
+ * Return early with an error response to block access.
+ *
+ * Usage:
+ *   @Middleware(${c}Guard)
+ *   @Get('/protected')
+ *   async handler(ctx: RequestContext) { ... }
+ */
+export async function ${c}Guard(ctx: RequestContext, next: () => void): Promise<void> {
+  // Example: check for an authorization header
+  const header = ctx.headers.authorization
+  if (!header?.startsWith('Bearer ')) {
+    ctx.res.status(401).json({ message: 'Missing or invalid authorization header' })
+    return
+  }
+
+  const token = header.slice(7)
+
+  try {
+    // Verify the token using a service from the DI container
+    // const container = Container.getInstance()
+    // const authService = container.resolve(AuthService)
+    // const payload = authService.verifyToken(token)
+    // ctx.set('auth', payload)
+
+    next()
+  } catch {
+    ctx.res.status(401).json({ message: 'Invalid or expired token' })
+  }
+}
+`),u.push(d),u}async function Ze(e){let{name:t,moduleName:n,modulesDir:i,pattern:a}=e,o=K({type:`service`,outDir:e.outDir,moduleName:n,modulesDir:i,defaultDir:`src/services`,pattern:a,shouldPluralize:e.pluralize??!0}),s=k(t),c=D(t),l=[],u=r(o,`${s}.service.ts`);return await b(u,`import { Service } from '@forinda/kickjs'
+
+@Service()
+export class ${c}Service {
+  // Inject dependencies via constructor
+  // constructor(
+  //   @Inject(MY_REPO) private readonly repo: IMyRepository,
+  // ) {}
+}
+`),l.push(u),l}async function Qe(e){let{name:t,moduleName:n,modulesDir:i,pattern:a}=e,o=K({type:`controller`,outDir:e.outDir,moduleName:n,modulesDir:i,defaultDir:`src/controllers`,pattern:a,shouldPluralize:e.pluralize??!0}),s=k(t),c=D(t),l=[],u=r(o,`${s}.controller.ts`);return await b(u,`import { Controller, Get, Post, type Ctx } from '@forinda/kickjs'
+
+// \`Ctx<KickRoutes.${c}Controller['<method>']>\` is generated by
+// \`kick typegen\` (auto-run on \`kick dev\`). After the first run, your IDE
+// will autocomplete \`ctx.params\`, \`ctx.body\`, and \`ctx.query\`.
+// See https://forinda.github.io/kick-js/guide/typegen for details.
+
+@Controller()
+export class ${c}Controller {
+  // @Autowired() private readonly myService!: MyService
+
+  @Get('/')
+  async list(ctx: Ctx<KickRoutes.${c}Controller['list']>) {
+    ctx.json({ message: '${c} list' })
+  }
+
+  @Post('/')
+  async create(ctx: Ctx<KickRoutes.${c}Controller['create']>) {
+    ctx.created({ message: '${c} created', data: ctx.body })
+  }
+}
+`),l.push(u),l}async function $e(e){let{name:t,moduleName:n,modulesDir:i,pattern:a}=e,o=K({type:`dto`,outDir:e.outDir,moduleName:n,modulesDir:i,defaultDir:`src/dtos`,pattern:a,shouldPluralize:e.pluralize??!0}),s=k(t),c=D(t),l=O(t),u=[],d=r(o,`${s}.dto.ts`);return await b(d,`import { z } from 'zod'
+
+export const ${l}Schema = z.object({
+  // Define your schema fields here
+  name: z.string().min(1).max(200),
+})
+
+export type ${c}DTO = z.infer<typeof ${l}Schema>
+`),u.push(d),u}const et={auth:`@forinda/kickjs-auth`,swagger:`@forinda/kickjs-swagger`,ws:`@forinda/kickjs-ws`,queue:`@forinda/kickjs-queue`,devtools:`@forinda/kickjs-devtools`};function tt(e,t,n,r=[]){let i={"@forinda/kickjs":n,dotenv:`^17.3.1`,express:`^5.1.0`,"reflect-metadata":`^0.2.2`,zod:`^4.3.6`,pino:`^10.3.1`,"pino-pretty":`^13.1.3`};for(let e of r){let t=et[e];t&&!i[t]&&(i[t]=n)}return JSON.stringify({name:e,version:n.replace(`^`,``),type:`module`,scripts:{dev:`vite`,"dev:debug":`kick dev:debug`,build:`kick build`,start:`kick start`,test:`vitest run`,"test:watch":`vitest`,typecheck:`tsc --noEmit`,typegen:`kick typegen`,lint:`eslint src/`,format:`prettier --write src/`},dependencies:i,devDependencies:{"@forinda/kickjs-cli":n,"@forinda/kickjs-vite":n,"@swc/core":`^1.15.21`,"@types/express":`^5.0.6`,"@types/node":`^25.0.0`,"unplugin-swc":`^1.5.9`,vite:`^8.0.3`,vitest:`^4.1.2`,typescript:`^6.0.3`,prettier:`^3.8.1`}},null,2)}function nt(){return`import { defineConfig } from 'vite'
+import { resolve } from 'node:path'
+import swc from 'unplugin-swc'
+import { kickjsVitePlugin, envWatchPlugin } from '@forinda/kickjs-vite'
+
+export default defineConfig({
+  oxc: false,
+  plugins: [
+    swc.vite(),
+    kickjsVitePlugin({ entry: 'src/index.ts' }),
+    // Watches .env files and triggers a full reload on change so the
+    // dev server picks up env tweaks without a manual restart.
+    envWatchPlugin(),
+  ],
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, 'src'),
+    },
+  },
+  ssr: {
+    // Don't bundle pino — its worker-thread transport needs Node.js resolution
+    // to find pino-pretty at runtime for colored log output
+    external: ['pino', 'pino-pretty'],
+  },
+  build: {
+    target: 'node20',
+    ssr: true,
+    outDir: 'dist',
+    sourcemap: true,
+    rollupOptions: {
+      input: resolve(__dirname, 'src/index.ts'),
+      output: { format: 'esm' },
+    },
+  },
+})
+`}function rt(){return JSON.stringify({compilerOptions:{target:`ES2022`,module:`ESNext`,moduleResolution:`bundler`,lib:[`ES2022`],types:[`node`,`vite/client`],strict:!0,esModuleInterop:!0,skipLibCheck:!0,sourceMap:!0,declaration:!0,experimentalDecorators:!0,emitDecoratorMetadata:!0,outDir:`dist`,paths:{"@/*":[`./src/*`]}},include:[`src`,`.kickjs/types/**/*.d.ts`,`.kickjs/types/**/*.ts`]},null,2)}function it(){return JSON.stringify({semi:!1,singleQuote:!0,trailingComma:`all`,printWidth:100,tabWidth:2},null,2)}function at(){return`# 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
+`}function ot(){return`node_modules/
+dist/
+.env
+coverage/
+.DS_Store
+*.tsbuildinfo
+.kickjs/
+`}function st(){return`# 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 — treat as generated
+pnpm-lock.yaml -diff linguist-generated
+yarn.lock -diff linguist-generated
+package-lock.json -diff linguist-generated
+`}function ct(){return`PORT=3000
+NODE_ENV=development
+`}function lt(){return`PORT=3000
+NODE_ENV=development
+`}function ut(){return`import { defineConfig } from 'vitest/config'
+import swc from 'unplugin-swc'
+
+export default defineConfig({
+  plugins: [swc.vite()],
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.test.ts'],
+  },
+})
+`}function dt(e,t,n){let r={rest:`REST API`,ddd:`Domain-Driven Design`,cqrs:`CQRS + Event-Driven`,minimal:`Minimal`},i=[`@forinda/kickjs`,`@forinda/kickjs-vite`];return t!==`minimal`&&i.push(`@forinda/kickjs-swagger`,`@forinda/kickjs-devtools`),t===`cqrs`&&i.push(`@forinda/kickjs-queue`,`@forinda/kickjs-ws`),`# ${e}
+
+A **${r[t]??`REST API`}** built with [KickJS](https://forinda.github.io/kick-js/) — a decorator-driven Node.js framework on Express 5 and TypeScript.
+
+## Getting Started
+
+\`\`\`bash
+${n} install
+kick dev
+\`\`\`
+
+## Scripts
+
+| Command | Description |
+|---|---|
+| \`kick dev\` | Start dev server with Vite HMR |
+| \`kick build\` | Production build |
+| \`kick start\` | Run production build |
+| \`${n} run test\` | Run tests with Vitest |
+| \`kick g module <name>\` | Generate a DDD module |
+| \`kick g scaffold <name> <fields...>\` | Generate CRUD from field definitions |
+| \`kick add <package>\` | Add a KickJS package |
+
+## Project Structure
+
+\`\`\`
+src/
+├── index.ts           # Application entry point
+├── modules/           # Feature modules (controllers, services, repos)
+│   └── index.ts       # Module registry
+└── ...
+\`\`\`
+
+## Packages
+
+${i.map(e=>`- \`${e}\``).join(`
+`)}
+
+## Adding Features
+
+\`\`\`bash
+kick add auth          # Authentication (JWT, API key, OAuth)
+kick add swagger       # OpenAPI documentation
+kick add ws            # WebSocket support
+kick add queue         # Background job processing
+kick add --list        # Show all available packages
+\`\`\`
+
+For email, scheduled tasks, multi-tenancy, OpenTelemetry, GraphQL, and notifications use the BYO recipes in the [KickJS guides](https://forinda.github.io/kick-js/guide/) — they wire the upstream library through \`defineAdapter()\` / \`definePlugin()\` directly, so you keep control of the integration.
+
+## Environment Variables
+
+Copy \`.env.example\` to \`.env\` and configure:
+
+| Variable | Default | Description |
+|---|---|---|
+| \`PORT\` | \`3000\` | Server port |
+| \`NODE_ENV\` | \`development\` | Environment |
+
+## Learn More
+
+- [KickJS Documentation](https://forinda.github.io/kick-js/)
+- [CLI Reference](https://forinda.github.io/kick-js/api/cli.html)
+`}function q(e,t,n){return`# CLAUDE.md — ${e}
+
+**Read \`./AGENTS.md\` first.** It is the canonical, multi-agent
+reference for this project (Claude, Copilot, Codex, Gemini, etc.) —
+project conventions, structure, decorator patterns, env wiring, CLI
+generators, every gotcha.
+
+**Then read \`./kickjs-skills.md\`.** That file is the task-oriented
+skill index — short, rigid recipes keyed to triggers ("add-module",
+"write-controller-test", "bootstrap-export", "deny-list", …). Use it
+as the playbook when executing common KickJS workflows.
+
+This file is a thin Claude-specific layer on top of those two; when
+they disagree on anything substantive, treat \`AGENTS.md\` as
+authoritative and flag the discrepancy.
+
+## Why two files
+
+\`AGENTS.md\` is what every agent reads. \`CLAUDE.md\` is what
+Claude Code automatically loads as project context on each
+conversation. Keeping CLAUDE.md slim avoids two files drifting; the
+redirect above ensures Claude pulls the canonical content without
+us copy-pasting.
+
+## Claude-specific notes
+
+- **Slash commands** — \`/help\` for Claude Code commands; \`/init\`
+  to refresh project memory if AGENTS.md changes substantially.
+- **Feedback** — file issues at <https://github.com/anthropics/claude-code/issues>.
+- **Persistent memory** — Claude maintains user/feedback/project/
+  reference memories under \`.claude/memory/\`. If you ask for
+  something that contradicts a remembered preference, Claude flags
+  it before acting; corrections update memory automatically.
+- **Long-running tasks** — \`/loop\` and \`/schedule\` for recurring
+  or background work. Useful for "wait for the deploy then open a
+  cleanup PR" or "every Monday triage the issue board" patterns.
+
+## Quick reference (full version in AGENTS.md)
+
+\`\`\`bash
+${n} install            # Install dependencies
+kick dev                 # Dev server with HMR + typegen
+kick build && kick start # Production
+${n} run test           # Vitest
+${n} run typecheck      # tsc --noEmit
+${n} run format         # Prettier
+\`\`\`
+
+## v4 framework reminders
+
+When generating or modifying code in this project, stay aligned with the v4 conventions documented in \`AGENTS.md\`:
+
+- **Adapters**: \`defineAdapter()\` factory — never \`class implements AppAdapter\`.
+- **Plugins**: \`definePlugin()\` factory — never plain function returning \`KickPlugin\`.
+- **DI tokens**: \`<scope>/<PascalKey>[/<suffix>]\` — scope is lowercase, the key segment is **PascalCase** (e.g. \`'app/Users/repository'\`, \`'mycorp/Cache/redis'\`). First-party uses the reserved \`'kick/'\` prefix; this project owns its own scope.
+- **Decorators**: \`@Controller()\` (no path arg — mount prefix comes from \`routes().path\`).
+- **Module entry file** MUST be named \`<name>.module.ts\` and live under \`src/modules/<name>/\`. The Vite plugin auto-discovers \`*.module.[tj]sx?\` for graceful HMR — a misnamed \`projects.ts\` silently degrades every save into a full restart.
+- **Env**: schema lives in \`src/config/index.ts\`; \`import './config'\` MUST be the first import in \`src/index.ts\` (side-effect registers the schema before any \`@Value\` resolves).
+- **Assets**: drop new template files into \`src/templates/<namespace>/\`; the dev watcher auto-rebuilds the \`KickAssets\` augmentation + \`assets.x.y()\` re-walks on next call. No restart, no manual build.
+- **Context Contributors** (\`defineContextDecorator\`) over \`@Middleware()\` for ctx-population work.
+- **Repos under tests**: \`Container.create()\` for isolation — never \`new Container()\` or \`getInstance().reset()\`.
+- **Bootstrap export**: \`src/index.ts\` must end with \`export const app = await bootstrap({ ... })\`. The Vite plugin and \`createTestApp\` import the named \`app\`; without the export, HMR silently degrades to full restarts.
+- **Thin entry file**: aggregate \`modules\`, \`middleware\`, \`plugins\`, \`adapters\` in their own folders (\`src/modules/index.ts\`, \`src/middleware/index.ts\`, …) and pass them by name to \`bootstrap()\` — never inline the lists in \`src/index.ts\`.
+- **Refresh these files**: \`kick g agents -f\` regenerates \`AGENTS.md\` + \`CLAUDE.md\` from the latest CLI templates. Hand-edited content is overwritten — keep customisation in \`AGENTS.local.md\`.
+
+For everything else (controllers, services, modules, RequestContext API, generators, CLI commands, package additions, env wiring, troubleshooting) → \`AGENTS.md\`.
+`}function J(e,t,n){return`# AGENTS.md — AI Agent Guide for ${e}
+
+This guide is the **canonical, multi-agent reference** for this KickJS
+application — Claude, Copilot, Codex, Gemini, etc. all read it first.
+Per-agent files (\`CLAUDE.md\`, \`GEMINI.md\`, etc.) are thin layers that
+add tool-specific affordances on top.
+
+## Before You Start
+
+1. Run \`${n} install\` to install dependencies
+2. Run \`kick dev\` to verify the app starts
+3. Read the [KickJS documentation](https://forinda.github.io/kick-js/) for framework details
+
+## v4 Conventions (don't skip)
+
+KickJS v4 made a handful of structural changes from v3. Internalise these
+before generating or modifying code — they are the source of most agent
+mistakes:
+
+- **Adapters** — \`defineAdapter()\` factory. Never write \`class Foo implements AppAdapter\`.
+
+  \`\`\`ts
+  export const MyAdapter = defineAdapter<MyOptions>({
+    name: 'MyAdapter',
+    defaults: { ... },
+    build: (config) => ({
+      beforeMount({ app }) { /* ... */ },
+      afterStart({ server }) { /* ... */ },
+    }),
+  })
+  \`\`\`
+
+- **Plugins** — \`definePlugin()\` factory. Same shape, never plain function returning \`KickPlugin\`.
+
+- **DI tokens** — \`<scope>/<PascalKey>[/<suffix>]\`. Scope is lowercase,
+  the key segment is **PascalCase** (the regex enforces both):
+
+  \`\`\`ts
+  const USERS_REPO = createToken<UsersRepo>('app/Users/repository')
+  const DB         = createToken<Database>('app/Db/connection')
+  \`\`\`
+
+  The \`kick/\` prefix is reserved for first-party packages; this project
+  owns its own scope (\`app/\`, your domain name, etc.).
+
+- **\`@Controller()\`** takes **no path argument**. Mount prefix comes from
+  the module's \`routes()\` return value, not the decorator. \`@Controller('/users')\`
+  is a v3 leftover; the linter and codegen reject it.
+
+- **Env wiring** — \`src/config/index.ts\` calls \`loadEnv(envSchema)\` as a
+  side effect. \`src/index.ts\` MUST have \`import './config'\` as its **first**
+  import (before \`bootstrap()\`). Without it, \`ConfigService.get('YOUR_KEY')\`
+  returns \`undefined\` and \`@Value()\` only works via raw \`process.env\` fallback
+  (Zod coercion + defaults silently skipped).
+
+- **Module entry files MUST be named \`<name>.module.ts\`** — see the Vite
+  HMR contract at the top of "Module Pattern" below. The CLI enforces this;
+  hand-rolled files must too.
+
+- **Assets** — drop new template files into \`src/templates/<namespace>/\`
+  (or wherever \`kick.config.ts\` points). The dev watcher auto-rebuilds the
+  \`KickAssets\` augmentation; \`assets.x.y()\` re-walks on next call. No restart,
+  no manual build step.
+
+- **Context over \`@Middleware()\`** — when a middleware's only job is to
+  populate \`ctx.set('key', value)\`, use \`defineHttpContextDecorator()\`
+  (HTTP) or \`defineContextDecorator()\` (transport-agnostic) instead.
+  Typed via \`ContextMeta\`, ordered via \`dependsOn\`, validated at boot.
+  Reserve \`@Middleware()\` for response short-circuit / stream mutation /
+  pre-route-matching work.
+
+  Two ground rules around the data flow — both stem from the fact that
+  every per-request stage gets its OWN \`RequestContext\` instance, all
+  reading/writing the SAME \`AsyncLocalStorage\`-backed Map:
+  - **\`resolve\` and \`onError\` must RETURN the value.** The runner
+    writes it via \`ctx.set(reg.key, value)\` on your behalf. Direct
+    property assignment (\`ctx.tenant = …\`) sticks to the contributor
+    instance only — the handler instance never sees it.
+  - **Read across instances via \`ctx.set\` / \`ctx.get\`** (or
+    \`getRequestValue(key)\` from a service that has no \`ctx\` reference
+    — typed via \`MetaValue<K>\`). \`ctx.req\` works because the underlying
+    Express request is shared; bespoke property assignments don't.
+
+- **Test isolation** — default to \`Container.create()\` for fresh DI state.
+  Never \`new Container()\` and never \`getInstance().reset()\` — both leak
+  registrations between tests.
+
+  \`\`\`ts
+  const container = Container.create()
+  // ... register test-scoped providers, run, discard
+  \`\`\`
+
+- **Bootstrap export** — \`src/index.ts\` MUST end with
+  \`export const app = await bootstrap({ ... })\`. The Vite plugin imports
+  the named \`app\` symbol to drive HMR module swaps; testing helpers
+  (\`createTestApp\`) and the OpenAPI introspector also rely on it. Drop
+  the \`export\` and \`kick dev\` will silently fall back to a full restart
+  on every save while \`createTestApp\` complains about a missing handle.
+
+- **Keep \`src/index.ts\` thin** — collect plugins, modules, middleware, and
+  adapters in dedicated folders and re-export aggregated arrays. Do **not**
+  inline registration in the entry file:
+
+  \`\`\`ts
+  // src/modules/index.ts
+  export const modules: AppModuleClass[] = [HelloModule, UsersModule, ...]
+
+  // src/middleware/index.ts
+  export const middleware = [helmet(), cors(), requestId(), ...]
+
+  // src/plugins/index.ts
+  export const plugins = [MetricsPlugin(), AuditPlugin()]
+
+  // src/adapters/index.ts
+  export const adapters = [SwaggerAdapter({ ... }), DevToolsAdapter()]
+  \`\`\`
+
+  \`\`\`ts
+  // src/index.ts — stays small; one import per category
+  import 'reflect-metadata'
+  import './config'
+  import { bootstrap } from '@forinda/kickjs'
+  import { modules } from './modules'
+  import { middleware } from './middleware'
+  import { plugins } from './plugins'
+  import { adapters } from './adapters'
+
+  export const app = await bootstrap({ modules, middleware, plugins, adapters })
+  \`\`\`
+
+  This keeps the entry file diff-friendly, scales to dozens of modules
+  without git churn, and lets each domain own its own registration list.
+  The generators (\`kick g module\`, \`kick g middleware\`, \`kick g plugin\`,
+  \`kick g adapter\`) follow this layout — manual additions should too.
+
+Everything else (controllers, services, modules, RequestContext API, generators,
+package additions, env access patterns, troubleshooting) is detailed below.
+
+## Where to Find Things
+
+### Application Structure
+
+| What | Where |
+|------|-------|
+| Entry point | \`src/index.ts\` |
+| Module registry | \`src/modules/index.ts\` |
+| Feature modules | \`src/modules/<module-name>/\` |
+| **Module entry file** | \`src/modules/<name>/<name>.module.ts\` (filename suffix is required — see Vite HMR contract below) |
+| Env values | \`.env\` |
+| Env schema (Zod) | \`src/config/index.ts\` |
+| TypeScript config | \`tsconfig.json\` |
+| Vite config (HMR) | \`vite.config.ts\` |
+| Vitest config | \`vitest.config.ts\` |
+| Prettier config | \`.prettierrc\` |
+| CLI config | \`kick.config.ts\` |
+
+### Module Pattern (${t.toUpperCase()})
+
+> **Vite HMR auto-discovery contract:** module files **must** be named \`<name>.module.ts\` (or \`.tsx\`/\`.js\`/\`.jsx\`) and live under \`src/modules/\`. The Vite plugin scans for \`*.module.[tj]sx?\` to drive graceful HMR rebuilds; renaming a file to \`projects.ts\` (no \`.module\`) silently breaks HMR — saves trigger a full restart instead of a swap. The CLI generator (\`kick g module <name>\`) follows the convention; manual files must too.
+
+Each module in \`src/modules/<name>/\` typically contains:
+
+${t===`ddd`?`\`\`\`
+<name>/
+├── <name>.controller.ts     # HTTP routes (@Controller)
+├── <name>.service.ts        # Business logic (@Service)
+├── <name>.repository.ts     # Data access (@Repository)
+├── <name>.dto.ts            # Request/response schemas (Zod)
+├── <name>.entity.ts         # Domain entity (optional)
+└── <name>.module.ts         # Module definition (implements AppModule)
+\`\`\`
+`:t===`cqrs`?`\`\`\`
+<name>/
+├── commands/                # Write operations
+│   ├── create-<name>.command.ts
+│   └── create-<name>.handler.ts
+├── queries/                 # Read operations
+│   ├── get-<name>.query.ts
+│   └── get-<name>.handler.ts
+├── events/                  # Domain events
+│   └── <name>-created.event.ts
+├── <name>.controller.ts     # HTTP routes
+├── <name>.repository.ts     # Data access
+└── <name>.module.ts         # Module definition (implements AppModule)
+\`\`\`
+`:t===`rest`?`\`\`\`
+<name>/
+├── <name>.controller.ts     # HTTP routes (@Controller)
+├── <name>.service.ts        # Business logic (@Service)
+├── <name>.dto.ts            # Request/response schemas (Zod)
+└── <name>.module.ts         # Module definition (implements AppModule)
+\`\`\`
+`:"```\nsrc/\n├── index.ts                 # Add routes here\n└── ...                      # Custom structure\n```\n"}
+
+## Checklist: Adding a Feature
+
+### New Module (Recommended)
+
+Use the CLI generator for consistency:
+
+\`\`\`bash
+kick g module <name>              # Generate full module
+# or
+kick g scaffold <name> <fields>   # Generate CRUD from fields
+\`\`\`
+
+Then:
+- [ ] Review generated files in \`src/modules/<name>/\`
+- [ ] Verify module is registered in \`src/modules/index.ts\`
+- [ ] Update DTOs in \`<name>.dto.ts\` if needed
+- [ ] Implement business logic in \`<name>.service.ts\`
+- [ ] Run \`kick dev\` to test with HMR
+- [ ] Write tests in \`<name>.test.ts\`
+
+### Manual Controller
+
+If not using generators:
+
+- [ ] Create \`src/modules/<name>/<name>.controller.ts\`
+- [ ] Add \`@Controller()\` decorator
+- [ ] Add route handlers with \`@Get()\`, \`@Post()\`, etc.
+- [ ] Create module file implementing \`AppModule\` with \`routes()\` returning \`{ path, router: buildRoutes(Controller), controller }\`
+- [ ] Register module in \`src/modules/index.ts\` (\`AppModuleClass[]\` array)
+- [ ] Test with \`kick dev\`
+
+### Manual Service
+
+- [ ] Create \`src/modules/<name>/<name>.service.ts\`
+- [ ] Add \`@Service()\` decorator
+- [ ] Inject dependencies with \`@Autowired()\`
+- [ ] Inject via \`@Autowired()\` where needed
+- [ ] Write unit tests
+
+### New Middleware
+
+- [ ] Create \`src/middleware/<name>.middleware.ts\`
+- [ ] Export middleware function (Express format)
+- [ ] Register in \`src/index.ts\` or attach to routes with \`@Middleware()\`
+- [ ] Test with sample requests
+
+### Adding a Package
+
+Use \`kick add\` to install KickJS packages with correct peer dependencies:
+
+- [ ] Run \`kick add <package>\` (e.g., \`kick add auth\`)
+- [ ] Follow package-specific setup in terminal output
+- [ ] Update \`src/index.ts\` to register adapter (if needed)
+- [ ] Configure environment variables in \`.env\`
+- [ ] Test integration with \`kick dev\`
+
+## Common Tasks
+
+### Generate CRUD Module
+
+\`\`\`bash
+kick g scaffold user name:string email:string:optional age:number
+\`\`\`
+
+Append \`:optional\` for optional fields (shell-safe, no quoting needed).
+Quoted \`?\` syntax also works: \`"email:string?"\` or \`"email?:string"\`.
+
+This creates a full CRUD module with:
+- Controller with GET, POST, PUT, DELETE routes
+- Service with business logic
+- Repository with data access
+- DTOs with Zod validation
+
+### Add Authentication
+
+\`\`\`bash
+kick add auth
+\`\`\`
+
+Then configure in \`src/index.ts\`:
+
+\`\`\`ts
+import { AuthAdapter, JwtStrategy } from '@forinda/kickjs-auth'
+
+bootstrap({
+  modules,
+  adapters: [
+    AuthAdapter({
+      strategies: [JwtStrategy({ secret: process.env.JWT_SECRET! })],
+    }),
+  ],
+})
+\`\`\`
+
+### Add Database (Prisma)
+
+\`\`\`bash
+kick add prisma
+${n} install prisma @prisma/client
+npx prisma init
+# Edit prisma/schema.prisma
+npx prisma migrate dev --name init
+kick g module user --repo prisma
+\`\`\`
+
+### Add WebSocket Support
+
+\`\`\`bash
+kick add ws
+\`\`\`
+
+Then add adapter in \`src/index.ts\`:
+
+\`\`\`ts
+import { WsAdapter } from '@forinda/kickjs-ws'
+
+bootstrap({
+  modules,
+  adapters: [WsAdapter()],
+})
+\`\`\`
+
+Create WebSocket controller:
+
+\`\`\`bash
+kick g controller chat --ws
+\`\`\`
+
+## Testing Guidelines
+
+All tests use Vitest:
+
+\`\`\`ts
+import { describe, it, expect, beforeEach } from 'vitest'
+import { Container } from '@forinda/kickjs'
+import { createTestApp } from '@forinda/kickjs-testing'
+
+describe('UserController', () => {
+  it('should return users', async () => {
+    // Container.create() — isolated DI state per test, never new Container()
+    // and never getInstance().reset() (both leak registrations between tests).
+    const container = Container.create()
+    const app = await createTestApp([UserModule], { container })
+    const res = await app.get('/users')
+
+    expect(res.status).toBe(200)
+    expect(res.body).toHaveProperty('users')
+  })
+})
+\`\`\`
+
+Run tests:
+- \`${n} run test\` — run all tests once
+- \`${n} run test:watch\` — watch mode
+- Individual file: \`${n} run test src/modules/user/user.test.ts\`
+
+## Environment Variables
+
+Schema is declared in \`src/config/index.ts\` (extends the base
+\`PORT\`/\`NODE_ENV\`/\`LOG_LEVEL\` shape via \`defineEnv\`) and registered
+with kickjs at module load. \`src/index.ts\` imports it via
+\`import './config'\` **before** \`bootstrap()\` so the cache is populated
+in time for DI. Add new keys to the schema, drop their values into
+\`.env\`, and they're typed everywhere.
+
+Access patterns:
+
+1. **@Value() decorator** (recommended for known-at-construction keys):
+\`\`\`ts
+@Value('DATABASE_URL')
+private dbUrl!: string
+\`\`\`
+
+2. **ConfigService** (recommended for dynamic / method-scoped access):
+\`\`\`ts
+@Autowired()
+private config!: ConfigService
+
+const port = this.config.get('PORT')  // typed: number
+\`\`\`
+
+3. **Standalone utilities** (no DI — works in scripts, CLI, plain files):
+\`\`\`ts
+import { loadEnv, getEnv, reloadEnv, resetEnvCache } from '@forinda/kickjs/config'
+
+const env = loadEnv(schema)         // Parse + validate all vars
+const port = getEnv('PORT')         // Single value lookup
+reloadEnv()                         // Re-read .env from disk
+resetEnvCache()                     // Full reset (for tests)
+\`\`\`
+
+4. **Direct \`process.env\`** — avoid in app code; bypasses Zod
+   coercion and the typed \`KickEnv\` registry.
+
+> **Pitfall**: never delete \`import './config'\` from \`src/index.ts\`.
+> If the schema is not registered before DI runs, \`config.get()\`
+> returns \`undefined\` for user keys (the base shape only) and
+> \`@Value()\` only works because of its raw \`process.env\` fallback —
+> Zod coercion + schema defaults are silently skipped.
+
+## Standalone Utilities (No DI Required)
+
+These work anywhere — scripts, plain files, outside \`@Service\`/\`@Controller\`:
+
+| Utility | Import | Example |
+|---------|--------|---------|
+| \`Logger.for(name)\` | \`@forinda/kickjs\` | \`const log = Logger.for('MyScript')\` |
+| \`createLogger(name)\` | \`@forinda/kickjs\` | \`const log = createLogger('Worker')\` |
+| \`createToken<T>(name)\` | \`@forinda/kickjs\` | \`const TOKEN = createToken<string>('app/Db/url')\` |
+| \`ref(value)\` | \`@forinda/kickjs\` | \`const count = ref(0)\` |
+| \`computed(fn)\` | \`@forinda/kickjs\` | \`const doubled = computed(() => count.value * 2)\` |
+| \`watch(source, cb)\` | \`@forinda/kickjs\` | \`watch(() => count.value, (v) => log(v))\` |
+| \`reactive(obj)\` | \`@forinda/kickjs\` | \`const state = reactive({ count: 0 })\` |
+| \`HttpException\` | \`@forinda/kickjs\` | \`throw new HttpException(404, 'Not found')\` |
+| \`HttpStatus\` | \`@forinda/kickjs\` | \`HttpStatus.NOT_FOUND // 404\` |
+
+## Key Decorators
+
+### HTTP Routes
+| Decorator | Purpose |
+|-----------|---------|
+| \`@Controller()\` | Define route prefix |
+| \`@Get('/'), @Post('/')\` | HTTP method handlers |
+| \`@Middleware(fn)\` | Attach middleware |
+| \`@Public()\` | Skip auth (requires auth adapter) |
+| \`@Roles('admin')\` | Role-based access |
+
+### Dependency Injection
+| Decorator | Purpose |
+|-----------|---------|
+| \`AppModule\` interface | Define feature module (implements \`routes()\`) |
+| \`@Service()\` | Register singleton service |
+| \`@Repository()\` | Register repository |
+| \`@Autowired()\` | Property injection |
+| \`@Inject('token')\` | Token-based injection |
+| \`@Value('VAR')\` | Inject env variable |
+
+### Context Decorators
+
+Typed, ordered way to populate \`ctx.set/get\` keys before the handler runs.
+Use this **instead of \`@Middleware()\`** when the middleware's only output
+is a value other code reads off \`ctx\`.
+
+| Concept | Where it lives |
+|---------|----------------|
+| \`defineContextDecorator({ key, deps, dependsOn, optional, onError, resolve })\` | \`@forinda/kickjs\` |
+| Method/class decorator | \`@LoadX\` on a controller method/class |
+| Module hook | \`AppModule.contributors?(): ContributorRegistration[]\` |
+| Adapter hook | \`AppAdapter.contributors?(): ContributorRegistration[]\` |
+| Global registration | \`bootstrap({ contributors: [LoadX.registration] })\` |
+| Type augmentation | \`declare module '@forinda/kickjs' { interface ContextMeta { ... } }\` |
+
+Precedence high → low: **method > class > module > adapter > global**.
+Cycles and missing \`dependsOn\` keys throw at \`app.setup()\` (boot fails
+fast). The \`onError\` hook is async-permitted.
+
+Full guide: <https://forinda.github.io/kick-js/guide/context-decorators>.
+
+${t===`cqrs`?`### Background Jobs
+| Decorator | Purpose |
+|-----------|---------|
+| \`@Job('name')\` | Queue job handler |
+| \`@Process('queue')\` | Queue processor |
+| \`@Cron('0 * * * *')\` | Cron schedule |
+| \`@WsController()\` | WebSocket controller |
+
+`:``}## Common Pitfalls
+
+1. **Forgot to register module** — Add to \`src/modules/index.ts\` exports array
+2. **DI not working** — Ensure \`reflect-metadata\` is imported in \`src/index.ts\`
+3. **Tests failing randomly** — Sharing the global container between tests. Default to \`Container.create()\` per test (or per \`beforeEach\`) instead of \`new Container()\` / \`getInstance().reset()\`
+4. **Routes not found** — Check controller path and module registration
+5. **HMR not working** — Two checks: (a) \`vite.config.ts\` has \`hmr: true\`; (b) module file is named \`<name>.module.ts\` (or \`.tsx\`/\`.js\`/\`.jsx\`) and lives under \`src/modules/\`. The Vite plugin auto-discovers \`*.module.[tj]sx?\` for graceful HMR — a misnamed module file (e.g., \`projects.ts\`) silently degrades to a full restart on every save.
+6. **Decorators not working** — Check \`tsconfig.json\` has \`experimentalDecorators: true\`
+7. **\`config.get('YOUR_KEY')\` returns \`undefined\`** — \`src/index.ts\` is missing \`import './config'\`. That side-effect import registers the env schema with kickjs (\`loadEnv(envSchema)\` runs at module load). Without it, \`ConfigService\` falls back to the base schema (\`PORT\`/\`NODE_ENV\`/\`LOG_LEVEL\` only) and every user-defined key reads as \`undefined\`. \`@Value()\` may *appear* to work because of a raw \`process.env\` fallback, but Zod coercion and schema defaults are silently skipped — investigate \`src/index.ts\` and \`src/config/index.ts\` first.
+8. **Used \`@Middleware()\` to compute a value for \`ctx\`** — prefer \`defineContextDecorator()\` (see Context Decorators above). It's typed via \`ContextMeta\`, supports \`dependsOn\` for ordering, and validates the pipeline at boot. \`@Middleware()\` is for response short-circuiting, stream mutation, and pre-route-matching work.
+9. **Context contributor's \`dependsOn\` key not produced anywhere** — boot throws \`MissingContributorError\` naming the dependent and the route. Either remove the dep or register a contributor that produces the key (at any precedence level: method/class/module/adapter/global).
+10. **\`bootstrap()\` not exported** — \`src/index.ts\` calls \`await bootstrap({ ... })\` but discards the return value (no \`export const app = ...\`). Vite HMR can't locate the running instance, so module saves degrade to full restarts; \`createTestApp\`/\`@forinda/kickjs-testing\` consumers can't import the handle either. Always: \`export const app = await bootstrap({ ... })\`.
+11. **Refresh AGENTS.md / CLAUDE.md after a framework upgrade** — these files are scaffolded by the CLI and don't auto-update. Run \`kick g agents -f\` (or \`kick g agent-docs -f\`) to regenerate from the latest CLI templates after \`kick add\` / version bumps. Hand-edited sections will be overwritten — keep customisation in a separate file like \`AGENTS.local.md\`.
+
+## CLI Commands Reference
+
+| Command | Description |
+|---------|-------------|
+| \`kick dev\` | Dev server with HMR |
+| \`kick dev:debug\` | Dev server with debugger |
+| \`kick build\` | Production build |
+| \`kick start\` | Run production build |
+| \`kick g module <names...>\` | Generate one or more modules |
+| \`kick g scaffold <name> <fields>\` | Generate CRUD |
+| \`kick g controller <name>\` | Generate controller |
+| \`kick g service <name>\` | Generate service |
+| \`kick g middleware <name>\` | Generate middleware |
+| \`kick add <package>\` | Add KickJS package |
+| \`kick add --list\` | List available packages |
+| \`kick rm module <names...>\` | Remove one or more modules |
+
+> **Note:** When using \`kick new\` in scripts or CI, pass \`-t\` (or \`--template\`) and \`-r\` (or \`--repo\`) flags to bypass interactive prompts:
+> \`\`\`bash
+> kick new my-api -t ddd -r prisma --pm ${n} --no-git --no-install -f
+> \`\`\`
+
+## Learn More
+
+- [KickJS Docs](https://forinda.github.io/kick-js/)
+- [CLI Reference](https://forinda.github.io/kick-js/api/cli.html)
+- [Decorators Guide](https://forinda.github.io/kick-js/guide/decorators.html)
+- [DI System](https://forinda.github.io/kick-js/guide/dependency-injection.html)
+- [Testing](https://forinda.github.io/kick-js/api/testing.html)
+`}function Y(e,t,n){return`# kickjs-skills.md — Task Skills for AI Agents (${e})
+
+This file is the agent-facing **skills index** for KickJS work in this
+repo. Each block below is a short, rigid workflow keyed to a specific
+trigger ("user wants to add a module", "tests are leaking state", etc.).
+
+- Reference docs (narrative, exhaustive) → \`AGENTS.md\`.
+- Tool-specific notes → \`CLAUDE.md\`, \`GEMINI.md\`, etc.
+- **This file** → step-by-step recipes the agent should *execute*.
+
+Re-run \`kick g agents -f --only skills\` after framework upgrades to refresh.
+
+---
+
+## Skill: add-module
+
+\`\`\`yaml
+name: kickjs-add-module
+description: Use when the user asks to add a new feature module (controller + service + repo + DTOs).
+\`\`\`
+
+**Trigger phrases**: "add a users module", "scaffold tasks", "new feature for X".
+
+**Steps**:
+1. Run \`kick g module <name>\` (use plural form if the project pluralizes — check \`kick.config.ts\`).
+2. Verify the new folder under \`src/modules/<name>/\` contains \`<name>.module.ts\` (filename suffix is mandatory for HMR).
+3. Confirm the module appears in \`src/modules/index.ts\` exports — generator does this automatically; verify if you bypassed it.
+4. Open \`<name>.dto.ts\` and tighten the Zod schemas to real fields (the generator emits placeholders).
+5. Run \`${n} run typecheck\` and \`${n} run test\` before claiming done.
+
+**Red flags** (stop and ask):
+- File created as \`<name>.ts\` instead of \`<name>.module.ts\` — Vite won't HMR it.
+- Module not registered in \`src/modules/index.ts\`.
+- \`@Controller('/path')\` with a path argument — that's a v3 pattern; remove it (mount comes from \`routes().path\`).
+
+---
+
+## Skill: add-adapter
+
+\`\`\`yaml
+name: kickjs-add-adapter
+description: Use when wiring a new lifecycle integration (Swagger, DevTools, Auth, custom).
+\`\`\`
+
+**Steps**:
+1. \`kick g adapter <name>\` to scaffold the boilerplate, OR install via \`kick add <package>\` for first-party adapters.
+2. The generated file uses \`defineAdapter()\` — never \`class implements AppAdapter\`.
+3. Add the adapter instance to \`src/adapters/index.ts\` (don't inline in \`src/index.ts\`).
+4. If the adapter contributes to \`ctx.set/get\`, prefer \`AppAdapter.contributors?()\` over a wrapping middleware.
+5. Verify with \`kick dev\` that the adapter's lifecycle logs fire.
+
+**Red flags**:
+- Inlining the adapter list directly in \`src/index.ts\` (entry file should stay thin).
+- Returning a plain object instead of going through \`defineAdapter()\` — type inference for \`config\` will be wrong.
+
+---
+
+## Skill: write-controller-test
+
+\`\`\`yaml
+name: kickjs-write-controller-test
+description: Use when adding a Vitest test that exercises an HTTP route or DI graph.
+\`\`\`
+
+**Template** (copy/paste, adjust):
+
+\`\`\`ts
+import { describe, it, expect } from 'vitest'
+import { Container } from '@forinda/kickjs'
+import { createTestApp } from '@forinda/kickjs-testing'
+
+describe('UserController', () => {
+  it('returns users', async () => {
+    const container = Container.create()           // isolated DI per test
+    const app = await createTestApp([UserModule], { container })
+    const res = await app.get('/users')
+    expect(res.status).toBe(200)
+  })
+})
+\`\`\`
+
+**Red flags**:
+- \`new Container()\` — wrong; use \`Container.create()\`.
+- \`Container.getInstance().reset()\` — wrong; same fix.
+- Sharing a container across \`it()\` blocks — leaks registrations.
+
+---
+
+## Skill: env-wiring-check
+
+\`\`\`yaml
+name: kickjs-env-wiring-check
+description: Use when ConfigService.get('SOME_KEY') returns undefined or @Value silently falls back to process.env.
+\`\`\`
+
+**Diagnosis**:
+1. Open \`src/index.ts\`. The **first non-\`reflect-metadata\`** import MUST be \`import './config'\`.
+2. Open \`src/config/index.ts\`. It MUST call \`loadEnv(envSchema)\` as a top-level side effect.
+3. The new key MUST be declared in the Zod schema there. \`@Value('NEW_KEY')\` won't work without a schema entry (it'll fall back to raw \`process.env\` and skip Zod coercion silently).
+
+**Fix**: add the key to the schema; ensure both side-effect imports above are present.
+
+---
+
+## Skill: bootstrap-export
+
+\`\`\`yaml
+name: kickjs-bootstrap-export
+description: Use when HMR is silently doing full restarts on every save, or createTestApp can't find the app handle.
+\`\`\`
+
+**Check** \`src/index.ts\`'s last line:
+
+\`\`\`ts
+// CORRECT
+export const app = await bootstrap({ ... })
+
+// WRONG (HMR degrades to full restart, createTestApp loses the handle)
+await bootstrap({ ... })
+\`\`\`
+
+The Vite plugin imports the named \`app\` symbol; testing helpers do too.
+
+---
+
+## Skill: thin-entry-file
+
+\`\`\`yaml
+name: kickjs-thin-entry-file
+description: Use when src/index.ts is accumulating module/middleware/plugin/adapter literals.
+\`\`\`
+
+**Refactor target**:
+
+\`\`\`ts
+// src/modules/index.ts
+export const modules: AppModuleClass[] = [HelloModule, UsersModule, ...]
+
+// src/middleware/index.ts
+export const middleware = [helmet(), cors(), requestId(), ...]
+
+// src/plugins/index.ts
+export const plugins = [MetricsPlugin(), ...]
+
+// src/adapters/index.ts
+export const adapters = [SwaggerAdapter({ ... }), DevToolsAdapter()]
+
+// src/index.ts — stays small
+import 'reflect-metadata'
+import './config'
+import { bootstrap } from '@forinda/kickjs'
+import { modules } from './modules'
+import { middleware } from './middleware'
+import { plugins } from './plugins'
+import { adapters } from './adapters'
+export const app = await bootstrap({ modules, middleware, plugins, adapters })
+\`\`\`
+
+**Red flags**: any \`new SomeAdapter()\` or \`SomePlugin()\` literal inside \`bootstrap({ ... })\` instead of imported from a category folder.
+
+---
+
+## Skill: context-contributor
+
+\`\`\`yaml
+name: kickjs-context-contributor
+description: Use when a middleware's only job is to set ctx values consumed elsewhere — replace with defineHttpContextDecorator (HTTP) or defineContextDecorator (transport-agnostic).
+\`\`\`
+
+**Pattern** (HTTP — most common):
+
+\`\`\`ts
+import { defineHttpContextDecorator, type RequestContext } from '@forinda/kickjs'
+
+const LoadTenant = defineHttpContextDecorator({
+  key: 'tenant',
+  deps: { repo: TENANT_REPO },
+  resolve: (ctx, { repo }) => repo.findById(ctx.req.headers['x-tenant-id'] as string),
+})
+
+const LoadProject = defineHttpContextDecorator({
+  key: 'project',
+  dependsOn: ['tenant'],
+  resolve: (ctx) => projectsRepo.find(ctx.get('tenant')!.id, ctx.params.id),
+})
+
+@LoadTenant
+@LoadProject
+@Get('/projects/:id')
+getProject(ctx: RequestContext) { ctx.json(ctx.get('project')) }
+\`\`\`
+
+Use \`defineContextDecorator\` (no Http prefix) when authoring a contributor that must run across HTTP, WebSocket, queue, and cron transports — \`Ctx\` defaults to the smaller \`ExecutionContext\` surface (\`get\` / \`set\` / \`requestId\` only, no \`req\`).
+
+Precedence high → low: **method > class > module > adapter > global**.
+Cycles or unmet \`dependsOn\` keys throw \`MissingContributorError\` at boot.
+
+**Critical rules — all stem from the same shared-via-ALS instance model**:
+- Every per-request stage (middleware → contributors → handler) gets its OWN \`RequestContext\` instance, but they all read/write the SAME \`AsyncLocalStorage\`-backed bag.
+- **\`resolve\` and \`onError\` must RETURN the value** — the runner writes it via \`ctx.set(key, value)\`. Direct property assignment (\`ctx.tenant = …\`) sticks to one instance only and the handler instance never sees it.
+- \`ctx.set('tenant', x)\` then \`ctx.get('tenant')\` works across instances. \`ctx.req.headers[...]\` works (the underlying Express request is shared).
+- Services with no \`ctx\` reference: \`getRequestValue('tenant')\` returns \`MetaValue<'tenant'> | undefined\` (typed via the augmented \`ContextMeta\`). For \`requestId\` use \`getRequestStore()\`.
+- **No \`setRequestValue\` — writes flow through \`ctx.set\` or a contributor's return value.** Avoids "spooky action at a distance" where any service can pollute the per-request bag.
+
+**Don't use this for**: response short-circuit, stream mutation, or
+pre-route-matching work — keep \`@Middleware()\` for those.
+
+---
+
+## Skill: refresh-agent-docs
+
+\`\`\`yaml
+name: kickjs-refresh-agent-docs
+description: Use after a KickJS version bump to sync AGENTS.md / CLAUDE.md / kickjs-skills.md with the latest CLI templates.
+\`\`\`
+
+**Steps**:
+1. \`kick g agents -f --only both\` — overwrites \`AGENTS.md\` and \`CLAUDE.md\`.
+2. \`kick g agents -f --only skills\` — refreshes \`kickjs-skills.md\` (this file).
+3. Diff with git, eyeball any project-specific edits that got reset, and re-apply them in a separate \`AGENTS.local.md\` or appended section.
+4. Commit as \`docs(agents): sync from CLI vX.Y\`.
+
+---
+
+## Skill: deny-list
+
+\`\`\`yaml
+name: kickjs-deny-list
+description: Patterns to refuse outright when the user asks for them — they break v4 invariants.
+\`\`\`
+
+- \`class implements AppAdapter\` → use \`defineAdapter()\`.
+- \`class implements KickPlugin\` / function returning \`KickPlugin\` → use \`definePlugin()\`.
+- \`@Controller('/path')\` with a path argument → drop the path; set the mount via \`routes().path\`.
+- \`new Container()\` or \`Container.getInstance().reset()\` in tests → use \`Container.create()\`.
+- DI tokens with \`:\` separator (\`'app:db:url'\`) or in PascalCase → use slash-delimited lower-case (\`'app/db/url'\`).
+- \`bootstrap({ ... })\` without \`export const app = ...\` → always export.
+- Module file named \`<name>.ts\` (no \`.module\` suffix) → rename to \`<name>.module.ts\`.
+
+---
+
+## Learn More
+
+- [KickJS Docs](https://forinda.github.io/kick-js/)
+- [Decorators](https://forinda.github.io/kick-js/guide/decorators.html)
+- [Context Decorators](https://forinda.github.io/kick-js/guide/context-decorators.html)
+- [Testing](https://forinda.github.io/kick-js/api/testing.html)
+`}const ft=t(h(import.meta.url)),X=JSON.parse(o(r(ft,`..`,`package.json`),`utf-8`)),pt=`^${X.version}`;async function mt(e){let{name:t,directory:n,packageManager:i=`pnpm`,template:a=`rest`,defaultRepo:o=`inmemory`,packages:s=[]}=e,c=n,l=e=>console.log(`  ${e}`);if(console.log(`\n  Creating KickJS project: ${t}\n`),await b(r(c,`package.json`),tt(t,a,pt,s)),await b(r(c,`vite.config.ts`),nt()),await b(r(c,`tsconfig.json`),rt()),await b(r(c,`.prettierrc`),it()),await b(r(c,`.editorconfig`),at()),await b(r(c,`.gitignore`),ot()),await b(r(c,`.gitattributes`),st()),await b(r(c,`.env`),ct()),await b(r(c,`.env.example`),lt()),await b(r(c,`src/config/index.ts`),Ne()),await b(r(c,`src/index.ts`),je(t,a,X.version,s)),await b(r(c,`src/modules/index.ts`),Me()),await b(r(c,`src/modules/hello/hello.service.ts`),Pe()),await b(r(c,`src/modules/hello/hello.controller.ts`),Fe()),await b(r(c,`src/modules/hello/hello.module.ts`),Ie()),await b(r(c,`kick.config.ts`),Le(a,o,i)),await b(r(c,`vitest.config.ts`),ut()),await b(r(c,`README.md`),dt(t,a,i)),await b(r(c,`CLAUDE.md`),q(t,a,i)),await b(r(c,`AGENTS.md`),J(t,a,i)),await b(r(c,`kickjs-skills.md`),Y(t,a,i)),e.installDeps){console.log(`\n  Installing dependencies with ${i}...\n`);try{m(`${i} install`,{cwd:c,stdio:`inherit`}),console.log(`
+  Dependencies installed successfully!`)}catch{console.log(`\n  Warning: ${i} install failed. Run it manually.`)}}try{let{runTypegen:e}=await import(`./typegen-CBI7dNXr.mjs`).then(e=>e.n);await e({cwd:c,allowDuplicates:!0,silent:!0})}catch{}if(e.initGit)try{m(`git init`,{cwd:c,stdio:`pipe`}),m(`git branch -M main`,{cwd:c,stdio:`pipe`}),m(`git add -A`,{cwd:c,stdio:`pipe`}),m(`git commit -m "chore: initial commit from kick new"`,{cwd:c,stdio:`pipe`}),l(`Git repository initialized`)}catch{l(`Warning: git init failed (git may not be installed)`)}console.log(`
+  Project scaffolded successfully!`),console.log();let u=c!==process.cwd();l(`Next steps:`),u&&l(`  cd ${t}`),e.installDeps||l(`  ${i} install`);let d={rest:`kick g module user`,ddd:`kick g module user --repo drizzle`,cqrs:`kick g module user --pattern cqrs`,minimal:`# add your routes to src/index.ts`};l(`  ${d[a]??d.rest}`),l(`  kick dev`),l(``),l(`Commands:`),l(`  kick dev                  Start dev server with Vite HMR`),l(`  kick build                Production build via Vite`),l(`  kick start                Run production build`),l(``),l(`Generators:`),l(`  kick g module <name>      Full DDD module (controller, DTOs, use-cases, repo)`),l(`  kick g scaffold <n> <f..> CRUD module from field definitions`),l(`  kick g controller <name>  Standalone controller`),l(`  kick g service <name>     @Service() class`),l(`  kick g middleware <name>   Express middleware`),l(`  kick g guard <name>       Route guard (auth, roles, etc.)`),l(`  kick g adapter <name>     AppAdapter with lifecycle hooks`),l(`  kick g dto <name>         Zod DTO schema`),a===`cqrs`&&l(`  kick g job <name>         Queue job processor`),l(`  kick g config             Generate kick.config.ts`),l(``),l(`Add packages:`),l(`  kick add <pkg>            Install a KickJS package + peers`),l(`  kick add --list           Show all available packages`),l(``),l(`Available: auth, swagger, drizzle, prisma, ws, queue, devtools, mcp, testing`),l(``)}function ht(e){return e}function gt(e){return k(e).replace(/-/g,`_`)}function Z(e){let t=e.cwd??process.cwd(),n=e.pluralize??!0,r=D(e.name),i=O(e.name),a=k(e.name),o=gt(e.name),s={name:e.name,pascal:r,camel:i,kebab:a,snake:o,modulesDir:e.modulesDir??`src/modules`,cwd:t,args:e.args??[],flags:e.flags??{}};if(n){let e=A(a);s.pluralKebab=e,s.pluralPascal=D(e),s.pluralCamel=O(e)}return s}function _t(e,t){return i(e.cwd,t)}async function vt(e){return import(g(e).href)}const Q=new Map;async function $(e){let t=Q.get(e);if(t)return t;let n=yt(e);return Q.set(e,n),n}async function yt(n){let r=i(n,`package.json`);if(!a(r))return{generators:[],loaded:[],failed:[]};let o=bt(JSON.parse(await l(r,`utf-8`))),s=e(i(n,`package.json`)),c=[],u=[],d=[];for(let e of o){let n;try{n=s.resolve(`${e}/package.json`)}catch{continue}let r;try{r=JSON.parse(await l(n,`utf-8`))}catch(t){d.push({source:e,reason:`failed to parse package.json: ${t}`});continue}if(!r.kickjs?.generators)continue;let o=r.kickjs.generators,f=i(t(n),o);if(!a(f)){d.push({source:e,reason:`kickjs.generators points to missing file: ${o}`});continue}let p;try{p=await vt(f)}catch(t){d.push({source:e,reason:`failed to import manifest: ${t}`});continue}let m=p.default;if(!Array.isArray(m)){d.push({source:e,reason:`manifest's default export is not an array of GeneratorSpec`});continue}for(let t of m){if(!xt(t)){d.push({source:e,reason:`manifest entry is not a valid GeneratorSpec (missing name/files)`});continue}c.push({source:e,spec:t})}u.push(e)}return{generators:c,loaded:u,failed:d}}function bt(e){let t=new Set;for(let n of[e.dependencies,e.devDependencies,e.peerDependencies])if(n)for(let e of Object.keys(n))t.add(e);return Array.from(t)}function xt(e){if(!e||typeof e!=`object`)return!1;let t=e;return typeof t.name==`string`&&typeof t.files==`function`}async function St(e,t=[]){let n=e.cwd??process.cwd(),r=t.find(t=>t.spec.name===e.generatorName);if(r)return Tt(r.spec,r.source,e,n);let i=wt(await $(n),e.generatorName);return i?Tt(i.spec,i.source,e,n):null}async function Ct(e,t=[]){let n=await $(e),r=new Set(t.map(e=>e.spec.name)),i=n.generators.filter(e=>!r.has(e.spec.name));return{generators:[...t,...i],loaded:n.loaded,failed:n.failed}}function wt(e,t){return e.generators.find(e=>e.spec.name===t)}async function Tt(e,t,n,r){let i=Z({name:n.itemName,args:n.args,flags:n.flags,modulesDir:n.modulesDir,pluralize:n.pluralize,cwd:r}),a=await e.files(i),o=[];for(let e of a){let t=_t(i,e.path);await b(t,e.content),o.push(t)}return{files:o,source:t}}export{ie as A,oe as C,le as D,se as E,b as F,ae as M,C as N,de as O,v as P,T as S,ue as T,A as _,mt as a,k as b,Y as c,Ze as d,Xe as f,He as g,Ue as h,ht as i,f as j,ce as k,$e as l,Ge as m,St as n,J as o,Ye as p,Z as r,q as s,Ct as t,Qe as u,j as v,E as w,D as x,O as y};
+//# sourceMappingURL=generator-extension-Cp5FUUAw.mjs.map