@cellajs/create-cella 0.1.7 → 0.2.1

package/dist/index.js

@@ -1,19 +1,18 @@
 #!/usr/bin/env tsx
 
-// src/index.ts
-import { basename as basename2, resolve as resolve2 } from "node:path";
-import { existsSync as existsSync2 } from "node:fs";
-import colors3 from "picocolors";
-import { input, confirm, select } from "@inquirer/prompts";
+// src/create-cella-cli.ts
+import { existsSync as existsSync2 } from "fs";
+import { basename as basename2, resolve as resolve3 } from "path";
+import { input, select } from "@inquirer/prompts";
+import pc5 from "picocolors";
 
-// src/cli.ts
-import { basename, resolve } from "node:path";
-import { Command, InvalidArgumentError } from "commander";
+// src/constants.ts
+import pc from "picocolors";
 
 // package.json
 var package_default = {
   name: "@cellajs/create-cella",
-  version: "0.1.7",
+  version: "0.2.1",
   private: false,
   license: "MIT",
   description: "Cella is a TypeScript template to create web apps with sync and offline capabilities.",
@@ -28,39 +27,59 @@ var package_default = {
   homepage: "https://cellajs.com",
   author: "CellaJS <info@cellajs.com>",
   engines: {
-    node: ">=20.14.0"
+    node: "24.x"
   },
   type: "module",
-  main: "./src/index.ts",
+  main: "./dist/index.js",
+  files: [
+    "configs",
+    "dist",
+    "index.js",
+    "README.md"
+  ],
+  imports: {
+    "#/*": "./src/*"
+  },
   bin: {
     "create-cella": "index.js"
   },
   scripts: {
-    start: "tsx ./src/index.ts",
+    start: "tsx ./src/create-cella-cli.ts",
     clean: "rimraf ./dist",
     build: "tsup",
     "test-build": "pnpm run build && node index.js",
-    prepublishOnly: "pnpm run build"
+    prepublishOnly: "pnpm run test:release",
+    check: "pnpm ts && pnpm biome check --write .",
+    ts: "tsgo --pretty",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    test: "vitest run",
+    "test:release": "pnpm run build && vitest run tests/release-artifact.test.ts",
+    "test:watch": "vitest"
   },
-  packageManager: "pnpm@9.11.0",
   dependencies: {
-    "@inquirer/prompts": "^6.0.1",
-    axios: "^1.8.3",
-    commander: "^12.1.0",
-    "cross-spawn": "^7.0.3",
-    giget: "^1.2.3",
-    picocolors: "^1.1.0",
-    "validate-npm-package-name": "^5.0.1",
-    "yocto-spinner": "^0.1.0"
+    "@inquirer/prompts": "^8.5.2",
+    axios: "^1.17.0",
+    commander: "^15.0.0",
+    giget: "^3.1.2",
+    "nano-spawn": "^2.0.0",
+    ora: "^9.3.0",
+    picocolors: "^1.1.1",
+    "validate-npm-package-name": "^8.0.0"
   },
   devDependencies: {
-    tsup: "^8.3.5",
-    tsx: "^4.19.2"
+    "@types/node": "catalog:",
+    "@typescript/native-preview": "catalog:",
+    "@types/validate-npm-package-name": "^4.0.2",
+    tsup: "catalog:",
+    tsx: "catalog:",
+    vitest: "catalog:"
   }
 };
 
 // src/constants.ts
-var NAME = "create-cella";
+var NAME = "create cella";
+var DIVIDER = "\u2500".repeat(60);
 var TEMPLATE_URL = "github:cellajs/cella";
 var CELLA_REMOTE_URL = "git@github.com:cellajs/cella.git";
 var DESCRIPTION = package_default.description;
@@ -68,41 +87,190 @@ var VERSION = package_default.version;
 var AUTHOR = package_default.author;
 var WEBSITE = package_default.homepage;
 var GITHUB = package_default.repository.url;
-var TO_REMOVE = [
-  "info",
-  "./cli/create-cella"
-];
-var TO_CLEAN = [
-  "./backend/drizzle"
-];
+function getHeaderLine(templateVersion) {
+  const leftText = `\u29C8 ${NAME} \xB7 v${VERSION} \xB7 cella v${templateVersion}`;
+  const rightText = package_default.homepage.replace("https://", "");
+  const left = `${pc.cyan(`\u29C8 ${NAME}`)} ${pc.dim(`\xB7 v${VERSION} \xB7 cella v${templateVersion}`)}`;
+  const right = pc.cyan(rightText);
+  const padding = Math.max(1, 60 - leftText.length - rightText.length);
+  return `${left}${" ".repeat(padding)}${right}`;
+}
+var TO_REMOVE = ["./cli/create", "./info/QUICKSTART.md"];
+var TO_CLEAN = ["./backend/drizzle"];
 var TO_COPY = {
-  "./backend/.env.example": "./backend/.env",
   "./frontend/.env.example": "./frontend/.env",
   "./info/QUICKSTART.md": "README.md"
 };
-var TO_EDIT = {
-  "./config/default.ts": [
-    {
-      regexMatch: /enabledAuthenticationStrategies:\s*\[[^\]]+\]\s*as\s*const,/g,
-      replaceWith: "enabledAuthenticationStrategies: ['password', 'passkey'] as const,"
+var PLACEHOLDER_CONFIG = "./cli/create-cella/configs/default-config.ts.template";
+async function generateEnvFromExample(examplePath, replacements) {
+  const { readFile: readFile2 } = await import("fs/promises");
+  let content;
+  try {
+    content = await readFile2(examplePath, "utf8");
+  } catch {
+    return null;
+  }
+  return content.replace(/^([A-Z_][A-Z0-9_]*)=(.*)$/gm, (match, key, _value) => {
+    if (key in replacements) return `${key}=${replacements[key]}`;
+    return match;
+  });
+}
+function getRootEnvReplacements(slug, portOffset) {
+  return {
+    PROJECT_SLUG: slug,
+    DB_PORT: String(5432 + portOffset),
+    DB_TEST_PORT: String(5434 + portOffset)
+  };
+}
+function getBackendEnvReplacements(adminEmail, portOffset) {
+  const db = 5432 + portOffset;
+  return {
+    DATABASE_URL: `postgres://runtime_role:dev_password@0.0.0.0:${db}/postgres`,
+    DATABASE_ADMIN_URL: `postgres://postgres:postgres@0.0.0.0:${db}/postgres`,
+    DATABASE_CDC_URL: `postgres://admin_role:dev_password@0.0.0.0:${db}/postgres`,
+    ADMIN_EMAIL: adminEmail,
+    PORT: String(4e3 + portOffset)
+  };
+}
+function generateEnvConfigs(slug, name, portOffset) {
+  const fe = 3e3 + portOffset;
+  const be = 4e3 + portOffset;
+  const header = "import type { DeepPartial } from '../src/builder/types';\nimport type _default from './config.default';\n";
+  const envs = {
+    development: {
+      props: {
+        slug: `${slug}-development`,
+        debug: false,
+        domain: "",
+        frontendUrl: `http://localhost:${fe}`,
+        backendUrl: `http://localhost:${be}`,
+        backendAuthUrl: `http://localhost:${be}/auth`
+      }
     },
-    {
-      regexMatch: /uploadEnabled\:\s*(true|false),/g,
-      replaceWith: "uploadEnabled: false,"
+    staging: {
+      props: {
+        slug: `${slug}-staging`,
+        debug: false,
+        domain: `${slug}.example.com`,
+        frontendUrl: `https://staging.${slug}.example.com`,
+        backendUrl: `https://api-staging.${slug}.example.com`,
+        backendAuthUrl: `https://api-staging.${slug}.example.com/auth`
+      }
     },
-    {
-      regexMatch: /enabledOauthProviders:\s*\[[^\]]+\]\s*as\s*const,/g,
-      replaceWith: "enabledOauthProviders: [] as const,"
-    }
-  ]
-};
-var LOGO = `
-                         _ _            
-    \u2592\u2593\u2588\u2588\u2588\u2588\u2588\u2593\u2592     ___ ___| | | __ _
-    \u2592\u2593\u2588   \u2588\u2593\u2592    / __/ _ \\ | |/ _\` |
-    \u2592\u2593\u2588   \u2588\u2593\u2592   | (_|  __/ | | (_| |
-    \u2592\u2593\u2588\u2588\u2588\u2588\u2588\u2593\u2592    \\___\\___|_|_|\\__,_|
+    tunnel: {
+      props: {
+        frontendUrl: `https://localhost:${fe}`,
+        backendUrl: `https://${slug}.ngrok.dev`,
+        backendAuthUrl: `https://${slug}.ngrok.dev/auth`
+      }
+    },
+    test: {
+      imports: "import development from './config.development';\n",
+      props: {
+        debug: false,
+        domain: "",
+        frontendUrl: "=development.frontendUrl",
+        backendUrl: "=development.backendUrl",
+        backendAuthUrl: "=development.backendAuthUrl"
+      }
+    },
+    production: { props: { maintenance: false } }
+  };
+  const lit = (v) => {
+    if (typeof v === "boolean") return String(v);
+    if (v.startsWith("=")) return v.slice(1);
+    return `'${v}'`;
+  };
+  const result = {};
+  for (const [mode, { imports = "", props }] of Object.entries(envs)) {
+    const nameEntry = mode !== "production" ? `  name: '${name} ${mode.toUpperCase()}',
+` : "";
+    const body = Object.entries(props).map(([k, v]) => `  ${k}: ${lit(v)},`).join("\n");
+    result[`./shared/config/config.${mode}.ts`] = `${imports}${header}
+export default {
+  mode: '${mode}',
+${nameEntry}${body}
+} satisfies DeepPartial<typeof _default>;
 `;
+  }
+  return result;
+}
+
+// src/create.ts
+import { existsSync } from "fs";
+import { cp, mkdir } from "fs/promises";
+import { join, relative, resolve as resolve2 } from "path";
+import { downloadTemplate } from "giget";
+
+// src/utils/git/command.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function runGitCommand(args, repoPath, options2 = {}) {
+  const gitArgs = repoPath ? ["-C", repoPath, ...args] : args;
+  const env = {
+    ...process.env,
+    ...options2.skipEditor ? { GIT_EDITOR: "true" } : {}
+  };
+  const maxBuffer = options2.maxBuffer ?? 10 * 1024 * 1024;
+  const { stdout } = await execFileAsync("git", gitArgs, { env, maxBuffer });
+  return stdout.trim();
+}
+async function gitInit(repoPath) {
+  return runGitCommand(["init"], repoPath);
+}
+async function gitAddAll(repoPath) {
+  return runGitCommand(["add", "."], repoPath);
+}
+async function gitCommit(repoPath, message) {
+  return runGitCommand(["commit", "-m", message], repoPath);
+}
+async function gitBranch(repoPath, branchName) {
+  return runGitCommand(["branch", branchName], repoPath);
+}
+async function gitCheckout(repoPath, branchName) {
+  return runGitCommand(["checkout", branchName], repoPath);
+}
+async function gitRemoteGetUrl(repoPath, remoteName) {
+  return runGitCommand(["remote", "get-url", remoteName], repoPath);
+}
+async function gitRemoteAdd(repoPath, remoteName, remoteUrl) {
+  return runGitCommand(["remote", "add", remoteName, remoteUrl], repoPath);
+}
+async function gitRemoteRemove(repoPath, remoteName) {
+  return runGitCommand(["remote", "remove", remoteName], repoPath);
+}
+
+// src/add-remote.ts
+async function addRemote({
+  targetFolder,
+  remoteUrl = CELLA_REMOTE_URL,
+  remoteName = "upstream",
+  silent = false
+}) {
+  try {
+    let remote = null;
+    try {
+      remote = await gitRemoteGetUrl(targetFolder, remoteName);
+    } catch {
+      remote = null;
+    }
+    if (!remote) {
+      await gitRemoteAdd(targetFolder, remoteName, remoteUrl);
+    } else if (remote !== remoteUrl) {
+      await gitRemoteRemove(targetFolder, remoteName);
+      await gitRemoteAdd(targetFolder, remoteName, remoteUrl);
+    }
+  } catch (error) {
+    if (!silent) {
+      throw error;
+    }
+  }
+}
+
+// src/modules/cli/commands.ts
+import { basename, resolve } from "path";
+import { Command, InvalidArgumentError } from "commander";
 
 // src/utils/validate-project-name.ts
 import validate from "validate-npm-package-name";
