@forinda/kickjs-cli 1.0.0 → 1.1.1

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 join14 } from "path";
+import { dirname as dirname3, join as join16 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/init.ts
@@ -296,7 +296,7 @@ function getEntryFile(name, template) {
     case "graphql":
       return `import 'reflect-metadata'
 import { bootstrap } from '@forinda/kickjs-http'
-import { DevToolsAdapter } from '@forinda/kickjs-http/devtools'
+import { DevToolsAdapter } from '@forinda/kickjs-devtools'
 import { GraphQLAdapter } from '@forinda/kickjs-graphql'
 import { modules } from './modules'
 
@@ -318,7 +318,7 @@ bootstrap({
     case "microservice":
       return `import 'reflect-metadata'
 import { bootstrap } from '@forinda/kickjs-http'
-import { DevToolsAdapter } from '@forinda/kickjs-http/devtools'
+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'
@@ -351,7 +351,7 @@ bootstrap({ modules })
     default:
       return `import 'reflect-metadata'
 import { bootstrap } from '@forinda/kickjs-http'
-import { DevToolsAdapter } from '@forinda/kickjs-http/devtools'
+import { DevToolsAdapter } from '@forinda/kickjs-devtools'
 import { SwaggerAdapter } from '@forinda/kickjs-swagger'
 import { modules } from './modules'
 
@@ -1528,10 +1528,10 @@ async function confirm2(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     rl.question(`  ${message} (y/N) `, (answer) => {
       rl.close();
-      resolve5(answer.trim().toLowerCase() === "y");
+      resolve6(answer.trim().toLowerCase() === "y");
     });
   });
 }
@@ -1714,6 +1714,543 @@ export class ${pascal}Job {
 }
 __name(generateJob, "generateJob");
 
+// 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();
@@ -1795,6 +2332,26 @@ function registerGenerateCommand(program) {
     });
     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("."),
@@ -1809,7 +2366,7 @@ __name(registerGenerateCommand, "registerGenerateCommand");
 
 // src/commands/run.ts
 import { cpSync, existsSync as existsSync3, mkdirSync } from "fs";
-import { resolve as resolve3, join as join13 } from "path";
+import { resolve as resolve3, join as join14 } from "path";
 
 // src/utils/shell.ts
 import { execSync as execSync2 } from "child_process";
@@ -1822,8 +2379,8 @@ function runShellCommand(command, cwd) {
 __name(runShellCommand, "runShellCommand");
 
 // src/config.ts
-import { readFile as readFile3, access as access2 } from "fs/promises";
-import { join as join12 } from "path";
+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",
@@ -1832,19 +2389,19 @@ var CONFIG_FILES = [
 ];
 async function loadKickConfig(cwd) {
   for (const filename of CONFIG_FILES) {
-    const filepath = join12(cwd, filename);
+    const filepath = join13(cwd, filename);
     try {
       await access2(filepath);
     } catch {
       continue;
     }
     if (filename.endsWith(".json")) {
-      const content = await readFile3(filepath, "utf-8");
+      const content = await readFile4(filepath, "utf-8");
       return JSON.parse(content);
     }
     try {
-      const { pathToFileURL } = await import("url");
-      const mod = await import(pathToFileURL(filepath).href);
+      const { pathToFileURL: pathToFileURL2 } = await import("url");
+      const mod = await import(pathToFileURL2(filepath).href);
       return mod.default ?? mod;
     } catch (err) {
       if (filename.endsWith(".ts")) {
@@ -1883,7 +2440,7 @@ function registerRunCommands(program) {
       console.log("\n  Copying directories to dist...");
       for (const entry of copyDirs) {
         const src = typeof entry === "string" ? entry : entry.src;
-        const dest = typeof entry === "string" ? join13("dist", entry) : entry.dest ?? join13("dist", 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)) {
@@ -2157,7 +2714,8 @@ var PACKAGE_REGISTRY = {
   cli: {
     pkg: "@forinda/kickjs-cli",
     peers: [],
-    description: "CLI tool and code generators"
+    description: "CLI tool and code generators",
+    dev: true
   },
   // API
   swagger: {
@@ -2203,6 +2761,37 @@ var PACKAGE_REGISTRY = {
     ],
     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",
@@ -2237,11 +2826,18 @@ var PACKAGE_REGISTRY = {
     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"
+    description: "Test utilities and TestModule builder",
+    dev: true
   }
 };
 function detectPackageManager() {
@@ -2266,8 +2862,9 @@ function registerAddCommand(program) {
       return;
     }
     const pm = opts.pm ?? detectPackageManager();
-    const devFlag = opts.dev ? " -D" : "";
-    const allDeps = /* @__PURE__ */ new Set();
+    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];
@@ -2275,43 +2872,176 @@ function registerAddCommand(program) {
         unknown.push(name);
         continue;
       }
-      allDeps.add(entry.pkg);
+      const target = forceDevFlag || entry.dev ? devDeps : prodDeps;
+      target.add(entry.pkg);
       for (const peer of entry.peers) {
-        allDeps.add(peer);
+        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 (allDeps.size === 0) return;
+      if (prodDeps.size === 0 && devDeps.size === 0) return;
     }
-    const depsArray = Array.from(allDeps);
-    const installCmd = `${pm} add${devFlag} ${depsArray.join(" ")}`;
-    console.log(`
-  Installing ${depsArray.length} package(s):`);
-    for (const dep of depsArray) {
-      console.log(`    + ${dep}`);
+    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}
+`);
+      }
     }
-    console.log();
-    try {
-      execSync3(installCmd, {
-        stdio: "inherit"
-      });
-      console.log("\n  Done!\n");
-    } catch {
+    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:
-    ${installCmd}
+    ${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 child = fork(tmpFile, [], {
+        cwd,
+        execPath: tsxBin,
+        stdio: "inherit"
+      });
+      await new Promise((resolve6) => {
+        child.on("exit", () => resolve6());
+      });
+    } finally {
+      try {
+        unlinkSync(tmpFile);
+      } catch {
+      }
+    }
+  });
+}
+__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(findBin, "findBin");
+
 // src/cli.ts
 var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
-var pkg = JSON.parse(readFileSync2(join14(__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);
@@ -2322,6 +3052,7 @@ async function main() {
   registerInfoCommand(program);
   registerInspectCommand(program);
   registerAddCommand(program);
+  registerTinkerCommand(program);
   registerCustomCommands(program, config);
   program.showHelpAfterError();
   await program.parseAsync(process.argv);