@thinhnguyencth1204/nextcli 0.2.1 → 0.4.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/commands/add.ts
-import path4 from "path";
+import path7 from "path";
 
 // src/core/fs.ts
 import {
@@ -14,6 +14,21 @@ import {
   writeFile
 } from "fs/promises";
 import path from "path";
+var TEMPLATE_COPY_SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".next",
+  ".git",
+  "dist",
+  "out",
+  ".turbo",
+  "coverage"
+]);
+function shouldSkipTemplateDir(dirName) {
+  return TEMPLATE_COPY_SKIP_DIRS.has(dirName);
+}
+function shouldSkipTemplatePath(filePath) {
+  return filePath.split(path.sep).some((segment) => shouldSkipTemplateDir(segment));
+}
 async function ensureDir(targetPath) {
   await mkdir(targetPath, { recursive: true });
 }
@@ -27,7 +42,10 @@ async function pathExists(targetPath) {
 }
 async function copyDirectory(source, destination) {
   await ensureDir(destination);
-  await cp(source, destination, { recursive: true });
+  await cp(source, destination, {
+    recursive: true,
+    filter: (src) => !shouldSkipTemplatePath(src)
+  });
 }
 async function copyDirectorySafely(source, destination) {
   const report = {
@@ -41,6 +59,9 @@ async function copyDirectorySafely(source, destination) {
       const sourcePath = path.join(currentSource, entry.name);
       const destinationPath = path.join(currentDestination, entry.name);
       if (entry.isDirectory()) {
+        if (shouldSkipTemplateDir(entry.name)) {
+          continue;
+        }
         await walk(sourcePath, destinationPath);
         continue;
       }
@@ -48,7 +69,9 @@ async function copyDirectorySafely(source, destination) {
         continue;
       }
       if (await pathExists(destinationPath)) {
-        report.skippedConflicts.push(path.relative(destination, destinationPath));
+        report.skippedConflicts.push(
+          path.relative(destination, destinationPath)
+        );
         continue;
       }
       await ensureDir(path.dirname(destinationPath));
@@ -90,7 +113,9 @@ async function replaceTokensInDirectory(directoryPath, replacements) {
   for (const entry of entries) {
     const fullPath = path.join(directoryPath, entry.name);
     if (entry.isDirectory()) {
-      await replaceTokensInDirectory(fullPath, replacements);
+      if (!shouldSkipTemplateDir(entry.name)) {
+        await replaceTokensInDirectory(fullPath, replacements);
+      }
       continue;
     }
     if (!entry.isFile() || !isTextFile(fullPath)) {
@@ -152,12 +177,16 @@ async function addDependencies(packageJsonPath, dependencies) {
     ...current,
     ...dependencies
   };
-  await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
-`, "utf8");
+  await writeFile(
+    packageJsonPath,
+    `${JSON.stringify(packageJson, null, 2)}
+`,
+    "utf8"
+  );
 }
 
 // src/commands/add.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
 
 // src/core/templates.ts
 import path2 from "path";
@@ -182,7 +211,12 @@ var optionalModules = [
     templatePath: templatePaths.chat,
     env: {
       NEXT_PUBLIC_ENABLE_CHAT: "true"
-    }
+    },
+    setupSection: `| Variable | Where to get |
+| -------- | ------------ |
+| \`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.`
   },
   {
     id: "supabase",
@@ -196,7 +230,12 @@ var optionalModules = [
     },
     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 Project API keys \u2192 \`anon\` \`public\` |
+| \`NEXT_PUBLIC_SUPABASE_STORAGE_BUCKET\` | Storage \u2192 create bucket \u2192 use bucket name (default scaffold: \`public\`) |`
   },
   {
     id: "supabase-realtime",
@@ -209,14 +248,16 @@ var optionalModules = [
     },
     dependencies: {
       "@supabase/supabase-js": "^2.44.2"
-    }
+    },
+    setupSection: `Uses same Supabase URL/anon key as \`supabase\` module. Enable Realtime on tables in Supabase Dashboard \u2192 Database \u2192 Replication.`
   },
   {
     id: "seo",
     label: "SEO pack",
     description: "Adds robots/sitemap and JsonLd helper files",
     templatePath: templatePaths.seo,
-    env: {}
+    env: {},
+    setupSection: `No extra env keys. Edit \`src/app/robots.ts\`, \`sitemap.ts\`, and JSON-LD helpers after add.`
   },
   {
     id: "resend",
@@ -231,7 +272,11 @@ var optionalModules = [
       resend: "^6.9.2",
       "@react-email/components": "^1.0.12",
       "react-email": "^4.0.0"
-    }
+    },
+    setupSection: `| Variable | Where to get |
+| -------- | ------------ |
+| \`RESEND_API_KEY\` | resend.com \u2192 API Keys \u2192 Create |
+| \`RESEND_FROM_EMAIL\` | resend.com \u2192 Domains \u2192 verify domain \u2192 use \`Name <you@domain.com>\` |`
   }
 ];
 function getModuleById(moduleId) {
@@ -501,6 +546,263 @@ async function ensureChatSchemaInProject(projectRoot) {
   return "added";
 }
 
+// src/core/i18n.ts
+import path5 from "path";
+import { readdir as readdir3, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+
+// src/core/manifest.ts
+import path4 from "path";
+import { readdir as readdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+var defaultManifest = {
+  cli: "0.4.0",
+  defaultLocale: "vi",
+  locales: ["vi"],
+  namespaces: ["common", "auth", "example"],
+  modules: [],
+  features: ["example"]
+};
+function getManifestPath(projectDir) {
+  return path4.join(projectDir, "nextcli.json");
+}
+async function readManifest(projectDir) {
+  const manifestPath = getManifestPath(projectDir);
+  if (!await pathExists(manifestPath)) {
+    return null;
+  }
+  const raw = await readFile3(manifestPath, "utf8");
+  return JSON.parse(raw);
+}
+async function writeManifest(projectDir, manifest) {
+  const manifestPath = getManifestPath(projectDir);
+  await writeFile3(
+    manifestPath,
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+}
+function parseConstArray(content, marker) {
+  const regex = marker === "locales" ? /nextcli:locales:start[\s\S]*?=\s*\[(.*?)\]\s*as const[\s\S]*?nextcli:locales:end/m : /nextcli:namespaces:start[\s\S]*?=\s*\[(.*?)\]\s*as const[\s\S]*?nextcli:namespaces:end/m;
+  const match = content.match(regex);
+  if (!match) {
+    return [];
+  }
+  return match[1].split(",").map((item) => item.trim().replaceAll('"', "").replaceAll("'", "")).filter(Boolean);
+}
+async function detectLocalesFromDisk(projectDir) {
+  const messagesDir = path4.join(projectDir, "messages");
+  if (!await pathExists(messagesDir)) {
+    return ["vi"];
+  }
+  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"];
+}
+async function detectNamespacesFromDisk(projectDir) {
+  const namespaceFile = path4.join(projectDir, "src/i18n/namespaces.ts");
+  if (!await pathExists(namespaceFile)) {
+    return [...defaultManifest.namespaces];
+  }
+  const content = await readFile3(namespaceFile, "utf8");
+  const namespaces = parseConstArray(content, "namespaces");
+  return namespaces.length > 0 ? namespaces : [...defaultManifest.namespaces];
+}
+async function reconcileManifest(projectDir) {
+  const localesFromDisk = await detectLocalesFromDisk(projectDir);
+  const namespacesFromDisk = await detectNamespacesFromDisk(projectDir);
+  const existing = await readManifest(projectDir);
+  const merged = {
+    ...existing ?? defaultManifest,
+    locales: [.../* @__PURE__ */ new Set([...existing?.locales ?? [], ...localesFromDisk])],
+    namespaces: [
+      .../* @__PURE__ */ new Set([...existing?.namespaces ?? [], ...namespacesFromDisk])
+    ]
+  };
+  merged.defaultLocale = merged.locales.includes(merged.defaultLocale) ? merged.defaultLocale : merged.locales[0] ?? "vi";
+  merged.modules = [...new Set(merged.modules)];
+  merged.features = [...new Set(merged.features)];
+  await writeManifest(projectDir, merged);
+  return merged;
+}
+
+// src/core/i18n.ts
+var localeStartMarker = "// nextcli:locales:start";
+var localeEndMarker = "// nextcli:locales:end";
+var namespaceStartMarker = "// nextcli:namespaces:start";
+var namespaceEndMarker = "// nextcli:namespaces:end";
+function formatArray(items) {
+  return items.map((item) => `"${item}"`).join(", ");
+}
+function patchBetweenMarkers(content, start, end, replacement) {
+  const regex = new RegExp(`(${start})([\\s\\S]*?)(${end})`, "m");
+  return content.replace(regex, `$1
+${replacement}
+$3`);
+}
+function deepCloneValue(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+async function detectProjectState(projectDir) {
+  return reconcileManifest(projectDir);
+}
+async function patchLocalesConfig(projectDir, locales) {
+  const configPath = path5.join(projectDir, "src/i18n/config.ts");
+  if (!await pathExists(configPath)) {
+    return;
+  }
+  const content = await readFile4(configPath, "utf8");
+  const next = patchBetweenMarkers(
+    content,
+    localeStartMarker,
+    localeEndMarker,
+    `export const locales = [${formatArray(locales)}] as const;`
+  );
+  await writeFile4(configPath, next, "utf8");
+}
+async function appendNamespace(projectDir, namespace) {
+  const namespacePath = path5.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 next = patchBetweenMarkers(
+    content,
+    namespaceStartMarker,
+    namespaceEndMarker,
+    `export const namespaces = [${formatArray(namespaces)}] as const;`
+  );
+  await writeFile4(namespacePath, next, "utf8");
+  await writeManifest(projectDir, {
+    ...currentState,
+    namespaces
+  });
+  return namespaces;
+}
+async function cloneLocaleMessages(projectDir, fromLocale, toLocale) {
+  const sourceDir = path5.join(projectDir, "messages", fromLocale);
+  const targetDir = path5.join(projectDir, "messages", toLocale);
+  if (!await pathExists(sourceDir)) {
+    return;
+  }
+  const entries = await readdir3(sourceDir, { withFileTypes: true });
+  if (!await pathExists(targetDir)) {
+    await ensureDir(targetDir);
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) {
+      continue;
+    }
+    const sourcePath = path5.join(sourceDir, entry.name);
+    const targetPath = path5.join(targetDir, entry.name);
+    const sourceContent = JSON.parse(
+      await readFile4(sourcePath, "utf8")
+    );
+    await writeFile4(
+      targetPath,
+      `${JSON.stringify(deepCloneValue(sourceContent), null, 2)}
+`,
+      "utf8"
+    );
+  }
+}
+async function writeNamespaceMessages(projectDir, namespace, viTemplate) {
+  const state = await detectProjectState(projectDir);
+  for (const locale of state.locales) {
+    const localeDir = path5.join(projectDir, "messages", locale);
+    if (!await pathExists(localeDir)) {
+      continue;
+    }
+    const filePath = path5.join(localeDir, `${namespace}.json`);
+    await writeFile4(
+      filePath,
+      `${JSON.stringify(deepCloneValue(viTemplate), null, 2)}
+`,
+      "utf8"
+    );
+  }
+}
+
+// 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
 function toKebabCase(input) {
   return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -654,6 +956,172 @@ export function useDelete${modelPascal}() {
 }
 `;
 }
+function buildFeatureTableContent(featureSlug, modelPascal) {
+  return `"use client";
+
+import { useMemo } from "react";
+import { useTranslations } from "next-intl";
+import { createColumnHelper, getCoreRowModel, getPaginationRowModel, useReactTable } from "@tanstack/react-table";
+import { DataTable } from "@/components/ui/data-table/data-table";
+import { use${modelPascal}s } from "@/features/${featureSlug}/api/use-${featureSlug}";
+
+type ${modelPascal}Item = {
+  id: string;
+  name: string;
+  description?: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+const columnHelper = createColumnHelper<${modelPascal}Item>();
+
+export function ${modelPascal}Table() {
+  const t = useTranslations("${featureSlug}");
+  const { data, isLoading } = use${modelPascal}s();
+
+  const columns = useMemo(
+    () => [
+      columnHelper.accessor("name", {
+        header: t("table.name"),
+      }),
+      columnHelper.accessor("description", {
+        header: t("table.description"),
+      }),
+    ],
+    [t],
+  );
+
+  const table = useReactTable({
+    data: Array.isArray(data) ? data : [],
+    columns,
+    getCoreRowModel: getCoreRowModel(),
+    getPaginationRowModel: getPaginationRowModel(),
+  });
+
+  if (isLoading) {
+    return <p>{t("table.loading")}</p>;
+  }
+
+  return <DataTable table={table} />;
+}
+`;
+}
+function buildFeatureDialogContent(featureSlug, modelPascal) {
+  return `"use client";
+
+import { useState, type FormEvent } from "react";
+import { useTranslations } from "next-intl";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle, DialogTrigger } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+
+export function Create${modelPascal}Dialog({
+  onCreate,
+}: {
+  onCreate: (payload: { name: string; description?: string }) => Promise<void>;
+}) {
+  const t = useTranslations("${featureSlug}");
+  const [open, setOpen] = useState(false);
+  const [name, setName] = useState("");
+  const [description, setDescription] = useState("");
+  const [submitting, setSubmitting] = useState(false);
+
+  const handleSubmit = async (event: FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    setSubmitting(true);
+    try {
+      await onCreate({ name, description: description || undefined });
+      setName("");
+      setDescription("");
+      setOpen(false);
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <Button>{t("dialog.open")}</Button>
+      </DialogTrigger>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>{t("dialog.title")}</DialogTitle>
+        </DialogHeader>
+        <form className="grid gap-4" onSubmit={handleSubmit}>
+          <div className="grid gap-2">
+            <Label htmlFor="name">{t("dialog.name")}</Label>
+            <Input id="name" value={name} onChange={(event) => setName(event.target.value)} required />
+          </div>
+          <div className="grid gap-2">
+            <Label htmlFor="description">{t("dialog.description")}</Label>
+            <Input
+              id="description"
+              value={description}
+              onChange={(event) => setDescription(event.target.value)}
+            />
+          </div>
+          <DialogFooter>
+            <Button type="submit" disabled={submitting}>
+              {submitting ? t("dialog.submitting") : t("dialog.submit")}
+            </Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  );
+}
+`;
+}
+function buildFeaturePageContent(featureSlug, modelPascal) {
+  return `"use client";
+
+import { useTranslations } from "next-intl";
+import { useCreate${modelPascal} } from "@/features/${featureSlug}/api/use-${featureSlug}";
+import { Create${modelPascal}Dialog } from "@/features/${featureSlug}/components/create-${featureSlug}-dialog";
+import { ${modelPascal}Table } from "@/features/${featureSlug}/components/${featureSlug}-table";
+
+export default function ${modelPascal}Page() {
+  const t = useTranslations("${featureSlug}");
+  const createMutation = useCreate${modelPascal}();
+
+  return (
+    <main className="space-y-4">
+      <div className="flex items-center justify-between">
+        <h1 className="text-2xl font-semibold">{t("page.title")}</h1>
+        <Create${modelPascal}Dialog
+          onCreate={async (payload) => {
+            await createMutation.mutateAsync(payload);
+          }}
+        />
+      </div>
+      <${modelPascal}Table />
+    </main>
+  );
+}
+`;
+}
+function buildFeatureMessages(featureName) {
+  return {
+    page: {
+      title: featureName
+    },
+    table: {
+      name: "T\xEAn",
+      description: "M\xF4 t\u1EA3",
+      loading: "\u0110ang t\u1EA3i d\u1EEF li\u1EC7u..."
+    },
+    dialog: {
+      open: "T\u1EA1o m\u1EDBi",
+      title: `T\u1EA1o ${featureName}`,
+      name: "T\xEAn",
+      description: "M\xF4 t\u1EA3",
+      submit: "L\u01B0u",
+      submitting: "\u0110ang l\u01B0u..."
+    }
+  };
+}
 function buildCollectionRouteContent(featureSlug, modelPascal) {
   return `import { fail, ok } from "@/lib/api-response";
 import {
@@ -750,11 +1218,11 @@ export async function DELETE(
 `;
 }
 async function appendFeatureModelToPrismaSchema(cwd, modelPascal) {
-  const schemaPath = path4.join(cwd, "prisma", "schema.prisma");
+  const schemaPath = path7.join(cwd, "prisma", "schema.prisma");
   if (!await pathExists(schemaPath)) {
     return "skipped";
   }
-  const schemaContent = await readFile3(schemaPath, "utf8");
+  const schemaContent = await readFile6(schemaPath, "utf8");
   const modelRegex = new RegExp(`\\bmodel\\s+${modelPascal}\\b`);
   if (modelRegex.test(schemaContent)) {
     return "exists";
@@ -771,8 +1239,12 @@ model ${modelPascal} {
   updatedAt   DateTime @updatedAt
 }
 `;
-  await writeFile3(schemaPath, `${schemaContent.trimEnd()}${modelBlock}
-`, "utf8");
+  await writeFile6(
+    schemaPath,
+    `${schemaContent.trimEnd()}${modelBlock}
+`,
+    "utf8"
+  );
   return "added";
 }
 var authProviderStartMarker = "// AUTO_GENERATED_AUTH_PROVIDERS_START";
@@ -833,18 +1305,18 @@ async function upsertEnvValue(envFilePath, key, value) {
   if (!await pathExists(envFilePath)) {
     return;
   }
-  const content = await readFile3(envFilePath, "utf8");
+  const content = await readFile6(envFilePath, "utf8");
   const entry = `${key}=${value}`;
   const pattern = new RegExp(`^${key}=.*$`, "m");
   if (pattern.test(content)) {
     const next = content.replace(pattern, entry);
     if (next !== content) {
-      await writeFile3(envFilePath, next, "utf8");
+      await writeFile6(envFilePath, next, "utf8");
     }
     return;
   }
   const separator = content.endsWith("\n") || content.length === 0 ? "" : "\n";
-  await writeFile3(envFilePath, `${content}${separator}${entry}
+  await writeFile6(envFilePath, `${content}${separator}${entry}
 `, "utf8");
 }
 function registerAddCommand(program2) {
@@ -857,54 +1329,118 @@ function registerAddCommand(program2) {
       return;
     }
     const cwd = process.cwd();
-    const srcPath = path4.join(cwd, "src");
+    const srcPath = path7.join(cwd, "src");
     if (!await pathExists(srcPath)) {
-      log.error("Run this command from your generated Next.js project root (missing ./src).");
+      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 = path4.join(cwd, "src/features", featureSlug);
+    const featureRoot = path7.join(cwd, "src/features", featureSlug);
     if (await pathExists(featureRoot)) {
       log.error(`Feature already exists: ${featureRoot}`);
       process.exitCode = 1;
       return;
     }
-    await ensureDir(path4.join(featureRoot, "api"));
-    await ensureDir(path4.join(featureRoot, "components"));
-    await writeFile3(
-      path4.join(featureRoot, "services.ts"),
+    await ensureDir(path7.join(featureRoot, "api"));
+    await ensureDir(path7.join(featureRoot, "components"));
+    await writeFile6(
+      path7.join(featureRoot, "services.ts"),
       buildFeatureServicesContent(modelPascal, modelDelegate),
       "utf8"
     );
-    await writeFile3(
-      path4.join(featureRoot, "validations.ts"),
+    await writeFile6(
+      path7.join(featureRoot, "validations.ts"),
       buildFeatureValidationContent(modelPascal),
       "utf8"
     );
-    await writeFile3(
-      path4.join(featureRoot, "api", `use-${featureSlug}.ts`),
+    await writeFile6(
+      path7.join(featureRoot, "api", `use-${featureSlug}.ts`),
       buildFeatureHooksContent(featureSlug, modelPascal),
       "utf8"
     );
-    const routeFilePath = path4.join(cwd, "src/app/api/v1", featureSlug, "route.ts");
-    await ensureDir(path4.dirname(routeFilePath));
-    await writeFile3(routeFilePath, buildCollectionRouteContent(featureSlug, modelPascal), "utf8");
-    const idRoutePath = path4.join(cwd, "src/app/api/v1", featureSlug, "[id]", "route.ts");
-    await ensureDir(path4.dirname(idRoutePath));
-    await writeFile3(idRoutePath, buildItemRouteContent(featureSlug, modelPascal), "utf8");
-    const schemaStatus = await appendFeatureModelToPrismaSchema(cwd, modelPascal);
+    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 = 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.");
+    log.warn(
+      "No migration was executed. Run your migration command manually when ready."
+    );
   });
   add.command("module").description("Add optional modules using interactive multi-select").option("--module <module...>", "Preselect module ids").option("--yes", "Skip prompts").action(async (options) => {
     const cwd = process.cwd();
-    const hasSrc = await pathExists(path4.join(cwd, "src"));
-    const hasPackageJson = await pathExists(path4.join(cwd, "package.json"));
+    const hasSrc = await pathExists(path7.join(cwd, "src"));
+    const hasPackageJson = await pathExists(path7.join(cwd, "package.json"));
     if (!hasSrc || !hasPackageJson) {
       log.error("Run this command from your generated Next.js project root.");
       process.exitCode = 1;
@@ -951,46 +1487,89 @@ function registerAddCommand(program2) {
     if (selectedModules.includes("chat")) {
       chatSchemaStatus = await ensureChatSchemaInProject(cwd);
     }
-    const envEntries = selectedModules.reduce((acc, moduleId) => {
-      const module = getModuleById(moduleId);
-      return {
-        ...acc,
-        ...module.env
-      };
-    }, {});
+    const envEntries = selectedModules.reduce(
+      (acc, moduleId) => {
+        const module = getModuleById(moduleId);
+        return {
+          ...acc,
+          ...module.env
+        };
+      },
+      {}
+    );
     if (Object.keys(envEntries).length > 0) {
-      const envTargets = [
-        ".env",
-        ".env.example",
-        ".env.development"
-      ];
+      const envTargets = [".env", ".env.example", ".env.development"];
       for (const envFile of envTargets) {
-        const envPath = path4.join(cwd, envFile);
+        const envPath = path7.join(cwd, envFile);
         if (await pathExists(envPath)) {
           await mergeEnvFile(envPath, envEntries);
         }
       }
     }
     if (selectedModules.includes("chat")) {
-      const envTargets = [
-        ".env",
-        ".env.example",
-        ".env.development"
-      ];
+      const envTargets = [".env", ".env.example", ".env.development"];
       for (const envFile of envTargets) {
-        await upsertEnvValue(path4.join(cwd, envFile), "NEXT_PUBLIC_ENABLE_CHAT", "true");
+        await upsertEnvValue(
+          path7.join(cwd, envFile),
+          "NEXT_PUBLIC_ENABLE_CHAT",
+          "true"
+        );
       }
     }
-    const dependencyEntries = selectedModules.reduce((acc, moduleId) => {
-      const module = getModuleById(moduleId);
-      return {
-        ...acc,
-        ...module.dependencies ?? {}
-      };
-    }, {});
+    const dependencyEntries = selectedModules.reduce(
+      (acc, moduleId) => {
+        const module = getModuleById(moduleId);
+        return {
+          ...acc,
+          ...module.dependencies ?? {}
+        };
+      },
+      {}
+    );
     if (Object.keys(dependencyEntries).length > 0) {
-      await addDependencies(path4.join(cwd, "package.json"), dependencyEntries);
+      await addDependencies(
+        path7.join(cwd, "package.json"),
+        dependencyEntries
+      );
     }
+    const state = await detectProjectState(cwd);
+    const namespaceSet = new Set(state.namespaces);
+    for (const moduleId of selectedModules) {
+      const moduleTemplateMessages = path7.join(
+        getModuleById(moduleId).templatePath,
+        "messages/vi"
+      );
+      if (!await pathExists(moduleTemplateMessages)) {
+        continue;
+      }
+      const files = await readdir4(moduleTemplateMessages, {
+        withFileTypes: true
+      });
+      for (const file of files) {
+        if (!file.isFile() || !file.name.endsWith(".json")) {
+          continue;
+        }
+        const namespace = file.name.replace(/\.json$/, "");
+        namespaceSet.add(namespace);
+        const templateData = JSON.parse(
+          await readFile6(
+            path7.join(moduleTemplateMessages, file.name),
+            "utf8"
+          )
+        );
+        await writeNamespaceMessages(cwd, namespace, templateData);
+        await appendNamespace(cwd, namespace);
+      }
+    }
+    await writeManifest(cwd, {
+      ...state,
+      namespaces: [...namespaceSet],
+      modules: [.../* @__PURE__ */ new Set([...state.modules, ...selectedModules])]
+    });
+    const mergedModules = [
+      .../* @__PURE__ */ new Set([...state.modules, ...selectedModules])
+    ];
+    await mergeModuleSetupSections(cwd, selectedModules, mergedModules);
     finishPrompt(`Added modules: ${selectedModules.join(", ")}`);
     log.detail("Copied files", String(copiedFileCount));
     if (autoAddedModules.length > 0) {
@@ -1011,18 +1590,92 @@ function registerAddCommand(program2) {
       }
     }
     if (chatSchemaStatus === "added") {
-      log.info("Optional chat schema block was appended to prisma/schema.prisma.");
+      log.info(
+        "Optional chat schema block was appended to prisma/schema.prisma."
+      );
+    }
+    log.step(
+      "Next: run your package manager install to apply new dependencies."
+    );
+  });
+  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"));
+    if (!hasMessages || !hasConfig) {
+      log.error(
+        "Run this command from a generated Next.js project with i18n scaffold."
+      );
+      process.exitCode = 1;
+      return;
     }
-    log.step("Next: run your package manager install to apply new dependencies.");
+    const state = await detectProjectState(cwd);
+    const supportedLocales = [
+      { id: "en", label: "English" },
+      { id: "ja", label: "Japanese" },
+      { id: "ko", label: "Korean" }
+    ];
+    const requested = options.locale ? options.locale.flatMap((value) => value.split(",")).map((value) => value.trim().toLowerCase()).filter(Boolean) : [];
+    const preselected = requested.filter(
+      (item) => supportedLocales.some((supported) => supported.id === item)
+    );
+    const available = supportedLocales.filter(
+      (locale) => !state.locales.includes(locale.id)
+    );
+    if (available.length === 0) {
+      log.info("All supported locales already exist.");
+      return;
+    }
+    startPrompt("NexTCLI i18n language setup");
+    const selected = preselected.length > 0 ? preselected : options.yes ? ["en"] : await askMultiSelect(
+      "Select locales to add:",
+      available.map((locale) => ({
+        value: locale.id,
+        label: locale.label,
+        hint: locale.id === "en" ? "Required baseline locale" : "Optional locale"
+      })),
+      available.some((locale) => locale.id === "en") ? ["en"] : []
+    );
+    const normalized = [
+      ...new Set(
+        selected.filter(
+          (value) => available.some((item) => item.id === value)
+        )
+      )
+    ];
+    if (!normalized.includes("en")) {
+      normalized.unshift("en");
+    }
+    if (normalized.length === 0) {
+      finishPrompt("No locales selected.");
+      return;
+    }
+    for (const locale of normalized) {
+      await cloneLocaleMessages(cwd, "vi", locale);
+    }
+    const mergedLocales = [
+      .../* @__PURE__ */ new Set([...state.locales, ...normalized])
+    ].sort();
+    await patchLocalesConfig(cwd, mergedLocales);
+    await writeManifest(cwd, {
+      ...state,
+      locales: mergedLocales
+    });
+    finishPrompt(`Added locales: ${normalized.join(", ")}`);
+    log.info(
+      "Locale files were cloned from Vietnamese values. Translate them when ready."
+    );
   });
   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 = path4.join(cwd, "src/lib/auth.ts");
-    const hasSrc = await pathExists(path4.join(cwd, "src"));
-    const hasPackageJson = await pathExists(path4.join(cwd, "package.json"));
+    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 hasAuthFile = await pathExists(authFilePath);
     if (!hasSrc || !hasPackageJson || !hasAuthFile) {
-      log.error("Run this command from a generated Next.js project with src/lib/auth.ts.");
+      log.error(
+        "Run this command from a generated Next.js project with src/lib/auth.ts."
+      );
       process.exitCode = 1;
       return;
     }
@@ -1039,8 +1692,16 @@ function registerAddCommand(program2) {
     const selectedProviders = requestedProviders.length > 0 ? [...new Set(requestedProviders)] : options.yes ? [] : await askMultiSelect(
       "Select social providers to enable:",
       [
-        { value: "google", label: "Google", hint: "Google OAuth login" },
-        { value: "facebook", label: "Facebook", hint: "Facebook OAuth login" }
+        {
+          value: "google",
+          label: "Google",
+          hint: "Google OAuth login"
+        },
+        {
+          value: "facebook",
+          label: "Facebook",
+          hint: "Facebook OAuth login"
+        }
       ],
       []
     );
@@ -1048,11 +1709,13 @@ function registerAddCommand(program2) {
       finishPrompt("No auth providers selected.");
       return;
     }
-    const authContent = await readFile3(authFilePath, "utf8");
+    const authContent = await readFile6(authFilePath, "utf8");
     const existingProviders = readConfiguredProviders(authContent);
-    const mergedProviders = [.../* @__PURE__ */ new Set([...existingProviders, ...selectedProviders])];
+    const mergedProviders = [
+      .../* @__PURE__ */ new Set([...existingProviders, ...selectedProviders])
+    ];
     const nextAuthContent = patchAuthProviders(authContent, mergedProviders);
-    await writeFile3(authFilePath, nextAuthContent, "utf8");
+    await writeFile6(authFilePath, nextAuthContent, "utf8");
     const envEntries = {};
     if (mergedProviders.includes("google")) {
       envEntries.GOOGLE_CLIENT_ID = "";
@@ -1062,19 +1725,17 @@ function registerAddCommand(program2) {
       envEntries.FACEBOOK_CLIENT_ID = "";
       envEntries.FACEBOOK_CLIENT_SECRET = "";
     }
-    const envTargets = [
-      ".env",
-      ".env.example",
-      ".env.development"
-    ];
+    const envTargets = [".env", ".env.example", ".env.development"];
     for (const envFile of envTargets) {
-      const envPath = path4.join(cwd, envFile);
+      const envPath = path7.join(cwd, envFile);
       if (await pathExists(envPath)) {
         await mergeEnvFile(envPath, envEntries);
       }
     }
     finishPrompt(`Enabled providers: ${mergedProviders.join(", ")}`);
-    await ensureBetterAuthGenerate(cwd, { nonInteractive: Boolean(options.yes) });
+    await ensureBetterAuthGenerate(cwd, {
+      nonInteractive: Boolean(options.yes)
+    });
     log.step("Next: set provider secrets in .env and restart dev server.");
   });
 }
@@ -1082,7 +1743,7 @@ function registerAddCommand(program2) {
 // src/commands/create.ts
 import { spawn as spawn2 } from "child_process";
 import { randomBytes } from "crypto";
-import path5 from "path";
+import path8 from "path";
 async function runInstall(packageManager, cwd) {
   const installArgsMap = {
     npm: ["install"],
@@ -1138,7 +1799,7 @@ async function resolveProjectName() {
         }
       }
     });
-    const targetPath = path5.resolve(process.cwd(), projectName);
+    const targetPath = path8.resolve(process.cwd(), projectName);
     if (await pathExists(targetPath)) {
       log.error(`Target directory already exists: ${targetPath}`);
       continue;
@@ -1150,8 +1811,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 = path5.resolve(process.cwd(), projectName);
-    const projectDirectoryName = path5.basename(targetPath);
+    const targetPath = path8.resolve(process.cwd(), projectName);
+    const projectDirectoryName = path8.basename(targetPath);
     const projectSlug = toProjectSlug(projectDirectoryName);
     const packageManager = await askSelect(
       "Which package manager do you want to use?",
@@ -1200,7 +1861,7 @@ function registerCreateCommand(program2) {
     if (Object.keys(moduleEnvEntries).length > 0) {
       const envTargets = [".env", ".env.example", ".env.development"];
       for (const envFile of envTargets) {
-        const envPath = path5.join(targetPath, envFile);
+        const envPath = path8.join(targetPath, envFile);
         if (await pathExists(envPath)) {
           await mergeEnvFile(envPath, moduleEnvEntries);
         }
@@ -1218,7 +1879,7 @@ function registerCreateCommand(program2) {
     );
     if (Object.keys(dependencyEntries).length > 0) {
       await addDependencies(
-        path5.join(targetPath, "package.json"),
+        path8.join(targetPath, "package.json"),
         dependencyEntries
       );
     }
@@ -1226,8 +1887,22 @@ function registerCreateCommand(program2) {
     await replaceTokensInDirectory(targetPath, {
       __PROJECT_NAME__: projectSlug,
       __ENABLE_CHAT__: selectedModules.includes("chat") ? "true" : "false",
-      __BETTER_AUTH_SECRET__: betterAuthSecret
+      __BETTER_AUTH_SECRET__: betterAuthSecret,
+      __NEXTCLI_VERSION__: "0.4.0"
     });
+    await mergeModuleSetupSections(
+      targetPath,
+      selectedModules,
+      selectedModules
+    );
+    const manifest = await readManifest(targetPath);
+    if (manifest) {
+      await writeManifest(targetPath, {
+        ...manifest,
+        cli: "0.4.0",
+        modules: selectedModules
+      });
+    }
     if (shouldInstall) {
       log.step(`Installing dependencies with ${packageManager}...`);
       await runInstall(packageManager, targetPath);
@@ -1249,13 +1924,15 @@ function registerCreateCommand(program2) {
         "Optional chat schema block was appended to prisma/schema.prisma."
       );
     }
-    log.step(`Next: cd ${projectName} && ${packageManager} run dev`);
+    log.step(
+      `Next: cd ${projectName} && ${packageManager} run db:migrate && ${packageManager} run dev`
+    );
   });
 }
 
 // src/commands/migrate.ts
 import { spawn as spawn3 } from "child_process";
-import path6 from "path";
+import path9 from "path";
 function createDefaultMigrationName() {
   const now = /* @__PURE__ */ new Date();
   const y = now.getFullYear();
@@ -1267,16 +1944,16 @@ function createDefaultMigrationName() {
   return `auto_${y}${m}${d}${hh}${mm}${ss}`;
 }
 async function detectPackageManager(cwd) {
-  if (await pathExists(path6.join(cwd, "bun.lockb"))) {
+  if (await pathExists(path9.join(cwd, "bun.lockb"))) {
     return "bun";
   }
-  if (await pathExists(path6.join(cwd, "bun.lock"))) {
+  if (await pathExists(path9.join(cwd, "bun.lock"))) {
     return "bun";
   }
-  if (await pathExists(path6.join(cwd, "pnpm-lock.yaml"))) {
+  if (await pathExists(path9.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (await pathExists(path6.join(cwd, "yarn.lock"))) {
+  if (await pathExists(path9.join(cwd, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
@@ -1311,8 +1988,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(path6.join(cwd, "package.json"));
-    const hasPrismaSchema = await pathExists(path6.join(cwd, "prisma", "schema.prisma"));
+    const hasPackageJson = await pathExists(path9.join(cwd, "package.json"));
+    const hasPrismaSchema = await pathExists(path9.join(cwd, "prisma", "schema.prisma"));
     if (!hasPackageJson || !hasPrismaSchema) {
       log.error(
         "Run this command from a generated project root (requires package.json + prisma/schema.prisma)."
@@ -1464,7 +2141,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.2.1");
+program.name("nextcli").description("Scaffold outsource-ready Next.js projects").version("0.4.0");
 registerCreateCommand(program);
 registerAddCommand(program);
 registerMigrateCommand(program);