@thinhnguyencth1204/nextcli 0.6.0 → 0.7.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/commands/add.ts
-import path7 from "path";
+import path10 from "path";
 
 // src/core/fs.ts
 import {
@@ -187,14 +187,27 @@ function formatEnvValue(value) {
   }
   return JSON.stringify(value);
 }
-async function addDependencies(packageJsonPath, dependencies) {
+async function mergePackageJson(packageJsonPath, options) {
   const packageRaw = await readFile(packageJsonPath, "utf8");
   const packageJson = JSON.parse(packageRaw);
-  const current = packageJson.dependencies ?? {};
-  packageJson.dependencies = {
-    ...current,
-    ...dependencies
-  };
+  if (options.dependencies) {
+    packageJson.dependencies = {
+      ...packageJson.dependencies ?? {},
+      ...options.dependencies
+    };
+  }
+  if (options.devDependencies) {
+    packageJson.devDependencies = {
+      ...packageJson.devDependencies ?? {},
+      ...options.devDependencies
+    };
+  }
+  if (options.scripts) {
+    packageJson.scripts = {
+      ...packageJson.scripts ?? {},
+      ...options.scripts
+    };
+  }
   await writeFile(
     packageJsonPath,
     `${JSON.stringify(packageJson, null, 2)}
@@ -203,24 +216,367 @@ async function addDependencies(packageJsonPath, dependencies) {
   );
 }
 
-// src/commands/add.ts
-import { readdir as readdir4, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
+// src/core/apply-modules.ts
+import { randomBytes } from "crypto";
+import path6 from "path";
 
-// src/core/templates.ts
+// src/core/chat-schema.ts
 import path2 from "path";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+var chatSchemaBlock = `
+
+// ------------------------------------------------------------
+// Optional Chatbox Models (Provider-Agnostic)
+// Review carefully before running migrations on production.
+// ------------------------------------------------------------
+model ChatConversation {
+  id           String            @id @default(cuid())
+  title        String?
+  createdAt    DateTime          @default(now())
+  updatedAt    DateTime          @updatedAt
+  participants ChatParticipant[]
+  messages     ChatMessage[]
+}
+
+model ChatParticipant {
+  id             String              @id @default(cuid())
+  conversationId String
+  userId         String
+  role           ChatParticipantRole @default(MEMBER)
+  createdAt      DateTime            @default(now())
+  conversation   ChatConversation    @relation(fields: [conversationId], references: [id], onDelete: Cascade)
+  user           User                @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([conversationId, userId])
+  @@index([userId])
+}
+
+model ChatMessage {
+  id             String           @id @default(cuid())
+  conversationId String
+  senderId       String
+  content        String
+  kind           ChatMessageKind  @default(TEXT)
+  createdAt      DateTime         @default(now())
+  updatedAt      DateTime         @updatedAt
+  conversation   ChatConversation @relation(fields: [conversationId], references: [id], onDelete: Cascade)
+  sender         User             @relation(fields: [senderId], references: [id], onDelete: Cascade)
+
+  @@index([conversationId, createdAt])
+}
+
+enum ChatParticipantRole {
+  OWNER
+  MEMBER
+}
+
+enum ChatMessageKind {
+  TEXT
+  SYSTEM
+}
+`;
+function ensureUserRelations(schema) {
+  if (schema.includes("chatParticipants") && schema.includes("chatMessages")) {
+    return schema;
+  }
+  const userBlockRegex = /model User \{[\s\S]*?\n\}/m;
+  const userBlock = schema.match(userBlockRegex)?.[0];
+  if (!userBlock) {
+    return schema;
+  }
+  const relationLines = [];
+  if (!userBlock.includes("chatParticipants")) {
+    relationLines.push("  chatParticipants ChatParticipant[]");
+  }
+  if (!userBlock.includes("chatMessages")) {
+    relationLines.push("  chatMessages     ChatMessage[]");
+  }
+  if (relationLines.length === 0) {
+    return schema;
+  }
+  const nextUserBlock = userBlock.replace(/\n\}$/, `
+${relationLines.join("\n")}
+}`);
+  return schema.replace(userBlock, nextUserBlock);
+}
+async function ensureChatSchemaInProject(projectRoot) {
+  const schemaPath = path2.join(projectRoot, "prisma", "schema.prisma");
+  if (!await pathExists(schemaPath)) {
+    return "skipped";
+  }
+  let schema = await readFile2(schemaPath, "utf8");
+  schema = ensureUserRelations(schema);
+  if (schema.includes("model ChatConversation")) {
+    await writeFile2(schemaPath, schema, "utf8");
+    return "exists";
+  }
+  const nextSchema = `${schema.trimEnd()}${chatSchemaBlock}
+`;
+  await writeFile2(schemaPath, nextSchema, "utf8");
+  return "added";
+}
+
+// src/core/example-schema.ts
+import path3 from "path";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+var exampleSchemaBlock = `
+
+// Starter demo table for template onboarding only.
+// Rename/remove this \`Example\` model before production migration.
+model Example {
+  id          String   @id @default(cuid())
+  name        String
+  description String?
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+}
+`;
+async function ensureExampleSchemaInProject(projectRoot) {
+  const schemaPath = path3.join(projectRoot, "prisma", "schema.prisma");
+  if (!await pathExists(schemaPath)) {
+    return "skipped";
+  }
+  const schema = await readFile3(schemaPath, "utf8");
+  if (schema.includes("model Example")) {
+    return "exists";
+  }
+  const nextSchema = `${schema.trimEnd()}${exampleSchemaBlock}
+`;
+  await writeFile3(schemaPath, nextSchema, "utf8");
+  return "added";
+}
+
+// src/core/email-module.ts
+var EMAIL_PROVIDER_OPTIONS = ["resend", "smtp"];
+function isEmailProvider(value) {
+  return EMAIL_PROVIDER_OPTIONS.includes(value);
+}
+function getEmailProviderEnv(provider) {
+  if (provider === "smtp") {
+    return {
+      EMAIL_PROVIDER: "smtp",
+      SMTP_HOST: "",
+      SMTP_PORT: "587",
+      SMTP_USER: "",
+      SMTP_PASSWORD: "",
+      SMTP_FROM: ""
+    };
+  }
+  return {
+    EMAIL_PROVIDER: "resend",
+    RESEND_API_KEY: "",
+    RESEND_FROM_EMAIL: ""
+  };
+}
+function getEmailProviderDependencies(provider) {
+  if (provider === "smtp") {
+    return {
+      nodemailer: "^6.10.1",
+      "@types/nodemailer": "^6.4.17"
+    };
+  }
+  return {
+    resend: "^6.9.2",
+    "@react-email/components": "^1.0.12",
+    "react-email": "^4.0.0"
+  };
+}
+
+// src/core/module-selection.ts
+var MODULE_ORDER = [
+  "database",
+  "supabase",
+  "auth",
+  "api",
+  "i18n",
+  "dashboard",
+  "example",
+  "supabase-realtime",
+  "chat",
+  "seo",
+  "email"
+];
+var MODULE_DEPENDENCIES = {
+  auth: ["database"],
+  i18n: ["api"],
+  dashboard: ["auth", "api", "i18n"],
+  example: ["dashboard", "database"],
+  chat: ["database", "supabase-realtime"],
+  "supabase-realtime": ["supabase"]
+};
+function sortModules(moduleIds) {
+  const set = new Set(moduleIds);
+  return MODULE_ORDER.filter((id) => set.has(id));
+}
+function normalizeModuleSelection(moduleIds) {
+  const requested = new Set(moduleIds);
+  const autoAdded = [];
+  function addDependencies(moduleId) {
+    for (const dep of MODULE_DEPENDENCIES[moduleId] ?? []) {
+      if (!requested.has(dep)) {
+        requested.add(dep);
+        autoAdded.push(dep);
+        addDependencies(dep);
+      }
+    }
+  }
+  for (const moduleId of moduleIds) {
+    addDependencies(moduleId);
+  }
+  return {
+    selectedModules: sortModules([...requested]),
+    autoAddedModules: autoAdded
+  };
+}
+
+// src/core/templates.ts
+import path4 from "path";
+import { existsSync } from "fs";
 import { fileURLToPath } from "url";
-var currentDir = path2.dirname(fileURLToPath(import.meta.url));
-var rootDir = path2.resolve(currentDir, "../");
+var currentDir = path4.dirname(fileURLToPath(import.meta.url));
+var rootDir = [path4.resolve(currentDir, ".."), path4.resolve(currentDir, "../..")].find(
+  (dir) => existsSync(path4.join(dir, "templates", "next-base"))
+) ?? path4.resolve(currentDir, "../..");
 var templatePaths = {
-  base: path2.join(rootDir, "templates/next-base"),
-  chat: path2.join(rootDir, "templates/features/chat"),
-  supabaseRealtime: path2.join(rootDir, "templates/features/supabase-realtime"),
-  seo: path2.join(rootDir, "templates/features/seo"),
-  email: path2.join(rootDir, "templates/features/email")
+  base: path4.join(rootDir, "templates/next-base"),
+  database: path4.join(rootDir, "templates/features/database"),
+  supabase: path4.join(rootDir, "templates/features/supabase"),
+  auth: path4.join(rootDir, "templates/features/auth"),
+  api: path4.join(rootDir, "templates/features/api"),
+  i18n: path4.join(rootDir, "templates/features/i18n"),
+  dashboard: path4.join(rootDir, "templates/features/dashboard"),
+  example: path4.join(rootDir, "templates/features/example"),
+  chat: path4.join(rootDir, "templates/features/chat"),
+  supabaseRealtime: path4.join(rootDir, "templates/features/supabase-realtime"),
+  seo: path4.join(rootDir, "templates/features/seo"),
+  email: path4.join(rootDir, "templates/features/email")
 };
 
 // src/core/modules.ts
 var optionalModules = [
+  {
+    id: "database",
+    label: "Database (Prisma + Postgres)",
+    description: "Adds Prisma schema, client, migrations scripts, and DATABASE_URL",
+    templatePath: templatePaths.database,
+    env: {
+      DATABASE_URL: "postgresql://postgres.your-project-ref:your-supabase-db-password@aws-0-us-east-1.pooler.supabase.com:6543/postgres?pgbouncer=true",
+      DIRECT_URL: "postgresql://postgres.your-project-ref:your-supabase-db-password@aws-0-us-east-1.pooler.supabase.com:5432/postgres"
+    },
+    dependencies: {
+      "@prisma/client": "^7.8.0",
+      "@prisma/adapter-pg": "^7.8.0",
+      pg: "^8.16.3"
+    },
+    devDependencies: {
+      prisma: "^7.8.0",
+      dotenv: "^17.4.2"
+    },
+    scripts: {
+      postinstall: "prisma generate",
+      "db:generate": "prisma generate",
+      "db:migrate": "prisma migrate dev",
+      "db:studio": "prisma studio"
+    },
+    setupSection: `| Variable | Where to get |
+| -------- | ------------ |
+| \`DATABASE_URL\` | Supabase Dashboard \u2192 Connect \u2192 ORMs \u2192 Prisma \u2192 pooled URL (\`:6543\`, \`?pgbouncer=true\`) |
+| \`DIRECT_URL\` | Supabase Dashboard \u2192 Connect \u2192 direct/session URL (\`:5432\`) |
+
+Run \`bun run db:migrate\` after setting \`DATABASE_URL\`.`
+  },
+  {
+    id: "supabase",
+    label: "Supabase client + Storage",
+    description: "Adds browser Supabase client and Storage upload helpers",
+    templatePath: templatePaths.supabase,
+    env: {
+      NEXT_PUBLIC_SUPABASE_URL: "",
+      NEXT_PUBLIC_SUPABASE_ANON_KEY: "",
+      NEXT_PUBLIC_SUPABASE_STORAGE_BUCKET: "public"
+    },
+    dependencies: {
+      "@supabase/supabase-js": "^2.44.2"
+    },
+    setupSection: `| Variable | Where to get |
+| -------- | ------------ |
+| \`NEXT_PUBLIC_SUPABASE_URL\` | Supabase Dashboard \u2192 Project Settings \u2192 API \u2192 Project URL |
+| \`NEXT_PUBLIC_SUPABASE_ANON_KEY\` | Same page \u2192 \`anon\` \`public\` key |
+| \`NEXT_PUBLIC_SUPABASE_STORAGE_BUCKET\` | Storage bucket name (default scaffold: \`public\`) |
+
+Create the bucket and RLS policies in Supabase Dashboard before uploads.`
+  },
+  {
+    id: "auth",
+    label: "Auth (Better Auth + RBAC)",
+    description: "Adds Better Auth, sign-in pages, user APIs, bootstrap admin, and JWT refresh",
+    templatePath: templatePaths.auth,
+    env: {
+      BETTER_AUTH_SECRET: "",
+      BETTER_AUTH_URL: "http://localhost:3000"
+    },
+    dependencies: {
+      "better-auth": "^1.6.11"
+    },
+    setupSection: `| Variable | Where to get |
+| -------- | ------------ |
+| \`BETTER_AUTH_SECRET\` | Auto-generated on create; rotate in production |
+| \`BETTER_AUTH_URL\` | Your app URL (e.g. \`http://localhost:3000\`) |
+
+Requires \`database\` (auto-added). Bootstrap seeds \`admin\` / \`admin1234\` on first dev start.`
+  },
+  {
+    id: "api",
+    label: "API client (Axios + React Query)",
+    description: "Adds unified API envelope helpers and token-aware Axios client",
+    templatePath: templatePaths.api,
+    env: {},
+    dependencies: {
+      axios: "^1.7.7",
+      "@tanstack/react-query": "^5.56.2",
+      "@tanstack/react-query-devtools": "^5.56.2"
+    },
+    setupSection: `No extra env keys. Use \`publicApi\` / \`protectedApi\` from \`src/lib/api/axios.ts\` and \`ok\` / \`fail\` from \`src/lib/api/response.ts\`.`
+  },
+  {
+    id: "i18n",
+    label: "Internationalization (next-intl)",
+    description: "Adds locale config, Vietnamese messages, and locale switcher",
+    templatePath: templatePaths.i18n,
+    env: {
+      NEXT_PUBLIC_DEFAULT_LOCALE: "vi"
+    },
+    dependencies: {
+      "next-intl": "^4.13.0"
+    },
+    setupSection: `| Variable | Where to get |
+| -------- | ------------ |
+| \`NEXT_PUBLIC_DEFAULT_LOCALE\` | Default locale code (scaffold: \`vi\`) |
+
+Add more locales with \`nextcli add language\`.`
+  },
+  {
+    id: "dashboard",
+    label: "Dashboard shell",
+    description: "Adds protected dashboard layout, sidebar navigation, and data-table UI",
+    templatePath: templatePaths.dashboard,
+    env: {},
+    dependencies: {
+      "@tanstack/react-table": "^8.20.5",
+      "@dnd-kit/core": "^6.3.1",
+      nuqs: "^2.8.1",
+      "date-fns": "^3.6.0"
+    },
+    setupSection: `Requires \`auth\`, \`api\`, and \`i18n\` (auto-added). Protected routes redirect unauthenticated users to \`/sign-in\`.`
+  },
+  {
+    id: "example",
+    label: "Example CRUD demo",
+    description: "Adds starter example feature with API route, hooks, and Prisma model",
+    templatePath: templatePaths.example,
+    env: {},
+    setupSection: `Requires \`dashboard\` and \`database\` (auto-added). Appends \`Example\` model to \`prisma/schema.prisma\` \u2014 run \`db:migrate\` after add.`
+  },
   {
     id: "chat",
     label: "Chat module",
@@ -233,21 +589,16 @@ var optionalModules = [
 | -------- | ------------ |
 | \`NEXT_PUBLIC_ENABLE_CHAT\` | Set \`true\` when chat module is enabled (auto on add) |
 
-Requires \`supabase-realtime\` (auto-added). Run \`db:migrate\` after add \u2014 chat Prisma models are appended.`
+Requires \`database\`, \`supabase\`, and \`supabase-realtime\` (auto-added). Run \`db:migrate\` after add \u2014 chat Prisma models are appended.`
   },
   {
     id: "supabase-realtime",
     label: "Supabase Realtime",
     description: "Adds Realtime channel helper and hooks",
     templatePath: templatePaths.supabaseRealtime,
-    env: {
-      NEXT_PUBLIC_SUPABASE_URL: "",
-      NEXT_PUBLIC_SUPABASE_ANON_KEY: ""
-    },
-    dependencies: {
-      "@supabase/supabase-js": "^2.44.2"
-    },
-    setupSection: `Uses the base Supabase URL/anon key. Enable Realtime on tables in Supabase Dashboard \u2192 Database \u2192 Replication.`
+    env: {},
+    dependencies: {},
+    setupSection: `Requires \`supabase\` (auto-added). Enable Realtime on tables in Supabase Dashboard \u2192 Database \u2192 Replication.`
   },
   {
     id: "seo",
@@ -279,330 +630,208 @@ function getModuleById(moduleId) {
   return module;
 }
 
-// src/core/prompts.ts
-import {
-  cancel,
-  confirm,
-  intro,
-  isCancel,
-  multiselect,
-  outro,
-  select,
-  text
-} from "@clack/prompts";
-
-// src/core/theme.ts
-var reset = "\x1B[0m";
-function paint(code, text2) {
-  return `${code}${text2}${reset}`;
-}
-var theme = {
-  cyan: (text2) => paint("\x1B[36m", text2),
-  green: (text2) => paint("\x1B[32m", text2),
-  yellow: (text2) => paint("\x1B[33m", text2),
-  red: (text2) => paint("\x1B[31m", text2),
-  blue: (text2) => paint("\x1B[34m", text2),
-  magenta: (text2) => paint("\x1B[35m", text2),
-  dim: (text2) => paint("\x1B[2m", text2),
-  bold: (text2) => paint("\x1B[1m", text2)
-};
-var bannerGradient = [
-  "\x1B[38;5;51m",
-  "\x1B[38;5;45m",
-  "\x1B[38;5;39m",
-  "\x1B[38;5;33m",
-  "\x1B[38;5;27m"
-];
-var log = {
-  info(message) {
-    console.log(`${theme.cyan("\u2139")} ${message}`);
-  },
-  success(message) {
-    console.log(`${theme.green("\u2714")} ${message}`);
-  },
-  warn(message) {
-    console.log(`${theme.yellow("\u26A0")} ${message}`);
-  },
-  error(message) {
-    console.error(`${theme.red("\u2716")} ${message}`);
-  },
-  step(message) {
-    console.log(`${theme.blue("\u2192")} ${message}`);
-  },
-  detail(label, value) {
-    console.log(`${theme.dim(`${label}:`)} ${theme.cyan(value)}`);
-  },
-  command(command) {
-    console.log(`${theme.dim("  ")}${theme.magenta(command)}`);
+// src/core/setup-docs.ts
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import path5 from "path";
+var ENABLED_MODULES_START = "<!-- nextcli:enabled-modules:start -->";
+var ENABLED_MODULES_END = "<!-- nextcli:enabled-modules:end -->";
+var MODULE_ENV_START = "<!-- nextcli:module-env:start -->";
+var MODULE_ENV_END = "<!-- nextcli:module-env:end -->";
+function buildModuleSection(moduleId) {
+  const module = getModuleById(moduleId);
+  if (!module.setupSection) {
+    return null;
   }
-};
+  return `### Module: ${module.label} (\`${module.id}\`)
 
-// src/core/prompts.ts
-function handleCancelled(value) {
-  if (!isCancel(value)) {
-    return;
-  }
-  cancel(theme.red("Operation cancelled."));
-  process.exit(0);
-}
-function startPrompt(title) {
-  intro(theme.cyan(theme.bold(title)));
-}
-function finishPrompt(message) {
-  outro(theme.green(message));
-}
-async function askSelect(message, options, initialValue) {
-  const value = await select({
-    message,
-    options,
-    initialValue
-  });
-  handleCancelled(value);
-  return value;
-}
-async function askMultiSelect(message, options, initialValues = []) {
-  const values = await multiselect({
-    message,
-    options,
-    initialValues,
-    required: false
-  });
-  handleCancelled(values);
-  return values;
-}
-async function askConfirm(message, initialValue = false) {
-  const value = await confirm({
-    message,
-    initialValue
-  });
-  handleCancelled(value);
-  return Boolean(value);
-}
-async function askText(message, options = {}) {
-  const value = await text({
-    message,
-    placeholder: options.placeholder,
-    initialValue: options.initialValue,
-    validate: options.validate
-  });
-  handleCancelled(value);
-  return value;
+${module.setupSection.trim()}
+`;
 }
-
-// src/core/auth-bootstrap.ts
-import { spawn } from "child_process";
-async function runCommand(command, args, cwd, silent = true) {
-  return new Promise((resolve) => {
-    const chunks = [];
-    const child = spawn(command, args, {
-      cwd,
-      shell: process.platform === "win32",
-      stdio: silent ? "pipe" : "inherit"
-    });
-    if (silent) {
-      child.stdout?.on("data", (chunk) => chunks.push(String(chunk)));
-      child.stderr?.on("data", (chunk) => chunks.push(String(chunk)));
-    }
-    child.on("error", () => {
-      resolve({ ok: false, output: chunks.join("") });
-    });
-    child.on("close", (code) => {
-      resolve({ ok: code === 0, output: chunks.join("") });
-    });
-  });
+function formatEnabledModulesLine(moduleIds) {
+  if (moduleIds.length === 0) {
+    return "**Enabled modules:** none";
+  }
+  const labels = moduleIds.map((id) => `\`${id}\``).join(", ");
+  return `**Enabled modules:** ${labels}`;
 }
-async function ensureBetterAuthGenerate(cwd, options = {}) {
-  const localCheck = await runCommand("npx", ["--no-install", "auth", "--help"], cwd);
-  const hasCli = localCheck.ok;
-  let canInstall = hasCli;
-  if (!hasCli) {
-    if (options.nonInteractive) {
-      log.warn("Better Auth CLI not detected. Skipping schema generation in non-interactive mode.");
-      return;
-    }
-    const approved = await askConfirm(
-      "Better Auth CLI is not installed. Install/use npx auth@latest and run schema generation now?",
-      true
-    );
-    if (!approved) {
-      log.warn("Skipped Better Auth schema generation.");
-      log.command("npx auth@latest generate --config src/lib/auth.ts");
-      return;
-    }
-    canInstall = true;
+async function updateEnabledModulesLine(content, moduleIds) {
+  const startIndex = content.indexOf(ENABLED_MODULES_START);
+  const endIndex = content.indexOf(ENABLED_MODULES_END);
+  if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
+    return content;
   }
-  if (!canInstall) {
+  const before = content.slice(0, startIndex + ENABLED_MODULES_START.length);
+  const after = content.slice(endIndex);
+  const line = formatEnabledModulesLine(moduleIds);
+  return `${before}
+${line}
+${after}`;
+}
+async function mergeModuleSetupSections(projectDir, moduleIds, allProjectModules) {
+  const setupPath = path5.join(projectDir, "SETUP.md");
+  if (!await pathExists(setupPath)) {
     return;
   }
-  const generateArgs = hasCli ? ["auth", "generate", "--config", "src/lib/auth.ts"] : ["auth@latest", "generate", "--config", "src/lib/auth.ts"];
-  const result = await runCommand("npx", generateArgs, cwd, false);
-  if (!result.ok) {
-    log.error("Better Auth generate command failed. Run manually:");
-    log.command("npx auth@latest generate --config src/lib/auth.ts");
-  }
-}
-
-// src/core/email-module.ts
-var EMAIL_PROVIDER_OPTIONS = ["resend", "smtp"];
-function isEmailProvider(value) {
-  return EMAIL_PROVIDER_OPTIONS.includes(value);
-}
-function getEmailProviderEnv(provider) {
-  if (provider === "smtp") {
-    return {
-      EMAIL_PROVIDER: "smtp",
-      SMTP_HOST: "",
-      SMTP_PORT: "587",
-      SMTP_USER: "",
-      SMTP_PASSWORD: "",
-      SMTP_FROM: ""
-    };
+  let content = await readFile4(setupPath, "utf8");
+  const enabledIds = allProjectModules ?? moduleIds;
+  content = await updateEnabledModulesLine(content, enabledIds);
+  const sections = moduleIds.map((moduleId) => buildModuleSection(moduleId)).filter((section) => Boolean(section));
+  if (sections.length === 0) {
+    await writeFile4(setupPath, content, "utf8");
+    return;
   }
-  return {
-    EMAIL_PROVIDER: "resend",
-    RESEND_API_KEY: "",
-    RESEND_FROM_EMAIL: ""
-  };
-}
-function getEmailProviderDependencies(provider) {
-  if (provider === "smtp") {
-    return {
-      nodemailer: "^6.10.1",
-      "@types/nodemailer": "^6.4.17"
-    };
+  const startIndex = content.indexOf(MODULE_ENV_START);
+  const endIndex = content.indexOf(MODULE_ENV_END);
+  if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
+    await writeFile4(setupPath, content, "utf8");
+    return;
   }
-  return {
-    resend: "^6.9.2",
-    "@react-email/components": "^1.0.12",
-    "react-email": "^4.0.0"
-  };
-}
-
-// src/core/chat-schema.ts
-import path3 from "path";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-var chatSchemaBlock = `
-
-// ------------------------------------------------------------
-// Optional Chatbox Models (Provider-Agnostic)
-// Review carefully before running migrations on production.
-// ------------------------------------------------------------
-model ChatConversation {
-  id           String            @id @default(cuid())
-  title        String?
-  createdAt    DateTime          @default(now())
-  updatedAt    DateTime          @updatedAt
-  participants ChatParticipant[]
-  messages     ChatMessage[]
-}
-
-model ChatParticipant {
-  id             String              @id @default(cuid())
-  conversationId String
-  userId         String
-  role           ChatParticipantRole @default(MEMBER)
-  createdAt      DateTime            @default(now())
-  conversation   ChatConversation    @relation(fields: [conversationId], references: [id], onDelete: Cascade)
-  user           User                @relation(fields: [userId], references: [id], onDelete: Cascade)
-
-  @@unique([conversationId, userId])
-  @@index([userId])
-}
-
-model ChatMessage {
-  id             String           @id @default(cuid())
-  conversationId String
-  senderId       String
-  content        String
-  kind           ChatMessageKind  @default(TEXT)
-  createdAt      DateTime         @default(now())
-  updatedAt      DateTime         @updatedAt
-  conversation   ChatConversation @relation(fields: [conversationId], references: [id], onDelete: Cascade)
-  sender         User             @relation(fields: [senderId], references: [id], onDelete: Cascade)
-
-  @@index([conversationId, createdAt])
-}
-
-enum ChatParticipantRole {
-  OWNER
-  MEMBER
-}
+  const before = content.slice(0, startIndex + MODULE_ENV_START.length);
+  const after = content.slice(endIndex);
+  const existingBlock = content.slice(
+    startIndex + MODULE_ENV_START.length,
+    endIndex
+  );
+  let nextBlock = existingBlock.trim();
+  for (const section of sections) {
+    const header = section.split("\n")[0];
+    if (header && nextBlock.includes(header)) {
+      continue;
+    }
+    nextBlock = nextBlock ? `${nextBlock}
 
-enum ChatMessageKind {
-  TEXT
-  SYSTEM
-}
-`;
-function ensureUserRelations(schema) {
-  if (schema.includes("chatParticipants") && schema.includes("chatMessages")) {
-    return schema;
+${section}` : section;
   }
-  const userBlockRegex = /model User \{[\s\S]*?\n\}/m;
-  const userBlock = schema.match(userBlockRegex)?.[0];
-  if (!userBlock) {
-    return schema;
+  content = `${before}
+${nextBlock ? `
+${nextBlock}
+` : "\n"}${after}`;
+  await writeFile4(setupPath, content, "utf8");
+}
+
+// src/core/apply-modules.ts
+function resolveModuleEnv(moduleId, emailProvider, authSecret) {
+  if (moduleId === "email" && emailProvider) {
+    return getEmailProviderEnv(emailProvider);
   }
-  const relationLines = [];
-  if (!userBlock.includes("chatParticipants")) {
-    relationLines.push("  chatParticipants ChatParticipant[]");
+  const module = getModuleById(moduleId);
+  const env = { ...module.env };
+  if (moduleId === "auth" && authSecret) {
+    env.BETTER_AUTH_SECRET = authSecret;
+  }
+  return env;
+}
+async function applyModulesToProject(options) {
+  const { projectDir, moduleIds, emailProvider, safeCopy = false } = options;
+  const authSecret = options.authSecret ?? randomBytes(32).toString("base64url");
+  const { selectedModules, autoAddedModules } = normalizeModuleSelection(moduleIds);
+  const copyReports = [];
+  for (const moduleId of selectedModules) {
+    const module = getModuleById(moduleId);
+    if (safeCopy) {
+      copyReports.push({
+        moduleId,
+        report: await copyDirectorySafely(module.templatePath, projectDir)
+      });
+    } else {
+      await copyDirectory(module.templatePath, projectDir);
+    }
   }
-  if (!userBlock.includes("chatMessages")) {
-    relationLines.push("  chatMessages     ChatMessage[]");
+  let chatSchemaStatus;
+  if (selectedModules.includes("chat")) {
+    chatSchemaStatus = await ensureChatSchemaInProject(projectDir);
   }
-  if (relationLines.length === 0) {
-    return schema;
+  let exampleSchemaStatus;
+  if (selectedModules.includes("example")) {
+    exampleSchemaStatus = await ensureExampleSchemaInProject(projectDir);
   }
-  const nextUserBlock = userBlock.replace(/\n\}$/, `
-${relationLines.join("\n")}
-}`);
-  return schema.replace(userBlock, nextUserBlock);
-}
-async function ensureChatSchemaInProject(projectRoot) {
-  const schemaPath = path3.join(projectRoot, "prisma", "schema.prisma");
-  if (!await pathExists(schemaPath)) {
-    return "skipped";
+  const envTargets = [".env", ".env.example", ".env.development"];
+  for (const moduleId of selectedModules) {
+    const moduleEnv = resolveModuleEnv(moduleId, emailProvider, authSecret);
+    if (Object.keys(moduleEnv).length === 0) {
+      continue;
+    }
+    for (const envFile of envTargets) {
+      const envPath = path6.join(projectDir, envFile);
+      if (await pathExists(envPath)) {
+        await mergeEnvFile(envPath, moduleEnv, {
+          header: `# --- module: ${moduleId} ---`
+        });
+      }
+    }
   }
-  let schema = await readFile2(schemaPath, "utf8");
-  schema = ensureUserRelations(schema);
-  if (schema.includes("model ChatConversation")) {
-    await writeFile2(schemaPath, schema, "utf8");
-    return "exists";
+  const packageJsonPath = path6.join(projectDir, "package.json");
+  if (await pathExists(packageJsonPath)) {
+    const dependencies = {};
+    const devDependencies = {};
+    const scripts = {};
+    for (const moduleId of selectedModules) {
+      const module = getModuleById(moduleId);
+      Object.assign(dependencies, module.dependencies ?? {});
+      Object.assign(devDependencies, module.devDependencies ?? {});
+      Object.assign(scripts, module.scripts ?? {});
+      if (moduleId === "email" && emailProvider) {
+        Object.assign(
+          dependencies,
+          getEmailProviderDependencies(emailProvider)
+        );
+      }
+    }
+    await mergePackageJson(packageJsonPath, {
+      dependencies,
+      devDependencies,
+      scripts
+    });
   }
-  const nextSchema = `${schema.trimEnd()}${chatSchemaBlock}
-`;
-  await writeFile2(schemaPath, nextSchema, "utf8");
-  return "added";
+  return {
+    selectedModules,
+    autoAddedModules,
+    copyReports,
+    chatSchemaStatus,
+    exampleSchemaStatus
+  };
+}
+async function mergeModuleDocs(projectDir, selectedModules, allProjectModules) {
+  await mergeModuleSetupSections(
+    projectDir,
+    selectedModules,
+    allProjectModules
+  );
 }
 
+// src/core/add-feature.ts
+import path9 from "path";
+import { readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
+
 // src/core/i18n.ts
-import path5 from "path";
-import { readdir as readdir3, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import path8 from "path";
+import { readdir as readdir3, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
 
 // src/core/manifest.ts
-import path4 from "path";
-import { readdir as readdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import path7 from "path";
+import { readdir as readdir2, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 var defaultManifest = {
-  cli: "0.6.0",
+  cli: "0.7.0",
   defaultLocale: "vi",
-  locales: ["vi"],
-  namespaces: ["common", "auth", "example"],
+  locales: [],
+  namespaces: [],
   modules: [],
-  features: ["example"]
+  features: []
 };
 function getManifestPath(projectDir) {
-  return path4.join(projectDir, "nextcli.json");
+  return path7.join(projectDir, "nextcli.json");
 }
 async function readManifest(projectDir) {
   const manifestPath = getManifestPath(projectDir);
   if (!await pathExists(manifestPath)) {
     return null;
   }
-  const raw = await readFile3(manifestPath, "utf8");
+  const raw = await readFile5(manifestPath, "utf8");
   return JSON.parse(raw);
 }
 async function writeManifest(projectDir, manifest) {
   const manifestPath = getManifestPath(projectDir);
-  await writeFile3(
+  await writeFile5(
     manifestPath,
     `${JSON.stringify(manifest, null, 2)}
 `,
@@ -618,22 +847,22 @@ function parseConstArray(content, marker) {
   return match[1].split(",").map((item) => item.trim().replaceAll('"', "").replaceAll("'", "")).filter(Boolean);
 }
 async function detectLocalesFromDisk(projectDir) {
-  const messagesDir = path4.join(projectDir, "messages");
+  const messagesDir = path7.join(projectDir, "messages");
   if (!await pathExists(messagesDir)) {
-    return ["vi"];
+    return [];
   }
   const entries = await readdir2(messagesDir, { withFileTypes: true });
   const locales = entries.filter((item) => item.isDirectory()).map((item) => item.name);
-  return locales.length > 0 ? locales.sort() : ["vi"];
+  return locales.sort();
 }
 async function detectNamespacesFromDisk(projectDir) {
-  const namespaceFile = path4.join(projectDir, "src/i18n/namespaces.ts");
+  const namespaceFile = path7.join(projectDir, "src/i18n/namespaces.ts");
   if (!await pathExists(namespaceFile)) {
-    return [...defaultManifest.namespaces];
+    return [];
   }
-  const content = await readFile3(namespaceFile, "utf8");
+  const content = await readFile5(namespaceFile, "utf8");
   const namespaces = parseConstArray(content, "namespaces");
-  return namespaces.length > 0 ? namespaces : [...defaultManifest.namespaces];
+  return namespaces;
 }
 async function reconcileManifest(projectDir) {
   const localesFromDisk = await detectLocalesFromDisk(projectDir);
@@ -647,7 +876,9 @@ async function reconcileManifest(projectDir) {
     ]
   };
   merged.defaultLocale = merged.locales.includes(merged.defaultLocale) ? merged.defaultLocale : merged.locales[0] ?? "vi";
-  merged.modules = [...new Set(merged.modules)].map((moduleId) => moduleId === "resend" ? "email" : moduleId).filter((moduleId) => moduleId !== "supabase");
+  merged.modules = [...new Set(merged.modules)].map(
+    (moduleId) => moduleId === "resend" ? "email" : moduleId
+  );
   merged.features = [...new Set(merged.features)];
   await writeManifest(projectDir, merged);
   return merged;
@@ -674,34 +905,34 @@ async function detectProjectState(projectDir) {
   return reconcileManifest(projectDir);
 }
 async function patchLocalesConfig(projectDir, locales) {
-  const configPath = path5.join(projectDir, "src/i18n/config.ts");
+  const configPath = path8.join(projectDir, "src/i18n/config.ts");
   if (!await pathExists(configPath)) {
     return;
   }
-  const content = await readFile4(configPath, "utf8");
+  const content = await readFile6(configPath, "utf8");
   const next = patchBetweenMarkers(
     content,
     localeStartMarker,
     localeEndMarker,
     `export const locales = [${formatArray(locales)}] as const;`
   );
-  await writeFile4(configPath, next, "utf8");
+  await writeFile6(configPath, next, "utf8");
 }
 async function appendNamespace(projectDir, namespace) {
-  const namespacePath = path5.join(projectDir, "src/i18n/namespaces.ts");
+  const namespacePath = path8.join(projectDir, "src/i18n/namespaces.ts");
   if (!await pathExists(namespacePath)) {
     return [];
   }
   const currentState = await detectProjectState(projectDir);
   const namespaces = [.../* @__PURE__ */ new Set([...currentState.namespaces, namespace])];
-  const content = await readFile4(namespacePath, "utf8");
+  const content = await readFile6(namespacePath, "utf8");
   const next = patchBetweenMarkers(
     content,
     namespaceStartMarker,
     namespaceEndMarker,
     `export const namespaces = [${formatArray(namespaces)}] as const;`
   );
-  await writeFile4(namespacePath, next, "utf8");
+  await writeFile6(namespacePath, next, "utf8");
   await writeManifest(projectDir, {
     ...currentState,
     namespaces
@@ -709,8 +940,8 @@ async function appendNamespace(projectDir, namespace) {
   return namespaces;
 }
 async function cloneLocaleMessages(projectDir, fromLocale, toLocale) {
-  const sourceDir = path5.join(projectDir, "messages", fromLocale);
-  const targetDir = path5.join(projectDir, "messages", toLocale);
+  const sourceDir = path8.join(projectDir, "messages", fromLocale);
+  const targetDir = path8.join(projectDir, "messages", toLocale);
   if (!await pathExists(sourceDir)) {
     return;
   }
@@ -722,12 +953,12 @@ async function cloneLocaleMessages(projectDir, fromLocale, toLocale) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) {
       continue;
     }
-    const sourcePath = path5.join(sourceDir, entry.name);
-    const targetPath = path5.join(targetDir, entry.name);
+    const sourcePath = path8.join(sourceDir, entry.name);
+    const targetPath = path8.join(targetDir, entry.name);
     const sourceContent = JSON.parse(
-      await readFile4(sourcePath, "utf8")
+      await readFile6(sourcePath, "utf8")
     );
-    await writeFile4(
+    await writeFile6(
       targetPath,
       `${JSON.stringify(deepCloneValue(sourceContent), null, 2)}
 `,
@@ -738,12 +969,12 @@ async function cloneLocaleMessages(projectDir, fromLocale, toLocale) {
 async function writeNamespaceMessages(projectDir, namespace, viTemplate) {
   const state = await detectProjectState(projectDir);
   for (const locale of state.locales) {
-    const localeDir = path5.join(projectDir, "messages", locale);
+    const localeDir = path8.join(projectDir, "messages", locale);
     if (!await pathExists(localeDir)) {
       continue;
     }
-    const filePath = path5.join(localeDir, `${namespace}.json`);
-    await writeFile4(
+    const filePath = path8.join(localeDir, `${namespace}.json`);
+    await writeFile6(
       filePath,
       `${JSON.stringify(deepCloneValue(viTemplate), null, 2)}
 `,
@@ -752,86 +983,7 @@ async function writeNamespaceMessages(projectDir, namespace, viTemplate) {
   }
 }
 
-// src/core/setup-docs.ts
-import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import path6 from "path";
-var ENABLED_MODULES_START = "<!-- nextcli:enabled-modules:start -->";
-var ENABLED_MODULES_END = "<!-- nextcli:enabled-modules:end -->";
-var MODULE_ENV_START = "<!-- nextcli:module-env:start -->";
-var MODULE_ENV_END = "<!-- nextcli:module-env:end -->";
-function buildModuleSection(moduleId) {
-  const module = getModuleById(moduleId);
-  if (!module.setupSection) {
-    return null;
-  }
-  return `### Module: ${module.label} (\`${module.id}\`)
-
-${module.setupSection.trim()}
-`;
-}
-function formatEnabledModulesLine(moduleIds) {
-  if (moduleIds.length === 0) {
-    return "**Enabled modules:** none";
-  }
-  const labels = moduleIds.map((id) => `\`${id}\``).join(", ");
-  return `**Enabled modules:** ${labels}`;
-}
-async function updateEnabledModulesLine(content, moduleIds) {
-  const startIndex = content.indexOf(ENABLED_MODULES_START);
-  const endIndex = content.indexOf(ENABLED_MODULES_END);
-  if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
-    return content;
-  }
-  const before = content.slice(0, startIndex + ENABLED_MODULES_START.length);
-  const after = content.slice(endIndex);
-  const line = formatEnabledModulesLine(moduleIds);
-  return `${before}
-${line}
-${after}`;
-}
-async function mergeModuleSetupSections(projectDir, moduleIds, allProjectModules) {
-  const setupPath = path6.join(projectDir, "SETUP.md");
-  if (!await pathExists(setupPath)) {
-    return;
-  }
-  let content = await readFile5(setupPath, "utf8");
-  const enabledIds = allProjectModules ?? moduleIds;
-  content = await updateEnabledModulesLine(content, enabledIds);
-  const sections = moduleIds.map((moduleId) => buildModuleSection(moduleId)).filter((section) => Boolean(section));
-  if (sections.length === 0) {
-    await writeFile5(setupPath, content, "utf8");
-    return;
-  }
-  const startIndex = content.indexOf(MODULE_ENV_START);
-  const endIndex = content.indexOf(MODULE_ENV_END);
-  if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
-    await writeFile5(setupPath, content, "utf8");
-    return;
-  }
-  const before = content.slice(0, startIndex + MODULE_ENV_START.length);
-  const after = content.slice(endIndex);
-  const existingBlock = content.slice(
-    startIndex + MODULE_ENV_START.length,
-    endIndex
-  );
-  let nextBlock = existingBlock.trim();
-  for (const section of sections) {
-    const header = section.split("\n")[0];
-    if (header && nextBlock.includes(header)) {
-      continue;
-    }
-    nextBlock = nextBlock ? `${nextBlock}
-
-${section}` : section;
-  }
-  content = `${before}
-${nextBlock ? `
-${nextBlock}
-` : "\n"}${after}`;
-  await writeFile5(setupPath, content, "utf8");
-}
-
-// src/commands/add.ts
+// src/core/add-feature.ts
 function toKebabCase(input) {
   return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -853,8 +1005,18 @@ function singularizeWord(word) {
   }
   return word;
 }
+function resolveFeatureNames(featureName) {
+  const featureSlug = toKebabCase(featureName);
+  if (!featureSlug) {
+    return null;
+  }
+  const featurePascal = toPascalCase(featureSlug);
+  const modelPascal = singularizeWord(featurePascal);
+  const modelDelegate = toCamelCase(modelPascal);
+  return { featureSlug, featurePascal, modelPascal, modelDelegate };
+}
 function buildFeatureServicesContent(modelPascal, modelDelegate) {
-  return `import prisma from "@/lib/prisma";
+  return `import prisma from "@/lib/db/prisma";
 
 export async function list${modelPascal}s() {
   return prisma.${modelDelegate}.findMany({
@@ -919,7 +1081,7 @@ export type Update${modelPascal}Input = z.infer<typeof update${modelPascal}Schem
 }
 function buildFeatureHooksContent(featureSlug, modelPascal) {
   return `import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { api } from "@/lib/axios-instance";
+import { api } from "@/lib/api/axios";
 import type { ApiSuccess } from "@/types";
 import type { Create${modelPascal}Input, Update${modelPascal}Input } from "../validations";
 
@@ -1151,7 +1313,7 @@ function buildFeatureMessages(featureName) {
   };
 }
 function buildCollectionRouteContent(featureSlug, modelPascal) {
-  return `import { fail, ok } from "@/lib/api-response";
+  return `import { fail, ok } from "@/lib/api/response";
 import {
   create${modelPascal},
   list${modelPascal}s,
@@ -1187,7 +1349,7 @@ export async function POST(request: Request) {
 `;
 }
 function buildItemRouteContent(featureSlug, modelPascal) {
-  return `import { fail, ok } from "@/lib/api-response";
+  return `import { fail, ok } from "@/lib/api/response";
 import {
   delete${modelPascal},
   get${modelPascal}ById,
@@ -1223,58 +1385,321 @@ export async function PUT(
     });
   }
 
-  try {
-    const updated = await update${modelPascal}(id, parsed.data);
-    return ok(updated);
-  } catch {
-    return fail("INTERNAL_ERROR", "Failed to update ${featureSlug}.", { status: 500 });
+  try {
+    const updated = await update${modelPascal}(id, parsed.data);
+    return ok(updated);
+  } catch {
+    return fail("INTERNAL_ERROR", "Failed to update ${featureSlug}.", { status: 500 });
+  }
+}
+
+export async function DELETE(
+  _request: Request,
+  context: { params: Promise<{ id: string }> },
+) {
+  const { id } = await context.params;
+  try {
+    await delete${modelPascal}(id);
+    return ok({ deleted: true });
+  } catch {
+    return fail("INTERNAL_ERROR", "Failed to delete ${featureSlug}.", { status: 500 });
+  }
+}
+`;
+}
+async function appendFeatureModelToPrismaSchema(cwd, modelPascal) {
+  const schemaPath = path9.join(cwd, "prisma", "schema.prisma");
+  if (!await pathExists(schemaPath)) {
+    return "skipped";
+  }
+  const schemaContent = await readFile7(schemaPath, "utf8");
+  const modelRegex = new RegExp(`\\bmodel\\s+${modelPascal}\\b`);
+  if (modelRegex.test(schemaContent)) {
+    return "exists";
+  }
+  const modelBlock = `
+
+// Example feature model generated by NexTCLI.
+// Review fields/indexes before running migration on production.
+model ${modelPascal} {
+  id          String   @id @default(cuid())
+  name        String
+  description String?
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+}
+`;
+  await writeFile7(
+    schemaPath,
+    `${schemaContent.trimEnd()}${modelBlock}
+`,
+    "utf8"
+  );
+  return "added";
+}
+async function addFeatureToProject(cwd, featureName) {
+  const names = resolveFeatureNames(featureName);
+  if (!names) {
+    return { ok: false, reason: "invalid-name" };
+  }
+  const { featureSlug, modelPascal, modelDelegate } = names;
+  const srcPath = path9.join(cwd, "src");
+  if (!await pathExists(srcPath)) {
+    return { ok: false, reason: "missing-src" };
+  }
+  const featureRoot = path9.join(cwd, "src/features", featureSlug);
+  if (await pathExists(featureRoot)) {
+    return { ok: false, reason: "already-exists" };
+  }
+  await ensureDir(path9.join(featureRoot, "api"));
+  await ensureDir(path9.join(featureRoot, "components"));
+  await writeFile7(
+    path9.join(featureRoot, "services.ts"),
+    buildFeatureServicesContent(modelPascal, modelDelegate),
+    "utf8"
+  );
+  await writeFile7(
+    path9.join(featureRoot, "validations.ts"),
+    buildFeatureValidationContent(modelPascal),
+    "utf8"
+  );
+  await writeFile7(
+    path9.join(featureRoot, "api", `use-${featureSlug}.ts`),
+    buildFeatureHooksContent(featureSlug, modelPascal),
+    "utf8"
+  );
+  await writeFile7(
+    path9.join(featureRoot, "components", `${featureSlug}-table.tsx`),
+    buildFeatureTableContent(featureSlug, modelPascal),
+    "utf8"
+  );
+  await writeFile7(
+    path9.join(featureRoot, "components", `create-${featureSlug}-dialog.tsx`),
+    buildFeatureDialogContent(featureSlug, modelPascal),
+    "utf8"
+  );
+  const routeFilePath = path9.join(
+    cwd,
+    "src/app/api/v1",
+    featureSlug,
+    "route.ts"
+  );
+  await ensureDir(path9.dirname(routeFilePath));
+  await writeFile7(
+    routeFilePath,
+    buildCollectionRouteContent(featureSlug, modelPascal),
+    "utf8"
+  );
+  const idRoutePath = path9.join(
+    cwd,
+    "src/app/api/v1",
+    featureSlug,
+    "[id]",
+    "route.ts"
+  );
+  await ensureDir(path9.dirname(idRoutePath));
+  await writeFile7(
+    idRoutePath,
+    buildItemRouteContent(featureSlug, modelPascal),
+    "utf8"
+  );
+  const featurePagePath = path9.join(
+    cwd,
+    "src/app/(dashboard)",
+    featureSlug,
+    "page.tsx"
+  );
+  await ensureDir(path9.dirname(featurePagePath));
+  await writeFile7(
+    featurePagePath,
+    buildFeaturePageContent(featureSlug, modelPascal),
+    "utf8"
+  );
+  const manifestState = await detectProjectState(cwd);
+  await writeNamespaceMessages(cwd, featureSlug, buildFeatureMessages(modelPascal));
+  const namespaces = await appendNamespace(cwd, featureSlug);
+  await writeManifest(cwd, {
+    ...manifestState,
+    namespaces,
+    features: [.../* @__PURE__ */ new Set([...manifestState.features, featureSlug])]
+  });
+  const schemaStatus = await appendFeatureModelToPrismaSchema(cwd, modelPascal);
+  return { ok: true, featureSlug, modelPascal, schemaStatus };
+}
+
+// src/commands/add.ts
+import { readdir as readdir4, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
+
+// src/core/prompts.ts
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  multiselect,
+  outro,
+  select,
+  text
+} from "@clack/prompts";
+
+// src/core/theme.ts
+var reset = "\x1B[0m";
+function paint(code, text2) {
+  return `${code}${text2}${reset}`;
+}
+var theme = {
+  cyan: (text2) => paint("\x1B[36m", text2),
+  green: (text2) => paint("\x1B[32m", text2),
+  yellow: (text2) => paint("\x1B[33m", text2),
+  red: (text2) => paint("\x1B[31m", text2),
+  blue: (text2) => paint("\x1B[34m", text2),
+  magenta: (text2) => paint("\x1B[35m", text2),
+  dim: (text2) => paint("\x1B[2m", text2),
+  bold: (text2) => paint("\x1B[1m", text2)
+};
+var bannerGradient = [
+  "\x1B[38;5;51m",
+  "\x1B[38;5;45m",
+  "\x1B[38;5;39m",
+  "\x1B[38;5;33m",
+  "\x1B[38;5;27m"
+];
+var log = {
+  info(message) {
+    console.log(`${theme.cyan("\u2139")} ${message}`);
+  },
+  success(message) {
+    console.log(`${theme.green("\u2714")} ${message}`);
+  },
+  warn(message) {
+    console.log(`${theme.yellow("\u26A0")} ${message}`);
+  },
+  error(message) {
+    console.error(`${theme.red("\u2716")} ${message}`);
+  },
+  step(message) {
+    console.log(`${theme.blue("\u2192")} ${message}`);
+  },
+  detail(label, value) {
+    console.log(`${theme.dim(`${label}:`)} ${theme.cyan(value)}`);
+  },
+  command(command) {
+    console.log(`${theme.dim("  ")}${theme.magenta(command)}`);
+  }
+};
+
+// src/core/prompts.ts
+function handleCancelled(value) {
+  if (!isCancel(value)) {
+    return;
   }
+  cancel(theme.red("Operation cancelled."));
+  process.exit(0);
 }
-
-export async function DELETE(
-  _request: Request,
-  context: { params: Promise<{ id: string }> },
-) {
-  const { id } = await context.params;
-  try {
-    await delete${modelPascal}(id);
-    return ok({ deleted: true });
-  } catch {
-    return fail("INTERNAL_ERROR", "Failed to delete ${featureSlug}.", { status: 500 });
-  }
+function startPrompt(title) {
+  intro(theme.cyan(theme.bold(title)));
 }
-`;
+function finishPrompt(message) {
+  outro(theme.green(message));
+}
+async function askSelect(message, options, initialValue) {
+  const value = await select({
+    message,
+    options,
+    initialValue
+  });
+  handleCancelled(value);
+  return value;
+}
+async function askMultiSelect(message, options, initialValues = []) {
+  const values = await multiselect({
+    message,
+    options,
+    initialValues,
+    required: false
+  });
+  handleCancelled(values);
+  return values;
+}
+async function askConfirm(message, initialValue = false) {
+  const value = await confirm({
+    message,
+    initialValue
+  });
+  handleCancelled(value);
+  return Boolean(value);
+}
+async function askText(message, options = {}) {
+  const value = await text({
+    message,
+    placeholder: options.placeholder,
+    initialValue: options.initialValue,
+    validate: options.validate
+  });
+  handleCancelled(value);
+  return value;
 }
-async function appendFeatureModelToPrismaSchema(cwd, modelPascal) {
-  const schemaPath = path7.join(cwd, "prisma", "schema.prisma");
-  if (!await pathExists(schemaPath)) {
-    return "skipped";
-  }
-  const schemaContent = await readFile6(schemaPath, "utf8");
-  const modelRegex = new RegExp(`\\bmodel\\s+${modelPascal}\\b`);
-  if (modelRegex.test(schemaContent)) {
-    return "exists";
-  }
-  const modelBlock = `
 
-// Example feature model generated by NexTCLI.
-// Review fields/indexes before running migration on production.
-model ${modelPascal} {
-  id          String   @id @default(cuid())
-  name        String
-  description String?
-  createdAt   DateTime @default(now())
-  updatedAt   DateTime @updatedAt
+// src/core/auth-bootstrap.ts
+import { spawn } from "child_process";
+async function runCommand(command, args, cwd, silent = true) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    const child = spawn(command, args, {
+      cwd,
+      shell: process.platform === "win32",
+      stdio: silent ? "pipe" : "inherit"
+    });
+    if (silent) {
+      child.stdout?.on("data", (chunk) => chunks.push(String(chunk)));
+      child.stderr?.on("data", (chunk) => chunks.push(String(chunk)));
+    }
+    child.on("error", () => {
+      resolve({ ok: false, output: chunks.join("") });
+    });
+    child.on("close", (code) => {
+      resolve({ ok: code === 0, output: chunks.join("") });
+    });
+  });
 }
-`;
-  await writeFile6(
-    schemaPath,
-    `${schemaContent.trimEnd()}${modelBlock}
-`,
-    "utf8"
+async function ensureBetterAuthGenerate(cwd, options = {}) {
+  const localCheck = await runCommand(
+    "npx",
+    ["--no-install", "auth", "--help"],
+    cwd
   );
-  return "added";
+  const hasCli = localCheck.ok;
+  let canInstall = hasCli;
+  if (!hasCli) {
+    if (options.nonInteractive) {
+      log.warn(
+        "Better Auth CLI not detected. Skipping schema generation in non-interactive mode."
+      );
+      return;
+    }
+    const approved = await askConfirm(
+      "Better Auth CLI is not installed. Install/use npx auth@latest and run schema generation now?",
+      true
+    );
+    if (!approved) {
+      log.warn("Skipped Better Auth schema generation.");
+      log.command("npx auth@latest generate --config src/lib/auth/server.ts");
+      return;
+    }
+    canInstall = true;
+  }
+  if (!canInstall) {
+    return;
+  }
+  const generateArgs = hasCli ? ["auth", "generate", "--config", "src/lib/auth/server.ts"] : ["auth@latest", "generate", "--config", "src/lib/auth/server.ts"];
+  const result = await runCommand("npx", generateArgs, cwd, false);
+  if (!result.ok) {
+    log.error("Better Auth generate command failed. Run manually:");
+    log.command("npx auth@latest generate --config src/lib/auth/server.ts");
+  }
 }
+
+// src/commands/add.ts
 var authProviderStartMarker = "// AUTO_GENERATED_AUTH_PROVIDERS_START";
 var authProviderEndMarker = "// AUTO_GENERATED_AUTH_PROVIDERS_END";
 function buildProviderSnippet(providers) {
@@ -1317,131 +1742,29 @@ function patchAuthProviders(content, providers) {
 ${snippet ? `${snippet}
 ` : ""}  $3`);
 }
-function normalizeModuleSelection(moduleIds) {
-  const selected = [...new Set(moduleIds)];
-  const autoAdded = [];
-  if (selected.includes("chat") && !selected.includes("supabase-realtime")) {
-    selected.unshift("supabase-realtime");
-    autoAdded.push("supabase-realtime");
-  }
-  return {
-    selectedModules: [...new Set(selected)],
-    autoAddedModules: autoAdded
-  };
-}
 function registerAddCommand(program2) {
   const add = program2.command("add").description("Add modules to an existing app");
   add.command("feature").description("Scaffold a feature folder under src/features").argument("<feature-name>", "Feature name").action(async (featureName) => {
-    const featureSlug = toKebabCase(featureName);
-    if (!featureSlug) {
-      log.error("Invalid feature name.");
-      process.exitCode = 1;
-      return;
-    }
     const cwd = process.cwd();
-    const srcPath = path7.join(cwd, "src");
-    if (!await pathExists(srcPath)) {
-      log.error(
-        "Run this command from your generated Next.js project root (missing ./src)."
-      );
-      process.exitCode = 1;
-      return;
-    }
-    const featurePascal = toPascalCase(featureSlug);
-    const modelPascal = singularizeWord(featurePascal);
-    const modelDelegate = toCamelCase(modelPascal);
-    const featureRoot = path7.join(cwd, "src/features", featureSlug);
-    if (await pathExists(featureRoot)) {
-      log.error(`Feature already exists: ${featureRoot}`);
+    const result = await addFeatureToProject(cwd, featureName);
+    if (!result.ok) {
+      if (result.reason === "invalid-name") {
+        log.error("Invalid feature name.");
+      } else if (result.reason === "missing-src") {
+        log.error(
+          "Run this command from your generated Next.js project root (missing ./src)."
+        );
+      } else if (result.reason === "already-exists") {
+        const slug = featureName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-");
+        log.error(`Feature already exists: ${path10.join(cwd, "src/features", slug)}`);
+      }
       process.exitCode = 1;
       return;
     }
-    await ensureDir(path7.join(featureRoot, "api"));
-    await ensureDir(path7.join(featureRoot, "components"));
-    await writeFile6(
-      path7.join(featureRoot, "services.ts"),
-      buildFeatureServicesContent(modelPascal, modelDelegate),
-      "utf8"
-    );
-    await writeFile6(
-      path7.join(featureRoot, "validations.ts"),
-      buildFeatureValidationContent(modelPascal),
-      "utf8"
-    );
-    await writeFile6(
-      path7.join(featureRoot, "api", `use-${featureSlug}.ts`),
-      buildFeatureHooksContent(featureSlug, modelPascal),
-      "utf8"
-    );
-    await writeFile6(
-      path7.join(featureRoot, "components", `${featureSlug}-table.tsx`),
-      buildFeatureTableContent(featureSlug, modelPascal),
-      "utf8"
-    );
-    await writeFile6(
-      path7.join(
-        featureRoot,
-        "components",
-        `create-${featureSlug}-dialog.tsx`
-      ),
-      buildFeatureDialogContent(featureSlug, modelPascal),
-      "utf8"
-    );
-    const routeFilePath = path7.join(
-      cwd,
-      "src/app/api/v1",
-      featureSlug,
-      "route.ts"
-    );
-    await ensureDir(path7.dirname(routeFilePath));
-    await writeFile6(
-      routeFilePath,
-      buildCollectionRouteContent(featureSlug, modelPascal),
-      "utf8"
-    );
-    const idRoutePath = path7.join(
-      cwd,
-      "src/app/api/v1",
-      featureSlug,
-      "[id]",
-      "route.ts"
-    );
-    await ensureDir(path7.dirname(idRoutePath));
-    await writeFile6(
-      idRoutePath,
-      buildItemRouteContent(featureSlug, modelPascal),
-      "utf8"
-    );
-    const featurePagePath = path7.join(
-      cwd,
-      "src/app/(dashboard)",
-      featureSlug,
-      "page.tsx"
-    );
-    await ensureDir(path7.dirname(featurePagePath));
-    await writeFile6(
-      featurePagePath,
-      buildFeaturePageContent(featureSlug, modelPascal),
-      "utf8"
-    );
-    const manifestState = await detectProjectState(cwd);
-    await writeNamespaceMessages(
-      cwd,
-      featureSlug,
-      buildFeatureMessages(modelPascal)
-    );
-    const namespaces = await appendNamespace(cwd, featureSlug);
-    await writeManifest(cwd, {
-      ...manifestState,
-      namespaces,
-      features: [.../* @__PURE__ */ new Set([...manifestState.features, featureSlug])]
-    });
-    const schemaStatus = await appendFeatureModelToPrismaSchema(
-      cwd,
-      modelPascal
+    const schemaMessage = result.schemaStatus === "added" ? `Model ${result.modelPascal} appended to prisma/schema.prisma` : result.schemaStatus === "exists" ? `Model ${result.modelPascal} already exists in prisma/schema.prisma` : "Skipped prisma/schema.prisma update (file not found)";
+    log.success(
+      `Feature generated with CRUD: src/features/${result.featureSlug}`
     );
-    const schemaMessage = schemaStatus === "added" ? `Model ${modelPascal} appended to prisma/schema.prisma` : schemaStatus === "exists" ? `Model ${modelPascal} already exists in prisma/schema.prisma` : "Skipped prisma/schema.prisma update (file not found)";
-    log.success(`Feature generated with CRUD: src/features/${featureSlug}`);
     log.info(schemaMessage);
     log.warn(
       "No migration was executed. Run your migration command manually when ready."
@@ -1453,8 +1776,8 @@ function registerAddCommand(program2) {
   ).option("--yes", "Skip prompts").action(
     async (options) => {
       const cwd = process.cwd();
-      const hasSrc = await pathExists(path7.join(cwd, "src"));
-      const hasPackageJson = await pathExists(path7.join(cwd, "package.json"));
+      const hasSrc = await pathExists(path10.join(cwd, "src"));
+      const hasPackageJson = await pathExists(path10.join(cwd, "package.json"));
       if (!hasSrc || !hasPackageJson) {
         log.error(
           "Run this command from your generated Next.js project root."
@@ -1480,9 +1803,7 @@ function registerAddCommand(program2) {
           continue;
         }
         if (moduleId === "supabase") {
-          log.info(
-            "Supabase is now part of the base template; only supabase-realtime is optional."
-          );
+          requestedIds.push("supabase");
           continue;
         }
         if (moduleId === "resend") {
@@ -1549,61 +1870,31 @@ function registerAddCommand(program2) {
         finishPrompt("No modules selected.");
         return;
       }
-      const skippedConflictsByModule = [];
-      let copiedFileCount = 0;
-      for (const moduleId of selectedModules) {
-        const module = getModuleById(moduleId);
-        const copyReport = await copyDirectorySafely(
-          module.templatePath,
-          cwd
-        );
-        copiedFileCount += copyReport.copiedCount;
-        if (copyReport.skippedConflicts.length > 0) {
-          skippedConflictsByModule.push({
-            moduleId,
-            paths: copyReport.skippedConflicts
-          });
-        }
-      }
-      let chatSchemaStatus;
-      if (selectedModules.includes("chat")) {
-        chatSchemaStatus = await ensureChatSchemaInProject(cwd);
-      }
-      const envTargets = [".env", ".env.example", ".env.development"];
-      for (const moduleId of selectedModules) {
-        const module = getModuleById(moduleId);
-        const moduleEnv = moduleId === "email" && emailProvider ? getEmailProviderEnv(emailProvider) : module.env;
-        if (Object.keys(moduleEnv).length === 0) {
-          continue;
-        }
-        for (const envFile of envTargets) {
-          const envPath = path7.join(cwd, envFile);
-          if (await pathExists(envPath)) {
-            await mergeEnvFile(envPath, moduleEnv, {
-              header: `# --- module: ${module.id} ---`
-            });
-          }
-        }
-      }
-      const dependencyEntries = selectedModules.reduce((acc, moduleId) => {
-        const module = getModuleById(moduleId);
-        const emailDependencies = moduleId === "email" && emailProvider ? getEmailProviderDependencies(emailProvider) : {};
-        return {
-          ...acc,
-          ...emailDependencies,
-          ...module.dependencies ?? {}
-        };
-      }, {});
-      if (Object.keys(dependencyEntries).length > 0) {
-        await addDependencies(
-          path7.join(cwd, "package.json"),
-          dependencyEntries
-        );
-      }
       const state = await detectProjectState(cwd);
+      const modulesToInstall = selectedModules.filter(
+        (moduleId) => !state.modules.includes(moduleId)
+      );
+      if (modulesToInstall.length === 0) {
+        finishPrompt("Selected modules are already installed.");
+        return;
+      }
+      const applyResult = await applyModulesToProject({
+        projectDir: cwd,
+        moduleIds: rawModules.length > 0 ? rawModules : selectedModules,
+        emailProvider,
+        safeCopy: true
+      });
+      const skippedConflictsByModule = applyResult.copyReports.filter((item) => item.report.skippedConflicts.length > 0).map((item) => ({
+        moduleId: item.moduleId,
+        paths: item.report.skippedConflicts
+      }));
+      const copiedFileCount = applyResult.copyReports.reduce(
+        (total, item) => total + item.report.copiedCount,
+        0
+      );
       const namespaceSet = new Set(state.namespaces);
-      for (const moduleId of selectedModules) {
-        const moduleTemplateMessages = path7.join(
+      for (const moduleId of applyResult.selectedModules) {
+        const moduleTemplateMessages = path10.join(
           getModuleById(moduleId).templatePath,
           "messages/vi"
         );
@@ -1620,8 +1911,8 @@ function registerAddCommand(program2) {
           const namespace = file.name.replace(/\.json$/, "");
           namespaceSet.add(namespace);
           const templateData = JSON.parse(
-            await readFile6(
-              path7.join(moduleTemplateMessages, file.name),
+            await readFile8(
+              path10.join(moduleTemplateMessages, file.name),
               "utf8"
             )
           );
@@ -1629,29 +1920,21 @@ function registerAddCommand(program2) {
           await appendNamespace(cwd, namespace);
         }
       }
+      const mergedModules = [
+        .../* @__PURE__ */ new Set([...state.modules, ...applyResult.selectedModules])
+      ];
       await writeManifest(cwd, {
         ...state,
         namespaces: [...namespaceSet],
-        modules: [
-          ...new Set(
-            [...state.modules, ...selectedModules].map(
-              (moduleId) => moduleId === "resend" ? "email" : moduleId
-            )
-          )
-        ]
+        modules: mergedModules,
+        locales: mergedModules.includes("i18n") ? [.../* @__PURE__ */ new Set([...state.locales, "vi"])] : state.locales,
+        features: mergedModules.includes("example") ? [.../* @__PURE__ */ new Set([...state.features, "example"])] : state.features
       });
-      const mergedModules = [
-        ...new Set(
-          [...state.modules, ...selectedModules].map(
-            (moduleId) => moduleId === "resend" ? "email" : moduleId
-          )
-        )
-      ];
-      await mergeModuleSetupSections(cwd, selectedModules, mergedModules);
-      finishPrompt(`Added modules: ${selectedModules.join(", ")}`);
+      await mergeModuleDocs(cwd, modulesToInstall, mergedModules);
+      finishPrompt(`Added modules: ${modulesToInstall.join(", ")}`);
       log.detail("Copied files", String(copiedFileCount));
-      if (autoAddedModules.length > 0) {
-        log.detail("Auto-added", autoAddedModules.join(", "));
+      if (applyResult.autoAddedModules.length > 0) {
+        log.detail("Auto-added", applyResult.autoAddedModules.join(", "));
       }
       if (emailProvider) {
         log.detail("Email provider", emailProvider);
@@ -1670,11 +1953,14 @@ function registerAddCommand(program2) {
           log.detail(`Skipped (${conflict.moduleId})`, `${preview}${suffix}`);
         }
       }
-      if (chatSchemaStatus === "added") {
+      if (applyResult.chatSchemaStatus === "added") {
         log.info(
           "Optional chat schema block was appended to prisma/schema.prisma."
         );
       }
+      if (applyResult.exampleSchemaStatus === "added") {
+        log.info("Example model was appended to prisma/schema.prisma.");
+      }
       log.step(
         "Next: run your package manager install to apply new dependencies."
       );
@@ -1682,8 +1968,8 @@ function registerAddCommand(program2) {
   );
   add.command("language").description("Add locales and clone message files from Vietnamese").option("--locale <locale...>", "Preselect locales: en,ja,ko").option("--yes", "Skip prompts").action(async (options) => {
     const cwd = process.cwd();
-    const hasMessages = await pathExists(path7.join(cwd, "messages"));
-    const hasConfig = await pathExists(path7.join(cwd, "src/i18n/config.ts"));
+    const hasMessages = await pathExists(path10.join(cwd, "messages"));
+    const hasConfig = await pathExists(path10.join(cwd, "src/i18n/config.ts"));
     if (!hasMessages || !hasConfig) {
       log.error(
         "Run this command from a generated Next.js project with i18n scaffold."
@@ -1750,13 +2036,13 @@ function registerAddCommand(program2) {
   });
   add.command("auth-provider").description("Add social auth providers to existing Better Auth setup").option("--provider <provider...>", "Preselect providers: google,facebook").option("--yes", "Skip prompts").action(async (options) => {
     const cwd = process.cwd();
-    const authFilePath = path7.join(cwd, "src/lib/auth.ts");
-    const hasSrc = await pathExists(path7.join(cwd, "src"));
-    const hasPackageJson = await pathExists(path7.join(cwd, "package.json"));
+    const authFilePath = path10.join(cwd, "src/lib/auth/server.ts");
+    const hasSrc = await pathExists(path10.join(cwd, "src"));
+    const hasPackageJson = await pathExists(path10.join(cwd, "package.json"));
     const hasAuthFile = await pathExists(authFilePath);
     if (!hasSrc || !hasPackageJson || !hasAuthFile) {
       log.error(
-        "Run this command from a generated Next.js project with src/lib/auth.ts."
+        "Run this command from a generated Next.js project with src/lib/auth/server.ts."
       );
       process.exitCode = 1;
       return;
@@ -1791,13 +2077,13 @@ function registerAddCommand(program2) {
       finishPrompt("No auth providers selected.");
       return;
     }
-    const authContent = await readFile6(authFilePath, "utf8");
+    const authContent = await readFile8(authFilePath, "utf8");
     const existingProviders = readConfiguredProviders(authContent);
     const mergedProviders = [
       .../* @__PURE__ */ new Set([...existingProviders, ...selectedProviders])
     ];
     const nextAuthContent = patchAuthProviders(authContent, mergedProviders);
-    await writeFile6(authFilePath, nextAuthContent, "utf8");
+    await writeFile8(authFilePath, nextAuthContent, "utf8");
     const envEntries = {};
     if (mergedProviders.includes("google")) {
       envEntries.GOOGLE_CLIENT_ID = "";
@@ -1809,7 +2095,7 @@ function registerAddCommand(program2) {
     }
     const envTargets = [".env", ".env.example", ".env.development"];
     for (const envFile of envTargets) {
-      const envPath = path7.join(cwd, envFile);
+      const envPath = path10.join(cwd, envFile);
       if (await pathExists(envPath)) {
         await mergeEnvFile(envPath, envEntries, {
           header: "# --- auth providers ---"
@@ -1826,8 +2112,8 @@ function registerAddCommand(program2) {
 
 // src/commands/create.ts
 import { spawn as spawn2 } from "child_process";
-import { randomBytes } from "crypto";
-import path8 from "path";
+import path11 from "path";
+var CLI_VERSION = "0.7.0";
 async function runInstall(packageManager, cwd) {
   const installArgsMap = {
     npm: ["install"],
@@ -1858,18 +2144,6 @@ async function runInstall(packageManager, cwd) {
 function toProjectSlug(input) {
   return input.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
 }
-function normalizeModuleSelection2(moduleIds) {
-  const selected = [...new Set(moduleIds)];
-  const autoAdded = [];
-  if (selected.includes("chat") && !selected.includes("supabase-realtime")) {
-    selected.unshift("supabase-realtime");
-    autoAdded.push("supabase-realtime");
-  }
-  return {
-    selectedModules: [...new Set(selected)],
-    autoAddedModules: autoAdded
-  };
-}
 async function resolveProjectName() {
   while (true) {
     const projectName = await askText("What is your project name?", {
@@ -1883,7 +2157,7 @@ async function resolveProjectName() {
         }
       }
     });
-    const targetPath = path8.resolve(process.cwd(), projectName);
+    const targetPath = path11.resolve(process.cwd(), projectName);
     if (await pathExists(targetPath)) {
       log.error(`Target directory already exists: ${targetPath}`);
       continue;
@@ -1895,8 +2169,8 @@ function registerCreateCommand(program2) {
   program2.command("create").description("Create a new outsource-ready Next.js app").action(async () => {
     startPrompt("NexTCLI project creation");
     const projectName = await resolveProjectName();
-    const targetPath = path8.resolve(process.cwd(), projectName);
-    const projectDirectoryName = path8.basename(targetPath);
+    const targetPath = path11.resolve(process.cwd(), projectName);
+    const projectDirectoryName = path11.basename(targetPath);
     const projectSlug = toProjectSlug(projectDirectoryName);
     const packageManager = await askSelect(
       "Which package manager do you want to use?",
@@ -1921,9 +2195,8 @@ function registerCreateCommand(program2) {
       })),
       []
     );
-    const { selectedModules, autoAddedModules } = normalizeModuleSelection2(rawModules);
     let emailProvider;
-    if (selectedModules.includes("email")) {
+    if (rawModules.includes("email")) {
       emailProvider = await askSelect(
         "Select email provider:",
         [
@@ -1943,65 +2216,39 @@ function registerCreateCommand(program2) {
     }
     const shouldInstall = await askConfirm("Install dependencies now?", true);
     await copyDirectory(templatePaths.base, targetPath);
-    for (const moduleId of selectedModules) {
-      const moduleDefinition = getModuleById(moduleId);
-      await copyDirectory(moduleDefinition.templatePath, targetPath);
-    }
-    let chatSchemaStatus;
-    if (selectedModules.includes("chat")) {
-      chatSchemaStatus = await ensureChatSchemaInProject(targetPath);
-    }
-    const envTargets = [".env", ".env.example", ".env.development"];
-    for (const moduleId of selectedModules) {
-      const module = getModuleById(moduleId);
-      const moduleEnv = moduleId === "email" && emailProvider ? getEmailProviderEnv(emailProvider) : module.env;
-      if (Object.keys(moduleEnv).length === 0) {
-        continue;
-      }
-      for (const envFile of envTargets) {
-        const envPath = path8.join(targetPath, envFile);
-        if (await pathExists(envPath)) {
-          await mergeEnvFile(envPath, moduleEnv, {
-            header: `# --- module: ${module.id} ---`
-          });
-        }
-      }
-    }
-    const dependencyEntries = selectedModules.reduce(
-      (acc, moduleId) => {
-        const module = getModuleById(moduleId);
-        const emailDependencies = moduleId === "email" && emailProvider ? getEmailProviderDependencies(emailProvider) : {};
-        return {
-          ...acc,
-          ...emailDependencies,
-          ...module.dependencies ?? {}
-        };
-      },
-      {}
-    );
-    if (Object.keys(dependencyEntries).length > 0) {
-      await addDependencies(
-        path8.join(targetPath, "package.json"),
-        dependencyEntries
-      );
-    }
-    const betterAuthSecret = randomBytes(32).toString("base64url");
+    const applyResult = await applyModulesToProject({
+      projectDir: targetPath,
+      moduleIds: rawModules,
+      emailProvider
+    });
     await replaceTokensInDirectory(targetPath, {
       __PROJECT_NAME__: projectSlug,
-      __BETTER_AUTH_SECRET__: betterAuthSecret,
-      __NEXTCLI_VERSION__: "0.6.0"
+      __NEXTCLI_VERSION__: CLI_VERSION
     });
-    await mergeModuleSetupSections(
+    await mergeModuleDocs(
       targetPath,
-      selectedModules,
-      selectedModules
+      applyResult.selectedModules,
+      applyResult.selectedModules
     );
     const manifest = await readManifest(targetPath);
     if (manifest) {
+      const namespaces = [...manifest.namespaces];
+      if (applyResult.selectedModules.includes("i18n")) {
+        namespaces.push("common");
+      }
+      if (applyResult.selectedModules.includes("auth")) {
+        namespaces.push("auth");
+      }
+      if (applyResult.selectedModules.includes("example")) {
+        namespaces.push("example");
+      }
       await writeManifest(targetPath, {
         ...manifest,
-        cli: "0.6.0",
-        modules: selectedModules
+        cli: CLI_VERSION,
+        modules: applyResult.selectedModules,
+        namespaces: [...new Set(namespaces)],
+        locales: applyResult.selectedModules.includes("i18n") ? ["vi"] : manifest.locales,
+        features: applyResult.selectedModules.includes("example") ? ["example"] : manifest.features
       });
     }
     if (shouldInstall) {
@@ -2015,28 +2262,30 @@ function registerCreateCommand(program2) {
     }
     log.detail(
       "Modules",
-      selectedModules.length > 0 ? selectedModules.join(", ") : "none"
+      applyResult.selectedModules.length > 0 ? applyResult.selectedModules.join(", ") : "none"
     );
-    if (autoAddedModules.length > 0) {
-      log.detail("Auto-added", autoAddedModules.join(", "));
+    if (applyResult.autoAddedModules.length > 0) {
+      log.detail("Auto-added", applyResult.autoAddedModules.join(", "));
     }
     if (emailProvider) {
       log.detail("Email provider", emailProvider);
     }
-    if (chatSchemaStatus === "added") {
+    if (applyResult.chatSchemaStatus === "added") {
       log.info(
         "Optional chat schema block was appended to prisma/schema.prisma."
       );
     }
-    log.step(
-      `Next: cd ${projectName} && ${packageManager} run db:migrate && ${packageManager} run dev`
-    );
+    if (applyResult.exampleSchemaStatus === "added") {
+      log.info("Example model was appended to prisma/schema.prisma.");
+    }
+    const nextStep = applyResult.selectedModules.includes("database") ? `cd ${projectName} && ${packageManager} run db:migrate && ${packageManager} run dev` : `cd ${projectName} && ${packageManager} run dev`;
+    log.step(`Next: ${nextStep}`);
   });
 }
 
 // src/commands/migrate.ts
 import { spawn as spawn3 } from "child_process";
-import path9 from "path";
+import path12 from "path";
 function createDefaultMigrationName() {
   const now = /* @__PURE__ */ new Date();
   const y = now.getFullYear();
@@ -2048,16 +2297,16 @@ function createDefaultMigrationName() {
   return `auto_${y}${m}${d}${hh}${mm}${ss}`;
 }
 async function detectPackageManager(cwd) {
-  if (await pathExists(path9.join(cwd, "bun.lockb"))) {
+  if (await pathExists(path12.join(cwd, "bun.lockb"))) {
     return "bun";
   }
-  if (await pathExists(path9.join(cwd, "bun.lock"))) {
+  if (await pathExists(path12.join(cwd, "bun.lock"))) {
     return "bun";
   }
-  if (await pathExists(path9.join(cwd, "pnpm-lock.yaml"))) {
+  if (await pathExists(path12.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (await pathExists(path9.join(cwd, "yarn.lock"))) {
+  if (await pathExists(path12.join(cwd, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
@@ -2092,8 +2341,8 @@ async function runCommand2(command, args, cwd) {
 function registerMigrateCommand(program2) {
   program2.command("migrate").description("Run Prisma migration script in current project").option("--name <migration-name>", "Migration name (defaults to auto timestamp)").option("--skip-generate", "Pass --skip-generate to prisma migrate dev").action(async (options) => {
     const cwd = process.cwd();
-    const hasPackageJson = await pathExists(path9.join(cwd, "package.json"));
-    const hasPrismaSchema = await pathExists(path9.join(cwd, "prisma", "schema.prisma"));
+    const hasPackageJson = await pathExists(path12.join(cwd, "package.json"));
+    const hasPrismaSchema = await pathExists(path12.join(cwd, "prisma", "schema.prisma"));
     if (!hasPackageJson || !hasPrismaSchema) {
       log.error(
         "Run this command from a generated project root (requires package.json + prisma/schema.prisma)."
@@ -2245,7 +2494,7 @@ var NexTCLICommand = class _NexTCLICommand extends Command {
 
 // src/cli.ts
 var program = new NexTCLICommand();
-program.name("nextcli").description("Scaffold outsource-ready Next.js projects").version("0.6.0");
+program.name("nextcli").description("Scaffold outsource-ready Next.js projects").version("0.7.0");
 registerCreateCommand(program);
 registerAddCommand(program);
 registerMigrateCommand(program);