betterstart-cli 0.0.99 → 0.0.100

package/dist/{chunk-SO2CAJFC.js → chunk-45Z6XDG5.js}

@@ -1,58 +1,407 @@
 // adapters/next/template-reader.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, "-");
+}
+
+// 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);
     }
-    dir = parentDir;
+    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;
+    }
+    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 });
+  }
+}
+
+// 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);
 }
 
 // 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]+)*$/;
@@ -157,53 +506,6 @@ 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();
@@ -418,8 +720,8 @@ function applyAdminNamespaceToContent(content, namespaceValue) {
 
 // adapters/next/template-reader.ts
 function readTemplate(relativePath) {
-  return fs2.readFileSync(
-    path2.join(resolveCliAssetPath("adapters", "next", "templates", "init"), relativePath),
+  return fs3.readFileSync(
+    path3.join(resolveCliAssetPath("adapters", "next", "templates", "init"), relativePath),
     "utf-8"
   );
 }
@@ -443,15 +745,57 @@ function namespacedTemplatePath(relativePath, namespace) {
 }
 
 export {
+  BETTERSTART_DIR,
+  CONFIG_FILE_NAME,
+  LOCKFILE_MAP,
+  stripAnsi,
   toPascalCase,
   toCamelCase,
   singularize,
   pluralize,
   toKebabCase,
   quotePropertyName,
+  humanizeName,
   singularizeLabel,
-  singleQuote,
+  quoteLiteral,
   escapeTemplateText,
+  normalizeLineEndings,
+  escapeRegExp,
+  hasConflictMarkers,
+  splitLines,
+  normalizeWhitespace,
+  escapeJsx,
+  escapeAttribute,
+  findNextNonEmptyLine,
+  levenshtein,
+  toTitleCase,
+  slugify,
+  findUpwards,
+  hashContent,
+  ensureDir,
+  safeWriteFile,
+  createGeneratedFile,
+  toStrictJson,
+  parseDotenvFile,
+  readEnvVar,
+  resolveProjectEnvVar,
+  readProjectEnvVar,
+  appendEnvVars,
+  removeEnvVars,
+  captureFile,
+  restoreFile,
+  CLI_PACKAGE_NAME,
+  REDACTED,
+  betterstartDir,
+  toPosixPath,
+  trimDotSlash,
+  normalizePosixDir,
+  toProjectAbsolutePath,
+  readLocalProjectFile,
+  removePath,
+  cleanupEmptyDirs,
+  getCurrentCliVersion,
+  resolveCliAssetPath,
   DEFAULT_ADMIN_NAMESPACE,
   ADMIN_THEME_BLOCK,
   ADMIN_SHADOW_INPUT_UTILITY,
@@ -465,7 +809,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,
@@ -482,13 +825,9 @@ export {
   deriveMigrationsDir,
   applyAdminNamespaceToPath,
   applyAdminNamespaceToContent,
-  CLI_PACKAGE_NAME,
-  REDACTED,
-  getCurrentCliVersion,
-  resolveCliAssetPath,
   readTemplate,
   applyNextCacheApiForVersion,
   readNamespacedTemplate,
   namespacedTemplatePath
 };
-//# sourceMappingURL=chunk-SO2CAJFC.js.map
+//# sourceMappingURL=chunk-45Z6XDG5.js.map