create-next-pro-cli 0.1.25 → 0.1.27

package/dist/bin.node.js

@@ -1,17 +1,241 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import fs from "fs";
-import os from "os";
+import path8 from "path";
+
+// src/cli/onboarding.ts
 import path from "path";
-import prompts8 from "prompts";
-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(`\u{1F680} 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 = (/* @__PURE__ */ 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("\n\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!  \u{1F389}");
+  return config;
+}
 
-// src/lib/addComponent.ts
+// 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) : void 0
+        });
+      }
+    }
+    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 });
+var CliError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+  exitCode;
+};
+
+// src/lib/addApi.ts
 import { join as join2 } from "path";
-import { mkdir, readFile as readFile2, writeFile, readdir } from "fs/promises";
-import prompts from "prompts";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import prompts2 from "prompts";
+import { existsSync as existsSync3 } from "fs";
 
 // src/lib/utils.ts
 import { readFile } from "fs/promises";
@@ -20,8 +244,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 {
     const raw = await readFile(configPath, "utf-8");
@@ -55,21 +283,212 @@ function toFileName(key) {
   }
 }
 
+// src/runtime/node-context.ts
+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";
+import prompts from "prompts";
+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: prompts,
+    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 prompts2.prompt({
+      type: "text",
+      name: "apiName",
+      message: "\u{1F50C} 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(`\u{1F4C4} 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) {
+import { join as join3 } from "path";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3, readdir as readdir3 } from "fs/promises";
+import prompts3 from "prompts";
+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 prompts.prompt({
+    const response = await prompts3.prompt({
       type: "text",
       name: "componentName",
       message: "\u{1F9E9} Component name to add:",
@@ -77,7 +496,9 @@ 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."
@@ -86,15 +507,15 @@ async function addComponent(args) {
   }
   const useI18n = !!config.useI18n;
   const componentNameUpper = capitalize(componentName);
-  const templatePath = join2(
-    new URL("..", import.meta.url).pathname,
+  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."
       );
@@ -105,25 +526,26 @@ 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(`\u{1F4C4} File created: ${componentFile}`);
   } else {
     console.error(
@@ -132,32 +554,40 @@ async function addComponent(args) {
     );
   }
   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(`\u{1F4C4} File updated: ${jsonTarget}`);
     }
   } else {
@@ -168,15 +598,270 @@ async function addComponent(args) {
   );
 }
 
+// src/lib/addLanguage.ts
+import { join as join4 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { cp, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import prompts4 from "prompts";
+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, cwd = process.cwd()) {
+  const config = await loadConfig(cwd);
+  if (!config?.useI18n) {
+    console.error("\u274C i18n is not enabled in this project.");
+    return;
+  }
+  const messagesPath = join4(cwd, "messages");
+  if (!existsSync5(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 prompts4({
+      type: "autocomplete",
+      name: "locale",
+      message: "\u{1F310} Locale to add:",
+      choices: available.map((l) => ({ title: l, value: l }))
+    });
+    locale = response.locale;
+  }
+  if (!locale) return;
+  parseLogicalName(locale, "locale");
+  await assertSafeTarget(cwd, messagesPath);
+  if (existsSync5(join4(messagesPath, locale))) {
+    throw new Error(`Locale ${locale} already exists.`);
+  }
+  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?");
+  }
+  if (!existsSync5(messagesRegistryFile)) {
+    throw new Error("messages.ts not found. Are you in project root?");
+  }
+  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.");
+  }
+  const defaultAggregatorFile = join4(messagesPath, `${defaultLocale}.ts`);
+  if (!existsSync5(defaultAggregatorFile)) {
+    throw new Error(`Default locale aggregator not found: ${defaultLocale}.ts`);
+  }
+  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}";
+
+` + messagesRegistryContent.slice(declarationIndex).replace(/const messages = \{[^}]*\} as const;/, registryDeclaration);
+  await cp(join4(messagesPath, defaultLocale), join4(messagesPath, locale), {
+    recursive: true
+  });
+  console.log(`\u{1F4C4} Directory created: ${join4(messagesPath, locale)}`);
+  await writeFile4(join4(messagesPath, `${locale}.ts`), nextAggregatorContent);
+  console.log(`\u{1F4C4} File created: ${join4(messagesPath, `${locale}.ts`)}`);
+  await writeFile4(messagesRegistryFile, nextMessagesRegistryContent);
+  console.log(`\u{1F4C4} File updated: ${messagesRegistryFile}`);
+  await writeFile4(routingFile, nextRoutingContent);
+  console.log(`\u{1F4C4} File updated: ${routingFile}`);
+  console.log(
+    `\u2705 Locale "${locale}" added and copied from default locale "${defaultLocale}".`
+  );
+}
+
+// src/lib/addLib.ts
+import { join as join5 } from "path";
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import prompts5 from "prompts";
+import { existsSync as existsSync6 } from "fs";
+async function addLib(args, cwd = process.cwd()) {
+  let libArg = args[1];
+  if (!libArg || libArg.startsWith("-")) {
+    const response = await prompts5.prompt({
+      type: "text",
+      name: "libArg",
+      message: "\u{1F4E6} Lib name to add:",
+      validate: (name) => name ? true : "Lib name is required"
+    });
+    libArg = response.libArg;
+  }
+  const libSegments = parseLogicalName(libArg, "library name");
+  let libName = libArg;
+  let fileName = null;
+  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(cwd);
+  if (!config) {
+    console.error(
+      "\u274C Configuration file cnp.config.json not found. Run this command from the project root."
+    );
+    return;
+  }
+  const libDir = join5(cwd, "src", "lib", libName);
+  await assertSafeTarget(cwd, libDir);
+  if (!existsSync6(libDir)) {
+    await mkdir4(libDir, { recursive: true });
+  }
+  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 (!existsSync6(indexPath)) {
+    if (existsSync6(indexTemplate)) {
+      const content = await readFile6(indexTemplate, "utf-8");
+      await writeFile5(indexPath, content);
+    } else {
+      await writeFile5(indexPath, "export {}\n");
+    }
+    console.log(`\u{1F4C4} File created: ${indexPath}`);
+  }
+  if (fileName) {
+    const filePath = join5(libDir, `${fileName}.ts`);
+    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 writeFile5(filePath, content);
+      } else {
+        await writeFile5(
+          filePath,
+          `export function ${fileName}() {
+  // TODO: implement
+}
+`
+        );
+      }
+      console.log(`\u{1F4C4} File created: ${filePath}`);
+    }
+    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;
+    const imports = [];
+    const exportsSet = [];
+    for (const line of indexContent.split("\n")) {
+      if (line.startsWith("import")) {
+        imports.push(line);
+      } else if (line.startsWith("export")) {
+        const match = line.match(exportRegex);
+        if (match && match[1]) {
+          exportsSet.push(
+            ...match[1].split(",").map((s) => s.trim()).filter(Boolean)
+          );
+        }
+      }
+    }
+    if (!imports.some((l) => importRegex.test(l))) {
+      imports.push(importLine);
+    }
+    if (!exportsSet.includes(fileName)) {
+      exportsSet.push(fileName);
+    }
+    indexContent = imports.join("\n") + "\n\nexport { " + exportsSet.join(", ") + " };\n";
+    await writeFile5(indexPath, indexContent);
+    console.log(`\u270F\uFE0F Updated index: ${indexPath}`);
+  }
+  console.log(
+    `\u2705 Lib "${libName}"${fileName ? ` with module ${fileName}` : ""} added.`
+  );
+}
+
 // src/lib/addPage.ts
-import { join as join3 } from "path";
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2, readdir as readdir2 } from "fs/promises";
-import prompts2 from "prompts";
-import { existsSync as existsSync3, statSync as statSync2 } from "fs";
-async function addPage(args) {
+import { join as join6 } from "path";
+import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile6, readdir as readdir4 } from "fs/promises";
+import prompts6 from "prompts";
+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 prompts2.prompt({
+    const response = await prompts6.prompt({
       type: "text",
       name: "pageName",
       message: "\u{1F4DD} Page name to add:",
@@ -184,13 +869,16 @@ async function addPage(args) {
     });
     pageName = response.pageName;
   }
+  const pageSegments = parseLogicalName(pageName, "page name");
   let parentName = null;
   let childName = null;
-  if (pageName.includes(".")) {
-    [parentName, childName] = pageName.split(".");
+  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));
-  let longFlags = new Set(args.filter((a) => a.startsWith("--")));
+  const longFlags = new Set(args.filter((a) => a.startsWith("--")));
   const flags = /* @__PURE__ */ new Set();
   if (!shortFlags && Array.from(longFlags).length === 0) {
     shortFlags = "-LPl";
@@ -241,7 +929,7 @@ async function addPage(args) {
   ]) {
     if (longFlags.has("--" + flag)) flags.add(flag);
   }
-  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."
@@ -249,50 +937,58 @@ async function addPage(args) {
     return;
   }
   const useI18n = !!config.useI18n;
+  const aliasPrefix = configuredAliasPrefix(config);
   const srcSegments = ["src", "app"];
   if (useI18n) srcSegments.push("[locale]");
-  const srcPath = join3(process.cwd(), ...srcSegments);
-  if (!existsSync3(srcPath)) {
+  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 = join3(process.cwd(), "messages");
-    if (!existsSync3(messagesPath)) {
+    messagesPath = join6(cwd, "messages");
+    if (!existsSync7(messagesPath)) {
       console.error(
         "\u274C Messages directory missing. Ensure i18n was configured."
       );
       return;
     }
-    const entries = await readdir2(messagesPath, { withFileTypes: true });
+    const entries = await readdir4(messagesPath, { withFileTypes: true });
     locales = entries.filter((e) => e.isDirectory()).map((e) => e.name);
   }
-  const templatePath = join3(
-    new URL("..", import.meta.url).pathname,
+  const templatePath = join6(
+    resolvePackageRoot(import.meta.url),
     "templates",
     "Page"
   );
   let uiPageDir, localePagePath, jsonFileName;
   if (parentName && childName) {
-    uiPageDir = join3(process.cwd(), "src", "ui", parentName, childName);
-    localePagePath = join3(srcPath, parentName, childName);
+    uiPageDir = join6(cwd, "src", "ui", parentName, childName);
+    localePagePath = join6(srcPath, parentName, childName);
     jsonFileName = parentName;
   } else {
-    uiPageDir = join3(process.cwd(), "src", "ui", pageName);
-    localePagePath = join3(srcPath, pageName);
+    uiPageDir = join6(cwd, "src", "ui", pageName);
+    localePagePath = join6(srcPath, pageName);
     jsonFileName = pageName;
   }
-  if (!existsSync3(uiPageDir)) {
-    await mkdir2(uiPageDir, { recursive: true });
-  }
-  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);
+  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(`\u{1F4C4} File created: ${uiPageFile}`);
   } else {
     console.warn(
@@ -300,37 +996,38 @@ async function addPage(args) {
       uiPageTemplate
     );
   }
-  if (!existsSync3(localePagePath)) {
-    await mkdir2(localePagePath, { recursive: true });
+  if (!existsSync7(localePagePath)) {
+    await mkdir5(localePagePath, { recursive: true });
   }
   for (const flag of flags) {
     const filename = toFileName(flag);
-    const src = join3(templatePath, filename);
-    const dst = join3(localePagePath, filename);
-    if (!existsSync3(src)) {
+    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 readFile3(src, "utf-8");
-    const replaced = content.replace(/template/g, childName || pageName).replace(/Template/g, capitalize(childName || pageName));
-    await writeFile2(dst, replaced);
+    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(`\u{1F4C4} File created: ${dst}`);
   }
   if (useI18n && messagesPath) {
-    const jsonTemplate = join3(templatePath, "page.json");
-    if (!existsSync3(jsonTemplate)) {
+    const jsonTemplate = join6(templatePath, "page.json");
+    if (!existsSync7(jsonTemplate)) {
       console.warn("\u26A0\uFE0F Missing template: page.json at path:", jsonTemplate);
     } else {
-      const content = await readFile3(jsonTemplate, "utf-8");
+      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 = join3(messagesPath, locale);
-        if (!existsSync3(localeDir) || !statSync2(localeDir).isDirectory())
+        const localeDir = join6(messagesPath, locale);
+        if (!existsSync7(localeDir) || !statSync2(localeDir).isDirectory())
           continue;
-        const jsonTarget = join3(messagesPath, locale, `${jsonFileName}.json`);
+        const jsonTarget = join6(messagesPath, locale, `${jsonFileName}.json`);
         let current = {};
-        if (existsSync3(jsonTarget)) {
-          const jsonFile = await readFile3(jsonTarget, "utf-8");
+        if (existsSync7(jsonTarget)) {
+          const jsonFile = await readFile7(jsonTarget, "utf-8");
           try {
             current = JSON.parse(jsonFile);
           } catch {
@@ -342,8 +1039,23 @@ async function addPage(args) {
         } else {
           current = JSON.parse(replaced);
         }
-        await writeFile2(jsonTarget, JSON.stringify(current, null, 2));
+        await writeFile6(jsonTarget, `${JSON.stringify(current, null, 2)}
+`);
         console.log(`\u{1F4C4} 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(`\u{1F4C4} File updated: ${localeAggregator}`);
+        }
       }
     }
   } else {
@@ -354,216 +1066,170 @@ async function addPage(args) {
   );
 }
 
