@korajs/cli 0.0.0-canary-20261008174129

package/dist/create.cjs

@@ -0,0 +1,1368 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/create.ts
+var import_citty2 = require("citty");
+
+// src/commands/create/create-command.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_path6 = require("path");
+var import_node_url2 = require("url");
+var import_citty = require("citty");
+
+// src/errors.ts
+var import_core = require("@korajs/core");
+var ProjectExistsError = class extends import_core.KoraError {
+  constructor(directory) {
+    super(
+      `Directory "${directory}" already exists. Choose a different name or remove the existing directory.`,
+      "PROJECT_EXISTS",
+      { directory }
+    );
+    this.directory = directory;
+    this.name = "ProjectExistsError";
+  }
+  directory;
+};
+
+// src/prompts/preferences.ts
+var import_conf = __toESM(require("conf"), 1);
+var DEFAULT_PREFERENCES = {
+  platform: "web",
+  framework: "react",
+  tailwind: true,
+  sync: true,
+  db: "sqlite",
+  dbProvider: "none",
+  auth: "none",
+  packageManager: "pnpm"
+};
+var PREFERENCES_KEY = "create.defaults";
+var PreferenceStore = class {
+  store;
+  constructor() {
+    this.store = new import_conf.default({
+      projectName: "korajs-cli"
+    });
+  }
+  getCreatePreferences() {
+    return this.store.get(PREFERENCES_KEY) ?? null;
+  }
+  saveCreatePreferences(preferences) {
+    this.store.set(PREFERENCES_KEY, preferences);
+  }
+  clearCreatePreferences() {
+    this.store.delete(PREFERENCES_KEY);
+  }
+};
+function getCreatePreferencesOrDefault(store) {
+  return store.getCreatePreferences() ?? DEFAULT_PREFERENCES;
+}
+function getDefaultCreatePreferences() {
+  return { ...DEFAULT_PREFERENCES };
+}
+
+// src/prompts/prompt-client.ts
+var import_prompts = require("@clack/prompts");
+
+// src/utils/prompt.ts
+var import_node_readline = require("readline");
+function promptText(message, defaultValue, options) {
+  return new Promise((resolve5) => {
+    const rl = createReadline(options);
+    const suffix = defaultValue !== void 0 ? ` (${defaultValue})` : "";
+    rl.question(`  ? ${message}${suffix}: `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      resolve5(trimmed || defaultValue || "");
+    });
+  });
+}
+function promptSelect(message, choices, options) {
+  return new Promise((resolve5) => {
+    const rl = createReadline(options);
+    const out = options?.output ?? process.stdout;
+    out.write(`  ? ${message}
+`);
+    for (let i = 0; i < choices.length; i++) {
+      const choice = choices[i];
+      if (choice) {
+        out.write(`    ${i + 1}) ${choice.label}
+`);
+      }
+    }
+    const ask = () => {
+      rl.question("  > ", (answer) => {
+        const index = Number.parseInt(answer.trim(), 10) - 1;
+        const selected = choices[index];
+        if (selected) {
+          rl.close();
+          resolve5(selected.value);
+        } else {
+          out.write(`  Please enter a number between 1 and ${choices.length}
+`);
+          ask();
+        }
+      });
+    };
+    ask();
+  });
+}
+function promptConfirm(message, defaultValue = false, options) {
+  return new Promise((resolve5) => {
+    const rl = createReadline(options);
+    const suffix = defaultValue ? "Y/n" : "y/N";
+    const ask = () => {
+      rl.question(`  ? ${message} (${suffix}): `, (answer) => {
+        const normalized = answer.trim().toLowerCase();
+        if (normalized.length === 0) {
+          rl.close();
+          resolve5(defaultValue);
+          return;
+        }
+        if (normalized === "y" || normalized === "yes") {
+          rl.close();
+          resolve5(true);
+          return;
+        }
+        if (normalized === "n" || normalized === "no") {
+          rl.close();
+          resolve5(false);
+          return;
+        }
+        ;
+        (options?.output ?? process.stdout).write("  Please answer with y or n\n");
+        ask();
+      });
+    };
+    ask();
+  });
+}
+function createReadline(options) {
+  return (0, import_node_readline.createInterface)({
+    input: options?.input ?? process.stdin,
+    output: options?.output ?? process.stdout
+  });
+}
+
+// src/prompts/prompt-client.ts
+var PromptCancelledError = class extends Error {
+  constructor(message = "Prompt cancelled by user") {
+    super(message);
+    this.name = "PromptCancelledError";
+  }
+};
+var ReadlinePromptClient = class {
+  async text(message, defaultValue) {
+    return promptText(message, defaultValue);
+  }
+  async select(message, options) {
+    return promptSelect(
+      message,
+      options.filter((option) => option.disabled !== true).map((option) => ({ label: option.label, value: option.value }))
+    );
+  }
+  async confirm(message, defaultValue = false) {
+    return promptConfirm(message, defaultValue);
+  }
+  intro(message) {
+    void message;
+  }
+  outro(message) {
+    void message;
+  }
+};
+function createPromptClient() {
+  const canUseInteractiveClack = typeof process !== "undefined" && process.stdin.isTTY && process.stdout.isTTY;
+  if (canUseInteractiveClack) {
+    return new ClackPromptClient();
+  }
+  return new ReadlinePromptClient();
+}
+var ClackPromptClient = class {
+  async text(message, defaultValue) {
+    const result = await (0, import_prompts.text)({
+      message,
+      placeholder: defaultValue,
+      defaultValue
+    });
+    if ((0, import_prompts.isCancel)(result)) {
+      (0, import_prompts.cancel)("Operation cancelled.");
+      throw new PromptCancelledError();
+    }
+    const value = result.trim();
+    if (value.length > 0) return value;
+    return defaultValue ?? "";
+  }
+  async select(message, options) {
+    const mappedOptions = options.map((option) => ({
+      label: option.label,
+      value: option.value,
+      hint: option.hint,
+      disabled: option.disabled
+    }));
+    const result = await (0, import_prompts.select)({
+      message,
+      options: mappedOptions
+    });
+    if ((0, import_prompts.isCancel)(result)) {
+      (0, import_prompts.cancel)("Operation cancelled.");
+      throw new PromptCancelledError();
+    }
+    return result;
+  }
+  async confirm(message, defaultValue = false) {
+    const result = await (0, import_prompts.confirm)({
+      message,
+      initialValue: defaultValue
+    });
+    if ((0, import_prompts.isCancel)(result)) {
+      (0, import_prompts.cancel)("Operation cancelled.");
+      throw new PromptCancelledError();
+    }
+    return result;
+  }
+  intro(message) {
+    (0, import_prompts.intro)(message);
+  }
+  outro(message) {
+    (0, import_prompts.outro)(message);
+  }
+};
+
+// src/types.ts
+var PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+var TEMPLATES = [
+  "react-tailwind-sync",
+  "react-tailwind",
+  "react-sync",
+  "react-basic",
+  "vue-sync",
+  "vue-basic",
+  "vue-tailwind-sync",
+  "vue-tailwind",
+  "svelte-sync",
+  "svelte-basic",
+  "svelte-tailwind-sync",
+  "svelte-tailwind",
+  "tauri-react"
+];
+
+// src/utils/fs-helpers.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+async function directoryExists(path) {
+  try {
+    await (0, import_promises.access)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/logger.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var CYAN = "\x1B[36m";
+function createLogger(options) {
+  const colorDisabled = options?.noColor === true || process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
+  function color(code, text) {
+    return colorDisabled ? text : `${code}${text}${RESET}`;
+  }
+  return {
+    info(message) {
+      console.log(color(CYAN, message));
+    },
+    success(message) {
+      console.log(color(GREEN, `  \u2713 ${message}`));
+    },
+    warn(message) {
+      console.warn(color(YELLOW, `  \u26A0 ${message}`));
+    },
+    error(message) {
+      console.error(color(RED, `  \u2717 ${message}`));
+    },
+    step(message) {
+      console.log(color(DIM, `  ${message}`));
+    },
+    blank() {
+      console.log();
+    },
+    banner() {
+      console.log();
+      console.log(
+        color(BOLD + CYAN, "  Kora.js") + color(DIM, ", the offline-first application framework")
+      );
+      console.log();
+    }
+  };
+}
+
+// src/utils/package-manager.ts
+var import_node_child_process = require("child_process");
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (!userAgent) return "npm";
+  if (userAgent.startsWith("pnpm/")) return "pnpm";
+  if (userAgent.startsWith("yarn/")) return "yarn";
+  if (userAgent.startsWith("bun/")) return "bun";
+  return "npm";
+}
+function getInstallCommand(pm) {
+  return pm === "yarn" ? "yarn" : `${pm} install`;
+}
+function getRunDevCommand(pm) {
+  if (pm === "npm") return "npm run dev";
+  return `${pm} dev`;
+}
+
+// src/commands/create/environment-detection.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+function detectEditorFromEnvironment(env = process.env) {
+  const termProgram = String(env.TERM_PROGRAM ?? "").toLowerCase();
+  const editorValue = `${String(env.EDITOR ?? "")} ${String(env.VISUAL ?? "")}`.toLowerCase();
+  if (termProgram.includes("cursor") || env.CURSOR_TRACE_ID !== void 0 || env.CURSOR_SESSION_ID !== void 0 || editorValue.includes("cursor")) {
+    return { editor: "cursor", source: "env" };
+  }
+  if (termProgram.includes("windsurf") || env.WINDSURF_SESSION_ID !== void 0 || editorValue.includes("windsurf")) {
+    return { editor: "windsurf", source: "env" };
+  }
+  if (termProgram.includes("vscode") || env.VSCODE_GIT_IPC_HANDLE !== void 0 || env.VSCODE_IPC_HOOK !== void 0 || env.VSCODE_PID !== void 0 || editorValue.includes("code")) {
+    return { editor: "vscode", source: "env" };
+  }
+  if (termProgram.includes("zed") || env.ZED_TERM !== void 0 || editorValue.includes("zed")) {
+    return { editor: "zed", source: "env" };
+  }
+  return { editor: "unknown", source: "none" };
+}
+async function detectGitContext(startDir) {
+  const root = await findNearestAncestorWithEntry(startDir, ".git");
+  return {
+    hasRepository: root !== null,
+    repositoryRoot: root
+  };
+}
+async function detectMonorepoContext(startDir) {
+  let current = (0, import_node_path2.resolve)(startDir);
+  for (; ; ) {
+    if (await fileExists((0, import_node_path2.join)(current, "pnpm-workspace.yaml"))) {
+      return { isMonorepo: true, root: current, kind: "pnpm-workspace" };
+    }
+    if (await fileExists((0, import_node_path2.join)(current, "turbo.json"))) {
+      return { isMonorepo: true, root: current, kind: "turborepo" };
+    }
+    const packageJsonPath = (0, import_node_path2.join)(current, "package.json");
+    if (await fileExists(packageJsonPath)) {
+      try {
+        const packageJsonRaw = await (0, import_promises2.readFile)(packageJsonPath, "utf-8");
+        const parsed = JSON.parse(packageJsonRaw);
+        if (Array.isArray(parsed.workspaces) || isNpmWorkspaceObject(parsed.workspaces)) {
+          return { isMonorepo: true, root: current, kind: "npm-workspaces" };
+        }
+      } catch {
+      }
+    }
+    const parent = (0, import_node_path2.dirname)(current);
+    if (parent === current) {
+      return { isMonorepo: false, root: null, kind: "none" };
+    }
+    current = parent;
+  }
+}
+async function applyEditorWorkspacePreset(params) {
+  const { targetDir, editor } = params;
+  if (editor !== "vscode" && editor !== "cursor" && editor !== "windsurf") {
+    return { applied: false, filePath: null };
+  }
+  const vscodeDir = (0, import_node_path2.join)(targetDir, ".vscode");
+  const extensionsPath = (0, import_node_path2.join)(vscodeDir, "extensions.json");
+  await (0, import_promises2.mkdir)(vscodeDir, { recursive: true });
+  const recommendations = ["korajs.kora-devtools"];
+  const existing = await readJsonObject(extensionsPath);
+  const existingRecommendations = Array.isArray(existing?.recommendations) ? existing.recommendations.filter((item) => typeof item === "string") : [];
+  const mergedRecommendations = dedupeStrings([...existingRecommendations, ...recommendations]);
+  const next = {
+    recommendations: mergedRecommendations
+  };
+  await (0, import_promises2.writeFile)(extensionsPath, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+  return { applied: true, filePath: extensionsPath };
+}
+function resolveMonorepoTargetDirectory(monorepoRoot, projectName) {
+  return (0, import_node_path2.join)(monorepoRoot, "packages", projectName);
+}
+function dedupeStrings(values) {
+  return Array.from(new Set(values));
+}
+async function readJsonObject(path) {
+  try {
+    const content = await (0, import_promises2.readFile)(path, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed === "object" && parsed !== null) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function isNpmWorkspaceObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return Array.isArray(record.packages);
+}
+async function fileExists(path) {
+  try {
+    await (0, import_promises2.access)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findNearestAncestorWithEntry(startDir, entryName) {
+  let current = (0, import_node_path2.resolve)(startDir);
+  for (; ; ) {
+    const candidate = (0, import_node_path2.join)(current, entryName);
+    try {
+      await (0, import_promises2.stat)(candidate);
+      return current;
+    } catch {
+    }
+    const parent = (0, import_node_path2.dirname)(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+// src/commands/create/options.ts
+function determineTemplateFromSelections(input) {
+  if (input.platform === "desktop-tauri") return "tauri-react";
+  const shouldSync = input.sync && input.db !== "none";
+  if (input.framework === "vue") {
+    if (input.tailwind && shouldSync) return "vue-tailwind-sync";
+    if (input.tailwind && !shouldSync) return "vue-tailwind";
+    return shouldSync ? "vue-sync" : "vue-basic";
+  }
+  if (input.framework === "svelte") {
+    if (input.tailwind && shouldSync) return "svelte-tailwind-sync";
+    if (input.tailwind && !shouldSync) return "svelte-tailwind";
+    return shouldSync ? "svelte-sync" : "svelte-basic";
+  }
+  if (input.framework === "solid") {
+    throw new Error("Solid templates are not available yet. Use react, vue, or svelte.");
+  }
+  if (input.tailwind && shouldSync) return "react-tailwind-sync";
+  if (input.tailwind && !shouldSync) return "react-tailwind";
+  if (!input.tailwind && shouldSync) return "react-sync";
+  return "react-basic";
+}
+function isPlatformValue(value) {
+  return value === "web" || value === "desktop-tauri";
+}
+function isFrameworkValue(value) {
+  return value === "react" || value === "vue" || value === "svelte" || value === "solid";
+}
+function isAuthValue(value) {
+  return value === "none" || value === "email-password" || value === "oauth";
+}
+function isDatabaseValue(value) {
+  return value === "none" || value === "sqlite" || value === "postgres";
+}
+function isDatabaseProviderValue(value) {
+  return value === "none" || value === "local" || value === "supabase" || value === "neon" || value === "railway" || value === "vercel-postgres" || value === "custom";
+}
+function isSupportedWebFramework(framework) {
+  return framework === "react" || framework === "vue" || framework === "svelte";
+}
+
+// src/commands/create/pnpm-workspace.ts
+var import_promises3 = require("fs/promises");
+var import_node_path3 = require("path");
+async function writePnpmWorkspaceSettings(targetDir) {
+  const manifest = JSON.parse(await (0, import_promises3.readFile)((0, import_node_path3.join)(targetDir, "package.json"), "utf-8"));
+  const listed = manifest.pnpm?.onlyBuiltDependencies;
+  const allowed = Array.isArray(listed) ? [...new Set(listed.filter((name) => typeof name === "string"))].sort() : [];
+  await (0, import_promises3.writeFile)((0, import_node_path3.join)(targetDir, "pnpm-workspace.yaml"), renderPnpmWorkspace(allowed), "utf-8");
+  return allowed;
+}
+function renderPnpmWorkspace(allowed) {
+  const quote = (name) => `'${name.replace(/'/g, "''")}'`;
+  const lines = [
+    "# pnpm settings for this app. Dependencies listed here may run their install",
+    "# (build) scripts: pnpm 10 reads onlyBuiltDependencies, pnpm 11+ reads allowBuilds.",
+    "packages:",
+    "  - '.'"
+  ];
+  if (allowed.length > 0) {
+    lines.push("onlyBuiltDependencies:", ...allowed.map((name) => `  - ${quote(name)}`));
+    lines.push("allowBuilds:", ...allowed.map((name) => `  ${quote(name)}: true`));
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/commands/create/preferences-flow.ts
+async function resolveCreatePreferencesFlow(params) {
+  const { flags, prompts, store } = params;
+  const stored = store.getCreatePreferences();
+  const base = getCreatePreferencesOrDefault(store);
+  const hasExplicitFlags = hasExplicitPreferenceFlags(flags);
+  const canOfferStored = !flags.useDefaults && !hasExplicitFlags && stored !== null && promptSupportsRichOptions();
+  let effective = { ...base };
+  let usedStoredPreferences = false;
+  if (flags.useDefaults) {
+    effective = getDefaultCreatePreferences();
+  } else if (canOfferStored && stored !== null) {
+    const reuseStored = await prompts.select("Welcome back! Choose setup mode:", [
+      { label: formatStoredPreferenceLabel(stored), value: "reuse" },
+      { label: "Customize", value: "customize" }
+    ]);
+    if (reuseStored === "reuse") {
+      effective = { ...stored };
+      usedStoredPreferences = true;
+    }
+  }
+  if (flags.platform !== void 0) {
+    if (!isPlatformValue(flags.platform)) {
+      throw new Error(
+        `Invalid --platform value "${flags.platform}". Expected one of: web, desktop-tauri.`
+      );
+    }
+    effective.platform = flags.platform;
+  } else if (!flags.useDefaults && !usedStoredPreferences) {
+    effective.platform = await prompts.select("Platform:", [
+      { label: "Web (browser)", value: "web" },
+      { label: "Desktop (Tauri \u2014 native SQLite)", value: "desktop-tauri" }
+    ]);
+  }
+  const isTauri = effective.platform === "desktop-tauri";
+  if (isTauri) {
+    effective.framework = "react";
+    effective.tailwind = false;
+    effective.auth = "none";
+    if (flags.sync !== void 0) {
+      effective.sync = flags.sync;
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.sync = await prompts.confirm("Enable multi-device sync?", true);
+    }
+    if (flags.db !== void 0) {
+      if (!isDatabaseValue(flags.db)) {
+        throw new Error(
+          `Invalid --db value "${flags.db}". Expected one of: none, sqlite, postgres.`
+        );
+      }
+      effective.db = flags.db;
+    } else if (!effective.sync) {
+      effective.db = "none";
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.db = await prompts.select("Sync server database:", [
+        { label: "SQLite (zero-config; local, LAN, small teams)", value: "sqlite" },
+        { label: "PostgreSQL (production-scale)", value: "postgres" }
+      ]);
+    }
+    if (effective.db === "none") {
+      effective.sync = false;
+    }
+    if (effective.db !== "postgres") {
+      effective.dbProvider = "none";
+    } else if (flags.dbProvider !== void 0) {
+      if (!isDatabaseProviderValue(flags.dbProvider)) {
+        throw new Error(
+          `Invalid --db-provider value "${flags.dbProvider}". Expected one of: none, local, supabase, neon, railway, vercel-postgres, custom.`
+        );
+      }
+      effective.dbProvider = flags.dbProvider;
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.dbProvider = await prompts.select("Database provider:", [
+        { label: "Local Postgres", value: "local" },
+        { label: "Supabase", value: "supabase" },
+        { label: "Neon", value: "neon" },
+        { label: "Railway", value: "railway" },
+        { label: "Vercel Postgres", value: "vercel-postgres" },
+        { label: "Custom connection string", value: "custom" }
+      ]);
+    }
+  } else {
+    if (flags.framework !== void 0) {
+      if (!isFrameworkValue(flags.framework)) {
+        throw new Error(
+          `Invalid --framework value "${flags.framework}". Expected one of: react, vue, svelte, solid.`
+        );
+      }
+      effective.framework = flags.framework;
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.framework = await prompts.select("UI framework:", [
+        { label: "React", value: "react" },
+        { label: "Vue 3", value: "vue" },
+        { label: "Svelte 5", value: "svelte" },
+        { label: "Solid (coming soon)", value: "solid", disabled: true }
+      ]);
+    }
+    if (flags.auth !== void 0) {
+      if (!isAuthValue(flags.auth)) {
+        throw new Error(
+          `Invalid --auth value "${flags.auth}". Expected one of: none, email-password, oauth.`
+        );
+      }
+      effective.auth = flags.auth;
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.auth = await prompts.select("Authentication:", [
+        { label: "None", value: "none" },
+        { label: "Email + Password (coming soon)", value: "email-password", disabled: true },
+        { label: "OAuth (coming soon)", value: "oauth", disabled: true }
+      ]);
+    }
+    if (flags.tailwind !== void 0) {
+      effective.tailwind = flags.tailwind;
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.tailwind = await prompts.confirm("Use Tailwind CSS?", true);
+    }
+    if (flags.sync !== void 0) {
+      effective.sync = flags.sync;
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.sync = await prompts.confirm("Enable multi-device sync?", true);
+    }
+    if (flags.db !== void 0) {
+      if (!isDatabaseValue(flags.db)) {
+        throw new Error(
+          `Invalid --db value "${flags.db}". Expected one of: none, sqlite, postgres.`
+        );
+      }
+      effective.db = flags.db;
+    } else if (!effective.sync) {
+      effective.db = "none";
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.db = await prompts.select("Server-side database:", [
+        { label: "SQLite (zero-config)", value: "sqlite" },
+        { label: "PostgreSQL (production-scale)", value: "postgres" }
+      ]);
+    }
+    if (effective.db !== "postgres") {
+      effective.dbProvider = "none";
+    } else if (flags.dbProvider !== void 0) {
+      if (!isDatabaseProviderValue(flags.dbProvider)) {
+        throw new Error(
+          `Invalid --db-provider value "${flags.dbProvider}". Expected one of: none, local, supabase, neon, railway, vercel-postgres, custom.`
+        );
+      }
+      effective.dbProvider = flags.dbProvider;
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.dbProvider = await prompts.select("Database provider:", [
+        { label: "Local Postgres", value: "local" },
+        { label: "Supabase", value: "supabase" },
+        { label: "Neon", value: "neon" },
+        { label: "Railway", value: "railway" },
+        { label: "Vercel Postgres", value: "vercel-postgres" },
+        { label: "Custom connection string", value: "custom" }
+      ]);
+    }
+  }
+  const template = determineTemplateFromSelections({
+    platform: effective.platform,
+    framework: effective.framework,
+    tailwind: effective.tailwind,
+    sync: effective.sync,
+    db: effective.db
+  });
+  return {
+    platform: effective.platform,
+    framework: effective.framework,
+    auth: effective.auth,
+    db: effective.db,
+    dbProvider: effective.dbProvider,
+    tailwind: effective.tailwind,
+    sync: effective.sync,
+    template,
+    usedStoredPreferences
+  };
+}
+function shouldSavePreferences(flags) {
+  return !flags.useDefaults;
+}
+function saveResolvedPreferences(store, resolution) {
+  store.saveCreatePreferences({
+    platform: resolution.platform,
+    framework: resolution.framework,
+    tailwind: resolution.tailwind,
+    sync: resolution.sync,
+    db: resolution.db,
+    dbProvider: resolution.dbProvider,
+    auth: resolution.auth,
+    packageManager: resolution.packageManager
+  });
+}
+function hasExplicitPreferenceFlags(flags) {
+  return flags.platform !== void 0 || flags.framework !== void 0 || flags.auth !== void 0 || flags.db !== void 0 || flags.dbProvider !== void 0 || flags.tailwind !== void 0 || flags.sync !== void 0;
+}
+function promptSupportsRichOptions() {
+  return typeof process !== "undefined" && process.stdin.isTTY && process.stdout.isTTY;
+}
+function formatStoredPreferenceLabel(preferences) {
+  if (preferences.platform === "desktop-tauri") {
+    return `Use previous settings (tauri-desktop + ${preferences.packageManager})`;
+  }
+  const syncLabel = preferences.sync ? `sync/${preferences.db}` : "local-only";
+  const styleLabel = preferences.tailwind ? "tailwind" : "css";
+  return `Use previous settings (${preferences.framework} + ${styleLabel} + ${syncLabel} + ${preferences.packageManager})`;
+}
+
+// src/commands/create/project-name.ts
+var import_validate_npm_package_name = __toESM(require("validate-npm-package-name"), 1);
+function validateProjectName(name) {
+  const trimmedName = name.trim();
+  if (trimmedName.length === 0) {
+    return {
+      valid: false,
+      issues: ["Project name cannot be empty."]
+    };
+  }
+  const validation = (0, import_validate_npm_package_name.default)(trimmedName);
+  const issues = [...validation.errors ?? [], ...validation.warnings ?? []];
+  if (!validation.validForNewPackages && issues.length === 0) {
+    return {
+      valid: false,
+      issues: ["Project name is not a valid npm package name."]
+    };
+  }
+  return {
+    valid: validation.validForNewPackages,
+    issues
+  };
+}
+
+// src/commands/create/sync-provider-preset.ts
+var import_promises4 = require("fs/promises");
+var import_node_path4 = require("path");
+async function applySyncProviderPreset(options) {
+  if (!isSyncTemplate(options.template)) {
+    return;
+  }
+  if (options.db !== "postgres") {
+    return;
+  }
+  const providerName = getProviderDisplayName(options.dbProvider);
+  const providerConnectionString = getProviderConnectionStringExample(options.dbProvider);
+  const envPath = (0, import_node_path4.join)(options.targetDir, ".env.example");
+  const readmePath = (0, import_node_path4.join)(options.targetDir, "README.md");
+  const existingReadme = await (0, import_promises4.readFile)(readmePath, "utf-8");
+  const existingEnv = await (0, import_promises4.readFile)(envPath, "utf-8");
+  const trimmedReadme = existingReadme.trimEnd();
+  const trimmedEnv = existingEnv.trimEnd();
+  const envSuffix = [
+    "",
+    `# PostgreSQL provider preset: ${providerName}`,
+    `# Example: ${providerConnectionString}`
+  ].join("\n");
+  const readmeSuffix = [
+    "",
+    "## PostgreSQL Provider Preset",
+    "",
+    `Selected DB provider: ${options.dbProvider}`,
+    "",
+    "This scaffold keeps one sync server entrypoint. When `DATABASE_URL` is set, `server.ts` uses PostgreSQL. When it is empty, the same server uses SQLite at `KORA_SERVER_DB`.",
+    "",
+    "The generated server uses `createPostgresServerStore` automatically when `DATABASE_URL` is present.",
+    ""
+  ].join("\n");
+  const readmeTemplate = `${trimmedReadme}${readmeSuffix}`;
+  await (0, import_promises4.writeFile)(envPath, `${trimmedEnv}${envSuffix}
+`, "utf-8");
+  await (0, import_promises4.writeFile)(readmePath, readmeTemplate, "utf-8");
+}
+function isSyncTemplate(template) {
+  return template === "react-sync" || template === "react-tailwind-sync" || template === "vue-sync" || template === "vue-tailwind-sync" || template === "svelte-sync" || template === "svelte-tailwind-sync" || template === "tauri-react";
+}
+function getProviderDisplayName(provider) {
+  switch (provider) {
+    case "supabase":
+      return "Supabase";
+    case "neon":
+      return "Neon";
+    case "railway":
+      return "Railway";
+    case "vercel-postgres":
+      return "Vercel Postgres";
+    case "custom":
+      return "Custom";
+    case "local":
+      return "Local Postgres";
+    case "none":
+      return "PostgreSQL";
+  }
+}
+function getProviderConnectionStringExample(provider) {
+  switch (provider) {
+    case "supabase":
+      return "postgresql://postgres:<password>@db.<project-ref>.supabase.co:5432/postgres?sslmode=require";
+    case "neon":
+      return "postgresql://<user>:<password>@<branch>.<project>.neon.tech/neondb?sslmode=require";
+    case "railway":
+      return "postgresql://postgres:<password>@<host>.railway.app:<port>/railway?sslmode=require";
+    case "vercel-postgres":
+      return "postgresql://<user>:<password>@<host>.pooler.vercel-storage.com:5432/verceldb?sslmode=require";
+    case "custom":
+      return "postgresql://<user>:<password>@<host>:5432/<database>";
+    case "local":
+      return "postgresql://postgres:postgres@localhost:5432/kora";
+    case "none":
+      return "postgresql://postgres:postgres@localhost:5432/kora";
+  }
+}
+
+// src/templates/composer.ts
+var import_node_fs = require("fs");
+var import_promises5 = require("fs/promises");
+var import_node_path5 = require("path");
+var import_node_url = require("url");
+
+// src/templates/tauri-version.ts
+var KORA_TAURI_TEMPLATE_VERSION = "0.4.3-beta.13";
+
+// src/templates/composer.ts
+var import_meta = {};
+function substituteVariables(template, context) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+    const value = context[key];
+    return value !== void 0 ? value : `{{${key}}}`;
+  });
+}
+function getTemplatePath(templateName) {
+  let dir = (0, import_node_path5.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+  for (let i = 0; i < 7; i++) {
+    const candidate = (0, import_node_path5.resolve)(dir, "templates", templateName);
+    if ((0, import_node_fs.existsSync)(candidate)) {
+      return candidate;
+    }
+    dir = (0, import_node_path5.dirname)(dir);
+  }
+  const currentDir = (0, import_node_path5.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+  return (0, import_node_path5.resolve)(currentDir, "..", "..", "..", "templates", templateName);
+}
+function createCompatibilityLayerPlan(templateName) {
+  const baseLayer = { category: "base", name: "base", sourceTemplate: "react-basic" };
+  const uiLayer = { category: "ui", name: "react", sourceTemplate: null };
+  const authLayer = { category: "auth", name: "none", sourceTemplate: null };
+  switch (templateName) {
+    case "react-basic":
+      return {
+        compatibilityTarget: templateName,
+        layers: [
+          baseLayer,
+          uiLayer,
+          { category: "style", name: "plain", sourceTemplate: null },
+          { category: "sync", name: "disabled", sourceTemplate: null },
+          { category: "db", name: "none", sourceTemplate: null },
+          authLayer
+        ]
+      };
+    case "react-tailwind":
+      return {
+        compatibilityTarget: templateName,
+        layers: [
+          baseLayer,
+          uiLayer,
+          { category: "style", name: "tailwind", sourceTemplate: "react-tailwind" },
+          { category: "sync", name: "disabled", sourceTemplate: null },
+          { category: "db", name: "none", sourceTemplate: null },
+          authLayer
+        ]
+      };
+    case "react-sync":
+      return {
+        compatibilityTarget: templateName,
+        layers: [
+          baseLayer,
+          uiLayer,
+          { category: "style", name: "plain", sourceTemplate: null },
+          { category: "sync", name: "enabled", sourceTemplate: "react-sync" },
+          { category: "db", name: "sqlite", sourceTemplate: null },
+          authLayer
+        ]
+      };
+    case "react-tailwind-sync":
+      return {
+        compatibilityTarget: templateName,
+        layers: [
+          baseLayer,
+          uiLayer,
+          { category: "style", name: "tailwind", sourceTemplate: "react-tailwind" },
+          { category: "sync", name: "enabled", sourceTemplate: "react-tailwind-sync" },
+          { category: "db", name: "sqlite", sourceTemplate: null },
+          authLayer
+        ]
+      };
+    case "tauri-react":
+      return {
+        compatibilityTarget: templateName,
+        layers: [
+          { category: "base", name: "tauri", sourceTemplate: "tauri-react" },
+          uiLayer,
+          { category: "style", name: "plain", sourceTemplate: null },
+          { category: "sync", name: "enabled", sourceTemplate: null },
+          { category: "db", name: "tauri-sqlite", sourceTemplate: null },
+          authLayer
+        ]
+      };
+    case "vue-sync":
+      return {
+        compatibilityTarget: templateName,
+        layers: [{ category: "base", name: "vue-sync", sourceTemplate: "vue-sync" }]
+      };
+    case "vue-basic":
+      return {
+        compatibilityTarget: templateName,
+        layers: [{ category: "base", name: "vue-basic", sourceTemplate: "vue-basic" }]
+      };
+    case "svelte-sync":
+      return {
+        compatibilityTarget: templateName,
+        layers: [{ category: "base", name: "svelte-sync", sourceTemplate: "svelte-sync" }]
+      };
+    case "svelte-basic":
+      return {
+        compatibilityTarget: templateName,
+        layers: [{ category: "base", name: "svelte-basic", sourceTemplate: "svelte-basic" }]
+      };
+    case "vue-tailwind-sync":
+      return {
+        compatibilityTarget: templateName,
+        layers: [
+          { category: "base", name: "vue-tailwind-sync", sourceTemplate: "vue-tailwind-sync" }
+        ]
+      };
+    case "vue-tailwind":
+      return {
+        compatibilityTarget: templateName,
+        layers: [{ category: "base", name: "vue-tailwind", sourceTemplate: "vue-tailwind" }]
+      };
+    case "svelte-tailwind-sync":
+      return {
+        compatibilityTarget: templateName,
+        layers: [
+          {
+            category: "base",
+            name: "svelte-tailwind-sync",
+            sourceTemplate: "svelte-tailwind-sync"
+          }
+        ]
+      };
+    case "svelte-tailwind":
+      return {
+        compatibilityTarget: templateName,
+        layers: [{ category: "base", name: "svelte-tailwind", sourceTemplate: "svelte-tailwind" }]
+      };
+  }
+}
+async function composeTemplateLayers(plan, targetDir, context) {
+  const vars = {
+    projectName: context.projectName,
+    packageManager: context.packageManager,
+    koraVersion: context.koraVersion,
+    tauriVersion: context.tauriVersion ?? KORA_TAURI_TEMPLATE_VERSION,
+    dbProvider: context.dbProvider ?? "none"
+  };
+  for (const layer of plan.layers) {
+    if (layer.sourceTemplate === null) {
+      continue;
+    }
+    const sourceDir = getTemplatePath(layer.sourceTemplate);
+    await copyDirectory(sourceDir, targetDir, vars);
+  }
+}
+async function copyDirectory(src, dest, vars) {
+  await (0, import_promises5.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises5.readdir)(src);
+  for (const entry of entries) {
+    const srcPath = (0, import_node_path5.join)(src, entry);
+    const srcStat = await (0, import_promises5.stat)(srcPath);
+    if (srcStat.isDirectory()) {
+      await copyDirectory(srcPath, (0, import_node_path5.join)(dest, entry), vars);
+      continue;
+    }
+    if (entry.endsWith(".hbs")) {
+      const content = await (0, import_promises5.readFile)(srcPath, "utf-8");
+      const outputName = entry.slice(0, -4);
+      await (0, import_promises5.writeFile)((0, import_node_path5.join)(dest, outputName), substituteVariables(content, vars), "utf-8");
+      continue;
+    }
+    await (0, import_promises5.copyFile)(srcPath, (0, import_node_path5.join)(dest, entry));
+  }
+}
+
+// src/commands/create/template-engine.ts
+async function scaffoldTemplate(templateName, targetDir, context) {
+  const plan = createCompatibilityLayerPlan(templateName);
+  await composeTemplateLayers(plan, targetDir, context);
+}
+
+// src/commands/create/create-command.ts
+var import_meta2 = {};
+var createCommand = (0, import_citty.defineCommand)({
+  meta: {
+    name: "create",
+    description: "Create a new Kora application"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Project directory name",
+      required: false
+    },
+    platform: {
+      type: "string",
+      description: "Target platform (web, desktop-tauri)"
+    },
+    template: {
+      type: "string",
+      description: "Project template (react-tailwind-sync, react-sync, vue-sync, svelte-sync, tauri-react, ...)"
+    },
+    pm: {
+      type: "string",
+      description: "Package manager (pnpm, npm, yarn, bun)"
+    },
+    framework: {
+      type: "string",
+      description: "UI framework (react, vue, svelte, solid)"
+    },
+    db: {
+      type: "string",
+      description: "Database backend for sync templates (sqlite, postgres)"
+    },
+    "db-provider": {
+      type: "string",
+      description: "Database provider for postgres (local, supabase, neon, railway, vercel-postgres, custom)"
+    },
+    auth: {
+      type: "string",
+      description: "Authentication mode (none, email-password, oauth)"
+    },
+    "skip-install": {
+      type: "boolean",
+      description: "Skip installing dependencies",
+      default: false
+    },
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Accept all defaults (react-tailwind-sync + detected package manager)",
+      default: false
+    },
+    tailwind: {
+      type: "boolean",
+      description: "Use Tailwind CSS (use --no-tailwind to skip)"
+    },
+    sync: {
+      type: "boolean",
+      description: "Include sync server (use --no-sync to skip)"
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const prompts = createPromptClient();
+    const preferenceStore = new PreferenceStore();
+    logger.banner();
+    try {
+      const useDefaults = args.yes === true;
+      if (!useDefaults) {
+        prompts.intro("Kora.js \u2014 Offline-first application framework");
+      }
+      const projectName = args.name || (useDefaults ? "my-kora-app" : await prompts.text("Project name", "my-kora-app"));
+      if (!projectName) {
+        logger.error("Project name is required");
+        process.exitCode = 1;
+        return;
+      }
+      const nameValidation = validateProjectName(projectName);
+      if (!nameValidation.valid) {
+        logger.error("Invalid project name.");
+        for (const issue of nameValidation.issues) {
+          logger.step(`- ${issue}`);
+        }
+        if (!useDefaults) {
+          prompts.outro("Project creation aborted.");
+        }
+        process.exitCode = 1;
+        return;
+      }
+      const preferenceFlags = {
+        platform: typeof args.platform === "string" ? args.platform : void 0,
+        framework: typeof args.framework === "string" ? args.framework : void 0,
+        auth: typeof args.auth === "string" ? args.auth : void 0,
+        db: typeof args.db === "string" ? args.db : void 0,
+        dbProvider: typeof args["db-provider"] === "string" ? args["db-provider"] : void 0,
+        tailwind: args.tailwind,
+        sync: args.sync,
+        useDefaults
+      };
+      const selection = await resolveCreatePreferencesFlow({
+        flags: preferenceFlags,
+        prompts,
+        store: preferenceStore
+      });
+      if (!isSupportedWebFramework(selection.framework)) {
+        logger.error(
+          `Framework "${selection.framework}" is not available yet. Use react, vue, or svelte.`
+        );
+        if (!useDefaults) {
+          prompts.outro("Project creation aborted.");
+        }
+        process.exitCode = 1;
+        return;
+      }
+      if (selection.auth !== "none") {
+        logger.error(`Auth mode "${selection.auth}" is not available yet. Use "none".`);
+        if (!useDefaults) {
+          prompts.outro("Project creation aborted.");
+        }
+        process.exitCode = 1;
+        return;
+      }
+      const template = args.template && isValidTemplate(args.template) ? args.template : selection.template;
+      let pm;
+      if (args.pm && isValidPackageManager(args.pm)) {
+        pm = args.pm;
+      } else if (useDefaults) {
+        pm = detectPackageManager();
+      } else if (selection.usedStoredPreferences) {
+        pm = preferenceStore.getCreatePreferences()?.packageManager ?? detectPackageManager();
+      } else {
+        const detected = detectPackageManager();
+        pm = await prompts.select(
+          "Package manager:",
+          PACKAGE_MANAGERS.map((p) => ({
+            label: p === detected ? `${p} (detected)` : p,
+            value: p
+          }))
+        );
+      }
+      const editorDetection = detectEditorFromEnvironment();
+      const gitContext = await detectGitContext(process.cwd());
+      const monorepoContext = await detectMonorepoContext(process.cwd());
+      let targetDir = (0, import_node_path6.resolve)(process.cwd(), projectName);
+      if (!useDefaults && monorepoContext.isMonorepo && monorepoContext.root !== null) {
+        const useWorkspaceTarget = await prompts.confirm(
+          `Detected ${formatMonorepoKind(monorepoContext.kind)} at ${monorepoContext.root}. Create app under packages/${projectName}?`,
+          true
+        );
+        if (useWorkspaceTarget) {
+          targetDir = resolveMonorepoTargetDirectory(monorepoContext.root, projectName);
+        }
+      }
+      if (await directoryExists(targetDir)) {
+        throw new ProjectExistsError(projectName);
+      }
+      const koraVersion = resolveKoraVersion();
+      logger.step(`Creating ${projectName} with ${template} template...`);
+      await scaffoldTemplate(template, targetDir, {
+        projectName,
+        packageManager: pm,
+        koraVersion,
+        dbProvider: selection.dbProvider
+      });
+      await applySyncProviderPreset({
+        targetDir,
+        template,
+        db: selection.db,
+        dbProvider: selection.dbProvider
+      });
+      if (pm === "pnpm") {
+        await writePnpmWorkspaceSettings(targetDir);
+      }
+      if (!useDefaults && editorDetection.editor !== "unknown") {
+        const shouldApplyEditorPreset = await prompts.confirm(
+          `Detected ${formatEditor(editorDetection.editor)}. Add workspace recommendations for ${formatEditor(editorDetection.editor)}?`,
+          true
+        );
+        if (shouldApplyEditorPreset) {
+          const appliedPreset = await applyEditorWorkspacePreset({
+            targetDir,
+            editor: editorDetection.editor
+          });
+          if (appliedPreset.applied) {
+            logger.step(
+              `Added editor recommendations at ${relativeToTarget(targetDir, appliedPreset.filePath)}`
+            );
+          }
+        }
+      }
+      if (selection.db === "postgres" && isSyncTemplate2(template)) {
+        logger.info(
+          `Applied PostgreSQL sync preset (${formatDbProviderForLog(selection.dbProvider)}). Update DATABASE_URL in .env.example before running the sync server.`
+        );
+      }
+      if (gitContext.hasRepository) {
+        logger.step(
+          `Detected existing git repository at ${gitContext.repositoryRoot}. Skipping git initialization.`
+        );
+      }
+      logger.success("Project scaffolded");
+      if (shouldSavePreferences(preferenceFlags)) {
+        saveResolvedPreferences(preferenceStore, {
+          platform: selection.platform,
+          framework: selection.framework,
+          auth: selection.auth,
+          db: selection.db,
+          dbProvider: selection.dbProvider,
+          tailwind: selection.tailwind,
+          sync: selection.sync,
+          packageManager: pm
+        });
+      }
+      if (!args["skip-install"]) {
+        logger.step("Installing dependencies...");
+        try {
+          (0, import_node_child_process2.execSync)(getInstallCommand(pm), { cwd: targetDir, stdio: "inherit" });
+          logger.success("Dependencies installed");
+        } catch {
+          logger.warn("Failed to install dependencies. Run install manually.");
+        }
+      }
+      logger.blank();
+      logger.info("Done! Next steps:");
+      logger.blank();
+      logger.step(`  cd ${targetDir}`);
+      logger.step(`  ${getRunDevCommand(pm)}`);
+      logger.blank();
+      if (!useDefaults) {
+        prompts.outro("Project ready. Happy building with Kora!");
+      }
+    } catch (error) {
+      if (error instanceof PromptCancelledError) {
+        process.exitCode = 1;
+        return;
+      }
+      if (error instanceof Error && error.message.startsWith("Invalid --")) {
+        logger.error(error.message);
+        if (!args.yes) {
+          prompts.outro("Project creation aborted.");
+        }
+        process.exitCode = 1;
+        return;
+      }
+      throw error;
+    }
+  }
+});
+function isValidTemplate(value) {
+  return TEMPLATES.includes(value);
+}
+function isValidPackageManager(value) {
+  return PACKAGE_MANAGERS.includes(value);
+}
+function isSyncTemplate2(template) {
+  return template === "react-sync" || template === "react-tailwind-sync" || template === "vue-sync" || template === "vue-tailwind-sync" || template === "svelte-sync" || template === "svelte-tailwind-sync" || template === "tauri-react";
+}
+function formatDbProviderForLog(dbProvider) {
+  switch (dbProvider) {
+    case "supabase":
+      return "Supabase";
+    case "neon":
+      return "Neon";
+    case "railway":
+      return "Railway";
+    case "vercel-postgres":
+      return "Vercel Postgres";
+    case "custom":
+      return "Custom";
+    case "local":
+      return "Local Postgres";
+    case "none":
+      return "PostgreSQL";
+    default:
+      return dbProvider;
+  }
+}
+function formatEditor(editor) {
+  switch (editor) {
+    case "vscode":
+      return "VS Code";
+    case "cursor":
+      return "Cursor";
+    case "windsurf":
+      return "Windsurf";
+    case "zed":
+      return "Zed";
+    default:
+      return editor;
+  }
+}
+function formatMonorepoKind(kind) {
+  switch (kind) {
+    case "pnpm-workspace":
+      return "pnpm workspace";
+    case "npm-workspaces":
+      return "npm workspace";
+    case "turborepo":
+      return "Turborepo";
+    default:
+      return "monorepo";
+  }
+}
+function relativeToTarget(targetDir, filePath) {
+  if (filePath === null) return ".";
+  const normalizedTarget = targetDir.endsWith("/") ? targetDir : `${targetDir}/`;
+  if (filePath.startsWith(normalizedTarget)) {
+    return filePath.slice(normalizedTarget.length);
+  }
+  if (filePath === targetDir) {
+    return ".";
+  }
+  return filePath;
+}
+function resolveKoraVersion() {
+  try {
+    let dir = (0, import_node_path6.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
+    for (let i = 0; i < 5; i++) {
+      const pkgPath = (0, import_node_path6.resolve)(dir, "package.json");
+      if ((0, import_node_fs2.existsSync)(pkgPath)) {
+        const pkg = JSON.parse((0, import_node_fs2.readFileSync)(pkgPath, "utf-8"));
+        if (pkg.name === "@korajs/cli") {
+          return deriveKoraTemplateVersion(pkg.version);
+        }
+      }
+      dir = (0, import_node_path6.dirname)(dir);
+    }
+    return "latest";
+  } catch {
+    return "latest";
+  }
+}
+function deriveKoraTemplateVersion(version) {
+  if (version === "0.0.0") return "latest";
+  if (version.includes("-")) return version;
+  const parts = version.split(".");
+  return `^${parts[0]}.${parts[1]}.0`;
+}
+
+// src/create.ts
+(0, import_citty2.runMain)(createCommand);
+//# sourceMappingURL=create.cjs.map