@thinhnguyencth1204/nextcli 0.2.1 → 0.3.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/commands/add.ts
-import path4 from "path";
+import path6 from "path";
 
 // src/core/fs.ts
 import {
@@ -157,7 +157,7 @@ async function addDependencies(packageJsonPath, dependencies) {
 }
 
 // src/commands/add.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 
 // src/core/templates.ts
 import path2 from "path";
@@ -501,6 +501,184 @@ 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.3.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/commands/add.ts
 function toKebabCase(input) {
   return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -654,6 +832,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 +1094,11 @@ export async function DELETE(
 `;
 }
 async function appendFeatureModelToPrismaSchema(cwd, modelPascal) {
-  const schemaPath = path4.join(cwd, "prisma", "schema.prisma");
+  const schemaPath = path6.join(cwd, "prisma", "schema.prisma");
   if (!await pathExists(schemaPath)) {
     return "skipped";
   }
-  const schemaContent = await readFile3(schemaPath, "utf8");
+  const schemaContent = await readFile5(schemaPath, "utf8");
   const modelRegex = new RegExp(`\\bmodel\\s+${modelPascal}\\b`);
   if (modelRegex.test(schemaContent)) {
     return "exists";
@@ -771,8 +1115,12 @@ model ${modelPascal} {
   updatedAt   DateTime @updatedAt
 }
 `;
-  await writeFile3(schemaPath, `${schemaContent.trimEnd()}${modelBlock}
-`, "utf8");
+  await writeFile5(
+    schemaPath,
+    `${schemaContent.trimEnd()}${modelBlock}
+`,
+    "utf8"
+  );
   return "added";
 }
 var authProviderStartMarker = "// AUTO_GENERATED_AUTH_PROVIDERS_START";
@@ -833,18 +1181,18 @@ async function upsertEnvValue(envFilePath, key, value) {
   if (!await pathExists(envFilePath)) {
     return;
   }
-  const content = await readFile3(envFilePath, "utf8");
+  const content = await readFile5(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 writeFile5(envFilePath, next, "utf8");
     }
     return;
   }
   const separator = content.endsWith("\n") || content.length === 0 ? "" : "\n";
-  await writeFile3(envFilePath, `${content}${separator}${entry}
+  await writeFile5(envFilePath, `${content}${separator}${entry}
 `, "utf8");
 }
 function registerAddCommand(program2) {
@@ -857,54 +1205,118 @@ function registerAddCommand(program2) {
       return;
     }
     const cwd = process.cwd();
-    const srcPath = path4.join(cwd, "src");
+    const srcPath = path6.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 = path6.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(path6.join(featureRoot, "api"));
+    await ensureDir(path6.join(featureRoot, "components"));
+    await writeFile5(
+      path6.join(featureRoot, "services.ts"),
       buildFeatureServicesContent(modelPascal, modelDelegate),
       "utf8"
     );
-    await writeFile3(
-      path4.join(featureRoot, "validations.ts"),
+    await writeFile5(
+      path6.join(featureRoot, "validations.ts"),
       buildFeatureValidationContent(modelPascal),
       "utf8"
     );
-    await writeFile3(
-      path4.join(featureRoot, "api", `use-${featureSlug}.ts`),
+    await writeFile5(
+      path6.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 writeFile5(
+      path6.join(featureRoot, "components", `${featureSlug}-table.tsx`),
+      buildFeatureTableContent(featureSlug, modelPascal),
+      "utf8"
+    );
+    await writeFile5(
+      path6.join(
+        featureRoot,
+        "components",
+        `create-${featureSlug}-dialog.tsx`
+      ),
+      buildFeatureDialogContent(featureSlug, modelPascal),
+      "utf8"
+    );
+    const routeFilePath = path6.join(
+      cwd,
+      "src/app/api/v1",
+      featureSlug,
+      "route.ts"
+    );
+    await ensureDir(path6.dirname(routeFilePath));
+    await writeFile5(
+      routeFilePath,
+      buildCollectionRouteContent(featureSlug, modelPascal),
+      "utf8"
+    );
+    const idRoutePath = path6.join(
+      cwd,
+      "src/app/api/v1",
+      featureSlug,
+      "[id]",
+      "route.ts"
+    );
+    await ensureDir(path6.dirname(idRoutePath));
+    await writeFile5(
+      idRoutePath,
+      buildItemRouteContent(featureSlug, modelPascal),
+      "utf8"
+    );
+    const featurePagePath = path6.join(
+      cwd,
+      "src/app/(dashboard)",
+      featureSlug,
+      "page.tsx"
+    );
+    await ensureDir(path6.dirname(featurePagePath));
+    await writeFile5(
+      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(path6.join(cwd, "src"));
+    const hasPackageJson = await pathExists(path6.join(cwd, "package.json"));
     if (!hasSrc || !hasPackageJson) {
       log.error("Run this command from your generated Next.js project root.");
       process.exitCode = 1;
@@ -951,46 +1363,85 @@ 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 = path6.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(
+          path6.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(
+        path6.join(cwd, "package.json"),
+        dependencyEntries
+      );
     }
+    const state = await detectProjectState(cwd);
+    const namespaceSet = new Set(state.namespaces);
+    for (const moduleId of selectedModules) {
+      const moduleTemplateMessages = path6.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 readFile5(
+            path6.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])]
+    });
     finishPrompt(`Added modules: ${selectedModules.join(", ")}`);
     log.detail("Copied files", String(copiedFileCount));
     if (autoAddedModules.length > 0) {
@@ -1011,18 +1462,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(path6.join(cwd, "messages"));
+    const hasConfig = await pathExists(path6.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;
+    }
+    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;
     }
-    log.step("Next: run your package manager install to apply new dependencies.");
+    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 = path6.join(cwd, "src/lib/auth.ts");
+    const hasSrc = await pathExists(path6.join(cwd, "src"));
+    const hasPackageJson = await pathExists(path6.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 +1564,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 +1581,13 @@ function registerAddCommand(program2) {
       finishPrompt("No auth providers selected.");
       return;
     }
-    const authContent = await readFile3(authFilePath, "utf8");
+    const authContent = await readFile5(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 writeFile5(authFilePath, nextAuthContent, "utf8");
     const envEntries = {};
     if (mergedProviders.includes("google")) {
       envEntries.GOOGLE_CLIENT_ID = "";
@@ -1062,19 +1597,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 = path6.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 +1615,7 @@ function registerAddCommand(program2) {
 // src/commands/create.ts
 import { spawn as spawn2 } from "child_process";
 import { randomBytes } from "crypto";
-import path5 from "path";
+import path7 from "path";
 async function runInstall(packageManager, cwd) {
   const installArgsMap = {
     npm: ["install"],
@@ -1138,7 +1671,7 @@ async function resolveProjectName() {
         }
       }
     });
-    const targetPath = path5.resolve(process.cwd(), projectName);
+    const targetPath = path7.resolve(process.cwd(), projectName);
     if (await pathExists(targetPath)) {
       log.error(`Target directory already exists: ${targetPath}`);
       continue;
@@ -1150,8 +1683,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 = path7.resolve(process.cwd(), projectName);
+    const projectDirectoryName = path7.basename(targetPath);
     const projectSlug = toProjectSlug(projectDirectoryName);
     const packageManager = await askSelect(
       "Which package manager do you want to use?",
@@ -1200,7 +1733,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 = path7.join(targetPath, envFile);
         if (await pathExists(envPath)) {
           await mergeEnvFile(envPath, moduleEnvEntries);
         }
@@ -1218,7 +1751,7 @@ function registerCreateCommand(program2) {
     );
     if (Object.keys(dependencyEntries).length > 0) {
       await addDependencies(
-        path5.join(targetPath, "package.json"),
+        path7.join(targetPath, "package.json"),
         dependencyEntries
       );
     }
@@ -1226,8 +1759,17 @@ 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.3.0"
     });
+    const manifest = await readManifest(targetPath);
+    if (manifest) {
+      await writeManifest(targetPath, {
+        ...manifest,
+        cli: "0.3.0",
+        modules: selectedModules
+      });
+    }
     if (shouldInstall) {
       log.step(`Installing dependencies with ${packageManager}...`);
       await runInstall(packageManager, targetPath);
@@ -1255,7 +1797,7 @@ function registerCreateCommand(program2) {
 
 // src/commands/migrate.ts
 import { spawn as spawn3 } from "child_process";
-import path6 from "path";
+import path8 from "path";
 function createDefaultMigrationName() {
   const now = /* @__PURE__ */ new Date();
   const y = now.getFullYear();
@@ -1267,16 +1809,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(path8.join(cwd, "bun.lockb"))) {
     return "bun";
   }
-  if (await pathExists(path6.join(cwd, "bun.lock"))) {
+  if (await pathExists(path8.join(cwd, "bun.lock"))) {
     return "bun";
   }
-  if (await pathExists(path6.join(cwd, "pnpm-lock.yaml"))) {
+  if (await pathExists(path8.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (await pathExists(path6.join(cwd, "yarn.lock"))) {
+  if (await pathExists(path8.join(cwd, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
@@ -1311,8 +1853,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(path8.join(cwd, "package.json"));
+    const hasPrismaSchema = await pathExists(path8.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 +2006,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.3.0");
 registerCreateCommand(program);
 registerAddCommand(program);
 registerMigrateCommand(program);