-// src/lib/rmPage.ts
-import { join as join4 } from "path";
-import { writeFile as writeFile3, readdir as readdir3 } from "fs/promises";
-import prompts3 from "prompts";
-import { existsSync as existsSync4 } from "fs";
-async function rmPage(args) {
-  let pageName = args[1];
-  if (!pageName || pageName.startsWith("-")) {
-    const response = await prompts3.prompt({
-      type: "text",
-      name: "pageName",
-      message: "\u{1F5D1}\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(
-        (cp3) => cp3.execSync(`rm -f '${jsonTarget}'`)
-      );
-      console.log(`\u{1F5D1}\uFE0F Deleted: ${jsonTarget}`);
-    }
-  }
-  const uiPageDir = join4(process.cwd(), "src", "ui", pageName);
-  if (existsSync4(uiPageDir)) {
-    await import("child_process").then(
-      (cp3) => cp3.execSync(`rm -rf '${uiPageDir}'`)
-    );
-    console.log(`\u{1F5D1}\uFE0F Deleted: ${uiPageDir}`);
-  }
-  const appLocaleDir = join4(process.cwd(), "src", "app", "[locale]", pageName);
-  if (existsSync4(appLocaleDir)) {
-    await import("child_process").then(
-      (cp3) => cp3.execSync(`rm -rf '${appLocaleDir}'`)
-    );
-    console.log(`\u{1F5D1}\uFE0F Deleted: ${appLocaleDir}`);
-  }
-  console.log(`\u2705 Page "${pageName}" deleted.`);
+// 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());
 }
