@forinda/kickjs-cli 5.2.0 → 5.2.3

package/dist/builtins-BdvmVAJ1.mjs

@@ -0,0 +1,3740 @@
+/**
+ * @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{t as e}from"./rolldown-runtime-B6QC8dMY.mjs";import{a as t,i as n,r,t as i}from"./config-Dzw8Ws4d.mjs";import{n as a,r as o}from"./plugin-Dv2gKsuC.mjs";import{a as s,i as c,o as l,r as u,s as d,t as f}from"./typegen-C6ZfoYTC.mjs";import{createRequire as p}from"node:module";import{cpSync as m,existsSync as h,mkdirSync as g,readFileSync as _,readdirSync as ee,rmSync as te,statSync as ne,writeFileSync as re}from"node:fs";import v,{basename as ie,dirname as y,extname as ae,isAbsolute as oe,join as b,relative as x,resolve as S,sep as se}from"node:path";import{fileURLToPath as ce,pathToFileURL as C}from"node:url";import{execSync as w,fork as le,spawn as ue,spawnSync as de}from"node:child_process";import{access as fe,mkdir as pe,readFile as T,rm as me,writeFile as E}from"node:fs/promises";import*as D from"@clack/prompts";import O from"picocolors";import he from"pluralize";import{glob as ge}from"glob";import{groupAssetKeys as _e}from"@forinda/kickjs";import{arch as ve,platform as ye,release as be}from"node:os";import{generate as xe,migrateDown as Se,migrateLatest as Ce,migrateRollback as we,migrateStatus as Te,migrateUp as Ee,renderSchemaSource as De,resolveDbConfig as Oe}from"@forinda/kickjs-db";function ke(e,t,n){w(e,{cwd:t,stdio:`inherit`,env:n?{...process.env,...n}:process.env})}function Ae(e,t,n){let r=de(process.execPath,[e],{cwd:n,stdio:`inherit`,env:{...process.env,...t}});r.status!==0&&process.exit(r.status??1)}let je=!1;function k(e){je=e}const Me=new Set([`.ts`,`.tsx`,`.js`,`.jsx`,`.mjs`,`.cjs`,`.json`,`.md`]);async function A(e,t){je||(await pe(y(e),{recursive:!0}),await E(e,t,`utf-8`),Me.has(ae(e))&&await Pe(e,t).catch(()=>{}))}let j;async function Ne(e){if(j!==void 0)return j;try{j=await import(p(b(e,`package.json`)).resolve(`oxfmt`))}catch{j=null}return j}async function Pe(e,t){let n=await Ne(process.cwd());if(!n)return;let r=await Fe(e);if(r===null)return;let i=await n.format(e,t,r);i.code!==t&&await E(e,i.code,`utf-8`)}const M=new Map;async function Fe(e){let t=y(e),n=t;if(M.has(n))return M.get(n);for(;;){let e=b(t,`.oxfmtrc.json`);if(h(e))try{let t=await T(e,`utf-8`),r=JSON.parse(t);return delete r.$schema,delete r.ignorePatterns,M.set(n,r),r}catch{return M.set(n,null),null}let r=y(t);if(r===t)return M.set(n,null),null;t=r}}async function N(e){try{return await fe(e),!0}catch{return!1}}const Ie={auth:`@forinda/kickjs-auth`,swagger:`@forinda/kickjs-swagger`,ws:`@forinda/kickjs-ws`,queue:`@forinda/kickjs-queue`,devtools:`@forinda/kickjs-devtools`};function Le(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=Ie[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 Re(){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 ze(){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 Be(){return JSON.stringify({semi:!1,singleQuote:!0,trailingComma:`all`,printWidth:100,tabWidth:2},null,2)}function Ve(){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 He(){return`node_modules/
+dist/
+.env
+coverage/
+.DS_Store
+*.tsbuildinfo
+.kickjs/
+`}function Ue(){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 We(){return`PORT=3000
+NODE_ENV=development
+`}function Ge(){return`PORT=3000
+NODE_ENV=development
+`}function Ke(){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 qe(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 Je(){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 Ye(){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 Xe(){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 Ze(){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 Qe(){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 $e(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'],
+    },
+  ],
+})
+`}function et(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 tt(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 nt(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 rt(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 it=y(ce(import.meta.url)),at=JSON.parse(_(b(it,`..`,`package.json`),`utf-8`)),ot=`^${at.version}`;async function st(e){let{name:t,directory:n,packageManager:r=`pnpm`,template:i=`rest`,defaultRepo:a=`inmemory`,packages:o=[]}=e,s=n,c=e=>console.log(`  ${e}`);if(console.log(`\n  Creating KickJS project: ${t}\n`),await A(b(s,`package.json`),Le(t,i,ot,o)),await A(b(s,`vite.config.ts`),Re()),await A(b(s,`tsconfig.json`),ze()),await A(b(s,`.prettierrc`),Be()),await A(b(s,`.editorconfig`),Ve()),await A(b(s,`.gitignore`),He()),await A(b(s,`.gitattributes`),Ue()),await A(b(s,`.env`),We()),await A(b(s,`.env.example`),Ge()),await A(b(s,`src/config/index.ts`),Ye()),await A(b(s,`src/index.ts`),qe(t,i,at.version,o)),await A(b(s,`src/modules/index.ts`),Je()),await A(b(s,`src/modules/hello/hello.service.ts`),Xe()),await A(b(s,`src/modules/hello/hello.controller.ts`),Ze()),await A(b(s,`src/modules/hello/hello.module.ts`),Qe()),await A(b(s,`kick.config.ts`),$e(i,a,r)),await A(b(s,`vitest.config.ts`),Ke()),await A(b(s,`README.md`),et(t,i,r)),await A(b(s,`CLAUDE.md`),tt(t,i,r)),await A(b(s,`AGENTS.md`),nt(t,i,r)),await A(b(s,`kickjs-skills.md`),rt(t,i,r)),e.installDeps){console.log(`\n  Installing dependencies with ${r}...\n`);try{w(`${r} install`,{cwd:s,stdio:`inherit`}),console.log(`
+  Dependencies installed successfully!`)}catch{console.log(`\n  Warning: ${r} install failed. Run it manually.`)}}try{let{runTypegen:e}=await import(`./typegen-C6ZfoYTC.mjs`).then(e=>e.n);await e({cwd:s,allowDuplicates:!0,silent:!0})}catch{}if(e.initGit)try{w(`git init`,{cwd:s,stdio:`pipe`}),w(`git branch -M main`,{cwd:s,stdio:`pipe`}),w(`git add -A`,{cwd:s,stdio:`pipe`}),w(`git commit -m "chore: initial commit from kick new"`,{cwd:s,stdio:`pipe`}),c(`Git repository initialized`)}catch{c(`Warning: git init failed (git may not be installed)`)}console.log(`
+  Project scaffolded successfully!`),console.log();let l=s!==process.cwd();c(`Next steps:`),l&&c(`  cd ${t}`),e.installDeps||c(`  ${r} install`);let u={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`};c(`  ${u[i]??u.rest}`),c(`  kick dev`),c(``),c(`Commands:`),c(`  kick dev                  Start dev server with Vite HMR`),c(`  kick build                Production build via Vite`),c(`  kick start                Run production build`),c(``),c(`Generators:`),c(`  kick g module <name>      Full DDD module (controller, DTOs, use-cases, repo)`),c(`  kick g scaffold <n> <f..> CRUD module from field definitions`),c(`  kick g controller <name>  Standalone controller`),c(`  kick g service <name>     @Service() class`),c(`  kick g middleware <name>   Express middleware`),c(`  kick g guard <name>       Route guard (auth, roles, etc.)`),c(`  kick g adapter <name>     AppAdapter with lifecycle hooks`),c(`  kick g dto <name>         Zod DTO schema`),i===`cqrs`&&c(`  kick g job <name>         Queue job processor`),c(`  kick g config             Generate kick.config.ts`),c(``),c(`Add packages:`),c(`  kick add <pkg>            Install a KickJS package + peers`),c(`  kick add --list           Show all available packages`),c(``),c(`Available: auth, swagger, drizzle, prisma, ws, queue, devtools, mcp, testing`),c(``)}const ct={GET:O.green,POST:O.cyan,PUT:O.yellow,PATCH:O.magenta,DELETE:O.red};function lt(e){return(ct[e]??O.dim)(e.padEnd(7))}function ut(e){let t=`[${e}]`.padEnd(10);switch(e){case`CRITICAL`:return O.red(t);case`WARNING`:return O.yellow(t);case`INFO`:return O.blue(O.dim(t));default:return t}}O.green(`✓`),O.red(`✖`),O.yellow(`⚠`),O.blue(`ℹ`);function dt(e){D.intro(O.bgCyan(O.black(` ${e} `)))}function P(e){D.outro(e)}function ft(e){D.isCancel(e)&&(D.cancel(`Operation cancelled.`),process.exit(0))}async function pt(e){let t=await D.text(e);return ft(t),t}async function mt(e){let t=await D.select(e);return ft(t),t}async function ht(e){let t=await D.multiselect(e);return ft(t),t}async function F(e){let t=await D.confirm(e);return ft(t),t}function gt(){return D.spinner()}const I=D.log,_t={kickjs:{pkg:`@forinda/kickjs`,peers:[`express`],description:`Unified framework: DI, decorators, routing, middleware`,core:!0},vite:{pkg:`@forinda/kickjs-vite`,peers:[`vite`],description:`Vite plugin: dev server, HMR, module discovery`,dev:!0,core:!0},cli:{pkg:`@forinda/kickjs-cli`,peers:[],description:`CLI tool and code generators`,dev:!0,core:!0},swagger:{pkg:`@forinda/kickjs-swagger`,peers:[],description:`OpenAPI spec + Swagger UI + ReDoc`},db:{pkg:`@forinda/kickjs-db`,peers:[],description:`kick/db core — schema DSL, migrations, KickDbClient, customType`},"db-pg":{pkg:`@forinda/kickjs-db-pg`,peers:[`pg`],description:`kick/db PostgreSQL dialect + adapter (pgDialect, pgAdapter)`},drizzle:{pkg:`@forinda/kickjs-drizzle`,peers:[`drizzle-orm`],description:`Drizzle ORM adapter + query builder`},prisma:{pkg:`@forinda/kickjs-prisma`,peers:[`@prisma/client`],description:`Prisma adapter + query builder`},ws:{pkg:`@forinda/kickjs-ws`,peers:[`socket.io`],description:`WebSocket with @WsController decorators`},devtools:{pkg:`@forinda/kickjs-devtools`,peers:[],description:`Development dashboard — routes, DI, metrics, health`,dev:!0},auth:{pkg:`@forinda/kickjs-auth`,peers:[`jsonwebtoken`],description:`Authentication — JWT, API key, and custom strategies`},queue:{pkg:`@forinda/kickjs-queue`,peers:[],description:`Queue adapter (BullMQ/RabbitMQ/Kafka)`},"queue:bullmq":{pkg:`@forinda/kickjs-queue`,peers:[`bullmq`,`ioredis`],description:`Queue with BullMQ + Redis`},"queue:rabbitmq":{pkg:`@forinda/kickjs-queue`,peers:[`amqplib`],description:`Queue with RabbitMQ`},"queue:kafka":{pkg:`@forinda/kickjs-queue`,peers:[`kafkajs`],description:`Queue with Kafka`},mcp:{pkg:`@forinda/kickjs-mcp`,peers:[`@modelcontextprotocol/sdk`],description:`Model Context Protocol server — expose @Controller endpoints as AI tools`},testing:{pkg:`@forinda/kickjs-testing`,peers:[],description:`Test utilities and TestModule builder`,dev:!0}};function L(e,t=process.cwd()){let n=t;for(;;){if(h(S(n,e)))return n;let t=y(n);if(t===n)return null;n=t}}function vt(){return L(`pnpm-lock.yaml`)?`pnpm`:L(`yarn.lock`)?`yarn`:L(`bun.lockb`)||L(`bun.lock`)?`bun`:L(`package-lock.json`)?`npm`:null}function yt(){let e=process.cwd();for(;e;){let t=S(e,`package.json`);if(h(t))try{let e=JSON.parse(_(t,`utf-8`)).packageManager;if(typeof e==`string`){let t=e.split(`@`)[0];if(i.includes(t))return t}}catch{}let n=y(e);if(n===e)return null;e=n}return null}async function bt(e){if(e&&i.includes(e))return{pm:e,source:`flag`};let t=await r(process.cwd());if(t?.packageManager&&i.includes(t.packageManager))return{pm:t.packageManager,source:`config`};let n=yt();if(n)return{pm:n,source:`package.json`};let a=vt();return a?{pm:a,source:`lockfile`}:{pm:`npm`,source:`default`}}async function xt(e){let{pm:t}=await bt(e);return t}function St(e=!1){let t=Object.entries(_t),n=Math.max(...t.map(([e])=>e.length)),r=t.filter(([,e])=>e.core),i=t.filter(([,e])=>!e.core),a=([e,t])=>{let r=e.padEnd(n+2),i=t.peers.length?` (+ ${t.peers.join(`, `)})`:``;return`    ${r} ${t.description}${i}`};console.log(`
+  Core packages (always installed by \`kick new\`):
+`);for(let e of r)console.log(a(e));if(e){console.log(`
+  Optional packages (add as needed):
+`);for(let e of i)console.log(a(e))}else console.log(`\n  Plus ${i.length} optional packages (auth, swagger, db, queue, …).`),console.log("  Run `kick add --list --all` for the full catalog.");console.log(`
+  Usage: kick add auth drizzle swagger`),console.log(`         kick add queue:bullmq`),console.log()}function Ct(e){e.command(`list`).alias(`ls`).description(`List KickJS packages (core only; pair with --all for the full catalog)`).option(`--all`,`Include the full optional catalog`).action(e=>{St(!!e.all)})}function wt(e){e.command(`add [packages...]`).description(`Add KickJS packages with their required dependencies`).option(`--pm <manager>`,`Package manager override`).option(`-D, --dev`,`Install as dev dependency`).option(`--list`,`List packages (core only by default; pair with --all)`).option(`--all`,`When listing, include the full optional catalog`).action(async(e,t)=>{if(t.list||e.length===0){St(!!t.all);return}let{pm:n,source:r}=await bt(t.pm);console.log(`\n  Using ${n} (resolved from ${r})`);let i=t.dev,a=new Set,o=new Set,s=[];for(let t of e){let e=_t[t];if(!e){s.push(t);continue}let n=i||e.dev?o:a;n.add(e.pkg);for(let t of e.peers)n.add(t)}if(!(s.length>0&&(console.log(`\n  Unknown packages: ${s.join(`, `)}`),console.log(`  Run "kick add --list" to see available packages.
+`),a.size===0&&o.size===0))){if(a.size>0){let e=Array.from(a),t=`${n} add ${e.join(` `)}`;console.log(`\n  Installing ${e.length} dependency(ies):`);for(let t of e)console.log(`    + ${t}`);console.log();try{w(t,{stdio:`inherit`})}catch{console.log(`\n  Installation failed. Run manually:\n    ${t}\n`)}}if(o.size>0){let e=Array.from(o),t=`${n} add -D ${e.join(` `)}`;console.log(`\n  Installing ${e.length} dev dependency(ies):`);for(let t of e)console.log(`    + ${t} (dev)`);console.log();try{w(t,{stdio:`inherit`})}catch{console.log(`\n  Installation failed. Run manually:\n    ${t}\n`)}}console.log(`  Done!
+`)}})}const Tt=[{value:`auth`,label:`Auth`,hint:`JWT, OAuth, API keys`},{value:`swagger`,label:`Swagger`,hint:`OpenAPI docs`},{value:`ws`,label:`WebSocket`,hint:`rooms, heartbeat`},{value:`queue`,label:`Queue`,hint:`BullMQ/RabbitMQ/Kafka`},{value:`devtools`,label:`DevTools`,hint:`debug dashboard`}];function Et(e){e.command(`new [name]`).alias(`init`).description(`Create a new KickJS project (use "." for current directory)`).option(`-d, --directory <dir>`,`Target directory (defaults to project name)`).option(`--pm <manager>`,`Package manager: pnpm | npm | yarn | bun`).option(`--git`,`Initialize git repository`).option(`--no-git`,`Skip git initialization`).option(`--install`,`Install dependencies after scaffolding`).option(`--no-install`,`Skip dependency installation`).option(`-f, --force`,`Remove existing files without prompting`).option(`-t, --template <type>`,`Project template: rest | ddd | cqrs | minimal`).option(`-r, --repo <type>`,`Default repository: prisma | drizzle | inmemory | custom`).option(`--packages <packages>`,`Comma-separated packages to include (e.g. auth,swagger,ws,queue)`).option(`-y, --yes`,`Pick safe defaults for every prompt (template=minimal, repo=inmemory, no extras, git+install on)`).option(`--non-interactive`,`alias for --yes`).action(async(e,t)=>{dt(`KickJS — Create a new project`);let n=!!(t.yes||t.nonInteractive);e||=n?`my-api`:await pt({message:`Project name`,placeholder:`my-api`,defaultValue:`my-api`});let r;if(e===`.`?(r=S(`.`),e=ie(r)):r=S(t.directory||e),h(r)){let i=ee(r);if(i.length>0){if(t.force)I.warn(`Clearing existing files in ${r}`);else if(n){I.warn(`Directory "${e}" is not empty. Pass --force to clear it.`),P(`Aborted.`);return}else{I.warn(`Directory "${e}" is not empty:`);let t=i.slice(0,5);for(let e of t)I.message(`  - ${e}`);if(i.length>5&&I.message(`  ... and ${i.length-5} more`),!await F({message:O.red(`Remove all existing files and proceed?`),initialValue:!1})){P(`Aborted.`);return}}for(let e of i)te(S(r,e),{recursive:!0,force:!0})}}let i=t.template;i||=n?`minimal`:await mt({message:`Project template`,options:[{value:`rest`,label:`REST API`,hint:`Express + Swagger`},{value:`ddd`,label:`DDD`,hint:`Domain-Driven Design modules`},{value:`cqrs`,label:`CQRS`,hint:`Commands, Queries, Events + WS/Queue`},{value:`minimal`,label:`Minimal`,hint:`bare Express`}]});let a=t.pm;a||=n?await xt(void 0):await mt({message:`Package manager`,options:[{value:`pnpm`,label:`pnpm`},{value:`npm`,label:`npm`},{value:`yarn`,label:`yarn`},{value:`bun`,label:`bun`}]});let o=t.repo;o||(n?o=`inmemory`:(o=await mt({message:`Default repository/ORM`,options:[{value:`prisma`,label:`Prisma`},{value:`drizzle`,label:`Drizzle`},{value:`inmemory`,label:`In-Memory`},{value:`custom`,label:`Custom`,hint:`specify later`}]}),o===`custom`&&(o=await pt({message:`Custom repository name`,defaultValue:`custom`}))));let s;if(t.packages!==void 0){let e=t.packages.trim().toLowerCase();s=e===``||e===`none`||e===`false`?[]:t.packages.split(`,`).map(e=>e.trim()).filter(Boolean)}else s=n?[]:await ht({message:`Select packages to include`,options:[...Tt],required:!1});let c;c=t.git===void 0?n?!0:await F({message:`Initialize git repository?`,initialValue:!0}):t.git;let l;l=t.install===void 0?n?!0:await F({message:`Install dependencies?`,initialValue:!0}):t.install,await st({name:e,directory:r,packageManager:a,initGit:c,installDeps:l,template:i,defaultRepo:o,packages:s}),P(`Done! Next steps: ${O.cyan(`cd ${e} && ${a} dev`)}`)})}function R(e){return e.replace(/[-_\s]+(.)?/g,(e,t)=>t?t.toUpperCase():``).replace(/^(.)/,e=>e.toUpperCase())}function z(e){let t=R(e);return t.charAt(0).toLowerCase()+t.slice(1)}function B(e){return e.replace(/([a-z])([A-Z])/g,`$1-$2`).replace(/[\s_]+/g,`-`).toLowerCase()}function V(e){return he.plural(e)}function Dt(e){return he.plural(e)}function Ot(e){return B(e).replace(/-/g,`_`)}function kt(e){let t=e.cwd??process.cwd(),n=e.pluralize??!0,r=R(e.name),i=z(e.name),a=B(e.name),o=Ot(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=V(a);s.pluralKebab=e,s.pluralPascal=R(e),s.pluralCamel=z(e)}return s}function At(e,t){return S(e.cwd,t)}async function jt(e){return import(C(e).href)}const Mt=new Map;async function Nt(e){let t=Mt.get(e);if(t)return t;let n=Pt(e);return Mt.set(e,n),n}async function Pt(e){let t=S(e,`package.json`);if(!h(t))return{generators:[],loaded:[],failed:[]};let n=Ft(JSON.parse(await T(t,`utf-8`))),r=p(S(e,`package.json`)),i=[],a=[],o=[];for(let e of n){let t;try{t=r.resolve(`${e}/package.json`)}catch{continue}let n;try{n=JSON.parse(await T(t,`utf-8`))}catch(t){o.push({source:e,reason:`failed to parse package.json: ${t}`});continue}if(!n.kickjs?.generators)continue;let s=n.kickjs.generators,c=S(y(t),s);if(!h(c)){o.push({source:e,reason:`kickjs.generators points to missing file: ${s}`});continue}let l;try{l=await jt(c)}catch(t){o.push({source:e,reason:`failed to import manifest: ${t}`});continue}let u=l.default;if(!Array.isArray(u)){o.push({source:e,reason:`manifest's default export is not an array of GeneratorSpec`});continue}for(let t of u){if(!It(t)){o.push({source:e,reason:`manifest entry is not a valid GeneratorSpec (missing name/files)`});continue}i.push({source:e,spec:t})}a.push(e)}return{generators:i,loaded:a,failed:o}}function Ft(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 It(e){if(!e||typeof e!=`object`)return!1;let t=e;return typeof t.name==`string`&&typeof t.files==`function`}async function Lt(e,t=[]){let n=e.cwd??process.cwd(),r=t.find(t=>t.spec.name===e.generatorName);if(r)return Bt(r.spec,r.source,e,n);let i=zt(await Nt(n),e.generatorName);return i?Bt(i.spec,i.source,e,n):null}async function Rt(e,t=[]){let n=await Nt(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 zt(e,t){return e.generators.find(e=>e.spec.name===t)}async function Bt(e,t,n,r){let i=kt({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=At(i,e.path);await A(t,e.content),o.push(t)}return{files:o,source:t}}const Vt={inmemory:`in-memory`,drizzle:`Drizzle`,prisma:`Prisma`};function Ht(e){return e.charAt(0).toUpperCase()+e.slice(1).replace(/-([a-z])/g,(e,t)=>t.toUpperCase())}function Ut(e){return e.replace(/([a-z])([A-Z])/g,`$1-$2`).toLowerCase()}function Wt(e){return Vt[e]??Ht(e)}function Gt(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]??`${Ht(n)}${e}Repository`,repoFile:i[n]??`${Ut(n)}-${t}`}}function Kt(e){let{pascal:t,kebab:n,plural:r=``,repo:i}=e,{repoClass:a,repoFile:o}=Gt(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 ${Wt(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 ${Wt(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 qt(e){let{pascal:t,kebab:n,plural:r=``,repo:i}=e,{repoClass:a,repoFile:o}=Gt(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 Jt(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 Yt(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 Xt(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 Zt(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 Qt(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 $t(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 en(e){let{pascal:t}=e;return`export interface ${t}ResponseDTO {
+  id: string
+  name: string
+  createdAt: string
+  updatedAt: string
+}
+`}function tn(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 nn(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 H(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 rn(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 an(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 on(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 sn(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 cn(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 ln(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 un(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 dn(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 fn(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 pn(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 mn(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 hn(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 gn(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 _n(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 vn(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 yn(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 } })
+  }
+}
+`}async function bn(e){let{pascal:t,kebab:n,plural:r,write:i}=e;await i(`${n}.module.ts`,Jt({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 xn(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`,qt({pascal:t,kebab:n,plural:r,repo:a})),await l(`${n}.constants.ts`,dn({pascal:t,kebab:n})),await l(`${n}.controller.ts`,Xt({pascal:t,kebab:n,plural:r,pluralPascal:i})),await l(`${n}.service.ts`,un({pascal:t,kebab:n})),await l(`dtos/create-${n}.dto.ts`,Qt({pascal:t,kebab:n})),await l(`dtos/update-${n}.dto.ts`,$t({pascal:t,kebab:n})),await l(`dtos/${n}-response.dto.ts`,en({pascal:t,kebab:n})),await l(`${n}.repository.ts`,nn({pascal:t,kebab:n,dtoPrefix:`./dtos`,tokenScope:c}));let u={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},d={inmemory:()=>H({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),drizzle:()=>_n({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),prisma:()=>yn({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`,prismaClientPath:s})},f=u[a]??`${B(a)}-${n}`,p=d[a]??(()=>rn({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`,H({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`})),await l(`__tests__/${n}.controller.test.ts`,cn({pascal:t,kebab:n,plural:r})),await l(`__tests__/${n}.repository.test.ts`,ln({pascal:t,kebab:n,plural:r,repoPrefix:`../${u.inmemory??`in-memory-${n}`}.repository`})))}async function Sn(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`,fn({pascal:t,kebab:n,plural:r,repo:a})),await l(`${n}.constants.ts`,dn({pascal:t,kebab:n})),await l(`${n}.controller.ts`,pn({pascal:t,kebab:n,plural:r,pluralPascal:i})),await l(`dtos/create-${n}.dto.ts`,Qt({pascal:t,kebab:n})),await l(`dtos/update-${n}.dto.ts`,$t({pascal:t,kebab:n})),await l(`dtos/${n}-response.dto.ts`,en({pascal:t,kebab:n}));let u=mn({pascal:t,kebab:n});for(let e of u)await l(`commands/${e.file}`,e.content);let d=hn({pascal:t,kebab:n,plural:r,pluralPascal:i});for(let e of d)await l(`queries/${e.file}`,e.content);let f=gn({pascal:t,kebab:n});for(let e of f)await l(`events/${e.file}`,e.content);await l(`${n}.repository.ts`,nn({pascal:t,kebab:n,dtoPrefix:`./dtos`,tokenScope:c}));let p={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},m={inmemory:()=>H({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),drizzle:()=>_n({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`}),prisma:()=>yn({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`,prismaClientPath:s})},h=p[a]??`${B(a)}-${n}`,g=m[a]??(()=>rn({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`,H({pascal:t,kebab:n,repoPrefix:`.`,dtoPrefix:`./dtos`})),await l(`__tests__/${n}.controller.test.ts`,cn({pascal:t,kebab:n,plural:r})),await l(`__tests__/${n}.repository.test.ts`,ln({pascal:t,kebab:n,plural:r,repoPrefix:`../${p.inmemory??`in-memory-${n}`}.repository`})))}async function Cn(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`,Kt({pascal:t,kebab:n,plural:r,repo:a})),await u(`constants.ts`,a===`drizzle`?vn({pascal:t,kebab:n}):Zt({pascal:t,kebab:n})),await u(`presentation/${n}.controller.ts`,Yt({pascal:t,kebab:n,plural:r,pluralPascal:i})),await u(`application/dtos/create-${n}.dto.ts`,Qt({pascal:t,kebab:n})),await u(`application/dtos/update-${n}.dto.ts`,$t({pascal:t,kebab:n})),await u(`application/dtos/${n}-response.dto.ts`,en({pascal:t,kebab:n}));let d=tn({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`,nn({pascal:t,kebab:n,tokenScope:l})),await u(`domain/services/${n}-domain.service.ts`,an({pascal:t,kebab:n}));let f={inmemory:`in-memory-${n}`,drizzle:`drizzle-${n}`,prisma:`prisma-${n}`},p={inmemory:()=>H({pascal:t,kebab:n}),drizzle:()=>_n({pascal:t,kebab:n}),prisma:()=>yn({pascal:t,kebab:n,prismaClientPath:c})},m=f[a]??`${B(a)}-${n}`,h=p[a]??(()=>rn({pascal:t,kebab:n,repoType:a}));await u(`infrastructure/repositories/${m}.repository.ts`,h()),o||(await u(`domain/entities/${n}.entity.ts`,on({pascal:t,kebab:n})),await u(`domain/value-objects/${n}-id.vo.ts`,sn({pascal:t,kebab:n}))),s||(a!==`inmemory`&&await u(`infrastructure/repositories/in-memory-${n}.repository.ts`,H({pascal:t,kebab:n})),await u(`__tests__/${n}.controller.test.ts`,cn({pascal:t,kebab:n,plural:r})),await u(`__tests__/${n}.repository.test.ts`,ln({pascal:t,kebab:n,plural:r})))}function wn(e){return e?typeof e==`string`?e:e.name:`inmemory`}async function Tn(e){let{name:t,modulesDir:n,noEntity:r,noTests:i,repo:a=`inmemory`,force:o,dryRun:s}=e,c=e.pluralize!==!1,l=e.pattern??`ddd`;e.minimal&&(l=`minimal`);let u=B(t),d=R(t),f=c?V(u):u,p=c?Dt(d):d,m=b(n,f),h=[],g=o??!1,_={kebab:u,pascal:d,plural:f,pluralPascal:p,moduleDir:m,repo:a,noEntity:r??!1,noTests:i??!1,prismaClientPath:e.prismaClientPath??`@prisma/client`,tokenScope:e.tokenScope??`app`,write:async(e,t)=>{let n=b(m,e);if(s){h.push(n);return}if(!g&&await N(n)&&!await F({message:`File exists: ${O.dim(e)}. Overwrite?`,initialValue:!1})){I.warn(`Skipped: ${e}`);return}await A(n,t),h.push(n)},files:h};switch(l){case`minimal`:await bn(_);break;case`rest`:await xn(_);break;case`cqrs`:await Sn(_);break;default:await Cn(_);break}return s||await En(n,d,f,u),h}async function En(e,t,n,r){let i=b(e,`index.ts`),a=await N(i),o=`./${n}/${r}.module`;if(!a){await A(i,`import type { AppModuleClass } from '@forinda/kickjs'
+import { ${t}Module } from '${o}'
+
+export const modules: AppModuleClass[] = [${t}Module]
+`);return}let s=await T(i,`utf-8`),c=`import { ${t}Module } from '${o}'`;if(!s.includes(`${t}Module`)){let e=s.lastIndexOf(`import `);if(e!==-1){let t=s.indexOf(`
+`,e);s=s.slice(0,t+1)+c+`
+`+s.slice(t+1)}else s=c+`
+`+s;s=s.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 E(i,s,`utf-8`)}async function Dn(e){let{name:t,outDir:n}=e,r=B(t),i=R(t),a=[],o=b(n,`${r}.adapter.ts`);return await A(o,`import {
+  defineAdapter,
+  type AdapterContext,
+  type AdapterMiddleware,
+  type ContributorRegistrations,
+  type Constructor,
+} from '@forinda/kickjs'
+
+/**
+ * Configuration for the ${i} 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 ${i}AdapterConfig {
+  // Add your adapter configuration here, e.g.:
+  // enabled?: boolean
+  // apiKey?: string
+}
+
+/**
+ * ${i} 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 { ${i}Adapter } from './adapters/${r}.adapter'
+ *
+ * bootstrap({
+ *   modules,
+ *   adapters: [${i}Adapter({ /* config overrides *\\/ })],
+ * })
+ * \`\`\`
+ */
+export const ${i}Adapter = defineAdapter<${i}AdapterConfig>({
+  name: '${i}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-${i}', '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('/${r}/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 { ${r}: { id: string } } }
+          // const Load${i} = defineHttpContextDecorator({
+          //   key: '${r}',
+          //   resolve: (ctx) => ({ id: ctx.req.headers['x-${r}-id'] as string }),
+          // })
+          // return [Load${i}.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)
+      },
+    }
+  },
+})
+`),a.push(o),a}async function On(e){let{name:t,outDir:n}=e,r=B(t),i=R(t),a=[],o=b(n,`${r}.plugin.ts`);return await A(o,`import {
+  definePlugin,
+  type AppAdapter,
+  type AppModuleClass,
+  type Container,
+  type ContributorRegistrations,
+} from '@forinda/kickjs'
+
+/**
+ * Configuration for the ${i} plugin.
+ *
+ * Plugins 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 ${i}PluginConfig {
+  // Add your plugin config here, e.g.:
+  // enabled?: boolean
+  // apiKey?: string
+}
+
+/**
+ * ${i} plugin — built via \`definePlugin()\` so callers get the
+ * factory's call / \`.scoped()\` / \`.async()\` surfaces for free.
+ *
+ * A plugin bundles DI bindings, modules, adapters, and middleware
+ * into one object that can be added to \`bootstrap({ plugins })\`.
+ *
+ * Lifecycle order (each hook is optional — delete the ones you don't
+ * need and keep only the surface your plugin actually uses):
+ *
+ *   1. \`register(container)\` — runs before user modules load. Use
+ *      it to bind services that modules depend on.
+ *   2. \`modules()\`            — plugin modules load before user modules.
+ *   3. \`adapters()\`           — plugin adapters mount before user adapters.
+ *   4. \`middleware()\`         — plugin middleware runs before user middleware.
+ *   5. \`contributors()\`       — Context Contributors merged into every route.
+ *   6. \`onReady(container)\`   — runs after the app has fully bootstrapped.
+ *   7. \`shutdown()\`           — runs on graceful shutdown.
+ *
+ * @example
+ * \`\`\`ts
+ * import { bootstrap } from '@forinda/kickjs'
+ * import { ${i}Plugin } from './plugins/${r}.plugin'
+ *
+ * export const app = await bootstrap({
+ *   modules,
+ *   plugins: [${i}Plugin({ /* config overrides *\\/ })],
+ * })
+ * \`\`\`
+ */
+export const ${i}Plugin = definePlugin<${i}PluginConfig>({
+  name: '${i}Plugin',
+  defaults: {
+    // Default config values go here
+  },
+  build: (_config, { name: _name }) => ({
+    /**
+     * Register DI bindings before modules load.
+     * Use \`container.registerInstance(TOKEN, value)\` for singletons
+     * and \`container.registerFactory(TOKEN, () => ...)\` for lazy
+     * constructions.
+     */
+    register(_container: Container): void {
+      // Example: _container.registerInstance(MY_TOKEN, new MyService(_config))
+    },
+
+    /**
+     * Return module classes this plugin contributes to the app.
+     * These load before user modules, so plugin controllers and
+     * services are available for user code to \`@Autowired\`.
+     */
+    modules(): AppModuleClass[] {
+      return [
+        // ExampleModule,
+      ]
+    },
+
+    /**
+     * Return adapter instances to be added to the application.
+     * Plugin adapters mount before user adapters.
+     */
+    adapters(): AppAdapter[] {
+      return [
+        // MyAdapter({ ... }),
+      ]
+    },
+
+    /**
+     * Return Express middleware entries to be added to the global
+     * pipeline. Plugin middleware runs before user-defined middleware.
+     */
+    middleware(): unknown[] {
+      return [
+        // helmet(),
+        // myCustomMiddleware(_config),
+      ]
+    },
+
+    /**
+     * Return Context Contributors to merge into every route's pipeline.
+     * Plugins contribute at the same \`'adapter'\` precedence level as
+     * adapters — overrideable per-route at the method / class / module
+     * level. See https://forinda.github.io/kick-js/guide/context-decorators
+     *
+     * Delete this hook if your plugin doesn't ship typed per-request values.
+     */
+    contributors(): ContributorRegistrations {
+      return [
+        // Example:
+        // import { defineHttpContextDecorator } from '@forinda/kickjs'
+        // declare module '@forinda/kickjs' { interface ContextMeta { ${r}: { foo: string } } }
+        // const Load${i} = defineHttpContextDecorator({
+        //   key: '${r}',
+        //   resolve: (ctx) => ({ foo: ctx.req.headers['x-${r}'] as string }),
+        // })
+        // return [Load${i}.registration]
+      ]
+    },
+
+    /**
+     * Called after the application has fully bootstrapped. Use this
+     * for post-startup work like logging, health checks, or warming
+     * a cache. Runs once per process.
+     */
+    async onReady(_container: Container): Promise<void> {
+      // const log = _container.resolve(Logger)
+      // log.info('${i} plugin ready')
+    },
+
+    /**
+     * Called during graceful shutdown. Clean up any long-lived
+     * resources this plugin owns (connections, timers, subscriptions).
+     */
+    async shutdown(): Promise<void> {
+      // Example: await this.connection?.close()
+    },
+  }),
+})
+`),a.push(o),a}const kn={controller:`presentation`,service:`domain/services`,dto:`application/dtos`,guard:`presentation/guards`,middleware:`middleware`},An={controller:``,service:``,dto:`dtos`,guard:`guards`,middleware:`middleware`},jn={controller:``,service:``,dto:`dtos`,guard:`guards`,middleware:`middleware`,command:`commands`,query:`queries`,event:`events`};function U(e){let{type:t,outDir:n,moduleName:r,modulesDir:i=`src/modules`,defaultDir:a,pattern:o=`ddd`,shouldPluralize:s=!0}=e;if(n)return S(n);if(r){let e=o===`ddd`?kn:o===`cqrs`?jn:An,n=B(r),a=s?V(n):n,c=e[t]??``,l=b(i,a);return S(c?b(l,c):l)}return S(a)}async function Mn(e){let{name:t,moduleName:n,modulesDir:r,pattern:i}=e,a=U({type:`middleware`,outDir:e.outDir,moduleName:n,modulesDir:r,defaultDir:`src/middleware`,pattern:i,shouldPluralize:e.pluralize??!0}),o=B(t),s=z(t),c=[],l=b(a,`${o}.middleware.ts`);return await A(l,`import type { Request, Response, NextFunction } from 'express'
+
+export interface ${R(t)}Options {
+  // Add configuration options here
+}
+
+/**
+ * ${R(t)} middleware.
+ *
+ * Usage in bootstrap:
+ *   middleware: [${s}()]
+ *
+ * Usage with adapter:
+ *   middleware() { return [{ handler: ${s}(), phase: 'afterGlobal' }] }
+ *
+ * Usage with @Middleware decorator:
+ *   @Middleware(${s}())
+ */
+export function ${s}(options: ${R(t)}Options = {}) {
+  return (req: Request, res: Response, next: NextFunction) => {
+    // Implement your middleware logic here
+    next()
+  }
+}
+`),c.push(l),c}async function Nn(e){let{name:t,moduleName:n,modulesDir:r,pattern:i}=e,a=U({type:`guard`,outDir:e.outDir,moduleName:n,modulesDir:r,defaultDir:`src/guards`,pattern:i,shouldPluralize:e.pluralize??!0}),o=B(t),s=z(t),c=R(t),l=[],u=b(a,`${o}.guard.ts`);return await A(u,`import { Container, HttpException } from '@forinda/kickjs'
+import type { RequestContext } from '@forinda/kickjs'
+
+/**
+ * ${c} guard.
+ *
+ * Guards protect routes by checking conditions before the handler runs.
+ * Return early with an error response to block access.
+ *
+ * Usage:
+ *   @Middleware(${s}Guard)
+ *   @Get('/protected')
+ *   async handler(ctx: RequestContext) { ... }
+ */
+export async function ${s}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' })
+  }
+}
+`),l.push(u),l}async function Pn(e){let{name:t,moduleName:n,modulesDir:r,pattern:i}=e,a=U({type:`service`,outDir:e.outDir,moduleName:n,modulesDir:r,defaultDir:`src/services`,pattern:i,shouldPluralize:e.pluralize??!0}),o=B(t),s=R(t),c=[],l=b(a,`${o}.service.ts`);return await A(l,`import { Service } from '@forinda/kickjs'
+
+@Service()
+export class ${s}Service {
+  // Inject dependencies via constructor
+  // constructor(
+  //   @Inject(MY_REPO) private readonly repo: IMyRepository,
+  // ) {}
+}
+`),c.push(l),c}async function Fn(e){let{name:t,moduleName:n,modulesDir:r,pattern:i}=e,a=U({type:`controller`,outDir:e.outDir,moduleName:n,modulesDir:r,defaultDir:`src/controllers`,pattern:i,shouldPluralize:e.pluralize??!0}),o=B(t),s=R(t),c=[],l=b(a,`${o}.controller.ts`);return await A(l,`import { Controller, Get, Post, type Ctx } from '@forinda/kickjs'
+
+// \`Ctx<KickRoutes.${s}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 ${s}Controller {
+  // @Autowired() private readonly myService!: MyService
+
+  @Get('/')
+  async list(ctx: Ctx<KickRoutes.${s}Controller['list']>) {
+    ctx.json({ message: '${s} list' })
+  }
+
+  @Post('/')
+  async create(ctx: Ctx<KickRoutes.${s}Controller['create']>) {
+    ctx.created({ message: '${s} created', data: ctx.body })
+  }
+}
+`),c.push(l),c}async function In(e){let{name:t,moduleName:n,modulesDir:r,pattern:i}=e,a=U({type:`dto`,outDir:e.outDir,moduleName:n,modulesDir:r,defaultDir:`src/dtos`,pattern:i,shouldPluralize:e.pluralize??!0}),o=B(t),s=R(t),c=z(t),l=[],u=b(a,`${o}.dto.ts`);return await A(u,`import { z } from 'zod'
+
+export const ${c}Schema = z.object({
+  // Define your schema fields here
+  name: z.string().min(1).max(200),
+})
+
+export type ${s}DTO = z.infer<typeof ${c}Schema>
+`),l.push(u),l}async function Ln(e){let t=b(e.outDir,`kick.config.ts`),n=e.modulesDir??`src/modules`,r=e.defaultRepo??`inmemory`;return h(t)&&!e.force&&!await F({message:`kick.config.ts already exists. Overwrite?`,initialValue:!1})?(console.log(`
+  Skipped — existing kick.config.ts preserved.`),[]):(await A(t,`import { defineConfig } from '@forinda/kickjs-cli'
+
+export default defineConfig({
+  modules: {
+    dir: '${n}',
+    repo: '${r}',
+    pluralize: true,
+  },
+
+  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'],
+    },
+  ],
+})
+`),[t])}const Rn=new Set([`rest`,`ddd`,`cqrs`,`minimal`]);function zn(e,t){if(t)return t;try{let t=JSON.parse(_(b(e,`package.json`),`utf-8`));if(t.name)return t.name.replace(/^@[^/]+\//,``)}catch{}return e.split(`/`).findLast(Boolean)??`app`}function Bn(e,t){if(t)return t;try{let t=JSON.parse(_(b(e,`package.json`),`utf-8`));if(t.packageManager)return t.packageManager.split(`@`)[0]}catch{}return`pnpm`}async function Vn(e,t){if(t)return t;try{let t=(await r(e))?.pattern;if(t&&Rn.has(t))return t}catch{}return`ddd`}async function Hn(e){let t=e.only??`all`,n=zn(e.outDir,e.name),r=Bn(e.outDir,e.pm),i=await Vn(e.outDir,e.template),a=t===`agents`||t===`both`||t===`all`,o=t===`claude`||t===`both`||t===`all`,s=t===`skills`||t===`all`,c=[];a&&c.push({file:b(e.outDir,`AGENTS.md`),render:()=>nt(n,i,r)}),o&&c.push({file:b(e.outDir,`CLAUDE.md`),render:()=>tt(n,i,r)}),s&&c.push({file:b(e.outDir,`kickjs-skills.md`),render:()=>rt(n,i,r)});let l=[];for(let{file:t,render:n}of c){if(h(t)&&!e.force&&!await F({message:`${t.replace(e.outDir+`/`,``)} already exists. Overwrite?`,initialValue:!1})){console.log(`  Skipped — existing ${t.replace(e.outDir+`/`,``)} preserved.`);continue}await A(t,n()),l.push(t)}return l}async function Un(e={}){let t=e.strategy??`jwt`,n=e.outDir??`src/modules/auth`,r=b(n,`dto`),i=[],a=b(n,`auth.module.ts`);await A(a,`import { Module } from '@forinda/kickjs'
+import { AuthController } from './auth.controller'
+import { AuthService } from './auth.service'
+
+@Module({
+  controllers: [AuthController],
+  services: [AuthService],
+})
+export class AuthModule {}
+`),i.push(a);let o=b(n,`auth.controller.ts`);await A(o,t===`jwt`?Wn():Kn()),i.push(o);let s=b(n,`auth.service.ts`);await A(s,t===`jwt`?Gn():qn()),i.push(s);let c=b(r,`register.dto.ts`);await A(c,`import { z } from 'zod'
+
+export const RegisterDto = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+  name: z.string().min(1).optional(),
+})
+
+export type RegisterInput = z.infer<typeof RegisterDto>
+`),i.push(c);let l=b(r,`login.dto.ts`);await A(l,`import { z } from 'zod'
+
+export const LoginDto = z.object({
+  email: z.string().email(),
+  password: z.string().min(1),
+})
+
+export type LoginInput = z.infer<typeof LoginDto>
+`),i.push(l);let u=b(n,`auth.test.ts`);if(await A(u,`import { describe, it, expect } from 'vitest'
+
+describe('Auth Module', () => {
+  it.todo('POST /register — creates a new user')
+  it.todo('POST /login — returns token for valid credentials')
+  it.todo('POST /login — rejects invalid credentials')
+  it.todo('POST /logout — invalidates session/token')
+  it.todo('GET /me — returns authenticated user')
+})
+`),i.push(u),e.roleGuards!==!1){let e=b(n,`auth.guard.ts`);await A(e,`import { Roles } from '@forinda/kickjs-auth'
+
+/**
+ * Role-based access guard.
+ * Usage: @Roles('admin') on a controller method.
+ *
+ * The AuthAdapter extracts the user's roles from the JWT/session
+ * and the framework checks them automatically.
+ */
+export const AdminOnly = Roles('admin')
+export const ManagerOnly = Roles('manager')
+`),i.push(e)}return i}function Wn(){return`import { Controller, Post, Get } from '@forinda/kickjs'
+import { Authenticated, Public } from '@forinda/kickjs-auth'
+import type { RequestContext } from '@forinda/kickjs'
+import { Autowired } from '@forinda/kickjs'
+import { AuthService } from './auth.service'
+
+@Controller()
+@Authenticated()
+export class AuthController {
+  @Autowired() private authService!: AuthService
+
+  @Post('/register')
+  @Public()
+  async register(ctx: RequestContext) {
+    const result = await this.authService.register(ctx.body)
+    return ctx.created(result)
+  }
+
+  @Post('/login')
+  @Public()
+  async login(ctx: RequestContext) {
+    const result = await this.authService.login(ctx.body)
+    if (!result) return ctx.badRequest('Invalid credentials')
+    return ctx.json(result)
+  }
+
+  @Post('/logout')
+  async logout(ctx: RequestContext) {
+    return ctx.json({ message: 'Logged out' })
+  }
+
+  @Get('/me')
+  async me(ctx: RequestContext) {
+    return ctx.json({ user: ctx.user })
+  }
+}
+`}function Gn(){return`import { Service, Autowired } from '@forinda/kickjs'
+import { PasswordService } from '@forinda/kickjs-auth'
+import type { RegisterInput } from './dto/register.dto'
+import type { LoginInput } from './dto/login.dto'
+
+// TODO: Replace with your User repository
+const users = new Map<string, { id: string; email: string; name?: string; passwordHash: string }>()
+
+@Service()
+export class AuthService {
+  @Autowired() private password!: PasswordService
+
+  async register(input: RegisterInput) {
+    const { email, password, name } = input
+
+    if (users.has(email)) {
+      throw new Error('User already exists')
+    }
+
+    const passwordHash = await this.password.hash(password)
+    const id = crypto.randomUUID()
+    users.set(email, { id, email, name, passwordHash })
+
+    return { id, email, name }
+  }
+
+  async login(input: LoginInput) {
+    const { email, password } = input
+    const user = users.get(email)
+    if (!user) return null
+
+    const valid = await this.password.verify(user.passwordHash, password)
+    if (!valid) return null
+
+    // TODO: Generate JWT token here
+    // const token = jwt.sign({ sub: user.id, email: user.email }, process.env.JWT_SECRET!)
+    return { user: { id: user.id, email: user.email, name: user.name } }
+  }
+}
+`}function Kn(){return`import { Controller, Post, Get } from '@forinda/kickjs'
+import { Authenticated, Public } from '@forinda/kickjs-auth'
+import { sessionLogin, sessionLogout } from '@forinda/kickjs-auth'
+import type { RequestContext } from '@forinda/kickjs'
+import { Autowired } from '@forinda/kickjs'
+import { AuthService } from './auth.service'
+
+@Controller()
+@Authenticated()
+export class AuthController {
+  @Autowired() private authService!: AuthService
+
+  @Post('/register')
+  @Public()
+  async register(ctx: RequestContext) {
+    const result = await this.authService.register(ctx.body)
+    return ctx.created(result)
+  }
+
+  @Post('/login')
+  @Public()
+  async login(ctx: RequestContext) {
+    const user = await this.authService.login(ctx.body)
+    if (!user) return ctx.badRequest('Invalid credentials')
+    await sessionLogin(ctx.session, user)
+    return ctx.json({ message: 'Logged in', user })
+  }
+
+  @Post('/logout')
+  async logout(ctx: RequestContext) {
+    await sessionLogout(ctx.session)
+    return ctx.json({ message: 'Logged out' })
+  }
+
+  @Get('/me')
+  async me(ctx: RequestContext) {
+    return ctx.json({ user: ctx.user })
+  }
+}
+`}function qn(){return`import { Service, Autowired } from '@forinda/kickjs'
+import { PasswordService } from '@forinda/kickjs-auth'
+import type { RegisterInput } from './dto/register.dto'
+import type { LoginInput } from './dto/login.dto'
+
+// TODO: Replace with your User repository
+const users = new Map<string, { id: string; email: string; name?: string; passwordHash: string }>()
+
+@Service()
+export class AuthService {
+  @Autowired() private password!: PasswordService
+
+  async register(input: RegisterInput) {
+    const { email, password, name } = input
+
+    if (users.has(email)) {
+      throw new Error('User already exists')
+    }
+
+    const passwordHash = await this.password.hash(password)
+    const id = crypto.randomUUID()
+    users.set(email, { id, email, name, passwordHash })
+
+    return { id, email, name }
+  }
+
+  async login(input: LoginInput) {
+    const { email, password } = input
+    const user = users.get(email)
+    if (!user) return null
+
+    const valid = await this.password.verify(user.passwordHash, password)
+    if (!valid) return null
+
+    return { id: user.id, email: user.email, name: user.name }
+  }
+}
+`}async function Jn(e){let{name:t,outDir:n}=e,r=R(t),i=B(t),a=z(t),o=e.queue??`${i}-queue`,s=[];return await(async(e,t)=>{let r=b(n,e);await A(r,t),s.push(r)})(`${i}.job.ts`,`import { Inject } from '@forinda/kickjs'
+import { Job, Process, QUEUE_MANAGER, type QueueService } from '@forinda/kickjs-queue'
+
+/**
+ * ${r} Job Processor
+ *
+ * Decorators:
+ *   @Job(queueName) — marks this class as a job processor for a queue
+ *   @Process(jobName?) — marks a method as the handler for a specific job type
+ *     - Without a name: handles all jobs in the queue
+ *     - With a name: handles only jobs matching that name
+ *
+ * To add jobs to this queue from a service or controller:
+ *   @Inject(QUEUE_MANAGER) private queue: QueueService
+ *   await this.queue.add('${o}', '${a}', { ... })
+ */
+@Job('${o}')
+export class ${r}Job {
+  @Process()
+  async handle(job: { name: string; data: any; id?: string }) {
+    console.log(\`Processing \${job.name} (id: \${job.id})\`, job.data)
+
+    // TODO: Implement job logic here
+    // Example:
+    // await this.emailService.send(job.data.to, job.data.subject, job.data.body)
+  }
+
+  @Process('${a}.priority')
+  async handlePriority(job: { name: string; data: any; id?: string }) {
+    console.log(\`Priority job: \${job.name}\`, job.data)
+    // Handle high-priority variant of this job
+  }
+}
+`),s}const Yn={string:{ts:`string`,zod:`z.string()`},text:{ts:`string`,zod:`z.string()`},number:{ts:`number`,zod:`z.number()`},int:{ts:`number`,zod:`z.number().int()`},float:{ts:`number`,zod:`z.number()`},boolean:{ts:`boolean`,zod:`z.boolean()`},date:{ts:`string`,zod:`z.string().datetime()`},email:{ts:`string`,zod:`z.string().email()`},url:{ts:`string`,zod:`z.string().url()`},uuid:{ts:`string`,zod:`z.string().uuid()`},json:{ts:`any`,zod:`z.any()`}};function Xn(e){return e.map(e=>{let t=e.indexOf(`:`);if(t===-1)throw Error(`Invalid field: "${e}". Use format: name:type (e.g. title:string)`);let n=e.slice(0,t),r=e.slice(t+1);if(!n||!r)throw Error(`Invalid field: "${e}". Use format: name:type (e.g. title:string)`);let i=!1;r.endsWith(`:optional`)&&(r=r.slice(0,-9),i=!0),n.endsWith(`?`)&&(n=n.slice(0,-1),i=!0),r.endsWith(`?`)&&(r=r.slice(0,-1),i=!0);let a=r;if(a.startsWith(`enum:`)){let e=a.slice(5).split(`,`);return{name:n,type:`enum`,tsType:e.map(e=>`'${e}'`).join(` | `),zodType:`z.enum([${e.map(e=>`'${e}'`).join(`, `)}])`,optional:i}}let o=Yn[a];if(!o){let e=[...Object.keys(Yn),`enum:a,b,c`].join(`, `);throw Error(`Unknown field type: "${a}". Valid types: ${e}`)}return{name:n,type:a,tsType:o.ts,zodType:o.zod,optional:i}})}async function Zn(e){let{name:t,fields:n,modulesDir:r,noEntity:i,noTests:a,repo:o=`inmemory`,tokenScope:s=`app`}=e,c=e.pluralize!==!1,l=B(t),u=R(t);z(t);let d=c?V(l):l,f=c?Dt(u):u,p=b(r,d),m=[],h=async(e,t)=>{let n=b(p,e);await A(n,t),m.push(n)};await h(`${l}.module.ts`,ar(u,l,d)),await h(`constants.ts`,tr(u,n)),await h(`presentation/${l}.controller.ts`,or(u,l,d,f)),await h(`application/dtos/create-${l}.dto.ts`,Qn(u,n)),await h(`application/dtos/update-${l}.dto.ts`,$n(u,n)),await h(`application/dtos/${l}-response.dto.ts`,er(u,n));let g=lr(u,l,d,f);for(let e of g)await h(`application/use-cases/${e.file}`,e.content);return await h(`domain/repositories/${l}.repository.ts`,sr(u,l,s)),await h(`domain/services/${l}-domain.service.ts`,cr(u,l)),o===`inmemory`&&await h(`infrastructure/repositories/in-memory-${l}.repository.ts`,nr(u,l,n)),i||(await h(`domain/entities/${l}.entity.ts`,rr(u,l,n)),await h(`domain/value-objects/${l}-id.vo.ts`,ir(u))),await ur(r,u,d,l),m}function Qn(e,t){return`import { z } from 'zod'
+
+export const create${e}Schema = z.object({
+${t.map(e=>{let t=e.zodType;return`  ${e.name}: ${t}${e.optional?`.optional()`:``},`}).join(`
+`)}
+})
+
+export type Create${e}DTO = z.infer<typeof create${e}Schema>
+`}function $n(e,t){return`import { z } from 'zod'
+
+export const update${e}Schema = z.object({
+${t.map(e=>`  ${e.name}: ${e.zodType}.optional(),`).join(`
+`)}
+})
+
+export type Update${e}DTO = z.infer<typeof update${e}Schema>
+`}function er(e,t){return`export interface ${e}ResponseDTO {
+  id: string
+${t.map(e=>`  ${e.name}${e.optional?`?`:``}: ${e.tsType}`).join(`
+`)}
+  createdAt: string
+  updatedAt: string
+}
+`}function tr(e,t){let n=t.filter(e=>e.tsType===`string`).map(e=>`'${e.name}'`);t.filter(e=>e.tsType===`number`).map(e=>`'${e.name}'`);let r=t.map(e=>`'${e.name}'`),i=[...r].join(`, `),a=[...r,`'createdAt'`,`'updatedAt'`].join(`, `),o=n.length>0?n.join(`, `):`'name'`;return`import type { ApiQueryParamsConfig } from '@forinda/kickjs'
+
+export const ${e.toUpperCase()}_QUERY_CONFIG: ApiQueryParamsConfig = {
+  filterable: [${i}],
+  sortable: [${a}],
+  searchable: [${o}],
+}
+`}function nr(e,t,n){return`import { randomUUID } from 'node:crypto'
+import { Repository, HttpException } from '@forinda/kickjs'
+import type { ParsedQuery } from '@forinda/kickjs'
+import type { I${e}Repository } from '../../domain/repositories/${t}.repository'
+import type { ${e}ResponseDTO } from '../../application/dtos/${t}-response.dto'
+import type { Create${e}DTO } from '../../application/dtos/create-${t}.dto'
+import type { Update${e}DTO } from '../../application/dtos/update-${t}.dto'
+
+@Repository()
+export class InMemory${e}Repository implements I${e}Repository {
+  private store = new Map<string, ${e}ResponseDTO>()
+
+  async findById(id: string): Promise<${e}ResponseDTO | null> {
+    return this.store.get(id) ?? null
+  }
+
+  async findAll(): Promise<${e}ResponseDTO[]> {
+    return Array.from(this.store.values())
+  }
+
+  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${e}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${e}DTO): Promise<${e}ResponseDTO> {
+    const now = new Date().toISOString()
+    const entity: ${e}ResponseDTO = {
+      id: randomUUID(),
+${n.map(e=>`      ${e.name}: dto.${e.name},`).join(`
+`)}
+      createdAt: now,
+      updatedAt: now,
+    }
+    this.store.set(entity.id, entity)
+    return entity
+  }
+
+  async update(id: string, dto: Update${e}DTO): Promise<${e}ResponseDTO> {
+    const existing = this.store.get(id)
+    if (!existing) throw HttpException.notFound('${e} 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('${e} not found')
+    this.store.delete(id)
+  }
+}
+`}function rr(e,t,n){return`import { ${e}Id } from '../value-objects/${t}-id.vo'
+
+interface ${e}Props {
+  id: ${e}Id
+${n.map(e=>`  ${e.name}${e.optional?`?`:``}: ${e.tsType}`).join(`
+`)}
+  createdAt: Date
+  updatedAt: Date
+}
+
+export class ${e} {
+  private constructor(private props: ${e}Props) {}
+
+  static create(params: { ${n.filter(e=>!e.optional).map(e=>`${e.name}: ${e.tsType}`).join(`; `)} }): ${e} {
+    const now = new Date()
+    return new ${e}({
+      id: ${e}Id.create(),
+${n.filter(e=>!e.optional).map(e=>`      ${e.name}: params.${e.name},`).join(`
+`)}
+      createdAt: now,
+      updatedAt: now,
+    })
+  }
+
+  static reconstitute(props: ${e}Props): ${e} {
+    return new ${e}(props)
+  }
+
+  get id(): ${e}Id { return this.props.id }
+${n.map(e=>`  get ${e.name}(): ${e.tsType}${e.optional?` | undefined`:``} {
+    return this.props.${e.name}
+  }`).join(`
+`)}
+  get createdAt(): Date { return this.props.createdAt }
+  get updatedAt(): Date { return this.props.updatedAt }
+
+  toJSON() {
+    return {
+      id: this.props.id.toString(),
+${n.map(e=>`      ${e.name}: this.props.${e.name},`).join(`
+`)}
+      createdAt: this.props.createdAt.toISOString(),
+      updatedAt: this.props.updatedAt.toISOString(),
+    }
+  }
+}
+`}function ir(e){return`import { randomUUID } from 'node:crypto'
+
+export class ${e}Id {
+  private constructor(private readonly value: string) {}
+
+  static create(): ${e}Id { return new ${e}Id(randomUUID()) }
+
+  static from(id: string): ${e}Id {
+    if (!id || id.trim().length === 0) throw new Error('${e}Id cannot be empty')
+    return new ${e}Id(id)
+  }
+
+  toString(): string { return this.value }
+  equals(other: ${e}Id): boolean { return this.value === other.value }
+}
+`}function ar(e,t,n){return`import { type AppModule, type ModuleRoutes, Container, buildRoutes } from '@forinda/kickjs'
+import { ${e}Controller } from './presentation/${t}.controller'
+import { ${e.toUpperCase()}_REPOSITORY } from './domain/repositories/${t}.repository'
+import { InMemory${e}Repository } from './infrastructure/repositories/in-memory-${t}.repository'
+
+// Eagerly load decorated classes so @Service()/@Repository() decorators
+// register in the DI container before the application bootstraps.
+import.meta.glob(
+  ['./domain/services/**/*.ts', './application/use-cases/**/*.ts', '!./**/*.test.ts'],
+  { eager: true },
+)
+
+export class ${e}Module implements AppModule {
+  /**
+   * Bind the repository token to its concrete implementation.
+   * Decorator-managed classes (@Service, @Controller, @Repository) are
+   * registered automatically — only token-to-impl bindings need to live here.
+   */
+  register(container: Container): void {
+    container.registerFactory(
+      ${e.toUpperCase()}_REPOSITORY,
+      () => container.resolve(InMemory${e}Repository),
+    )
+  }
+
+  routes(): ModuleRoutes {
+    return {
+      path: '/${n}',
+      router: buildRoutes(${e}Controller),
+      controller: ${e}Controller,
+    }
+  }
+}
+`}function or(e,t,n,r){return`import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams, type Ctx } from '@forinda/kickjs'
+import { ApiTags } from '@forinda/kickjs-swagger'
+import { Create${e}UseCase } from '../application/use-cases/create-${t}.use-case'
+import { Get${e}UseCase } from '../application/use-cases/get-${t}.use-case'
+import { List${r}UseCase } from '../application/use-cases/list-${n}.use-case'
+import { Update${e}UseCase } from '../application/use-cases/update-${t}.use-case'
+import { Delete${e}UseCase } from '../application/use-cases/delete-${t}.use-case'
+import { create${e}Schema } from '../application/dtos/create-${t}.dto'
+import { update${e}Schema } from '../application/dtos/update-${t}.dto'
+import { ${e.toUpperCase()}_QUERY_CONFIG } from '../constants'
+
+// Each handler annotates its \`ctx\` with \`Ctx<KickRoutes.${e}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 ${e}Controller {
+  @Autowired() private readonly create${e}UseCase!: Create${e}UseCase
+  @Autowired() private readonly get${e}UseCase!: Get${e}UseCase
+  @Autowired() private readonly list${r}UseCase!: List${r}UseCase
+  @Autowired() private readonly update${e}UseCase!: Update${e}UseCase
+  @Autowired() private readonly delete${e}UseCase!: Delete${e}UseCase
+
+  @Get('/')
+  @ApiTags('${e}')
+  @ApiQueryParams(${e.toUpperCase()}_QUERY_CONFIG)
+  async list(ctx: Ctx<KickRoutes.${e}Controller['list']>) {
+    return ctx.paginate(
+      (parsed) => this.list${r}UseCase.execute(parsed),
+      ${e.toUpperCase()}_QUERY_CONFIG,
+    )
+  }
+
+  @Get('/:id')
+  @ApiTags('${e}')
+  async getById(ctx: Ctx<KickRoutes.${e}Controller['getById']>) {
+    const result = await this.get${e}UseCase.execute(ctx.params.id)
+    if (!result) return ctx.notFound('${e} not found')
+    ctx.json(result)
+  }
+
+  @Post('/', { body: create${e}Schema, name: 'Create${e}' })
+  @ApiTags('${e}')
+  async create(ctx: Ctx<KickRoutes.${e}Controller['create']>) {
+    const result = await this.create${e}UseCase.execute(ctx.body)
+    ctx.created(result)
+  }
+
+  @Put('/:id', { body: update${e}Schema, name: 'Update${e}' })
+  @ApiTags('${e}')
+  async update(ctx: Ctx<KickRoutes.${e}Controller['update']>) {
+    const result = await this.update${e}UseCase.execute(ctx.params.id, ctx.body)
+    ctx.json(result)
+  }
+
+  @Delete('/:id')
+  @ApiTags('${e}')
+  async remove(ctx: Ctx<KickRoutes.${e}Controller['remove']>) {
+    await this.delete${e}UseCase.execute(ctx.params.id)
+    ctx.noContent()
+  }
+}
+`}function sr(e,t,n){return`import { createToken } from '@forinda/kickjs'
+import type { ${e}ResponseDTO } from '../../application/dtos/${t}-response.dto'
+import type { Create${e}DTO } from '../../application/dtos/create-${t}.dto'
+import type { Update${e}DTO } from '../../application/dtos/update-${t}.dto'
+import type { ParsedQuery } from '@forinda/kickjs'
+
+export interface I${e}Repository {
+  findById(id: string): Promise<${e}ResponseDTO | null>
+  findAll(): Promise<${e}ResponseDTO[]>
+  findPaginated(parsed: ParsedQuery): Promise<{ data: ${e}ResponseDTO[]; total: number }>
+  create(dto: Create${e}DTO): Promise<${e}ResponseDTO>
+  update(id: string, dto: Update${e}DTO): Promise<${e}ResponseDTO>
+  delete(id: string): Promise<void>
+}
+
+/**
+ * Collision-safe DI token bound to \`I${e}Repository\`.
+ * \`container.resolve(${e.toUpperCase()}_REPOSITORY)\` and
+ * \`@Inject(${e.toUpperCase()}_REPOSITORY)\` both return the typed
+ * interface — no manual generic, no \`any\` cast.
+ *
+ * The \`'${n}/'\` 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 ${e.toUpperCase()}_REPOSITORY = createToken<I${e}Repository>('${n}/${e}/repository')
+`}function cr(e,t){return`import { Service, Inject, HttpException } from '@forinda/kickjs'
+import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../repositories/${t}.repository'
+
+@Service()
+export class ${e}DomainService {
+  constructor(
+    @Inject(${e.toUpperCase()}_REPOSITORY) private readonly repo: I${e}Repository,
+  ) {}
+
+  async ensureExists(id: string): Promise<void> {
+    const entity = await this.repo.findById(id)
+    if (!entity) throw HttpException.notFound('${e} not found')
+  }
+}
+`}function lr(e,t,n,r){return[{file:`create-${t}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../../domain/repositories/${t}.repository'
+import type { Create${e}DTO } from '../dtos/create-${t}.dto'
+
+@Service()
+export class Create${e}UseCase {
+  constructor(@Inject(${e.toUpperCase()}_REPOSITORY) private repo: I${e}Repository) {}
+  async execute(dto: Create${e}DTO) { return this.repo.create(dto) }
+}
+`},{file:`get-${t}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../../domain/repositories/${t}.repository'
+
+@Service()
+export class Get${e}UseCase {
+  constructor(@Inject(${e.toUpperCase()}_REPOSITORY) private repo: I${e}Repository) {}
+  async execute(id: string) { return this.repo.findById(id) }
+}
+`},{file:`list-${n}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import type { ParsedQuery } from '@forinda/kickjs'
+import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../../domain/repositories/${t}.repository'
+
+@Service()
+export class List${r}UseCase {
+  constructor(@Inject(${e.toUpperCase()}_REPOSITORY) private repo: I${e}Repository) {}
+  async execute(parsed: ParsedQuery) { return this.repo.findPaginated(parsed) }
+}
+`},{file:`update-${t}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../../domain/repositories/${t}.repository'
+import type { Update${e}DTO } from '../dtos/update-${t}.dto'
+
+@Service()
+export class Update${e}UseCase {
+  constructor(@Inject(${e.toUpperCase()}_REPOSITORY) private repo: I${e}Repository) {}
+  async execute(id: string, dto: Update${e}DTO) { return this.repo.update(id, dto) }
+}
+`},{file:`delete-${t}.use-case.ts`,content:`import { Service, Inject } from '@forinda/kickjs'
+import { ${e.toUpperCase()}_REPOSITORY, type I${e}Repository } from '../../domain/repositories/${t}.repository'
+
+@Service()
+export class Delete${e}UseCase {
+  constructor(@Inject(${e.toUpperCase()}_REPOSITORY) private repo: I${e}Repository) {}
+  async execute(id: string) { return this.repo.delete(id) }
+}
+`}]}async function ur(e,t,n,r){let i=b(e,`index.ts`),a=await N(i),o=`./${n}/${r}.module`;if(!a){await A(i,`import type { AppModuleClass } from '@forinda/kickjs'\nimport { ${t}Module } from '${o}'\n\nexport const modules: AppModuleClass[] = [${t}Module]\n`);return}let s=await T(i,`utf-8`),c=`import { ${t}Module } from '${o}'`;if(!s.includes(`${t}Module`)){let e=s.lastIndexOf(`import `);if(e!==-1){let t=s.indexOf(`
+`,e);s=s.slice(0,t+1)+c+`
+`+s.slice(t+1)}else s=c+`
+`+s;s=s.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 E(i,s,`utf-8`)}async function dr(e){let{name:t,moduleName:n,modulesDir:r}=e,i=e.pluralize??!0,a=B(t),o=R(t),s=[],c;if(e.outDir)c=S(e.outDir);else if(n){let e=B(n),t=i?V(e):e;c=S(b(r??`src/modules`,t,`__tests__`))}else c=S(`src/__tests__`);let l=b(c,`${a}.test.ts`);return await A(l,`import { describe, it, expect, beforeEach } from 'vitest'
+import { Container } from '@forinda/kickjs'
+
+describe('${o}', () => {
+  beforeEach(() => {
+    Container.reset()
+  })
+
+  it('should be defined', () => {
+    // TODO: Import and test your class/function here
+    expect(true).toBe(true)
+  })
+
+  it('should handle the happy path', async () => {
+    // TODO: Set up test data and assertions
+    expect(true).toBe(true)
+  })
+
+  it('should handle edge cases', async () => {
+    // TODO: Test error handling, empty inputs, etc.
+    expect(true).toBe(true)
+  })
+})
+`),s.push(l),s}const fr=[`agents`,`claude`,`skills`,`both`,`all`];function W(e){return e.parent?.opts()?.dryRun??!1}function G(e,t=!1){let n=process.cwd();console.log(`\n  ${t?`Would generate`:`Generated`} ${e.length} file${e.length===1?``:`s`}:`);for(let t of e)console.log(`    ${t.replace(n+`/`,``)}`);t&&console.log(`
+  (dry run — no files were written)`),console.log()}async function pr(e){if(!e)try{let e=await r(process.cwd());await f({cwd:process.cwd(),allowDuplicates:!0,silent:!0,schemaValidator:e?.typegen?.schemaValidator??`zod`,envFile:e?.typegen?.envFile,srcDir:e?.typegen?.srcDir,outDir:e?.typegen?.outDir})}catch{}}const mr=[{name:`module <name>`,description:`Full DDD module (controller, DTOs, use-cases, repo)`},{name:`scaffold <name> <fields...>`,description:`CRUD module from field definitions`},{name:`controller <name>`,description:`@Controller() class            [-m module]`},{name:`service <name>`,description:`@Service() singleton             [-m module]`},{name:`middleware <name>`,description:`Express middleware function     [-m module]`},{name:`guard <name>`,description:`Route guard (auth, roles, etc.)  [-m module]`},{name:`dto <name>`,description:`Zod DTO schema                  [-m module]`},{name:`adapter <name>`,description:`AppAdapter with lifecycle hooks (app-level only)`},{name:`test <name>`,description:`Vitest test scaffold            [-m module]`},{name:`job <name>`,description:`Queue @Job processor`},{name:`config`,description:`Generate kick.config.ts`},{name:`agents`,description:`Regenerate AGENTS.md + CLAUDE.md + kickjs-skills.md from upstream templates`}];async function hr(){console.log(`
+  Built-in generators:
+`);let e=Math.max(...mr.map(e=>e.name.length));for(let t of mr)console.log(`    kick g ${t.name.padEnd(e+2)} ${t.description}`);let t=await r(process.cwd()),n=a(t?.plugins??[],t?.commands??[]),i=await Rt(process.cwd(),n.generators);if(i.generators.length>0){console.log(`
+  Plugin generators:
+`);let e=Math.max(...i.generators.map(e=>`${e.spec.name} <name>`.length));for(let{source:t,spec:n}of i.generators){let r=`${n.name} <name>`;console.log(`    kick g ${r.padEnd(e+2)} ${n.description}  [${t}]`)}}if(i.failed.length>0){console.log(`
+  Failed to load:
+`);for(let{source:e,reason:t}of i.failed)console.log(`    ${e} — ${t}`)}console.log()}async function gr(e,i,a){let o=await r(process.cwd()),s=n(o),c=i.modulesDir??s.dir??`src/modules`,l=i.repo??wn(s.repo),u=i.pattern??o?.pattern??`ddd`,d=i.pluralize===!1?!1:s.pluralize??!0,f=t(o,process.cwd()),p=[];for(let t of e){let e=await Tn({name:t,modulesDir:S(c),noEntity:i.entity===!1,noTests:i.tests===!1,repo:l,minimal:i.minimal,force:i.force,pattern:u,dryRun:a,pluralize:d,prismaClientPath:s.prismaClientPath,tokenScope:f});p.push(...e)}G(p,a),await pr(a)}function _r(e){let i=e.command(`generate [names...]`).alias(`g`).description("Generate code scaffolds — bare form `kick g <name>` is shorthand for `kick g module <name>`").option(`--list`,`List all available generators`).option(`--dry-run`,`Preview files that would be generated without writing them`).option(`--no-entity`,`Skip entity and value object generation (module shortcut)`).option(`--no-tests`,`Skip test file generation (module shortcut)`).option(`--repo <type>`,`Repository implementation: inmemory | drizzle | prisma`).option(`--pattern <pattern>`,`Override project pattern: rest | ddd | cqrs | minimal`).option(`--minimal`,`Shorthand for --pattern minimal`).option(`--modules-dir <dir>`,`Modules directory`).option(`--no-pluralize`,`Use singular names (skip auto-pluralization)`).option(`-f, --force`,`Overwrite existing files without prompting`).action(async(e,t,n)=>{if(t.list){await hr();return}if(!e||e.length===0){i.help();return}let o=W(n);if(k(o),e.length>=2){let[n,i,...s]=e,c=await r(process.cwd()),l=a(c?.plugins??[],c?.commands??[]),u=await Lt({generatorName:n,itemName:i,args:s,flags:t,cwd:process.cwd()},l.generators);if(u){G(u.files,o);return}}await gr(e,t,o)});i.command(`module <names...>`).description(`Generate one or more modules (e.g. kick g module user task project)`).option(`--no-entity`,`Skip entity and value object generation`).option(`--no-tests`,`Skip test file generation`).option(`--repo <type>`,`Repository implementation: inmemory | drizzle | prisma`).option(`--pattern <pattern>`,`Override project pattern: rest | ddd | cqrs | minimal`).option(`--minimal`,`Shorthand for --pattern minimal`).option(`--modules-dir <dir>`,`Modules directory`).option(`--no-pluralize`,`Use singular names (skip auto-pluralization)`).option(`-f, --force`,`Overwrite existing files without prompting`).action(async(e,t,n)=>{let r=W(n);k(r),await gr(e,t,r)}),i.command(`adapter <name>`).description(`Generate an AppAdapter with lifecycle hooks and middleware support`).option(`-o, --out <dir>`,`Output directory`,`src/adapters`).action(async(e,t,n)=>{let r=W(n);k(r),G(await Dn({name:e,outDir:S(t.out)}),r)}),i.command(`plugin <name>`).description(`Generate a KickPlugin with DI, modules, adapters, middleware, and lifecycle hooks`).option(`-o, --out <dir>`,`Output directory`,`src/plugins`).action(async(e,t,n)=>{let r=W(n);k(r),G(await On({name:e,outDir:S(t.out)}),r)}),i.command(`middleware <name>`).description(`Generate an Express middleware function
+  Use -m to scope it to a module: kick g middleware auth -m users`).option(`-o, --out <dir>`,`Output directory (overrides --module)`).option(`-m, --module <module>`,`Place inside a module folder`).action(async(e,t,i)=>{let a=W(i);k(a);let o=await r(process.cwd()),s=n(o),c=s.dir??`src/modules`;G(await Mn({name:e,outDir:t.out,moduleName:t.module,modulesDir:c,pattern:o?.pattern,pluralize:s.pluralize??!0}),a)}),i.command(`guard <name>`).description(`Generate a route guard (auth, roles, etc.)
+  Use -m to scope it to a module: kick g guard admin -m users`).option(`-o, --out <dir>`,`Output directory (overrides --module)`).option(`-m, --module <module>`,`Place inside a module folder`).action(async(e,t,i)=>{let a=W(i);k(a);let o=await r(process.cwd()),s=n(o),c=s.dir??`src/modules`;G(await Nn({name:e,outDir:t.out,moduleName:t.module,modulesDir:c,pattern:o?.pattern,pluralize:s.pluralize??!0}),a)}),i.command(`service <name>`).description(`Generate a @Service() class
+  Use -m to scope it to a module: kick g service payment -m orders`).option(`-o, --out <dir>`,`Output directory (overrides --module)`).option(`-m, --module <module>`,`Place inside a module folder`).action(async(e,t,i)=>{let a=W(i);k(a);let o=await r(process.cwd()),s=n(o),c=s.dir??`src/modules`;G(await Pn({name:e,outDir:t.out,moduleName:t.module,modulesDir:c,pattern:o?.pattern,pluralize:s.pluralize??!0}),a)}),i.command(`controller <name>`).description(`Generate a @Controller() class with basic routes
+  Use -m to scope it to a module: kick g controller auth -m users`).option(`-o, --out <dir>`,`Output directory (overrides --module)`).option(`-m, --module <module>`,`Place inside a module folder`).action(async(e,t,i)=>{let a=W(i);k(a);let o=await r(process.cwd()),s=n(o),c=s.dir??`src/modules`;G(await Fn({name:e,outDir:t.out,moduleName:t.module,modulesDir:c,pattern:o?.pattern,pluralize:s.pluralize??!0}),a),await pr(a)}),i.command(`dto <name>`).description(`Generate a Zod DTO schema
+  Use -m to scope it to a module: kick g dto create-user -m users`).option(`-o, --out <dir>`,`Output directory (overrides --module)`).option(`-m, --module <module>`,`Place inside a module folder`).action(async(e,t,i)=>{let a=W(i);k(a);let o=await r(process.cwd()),s=n(o),c=s.dir??`src/modules`;G(await In({name:e,outDir:t.out,moduleName:t.module,modulesDir:c,pattern:o?.pattern,pluralize:s.pluralize??!0}),a)}),i.command(`test <name>`).description(`Generate a Vitest test scaffold
+  Use -m to scope it to a module: kick g test user-service -m users`).option(`-o, --out <dir>`,`Output directory (overrides --module)`).option(`-m, --module <module>`,`Place inside a module's __tests__/ folder`).action(async(e,t,i)=>{let a=W(i);k(a);let o=n(await r(process.cwd())),s=o.dir??`src/modules`;G(await dr({name:e,outDir:t.out,moduleName:t.module,modulesDir:s,pluralize:o.pluralize??!0}),a)}),i.command(`job <name>`).description(`Generate a @Job queue processor with @Process handlers`).option(`-o, --out <dir>`,`Output directory`,`src/jobs`).option(`-q, --queue <name>`,`Queue name (default: <name>-queue)`).action(async(e,t,n)=>{let r=W(n);k(r),G(await Jn({name:e,outDir:S(t.out),queue:t.queue}),r)}),i.command(`scaffold <name> [fields...]`).description(`Generate a full CRUD module from field definitions
+  Example: kick g scaffold Post title:string body:text:optional published:boolean:optional
+  Types: string, text, number, int, float, boolean, date, email, url, uuid, json, enum:a,b,c
+  Optional: append :optional (shell-safe):  description:text:optional
+            or use ? with quoting:           "description:text?" or "description?:text"`).option(`--no-entity`,`Skip entity and value object generation`).option(`--no-tests`,`Skip test file generation`).option(`--no-pluralize`,`Use singular names (skip auto-pluralization)`).option(`--modules-dir <dir>`,`Modules directory`).action(async(e,i,a,o)=>{let s=W(o);k(s),i.length===0&&(console.error(`
+  Error: At least one field is required.
+  Usage: kick g scaffold <name> <field:type> [field:type...]
+  Example: kick g scaffold Post title:string body:text:optional published:boolean:optional
+  Optional: append :optional (shell-safe, no quoting needed)
+`),process.exit(1));let c=await r(process.cwd()),l=n(c),u=a.modulesDir??l.dir??`src/modules`,d=Xn(i),f=t(c,process.cwd()),p=await Zn({name:e,fields:d,modulesDir:S(u),noEntity:a.entity===!1,noTests:a.tests===!1,pluralize:a.pluralize===!1?!1:l.pluralize??!0,tokenScope:f});console.log(`\n  Scaffolded ${e} with ${d.length} field(s):`);for(let e of d)console.log(`    ${e.name}: ${e.type}${e.optional?` (optional)`:``}`);G(p,s),await pr(s)}),i.command(`auth-scaffold`).description(`Generate a complete auth module (register, login, logout, password hashing)
+  Includes controller, service, DTOs, and test stubs.`).option(`-s, --strategy <type>`,`Auth strategy: jwt | session`).option(`--role-guards`,`Generate role-based guards (default: true)`).option(`--no-role-guards`,`Skip role-based guard generation`).option(`-o, --out <dir>`,`Output directory`,`src/modules/auth`).action(async(e,t)=>{let n=W(t);k(n);let r=e.strategy;r||=await mt({message:`Auth strategy`,options:[{value:`jwt`,label:`JWT`,hint:`stateless token-based auth`},{value:`session`,label:`Session`,hint:`server-side session with cookies`}]});let i=e.roleGuards;i===void 0&&(i=await F({message:`Generate role-based guards?`,initialValue:!0})),G(await Un({strategy:r,outDir:e.out,roleGuards:i}),n)}),i.command(`config`).description(`Generate a kick.config.ts at the project root`).option(`--modules-dir <dir>`,`Modules directory path`,`src/modules`).option(`--repo <type>`,`Default repository type: inmemory | drizzle | prisma`,`inmemory`).option(`-f, --force`,`Overwrite existing kick.config.ts without prompting`).action(async(e,t)=>{let n=W(t);k(n),G(await Ln({outDir:S(`.`),modulesDir:e.modulesDir,defaultRepo:e.repo,force:e.force}),n)}),i.command(`agents`).alias(`agent-docs`).alias(`ai-docs`).description(`Regenerate AGENTS.md + CLAUDE.md + kickjs-skills.md (sync after framework upgrades)`).option(`--only <which>`,`Limit scope: agents | claude | skills | both (agents+claude) | all (default: all)`,`all`).option(`--name <name>`,`Project name (defaults to package.json name)`).option(`--pm <pm>`,`Package manager (defaults to package.json packageManager)`).option(`--template <template>`,`Template: rest | ddd | cqrs | minimal`).option(`-f, --force`,`Overwrite existing files without prompting`).action(async(e,t)=>{let n=W(t);k(n);let r=e.only??`all`;if(!fr.includes(r)){console.error(`  Invalid --only value: ${r}. Expected: ${fr.join(` | `)}`),process.exitCode=1;return}G(await Hn({outDir:S(`.`),only:r,name:e.name,pm:e.pm,template:e.template,force:e.force}),n)})}async function vr(e){let t=v.resolve(e.cwd,`.kickjs/types`);await pe(t,{recursive:!0});let n=new Map,r=e.scan??d,i={cwd:e.cwd,config:e.config,async importTs(e){return await import(C(e).href)},async writeFile(t,n){let r=v.resolve(e.cwd,t);await pe(v.dirname(r),{recursive:!0}),await E(r,n,`utf8`)},getScanResult:e=>{let t=yr(e),i=n.get(t);return i||(i=r(e),n.set(t,i)),i},log:console},a=[];for(let n of e.plugins){let r=await n.generate(i);if(r===null){a.push({id:n.id,status:`skipped`});continue}let o=n.outExtension??`.d.ts`,s=v.join(t,`${n.id.replace(/\//g,`__`)}${o}`),c=`/* AUTO-GENERATED by kick typegen — do not edit. Plugin: ${n.id} */\n\n`+r+`
+`,l=``;if(h(s)&&(l=await T(s,`utf8`)),l===c){a.push({id:n.id,status:`unchanged`,outFile:s});continue}if(e.check)throw Error(`kick typegen --check: drift detected for ${n.id} (${s})`);await E(s,c,`utf8`),a.push({id:n.id,status:`written`,outFile:s})}return a}function yr(e){let t=(e.extensions??[]).slice().toSorted().join(`,`),n=(e.exclude??[]).slice().toSorted().join(`,`);return[`root=${e.root}`,`cwd=${e.cwd}`,`extensions=${t}`,`exclude=${n}`,`envFile=${e.envFile??``}`].join(`|`)}function br(e,t){let n=new Set(t),r=[],i=[],a=new Set;for(let t of e)n.has(t.id)?(i.push(t),a.add(t.id)):r.push(t);return{enabled:r,skipped:i,unknown:[...n].filter(e=>!a.has(e))}}var xr=e({applyDisableFilter:()=>br,runAllPluginTypegens:()=>Sr});async function Sr(e){let{enabled:t,skipped:n,unknown:r}=br(a([...Zi,...e.config?.plugins??[]],e.config?.commands??[]).typegens,e.config?.typegen?.disable??[]);if(!e.silent&&n.length>0)for(let e of n)console.log(`  ${e.id}: disabled (typegen.disable)`);if(!e.silent&&r.length>0&&console.warn(`  kick typegen: disable list references unknown id(s): ${r.map(e=>`'${e}'`).join(`, `)}. Run \`kick typegen --list\` to see registered ids.`),t.length===0)return[];try{let n=await vr({cwd:e.cwd,config:e.config??{},plugins:t,check:e.check});if(!e.silent)for(let e of n)console.log(`  ${e.id}: ${e.status}`);return n}catch(t){if(!e.silent){let e=t instanceof Error?t.message:String(t);console.warn(`  kick typegen plugins: skipped (${e})`)}return[]}}async function Cr(e,t){let{cwd:n,silent:r=!1}=t,i=t.distDir??e?.build?.outDir??`dist`,a=e?.assetMap;if(!a||Object.keys(a).length===0)return null;let o=r?()=>{}:console.log,s=S(n,i);g(s,{recursive:!0});let c=[],l={};for(let[e,t]of Object.entries(a)){let r=await wr(e,t,n,s);c.push(r.entrySummary),Object.assign(l,r.manifestSlice),o(`    ✓ ${e}: ${r.entrySummary.filesCopied} file(s) → ${r.entrySummary.dest}`)}let u={version:1,entries:l},d=b(s,`.kickjs-assets.json`);return re(d,JSON.stringify(u,null,2)+`
+`,`utf-8`),o(`    ✓ wrote manifest → ${x(n,d)} (${Object.keys(l).length} entries)`),{manifestPath:d,entries:c,manifest:u}}async function wr(e,t,n,r){let i=S(n,t.src),a=t.dest?S(n,t.dest):b(r,e);if(Er(a,n))return console.warn(`  ⚠ assetMap.${e}.dest ('${t.dest}') resolves outside the project root — skipping copy`),{entrySummary:{namespace:e,src:t.src,dest:x(n,a),filesCopied:0},manifestSlice:{}};if(!h(i)||!Dr(i))return{entrySummary:{namespace:e,src:t.src,dest:x(n,a),filesCopied:0},manifestSlice:{}};let o=await ge(t.glob??`**/*`,{cwd:i,nodir:!0,dot:!1,posix:!0});g(a,{recursive:!0});let s={},{pairs:c,collisionGroupsResolved:l}=_e(e,[...o].toSorted(),{strategy:t.keys??`auto`});for(let{rel:e,key:t}of c){let n=b(i,e),o=b(a,e);g(y(o),{recursive:!0}),m(n,o),s[t]=Tr(r,o)}return l>0&&console.log(`  ℹ assetMap.${e}: auto-resolved ${l} basename collision(s) by keeping extensions (set 'keys: "strip"' to opt back into legacy last-write-wins behaviour, or 'keys: "with-extension"' to keep all keys verbose).`),{entrySummary:{namespace:e,src:t.src,dest:x(n,a),filesCopied:o.length},manifestSlice:s}}function Tr(e,t){return x(e,t).split(/[\\/]/).filter(Boolean).join(`/`)}function Er(e,t){let n=x(t,e);return n===``?!1:n.startsWith(`..`)||oe(n)}function Dr(e){try{return ne(e).isDirectory()}catch{return!1}}function Or(e){if(typeof e==`boolean`)return e;let t=process.env.KICKJS_WATCH_POLLING;return t===`1`||t===`true`}async function kr(e,t,n={}){t&&(process.env.PORT=t);let i=Or(n.polling),a=process.cwd(),o=await r(a),s=o?.typegen?.schemaValidator??`zod`,c=o?.typegen?.envFile;try{await f({cwd:a,allowDuplicates:!0,schemaValidator:s,envFile:c,srcDir:o?.typegen?.srcDir,outDir:o?.typegen?.outDir,assetMap:o?.assetMap,runPlugins:!1})}catch(e){console.warn(`  kick typegen: skipped (${e?.message??e})`)}await Sr({cwd:a,config:o});let{createRequire:l}=await import(`node:module`),{createServer:u}=await import(C(l(S(`package.json`)).resolve(`vite`)).href),d=await u({configFile:S(`vite.config.ts`),server:{port:t?parseInt(t,10):void 0,...i?{watch:{usePolling:!0,interval:100}}:{}}}),p=o?.assetMap?Object.values(o.assetMap).map(e=>e?.src).filter(e=>typeof e==`string`&&e.length>0).map(e=>S(a,e)):[],m=e=>p.some(t=>e===t||e.startsWith(`${t}/`)),h=null,g=e=>{if(e.includes(`.kickjs`)||e.endsWith(`.d.ts`))return;let t=/\.(ts|tsx|mts|cts)$/.test(e),n=m(e);!t&&!n||(h&&clearTimeout(h),h=setTimeout(()=>{f({cwd:a,silent:!0,allowDuplicates:!0,schemaValidator:s,envFile:c,srcDir:o?.typegen?.srcDir,outDir:o?.typegen?.outDir,assetMap:o?.assetMap,runPlugins:!1}).catch(()=>{}),Sr({cwd:a,config:o,silent:!0}).catch(()=>{})},100))};d.watcher.on(`add`,g),d.watcher.on(`unlink`,g),d.watcher.on(`change`,g),p.length>0&&d.watcher.add(p),await d.listen(),d.printUrls(),console.log(`
+  KickJS dev server running (Vite + @forinda/kickjs-vite)
+`);let _=async()=>{h&&clearTimeout(h),await d.close(),process.exit(0)};process.on(`SIGINT`,_),process.on(`SIGTERM`,_)}function Ar(e){e.command(`dev`).description(`Start development server with Vite HMR (zero-downtime reload)`).option(`-e, --entry <file>`,`Entry file`,`src/index.ts`).option(`-p, --port <port>`,`Port number`).option(`--polling`,`Force chokidar to poll for file changes (Docker / WSL / NFS / older kernels)`).action(async e=>{try{await kr(e.entry,e.port,{polling:e.polling})}catch(e){e.code===`ERR_MODULE_NOT_FOUND`&&e.message?.includes(`vite`)?console.error(`
+  Error: vite is not installed.
+  Run: pnpm add -D vite unplugin-swc
+`):console.error(`
+  Dev server failed:`,e.message??e),process.exit(1)}}),e.command(`build`).description(`Build for production via Vite`).action(async()=>{console.log(`
+  Building for production...
+`);let{createRequire:e}=await import(`node:module`),{build:t}=await import(C(e(S(`package.json`)).resolve(`vite`)).href);await t({configFile:S(`vite.config.ts`)});let n=await r(process.cwd()),i=n?.copyDirs??[];if(i.length>0){console.log(`
+  Copying directories to dist...`);for(let e of i){let t=typeof e==`string`?e:e.src,n=typeof e==`string`?b(`dist`,e):e.dest??b(`dist`,t),r=S(t),i=S(n);if(!h(r)){console.log(`    ⚠ Skipped ${t} (not found)`);continue}g(i,{recursive:!0}),m(r,i,{recursive:!0}),console.log(`    ✓ ${t} → ${n}`)}}if(n?.assetMap&&Object.keys(n.assetMap).length>0){console.log(`
+  Building asset map...`);try{await Cr(n,{cwd:process.cwd()})}catch(e){console.error(`    ✗ asset build failed: ${e instanceof Error?e.message:String(e)}`),process.exit(1)}}console.log(`
+  Build complete.
+`)}),e.command(`build:assets`).description(`Rebuild the .kickjs-assets.json manifest under the configured outDir (no JS rebuild)`).action(async()=>{let e=await r(process.cwd());if(!e?.assetMap||Object.keys(e.assetMap).length===0){console.log(`  No assetMap entries — nothing to build.`);return}console.log(`
+  Building asset map...`);try{await Cr(e,{cwd:process.cwd()}),console.log(`
+  Asset build complete.
+`)}catch(e){console.error(`  ✗ ${e instanceof Error?e.message:String(e)}`),process.exit(1)}}),e.command(`start`).description(`Start production server`).option(`-e, --entry <file>`,`Entry file`,`dist/index.js`).option(`-p, --port <port>`,`Port number`).action(e=>{let t={NODE_ENV:`production`};e.port&&(t.PORT=String(e.port)),Ae(e.entry,t)}),e.command(`dev:debug`).description(`Start dev server with Node.js inspector attached`).option(`-e, --entry <file>`,`Entry file`,`src/index.ts`).option(`-p, --port <port>`,`Port number`).option(`--inspect-port <port>`,`Inspector port`,`9229`).action(async e=>{let t=e.inspectPort??`9229`;process.env.NODE_OPTIONS=`--inspect=0.0.0.0:${t}`,console.log(`  Debugger: ws://0.0.0.0:${t}`);try{await kr(e.entry,e.port)}catch(e){console.error(`
+  Dev server (debug) failed:`,e.message??e),process.exit(1)}})}function jr(e){e.command(`info`).description(`Print system and framework info`).action(()=>{console.log(`
+  KickJS CLI
+
+  System:
+    OS:       ${ye()} ${be()} (${ve()})
+    Node:     ${process.version}
+
+  Packages:
+    @forinda/kickjs          workspace
+    @forinda/kickjs-vite     workspace
+    @forinda/kickjs-cli      workspace
+`)})}const{bold:K,dim:q,green:Mr,red:Nr,yellow:Pr,blue:Fr}=O;function Ir(e){let t=Math.floor(e/86400),n=Math.floor(e%86400/3600),r=Math.floor(e%3600/60),i=e%60,a=[];return t&&a.push(`${t}d`),n&&a.push(`${n}h`),r&&a.push(`${r}m`),a.push(`${i}s`),a.join(` `)}async function Lr(e){let t=await fetch(e,{signal:AbortSignal.timeout(5e3)});if(!t.ok)throw Error(`${t.status} ${t.statusText}`);return t.json()}async function J(e,t){try{return await Lr(`${e}${t}`)}catch{return null}}async function Rr(e){let[t,n,r,i,a]=await Promise.all([J(e,`/health`),J(e,`/metrics`),J(e,`/routes`),J(e,`/container`),J(e,`/ws`)]);return{health:t,metrics:n,routes:r,container:i,ws:a}}function zr(e,t){let{health:n,metrics:r,routes:i,container:a,ws:o}=t,s=q(`─`.repeat(60));if(console.log(),console.log(K(`  KickJS Inspector`)+q(`  →  ${e}`)),console.log(s),n){let e=n.status===`healthy`?Mr(`● healthy`):Nr(`● `+n.status);console.log(`  ${K(`Health:`)}    ${e}`)}else console.log(`  ${K(`Health:`)}    ${Nr(`● unreachable`)}`);if(r){let e=((r.errorRate??0)*100).toFixed(1),t=r.errorRate>.1?Nr:r.errorRate>0?Pr:Mr;console.log(`  ${K(`Uptime:`)}    ${Ir(r.uptimeSeconds)}`),console.log(`  ${K(`Requests:`)}  ${r.requests}`),console.log(`  ${K(`Errors:`)}    ${r.serverErrors} server, ${r.clientErrors??0} client  ${q(`(`)}${t(e+`%`)}${q(`)`)}`)}if(a&&console.log(`  ${K(`DI:`)}        ${a.count} bindings`),o&&o.enabled&&console.log(`  ${K(`WS:`)}        ${o.connections??0} connections, ${o.namespaces??0} namespaces`),i?.routes?.length){console.log(),console.log(K(`  Routes`)),console.log(s),console.log(`  ${q(`METHOD`)}  ${q(`PATH`.padEnd(36))} ${q(`CONTROLLER`)}`);for(let e of i.routes){let t=e.path.length>36?e.path.slice(0,33)+`...`:e.path.padEnd(36);console.log(`  ${lt(e.method)} ${t} ${Fr(e.controller)}.${q(e.handler)}`)}}console.log(s),console.log()}function Br(e){e.command(`inspect [url]`).description(`Connect to a running KickJS app and display debug info`).option(`-p, --port <port>`,`Override port`).option(`-w, --watch`,`Poll every 5 seconds`).option(`-j, --json`,`Output raw JSON`).action(async(e,t)=>{let n=e??`http://localhost:3000`;if(t.port)try{let e=new URL(n);e.port=t.port,n=e.origin}catch{n=`http://localhost:${t.port}`}let r=`${n.replace(/\/$/,``)}/_debug`,i=async()=>{try{let e=await Rr(r);t.json?console.log(JSON.stringify(e,null,2)):zr(n,e)}catch(e){t.json?console.log(JSON.stringify({error:String(e)})):(console.error(Nr(`  ✖ Could not connect to ${n}`)),console.error(q(`    ${e instanceof Error?e.message:String(e)}`))),t.watch||(process.exitCode=1)}};if(t.watch){let e=async()=>{process.stdout.write(`\x1B[2J\x1B[H`),await i()};await e(),setInterval(e,5e3)}else await i()})}function Vr(e,t){let n=e.toLowerCase();return t.every(e=>n.includes(e.toLowerCase()))}function Y(e,t){let n=e.toLowerCase();return t.some(e=>n.includes(e.toLowerCase()))}const Hr=[{match(e,t){let n=Vr(e,[`config`,`get`])&&Y(e,[`undefined`,`null`]),r=e.includes(`@Value`)&&Y(e,[`undefined`,`is not defined`]);return!n&&!r?null:{confidence:n&&r?90:75,diagnosis:{id:`env-schema-not-registered`,title:`ConfigService.get() returns undefined for user-defined keys`,explanation:`Your src/index.ts is missing \`import "./config"\`. That side-effect import
+registers the env schema with kickjs at module-load time. 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 via a raw process.env fallback, but Zod coercion and schema defaults
+are silently skipped.`,fix:`Add this line to src/index.ts near the top, before bootstrap() runs:`,codeBefore:`import 'reflect-metadata'
+import { bootstrap } from '@forinda/kickjs'
+import { modules } from './modules'
+`,codeAfter:`import 'reflect-metadata'
+import './config'  // ← add this — registers env schema
+import { bootstrap } from '@forinda/kickjs'
+import { modules } from './modules'
+`,docs:`https://forinda.github.io/kick-js/guide/configuration.html#wiring-the-schema-at-startup`}}}},{match(e,t){let n=Y(e,[`vitest`,`test`,`spec`,`__tests__`,`.test.`]);return Y(e,[`already registered`,`already exists`,`duplicate`,`has been registered`])?{confidence:n?85:60,diagnosis:{id:`container-not-reset-in-tests`,title:`DI container leaks between test cases`,explanation:`KickJS decorators register classes on the global Container at import time.
+When vitest re-imports your modules across tests, the same class can be
+registered twice and the container throws. The fix is to wipe the
+container between tests so each case starts fresh.`,fix:`Add Container.reset() to a beforeEach hook in the failing test file:`,codeAfter:`import { describe, it, beforeEach } from 'vitest'
+import { Container } from '@forinda/kickjs'
+
+describe('UserController', () => {
+  beforeEach(() => Container.reset())
+
+  it('does the thing', async () => { /* ... */ })
+})`,docs:`https://forinda.github.io/kick-js/guide/testing.html`}}:null}},{match(e,t){return e.includes(`@Module`)||Vr(e,[`Module`,`is not a function`])||Vr(e,[`Module`,`no exported member`])?{confidence:80,diagnosis:{id:`module-decorator-not-found`,title:`KickJS does not have a @Module decorator (different pattern from NestJS)`,explanation:`NestJS uses @Module({ controllers, providers }). KickJS uses an interface
+pattern instead: a class implements AppModule and exposes routes() that
+returns the controller wiring. This was a deliberate choice — modules
+become explicit values rather than metadata, which makes them easier to
+compose, test, and serialize.`,fix:`Replace the @Module decorator with an AppModule class:`,codeBefore:`import { Module } from '@forinda/kickjs'  // ← does not exist
+import { UserController } from './user.controller'
+
+@Module({
+  controllers: [UserController],
+})
+export class UserModule {}`,codeAfter:`import { type AppModule, type ModuleRoutes, buildRoutes } from '@forinda/kickjs'
+import { UserController } from './user.controller'
+
+export class UserModule implements AppModule {
+  routes(): ModuleRoutes {
+    return {
+      path: '/users',
+      router: buildRoutes(UserController),
+      controller: UserController,
+    }
+  }
+}`,docs:`https://forinda.github.io/kick-js/guide/project-structure.html`}}:null}},{match(e,t){return/KickRoutes\s*\[\s*['"](GET|POST|PUT|PATCH|DELETE)/i.test(e)?{confidence:95,diagnosis:{id:`legacy-kick-routes-bracket-syntax`,title:`KickRoutes['POST /users'] is the legacy v1 syntax`,explanation:`KickJS v2 changed the typegen output from a flat string-keyed map to a
+namespaced shape: KickRoutes.UserController["create"] instead of
+KickRoutes["POST /users"]. The new form is per-controller, per-method,
+and matches the actual class names so refactors propagate via
+rename-symbol instead of grep.`,fix:`Update the Ctx<...> type parameter to use the namespace form:`,codeBefore:`@Post('/', { body: createUserSchema })
+create(ctx: Ctx<KickRoutes['POST /users']>) { /* ... */ }`,codeAfter:`@Post('/', { body: createUserSchema, name: 'CreateUser' })
+create(ctx: Ctx<KickRoutes.UserController['create']>) { /* ... */ }`,docs:`https://forinda.github.io/kick-js/guide/typegen.html`}}:null}},{match(e,t){let n=Y(e,[`cluster`,`workers`,`two ports`,`duplicate server`]),r=Y(e,[`kick dev`,`vite`,`eaddrinuse`,`5173`,`5174`,`two servers`]);return!n||!r?null:{confidence:85,diagnosis:{id:`cluster-in-vite-dev`,title:"Cluster mode is incompatible with `kick dev` (Vite owns the server)",explanation:`In dev mode, Vite owns the HTTP server. If your bootstrap passes
+cluster: { workers: N }, the framework forks N workers, each of which
+spins up its own Vite instance on a separate port. The fix landed in
+v2.2.5: McpAdapter (and bootstrap()) now detects Vite dev mode and
+silently skips cluster, with a warning. If you see this on an older
+version, upgrade or guard the cluster option behind NODE_ENV.`,fix:`Either upgrade to v2.2.5+ or gate cluster mode on production:`,codeAfter:`export const app = await bootstrap({
+  modules,
+  cluster: process.env.NODE_ENV === 'production' ? { workers: 4 } : false,
+})`,docs:`https://forinda.github.io/kick-js/guide/cluster.html`}}}},{match(e,t){return Y(e,[`reflect-metadata`,`Reflect.getMetadata is not a function`,`Reflect.defineMetadata`,`design:type`,`design:paramtypes`])?{confidence:90,diagnosis:{id:`reflect-metadata-missing`,title:`reflect-metadata is not loaded — DI cannot read decorator types`,explanation:`The DI container reads constructor parameter types via the
+reflect-metadata polyfill. The polyfill must be imported once,
+before any decorator runs. Most projects do this at the top of
+src/index.ts; missing the import causes obscure "design:paramtypes"
+or "Reflect.getMetadata is not a function" errors at runtime.`,fix:`Add the import at the very top of src/index.ts:`,codeAfter:`import 'reflect-metadata'  // ← must be the FIRST import
+import './config'
+import { bootstrap } from '@forinda/kickjs'
+import { modules } from './modules'
+
+export const app = await bootstrap({ modules })`,docs:`https://forinda.github.io/kick-js/guide/dependency-injection.html`}}:null}},{match(e,t){return Y(e,[`404`,`cannot get`,`cannot post`,`no route`])?{confidence:50,diagnosis:{id:`module-not-registered`,title:`A 404 may indicate a module is not in the modules array`,explanation:`KickJS only mounts modules listed in \`src/modules/index.ts\`. If you
+generated a module via \`kick g module foo\` but the routes don't appear,
+the most likely cause is that the module is missing from the exported
+array. The CLI usually wires this automatically, but a hand-edit can
+drop the entry.`,fix:`Open src/modules/index.ts and verify the module is in the array:`,codeAfter:`import type { AppModuleClass } from '@forinda/kickjs'
+import { UserModule } from './users/user.module'
+import { TaskModule } from './tasks/task.module'  // ← was this missing?
+
+export const modules: AppModuleClass[] = [UserModule, TaskModule]`,docs:`https://forinda.github.io/kick-js/guide/project-structure.html`}}:null}}];function Ur(e,t){let n=null;for(let r of Hr){let i=null;try{i=r.match(e,t)}catch{continue}!i||i.confidence<40||(!n||i.confidence>n.confidence)&&(n=i)}return n}async function Wr(e){let t=e.provider??`openai`,n=process.env.OPENAI_API_KEY;if(t===`openai`&&!n)return{kind:`unavailable`,reason:`OPENAI_API_KEY environment variable is not set`,suggestion:`Set OPENAI_API_KEY in your shell, e.g.
+  export OPENAI_API_KEY="sk-..."
+
+Then re-run \`kick explain --ai "<your error>"\`.`};let r;try{r=await import(`@forinda/kickjs-ai`)}catch{return{kind:`unavailable`,reason:`@forinda/kickjs-ai is not installed`,suggestion:`Install the AI package to enable the LLM fallback:
+  kick add ai
+
+Or manually:
+  pnpm add @forinda/kickjs-ai`}}let{OpenAIProvider:i}=r,a=new i({apiKey:n,defaultChatModel:e.model??`gpt-4o-mini`}),o=Gr(e.cwd),s=`Error or stack trace:\n\n${e.input.trim()}`;try{let e=Kr((await a.chat({messages:[{role:`system`,content:o},{role:`user`,content:s}]})).content);return e?{kind:`ok`,diagnosis:e}:{kind:`error`,message:`The LLM responded but the payload was not valid JSON in the expected shape. Try again, or file an issue with the error text.`}}catch(e){return{kind:`error`,message:`LLM request failed: ${e instanceof Error?e.message:String(e)}`}}}function Gr(e){return[`You are a diagnostic assistant for KickJS, a decorator-driven Node.js`,`framework built on Express 5 and TypeScript. KickJS projects use:`,`  - @Controller, @Get, @Post, @Autowired, @Service, @Value decorators`,`  - An AppModule interface with a routes() method (NOT a @Module decorator)`,`  - Zod schemas as both runtime validators and OpenAPI sources`,`  - Ctx<KickRoutes.ControllerName['method']> for typed request context`,`  - src/config/index.ts with defineEnv/loadEnv for env schema`,'  - A side-effect `import "./config"` in src/index.ts to register the schema',`  - Container.reset() in beforeEach for DI test isolation`,``,`When the user gives you an error message or stack trace, produce a`,`structured diagnosis that helps them fix the bug. You MUST respond`,`with a single JSON object (no surrounding prose, no markdown fences)`,`matching this shape:`,``,`{`,`  "id": "<kebab-case-identifier>",`,`  "title": "<one-line problem summary>",`,`  "explanation": "<multi-line explanation of what is wrong>",`,`  "fix": "<multi-line instructions for fixing the problem>",`,`  "codeBefore": "<optional: broken code snippet>",`,`  "codeAfter": "<optional: corrected code snippet>",`,`  "docs": "<optional: KickJS doc URL that discusses this topic>"`,`}`,``,`The KickJS docs live at https://forinda.github.io/kick-js/ — prefer`,`that domain for any doc links you suggest.`,e?`The project is located at ${e}.`:``].filter(e=>e.length>0).join(`
+`)}function Kr(e){let t=[e,qr(e),Jr(e)].filter(e=>e!==null);for(let e of t)try{let t=JSON.parse(e);if(Yr(t))return t}catch{continue}return null}function qr(e){let t=e.match(/```(?:json)?\s*\n([\s\S]*?)```/);return t?t[1]?.trim()??null:null}function Jr(e){let t=e.indexOf(`{`);if(t===-1)return null;let n=0,r=!1,i=!1;for(let a=t;a<e.length;a++){let o=e[a];if(i){i=!1;continue}if(o===`\\`&&r){i=!0;continue}if(o===`"`){r=!r;continue}if(!r&&(o===`{`&&n++,o===`}`&&(n--,n===0)))return e.slice(t,a+1)}return null}function Yr(e){if(typeof e!=`object`||!e)return!1;let t=e;return typeof t.id==`string`&&typeof t.title==`string`&&typeof t.explanation==`string`&&typeof t.fix==`string`}function Xr(e){e.command(`explain [message]`).description(`Explain a KickJS error and suggest a fix`).option(`-m, --message <text>`,`Error message to explain (alternative to positional arg)`).option(`--ai`,`Fall back to LLM if no known-issue matches (requires @forinda/kickjs-ai)`).option(`--model <name>`,`Model name for the --ai fallback`,`gpt-4o-mini`).option(`--json`,`Output the diagnosis as JSON for tooling integration`).action(async(e,t)=>{let n=await $r(e,t.message);(!n||n.trim().length===0)&&(process.stderr.write(`Error: no input provided.
+
+Pass a message as a positional arg, --message flag, or pipe via stdin:
+  kick explain "config.get returned undefined"
+  pnpm test 2>&1 | kick explain
+`),process.exit(1));let r=ti(),i=Ur(n,r);if(t.json&&i){process.stdout.write(JSON.stringify({matched:!0,...i},null,2)+`
+`);return}if(i){ni(n,i.diagnosis,i.confidence);return}t.ai||(t.json&&(process.stdout.write(JSON.stringify({matched:!1},null,2)+`
+`),process.exit(2)),ri(n,!1),process.exit(2));let a=await Wr({input:n,model:t.model,cwd:r.cwd});t.json&&(process.stdout.write(JSON.stringify(Zr(a),null,2)+`
+`),process.exit(a.kind===`ok`?0:2)),Qr(n,a),process.exit(a.kind===`ok`?0:2)})}function Zr(e){return e.kind===`ok`?{matched:!0,source:`ai`,diagnosis:e.diagnosis}:e.kind===`unavailable`?{matched:!1,aiUnavailable:!0,reason:e.reason}:{matched:!1,aiError:!0,error:e.message}}function Qr(e,t){if(t.kind===`ok`){ni(e,t.diagnosis,-1,!0);return}if(t.kind===`unavailable`){process.stdout.write(`\n  Explaining: ${Z(e.trim(),200)}\n\n`),process.stdout.write(`  AI fallback unavailable: ${t.reason}\n\n`),process.stdout.write(`${X(t.suggestion,`  `)}\n\n`);return}process.stdout.write(`\n  Explaining: ${Z(e.trim(),200)}\n\n`),process.stdout.write(`  AI fallback error: ${t.message}\n\n`)}async function $r(e,t){return e&&e.trim().length>0?e:t&&t.trim().length>0?t:process.stdin.isTTY?``:ei()}function ei(){return new Promise((e,t)=>{let n=``;process.stdin.setEncoding(`utf8`),process.stdin.on(`data`,e=>{n+=e}),process.stdin.on(`end`,()=>e(n)),process.stdin.on(`error`,t)})}function ti(){let e=process.cwd();return{cwd:e,hasFile:t=>h(S(e,t))}}function ni(e,t,n,r=!1){let i=Z(e.trim(),200),a=r?`AI-generated — verify before applying`:ii(n);process.stdout.write(`\n  Explaining: ${i}\n`),process.stdout.write(`\n  Match: ${t.id}  (${a})\n`),process.stdout.write(`  Title: ${t.title}\n`),process.stdout.write(`\n  Diagnosis:\n${X(t.explanation,`    `)}\n`),process.stdout.write(`\n  Fix:\n${X(t.fix,`    `)}\n`),t.codeBefore&&process.stdout.write(`\n  Before:\n${X(t.codeBefore,`      `)}\n`),t.codeAfter&&process.stdout.write(`\n  After:\n${X(t.codeAfter,`      `)}\n`),t.docs&&process.stdout.write(`\n  Docs: ${t.docs}\n`),process.stdout.write(`
+`)}function ri(e,t){let n=Z(e.trim(),200);process.stdout.write(`\n  Explaining: ${n}\n\n`),t?process.stdout.write(`  No known-issue matched, and --ai fallback is not yet wired.
+  When @forinda/kickjs-ai ships its provider implementations,
+  this command will call the configured LLM with the error +
+  project context and return a structured fix.
+
+`):process.stdout.write(`  No known-issue matched. Things you can try:
+
+    1. Check the framework docs for the error keywords:
+       https://forinda.github.io/kick-js/
+
+    2. Re-run with --ai to fall back to an LLM (requires
+       @forinda/kickjs-ai with a configured provider):
+       kick explain --ai "<your error>"
+
+    3. File an issue with the error text:
+       https://github.com/forinda/kick-js/issues/new
+
+`)}function X(e,t){return e.split(`
+`).map(e=>`${t}${e}`).join(`
+`)}function Z(e,t){return e.length<=t?e:e.slice(0,t-1)+`…`}function ii(e){return e>=90?`high confidence`:e>=70?`good match`:e>=50?`medium confidence`:`low confidence — verify manually`}function ai(e){let t=e.command(`mcp`).description(`Model Context Protocol commands (start | init)`);t.command(`start`,{isDefault:!0}).description(`Run the built application as an MCP server over stdio`).option(`-e, --entry <file>`,`Entry file`,`dist/index.js`).option(`--node-arg <arg...>`,`Extra arguments to pass to node`).action(oi),t.command(`init`).description(`Generate .mcp.json for Claude Code / Cursor / Zed`).option(`-n, --name <name>`,`Server name (defaults to package.json name)`).option(`-o, --out <file>`,`Output file`,`.mcp.json`).option(`-f, --force`,`Overwrite an existing entry without prompting`).option(`--global`,`Write to ~/.mcp.json instead of the project root`).action(si)}function oi(e){let t=S(e.entry);h(t)||(process.stderr.write(`Error: entry file not found: ${t}\n\nBuild the app first with \`kick build\`, or pass a custom entry:\n  kick mcp -e dist/server.js\n`),process.exit(1));let n=[...e.nodeArg??[],t],r=ue(process.execPath,n,{stdio:`inherit`,env:{...process.env,KICK_MCP_STDIO:`1`,NODE_ENV:process.env.NODE_ENV??`production`}});r.on(`error`,e=>{process.stderr.write(`Failed to start MCP server: ${e.message}\n`),process.exit(1)}),r.on(`exit`,(e,t)=>{if(t){process.kill(process.pid,t);return}process.exit(e??0)});let i=e=>{r.killed||r.kill(e)};process.on(`SIGINT`,()=>i(`SIGINT`)),process.on(`SIGTERM`,()=>i(`SIGTERM`))}function si(e){let t=process.cwd(),n=ci(t)??ie(t),r=e.name??n,i=e.global?S(process.env.HOME??`.`,`.mcp.json`):S(t,e.out),a={command:`kick`,args:[`mcp`],cwd:t},o={mcpServers:{}};if(h(i))try{let e=_(i,`utf8`),t=JSON.parse(e);t&&typeof t==`object`&&t.mcpServers&&(o={mcpServers:{...t.mcpServers}})}catch(e){let t=e instanceof Error?e.message:String(e);process.stderr.write(`Error: existing ${i} is not valid JSON (${t}).\nFix the file or pass --force to overwrite the entry.\n`),process.exit(1)}o.mcpServers[r]&&!e.force&&(process.stderr.write(`Error: an entry for "${r}" already exists in ${i}.\nPass --force to overwrite it, or use --name to pick a different key.\n`),process.exit(1)),o.mcpServers[r]=a,re(i,JSON.stringify(o,null,2)+`
+`,`utf8`),process.stdout.write(`\n  ✓ Wrote MCP server entry "${r}" to ${i}\n\n  To activate it:\n    1. Build your app:    kick build\n    2. Restart your MCP client (Claude Code, Cursor, Zed)\n    3. The server should appear in the client's tool picker\n\n`)}function ci(e){let t=S(e,`package.json`);if(!h(t))return null;try{let e=_(t,`utf8`),n=JSON.parse(e);return typeof n.name==`string`?n.name:null}catch{return null}}function li(e){e.command(`tinker`).description(`Interactive REPL with DI container and services loaded`).option(`-e, --entry <file>`,`Entry file to load`,`src/index.ts`).action(async e=>{let t=process.cwd(),n=S(t,e.entry);h(n)||(console.error(`\n  Error: ${e.entry} not found.\n`),process.exit(1));let r=di(t,`tsx`);r||(console.error(`
+  Error: tsx not found. Install it: pnpm add -D tsx
+`),process.exit(1));let i=ui(n,e.entry),a=b(t,`.kick-tinker.mjs`),{writeFileSync:o,unlinkSync:s}=await import(`node:fs`);o(a,i,`utf-8`);try{let e=le(a,[],{cwd:t,execPath:r,stdio:`inherit`});await new Promise(t=>{e.on(`exit`,()=>t())})}finally{try{s(a)}catch{}}})}function ui(e,t){return`
+import 'reflect-metadata'
+
+// Prevent bootstrap() from starting the HTTP server
+process.env.KICK_TINKER = '1'
+
+console.log('\\n  🔧 KickJS Tinker')
+console.log('  Loading: ${t}\\n')
+
+// Load core
+let Container, Logger, HttpException, HttpStatus
+try {
+  const core = await import('@forinda/kickjs')
+  Container = core.Container
+  Logger = core.Logger
+  HttpException = core.HttpException
+  HttpStatus = core.HttpStatus
+} catch {
+  console.error('  Error: @forinda/kickjs not found.')
+  console.error('  Install it: pnpm add @forinda/kickjs\\n')
+  process.exit(1)
+}
+
+// Load entry to trigger decorator registration
+try {
+  await import('${C(e).href}')
+} catch (err) {
+  console.warn('  Warning: ' + err.message)
+  console.warn('  Container may be partially initialized.\\n')
+}
+
+const container = Container.getInstance()
+
+// Start REPL
+const repl = await import('node:repl')
+const server = repl.start({ prompt: 'kick> ', useGlobal: true })
+
+server.context.container = container
+server.context.Container = Container
+server.context.resolve = (token) => container.resolve(token)
+server.context.Logger = Logger
+server.context.HttpException = HttpException
+server.context.HttpStatus = HttpStatus
+
+console.log('  Available globals:')
+console.log('    container    — DI container instance')
+console.log('    resolve(T)   — shorthand for container.resolve(T)')
+console.log('    Container, Logger, HttpException, HttpStatus')
+console.log()
+
+server.on('exit', () => {
+  console.log('\\n  Goodbye!\\n')
+  process.exit(0)
+})
+`}function di(e,t){let n=e;for(;;){let e=b(n,`node_modules`,`.bin`,t);if(h(e))return e;let r=S(n,`..`);if(r===n)break;n=r}return null}async function fi(e){let{name:t,modulesDir:n,force:r}=e,i=e.pluralize!==!1,a=B(t),o=R(t),s=i?V(a):a,c=b(n,s);if(!await N(c)){console.log(`\n  Module not found: ${c}\n`);return}if(!r&&!await F({message:O.red(`Delete module '${s}' at ${c}? This cannot be undone.`),initialValue:!1})){console.log(`
+  Cancelled.
+`);return}await me(c,{recursive:!0,force:!0}),console.log(`  Deleted: ${c}`);let l=b(n,`index.ts`);if(await N(l)){let e=await T(l,`utf-8`),t=e,n=RegExp(`^import\\s*\\{\\s*${o}Module\\s*\\}\\s*from\\s*['"][^'"]*${s}(?:/[^'"]*)?['"].*\\n?`,`gm`);e=e.replace(n,``),e=e.replace(RegExp(`\\s*,?\\s*${o}Module\\s*,?`,`g`),e=>{let t=e.trimStart().startsWith(`,`),n=e.trimEnd().endsWith(`,`);return t&&n?`,`:``}),e=e.replace(/,(\s*])/,`$1`),e=e.replace(/\n{3,}/g,`
+
+`),e!==t&&(await E(l,e,`utf-8`),console.log(`  Unregistered: ${o}Module from ${l}`))}console.log(`\n  Module '${s}' removed.\n`)}function pi(e){e.command(`remove`).alias(`rm`).description(`Remove generated code`).command(`module <names...>`).description(`Remove one or more modules (e.g. kick rm module user task)`).option(`--modules-dir <dir>`,`Modules directory`).option(`--no-pluralize`,`Use singular module name`).option(`-f, --force`,`Skip confirmation prompt`).action(async(e,t)=>{let i=n(await r(process.cwd())),a=t.modulesDir??i.dir??`src/modules`,o=t.pluralize===!1?!1:i.pluralize??!0;for(let n of e)await fi({name:n,modulesDir:S(a),force:t.force,pluralize:o})})}function mi(e){if(e!==void 0){if(e===`false`||e===`off`||e===`none`)return!1;if(e===`zod`)return`zod`;console.warn(`  kick typegen: unknown --schema-validator '${e}' (only 'zod' and 'false' are supported). Falling back to project config.`)}}function hi(e){if(e!==void 0)return e===`false`||e===`off`||e===`none`?!1:e}function gi(e){e.command(`typegen`).description(`Generate type-safe DI registry and module types into .kickjs/types/`).option(`-w, --watch`,`Watch source files and regenerate on change`).option(`-s, --src <dir>`,`Source directory to scan`,`src`).option(`-o, --out <dir>`,`Output directory`,`.kickjs/types`).option(`--silent`,`Suppress output`).option(`--allow-duplicates`,`Auto-namespace duplicate class names instead of failing (use with caution)`).option(`--schema-validator <name>`,`Schema validator for body/query/params typing (currently 'zod' or 'false')`).option(`--env-file <path>`,`Path to env schema file for KickEnv typing (default 'src/env.ts'; pass 'false' to disable)`).option(`--check`,`CI gate: fail on plugin-typegen drift instead of writing`).option(`--list`,"List every registered typegen plugin id (use to populate `typegen.disable`)").action(async e=>{let t=process.cwd(),n=await r(t);if(e.list){let{mergeCliPlugins:e}=await import(`./plugin-Dv2gKsuC.mjs`).then(e=>e.t),{builtinCliPlugins:t}=await Promise.resolve().then(()=>Xi),r=e([...t,...n?.plugins??[]],n?.commands??[]),i=new Set(n?.typegen?.disable??[]);if(r.typegens.length===0){console.log(`  No typegen plugins registered.`);return}let a=Math.max(...r.typegens.map(e=>e.id.length));console.log(`
+  Registered typegen plugins:
+`);for(let e of r.typegens){let t=i.has(e.id)?` (disabled)`:``;console.log(`    ${e.id.padEnd(a+2)}inputs: ${e.inputs.join(`, `)||`(none)`}${t}`)}console.log();return}let i=mi(e.schemaValidator)??n?.typegen?.schemaValidator??`zod`,a=hi(e.envFile)??n?.typegen?.envFile,o={cwd:t,srcDir:e.src??n?.typegen?.srcDir,outDir:e.out??n?.typegen?.outDir,silent:e.silent,allowDuplicates:e.allowDuplicates,schemaValidator:i,envFile:a,assetMap:n?.assetMap,runPlugins:!1};try{if(e.watch){let t=await u(o);e.silent||console.log(`  kick typegen: watching for changes (Ctrl-C to exit)`);let n=()=>{t(),process.exit(0)};process.on(`SIGINT`,n),process.on(`SIGTERM`,n),await new Promise(()=>{})}else{await f(o);let r=await Sr({cwd:t,config:n??null,silent:e.silent,check:e.check});e.check&&r.some(e=>e.status===`written`)&&process.exit(1)}}catch(e){e instanceof c?console.error(`
+`+e.message+`
+`):e instanceof Error?console.error(`\n  kick typegen failed: ${e.message}`):console.error(`\n  kick typegen failed: ${JSON.stringify(e)}`),process.exit(1)}})}function _i(e){let t=[];if(!h(e))return t;let n=ee(e,{withFileTypes:!0});for(let r of n){let n=b(e,r.name);if(r.isDirectory()){if([`node_modules`,`dist`,`.kickjs`,`.git`].includes(r.name))continue;t.push(..._i(n))}else r.isFile()&&/\.tsx?$/.test(r.name)&&!r.name.endsWith(`.d.ts`)&&t.push(n)}return t}function vi(e){try{return _(e,`utf-8`)}catch{return``}}const yi=new Set([`secret`,`changeme`,`password`,`test`,`default`,``]);function bi(e,t){let n=vi(b(e,`.env`));if(n){let e=n.match(/^JWT_SECRET\s*=\s*['"]?([^'"\n]*)['"]?/m);if(e){let t=e[1].trim();if(yi.has(t.toLowerCase())||t.length<32)return{severity:`CRITICAL`,message:`JWT_SECRET appears to be a default value or too short (< 32 chars) — change it`}}}for(let e of t)for(let t of[/JWT_SECRET['"]?\s*[:=]\s*['"]?(secret|changeme|password|test|default)['"]?/i,/secret\s*[:=]\s*['"]?(secret|changeme|password|test|default)['"]?/i])if(t.test(e))return{severity:`CRITICAL`,message:`JWT_SECRET appears to be a default value in source code — use an environment variable`};return null}function xi(e){for(let t of e)if(/cors\s*\(/.test(t)&&/origin\s*:\s*['"]\*['"]/.test(t))return{severity:`CRITICAL`,message:`CORS origin is '*' — restrict to your domains`};return null}function Si(e){for(let t of e)if(/rateLimit/i.test(t)||/@RateLimit/i.test(t))return null;return{severity:`WARNING`,message:`No rate limiting detected — add rateLimit() middleware or @RateLimit decorator`}}function Ci(){return process.env.NODE_ENV===`production`?null:{severity:`WARNING`,message:`NODE_ENV is '${process.env.NODE_ENV??`undefined`}', not 'production'`}}function wi(e){let t=!1,n=!1;for(let r of e)/tokenStore/i.test(r)&&(t=!0),/MemoryTokenStore/i.test(r)&&(n=!0);return n?{severity:`WARNING`,message:`MemoryTokenStore detected — use a persistent store (Redis, DB) for production deployments`}:t?null:{severity:`WARNING`,message:`No token revocation store detected — consider adding one for auth token management`}}function Ti(e){for(let t of e)if(/helmet\s*\(/.test(t))return/security\s*\.\s*helmet\s*.*false/.test(t)?{severity:`WARNING`,message:`Helmet security headers are disabled — enable them for production`}:{severity:`INFO`,message:`Helmet security headers active`};return{severity:`WARNING`,message:`Helmet not detected — add helmet() middleware for security headers`}}function Ei(e){for(let t of e)if(/AuthAdapter/i.test(t))return{severity:`INFO`,message:`AuthAdapter configured`};return{severity:`INFO`,message:`No AuthAdapter detected — add one if your app requires authentication`}}function Di(e){let t=_i(b(e,`src`)).map(e=>vi(e)),n=[],r=bi(e,t);r&&n.push(r);let i=xi(t);i&&n.push(i);let a=Si(t);a&&n.push(a);let o=Ci();o&&n.push(o);let s=wi(t);return s&&n.push(s),n.push(Ti(t)),n.push(Ei(t)),n}function Oi(e){e.command(`check`).description(`Audit project for common issues`).option(`--deploy`,`Run production readiness checks`).action(e=>{if(!e.deploy){console.log(`
+  Usage: kick check --deploy
+
+  Available checks:
+    --deploy    Audit for production readiness (security, config, best practices)
+`);return}let t=process.cwd();dt(`KickJS Deploy Check`);let n=gt();n.start(`Scanning project...`);let r=Di(t);n.stop(`Scan complete`);let i={CRITICAL:0,WARNING:1,INFO:2};r.sort((e,t)=>i[e.severity]-i[t.severity]);for(let e of r)I.message(`${ut(e.severity)} ${e.message}`);let a=r.filter(e=>e.severity===`CRITICAL`).length,o=r.filter(e=>e.severity===`WARNING`).length,s=r.filter(e=>e.severity===`INFO`).length,c=o===1?`warning`:`warnings`,l=[a>0?O.red(`${a} critical`):`${a} critical`,o>0?O.yellow(`${o} ${c}`):`${o} ${c}`,`${s} info`].join(`, `);a>0?(P(O.red(`${l} — fix critical issues before deploying`)),process.exit(1)):P(O.green(`${l} — looking good!`))})}async function Q(e){return Oe({configPath:v.resolve(process.cwd(),e.config)})}async function $(e){if(e.adapter){let t=await e.adapter();return{adapter:t,cleanup:async()=>t.close()}}if(!e.connectionString)throw Error(`kickjs-db: no adapter resolved — set db.connectionString (or DATABASE_URL) in kick.config.ts, or supply db.adapter() factory`);let t=e.dialect??`postgres`;if(t!==`postgres`)throw Error(`kickjs-db: built-in CLI adapter only supports postgres in M1 (dialect=${t}); use db.adapter() factory for other dialects`);let[{pgAdapter:n},r]=await Promise.all([import(`@forinda/kickjs-db-pg`),import(`pg`)]),i=new r.default.Pool({connectionString:e.connectionString}),a=n({pool:i});return{adapter:a,cleanup:async()=>{await a.close(),await i.end()}}}function ki(e){if(e.length===0){console.log(`No migrations.`);return}console.table(e.map(e=>({id:e.id,state:e.state,batch:e.batch??`-`,reviewed:e.reviewed,applied:e.appliedAt??`-`})))}function Ai(e){let t=e.command(`db`).description(`Database commands (kickjs-db)`);t.command(`generate <name>`).description(`Generate a new migration from schema diff`).option(`-c, --config <path>`,`Path to kick.config.ts`,`kick.config.ts`).option(`-e, --empty`,`Skip schema diff and create an empty migration shell (data migration, seed, freeform SQL)`).action(async(e,t)=>{let n=process.cwd(),r=await xe({name:e,config:await Q(t),cwd:n,empty:t.empty});if(r.status===`no-changes`){console.log(`No schema changes detected.`);return}if(r.empty){console.log(`Created empty migration ${r.migrationDir} (author up.sql + down.sql).`);return}let i=r.changeCount===1?``:`s`;console.log(`Created migration ${r.migrationDir} (${r.changeCount} change${i}).`)});let n=t.command(`migrate`).description(`Migration runner subcommands`);n.command(`latest`).description(`Apply all pending migrations in a new batch`).option(`-c, --config <path>`,`Path to kick.config.ts`,`kick.config.ts`).action(async e=>{let t=await Q(e),{adapter:n,cleanup:r}=await $(t);try{let e=await Ce({adapter:n,migrationsDir:t.migrationsDir});e.applied.length===0?console.log(`No pending migrations.`):console.log(`Applied batch ${e.batch}: ${e.applied.join(`, `)}`)}finally{await r()}}),n.command(`up`).description(`Apply the next single pending migration`).option(`-c, --config <path>`,`Path to kick.config.ts`,`kick.config.ts`).action(async e=>{let t=await Q(e),{adapter:n,cleanup:r}=await $(t);try{let e=await Ee({adapter:n,migrationsDir:t.migrationsDir});e.applied.length===0?console.log(`No pending migrations.`):console.log(`Applied ${e.applied[0]} (batch ${e.batch})`)}finally{await r()}}),n.command(`down`).description(`Reverse the most recent applied migration`).option(`-c, --config <path>`,`Path to kick.config.ts`,`kick.config.ts`).action(async e=>{let t=await Q(e),{adapter:n,cleanup:r}=await $(t);try{let e=await Se({adapter:n,migrationsDir:t.migrationsDir});e.reversed?console.log(`Reversed ${e.reversed}.`):console.log(`Nothing to reverse.`)}finally{await r()}}),n.command(`rollback`).description(`Reverse the entire last batch as a single unit`).option(`-c, --config <path>`,`Path to kick.config.ts`,`kick.config.ts`).action(async e=>{let t=await Q(e),{adapter:n,cleanup:r}=await $(t);try{let e=await we({adapter:n,migrationsDir:t.migrationsDir});e.reversed.length===0?console.log(`Nothing to roll back.`):console.log(`Rolled back batch ${e.batch}: ${e.reversed.join(`, `)}`)}finally{await r()}}),n.command(`status`).description(`Print applied + pending migrations`).option(`-c, --config <path>`,`Path to kick.config.ts`,`kick.config.ts`).action(async e=>{let t=await Q(e),{adapter:n,cleanup:r}=await $(t);try{ki(await Te({adapter:n,migrationsDir:t.migrationsDir}))}finally{await r()}}),t.command(`introspect`).description(`Generate a TypeScript schema file from a live database`).option(`-c, --config <path>`,`Path to kick.config.ts`,`kick.config.ts`).option(`--out <path>`,`Output file (defaults to db.schemaPath from config)`).option(`--json`,`Print the raw SchemaSnapshot JSON to stdout instead of writing TS source`).action(async e=>{let t=await Q(e),{adapter:n,cleanup:r}=await $(t);try{let r=await n.introspect();if(e.json){console.log(JSON.stringify(r,null,2));return}let i=e.out??t.schemaPath;await E(i,De(r),`utf8`);let a=Object.keys(r.tables).length;console.log(`Wrote ${i} (${a} table${a===1?``:`s`}).`)}finally{await r()}})}const ji=[`src/db/schema.ts`,`src/db/schema/index.ts`,`src/db/schema`],Mi=()=>({id:`kick/db`,inputs:[`src/db/schema.ts`,`src/db/schema/**/*.ts`],async generate(e){let t=Ni(e.cwd);if(!t)return null;let n=v.resolve(e.cwd,`.kickjs/types`);return[`import type { SchemaToTypes, KickDbClient } from '@forinda/kickjs-db'`,`import type * as appSchema from '${Pi(v.relative(n,t)).replace(/\.ts$/,``).replace(/\/index$/,``)}'`,``,`declare global {`,`  interface KickDbSchema extends SchemaToTypes<typeof appSchema> {}`,`}`,``,`declare module '@forinda/kickjs-db' {`,`  interface KickDbRegister {`,`    db: KickDbClient<KickDbSchema>`,`  }`,`}`].join(`
+`)}});function Ni(e){for(let t of ji){let n=v.resolve(e,t);if(t.endsWith(`.ts`)){if(h(n))return n}else{let e=v.join(n,`index.ts`);if(h(e))return e}}return null}function Pi(e){return e.replace(/\\/g,`/`)}const Fi=()=>({id:`kick/assets`,inputs:[`kick.config.ts`,`kick.config.js`,`kick.config.mjs`],async generate(e){if(!h(v.resolve(e.cwd,`kick.config.ts`)))return null;let t=await r(e.cwd);if(!t?.assetMap)return null;let n=s(t.assetMap,e.cwd);return n.count===0?null:l(n)}}),Ii="/* eslint-disable */\n// AUTO-GENERATED by `kick typegen`. DO NOT EDIT.\n// Re-run with `kick typegen` or rely on `kick dev` to refresh.\n";function Li(e,t,n){if(e.length===0)return`${Ii}
+// (no routes discovered yet — annotate a controller method with
+//  @Get/@Post/@Put/@Delete/@Patch and re-run \`kick typegen\`)
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace KickRoutes {}
+}
+
+export {}
+`;let r=new Map;for(let t of e){let e=r.get(t.controller)??[];e.push(t),r.set(t.controller,e)}let i=new Map,a=(e,r)=>{let a=Bi(e,r,t,n,i);return a?`import('zod').infer<typeof ${a}>`:null},o=[];for(let[e,t]of r){let n=[`    interface ${e} {`];for(let e of t){let t=e.pathParams.length>0?`{ ${e.pathParams.map(e=>`${e}: string`).join(`; `)} }`:`{}`,r=a(e.bodySchema,e.filePath),i=a(e.querySchema,e.filePath),o=a(e.paramsSchema,e.filePath)??t,s=r??`unknown`,c=i??Ri(e),l=zi(e);n.push(`      /**`,`       * ${e.httpMethod} ${e.path}`,...l.map(e=>`       * ${e}`),`       */`,`      ${e.method}: {`,`        params: ${o}`,`        body: ${s}`,`        query: ${c}`,`        response: unknown`,`      }`)}n.push(`    }`),o.push(n.join(`
+`))}return`${Ii}${Vi(i)}
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace KickRoutes {
+${o.join(`
+`)}
+  }
+}
+
+export {}
+`}function Ri(e){if(e.queryFilterable===null)return`unknown`;let t=e.querySortable??[];return`{ filter?: string | string[]; sort?: ${t.length>0?t.flatMap(e=>[`'${e}'`,`'-${e}'`]).join(` | `):`string`}; q?: string; page?: string; limit?: string }`}function zi(e){let t=[];return e.queryFilterable&&e.queryFilterable.length>0&&t.push(`Filterable: ${e.queryFilterable.join(`, `)}`),e.querySortable&&e.querySortable.length>0&&t.push(`Sortable: ${e.querySortable.join(`, `)}`),e.querySearchable&&e.querySearchable.length>0&&t.push(`Searchable: ${e.querySearchable.join(`, `)}`),t}function Bi(e,t,n,r,i){if(!e||r!==`zod`||e.source===null)return null;let a=Hi(e.source,t,n);if(a===`unknown`)return null;let o=`${a}::${e.identifier}`,s=i.get(o)?.specifier;return s?s=i.get(o).specifier:(s=`_S${i.size}`,i.set(o,{identifier:e.identifier,specifier:s})),s}function Vi(e){if(e.size===0)return``;let t=[];for(let[n,r]of e){let[e]=n.split(`::`);t.push(`import type { ${r.identifier} as ${r.specifier} } from '${e}'`)}return t.join(`
+`)+`
+`}function Hi(e,t,n){if(e===null)return`unknown`;let r=y(n);if(e===``){let e=x(r,t).split(se).join(`/`);return e=e.replace(/\.(ts|tsx|mts|cts)$/i,``),e.startsWith(`.`)||(e=`./`+e),e}if(!e.startsWith(`.`)&&!e.startsWith(`/`))return e;let i=x(r,S(y(t),e)).split(se).join(`/`);return i=i.replace(/\.(ts|tsx|mts|cts)$/i,``),i.startsWith(`.`)||(i=`./`+i),i}const Ui=()=>({id:`kick/routes`,outExtension:`.ts`,inputs:[`src/**/*.controller.ts`,`src/**/*.module.ts`],async generate(e){let t=await e.getScanResult({root:Wi(e),cwd:e.cwd,envFile:Gi(e)}),n=e.config?.typegen?.schemaValidator??`zod`,r=v.resolve(e.cwd,`.kickjs/types/kick__routes.ts`);return Li(t.routes,r,n)}});function Wi(e){return v.resolve(e.cwd,e.config?.typegen?.srcDir??`src`)}function Gi(e){let t=e.config?.typegen?.envFile;if(t!==!1)return t}function Ki(e,t){if(!e)return null;let n=x(y(t),e.filePath).split(se).join(`/`);return n=n.replace(/\.(ts|tsx|mts|cts)$/i,``),n.startsWith(`.`)||(n=`./`+n),`/* eslint-disable */
+// AUTO-GENERATED by \`kick typegen\`. DO NOT EDIT.
+// Re-run with \`kick typegen\` or rely on \`kick dev\` to refresh.
+
+// Importing the schema as a type lets us infer its shape without
+// pulling in any runtime code. \`Awaited<>\` strips an accidental
+// Promise wrap on dynamic-imported defaults.
+import type _envSchema from '${n}'
+
+// Local type alias — interfaces can only \`extend\` an identifier,
+// not an inline import expression, so we resolve the schema's
+// inferred shape into a named type first.
+type _KickEnvShape = import('zod').infer<typeof _envSchema>
+
+declare global {
+  /**
+   * Typed environment registry. Augmented from \`${e.relativePath}\`
+   * so \`@Value('PORT')\`, \`Env<'PORT'>\`, and \`process.env.PORT\` are
+   * all type-safe and autocomplete.
+   */
+  interface KickEnv extends _KickEnvShape {}
+
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace NodeJS {
+    /**
+     * Narrow \`process.env\` so known keys exist as \`string\` (the raw
+     * pre-Zod-coercion form). \`@Value\` and the \`ConfigService\` apply
+     * the schema's transforms internally; access \`process.env\` directly
+     * only when you need the raw string. Unknown keys still resolve to
+     * \`string | undefined\` via the base @types/node declaration.
+     */
+    interface ProcessEnv extends Record<keyof KickEnv, string> {}
+  }
+}
+
+export {}
+`}const qi=()=>({id:`kick/env`,outExtension:`.ts`,inputs:[`src/env.ts`,`src/**/env.ts`,`src/**/*.env.ts`],async generate(e){let t=Yi(e);if(t===!1)return null;let n=await e.getScanResult({root:Ji(e),cwd:e.cwd,envFile:t});if(!n.env)return null;let r=v.resolve(e.cwd,`.kickjs/types/kick__env.ts`);return Ki(n.env,r)}});function Ji(e){return v.resolve(e.cwd,e.config?.typegen?.srcDir??`src`)}function Yi(e){return e.config?.typegen?.envFile}var Xi=e({builtinCliPlugins:()=>Zi});const Zi=[o({name:`kick/init`,register:Et}),o({name:`kick/generate`,register:_r}),o({name:`kick/run`,register:Ar}),o({name:`kick/info`,register:jr}),o({name:`kick/inspect`,register:Br}),o({name:`kick/add`,register:wt}),o({name:`kick/list`,register:Ct}),o({name:`kick/explain`,register:Xr}),o({name:`kick/mcp`,register:ai}),o({name:`kick/tinker`,register:li}),o({name:`kick/remove`,register:pi}),o({name:`kick/typegen`,register:gi}),o({name:`kick/check`,register:Oi}),o({name:`kick/db`,register:Ai,typegens:[Mi()]}),o({name:`kick/assets`,typegens:[Fi()]}),o({name:`kick/routes`,typegens:[Ui()]}),o({name:`kick/env`,typegens:[qi()]})];export{ke as i,Xi as n,xr as r,Zi as t};