create-next-pro-cli 0.1.26 → 0.1.27

package/dist/bin.bun.js

@@ -5,21 +5,35 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = import.meta.require;
 
-// node_modules/prompts/node_modules/kleur/index.js
+// node_modules/kleur/index.js
 var require_kleur = __commonJS((exports, module) => {
   var { FORCE_COLOR, NODE_DISABLE_COLORS, TERM } = process.env;
   var $ = {
@@ -243,7 +257,7 @@ var require_clear = __commonJS((exports, module) => {
         if (it)
           o = it;
         var i = 0;
-        var F = function F() {};
+        var F = function F2() {};
         return { s: F, n: function n() {
           if (i >= o.length)
             return { done: true };
@@ -2575,7 +2589,7 @@ var require_dist = __commonJS((exports, module) => {
         if (it)
           o = it;
         var i = 0;
-        var F = function F() {};
+        var F = function F2() {};
         return { s: F, n: function n() {
           if (i >= o.length)
             return { done: true };
@@ -2678,7 +2692,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return question2.format ? yield question2.format(answer2, answers) : answer2;
         });
-        return function getFormattedAnswer(_x, _x2) {
+        return function getFormattedAnswer2(_x, _x2) {
           return _ref.apply(this, arguments);
         };
       }();
@@ -4937,17 +4951,211 @@ var require_prompts3 = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-var import_prompts8 = __toESM(require_prompts3(), 1);
-import fs from "fs";
-import os from "os";
+import path8 from "path";
+
+// src/cli/onboarding.ts
 import path from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname, resolve } from "path";
+function configDirectory(context) {
+  return context.env.XDG_CONFIG_HOME ? path.join(context.env.XDG_CONFIG_HOME, "create-next-pro") : path.join(context.homeDir, ".config", "create-next-pro");
+}
+function configFile(context) {
+  return path.join(configDirectory(context), "config.json");
+}
+async function readConfig(context) {
+  try {
+    return JSON.parse(await context.fs.readText(configFile(context)));
+  } catch {
+    return null;
+  }
+}
+async function ensureLineInRc(context, target, line) {
+  try {
+    const current = context.fs.exists(target) ? await context.fs.readText(target) : "";
+    if (!current.includes(line))
+      await context.fs.appendText(target, `
+${line}
+`);
+  } catch {}
+}
+async function installCompletion(context, shell) {
+  const directory = configDirectory(context);
+  const source = path.join(context.packageRoot, shell === "zsh" ? "create-next-pro-completion.zsh" : "create-next-pro-completion.sh");
+  const target = path.join(directory, `completion.${shell === "zsh" ? "zsh" : "sh"}`);
+  await context.fs.mkdir(directory);
+  await context.fs.copyFile(source, target);
+  const rcFile = path.join(context.homeDir, shell === "zsh" ? ".zshrc" : ".bashrc");
+  await ensureLineInRc(context, rcFile, `source "${target}"`);
+}
+async function onboarding(context, version) {
+  context.terminal.log(`\uD83D\uDE80 Welcome to create-next-pro v${version}
+`);
+  const response = await context.prompt([
+    {
+      type: "select",
+      name: "shell",
+      message: "Which shell do you use?",
+      choices: [
+        { title: "zsh", value: "zsh" },
+        { title: "bash", value: "bash" }
+      ],
+      initial: context.env.SHELL?.includes("zsh") ? 0 : 1
+    },
+    {
+      type: "toggle",
+      name: "completion",
+      message: "Install autocompletion?",
+      initial: true,
+      active: "Yes",
+      inactive: "No"
+    }
+  ], { onCancel: () => false });
+  if (response.shell !== "bash" && response.shell !== "zsh") {
+    throw new Error("Configuration cancelled.");
+  }
+  const now = new Date().toISOString();
+  const config = {
+    version: 1,
+    shell: response.shell,
+    completionInstalled: Boolean(response.completion),
+    createdAt: now,
+    updatedAt: now
+  };
+  if (config.completionInstalled)
+    await installCompletion(context, config.shell);
+  await context.fs.mkdir(configDirectory(context));
+  await context.fs.writeText(configFile(context), JSON.stringify(config, null, 2));
+  context.terminal.log(`
+\u2705 Configuration saved.`);
+  context.terminal.log("you can now use the CLI ! ex : ");
+  context.terminal.log("  Without prompt (will change in future) :");
+  context.terminal.log("    create-next-pro my-next-project");
+  context.terminal.log("  With prompt :");
+  context.terminal.log("    create-next-pro");
+  context.terminal.log("For more information, visit: https://github.com/Rising-Corporation/create-next-pro-cli");
+  context.terminal.log("Happy coding!  \uD83C\uDF89");
+  return config;
+}
 
-// src/lib/addComponent.ts
-var import_prompts = __toESM(require_prompts3(), 1);
+// src/cli/completion.ts
+import { readdir as readdir2 } from "fs/promises";
+import path3 from "path";
+
+// src/core/page-catalog.ts
+import { readdir } from "fs/promises";
+import path2 from "path";
+function isRouteGroup(segment) {
+  return segment.startsWith("(") && segment.endsWith(")");
+}
+async function discoverPages(projectRoot) {
+  const appRoot = path2.join(projectRoot, "src", "app", "[locale]");
+  const candidates = [];
+  async function visit(directory, relative = []) {
+    let entries;
+    try {
+      entries = await readdir(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (entries.some((entry) => entry.isFile() && entry.name === "page.tsx")) {
+      const routeSegments = relative.filter((segment) => !isRouteGroup(segment));
+      if (routeSegments.length > 0 && !routeSegments.some((segment) => segment.startsWith("_") || segment.startsWith("["))) {
+        const logicalName = routeSegments.join(".");
+        candidates.push({
+          logicalName,
+          routeSegments,
+          routeDirectory: directory,
+          uiDirectory: path2.join(projectRoot, "src", "ui", ...routeSegments),
+          messageFile: path2.join(projectRoot, "messages", "{locale}", `${routeSegments[0]}.json`),
+          messageKey: routeSegments.length > 1 ? routeSegments.at(-1) : undefined
+        });
+      }
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        await visit(path2.join(directory, entry.name), [
+          ...relative,
+          entry.name
+        ]);
+      }
+    }
+  }
+  await visit(appRoot);
+  return candidates.sort((left, right) => left.logicalName.localeCompare(right.logicalName));
+}
+
+// src/cli/completion.ts
+var PUBLIC_COMMANDS = [
+  "addpage",
+  "addcomponent",
+  "addlib",
+  "addapi",
+  "addlanguage",
+  "addtext",
+  "rmpage",
+  "--help",
+  "--version",
+  "--reconfigure"
+];
+var OPTIONS = {
+  addpage: [
+    "--layout",
+    "--page",
+    "--loading",
+    "--not-found",
+    "--error",
+    "--global-error",
+    "--route",
+    "--template",
+    "--default"
+  ],
+  addcomponent: ["--page", "-P"]
+};
+async function directories(root) {
+  try {
+    return (await readdir2(root, { withFileTypes: true })).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_")).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+async function completionCandidates(command, context) {
+  if (!command)
+    return [...PUBLIC_COMMANDS];
+  if (command === "rmpage") {
+    return (await discoverPages(context.cwd)).map((candidate) => candidate.logicalName);
+  }
+  if (command === "addcomponent" || command === "addpage") {
+    return [
+      ...OPTIONS[command] ?? [],
+      ...await directories(path3.join(context.cwd, "src", "ui"))
+    ];
+  }
+  if (command === "addlanguage")
+    return ["de", "en", "es", "fr", "it", "ja", "pt"];
+  return OPTIONS[command] ?? [];
+}
+async function printCompletions(args, context) {
+  for (const candidate of await completionCandidates(args[1], context)) {
+    context.terminal.log(candidate);
+  }
+}
+
+// src/core/contracts.ts
+var success = () => ({ exitCode: 0 });
+
+class CliError extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+}
+
+// src/lib/addApi.ts
+var import_prompts2 = __toESM(require_prompts3(), 1);
 import { join as join2 } from "path";
-import { mkdir, readFile as readFile2, writeFile, readdir } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
 
 // src/lib/utils.ts
 import { readFile } from "fs/promises";
@@ -4956,8 +5164,12 @@ import { join } from "path";
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
-async function loadConfig() {
-  const configPath = join(process.cwd(), "cnp.config.json");
+function configuredAliasPrefix(config) {
+  const alias = config.importAlias ?? "@/*";
+  return alias.endsWith("/*") ? alias.slice(0, -2) : "@";
+}
+async function loadConfig(cwd = process.cwd()) {
+  const configPath = join(cwd, "cnp.config.json");
   if (!existsSync(configPath))
     return null;
   try {
@@ -4992,21 +5204,193 @@ function toFileName(key) {
   }
 }
 
+// src/runtime/node-context.ts
+var import_prompts = __toESM(require_prompts3(), 1);
+import { existsSync as existsSync2 } from "fs";
+import {
+  appendFile,
+  copyFile,
+  mkdir,
+  readFile as readFile2,
+  writeFile
+} from "fs/promises";
+import os from "os";
+import path4 from "path";
+import { fileURLToPath } from "url";
+function findPackageRoot(start) {
+  let current = start;
+  while (true) {
+    const packagePath = path4.join(current, "package.json");
+    if (existsSync2(packagePath))
+      return current;
+    const parent = path4.dirname(current);
+    if (parent === current) {
+      throw new Error(`Unable to locate package.json from ${start}`);
+    }
+    current = parent;
+  }
+}
+function resolvePackageRoot(metaUrl = import.meta.url) {
+  return findPackageRoot(path4.dirname(fileURLToPath(metaUrl)));
+}
+function createNodeContext(overrides = {}) {
+  return {
+    argv: process.argv.slice(2),
+    cwd: process.cwd(),
+    env: process.env,
+    homeDir: os.homedir(),
+    packageRoot: resolvePackageRoot(),
+    terminal: console,
+    prompt: import_prompts.default,
+    fs: {
+      exists: existsSync2,
+      readText: (target) => readFile2(target, "utf8"),
+      writeText: async (target, content) => {
+        await writeFile(target, content);
+      },
+      mkdir: async (target) => {
+        await mkdir(target, { recursive: true });
+      },
+      copyFile: async (source, target) => {
+        await copyFile(source, target);
+      },
+      appendText: async (target, content) => {
+        await appendFile(target, content);
+      }
+    },
+    ...overrides
+  };
+}
+
+// src/core/project-paths.ts
+import path5 from "path";
+import { lstat } from "fs/promises";
+var SAFE_SEGMENT = /^[A-Za-z][A-Za-z0-9_-]*$/;
+function hasControlCharacters(value) {
+  return [...value].some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code === 127;
+  });
+}
+function parseLogicalName(value, label = "name") {
+  if (!value || hasControlCharacters(value)) {
+    throw new CliError(`Invalid ${label}: a non-empty printable value is required.`);
+  }
+  if (path5.isAbsolute(value) || value.includes("/") || value.includes("\\")) {
+    throw new CliError(`Invalid ${label}: paths and separators are not allowed.`);
+  }
+  const segments = value.split(".");
+  if (segments.some((segment) => !SAFE_SEGMENT.test(segment))) {
+    throw new CliError(`Invalid ${label}: use dot-separated alphanumeric segments beginning with a letter.`);
+  }
+  return segments;
+}
+function validateProjectName(value) {
+  if (!value || hasControlCharacters(value) || path5.isAbsolute(value) || value === "." || value === ".." || value.includes("/") || value.includes("\\") || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value)) {
+    throw new CliError("Invalid project name: use letters, numbers, dots, dashes or underscores without path separators.");
+  }
+  return value;
+}
+function resolveInside(root, ...segments) {
+  const absoluteRoot = path5.resolve(root);
+  const target = path5.resolve(absoluteRoot, ...segments);
+  if (target !== absoluteRoot && !target.startsWith(`${absoluteRoot}${path5.sep}`)) {
+    throw new CliError(`Refusing to access a path outside the project: ${target}`);
+  }
+  return target;
+}
+async function assertSafeTarget(root, target) {
+  const safeTarget = resolveInside(root, path5.relative(root, target));
+  const relativeSegments = path5.relative(path5.resolve(root), safeTarget).split(path5.sep);
+  let current = path5.resolve(root);
+  for (const segment of relativeSegments) {
+    if (!segment)
+      continue;
+    current = path5.join(current, segment);
+    try {
+      if ((await lstat(current)).isSymbolicLink()) {
+        throw new CliError(`Symbolic links are forbidden in project paths: ${current}`);
+      }
+    } catch (error) {
+      if (error instanceof CliError)
+        throw error;
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+  return safeTarget;
+}
+function normalizeImportAlias(value) {
+  if (!/^[A-Za-z@~][A-Za-z0-9@~_-]*\/\*$/.test(value)) {
+    throw new CliError('Invalid import alias: expected a prefix followed by "/*" (for example "@/*" or "@core/*").');
+  }
+  return value;
+}
+
+// src/lib/addApi.ts
+async function addApi(args, cwd = process.cwd()) {
+  let apiName = args[1];
+  if (!apiName || apiName.startsWith("-")) {
+    const response = await import_prompts2.default.prompt({
+      type: "text",
+      name: "apiName",
+      message: "\uD83D\uDD0C API route name to add:",
+      validate: (name) => name ? true : "API route name is required"
+    });
+    apiName = response.apiName;
+  }
+  const apiSegments = parseLogicalName(apiName, "API route name");
+  const config = await loadConfig(cwd);
+  if (!config) {
+    console.error("\u274C Configuration file cnp.config.json not found. Run this command from the project root.");
+    return;
+  }
+  const apiDir = join2(cwd, "src", "app", "api", ...apiSegments);
+  await assertSafeTarget(cwd, apiDir);
+  if (!existsSync3(apiDir)) {
+    await mkdir2(apiDir, { recursive: true });
+  }
+  const templateDir = join2(resolvePackageRoot(import.meta.url), "templates", "Api");
+  const routeTemplate = join2(templateDir, "route.ts");
+  const routePath = join2(apiDir, "route.ts");
+  if (!existsSync3(routePath)) {
+    if (existsSync3(routeTemplate)) {
+      let content = await readFile3(routeTemplate, "utf-8");
+      content = content.replace(/template/g, apiName);
+      await writeFile2(routePath, content);
+    } else {
+      await writeFile2(routePath, `import { NextResponse } from "next/server";
+
+export async function GET() {
+  return NextResponse.json({ message: "Hello from ${apiName}" });
+}
+`);
+    }
+    console.log(`\uD83D\uDCC4 File created: ${routePath}`);
+  } else {
+    console.log(`\u2139\uFE0F File already exists: ${routePath}`);
+  }
+  console.log(`\u2705 API route "${apiName}" added.`);
+}
+
 // src/lib/addComponent.ts
-import { existsSync as existsSync2, statSync } from "fs";
-async function addComponent(args) {
+var import_prompts3 = __toESM(require_prompts3(), 1);
+import { join as join3 } from "path";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync4, statSync } from "fs";
+async function addComponent(args, cwd = process.cwd()) {
   let componentName = args[1];
   let pageScope = null;
-  let pageIndex = args.findIndex((arg) => arg === "-P" || arg === "--page");
+  const pageIndex = args.findIndex((arg) => arg === "-P" || arg === "--page");
   if (pageIndex !== -1 && args[pageIndex + 1]) {
     pageScope = args[pageIndex + 1];
   }
   let nestedPath = null;
   if (pageScope && pageScope.includes(".")) {
-    nestedPath = join2(...pageScope.split("."));
+    nestedPath = join3(...pageScope.split("."));
   }
   if (!componentName || componentName.startsWith("-")) {
-    const response = await import_prompts.default.prompt({
+    const response = await import_prompts3.default.prompt({
       type: "text",
       name: "componentName",
       message: "\uD83E\uDDE9 Component name to add:",
@@ -5014,18 +5398,21 @@ async function addComponent(args) {
     });
     componentName = response.componentName;
   }
-  const config = await loadConfig();
+  parseLogicalName(componentName, "component name");
+  if (pageScope)
+    parseLogicalName(pageScope, "page name");
+  const config = await loadConfig(cwd);
   if (!config) {
     console.error("\u274C Configuration file cnp.config.json not found. Run this command from the project root.");
     return;
   }
   const useI18n = !!config.useI18n;
   const componentNameUpper = capitalize(componentName);
-  const templatePath = join2(new URL("..", import.meta.url).pathname, "templates", "Component");
+  const templatePath = join3(resolvePackageRoot(import.meta.url), "templates", "Component");
   let messagesPath = null;
   if (useI18n) {
-    messagesPath = join2(process.cwd(), "messages");
-    if (!existsSync2(messagesPath)) {
+    messagesPath = join3(cwd, "messages");
+    if (!existsSync4(messagesPath)) {
       console.error("\u274C Messages directory missing. Ensure i18n was configured.");
       return;
     }
@@ -5034,56 +5421,65 @@ async function addComponent(args) {
   let translationKey;
   if (pageScope) {
     if (nestedPath) {
-      componentTargetPath = join2(process.cwd(), "src", "ui", nestedPath);
+      componentTargetPath = join3(cwd, "src", "ui", nestedPath);
       translationKey = pageScope;
     } else {
-      componentTargetPath = join2(process.cwd(), "src", "ui", pageScope);
+      componentTargetPath = join3(cwd, "src", "ui", pageScope);
       translationKey = pageScope;
     }
   } else {
-    componentTargetPath = join2(process.cwd(), "src", "ui", "_global");
+    componentTargetPath = join3(cwd, "src", "ui", "_global");
     translationKey = "_global_ui";
   }
-  if (!existsSync2(componentTargetPath)) {
-    await mkdir(componentTargetPath, { recursive: true });
+  await assertSafeTarget(cwd, componentTargetPath);
+  if (!existsSync4(componentTargetPath)) {
+    await mkdir3(componentTargetPath, { recursive: true });
   }
-  const componentFile = join2(componentTargetPath, `${componentNameUpper}.tsx`);
-  const templateComponentPath = join2(templatePath, "Component.tsx");
-  if (existsSync2(templateComponentPath)) {
-    let content = await readFile2(templateComponentPath, "utf-8");
+  const componentFile = join3(componentTargetPath, `${componentNameUpper}.tsx`);
+  const templateComponentPath = join3(templatePath, "Component.tsx");
+  if (existsSync4(templateComponentPath)) {
+    let content = await readFile4(templateComponentPath, "utf-8");
     content = content.replace(/Component/g, componentNameUpper).replace(/componentPage/g, translationKey);
-    await writeFile(componentFile, content);
+    await writeFile3(componentFile, content);
     console.log(`\uD83D\uDCC4 File created: ${componentFile}`);
   } else {
     console.error("\u274C Template Component.tsx introuvable :", templateComponentPath);
   }
   if (useI18n && messagesPath) {
-    const entries = await readdir(messagesPath, { withFileTypes: true });
+    const entries = await readdir3(messagesPath, { withFileTypes: true });
     const langDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
-    const jsonTemplate = join2(templatePath, "component.json");
-    if (!existsSync2(jsonTemplate)) {
+    const jsonTemplate = join3(templatePath, "component.json");
+    if (!existsSync4(jsonTemplate)) {
       console.error("\u274C Template component.json not found:", jsonTemplate);
       return;
     }
-    const jsonContent = await readFile2(jsonTemplate, "utf-8");
+    const jsonContent = await readFile4(jsonTemplate, "utf-8");
     const parsed = JSON.parse(jsonContent);
     for (const locale of langDirs) {
-      const localeDir = join2(messagesPath, locale);
-      if (!existsSync2(localeDir) || !statSync(localeDir).isDirectory())
+      const localeDir = join3(messagesPath, locale);
+      if (!existsSync4(localeDir) || !statSync(localeDir).isDirectory())
         continue;
       let jsonTarget;
       if (pageScope) {
-        jsonTarget = join2(messagesPath, locale, `${pageScope}.json`);
+        const [messageFile] = pageScope.split(".");
+        jsonTarget = join3(messagesPath, locale, `${messageFile}.json`);
       } else {
-        jsonTarget = join2(messagesPath, locale, `_global_ui.json`);
+        jsonTarget = join3(messagesPath, locale, `_global_ui.json`);
       }
       let current = {};
-      if (existsSync2(jsonTarget)) {
-        const jsonFile = await readFile2(jsonTarget, "utf-8");
+      if (existsSync4(jsonTarget)) {
+        const jsonFile = await readFile4(jsonTarget, "utf-8");
         current = JSON.parse(jsonFile);
       }
-      current[componentNameUpper] = parsed;
-      await writeFile(jsonTarget, JSON.stringify(current, null, 2));
+      if (pageScope?.includes(".")) {
+        const child = pageScope.split(".")[1];
+        const childMessages = current[child] && typeof current[child] === "object" ? current[child] : {};
+        childMessages[componentNameUpper] = parsed;
+        current[child] = childMessages;
+      } else {
+        current[componentNameUpper] = parsed;
+      }
+      await writeFile3(jsonTarget, JSON.stringify(current, null, 2));
       console.log(`\uD83D\uDCC4 File updated: ${jsonTarget}`);
     }
   } else {
@@ -5092,230 +5488,129 @@ async function addComponent(args) {
   console.log(`\u2705 Component "${componentNameUpper}" added ${pageScope ? `to page ${pageScope}` : "globally"}${useI18n ? " with localized messages" : ""}.`);
 }
 
-// src/lib/addPage.ts
-var import_prompts2 = __toESM(require_prompts3(), 1);
-import { join as join3 } from "path";
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2, readdir as readdir2 } from "fs/promises";
-import { existsSync as existsSync3, statSync as statSync2 } from "fs";
-async function addPage(args) {
-  let pageName = args[1];
-  if (!pageName || pageName.startsWith("-")) {
-    const response = await import_prompts2.default.prompt({
-      type: "text",
-      name: "pageName",
-      message: "\uD83D\uDCDD Page name to add:",
-      validate: (name) => name ? true : "Page name is required"
-    });
-    pageName = response.pageName;
-  }
-  let parentName = null;
-  let childName = null;
-  if (pageName.includes(".")) {
-    [parentName, childName] = pageName.split(".");
-  }
-  let shortFlags = args.find((arg) => /^-[A-Za-z]+$/.test(arg));
-  let longFlags = new Set(args.filter((a) => a.startsWith("--")));
-  const flags = new Set;
-  if (!shortFlags && Array.from(longFlags).length === 0) {
-    shortFlags = "-LPl";
-  }
-  if (shortFlags) {
-    for (const char of shortFlags.slice(1)) {
-      switch (char) {
-        case "L":
-          flags.add("layout");
-          break;
-        case "P":
-          flags.add("page");
-          break;
-        case "l":
-          flags.add("loading");
-          break;
-        case "n":
-          flags.add("not-found");
-          break;
-        case "e":
-          flags.add("error");
-          break;
-        case "g":
-          flags.add("global-error");
-          break;
-        case "r":
-          flags.add("route");
-          break;
-        case "t":
-          flags.add("template");
-          break;
-        case "d":
-          flags.add("default");
-          break;
-      }
+// src/lib/addLanguage.ts
+var import_prompts4 = __toESM(require_prompts3(), 1);
+import { join as join4 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { cp, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+function generateLocales() {
+  const dn = new Intl.DisplayNames(["en"], { type: "language" });
+  const locales = [];
+  for (let i = 0;i < 26; i++) {
+    for (let j = 0;j < 26; j++) {
+      const code = String.fromCharCode(97 + i) + String.fromCharCode(97 + j);
+      try {
+        const name = dn.of(code);
+        if (name && name.toLowerCase() !== code) {
+          locales.push(code);
+        }
+      } catch {}
     }
   }
-  for (const flag of [
-    "layout",
-    "page",
-    "loading",
-    "not-found",
-    "error",
-    "global-error",
-    "route",
-    "template",
-    "default"
-  ]) {
-    if (longFlags.has("--" + flag))
-      flags.add(flag);
-  }
-  const config = await loadConfig();
-  if (!config) {
-    console.error("\u274C Configuration file cnp.config.json not found. Run this command from the project root.");
+  return locales.sort();
+}
+async function addLanguage(args, cwd = process.cwd()) {
+  const config = await loadConfig(cwd);
+  if (!config?.useI18n) {
+    console.error("\u274C i18n is not enabled in this project.");
     return;
   }
-  const useI18n = !!config.useI18n;
-  const srcSegments = ["src", "app"];
-  if (useI18n)
-    srcSegments.push("[locale]");
-  const srcPath = join3(process.cwd(), ...srcSegments);
-  if (!existsSync3(srcPath)) {
-    console.error(`\u274C Expected directory not found: ${srcPath}`);
+  const messagesPath = join4(cwd, "messages");
+  if (!existsSync5(messagesPath)) {
+    console.error("\u274C Messages directory missing. Ensure i18n was configured.");
     return;
   }
-  let messagesPath = null;
-  let locales = [];
-  if (useI18n) {
-    messagesPath = join3(process.cwd(), "messages");
-    if (!existsSync3(messagesPath)) {
-      console.error("\u274C Messages directory missing. Ensure i18n was configured.");
-      return;
-    }
-    const entries = await readdir2(messagesPath, { withFileTypes: true });
-    locales = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  const available = generateLocales();
+  let locale = args[1];
+  if (!locale || !available.includes(locale)) {
+    const response = await import_prompts4.default({
+      type: "autocomplete",
+      name: "locale",
+      message: "\uD83C\uDF10 Locale to add:",
+      choices: available.map((l) => ({ title: l, value: l }))
+    });
+    locale = response.locale;
   }
-  const templatePath = join3(new URL("..", import.meta.url).pathname, "templates", "Page");
-  let uiPageDir, localePagePath, jsonFileName;
-  if (parentName && childName) {
-    uiPageDir = join3(process.cwd(), "src", "ui", parentName, childName);
-    localePagePath = join3(srcPath, parentName, childName);
-    jsonFileName = parentName;
-  } else {
-    uiPageDir = join3(process.cwd(), "src", "ui", pageName);
-    localePagePath = join3(srcPath, pageName);
-    jsonFileName = pageName;
+  if (!locale)
+    return;
+  parseLogicalName(locale, "locale");
+  await assertSafeTarget(cwd, messagesPath);
+  if (existsSync5(join4(messagesPath, locale))) {
+    throw new Error(`Locale ${locale} already exists.`);
   }
-  if (!existsSync3(uiPageDir)) {
-    await mkdir2(uiPageDir, { recursive: true });
+  const routingFile = join4(cwd, "src", "lib", "i18n", "routing.ts");
+  const messagesRegistryFile = join4(cwd, "src", "lib", "i18n", "messages.ts");
+  if (!existsSync5(routingFile)) {
+    throw new Error("routing.ts not found. Are you in project root?");
   }
-  const uiPageFile = join3(uiPageDir, "page-ui.tsx");
-  const uiPageTemplate = join3(templatePath, "page-ui.tsx");
-  if (existsSync3(uiPageTemplate)) {
-    let uiContent = await readFile3(uiPageTemplate, "utf-8");
-    uiContent = uiContent.replace(/template/g, childName || pageName).replace(/Template/g, capitalize(childName || pageName));
-    await writeFile2(uiPageFile, uiContent);
-    console.log(`\uD83D\uDCC4 File created: ${uiPageFile}`);
-  } else {
-    console.warn("\u26A0\uFE0F Missing template file: page-ui.tsx at path:", uiPageTemplate);
+  if (!existsSync5(messagesRegistryFile)) {
+    throw new Error("messages.ts not found. Are you in project root?");
   }
-  if (!existsSync3(localePagePath)) {
-    await mkdir2(localePagePath, { recursive: true });
+  const routingContent = await readFile5(routingFile, "utf-8");
+  const defaultMatch = routingContent.match(/defaultLocale:\s*"([^"]+)"/);
+  const defaultLocale = defaultMatch ? defaultMatch[1] : null;
+  if (!defaultLocale || !existsSync5(join4(messagesPath, defaultLocale))) {
+    throw new Error("Default locale not found.");
   }
-  for (const flag of flags) {
-    const filename = toFileName(flag);
-    const src = join3(templatePath, filename);
-    const dst = join3(localePagePath, filename);
-    if (!existsSync3(src)) {
-      console.warn(`\u26A0\uFE0F Missing template file: ${filename} at path: ${src}`);
-      continue;
-    }
-    const content = await readFile3(src, "utf-8");
-    const replaced = content.replace(/template/g, childName || pageName).replace(/Template/g, capitalize(childName || pageName));
-    await writeFile2(dst, replaced);
-    console.log(`\uD83D\uDCC4 File created: ${dst}`);
+  const defaultAggregatorFile = join4(messagesPath, `${defaultLocale}.ts`);
+  if (!existsSync5(defaultAggregatorFile)) {
+    throw new Error(`Default locale aggregator not found: ${defaultLocale}.ts`);
   }
-  if (useI18n && messagesPath) {
-    const jsonTemplate = join3(templatePath, "page.json");
-    if (!existsSync3(jsonTemplate)) {
-      console.warn("\u26A0\uFE0F Missing template: page.json at path:", jsonTemplate);
-    } else {
-      const content = await readFile3(jsonTemplate, "utf-8");
-      const replaced = content.replace(/template/g, childName || pageName).replace(/Template/g, capitalize(childName || pageName));
-      for (const locale of locales) {
-        const localeDir = join3(messagesPath, locale);
-        if (!existsSync3(localeDir) || !statSync2(localeDir).isDirectory())
-          continue;
-        const jsonTarget = join3(messagesPath, locale, `${jsonFileName}.json`);
-        let current = {};
-        if (existsSync3(jsonTarget)) {
-          const jsonFile = await readFile3(jsonTarget, "utf-8");
-          try {
-            current = JSON.parse(jsonFile);
-          } catch {
-            current = {};
-          }
-        }
-        if (parentName && childName) {
-          current[childName] = JSON.parse(replaced);
-        } else {
-          current = JSON.parse(replaced);
-        }
-        await writeFile2(jsonTarget, JSON.stringify(current, null, 2));
-        console.log(`\uD83D\uDCC4 File created: ${jsonTarget}`);
-      }
-    }
-  } else {
-    console.log("\u2139\uFE0F Skipping translation templates; next-intl not enabled.");
-  }
-  console.log(`\u2705 Page "${pageName}" with templates added${useI18n ? " for each locale" : ""}.`);
-}
+  const localesMatch = routingContent.match(/locales:\s*\[([^\]]*)\]/);
+  if (!localesMatch) {
+    throw new Error("Unable to locate routing locales.");
+  }
+  const localesArr = localesMatch[1].split(",").map((s) => s.trim().replace(/["']/g, "")).filter(Boolean);
+  if (localesArr.includes(locale)) {
+    throw new Error(`Locale ${locale} already exists in routing.`);
+  }
+  const newLocales = `locales: [${[...localesArr, locale].map((item) => `"${item}"`).join(", ")}]`;
+  const nextRoutingContent = routingContent.replace(/locales:\s*\[[^\]]*\]/, newLocales);
+  const defaultAggregatorContent = await readFile5(defaultAggregatorFile, "utf-8");
+  const defaultImportPrefix = `./${defaultLocale}/`;
+  if (!defaultAggregatorContent.includes(defaultImportPrefix)) {
+    throw new Error(`Default locale aggregator does not import from ${defaultImportPrefix}`);
+  }
+  const nextAggregatorContent = defaultAggregatorContent.replaceAll(defaultImportPrefix, `./${locale}/`);
+  const messagesRegistryContent = await readFile5(messagesRegistryFile, "utf-8");
+  const registryMatch = messagesRegistryContent.match(/const messages = \{([^}]*)\} as const;/);
+  if (!registryMatch) {
+    throw new Error("Unable to locate the typed messages registry.");
+  }
+  const registeredLocales = registryMatch[1].split(",").map((item) => item.trim()).filter(Boolean);
+  if (registeredLocales.includes(locale)) {
+    throw new Error(`Locale ${locale} already exists in messages registry.`);
+  }
+  const registryDeclaration = `const messages = { ${[
+    ...registeredLocales,
+    locale
+  ].join(", ")} } as const;`;
+  const declarationIndex = messagesRegistryContent.indexOf("const messages =");
+  const nextMessagesRegistryContent = messagesRegistryContent.slice(0, declarationIndex) + `import ${locale} from "../../../messages/${locale}";
 
-// src/lib/rmPage.ts
-var import_prompts3 = __toESM(require_prompts3(), 1);
-import { join as join4 } from "path";
-import { writeFile as writeFile3, readdir as readdir3 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-async function rmPage(args) {
-  let pageName = args[1];
-  if (!pageName || pageName.startsWith("-")) {
-    const response = await import_prompts3.default.prompt({
-      type: "text",
-      name: "pageName",
-      message: "\uD83D\uDDD1\uFE0F Page name to remove:",
-      validate: (name) => name ? true : "Page name is required"
-    });
-    pageName = response.pageName;
-  }
-  const messagesPath = join4(process.cwd(), "messages");
-  const entries = await readdir3(messagesPath, { withFileTypes: true });
-  const langDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
-  for (const locale of langDirs) {
-    const jsonTarget = join4(messagesPath, locale, `${pageName}.json`);
-    if (existsSync4(jsonTarget)) {
-      await writeFile3(jsonTarget, "");
-      await import("child_process").then((cp) => cp.execSync(`rm -f '${jsonTarget}'`));
-      console.log(`\uD83D\uDDD1\uFE0F Deleted: ${jsonTarget}`);
-    }
-  }
-  const uiPageDir = join4(process.cwd(), "src", "ui", pageName);
-  if (existsSync4(uiPageDir)) {
-    await import("child_process").then((cp) => cp.execSync(`rm -rf '${uiPageDir}'`));
-    console.log(`\uD83D\uDDD1\uFE0F Deleted: ${uiPageDir}`);
-  }
-  const appLocaleDir = join4(process.cwd(), "src", "app", "[locale]", pageName);
-  if (existsSync4(appLocaleDir)) {
-    await import("child_process").then((cp) => cp.execSync(`rm -rf '${appLocaleDir}'`));
-    console.log(`\uD83D\uDDD1\uFE0F Deleted: ${appLocaleDir}`);
-  }
-  console.log(`\u2705 Page "${pageName}" deleted.`);
+` + messagesRegistryContent.slice(declarationIndex).replace(/const messages = \{[^}]*\} as const;/, registryDeclaration);
+  await cp(join4(messagesPath, defaultLocale), join4(messagesPath, locale), {
+    recursive: true
+  });
+  console.log(`\uD83D\uDCC4 Directory created: ${join4(messagesPath, locale)}`);
+  await writeFile4(join4(messagesPath, `${locale}.ts`), nextAggregatorContent);
+  console.log(`\uD83D\uDCC4 File created: ${join4(messagesPath, `${locale}.ts`)}`);
+  await writeFile4(messagesRegistryFile, nextMessagesRegistryContent);
+  console.log(`\uD83D\uDCC4 File updated: ${messagesRegistryFile}`);
+  await writeFile4(routingFile, nextRoutingContent);
+  console.log(`\uD83D\uDCC4 File updated: ${routingFile}`);
+  console.log(`\u2705 Locale "${locale}" added and copied from default locale "${defaultLocale}".`);
 }
 
 // src/lib/addLib.ts
-var import_prompts4 = __toESM(require_prompts3(), 1);
+var import_prompts5 = __toESM(require_prompts3(), 1);
 import { join as join5 } from "path";
-import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-async function addLib(args) {
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+async function addLib(args, cwd = process.cwd()) {
   let libArg = args[1];
   if (!libArg || libArg.startsWith("-")) {
-    const response = await import_prompts4.default.prompt({
+    const response = await import_prompts5.default.prompt({
       type: "text",
       name: "libArg",
       message: "\uD83D\uDCE6 Lib name to add:",
@@ -5323,50 +5618,54 @@ async function addLib(args) {
     });
     libArg = response.libArg;
   }
+  const libSegments = parseLogicalName(libArg, "library name");
   let libName = libArg;
   let fileName = null;
-  if (libArg.includes(".")) {
-    [libName, fileName] = libArg.split(".");
+  if (libSegments.length === 2) {
+    [libName, fileName] = libSegments;
+  } else if (libSegments.length > 2) {
+    throw new Error("Libraries currently support exactly library.module.");
   }
-  const config = await loadConfig();
+  const config = await loadConfig(cwd);
   if (!config) {
     console.error("\u274C Configuration file cnp.config.json not found. Run this command from the project root.");
     return;
   }
-  const libDir = join5(process.cwd(), "src", "lib", libName);
-  if (!existsSync5(libDir)) {
-    await mkdir3(libDir, { recursive: true });
+  const libDir = join5(cwd, "src", "lib", libName);
+  await assertSafeTarget(cwd, libDir);
+  if (!existsSync6(libDir)) {
+    await mkdir4(libDir, { recursive: true });
   }
-  const templateDir = join5(new URL("..", import.meta.url).pathname, "templates", "Lib");
+  const templateDir = join5(resolvePackageRoot(import.meta.url), "templates", "Lib");
   const indexTemplate = join5(templateDir, "index.ts");
   const fileTemplate = join5(templateDir, "item.ts");
   const indexPath = join5(libDir, "index.ts");
-  if (!existsSync5(indexPath)) {
-    if (existsSync5(indexTemplate)) {
-      const content = await readFile4(indexTemplate, "utf-8");
-      await writeFile4(indexPath, content);
+  if (!existsSync6(indexPath)) {
+    if (existsSync6(indexTemplate)) {
+      const content = await readFile6(indexTemplate, "utf-8");
+      await writeFile5(indexPath, content);
     } else {
-      await writeFile4(indexPath, `export {}
+      await writeFile5(indexPath, `export {}
 `);
     }
     console.log(`\uD83D\uDCC4 File created: ${indexPath}`);
   }
   if (fileName) {
     const filePath = join5(libDir, `${fileName}.ts`);
-    if (!existsSync5(filePath)) {
-      if (existsSync5(fileTemplate)) {
-        let content = await readFile4(fileTemplate, "utf-8");
+    if (!existsSync6(filePath)) {
+      if (existsSync6(fileTemplate)) {
+        let content = await readFile6(fileTemplate, "utf-8");
         content = content.replace(/template/g, fileName).replace(/Template/g, capitalize(fileName));
-        await writeFile4(filePath, content);
+        await writeFile5(filePath, content);
       } else {
-        await writeFile4(filePath, `export function ${fileName}() {
+        await writeFile5(filePath, `export function ${fileName}() {
   // TODO: implement
 }
 `);
       }
       console.log(`\uD83D\uDCC4 File created: ${filePath}`);
     }
-    let indexContent = await readFile4(indexPath, "utf-8");
+    let indexContent = await readFile6(indexPath, "utf-8");
     const importLine = `import { ${fileName} } from "./${fileName}";`;
     const importRegex = new RegExp(`import\\s*{\\s*${fileName}\\s*}\\s*from\\s*"\\./${fileName}";`);
     const exportRegex = /export\s*{([^}]*)}/m;
@@ -5394,65 +5693,382 @@ async function addLib(args) {
 
 export { ` + exportsSet.join(", ") + ` };
 `;
-    await writeFile4(indexPath, indexContent);
+    await writeFile5(indexPath, indexContent);
     console.log(`\u270F\uFE0F Updated index: ${indexPath}`);
   }
   console.log(`\u2705 Lib "${libName}"${fileName ? ` with module ${fileName}` : ""} added.`);
 }
 
-// src/lib/addApi.ts
-var import_prompts5 = __toESM(require_prompts3(), 1);
+// src/lib/addPage.ts
+var import_prompts6 = __toESM(require_prompts3(), 1);
 import { join as join6 } from "path";
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-async function addApi(args) {
-  let apiName = args[1];
-  if (!apiName || apiName.startsWith("-")) {
-    const response = await import_prompts5.default.prompt({
+import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile6, readdir as readdir4 } from "fs/promises";
+import { existsSync as existsSync7, statSync as statSync2 } from "fs";
+function registerMessagesFile(content, locale, fileName) {
+  const importPath = `./${locale}/${fileName}.json`;
+  if (content.includes(importPath))
+    return content;
+  const declarationIndex = content.indexOf("const messages =");
+  const registryMatch = content.match(/const messages = \{([\s\S]*?)\n\};/);
+  if (declarationIndex === -1 || !registryMatch) {
+    throw new Error(`Unable to register ${fileName}.json in messages/${locale}.ts`);
+  }
+  const importStatement = `import ${fileName} from "${importPath}";
+`;
+  const nextRegistry = registryMatch[0].replace(/\n\};$/, `
+  ${fileName},
+};`);
+  return content.slice(0, declarationIndex) + importStatement + content.slice(declarationIndex).replace(registryMatch[0], nextRegistry);
+}
+async function addPage(args, cwd = process.cwd()) {
+  let pageName = args[1];
+  if (!pageName || pageName.startsWith("-")) {
+    const response = await import_prompts6.default.prompt({
       type: "text",
-      name: "apiName",
-      message: "\uD83D\uDD0C API route name to add:",
-      validate: (name) => name ? true : "API route name is required"
+      name: "pageName",
+      message: "\uD83D\uDCDD Page name to add:",
+      validate: (name) => name ? true : "Page name is required"
     });
-    apiName = response.apiName;
+    pageName = response.pageName;
+  }
+  const pageSegments = parseLogicalName(pageName, "page name");
+  let parentName = null;
+  let childName = null;
+  if (pageSegments.length === 2) {
+    [parentName, childName] = pageSegments;
+  } else if (pageSegments.length > 2) {
+    throw new Error("Nested pages currently support exactly Parent.Child.");
+  }
+  let shortFlags = args.find((arg) => /^-[A-Za-z]+$/.test(arg));
+  const longFlags = new Set(args.filter((a) => a.startsWith("--")));
+  const flags = new Set;
+  if (!shortFlags && Array.from(longFlags).length === 0) {
+    shortFlags = "-LPl";
   }
-  const config = await loadConfig();
+  if (shortFlags) {
+    for (const char of shortFlags.slice(1)) {
+      switch (char) {
+        case "L":
+          flags.add("layout");
+          break;
+        case "P":
+          flags.add("page");
+          break;
+        case "l":
+          flags.add("loading");
+          break;
+        case "n":
+          flags.add("not-found");
+          break;
+        case "e":
+          flags.add("error");
+          break;
+        case "g":
+          flags.add("global-error");
+          break;
+        case "r":
+          flags.add("route");
+          break;
+        case "t":
+          flags.add("template");
+          break;
+        case "d":
+          flags.add("default");
+          break;
+      }
+    }
+  }
+  for (const flag of [
+    "layout",
+    "page",
+    "loading",
+    "not-found",
+    "error",
+    "global-error",
+    "route",
+    "template",
+    "default"
+  ]) {
+    if (longFlags.has("--" + flag))
+      flags.add(flag);
+  }
+  const config = await loadConfig(cwd);
   if (!config) {
     console.error("\u274C Configuration file cnp.config.json not found. Run this command from the project root.");
     return;
   }
-  const apiDir = join6(process.cwd(), "src", "app", "api", apiName);
-  if (!existsSync6(apiDir)) {
-    await mkdir4(apiDir, { recursive: true });
+  const useI18n = !!config.useI18n;
+  const aliasPrefix = configuredAliasPrefix(config);
+  const srcSegments = ["src", "app"];
+  if (useI18n)
+    srcSegments.push("[locale]");
+  const srcPath = join6(cwd, ...srcSegments);
+  if (!existsSync7(srcPath)) {
+    console.error(`\u274C Expected directory not found: ${srcPath}`);
+    return;
+  }
+  let messagesPath = null;
+  let locales = [];
+  if (useI18n) {
+    messagesPath = join6(cwd, "messages");
+    if (!existsSync7(messagesPath)) {
+      console.error("\u274C Messages directory missing. Ensure i18n was configured.");
+      return;
+    }
+    const entries = await readdir4(messagesPath, { withFileTypes: true });
+    locales = entries.filter((e) => e.isDirectory()).map((e) => e.name);
   }
-  const templateDir = join6(new URL("..", import.meta.url).pathname, "templates", "Api");
-  const routeTemplate = join6(templateDir, "route.ts");
-  const routePath = join6(apiDir, "route.ts");
-  if (!existsSync6(routePath)) {
-    if (existsSync6(routeTemplate)) {
-      let content = await readFile5(routeTemplate, "utf-8");
-      content = content.replace(/template/g, apiName);
-      await writeFile5(routePath, content);
+  const templatePath = join6(resolvePackageRoot(import.meta.url), "templates", "Page");
+  let uiPageDir, localePagePath, jsonFileName;
+  if (parentName && childName) {
+    uiPageDir = join6(cwd, "src", "ui", parentName, childName);
+    localePagePath = join6(srcPath, parentName, childName);
+    jsonFileName = parentName;
+  } else {
+    uiPageDir = join6(cwd, "src", "ui", pageName);
+    localePagePath = join6(srcPath, pageName);
+    jsonFileName = pageName;
+  }
+  await assertSafeTarget(cwd, uiPageDir);
+  await assertSafeTarget(cwd, localePagePath);
+  if (!existsSync7(uiPageDir)) {
+    await mkdir5(uiPageDir, { recursive: true });
+  }
+  const uiPageFile = join6(uiPageDir, "page-ui.tsx");
+  const uiPageTemplate = join6(templatePath, "page-ui.tsx");
+  if (existsSync7(uiPageTemplate)) {
+    let uiContent = await readFile7(uiPageTemplate, "utf-8");
+    const translationNamespace = parentName && childName ? `${parentName}.${childName}` : pageName;
+    uiContent = uiContent.replace('useTranslations("template")', `useTranslations("${translationNamespace}")`);
+    uiContent = uiContent.replaceAll('from "@/', `from "${aliasPrefix}/`).replace(/template/g, childName || pageName).replace(/Template/g, capitalize(childName || pageName));
+    await writeFile6(uiPageFile, uiContent);
+    console.log(`\uD83D\uDCC4 File created: ${uiPageFile}`);
+  } else {
+    console.warn("\u26A0\uFE0F Missing template file: page-ui.tsx at path:", uiPageTemplate);
+  }
+  if (!existsSync7(localePagePath)) {
+    await mkdir5(localePagePath, { recursive: true });
+  }
+  for (const flag of flags) {
+    const filename = toFileName(flag);
+    const src = join6(templatePath, filename);
+    const dst = join6(localePagePath, filename);
+    if (!existsSync7(src)) {
+      console.warn(`\u26A0\uFE0F Missing template file: ${filename} at path: ${src}`);
+      continue;
+    }
+    const content = await readFile7(src, "utf-8");
+    const uiImportPath = parentName && childName ? `${parentName}/${childName}` : pageName;
+    const replaced = content.replace("@/ui/template/", `@/ui/${uiImportPath}/`).replaceAll('from "@/', `from "${aliasPrefix}/`).replace(/template/g, childName || pageName).replace(/Template/g, capitalize(childName || pageName));
+    await writeFile6(dst, replaced);
+    console.log(`\uD83D\uDCC4 File created: ${dst}`);
+  }
+  if (useI18n && messagesPath) {
+    const jsonTemplate = join6(templatePath, "page.json");
+    if (!existsSync7(jsonTemplate)) {
+      console.warn("\u26A0\uFE0F Missing template: page.json at path:", jsonTemplate);
     } else {
-      await writeFile5(routePath, `import { NextResponse } from "next/server";
+      const content = await readFile7(jsonTemplate, "utf-8");
+      const replaced = content.replace(/template/g, childName || pageName).replace(/Template/g, capitalize(childName || pageName));
+      for (const locale of locales) {
+        const localeDir = join6(messagesPath, locale);
+        if (!existsSync7(localeDir) || !statSync2(localeDir).isDirectory())
+          continue;
+        const jsonTarget = join6(messagesPath, locale, `${jsonFileName}.json`);
+        let current = {};
+        if (existsSync7(jsonTarget)) {
+          const jsonFile = await readFile7(jsonTarget, "utf-8");
+          try {
+            current = JSON.parse(jsonFile);
+          } catch {
+            current = {};
+          }
+        }
+        if (parentName && childName) {
+          current[childName] = JSON.parse(replaced);
+        } else {
+          current = JSON.parse(replaced);
+        }
+        await writeFile6(jsonTarget, `${JSON.stringify(current, null, 2)}
+`);
+        console.log(`\uD83D\uDCC4 File created: ${jsonTarget}`);
+        const localeAggregator = join6(messagesPath, `${locale}.ts`);
+        if (!existsSync7(localeAggregator)) {
+          throw new Error(`Locale aggregator not found: messages/${locale}.ts`);
+        }
+        const aggregatorContent = await readFile7(localeAggregator, "utf-8");
+        const nextAggregatorContent = registerMessagesFile(aggregatorContent, locale, jsonFileName);
+        if (nextAggregatorContent !== aggregatorContent) {
+          await writeFile6(localeAggregator, nextAggregatorContent);
+          console.log(`\uD83D\uDCC4 File updated: ${localeAggregator}`);
+        }
+      }
+    }
+  } else {
+    console.log("\u2139\uFE0F Skipping translation templates; next-intl not enabled.");
+  }
+  console.log(`\u2705 Page "${pageName}" with templates added${useI18n ? " for each locale" : ""}.`);
+}
 
-export async function GET() {
-  return NextResponse.json({ message: "Hello from ${apiName}" });
+// src/lib/addText.ts
+import { join as join7 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile8, writeFile as writeFile7, readdir as readdir5 } from "fs/promises";
+function defaultText(key) {
+  return key.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+async function addText(args, cwd = process.cwd()) {
+  const pathArg = args[1];
+  if (!pathArg) {
+    console.error("\u274C Dot path parameter is required.");
+    return;
+  }
+  const providedText = args.slice(2).join(" ");
+  parseLogicalName(pathArg, "translation path");
+  const config = await loadConfig(cwd);
+  if (!config?.useI18n) {
+    console.error("\u274C i18n is not enabled in this project.");
+    return;
+  }
+  const messagesPath = join7(cwd, "messages");
+  if (!existsSync8(messagesPath)) {
+    console.error("\u274C Messages directory missing. Ensure i18n was configured.");
+    return;
+  }
+  const entries = await readdir5(messagesPath, { withFileTypes: true });
+  const locales = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  const [fileName, ...segments] = pathArg.split(".");
+  if (!fileName || segments.length === 0) {
+    console.error("\u274C Invalid dot path provided.");
+    return;
+  }
+  const finalKey = segments[segments.length - 1];
+  const text = providedText || defaultText(finalKey);
+  for (const locale of locales) {
+    const filePath = join7(messagesPath, locale, `${fileName}.json`);
+    await assertSafeTarget(cwd, filePath);
+    let data = {};
+    if (existsSync8(filePath)) {
+      const raw = await readFile8(filePath, "utf-8");
+      try {
+        data = JSON.parse(raw);
+      } catch {}
+    }
+    let cursor = data;
+    for (let i = 0;i < segments.length - 1; i++) {
+      const seg = segments[i];
+      if (!cursor[seg])
+        cursor[seg] = {};
+      cursor = cursor[seg];
+    }
+    cursor[finalKey] = text;
+    await writeFile7(filePath, JSON.stringify(data, null, 2));
+    console.log(`\uD83D\uDCC4 File updated: ${filePath}`);
+  }
+  console.log(`\u2705 Text added at path "${pathArg}" with value "${text}".`);
 }
+
+// src/lib/rmPage.ts
+import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile9, readdir as readdir6, rm, writeFile as writeFile8 } from "fs/promises";
+import path6 from "path";
+async function removeMessages(projectRoot, candidate, terminal) {
+  const messagesRoot = resolveInside(projectRoot, "messages");
+  let locales;
+  try {
+    locales = (await readdir6(messagesRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return;
+  }
+  for (const locale of locales) {
+    const target = resolveInside(projectRoot, "messages", locale, `${candidate.routeSegments[0]}.json`);
+    if (!existsSync9(target))
+      continue;
+    if (candidate.messageKey) {
+      const data = JSON.parse(await readFile9(target, "utf8"));
+      delete data[candidate.messageKey];
+      await writeFile8(target, `${JSON.stringify(data, null, 2)}
 `);
+    } else {
+      await rm(target);
     }
-    console.log(`\uD83D\uDCC4 File created: ${routePath}`);
-  } else {
-    console.log(`\u2139\uFE0F File already exists: ${routePath}`);
+    terminal.log(`\uD83D\uDDD1\uFE0F Deleted messages for ${candidate.logicalName}: ${target}`);
   }
-  console.log(`\u2705 API route "${apiName}" added.`);
+}
+async function rmPage(args, cwd = process.cwd(), prompt, terminal = console) {
+  const candidates = await discoverPages(cwd);
+  let logicalName = args[1];
+  if (!logicalName || logicalName.startsWith("-")) {
+    if (!prompt)
+      throw new CliError("A page name is required in non-interactive mode.");
+    const selected = await prompt([
+      {
+        type: "autocomplete",
+        name: "page",
+        message: "\uD83D\uDDD1\uFE0F Page to remove:",
+        choices: candidates.map((candidate2) => ({
+          title: candidate2.logicalName.replaceAll(".", " \u203A "),
+          value: candidate2.logicalName
+        }))
+      },
+      {
+        type: (value) => value ? "confirm" : null,
+        name: "confirm",
+        message: "Confirm page deletion?",
+        initial: false
+      }
+    ]);
+    if (!selected.confirm) {
+      terminal.log("Page deletion cancelled.");
+      return;
+    }
+    logicalName = String(selected.page ?? "");
+  }
+  parseLogicalName(logicalName, "page name");
+  const candidate = candidates.find((entry) => entry.logicalName === logicalName);
+  if (!candidate)
+    throw new CliError(`Page not found: ${logicalName}`);
+  await removeMessages(cwd, candidate, terminal);
+  for (const target of [candidate.uiDirectory, candidate.routeDirectory]) {
+    const safeTarget = resolveInside(cwd, path6.relative(cwd, target));
+    if (existsSync9(safeTarget)) {
+      await rm(safeTarget, { recursive: true, force: false });
+      terminal.log(`\uD83D\uDDD1\uFE0F Deleted: ${safeTarget}`);
+    }
+  }
+  terminal.log(`\u2705 Page "${logicalName}" deleted.`);
+}
+
+// src/cli/registry.ts
+function legacyHandler(command) {
+  return async (args, context) => {
+    await command(args, context.cwd);
+    return success();
+  };
+}
+function createCommandRegistry() {
+  return new Map([
+    ["addcomponent", legacyHandler(addComponent)],
+    ["addpage", legacyHandler(addPage)],
+    ["addlib", legacyHandler(addLib)],
+    ["addapi", legacyHandler(addApi)],
+    ["addlanguage", legacyHandler(addLanguage)],
+    ["addtext", legacyHandler(addText)],
+    [
+      "rmpage",
+      async (args, context) => {
+        await rmPage(args, context.cwd, context.prompt, context.terminal);
+        return success();
+      }
+    ]
+  ]);
 }
 
 // src/scaffold.ts
-import { cp, mkdir as mkdir5, rm, writeFile as writeFile6, readFile as readFile6 } from "fs/promises";
-import { join as join7 } from "path";
-import { existsSync as existsSync7 } from "fs";
-import { fileURLToPath } from "url";
+import { mkdir as mkdir7, rm as rm2, writeFile as writeFile10 } from "fs/promises";
+import { join as join8, resolve } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/lib/helper/consoleColor.ts
 var RED = "\x1B[31m";
@@ -5469,56 +6085,159 @@ function cyan(text) {
   return CYAN + text + RESET;
 }
 
+// src/core/template-manifest.ts
+import {
+  lstat as lstat2,
+  mkdir as mkdir6,
+  readdir as readdir7,
+  readFile as readFile10,
+  writeFile as writeFile9,
+  copyFile as copyFile2
+} from "fs/promises";
+import path7 from "path";
+var TEMPLATE_DENY_NAMES = new Set([
+  ".env",
+  ".git",
+  ".agent",
+  ".cursor",
+  ".next",
+  "node_modules",
+  "artifacts",
+  "coverage",
+  "playwright-report",
+  "test-results"
+]);
+function isDistributableTemplatePath(relativePath) {
+  const segments = relativePath.split(path7.sep);
+  return !segments.some((segment) => TEMPLATE_DENY_NAMES.has(segment) || segment.endsWith(".tsbuildinfo") || segment === ".DS_Store");
+}
+async function templateManifest(root) {
+  const files = [];
+  async function visit(directory, relativeDirectory = "") {
+    const entries = await readdir7(directory, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const relative = path7.join(relativeDirectory, entry.name);
+      if (!isDistributableTemplatePath(relative))
+        continue;
+      const source = path7.join(directory, entry.name);
+      const stats = await lstat2(source);
+      if (stats.isSymbolicLink()) {
+        throw new CliError(`Symbolic links are forbidden in templates: ${relative}`);
+      }
+      if (stats.isDirectory())
+        await visit(source, relative);
+      else if (stats.isFile())
+        files.push(relative);
+      else
+        throw new CliError(`Unsupported template entry: ${relative}`);
+    }
+  }
+  await visit(root);
+  return files;
+}
+async function copyTemplate(root, target) {
+  const manifest = await templateManifest(root);
+  await mkdir6(target, { recursive: true });
+  for (const relative of manifest) {
+    const destination = path7.join(target, relative === ".gitignore.template" ? ".gitignore" : relative);
+    await mkdir6(path7.dirname(destination), { recursive: true });
+    await copyFile2(path7.join(root, relative), destination);
+  }
+  return manifest;
+}
+async function customizeGeneratedProject(target, projectName, importAlias) {
+  const packagePath = path7.join(target, "package.json");
+  const packageJson = JSON.parse(await readFile10(packagePath, "utf8"));
+  packageJson.name = projectName.toLowerCase();
+  delete packageJson.packageManager;
+  await writeFile9(packagePath, `${JSON.stringify(packageJson, null, 2)}
+`);
+  const tsconfigPath = path7.join(target, "tsconfig.json");
+  const tsconfigContent = await readFile10(tsconfigPath, "utf8");
+  const tsconfig = JSON.parse(tsconfigContent);
+  if (!tsconfig.compilerOptions?.paths?.["@/*"]) {
+    throw new CliError('The template tsconfig must define the default "@/*" alias.');
+  }
+  await writeFile9(tsconfigPath, tsconfigContent.replace('"@/*"', `"${importAlias}"`));
+  if (importAlias !== "@/*") {
+    const prefix = importAlias.slice(0, -2);
+    for (const relative of await templateManifest(target)) {
+      if (!/\.[cm]?[jt]sx?$/.test(relative))
+        continue;
+      const file = path7.join(target, relative);
+      const content = await readFile10(file, "utf8");
+      const next = content.replaceAll('from "@/', `from "${prefix}/`).replaceAll("from '@/", `from '${prefix}/`);
+      if (next !== content)
+        await writeFile9(file, next);
+    }
+  }
+}
+
 // src/scaffold.ts
-async function scaffoldProject(options) {
-  const targetPath = join7(process.cwd(), options.projectName);
+async function scaffoldProject(options, runtime = {}) {
+  const requiredFeatures = [
+    "useTypescript",
+    "useEslint",
+    "useTailwind",
+    "useSrcDir",
+    "useTurbopack",
+    "useI18n"
+  ];
+  const unsupported = requiredFeatures.filter((feature) => options[feature] !== true);
+  if (unsupported.length > 0) {
+    throw new CliError(`The default Next.js 16 template requires: ${unsupported.join(", ")}.`);
+  }
+  const cwd = runtime.cwd ?? process.cwd();
+  const terminal = runtime.terminal ?? console;
+  const projectName = validateProjectName(options.projectName);
+  const importAlias = normalizeImportAlias(options.customAlias === false ? "@/*" : options.importAlias || "@/*");
+  const targetPath = join8(cwd, projectName);
   const __dirname2 = new URL(".", import.meta.url);
-  const templatePath = join7(fileURLToPath(__dirname2), "..", "templates", "Projects", "default");
-  if (existsSync7(targetPath)) {
+  const templatePath = runtime.templatePath ?? join8(fileURLToPath2(__dirname2), "..", "templates", "Projects", "default");
+  const resolvedCwd = resolve(cwd);
+  const resolvedTarget = resolve(targetPath);
+  if (!resolvedTarget.startsWith(`${resolvedCwd}/`)) {
+    throw new CliError("The project destination must be a child of the current directory.");
+  }
+  if (existsSync10(targetPath)) {
     if (options.force) {
-      console.warn("\u26A0\uFE0F Target directory already exists, removing...");
-      await rm(targetPath, { recursive: true, force: true });
+      terminal.warn("\u26A0\uFE0F Target directory already exists, removing...");
+      await rm2(targetPath, { recursive: true, force: true });
     } else {
-      console.error(red("[X] Target directory already exists. Use --force to overwrite."));
-      process.exit(1);
+      terminal.error(red("[X] Target directory already exists. Use --force to overwrite."));
+      throw new CliError("[X] Target directory already exists. Use --force to overwrite.");
     }
   }
   try {
-    console.log("Creating project directory...");
-    await mkdir5(targetPath, { recursive: true });
-    console.log("Copying files from template...");
-    await cp(templatePath, targetPath, { recursive: true });
-    const pkgPath = join7(targetPath, "package.json");
-    if (existsSync7(pkgPath)) {
-      const pkg = JSON.parse(await readFile6(pkgPath, "utf-8"));
-      pkg.dependencies = pkg.dependencies || {};
-      if (options.useI18n) {
-        pkg.dependencies["next-intl"] = pkg.dependencies["next-intl"] || "^4.3.5";
-      }
-      await writeFile6(pkgPath, JSON.stringify(pkg, null, 2));
-    }
-    await writeFile6(join7(targetPath, "cnp.config.json"), JSON.stringify(options, null, 2));
-    console.log("Project setup complete!");
-    console.log("");
-    console.log("To get started:");
-    console.log("    " + green(`cd ${options.projectName}`));
-    console.log("");
-    console.log("Then install dependencies and launch the dev server with your preferred tool:");
-    console.log("    " + green(`bun install && bun dev`));
-    console.log("    " + green(`npm install && npm run dev`));
-    console.log("    " + green(`pnpm install && pnpm run dev`));
-    console.log("");
-    console.log("Documentation and examples can be found at:");
-    console.log("    " + cyan("https://github.com/Rising-Corporation/create-next-pro-cli"));
-    console.log("_-`'-_-'`_`'-_-'`_`'-_-'`_`'-_-'`_`'-_-'`_`'-_-'`_`'-_-'`_`'-_-'`-_");
+    terminal.log("Creating project directory...");
+    await mkdir7(targetPath, { recursive: true });
+    terminal.log("Copying files from template...");
+    await copyTemplate(templatePath, targetPath);
+    await customizeGeneratedProject(targetPath, projectName, importAlias);
+    await writeFile10(join8(targetPath, "cnp.config.json"), `${JSON.stringify({ ...options, projectName, importAlias }, null, 2)}
+`);
+    terminal.log("Project setup complete!");
+    terminal.log("");
+    terminal.log("To get started:");
+    terminal.log("    " + green(`cd ${options.projectName}`));
+    terminal.log("");
+    terminal.log("Then install dependencies and launch the dev server with your preferred tool:");
+    terminal.log("    " + green(`bun install && bun dev`));
+    terminal.log("    " + green(`npm install && npm run dev`));
+    terminal.log("    " + green(`pnpm install && pnpm run dev`));
+    terminal.log("");
+    terminal.log("Documentation and examples can be found at:");
+    terminal.log("    " + cyan("https://github.com/Rising-Corporation/create-next-pro-cli"));
+    terminal.log("_-`'-_-'`_`'-_-'`_`'-_-'`_`'-_-'`_`'-_-'`_`'-_-'`_`'-_-'`_`'-_-'`-_");
   } catch (err) {
-    console.error(red("[X] Error during project creation:"), err);
-    process.exit(1);
+    terminal.error(red("[X] Error during project creation:"), err);
+    throw new CliError("[X] Error during project creation:");
   }
 }
 
 // src/lib/createProject.ts
-async function createProject(nameArg, force) {
+async function createProject(nameArg, force, context) {
   const response = {
     projectName: nameArg,
     useTypescript: true,
@@ -5531,14 +6250,17 @@ async function createProject(nameArg, force) {
     importAlias: "@/*",
     force
   };
-  console.log(`Creating project "${response.projectName}"...`);
-  await scaffoldProject(response);
+  const terminal = context?.terminal ?? console;
+  terminal.log(`Creating project "${response.projectName}"...`);
+  await scaffoldProject(response, {
+    cwd: context?.cwd ?? process.cwd(),
+    terminal
+  });
 }
 
 // src/lib/createProjectWithPrompt.ts
-var import_prompts6 = __toESM(require_prompts3(), 1);
-async function createProjectWithPrompt() {
-  const response = await import_prompts6.default.prompt([
+async function createProjectWithPrompt(context) {
+  const response = await context.prompt([
     {
       type: "text",
       name: "projectName",
@@ -5608,232 +6330,18 @@ async function createProjectWithPrompt() {
       initial: "@core/*"
     }
   ]);
-  console.log(`
+  const options = response;
+  context.terminal.log(`
 Your choices:`);
-  console.log(response);
-  await scaffoldProject(response);
-}
-
-// src/lib/addLanguage.ts
-var import_prompts7 = __toESM(require_prompts3(), 1);
-import { join as join8 } from "path";
-import { existsSync as existsSync8 } from "fs";
-import { cp as cp2, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
-function generateLocales() {
-  const dn = new Intl.DisplayNames(["en"], { type: "language" });
-  const locales = [];
-  for (let i = 0;i < 26; i++) {
-    for (let j = 0;j < 26; j++) {
-      const code = String.fromCharCode(97 + i) + String.fromCharCode(97 + j);
-      try {
-        const name = dn.of(code);
-        if (name && name.toLowerCase() !== code) {
-          locales.push(code);
-        }
-      } catch {}
-    }
-  }
-  return locales.sort();
-}
-async function addLanguage(args) {
-  const config = await loadConfig();
-  if (!config?.useI18n) {
-    console.error("\u274C i18n is not enabled in this project.");
-    return;
-  }
-  const messagesPath = join8(process.cwd(), "messages");
-  if (!existsSync8(messagesPath)) {
-    console.error("\u274C Messages directory missing. Ensure i18n was configured.");
-    return;
-  }
-  const available = generateLocales();
-  let locale = args[1];
-  if (!locale || !available.includes(locale)) {
-    const response = await import_prompts7.default({
-      type: "autocomplete",
-      name: "locale",
-      message: "\uD83C\uDF10 Locale to add:",
-      choices: available.map((l) => ({ title: l, value: l }))
-    });
-    locale = response.locale;
-  }
-  if (!locale)
-    return;
-  if (existsSync8(join8(messagesPath, locale))) {
-    console.error(`\u274C Locale ${locale} already exists.`);
-    return;
-  }
-  const routingFile = join8(process.cwd(), "src", "lib", "i18n", "routing.ts");
-  if (!existsSync8(routingFile)) {
-    console.error("\u274C routing.ts not found. Are you in project root?");
-    return;
-  }
-  const routingContent = await readFile7(routingFile, "utf-8");
-  const defaultMatch = routingContent.match(/defaultLocale:\s*"([^"]+)"/);
-  const defaultLocale = defaultMatch ? defaultMatch[1] : null;
-  if (!defaultLocale || !existsSync8(join8(messagesPath, defaultLocale))) {
-    console.error("\u274C Default locale not found.");
-    return;
-  }
-  await cp2(join8(messagesPath, defaultLocale), join8(messagesPath, locale), {
-    recursive: true
+  context.terminal.log(options);
+  await scaffoldProject(options, {
+    cwd: context.cwd,
+    terminal: context.terminal
   });
-  console.log(`\uD83D\uDCC4 Directory created: ${join8(messagesPath, locale)}`);
-  const localesMatch = routingContent.match(/locales:\s*\[([^\]]*)\]/);
-  if (localesMatch) {
-    const localesArr = localesMatch[1].split(",").map((s) => s.trim().replace(/["']/g, "")).filter(Boolean);
-    if (!localesArr.includes(locale)) {
-      localesArr.push(locale);
-      const newLocales = `locales: [${localesArr.map((l) => `"${l}"`).join(", ")}]`;
-      const newContent = routingContent.replace(/locales:\s*\[[^\]]*\]/, newLocales);
-      await writeFile7(routingFile, newContent);
-      console.log(`\uD83D\uDCC4 File updated: ${routingFile}`);
-    }
-  }
-  console.log(`\u2705 Locale "${locale}" added and copied from default locale "${defaultLocale}".`);
-}
-
-// src/lib/addText.ts
-import { join as join9 } from "path";
-import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile8, writeFile as writeFile8, readdir as readdir4 } from "fs/promises";
-function defaultText(key) {
-  return key.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-}
-async function addText(args) {
-  const pathArg = args[1];
-  if (!pathArg) {
-    console.error("\u274C Dot path parameter is required.");
-    return;
-  }
-  const providedText = args.slice(2).join(" ");
-  const config = await loadConfig();
-  if (!config?.useI18n) {
-    console.error("\u274C i18n is not enabled in this project.");
-    return;
-  }
-  const messagesPath = join9(process.cwd(), "messages");
-  if (!existsSync9(messagesPath)) {
-    console.error("\u274C Messages directory missing. Ensure i18n was configured.");
-    return;
-  }
-  const entries = await readdir4(messagesPath, { withFileTypes: true });
-  const locales = entries.filter((e) => e.isDirectory()).map((e) => e.name);
-  const [fileName, ...segments] = pathArg.split(".");
-  if (!fileName || segments.length === 0) {
-    console.error("\u274C Invalid dot path provided.");
-    return;
-  }
-  const finalKey = segments[segments.length - 1];
-  const text = providedText || defaultText(finalKey);
-  for (const locale of locales) {
-    const filePath = join9(messagesPath, locale, `${fileName}.json`);
-    let data = {};
-    if (existsSync9(filePath)) {
-      const raw = await readFile8(filePath, "utf-8");
-      try {
-        data = JSON.parse(raw);
-      } catch {}
-    }
-    let cursor = data;
-    for (let i = 0;i < segments.length - 1; i++) {
-      const seg = segments[i];
-      if (!cursor[seg])
-        cursor[seg] = {};
-      cursor = cursor[seg];
-    }
-    cursor[finalKey] = text;
-    await writeFile8(filePath, JSON.stringify(data, null, 2));
-    console.log(`\uD83D\uDCC4 File updated: ${filePath}`);
-  }
-  console.log(`\u2705 Text added at path "${pathArg}" with value "${text}".`);
 }
 
 // src/index.ts
-var CONFIG_DIR = process.env.XDG_CONFIG_HOME ? path.join(process.env.XDG_CONFIG_HOME, "create-next-pro") : path.join(os.homedir(), ".config", "create-next-pro");
-var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-function readCfg() {
-  try {
-    return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function writeCfg(cfg) {
-  fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2));
-}
-function rcFile(shell) {
-  return path.join(os.homedir(), shell === "zsh" ? ".zshrc" : ".bashrc");
-}
-function ensureLineInRc(file, line) {
-  try {
-    const cur = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
-    if (!cur.includes(line))
-      fs.appendFileSync(file, `
-${line}
-`);
-  } catch {}
-}
-async function installCompletion(shell) {
-  const __dirname2 = path.dirname(fileURLToPath2(import.meta.url));
-  const completionSrc = path.resolve(__dirname2, "../create-next-pro-completion.sh");
-  const completionDst = path.join(CONFIG_DIR, "completion.sh");
-  fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs.copyFileSync(completionSrc, completionDst);
-  ensureLineInRc(rcFile(shell), `source "${completionDst}"`);
-}
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname(__filename2);
-var packageJsonPath = resolve(__dirname2, "../package.json");
-var packageJson = fs.readFileSync(packageJsonPath, "utf8");
-async function onboarding() {
-  const pkg = JSON.parse(packageJson);
-  console.log(`\uD83D\uDE80 Welcome to create-next-pro v${pkg.version}
-`);
-  const res = await import_prompts8.default([
-    {
-      type: "select",
-      name: "shell",
-      message: "Which shell do you use?",
-      choices: [
-        { title: "zsh", value: "zsh" },
-        { title: "bash", value: "bash" }
-      ],
-      initial: (os.userInfo().shell || "").includes("zsh") ? 0 : 1
-    },
-    {
-      type: "toggle",
-      name: "completion",
-      message: "Install autocompletion?",
-      initial: true,
-      active: "Yes",
-      inactive: "No"
-    }
-  ], { onCancel: () => process.exit(1) });
-  const cfg = {
-    version: 1,
-    shell: res.shell,
-    completionInstalled: !!res.completion,
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString()
-  };
-  if (cfg.completionInstalled)
-    await installCompletion(cfg.shell);
-  writeCfg(cfg);
-  console.log(`
-\u2705 Configuration saved.`);
-  console.log("you can now use the CLI ! ex : ");
-  console.log("  Without prompt (will change in future) :");
-  console.log("    create-next-pro my-next-project");
-  console.log("  With prompt :");
-  console.log("    create-next-pro");
-  console.log("For more information, visit: https://github.com/Rising-Corporation/create-next-pro-cli");
-  console.log("Happy coding!  \uD83C\uDF89");
-  return cfg;
-}
-function showHelp() {
-  console.log(`create-next-pro
+var HELP_TEXT = `create-next-pro
 
 Usage:
   create-next-pro <project-name> [--force]
@@ -5847,69 +6355,60 @@ Usage:
 
 Options:
   --help          Show this help message
+  --version       Show the CLI version
   --reconfigure   Run the configuration assistant again
-`);
+`;
+function parseOptions(args) {
+  return {
+    force: args.includes("--force"),
+    help: args.includes("--help"),
+    version: args.includes("--version") || args.includes("-v"),
+    reconfigure: args.includes("--reconfigure")
+  };
 }
-function showVersion() {
-  const pkg = JSON.parse(packageJson);
-  console.log(`v${pkg.version}`);
+async function packageVersion(context) {
+  const packageJson = JSON.parse(await context.fs.readText(path8.join(context.packageRoot, "package.json")));
+  return packageJson.version;
 }
-async function main() {
-  let args;
-  if (typeof Bun !== "undefined") {
-    args = Bun.argv.slice(2);
-  } else if (typeof process !== "undefined" && process.argv) {
-    args = process.argv.slice(2);
-  } else {
-    args = [];
-  }
-  if (args.includes("--help"))
-    return showHelp();
-  if (args.includes("--version") || args.includes("-v"))
-    return showVersion();
-  if (args.includes("--reconfigure") || !readCfg()) {
-    await onboarding();
-    return;
-  }
-  const force = args.includes("--force");
-  if (args[0] === "addpage" && args.length === 1) {
-    args.push("-LPl");
-  }
-  if (args[0] === "addcomponent") {
-    addComponent(args);
-    return;
-  }
-  if (args[0] === "addpage") {
-    addPage(args);
-    return;
-  }
-  if (args[0] === "addlib") {
-    addLib(args);
-    return;
-  }
-  if (args[0] === "addapi") {
-    addApi(args);
-    return;
-  }
-  if (args[0] === "addlanguage") {
-    await addLanguage(args);
-    return;
-  }
-  if (args[0] === "addtext") {
-    await addText(args);
-    return;
-  }
-  if (args[0] === "rmpage") {
-    rmPage(args);
-    return;
-  }
-  const nameArg = args.find((arg) => !arg.startsWith("--"));
-  if (nameArg) {
-    createProject(nameArg, force);
-    return;
+async function main(context = createNodeContext()) {
+  try {
+    const args = [...context.argv];
+    const options = parseOptions(args);
+    const version = await packageVersion(context);
+    if (args[0] === "__complete") {
+      await printCompletions(args, context);
+      return 0;
+    }
+    if (options.help) {
+      context.terminal.log(HELP_TEXT);
+      return 0;
+    }
+    if (options.version) {
+      context.terminal.log(`v${version}`);
+      return 0;
+    }
+    if (options.reconfigure || !await readConfig(context)) {
+      await onboarding(context, version);
+      return 0;
+    }
+    if (args[0] === "addpage" && args.length === 1)
+      args.push("-LPl");
+    const handler = args[0] ? createCommandRegistry().get(args[0]) : undefined;
+    if (handler)
+      return (await handler(args, context)).exitCode;
+    const nameArg = args.find((arg) => !arg.startsWith("--"));
+    if (nameArg) {
+      await createProject(nameArg, options.force, context);
+      return 0;
+    }
+    await createProjectWithPrompt(context);
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    context.terminal.error(message);
+    return error instanceof CliError ? error.exitCode : 1;
   }
-  await createProjectWithPrompt();
 }
 
 // bin.bun.ts
-main();
+process.exitCode = await main();