@cellajs/create-cella 0.2.0 → 0.2.1

package/dist/index.js

@@ -0,0 +1,798 @@
+#!/usr/bin/env tsx
+
+// 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/constants.ts
+import pc from "picocolors";
+
+// package.json
+var package_default = {
+  name: "@cellajs/create-cella",
+  version: "0.2.1",
+  private: false,
+  license: "MIT",
+  description: "Cella is a TypeScript template to create web apps with sync and offline capabilities.",
+  publishConfig: {
+    access: "public"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/cellajs/cella",
+    directory: "cli/create-cella"
+  },
+  homepage: "https://cellajs.com",
+  author: "CellaJS <info@cellajs.com>",
+  engines: {
+    node: "24.x"
+  },
+  type: "module",
+  main: "./dist/index.js",
+  files: [
+    "configs",
+    "dist",
+    "index.js",
+    "README.md"
+  ],
+  imports: {
+    "#/*": "./src/*"
+  },
+  bin: {
+    "create-cella": "index.js"
+  },
+  scripts: {
+    start: "tsx ./src/create-cella-cli.ts",
+    clean: "rimraf ./dist",
+    build: "tsup",
+    "test-build": "pnpm run build && node index.js",
+    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"
+  },
+  dependencies: {
+    "@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: {
+    "@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 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;
+var VERSION = package_default.version;
+var AUTHOR = package_default.author;
+var WEBSITE = package_default.homepage;
+var GITHUB = package_default.repository.url;
+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 = {
+  "./frontend/.env.example": "./frontend/.env",
+  "./info/QUICKSTART.md": "README.md"
+};
+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`
+      }
+    },
+    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`
+      }
+    },
+    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";
+function validateProjectName(name) {
+  const nameValidation = validate(name);
+  if (nameValidation.validForNewPackages) {
+    return { valid: true };
+  }
+  return {
+    valid: false,
+    problems: [...nameValidation.errors || [], ...nameValidation.warnings || []]
+  };
+}
+
+// src/modules/cli/commands.ts
+var directory = null;
+var newBranchName = 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("--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] ?? "unknown error"}`);
+    }
+    directory = trimmedName;
+  }
+}).parse();
+var options = command.opts();
+function runCli() {
+  return {
+    options,
+    args: command.args,
+    directory,
+    newBranchName,
+    packageManager
+  };
+}
+var cli = runCli();
+
+// 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    \\___\\___|_|_|\\__,_|  "));
+}
+function showWelcome(templateVersion) {
+  console.info();
+  showAscii();
+  console.info();
+  console.info(pc2.dim(DESCRIPTION));
+  console.info();
+  console.info(getHeaderLine(templateVersion));
+  console.info(DIVIDER);
+}
+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 "fs/promises";
+import path from "path";
+import pc3 from "picocolors";
+var warningMark = pc3.yellow("\u26A0");
+async function cleanTemplate({
+  targetFolder,
+  projectName,
+  displayName,
+  portOffset = 0,
+  adminEmail = `admin@${projectName}.example.com`
+}) {
+  if (process.cwd() !== targetFolder) {
+    process.chdir(targetFolder);
+  }
+  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}`);
+      }
+    })();
+  });
+}
+async function removeFolderContents(folderPath) {
+  const files = await fs.readdir(folderPath);
+  await Promise.all(
+    files.map(async (file) => {
+      const filePath = path.join(folderPath, file);
+      const stat = await fs.lstat(filePath);
+      if (stat.isDirectory()) {
+        await fs.rm(filePath, { recursive: true, force: true });
+      } else {
+        await fs.rm(filePath);
+      }
+    })
+  );
+}
+async function removeFileOrFolder(pathToRemove) {
+  await fs.rm(pathToRemove, { recursive: true, force: true });
+}
+async function copyFile(src, dest) {
+  try {
+    await fs.access(src);
+    await fs.mkdir(path.dirname(dest), { recursive: true });
+    await fs.copyFile(src, dest);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      console.info(`
+${warningMark} Source file "${src}" does not exist > Skip copy`);
+    } else {
+      throw err;
+    }
+  }
+}
+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 {
+    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(`
+${warningMark} Placeholder config "${src}" not found > Skip`);
+    } else {
+      throw err;
+    }
+  }
+}
+
+// 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 {
+        spinner.stop();
+      }
+      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/utils/run-package-manager-command.ts
+import spawn from "nano-spawn";
+async function runPackageManagerCommand(packageManager2, args, env = {}) {
+  try {
+    await spawn(packageManager2, args, {
+      env: { ...process.env, ...env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (error) {
+    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,
+  packageManager: packageManager2,
+  templateUrl,
+  portOffset,
+  adminEmail,
+  silent = false
+}) {
+  const originalCwd = process.cwd();
+  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"
+      });
+    }
+    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)) {
+      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);
+      }
+    }
+    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);
+  }
+  const needsCd = originalCwd !== targetFolder;
+  const relativePath = relative(originalCwd, targetFolder);
+  showSuccess(projectName, targetFolder, relativePath, needsCd, packageManager2);
+}
+
+// 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;
+  }
+  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 {
+    }
+  }
+  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;
+  }
+  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",
+        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.newBranchName = "development";
+  }
+  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,
+        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,
+    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