betterstart-cli 0.0.99 → 0.0.101

package/dist/{chunk-SO2CAJFC.js → chunk-TIJEHWRF.js}

@@ -1,79 +1,468 @@
-// adapters/next/template-reader.ts
+// adapters/next/template-reader/read-template.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// utils/paths.ts
 import fs2 from "fs";
 import path2 from "path";
-
-// core-engine/utils/cli-root.ts
-import fs from "fs";
-import path from "path";
 import { fileURLToPath } from "url";
 
 // constants/cli.ts
 var CLI_PACKAGE_NAME = "betterstart-cli";
 var REDACTED = "[redacted]";
 
-// core-engine/utils/cli-root.ts
-function findCliPackage() {
-  let dir = path.dirname(fileURLToPath(import.meta.url));
+// constants/paths.ts
+var BETTERSTART_DIR = ".betterstart";
+var CONFIG_FILE_NAME = "betterstart.config.ts";
+var DEVELOPMENT_ENV_FILES = [
+  ".env.development.local",
+  ".env.local",
+  ".env.development",
+  ".env"
+];
+var LOCKFILE_MAP = {
+  "pnpm-lock.yaml": "pnpm",
+  "package-lock.json": "npm",
+  "yarn.lock": "yarn",
+  "bun.lockb": "bun",
+  "bun.lock": "bun"
+};
+
+// utils/files.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { parseEnv } from "util";
+
+// utils/text.ts
+import { stripVTControlCharacters } from "util";
+function stripAnsi(text, options = {}) {
+  const stripped = stripVTControlCharacters(text);
+  return options.stripCarriageReturns ? stripped.replaceAll("\r", "") : stripped;
+}
+function toPascalCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function toCamelCase(str) {
+  const p = toPascalCase(str);
+  return p.charAt(0).toLowerCase() + p.slice(1);
+}
+function singularize(str) {
+  if (str.endsWith("ies")) return `${str.slice(0, -3)}y`;
+  if (str.endsWith("ves")) return `${str.slice(0, -3)}f`;
+  if (str.endsWith("sses") || str.endsWith("xes") || str.endsWith("ches") || str.endsWith("shes") || str.endsWith("zes"))
+    return str.slice(0, -2);
+  if (str.endsWith("s") && !str.endsWith("ss")) return str.slice(0, -1);
+  return str;
+}
+function pluralize(str) {
+  if (str.endsWith("s") && !str.endsWith("ss")) return str;
+  if (str.endsWith("y") && !["ay", "ey", "iy", "oy", "uy"].some((v) => str.endsWith(v)))
+    return `${str.slice(0, -1)}ies`;
+  if (str.endsWith("s") || str.endsWith("x") || str.endsWith("ch") || str.endsWith("sh"))
+    return `${str}es`;
+  return `${str}s`;
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toScreamingSnake(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toUpperCase();
+}
+function quotePropertyName(name) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `'${name}'`;
+}
+function humanizeName(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim().split(/\s+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+function singularizeLabel(label) {
+  const words = label.split(" ");
+  const lastWord = words[words.length - 1];
+  words[words.length - 1] = singularize(lastWord.toLowerCase());
+  words[words.length - 1] = words[words.length - 1].charAt(0).toUpperCase() + words[words.length - 1].slice(1);
+  return words.join(" ");
+}
+function quoteLiteral(value, quote = "'") {
+  const escaped = value.replace(/\\/g, "\\\\").replace(new RegExp(escapeRegExp(quote), "g"), `\\${quote}`).replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+  return `${quote}${escaped}${quote}`;
+}
+function escapeTemplateText(value) {
+  return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function normalizeLineEndings(content) {
+  return content.replace(/\r\n/g, "\n");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasConflictMarkers(content) {
+  return /^(<{7}|={7}|>{7})( |$)/m.test(content);
+}
+function splitLines(content) {
+  return normalizeLineEndings(content).split("\n");
+}
+function normalizeWhitespace(value) {
+  return value.trim().replace(/\s+/g, " ");
+}
+function escapeJsx(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttribute(str) {
+  return escapeJsx(str).replace(/"/g, "&quot;");
+}
+function findNextNonEmptyLine(lines, startIndex) {
+  for (let i = startIndex; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed !== "") return trimmed;
+  }
+  return null;
+}
+function levenshtein(a, b) {
+  const matrix = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+  for (let i = 0; i <= a.length; i++) matrix[i][0] = i;
+  for (let j = 0; j <= b.length; j++) matrix[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        matrix[i][j - 1] + 1,
+        matrix[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return matrix[a.length][b.length];
+}
+function toTitleCase(value) {
+  return normalizeWhitespace(value).split(" ").map((word) => word ? `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}` : word).join(" ");
+}
+function slugify(value) {
+  return value.trim().toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+}
+function usesIdentifier(source, identifier) {
+  return new RegExp(`\\b${escapeRegExp(identifier)}\\b`).test(source);
+}
+function detectIndent(raw) {
+  const indentMatch = raw.match(/^[ \t]+(?=")/m);
+  return indentMatch?.[0] ?? 2;
+}
+function jsString(value) {
+  return JSON.stringify(value);
+}
+function safeIdentifier(value, fallback) {
+  const pascal = toPascalCase(value).replace(/[^A-Za-z0-9_$]/g, "");
+  const base = pascal ? `${pascal.charAt(0).toLowerCase()}${pascal.slice(1)}` : fallback;
+  return /^[A-Za-z_$]/.test(base) ? base : fallback;
+}
+
+// utils/files.ts
+import fse from "fs-extra";
+function findUpwards(startDir, visit) {
+  let dir = path.resolve(startDir);
   for (; ; ) {
-    const pkgPath = path.join(dir, "package.json");
-    if (fs.existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-        if (pkg.name === CLI_PACKAGE_NAME) {
-          return { dir, pkg };
+    const found = visit(dir);
+    if (found !== void 0) return found;
+    const parent = path.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function hashContent(content) {
+  return `sha256-${crypto.createHash("sha256").update(normalizeLineEndings(content)).digest("hex")}`;
+}
+function ensureDir(dirPath) {
+  fse.ensureDirSync(dirPath);
+}
+function safeWriteFile(filePath, content, force = false) {
+  if (!force && fs.existsSync(filePath)) {
+    return false;
+  }
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, content, "utf-8");
+  return true;
+}
+function createGeneratedFile(filePath, content) {
+  return {
+    path: filePath.split(path.sep).join("/"),
+    content
+  };
+}
+function stripJsonComments(input) {
+  let result = "";
+  let i = 0;
+  while (i < input.length) {
+    if (input[i] === '"') {
+      let j = i + 1;
+      while (j < input.length) {
+        if (input[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (input[j] === '"') {
+          j++;
+          break;
+        }
+        j++;
+      }
+      result += input.slice(i, j);
+      i = j;
+    } else if (input[i] === "/" && input[i + 1] === "/") {
+      const nl = input.indexOf("\n", i);
+      i = nl === -1 ? input.length : nl;
+    } else if (input[i] === "/" && input[i + 1] === "*") {
+      const end = input.indexOf("*/", i + 2);
+      i = end === -1 ? input.length : end + 2;
+    } else {
+      result += input[i];
+      i++;
+    }
+  }
+  return result;
+}
+function toStrictJson(input) {
+  return stripJsonComments(input).replace(/,\s*([\]}])/g, "$1");
+}
+function parseDotenvFile(filePath) {
+  if (!fs.existsSync(filePath)) return /* @__PURE__ */ new Map();
+  try {
+    const parsed = Object.entries(parseEnv(fs.readFileSync(filePath, "utf-8")));
+    return new Map(
+      parsed.filter((entry) => typeof entry[1] === "string")
+    );
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function readEnvVar(cwd, key) {
+  return parseDotenvFile(path.join(cwd, ".env.local")).get(key);
+}
+function resolveProjectEnvVar(cwd, key) {
+  for (const envFile of DEVELOPMENT_ENV_FILES) {
+    const value = parseDotenvFile(path.join(cwd, envFile)).get(key)?.trim();
+    if (value) return { source: envFile, value };
+  }
+  return void 0;
+}
+function readProjectEnvVar(cwd, key) {
+  return resolveProjectEnvVar(cwd, key)?.value;
+}
+function appendEnvVars(cwd, sections, overwrite) {
+  const envPath = path.join(cwd, ".env.local");
+  let existing = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf-8") : "";
+  const existingKeys = new Set(
+    existing.split("\n").filter((line) => line.trim() && !line.trim().startsWith("#")).map((line) => line.split("=")[0]?.trim()).filter(Boolean)
+  );
+  const added = [];
+  const skipped = [];
+  const updated = [];
+  const lines = [];
+  if (overwrite) {
+    for (const section of sections) {
+      for (const v of section.vars) {
+        if (overwrite.has(v.key) && existingKeys.has(v.key)) {
+          const pattern = new RegExp(`^${v.key}=.*$`, "m");
+          const replacement = v.comment ? `${v.key}="${v.value}"  # ${v.comment}` : `${v.key}="${v.value}"`;
+          existing = existing.replace(pattern, replacement);
+          updated.push(v.key);
         }
-      } catch {
       }
     }
-    const parentDir = path.dirname(dir);
-    if (parentDir === dir) {
-      return null;
+  }
+  if (existing.trim()) {
+    lines.push("");
+  }
+  for (const section of sections) {
+    const sectionVars = section.vars.filter((v) => {
+      if (existingKeys.has(v.key)) {
+        if (!updated.includes(v.key)) skipped.push(v.key);
+        return false;
+      }
+      added.push(v.key);
+      return true;
+    });
+    if (sectionVars.length === 0) continue;
+    lines.push(`# ${section.header}`);
+    for (const v of sectionVars) {
+      const line = v.comment ? `${v.key}="${v.value}"  # ${v.comment}` : `${v.key}="${v.value}"`;
+      lines.push(line);
+    }
+    lines.push("");
+  }
+  if (added.length > 0 || updated.length > 0) {
+    const header = existing.trim() ? "" : "# ============================================\n# BetterStart Admin\n# ============================================\n";
+    const content = existing.trim() ? `${existing.trimEnd()}
+${lines.join("\n")}` : header + lines.join("\n");
+    fs.writeFileSync(envPath, content);
+  }
+  return { added, skipped, updated };
+}
+function removeEnvVars(cwd, keys) {
+  const envPath = path.join(cwd, ".env.local");
+  if (!fs.existsSync(envPath) || keys.length === 0) {
+    return [];
+  }
+  const keySet = new Set(keys);
+  const removed = [];
+  const filteredLines = fs.readFileSync(envPath, "utf-8").split("\n").filter((line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || !trimmed.includes("=")) {
+      return true;
+    }
+    const [key] = trimmed.split("=");
+    const normalizedKey = key?.trim();
+    if (normalizedKey && keySet.has(normalizedKey)) {
+      removed.push(normalizedKey);
+      return false;
     }
-    dir = parentDir;
+    return true;
+  });
+  fs.writeFileSync(envPath, `${filteredLines.join("\n").trimEnd()}
+`, "utf-8");
+  return removed;
+}
+function captureFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return { existed: false };
   }
+  return { existed: true, content: fs.readFileSync(filePath, "utf-8") };
+}
+function restoreFile(filePath, snapshot) {
+  if (snapshot.existed) {
+    fs.writeFileSync(filePath, snapshot.content ?? "", "utf-8");
+    return;
+  }
+  if (fs.existsSync(filePath)) {
+    fs.rmSync(filePath, { force: true });
+  }
+}
+function readNonEmptyEnvVar(cwd, key) {
+  const value = readProjectEnvVar(cwd, key)?.trim();
+  return value ? value : void 0;
+}
+
+// utils/paths.ts
+function betterstartDir(cwd, ...segments) {
+  return path2.join(cwd, BETTERSTART_DIR, ...segments);
+}
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
+}
+function trimDotSlash(value) {
+  return value.replace(/^[.][/\\]/, "");
+}
+function normalizePosixDir(value) {
+  return trimDotSlash(toPosixPath(value)).replace(/\/+$/, "");
+}
+function toProjectAbsolutePath(cwd, filePath) {
+  return path2.isAbsolute(filePath) ? filePath : path2.join(cwd, ...filePath.split("/"));
+}
+function readLocalProjectFile(cwd, filePath) {
+  const fullPath = toProjectAbsolutePath(cwd, filePath);
+  return fs2.existsSync(fullPath) ? fs2.readFileSync(fullPath, "utf-8") : null;
+}
+function isInsideDir(child, parent) {
+  const relative = path2.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
+}
+function removePath(cwd, filePath) {
+  const fullPath = toProjectAbsolutePath(cwd, filePath);
+  const existed = fs2.existsSync(fullPath);
+  fs2.rmSync(fullPath, { recursive: true, force: true });
+  return existed;
+}
+function cleanupEmptyDirs(cwd, deletedPaths, stopRoots) {
+  const projectRoot = path2.resolve(cwd);
+  const stops = /* @__PURE__ */ new Set([projectRoot, ...stopRoots]);
+  for (const deletedPath of deletedPaths) {
+    let currentDir = path2.dirname(toProjectAbsolutePath(cwd, deletedPath));
+    while (isInsideDir(currentDir, projectRoot) && !stops.has(currentDir)) {
+      if (!fs2.existsSync(currentDir)) {
+        currentDir = path2.dirname(currentDir);
+        continue;
+      }
+      if (fs2.readdirSync(currentDir).length > 0) {
+        break;
+      }
+      fs2.rmdirSync(currentDir);
+      currentDir = path2.dirname(currentDir);
+    }
+  }
+}
+function findCliPackage() {
+  const start = path2.dirname(fileURLToPath(import.meta.url));
+  return findUpwards(start, (dir) => {
+    const pkgPath = path2.join(dir, "package.json");
+    if (!fs2.existsSync(pkgPath)) return void 0;
+    try {
+      const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+      return pkg.name === CLI_PACKAGE_NAME ? { dir, pkg } : void 0;
+    } catch {
+      return void 0;
+    }
+  }) ?? null;
 }
 function findCliRoot() {
   const found = findCliPackage();
   if (found) {
     return found.dir;
   }
-  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+  return path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..", "..");
 }
 function getCurrentCliVersion() {
   return findCliPackage()?.pkg.version ?? "0.0.0";
 }
 function resolveCliAssetPath(...segments) {
   const root = findCliRoot();
-  const builtPath = path.join(root, "dist", "assets", ...segments);
-  if (fs.existsSync(builtPath)) {
+  const builtPath = path2.join(root, "dist", "assets", ...segments);
+  if (fs2.existsSync(builtPath)) {
     return builtPath;
   }
-  return path.join(root, ...segments);
+  return path2.join(root, ...segments);
+}
+function resolveCommandCwd(command) {
+  const options = command.opts();
+  return typeof options.cwd === "string" ? path2.resolve(options.cwd) : process.cwd();
 }
 
-// constants/patterns.ts
-var ANSI_ESCAPE_PATTERN = /\u001B\[[0-?]*[ -/]*[@-~]/g;
-var REMOVABLE_NAMESPACE_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var SCHEMA_NAME_PATTERN = /^[a-z][a-zA-Z0-9-]*$/;
-var NAMESPACE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
-var MODULE_SPECIFIER_PATTERN = /(\bfrom\s*|\bimport\s*|\brequire\s*\(\s*|\bimport\s*\(\s*)(['"])([^'"\n]+)\2/g;
-var EXTERNAL_PACKAGE_PATTERN = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*(?:\/[^'"]*)?$/;
-var DEV_PORT_FLAG_PATTERN = /(?:^|\s)(?:--port(?:=|\s+)|-p(?:=|\s+)?)(\d+)(?=\s|$)/;
-var DEV_PORT_ENV_PATTERN = /(?:^|\s)PORT=(\d+)(?=\s|$)/;
-var LOCAL_PROTOCOL_PATTERN = /^(workspace|link|file|portal):/;
-var CONFIG_IMPORT_PATTERN = /^import\s+\{[^}]*\bdefineConfig\b[^}]*\}\s+from\s+['"]betterstart-cli['"];?[^\S\n]*$/m;
-var CONFIG_OBJECT_PATTERNS = [
-  /\b(?:const|let|var)\s+\w+\s*:\s*NextConfig\s*=\s*\{/g,
-  /\b(?:const|let|var)\s+nextConfig\s*=\s*\{/g,
-  /\b(?:const|let|var)\s+\w+\s*:\s*NextConfig\s*=\s*(?:[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*\(\s*)+\{/g,
-  /\b(?:const|let|var)\s+nextConfig\s*=\s*(?:[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*\(\s*)+\{/g,
-  /export\s+default\s+\{/g,
-  /export\s+default\s+(?:[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*\(\s*)+\{/g,
-  /module\.exports\s*=\s*\{/g,
-  /module\.exports\s*=\s*(?:[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*\(\s*)+\{/g
-];
-var ACCEPT_TERMS_URL_PATTERN = /https:\/\/vercel\.com\/\S+\/integrations\/accept-terms\/\S+/i;
-var TERMS_ACCEPTED_PATTERN = /terms accepted/i;
+// adapters/next/template-reader/read-template.ts
+function readTemplate(relativePath) {
+  return fs3.readFileSync(
+    path3.join(resolveCliAssetPath("adapters", "next", "templates", "init"), relativePath),
+    "utf-8"
+  );
+}
+
+// adapters/next/config/namespace/protect-admin-role-literals.ts
+function protectAdminRoleLiterals(content) {
+  const protectedValues = [
+    "UserRole.ADMIN",
+    "'admin'",
+    '"admin"',
+    "`admin`",
+    ">Admin</SelectItem>",
+    "Manage admin users and roles"
+  ];
+  const replacements = [];
+  let protectedContent = content;
+  for (const [index, value] of protectedValues.entries()) {
+    if (!protectedContent.includes(value)) {
+      continue;
+    }
+    const token = `__BETTERSTART_NAMESPACE_PROTECTED_${index}__`;
+    protectedContent = protectedContent.replaceAll(value, token);
+    replacements.push([token, value]);
+  }
+  return {
+    content: protectedContent,
+    restore(value) {
+      let restored = value;
+      for (const [token, original] of replacements) {
+        restored = restored.replaceAll(token, original);
+      }
+      return restored;
+    }
+  };
+}
 
 // constants/scaffolding.ts
 var DEFAULT_ADMIN_NAMESPACE = "admin";
@@ -157,122 +546,7 @@ var R2_ENV_KEYS = [
   "BETTERSTART_R2_PUBLIC_URL"
 ];
 
-// core-engine/utils/string.ts
-function toPascalCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1-$2").split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
-}
-function toCamelCase(str) {
-  const p = toPascalCase(str);
-  return p.charAt(0).toLowerCase() + p.slice(1);
-}
-function singularize(str) {
-  if (str.endsWith("ies")) return `${str.slice(0, -3)}y`;
-  if (str.endsWith("ves")) return `${str.slice(0, -3)}f`;
-  if (str.endsWith("sses") || str.endsWith("xes") || str.endsWith("ches") || str.endsWith("shes") || str.endsWith("zes"))
-    return str.slice(0, -2);
-  if (str.endsWith("s") && !str.endsWith("ss")) return str.slice(0, -1);
-  return str;
-}
-function pluralize(str) {
-  if (str.endsWith("s") && !str.endsWith("ss")) return str;
-  if (str.endsWith("y") && !["ay", "ey", "iy", "oy", "uy"].some((v) => str.endsWith(v)))
-    return `${str.slice(0, -1)}ies`;
-  if (str.endsWith("s") || str.endsWith("x") || str.endsWith("ch") || str.endsWith("sh"))
-    return `${str}es`;
-  return `${str}s`;
-}
-function toKebabCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
-}
-function toScreamingSnake(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toUpperCase();
-}
-function quotePropertyName(name) {
-  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `'${name}'`;
-}
-function singularizeLabel(label) {
-  const words = label.split(" ");
-  const lastWord = words[words.length - 1];
-  words[words.length - 1] = singularize(lastWord.toLowerCase());
-  words[words.length - 1] = words[words.length - 1].charAt(0).toUpperCase() + words[words.length - 1].slice(1);
-  return words.join(" ");
-}
-function singleQuote(value) {
-  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
-}
-function escapeTemplateText(value) {
-  return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
-}
-
-// adapters/next/config/namespace.ts
-function validateAdminNamespace(value) {
-  const segment = value.trim();
-  if (!NAMESPACE_PATTERN.test(segment)) {
-    throw new Error(
-      'Namespace must be one lowercase kebab-case segment starting with a letter, for example "admin" or "admin-panel".'
-    );
-  }
-  return segment;
-}
-function validateAdminDashboardPath(value) {
-  const input = value.trim();
-  const segment = input.startsWith("/") ? input.slice(1) : input;
-  if (input.startsWith("/") && input !== `/${segment}`) {
-    throw new Error(
-      'Dashboard path must be one lowercase kebab-case segment starting with a letter, for example "/admin" or "/admin-panel".'
-    );
-  }
-  try {
-    return validateAdminNamespace(segment);
-  } catch {
-    throw new Error(
-      'Dashboard path must be one lowercase kebab-case segment starting with a letter, for example "/admin" or "/admin-panel".'
-    );
-  }
-}
-function resolveAdminNamespace(value = DEFAULT_ADMIN_NAMESPACE) {
-  const segment = validateAdminNamespace(value);
-  const pascal = toPascalCase(segment);
-  return {
-    segment,
-    alias: `@${segment}`,
-    camel: toCamelCase(segment),
-    pascal,
-    screaming: toScreamingSnake(segment),
-    routePath: `/${segment}`,
-    apiPath: `/api/${segment}`,
-    cssRootClass: `${segment}-root`,
-    globalsFile: `${segment}-globals.css`,
-    routeGroup: `(${segment})`
-  };
-}
-function deriveNamespacePaths(namespaceValue, srcDir) {
-  const namespace = resolveAdminNamespace(namespaceValue);
-  const appBase = srcDir ? "./src/app" : "./app";
-  return {
-    admin: `./${namespace.segment}`,
-    schemas: `./${namespace.segment}/schemas`,
-    pages: `${appBase}/${namespace.routeGroup}/${namespace.segment}/(authenticated)`,
-    login: `${appBase}/${namespace.routeGroup}/${namespace.segment}/(auth)/login`,
-    api: `${appBase}/${namespace.routeGroup}/api/${namespace.segment}`
-  };
-}
-function deriveMigrationsDir(namespaceValue) {
-  const namespace = resolveAdminNamespace(namespaceValue);
-  return `./${namespace.segment}/lib/db/migrations`;
-}
-function replaceAdminDashToken(value, namespace) {
-  return value.replaceAll("admin-", `${namespace.segment}-`);
-}
-function replaceAdminScreamingToken(value, namespace) {
-  return value.replaceAll("ADMIN_", `${namespace.screaming}_`);
-}
-function replaceAdminPascalToken(value, namespace) {
-  return value.replaceAll("Admin", namespace.pascal);
-}
-function replaceAdminCamelToken(value, namespace) {
-  return value.replace(/\badmin(?=[A-Z])/g, namespace.camel);
-}
+// adapters/next/config/namespace/protect-existing-namespace-literals.ts
 function protectExistingNamespaceLiterals(value, namespace) {
   if (namespace.segment === DEFAULT_ADMIN_NAMESPACE) {
     return {
@@ -318,16 +592,31 @@ function protectExistingNamespaceLiterals(value, namespace) {
     }
   };
 }
-function applyAdminNamespaceToPath(filePath, namespaceValue) {
-  const namespace = resolveAdminNamespace(namespaceValue);
-  const canonicalPath = filePath.replaceAll("lib/actions/auth/middleware.ts", "lib/actions/auth/session.ts").replaceAll("lib/actions/auth/auth.ts", "lib/actions/auth/server.ts").replaceAll("lib/actions/r2/r2.ts", "lib/actions/r2/provider.ts").replaceAll("lib/actions/resend/resend.ts", "lib/actions/resend/provider.ts").replaceAll(
-    "lib/actions/mailchimp/mailchimp.ts",
-    "lib/actions/mailchimp/add-to-mailchimp-audience.ts"
-  ).replaceAll("(admin)", namespace.routeGroup).replace(/@admin(?=\/|$)/g, namespace.alias).replace(/\/api\/admin(?=\/|$)/g, namespace.apiPath).replace(/(^|\/)admin(?=\/|$)/g, `$1${namespace.segment}`);
-  const protectedNamespace = protectExistingNamespaceLiterals(canonicalPath, namespace);
-  const namespacedPath = replaceAdminDashToken(protectedNamespace.value, namespace);
-  return protectedNamespace.restore(namespacedPath);
-}
+
+// constants/patterns.ts
+var REMOVABLE_NAMESPACE_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SCHEMA_NAME_PATTERN = /^[a-z][a-zA-Z0-9-]*$/;
+var NAMESPACE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+var MODULE_SPECIFIER_PATTERN = /(\bfrom\s*|\bimport\s*|\brequire\s*\(\s*|\bimport\s*\(\s*)(['"])([^'"\n]+)\2/g;
+var EXTERNAL_PACKAGE_PATTERN = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*(?:\/[^'"]*)?$/;
+var DEV_PORT_FLAG_PATTERN = /(?:^|\s)(?:--port(?:=|\s+)|-p(?:=|\s+)?)(\d+)(?=\s|$)/;
+var DEV_PORT_ENV_PATTERN = /(?:^|\s)PORT=(\d+)(?=\s|$)/;
+var LOCAL_PROTOCOL_PATTERN = /^(workspace|link|file|portal):/;
+var CONFIG_IMPORT_PATTERN = /^import\s+\{[^}]*\bdefineConfig\b[^}]*\}\s+from\s+['"]betterstart-cli['"];?[^\S\n]*$/m;
+var CONFIG_OBJECT_PATTERNS = [
+  /\b(?:const|let|var)\s+\w+\s*:\s*NextConfig\s*=\s*\{/g,
+  /\b(?:const|let|var)\s+nextConfig\s*=\s*\{/g,
+  /\b(?:const|let|var)\s+\w+\s*:\s*NextConfig\s*=\s*(?:[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*\(\s*)+\{/g,
+  /\b(?:const|let|var)\s+nextConfig\s*=\s*(?:[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*\(\s*)+\{/g,
+  /export\s+default\s+\{/g,
+  /export\s+default\s+(?:[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*\(\s*)+\{/g,
+  /module\.exports\s*=\s*\{/g,
+  /module\.exports\s*=\s*(?:[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*\(\s*)+\{/g
+];
+var ACCEPT_TERMS_URL_PATTERN = /https:\/\/vercel\.com\/\S+\/integrations\/accept-terms\/\S+/i;
+var TERMS_ACCEPTED_PATTERN = /terms accepted/i;
+
+// adapters/next/config/namespace/is-external-module-specifier.ts
 function isExternalModuleSpecifier(specifier) {
   if (specifier.startsWith(".") || specifier.startsWith("/")) {
     return false;
@@ -337,6 +626,8 @@ function isExternalModuleSpecifier(specifier) {
   }
   return EXTERNAL_PACKAGE_PATTERN.test(specifier);
 }
+
+// adapters/next/config/namespace/protect-external-module-specifiers.ts
 function protectExternalModuleSpecifiers(content) {
   const replacements = [];
   const protectedContent = content.replace(
@@ -361,36 +652,57 @@ function protectExternalModuleSpecifiers(content) {
     }
   };
 }
-function protectAdminRoleLiterals(content) {
-  const protectedValues = [
-    "UserRole.ADMIN",
-    "'admin'",
-    '"admin"',
-    "`admin`",
-    ">Admin</SelectItem>",
-    "Manage admin users and roles"
-  ];
-  const replacements = [];
-  let protectedContent = content;
-  for (const [index, value] of protectedValues.entries()) {
-    if (!protectedContent.includes(value)) {
-      continue;
-    }
-    const token = `__BETTERSTART_NAMESPACE_PROTECTED_${index}__`;
-    protectedContent = protectedContent.replaceAll(value, token);
-    replacements.push([token, value]);
+
+// adapters/next/config/namespace/replace-admin-camel-token.ts
+function replaceAdminCamelToken(value, namespace) {
+  return value.replace(/\badmin(?=[A-Z])/g, namespace.camel);
+}
+
+// adapters/next/config/namespace/replace-admin-dash-token.ts
+function replaceAdminDashToken(value, namespace) {
+  return value.replaceAll("admin-", `${namespace.segment}-`);
+}
+
+// adapters/next/config/namespace/replace-admin-pascal-token.ts
+function replaceAdminPascalToken(value, namespace) {
+  return value.replaceAll("Admin", namespace.pascal);
+}
+
+// adapters/next/config/namespace/replace-admin-screaming-token.ts
+function replaceAdminScreamingToken(value, namespace) {
+  return value.replaceAll("ADMIN_", `${namespace.screaming}_`);
+}
+
+// adapters/next/config/namespace/validate-admin-namespace.ts
+function validateAdminNamespace(value) {
+  const segment = value.trim();
+  if (!NAMESPACE_PATTERN.test(segment)) {
+    throw new Error(
+      'Namespace must be one lowercase kebab-case segment starting with a letter, for example "admin" or "admin-panel".'
+    );
   }
+  return segment;
+}
+
+// adapters/next/config/namespace/resolve-admin-namespace.ts
+function resolveAdminNamespace(value = DEFAULT_ADMIN_NAMESPACE) {
+  const segment = validateAdminNamespace(value);
+  const pascal = toPascalCase(segment);
   return {
-    content: protectedContent,
-    restore(value) {
-      let restored = value;
-      for (const [token, original] of replacements) {
-        restored = restored.replaceAll(token, original);
-      }
-      return restored;
-    }
+    segment,
+    alias: `@${segment}`,
+    camel: toCamelCase(segment),
+    pascal,
+    screaming: toScreamingSnake(segment),
+    routePath: `/${segment}`,
+    apiPath: `/api/${segment}`,
+    cssRootClass: `${segment}-root`,
+    globalsFile: `${segment}-globals.css`,
+    routeGroup: `(${segment})`
   };
 }
+
+// adapters/next/config/namespace/apply-admin-namespace-to-content.ts
 function applyAdminNamespaceToContent(content, namespaceValue) {
   const namespace = resolveAdminNamespace(namespaceValue);
   const { content: externalSafeContent, restore: restoreExternalModules } = protectExternalModuleSpecifiers(content);
@@ -416,42 +728,64 @@ function applyAdminNamespaceToContent(content, namespaceValue) {
   return restoreExternalModules(restore(protectedNamespace.restore(namespacedContent)));
 }
 
-// adapters/next/template-reader.ts
-function readTemplate(relativePath) {
-  return fs2.readFileSync(
-    path2.join(resolveCliAssetPath("adapters", "next", "templates", "init"), relativePath),
-    "utf-8"
-  );
-}
-function applyNextCacheApiForVersion(content, nextMajorVersion) {
-  if (nextMajorVersion >= 16) {
-    return content;
-  }
-  return content.replace(
-    /import \{ cacheLife, cacheTag \} from 'next\/cache'\n/g,
-    "import { unstable_cacheTag as cacheTag } from 'next/cache'\n"
-  ).replace(/\n {2}cacheLife\('max'\)/g, "").replace(
-    /import \{ updateTag \} from 'next\/cache'\n/g,
-    "import { revalidateTag } from 'next/cache'\n"
-  ).replace(/revalidateTag\(([^,\n]+), \{ expire: 0 \}\)/g, "revalidateTag($1)").replace(/\bupdateTag\(/g, "revalidateTag(");
-}
-function readNamespacedTemplate(relativePath, namespace) {
-  return applyAdminNamespaceToContent(readTemplate(relativePath), namespace);
-}
-function namespacedTemplatePath(relativePath, namespace) {
-  return applyAdminNamespaceToPath(relativePath, namespace);
-}
-
 export {
+  BETTERSTART_DIR,
+  CONFIG_FILE_NAME,
+  LOCKFILE_MAP,
+  CLI_PACKAGE_NAME,
+  REDACTED,
+  stripAnsi,
   toPascalCase,
   toCamelCase,
   singularize,
   pluralize,
   toKebabCase,
   quotePropertyName,
+  humanizeName,
   singularizeLabel,
-  singleQuote,
+  quoteLiteral,
   escapeTemplateText,
+  normalizeLineEndings,
+  escapeRegExp,
+  hasConflictMarkers,
+  splitLines,
+  normalizeWhitespace,
+  escapeJsx,
+  escapeAttribute,
+  findNextNonEmptyLine,
+  levenshtein,
+  toTitleCase,
+  slugify,
+  usesIdentifier,
+  detectIndent,
+  jsString,
+  safeIdentifier,
+  findUpwards,
+  hashContent,
+  ensureDir,
+  safeWriteFile,
+  createGeneratedFile,
+  toStrictJson,
+  parseDotenvFile,
+  readEnvVar,
+  resolveProjectEnvVar,
+  readProjectEnvVar,
+  appendEnvVars,
+  removeEnvVars,
+  captureFile,
+  restoreFile,
+  readNonEmptyEnvVar,
+  betterstartDir,
+  toPosixPath,
+  trimDotSlash,
+  normalizePosixDir,
+  toProjectAbsolutePath,
+  readLocalProjectFile,
+  removePath,
+  cleanupEmptyDirs,
+  getCurrentCliVersion,
+  resolveCliAssetPath,
+  resolveCommandCwd,
   DEFAULT_ADMIN_NAMESPACE,
   ADMIN_THEME_BLOCK,
   ADMIN_SHADOW_INPUT_UTILITY,
@@ -465,7 +799,6 @@ export {
   TIPTAP_CONTENT_EDITOR_DIRECTORIES,
   RAILWAY_BUCKET_ENV_KEYS,
   R2_ENV_KEYS,
-  ANSI_ESCAPE_PATTERN,
   REMOVABLE_NAMESPACE_PATTERN,
   SCHEMA_NAME_PATTERN,
   DEV_PORT_FLAG_PATTERN,
@@ -476,19 +809,10 @@ export {
   ACCEPT_TERMS_URL_PATTERN,
   TERMS_ACCEPTED_PATTERN,
   validateAdminNamespace,
-  validateAdminDashboardPath,
   resolveAdminNamespace,
-  deriveNamespacePaths,
-  deriveMigrationsDir,
-  applyAdminNamespaceToPath,
-  applyAdminNamespaceToContent,
-  CLI_PACKAGE_NAME,
-  REDACTED,
-  getCurrentCliVersion,
-  resolveCliAssetPath,
   readTemplate,
-  applyNextCacheApiForVersion,
-  readNamespacedTemplate,
-  namespacedTemplatePath
+  protectExistingNamespaceLiterals,
+  replaceAdminDashToken,
+  applyAdminNamespaceToContent
 };
-//# sourceMappingURL=chunk-SO2CAJFC.js.map
+//# sourceMappingURL=chunk-TIJEHWRF.js.map