-
-// src/lib/addLib.ts
-import { join as join5 } from "path";
-import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import prompts4 from "prompts";
-import { existsSync as existsSync5 } from "fs";
-async function addLib(args) {
-  let libArg = args[1];
-  if (!libArg || libArg.startsWith("-")) {
-    const response = await prompts4.prompt({
-      type: "text",
-      name: "libArg",
-      message: "\u{1F4E6} Lib name to add:",
-      validate: (name) => name ? true : "Lib name is required"
-    });
-    libArg = response.libArg;
-  }
-  let libName = libArg;
-  let fileName = null;
-  if (libArg.includes(".")) {
-    [libName, fileName] = libArg.split(".");
+async function addText(args, cwd = process.cwd()) {
+  const pathArg = args[1];
+  if (!pathArg) {
+    console.error("\u274C Dot path parameter is required.");
+    return;
   }
-  const config = await loadConfig();
-  if (!config) {
-    console.error(
-      "\u274C Configuration file cnp.config.json not found. Run this command from the project root."
-    );
+  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 libDir = join5(process.cwd(), "src", "lib", libName);
-  if (!existsSync5(libDir)) {
-    await mkdir3(libDir, { recursive: true });
+  const messagesPath = join7(cwd, "messages");
+  if (!existsSync8(messagesPath)) {
+    console.error("\u274C Messages directory missing. Ensure i18n was configured.");
+    return;
   }
-  const templateDir = join5(
-    new URL("..", import.meta.url).pathname,
-    "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);
-    } else {
-      await writeFile4(indexPath, "export {}\n");
-    }
-    console.log(`\u{1F4C4} File created: ${indexPath}`);
+  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;
   }
-  if (fileName) {
-    const filePath = join5(libDir, `${fileName}.ts`);
-    if (!existsSync5(filePath)) {
-      if (existsSync5(fileTemplate)) {
-        let content = await readFile4(fileTemplate, "utf-8");
-        content = content.replace(/template/g, fileName).replace(/Template/g, capitalize(fileName));
-        await writeFile4(filePath, content);
-      } else {
-        await writeFile4(
-          filePath,
-          `export function ${fileName}() {
-  // TODO: implement
-}
-`
-        );
-      }
-      console.log(`\u{1F4C4} File created: ${filePath}`);
-    }
-    let indexContent = await readFile4(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;
-    const imports = [];
-    const exportsSet = [];
-    for (const line of indexContent.split("\n")) {
-      if (line.startsWith("import")) {
-        imports.push(line);
-      } else if (line.startsWith("export")) {
-        const match = line.match(exportRegex);
-        if (match && match[1]) {
-          exportsSet.push(
-            ...match[1].split(",").map((s) => s.trim()).filter(Boolean)
-          );
-        }
+  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 {
       }
     }
-    if (!imports.some((l) => importRegex.test(l))) {
-      imports.push(importLine);
-    }
-    if (!exportsSet.includes(fileName)) {
-      exportsSet.push(fileName);
+    let cursor = data;
+    for (let i = 0; i < segments.length - 1; i++) {
+      const seg = segments[i];
+      if (!cursor[seg]) cursor[seg] = {};
+      cursor = cursor[seg];
     }
-    indexContent = imports.join("\n") + "\n\nexport { " + exportsSet.join(", ") + " };\n";
-    await writeFile4(indexPath, indexContent);
-    console.log(`\u270F\uFE0F Updated index: ${indexPath}`);
-  }
-  console.log(
-    `\u2705 Lib "${libName}"${fileName ? ` with module ${fileName}` : ""} added.`
-  );
-}
-
-// src/lib/addApi.ts
-import { join as join6 } from "path";
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import prompts5 from "prompts";
-import { existsSync as existsSync6 } from "fs";
-async function addApi(args) {
-  let apiName = args[1];
-  if (!apiName || apiName.startsWith("-")) {
-    const response = await prompts5.prompt({
-      type: "text",
-      name: "apiName",
-      message: "\u{1F50C} API route name to add:",
-      validate: (name) => name ? true : "API route name is required"
-    });
-    apiName = response.apiName;
+    cursor[finalKey] = text;
+    await writeFile7(filePath, JSON.stringify(data, null, 2));
+    console.log(`\u{1F4C4} File updated: ${filePath}`);
   }
-  const config = await loadConfig();
-  if (!config) {
-    console.error(
-      "\u274C Configuration file cnp.config.json not found. Run this command from the project root."
-    );
+  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;
   }
-  const apiDir = join6(process.cwd(), "src", "app", "api", apiName);
-  if (!existsSync6(apiDir)) {
-    await mkdir4(apiDir, { recursive: true });
-  }
-  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);
+  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 writeFile5(
-        routePath,
-        `import { NextResponse } from "next/server";
-
-export async function GET() {
-  return NextResponse.json({ message: "Hello from ${apiName}" });
+      await rm(target);
+    }
+    terminal.log(`\u{1F5D1}\uFE0F Deleted messages for ${candidate.logicalName}: ${target}`);
+  }
 }
-`
-      );
+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: "\u{1F5D1}\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;
     }
-    console.log(`\u{1F4C4} File created: ${routePath}`);
-  } else {
-    console.log(`\u2139\uFE0F File already exists: ${routePath}`);
+    logicalName = String(selected.page ?? "");
   }
-  console.log(`\u2705 API route "${apiName}" added.`);
+  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(`\u{1F5D1}\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 /* @__PURE__ */ 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";
@@ -580,73 +1246,186 @@ 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 = /* @__PURE__ */ 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);
-  const __dirname2 = new URL(".", import.meta.url);
-  const templatePath = join7(
-    fileURLToPath(__dirname2),
-    "..",
-    "templates",
-    "Projects",
-    "default"
+async function scaffoldProject(options, runtime = {}) {
+  const requiredFeatures = [
+    "useTypescript",
+    "useEslint",
+    "useTailwind",
+    "useSrcDir",
+    "useTurbopack",
+    "useI18n"
+  ];
+  const unsupported = requiredFeatures.filter(
+    (feature) => options[feature] !== true
   );
-  if (existsSync7(targetPath)) {
+  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 __dirname = new URL(".", import.meta.url);
+  const templatePath = runtime.templatePath ?? join8(fileURLToPath2(__dirname), "..", "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(
+      terminal.error(
         red("[X] Target directory already exists. Use --force to overwrite.")
       );
-      process.exit(1);
+      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)
+    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)}
+`
     );
-    console.log("Project setup complete!");
-    console.log("");
-    console.log("To get started:");
-    console.log("    " + green(`cd ${options.projectName}`));
-    console.log("");
-    console.log(
+    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:"
     );
-    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(
+    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")
     );
-    console.log(
+    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,
@@ -659,14 +1438,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
-import prompts6 from "prompts";
-async function createProjectWithPrompt() {
-  const response = await prompts6.prompt([
+async function createProjectWithPrompt(context) {
+  const response = await context.prompt([
     {
       type: "text",
       name: "projectName",
@@ -736,239 +1518,17 @@ async function createProjectWithPrompt() {
       initial: "@core/*"
     }
   ]);
-  console.log("\nYour choices:");
-  console.log(response);
-  await scaffoldProject(response);
-}
-
-// src/lib/addLanguage.ts
-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";
-import prompts7 from "prompts";
-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 prompts7({
-      type: "autocomplete",
-      name: "locale",
-      message: "\u{1F310} 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
+  const options = response;
+  context.terminal.log("\nYour choices:");
+  context.terminal.log(options);
+  await scaffoldProject(options, {
+    cwd: context.cwd,
+    terminal: context.terminal
   });
-  console.log(`\u{1F4C4} 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(`\u{1F4C4} 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(`\u{1F4C4} 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 __filename = fileURLToPath2(import.meta.url);
-var __dirname = dirname(__filename);
-var packageJsonPath = resolve(__dirname, "../package.json");
-var packageJson = fs.readFileSync(packageJsonPath, "utf8");
-async function onboarding() {
-  const pkg = JSON.parse(packageJson);
-  console.log(`\u{1F680} Welcome to create-next-pro v${pkg.version}
-`);
-  const res = await prompts8(
-    [
-      {
-        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: (/* @__PURE__ */ new Date()).toISOString(),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  if (cfg.completionInstalled) await installCompletion(cfg.shell);
-  writeCfg(cfg);
-  console.log("\n\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!  \u{1F389}");
-  return cfg;
-}
-function showHelp() {
-  console.log(`create-next-pro
+var HELP_TEXT = `create-next-pro
 
 Usage:
   create-next-pro <project-name> [--force]
@@ -982,68 +1542,61 @@ 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]) : void 0;
+    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.node.ts
-main();
+process.exitCode = await main();
 //# sourceMappingURL=bin.node.js.map