@forinda/kickjs-cli 0.7.0 → 1.1.0

package/dist/cli.js

@@ -5,7 +5,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/cli.ts
 import { Command } from "commander";
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname3, join as join11 } from "path";
+import { dirname as dirname3, join as join16 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/init.ts
@@ -44,11 +44,35 @@ var __dirname = dirname2(fileURLToPath(import.meta.url));
 var cliPkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
 var KICKJS_VERSION = `^${cliPkg.version}`;
 async function initProject(options) {
-  const { name, directory, packageManager = "pnpm" } = options;
+  const { name, directory, packageManager = "pnpm", template = "rest" } = options;
   const dir = directory;
   console.log(`
   Creating KickJS project: ${name}
 `);
+  const baseDeps = {
+    "@forinda/kickjs-core": KICKJS_VERSION,
+    "@forinda/kickjs-http": KICKJS_VERSION,
+    "@forinda/kickjs-config": KICKJS_VERSION,
+    express: "^5.1.0",
+    "reflect-metadata": "^0.2.2",
+    zod: "^4.3.6",
+    pino: "^10.3.1",
+    "pino-pretty": "^13.1.3"
+  };
+  if (template !== "minimal") {
+    baseDeps["@forinda/kickjs-swagger"] = KICKJS_VERSION;
+  }
+  if (template === "graphql") {
+    baseDeps["@forinda/kickjs-graphql"] = KICKJS_VERSION;
+    baseDeps["graphql"] = "^16.11.0";
+  }
+  if (template === "microservice") {
+    baseDeps["@forinda/kickjs-queue"] = KICKJS_VERSION;
+    baseDeps["@forinda/kickjs-otel"] = KICKJS_VERSION;
+  }
+  if (template === "ddd") {
+    baseDeps["@forinda/kickjs-swagger"] = KICKJS_VERSION;
+  }
   await writeFileSafe(join(dir, "package.json"), JSON.stringify({
     name,
     version: cliPkg.version,
@@ -64,17 +88,7 @@ async function initProject(options) {
       lint: "eslint src/",
       format: "prettier --write src/"
     },
-    dependencies: {
-      "@forinda/kickjs-core": KICKJS_VERSION,
-      "@forinda/kickjs-http": KICKJS_VERSION,
-      "@forinda/kickjs-config": KICKJS_VERSION,
-      "@forinda/kickjs-swagger": KICKJS_VERSION,
-      express: "^5.1.0",
-      "reflect-metadata": "^0.2.2",
-      zod: "^4.3.6",
-      pino: "^10.3.1",
-      "pino-pretty": "^13.1.3"
-    },
+    dependencies: baseDeps,
     devDependencies: {
       "@forinda/kickjs-cli": KICKJS_VERSION,
       "@swc/core": "^1.7.28",
@@ -165,27 +179,18 @@ NODE_ENV=development
   await writeFileSafe(join(dir, ".env.example"), `PORT=3000
 NODE_ENV=development
 `);
-  await writeFileSafe(join(dir, "src/index.ts"), `import 'reflect-metadata'
-import { bootstrap } from '@forinda/kickjs-http'
-import { SwaggerAdapter } from '@forinda/kickjs-swagger'
-import { modules } from './modules'
-
-bootstrap({
-  modules,
-  adapters: [
-    new SwaggerAdapter({
-      info: { title: '${name}', version: '${cliPkg.version}' },
-    }),
-  ],
-})
-`);
+  await writeFileSafe(join(dir, "src/index.ts"), getEntryFile(name, template));
   await writeFileSafe(join(dir, "src/modules/index.ts"), `import type { AppModuleClass } from '@forinda/kickjs-core'
 
 export const modules: AppModuleClass[] = []
 `);
+  if (template === "graphql") {
+    await writeFileSafe(join(dir, "src/resolvers/.gitkeep"), "");
+  }
   await writeFileSafe(join(dir, "kick.config.ts"), `import { defineConfig } from '@forinda/kickjs-cli'
 
 export default defineConfig({
+  pattern: '${template}',
   modulesDir: 'src/modules',
   defaultRepo: 'inmemory',
 
@@ -266,17 +271,103 @@ export default defineConfig({
   console.log("  Next steps:");
   if (needsCd) console.log(`    cd ${name}`);
   if (!options.installDeps) console.log(`    ${packageManager} install`);
-  console.log("    kick g module user");
+  const genHint = {
+    rest: "kick g module user",
+    graphql: "kick g resolver user",
+    ddd: "kick g module user --repo drizzle",
+    microservice: "kick g module user && kick g job email",
+    minimal: "# add your routes to src/index.ts"
+  };
+  console.log(`    ${genHint[template] ?? genHint.rest}`);
   console.log("    kick dev");
   console.log();
   console.log("  Commands:");
   console.log("    kick dev         Start dev server with Vite HMR");
   console.log("    kick build       Production build via Vite");
   console.log("    kick start       Run production build");
-  console.log("    kick g module X  Generate a DDD module");
+  console.log(`    kick g module X  Generate a DDD module`);
+  if (template === "graphql") console.log("    kick g resolver X  Generate a GraphQL resolver");
+  if (template === "microservice") console.log("    kick g job X       Generate a queue job processor");
   console.log();
 }
 __name(initProject, "initProject");
+function getEntryFile(name, template) {
+  switch (template) {
+    case "graphql":
+      return `import 'reflect-metadata'
+import { bootstrap } from '@forinda/kickjs-http'
+import { DevToolsAdapter } from '@forinda/kickjs-devtools'
+import { GraphQLAdapter } from '@forinda/kickjs-graphql'
+import { modules } from './modules'
+
+// Import your resolvers here
+// import { UserResolver } from './resolvers/user.resolver'
+
+bootstrap({
+  modules,
+  adapters: [
+    new DevToolsAdapter(),
+    new GraphQLAdapter({
+      resolvers: [/* UserResolver */],
+      // Add custom type definitions here:
+      // typeDefs: userTypeDefs,
+    }),
+  ],
+})
+`;
+    case "microservice":
+      return `import 'reflect-metadata'
+import { bootstrap } from '@forinda/kickjs-http'
+import { DevToolsAdapter } from '@forinda/kickjs-devtools'
+import { SwaggerAdapter } from '@forinda/kickjs-swagger'
+import { OtelAdapter } from '@forinda/kickjs-otel'
+// import { QueueAdapter, BullMQProvider } from '@forinda/kickjs-queue'
+import { modules } from './modules'
+
+bootstrap({
+  modules,
+  adapters: [
+    new OtelAdapter({ serviceName: '${name}' }),
+    new DevToolsAdapter(),
+    new SwaggerAdapter({
+      info: { title: '${name}', version: '${cliPkg.version}' },
+    }),
+    // Uncomment when Redis is available:
+    // new QueueAdapter({
+    //   provider: new BullMQProvider({ host: 'localhost', port: 6379 }),
+    // }),
+  ],
+})
+`;
+    case "minimal":
+      return `import 'reflect-metadata'
+import { bootstrap } from '@forinda/kickjs-http'
+import { modules } from './modules'
+
+bootstrap({ modules })
+`;
+    case "ddd":
+    case "rest":
+    default:
+      return `import 'reflect-metadata'
+import { bootstrap } from '@forinda/kickjs-http'
+import { DevToolsAdapter } from '@forinda/kickjs-devtools'
+import { SwaggerAdapter } from '@forinda/kickjs-swagger'
+import { modules } from './modules'
+
+bootstrap({
+  modules,
+  adapters: [
+    new DevToolsAdapter(),
+    new SwaggerAdapter({
+      info: { title: '${name}', version: '${cliPkg.version}' },
+    }),
+  ],
+})
+`;
+  }
+}
+__name(getEntryFile, "getEntryFile");
 
 // src/commands/init.ts
 function ask(question, defaultValue) {
@@ -312,7 +403,7 @@ async function confirm(question, defaultYes = true) {
 }
 __name(confirm, "confirm");
 function registerInitCommand(program) {
-  program.command("new [name]").alias("init").description('Create a new KickJS project (use "." for current directory)').option("-d, --directory <dir>", "Target directory (defaults to project name)").option("--pm <manager>", "Package manager: pnpm | npm | yarn").option("--git", "Initialize git repository").option("--no-git", "Skip git initialization").option("--install", "Install dependencies after scaffolding").option("--no-install", "Skip dependency installation").option("-f, --force", "Remove existing files without prompting").action(async (name, opts) => {
+  program.command("new [name]").alias("init").description('Create a new KickJS project (use "." for current directory)').option("-d, --directory <dir>", "Target directory (defaults to project name)").option("--pm <manager>", "Package manager: pnpm | npm | yarn").option("--git", "Initialize git repository").option("--no-git", "Skip git initialization").option("--install", "Install dependencies after scaffolding").option("--no-install", "Skip dependency installation").option("-f, --force", "Remove existing files without prompting").option("-t, --template <type>", "Project template: rest | graphql | ddd | microservice | minimal").action(async (name, opts) => {
     console.log();
     if (!name) {
       name = await ask("Project name", "my-api");
@@ -354,6 +445,24 @@ function registerInitCommand(program) {
         }
       }
     }
+    let template = opts.template;
+    if (!template) {
+      template = await choose("Project template:", [
+        "REST API (Express + Swagger)",
+        "GraphQL API (GraphQL + GraphiQL)",
+        "DDD (Domain-Driven Design modules)",
+        "Microservice (REST + Queue worker)",
+        "Minimal (bare Express)"
+      ], 0);
+      const templateMap = {
+        "REST API (Express + Swagger)": "rest",
+        "GraphQL API (GraphQL + GraphiQL)": "graphql",
+        "DDD (Domain-Driven Design modules)": "ddd",
+        "Microservice (REST + Queue worker)": "microservice",
+        "Minimal (bare Express)": "minimal"
+      };
+      template = templateMap[template] ?? "rest";
+    }
     let packageManager = opts.pm;
     if (!packageManager) {
       packageManager = await choose("Package manager:", [
@@ -379,7 +488,8 @@ function registerInitCommand(program) {
       directory,
       packageManager,
       initGit,
-      installDeps
+      installDeps,
+      template
     });
   });
 }
@@ -1418,10 +1528,10 @@ async function confirm2(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve3) => {
+  return new Promise((resolve6) => {
     rl.question(`  ${message} (y/N) `, (answer) => {
       rl.close();
-      resolve3(answer.trim().toLowerCase() === "y");
+      resolve6(answer.trim().toLowerCase() === "y");
     });
   });
 }
@@ -1474,164 +1584,929 @@ export default defineConfig({
 }
 __name(generateConfig, "generateConfig");
 
-// src/commands/generate.ts
-function printGenerated(files) {
-  const cwd = process.cwd();
-  console.log(`
-  Generated ${files.length} file${files.length === 1 ? "" : "s"}:`);
-  for (const f of files) {
-    console.log(`    ${f.replace(cwd + "/", "")}`);
+// src/generators/resolver.ts
+import { join as join10 } from "path";
+async function generateResolver(options) {
+  const { name, outDir } = options;
+  const pascal = toPascalCase(name);
+  const kebab = toKebabCase(name);
+  const camel = toCamelCase(name);
+  const files = [];
+  const write = /* @__PURE__ */ __name(async (relativePath, content) => {
+    const fullPath = join10(outDir, relativePath);
+    await writeFileSafe(fullPath, content);
+    files.push(fullPath);
+  }, "write");
+  await write(`${kebab}.resolver.ts`, `import { Service } from '@forinda/kickjs-core'
+import { Resolver, Query, Mutation, Arg } from '@forinda/kickjs-graphql'
+
+/**
+ * ${pascal} GraphQL Resolver
+ *
+ * Decorators:
+ *   @Resolver(typeName?) \u2014 marks this class as a GraphQL resolver
+ *   @Query(name?, { returnType?, description? }) \u2014 defines a query field
+ *   @Mutation(name?, { returnType?, description? }) \u2014 defines a mutation field
+ *   @Arg(name, type?) \u2014 marks a method parameter as a GraphQL argument
+ */
+@Service()
+@Resolver('${pascal}')
+export class ${pascal}Resolver {
+  private items: Array<{ id: string; name: string }> = []
+
+  @Query('${camel}s', { returnType: '[${pascal}]', description: 'List all ${camel}s' })
+  findAll() {
+    return this.items
   }
-  console.log();
-}
-__name(printGenerated, "printGenerated");
-function registerGenerateCommand(program) {
-  const gen = program.command("generate").alias("g").description("Generate code scaffolds");
-  gen.command("module <name>").description("Generate a full DDD module with all layers").option("--no-entity", "Skip entity and value object generation").option("--no-tests", "Skip test file generation").option("--repo <type>", "Repository implementation: inmemory | drizzle", "inmemory").option("--minimal", "Only generate index.ts and controller").option("--modules-dir <dir>", "Modules directory", "src/modules").action(async (name, opts) => {
-    const files = await generateModule({
-      name,
-      modulesDir: resolve2(opts.modulesDir),
-      noEntity: opts.entity === false,
-      noTests: opts.tests === false,
-      repo: opts.repo,
-      minimal: opts.minimal
-    });
-    printGenerated(files);
-  });
-  gen.command("adapter <name>").description("Generate an AppAdapter with lifecycle hooks and middleware support").option("-o, --out <dir>", "Output directory", "src/adapters").action(async (name, opts) => {
-    const files = await generateAdapter({
-      name,
-      outDir: resolve2(opts.out)
-    });
-    printGenerated(files);
-  });
-  gen.command("middleware <name>").description("Generate an Express middleware function").option("-o, --out <dir>", "Output directory", "src/middleware").action(async (name, opts) => {
-    const files = await generateMiddleware({
-      name,
-      outDir: resolve2(opts.out)
-    });
-    printGenerated(files);
-  });
-  gen.command("guard <name>").description("Generate a route guard (auth, roles, etc.)").option("-o, --out <dir>", "Output directory", "src/guards").action(async (name, opts) => {
-    const files = await generateGuard({
-      name,
-      outDir: resolve2(opts.out)
-    });
-    printGenerated(files);
-  });
-  gen.command("service <name>").description("Generate a @Service() class").option("-o, --out <dir>", "Output directory", "src/services").action(async (name, opts) => {
-    const files = await generateService({
-      name,
-      outDir: resolve2(opts.out)
-    });
-    printGenerated(files);
-  });
-  gen.command("controller <name>").description("Generate a @Controller() class with basic routes").option("-o, --out <dir>", "Output directory", "src/controllers").action(async (name, opts) => {
-    const files = await generateController2({
-      name,
-      outDir: resolve2(opts.out)
-    });
-    printGenerated(files);
-  });
-  gen.command("dto <name>").description("Generate a Zod DTO schema").option("-o, --out <dir>", "Output directory", "src/dtos").action(async (name, opts) => {
-    const files = await generateDto({
-      name,
-      outDir: resolve2(opts.out)
-    });
-    printGenerated(files);
-  });
-  gen.command("config").description("Generate a kick.config.ts at the project root").option("--modules-dir <dir>", "Modules directory path", "src/modules").option("--repo <type>", "Default repository type: inmemory | drizzle", "inmemory").option("-f, --force", "Overwrite existing kick.config.ts without prompting").action(async (opts) => {
-    const files = await generateConfig({
-      outDir: resolve2("."),
-      modulesDir: opts.modulesDir,
-      defaultRepo: opts.repo,
-      force: opts.force
-    });
-    printGenerated(files);
-  });
-}
-__name(registerGenerateCommand, "registerGenerateCommand");
 
-// src/utils/shell.ts
-import { execSync as execSync2 } from "child_process";
-function runShellCommand(command, cwd) {
-  execSync2(command, {
-    cwd,
-    stdio: "inherit"
-  });
-}
-__name(runShellCommand, "runShellCommand");
+  @Query('${camel}', { returnType: '${pascal}', description: 'Get a ${camel} by ID' })
+  findById(@Arg('id', 'ID!') id: string) {
+    return this.items.find((item) => item.id === id) ?? null
+  }
 
-// src/commands/run.ts
-function registerRunCommands(program) {
-  program.command("dev").description("Start development server with Vite HMR (zero-downtime reload)").option("-e, --entry <file>", "Entry file", "src/index.ts").option("-p, --port <port>", "Port number").action((opts) => {
-    const envVars = [];
-    if (opts.port) envVars.push(`PORT=${opts.port}`);
-    const cmd = `npx vite-node --watch ${opts.entry}`;
-    const fullCmd = envVars.length ? `${envVars.join(" ")} ${cmd}` : cmd;
-    console.log(`
-  KickJS dev server starting...`);
-    console.log(`  Entry:  ${opts.entry}`);
-    console.log(`  HMR:    enabled (vite-node)
+  @Mutation('create${pascal}', { returnType: '${pascal}', description: 'Create a new ${camel}' })
+  create(@Arg('name', 'String!') name: string) {
+    const item = { id: String(this.items.length + 1), name }
+    this.items.push(item)
+    return item
+  }
+
+  @Mutation('update${pascal}', { returnType: '${pascal}', description: 'Update a ${camel}' })
+  update(@Arg('id', 'ID!') id: string, @Arg('name', 'String!') name: string) {
+    const item = this.items.find((i) => i.id === id)
+    if (item) item.name = name
+    return item
+  }
+
+  @Mutation('delete${pascal}', { returnType: 'Boolean', description: 'Delete a ${camel}' })
+  remove(@Arg('id', 'ID!') id: string) {
+    const idx = this.items.findIndex((i) => i.id === id)
+    if (idx === -1) return false
+    this.items.splice(idx, 1)
+    return true
+  }
+}
 `);
-    try {
-      runShellCommand(fullCmd);
-    } catch {
-    }
-  });
-  program.command("build").description("Build for production via Vite").action(() => {
-    console.log("\n  Building for production...\n");
-    runShellCommand("npx vite build");
-  });
-  program.command("start").description("Start production server").option("-e, --entry <file>", "Entry file", "dist/index.js").option("-p, --port <port>", "Port number").action((opts) => {
-    const envVars = [
-      "NODE_ENV=production"
-    ];
-    if (opts.port) envVars.push(`PORT=${opts.port}`);
-    runShellCommand(`${envVars.join(" ")} node ${opts.entry}`);
-  });
-  program.command("dev:debug").description("Start dev server with Node.js inspector").option("-e, --entry <file>", "Entry file", "src/index.ts").option("-p, --port <port>", "Port number").action((opts) => {
-    const envVars = opts.port ? `PORT=${opts.port} ` : "";
-    try {
-      runShellCommand(`${envVars}npx vite-node --inspect --watch ${opts.entry}`);
-    } catch {
-    }
-  });
+  await write(`${kebab}.typedefs.ts`, `/**
+ * ${pascal} GraphQL type definitions.
+ * Pass to GraphQLAdapter's typeDefs option to register custom types.
+ */
+export const ${camel}TypeDefs = \`
+  type ${pascal} {
+    id: ID!
+    name: String!
+  }
+\`
+`);
+  return files;
 }
-__name(registerRunCommands, "registerRunCommands");
+__name(generateResolver, "generateResolver");
 
-// src/commands/info.ts
-import { platform, release, arch } from "os";
-function registerInfoCommand(program) {
-  program.command("info").description("Print system and framework info").action(() => {
-    console.log(`
-  KickJS CLI
+// src/generators/job.ts
+import { join as join11 } from "path";
+async function generateJob(options) {
+  const { name, outDir } = options;
+  const pascal = toPascalCase(name);
+  const kebab = toKebabCase(name);
+  const camel = toCamelCase(name);
+  const queueName = options.queue ?? `${kebab}-queue`;
+  const files = [];
+  const write = /* @__PURE__ */ __name(async (relativePath, content) => {
+    const fullPath = join11(outDir, relativePath);
+    await writeFileSafe(fullPath, content);
+    files.push(fullPath);
+  }, "write");
+  await write(`${kebab}.job.ts`, `import { Inject } from '@forinda/kickjs-core'
+import { Job, Process, QUEUE_MANAGER, type QueueService } from '@forinda/kickjs-queue'
 
-  System:
-    OS:       ${platform()} ${release()} (${arch()})
-    Node:     ${process.version}
+/**
+ * ${pascal} Job Processor
+ *
+ * Decorators:
+ *   @Job(queueName) \u2014 marks this class as a job processor for a queue
+ *   @Process(jobName?) \u2014 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('${queueName}', '${camel}', { ... })
+ */
+@Job('${queueName}')
+export class ${pascal}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)
+  }
 
-  Packages:
-    @forinda/kickjs-core     workspace
-    @forinda/kickjs-http     workspace
-    @forinda/kickjs-config   workspace
-    @forinda/kickjs-cli      workspace
+  @Process('${camel}.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
+  }
+}
 `);
-  });
+  return files;
 }
-__name(registerInfoCommand, "registerInfoCommand");
+__name(generateJob, "generateJob");
 
-// src/commands/custom.ts
-function registerCustomCommands(program, config) {
-  if (!config?.commands?.length) return;
-  for (const cmd of config.commands) {
-    registerSingleCommand(program, cmd);
-  }
-}
-__name(registerCustomCommands, "registerCustomCommands");
-function registerSingleCommand(program, def) {
-  const command = program.command(def.name).description(def.description);
-  if (def.aliases) {
+// src/generators/scaffold.ts
+import { join as join12 } from "path";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+var TYPE_MAP = {
+  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 parseFields(raw) {
+  return raw.map((f) => {
+    const colonIdx = f.indexOf(":");
+    if (colonIdx === -1) {
+      throw new Error(`Invalid field: "${f}". Use format: name:type (e.g. title:string)`);
+    }
+    const namePart = f.slice(0, colonIdx);
+    const typePart = f.slice(colonIdx + 1);
+    if (!namePart || !typePart) {
+      throw new Error(`Invalid field: "${f}". Use format: name:type (e.g. title:string)`);
+    }
+    const optional = typePart.endsWith("?");
+    const cleanType = optional ? typePart.slice(0, -1) : typePart;
+    if (cleanType.startsWith("enum:")) {
+      const values = cleanType.slice(5).split(",");
+      return {
+        name: namePart,
+        type: "enum",
+        tsType: values.map((v) => `'${v}'`).join(" | "),
+        zodType: `z.enum([${values.map((v) => `'${v}'`).join(", ")}])`,
+        optional
+      };
+    }
+    const mapped = TYPE_MAP[cleanType];
+    if (!mapped) {
+      const validTypes = [
+        ...Object.keys(TYPE_MAP),
+        "enum:a,b,c"
+      ].join(", ");
+      throw new Error(`Unknown field type: "${cleanType}". Valid types: ${validTypes}`);
+    }
+    return {
+      name: namePart,
+      type: cleanType,
+      tsType: mapped.ts,
+      zodType: mapped.zod,
+      optional
+    };
+  });
+}
+__name(parseFields, "parseFields");
+async function generateScaffold(options) {
+  const { name, fields, modulesDir, noEntity, noTests, repo = "inmemory" } = options;
+  const kebab = toKebabCase(name);
+  const pascal = toPascalCase(name);
+  const camel = toCamelCase(name);
+  const plural = pluralize(kebab);
+  const pluralPascal = pluralizePascal(pascal);
+  const moduleDir = join12(modulesDir, plural);
+  const files = [];
+  const write = /* @__PURE__ */ __name(async (relativePath, content) => {
+    const fullPath = join12(moduleDir, relativePath);
+    await writeFileSafe(fullPath, content);
+    files.push(fullPath);
+  }, "write");
+  await write("index.ts", genModuleIndex(pascal, kebab, plural, repo));
+  await write("constants.ts", genConstants(pascal, fields));
+  await write(`presentation/${kebab}.controller.ts`, genController(pascal, kebab, plural, pluralPascal));
+  await write(`application/dtos/create-${kebab}.dto.ts`, genCreateDTO(pascal, fields));
+  await write(`application/dtos/update-${kebab}.dto.ts`, genUpdateDTO(pascal, fields));
+  await write(`application/dtos/${kebab}-response.dto.ts`, genResponseDTO(pascal, fields));
+  const useCases = genUseCases(pascal, kebab, plural, pluralPascal);
+  for (const uc of useCases) {
+    await write(`application/use-cases/${uc.file}`, uc.content);
+  }
+  await write(`domain/repositories/${kebab}.repository.ts`, genRepositoryInterface(pascal, kebab));
+  await write(`domain/services/${kebab}-domain.service.ts`, genDomainService(pascal, kebab));
+  if (repo === "inmemory") {
+    await write(`infrastructure/repositories/in-memory-${kebab}.repository.ts`, genInMemoryRepository(pascal, kebab, fields));
+  }
+  if (!noEntity) {
+    await write(`domain/entities/${kebab}.entity.ts`, genEntity(pascal, kebab, fields));
+    await write(`domain/value-objects/${kebab}-id.vo.ts`, genValueObject(pascal));
+  }
+  await autoRegisterModule2(modulesDir, pascal, plural);
+  return files;
+}
+__name(generateScaffold, "generateScaffold");
+function genCreateDTO(pascal, fields) {
+  const zodFields = fields.map((f) => {
+    const base = f.zodType;
+    return `  ${f.name}: ${base}${f.optional ? ".optional()" : ""},`;
+  }).join("\n");
+  return `import { z } from 'zod'
+
+export const create${pascal}Schema = z.object({
+${zodFields}
+})
+
+export type Create${pascal}DTO = z.infer<typeof create${pascal}Schema>
+`;
+}
+__name(genCreateDTO, "genCreateDTO");
+function genUpdateDTO(pascal, fields) {
+  const zodFields = fields.map((f) => `  ${f.name}: ${f.zodType}.optional(),`).join("\n");
+  return `import { z } from 'zod'
+
+export const update${pascal}Schema = z.object({
+${zodFields}
+})
+
+export type Update${pascal}DTO = z.infer<typeof update${pascal}Schema>
+`;
+}
+__name(genUpdateDTO, "genUpdateDTO");
+function genResponseDTO(pascal, fields) {
+  const tsFields = fields.map((f) => `  ${f.name}${f.optional ? "?" : ""}: ${f.tsType}`).join("\n");
+  return `export interface ${pascal}ResponseDTO {
+  id: string
+${tsFields}
+  createdAt: string
+  updatedAt: string
+}
+`;
+}
+__name(genResponseDTO, "genResponseDTO");
+function genConstants(pascal, fields) {
+  const stringFields = fields.filter((f) => f.tsType === "string").map((f) => `'${f.name}'`);
+  const numberFields = fields.filter((f) => f.tsType === "number").map((f) => `'${f.name}'`);
+  const allFieldNames = fields.map((f) => `'${f.name}'`);
+  const filterable = [
+    ...allFieldNames
+  ].join(", ");
+  const sortable = [
+    ...allFieldNames,
+    "'createdAt'",
+    "'updatedAt'"
+  ].join(", ");
+  const searchable = stringFields.length > 0 ? stringFields.join(", ") : "'name'";
+  return `import type { ApiQueryParamsConfig } from '@forinda/kickjs-core'
+
+export const ${pascal.toUpperCase()}_QUERY_CONFIG: ApiQueryParamsConfig = {
+  filterable: [${filterable}],
+  sortable: [${sortable}],
+  searchable: [${searchable}],
+}
+`;
+}
+__name(genConstants, "genConstants");
+function genInMemoryRepository(pascal, kebab, fields) {
+  const fieldAssignments = fields.map((f) => `      ${f.name}: dto.${f.name},`).join("\n");
+  const fieldSpread = "...dto";
+  return `import { randomUUID } from 'node:crypto'
+import { Repository, HttpException } from '@forinda/kickjs-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+import type { I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
+import type { ${pascal}ResponseDTO } from '../../application/dtos/${kebab}-response.dto'
+import type { Create${pascal}DTO } from '../../application/dtos/create-${kebab}.dto'
+import type { Update${pascal}DTO } from '../../application/dtos/update-${kebab}.dto'
+
+@Repository()
+export class InMemory${pascal}Repository implements I${pascal}Repository {
+  private store = new Map<string, ${pascal}ResponseDTO>()
+
+  async findById(id: string): Promise<${pascal}ResponseDTO | null> {
+    return this.store.get(id) ?? null
+  }
+
+  async findAll(): Promise<${pascal}ResponseDTO[]> {
+    return Array.from(this.store.values())
+  }
+
+  async findPaginated(parsed: ParsedQuery): Promise<{ data: ${pascal}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${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    const now = new Date().toISOString()
+    const entity: ${pascal}ResponseDTO = {
+      id: randomUUID(),
+${fieldAssignments}
+      createdAt: now,
+      updatedAt: now,
+    }
+    this.store.set(entity.id, entity)
+    return entity
+  }
+
+  async update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO> {
+    const existing = this.store.get(id)
+    if (!existing) throw HttpException.notFound('${pascal} not found')
+    const updated = { ...existing, ${fieldSpread}, 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('${pascal} not found')
+    this.store.delete(id)
+  }
+}
+`;
+}
+__name(genInMemoryRepository, "genInMemoryRepository");
+function genEntity(pascal, kebab, fields) {
+  const propsInterface = fields.map((f) => `  ${f.name}${f.optional ? "?" : ""}: ${f.tsType}`).join("\n");
+  const createParams = fields.filter((f) => !f.optional).map((f) => `${f.name}: ${f.tsType}`).join("; ");
+  const createAssignments = fields.filter((f) => !f.optional).map((f) => `      ${f.name}: params.${f.name},`).join("\n");
+  const getters = fields.map((f) => `  get ${f.name}(): ${f.tsType}${f.optional ? " | undefined" : ""} {
+    return this.props.${f.name}
+  }`).join("\n");
+  const toJsonFields = fields.map((f) => `      ${f.name}: this.props.${f.name},`).join("\n");
+  return `import { ${pascal}Id } from '../value-objects/${kebab}-id.vo'
+
+interface ${pascal}Props {
+  id: ${pascal}Id
+${propsInterface}
+  createdAt: Date
+  updatedAt: Date
+}
+
+export class ${pascal} {
+  private constructor(private props: ${pascal}Props) {}
+
+  static create(params: { ${createParams} }): ${pascal} {
+    const now = new Date()
+    return new ${pascal}({
+      id: ${pascal}Id.create(),
+${createAssignments}
+      createdAt: now,
+      updatedAt: now,
+    })
+  }
+
+  static reconstitute(props: ${pascal}Props): ${pascal} {
+    return new ${pascal}(props)
+  }
+
+  get id(): ${pascal}Id { return this.props.id }
+${getters}
+  get createdAt(): Date { return this.props.createdAt }
+  get updatedAt(): Date { return this.props.updatedAt }
+
+  toJSON() {
+    return {
+      id: this.props.id.toString(),
+${toJsonFields}
+      createdAt: this.props.createdAt.toISOString(),
+      updatedAt: this.props.updatedAt.toISOString(),
+    }
+  }
+}
+`;
+}
+__name(genEntity, "genEntity");
+function genValueObject(pascal) {
+  return `import { randomUUID } from 'node:crypto'
+
+export class ${pascal}Id {
+  private constructor(private readonly value: string) {}
+
+  static create(): ${pascal}Id { return new ${pascal}Id(randomUUID()) }
+
+  static from(id: string): ${pascal}Id {
+    if (!id || id.trim().length === 0) throw new Error('${pascal}Id cannot be empty')
+    return new ${pascal}Id(id)
+  }
+
+  toString(): string { return this.value }
+  equals(other: ${pascal}Id): boolean { return this.value === other.value }
+}
+`;
+}
+__name(genValueObject, "genValueObject");
+function genModuleIndex(pascal, kebab, plural, repo) {
+  return `import type { AppModule, AppModuleClass } from '@forinda/kickjs-core'
+import { ${pascal}Controller } from './presentation/${kebab}.controller'
+import { ${pascal}DomainService } from './domain/services/${kebab}-domain.service'
+import { ${pascal.toUpperCase()}_REPOSITORY } from './domain/repositories/${kebab}.repository'
+import { InMemory${pascal}Repository } from './infrastructure/repositories/in-memory-${kebab}.repository'
+
+export class ${pascal}Module implements AppModule {
+  register(container: any): void {
+    container.registerFactory(
+      ${pascal.toUpperCase()}_REPOSITORY,
+      () => container.resolve(InMemory${pascal}Repository),
+    )
+  }
+
+  routes() {
+    return { prefix: '/${plural}', controllers: [${pascal}Controller] }
+  }
+}
+`;
+}
+__name(genModuleIndex, "genModuleIndex");
+function genController(pascal, kebab, plural, pluralPascal) {
+  return `import { Controller, Get, Post, Put, Delete, Autowired, ApiQueryParams } from '@forinda/kickjs-core'
+import type { RequestContext } from '@forinda/kickjs-http'
+import { ApiTags } from '@forinda/kickjs-swagger'
+import { Create${pascal}UseCase } from '../application/use-cases/create-${kebab}.use-case'
+import { Get${pascal}UseCase } from '../application/use-cases/get-${kebab}.use-case'
+import { List${pluralPascal}UseCase } from '../application/use-cases/list-${plural}.use-case'
+import { Update${pascal}UseCase } from '../application/use-cases/update-${kebab}.use-case'
+import { Delete${pascal}UseCase } from '../application/use-cases/delete-${kebab}.use-case'
+import { create${pascal}Schema } from '../application/dtos/create-${kebab}.dto'
+import { update${pascal}Schema } from '../application/dtos/update-${kebab}.dto'
+import { ${pascal.toUpperCase()}_QUERY_CONFIG } from '../constants'
+
+@Controller()
+export class ${pascal}Controller {
+  @Autowired() private create${pascal}UseCase!: Create${pascal}UseCase
+  @Autowired() private get${pascal}UseCase!: Get${pascal}UseCase
+  @Autowired() private list${pluralPascal}UseCase!: List${pluralPascal}UseCase
+  @Autowired() private update${pascal}UseCase!: Update${pascal}UseCase
+  @Autowired() private delete${pascal}UseCase!: Delete${pascal}UseCase
+
+  @Get('/')
+  @ApiTags('${pascal}')
+  @ApiQueryParams(${pascal.toUpperCase()}_QUERY_CONFIG)
+  async list(ctx: RequestContext) {
+    return ctx.paginate(
+      (parsed) => this.list${pluralPascal}UseCase.execute(parsed),
+      ${pascal.toUpperCase()}_QUERY_CONFIG,
+    )
+  }
+
+  @Get('/:id')
+  @ApiTags('${pascal}')
+  async getById(ctx: RequestContext) {
+    const result = await this.get${pascal}UseCase.execute(ctx.params.id)
+    if (!result) return ctx.notFound('${pascal} not found')
+    ctx.json(result)
+  }
+
+  @Post('/', { body: create${pascal}Schema, name: 'Create${pascal}' })
+  @ApiTags('${pascal}')
+  async create(ctx: RequestContext) {
+    const result = await this.create${pascal}UseCase.execute(ctx.body)
+    ctx.created(result)
+  }
+
+  @Put('/:id', { body: update${pascal}Schema, name: 'Update${pascal}' })
+  @ApiTags('${pascal}')
+  async update(ctx: RequestContext) {
+    const result = await this.update${pascal}UseCase.execute(ctx.params.id, ctx.body)
+    ctx.json(result)
+  }
+
+  @Delete('/:id')
+  @ApiTags('${pascal}')
+  async remove(ctx: RequestContext) {
+    await this.delete${pascal}UseCase.execute(ctx.params.id)
+    ctx.noContent()
+  }
+}
+`;
+}
+__name(genController, "genController");
+function genRepositoryInterface(pascal, kebab) {
+  return `import type { ${pascal}ResponseDTO } from '../../application/dtos/${kebab}-response.dto'
+import type { Create${pascal}DTO } from '../../application/dtos/create-${kebab}.dto'
+import type { Update${pascal}DTO } from '../../application/dtos/update-${kebab}.dto'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+
+export interface I${pascal}Repository {
+  findById(id: string): Promise<${pascal}ResponseDTO | null>
+  findAll(): Promise<${pascal}ResponseDTO[]>
+  findPaginated(parsed: ParsedQuery): Promise<{ data: ${pascal}ResponseDTO[]; total: number }>
+  create(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO>
+  update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO>
+  delete(id: string): Promise<void>
+}
+
+export const ${pascal.toUpperCase()}_REPOSITORY = Symbol('I${pascal}Repository')
+`;
+}
+__name(genRepositoryInterface, "genRepositoryInterface");
+function genDomainService(pascal, kebab) {
+  return `import { Service, Inject, HttpException } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../repositories/${kebab}.repository'
+
+@Service()
+export class ${pascal}DomainService {
+  constructor(
+    @Inject(${pascal.toUpperCase()}_REPOSITORY) private readonly repo: I${pascal}Repository,
+  ) {}
+
+  async ensureExists(id: string): Promise<void> {
+    const entity = await this.repo.findById(id)
+    if (!entity) throw HttpException.notFound('${pascal} not found')
+  }
+}
+`;
+}
+__name(genDomainService, "genDomainService");
+function genUseCases(pascal, kebab, plural, pluralPascal) {
+  return [
+    {
+      file: `create-${kebab}.use-case.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
+import type { Create${pascal}DTO } from '../dtos/create-${kebab}.dto'
+
+@Service()
+export class Create${pascal}UseCase {
+  constructor(@Inject(${pascal.toUpperCase()}_REPOSITORY) private repo: I${pascal}Repository) {}
+  async execute(dto: Create${pascal}DTO) { return this.repo.create(dto) }
+}
+`
+    },
+    {
+      file: `get-${kebab}.use-case.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
+
+@Service()
+export class Get${pascal}UseCase {
+  constructor(@Inject(${pascal.toUpperCase()}_REPOSITORY) private repo: I${pascal}Repository) {}
+  async execute(id: string) { return this.repo.findById(id) }
+}
+`
+    },
+    {
+      file: `list-${plural}.use-case.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import type { ParsedQuery } from '@forinda/kickjs-http'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
+
+@Service()
+export class List${pluralPascal}UseCase {
+  constructor(@Inject(${pascal.toUpperCase()}_REPOSITORY) private repo: I${pascal}Repository) {}
+  async execute(parsed: ParsedQuery) { return this.repo.findPaginated(parsed) }
+}
+`
+    },
+    {
+      file: `update-${kebab}.use-case.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
+import type { Update${pascal}DTO } from '../dtos/update-${kebab}.dto'
+
+@Service()
+export class Update${pascal}UseCase {
+  constructor(@Inject(${pascal.toUpperCase()}_REPOSITORY) private repo: I${pascal}Repository) {}
+  async execute(id: string, dto: Update${pascal}DTO) { return this.repo.update(id, dto) }
+}
+`
+    },
+    {
+      file: `delete-${kebab}.use-case.ts`,
+      content: `import { Service, Inject } from '@forinda/kickjs-core'
+import { ${pascal.toUpperCase()}_REPOSITORY, type I${pascal}Repository } from '../../domain/repositories/${kebab}.repository'
+
+@Service()
+export class Delete${pascal}UseCase {
+  constructor(@Inject(${pascal.toUpperCase()}_REPOSITORY) private repo: I${pascal}Repository) {}
+  async execute(id: string) { return this.repo.delete(id) }
+}
+`
+    }
+  ];
+}
+__name(genUseCases, "genUseCases");
+async function autoRegisterModule2(modulesDir, pascal, plural) {
+  const indexPath = join12(modulesDir, "index.ts");
+  const exists = await fileExists(indexPath);
+  if (!exists) {
+    await writeFileSafe(indexPath, `import type { AppModuleClass } from '@forinda/kickjs-core'
+import { ${pascal}Module } from './${plural}'
+
+export const modules: AppModuleClass[] = [${pascal}Module]
+`);
+    return;
+  }
+  let content = await readFile3(indexPath, "utf-8");
+  const importLine = `import { ${pascal}Module } from './${plural}'`;
+  if (!content.includes(`${pascal}Module`)) {
+    const lastImportIdx = content.lastIndexOf("import ");
+    if (lastImportIdx !== -1) {
+      const lineEnd = content.indexOf("\n", lastImportIdx);
+      content = content.slice(0, lineEnd + 1) + importLine + "\n" + content.slice(lineEnd + 1);
+    } else {
+      content = importLine + "\n" + content;
+    }
+    content = content.replace(/(=\s*\[)([\s\S]*?)(])/, (_match, open, existing, close) => {
+      const trimmed = existing.trim();
+      if (!trimmed) return `${open}${pascal}Module${close}`;
+      const needsComma = trimmed.endsWith(",") ? "" : ",";
+      return `${open}${existing.trimEnd()}${needsComma} ${pascal}Module${close}`;
+    });
+  }
+  await writeFile3(indexPath, content, "utf-8");
+}
+__name(autoRegisterModule2, "autoRegisterModule");
+
+// src/commands/generate.ts
+function printGenerated(files) {
+  const cwd = process.cwd();
+  console.log(`
+  Generated ${files.length} file${files.length === 1 ? "" : "s"}:`);
+  for (const f of files) {
+    console.log(`    ${f.replace(cwd + "/", "")}`);
+  }
+  console.log();
+}
+__name(printGenerated, "printGenerated");
+function registerGenerateCommand(program) {
+  const gen = program.command("generate").alias("g").description("Generate code scaffolds");
+  gen.command("module <name>").description("Generate a full DDD module with all layers").option("--no-entity", "Skip entity and value object generation").option("--no-tests", "Skip test file generation").option("--repo <type>", "Repository implementation: inmemory | drizzle", "inmemory").option("--minimal", "Only generate index.ts and controller").option("--modules-dir <dir>", "Modules directory", "src/modules").action(async (name, opts) => {
+    const files = await generateModule({
+      name,
+      modulesDir: resolve2(opts.modulesDir),
+      noEntity: opts.entity === false,
+      noTests: opts.tests === false,
+      repo: opts.repo,
+      minimal: opts.minimal
+    });
+    printGenerated(files);
+  });
+  gen.command("adapter <name>").description("Generate an AppAdapter with lifecycle hooks and middleware support").option("-o, --out <dir>", "Output directory", "src/adapters").action(async (name, opts) => {
+    const files = await generateAdapter({
+      name,
+      outDir: resolve2(opts.out)
+    });
+    printGenerated(files);
+  });
+  gen.command("middleware <name>").description("Generate an Express middleware function").option("-o, --out <dir>", "Output directory", "src/middleware").action(async (name, opts) => {
+    const files = await generateMiddleware({
+      name,
+      outDir: resolve2(opts.out)
+    });
+    printGenerated(files);
+  });
+  gen.command("guard <name>").description("Generate a route guard (auth, roles, etc.)").option("-o, --out <dir>", "Output directory", "src/guards").action(async (name, opts) => {
+    const files = await generateGuard({
+      name,
+      outDir: resolve2(opts.out)
+    });
+    printGenerated(files);
+  });
+  gen.command("service <name>").description("Generate a @Service() class").option("-o, --out <dir>", "Output directory", "src/services").action(async (name, opts) => {
+    const files = await generateService({
+      name,
+      outDir: resolve2(opts.out)
+    });
+    printGenerated(files);
+  });
+  gen.command("controller <name>").description("Generate a @Controller() class with basic routes").option("-o, --out <dir>", "Output directory", "src/controllers").action(async (name, opts) => {
+    const files = await generateController2({
+      name,
+      outDir: resolve2(opts.out)
+    });
+    printGenerated(files);
+  });
+  gen.command("dto <name>").description("Generate a Zod DTO schema").option("-o, --out <dir>", "Output directory", "src/dtos").action(async (name, opts) => {
+    const files = await generateDto({
+      name,
+      outDir: resolve2(opts.out)
+    });
+    printGenerated(files);
+  });
+  gen.command("resolver <name>").description("Generate a GraphQL @Resolver class with @Query and @Mutation methods").option("-o, --out <dir>", "Output directory", "src/resolvers").action(async (name, opts) => {
+    const files = await generateResolver({
+      name,
+      outDir: resolve2(opts.out)
+    });
+    printGenerated(files);
+  });
+  gen.command("job <name>").description("Generate a @Job queue processor with @Process handlers").option("-o, --out <dir>", "Output directory", "src/jobs").option("-q, --queue <name>", "Queue name (default: <name>-queue)").action(async (name, opts) => {
+    const files = await generateJob({
+      name,
+      outDir: resolve2(opts.out),
+      queue: opts.queue
+    });
+    printGenerated(files);
+  });
+  gen.command("scaffold <name> [fields...]").description("Generate a full CRUD module from field definitions\n  Example: kick g scaffold Post title:string body:text published:boolean?\n  Types: string, text, number, int, float, boolean, date, email, url, uuid, json, enum:a,b,c\n  Append ? for optional fields: description:text?").option("--no-entity", "Skip entity and value object generation").option("--no-tests", "Skip test file generation").option("--modules-dir <dir>", "Modules directory", "src/modules").action(async (name, rawFields, opts) => {
+    if (rawFields.length === 0) {
+      console.error("\n  Error: At least one field is required.\n  Usage: kick g scaffold <name> <field:type> [field:type...]\n  Example: kick g scaffold Post title:string body:text published:boolean\n");
+      process.exit(1);
+    }
+    const fields = parseFields(rawFields);
+    const files = await generateScaffold({
+      name,
+      fields,
+      modulesDir: resolve2(opts.modulesDir),
+      noEntity: opts.entity === false,
+      noTests: opts.tests === false
+    });
+    console.log(`
+  Scaffolded ${name} with ${fields.length} field(s):`);
+    for (const f of fields) {
+      console.log(`    ${f.name}: ${f.type}${f.optional ? " (optional)" : ""}`);
+    }
+    printGenerated(files);
+  });
+  gen.command("config").description("Generate a kick.config.ts at the project root").option("--modules-dir <dir>", "Modules directory path", "src/modules").option("--repo <type>", "Default repository type: inmemory | drizzle", "inmemory").option("-f, --force", "Overwrite existing kick.config.ts without prompting").action(async (opts) => {
+    const files = await generateConfig({
+      outDir: resolve2("."),
+      modulesDir: opts.modulesDir,
+      defaultRepo: opts.repo,
+      force: opts.force
+    });
+    printGenerated(files);
+  });
+}
+__name(registerGenerateCommand, "registerGenerateCommand");
+
+// src/commands/run.ts
+import { cpSync, existsSync as existsSync3, mkdirSync } from "fs";
+import { resolve as resolve3, join as join14 } from "path";
+
+// src/utils/shell.ts
+import { execSync as execSync2 } from "child_process";
+function runShellCommand(command, cwd) {
+  execSync2(command, {
+    cwd,
+    stdio: "inherit"
+  });
+}
+__name(runShellCommand, "runShellCommand");
+
+// src/config.ts
+import { readFile as readFile4, access as access2 } from "fs/promises";
+import { join as join13 } from "path";
+var CONFIG_FILES = [
+  "kick.config.ts",
+  "kick.config.js",
+  "kick.config.mjs",
+  "kick.config.json"
+];
+async function loadKickConfig(cwd) {
+  for (const filename of CONFIG_FILES) {
+    const filepath = join13(cwd, filename);
+    try {
+      await access2(filepath);
+    } catch {
+      continue;
+    }
+    if (filename.endsWith(".json")) {
+      const content = await readFile4(filepath, "utf-8");
+      return JSON.parse(content);
+    }
+    try {
+      const { pathToFileURL: pathToFileURL2 } = await import("url");
+      const mod = await import(pathToFileURL2(filepath).href);
+      return mod.default ?? mod;
+    } catch (err) {
+      if (filename.endsWith(".ts")) {
+        console.warn(`Warning: Failed to load ${filename}. TypeScript config files require a runtime loader (e.g. tsx, ts-node) or use kick.config.js/.mjs instead.`);
+      }
+      continue;
+    }
+  }
+  return null;
+}
+__name(loadKickConfig, "loadKickConfig");
+
+// src/commands/run.ts
+function registerRunCommands(program) {
+  program.command("dev").description("Start development server with Vite HMR (zero-downtime reload)").option("-e, --entry <file>", "Entry file", "src/index.ts").option("-p, --port <port>", "Port number").action((opts) => {
+    const envVars = [];
+    if (opts.port) envVars.push(`PORT=${opts.port}`);
+    const cmd = `npx vite-node --watch ${opts.entry}`;
+    const fullCmd = envVars.length ? `${envVars.join(" ")} ${cmd}` : cmd;
+    console.log(`
+  KickJS dev server starting...`);
+    console.log(`  Entry:  ${opts.entry}`);
+    console.log(`  HMR:    enabled (vite-node)
+`);
+    try {
+      runShellCommand(fullCmd);
+    } catch {
+    }
+  });
+  program.command("build").description("Build for production via Vite").action(async () => {
+    console.log("\n  Building for production...\n");
+    runShellCommand("npx vite build");
+    const config = await loadKickConfig(process.cwd());
+    const copyDirs = config?.copyDirs ?? [];
+    if (copyDirs.length > 0) {
+      console.log("\n  Copying directories to dist...");
+      for (const entry of copyDirs) {
+        const src = typeof entry === "string" ? entry : entry.src;
+        const dest = typeof entry === "string" ? join14("dist", entry) : entry.dest ?? join14("dist", src);
+        const srcPath = resolve3(src);
+        const destPath = resolve3(dest);
+        if (!existsSync3(srcPath)) {
+          console.log(`    \u26A0 Skipped ${src} (not found)`);
+          continue;
+        }
+        mkdirSync(destPath, {
+          recursive: true
+        });
+        cpSync(srcPath, destPath, {
+          recursive: true
+        });
+        console.log(`    \u2713 ${src} \u2192 ${dest}`);
+      }
+    }
+    console.log("\n  Build complete.\n");
+  });
+  program.command("start").description("Start production server").option("-e, --entry <file>", "Entry file", "dist/index.js").option("-p, --port <port>", "Port number").action((opts) => {
+    const envVars = [
+      "NODE_ENV=production"
+    ];
+    if (opts.port) envVars.push(`PORT=${opts.port}`);
+    runShellCommand(`${envVars.join(" ")} node ${opts.entry}`);
+  });
+  program.command("dev:debug").description("Start dev server with Node.js inspector").option("-e, --entry <file>", "Entry file", "src/index.ts").option("-p, --port <port>", "Port number").action((opts) => {
+    const envVars = opts.port ? `PORT=${opts.port} ` : "";
+    try {
+      runShellCommand(`${envVars}npx vite-node --inspect --watch ${opts.entry}`);
+    } catch {
+    }
+  });
+}
+__name(registerRunCommands, "registerRunCommands");
+
+// src/commands/info.ts
+import { platform, release, arch } from "os";
+function registerInfoCommand(program) {
+  program.command("info").description("Print system and framework info").action(() => {
+    console.log(`
+  KickJS CLI
+
+  System:
+    OS:       ${platform()} ${release()} (${arch()})
+    Node:     ${process.version}
+
+  Packages:
+    @forinda/kickjs-core     workspace
+    @forinda/kickjs-http     workspace
+    @forinda/kickjs-config   workspace
+    @forinda/kickjs-cli      workspace
+`);
+  });
+}
+__name(registerInfoCommand, "registerInfoCommand");
+
+// src/commands/custom.ts
+function registerCustomCommands(program, config) {
+  if (!config?.commands?.length) return;
+  for (const cmd of config.commands) {
+    registerSingleCommand(program, cmd);
+  }
+}
+__name(registerCustomCommands, "registerCustomCommands");
+function registerSingleCommand(program, def) {
+  const command = program.command(def.name).description(def.description);
+  if (def.aliases) {
     for (const alias of def.aliases) {
       command.alias(alias);
     }
@@ -1813,45 +2688,360 @@ function registerInspectCommand(program) {
 }
 __name(registerInspectCommand, "registerInspectCommand");
 
-// src/config.ts
-import { readFile as readFile3, access as access2 } from "fs/promises";
-import { join as join10 } from "path";
-var CONFIG_FILES = [
-  "kick.config.ts",
-  "kick.config.js",
-  "kick.config.mjs",
-  "kick.config.json"
-];
-async function loadKickConfig(cwd) {
-  for (const filename of CONFIG_FILES) {
-    const filepath = join10(cwd, filename);
-    try {
-      await access2(filepath);
-    } catch {
-      continue;
+// src/commands/add.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve4 } from "path";
+var PACKAGE_REGISTRY = {
+  // Core (already installed by kick new)
+  core: {
+    pkg: "@forinda/kickjs-core",
+    peers: [],
+    description: "DI container, decorators, reactivity"
+  },
+  http: {
+    pkg: "@forinda/kickjs-http",
+    peers: [
+      "express"
+    ],
+    description: "Express 5, routing, middleware"
+  },
+  config: {
+    pkg: "@forinda/kickjs-config",
+    peers: [],
+    description: "Zod-based env validation"
+  },
+  cli: {
+    pkg: "@forinda/kickjs-cli",
+    peers: [],
+    description: "CLI tool and code generators",
+    dev: true
+  },
+  // API
+  swagger: {
+    pkg: "@forinda/kickjs-swagger",
+    peers: [],
+    description: "OpenAPI spec + Swagger UI + ReDoc"
+  },
+  graphql: {
+    pkg: "@forinda/kickjs-graphql",
+    peers: [
+      "graphql"
+    ],
+    description: "GraphQL resolvers + GraphiQL"
+  },
+  // Database
+  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"
+  },
+  // Real-time
+  ws: {
+    pkg: "@forinda/kickjs-ws",
+    peers: [
+      "socket.io"
+    ],
+    description: "WebSocket with @WsController decorators"
+  },
+  // Observability
+  otel: {
+    pkg: "@forinda/kickjs-otel",
+    peers: [
+      "@opentelemetry/api"
+    ],
+    description: "OpenTelemetry tracing + metrics"
+  },
+  // DevTools
+  devtools: {
+    pkg: "@forinda/kickjs-devtools",
+    peers: [],
+    description: "Development dashboard \u2014 routes, DI, metrics, health",
+    dev: true
+  },
+  // Auth
+  auth: {
+    pkg: "@forinda/kickjs-auth",
+    peers: [
+      "jsonwebtoken"
+    ],
+    description: "Authentication \u2014 JWT, API key, and custom strategies"
+  },
+  // Mailer
+  mailer: {
+    pkg: "@forinda/kickjs-mailer",
+    peers: [
+      "nodemailer"
+    ],
+    description: "Email sending \u2014 SMTP, Resend, SES, or custom provider"
+  },
+  // Cron
+  cron: {
+    pkg: "@forinda/kickjs-cron",
+    peers: [
+      "croner"
+    ],
+    description: "Cron job scheduling (production-grade with croner)"
+  },
+  // Queue
+  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"
+  },
+  // Multi-tenancy
+  "multi-tenant": {
+    pkg: "@forinda/kickjs-multi-tenant",
+    peers: [],
+    description: "Tenant resolution middleware"
+  },
+  // Notifications
+  notifications: {
+    pkg: "@forinda/kickjs-notifications",
+    peers: [],
+    description: "Multi-channel notifications \u2014 email, Slack, Discord, webhook"
+  },
+  // Testing
+  testing: {
+    pkg: "@forinda/kickjs-testing",
+    peers: [],
+    description: "Test utilities and TestModule builder",
+    dev: true
+  }
+};
+function detectPackageManager() {
+  if (existsSync4(resolve4("pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync4(resolve4("yarn.lock"))) return "yarn";
+  return "npm";
+}
+__name(detectPackageManager, "detectPackageManager");
+function registerAddCommand(program) {
+  program.command("add [packages...]").description("Add KickJS packages with their required dependencies").option("--pm <manager>", "Package manager override").option("-D, --dev", "Install as dev dependency").option("--list", "List all available packages").action(async (packages, opts) => {
+    if (opts.list || packages.length === 0) {
+      console.log("\n  Available KickJS packages:\n");
+      const maxName = Math.max(...Object.keys(PACKAGE_REGISTRY).map((k) => k.length));
+      for (const [name, info] of Object.entries(PACKAGE_REGISTRY)) {
+        const padded = name.padEnd(maxName + 2);
+        const peers = info.peers.length ? ` (+ ${info.peers.join(", ")})` : "";
+        console.log(`    ${padded} ${info.description}${peers}`);
+      }
+      console.log("\n  Usage: kick add graphql drizzle otel");
+      console.log("         kick add queue:bullmq");
+      console.log();
+      return;
     }
-    if (filename.endsWith(".json")) {
-      const content = await readFile3(filepath, "utf-8");
-      return JSON.parse(content);
+    const pm = opts.pm ?? detectPackageManager();
+    const forceDevFlag = opts.dev;
+    const prodDeps = /* @__PURE__ */ new Set();
+    const devDeps = /* @__PURE__ */ new Set();
+    const unknown = [];
+    for (const name of packages) {
+      const entry = PACKAGE_REGISTRY[name];
+      if (!entry) {
+        unknown.push(name);
+        continue;
+      }
+      const target = forceDevFlag || entry.dev ? devDeps : prodDeps;
+      target.add(entry.pkg);
+      for (const peer of entry.peers) {
+        target.add(peer);
+      }
+    }
+    if (unknown.length > 0) {
+      console.log(`
+  Unknown packages: ${unknown.join(", ")}`);
+      console.log('  Run "kick add --list" to see available packages.\n');
+      if (prodDeps.size === 0 && devDeps.size === 0) return;
+    }
+    if (prodDeps.size > 0) {
+      const deps = Array.from(prodDeps);
+      const cmd = `${pm} add ${deps.join(" ")}`;
+      console.log(`
+  Installing ${deps.length} dependency(ies):`);
+      for (const dep of deps) console.log(`    + ${dep}`);
+      console.log();
+      try {
+        execSync3(cmd, {
+          stdio: "inherit"
+        });
+      } catch {
+        console.log(`
+  Installation failed. Run manually:
+    ${cmd}
+`);
+      }
+    }
+    if (devDeps.size > 0) {
+      const deps = Array.from(devDeps);
+      const cmd = `${pm} add -D ${deps.join(" ")}`;
+      console.log(`
+  Installing ${deps.length} dev dependency(ies):`);
+      for (const dep of deps) console.log(`    + ${dep} (dev)`);
+      console.log();
+      try {
+        execSync3(cmd, {
+          stdio: "inherit"
+        });
+      } catch {
+        console.log(`
+  Installation failed. Run manually:
+    ${cmd}
+`);
+      }
+    }
+    console.log("  Done!\n");
+  });
+}
+__name(registerAddCommand, "registerAddCommand");
+
+// src/commands/tinker.ts
+import { resolve as resolve5, join as join15 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { pathToFileURL } from "url";
+import { fork } from "child_process";
+function registerTinkerCommand(program) {
+  program.command("tinker").description("Interactive REPL with DI container and services loaded").option("-e, --entry <file>", "Entry file to load", "src/index.ts").action(async (opts) => {
+    const cwd = process.cwd();
+    const entryPath = resolve5(cwd, opts.entry);
+    if (!existsSync5(entryPath)) {
+      console.error(`
+  Error: ${opts.entry} not found.
+`);
+      process.exit(1);
+    }
+    const tsxBin = findBin(cwd, "tsx");
+    if (!tsxBin) {
+      console.error("\n  Error: tsx not found. Install it: pnpm add -D tsx\n");
+      process.exit(1);
     }
+    const tinkerScript = generateTinkerScript(entryPath, opts.entry);
+    const tmpFile = join15(cwd, ".kick-tinker.mjs");
+    const { writeFileSync, unlinkSync } = await import("fs");
+    writeFileSync(tmpFile, tinkerScript, "utf-8");
     try {
-      const { pathToFileURL } = await import("url");
-      const mod = await import(pathToFileURL(filepath).href);
-      return mod.default ?? mod;
-    } catch (err) {
-      if (filename.endsWith(".ts")) {
-        console.warn(`Warning: Failed to load ${filename}. TypeScript config files require a runtime loader (e.g. tsx, ts-node) or use kick.config.js/.mjs instead.`);
+      const child = fork(tmpFile, [], {
+        cwd,
+        execPath: tsxBin,
+        stdio: "inherit"
+      });
+      await new Promise((resolve6) => {
+        child.on("exit", () => resolve6());
+      });
+    } finally {
+      try {
+        unlinkSync(tmpFile);
+      } catch {
       }
-      continue;
     }
+  });
+}
+__name(registerTinkerCommand, "registerTinkerCommand");
+function generateTinkerScript(entryPath, displayPath) {
+  const entryUrl = pathToFileURL(entryPath).href;
+  return `
+import 'reflect-metadata'
+
+// Prevent bootstrap() from starting the HTTP server
+process.env.KICK_TINKER = '1'
+
+console.log('\\n  \u{1F527} KickJS Tinker')
+console.log('  Loading: ${displayPath}\\n')
+
+// Load core
+let Container, Logger, HttpException, HttpStatus
+try {
+  const core = await import('@forinda/kickjs-core')
+  Container = core.Container
+  Logger = core.Logger
+  HttpException = core.HttpException
+  HttpStatus = core.HttpStatus
+} catch {
+  console.error('  Error: @forinda/kickjs-core not found.')
+  console.error('  Install it: pnpm add @forinda/kickjs-core\\n')
+  process.exit(1)
+}
+
+// Load entry to trigger decorator registration
+try {
+  await import('${entryUrl}')
+} 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    \u2014 DI container instance')
+console.log('    resolve(T)   \u2014 shorthand for container.resolve(T)')
+console.log('    Container, Logger, HttpException, HttpStatus')
+console.log()
+
+server.on('exit', () => {
+  console.log('\\n  Goodbye!\\n')
+  process.exit(0)
+})
+`;
+}
+__name(generateTinkerScript, "generateTinkerScript");
+function findBin(startDir, name) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join15(dir, "node_modules", ".bin", name);
+    if (existsSync5(candidate)) return candidate;
+    const parent = resolve5(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
   }
   return null;
 }
-__name(loadKickConfig, "loadKickConfig");
+__name(findBin, "findBin");
 
 // src/cli.ts
 var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
-var pkg = JSON.parse(readFileSync2(join11(__dirname2, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync2(join16(__dirname2, "..", "package.json"), "utf-8"));
 async function main() {
   const program = new Command();
   program.name("kick").description("KickJS \u2014 A production-grade, decorator-driven Node.js framework").version(pkg.version);
@@ -1861,6 +3051,8 @@ async function main() {
   registerRunCommands(program);
   registerInfoCommand(program);
   registerInspectCommand(program);
+  registerAddCommand(program);
+  registerTinkerCommand(program);
   registerCustomCommands(program, config);
   program.showHelpAfterError();
   await program.parseAsync(process.argv);