@korajs/cli 0.1.15 → 0.3.0

package/dist/chunk-ZGYRDYXS.js

@@ -0,0 +1,609 @@
+#!/usr/bin/env node
+import {
+  PACKAGE_MANAGERS,
+  PreferenceStore,
+  ProjectExistsError,
+  PromptCancelledError,
+  TEMPLATES,
+  applySyncProviderPreset,
+  createLogger,
+  createPromptClient,
+  directoryExists,
+  resolveCreatePreferencesFlow,
+  saveResolvedPreferences,
+  shouldSavePreferences,
+  validateProjectName
+} from "./chunk-KTSRAPSE.js";
+
+// src/commands/create/create-command.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname as dirname3, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { defineCommand } from "citty";
+
+// src/utils/package-manager.ts
+import { execSync } from "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
+import { access, mkdir, readFile, stat, writeFile } from "fs/promises";
+import { dirname, join, resolve } from "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 = resolve(startDir);
+  for (; ; ) {
+    if (await fileExists(join(current, "pnpm-workspace.yaml"))) {
+      return { isMonorepo: true, root: current, kind: "pnpm-workspace" };
+    }
+    if (await fileExists(join(current, "turbo.json"))) {
+      return { isMonorepo: true, root: current, kind: "turborepo" };
+    }
+    const packageJsonPath = join(current, "package.json");
+    if (await fileExists(packageJsonPath)) {
+      try {
+        const packageJsonRaw = await 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 = 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 = join(targetDir, ".vscode");
+  const extensionsPath = join(vscodeDir, "extensions.json");
+  await 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 writeFile(extensionsPath, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+  return { applied: true, filePath: extensionsPath };
+}
+function resolveMonorepoTargetDirectory(monorepoRoot, projectName) {
+  return join(monorepoRoot, "packages", projectName);
+}
+function dedupeStrings(values) {
+  return Array.from(new Set(values));
+}
+async function readJsonObject(path) {
+  try {
+    const content = await 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 access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findNearestAncestorWithEntry(startDir, entryName) {
+  let current = resolve(startDir);
+  for (; ; ) {
+    const candidate = join(current, entryName);
+    try {
+      await stat(candidate);
+      return current;
+    } catch {
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+// src/templates/composer.ts
+import { existsSync } from "fs";
+import { copyFile, mkdir as mkdir2, readFile as readFile2, readdir, stat as stat2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+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 = dirname2(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 7; i++) {
+    const candidate = resolve2(dir, "templates", templateName);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    dir = dirname2(dir);
+  }
+  const currentDir = dirname2(fileURLToPath(import.meta.url));
+  return resolve2(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
+        ]
+      };
+  }
+}
+async function composeTemplateLayers(plan, targetDir, context) {
+  const vars = {
+    projectName: context.projectName,
+    packageManager: context.packageManager,
+    koraVersion: context.koraVersion,
+    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 mkdir2(dest, { recursive: true });
+  const entries = await readdir(src);
+  for (const entry of entries) {
+    const srcPath = join2(src, entry);
+    const srcStat = await stat2(srcPath);
+    if (srcStat.isDirectory()) {
+      await copyDirectory(srcPath, join2(dest, entry), vars);
+      continue;
+    }
+    if (entry.endsWith(".hbs")) {
+      const content = await readFile2(srcPath, "utf-8");
+      const outputName = entry.slice(0, -4);
+      await writeFile2(join2(dest, outputName), substituteVariables(content, vars), "utf-8");
+      continue;
+    }
+    await copyFile(srcPath, join2(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 createCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: "Create a new Kora application"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Project directory name",
+      required: false
+    },
+    template: {
+      type: "string",
+      description: "Project template (react-tailwind-sync, react-tailwind, react-sync, react-basic)"
+    },
+    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 = {
+        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 (selection.framework !== "react") {
+        logger.error(`Framework "${selection.framework}" is not available yet. Use "react".`);
+        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 = resolve3(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 (!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" && isSyncTemplate(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, {
+          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 {
+          execSync2(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 isSyncTemplate(template) {
+  return template === "react-sync" || template === "react-tailwind-sync";
+}
+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 = dirname3(fileURLToPath2(import.meta.url));
+    for (let i = 0; i < 5; i++) {
+      const pkgPath = resolve3(dir, "package.json");
+      if (existsSync2(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "@korajs/cli") {
+          if (pkg.version === "0.0.0") return "latest";
+          const parts = pkg.version.split(".");
+          return `^${parts[0]}.${parts[1]}.0`;
+        }
+      }
+      dir = dirname3(dir);
+    }
+    return "latest";
+  } catch {
+    return "latest";
+  }
+}
+
+export {
+  createCommand
+};
+//# sourceMappingURL=chunk-ZGYRDYXS.js.map