@@ -113,180 +281,137 @@ function validateProjectName(name) {
   }
   return {
     valid: false,
-    problems: [
-      ...nameValidation.errors || [],
-      ...nameValidation.warnings || []
-    ]
+    problems: [...nameValidation.errors || [], ...nameValidation.warnings || []]
   };
 }
 
-// src/cli.ts
+// src/modules/cli/commands.ts
 var directory = null;
 var newBranchName = null;
-var createNewBranch = null;
 var packageManager = "pnpm";
-var command = new Command(NAME).version(
-  VERSION,
-  "-v, --version",
-  `Output the current version of ${NAME}.`
-).argument("[directory]", "The directory name for the new project.").usage("[directory] [options]").helpOption("-h, --help", "Display this help message.").option("--skip-new-branch", "Skip creating a new branch during initialization.", false).option("--skip-install", "Skip the installation of packages.", false).option("--skip-generate", "Skip generating SQL files.", false).option("--skip-clean", "Skip cleaning the `cella` template.", false).option("--skip-git", "Skip initializing a git repository.", false).option(
-  "--new-branch-name <name>",
-  "Specify a new branch name to create and use.",
-  (name) => {
-    if (typeof name === "string") {
-      name = name.trim();
-    }
-    if (name) {
-      const validation = validateProjectName(basename(resolve(name)));
-      if (!validation.valid) {
-        throw new InvalidArgumentError(
-          `Invalid branch name: ${validation.problems[0]}`
-        );
-      }
-      createNewBranch = true;
-      newBranchName = name;
-    }
-  }
-).action((name) => {
-  if (typeof name === "string") {
-    name = name.trim();
-  }
-  if (name) {
-    const validation = validateProjectName(basename(resolve(name)));
+var command = new Command(NAME).version(VERSION, "-v, --version", `output the current version of ${NAME}`).argument("[directory]", "the directory name for the new project").usage("[directory] [options]").helpOption("-h, --help", "display this help message").option("--template <path>", "use a custom template (local path or github:user/repo)").action((name) => {
+  const trimmedName = typeof name === "string" ? name.trim() : name;
+  if (trimmedName) {
+    const validation = validateProjectName(basename(resolve(trimmedName)));
     if (!validation.valid) {
-      throw new InvalidArgumentError(
-        `Invalid project name: ${validation.problems[0]}`
-      );
+      throw new InvalidArgumentError(`Invalid project name: ${validation.problems?.[0] ?? "unknown error"}`);
     }
-    directory = name;
+    directory = trimmedName;
   }
 }).parse();
-var options = command.opts({
-  skipNewBranch: false,
-  skipClean: false,
-  skipGit: false,
-  skipInstall: false,
-  skipGenerate: false
-});
-var cli = {
-  options,
-  args: command.args,
-  directory,
-  newBranchName,
-  createNewBranch,
-  packageManager
-};
-
-// src/utils/extract-package-json-version-from-uri.ts
-import axios from "axios";
-async function extractPackageJsonVersionFromUri(repositoryUrl, branch = "main") {
-  const [owner, repo] = repositoryUrl.replace("github:", "").split("/");
-  const packageJsonUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/package.json`;
-  try {
-    const response = await axios.get(packageJsonUrl);
-    const packageJson = response.data;
-    return packageJson.version || "unknown";
-  } catch (error) {
-    return "unknown";
-  }
-}
-
-// src/utils/is-empty-directory.ts
-import { readdir } from "node:fs/promises";
-async function isEmptyDirectory(path2) {
-  const files = await readdir(path2);
-  return files.length === 0 || files.length === 1 && files[0] === ".git";
+var options = command.opts();
+function runCli() {
+  return {
+    options,
+    args: command.args,
+    directory,
+    newBranchName,
+    packageManager
+  };
 }
+var cli = runCli();
 
-// src/create.ts
-import { mkdir } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { join, relative } from "node:path";
-import colors2 from "picocolors";
-import { downloadTemplate } from "giget";
-import yoctoSpinner2 from "yocto-spinner";
-
-// src/utils/run-package-manager-command.ts
-import spawn from "cross-spawn";
-async function runPackageManagerCommand(packageManager2, args, env = {}) {
-  return new Promise((resolve3, reject) => {
-    const child = spawn(packageManager2, args, {
-      env: {
-        ...process.env,
-        ...env
-      },
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stderrBuffer = "";
-    let stdoutBuffer = "";
-    child.stderr?.on("data", (data) => {
-      stderrBuffer += data.toString();
-    });
-    child.stdout?.on("data", (data) => {
-      stdoutBuffer += data.toString();
-    });
-    child.on("close", (code) => {
-      if (code !== 0) {
-        reject(
-          `"${packageManager2} ${args.join(" ")}" failed ${stdoutBuffer} ${stderrBuffer}`
-        );
-        return;
-      }
-      resolve3();
-    });
-  });
+// src/modules/cli/display.ts
+import pc2 from "picocolors";
+function showAscii() {
+  console.info(pc2.cyan("                      _ _            "));
+  console.info(pc2.cyan("\u2592\u2593\u2588\u2588\u2588\u2588\u2588\u2593\u2592     ___ ___| | | __ _      "));
+  console.info(pc2.cyan("\u2592\u2593\u2588   \u2588\u2593\u2592    / __/ _ \\ | |/ _` |    "));
+  console.info(pc2.cyan("\u2592\u2593\u2588   \u2588\u2593\u2592   | (_|  __/ | | (_| |     "));
+  console.info(pc2.cyan("\u2592\u2593\u2588\u2588\u2588\u2588\u2588\u2593\u2592    \\___\\___|_|_|\\__,_|  "));
 }
-async function install(packageManager2) {
-  return runPackageManagerCommand(packageManager2, ["install"], {
-    NODE_ENV: "development"
-  });
+function showWelcome(templateVersion) {
+  console.info();
+  showAscii();
+  console.info();
+  console.info(pc2.dim(DESCRIPTION));
+  console.info();
+  console.info(getHeaderLine(templateVersion));
+  console.info(DIVIDER);
 }
-async function generate(packageManager2) {
-  return runPackageManagerCommand(packageManager2, ["generate"], {
-    NODE_ENV: "development"
-  });
+function showSuccess(projectName, _targetFolder, relativePath, needsCd, packageManager2) {
+  console.info(DIVIDER);
+  console.info();
+  if (needsCd) {
+    console.info(`${pc2.green("\u2192")} cd ${pc2.cyan(relativePath)}`);
+    console.info();
+  }
+  console.info(`${pc2.green("\u2192")} ${pc2.cyan(`${packageManager2} quick`)}       ${pc2.gray("(pglite, no docker)")}`);
+  console.info();
+  console.info(pc2.gray("or, for full setup:"));
+  console.info();
+  console.info(
+    `${pc2.green("\u2192")} ${pc2.cyan(`${packageManager2} docker`)} ${pc2.dim("&&")} ${pc2.cyan(`${packageManager2} seed`)} ${pc2.dim("&&")} ${pc2.cyan(`${packageManager2} dev`)}`
+  );
+  console.info();
+  console.info(`sign in: ${pc2.gray("admin-test@cellajs.com / 12345678")}`);
+  console.info();
+  console.info(`enjoy building ${pc2.green(projectName)} with cella!`);
+  console.info();
 }
 
 // src/utils/clean-template.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-import colors from "picocolors";
+import fs from "fs/promises";
+import path from "path";
+import pc3 from "picocolors";
+var warningMark = pc3.yellow("\u26A0");
 async function cleanTemplate({
   targetFolder,
-  projectName
+  projectName,
+  displayName,
+  portOffset = 0,
+  adminEmail = `admin@${projectName}.example.com`
 }) {
   if (process.cwd() !== targetFolder) {
     process.chdir(targetFolder);
   }
-  return new Promise(async (resolve3, reject) => {
-    try {
-      for (const [src, dest] of Object.entries(TO_COPY)) {
-        const srcAbsolutePath = path.resolve(targetFolder, src);
-        const destAbsolutePath = path.resolve(targetFolder, dest);
-        await copyFile(srcAbsolutePath, destAbsolutePath);
+  return new Promise((resolve4, reject) => {
+    (async () => {
+      try {
+        for (const [src, dest] of Object.entries(TO_COPY)) {
+          const srcAbsolutePath = path.resolve(targetFolder, src);
+          const destAbsolutePath = path.resolve(targetFolder, dest);
+          await copyFile(srcAbsolutePath, destAbsolutePath);
+        }
+        await applyPlaceholderConfig(targetFolder, projectName);
+        const rootReplacements = getRootEnvReplacements(projectName, portOffset);
+        const rootEnv = await generateEnvFromExample(path.resolve(targetFolder, ".env.example"), rootReplacements);
+        await fs.writeFile(
+          path.resolve(targetFolder, ".env"),
+          rootEnv ?? Object.entries(rootReplacements).map(([k, v]) => `${k}=${v}`).join("\n"),
+          "utf8"
+        );
+        const backendReplacements = getBackendEnvReplacements(adminEmail, portOffset);
+        const backendEnv = await generateEnvFromExample(
+          path.resolve(targetFolder, "backend/.env.example"),
+          backendReplacements
+        );
+        if (backendEnv) {
+          await fs.writeFile(path.resolve(targetFolder, "backend/.env"), backendEnv, "utf8");
+        }
+        const envConfigs = generateEnvConfigs(projectName, displayName, portOffset);
+        await Promise.all(
+          Object.entries(envConfigs).map(
+            ([filePath, content]) => fs.writeFile(path.resolve(targetFolder, filePath), content, "utf8")
+          )
+        );
+        await Promise.all(
+          TO_CLEAN.map((folderPath) => {
+            const absolutePath = path.resolve(targetFolder, folderPath);
+            return removeFolderContents(absolutePath);
+          })
+        );
+        await Promise.all(
+          TO_REMOVE.map((filePath) => {
+            const absolutePath = path.resolve(targetFolder, filePath);
+            return removeFileOrFolder(absolutePath);
+          })
+        );
+        resolve4();
+      } catch (err) {
+        reject(`Error during the cleaning process: ${err}`);
       }
-      await Promise.all(
-        TO_CLEAN.map((folderPath) => {
-          const absolutePath = path.resolve(targetFolder, folderPath);
-          return removeFolderContents(absolutePath);
-        })
-      );
-      await Promise.all(
-        TO_REMOVE.map((filePath) => {
-          const absolutePath = path.resolve(targetFolder, filePath);
-          return removeFileOrFolder(absolutePath);
-        })
-      );
-      await Promise.all(
-        Object.entries(TO_EDIT).map(async ([filePath, edits]) => {
-          const absolutePath = path.resolve(targetFolder, filePath);
-          await editFile(absolutePath, edits);
-        })
-      );
-      resolve3();
-    } catch (err) {
-      reject(`Error during the cleaning process: ${err}`);
-    }
+    })();
   });
 }
 async function removeFolderContents(folderPath) {
@@ -314,320 +439,360 @@ async function copyFile(src, dest) {
   } catch (err) {
     if (err.code === "ENOENT") {
       console.info(`
-${colors.yellow("\u26A0")} Source file "${src}" does not exist > Skip copy`);
+${warningMark} Source file "${src}" does not exist > Skip copy`);
     } else {
       throw err;
     }
   }
 }
-async function editFile(filePath, edits) {
+async function applyPlaceholderConfig(targetFolder, projectName) {
+  const displayName = projectName.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  const src = path.resolve(targetFolder, PLACEHOLDER_CONFIG);
+  const dest = path.resolve(targetFolder, "./shared/config/config.default.ts");
   try {
-    await fs.access(filePath);
-    const fileContent = await fs.readFile(filePath, "utf8");
-    let updatedContent = fileContent;
-    edits.forEach(({ regexMatch, replaceWith }) => {
-      updatedContent = updatedContent.replace(regexMatch, replaceWith);
-    });
-    if (fileContent !== updatedContent) {
-      await fs.writeFile(filePath, updatedContent, "utf8");
-    }
+    let content = await fs.readFile(src, "utf8");
+    content = content.replaceAll("__project_name__", displayName);
+    content = content.replaceAll("__project_slug__", projectName);
+    await fs.writeFile(dest, content, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       console.info(`
-${colors.yellow("\u26A0")} Source file "${filePath}" does not exist > Skip edit`);
+${warningMark} Placeholder config "${src}" not found > Skip`);
     } else {
       throw err;
     }
   }
 }
 
-// src/utils/run-git-command.ts
-import { spawn as spawn2 } from "node:child_process";
-function getGitCommandType(command2) {
-  if (command2.startsWith("merge")) return "merge";
-  if (command2.startsWith("diff")) return "diff";
-  return "other";
-}
-function isGitCommandSuccess(gitCommand, code, errOutput) {
-  if (gitCommand === "merge") return code === 0 || code === 1 && !errOutput;
-  if (gitCommand === "diff") return code === 0 || code === 2 && !errOutput;
-  return code === 0;
-}
-async function runGitCommand({ targetFolder, command: command2 }) {
-  return new Promise((resolve3, reject) => {
-    const gitCommand = getGitCommandType(command2);
-    const child = spawn2(`git ${command2}`, [], { cwd: targetFolder, shell: true, timeout: 6e4 });
-    let output = "";
-    let errOutput = "";
-    child.on("error", (error) => {
-      reject(error);
-    });
-    child.on("exit", (code) => {
-      if (isGitCommandSuccess(gitCommand, code, errOutput)) {
-        resolve3(output.trim());
+// src/utils/progress.ts
+import ora from "ora";
+import pc4 from "picocolors";
+var activeSpinner = null;
+function createProgress(title, silent = false) {
+  const completedSteps = [];
+  const spinner = ora({
+    text: title,
+    isSilent: silent
+  });
+  activeSpinner = spinner;
+  spinner.start();
+  const log = (msg) => {
+    if (!silent) console.info(msg);
+  };
+  return {
+    step: (message) => {
+      if (completedSteps.length > 0) {
+        spinner.stop();
+        log(`${pc4.green("\u2713")} ${completedSteps[completedSteps.length - 1]}`);
+      }
+      completedSteps.push(message);
+      spinner.text = message;
+      spinner.start();
+    },
+    done: (message) => {
+      if (completedSteps.length > 0) {
+        spinner.stop();
+        log(`${pc4.green("\u2713")} ${completedSteps[completedSteps.length - 1]}`);
       } else {
-        reject(
-          `Git ${gitCommand} command failed with exit code ${code}, stderr: "${errOutput.trim()}", stdout: "${output.trim()}"`
-        );
+        spinner.stop();
       }
-    });
-    child.stdout.on("data", (data) => {
-      output += data.toString();
-    });
-    child.stderr.on("data", (data) => {
-      errOutput += data.toString();
-    });
-  });
+      activeSpinner = null;
+      if (message) {
+        log("");
+        log(`${pc4.green("\u2713")} ${message}`);
+      }
+    },
+    fail: (message) => {
+      spinner.stop();
+      activeSpinner = null;
+      log(`${pc4.red("\u2717")} ${pc4.red(message)}`);
+    },
+    wrap: async (fn) => {
+      try {
+        return await fn();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        spinner.stop();
+        activeSpinner = null;
+        log(pc4.cyan(`
+${title}`));
+        for (const step of completedSteps) {
+          log(pc4.gray(`  \u251C\u2500 ${step}`));
+        }
+        log(pc4.red(`  \u2514\u2500 \u2717 ${errorMessage}`));
+        throw error;
+      }
+    }
+  };
 }
 
-// src/add-remote.ts
-import yoctoSpinner from "yocto-spinner";
-async function addRemote({
-  targetFolder,
-  remoteUrl = CELLA_REMOTE_URL,
-  remoteName = "upstream"
-}) {
-  const remoteSpinner = yoctoSpinner({
-    text: "Adding remote"
-  }).start();
+// src/utils/run-package-manager-command.ts
+import spawn from "nano-spawn";
+async function runPackageManagerCommand(packageManager2, args, env = {}) {
   try {
-    let remote = null;
-    try {
-      remote = await runGitCommand({ targetFolder, command: `remote get-url ${remoteName}` });
-    } catch (error) {
-      remote = null;
-    }
-    if (!remote) {
-      await runGitCommand({ targetFolder, command: `remote add ${remoteName} ${remoteUrl}` });
-      remoteSpinner.success("Remote added successfully.");
-    } else if (remote !== remoteUrl) {
-      await runGitCommand({ targetFolder, command: `remote remove ${remoteName}` });
-      await runGitCommand({ targetFolder, command: `remote add ${remoteName} ${remoteUrl}` });
-      remoteSpinner.success("Remote updated successfully.");
-    } else {
-      remoteSpinner.success("Remote is already configured correctly.");
-    }
+    await spawn(packageManager2, args, {
+      env: { ...process.env, ...env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
   } catch (error) {
-    console.error(error);
-    remoteSpinner.error("Failed to add remote.");
-    process.exit(1);
+    const err = error;
+    throw new Error(`"${packageManager2} ${args.join(" ")}" failed ${err.stdout || ""} ${err.stderr || ""}`);
   }
 }
+async function install(packageManager2) {
+  return runPackageManagerCommand(packageManager2, ["install"], {
+    NODE_ENV: "development"
+  });
+}
+async function generate(packageManager2) {
+  return runPackageManagerCommand(packageManager2, ["generate"], {
+    NODE_ENV: "development"
+  });
+}
 
 // src/create.ts
+function isLocalPath(path2) {
+  return path2.startsWith("/") || path2.startsWith("./") || path2.startsWith("../");
+}
 async function create({
   projectName,
   targetFolder,
   newBranchName: newBranchName2,
-  skipInstall,
-  skipGit,
-  skipClean,
-  skipGenerate,
-  packageManager: packageManager2
+  packageManager: packageManager2,
+  templateUrl,
+  portOffset,
+  adminEmail,
+  silent = false
 }) {
   const originalCwd = process.cwd();
-  console.info();
-  const createFolderSpinner = yoctoSpinner2({
-    text: "Creating project folder"
-  }).start();
-  await mkdir(targetFolder, { recursive: true });
-  process.chdir(targetFolder);
-  createFolderSpinner.success("Project folder created");
-  const downloadSpinner = yoctoSpinner2({
-    text: "Downloading `cella` template"
-  }).start();
-  await downloadTemplate(TEMPLATE_URL, {
-    cwd: process.cwd(),
-    dir: targetFolder,
-    force: true,
-    provider: "github"
-  });
-  downloadSpinner.success("`cella` template downloaded");
-  if (!skipClean) {
-    const cleanSpinner = yoctoSpinner2({
-      text: "cleaning `cella` template"
-    }).start();
-    try {
-      await cleanTemplate({
-        targetFolder,
-        projectName
+  const template = templateUrl || TEMPLATE_URL;
+  const isLocalTemplate = templateUrl && isLocalPath(templateUrl);
+  const progress = createProgress("creating project", silent);
+  try {
+    progress.step("creating project folder");
+    await mkdir(targetFolder, { recursive: true });
+    process.chdir(targetFolder);
+    if (isLocalTemplate) {
+      progress.step("copying local template");
+      const sourcePath = resolve2(originalCwd, templateUrl);
+      if (targetFolder.startsWith(sourcePath)) {
+        throw new Error(
+          `Cannot create project inside the template directory.
+  Run from outside: cd ~ && pnpm create @cellajs/cella ${projectName} --template ${templateUrl}`
+        );
+      }
+      await cp(sourcePath, targetFolder, {
+        recursive: true,
+        filter: (src) => !src.includes("node_modules") && !src.includes(".git")
+      });
+    } else {
+      progress.step("downloading cella template");
+      await downloadTemplate(template, {
+        cwd: process.cwd(),
+        dir: targetFolder,
+        force: true,
+        provider: "github"
       });
-      cleanSpinner.success("`cella` template cleaned");
-    } catch (e) {
-      console.error(e);
-      cleanSpinner.error("Failed to clean `cella` template");
-      process.exit(1);
-    }
-  } else {
-    console.info(`${colors2.yellow("\u26A0")} --skip-clean > Skip cleaning \`cella\` template`);
-  }
-  if (!skipInstall) {
-    const installSpinner = yoctoSpinner2({
-      text: "installing dependencies"
-    }).start();
-    try {
-      await install(packageManager2);
-      installSpinner.success("Dependencies installed");
-    } catch (e) {
-      console.error(e);
-      installSpinner.error("Failed to install dependencies");
-      process.exit(1);
-    }
-  } else {
-    console.info(`${colors2.yellow("\u26A0")} --skip-install > Skip installing dependencies`);
-  }
-  if (!skipGenerate) {
-    const generateSpinner = yoctoSpinner2({
-      text: "generating SQL files"
-    }).start();
-    try {
-      await generate(packageManager2);
-      generateSpinner.success("SQL files generated");
-    } catch (e) {
-      console.error(e);
-      generateSpinner.error("Failed to generate SQL files");
-      process.exit(1);
     }
-  } else {
-    console.info(`${colors2.yellow("\u26A0")} --skip-generate > Skip generating SQL files`);
-  }
-  if (!skipGit) {
-    const gitSpinner = yoctoSpinner2({
-      text: "initializing git repository"
-    }).start();
+    progress.step("cleaning template");
+    const displayName = projectName.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    await cleanTemplate({ targetFolder, projectName, displayName, portOffset, adminEmail });
+    progress.step("installing dependencies");
+    await install(packageManager2);
+    progress.step("generating migrations");
+    await generate(packageManager2);
     const gitFolderPath = join(targetFolder, ".git");
     if (!existsSync(gitFolderPath)) {
-      try {
-        await runGitCommand({ targetFolder, command: "init" });
-        await runGitCommand({ targetFolder, command: "add ." });
-        await runGitCommand({ targetFolder, command: 'commit -m "Initial commit"' });
-        if (newBranchName2) {
-          await runGitCommand({ targetFolder, command: `branch ${newBranchName2}` });
-          await runGitCommand({ targetFolder, command: `checkout ${newBranchName2}` });
-          gitSpinner.success(`Git repository initialized, initial commit created, and new branch ${newBranchName2} created`);
-        } else {
-          gitSpinner.success("Git repository initialized and initial commit created");
-        }
-      } catch (e) {
-        console.error(e);
-        gitSpinner.error("Failed to initialize Git repository or create branch");
-        process.exit(1);
+      progress.step("initializing git");
+      await gitInit(targetFolder);
+      await gitAddAll(targetFolder);
+      await gitCommit(targetFolder, "Initial commit");
+      if (newBranchName2) {
+        progress.step(`creating branch '${newBranchName2}'`);
+        await gitBranch(targetFolder, newBranchName2);
+        await gitCheckout(targetFolder, newBranchName2);
       }
-    } else {
-      gitSpinner.warning("Git repository already initialized > Skip git init");
     }
-  } else {
-    console.info(`${colors2.yellow("\u26A0")} --skip-git > Skip git init`);
+    progress.step("adding upstream remote");
+    await addRemote({ targetFolder, silent: true });
+    progress.done(`created ${projectName}`);
+  } catch (error) {
+    progress.fail(error instanceof Error ? error.message : String(error));
+    process.exit(1);
   }
-  await addRemote({ targetFolder });
-  console.info();
-  console.info(`${colors2.green("Success")} Created ${projectName} at ${targetFolder}`);
-  console.info();
   const needsCd = originalCwd !== targetFolder;
   const relativePath = relative(originalCwd, targetFolder);
-  if (needsCd) {
-    console.info("now go to your project using:");
-    console.info(colors2.cyan(`  cd ${relativePath}`));
-    console.info();
-  }
-  console.info(`${needsCd ? "then " : ""}quick start using pglite with:`);
-  console.info(colors2.cyan(`  ${packageManager2} quick`));
-  console.info();
-  console.info("Already have docker installed? Then you can run a full setup:");
-  console.info(colors2.cyan(`  ${packageManager2} docker`));
-  console.info(colors2.cyan(`  ${packageManager2} dev`));
-  console.info(colors2.cyan(`  ${packageManager2} seed`));
-  console.info();
-  console.info(`Once running, you can sign in using:`);
-  console.info(`email: ${colors2.greenBright("admin-test@cellajs.com")}`);
-  console.info(`password: ${colors2.greenBright("12345678")}`);
-  console.info();
-  console.info(`For more info, check out: ${relativePath}/README.md`);
-  console.info(`Enjoy building ${projectName} using cella! \u{1F389}`);
-  console.info();
+  showSuccess(projectName, targetFolder, relativePath, needsCd, packageManager2);
 }
 
-// src/index.ts
-async function main() {
-  console.info(LOGO);
-  const templateVersion = await extractPackageJsonVersionFromUri(TEMPLATE_URL);
-  console.info();
-  console.info(DESCRIPTION);
-  console.info();
-  console.info(`Cella version: ${colors3.green(templateVersion)}`);
-  console.info(`Cli version ${colors3.green(VERSION)}`);
-  console.info(`Created by ${AUTHOR}`);
-  console.info(`${GITHUB} | ${WEBSITE}`);
-  console.info();
-  if (cli.options.skipNewBranch || cli.options.skipGit) {
-    cli.createNewBranch = false;
-    cli.newBranchName = null;
-  }
-  if (cli.options.skipGenerate === true) {
-    cli.options.skipGenerate = true;
+// src/utils/detect-used-ports.ts
+import { readdir, readFile } from "fs/promises";
+import { dirname, join as join2 } from "path";
+async function detectUsedPorts(targetFolder) {
+  const parentDir = dirname(targetFolder);
+  const used = [];
+  let siblings;
+  try {
+    siblings = await readdir(parentDir);
+  } catch {
+    return used;
   }
-  if (cli.options.skipInstall === true) {
-    cli.options.skipInstall = true;
+  for (const name of siblings) {
+    const configPath = join2(parentDir, name, "shared/config/config.development.ts");
+    try {
+      const content = await readFile(configPath, "utf8");
+      const feMatch = content.match(/frontendUrl:\s*'http:\/\/localhost:(\d+)'/);
+      const beMatch = content.match(/backendUrl:\s*'http:\/\/localhost:(\d+)'/);
+      if (feMatch && beMatch) {
+        const frontend = Number(feMatch[1]);
+        const backend = Number(beMatch[1]);
+        used.push({
+          project: name,
+          frontend,
+          backend,
+          offset: frontend - 3e3
+        });
+      }
+    } catch {
+    }
   }
-  if (cli.options.skipClean === true) {
-    cli.options.skipClean = true;
+  return used;
+}
+function findNextOffset(usedPorts) {
+  const usedOffsets = new Set(usedPorts.map((p) => p.offset));
+  for (let offset = 0; offset <= 490; offset += 10) {
+    if (!usedOffsets.has(offset)) return offset;
   }
-  if (cli.options.skipGit === true) {
-    cli.options.skipGit = true;
+  return 0;
+}
+
+// src/utils/extract-package-json-version-from-uri.ts
+import axios from "axios";
+async function extractPackageJsonVersionFromUri(repositoryUrl, branch = "main") {
+  const [owner, repo] = repositoryUrl.replace("github:", "").split("/");
+  const packageJsonUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/package.json`;
+  try {
+    const response = await axios.get(packageJsonUrl);
+    const packageJson = response.data;
+    return packageJson.version || "unknown";
+  } catch (error) {
+    return "unknown";
   }
+}
+
+// src/utils/is-empty-directory.ts
+import { readdir as readdir2 } from "fs/promises";
+async function isEmptyDirectory(path2) {
+  const files = await readdir2(path2);
+  return files.length === 0 || files.length === 1 && files[0] === ".git";
+}
+
+// src/create-cella-cli.ts
+async function main() {
+  const templateVersion = await extractPackageJsonVersionFromUri(TEMPLATE_URL);
+  showWelcome(templateVersion);
+  const promptTheme = { prefix: "", style: { answer: (text) => text } };
+  const promptContext = { clearPromptOnDone: true };
   if (!cli.directory) {
-    cli.directory = await input({
-      message: "Enter your project name",
-      default: "my-cella-app",
-      validate: (name) => {
-        const validation = validateProjectName(basename2(resolve2(name)));
-        return validation.valid ? true : `Invalid project name: ${validation.problems[0]}`;
-      }
-    });
-  }
-  if (cli.createNewBranch === null) {
-    cli.createNewBranch = await confirm({
-      message: 'Would you like to create a new branch (besides "main")?',
-      default: true
-    });
+    cli.directory = await input(
+      {
+        message: "Enter your project name",
+        default: "my-cella-app",
+        theme: promptTheme,
+        validate: (name) => {
+          const validation = validateProjectName(basename2(resolve3(name)));
+          return validation.valid ? true : `Invalid project name: ${validation.problems?.[0] ?? "unknown error"}`;
+        }
+      },
+      promptContext
+    );
   }
-  if (!cli.newBranchName && cli.createNewBranch) {
-    cli.newBranchName = await input({
-      message: "Enter the new branch name",
-      default: "development",
-      validate: (name) => {
-        const validation = validateProjectName(basename2(resolve2(name)));
-        return validation.valid ? true : `Invalid branch name: ${validation.problems[0]}`;
-      }
-    });
+  if (!cli.newBranchName) {
+    cli.newBranchName = "development";
   }
-  const targetFolder = resolve2(cli.directory);
-  const projectName = basename2(targetFolder);
+  const targetFolder = resolve3(cli.directory);
+  const projectName = basename2(targetFolder)?.toLowerCase() || "project";
   if (existsSync2(targetFolder) && !await isEmptyDirectory(targetFolder)) {
     const dirName = cli.directory === "." ? "Current directory" : `Target directory "${targetFolder}"`;
     const message = `${dirName} is not empty. Please choose how you would like to proceed:`;
-    const action = await select({
-      message,
-      choices: [
-        { name: "Cancel and exit", value: "cancel" },
-        { name: "Ignore existing files and continue", value: "ignore" }
-      ]
-    });
+    const action = await select(
+      {
+        message,
+        theme: promptTheme,
+        choices: [
+          { name: "Cancel and exit", value: "cancel" },
+          { name: "Ignore existing files and continue", value: "ignore" }
+        ]
+      },
+      promptContext
+    );
     if (action === "cancel") {
       process.exit(1);
     }
   }
+  const portOffset = await promptPortOffset(targetFolder, promptTheme, promptContext);
+  const adminEmail = await input(
+    {
+      message: "Admin email for initial seed user",
+      default: `admin@${projectName}.com`,
+      theme: promptTheme
+    },
+    promptContext
+  );
   const createOptions = {
     projectName,
     targetFolder,
     newBranchName: cli.newBranchName,
-    skipInstall: cli.options.skipInstall,
-    skipGit: cli.options.skipGit,
-    skipClean: cli.options.skipClean,
-    skipGenerate: cli.options.skipGenerate,
-    packageManager: cli.packageManager
+    packageManager: cli.packageManager,
+    templateUrl: cli.options.template,
+    portOffset,
+    adminEmail
   };
   await create(createOptions);
 }
 main().catch(console.error);
+function formatOffset(o, suffix = "") {
+  return `${o} \u2192 :${3e3 + o} / :${4e3 + o} / :${5432 + o}${suffix}`;
+}
+async function promptPortOffset(targetFolder, theme, context) {
+  const usedPorts = await detectUsedPorts(targetFolder);
+  const suggested = findNextOffset(usedPorts);
+  if (usedPorts.length > 0) {
+    console.info(pc5.dim("\nDetected cella forks in sibling directories:"));
+    for (const p of usedPorts) {
+      console.info(pc5.dim(`  ${p.project}: frontend :${p.frontend}, backend :${p.backend} (offset ${p.offset})`));
+    }
+    console.info();
+  }
+  const presets = [0, 10, 20, 30].filter((o) => o !== suggested);
+  const choice = await select(
+    {
+      message: "Port offset (avoids conflicts with sibling forks)",
+      theme,
+      choices: [
+        ...suggested > 0 ? [{ name: formatOffset(suggested, " (suggested)"), value: suggested }] : [],
+        { name: formatOffset(0, " (default)"), value: 0 },
+        ...presets.map((o) => ({ name: formatOffset(o), value: o })),
+        { name: "Custom offset", value: -1 }
+      ]
+    },
+    context
+  );
+  if (choice !== -1) return choice;
+  const custom = await input(
+    {
+      message: "Enter custom offset (0-490, multiples of 10)",
+      default: String(suggested),
+      theme,
+      validate: (val) => {
+        const n = Number(val);
+        if (Number.isNaN(n) || n < 0 || n > 490) return "Must be between 0 and 490";
+        if (n % 10 !== 0) return "Must be a multiple of 10";
+        return true;
+      }
+    },
+    context
+  );
+  return Number(custom);
+}
 //# sourceMappingURL=index.js.map