@korajs/cli 0.1.15 → 0.2.0

package/dist/chunk-KTSRAPSE.js

@@ -0,0 +1,752 @@
+#!/usr/bin/env node
+
+// src/errors.ts
+import { KoraError } from "@korajs/core";
+var CliError = class extends KoraError {
+  constructor(message, context) {
+    super(message, "CLI_ERROR", context);
+    this.name = "CliError";
+  }
+};
+var ProjectExistsError = class extends 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;
+};
+var SchemaNotFoundError = class extends KoraError {
+  constructor(searchedPaths) {
+    super(
+      `Could not find a schema file. Searched: ${searchedPaths.join(", ")}. Create a schema file using defineSchema() from @korajs/core.`,
+      "SCHEMA_NOT_FOUND",
+      { searchedPaths }
+    );
+    this.searchedPaths = searchedPaths;
+    this.name = "SchemaNotFoundError";
+  }
+  searchedPaths;
+};
+var InvalidProjectError = class extends KoraError {
+  constructor(directory) {
+    super(
+      `"${directory}" is not a valid Kora project. No package.json with a kora dependency found. Run this command from inside a Kora project.`,
+      "INVALID_PROJECT",
+      { directory }
+    );
+    this.directory = directory;
+    this.name = "InvalidProjectError";
+  }
+  directory;
+};
+var DevServerError = class extends KoraError {
+  constructor(binary, searchPath) {
+    super(
+      `Could not find required binary "${binary}" at ${searchPath}. Install project dependencies and try again.`,
+      "DEV_SERVER_ERROR",
+      { binary, searchPath }
+    );
+    this.binary = binary;
+    this.searchPath = searchPath;
+    this.name = "DevServerError";
+  }
+  binary;
+  searchPath;
+};
+
+// src/prompts/preferences.ts
+import Conf from "conf";
+var DEFAULT_PREFERENCES = {
+  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 Conf({
+      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
+import {
+  cancel as clackCancel,
+  confirm as clackConfirm,
+  intro as clackIntro,
+  isCancel as clackIsCancel,
+  outro as clackOutro,
+  select as clackSelect,
+  text as clackText
+} from "@clack/prompts";
+
+// src/utils/prompt.ts
+import { createInterface } from "readline";
+function promptText(message, defaultValue, options) {
+  return new Promise((resolve2) => {
+    const rl = createReadline(options);
+    const suffix = defaultValue !== void 0 ? ` (${defaultValue})` : "";
+    rl.question(`  ? ${message}${suffix}: `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      resolve2(trimmed || defaultValue || "");
+    });
+  });
+}
+function promptSelect(message, choices, options) {
+  return new Promise((resolve2) => {
+    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();
+          resolve2(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((resolve2) => {
+    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();
+          resolve2(defaultValue);
+          return;
+        }
+        if (normalized === "y" || normalized === "yes") {
+          rl.close();
+          resolve2(true);
+          return;
+        }
+        if (normalized === "n" || normalized === "no") {
+          rl.close();
+          resolve2(false);
+          return;
+        }
+        (options?.output ?? process.stdout).write("  Please answer with y or n\n");
+        ask();
+      });
+    };
+    ask();
+  });
+}
+function createReadline(options) {
+  return 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 clackText({
+      message,
+      placeholder: defaultValue,
+      defaultValue
+    });
+    if (clackIsCancel(result)) {
+      clackCancel("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 clackSelect({
+      message,
+      options: mappedOptions
+    });
+    if (clackIsCancel(result)) {
+      clackCancel("Operation cancelled.");
+      throw new PromptCancelledError();
+    }
+    return result;
+  }
+  async confirm(message, defaultValue = false) {
+    const result = await clackConfirm({
+      message,
+      initialValue: defaultValue
+    });
+    if (clackIsCancel(result)) {
+      clackCancel("Operation cancelled.");
+      throw new PromptCancelledError();
+    }
+    return result;
+  }
+  intro(message) {
+    clackIntro(message);
+  }
+  outro(message) {
+    clackOutro(message);
+  }
+};
+
+// src/types.ts
+var PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+var TEMPLATES = [
+  "react-tailwind-sync",
+  "react-tailwind",
+  "react-sync",
+  "react-basic"
+];
+var TEMPLATE_INFO = [
+  {
+    name: "react-tailwind-sync",
+    label: "React + Tailwind (with sync)",
+    description: "Polished dark-themed app with Tailwind CSS and sync server (Recommended)"
+  },
+  {
+    name: "react-tailwind",
+    label: "React + Tailwind (local-only)",
+    description: "Polished dark-themed app with Tailwind CSS \u2014 no sync server"
+  },
+  {
+    name: "react-sync",
+    label: "React + CSS (with sync)",
+    description: "Clean CSS app with sync server included"
+  },
+  {
+    name: "react-basic",
+    label: "React + CSS (local-only)",
+    description: "Clean CSS app \u2014 no sync server"
+  }
+];
+
+// src/commands/create/options.ts
+function determineTemplateFromSelections(input) {
+  const shouldSync = input.sync && input.db !== "none";
+  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 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";
+}
+
+// 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.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 (coming soon)", value: "vue", disabled: true },
+      { label: "Svelte (coming soon)", value: "svelte", disabled: true },
+      { 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({
+    tailwind: effective.tailwind,
+    sync: effective.sync,
+    db: effective.db
+  });
+  return {
+    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({
+    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.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) {
+  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
+import validateNpmPackageName from "validate-npm-package-name";
+function validateProjectName(name) {
+  const trimmedName = name.trim();
+  if (trimmedName.length === 0) {
+    return {
+      valid: false,
+      issues: ["Project name cannot be empty."]
+    };
+  }
+  const validation = validateNpmPackageName(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
+import { readFile, writeFile } from "fs/promises";
+import { join } from "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 serverPath = join(options.targetDir, "server.ts");
+  const envPath = join(options.targetDir, ".env.example");
+  const readmePath = join(options.targetDir, "README.md");
+  const serverTemplate = [
+    "import { createPostgresServerStore, createProductionServer } from '@korajs/server'",
+    "",
+    `// PostgreSQL provider preset: ${providerName}`,
+    "// Ensure DATABASE_URL is set in your environment.",
+    "",
+    "async function start(): Promise<void> {",
+    "	const connectionString = process.env.DATABASE_URL || ''",
+    "	if (connectionString.length === 0) {",
+    "		throw new Error('DATABASE_URL is required for PostgreSQL sync server store.')",
+    "	}",
+    "",
+    "	const store = await createPostgresServerStore({ connectionString })",
+    "	const server = createProductionServer({",
+    "		store,",
+    "		port: Number(process.env.PORT) || 3001,",
+    "		staticDir: './dist',",
+    "		syncPath: '/kora-sync',",
+    "	})",
+    "",
+    "	const url = await server.start()",
+    "	console.log(`Kora app running at ${url}`)",
+    "}",
+    "",
+    "void start()",
+    ""
+  ].join("\n");
+  const envTemplate = [
+    "# Kora Sync Server",
+    "# WebSocket URL for the sync server (used by the client)",
+    "VITE_SYNC_URL=ws://localhost:3001",
+    "",
+    "# Sync server port",
+    "PORT=3001",
+    "",
+    `# PostgreSQL connection string (${providerName})`,
+    `# Example: ${providerConnectionString}`,
+    "DATABASE_URL=",
+    ""
+  ].join("\n");
+  const existingReadme = await readFile(readmePath, "utf-8");
+  const trimmedReadme = existingReadme.trimEnd();
+  const readmeSuffix = [
+    "",
+    "## PostgreSQL Provider Preset",
+    "",
+    `Selected DB provider: ${options.dbProvider}`,
+    "",
+    "This scaffold uses `createPostgresServerStore` in `server.ts` and reads `DATABASE_URL` from the environment. See `.env.example` for provider-specific examples.",
+    ""
+  ].join("\n");
+  const readmeTemplate = `${trimmedReadme}${readmeSuffix}`;
+  await writeFile(serverPath, serverTemplate, "utf-8");
+  await writeFile(envPath, envTemplate, "utf-8");
+  await writeFile(readmePath, readmeTemplate, "utf-8");
+}
+function isSyncTemplate(template) {
+  return template === "react-sync" || template === "react-tailwind-sync";
+}
+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/utils/fs-helpers.ts
+import { access, readFile as readFile2 } from "fs/promises";
+import { dirname, join as join2, resolve } from "path";
+async function directoryExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findProjectRoot(startDir) {
+  let current = resolve(startDir ?? process.cwd());
+  for (; ; ) {
+    const pkgPath = join2(current, "package.json");
+    try {
+      const content = await readFile2(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (isKoraProject(pkg)) {
+        return current;
+      }
+    } catch {
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+async function findSchemaFile(projectRoot) {
+  const candidates = [
+    join2(projectRoot, "src", "schema.ts"),
+    join2(projectRoot, "schema.ts"),
+    join2(projectRoot, "src", "schema.js"),
+    join2(projectRoot, "schema.js")
+  ];
+  for (const candidate of candidates) {
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function hasTsxInstalled(projectRoot) {
+  try {
+    await access(join2(projectRoot, "node_modules", "tsx", "package.json"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveProjectBinaryEntryPoint(projectRoot, packageName, binaryName) {
+  const pkgJsonPath = join2(projectRoot, "node_modules", packageName, "package.json");
+  try {
+    const content = await readFile2(pkgJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    let binPath;
+    if (typeof pkg.bin === "string") {
+      binPath = pkg.bin;
+    } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
+      binPath = pkg.bin[binaryName];
+    }
+    if (!binPath) return null;
+    const fullPath = join2(projectRoot, "node_modules", packageName, binPath);
+    await access(fullPath);
+    return fullPath;
+  } catch {
+    return null;
+  }
+}
+function isKoraProject(pkg) {
+  if (typeof pkg !== "object" || pkg === null) return false;
+  const record = pkg;
+  return hasKoraDep(record.dependencies) || hasKoraDep(record.devDependencies);
+}
+function hasKoraDep(deps) {
+  if (typeof deps !== "object" || deps === null) return false;
+  return Object.keys(deps).some((key) => key === "kora" || key.startsWith("@korajs/"));
+}
+
+// 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, " \u2014 Offline-first application framework")
+      );
+      console.log();
+    }
+  };
+}
+
+export {
+  CliError,
+  ProjectExistsError,
+  SchemaNotFoundError,
+  InvalidProjectError,
+  DevServerError,
+  PreferenceStore,
+  getCreatePreferencesOrDefault,
+  getDefaultCreatePreferences,
+  promptConfirm,
+  PromptCancelledError,
+  ReadlinePromptClient,
+  createPromptClient,
+  ClackPromptClient,
+  PACKAGE_MANAGERS,
+  TEMPLATES,
+  TEMPLATE_INFO,
+  directoryExists,
+  findProjectRoot,
+  findSchemaFile,
+  hasTsxInstalled,
+  resolveProjectBinaryEntryPoint,
+  createLogger,
+  determineTemplateFromSelections,
+  isFrameworkValue,
+  isAuthValue,
+  isDatabaseValue,
+  isDatabaseProviderValue,
+  resolveCreatePreferencesFlow,
+  shouldSavePreferences,
+  saveResolvedPreferences,
+  validateProjectName,
+  applySyncProviderPreset
+};
+//# sourceMappingURL=chunk-KTSRAPSE.js.map