@nexusts/cli 0.7.0

package/dist/index.js

@@ -0,0 +1,4169 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = import.meta.require;
+
+// packages/cli/src/commands/info.ts
+import { resolve } from "path";
+import { colors, logger } from "@nexusts/core/index.js";
+var infoCommand = {
+  name: "info",
+  aliases: ["i"],
+  summary: "Show project configuration",
+  description: "Prints the resolved nx.config.ts plus relevant env vars.",
+  async run(ctx) {
+    logger.heading("Nexus CLI \u2014 Project Info");
+    logger.info(colors.bold("Resolved configuration"));
+    logger.blank();
+    logger.table([
+      ["routing", String(ctx.config.routing)],
+      ["view", String(ctx.config.view)],
+      ["orm", String(ctx.config.orm)],
+      ["dialect", String(ctx.config.dialect ?? "(none)")],
+      ["database.driver", String(ctx.config.database.driver)],
+      ["database.url", String(ctx.config.database.url)],
+      ["inertia.frontend", String(ctx.config.inertia.frontend)],
+      ["inertia.ssr", String(ctx.config.inertia.ssr)],
+      ["inertia.version", String(ctx.config.inertia.version)]
+    ]);
+    logger.blank();
+    logger.info(colors.bold("Paths"));
+    logger.blank();
+    for (const [k, v] of Object.entries(ctx.config.paths)) {
+      logger.table([[k, v]]);
+    }
+    logger.blank();
+    logger.info(colors.bold("Environment"));
+    logger.blank();
+    const envKeys = [
+      "NODE_ENV",
+      "PORT",
+      "NEXUS_DEBUG",
+      "NO_COLOR",
+      "FORCE_COLOR",
+      "NX_ROUTING",
+      "NX_VIEW",
+      "NX_ORM",
+      "NX_DATABASE_DRIVER",
+      "NX_DATABASE_URL",
+      "NX_INERTIA_FRONTEND",
+      "NX_INERTIA_SSR"
+    ];
+    for (const k of envKeys) {
+      const v = process.env[k];
+      logger.table([[k, v === undefined ? colors.dim("(unset)") : v]]);
+    }
+    logger.blank();
+    logger.info(colors.bold("Working directory"));
+    logger.blank();
+    logger.info(`  ${resolve(ctx.cwd)}`);
+    logger.blank();
+    return 0;
+  }
+};
+var info_default = infoCommand;
+
+// packages/cli/src/commands/init.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { flagBool, logger as logger2, render, select } from "@nexusts/core/index.js";
+import { parseJsonLoose } from "@nexusts/core/loose-json.js";
+
+// packages/cli/src/templates/controller/adonis.ts
+var adonis_default = `
+import { {{ service }} } from '../services/{{ kebab }}.service.js';
+
+export class {{ name }}Controller {
+  async index() {
+    return new {{ service }}().findAll();
+  }
+
+  async show({ params }: { params: { id: string } }) {
+    return new {{ service }}().findOne(Number(params.id));
+  }
+
+  async create({ body }: { body: any }) {
+    return { status: 201, body: new {{ service }}().create(body) };
+  }
+
+  async update({ params, body }: { params: { id: string }; body: any }) {
+    return new {{ service }}().update(Number(params.id), body);
+  }
+
+  async destroy({ params }: { params: { id: string } }) {
+    return new {{ service }}().delete(Number(params.id));
+  }
+}
+
+export const {{ camel }}Controller = new {{ name }}Controller();
+`.trimStart();
+
+// packages/cli/src/templates/controller/functional.ts
+var functional_default = `
+import type { Context } from 'hono';
+
+export const {{ camel }}Routes = {
+  list: async (c: Context) => {
+    return c.json([]);
+  },
+
+  show: async (c: Context) => {
+    const id = c.req.param('id');
+    return c.json({ id });
+  },
+
+  create: async (c: Context) => {
+    const body = await c.req.json();
+    return c.json({ created: body }, 201);
+  },
+
+  update: async (c: Context) => {
+    const id = c.req.param('id');
+    const body = await c.req.json();
+    return c.json({ id, body });
+  },
+
+  destroy: async (c: Context) => {
+    const id = c.req.param('id');
+    return c.json({ removed: id });
+  },
+};
+`.trimStart();
+
+// packages/cli/src/templates/controller/nest.ts
+var nest_default = `
+import { Body, Controller, Delete, Get, Inject, Param, Post, Put } from '@nexusts/core';
+import { {{ service }} } from '../services/{{ kebab }}.service.js';
+
+@Controller('/{{ kebab }}s')
+export class {{ name }}Controller {
+  constructor(@Inject({{ service }}) private readonly {{ serviceCamel }}: {{ service }}) {}
+
+  @Get('/')
+  async index() {
+    return this.{{ serviceCamel }}.findAll();
+  }
+
+  @Get('/:id')
+  async show(@Param('id') id: string) {
+    return this.{{ serviceCamel }}.findOne(Number(id));
+  }
+
+  @Post('/')
+  async create(@Body() body: any) {
+    return { status: 201, body: this.{{ serviceCamel }}.create(body) };
+  }
+
+  @Put('/:id')
+  async update(@Param('id') id: string, @Body() body: any) {
+    return this.{{ serviceCamel }}.update(Number(id), body);
+  }
+
+  @Delete('/:id')
+  async destroy(@Param('id') id: string) {
+    return this.{{ serviceCamel }}.delete(Number(id));
+  }
+}
+`.trimStart();
+
+// packages/cli/src/templates/crud/controller.ts
+var controller_default = `
+import { Body, Controller, Delete, Get, Inject, Param, Post, Put } from '@nexusts/core';
+import { z } from 'zod';
+import { Validate } from '@nexusts/core';
+import { {{ service }} } from '../services/{{ kebab }}.service.js';
+{{#hasInertia}}import { Inertia } from '@nexusts/view/inertia';{{/hasInertia}}
+
+const Create{{ name }}Schema = z.object({
+  // TODO: define fields
+  title: z.string().min(1),
+});
+
+@Controller('/{{ kebab }}s')
+export class {{ controller }} {
+  constructor(
+    @Inject({{ service }}) private readonly {{ camel }}Service: {{ service }},
+{{#hasInertia}}    @Inject(Inertia.TOKEN) private readonly inertia: Inertia,{{/hasInertia}}
+  ) {}
+
+  @Get('/')
+  async index() {
+    const items = await this.{{ camel }}Service.findAll();
+{{#hasInertia}}
+    return this.inertia.render('{{ viewComponent }}', { items });
+{{/hasInertia}}
+{{^hasInertia}}
+    return items;
+{{/hasInertia}}
+  }
+
+  @Get('/:id')
+  async show(@Param('id') id: string) {
+    const item = await this.{{ camel }}Service.findOne(Number(id));
+{{#hasInertia}}
+    return this.inertia.render('{{ viewShowComponent }}', { item });
+{{/hasInertia}}
+{{^hasInertia}}
+    return item;
+{{/hasInertia}}
+  }
+
+  @Post('/')
+  @Validate({ body: Create{{ name }}Schema })
+  async create(@Body() body: z.infer<typeof Create{{ name }}Schema>) {
+    return { status: 201, body: await this.{{ camel }}Service.create(body) };
+  }
+
+  @Put('/:id')
+  @Validate({ body: Create{{ name }}Schema.partial() })
+  async update(
+    @Param('id') id: string,
+    @Body() body: Partial<z.infer<typeof Create{{ name }}Schema>>,
+  ) {
+    return await this.{{ camel }}Service.update(Number(id), body);
+  }
+
+  @Delete('/:id')
+  async destroy(@Param('id') id: string) {
+    return await this.{{ camel }}Service.delete(Number(id));
+  }
+}
+`.trimStart();
+
+// packages/cli/src/templates/crud/dto.ts
+var dto_default = `
+import { z } from 'zod';
+
+export const Create{{ name }}Dto = z.object({
+  // TODO: define fields. Example:
+  // title: z.string().min(1).max(200),
+  // body: z.string().optional(),
+});
+
+export const Update{{ name }}Dto = Create{{ name }}Dto.partial();
+
+export type Create{{ name }} = z.infer<typeof Create{{ name }}Dto>;
+export type Update{{ name }} = z.infer<typeof Update{{ name }}Dto>;
+`.trimStart();
+
+// packages/cli/src/templates/crud/module.ts
+var module_default = `
+import { Module } from '@nexusts/core';
+import { {{ controller }} } from '../controllers/{{ kebab }}.controller.js';
+import { {{ service }} } from '../services/{{ kebab }}.service.js';
+{{#hasRepo}}import { {{ repository }} } from '../repositories/{{ kebab }}.repository.js';{{/hasRepo}}
+
+@Module({
+  controllers: [{{ controller }}],
+  providers: [
+    {{ service }},
+    {{#hasRepo}}{{ repository }},{{/hasRepo}}
+  ],
+  exports: [{{ service }}],
+})
+export class {{ name }}Module {}
+`.trimStart();
+
+// packages/cli/src/templates/crud/test.ts
+var test_default = `
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Application } from '@nexusts/core';
+import { {{ name }}Module } from '../{{ kebab }}.module.js';
+
+describe('{{ controller }}', () => {
+  let app: Application;
+
+  beforeEach(() => {
+    app = new Application({{ name }}Module);
+  });
+
+  it('GET /{{ kebab }}s returns an empty list', async () => {
+    const res = await app.server.app.request('/{{ kebab }}s');
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(Array.isArray(body) || typeof body === 'object').toBe(true);
+  });
+
+  it('POST /{{ kebab }}s creates a record', async () => {
+    const res = await app.server.app.request('/{{ kebab }}s', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: 'Test' }),
+    });
+    expect([200, 201]).toContain(res.status);
+  });
+});
+`.trimStart();
+
+// packages/cli/src/templates/middleware/middleware.ts
+var middleware_default = `
+import { Injectable } from '@nexusts/core';
+import type { Context, Next } from 'hono';
+
+/**
+ * {{ name }} middleware \u2014 generated by \`nx make:middleware {{ name }}\`.
+ */
+@Injectable()
+export class {{ name }}Middleware {
+  async handle(c: Context, next: Next): Promise<Response> {
+    // TODO: pre-handler logic
+    const res = await next();
+    // TODO: post-handler logic
+    return res;
+  }
+}
+`.trimStart();
+
+// packages/cli/src/templates/migration/drizzle.ts
+var drizzle_default = `
+import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core';
+
+/**
+ * {{ name }} \u2014 migration generated by \`nx make:migration {{ name }}\`.
+ * Run with \`bunx drizzle-kit migrate\` or your migration runner.
+ */
+export const {{ snake }} = sqliteTable('{{ tableName }}', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+{{ columns }}
+  created_at: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+  updated_at: integer('updated_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+});
+`.trimStart();
+
+// packages/cli/src/templates/migration/sql.ts
+var sql_default = `
+-- {{ timestamp }}_create_{{ snake }}.sql
+-- Generated by \`nx make:migration {{ name }}\`.
+
+CREATE TABLE IF NOT EXISTS {{ tableName }} (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+{{ columns }}
+  created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+  updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+);
+`.trimStart();
+
+// packages/cli/src/templates/model/drizzle.ts
+var drizzle_default2 = `
+import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core';
+
+/**
+ * {{ tableName }} \u2014 generated by \`nx make:model {{ name }}\`.
+ */
+export const {{ snake }} = sqliteTable('{{ tableName }}', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+{{ columns }}
+  createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+  updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+});
+
+export type {{ name }} = typeof {{ snake }}.$inferSelect;
+export type New{{ name }} = typeof {{ snake }}.$inferInsert;
+`.trimStart();
+
+// packages/cli/src/templates/model/kysely.ts
+var kysely_default = `
+import type { Generated, Insertable, Selectable, Updateable } from 'kysely';
+import { Kysely } from 'kysely';
+import { Inject, Injectable } from '@nexusts/core';
+
+export interface {{ name }}Table {
+  id: Generated<number>;
+{{ columns }}
+  created_at: Generated<Date>;
+  updated_at: Generated<Date>;
+}
+
+export type {{ name }}       = Selectable<{{ name }}Table>;
+export type New{{ name }}    = Insertable<{{ name }}Table>;
+export type {{ name }}Update = Updateable<{{ name }}Table>;
+
+@Injectable()
+export class {{ name }}Repository {
+  constructor(@Inject('DB') private readonly db: Kysely<any>) {}
+
+  findAll() {
+    return this.db.selectFrom('{{ tableName }}').selectAll().execute();
+  }
+
+  findOne(id: number) {
+    return this.db
+      .selectFrom('{{ tableName }}')
+      .selectAll()
+      .where('id', '=', id)
+      .executeTakeFirst();
+  }
+
+  create(data: New{{ name }}) {
+    return this.db.insertInto('{{ tableName }}').values(data).returningAll().executeTakeFirst();
+  }
+
+  update(id: number, data: {{ name }}Update) {
+    return this.db
+      .updateTable('{{ tableName }}')
+      .set(data)
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst();
+  }
+
+  delete(id: number) {
+    return this.db.deleteFrom('{{ tableName }}').where('id', '=', id).execute();
+  }
+}
+`.trimStart();
+
+// packages/cli/src/templates/model/prisma.ts
+var prisma_default = `
+/**
+ * {{ name }} \u2014 generated by \`nx make:model {{ name }}\`.
+ *
+ * Add this block to your schema.prisma file:
+ *
+{{ prismaBlock }}
+ */
+
+import { PrismaClient } from '@prisma/client';
+import { Inject, Injectable } from '@nexusts/core';
+
+@Injectable()
+export class {{ name }}Repository {
+  constructor(@Inject('PRISMA') private readonly prisma: PrismaClient) {}
+
+  findAll() {
+    return this.prisma.{{ camel }}.findMany();
+  }
+
+  findOne(id: number) {
+    return this.prisma.{{ camel }}.findUnique({ where: { id } });
+  }
+
+  create(data: any) {
+    return this.prisma.{{ camel }}.create({ data });
+  }
+
+  update(id: number, data: any) {
+    return this.prisma.{{ camel }}.update({ where: { id }, data });
+  }
+
+  delete(id: number) {
+    return this.prisma.{{ camel }}.delete({ where: { id } });
+  }
+}
+`.trimStart();
+
+// packages/cli/src/templates/module/module.ts
+var module_default2 = `
+import { Module } from '@nexusts/core';
+import { {{ controller }} } from '../controllers/{{ kebab }}.controller.js';
+{{#hasService}}import { {{ service }} } from '../services/{{ kebab }}.service.js';{{/hasService}}
+{{#hasRepo}}import { {{ repository }} } from '../repositories/{{ kebab }}.repository.js';{{/hasRepo}}
+
+@Module({
+  controllers: [{{ controller }}],
+  providers: [
+    {{#hasService}}{{ service }},{{/hasService}}
+    {{#hasRepo}}{{ repository }},{{/hasRepo}}
+  ],
+  exports: [
+    {{#hasService}}{{ service }},{{/hasService}}
+  ],
+})
+export class {{ name }}Module {}
+`.trimStart();
+
+// packages/cli/src/templates/project/nx.config.ts
+var nx_config_default = `/**
+ * Nexus project configuration.
+ * Run \`nx info\` to see the resolved values.
+ */
+
+export default {
+  // ---------------------------------------------------------------------------
+  // Core
+  // ---------------------------------------------------------------------------
+
+  /** Routing style used by \`make:controller\` / \`make:crud\`. */
+  routing: '{{ routing }}',
+
+  /** View engine \u2014 \`inertia\`, \`rendu\`, \`edge\`, or \`none\`. */
+  view: '{{ view }}',
+
+  /**
+   * Directory searched when a controller returns a view file name
+   * (e.g. \`about.html\`). Empty string = inline templates only.
+   * Typical: \`'resources/views'\`. On edge runtimes
+   * (Cloudflare Workers), leave empty and pass inline strings.
+   */
+  viewPaths: '{{ viewPaths }}',
+
+  /** ORM driver \u2014 \`drizzle\`, \`prisma\`, \`kysely\`, or \`none\`. */
+  orm: '{{ orm }}',
+
+  // ---------------------------------------------------------------------------
+  // Database
+  // ---------------------------------------------------------------------------
+
+  database: {
+    driver: '{{ dbDriver }}',
+    url: process.env.DATABASE_URL ?? '{{ dbUrl }}',
+  },
+
+  // ---------------------------------------------------------------------------
+  // Inertia (only consulted when \`view === 'inertia'\`)
+  // ---------------------------------------------------------------------------
+
+  inertia: {
+    frontend: '{{ inertiaFrontend }}',
+    ssr: {{ inertiaSSR }},
+    version: '{{ inertiaVersion }}',
+  },
+
+  // ---------------------------------------------------------------------------
+  // Paths
+  // ---------------------------------------------------------------------------
+
+  paths: {
+    app:         'app',
+    controllers: 'app/controllers',
+    services:    'app/services',
+    modules:     'app/modules',
+    models:      'app/models',
+    migrations:  'app/database/migrations',
+    seeds:       'db/seeds',
+    middleware:  'app/middleware',
+    dto:         'app/dto',
+  },
+};
+`;
+
+// packages/cli/src/templates/project/drizzle.config.ts
+var drizzle_config_default = `
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  dialect: "{{ dialect }}",
+  schema: "./app/models/*.model.ts",
+  out: "./drizzle",
+  dbCredentials: {
+    url: process.env.DATABASE_URL ?? "{{ dbUrl }}",
+  },
+  verbose: true,
+  strict: true,
+});
+`;
+
+// packages/cli/src/templates/repository/repository.ts
+var repository_default = `
+import { Injectable } from '@nexusts/core';
+import { DrizzleRepository } from '@nexusts/drizzle';
+import { {{ tableName }} } from '../models/{{ kebab }}.model.js';
+import type { {{ name }}, New{{ name }} } from '../models/{{ kebab }}.model.js';
+
+@Injectable()
+export class {{ repository }} extends DrizzleRepository<typeof {{ tableName }}, {{ name }}> {
+  constructor() {
+    super({{ tableName }});
+  }
+}
+`.trimStart();
+
+// packages/cli/src/templates/service/service.ts
+var service_default = `
+import { Inject, Injectable } from '@nexusts/core';
+{{#hasRepo}}import { {{ repository }} } from '../repositories/{{ kebab }}.repository.js';{{/hasRepo}}
+
+@Injectable()
+export class {{ name }}Service {
+  constructor({{#hasRepo}}
+    @Inject({{ repository }}) private readonly {{ repositoryCamel }}: {{ repository }},
+  {{/hasRepo}}) {}
+
+  async findAll() {
+    {{#hasRepo}}return this.{{ repositoryCamel }}.findAll();{{/hasRepo}}
+    {{^hasRepo}}return []; // TODO: implement{{/hasRepo}}
+  }
+
+  async findOne(id: number) {
+    {{#hasRepo}}return this.{{ repositoryCamel }}.findOne(id);{{/hasRepo}}
+    {{^hasRepo}}return { id }; // TODO: implement{{/hasRepo}}
+  }
+
+  async create(data: any) {
+    {{#hasRepo}}return this.{{ repositoryCamel }}.create(data);{{/hasRepo}}
+    {{^hasRepo}}return { id: Date.now(), ...data }; // TODO: implement{{/hasRepo}}
+  }
+
+  async update(id: number, data: any) {
+    {{#hasRepo}}return this.{{ repositoryCamel }}.update(id, data);{{/hasRepo}}
+    {{^hasRepo}}return { id, ...data }; // TODO: implement{{/hasRepo}}
+  }
+
+  async delete(id: number) {
+    {{#hasRepo}}return this.{{ repositoryCamel }}.delete(id);{{/hasRepo}}
+    {{^hasRepo}}return { removed: id }; // TODO: implement{{/hasRepo}}
+  }
+}
+`.trimStart();
+
+// packages/cli/src/templates/validator/validator.ts
+var validator_default = `
+import { z } from 'zod';
+
+/**
+ * Validation schema for {{ name }}.
+ * Generated by \`nx make:validator {{ name }}\`.
+ */
+export const {{ name }}Schema = z.object({
+  // TODO: define fields. Example:
+  // name: z.string().min(1).max(100),
+  // email: z.string().email().optional(),
+});
+
+export type {{ name }}Input = z.infer<typeof {{ name }}Schema>;
+`.trimStart();
+
+// packages/cli/src/templates/index.ts
+var templates = {
+  controller: {
+    nest: nest_default,
+    adonis: adonis_default,
+    functional: functional_default
+  },
+  service: service_default,
+  repository: repository_default,
+  module: module_default2,
+  validator: validator_default,
+  middleware: middleware_default,
+  model: {
+    drizzle: drizzle_default2,
+    prisma: prisma_default,
+    kysely: kysely_default
+  },
+  migration: {
+    drizzle: drizzle_default,
+    sql: sql_default
+  },
+  crud: {
+    controller: controller_default,
+    module: module_default,
+    dto: dto_default,
+    test: test_default
+  },
+  project: {
+    "nx.config.ts": nx_config_default,
+    "drizzle.config.ts": drizzle_config_default
+  }
+};
+
+// packages/cli/src/commands/init.ts
+var initCommand = {
+  name: "init",
+  aliases: ["i"],
+  summary: "Initialize nx.config.ts + app scaffold in the current directory",
+  description: "Non-destructive scaffold: adds nx.config.ts, app/*, and merges NexusTS into the existing package.json and tsconfig.json. Skips files that already exist (unless --force).",
+  examples: [
+    "nx init",
+    "nx init ./my-existing-app",
+    "nx init --style nest --view inertia --orm drizzle --db bun-sqlite",
+    "nx init --force"
+  ],
+  flags: [
+    { name: "target", description: "Target directory (default: cwd)" },
+    {
+      name: "style",
+      description: "Routing style (nest|adonis|functional|mixed)"
+    },
+    { name: "view", description: "View engine (rendu|edge|eta|inertia|none)" },
+    { name: "orm", description: "ORM driver (drizzle|prisma|kysely|none)" },
+    {
+      name: "db",
+      description: "Database driver (bun-sqlite|node-sqlite|libsql|postgres|mysql|none)"
+    },
+    {
+      name: "frontend",
+      description: "Inertia frontend (react|vue|svelte|solid)"
+    },
+    { name: "no-ssr", description: "Disable Inertia SSR" },
+    { name: "force", description: "Overwrite files that already exist" },
+    { name: "no-interaction", description: "Disable interactive prompts" }
+  ],
+  async run(ctx) {
+    const interactive = !flagBool(ctx.flags, "no-interaction", false);
+    const force = flagBool(ctx.flags, "force", false);
+    const target = resolve2(ctx.cwd, ctx.flags["target"] ?? ".");
+    if (!existsSync(target)) {
+      logger2.error(`Target directory does not exist: ${target}`);
+      logger2.info(`Run \`nx new <name>\` to create a fresh project, or \`mkdir -p ${target}\` first.`);
+      return 1;
+    }
+    const routing = ctx.flags["style"] ?? await select("Routing style", ["nest", "adonis", "functional"], {
+      interactive,
+      default: "nest"
+    });
+    const view = ctx.flags["view"] ?? await select("View engine", ["rendu", "edge", "eta", "inertia", "none"], {
+      interactive,
+      default: "rendu"
+    });
+    const orm = ctx.flags["orm"] ?? await select("ORM driver", ["drizzle", "prisma", "kysely", "none"], {
+      interactive,
+      default: "drizzle"
+    });
+    const db = ctx.flags["db"] ?? await select("Database driver", ["bun-sqlite", "node-sqlite", "libsql", "postgres", "mysql", "none"], {
+      interactive,
+      default: "bun-sqlite"
+    });
+    const frontend = ctx.flags["frontend"] ?? await select("Inertia frontend", ["react", "vue", "svelte", "solid"], {
+      interactive,
+      default: "react"
+    });
+    const ssr = !flagBool(ctx.flags, "no-ssr", false);
+    const plan = [
+      { path: "nx.config.ts", mode: "write" },
+      { path: "package.json", mode: "merge-pkg" },
+      { path: "tsconfig.json", mode: "merge-tsconfig" },
+      { path: "public/.gitkeep", mode: "write" },
+      { path: "resources/views/welcome.html", mode: "write" },
+      { path: ".env", mode: "skip" },
+      { path: ".env.local", mode: "skip" },
+      { path: ".gitignore", mode: "skip" },
+      { path: "app/main.ts", mode: "write" },
+      { path: "app/app.module.ts", mode: "write" },
+      { path: "app/controllers/home.controller.ts", mode: "write" },
+      { path: "README.md", mode: "write" }
+    ];
+    const created = [];
+    const skipped = [];
+    const merged = [];
+    mkdirSync(resolve2(target, "app/controllers"), { recursive: true });
+    mkdirSync(resolve2(target, "public"), { recursive: true });
+    mkdirSync(resolve2(target, "resources/views"), { recursive: true });
+    for (const entry of plan) {
+      const abs = resolve2(target, entry.path);
+      const exists = existsSync(abs);
+      if (entry.mode === "merge-pkg") {
+        if (exists) {
+          mergePackageJson(abs, {
+            "@nexusts/core": "*",
+            "reflect-metadata": "^0.2.2",
+            hono: "^4.6.0",
+            zod: "^3.23.8"
+          });
+          merged.push(entry.path);
+        } else {
+          writeFileSync(abs, JSON.stringify({
+            name: target.split("/").pop() ?? "nexus-app",
+            version: "0.1.0",
+            type: "module",
+            private: true,
+            scripts: {
+              dev: "bun --hot app/main.ts",
+              build: "bun run build.ts",
+              start: "bun app/main.ts",
+              test: "vitest",
+              nx: "nx"
+            },
+            dependencies: {
+              "@nexusts/core": "*",
+              "reflect-metadata": "^0.2.2",
+              hono: "^4.6.0",
+              zod: "^3.23.8"
+            }
+          }, null, 2));
+          created.push(entry.path);
+        }
+        continue;
+      }
+      if (entry.mode === "merge-tsconfig") {
+        if (exists) {
+          mergeTsconfig(abs, {
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true
+          });
+          merged.push(entry.path);
+        } else {
+          writeFileSync(abs, defaultTsconfig());
+          created.push(entry.path);
+        }
+        continue;
+      }
+      if (exists && !force) {
+        skipped.push(entry.path);
+        continue;
+      }
+      const content = renderContent(entry.path, {
+        routing,
+        view,
+        viewPaths: view === "none" ? "" : "resources/views",
+        orm,
+        dbDriver: db,
+        dbUrl: db === "bun-sqlite" || db === "node-sqlite" ? "app.db" : "",
+        inertiaFrontend: frontend,
+        inertiaSSR: ssr,
+        inertiaVersion: "1.0.0",
+        targetName: target.split("/").pop() ?? "nexus-app"
+      });
+      writeFileSync(abs, content);
+      created.push(entry.path);
+    }
+    logger2.success(`initialized NexusTS in ${target}`);
+    logger2.blank();
+    if (created.length) {
+      logger2.heading("Created");
+      for (const f of created)
+        logger2.info(`  + ${f}`);
+    }
+    if (merged.length) {
+      logger2.heading("Merged into existing files");
+      for (const f of merged)
+        logger2.info(`  ~ ${f}`);
+    }
+    if (skipped.length) {
+      logger2.heading("Skipped (already exist; use --force to overwrite)");
+      for (const f of skipped)
+        logger2.info(`  - ${f}`);
+    }
+    logger2.blank();
+    logger2.heading("Next steps");
+    logger2.info(`  cd ${target === ctx.cwd ? "." : target}`);
+    logger2.info(`  bun install`);
+    logger2.info(`  bun run dev`);
+    logger2.blank();
+    return 0;
+  }
+};
+function renderContent(path, ctx) {
+  switch (path) {
+    case "nx.config.ts":
+      return render(templates.project["nx.config.ts"], ctx);
+    case "public/.gitkeep":
+      return "";
+    case "resources/views/welcome.html":
+      return `<h1>Welcome to ${ctx.targetName}</h1>
+<p>This is a sample Rendu template.</p>
+<p>Founded <?= year ?>.</p>
+`;
+    case ".gitignore":
+      return `# NexusTS
+node_modules/
+app.db
+*.db
+.env.local
+dist/
+`;
+    case ".env":
+      return `# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# NexusTS \u2014 Environment Variables (committed to git)
+#
+# Shared defaults for all environments. Override locally via
+# .env.local (gitignored) or by environment via .env.{NODE_ENV}
+# (e.g. .env.production, .env.development).
+#
+# Uncomment the database config for your driver:
+# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+# \u2500\u2500 App \u2500\u2500
+NODE_ENV=development
+PORT=3000
+
+# \u2500\u2500 Session secret (REQUIRED) \u2500\u2500
+# Generate with: openssl rand -base64 32
+SESSION_SECRET=change-me-in-production
+
+# \u2500\u2500 Database: SQLite (default, zero config) \u2500\u2500
+DATABASE_URL=app.db
+
+# \u2500\u2500 Database: PostgreSQL \u2500\u2500
+# DATABASE_URL=postgres://user:password@localhost:5432/myapp
+
+# \u2500\u2500 Database: MySQL \u2500\u2500
+# DATABASE_URL=mysql://user:password@localhost:3306/myapp
+
+# \u2500\u2500 Better Auth (if using nexusjs/auth) \u2500\u2500
+# BETTER_AUTH_SECRET=
+# BETTER_AUTH_URL=http://localhost:3000
+`;
+    case ".env.local":
+      return `# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# NexusTS \u2014 Local Overrides (DO NOT COMMIT to git)
+#
+# This file is gitignored. Use it for secrets and local
+# configuration that should never be checked in.
+# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+# Override any value from .env here:
+# DATABASE_URL=postgres://user:password@localhost:5432/myapp
+# SESSION_SECRET=my-local-secret
+`;
+    case "app/main.ts":
+      return `import 'reflect-metadata';
+import { Application } from '@nexusts/core';
+import { StaticModule } from '@nexusts/static';
+import { AppModule } from './app.module.js';
+
+const app = new Application(AppModule);
+// Serve ./public files under /static/*
+app.server.app.use('/static/*', StaticModule.mount({ root: './public', prefix: '/static' }));
+
+const port = Number(process.env["PORT"] ?? 3000);
+await app.listen(port);
+console.log("[nexusjs] Listening on http://localhost:" + port);
+`;
+    case "app/app.module.ts":
+      return `import { Module } from '@nexusts/core';
+import { HomeController } from './controllers/home.controller.js';
+
+@Module({
+  imports: [],
+  controllers: [HomeController],
+})
+export class AppModule {}
+`;
+    case "app/controllers/home.controller.ts":
+      return `import { Controller, Get } from '@nexusts/core';
+
+@Controller('/')
+export class HomeController {
+  @Get('/')
+  index() {
+    return {
+      view: 'welcome.html',
+      data: { year: new Date().getFullYear() },
+    };
+  }
+}
+`;
+    case "README.md":
+      return `# ${ctx.targetName}
+
+A Nexus project.
+
+## Run
+
+\`\`\`bash
+bun install
+bun run dev
+\`\`\`
+
+## Scaffolding
+
+\`\`\`bash
+bunx nx make:crud Post
+\`\`\`
+`;
+    default:
+      throw new Error(`No render template for: ${path}`);
+  }
+}
+function defaultTsconfig() {
+  return `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["bun-types"]
+  },
+  "include": ["app/**/*.ts", "nx.config.ts"]
+}
+`;
+}
+function mergePackageJson(path, additions) {
+  const raw = readFileSync(path, "utf8");
+  const pkg = parseJsonLoose(raw);
+  let changed = false;
+  if (!pkg["type"]) {
+    pkg["type"] = "module";
+    changed = true;
+  }
+  if (!pkg["private"]) {
+    pkg["private"] = true;
+    changed = true;
+  }
+  const SCRIPTS = {
+    dev: "bun --hot app/main.ts",
+    build: "bun run build.ts",
+    start: "bun app/main.ts",
+    test: "vitest",
+    nx: "nx"
+  };
+  const existingScripts = pkg["scripts"] ?? {};
+  for (const [k, v] of Object.entries(SCRIPTS)) {
+    if (!(k in existingScripts)) {
+      existingScripts[k] = v;
+      changed = true;
+    }
+  }
+  if (Object.keys(existingScripts).length > 0) {
+    pkg["scripts"] = existingScripts;
+  }
+  const deps = pkg["dependencies"] ?? {};
+  for (const [k, v] of Object.entries(additions)) {
+    if (!(k in deps)) {
+      deps[k] = v;
+      changed = true;
+    }
+  }
+  pkg["dependencies"] = deps;
+  if (changed) {
+    writeFileSync(path, JSON.stringify(pkg, null, 2) + `
+`);
+  }
+}
+function mergeTsconfig(path, additions) {
+  const raw = readFileSync(path, "utf8");
+  const cfg = parseJsonLoose(raw);
+  const co = cfg.compilerOptions ?? {};
+  let changed = false;
+  for (const [k, v] of Object.entries(additions)) {
+    if (!(k in co)) {
+      co[k] = v;
+      changed = true;
+    }
+  }
+  const inc = cfg.include ?? [];
+  if (!inc.includes("app/**/*.ts")) {
+    inc.push("app/**/*.ts");
+    changed = true;
+  }
+  if (!inc.includes("nx.config.ts")) {
+    inc.push("nx.config.ts");
+    changed = true;
+  }
+  if (changed) {
+    cfg.compilerOptions = co;
+    cfg.include = inc;
+    writeFileSync(path, JSON.stringify(cfg, null, 2) + `
+`);
+  }
+}
+var init_default = initCommand;
+
+// packages/cli/src/commands/make-auth.ts
+import { resolve as resolve3 } from "path";
+import {
+  flagList,
+  logger as logger3,
+  render as render2,
+  writeFile
+} from "@nexusts/core/index.js";
+var AUTH_INSTANCE_TEMPLATE = `/**
+ * Better-auth instance \u2014 generated by \`nx make:auth\`.
+ *
+ * Edit \`nx.config.ts\` (\`auth\` section) instead of this file when possible.
+ */
+import 'reflect-metadata';
+import { createAuth } from '@nexusts/auth';
+
+export const auth = createAuth({
+{{^jwt}}
+  jwt: { enabled: false },
+{{/jwt}}
+{{#jwt}}
+  jwt: { enabled: true },
+{{/jwt}}
+{{#passkey}}
+  passkey: {
+    enabled: true,
+    rpName: '{{ passkeyRpName }}',
+    rpId:   '{{ passkeyRpId }}',
+    origin: '{{ passkeyOrigin }}',
+  },
+{{/passkey}}
+{{#providers}}
+  socialProviders: {
+{{#entries}}
+    {{ name }}: {
+      clientId:     process.env.{{ envVar }}_CLIENT_ID!,
+      clientSecret: process.env.{{ envVar }}_CLIENT_SECRET!,
+    },
+{{/entries}}
+  },
+{{/providers}}
+});
+`;
+var ENV_EXAMPLE_TEMPLATE = `# Better Auth \u2014 generated by \`nx make:auth\`.
+# Generate a secret with: openssl rand -base64 32
+BETTER_AUTH_SECRET=
+BETTER_AUTH_URL=http://localhost:3000
+{{#providers}}
+{{#entries}}
+{{ envVar }}_CLIENT_ID=
+{{ envVar }}_CLIENT_SECRET=
+{{/entries}}
+{{/providers}}
+`;
+var MODULE_UPDATE_HINT = `import { AuthModule } from '@nexusts/auth';
+// In your AppModule.imports:
+imports: [AuthModule.forRoot({ /* ... */ })],
+`;
+var KNOWN_PROVIDERS = {
+  github: { env: "GITHUB", label: "GitHub" },
+  google: { env: "GOOGLE", label: "Google" },
+  discord: { env: "DISCORD", label: "Discord" },
+  microsoft: { env: "MICROSOFT", label: "Microsoft" },
+  apple: { env: "APPLE", label: "Apple" },
+  facebook: { env: "FACEBOOK", label: "Facebook" },
+  gitlab: { env: "GITLAB", label: "GitLab" },
+  slack: { env: "SLACK", label: "Slack" },
+  twitter: { env: "TWITTER", label: "Twitter" },
+  spotify: { env: "SPOTIFY", label: "Spotify" },
+  linkedin: { env: "LINKEDIN", label: "LinkedIn" }
+};
+var makeAuthCommand = {
+  name: "make:auth",
+  aliases: ["auth", "auth-install"],
+  summary: "Scaffold the auth module",
+  description: "Generates app/auth/auth.ts, .env.example, and an auth-ready module skeleton using better-auth.",
+  examples: [
+    "nx make:auth",
+    "nx make:auth --provider github --jwt",
+    "nx make:auth --provider github,google --jwt --passkey --rp-id example.com"
+  ],
+  flags: [
+    {
+      name: "provider",
+      description: "Comma-separated OAuth providers (github, google, ...)"
+    },
+    {
+      name: "jwt",
+      description: "Enable the JWT plugin (token + JWKS endpoint)"
+    },
+    { name: "passkey", description: "Enable the passkey (WebAuthn) plugin" },
+    { name: "rp-id", description: "Passkey RP ID (defaults to 'localhost')" },
+    { name: "rp-name", description: "Passkey RP display name" },
+    {
+      name: "origin",
+      description: "Passkey origin (defaults to http://localhost:3000)"
+    }
+  ],
+  async run(ctx) {
+    logger3.heading("Scaffolding auth module");
+    const providers = flagList(ctx.flags, "provider");
+    const jwtEnabled = ctx.flags["jwt"] === true;
+    const passkeyEnabled = ctx.flags["passkey"] === true;
+    const rpId = ctx.flags["rp-id"] ?? "localhost";
+    const rpName = ctx.flags["rp-name"] ?? "NexusTS App";
+    const origin = ctx.flags["origin"] ?? "http://localhost:3000";
+    const entries = providers.map((p) => {
+      const known = KNOWN_PROVIDERS[p.toLowerCase()];
+      return {
+        name: p.toLowerCase(),
+        envVar: known?.env ?? p.toUpperCase()
+      };
+    });
+    const authCode = render2(AUTH_INSTANCE_TEMPLATE, {
+      jwt: jwtEnabled,
+      passkey: passkeyEnabled,
+      providers: providers.length > 0,
+      entries,
+      passkeyRpName: rpName,
+      passkeyRpId: rpId,
+      passkeyOrigin: Array.isArray(origin) ? origin.join(",") : origin
+    });
+    const authOut = resolve3(ctx.cwd, "app/auth/auth.ts");
+    if (writeFile(authOut, authCode)) {
+      logger3.success(`created ${authOut}`);
+    } else {
+      logger3.warn(`skipped (exists): ${authOut}`);
+    }
+    const envCode = render2(ENV_EXAMPLE_TEMPLATE, {
+      providers: providers.length > 0,
+      entries
+    });
+    const envOut = resolve3(ctx.cwd, ".env.example");
+    if (writeFile(envOut, envCode, { skipIfExists: true })) {
+      logger3.success(`created ${envOut}`);
+    } else {
+      logger3.warn(`skipped (exists): ${envOut}`);
+    }
+    logger3.blank();
+    logger3.heading("Next steps");
+    logger3.info("1. Add a secret to .env:");
+    logger3.info("     BETTER_AUTH_SECRET=$(openssl rand -base64 32)");
+    logger3.info("2. Wire the module in AppModule:");
+    logger3.info(`     ${MODULE_UPDATE_HINT.trim()}`);
+    if (providers.length > 0) {
+      logger3.info(`3. Set up OAuth credentials for: ${providers.join(", ")}`);
+    }
+    if (passkeyEnabled) {
+      logger3.info("4. Configure passkey RP ID + origin for your domain.");
+    }
+    logger3.info("5. Run `bun --hot app/main.ts` to start the server.");
+    logger3.blank();
+    return 0;
+  }
+};
+var make_auth_default = makeAuthCommand;
+
+// packages/cli/src/commands/make-controller.ts
+import { resolve as resolve4 } from "path";
+import { logger as logger4, nameVariants, render as render3, writeFile as writeFile2 } from "@nexusts/core/index.js";
+var makeControllerCommand = {
+  name: "make:controller",
+  aliases: ["mc", "make-controller"],
+  summary: "Generate a controller class",
+  description: "Generates a controller file under app/controllers/. The routing style is read from nx.config.ts.",
+  examples: [
+    "nx make:controller User",
+    "nx make:controller Post --style nest",
+    "nx make:controller Webhook --style functional"
+  ],
+  flags: [
+    {
+      name: "style",
+      description: "Override routing style (nest|adonis|functional)"
+    },
+    {
+      name: "no-service",
+      description: "Skip injecting a service into the controller"
+    }
+  ],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger4.error("Usage: nx make:controller <Name>");
+      return 1;
+    }
+    const variants = nameVariants(name);
+    const style = ctx.flags["style"] ?? ctx.config.routing;
+    if (!["nest", "adonis", "functional"].includes(style)) {
+      logger4.error(`Unknown style: ${style}. Allowed: nest, adonis, functional.`);
+      return 1;
+    }
+    const skipService = ctx.flags["no-service"] === true;
+    const serviceName = `${variants.pascal}Service`;
+    const serviceCamel = variants.camel + "Service";
+    const tpl = templates.controller[style];
+    const code = render3(tpl, {
+      name: variants.pascal,
+      camel: variants.camel,
+      kebab: variants.kebab,
+      snake: variants.snake,
+      pascal: variants.pascal,
+      service: serviceName,
+      serviceCamel
+    }).replace(/import .*\n/g, skipService ? (m) => m.includes("services/") ? "" : m : (m) => m);
+    const out = resolve4(ctx.cwd, ctx.config.paths.controllers, `${variants.kebab}.controller.ts`);
+    const ok = writeFile2(out, code, { skipIfExists: false });
+    if (!ok) {
+      logger4.error(`Refusing to overwrite existing file: ${out}`);
+      return 1;
+    }
+    logger4.success(`created ${out}`);
+    logger4.finger(`edit ${variants.kebab}.controller.ts and add to a module.`);
+    return 0;
+  }
+};
+var make_controller_default = makeControllerCommand;
+
+// packages/cli/src/commands/make-crud.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname, resolve as resolve5 } from "path";
+import {
+  flagBool as flagBool2,
+  logger as logger5,
+  nameVariants as nameVariants2,
+  render as render4,
+  writeFile as writeFile3
+} from "@nexusts/core/index.js";
+
+// packages/cli/src/templates/model/drizzle-dialect.ts
+function renderDrizzleDialect(dialect) {
+  const spec = DIALECT_SPECS[dialect] ?? DIALECT_SPECS.sqlite;
+  return `
+import { ${spec.imports.join(", ")} } from '${spec.importPath}';
+
+/**
+ * {{ tableName }} \u2014 generated by \`nx make:model {{ name }}\`.
+ */
+export const {{ snake }} = ${spec.tableFn}('{{ tableName }}', {
+  id: ${spec.idHelper}('id').primaryKey(${spec.idOpts}),
+{{ columns }}
+  createdAt: ${spec.tsTimestamp}('created_at'${spec.tsDateMode}).notNull().$defaultFn(() => new Date()),
+  updatedAt: ${spec.tsTimestamp}('updated_at'${spec.tsDateMode}).notNull().$defaultFn(() => new Date()),
+});
+
+export type {{ name }} = typeof {{ snake }}.$inferSelect;
+export type New{{ name }} = typeof {{ snake }}.$inferInsert;
+`.trimStart();
+}
+var DIALECT_SPECS = {
+  postgres: {
+    imports: [
+      "pgTable",
+      "serial",
+      "text",
+      "timestamp",
+      "boolean",
+      "integer",
+      "bigint"
+    ],
+    importPath: "drizzle-orm/pg-core",
+    tableFn: "pgTable",
+    idHelper: "serial",
+    idOpts: "",
+    tsTimestamp: "timestamp",
+    tsDateMode: ""
+  },
+  "bun-sqlite": {
+    imports: ["sqliteTable", "integer", "text", "real"],
+    importPath: "drizzle-orm/sqlite-core",
+    tableFn: "sqliteTable",
+    idHelper: "integer",
+    idOpts: "{ autoIncrement: true }",
+    tsTimestamp: "integer",
+    tsDateMode: ", { mode: 'timestamp' }"
+  },
+  sqlite: {
+    imports: ["sqliteTable", "integer", "text", "real"],
+    importPath: "drizzle-orm/sqlite-core",
+    tableFn: "sqliteTable",
+    idHelper: "integer",
+    idOpts: "{ autoIncrement: true }",
+    tsTimestamp: "integer",
+    tsDateMode: ", { mode: 'timestamp' }"
+  },
+  d1: {
+    imports: ["sqliteTable", "integer", "text", "real"],
+    importPath: "drizzle-orm/d1",
+    tableFn: "sqliteTable",
+    idHelper: "integer",
+    idOpts: "{ autoIncrement: true }",
+    tsTimestamp: "integer",
+    tsDateMode: ", { mode: 'timestamp' }"
+  },
+  mysql: {
+    imports: [
+      "mysqlTable",
+      "int",
+      "text",
+      "timestamp",
+      "boolean",
+      "bigint",
+      "double"
+    ],
+    importPath: "drizzle-orm/mysql-core",
+    tableFn: "mysqlTable",
+    idHelper: "int",
+    idOpts: "{ autoIncrement: true }",
+    tsTimestamp: "timestamp",
+    tsDateMode: ""
+  }
+};
+function mapDrizzleType(dialect, type) {
+  const t = type.toLowerCase();
+  if (t === "text" || t === "string" || t === "varchar")
+    return "text";
+  if (t === "int" || t === "integer") {
+    return dialect === "mysql" ? "int" : "integer";
+  }
+  if (t === "bigint" || t === "bigintunsigned")
+    return dialect === "mysql" ? "bigint" : "bigint";
+  if (t === "bool" || t === "boolean")
+    return dialect === "mysql" ? "boolean" : "boolean";
+  if (t === "float" || t === "number" || t === "real" || t === "double") {
+    return dialect === "mysql" ? "double" : "real";
+  }
+  if (t === "datetime" || t === "timestamp" || t === "date") {
+    return dialect === "mysql" ? "timestamp" : dialect === "postgres" ? "timestamp" : "integer";
+  }
+  if (t === "json" || t === "jsonb") {
+    return dialect === "mysql" ? "text" : "text";
+  }
+  return "text";
+}
+
+// packages/cli/src/commands/make-crud.ts
+var makeCrudCommand = {
+  name: "make:crud",
+  aliases: ["crud", "make-crud", "scaffold"],
+  summary: "Generate a full CRUD scaffold for a resource",
+  description: "Generates controller + service + repository + model + dto + module + test for a single resource, adapted to the project's nx.config.ts.",
+  examples: [
+    "nx make:crud Post",
+    "nx make:crud User --no-views",
+    "nx make:crud Comment --no-repo --no-test"
+  ],
+  flags: [
+    { name: "no-views", description: "Skip Inertia view rendering" },
+    { name: "no-repo", description: "Skip the repository / model" },
+    { name: "no-test", description: "Skip generating the test file" },
+    { name: "style", description: "Override routing style" },
+    { name: "orm", description: "Override ORM driver" },
+    {
+      name: "dialect",
+      description: "Drizzle dialect (postgres|mysql|sqlite|bun-sqlite|d1). Default: bun-sqlite"
+    }
+  ],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger5.error("Usage: nx make:crud <Name>");
+      return 1;
+    }
+    const variants = nameVariants2(name);
+    const style = ctx.flags["style"] ?? ctx.config.routing;
+    const orm = ctx.flags["orm"] ?? ctx.config.orm;
+    const dialect = ctx.flags["dialect"] ?? ctx.config.dialect ?? "bun-sqlite";
+    const noRepo = flagBool2(ctx.flags, "no-repo", false) || orm === "none";
+    const noTest = flagBool2(ctx.flags, "no-test", false);
+    const hasInertia = ctx.config.view === "inertia" && !flagBool2(ctx.flags, "no-views", false);
+    const controller = `${variants.pascal}Controller`;
+    const service = `${variants.pascal}Service`;
+    const repository = `${variants.pascal}Repository`;
+    const tableName = variants.pluralSnake;
+    const viewComponent = `${variants.pascal}s/Index`;
+    const viewShowComponent = `${variants.pascal}s/Show`;
+    logger5.heading(`Scaffolding ${variants.pascal} (style=${style}, view=${ctx.config.view}, orm=${orm})`);
+    const written = [];
+    {
+      const code = render4(templates.crud.controller, {
+        name: variants.pascal,
+        camel: variants.camel,
+        kebab: variants.kebab,
+        snake: variants.snake,
+        tableName,
+        service,
+        serviceCamel: variants.camel + "Service",
+        controller,
+        viewComponent,
+        viewShowComponent,
+        hasInertia
+      });
+      const out = resolve5(ctx.cwd, ctx.config.paths.controllers, `${variants.kebab}.controller.ts`);
+      if (!writeFile3(out, code, { skipIfExists: true })) {
+        logger5.warn(`skipped (exists): ${out}`);
+      } else {
+        logger5.success(`created ${out}`);
+        written.push(out);
+      }
+    }
+    {
+      const code = render4(templates.service, {
+        name: variants.pascal,
+        camel: variants.camel,
+        kebab: variants.kebab,
+        hasRepo: !noRepo,
+        repository,
+        repositoryCamel: variants.camel + "Repository"
+      });
+      const out = resolve5(ctx.cwd, ctx.config.paths.services, `${variants.kebab}.service.ts`);
+      if (!writeFile3(out, code, { skipIfExists: true })) {
+        logger5.warn(`skipped (exists): ${out}`);
+      } else {
+        logger5.success(`created ${out}`);
+        written.push(out);
+      }
+    }
+    if (!noRepo) {
+      if (orm === "drizzle" || orm === "prisma" || orm === "kysely") {
+        let code;
+        if (orm === "drizzle") {
+          const tpl = renderDrizzleDialect(dialect);
+          code = render4(tpl, {
+            name: variants.pascal,
+            camel: variants.camel,
+            kebab: variants.kebab,
+            snake: variants.snake,
+            tableName,
+            columns: renderDrizzleColumns(dialect),
+            prismaBlock: ""
+          });
+        } else {
+          const tpl = templates.model[orm];
+          code = render4(tpl, {
+            name: variants.pascal,
+            camel: variants.camel,
+            kebab: variants.kebab,
+            snake: variants.snake,
+            tableName,
+            columns: renderDefaultColumns(orm),
+            prismaBlock: ""
+          });
+        }
+        const out = resolve5(ctx.cwd, ctx.config.paths.models, `${variants.kebab}.model.ts`);
+        if (!writeFile3(out, code, { skipIfExists: true })) {
+          logger5.warn(`skipped (exists): ${out}`);
+        } else {
+          logger5.success(`created ${out}`);
+          written.push(out);
+        }
+      }
+      const repoCode = render4(templates.repository, {
+        name: variants.pascal,
+        camel: variants.camel,
+        kebab: variants.kebab,
+        tableName,
+        repository
+      });
+      const repoOut = resolve5(ctx.cwd, `${ctx.config.paths.app}/repositories`, `${variants.kebab}.repository.ts`);
+      mkdirSync2(dirname(repoOut), { recursive: true });
+      if (!writeFile3(repoOut, repoCode, { skipIfExists: true })) {
+        logger5.warn(`skipped (exists): ${repoOut}`);
+      } else {
+        logger5.success(`created ${repoOut}`);
+        written.push(repoOut);
+      }
+    }
+    {
+      const code = render4(templates.crud.dto, {
+        name: variants.pascal,
+        camel: variants.camel,
+        kebab: variants.kebab
+      });
+      const out = resolve5(ctx.cwd, ctx.config.paths.dto, `${variants.kebab}.dto.ts`);
+      if (!writeFile3(out, code, { skipIfExists: true })) {
+        logger5.warn(`skipped (exists): ${out}`);
+      } else {
+        logger5.success(`created ${out}`);
+        written.push(out);
+      }
+    }
+    {
+      const code = render4(templates.crud.module, {
+        name: variants.pascal,
+        camel: variants.camel,
+        kebab: variants.kebab,
+        controller,
+        service,
+        repository,
+        hasRepo: !noRepo
+      });
+      const out = resolve5(ctx.cwd, ctx.config.paths.modules, `${variants.kebab}.module.ts`);
+      if (!writeFile3(out, code, { skipIfExists: true })) {
+        logger5.warn(`skipped (exists): ${out}`);
+      } else {
+        logger5.success(`created ${out}`);
+        written.push(out);
+      }
+    }
+    if (!noTest) {
+      const code = render4(templates.crud.test, {
+        name: variants.pascal,
+        camel: variants.camel,
+        kebab: variants.kebab,
+        controller,
+        service
+      });
+      const out = resolve5(ctx.cwd, "tests", `${variants.kebab}.test.ts`);
+      if (!writeFile3(out, code, { skipIfExists: true })) {
+        logger5.warn(`skipped (exists): ${out}`);
+      } else {
+        logger5.success(`created ${out}`);
+        written.push(out);
+      }
+    }
+    logger5.blank();
+    logger5.heading("Next steps");
+    logger5.info(`1. Review the generated files:`);
+    for (const f of written)
+      logger5.info(`     ${f}`);
+    logger5.info(`2. Add ${variants.pascal}Module to AppModule.imports.`);
+    logger5.info(`3. ${noRepo ? "" : `Run \`bunx drizzle-kit migrate\` (or your migration tool).`}`);
+    logger5.info(`4. Start the dev server: \`bun --hot app/main.ts\`.`);
+    logger5.blank();
+    return 0;
+  }
+};
+function renderDefaultColumns(orm) {
+  if (orm === "drizzle") {
+    return "  title: text('title').notNull(),";
+  }
+  if (orm === "kysely") {
+    return "  title: string,";
+  }
+  return "  title text,";
+}
+function renderDrizzleColumns(dialect) {
+  const helper = mapDrizzleType(dialect, "text");
+  return `  title: ${helper}('title').notNull(),`;
+}
+var make_crud_default = makeCrudCommand;
+
+// packages/cli/src/commands/make-listener.ts
+import { resolve as resolve6 } from "path";
+import { logger as logger6, nameVariants as nameVariants3, render as render5, writeFile as writeFile4 } from "@nexusts/core/index.js";
+var LISTENER_TEMPLATE = `
+import { Inject, Injectable } from '@nexusts/core';
+import { EventService, OnEvent } from '@nexusts/events';
+
+/**
+ * {{ name }} listener \u2014 generated by \`nx make:listener {{ name }}\`.
+ *
+ * Register handlers below with \`@OnEvent(pattern)\`. Pair with
+ * \`scanForListeners(this, eventService)\` at boot.
+ */
+@Injectable()
+export class {{ name }}Listener {
+  constructor(@Inject(EventService.TOKEN) private readonly events: EventService) {}
+
+  // TODO: add @OnEvent('your.event') handlers below.
+
+  // @OnEvent('user.created')
+  // async onUserCreated(payload: { userId: string; email: string }) {
+  //   this.events; // unused \u2014 remove if you don't need it
+  // }
+}
+
+import { scanForListeners } from '@nexusts/events';
+
+/**
+ * Bootstrap helper \u2014 call this from your main.ts (or wherever you
+ * wire up the application) to register every \`@OnEvent\` handler
+ * on this listener class.
+ */
+export async function register{{ name }}(listener: {{ name }}Listener, events: EventService) {
+  return scanForListeners(listener, events);
+}
+`.trimStart();
+var makeListenerCommand = {
+  name: "make:listener",
+  aliases: ["ml", "make-listener"],
+  summary: "Scaffold an event listener class",
+  description: "Generates an @Injectable listener class with example @OnEvent handlers under app/events/listeners/.",
+  examples: ["nx make:listener UserEvents", "nx make:listener OrderEvents"],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger6.error("Usage: nx make:listener <Name>");
+      return 1;
+    }
+    const variants = nameVariants3(name);
+    const code = render5(LISTENER_TEMPLATE, {
+      name: variants.pascal,
+      kebab: variants.kebab
+    });
+    const out = resolve6(ctx.cwd, "app/events/listeners", `${variants.kebab}.listener.ts`);
+    if (writeFile4(out, code, { skipIfExists: true })) {
+      logger6.success(`created ${out}`);
+    } else {
+      logger6.warn(`skipped (exists): ${out}`);
+    }
+    logger6.blank();
+    logger6.heading("Next steps");
+    logger6.info("1. Add @OnEvent('your.event') handlers to the class.");
+    logger6.info(`2. Import + register at boot:`);
+    logger6.info(`     scanForListeners(listener, events)`);
+    logger6.info(`3. Emit events from anywhere:`);
+    logger6.info(`     await events.emit('user.created', { userId: '1' })`);
+    logger6.blank();
+    return 0;
+  }
+};
+var make_listener_default = makeListenerCommand;
+
+// packages/cli/src/commands/make-middleware.ts
+import { resolve as resolve7 } from "path";
+import { logger as logger7, nameVariants as nameVariants4, render as render6, writeFile as writeFile5 } from "@nexusts/core/index.js";
+var makeMiddlewareCommand = {
+  name: "make:middleware",
+  aliases: ["mwm", "make-middleware"],
+  summary: "Generate a middleware class",
+  description: "Generates an @Injectable() middleware class with a `handle(c, next)` method.",
+  examples: ["nx make:middleware Auth", "nx make:middleware RateLimit"],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger7.error("Usage: nx make:middleware <Name>");
+      return 1;
+    }
+    const variants = nameVariants4(name);
+    const code = render6(templates.middleware, {
+      name: variants.pascal
+    });
+    const out = resolve7(ctx.cwd, ctx.config.paths.middleware, `${variants.kebab}.middleware.ts`);
+    writeFile5(out, code);
+    logger7.success(`created ${out}`);
+    logger7.finger(`register with: app.server.app.use('*', new ${variants.pascal}Middleware().handle)`);
+    return 0;
+  }
+};
+var make_middleware_default = makeMiddlewareCommand;
+
+// packages/cli/src/commands/make-migration.ts
+import { resolve as resolve8 } from "path";
+import { logger as logger8, nameVariants as nameVariants5, render as render7, writeFile as writeFile6 } from "@nexusts/core/index.js";
+var makeMigrationCommand = {
+  name: "make:migration",
+  aliases: ["mkm", "make-migration"],
+  summary: "Generate a migration file",
+  description: "Generates a migration under app/database/migrations/. The template is chosen from nx.config.ts's `orm` field. Use --dialect for Drizzle migrations.",
+  examples: [
+    "nx make:migration create_users_table",
+    "nx make:migration add_email_to_users --orm drizzle --dialect postgres",
+    "nx make:migration drop_old_index --orm none"
+  ],
+  flags: [
+    {
+      name: "columns",
+      description: "Comma-separated `name:type` pairs (default: title:text)"
+    },
+    {
+      name: "orm",
+      description: "Override ORM driver (drizzle|prisma|kysely|none)"
+    },
+    {
+      name: "dialect",
+      description: "Drizzle dialect (postgres|mysql|sqlite|bun-sqlite|d1). Default: bun-sqlite"
+    }
+  ],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger8.error("Usage: nx make:migration <Name> [--dialect ...]");
+      return 1;
+    }
+    const orm = ctx.flags["orm"] ?? ctx.config.orm;
+    const dialect = ctx.flags["dialect"] ?? ctx.config.dialect ?? "bun-sqlite";
+    const isDrizzle = orm === "drizzle";
+    const useGenericSql = orm === "none" || orm === "prisma" || orm === "kysely";
+    const variants = nameVariants5(name);
+    const tableName = inferTableName(name);
+    const colsFlag = ctx.flags["columns"];
+    const cols = parseColumns(colsFlag ?? "title:text");
+    const drizzleColumns = renderDrizzleColumns2(cols, dialect);
+    const sqlColumns = renderSqlColumns(cols, dialect);
+    let code;
+    let extension;
+    if (isDrizzle) {
+      if (!isValidDialect(dialect)) {
+        logger8.error(`Unsupported drizzle dialect: ${dialect}. Allowed: postgres, mysql, sqlite, bun-sqlite, d1.`);
+        return 1;
+      }
+      code = renderDrizzleDialect(dialect);
+      code = render7(code, {
+        name: variants.pascal,
+        snake: variants.snake,
+        tableName,
+        columns: drizzleColumns,
+        timestamp: formatTimestamp(new Date)
+      });
+      extension = "ts";
+    } else if (useGenericSql) {
+      const tpl = templates.migration.sql;
+      code = render7(tpl, {
+        name: variants.pascal,
+        snake: variants.snake,
+        tableName,
+        columns: sqlColumns,
+        timestamp: formatTimestamp(new Date)
+      });
+      extension = "sql";
+    } else {
+      logger8.error(`Unsupported ORM for migration: ${orm}. Allowed: drizzle, none, prisma, kysely.`);
+      return 1;
+    }
+    const filename = `${formatTimestamp(new Date)}_${variants.snake}.${extension}`;
+    const out = resolve8(ctx.cwd, ctx.config.paths.migrations, filename);
+    writeFile6(out, code);
+    logger8.success(`created ${out}`);
+    if (isDrizzle) {
+      logger8.finger(`run \`nx migrate\` to apply pending migrations.`);
+    } else {
+      logger8.finger(`run \`bunx drizzle-kit migrate\` or your migration tool.`);
+    }
+    return 0;
+  }
+};
+function isValidDialect(d) {
+  return ["postgres", "mysql", "sqlite", "bun-sqlite", "d1"].includes(d);
+}
+function inferTableName(input) {
+  const m = /^create_(\w+)_table$/.exec(input);
+  if (m)
+    return m[1];
+  const m2 = /^(?:add|remove|drop|alter)_(\w+)_to_(\w+)$/.exec(input);
+  if (m2)
+    return m2[2];
+  return input.toLowerCase().replace(/s$/, "") + "s";
+}
+function parseColumns(input) {
+  const list = Array.isArray(input) ? input : input.split(",");
+  return list.map((s) => s.trim()).filter(Boolean).map((c) => {
+    const [name, type = "text"] = c.split(":");
+    return [name, type];
+  });
+}
+function renderSqlColumns(cols, dialect) {
+  return cols.map(([name, type]) => {
+    const sqlType = mapSqlType(type, dialect);
+    const notNull = /NOT NULL/i.test(sqlType) ? "" : " NOT NULL";
+    return `  ${name} ${sqlType}${notNull},`;
+  }).join(`
+`);
+}
+function renderDrizzleColumns2(cols, dialect) {
+  return cols.map(([name, type]) => {
+    const helper = mapDrizzleType(dialect, type);
+    return `  ${name}: ${helper}('${name}'),`;
+  }).join(`
+`);
+}
+function mapSqlType(t, dialect) {
+  const type = t.toLowerCase();
+  switch (type) {
+    case "text":
+    case "string":
+    case "varchar":
+      return dialect === "mysql" ? "VARCHAR(255)" : "TEXT";
+    case "int":
+    case "integer":
+      return dialect === "postgres" ? "INTEGER" : dialect === "mysql" ? "INT" : "INTEGER";
+    case "bigint":
+    case "bigintunsigned":
+      return dialect === "postgres" ? "BIGINT" : "BIGINT UNSIGNED";
+    case "serial":
+      return dialect === "postgres" ? "SERIAL" : "INTEGER AUTO_INCREMENT";
+    case "bool":
+    case "boolean":
+      return dialect === "mysql" ? "BOOLEAN" : "BOOLEAN";
+    case "float":
+    case "number":
+    case "real":
+    case "double":
+      return dialect === "mysql" ? "DOUBLE" : "REAL";
+    case "datetime":
+    case "timestamp":
+      return dialect === "postgres" ? "TIMESTAMP" : dialect === "mysql" ? "DATETIME" : "INTEGER";
+    case "date":
+      return dialect === "mysql" ? "DATE" : "TEXT";
+    case "json":
+      return dialect === "postgres" ? "JSONB" : dialect === "mysql" ? "JSON" : "TEXT";
+    case "jsonb":
+      return dialect === "postgres" ? "JSONB" : "TEXT";
+    default:
+      return "TEXT";
+  }
+}
+function formatTimestamp(d) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}` + `_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+var make_migration_default = makeMigrationCommand;
+
+// packages/cli/src/commands/make-model.ts
+import { resolve as resolve9 } from "path";
+import {
+  flagList as flagList2,
+  logger as logger9,
+  nameVariants as nameVariants6,
+  render as render8,
+  writeFile as writeFile7
+} from "@nexusts/core/index.js";
+var makeModelCommand = {
+  name: "make:model",
+  aliases: ["mmodel", "make-model"],
+  summary: "Generate a model (table schema)",
+  description: "Generates a model file under app/models/. The template is chosen from nx.config.ts's `orm` field (drizzle|prisma|kysely). For drizzle, use --dialect to pick the import path.",
+  examples: [
+    "nx make:model User",
+    'nx make:model User --columns "name:text,email:text"',
+    "nx make:model User --orm drizzle --dialect postgres",
+    "nx make:model Post --orm drizzle --dialect postgres --columns 'title:text,body:text,published:boolean'"
+  ],
+  flags: [
+    {
+      name: "columns",
+      description: "Comma-separated `name:type` pairs (default: title:text)"
+    },
+    {
+      name: "orm",
+      description: "Override ORM driver (drizzle|prisma|kysely)"
+    },
+    {
+      name: "dialect",
+      description: "Drizzle dialect (postgres|mysql|sqlite|bun-sqlite|d1). Default: bun-sqlite"
+    }
+  ],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger9.error("Usage: nx make:model <Name> [--columns name:type,...] [--dialect ...]");
+      return 1;
+    }
+    const orm = ctx.flags["orm"] ?? ctx.config.orm;
+    if (orm !== "drizzle" && orm !== "prisma" && orm !== "kysely") {
+      logger9.error(`Unsupported ORM: ${orm}. Allowed: drizzle, prisma, kysely. Use --orm or set "orm" in nx.config.ts.`);
+      return 1;
+    }
+    const variants = nameVariants6(name);
+    const tableName = variants.pluralSnake;
+    const colsFlag = flagList2(ctx.flags, "columns");
+    const columns = colsFlag.length > 0 ? colsFlag : ["title:text"];
+    const columnLines = renderColumns(columns, orm, ctx.flags["dialect"]);
+    const prismaBlock = renderPrismaBlock(variants.pascal, columns);
+    let code;
+    if (orm === "drizzle") {
+      const dialect = ctx.flags["dialect"] ?? ctx.config.dialect ?? "bun-sqlite";
+      if (!isValidDialect2(dialect)) {
+        logger9.error(`Unsupported drizzle dialect: ${dialect}. Allowed: postgres, mysql, sqlite, bun-sqlite, d1.`);
+        return 1;
+      }
+      code = renderDrizzleDialect(dialect);
+      code = render8(code, {
+        name: variants.pascal,
+        camel: variants.camel,
+        kebab: variants.kebab,
+        snake: variants.snake,
+        tableName,
+        columns: columnLines,
+        prismaBlock
+      });
+    } else {
+      const tpl = templates.model[orm];
+      code = render8(tpl, {
+        name: variants.pascal,
+        camel: variants.camel,
+        kebab: variants.kebab,
+        snake: variants.snake,
+        tableName,
+        columns: columnLines,
+        prismaBlock
+      });
+    }
+    const out = resolve9(ctx.cwd, ctx.config.paths.models, `${variants.kebab}.model.ts`);
+    writeFile7(out, code);
+    logger9.success(`created ${out}`);
+    logger9.finger(`run \`nx make:migration create_${tableName}_table\` to scaffold a migration.`);
+    if (orm === "drizzle") {
+      logger9.finger(`run \`nx migrate\` to apply pending migrations to the database.`);
+    }
+    return 0;
+  }
+};
+function isValidDialect2(d) {
+  return ["postgres", "mysql", "sqlite", "bun-sqlite", "d1"].includes(d);
+}
+function renderColumns(cols, orm, dialect) {
+  const flat = cols.flatMap((c) => c.split(",")).map((c) => c.trim()).filter(Boolean);
+  return flat.map((col) => {
+    const [colName, colType = "text"] = col.split(":");
+    const tsName = toCamel(colName);
+    switch (orm) {
+      case "drizzle": {
+        const d = dialect ?? "bun-sqlite";
+        const helper = mapDrizzleType(d, colType);
+        return `  ${tsName}: ${helper}('${colName}'),`;
+      }
+      case "kysely": {
+        const tsType = colType === "text" ? "string" : colType;
+        return `  ${colName}: ${tsType},`;
+      }
+      case "prisma":
+      default:
+        return `  ${colName} ${colType},`;
+    }
+  }).join(`
+`);
+}
+function renderPrismaBlock(modelName, cols) {
+  const fieldLines = cols.map((c) => {
+    const [name, type = "String"] = c.split(":");
+    return `  ${name.padEnd(16)} ${capitalize(type)}`;
+  }).join(`
+`);
+  return ` * model ${modelName} {
+ *   id          Int      @id @default(autoincrement())
+${fieldLines.split(`
+`).map((l) => ` *${l}`).join(`
+`)}
+ *   createdAt   DateTime @default(now())
+ *   updatedAt   DateTime @updatedAt
+ * }`;
+}
+function toCamel(s) {
+  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+var make_model_default = makeModelCommand;
+
+// packages/cli/src/commands/make-module.ts
+import { resolve as resolve10 } from "path";
+import {
+  flagBool as flagBool3,
+  logger as logger10,
+  nameVariants as nameVariants7,
+  render as render9,
+  writeFile as writeFile8
+} from "@nexusts/core/index.js";
+var makeModuleCommand = {
+  name: "make:module",
+  aliases: ["mm", "make-module"],
+  summary: "Generate a feature module",
+  description: "Generates a @Module() class that wires a controller + service (+ optional repository) under app/modules/.",
+  examples: ["nx make:module User", "nx make:module User --no-controller"],
+  flags: [
+    {
+      name: "no-controller",
+      description: "Skip including the controller in the module"
+    },
+    { name: "no-service", description: "Skip including the service" },
+    { name: "no-repo", description: "Skip including the repository" }
+  ],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger10.error("Usage: nx make:module <Name>");
+      return 1;
+    }
+    const variants = nameVariants7(name);
+    const hasController = !flagBool3(ctx.flags, "no-controller", false);
+    const hasService = !flagBool3(ctx.flags, "no-service", false);
+    const hasRepo = !flagBool3(ctx.flags, "no-repo", false) && ctx.config.orm !== "none";
+    const code = render9(templates.module, {
+      name: variants.pascal,
+      kebab: variants.kebab,
+      controller: `${variants.pascal}Controller`,
+      service: `${variants.pascal}Service`,
+      repository: `${variants.pascal}Repository`,
+      hasService,
+      hasRepo
+    });
+    const out = resolve10(ctx.cwd, ctx.config.paths.modules, `${variants.kebab}.module.ts`);
+    writeFile8(out, code);
+    logger10.success(`created ${out}`);
+    logger10.finger(`add ${variants.pascal}Module to AppModule.imports.`);
+    return 0;
+  }
+};
+var make_module_default = makeModuleCommand;
+
+// packages/cli/src/commands/make-queue.ts
+import { resolve as resolve11 } from "path";
+import {
+  flagBool as flagBool4,
+  logger as logger11,
+  nameVariants as nameVariants8,
+  render as render10,
+  writeFile as writeFile9
+} from "@nexusts/core/index.js";
+var WORKER_TEMPLATE = `
+import { Inject, Injectable } from '@nexusts/core';
+import { QueueService, OnQueueReady } from '@nexusts/queue';
+
+/**
+ * {{ name }} worker \u2014 generated by \`nx make:queue {{ name }}\`.
+ *
+ * Registers a handler for the \`{{ name }}\` job name on boot.
+ */
+@Injectable()
+export class {{ name }}Worker {
+  constructor(@Inject(QueueService.TOKEN) private readonly queue: QueueService) {}
+
+  @OnQueueReady()
+  async register(): Promise<void> {
+    await this.queue.process('{{ name }}', async (data, ctx) => {
+      ctx.prefix; // \u2192 "[queue:{{ name }}]"
+      try {
+        await this.handle(data as {{ name }}Data);
+        return { status: 'completed' };
+      } catch (err) {
+        return {
+          status: 'failed',
+          error: err instanceof Error ? err : new Error(String(err)),
+          willRetry: ctx.attempts < 3,
+        };
+      }
+    });
+  }
+
+  /**
+   * Replace this body with your actual worker logic.
+   */
+  async handle(data: {{ name }}Data): Promise<void> {
+    // TODO: implement
+  }
+}
+
+/**
+ * Typed payload for the \`{{ name }}\` job.
+ */
+export interface {{ name }}Data {
+  // TODO: define fields
+  [key: string]: unknown;
+}
+`.trimStart();
+var JOB_HELPER_TEMPLATE = `
+import { Inject, Injectable } from '@nexusts/core';
+import { QueueService } from '@nexusts/queue';
+import type { {{ name }}Data } from './{{ kebab }}.worker.js';
+
+/**
+ * Helper for enqueuing \`{{ name }}\` jobs from controllers / services.
+ * Generated by \`nx make:queue {{ name }}\`.
+ */
+@Injectable()
+export class {{ name }}Job {
+  constructor(@Inject(QueueService.TOKEN) private readonly queue: QueueService) {}
+
+  /** Enqueue a single {{ name }} job. */
+  async enqueue(data: {{ name }}Data, options?: {
+    delaySeconds?: number;
+    attempts?: number;
+  }) {
+    return this.queue.add('{{ name }}', data, options);
+  }
+
+  /** Enqueue many at once. */
+  async enqueueBatch(items: {{ name }}Data[]) {
+    return this.queue.addBatch(
+      items.map((data) => ({ name: '{{ name }}', data })),
+    );
+  }
+}
+`.trimStart();
+var WIRE_HINT = `
+import { QueueService } from '@nexusts/queue';
+import { %%NAME%%Job } from './queue/jobs/%%KEBAB%%.job.js';
+import { %%NAME%%Worker } from './queue/workers/%%KEBAB%%.worker.js';
+
+@Module({
+  providers: [%%NAME%%Job, %%NAME%%Worker],
+})
+export class QueueBindingsModule {}
+`.trim();
+var makeQueueCommand = {
+  name: "make:queue",
+  aliases: ["mq", "make-queue"],
+  summary: "Scaffold a queue worker",
+  description: "Generates a worker class + enqueue helper under app/queue/. The backend is read from nx.config.ts (or --backend).",
+  examples: [
+    "nx make:queue send-welcome-email",
+    "nx make:queue process-image --backend cloudflare",
+    "nx make:queue notify --backend memory"
+  ],
+  flags: [
+    {
+      name: "backend",
+      description: "Override backend (bullmq|cloudflare|memory)"
+    },
+    {
+      name: "no-job",
+      description: "Skip the enqueue helper, only generate the worker"
+    },
+    {
+      name: "no-worker",
+      description: "Skip the worker class, only generate the enqueue helper"
+    }
+  ],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger11.error("Usage: nx make:queue <Name>");
+      return 1;
+    }
+    const variants = nameVariants8(name);
+    const backend = ctx.flags["backend"] ?? ctx.config.queue?.backend ?? "memory";
+    if (!["bullmq", "cloudflare", "memory"].includes(backend)) {
+      logger11.error(`Unknown backend: ${backend}. Allowed: bullmq, cloudflare, memory.`);
+      return 1;
+    }
+    logger11.heading(`Scaffolding ${variants.pascal} (backend=${backend})`);
+    if (!flagBool4(ctx.flags, "no-worker", false)) {
+      const code = render10(WORKER_TEMPLATE, {
+        name: variants.pascal,
+        kebab: variants.kebab
+      });
+      const out = resolve11(ctx.cwd, "app/queue/workers", `${variants.kebab}.worker.ts`);
+      if (writeFile9(out, code, { skipIfExists: true })) {
+        logger11.success(`created ${out}`);
+      } else {
+        logger11.warn(`skipped (exists): ${out}`);
+      }
+    }
+    if (!flagBool4(ctx.flags, "no-job", false)) {
+      const code = render10(JOB_HELPER_TEMPLATE, {
+        name: variants.pascal,
+        kebab: variants.kebab
+      });
+      const out = resolve11(ctx.cwd, "app/queue/jobs", `${variants.kebab}.job.ts`);
+      if (writeFile9(out, code, { skipIfExists: true })) {
+        logger11.success(`created ${out}`);
+      } else {
+        logger11.warn(`skipped (exists): ${out}`);
+      }
+    }
+    logger11.blank();
+    logger11.heading("Next steps");
+    logger11.info(`1. Add QueueModule.forRoot() to your AppModule.imports:`);
+    logger11.info(`     QueueModule.forRoot({ backend: '${backend}', ... })`);
+    logger11.info(`2. Wire the worker + helper as providers:`);
+    logger11.info(render10(WIRE_HINT, { name: variants.pascal, kebab: variants.kebab }).split(`
+`).map((l) => "     " + l).join(`
+`));
+    logger11.info(`3. Replace the TODO in ${variants.pascal}Worker.handle() with your logic.`);
+    logger11.blank();
+    return 0;
+  }
+};
+var make_queue_default = makeQueueCommand;
+
+// packages/cli/src/commands/make-schedule.ts
+import { resolve as resolve12 } from "path";
+import { logger as logger12, nameVariants as nameVariants9, render as render11, writeFile as writeFile10 } from "@nexusts/core/index.js";
+var TASK_TEMPLATE = `
+import { Inject, Injectable } from '@nexusts/core';
+import { Cron, Interval, Timeout, ScheduleService } from '@nexusts/schedule';
+
+/**
+ * {{ name }} task \u2014 generated by \`nx make:schedule {{ name }}\`.
+ *
+ * Mark methods with \`@Cron\`, \`@Interval\`, or \`@Timeout\` and register
+ * them at boot via \`scanForSchedulers(this, scheduleService)\`.
+ */
+@Injectable()
+export class {{ name }}Task {
+  constructor(@Inject(ScheduleService.TOKEN) private readonly schedule: ScheduleService) {}
+
+  // TODO: add @Cron, @Interval, or @Timeout handlers below.
+
+  // @Cron('0 * * * *')                          // every hour
+  // async hourly() {
+  //   this.schedule; // unused \u2014 remove if you don't need it
+  // }
+
+  // @Interval(60_000)                         // every minute
+  // async tick() { /* ... */ }
+
+  // @Timeout(5_000)                            // 5s after boot
+  // async startup() { /* ... */ }
+}
+
+import { scanForSchedulers } from '@nexusts/schedule';
+
+/**
+ * Bootstrap helper \u2014 call from main.ts to register every @Cron /
+ * @Interval / @Timeout handler on this task class.
+ */
+export async function register{{ name }}(task: {{ name }}Task, schedule: ScheduleService) {
+  return scanForSchedulers(task, schedule);
+}
+`.trimStart();
+var makeScheduleCommand = {
+  name: "make:schedule",
+  aliases: ["msk", "make-schedule"],
+  summary: "Scaffold a scheduled task class",
+  description: "Generates an @Injectable task class with example @Cron / @Interval / @Timeout handlers under app/schedule/tasks/.",
+  examples: ["nx make:schedule HourlyCleanup", "nx make:schedule DailyDigest"],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger12.error("Usage: nx make:schedule <Name>");
+      return 1;
+    }
+    const variants = nameVariants9(name);
+    const code = render11(TASK_TEMPLATE, {
+      name: variants.pascal,
+      kebab: variants.kebab
+    });
+    const out = resolve12(ctx.cwd, "app/schedule/tasks", `${variants.kebab}.task.ts`);
+    if (writeFile10(out, code, { skipIfExists: true })) {
+      logger12.success(`created ${out}`);
+    } else {
+      logger12.warn(`skipped (exists): ${out}`);
+    }
+    logger12.blank();
+    logger12.heading("Next steps");
+    logger12.info("1. Add @Cron / @Interval / @Timeout handlers to the class.");
+    logger12.info(`2. Import + register at boot:`);
+    logger12.info(`     scanForSchedulers(task, schedule)`);
+    logger12.info(`3. Don't forget to call \`schedule.start()\` to begin the tick.`);
+    logger12.blank();
+    return 0;
+  }
+};
+var make_schedule_default = makeScheduleCommand;
+
+// packages/cli/src/commands/make-service.ts
+import { resolve as resolve13 } from "path";
+import { logger as logger13, nameVariants as nameVariants10, render as render12, writeFile as writeFile11 } from "@nexusts/core/index.js";
+var makeServiceCommand = {
+  name: "make:service",
+  aliases: ["ms", "make-service"],
+  summary: "Generate a service class",
+  description: "Generates an @Injectable() service under app/services/. If the project's ORM is configured, the service constructor takes a repository.",
+  examples: ["nx make:service User", "nx make:service Order --no-repo"],
+  flags: [
+    {
+      name: "no-repo",
+      description: "Skip injecting a repository (no ORM dependency)"
+    }
+  ],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger13.error("Usage: nx make:service <Name>");
+      return 1;
+    }
+    const variants = nameVariants10(name);
+    const hasRepo = ctx.flags["no-repo"] !== true && ctx.config.orm !== "none";
+    const repository = `${variants.pascal}Repository`;
+    const repositoryCamel = variants.camel + "Repository";
+    const code = render12(templates.service, {
+      name: variants.pascal,
+      camel: variants.camel,
+      kebab: variants.kebab,
+      hasRepo,
+      repository,
+      repositoryCamel
+    });
+    const out = resolve13(ctx.cwd, ctx.config.paths.services, `${variants.kebab}.service.ts`);
+    writeFile11(out, code);
+    logger13.success(`created ${out}`);
+    return 0;
+  }
+};
+var make_service_default = makeServiceCommand;
+
+// packages/cli/src/commands/make-session.ts
+import { resolve as resolve14 } from "path";
+import { logger as logger14, nameVariants as nameVariants11, render as render13, writeFile as writeFile12 } from "@nexusts/core/index.js";
+var SESSION_TEMPLATE = `
+import { Inject, Injectable } from '@nexusts/core';
+import { SessionService } from '@nexusts/session';
+import type { SessionRecord } from '@nexusts/session';
+
+/**
+ * {{ name }} session helper \u2014 generated by \`nx make:session {{ name }}\`.
+ *
+ * Wraps SessionService with typed accessors for the {{ name }} session's
+ * data. Use from controllers / services.
+ */
+@Injectable()
+export class {{ name }}Session {
+  constructor(@Inject(SessionService.TOKEN) private readonly sessions: SessionService) {}
+
+  /** Read the current session record (or null). */
+  async getCurrent(sessionId: string | null | undefined) {
+    if (!sessionId) return null;
+    return this.sessions.read(sessionId);
+  }
+
+  /** Patch the {{ name }} session's data. */
+  async update(sessionId: string, patch: {{ name }}DataPatch) {
+    return this.sessions.update(sessionId, { dataPatch: patch });
+  }
+
+  /** Destroy the session (logout-everywhere equivalent). */
+  async destroy(sessionId: string) {
+    return this.sessions.destroy(sessionId, 'logout');
+  }
+}
+
+/**
+ * Typed payload for the {{ name }} session.
+ *
+ * TODO: define the fields below to match your feature.
+ */
+export interface {{ name }}Data {
+  // userId?: string;
+  // createdAt?: string;
+}
+
+export type {{ name }}DataPatch = Partial<{{ name }}Data>;
+`.trimStart();
+var makeSessionCommand = {
+  name: "make:session",
+  aliases: ["msess", "make-session"],
+  summary: "Scaffold a session helper class",
+  description: "Generates an @Injectable session helper under app/session/services/.",
+  examples: ["nx make:session Cart", "nx make:session Flash"],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger14.error("Usage: nx make:session <Name>");
+      return 1;
+    }
+    const variants = nameVariants11(name);
+    const code = render13(SESSION_TEMPLATE, {
+      name: variants.pascal,
+      kebab: variants.kebab
+    });
+    const out = resolve14(ctx.cwd, "app/session/services", `${variants.kebab}.session.ts`);
+    if (writeFile12(out, code, { skipIfExists: true })) {
+      logger14.success(`created ${out}`);
+    } else {
+      logger14.warn(`skipped (exists): ${out}`);
+    }
+    logger14.blank();
+    logger14.heading("Next steps");
+    logger14.info("1. Define the typed payload (replace the TODO interface).");
+    logger14.info(`2. Inject {{name}}Session in your controllers / services.`);
+    logger14.info("3. Bind it in the module's providers array.");
+    logger14.blank();
+    return 0;
+  }
+};
+var make_session_default = makeSessionCommand;
+
+// packages/cli/src/commands/make-validator.ts
+import { resolve as resolve15 } from "path";
+import { logger as logger15, nameVariants as nameVariants12, render as render14, writeFile as writeFile13 } from "@nexusts/core/index.js";
+var makeValidatorCommand = {
+  name: "make:validator",
+  aliases: ["mv", "make-validator"],
+  summary: "Generate a Zod validation schema",
+  description: "Generates a Zod schema and inferred type under app/dto/.",
+  examples: ["nx make:validator User", "nx make:validator CreateOrder"],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger15.error("Usage: nx make:validator <Name>");
+      return 1;
+    }
+    const variants = nameVariants12(name);
+    const code = render14(templates.validator, {
+      name: variants.pascal
+    });
+    const out = resolve15(ctx.cwd, ctx.config.paths.dto, `${variants.kebab}.dto.ts`);
+    writeFile13(out, code);
+    logger15.success(`created ${out}`);
+    return 0;
+  }
+};
+var make_validator_default = makeValidatorCommand;
+
+// packages/cli/src/commands/db-migrate.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve16 } from "path";
+import { logger as logger16 } from "@nexusts/core/index.js";
+var dbMigrateCommand = {
+  name: "db:migrate",
+  aliases: ["db:m", "migrate"],
+  summary: "Apply pending database migrations",
+  description: "Runs the Drizzle migrator against the configured migrations folder. Use --status to inspect, --generate to scaffold a new migration via drizzle-kit. See also `nx db:seed` for fixture data.",
+  examples: [
+    "nx db:migrate",
+    "nx db:migrate --status",
+    "nx db:migrate --generate 'add_email_to_users'",
+    "nx db:migrate --folder ./drizzle"
+  ],
+  flags: [
+    {
+      name: "status",
+      description: "List applied migrations and exit (no apply)."
+    },
+    {
+      name: "generate",
+      description: "Run `drizzle-kit generate` with the given migration name."
+    },
+    {
+      name: "folder",
+      description: "Override migrations folder (default: from nx.config.ts)."
+    },
+    {
+      name: "dialect",
+      description: "Drizzle dialect (postgres|mysql|sqlite|bun-sqlite|d1). Default: bun-sqlite."
+    },
+    {
+      name: "config",
+      description: "Path to drizzle.config.ts. Default: ./drizzle.config.ts."
+    }
+  ],
+  async run(ctx) {
+    const folder = ctx.flags["folder"] ?? resolve16(ctx.cwd, ctx.config.paths.migrations);
+    const dialect = ctx.flags["dialect"] ?? ctx.config.dialect ?? "bun-sqlite";
+    const configPath = ctx.flags["config"] ?? resolve16(ctx.cwd, "drizzle.config.ts");
+    const wantStatus = Boolean(ctx.flags["status"]);
+    const generateName = ctx.flags["generate"];
+    if (generateName) {
+      return runDrizzleKit(ctx.cwd, [
+        "generate",
+        ...existsSync2(configPath) ? [`--config=${configPath}`] : [],
+        "--name",
+        generateName
+      ]);
+    }
+    if (wantStatus) {
+      return await runStatus(ctx.cwd, folder, dialect, ctx.config.database?.url ?? "");
+    }
+    return runDrizzleKit(ctx.cwd, [
+      "migrate",
+      ...existsSync2(configPath) ? [`--config=${configPath}`] : []
+    ]);
+  }
+};
+function runDrizzleKit(cwd, args) {
+  return new Promise((resolveP) => {
+    const cmd = "bunx";
+    logger16.info(`$ ${cmd} drizzle-kit ${args.join(" ")}`);
+    const child = spawn(cmd, ["drizzle-kit", ...args], {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("exit", (code) => resolveP(code ?? 0));
+    child.on("error", (err) => {
+      logger16.error(`failed to spawn drizzle-kit: ${err.message}`);
+      resolveP(1);
+    });
+  });
+}
+async function runStatus(cwd, folder, dialect, configUrl = "") {
+  if (!existsSync2(folder)) {
+    logger16.warn(`migrations folder not found: ${folder}`);
+    return 0;
+  }
+  const url = readEnvUrl(dialect) ?? configUrl;
+  if (!url) {
+    logger16.error(`could not read ${dialect} URL from environment. Set DATABASE_URL or NEXUS_DB_URL.`);
+    return 1;
+  }
+  const script = `
+import 'reflect-metadata';
+import { DrizzleService } from '@nexusts/drizzle';
+
+const url = ${JSON.stringify(url)};
+const dialect = ${JSON.stringify(dialect)};
+const folder = ${JSON.stringify(folder)};
+
+const cfg = { dialect, connection: { url }, schema: dialect === 'postgres' ? 'public' : undefined };
+const svc = new DrizzleService(cfg);
+await svc.open();
+const applied = await svc.appliedMigrations();
+console.log(JSON.stringify({ total: applied.length, applied }, null, 2));
+await svc.close();
+`;
+  const tmpFile = resolve16(cwd, ".nx-migrate-status.mjs");
+  await import("fs/promises").then((m) => m.writeFile(tmpFile, script, "utf-8"));
+  try {
+    const code = await new Promise((resP) => {
+      const child = spawn("bun", [tmpFile], {
+        cwd,
+        stdio: "inherit",
+        shell: process.platform === "win32"
+      });
+      child.on("exit", (c) => resP(c ?? 0));
+      child.on("error", () => resP(1));
+    });
+    return code;
+  } finally {
+    await import("fs/promises").then((m) => m.unlink(tmpFile).catch(() => {}));
+  }
+}
+function readEnvUrl(dialect) {
+  const url = process.env["DATABASE_URL"] ?? process.env["NEXUS_DB_URL"] ?? (dialect === "postgres" ? process.env["POSTGRES_URL"] : dialect === "mysql" ? process.env["MYSQL_URL"] : dialect.includes("sqlite") ? process.env["SQLITE_FILENAME"] : null);
+  return url ?? null;
+}
+var db_migrate_default = dbMigrateCommand;
+
+// packages/cli/src/commands/db-generate.ts
+import { resolve as resolve17 } from "path";
+import { logger as logger17 } from "@nexusts/core/index.js";
+var dbGenerateCommand = {
+  name: "db:generate",
+  aliases: ["db:g", "db-generate", "generate-migration"],
+  summary: "Generate a new migration from schema changes",
+  description: "Generates a new migration file by running drizzle-kit generate with the project's config. " + "If no name is given, drizzle-kit auto-generates one. " + "Run after editing your schema files, then apply with `nx db:migrate`.",
+  examples: [
+    "nx db:generate",
+    "nx db:generate add_users_table",
+    "nx db:generate add_posts --dialect postgres"
+  ],
+  flags: [
+    {
+      name: "dialect",
+      description: "Database dialect (bun-sqlite|postgres|mysql|sqlite). Reads from nx.config.ts by default."
+    },
+    {
+      name: "sql",
+      description: "Generate a raw SQL file instead of using drizzle-kit"
+    }
+  ],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    const dialect = ctx.flags["dialect"] ?? ctx.config.dialect ?? "bun-sqlite";
+    const isSql = ctx.flags["sql"] === true;
+    if (isSql) {
+      if (!name) {
+        logger17.error("Usage: nx db:generate <name> --sql");
+        return 1;
+      }
+      logger17.info(`Generating raw SQL migration: ${name} (dialect=${dialect})`);
+      return runSqlTemplate(ctx.cwd, name, dialect);
+    }
+    const configPath = resolve17(ctx.cwd, "drizzle.config.ts");
+    const args = ["generate", "--config", configPath];
+    if (name)
+      args.push("--name", name);
+    logger17.info(`Generating migration: ${name} (dialect=${dialect})`);
+    return runDrizzleKit(ctx.cwd, args);
+  }
+};
+async function runSqlTemplate(cwd, name, dialect) {
+  const { mkdirSync: mkdirSync3, writeFileSync: writeFileSync2 } = await import("fs");
+  const { join } = await import("path");
+  const migrationsDir = join(cwd, "app", "database", "migrations");
+  mkdirSync3(migrationsDir, { recursive: true });
+  const timestamp = Date.now();
+  const filename = `${timestamp}_${name.replace(/[^a-z0-9_]+/g, "_")}.sql`;
+  const filepath = join(migrationsDir, filename);
+  const header = dialect === "postgres" || dialect === "mysql" ? `-- Migration: ${name}
+-- Dialect: ${dialect}
+-- Generated: ${new Date().toISOString()}
+
+` : `-- Migration: ${name}
+-- Dialect: ${dialect} (SQLite)
+-- Generated: ${new Date().toISOString()}
+
+`;
+  writeFileSync2(filepath, header);
+  logger17.success(`created ${filepath}`);
+  logger17.info("Edit the SQL file, then run `nx db:migrate` to apply it.");
+  return 0;
+}
+var db_generate_default = dbGenerateCommand;
+
+// packages/cli/src/commands/db-seed.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir, readdir, writeFile as writeFile14, unlink } from "fs/promises";
+import { resolve as resolve18 } from "path";
+import { logger as logger18 } from "@nexusts/core/index.js";
+var SEED_TEMPLATE = `/**
+ * Seed: {name}
+ *
+ * Run with: nx db:seed
+ *
+ * The default export receives a \`SeedContext\` with:
+ *   - \`ctx.db\`        : the active DrizzleService
+ *   - \`ctx.logger\`    : the framework logger
+ *   - \`ctx.dialect\`   : the active Drizzle dialect
+ *   - \`ctx.truncate(table)\` : helper to clear a table
+ *
+ * Use ctx.db.insert(table).values([...]) etc. for inserts.
+ */
+
+import type { SeedContext } from "@nexusts/cli";
+
+export default async function seed(ctx: SeedContext): Promise<void> {
+	ctx.logger.info("Running seed: {name}");
+	// Example:
+	// await ctx.db.insert(usersTable).values([
+	//   { email: "alice@example.com", name: "Alice" },
+	//   { email: "bob@example.com",   name: "Bob"   },
+	// ]);
+}
+`;
+var dbSeedCommand = {
+  name: "db:seed",
+  aliases: ["db:s", "seed"],
+  summary: "Run database seed scripts",
+  description: "Loads and runs every seed file in the configured seeds folder in alphabetical order. Use --file to run a single seed, --create to scaffold a new one, --reset to truncate first (DESTRUCTIVE).",
+  examples: [
+    "nx db:seed",
+    "nx db:seed --file 01_users",
+    "nx db:seed --create users",
+    "nx db:seed --reset",
+    "nx db:seed --folder ./seeds"
+  ],
+  flags: [
+    {
+      name: "file",
+      description: "Run a single seed file by name (without .ts extension, fuzzy match)."
+    },
+    {
+      name: "create",
+      description: "Scaffold a new seed file with a default template. Provide a name (e.g. `users`)."
+    },
+    {
+      name: "reset",
+      description: "DESTRUCTIVE: Truncate every table in the schema before running seeds."
+    },
+    {
+      name: "folder",
+      description: "Override seeds folder. Default: ./db/seeds (or nx.config.ts paths.seeds)."
+    },
+    {
+      name: "dialect",
+      description: "Drizzle dialect (postgres|mysql|sqlite|bun-sqlite|d1). Default: from nx.config.ts or bun-sqlite."
+    }
+  ],
+  async run(ctx) {
+    const folder = resolve18(ctx.cwd, ctx.flags["folder"] ?? ctx.config.paths?.seeds ?? "db/seeds");
+    const dialect = ctx.flags["dialect"] ?? ctx.config.dialect ?? "bun-sqlite";
+    const createName = ctx.flags["create"];
+    const fileName = ctx.flags["file"];
+    const reset = Boolean(ctx.flags["reset"]);
+    if (createName) {
+      return await createSeedFile(folder, createName);
+    }
+    if (!existsSync3(folder)) {
+      logger18.info(`creating empty seeds folder at ${folder}`);
+      await mkdir(folder, { recursive: true });
+      await writeFile14(resolve18(folder, "_README.ts"), `// Seed files go here. Run with: nx db:seed
+`, "utf-8");
+      return 0;
+    }
+    const files = await collectSeedFiles(folder);
+    if (fileName) {
+      const matched = files.filter((f) => f.toLowerCase().includes(fileName.toLowerCase()));
+      if (matched.length === 0) {
+        logger18.error(`no seed file matching "${fileName}" in ${folder}`);
+        return 1;
+      }
+    } else if (files.length === 0) {
+      logger18.warn(`no seed files found in ${folder}`);
+      return 0;
+    }
+    const target = fileName ? files.filter((f) => f.toLowerCase().includes(fileName.toLowerCase())) : files;
+    const url = readEnvUrl2(dialect);
+    if (!url) {
+      logger18.error(`could not read ${dialect} URL from environment. Set DATABASE_URL or NEXUS_DB_URL.`);
+      return 1;
+    }
+    if (reset) {
+      logger18.warn("--reset is set: truncating every table in the schema before running seeds.");
+    }
+    const seedImports = target.map((f, i) => `import seed_${i} from ${JSON.stringify(resolve18(folder, f))};`).join(`
+`);
+    const seedCalls = target.map((_, i) => `  await seed_${i}({ db, logger, dialect, truncate: (t) => db.truncate(t) });`).join(`
+`);
+    const script = `
+import 'reflect-metadata';
+import { DrizzleService } from '${relativeImport(ctx.cwd, "src/drizzle/index.js")}';
+import { logger as frameworkLogger } from '${relativeImport(ctx.cwd, "src/logger/index.js")}';
+
+const url = ${JSON.stringify(url)};
+const dialect = ${JSON.stringify(dialect)};
+const reset = ${JSON.stringify(reset)};
+
+const cfg = { dialect, connection: { url }, schema: dialect === 'postgres' ? 'public' : undefined };
+const db = new DrizzleService(cfg);
+await db.open();
+const logger = frameworkLogger;
+
+if (reset) {
+  const tables = await db.allTables();
+  for (const t of tables) {
+    await db.truncate(t);
+  }
+  logger.info(\`Truncated \${tables.length} table(s)\`);
+}
+
+${seedImports}
+
+${seedCalls}
+
+await db.close();
+logger.info(\`Seeds complete (\${${target.length}} file(s))\`);
+`;
+    const tmpFile = resolve18(ctx.cwd, ".nx-db-seed.mjs");
+    await writeFile14(tmpFile, script, "utf-8");
+    try {
+      const code = await new Promise((resP) => {
+        const child = spawn2("bun", [tmpFile], {
+          cwd: ctx.cwd,
+          stdio: "inherit",
+          shell: process.platform === "win32"
+        });
+        child.on("exit", (c) => resP(c ?? 0));
+        child.on("error", () => resP(1));
+      });
+      return code;
+    } finally {
+      await unlink(tmpFile).catch(() => {});
+    }
+  }
+};
+async function collectSeedFiles(folder) {
+  const all = await readdir(folder, { withFileTypes: true });
+  const out = [];
+  for (const e of all) {
+    if (!e.isFile())
+      continue;
+    if (e.name.startsWith("_"))
+      continue;
+    if (!/\.(ts|js|mjs|cjs)$/.test(e.name))
+      continue;
+    out.push(e.name);
+  }
+  out.sort();
+  return out;
+}
+async function createSeedFile(folder, name) {
+  if (!/^[a-z0-9_-]+$/i.test(name)) {
+    logger18.error(`invalid seed name "${name}" \u2014 use letters, numbers, dash, underscore.`);
+    return 1;
+  }
+  if (!existsSync3(folder))
+    await mkdir(folder, { recursive: true });
+  let candidate = `${name}.ts`;
+  let i = 1;
+  while (existsSync3(resolve18(folder, candidate))) {
+    candidate = `${name}_${i}.ts`;
+    i++;
+  }
+  const path = resolve18(folder, candidate);
+  const body = SEED_TEMPLATE.replace(/\{name\}/g, name);
+  await writeFile14(path, body, "utf-8");
+  logger18.info(`created ${path}`);
+  return 0;
+}
+function readEnvUrl2(dialect) {
+  const url = process.env["DATABASE_URL"] ?? process.env["NEXUS_DB_URL"] ?? (dialect === "postgres" ? process.env["POSTGRES_URL"] : dialect === "mysql" ? process.env["MYSQL_URL"] : dialect.includes("sqlite") ? process.env["SQLITE_FILENAME"] : null);
+  return url ?? null;
+}
+function relativeImport(cwd, target) {
+  const abs = resolve18(cwd, target);
+  let rel = abs;
+  if (rel.startsWith(cwd))
+    rel = rel.slice(cwd.length);
+  if (rel.startsWith("/"))
+    rel = rel.slice(1);
+  if (!rel.startsWith("."))
+    rel = "./" + rel;
+  return rel;
+}
+var db_seed_default = dbSeedCommand;
+
+// packages/cli/src/commands/new.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve19 } from "path";
+import { flagBool as flagBool5, logger as logger19, render as render15, select as select2 } from "@nexusts/core/index.js";
+var newCommand = {
+  name: "new",
+  aliases: ["n"],
+  summary: "Create a new Nexus project",
+  description: "Generates a new project directory with nx.config.ts, tsconfig, package.json, and a starter app/main.ts.",
+  examples: [
+    "nx new my-app",
+    "nx new my-app --style nest --view rendu --orm drizzle --db bun-sqlite"
+  ],
+  flags: [
+    {
+      name: "style",
+      description: "Routing style (nest|adonis|functional|mixed)"
+    },
+    { name: "view", description: "View engine (rendu|edge|eta|inertia|none)" },
+    { name: "orm", description: "ORM driver (drizzle|prisma|kysely|none)" },
+    {
+      name: "db",
+      description: "Database driver (bun-sqlite|node-sqlite|libsql|postgres|mysql|none)"
+    },
+    {
+      name: "frontend",
+      description: "Inertia frontend (react|vue|svelte|solid)"
+    },
+    { name: "no-ssr", description: "Disable Inertia SSR" },
+    { name: "no-interaction", description: "Disable interactive prompts" }
+  ],
+  async run(ctx) {
+    const name = ctx.positional[0];
+    if (!name) {
+      logger19.error("Usage: nx new <project-name>");
+      return 1;
+    }
+    const interactive = !flagBool5(ctx.flags, "no-interaction", false);
+    const target = resolve19(ctx.cwd, name);
+    if (existsSync4(target)) {
+      logger19.error(`Directory already exists: ${target}`);
+      return 1;
+    }
+    const routing = ctx.flags["style"] ?? await select2("Routing style", ["nest", "adonis", "functional"], {
+      interactive,
+      default: "nest"
+    });
+    const view = ctx.flags["view"] ?? await select2("View engine", ["rendu", "edge", "eta", "inertia", "none"], {
+      interactive,
+      default: "rendu"
+    });
+    const orm = ctx.flags["orm"] ?? await select2("ORM driver", ["drizzle", "prisma", "kysely", "none"], {
+      interactive,
+      default: "drizzle"
+    });
+    const db = ctx.flags["db"] ?? await select2("Database driver", ["bun-sqlite", "node-sqlite", "libsql", "postgres", "mysql", "none"], {
+      interactive,
+      default: "bun-sqlite"
+    });
+    const frontend = ctx.flags["frontend"] ?? await select2("Inertia frontend", ["react", "vue", "svelte", "solid"], {
+      interactive,
+      default: "react"
+    });
+    const ssr = !flagBool5(ctx.flags, "no-ssr", false);
+    mkdirSync3(resolve19(target, "app"), { recursive: true });
+    mkdirSync3(resolve19(target, "public"), { recursive: true });
+    mkdirSync3(resolve19(target, "resources/views"), { recursive: true });
+    writeFileSync2(resolve19(target, "public/.gitkeep"), "");
+    writeFileSync2(resolve19(target, "resources/views/welcome.html"), `<h1>Welcome to ${name}</h1>
+<p>This is a sample Rendu template.</p>
+<p>Founded <?= year ?>.</p>
+`);
+    writeFileSync2(resolve19(target, ".env"), generateEnvFile());
+    writeFileSync2(resolve19(target, ".env.local"), generateEnvLocalFile());
+    writeFileSync2(resolve19(target, ".gitignore"), generateGitIgnore());
+    const code = render15(templates.project["nx.config.ts"], {
+      routing,
+      view,
+      viewPaths: view === "none" ? "" : "resources/views",
+      orm,
+      dbDriver: db,
+      dbUrl: db === "bun-sqlite" || db === "node-sqlite" ? "app.db" : "",
+      inertiaFrontend: frontend,
+      inertiaSSR: ssr,
+      inertiaVersion: "1.0.0"
+    });
+    writeFileSync2(resolve19(target, "nx.config.ts"), code);
+    writeFileSync2(resolve19(target, "package.json"), JSON.stringify({
+      name,
+      version: "0.1.0",
+      type: "module",
+      scripts: {
+        dev: "bun --hot app/main.ts",
+        build: "bun run build.ts",
+        start: "bun app/main.ts",
+        test: "vitest",
+        nx: "nx"
+      },
+      dependencies: {
+        "@nexusts/core": "*",
+        "reflect-metadata": "^0.2.2",
+        hono: "^4.6.0",
+        zod: "^3.23.8"
+      }
+    }, null, 2));
+    writeFileSync2(resolve19(target, "tsconfig.json"), `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["bun-types"]
+  },
+  "include": ["app/**/*.ts", "nx.config.ts"]
+}
+`);
+    writeFileSync2(resolve19(target, "app/main.ts"), `import 'reflect-metadata';
+import { Application } from '@nexusts/core';
+import { StaticModule } from '@nexusts/static';
+import { AppModule } from './app.module.js';
+
+const app = new Application(AppModule);
+// Serve ./public files under /static/*
+app.server.app.use('/static/*', StaticModule.mount({ root: './public', prefix: '/static' }));
+
+const port = Number(process.env["PORT"] ?? 3000);
+await app.listen(port);
+console.log("[nexusjs] Listening on http://localhost:" + port);
+`);
+    writeFileSync2(resolve19(target, "app/app.module.ts"), `import { Module } from '@nexusts/core';
+import { HomeController } from './controllers/home.controller.js';
+
+@Module({
+  imports: [],
+  controllers: [HomeController],
+})
+export class AppModule {}
+`);
+    mkdirSync3(resolve19(target, "app/controllers"), { recursive: true });
+    writeFileSync2(resolve19(target, "app/controllers/home.controller.ts"), `import { Controller, Get } from '@nexusts/core';
+
+@Controller('/')
+export class HomeController {
+  @Get('/')
+  index() {
+    return {
+      view: 'welcome.html',
+      data: { year: new Date().getFullYear() },
+    };
+  }
+}
+`);
+    writeFileSync2(resolve19(target, "README.md"), `# ${name}
+
+A new Nexus project.
+
+## Run
+
+\`\`\`bash
+bun install
+bun run dev
+\`\`\`
+
+## Scaffolding
+
+\`\`\`bash
+bunx nx make:crud Post
+\`\`\`
+`);
+    logger19.success(`created ${target}`);
+    logger19.blank();
+    logger19.heading("Next steps");
+    logger19.info(`  cd ${name}`);
+    logger19.info(`  bun install`);
+    logger19.info(`  bun run dev`);
+    logger19.blank();
+    return 0;
+  }
+};
+function generateEnvFile() {
+  return `# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# NexusTS \u2014 Environment Variables (committed to git)
+#
+# Shared defaults for all environments. Override locally via
+# .env.local (gitignored) or by environment via .env.{NODE_ENV}
+# (e.g. .env.production, .env.development).
+#
+# Uncomment the database config for your driver:
+# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+# \u2500\u2500 App \u2500\u2500
+NODE_ENV=development
+PORT=3000
+
+# \u2500\u2500 Session secret (REQUIRED) \u2500\u2500
+# Generate with: openssl rand -base64 32
+SESSION_SECRET=change-me-in-production
+
+# \u2500\u2500 Database: SQLite (default, zero config) \u2500\u2500
+DATABASE_URL=app.db
+
+# \u2500\u2500 Database: PostgreSQL \u2500\u2500
+# DATABASE_URL=postgres://user:password@localhost:5432/myapp
+
+# \u2500\u2500 Database: MySQL \u2500\u2500
+# DATABASE_URL=mysql://user:password@localhost:3306/myapp
+`;
+}
+function generateEnvLocalFile() {
+  return `# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# NexusTS \u2014 Local Overrides (DO NOT COMMIT to git)
+#
+# This file is gitignored. Use it for secrets and local
+# configuration that should never be checked in.
+# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+# Override any value from .env here:
+# DATABASE_URL=postgres://user:password@localhost:5432/myapp
+# SESSION_SECRET=my-local-secret
+`;
+}
+function generateGitIgnore() {
+  return `# NexusTS
+node_modules/
+app.db
+*.db
+.env.local
+dist/
+`;
+}
+var new_default = newCommand;
+
+// packages/cli/src/commands/config.ts
+import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve20 } from "path";
+import { flagBool as flagBool6, logger as logger20, render as render16, select as select3 } from "@nexusts/core/index.js";
+var DEFAULT_VALUES = {
+  routing: "nest",
+  view: "rendu",
+  viewPaths: "resources/views",
+  orm: "drizzle",
+  dbDriver: "bun-sqlite",
+  dbUrl: "app.db",
+  inertiaFrontend: "react",
+  inertiaSSR: true,
+  inertiaVersion: "1.0.0"
+};
+function parseExistingConfig(path) {
+  const out = { ...DEFAULT_VALUES };
+  if (!existsSync5(path))
+    return out;
+  const src = readFileSync2(path, "utf8");
+  const grab = (re) => {
+    const m = src.match(re);
+    return m?.[1];
+  };
+  const routing = grab(/routing:\s*['"]([^'"]+)['"]/);
+  const view = grab(/view:\s*['"]([^'"]+)['"]/);
+  const viewPathsMatch = src.match(/viewPaths:\s*['"]([^'"]+)['"]/);
+  if (viewPathsMatch) {
+    out.viewPaths = viewPathsMatch[1];
+  }
+  const orm = grab(/orm:\s*['"]([^'"]+)['"]/);
+  const driver = grab(/driver:\s*['"]([^'"]+)['"]/);
+  const url = grab(/url:\s*process\.env\.DATABASE_URL\s*\?\?\s*['"]([^'"]+)['"]/);
+  const frontend = grab(/frontend:\s*['"]([^'"]+)['"]/);
+  const ssr = grab(/ssr:\s*(true|false)/);
+  const version = grab(/version:\s*['"]([^'"]+)['"]/);
+  if (routing)
+    out.routing = routing;
+  if (view)
+    out.view = view;
+  if (orm)
+    out.orm = orm;
+  if (driver)
+    out.dbDriver = driver;
+  if (url !== undefined)
+    out.dbUrl = url;
+  if (frontend)
+    out.inertiaFrontend = frontend;
+  if (ssr)
+    out.inertiaSSR = ssr === "true";
+  if (version)
+    out.inertiaVersion = version;
+  return out;
+}
+function driverToDialect(driver) {
+  switch (driver) {
+    case "bun-sqlite":
+    case "node-sqlite":
+    case "libsql":
+      return "sqlite";
+    case "postgres":
+      return "postgresql";
+    case "mysql":
+      return "mysql";
+    default:
+      return "sqlite";
+  }
+}
+function defaultDbUrl(driver) {
+  if (driver === "bun-sqlite" || driver === "node-sqlite" || driver === "libsql") {
+    return "app.db";
+  }
+  return "";
+}
+var configCommand = {
+  name: "config",
+  aliases: ["cfg"],
+  summary: "Update or create nx.config.ts (+ drizzle.config.ts if Drizzle is selected)",
+  description: "Re-renders nx.config.ts from the current values (parsed from the existing file, or prompted) plus any flag overrides. Also creates or updates drizzle.config.ts when the ORM is `drizzle`.",
+  examples: [
+    "nx config",
+    "nx config --db postgres --db-url postgres://localhost/mydb",
+    "nx config --orm drizzle --db bun-sqlite",
+    "nx config --view inertia --frontend vue --no-ssr",
+    "nx config --force"
+  ],
+  flags: [
+    { name: "target", description: "Target directory (default: cwd)" },
+    {
+      name: "style",
+      description: "Routing style (nest|adonis|functional|mixed)"
+    },
+    { name: "view", description: "View engine (rendu|edge|inertia|none)" },
+    {
+      name: "view-paths",
+      description: "Comma-separated directories searched for view files (e.g. resources/views)"
+    },
+    { name: "orm", description: "ORM driver (drizzle|prisma|kysely|none)" },
+    {
+      name: "db",
+      description: "Database driver (bun-sqlite|node-sqlite|libsql|postgres|mysql|none)"
+    },
+    {
+      name: "db-url",
+      description: "Default DATABASE_URL when the env var is unset"
+    },
+    {
+      name: "frontend",
+      description: "Inertia frontend (react|vue|svelte|solid)"
+    },
+    { name: "ssr", description: "Enable Inertia SSR" },
+    { name: "no-ssr", description: "Disable Inertia SSR" },
+    { name: "force", description: "Overwrite even if file already exists" },
+    { name: "no-interaction", description: "Disable interactive prompts" }
+  ],
+  async run(ctx) {
+    const interactive = !flagBool6(ctx.flags, "no-interaction", false);
+    const force = flagBool6(ctx.flags, "force", false);
+    const target = resolve20(ctx.cwd, ctx.flags["target"] ?? ".");
+    if (!existsSync5(target)) {
+      logger20.error(`Target directory does not exist: ${target}`);
+      return 1;
+    }
+    const nxConfigPath = resolve20(target, "nx.config.ts");
+    const values = parseExistingConfig(nxConfigPath);
+    const flag = (k) => ctx.flags[k];
+    const flagBoolStrict = (k, def) => flagBool6(ctx.flags, k, def);
+    if (flag("style"))
+      values.routing = flag("style");
+    if (flag("view"))
+      values.view = flag("view");
+    if (flag("view-paths")) {
+      values.viewPaths = flag("view-paths");
+    }
+    if (flag("orm"))
+      values.orm = flag("orm");
+    if (flag("db"))
+      values.dbDriver = flag("db");
+    if (flag("db-url") !== undefined)
+      values.dbUrl = flag("db-url");
+    if (flag("frontend"))
+      values.inertiaFrontend = flag("frontend");
+    if (flagBoolStrict("ssr", false))
+      values.inertiaSSR = true;
+    if (flagBoolStrict("no-ssr", false))
+      values.inertiaSSR = false;
+    const anyFlag = Object.values(ctx.flags).some((v) => v !== undefined && v !== false);
+    if (interactive && !anyFlag && !existsSync5(nxConfigPath)) {
+      values.routing = await select3("Routing style", ["nest", "adonis", "functional"], {
+        interactive,
+        default: values.routing
+      }) ?? values.routing;
+      values.view = await select3("View engine", ["inertia", "rendu", "edge", "none"], {
+        interactive,
+        default: values.view
+      }) ?? values.view;
+      values.orm = await select3("ORM driver", ["drizzle", "prisma", "kysely", "none"], {
+        interactive,
+        default: values.orm
+      }) ?? values.orm;
+      values.dbDriver = await select3("Database driver", ["bun-sqlite", "node-sqlite", "libsql", "postgres", "mysql", "none"], { interactive, default: values.dbDriver }) ?? values.dbDriver;
+      values.inertiaFrontend = await select3("Inertia frontend", ["react", "vue", "svelte", "solid"], { interactive, default: values.inertiaFrontend }) ?? values.inertiaFrontend;
+    }
+    if (flag("db-url") === undefined && flag("db") !== undefined) {
+      values.dbUrl = defaultDbUrl(values.dbDriver);
+    }
+    const existed = existsSync5(nxConfigPath);
+    if (existed && !force) {
+      if (anyFlag) {
+        writeNxConfig(target, values);
+        logger20.info(`  ~ nx.config.ts (updated)`);
+      } else {
+        logger20.info(`  - nx.config.ts (unchanged; pass --force or a flag to update)`);
+      }
+    } else {
+      writeNxConfig(target, values);
+      logger20.info(`  + nx.config.ts`);
+    }
+    const drizzleConfigPath = resolve20(target, "drizzle.config.ts");
+    if (values.orm === "drizzle") {
+      const dialect = driverToDialect(values.dbDriver);
+      const dbUrl = values.dbUrl;
+      const existedDrizzle = existsSync5(drizzleConfigPath);
+      if (existedDrizzle && !force && !anyFlag) {
+        logger20.info(`  - drizzle.config.ts (unchanged; pass --force or a flag to update)`);
+      } else {
+        writeDrizzleConfig(target, { dialect, dbUrl });
+        logger20.info(`  ${existedDrizzle ? "~" : "+"} drizzle.config.ts`);
+      }
+    } else if (existsSync5(drizzleConfigPath)) {
+      logger20.info(`  - drizzle.config.ts (left as-is; ORM is '${values.orm}', not 'drizzle')`);
+    }
+    logger20.blank();
+    logger20.success(`config updated in ${target}`);
+    logger20.blank();
+    logger20.heading("Next steps");
+    logger20.info(`  cd ${target === ctx.cwd ? "." : target}`);
+    if (values.orm === "drizzle") {
+      logger20.info(`  bun run db:generate    # generate migrations`);
+    }
+    logger20.blank();
+    return 0;
+  }
+};
+function writeNxConfig(target, values) {
+  const code = render16(templates.project["nx.config.ts"], values);
+  writeFileSync3(resolve20(target, "nx.config.ts"), code);
+}
+function writeDrizzleConfig(target, values) {
+  const code = render16(templates.project["drizzle.config.ts"], values);
+  writeFileSync3(resolve20(target, "drizzle.config.ts"), code);
+}
+var config_default = configCommand;
+
+// packages/cli/src/commands/repl.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { dirname as dirname2, resolve as resolve21 } from "path";
+import * as readline from "readline";
+import * as vm from "vm";
+import { logger as logger21 } from "@nexusts/core/index.js";
+var BANNER = `
+\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E
+\u2502  NexusTS REPL                                    \u2502
+\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F
+`;
+var HELP = `
+Available commands:
+  .help              Show this help
+  .exit              Exit the REPL (alias: .quit)
+  .services          List services in the DI container
+  .modules           List all modules
+  .routes            List all registered routes
+  .history           Show command history
+  .clear             Clear the screen
+  .reset             Reset the REPL context (clear all variables)
+
+Pre-loaded variables (when an app is booted):
+  app                The Application instance
+  container          The DI container
+  db                 DrizzleService (if registered)
+  logger             LoggerService (if registered)
+  cfg                ConfigService (if registered)
+  cache              CacheService (if registered)
+  events             EventService (if registered)
+
+Examples:
+  > await db.select().from(users).all()
+  > logger.info("hello from REPL")
+  > app.container.size
+`;
+var PRELOAD = [
+  ["db", "../../drizzle/drizzle.service.js", "DrizzleService"],
+  ["logger", "../../logger/logger.service.js", "LoggerService"],
+  ["cfg", "../../config/config.service.js", "ConfigService"],
+  ["cache", "../../cache/cache.service.js", "CacheService"],
+  ["events", "../../events/event.service.js", "EventService"]
+];
+var replCommand = {
+  name: "repl",
+  aliases: ["console", "shell"],
+  summary: "Start an interactive REPL with the app's services",
+  description: "Boots the user's app module and drops into an interactive REPL. Useful for debugging, exploring data, and trying out queries. Multi-line input is supported. History is persisted to .nx-repl-history.",
+  examples: [
+    "nx repl",
+    "nx repl --module app/app.module.ts",
+    "nx repl --no-boot",
+    "nx repl --history /tmp/nx-history"
+  ],
+  flags: [
+    {
+      name: "module",
+      description: "Path to the AppModule (default: app/app.module.ts)."
+    },
+    {
+      name: "no-boot",
+      description: "Skip booting the app \u2014 start a vanilla REPL."
+    },
+    {
+      name: "history",
+      description: "History file path (default: .nx-repl-history)."
+    }
+  ],
+  async run(ctx) {
+    const mod = ctx.flags["module"];
+    const noBoot = Boolean(ctx.flags["no-boot"]);
+    const histPath = resolve21(ctx.cwd, ctx.flags["history"] ?? ".nx-repl-history");
+    const env = { console };
+    if (!noBoot) {
+      const modPath = resolve21(ctx.cwd, mod ?? "app/app.module.ts");
+      if (!existsSync6(modPath)) {
+        logger21.error(`module not found: ${modPath}`);
+        logger21.info("pass --module <path> or --no-boot to skip booting");
+        return 1;
+      }
+      try {
+        const modSpec = await import(modPath);
+        const AppModule = modSpec.default ?? modSpec.AppModule;
+        if (!AppModule) {
+          logger21.error(`module at ${modPath} does not export AppModule as default or named export`);
+          return 1;
+        }
+        const { Application } = await import("@nexusts/core/src/application.js");
+        const app = new Application(AppModule);
+        env.app = app;
+        env.container = app.container;
+        for (const [name, path, className] of PRELOAD) {
+          await preloadService(env, app, name, path, className);
+        }
+        logger21.info(`\u2713 Booted ${modPath}`);
+      } catch (err) {
+        logger21.error(`failed to boot: ${err.message}`);
+        return 1;
+      }
+    }
+    console.log(BANNER);
+    if (noBoot) {
+      console.log("  (started with --no-boot; no app is loaded)");
+    }
+    const history = loadHistory(histPath);
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: "\u276F ",
+      terminal: true,
+      history,
+      historySize: 1000
+    });
+    const saveHist = () => saveHistoryFile(histPath, rl.history ?? []);
+    rl.on("close", () => {
+      saveHist();
+      process.exit(0);
+    });
+    process.on("SIGINT", () => {
+      saveHist();
+      process.exit(0);
+    });
+    process.on("exit", saveHist);
+    let buffer = "";
+    const vmContext = vm.createContext(env);
+    const evaluate = async (code) => {
+      try {
+        const script = new vm.Script(code, { filename: "<nx-repl>" });
+        const result = script.runInContext(vmContext, {
+          displayErrors: false
+        });
+        if (result === undefined)
+          return;
+        if (result && typeof result.then === "function") {
+          const v = await result;
+          console.log(formatResult(v));
+        } else {
+          console.log(formatResult(result));
+        }
+      } catch (err) {
+        console.error(formatError(err));
+      }
+    };
+    const handleDotCommand = async (line) => {
+      const cmd = line.trim();
+      switch (cmd) {
+        case ".help":
+          console.log(HELP);
+          return true;
+        case ".exit":
+        case ".quit":
+          saveHist();
+          rl.close();
+          return true;
+        case ".clear":
+          console.clear();
+          console.log(BANNER);
+          return true;
+        case ".services": {
+          const services = listServices(env.container);
+          if (services.length === 0) {
+            console.log("  (no services registered)");
+          } else {
+            for (const s of services)
+              console.log(`  ${s}`);
+          }
+          return true;
+        }
+        case ".modules": {
+          const mods = env.app?.modules;
+          if (!mods || mods.length === 0) {
+            console.log("  (no modules)");
+          } else {
+            for (const m of mods) {
+              console.log(`  ${m.name ?? m.constructor?.name ?? "(anon)"}`);
+            }
+          }
+          return true;
+        }
+        case ".routes": {
+          const app = env.app;
+          const routes = app?.server?.app?.routes ?? [];
+          if (routes.length === 0) {
+            console.log("  (no routes registered)");
+          } else {
+            for (const r of routes) {
+              const m = (r.method ?? "?").padEnd(7);
+              console.log(`  ${m} ${r.path ?? "?"}`);
+            }
+          }
+          return true;
+        }
+        case ".history": {
+          const hist = rl.history ?? [];
+          const histArr = hist;
+          histArr.forEach((h, i) => {
+            console.log(`  ${(i + 1).toString().padStart(4)}: ${h}`);
+          });
+          return true;
+        }
+        case ".reset": {
+          for (const k of Object.keys(env)) {
+            if (k !== "console")
+              delete env[k];
+          }
+          console.log("  context reset");
+          return true;
+        }
+        default:
+          console.error(`  unknown command: ${cmd}`);
+          console.log("  type .help for the list");
+          return true;
+      }
+    };
+    rl.on("line", async (line) => {
+      const trimmed = line.trim();
+      if (trimmed.startsWith(".")) {
+        await handleDotCommand(trimmed);
+      } else {
+        buffer += line + `
+`;
+        if (isIncomplete(buffer)) {
+          rl.setPrompt("... ");
+          rl.prompt();
+          return;
+        }
+        await evaluate(buffer);
+        buffer = "";
+        rl.setPrompt("\u276F ");
+      }
+      rl.prompt();
+    });
+    rl.prompt();
+    return new Promise(() => {});
+  }
+};
+async function preloadService(env, app, name, path, className) {
+  try {
+    const mod = await import(path);
+    const ServiceClass = mod[className];
+    if (!ServiceClass)
+      return;
+    const Token = ServiceClass.TOKEN ?? ServiceClass[`${className.toUpperCase()}_TOKEN`];
+    if (!Token)
+      return;
+    try {
+      env[name] = app.container.resolve(Token);
+    } catch {
+      try {
+        env[name] = app.container.resolve(ServiceClass);
+      } catch {}
+    }
+  } catch {}
+}
+function listServices(container) {
+  if (!container)
+    return [];
+  const c = container;
+  if (typeof c.listProviders !== "function")
+    return [];
+  try {
+    return c.listProviders().map((p) => p.token?.toString?.() ?? String(p.token));
+  } catch {
+    return [];
+  }
+}
+function isIncomplete(code) {
+  const stack = [];
+  let inString = null;
+  let inComment = null;
+  for (let i = 0;i < code.length; i++) {
+    const c = code[i];
+    const next = code[i + 1];
+    if (inComment === "line") {
+      if (c === `
+`)
+        inComment = null;
+      continue;
+    }
+    if (inComment === "block") {
+      if (c === "*" && next === "/") {
+        inComment = null;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      if (c === "\\") {
+        i++;
+        continue;
+      }
+      if (c === inString)
+        inString = null;
+      continue;
+    }
+    if (c === "/" && next === "/") {
+      inComment = "line";
+      i++;
+      continue;
+    }
+    if (c === "/" && next === "*") {
+      inComment = "block";
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      inString = c;
+      continue;
+    }
+    if (c === "{" || c === "[" || c === "(")
+      stack.push(c);
+    else if (c === "}" || c === "]" || c === ")")
+      stack.pop();
+  }
+  return stack.length > 0 || inString !== null || inComment === "block";
+}
+function formatResult(r) {
+  if (r === null)
+    return "null";
+  if (r === undefined)
+    return "undefined";
+  if (typeof r === "string")
+    return r;
+  if (typeof r === "number" || typeof r === "boolean" || typeof r === "bigint")
+    return String(r);
+  if (typeof r === "function") {
+    const fn = r;
+    return `[Function: ${fn.name || "anonymous"}]`;
+  }
+  if (typeof r === "symbol")
+    return r.toString();
+  try {
+    return JSON.stringify(r, null, 2);
+  } catch {
+    return Object.prototype.toString.call(r);
+  }
+}
+function formatError(e) {
+  if (e.name === "SyntaxError")
+    return e.message;
+  return e.stack ? e.stack.split(`
+`).slice(0, 5).join(`
+`) : e.message;
+}
+function loadHistory(path) {
+  if (!existsSync6(path))
+    return [];
+  try {
+    return readFileSync3(path, "utf-8").split(`
+`).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function saveHistoryFile(path, history) {
+  try {
+    const dir = dirname2(path);
+    if (!existsSync6(dir))
+      mkdirSync4(dir, { recursive: true });
+    writeFileSync4(path, history.slice(-1000).join(`
+`));
+  } catch {}
+}
+var repl_default = replCommand;
+
+// packages/cli/src/commands/route-list.ts
+import { readdirSync, statSync } from "fs";
+import { resolve as resolve22 } from "path";
+import { colors as colors2, logger as logger22 } from "@nexusts/core/index.js";
+var routeListCommand = {
+  name: "route:list",
+  aliases: ["routes", "route-list"],
+  summary: "List registered HTTP routes",
+  description: "Reads route metadata from controllers and prints a table. Falls back to a scan message when controllers don't use the decorator style.",
+  flags: [
+    { name: "format", description: "Output format: table (default) | json" }
+  ],
+  async run(ctx) {
+    const controllersDir = resolve22(ctx.cwd, ctx.config.paths.controllers);
+    try {
+      statSync(controllersDir);
+    } catch {
+      logger22.warn(`No controllers directory at ${controllersDir}.`);
+      return 0;
+    }
+    const files = readdirSync(controllersDir).filter((f) => f.endsWith(".ts"));
+    if (files.length === 0) {
+      logger22.info("No controllers found.");
+      return 0;
+    }
+    const routes = [];
+    for (const file of files) {
+      const fullPath = resolve22(controllersDir, file);
+      try {
+        const mod = await import(`${fullPath}?t=${Date.now()}`);
+        for (const exportName of Object.keys(mod)) {
+          const cls = mod[exportName];
+          if (typeof cls !== "function")
+            continue;
+          const prefix = Reflect.getMetadata("nexus:controller:prefix", cls) ?? "";
+          const routeList = Reflect.getMetadata("nexus:routes", cls) ?? [];
+          for (const r of routeList) {
+            routes.push({
+              method: String(r.method).toUpperCase(),
+              path: joinPath(prefix, r.path),
+              handler: String(r.propertyKey),
+              controller: cls.name || exportName
+            });
+          }
+        }
+      } catch (err) {
+        logger22.warn(`could not parse ${file}: ${err.message ?? err}`);
+      }
+    }
+    if (routes.length === 0) {
+      logger22.info("No routes discovered via metadata. " + "This usually means the controllers use the Adonis or functional style \u2014 see nx.config.ts:routing.");
+      return 0;
+    }
+    const format = ctx.flags["format"] ?? "table";
+    if (format === "json") {
+      console.log(JSON.stringify(routes, null, 2));
+      return 0;
+    }
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    logger22.heading(`Routes (${routes.length})`);
+    const methodColors = {
+      GET: colors2.cyan,
+      POST: colors2.green,
+      PUT: colors2.yellow,
+      PATCH: colors2.yellow,
+      DELETE: colors2.red,
+      OPTIONS: colors2.gray,
+      HEAD: colors2.gray
+    };
+    const pathWidth = Math.max(...routes.map((r) => r.path.length));
+    const methodWidth = Math.max(...routes.map((r) => r.method.length));
+    for (const r of routes) {
+      const colorize = methodColors[r.method] ?? colors2.reset;
+      const m = colorize(r.method.padEnd(methodWidth));
+      const p = colors2.bold(r.path.padEnd(pathWidth));
+      const c = colors2.dim(`${r.controller}.${r.handler}`);
+      console.log(`  ${m}  ${p}  ${c}`);
+    }
+    logger22.blank();
+    return 0;
+  }
+};
+function joinPath(prefix, sub) {
+  const a = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  const b = sub.startsWith("/") ? sub : `/${sub}`;
+  return `${a}${b}` || "/";
+}
+var route_list_default = routeListCommand;
+
+// packages/cli/src/commands/index.ts
+var commands = [
+  new_default,
+  init_default,
+  config_default,
+  make_crud_default,
+  make_controller_default,
+  make_service_default,
+  make_module_default,
+  make_model_default,
+  make_migration_default,
+  make_middleware_default,
+  make_validator_default,
+  make_auth_default,
+  make_queue_default,
+  make_schedule_default,
+  make_listener_default,
+  make_session_default,
+  db_migrate_default,
+  db_generate_default,
+  db_seed_default,
+  route_list_default,
+  info_default,
+  repl_default
+];
+function findCommand(name) {
+  return commands.find((c) => c.name === name || (c.aliases ?? []).includes(name));
+}
+
+// packages/cli/src/core/config.ts
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve23 } from "path";
+var DEFAULT_CONFIG = {
+  routing: "nest",
+  view: "inertia",
+  orm: "drizzle",
+  database: {
+    driver: "bun-sqlite",
+    url: "app.db"
+  },
+  inertia: {
+    frontend: "react",
+    ssr: true,
+    version: "1.0.0"
+  },
+  paths: {
+    app: "app",
+    controllers: "app/controllers",
+    services: "app/services",
+    modules: "app/modules",
+    models: "app/models",
+    migrations: "app/database/migrations",
+    seeds: "db/seeds",
+    middleware: "app/middleware",
+    dto: "app/dto"
+  },
+  moduleStyle: "nest",
+  auth: undefined,
+  queue: undefined
+};
+var CONFIG_CANDIDATES = [
+  "nx.config.ts",
+  "nx.config.js",
+  "nx.config.mjs",
+  ".nxrc.json"
+];
+async function loadConfig(cwd = process.cwd()) {
+  let config = {};
+  let configSource = "<defaults>";
+  for (const candidate of CONFIG_CANDIDATES) {
+    const path = resolve23(cwd, candidate);
+    if (!existsSync7(path))
+      continue;
+    try {
+      if (candidate.endsWith(".json")) {
+        const raw = readFileSync4(path, "utf8");
+        config = JSON.parse(raw);
+      } else {
+        try {
+          const mod = await import(path);
+          config = mod.default ?? mod;
+        } catch (importErr) {
+          console.warn(`[nx] Could not dynamically import ${candidate}: ${importErr.message ?? importErr}. Falling back to defaults.`);
+          config = {};
+        }
+      }
+      configSource = candidate;
+      break;
+    } catch (err) {
+      throw new Error(`Failed to load ${candidate}: ${err.message ?? String(err)}`);
+    }
+  }
+  const merged = mergeWithEnv(DEFAULT_CONFIG, config);
+  assertEnum("routing", merged.routing, [
+    "nest",
+    "adonis",
+    "functional",
+    "mixed"
+  ]);
+  assertEnum("view", merged.view, ["rendu", "edge", "inertia", "none"]);
+  assertEnum("orm", merged.orm, ["drizzle", "prisma", "kysely", "none"]);
+  assertEnum("database.driver", merged.database.driver, [
+    "bun-sqlite",
+    "node-sqlite",
+    "libsql",
+    "postgres",
+    "mysql",
+    "none"
+  ]);
+  assertEnum("inertia.frontend", merged.inertia.frontend, [
+    "react",
+    "vue",
+    "svelte",
+    "solid"
+  ]);
+  if (process.env["NX_DEBUG"] === "1") {
+    console.log(`[nx] config source: ${configSource}`);
+  }
+  return merged;
+}
+function mergeWithEnv(base, override) {
+  const env = process.env;
+  const merged = {
+    ...base,
+    ...override,
+    database: { ...base.database, ...override.database ?? {} },
+    inertia: { ...base.inertia, ...override.inertia ?? {} },
+    paths: { ...base.paths, ...override.paths ?? {} }
+  };
+  if (env["NX_ROUTING"])
+    merged.routing = env["NX_ROUTING"];
+  if (env["NX_VIEW"])
+    merged.view = env["NX_VIEW"];
+  if (env["NX_ORM"])
+    merged.orm = env["NX_ORM"];
+  if (env["NX_DATABASE_DRIVER"])
+    merged.database.driver = env["NX_DATABASE_DRIVER"];
+  if (env["NX_DATABASE_URL"])
+    merged.database.url = env["NX_DATABASE_URL"];
+  if (env["NX_INERTIA_FRONTEND"])
+    merged.inertia.frontend = env["NX_INERTIA_FRONTEND"];
+  if (env["NX_INERTIA_SSR"])
+    merged.inertia.ssr = env["NX_INERTIA_SSR"] !== "false" && env["NX_INERTIA_SSR"] !== "0";
+  if (env["NX_INERTIA_VERSION"])
+    merged.inertia.version = env["NX_INERTIA_VERSION"];
+  return merged;
+}
+function assertEnum(key, value, allowed) {
+  if (!allowed.includes(value)) {
+    throw new Error(`Invalid value for ${key}: "${value}". Allowed: ${allowed.join(", ")}.`);
+  }
+}
+
+// packages/cli/src/core/args.ts
+var LONG_RE = /^--([^=]+)(?:=(.*))?$/;
+var SHORT_RE = /^-([A-Za-z])$/;
+function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  let endOfOptions = false;
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--") {
+      endOfOptions = true;
+      i++;
+      continue;
+    }
+    if (endOfOptions || !arg.startsWith("-")) {
+      positional.push(arg);
+      i++;
+      continue;
+    }
+    const longMatch = LONG_RE.exec(arg);
+    if (longMatch) {
+      const [, name, inline] = longMatch;
+      const flagName = name;
+      if (inline !== undefined) {
+        setFlag(flags, flagName, inline);
+        i++;
+        continue;
+      }
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        setFlag(flags, flagName, next);
+        i += 2;
+      } else {
+        setFlag(flags, flagName, true);
+        i++;
+      }
+      continue;
+    }
+    const shortMatch = SHORT_RE.exec(arg);
+    if (shortMatch) {
+      const flagName = shortMatch[1];
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        setFlag(flags, flagName, next);
+        i += 2;
+      } else {
+        setFlag(flags, flagName, true);
+        i++;
+      }
+      continue;
+    }
+    positional.push(arg);
+    i++;
+  }
+  const command = positional.shift();
+  return { command, positional, flags };
+}
+function setFlag(flags, name, value) {
+  if (name.startsWith("no-") && value === true) {
+    const key = name.slice(3);
+    flags[key] = false;
+    return;
+  }
+  const existing = flags[name];
+  if (existing === undefined) {
+    flags[name] = value;
+  } else if (Array.isArray(existing)) {
+    existing.push(typeof value === "string" ? value : String(value));
+  } else {
+    flags[name] = [
+      String(existing),
+      typeof value === "string" ? value : String(value)
+    ];
+  }
+}
+function flagBool7(flags, name, fallback = false) {
+  const v = flags[name];
+  if (v === undefined)
+    return fallback;
+  if (typeof v === "boolean")
+    return v;
+  return v !== "false" && v !== "0" && v !== "no";
+}
+// packages/cli/src/core/logger.ts
+var USE_COLOR = process.env["NO_COLOR"] === undefined && process.env["FORCE_COLOR"] !== "0" && process.stdout.isTTY === true;
+var wrap = (open, close) => (s) => USE_COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : s;
+var c = {
+  reset: wrap(0, 0),
+  bold: wrap(1, 22),
+  dim: wrap(2, 22),
+  red: wrap(31, 39),
+  green: wrap(32, 39),
+  yellow: wrap(33, 39),
+  blue: wrap(34, 39),
+  magenta: wrap(35, 39),
+  cyan: wrap(36, 39),
+  gray: wrap(90, 39)
+};
+var PREFIXES = {
+  info: `${c.cyan("\u2139")}`,
+  success: `${c.green("\u2714")}`,
+  warn: `${c.yellow("\u26A0")}`,
+  error: `${c.red("\u2716")}`,
+  debug: `${c.gray("\xB7")}`,
+  finger: `${c.magenta("\u279C")}`
+};
+
+class Logger {
+  verbose = false;
+  setVerbose(v) {
+    this.verbose = v;
+  }
+  info(message) {
+    console.log(`${PREFIXES.info}  ${message}`);
+  }
+  success(message) {
+    console.log(`${PREFIXES.success}  ${message}`);
+  }
+  warn(message) {
+    console.warn(`${PREFIXES.warn}  ${c.yellow(message)}`);
+  }
+  error(message) {
+    console.error(`${PREFIXES.error}  ${c.red(message)}`);
+  }
+  debug(message) {
+    if (!this.verbose)
+      return;
+    console.log(`${PREFIXES.debug}  ${c.gray(message)}`);
+  }
+  finger(message) {
+    console.log(`${PREFIXES.finger}  ${c.magenta(message)}`);
+  }
+  table(rows) {
+    const labelWidth = Math.max(...rows.map(([l]) => l.length));
+    for (const [label, value] of rows) {
+      const padded = label.padEnd(labelWidth);
+      console.log(`  ${c.dim(padded)}  ${value}`);
+    }
+  }
+  heading(text) {
+    const bar = "\u2500".repeat(text.length + 4);
+    console.log(`
+${c.bold(c.cyan(bar))}`);
+    console.log(`${c.bold(c.cyan(`  ${text}  `))}`);
+    console.log(`${c.bold(c.cyan(bar))}
+`);
+  }
+  blank() {
+    console.log("");
+  }
+}
+var logger23 = new Logger;
+var colors3 = c;
+// packages/cli/src/index.ts
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  const verbose = flagBool7(parsed.flags, "verbose", false);
+  logger23.setVerbose(verbose);
+  if (parsed.flags["version"] === true) {
+    console.log(PKG_VERSION);
+    return 0;
+  }
+  if (parsed.flags["help"] === true || parsed.command === "help") {
+    return renderHelp(parsed.positional[0]);
+  }
+  const command = parsed.command ? findCommand(parsed.command) : undefined;
+  if (!command) {
+    if (parsed.command) {
+      logger23.error(`Unknown command: ${parsed.command}`);
+      logger23.info(`Run \`nx help\` for a list of commands.`);
+      return 1;
+    }
+    return renderHelp();
+  }
+  const cwd = process.cwd();
+  const config2 = await loadConfig(cwd);
+  return command.run({
+    cwd,
+    config: config2,
+    positional: parsed.positional,
+    flags: parsed.flags
+  });
+}
+function renderHelp(commandName) {
+  if (commandName) {
+    const cmd = findCommand(commandName);
+    if (!cmd) {
+      logger23.error(`Unknown command: ${commandName}`);
+      return 1;
+    }
+    renderCommandHelp(cmd);
+    return 0;
+  }
+  logger23.heading("nx \u2014 Nexus CLI");
+  console.log(`
+  ${colors3.dim("Adonis ACE-style command runner for the NexusTS framework.")}
+
+${colors3.bold("Usage")}
+  nx <command> [args...]
+
+${colors3.bold("Commands")}
+`);
+  const nameWidth = Math.max(...commands.map((c2) => c2.name.length));
+  for (const c2 of commands) {
+    const padded = c2.name.padEnd(nameWidth);
+    const aliasStr = c2.aliases?.length ? ` ${colors3.dim(`(${c2.aliases.join(", ")})`)}` : "";
+    console.log(`  ${colors3.cyan(padded)}${aliasStr}  ${c2.summary}`);
+  }
+  console.log(`
+${colors3.bold("Global flags")}
+  --help, -h           Show help (or \`nx help <command>\`)
+  --version, -v        Print the CLI version
+  --verbose            Verbose output
+  --no-color           Disable ANSI color output
+
+${colors3.bold("Examples")}
+  ${colors3.dim("nx new my-app")}
+  ${colors3.dim("nx init --style nest --view inertia --orm drizzle")}
+  ${colors3.dim("nx make:crud Post")}
+  ${colors3.dim("nx make:controller User")}
+  ${colors3.dim("nx make:migration create_users_table")}
+  ${colors3.dim("nx info")}
+  ${colors3.dim("nx route:list")}
+`);
+  return 0;
+}
+function renderCommandHelp(cmd) {
+  logger23.heading(cmd.name);
+  if (cmd.aliases?.length) {
+    console.log(`  ${colors3.dim("aliases:")} ${cmd.aliases.join(", ")}`);
+  }
+  if (cmd.description)
+    console.log(`
+  ${cmd.description}
+`);
+  if (cmd.flags?.length) {
+    console.log(colors3.bold(`
+Flags`));
+    for (const f of cmd.flags) {
+      const short = f.short ? `, -${f.short}` : "";
+      const def = f.default !== undefined ? ` ${colors3.dim(`(default: ${String(f.default)})`)}` : "";
+      console.log(`  --${f.name}${short.padEnd(6)}  ${f.description}${def}`);
+    }
+  }
+  if (cmd.examples?.length) {
+    console.log(colors3.bold(`
+Examples`));
+    for (const ex of cmd.examples) {
+      console.log(`  ${colors3.cyan(ex)}`);
+    }
+  }
+  console.log();
+}
+var PKG_VERSION = "0.1.0";
+main().then((code) => process.exit(code)).catch((err) => {
+  logger23.error(err?.message ?? String(err));
+  if (process.env["NX_DEBUG"] === "1" && err?.stack) {
+    console.error(err.stack);
+  }
+  process.exit(1);
+});
+
+//# debugId=D18D0C47D950221364756E2164756E21
+//# sourceMappingURL=index.js.map