@rebasepro/cli 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -1,1168 +1,1344 @@
 (function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("chalk"), require("arg"), require("inquirer"), require("path"), require("fs"), require("net"), require("util"), require("execa"), require("fs/promises"), require("url"), require("crypto"), require("@rebasepro/sdk-generator"), require("child_process")) : typeof define === "function" && define.amd ? define(["exports", "chalk", "arg", "inquirer", "path", "fs", "net", "util", "execa", "fs/promises", "url", "crypto", "@rebasepro/sdk-generator", "child_process"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase CLI"] = {}, global.chalk, global.arg, global.inquirer, global.path, global.fs, global.net, global.util, global.execa, global.promises, global.url, global.crypto, global.sdkGenerator, global.child_process));
-})(this, (function(exports2, chalk, arg, inquirer, path, fs, net, util, execa, promises, url, crypto, sdkGenerator, child_process) {
-  "use strict";
-  var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
-  function detectPackageManager(targetDir) {
-    const userAgent = process.env.npm_config_user_agent ?? "";
-    if (userAgent.startsWith("npm/")) return "npm";
-    if (userAgent.startsWith("pnpm/")) return "pnpm";
-    if (targetDir) {
-      if (fs.existsSync(path.join(targetDir, "package-lock.json"))) return "npm";
-      if (fs.existsSync(path.join(targetDir, "pnpm-lock.yaml"))) return "pnpm";
-    }
-    const cwd = process.cwd();
-    if (cwd !== targetDir) {
-      if (fs.existsSync(path.join(cwd, "package-lock.json"))) return "npm";
-      if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-    }
-    return "pnpm";
-  }
-  function getPMCommands(pm) {
-    if (pm === "npm") {
-      return {
-        name: "npm",
-        install: ["npm", "install"],
-        run: (script) => ["npm", "run", script],
-        exec: (bin, args) => ["npx", bin, ...args],
-        view: (pkg, field) => ["npm", "view", pkg, field],
-        runAll: (script) => ["npm", "run", script, "--workspaces", "--if-present"],
-        runWorkspace: (workspace, script) => ["npm", "run", script, "-w", workspace],
-        workspaceProtocol: "*"
-      };
-    }
-    return {
-      name: "pnpm",
-      install: ["pnpm", "install"],
-      run: (script) => ["pnpm", "run", script],
-      exec: (bin, args) => ["pnpm", "exec", bin, ...args],
-      view: (pkg, field) => ["pnpm", "view", pkg, field],
-      runAll: (script) => ["pnpm", "-r", "run", script],
-      runWorkspace: (workspace, script) => ["pnpm", "--filter", workspace, script],
-      workspaceProtocol: "workspace:*"
-    };
-  }
-  const access = util.promisify(fs.access);
-  const __filename$2 = url.fileURLToPath(typeof document === "undefined" && typeof location === "undefined" ? require("url").pathToFileURL(__filename).href : typeof document === "undefined" ? location.href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href);
-  const __dirname$2 = path.dirname(__filename$2);
-  function findParentDir(currentDir, targetName) {
-    const root = path.parse(currentDir).root;
-    while (currentDir && currentDir !== root) {
-      if (path.basename(currentDir) === targetName) {
-        return currentDir;
-      }
-      currentDir = path.dirname(currentDir);
-    }
-    return null;
-  }
-  const cliRoot = findParentDir(__dirname$2, "cli");
-  const PRESET_CHOICES = [
-    { name: "Blog         — Posts, Authors, Tags (with markdown editor)", value: "blog", short: "Blog" },
-    { name: "E-commerce   — Products, Categories, Orders", value: "ecommerce", short: "E-commerce" },
-    { name: "Blank        — Empty project, just authentication", value: "blank", short: "Blank" }
-  ];
-  async function createRebaseApp(rawArgs) {
-    console.log(`
-${chalk.bold("Rebase")} — Create a new project 🚀
+	typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("chalk"), require("arg"), require("inquirer"), require("path"), require("fs"), require("net"), require("util"), require("execa"), require("fs/promises"), require("url"), require("crypto"), require("@rebasepro/sdk-generator"), require("child_process")) : typeof define === "function" && define.amd ? define([
+		"exports",
+		"chalk",
+		"arg",
+		"inquirer",
+		"path",
+		"fs",
+		"net",
+		"util",
+		"execa",
+		"fs/promises",
+		"url",
+		"crypto",
+		"@rebasepro/sdk-generator",
+		"child_process"
+	], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase CLI"] = {}, global.chalk, global.arg, global.inquirer, global.path, global.fs, global.net, global.util, global.execa, global.fs_promises, global.url, global.crypto, global._rebasepro_sdk_generator, global.child_process));
+})(this, function(exports, chalk, arg, inquirer, path, fs, net, util, execa, fs_promises, url, crypto, _rebasepro_sdk_generator, child_process) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region \0rolldown/runtime.js
+	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 (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+	//#endregion
+	chalk = __toESM(chalk, 1);
+	arg = __toESM(arg, 1);
+	inquirer = __toESM(inquirer, 1);
+	path = __toESM(path, 1);
+	fs = __toESM(fs, 1);
+	net = __toESM(net, 1);
+	crypto = __toESM(crypto, 1);
+	//#region src/utils/package-manager.ts
+	/**
+	* Package manager detection and command abstraction.
+	*
+	* Detects whether the user is running pnpm or npm and provides
+	* a unified interface for common package-manager operations so
+	* the rest of the CLI never has to hardcode a specific PM.
+	*/
+	/**
+	* Detect the package manager from the environment or the target directory.
+	*
+	* Detection order:
+	* 1. Explicit override (if provided)
+	* 2. `npm_config_user_agent` env var (set by npm/pnpm when running via `npx`/`pnpm dlx`)
+	* 3. Lock-file presence in the target directory
+	* 4. Default to pnpm (Rebase's recommended PM)
+	*/
+	function detectPackageManager(targetDir) {
+		const userAgent = process.env.npm_config_user_agent ?? "";
+		if (userAgent.startsWith("npm/")) return "npm";
+		if (userAgent.startsWith("pnpm/")) return "pnpm";
+		if (targetDir) {
+			if (fs.default.existsSync(path.default.join(targetDir, "package-lock.json"))) return "npm";
+			if (fs.default.existsSync(path.default.join(targetDir, "pnpm-lock.yaml"))) return "pnpm";
+		}
+		const cwd = process.cwd();
+		if (cwd !== targetDir) {
+			if (fs.default.existsSync(path.default.join(cwd, "package-lock.json"))) return "npm";
+			if (fs.default.existsSync(path.default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+		}
+		return "pnpm";
+	}
+	/** Build the command helpers for a given package manager. */
+	function getPMCommands(pm) {
+		if (pm === "npm") return {
+			name: "npm",
+			install: ["npm", "install"],
+			run: (script) => [
+				"npm",
+				"run",
+				script
+			],
+			exec: (bin, args) => [
+				"npx",
+				bin,
+				...args
+			],
+			view: (pkg, field) => [
+				"npm",
+				"view",
+				pkg,
+				field
+			],
+			runAll: (script) => [
+				"npm",
+				"run",
+				script,
+				"--workspaces",
+				"--if-present"
+			],
+			runWorkspace: (workspace, script) => [
+				"npm",
+				"run",
+				script,
+				"-w",
+				workspace
+			],
+			dlx: (pkg, args) => [
+				"npx",
+				"-y",
+				pkg,
+				...args
+			],
+			workspaceProtocol: "*"
+		};
+		return {
+			name: "pnpm",
+			install: ["pnpm", "install"],
+			run: (script) => [
+				"pnpm",
+				"run",
+				script
+			],
+			exec: (bin, args) => [
+				"pnpm",
+				"exec",
+				bin,
+				...args
+			],
+			view: (pkg, field) => [
+				"pnpm",
+				"view",
+				pkg,
+				field
+			],
+			runAll: (script) => [
+				"pnpm",
+				"-r",
+				"run",
+				script
+			],
+			runWorkspace: (workspace, script) => [
+				"pnpm",
+				"--filter",
+				workspace,
+				script
+			],
+			dlx: (pkg, args) => [
+				"pnpm",
+				"dlx",
+				pkg,
+				...args
+			],
+			workspaceProtocol: "workspace:*"
+		};
+	}
+	//#endregion
+	//#region src/commands/init.ts
+	var access = (0, util.promisify)(fs.default.access);
+	var __filename$2 = (0, url.fileURLToPath)({}.url);
+	var __dirname$2 = path.default.dirname(__filename$2);
+	function findParentDir$1(currentDir, targetName) {
+		const root = path.default.parse(currentDir).root;
+		while (currentDir && currentDir !== root) {
+			if (path.default.basename(currentDir) === targetName) return currentDir;
+			currentDir = path.default.dirname(currentDir);
+		}
+		return null;
+	}
+	var cliRoot = findParentDir$1(__dirname$2, "cli");
+	var PRESET_CHOICES = [
+		{
+			name: "Blog         — Posts, Authors, Tags (with markdown editor)",
+			value: "blog",
+			short: "Blog"
+		},
+		{
+			name: "E-commerce   — Products, Categories, Orders",
+			value: "ecommerce",
+			short: "E-commerce"
+		},
+		{
+			name: "Blank        — Empty project, just authentication",
+			value: "blank",
+			short: "Blank"
+		}
+	];
+	async function createRebaseApp(rawArgs) {
+		console.log(`
+${chalk.default.bold("Rebase")} — Create a new project 🚀
 `);
-    const pm = detectPackageManager();
-    const options = await promptForOptions(rawArgs, pm);
-    await createProject(options);
-  }
-  async function promptForOptions(rawArgs, pm) {
-    const args = arg(
-      {
-        "--git": Boolean,
-        "--install": Boolean,
-        "--database-url": String,
-        "--introspect": Boolean,
-        "--template": String,
-        "--yes": Boolean,
-        "-g": "--git",
-        "-i": "--install",
-        "-t": "--template",
-        "-y": "--yes"
-      },
-      {
-        argv: rawArgs.slice(3),
-        // skip "node", "rebase", "init"
-        permissive: true
-      }
-    );
-    const nameArg = args._[0];
-    const isNonInteractive = args["--yes"] || false;
-    const templateArg = args["--template"];
-    if (templateArg && !PRESET_CHOICES.some((p) => p.value === templateArg)) {
-      console.error(chalk.red(`Unknown template "${templateArg}". Available: ${PRESET_CHOICES.map((p) => p.value).join(", ")}`));
-      process.exit(1);
-    }
-    if (isNonInteractive) {
-      const projectName2 = nameArg || "my-rebase-app";
-      const targetDirectory2 = path.resolve(process.cwd(), projectName2);
-      const templateDirectory2 = path.resolve(cliRoot, "templates", "template");
-      const pmCommands2 = getPMCommands(pm);
-      return {
-        projectName: path.basename(targetDirectory2),
-        git: args["--git"] ?? false,
-        installDeps: args["--install"] ?? false,
-        targetDirectory: targetDirectory2,
-        templateDirectory: templateDirectory2,
-        databaseUrl: args["--database-url"] || void 0,
-        introspect: args["--introspect"] || false,
-        preset: templateArg || "blog",
-        pm,
-        pmCommands: pmCommands2
-      };
-    }
-    const questions = [];
-    if (!nameArg) {
-      questions.push({
-        type: "input",
-        name: "projectName",
-        message: "Project name:",
-        default: "my-rebase-app",
-        validate: (input) => {
-          if (!input.trim()) return "Project name is required";
-          if (!/^[a-z0-9][a-z0-9._-]*$/.test(input)) {
-            return "Project name must start with a lowercase letter or number and contain only lowercase letters, numbers, hyphens, dots, or underscores";
-          }
-          return true;
-        }
-      });
-    }
-    if (!templateArg) {
-      questions.push({
-        type: "list",
-        name: "preset",
-        message: "Choose a starter template:",
-        choices: PRESET_CHOICES,
-        default: "blog"
-      });
-    }
-    if (!args["--git"]) {
-      questions.push({
-        type: "confirm",
-        name: "git",
-        message: "Initialize a git repository?",
-        default: true
-      });
-    }
-    if (!args["--install"]) {
-      questions.push({
-        type: "confirm",
-        name: "installDeps",
-        message: `Install dependencies with ${pm}?`,
-        default: true
-      });
-    }
-    questions.push({
-      type: "input",
-      name: "databaseUrl",
-      message: "Enter your PostgreSQL database connection string (leave blank to use a local default):",
-      default: "",
-      validate: (input) => {
-        if (input.trim() && /[\r\n]/.test(input)) {
-          return "Database URL cannot contain newline characters.";
-        }
-        return true;
-      }
-    });
-    questions.push({
-      type: "confirm",
-      name: "introspect",
-      message: "Would you like to introspect this database to automatically generate collections?",
-      default: true,
-      when: (answers2) => !!answers2.databaseUrl?.trim()
-    });
-    const answers = await inquirer.prompt(questions);
-    const targetDirectory = path.resolve(process.cwd(), nameArg || answers.projectName);
-    const projectName = path.basename(targetDirectory);
-    const templateDirectory = path.resolve(cliRoot, "templates", "template");
-    const pmCommands = getPMCommands(pm);
-    return {
-      projectName,
-      git: args["--git"] || answers.git || false,
-      installDeps: args["--install"] || answers.installDeps || false,
-      targetDirectory,
-      templateDirectory,
-      databaseUrl: answers.databaseUrl?.trim() || void 0,
-      introspect: answers.introspect || false,
-      preset: templateArg || answers.preset || "blog",
-      pm,
-      pmCommands
-    };
-  }
-  async function createProject(options) {
-    if (fs.existsSync(options.targetDirectory)) {
-      if (fs.readdirSync(options.targetDirectory).length !== 0) {
-        console.error(`${chalk.red.bold("ERROR")} Directory "${options.projectName}" already exists and is not empty`);
-        process.exit(1);
-      }
-    } else {
-      fs.mkdirSync(options.targetDirectory, { recursive: true });
-    }
-    try {
-      await access(options.templateDirectory, fs.constants.R_OK);
-    } catch {
-      console.error(`${chalk.red.bold("ERROR")} Template not found at ${options.templateDirectory}`);
-      process.exit(1);
-    }
-    console.log(chalk.gray("  Copying project files..."));
-    try {
-      await promises.cp(options.templateDirectory, options.targetDirectory, {
-        recursive: true,
-        filter: (source) => {
-          const basename = path.basename(source);
-          return basename !== "node_modules" && basename !== ".DS_Store";
-        }
-      });
-    } catch (err) {
-      console.error(`${chalk.red.bold("ERROR")} Failed to copy template files: ${err instanceof Error ? err.message : String(err)}`);
-      process.exit(1);
-    }
-    await applyPreset(options.targetDirectory, options.preset);
-    await replacePlaceholders(options);
-    await configureEnvFile(options.targetDirectory, options.databaseUrl);
-    if (options.git) {
-      console.log(chalk.gray("  Initializing git repository..."));
-      try {
-        await execa.execa("git", ["init"], { cwd: options.targetDirectory });
-      } catch {
-        console.warn(chalk.yellow("  Warning: Failed to initialize git repository"));
-      }
-    }
-    const { pm, pmCommands } = options;
-    const installCmd = pmCommands.install;
-    const execCmd = pmCommands.exec("rebase", ["schema", "introspect", "--force"]);
-    if (options.installDeps) {
-      console.log("");
-      console.log(chalk.gray(`  Installing dependencies with ${pm}...`));
-      console.log("");
-      try {
-        await execa.execa(installCmd[0], installCmd.slice(1), {
-          cwd: options.targetDirectory,
-          stdio: "inherit"
-        });
-      } catch {
-        console.warn(chalk.yellow(`  Warning: Failed to install dependencies. You may need to run \`${installCmd.join(" ")}\` manually.`));
-      }
-    }
-    if (options.introspect) {
-      console.log("");
-      if (options.installDeps) {
-        console.log(chalk.gray("  Introspecting database and generating collections..."));
-        console.log("");
-        try {
-          await execa.execa(execCmd[0], execCmd.slice(1), {
-            cwd: options.targetDirectory,
-            stdio: "inherit"
-          });
-          console.log(chalk.green("  Database successfully introspected!"));
-        } catch {
-          console.warn(chalk.yellow("  Warning: Failed to introspect database automatically."));
-          console.warn(chalk.yellow(`  You can run \`${execCmd.join(" ")}\` manually after setup.`));
-        }
-      } else {
-        console.warn(chalk.yellow("  Skipping introspection because dependencies were not installed."));
-        console.warn(chalk.yellow(`  Run \`${installCmd.join(" ")}\` then \`${execCmd.join(" ")}\` manually.`));
-      }
-    }
-    console.log("");
-    console.log(`${chalk.green.bold("✓")} Project ${chalk.bold(options.projectName)} created successfully!`);
-    console.log("");
-    console.log(chalk.bold("Next steps:"));
-    console.log("");
-    const runDev = pmCommands.run("dev");
-    const runDbPush = pmCommands.run("db:push");
-    console.log(`  ${chalk.cyan("cd")} ${options.projectName}`);
-    if (!options.installDeps) {
-      console.log(`  ${chalk.cyan(installCmd.join(" "))}`);
-    }
-    console.log("");
-    if (options.databaseUrl) {
-      if (options.introspect) {
-        console.log(chalk.gray("  # Database has been introspected & collections generated!"));
-        console.log(chalk.gray("  # Start the development server (frontend + backend):"));
-        console.log(`  ${chalk.cyan(runDev.join(" "))}`);
-      } else {
-        console.log(chalk.gray("  # Your custom database is configured in .env."));
-        console.log(chalk.gray("  # If the database is empty, push the Rebase schema to initialize it:"));
-        console.log(`  ${chalk.cyan(runDbPush.join(" "))}`);
-        console.log("");
-        console.log(chalk.gray("  # Then start the development server:"));
-        console.log(`  ${chalk.cyan(runDev.join(" "))}`);
-      }
-    } else {
-      console.log(chalk.gray("  # A local database configuration has been generated in .env."));
-      console.log(chalk.gray("  # 1. Start the PostgreSQL database container:"));
-      console.log(`  ${chalk.cyan("docker compose up -d db")}`);
-      console.log("");
-      console.log(chalk.gray("  # 2. Push the Rebase schema to initialize database tables:"));
-      console.log(`  ${chalk.cyan(runDbPush.join(" "))}`);
-      console.log("");
-      console.log(chalk.gray("  # 3. Start the development server (frontend + backend):"));
-      console.log(`  ${chalk.cyan(runDev.join(" "))}`);
-    }
-    console.log("");
-    console.log(chalk.gray("This starts both the backend (Hono + PostgreSQL)") + chalk.gray(" and the frontend (Vite + React) concurrently."));
-    console.log("");
-    console.log(chalk.gray("Docs: https://rebase.pro/docs"));
-    console.log(chalk.gray("GitHub: https://github.com/rebasepro/rebase"));
-    console.log("");
-  }
-  async function applyPreset(targetDirectory, preset) {
-    const collectionsDir = path.join(targetDirectory, "config", "collections");
-    const presetsDir = path.join(collectionsDir, "presets");
-    if (preset !== "blog") {
-      const presetDir = path.join(presetsDir, preset);
-      if (!fs.existsSync(presetDir)) {
-        console.warn(chalk.yellow(`  Warning: Preset "${preset}" not found, falling back to blog template.`));
-        cleanupPresets(presetsDir);
-        return;
-      }
-      const blogFiles = ["posts.ts", "authors.ts", "tags.ts", "index.ts"];
-      for (const file of blogFiles) {
-        const filePath = path.join(collectionsDir, file);
-        if (fs.existsSync(filePath)) {
-          fs.unlinkSync(filePath);
-        }
-      }
-      const presetFiles = fs.readdirSync(presetDir).filter((f) => f.endsWith(".ts"));
-      for (const file of presetFiles) {
-        fs.copyFileSync(
-          path.join(presetDir, file),
-          path.join(collectionsDir, file)
-        );
-      }
-    }
-    cleanupPresets(presetsDir);
-  }
-  function cleanupPresets(presetsDir) {
-    if (fs.existsSync(presetsDir)) {
-      fs.rmSync(presetsDir, { recursive: true, force: true });
-    }
-  }
-  async function replacePlaceholders(options) {
-    const filesToProcess = [
-      "package.json",
-      "frontend/package.json",
-      "backend/package.json",
-      "config/package.json",
-      "frontend/index.html",
-      "pnpm-workspace.yaml",
-      "README.md"
-    ];
-    const packageJsonPath = path.resolve(cliRoot, "package.json");
-    let cliVersion = "latest";
-    if (fs.existsSync(packageJsonPath)) {
-      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-      cliVersion = pkg.version || "latest";
-    }
-    const versionCache = /* @__PURE__ */ new Map();
-    const viewBin = "npm";
-    const getPackageVersion = async (pkgName) => {
-      if (versionCache.has(pkgName)) return versionCache.get(pkgName);
-      if (process.env.REBASE_E2E === "true") {
-        versionCache.set(pkgName, cliVersion);
-        return cliVersion;
-      }
-      let versionToUse = cliVersion;
-      try {
-        const { stdout } = await execa.execa(viewBin, ["view", `${pkgName}@${cliVersion}`, "version"]);
-        if (!stdout.trim()) throw new Error("Not found");
-        versionToUse = stdout.trim();
-      } catch {
-        try {
-          const tag = cliVersion.includes("canary") ? "canary" : "latest";
-          const { stdout } = await execa.execa(viewBin, ["view", `${pkgName}@${tag}`, "version"]);
-          if (!stdout.trim()) throw new Error("Not found");
-          versionToUse = stdout.trim();
-        } catch {
-          try {
-            const { stdout } = await execa.execa(viewBin, ["view", pkgName, "version"]);
-            versionToUse = stdout.trim() || "latest";
-          } catch {
-            versionToUse = "latest";
-          }
-        }
-      }
-      versionCache.set(pkgName, versionToUse);
-      return versionToUse;
-    };
-    const allPackages = /* @__PURE__ */ new Set();
-    const fileContents = /* @__PURE__ */ new Map();
-    for (const file of filesToProcess) {
-      const fullPath = path.resolve(options.targetDirectory, file);
-      if (!fs.existsSync(fullPath)) continue;
-      const content = fs.readFileSync(fullPath, "utf-8");
-      fileContents.set(fullPath, content);
-      const matches = [...content.matchAll(/"(@rebasepro\/[^"]+)":\s*"workspace:\*"/g)];
-      for (const match of matches) {
-        allPackages.add(match[1]);
-      }
-    }
-    console.log(chalk.gray("  Resolving package versions..."));
-    await Promise.all(Array.from(allPackages).map(getPackageVersion));
-    for (const [fullPath, originalContent] of fileContents.entries()) {
-      let content = originalContent.replace(/\{\{PROJECT_NAME\}\}/g, options.projectName);
-      const matches = [...content.matchAll(/"(@rebasepro\/[^"]+)":\s*"workspace:\*"/g)];
-      for (const match of matches) {
-        const pkgName = match[1];
-        const resolvedVersion = versionCache.get(pkgName) || "latest";
-        content = content.replace(new RegExp(`"${pkgName}":\\s*"workspace:\\*"`, "g"), `"${pkgName}": "${resolvedVersion}"`);
-      }
-      fs.writeFileSync(fullPath, content, "utf-8");
-    }
-  }
-  async function isPortAvailable(port) {
-    return new Promise((resolve) => {
-      const server = net.createServer();
-      server.once("error", () => {
-        resolve(false);
-      });
-      server.once("listening", () => {
-        server.close(() => resolve(true));
-      });
-      server.listen(port);
-    });
-  }
-  async function findAvailablePort(startPort) {
-    let port = startPort;
-    while (!await isPortAvailable(port)) {
-      port++;
-    }
-    return port;
-  }
-  async function configureEnvFile(targetDirectory, databaseUrl) {
-    const envExamplePath = path.join(targetDirectory, ".env.example");
-    const envPath = path.join(targetDirectory, ".env");
-    if (fs.existsSync(envExamplePath) && !fs.existsSync(envPath)) {
-      fs.copyFileSync(envExamplePath, envPath);
-      const jwtSecret = crypto.randomBytes(32).toString("hex");
-      const dbPassword = crypto.randomBytes(16).toString("hex");
-      let envContent = fs.readFileSync(envPath, "utf-8");
-      envContent = envContent.replace(
-        /^JWT_SECRET=.*$/m,
-        `JWT_SECRET=${jwtSecret}`
-      );
-      if (databaseUrl) {
-        if (/[\r\n]/.test(databaseUrl)) {
-          throw new Error("Invalid DATABASE_URL: multiline values are not allowed.");
-        }
-        envContent = envContent.replace(
-          /^DATABASE_URL=.*$/m,
-          `DATABASE_URL=${databaseUrl}`
-        );
-      } else {
-        const dbPort = await findAvailablePort(5432);
-        envContent = envContent.replace(
-          /^DATABASE_URL=.*$/m,
-          `DATABASE_URL=postgresql://rebase:${dbPassword}@localhost:${dbPort}/rebase?options=-c%20search_path=public
-DATABASE_PASSWORD=${dbPassword}`
-        );
-        const dockerComposePath = path.join(targetDirectory, "docker-compose.yml");
-        if (fs.existsSync(dockerComposePath)) {
-          let dockerComposeContent = fs.readFileSync(dockerComposePath, "utf-8");
-          dockerComposeContent = dockerComposeContent.replace(
-            /-\s*"5432:5432"/g,
-            `- "${dbPort}:5432"`
-          );
-          fs.writeFileSync(dockerComposePath, dockerComposeContent, "utf-8");
-        }
-      }
-      fs.writeFileSync(envPath, envContent, "utf-8");
-    }
-  }
-  async function loadCollections(collectionsDir) {
-    const absDir = path.resolve(collectionsDir);
-    if (!fs.existsSync(absDir)) {
-      throw new Error(`Collections directory not found: ${absDir}`);
-    }
-    let jiti;
-    try {
-      const jitiModule = await import("jiti");
-      jiti = jitiModule.default || jitiModule;
-    } catch {
-      throw new Error(
-        "Could not load 'jiti'. Install it with: pnpm add -D jiti\njiti is required to dynamically import TypeScript collection definitions."
-      );
-    }
-    const jitiInstance = jiti(absDir, {
-      interopDefault: true,
-      esmResolve: true
-    });
-    const indexCandidates = ["index.ts", "index.js", "index.mjs"];
-    let indexPath = null;
-    for (const candidate of indexCandidates) {
-      const p = path.join(absDir, candidate);
-      if (fs.existsSync(p)) {
-        indexPath = p;
-        break;
-      }
-    }
-    if (!indexPath) {
-      console.log(chalk.yellow("  No index file found, scanning individual collection files..."));
-      const collections = [];
-      const files = fs.readdirSync(absDir).filter(
-        (f) => (f.endsWith(".ts") || f.endsWith(".js")) && !f.startsWith(".")
-      );
-      for (const file of files) {
-        try {
-          const mod2 = jitiInstance(path.join(absDir, file));
-          const exported2 = mod2.default || mod2;
-          if (exported2 && typeof exported2 === "object" && "slug" in exported2) {
-            collections.push(exported2);
-          } else if (Array.isArray(exported2)) {
-            collections.push(...exported2);
-          }
-        } catch (err) {
-          console.warn(chalk.yellow(`  ⚠ Skipping ${file}: ${err.message}`));
-        }
-      }
-      return collections;
-    }
-    const mod = jitiInstance(indexPath);
-    const exported = mod.default || mod;
-    if (Array.isArray(exported)) {
-      return exported;
-    } else if (typeof exported === "object" && exported !== null) {
-      if ("collections" in exported && Array.isArray(exported.collections)) {
-        return exported.collections;
-      }
-      const collections = [];
-      for (const value of Object.values(exported)) {
-        if (value && typeof value === "object" && "slug" in value) {
-          collections.push(value);
-        }
-      }
-      if (collections.length > 0) return collections;
-    }
-    throw new Error(
-      `Could not extract collections from ${indexPath}.
-Expected a default export of EntityCollection[] or an object with named collection exports.`
-    );
-  }
-  function writeFiles(outputDir, files) {
-    const absOutput = path.resolve(outputDir);
-    fs.mkdirSync(absOutput, { recursive: true });
-    for (const file of files) {
-      const filePath = path.join(absOutput, file.path);
-      const dir = path.dirname(filePath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      fs.writeFileSync(filePath, file.content, "utf-8");
-    }
-  }
-  async function generateSdkCommand(args) {
-    const { collectionsDir, output, cwd } = args;
-    const resolvedCollectionsDir = path.isAbsolute(collectionsDir) ? collectionsDir : path.join(cwd, collectionsDir);
-    const resolvedOutput = path.isAbsolute(output) ? output : path.join(cwd, output);
-    console.log("");
-    console.log(chalk.bold("  🔧 Rebase SDK Generator"));
-    console.log("");
-    console.log(`  ${chalk.gray("Collections:")} ${resolvedCollectionsDir}`);
-    console.log(`  ${chalk.gray("Output:")}      ${resolvedOutput}`);
-    console.log("");
-    console.log(chalk.cyan("  → Loading collection definitions..."));
-    const collections = await loadCollections(resolvedCollectionsDir);
-    collections.sort((a, b) => a.slug.localeCompare(b.slug));
-    if (collections.length === 0) {
-      console.log(chalk.red("  ✗ No collections found. Nothing to generate."));
-      process.exit(1);
-    }
-    console.log(chalk.green(`  ✓ Found ${collections.length} collection(s): ${collections.map((c) => c.slug).join(", ")}`));
-    console.log("");
-    console.log(chalk.cyan("  → Generating SDK files..."));
-    const files = sdkGenerator.generateSDK(collections);
-    console.log(chalk.green(`  ✓ Generated ${files.length} file(s)`));
-    console.log(chalk.cyan(`  → Writing to ${resolvedOutput}...`));
-    writeFiles(resolvedOutput, files);
-    console.log("");
-    console.log(chalk.green.bold("  ✓ SDK generated successfully!"));
-    console.log("");
-    console.log(chalk.gray("  Usage:"));
-    console.log(chalk.gray("    import { createRebaseClient } from '@rebasepro/client';"));
-    console.log(chalk.gray(`    import type { Database } from './${path.relative(cwd, path.join(resolvedOutput, "database.types"))}';`));
-    console.log("");
-    console.log(chalk.gray("    const rebase = createRebaseClient<Database>({"));
-    console.log(chalk.gray("        baseUrl: 'http://localhost:3001',"));
-    console.log(chalk.gray("        // token: 'your-jwt-token',"));
-    console.log(chalk.gray("    });"));
-    console.log("");
-    console.log(chalk.gray(`    const { data } = await rebase.collection('${collections[0]?.slug || "my_collection"}').find();`));
-    console.log("");
-  }
-  function findProjectRoot(startDir = process.cwd()) {
-    let dir = path.resolve(startDir);
-    const root = path.parse(dir).root;
-    while (dir !== root) {
-      const pkgPath = path.join(dir, "package.json");
-      if (fs.existsSync(pkgPath)) {
-        try {
-          const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-          if (pkg.workspaces && Array.isArray(pkg.workspaces)) {
-            const hasBackend = pkg.workspaces.some(
-              (w) => w === "backend" || w.includes("backend")
-            );
-            if (hasBackend) return dir;
-          }
-        } catch {
-        }
-        if (fs.existsSync(path.join(dir, "backend")) && fs.existsSync(path.join(dir, "config"))) {
-          return dir;
-        }
-      }
-      dir = path.dirname(dir);
-    }
-    return null;
-  }
-  function findBackendDir(projectRoot) {
-    const backendDir = path.join(projectRoot, "backend");
-    return fs.existsSync(backendDir) ? backendDir : null;
-  }
-  function getActiveBackendPlugin(backendDir) {
-    const pkgPath = path.join(backendDir, "package.json");
-    if (!fs.existsSync(pkgPath)) return null;
-    try {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-      const candidates = Object.keys(deps).filter(
-        (dep) => dep.startsWith("@rebasepro/server-") && dep !== "@rebasepro/server-core"
-      );
-      if (candidates.length === 0) return null;
-      if (candidates.includes("@rebasepro/server-postgresql")) {
-        return "@rebasepro/server-postgresql";
-      }
-      for (const candidate of candidates) {
-        if (resolvePluginCliScript(backendDir, candidate)) {
-          return candidate;
-        }
-      }
-      return candidates[0];
-    } catch {
-    }
-    return null;
-  }
-  function resolvePluginCliScript(backendDir, pluginName) {
-    const candidates = [
-      path.join(backendDir, "node_modules", pluginName, "src", "cli.ts"),
-      path.join(backendDir, "node_modules", pluginName, "dist", "cli.js"),
-      // For monorepo dev mode:
-      path.resolve(backendDir, "..", "..", "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts"),
-      path.resolve(backendDir, "..", "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts"),
-      path.resolve(backendDir, "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts")
-    ];
-    for (const candidate of candidates) {
-      if (fs.existsSync(candidate)) return candidate;
-    }
-    return null;
-  }
-  function findFrontendDir(projectRoot) {
-    const frontendDir = path.join(projectRoot, "frontend");
-    return fs.existsSync(frontendDir) ? frontendDir : null;
-  }
-  function findEnvFile(projectRoot) {
-    const candidates = [
-      path.join(projectRoot, ".env"),
-      path.join(projectRoot, "backend", ".env")
-    ];
-    for (const candidate of candidates) {
-      if (fs.existsSync(candidate)) return candidate;
-    }
-    return null;
-  }
-  function resolveLocalBin(projectRoot, binName) {
-    const candidates = [
-      path.join(projectRoot, "backend", "node_modules", ".bin", binName),
-      path.join(projectRoot, "node_modules", ".bin", binName)
-    ];
-    let parent = path.dirname(projectRoot);
-    const rootDir = path.parse(parent).root;
-    while (parent !== rootDir) {
-      candidates.push(path.join(parent, "node_modules", ".bin", binName));
-      parent = path.dirname(parent);
-    }
-    for (const candidate of candidates) {
-      if (fs.existsSync(candidate)) return candidate;
-    }
-    try {
-      const globalPath = child_process.execSync(`which ${binName}`, { encoding: "utf-8" }).trim();
-      if (globalPath && fs.existsSync(globalPath)) return globalPath;
-    } catch {
-    }
-    return null;
-  }
-  function resolveTsx(projectRoot) {
-    return resolveLocalBin(projectRoot, "tsx");
-  }
-  function requireProjectRoot() {
-    const root = findProjectRoot();
-    if (!root) {
-      console.error(chalk.red("✗ Could not find a Rebase project root."));
-      console.error(chalk.gray("  Make sure you are inside a Rebase project directory"));
-      console.error(chalk.gray("  (one with backend/, frontend/, and config/ directories)."));
-      process.exit(1);
-    }
-    return root;
-  }
-  function requireBackendDir(projectRoot) {
-    const backendDir = findBackendDir(projectRoot);
-    if (!backendDir) {
-      console.error(chalk.red("✗ Could not find a backend/ directory."));
-      console.error(chalk.gray(`  Expected at: ${path.join(projectRoot, "backend")}`));
-      process.exit(1);
-    }
-    return backendDir;
-  }
-  async function schemaCommand(subcommand, rawArgs) {
-    if (!subcommand || subcommand === "--help") {
-      printSchemaHelp();
-      return;
-    }
-    const projectRoot = requireProjectRoot();
-    const backendDir = requireBackendDir(projectRoot);
-    const activePlugin = getActiveBackendPlugin(backendDir);
-    if (!activePlugin) {
-      console.error(chalk.red("✗ Could not detect an active database plugin."));
-      console.error(chalk.gray("  Make sure a package like @rebasepro/server-postgresql is installed in backend/package.json."));
-      process.exit(1);
-    }
-    const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
-    if (!pluginCli) {
-      console.error(chalk.red(`✗ Could not find CLI entry point for ${activePlugin}.`));
-      process.exit(1);
-    }
-    const envFile = findEnvFile(projectRoot);
-    const env = { ...process.env };
-    if (envFile) {
-      env.DOTENV_CONFIG_PATH = envFile;
-    }
-    try {
-      const isTs = pluginCli.endsWith(".ts");
-      if (isTs) {
-        const tsxBin = resolveTsx(projectRoot);
-        if (!tsxBin) {
-          console.error(chalk.red("✗ Could not find tsx binary."));
-          process.exit(1);
-        }
-        await execa.execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
-          cwd: backendDir,
-          stdio: "inherit",
-          env
-        });
-      } else {
-        await execa.execa("node", [pluginCli, ...rawArgs.slice(2)], {
-          cwd: backendDir,
-          stdio: "inherit",
-          env
-        });
-      }
-    } catch {
-      process.exit(1);
-    }
-  }
-  function printSchemaHelp() {
-    console.log(`
-${chalk.bold("rebase schema")} — Schema management commands
+		await createProject(await promptForOptions(rawArgs, detectPackageManager()));
+	}
+	async function promptForOptions(rawArgs, pm) {
+		const args = (0, arg.default)({
+			"--git": Boolean,
+			"--install": Boolean,
+			"--database-url": String,
+			"--introspect": Boolean,
+			"--template": String,
+			"--yes": Boolean,
+			"-g": "--git",
+			"-i": "--install",
+			"-t": "--template",
+			"-y": "--yes"
+		}, {
+			argv: rawArgs.slice(3),
+			permissive: true
+		});
+		const nameArg = args._[0];
+		const isNonInteractive = args["--yes"] || false;
+		const templateArg = args["--template"];
+		if (templateArg && !PRESET_CHOICES.some((p) => p.value === templateArg)) {
+			console.error(chalk.default.red(`Unknown template "${templateArg}". Available: ${PRESET_CHOICES.map((p) => p.value).join(", ")}`));
+			process.exit(1);
+		}
+		if (isNonInteractive) {
+			const projectName = nameArg || "my-rebase-app";
+			const targetDirectory = path.default.resolve(process.cwd(), projectName);
+			const templateDirectory = path.default.resolve(cliRoot, "templates", "template");
+			const pmCommands = getPMCommands(pm);
+			return {
+				projectName: path.default.basename(targetDirectory),
+				git: args["--git"] ?? false,
+				installDeps: args["--install"] ?? false,
+				targetDirectory,
+				templateDirectory,
+				databaseUrl: args["--database-url"] || void 0,
+				introspect: args["--introspect"] || false,
+				preset: templateArg || "blog",
+				pm,
+				pmCommands
+			};
+		}
+		const questions = [];
+		if (!nameArg) questions.push({
+			type: "input",
+			name: "projectName",
+			message: "Project name:",
+			default: "my-rebase-app",
+			validate: (input) => {
+				if (!input.trim()) return "Project name is required";
+				if (!/^[a-z0-9][a-z0-9._-]*$/.test(input)) return "Project name must start with a lowercase letter or number and contain only lowercase letters, numbers, hyphens, dots, or underscores";
+				return true;
+			}
+		});
+		if (!templateArg) questions.push({
+			type: "list",
+			name: "preset",
+			message: "Choose a starter template:",
+			choices: PRESET_CHOICES,
+			default: "blog"
+		});
+		if (!args["--git"]) questions.push({
+			type: "confirm",
+			name: "git",
+			message: "Initialize a git repository?",
+			default: true
+		});
+		if (!args["--install"]) questions.push({
+			type: "confirm",
+			name: "installDeps",
+			message: `Install dependencies with ${pm}?`,
+			default: true
+		});
+		questions.push({
+			type: "input",
+			name: "databaseUrl",
+			message: "Enter your PostgreSQL database connection string (leave blank to use a local default):",
+			default: "",
+			validate: (input) => {
+				if (input.trim() && /[\r\n]/.test(input)) return "Database URL cannot contain newline characters.";
+				return true;
+			}
+		});
+		questions.push({
+			type: "confirm",
+			name: "introspect",
+			message: "Would you like to introspect this database to automatically generate collections?",
+			default: true,
+			when: (answers) => !!answers.databaseUrl?.trim()
+		});
+		const answers = await inquirer.default.prompt(questions);
+		const targetDirectory = path.default.resolve(process.cwd(), nameArg || answers.projectName);
+		const projectName = path.default.basename(targetDirectory);
+		const templateDirectory = path.default.resolve(cliRoot, "templates", "template");
+		const pmCommands = getPMCommands(pm);
+		return {
+			projectName,
+			git: args["--git"] || answers.git || false,
+			installDeps: args["--install"] || answers.installDeps || false,
+			targetDirectory,
+			templateDirectory,
+			databaseUrl: answers.databaseUrl?.trim() || void 0,
+			introspect: answers.introspect || false,
+			preset: templateArg || answers.preset || "blog",
+			pm,
+			pmCommands
+		};
+	}
+	async function createProject(options) {
+		if (fs.default.existsSync(options.targetDirectory)) {
+			if (fs.default.readdirSync(options.targetDirectory).length !== 0) {
+				console.error(`${chalk.default.red.bold("ERROR")} Directory "${options.projectName}" already exists and is not empty`);
+				process.exit(1);
+			}
+		} else fs.default.mkdirSync(options.targetDirectory, { recursive: true });
+		try {
+			await access(options.templateDirectory, fs.default.constants.R_OK);
+		} catch {
+			console.error(`${chalk.default.red.bold("ERROR")} Template not found at ${options.templateDirectory}`);
+			process.exit(1);
+		}
+		console.log(chalk.default.gray("  Copying project files..."));
+		try {
+			await (0, fs_promises.cp)(options.templateDirectory, options.targetDirectory, {
+				recursive: true,
+				filter: (source) => {
+					const basename = path.default.basename(source);
+					return basename !== "node_modules" && basename !== ".DS_Store";
+				}
+			});
+		} catch (err) {
+			console.error(`${chalk.default.red.bold("ERROR")} Failed to copy template files: ${err instanceof Error ? err.message : String(err)}`);
+			process.exit(1);
+		}
+		await applyPreset(options.targetDirectory, options.preset);
+		await replacePlaceholders(options);
+		await configureEnvFile(options.targetDirectory, options.databaseUrl);
+		if (options.git) {
+			console.log(chalk.default.gray("  Initializing git repository..."));
+			try {
+				await (0, execa.execa)("git", ["init"], { cwd: options.targetDirectory });
+			} catch {
+				console.warn(chalk.default.yellow("  Warning: Failed to initialize git repository"));
+			}
+		}
+		const { pm, pmCommands } = options;
+		const installCmd = pmCommands.install;
+		const execCmd = pmCommands.exec("rebase", [
+			"schema",
+			"introspect",
+			"--force"
+		]);
+		if (options.installDeps) {
+			console.log("");
+			console.log(chalk.default.gray(`  Installing dependencies with ${pm}...`));
+			console.log("");
+			try {
+				await (0, execa.execa)(installCmd[0], installCmd.slice(1), {
+					cwd: options.targetDirectory,
+					stdio: "inherit"
+				});
+			} catch {
+				console.warn(chalk.default.yellow(`  Warning: Failed to install dependencies. You may need to run \`${installCmd.join(" ")}\` manually.`));
+			}
+		}
+		if (options.introspect) {
+			console.log("");
+			if (options.installDeps) {
+				console.log(chalk.default.gray("  Introspecting database and generating collections..."));
+				console.log("");
+				try {
+					await (0, execa.execa)(execCmd[0], execCmd.slice(1), {
+						cwd: options.targetDirectory,
+						stdio: "inherit"
+					});
+					console.log(chalk.default.green("  Database successfully introspected!"));
+				} catch {
+					console.warn(chalk.default.yellow("  Warning: Failed to introspect database automatically."));
+					console.warn(chalk.default.yellow(`  You can run \`${execCmd.join(" ")}\` manually after setup.`));
+				}
+			} else {
+				console.warn(chalk.default.yellow("  Skipping introspection because dependencies were not installed."));
+				console.warn(chalk.default.yellow(`  Run \`${installCmd.join(" ")}\` then \`${execCmd.join(" ")}\` manually.`));
+			}
+		}
+		console.log("");
+		console.log(`${chalk.default.green.bold("✓")} Project ${chalk.default.bold(options.projectName)} created successfully!`);
+		console.log("");
+		console.log(chalk.default.bold("Next steps:"));
+		console.log("");
+		const runDev = pmCommands.run("dev");
+		const runDbPush = pmCommands.run("db:push");
+		console.log(`  ${chalk.default.cyan("cd")} ${options.projectName}`);
+		if (!options.installDeps) console.log(`  ${chalk.default.cyan(installCmd.join(" "))}`);
+		console.log("");
+		if (options.databaseUrl) if (options.introspect) {
+			console.log(chalk.default.gray("  # Database has been introspected & collections generated!"));
+			console.log(chalk.default.gray("  # Start the development server (frontend + backend):"));
+			console.log(`  ${chalk.default.cyan(runDev.join(" "))}`);
+		} else {
+			console.log(chalk.default.gray("  # Your custom database is configured in .env."));
+			console.log(chalk.default.gray("  # If the database is empty, push the Rebase schema to initialize it:"));
+			console.log(`  ${chalk.default.cyan(runDbPush.join(" "))}`);
+			console.log("");
+			console.log(chalk.default.gray("  # Then start the development server:"));
+			console.log(`  ${chalk.default.cyan(runDev.join(" "))}`);
+		}
+		else {
+			console.log(chalk.default.gray("  # A local database configuration has been generated in .env."));
+			console.log(chalk.default.gray("  # 1. Start the PostgreSQL database container:"));
+			console.log(`  ${chalk.default.cyan("docker compose up -d db")}`);
+			console.log("");
+			console.log(chalk.default.gray("  # 2. Push the Rebase schema to initialize database tables:"));
+			console.log(`  ${chalk.default.cyan(runDbPush.join(" "))}`);
+			console.log("");
+			console.log(chalk.default.gray("  # 3. Start the development server (frontend + backend):"));
+			console.log(`  ${chalk.default.cyan(runDev.join(" "))}`);
+		}
+		console.log("");
+		console.log(chalk.default.gray("This starts both the backend (Hono + PostgreSQL)") + chalk.default.gray(" and the frontend (Vite + React) concurrently."));
+		console.log("");
+		console.log(chalk.default.gray("Docs: https://rebase.pro/docs"));
+		console.log(chalk.default.gray("GitHub: https://github.com/rebasepro/rebase"));
+		console.log("");
+		console.log(chalk.default.bold("🤖 AI Agent Skills"));
+		console.log("");
+		console.log(chalk.default.gray("  Install Rebase agent skills for your AI coding assistant:"));
+		console.log("");
+		console.log(`  ${chalk.default.cyan("rebase skills install")}  ${chalk.default.gray("or")}  ${chalk.default.cyan(pmCommands.run("skills:install").join(" "))}`);
+		console.log("");
+	}
+	/**
+	* Apply a template preset by replacing the default collection files.
+	*
+	* The template ships with blog collections at the top level and
+	* preset alternatives under `config/collections/presets/<name>/`.
+	* This function swaps the active collection files and removes the
+	* presets directory so the final project is clean.
+	*/
+	async function applyPreset(targetDirectory, preset) {
+		const collectionsDir = path.default.join(targetDirectory, "config", "collections");
+		const presetsDir = path.default.join(collectionsDir, "presets");
+		if (preset !== "blog") {
+			const presetDir = path.default.join(presetsDir, preset);
+			if (!fs.default.existsSync(presetDir)) {
+				console.warn(chalk.default.yellow(`  Warning: Preset "${preset}" not found, falling back to blog template.`));
+				cleanupPresets(presetsDir);
+				return;
+			}
+			for (const file of [
+				"posts.ts",
+				"authors.ts",
+				"tags.ts",
+				"index.ts"
+			]) {
+				const filePath = path.default.join(collectionsDir, file);
+				if (fs.default.existsSync(filePath)) fs.default.unlinkSync(filePath);
+			}
+			const presetFiles = fs.default.readdirSync(presetDir).filter((f) => f.endsWith(".ts"));
+			for (const file of presetFiles) fs.default.copyFileSync(path.default.join(presetDir, file), path.default.join(collectionsDir, file));
+		}
+		cleanupPresets(presetsDir);
+	}
+	function cleanupPresets(presetsDir) {
+		if (fs.default.existsSync(presetsDir)) fs.default.rmSync(presetsDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	async function replacePlaceholders(options) {
+		const filesToProcess = [
+			"package.json",
+			"frontend/package.json",
+			"backend/package.json",
+			"config/package.json",
+			"frontend/index.html",
+			"pnpm-workspace.yaml",
+			"README.md"
+		];
+		const packageJsonPath = path.default.resolve(cliRoot, "package.json");
+		let cliVersion = "latest";
+		if (fs.default.existsSync(packageJsonPath)) cliVersion = JSON.parse(fs.default.readFileSync(packageJsonPath, "utf-8")).version || "latest";
+		const versionCache = /* @__PURE__ */ new Map();
+		const viewBin = "npm";
+		const getPackageVersion = async (pkgName) => {
+			if (versionCache.has(pkgName)) return versionCache.get(pkgName);
+			if (process.env.REBASE_E2E === "true") {
+				versionCache.set(pkgName, cliVersion);
+				return cliVersion;
+			}
+			let versionToUse = cliVersion;
+			try {
+				const { stdout } = await (0, execa.execa)(viewBin, [
+					"view",
+					`${pkgName}@${cliVersion}`,
+					"version"
+				]);
+				if (!stdout.trim()) throw new Error("Not found");
+				versionToUse = stdout.trim();
+			} catch {
+				try {
+					const { stdout } = await (0, execa.execa)(viewBin, [
+						"view",
+						`${pkgName}@${cliVersion.includes("canary") ? "canary" : "latest"}`,
+						"version"
+					]);
+					if (!stdout.trim()) throw new Error("Not found");
+					versionToUse = stdout.trim();
+				} catch {
+					try {
+						const { stdout } = await (0, execa.execa)(viewBin, [
+							"view",
+							pkgName,
+							"version"
+						]);
+						versionToUse = stdout.trim() || "latest";
+					} catch {
+						versionToUse = "latest";
+					}
+				}
+			}
+			versionCache.set(pkgName, versionToUse);
+			return versionToUse;
+		};
+		const allPackages = /* @__PURE__ */ new Set();
+		const fileContents = /* @__PURE__ */ new Map();
+		for (const file of filesToProcess) {
+			const fullPath = path.default.resolve(options.targetDirectory, file);
+			if (!fs.default.existsSync(fullPath)) continue;
+			const content = fs.default.readFileSync(fullPath, "utf-8");
+			fileContents.set(fullPath, content);
+			const matches = [...content.matchAll(/"(@rebasepro\/[^"]+)":\s*"workspace:\*"/g)];
+			for (const match of matches) allPackages.add(match[1]);
+		}
+		console.log(chalk.default.gray("  Resolving package versions..."));
+		await Promise.all(Array.from(allPackages).map(getPackageVersion));
+		for (const [fullPath, originalContent] of fileContents.entries()) {
+			let content = originalContent.replace(/\{\{PROJECT_NAME\}\}/g, options.projectName);
+			const matches = [...content.matchAll(/"(@rebasepro\/[^"]+)":\s*"workspace:\*"/g)];
+			for (const match of matches) {
+				const pkgName = match[1];
+				const resolvedVersion = versionCache.get(pkgName) || "latest";
+				content = content.replace(new RegExp(`"${pkgName}":\\s*"workspace:\\*"`, "g"), `"${pkgName}": "${resolvedVersion}"`);
+			}
+			fs.default.writeFileSync(fullPath, content, "utf-8");
+		}
+	}
+	async function isPortAvailable(port) {
+		return new Promise((resolve) => {
+			const server = net.default.createServer();
+			server.once("error", () => {
+				resolve(false);
+			});
+			server.once("listening", () => {
+				server.close(() => resolve(true));
+			});
+			server.listen(port);
+		});
+	}
+	async function findAvailablePort(startPort) {
+		let port = startPort;
+		while (!await isPortAvailable(port)) port++;
+		return port;
+	}
+	async function configureEnvFile(targetDirectory, databaseUrl) {
+		const envExamplePath = path.default.join(targetDirectory, ".env.example");
+		const envPath = path.default.join(targetDirectory, ".env");
+		if (fs.default.existsSync(envExamplePath) && !fs.default.existsSync(envPath)) {
+			fs.default.copyFileSync(envExamplePath, envPath);
+			const jwtSecret = crypto.default.randomBytes(32).toString("hex");
+			const dbPassword = crypto.default.randomBytes(16).toString("hex");
+			let envContent = fs.default.readFileSync(envPath, "utf-8");
+			envContent = envContent.replace(/^JWT_SECRET=.*$/m, `JWT_SECRET=${jwtSecret}`);
+			if (databaseUrl) {
+				if (/[\r\n]/.test(databaseUrl)) throw new Error("Invalid DATABASE_URL: multiline values are not allowed.");
+				envContent = envContent.replace(/^DATABASE_URL=.*$/m, `DATABASE_URL=${databaseUrl}`);
+			} else {
+				const dbPort = await findAvailablePort(5432);
+				envContent = envContent.replace(/^DATABASE_URL=.*$/m, `DATABASE_URL=postgresql://rebase:${dbPassword}@localhost:${dbPort}/rebase?options=-c%20search_path=public\nDATABASE_PASSWORD=${dbPassword}`);
+				const dockerComposePath = path.default.join(targetDirectory, "docker-compose.yml");
+				if (fs.default.existsSync(dockerComposePath)) {
+					let dockerComposeContent = fs.default.readFileSync(dockerComposePath, "utf-8");
+					dockerComposeContent = dockerComposeContent.replace(/-\s*"5432:5432"/g, `- "${dbPort}:5432"`);
+					fs.default.writeFileSync(dockerComposePath, dockerComposeContent, "utf-8");
+				}
+			}
+			fs.default.writeFileSync(envPath, envContent, "utf-8");
+		}
+	}
+	//#endregion
+	//#region src/commands/generate_sdk.ts
+	/**
+	* CLI command: generate-sdk
+	*
+	* Reads collection definitions from a specified directory (default: ./config/collections),
+	* generates a typed JS SDK, and writes it to the output directory (default: ./generated/sdk).
+	*
+	* Uses jiti for dynamic TypeScript import of collection files.
+	*/
+	/**
+	* Dynamically load collection definitions from a directory.
+	*
+	* Expects the directory to have an index.ts/index.js that exports a default
+	* array of EntityCollection objects (matching the app/config/collections pattern).
+	*/
+	async function loadCollections(collectionsDir) {
+		const absDir = path.default.resolve(collectionsDir);
+		if (!fs.default.existsSync(absDir)) throw new Error(`Collections directory not found: ${absDir}`);
+		let jiti;
+		try {
+			const jitiModule = await import("jiti");
+			jiti = jitiModule.default || jitiModule;
+		} catch {
+			const installCmd = [
+				...getPMCommands(detectPackageManager()).install,
+				"-D",
+				"jiti"
+			].join(" ");
+			throw new Error(`Could not load 'jiti'. Install it with: ${installCmd}\njiti is required to dynamically import TypeScript collection definitions.`);
+		}
+		const jitiInstance = jiti(absDir, {
+			interopDefault: true,
+			esmResolve: true
+		});
+		const indexCandidates = [
+			"index.ts",
+			"index.js",
+			"index.mjs"
+		];
+		let indexPath = null;
+		for (const candidate of indexCandidates) {
+			const p = path.default.join(absDir, candidate);
+			if (fs.default.existsSync(p)) {
+				indexPath = p;
+				break;
+			}
+		}
+		if (!indexPath) {
+			console.log(chalk.default.yellow("  No index file found, scanning individual collection files..."));
+			const collections = [];
+			const files = fs.default.readdirSync(absDir).filter((f) => (f.endsWith(".ts") || f.endsWith(".js")) && !f.startsWith("."));
+			for (const file of files) try {
+				const mod = jitiInstance(path.default.join(absDir, file));
+				const exported = mod.default || mod;
+				if (exported && typeof exported === "object" && "slug" in exported) collections.push(exported);
+				else if (Array.isArray(exported)) collections.push(...exported);
+			} catch (err) {
+				console.warn(chalk.default.yellow(`  ⚠ Skipping ${file}: ${err.message}`));
+			}
+			return collections;
+		}
+		const mod = jitiInstance(indexPath);
+		const exported = mod.default || mod;
+		if (Array.isArray(exported)) return exported;
+		else if (typeof exported === "object" && exported !== null) {
+			if ("collections" in exported && Array.isArray(exported.collections)) return exported.collections;
+			const collections = [];
+			for (const value of Object.values(exported)) if (value && typeof value === "object" && "slug" in value) collections.push(value);
+			if (collections.length > 0) return collections;
+		}
+		throw new Error(`Could not extract collections from ${indexPath}.\nExpected a default export of EntityCollection[] or an object with named collection exports.`);
+	}
+	/**
+	* Write generated files to the output directory.
+	*/
+	function writeFiles(outputDir, files) {
+		const absOutput = path.default.resolve(outputDir);
+		fs.default.mkdirSync(absOutput, { recursive: true });
+		for (const file of files) {
+			const filePath = path.default.join(absOutput, file.path);
+			const dir = path.default.dirname(filePath);
+			if (!fs.default.existsSync(dir)) fs.default.mkdirSync(dir, { recursive: true });
+			fs.default.writeFileSync(filePath, file.content, "utf-8");
+		}
+	}
+	/**
+	* Main entry point for the generate-sdk command.
+	*/
+	async function generateSdkCommand(args) {
+		const { collectionsDir, output, cwd } = args;
+		const resolvedCollectionsDir = path.default.isAbsolute(collectionsDir) ? collectionsDir : path.default.join(cwd, collectionsDir);
+		const resolvedOutput = path.default.isAbsolute(output) ? output : path.default.join(cwd, output);
+		console.log("");
+		console.log(chalk.default.bold("  🔧 Rebase SDK Generator"));
+		console.log("");
+		console.log(`  ${chalk.default.gray("Collections:")} ${resolvedCollectionsDir}`);
+		console.log(`  ${chalk.default.gray("Output:")}      ${resolvedOutput}`);
+		console.log("");
+		console.log(chalk.default.cyan("  → Loading collection definitions..."));
+		const collections = await loadCollections(resolvedCollectionsDir);
+		collections.sort((a, b) => a.slug.localeCompare(b.slug));
+		if (collections.length === 0) {
+			console.log(chalk.default.red("  ✗ No collections found. Nothing to generate."));
+			process.exit(1);
+		}
+		console.log(chalk.default.green(`  ✓ Found ${collections.length} collection(s): ${collections.map((c) => c.slug).join(", ")}`));
+		console.log("");
+		console.log(chalk.default.cyan("  → Generating SDK files..."));
+		const files = (0, _rebasepro_sdk_generator.generateSDK)(collections);
+		console.log(chalk.default.green(`  ✓ Generated ${files.length} file(s)`));
+		console.log(chalk.default.cyan(`  → Writing to ${resolvedOutput}...`));
+		writeFiles(resolvedOutput, files);
+		console.log("");
+		console.log(chalk.default.green.bold("  ✓ SDK generated successfully!"));
+		console.log("");
+		console.log(chalk.default.gray("  Usage:"));
+		console.log(chalk.default.gray("    import { createRebaseClient } from '@rebasepro/client';"));
+		console.log(chalk.default.gray(`    import type { Database } from './${path.default.relative(cwd, path.default.join(resolvedOutput, "database.types"))}';`));
+		console.log("");
+		console.log(chalk.default.gray("    const rebase = createRebaseClient<Database>({"));
+		console.log(chalk.default.gray("        baseUrl: 'http://localhost:3001',"));
+		console.log(chalk.default.gray("        // token: 'your-jwt-token',"));
+		console.log(chalk.default.gray("    });"));
+		console.log("");
+		console.log(chalk.default.gray(`    const { data } = await rebase.collection('${collections[0]?.slug || "my_collection"}').find();`));
+		console.log("");
+	}
+	//#endregion
+	//#region src/utils/project.ts
+	/**
+	* Project discovery utilities for the Rebase CLI.
+	*
+	* These helpers locate the project root, backend directory, .env file,
+	* and local binaries — used by all CLI command modules.
+	*/
+	/**
+	* Walk up from `startDir` to find the Rebase project root.
+	*
+	* The root is identified by a `package.json` that either:
+	* - has `workspaces` containing "backend" or "frontend", OR
+	* - has a sibling `backend/` directory
+	*/
+	function findProjectRoot(startDir = process.cwd()) {
+		let dir = path.default.resolve(startDir);
+		const root = path.default.parse(dir).root;
+		while (dir !== root) {
+			const pkgPath = path.default.join(dir, "package.json");
+			if (fs.default.existsSync(pkgPath)) {
+				try {
+					const pkg = JSON.parse(fs.default.readFileSync(pkgPath, "utf-8"));
+					if (pkg.workspaces && Array.isArray(pkg.workspaces)) {
+						if (pkg.workspaces.some((w) => w === "backend" || w.includes("backend"))) return dir;
+					}
+				} catch {}
+				if (fs.default.existsSync(path.default.join(dir, "backend")) && fs.default.existsSync(path.default.join(dir, "config"))) return dir;
+			}
+			dir = path.default.dirname(dir);
+		}
+		return null;
+	}
+	/**
+	* Locate the backend directory within the project root.
+	*/
+	function findBackendDir(projectRoot) {
+		const backendDir = path.default.join(projectRoot, "backend");
+		return fs.default.existsSync(backendDir) ? backendDir : null;
+	}
+	/**
+	* Detect the active backend plugin (e.g. @rebasepro/server-postgresql) from the backend's package.json.
+	*/
+	function getActiveBackendPlugin(backendDir) {
+		const pkgPath = path.default.join(backendDir, "package.json");
+		if (!fs.default.existsSync(pkgPath)) return null;
+		try {
+			const pkg = JSON.parse(fs.default.readFileSync(pkgPath, "utf-8"));
+			const deps = {
+				...pkg.dependencies,
+				...pkg.devDependencies
+			};
+			const candidates = Object.keys(deps).filter((dep) => dep.startsWith("@rebasepro/server-") && dep !== "@rebasepro/server-core");
+			if (candidates.length === 0) return null;
+			if (candidates.includes("@rebasepro/server-postgresql")) return "@rebasepro/server-postgresql";
+			for (const candidate of candidates) if (resolvePluginCliScript(backendDir, candidate)) return candidate;
+			return candidates[0];
+		} catch {}
+		return null;
+	}
+	/**
+	* Resolve the active plugin's CLI script.
+	*/
+	function resolvePluginCliScript(backendDir, pluginName) {
+		const candidates = [
+			path.default.join(backendDir, "node_modules", pluginName, "src", "cli.ts"),
+			path.default.join(backendDir, "node_modules", pluginName, "dist", "cli.js"),
+			path.default.resolve(backendDir, "..", "..", "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts"),
+			path.default.resolve(backendDir, "..", "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts"),
+			path.default.resolve(backendDir, "..", "packages", pluginName.replace("@rebasepro/", ""), "src", "cli.ts")
+		];
+		for (const candidate of candidates) if (fs.default.existsSync(candidate)) return candidate;
+		return null;
+	}
+	/**
+	* Locate the frontend directory within the project root.
+	*/
+	function findFrontendDir(projectRoot) {
+		const frontendDir = path.default.join(projectRoot, "frontend");
+		return fs.default.existsSync(frontendDir) ? frontendDir : null;
+	}
+	/**
+	* Find the .env file. Checks the project root first, then backend.
+	*/
+	function findEnvFile(projectRoot) {
+		const candidates = [path.default.join(projectRoot, ".env"), path.default.join(projectRoot, "backend", ".env")];
+		for (const candidate of candidates) if (fs.default.existsSync(candidate)) return candidate;
+		return null;
+	}
+	/**
+	* Resolve a binary from the project's node_modules/.bin.
+	* Checks backend, root, parent monorepo root, then falls back to PATH.
+	*/
+	function resolveLocalBin(projectRoot, binName) {
+		const candidates = [path.default.join(projectRoot, "backend", "node_modules", ".bin", binName), path.default.join(projectRoot, "node_modules", ".bin", binName)];
+		let parent = path.default.dirname(projectRoot);
+		const rootDir = path.default.parse(parent).root;
+		while (parent !== rootDir) {
+			candidates.push(path.default.join(parent, "node_modules", ".bin", binName));
+			parent = path.default.dirname(parent);
+		}
+		for (const candidate of candidates) if (fs.default.existsSync(candidate)) return candidate;
+		try {
+			const globalPath = (0, child_process.execSync)(`which ${binName}`, { encoding: "utf-8" }).trim();
+			if (globalPath && fs.default.existsSync(globalPath)) return globalPath;
+		} catch {}
+		return null;
+	}
+	/**
+	* Resolve the tsx binary. Checks backend node_modules first, then root.
+	*/
+	function resolveTsx(projectRoot) {
+		return resolveLocalBin(projectRoot, "tsx");
+	}
+	/**
+	* Require the project root or exit with a helpful error.
+	*/
+	function requireProjectRoot() {
+		const root = findProjectRoot();
+		if (!root) {
+			console.error(chalk.default.red("✗ Could not find a Rebase project root."));
+			console.error(chalk.default.gray("  Make sure you are inside a Rebase project directory"));
+			console.error(chalk.default.gray("  (one with backend/, frontend/, and config/ directories)."));
+			process.exit(1);
+		}
+		return root;
+	}
+	/**
+	* Require the backend directory or exit with a helpful error.
+	*/
+	function requireBackendDir(projectRoot) {
+		const backendDir = findBackendDir(projectRoot);
+		if (!backendDir) {
+			console.error(chalk.default.red("✗ Could not find a backend/ directory."));
+			console.error(chalk.default.gray(`  Expected at: ${path.default.join(projectRoot, "backend")}`));
+			process.exit(1);
+		}
+		return backendDir;
+	}
+	//#endregion
+	//#region src/commands/schema.ts
+	/**
+	* CLI command: rebase schema <action>
+	*/
+	async function schemaCommand(subcommand, rawArgs) {
+		if (!subcommand || subcommand === "--help") {
+			printSchemaHelp();
+			return;
+		}
+		const projectRoot = requireProjectRoot();
+		const backendDir = requireBackendDir(projectRoot);
+		const activePlugin = getActiveBackendPlugin(backendDir);
+		if (!activePlugin) {
+			console.error(chalk.default.red("✗ Could not detect an active database plugin."));
+			console.error(chalk.default.gray("  Make sure a package like @rebasepro/server-postgresql is installed in backend/package.json."));
+			process.exit(1);
+		}
+		const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
+		if (!pluginCli) {
+			console.error(chalk.default.red(`✗ Could not find CLI entry point for ${activePlugin}.`));
+			process.exit(1);
+		}
+		const envFile = findEnvFile(projectRoot);
+		const env = { ...process.env };
+		if (envFile) env.DOTENV_CONFIG_PATH = envFile;
+		try {
+			if (pluginCli.endsWith(".ts")) {
+				const tsxBin = resolveTsx(projectRoot);
+				if (!tsxBin) {
+					console.error(chalk.default.red("✗ Could not find tsx binary."));
+					process.exit(1);
+				}
+				await (0, execa.execa)(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+					cwd: backendDir,
+					stdio: "inherit",
+					env
+				});
+			} else await (0, execa.execa)("node", [pluginCli, ...rawArgs.slice(2)], {
+				cwd: backendDir,
+				stdio: "inherit",
+				env
+			});
+		} catch {
+			process.exit(1);
+		}
+	}
+	function printSchemaHelp() {
+		console.log(`
+${chalk.default.bold("rebase schema")} — Schema management commands
 
-${chalk.green.bold("Usage")}
-  rebase schema ${chalk.blue("<command>")} [options]
+${chalk.default.green.bold("Usage")}
+  rebase schema ${chalk.default.blue("<command>")} [options]
 
-${chalk.green.bold("Commands")}
-  ${chalk.gray("(Commands are provided by your active database driver plugin)")}
-  ${chalk.blue.bold("generate")}    Generate Schema from collection definitions
-  ${chalk.blue.bold("introspect")}  Introspect an existing database to generate collection definitions
+${chalk.default.green.bold("Commands")}
+  ${chalk.default.gray("(Commands are provided by your active database driver plugin)")}
+  ${chalk.default.blue.bold("generate")}    Generate Schema from collection definitions
+  ${chalk.default.blue.bold("introspect")}  Introspect an existing database to generate collection definitions
 
-${chalk.green.bold("generate Options")}
-  ${chalk.blue("--collections, -c")}  Path to collections directory
-  ${chalk.blue("--output, -o")}       Output path for generated schema
-  ${chalk.blue("--watch, -w")}        Watch for changes and regenerate automatically
+${chalk.default.green.bold("generate Options")}
+  ${chalk.default.blue("--collections, -c")}  Path to collections directory
+  ${chalk.default.blue("--output, -o")}       Output path for generated schema
+  ${chalk.default.blue("--watch, -w")}        Watch for changes and regenerate automatically
 
-${chalk.green.bold("introspect Options")}
-  ${chalk.blue("--output, -o")}       Output directory for generated collection files
+${chalk.default.green.bold("introspect Options")}
+  ${chalk.default.blue("--output, -o")}       Output directory for generated collection files
 `);
-  }
-  async function dbCommand(subcommand, rawArgs) {
-    if (!subcommand || subcommand === "--help") {
-      printDbHelp();
-      return;
-    }
-    const projectRoot = requireProjectRoot();
-    const backendDir = requireBackendDir(projectRoot);
-    const activePlugin = getActiveBackendPlugin(backendDir);
-    if (!activePlugin) {
-      console.error(chalk.red("✗ Could not detect an active database plugin."));
-      console.error(chalk.gray("  Make sure a package like @rebasepro/server-postgresql is installed in backend/package.json."));
-      process.exit(1);
-    }
-    const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
-    if (!pluginCli) {
-      console.error(chalk.red(`✗ Could not find CLI entry point for ${activePlugin}.`));
-      process.exit(1);
-    }
-    const envFile = findEnvFile(projectRoot);
-    const env = { ...process.env };
-    if (envFile) {
-      env.DOTENV_CONFIG_PATH = envFile;
-    }
-    try {
-      const isTs = pluginCli.endsWith(".ts");
-      if (isTs) {
-        const tsxBin = resolveTsx(projectRoot);
-        if (!tsxBin) {
-          console.error(chalk.red("✗ Could not find tsx binary."));
-          process.exit(1);
-        }
-        await execa.execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
-          cwd: backendDir,
-          stdio: "inherit",
-          env
-        });
-      } else {
-        await execa.execa("node", [pluginCli, ...rawArgs.slice(2)], {
-          cwd: backendDir,
-          stdio: "inherit",
-          env
-        });
-      }
-    } catch {
-      process.exit(1);
-    }
-  }
-  function printDbHelp() {
-    console.log(`
-${chalk.bold("rebase db")} — Database management commands
+	}
+	//#endregion
+	//#region src/commands/db.ts
+	/**
+	* CLI command: rebase db <action>
+	*/
+	async function dbCommand(subcommand, rawArgs) {
+		if (!subcommand || subcommand === "--help") {
+			printDbHelp();
+			return;
+		}
+		const projectRoot = requireProjectRoot();
+		const backendDir = requireBackendDir(projectRoot);
+		const activePlugin = getActiveBackendPlugin(backendDir);
+		if (!activePlugin) {
+			console.error(chalk.default.red("✗ Could not detect an active database plugin."));
+			console.error(chalk.default.gray("  Make sure a package like @rebasepro/server-postgresql is installed in backend/package.json."));
+			process.exit(1);
+		}
+		const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
+		if (!pluginCli) {
+			console.error(chalk.default.red(`✗ Could not find CLI entry point for ${activePlugin}.`));
+			process.exit(1);
+		}
+		const envFile = findEnvFile(projectRoot);
+		const env = { ...process.env };
+		if (envFile) env.DOTENV_CONFIG_PATH = envFile;
+		try {
+			if (pluginCli.endsWith(".ts")) {
+				const tsxBin = resolveTsx(projectRoot);
+				if (!tsxBin) {
+					console.error(chalk.default.red("✗ Could not find tsx binary."));
+					process.exit(1);
+				}
+				await (0, execa.execa)(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+					cwd: backendDir,
+					stdio: "inherit",
+					env
+				});
+			} else await (0, execa.execa)("node", [pluginCli, ...rawArgs.slice(2)], {
+				cwd: backendDir,
+				stdio: "inherit",
+				env
+			});
+		} catch {
+			process.exit(1);
+		}
+	}
+	function printDbHelp() {
+		console.log(`
+${chalk.default.bold("rebase db")} — Database management commands
 
-${chalk.green.bold("Usage")}
-  rebase db ${chalk.blue("<command>")} [options]
+${chalk.default.green.bold("Usage")}
+  rebase db ${chalk.default.blue("<command>")} [options]
 
-${chalk.green.bold("Commands")}
-  ${chalk.gray("(Commands are provided by your active database driver plugin)")}
-  ${chalk.blue.bold("push")}       Apply schema directly to database (development)
-  ${chalk.blue.bold("generate")}   Generate migration files
-  ${chalk.blue.bold("migrate")}    Run pending migrations
-  ${chalk.blue.bold("studio")}     Open Studio viewer
-  ${chalk.blue.bold("branch")}     Database branching (create, list, delete, info)
+${chalk.default.green.bold("Commands")}
+  ${chalk.default.gray("(Commands are provided by your active database driver plugin)")}
+  ${chalk.default.blue.bold("push")}       Apply schema directly to database (development)
+  ${chalk.default.blue.bold("generate")}   Generate migration files
+  ${chalk.default.blue.bold("migrate")}    Run pending migrations
+  ${chalk.default.blue.bold("studio")}     Open Studio viewer
+  ${chalk.default.blue.bold("branch")}     Database branching (create, list, delete, info)
 
-${chalk.green.bold("Examples")}
-  ${chalk.gray("# Quick development workflow")}
+${chalk.default.green.bold("Examples")}
+  ${chalk.default.gray("# Quick development workflow")}
   rebase schema generate && rebase db push
 
-  ${chalk.gray("# Production migration workflow")}
+  ${chalk.default.gray("# Production migration workflow")}
   rebase db generate
   rebase db migrate
 
-  ${chalk.gray("# Create a database branch")}
+  ${chalk.default.gray("# Create a database branch")}
   rebase db branch create feature_auth
 `);
-  }
-  const DEV_PORT_FILENAME = ".rebase-dev-port";
-  function getProjectPort(projectRoot) {
-    let hash = 0;
-    for (let i = 0; i < projectRoot.length; i++) {
-      hash = (hash << 5) - hash + projectRoot.charCodeAt(i) | 0;
-    }
-    return 3001 + Math.abs(hash) % 999;
-  }
-  function resolveStartPort(projectRoot, explicitPort) {
-    if (explicitPort) return explicitPort;
-    if (process.env.PORT) return parseInt(process.env.PORT, 10);
-    try {
-      const portFile = path.join(projectRoot, DEV_PORT_FILENAME);
-      if (fs.existsSync(portFile)) {
-        const saved = parseInt(fs.readFileSync(portFile, "utf-8").trim(), 10);
-        if (saved > 0 && saved < 65536) return saved;
-      }
-    } catch {
-    }
-    return getProjectPort(projectRoot);
-  }
-  async function devCommand(rawArgs) {
-    const args = arg(
-      {
-        "--backend-only": Boolean,
-        "--frontend-only": Boolean,
-        "--port": Number,
-        "--generate": Boolean,
-        "--help": Boolean,
-        "-b": "--backend-only",
-        "-f": "--frontend-only",
-        "-p": "--port",
-        "-g": "--generate",
-        "-h": "--help"
-      },
-      {
-        argv: rawArgs.slice(3),
-        // skip "node rebase dev"
-        permissive: true
-      }
-    );
-    if (args["--help"]) {
-      printDevHelp();
-      return;
-    }
-    const projectRoot = requireProjectRoot();
-    const backendDir = findBackendDir(projectRoot);
-    const frontendDir = findFrontendDir(projectRoot);
-    const backendOnly = args["--backend-only"] || false;
-    const frontendOnly = args["--frontend-only"] || false;
-    const shouldGenerate = args["--generate"] || process.env.REBASE_AUTO_GENERATE === "true" || process.env.REBASE_GENERATE === "true";
-    const startPort = resolveStartPort(projectRoot, args["--port"]);
-    console.log("");
-    console.log(chalk.bold("  🚀 Rebase Dev Server"));
-    console.log("");
-    const children = [];
-    let frontendUrl = "";
-    let backendUrl = "";
-    let debounceSummary = null;
-    let bannerPrinted = false;
-    let resolvedBackendPort = null;
-    const stripAnsi = (str) => str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
-    function printSummary() {
-      if (!frontendUrl || !backendUrl) return;
-      if (debounceSummary) clearTimeout(debounceSummary);
-      debounceSummary = setTimeout(() => {
-        if (bannerPrinted) return;
-        console.log("");
-        console.log(chalk.cyan("┌────────────────────────────────────────────────────────────┐"));
-        console.log(chalk.cyan("│                                                            │"));
-        console.log(chalk.cyan("│   ✦ Rebase Admin App is ready!                             │"));
-        const cleanUrl = stripAnsi(frontendUrl);
-        const paddedUrl = cleanUrl.padEnd(41);
-        console.log(chalk.cyan("│   ➜ Frontend URL: ") + chalk.white(paddedUrl) + chalk.cyan("│"));
-        console.log(chalk.cyan("│                                                            │"));
-        console.log(chalk.cyan("└────────────────────────────────────────────────────────────┘"));
-        console.log("");
-        bannerPrinted = true;
-      }, 500);
-    }
-    const cleanup = () => {
-      try {
-        const portFile = path.join(projectRoot, DEV_PORT_FILENAME);
-        if (fs.existsSync(portFile)) fs.unlinkSync(portFile);
-        const urlFile = path.join(projectRoot, ".rebase-dev-url");
-        if (fs.existsSync(urlFile)) fs.unlinkSync(urlFile);
-      } catch {
-      }
-      children.forEach((child) => {
-        if (child.pid && !child.killed) {
-          try {
-            if (process.platform === "win32") {
-              execa.execaCommandSync(`taskkill /pid ${child.pid} /T /F`);
-            } else {
-              process.kill(-child.pid, "SIGKILL");
-            }
-          } catch (e) {
-            try {
-              child.kill("SIGKILL");
-            } catch (err) {
-            }
-          }
-        }
-      });
-      process.exit(0);
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-    function startFrontend(backendPort) {
-      if (!frontendDir) return;
-      console.log(`  ${chalk.magenta("▶")} Frontend: ${chalk.gray(frontendDir)}`);
-      const frontendEnv = { ...process.env };
-      if (backendPort) {
-        frontendEnv.VITE_API_URL = `http://localhost:${backendPort}`;
-        console.log(`  ${chalk.gray("↳ VITE_API_URL")} = ${chalk.white(`http://localhost:${backendPort}`)}`);
-      }
-      const pm = detectPackageManager(projectRoot);
-      const pmCmds = getPMCommands(pm);
-      const runDevCmd = pmCmds.run("dev");
-      const frontendChild = execa.execa(
-        runDevCmd[0],
-        runDevCmd.slice(1),
-        {
-          cwd: frontendDir,
-          stdio: ["inherit", "pipe", "pipe"],
-          env: frontendEnv,
-          shell: true,
-          detached: process.platform !== "win32"
-        }
-      );
-      frontendChild.catch(() => {
-      });
-      frontendChild.stdout?.on("data", (data) => {
-        const lines = data.toString().split("\n").filter(Boolean);
-        lines.forEach((line) => {
-          console.log(`${chalk.magenta.bold("[admin]")} ${line}`);
-          const cleanLine = stripAnsi(line);
-          const urlMatch = cleanLine.match(/(http:\/\/(?:localhost|127\.0\.0\.1):\d+)/);
-          if (cleanLine.includes("Local:") && urlMatch) {
-            frontendUrl = urlMatch[1];
-            printSummary();
-          }
-        });
-      });
-      frontendChild.stderr?.on("data", (data) => {
-        const lines = data.toString().split("\n").filter(Boolean);
-        lines.forEach((line) => {
-          console.log(`${chalk.magenta.bold("[admin]")} ${line}`);
-        });
-      });
-      children.push(frontendChild);
-    }
-    if (!frontendOnly && backendDir) {
-      const tsxBin = resolveTsx(projectRoot);
-      if (!tsxBin) {
-        const pmName = detectPackageManager(projectRoot);
-        const addCmd = pmName === "npm" ? "npm install -D tsx" : "pnpm add -D tsx";
-        console.error(chalk.red("  ✗ Could not find tsx binary for backend."));
-        console.error(chalk.gray(`    Install it with: ${addCmd}`));
-        process.exit(1);
-      }
-      const envFile = findEnvFile(projectRoot);
-      const env = { ...process.env };
-      if (envFile) {
-        env.DOTENV_CONFIG_PATH = envFile;
-      }
-      env.PORT = String(startPort);
-      console.log(`  ${chalk.cyan("▶")} Backend:  ${chalk.gray(backendDir)}`);
-      console.log(`  ${chalk.gray("↳ PORT")} = ${chalk.white(String(startPort))}`);
-      let frontendLaunched = false;
-      if (shouldGenerate) {
-        console.log(chalk.gray("  → Ensuring schema and SDK are generated on start..."));
-        try {
-          const activePlugin = getActiveBackendPlugin(backendDir);
-          const pluginCli = activePlugin ? resolvePluginCliScript(backendDir, activePlugin) : null;
-          if (pluginCli) {
-            await execa.execa(tsxBin, [pluginCli, "schema", "generate"], {
-              cwd: backendDir,
-              stdio: "inherit",
-              env
-            });
-          }
-          await execa.execa("npx", ["rebase", "generate-sdk"], {
-            cwd: projectRoot,
-            stdio: "inherit",
-            env
-          });
-          console.log(chalk.green("  ✓ Initial schema and SDK generated successfully.\n"));
-        } catch (err) {
-          console.error(chalk.red(`  ✗ Initial schema/SDK generation failed: ${err instanceof Error ? err.message : err}
-`));
-        }
-        const collectionsDir = path.join(projectRoot, "config", "collections");
-        if (fs.existsSync(collectionsDir)) {
-          let watchDebounce = null;
-          fs.watch(collectionsDir, { recursive: true }, (eventType, filename) => {
-            if (!filename || filename.startsWith(".") || filename.endsWith(".tmp")) return;
-            if (watchDebounce) clearTimeout(watchDebounce);
-            watchDebounce = setTimeout(async () => {
-              console.log(chalk.yellow(`
-  🔄 Collection change detected (${filename}). Regenerating schema & SDK...`));
-              try {
-                const activePlugin = getActiveBackendPlugin(backendDir);
-                const pluginCli = activePlugin ? resolvePluginCliScript(backendDir, activePlugin) : null;
-                if (pluginCli) {
-                  await execa.execa(tsxBin, [pluginCli, "schema", "generate"], {
-                    cwd: backendDir,
-                    stdio: "inherit",
-                    env
-                  });
-                }
-                await execa.execa("npx", ["rebase", "generate-sdk"], {
-                  cwd: projectRoot,
-                  stdio: "inherit",
-                  env
-                });
-                console.log(chalk.green("  ✓ Schema & SDK regenerated successfully. Hono will reload."));
-              } catch (err) {
-                console.error(chalk.red(`  ✗ Failed to regenerate schema/SDK: ${err instanceof Error ? err.message : err}`));
-              }
-            }, 300);
-          });
-        }
-      }
-      const watchArgs = ["watch", "--conditions", "development", "src/index.ts"];
-      if (!shouldGenerate) {
-        watchArgs.splice(1, 0, `--watch="${path.join("..", "config", "**", "*")}"`);
-      }
-      const backendChild = execa.execa(
-        tsxBin,
-        watchArgs,
-        {
-          cwd: backendDir,
-          stdio: ["inherit", "pipe", "pipe"],
-          env,
-          shell: true,
-          detached: process.platform !== "win32"
-        }
-      );
-      backendChild.catch(() => {
-      });
-      backendChild.stdout?.on("data", (data) => {
-        const lines = data.toString().split("\n").filter(Boolean);
-        lines.forEach((line) => {
-          console.log(`${chalk.cyan.bold("[backend]")}  ${line}`);
-          const cleanLine = stripAnsi(line);
-          const serverMatch = cleanLine.match(/Server running at http:\/\/(?:localhost|127\.0\.0\.1):(\d+)/);
-          if (serverMatch) {
-            resolvedBackendPort = parseInt(serverMatch[1], 10);
-            backendUrl = "started";
-            printSummary();
-            const urlFile = path.join(projectRoot, ".rebase-dev-url");
-            fs.writeFileSync(urlFile, `http://localhost:${resolvedBackendPort}`, "utf-8");
-            const portFile = path.join(projectRoot, DEV_PORT_FILENAME);
-            fs.writeFileSync(portFile, String(resolvedBackendPort), "utf-8");
-            if (!backendOnly && frontendDir && !frontendLaunched) {
-              frontendLaunched = true;
-              startFrontend(resolvedBackendPort);
-            }
-          }
-        });
-      });
-      backendChild.stderr?.on("data", (data) => {
-        const lines = data.toString().split("\n").filter(Boolean);
-        lines.forEach((line) => {
-          console.log(`${chalk.cyan.bold("[backend]")}  ${line}`);
-        });
-      });
-      children.push(backendChild);
-    } else if (!frontendOnly && !backendDir) {
-      console.warn(chalk.yellow("  ⚠ No backend/ directory found, skipping backend."));
-    }
-    if (!backendOnly && frontendDir && (frontendOnly || !backendDir)) {
-      startFrontend(null);
-    } else if (!backendOnly && !frontendDir) {
-      console.warn(chalk.yellow("  ⚠ No frontend/ directory found, skipping frontend."));
-    }
-    if (children.length === 0) {
-      console.error(chalk.red("  ✗ Nothing to start. Check your project structure."));
-      process.exit(1);
-    }
-    console.log("");
-    console.log(chalk.gray("  Press Ctrl+C to stop all servers."));
-    console.log("");
-    await Promise.all(
-      children.map(
-        (child) => new Promise((resolve) => {
-          child.finally(() => resolve());
-        })
-      )
-    );
-  }
-  function printDevHelp() {
-    console.log(`
-${chalk.bold("rebase dev")} — Start the development server
+	}
+	//#endregion
+	//#region src/commands/dev.ts
+	/**
+	* CLI command: rebase dev
+	*
+	* Starts the full development environment:
+	* - Backend: tsx watch with auto-reload
+	* - Frontend: vite dev server
+	*
+	* Both processes stream output with color-coded prefixes.
+	*
+	* When the backend uses port-retry (i.e. the configured port is busy and it
+	* binds to the next free one), the CLI detects the actual port from stdout
+	* and injects VITE_API_URL into the frontend so it connects automatically.
+	*
+	* Each project gets a deterministic default port derived from the project
+	* root path, so multiple Rebase instances never collide.
+	*/
+	/** Well-known filename the backend writes its actual port to. */
+	var DEV_PORT_FILENAME = ".rebase-dev-port";
+	/**
+	* Compute a deterministic port from the project root path.
+	* Range: 3001–3999 (avoids privileged ports and common services).
+	* Two different project directories will almost always get different ports.
+	*/
+	function getProjectPort(projectRoot) {
+		let hash = 0;
+		for (let i = 0; i < projectRoot.length; i++) hash = (hash << 5) - hash + projectRoot.charCodeAt(i) | 0;
+		return 3001 + Math.abs(hash) % 999;
+	}
+	/**
+	* Resolve the best starting port for this project:
+	* 1. Explicit --port flag (highest priority)
+	* 2. PORT env var
+	* 3. Previously used port from .rebase-dev-port (port affinity across restarts)
+	* 4. Deterministic hash from project path (unique per project)
+	*/
+	function resolveStartPort(projectRoot, explicitPort) {
+		if (explicitPort) return explicitPort;
+		if (process.env.PORT) return parseInt(process.env.PORT, 10);
+		try {
+			const portFile = path.default.join(projectRoot, DEV_PORT_FILENAME);
+			if (fs.default.existsSync(portFile)) {
+				const saved = parseInt(fs.default.readFileSync(portFile, "utf-8").trim(), 10);
+				if (saved > 0 && saved < 65536) return saved;
+			}
+		} catch {}
+		return getProjectPort(projectRoot);
+	}
+	async function devCommand(rawArgs) {
+		const args = (0, arg.default)({
+			"--backend-only": Boolean,
+			"--frontend-only": Boolean,
+			"--port": Number,
+			"--generate": Boolean,
+			"--help": Boolean,
+			"-b": "--backend-only",
+			"-f": "--frontend-only",
+			"-p": "--port",
+			"-g": "--generate",
+			"-h": "--help"
+		}, {
+			argv: rawArgs.slice(3),
+			permissive: true
+		});
+		if (args["--help"]) {
+			printDevHelp();
+			return;
+		}
+		const projectRoot = requireProjectRoot();
+		const backendDir = findBackendDir(projectRoot);
+		const frontendDir = findFrontendDir(projectRoot);
+		const backendOnly = args["--backend-only"] || false;
+		const frontendOnly = args["--frontend-only"] || false;
+		const shouldGenerate = args["--generate"] || process.env.REBASE_AUTO_GENERATE === "true" || process.env.REBASE_GENERATE === "true";
+		const startPort = resolveStartPort(projectRoot, args["--port"]);
+		console.log("");
+		console.log(chalk.default.bold("  🚀 Rebase Dev Server"));
+		console.log("");
+		const children = [];
+		let frontendUrl = "";
+		let backendUrl = "";
+		let debounceSummary = null;
+		let bannerPrinted = false;
+		/** Actual backend port, resolved once the server prints its URL. */
+		let resolvedBackendPort = null;
+		const stripAnsi = (str) => str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
+		function printSummary() {
+			if (!frontendUrl || !backendUrl) return;
+			if (debounceSummary) clearTimeout(debounceSummary);
+			debounceSummary = setTimeout(() => {
+				if (bannerPrinted) return;
+				console.log("");
+				console.log(chalk.default.cyan("┌────────────────────────────────────────────────────────────┐"));
+				console.log(chalk.default.cyan("│                                                            │"));
+				console.log(chalk.default.cyan("│   ✦ Rebase Admin App is ready!                             │"));
+				const paddedUrl = stripAnsi(frontendUrl).padEnd(41);
+				console.log(chalk.default.cyan("│   ➜ Frontend URL: ") + chalk.default.white(paddedUrl) + chalk.default.cyan("│"));
+				console.log(chalk.default.cyan("│                                                            │"));
+				console.log(chalk.default.cyan("└────────────────────────────────────────────────────────────┘"));
+				console.log("");
+				bannerPrinted = true;
+			}, 500);
+		}
+		const cleanup = () => {
+			try {
+				const portFile = path.default.join(projectRoot, DEV_PORT_FILENAME);
+				if (fs.default.existsSync(portFile)) fs.default.unlinkSync(portFile);
+				const urlFile = path.default.join(projectRoot, ".rebase-dev-url");
+				if (fs.default.existsSync(urlFile)) fs.default.unlinkSync(urlFile);
+			} catch {}
+			children.forEach((child) => {
+				if (child.pid && !child.killed) try {
+					if (process.platform === "win32") (0, execa.execaCommandSync)(`taskkill /pid ${child.pid} /T /F`);
+					else process.kill(-child.pid, "SIGKILL");
+				} catch (e) {
+					try {
+						child.kill("SIGKILL");
+					} catch (err) {}
+				}
+			});
+			process.exit(0);
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+		/**
+		* Start the Vite frontend, optionally injecting the backend port.
+		*/
+		function startFrontend(backendPort) {
+			if (!frontendDir) return;
+			console.log(`  ${chalk.default.magenta("▶")} Frontend: ${chalk.default.gray(frontendDir)}`);
+			const frontendEnv = { ...process.env };
+			if (backendPort) {
+				frontendEnv.VITE_API_URL = `http://localhost:${backendPort}`;
+				console.log(`  ${chalk.default.gray("↳ VITE_API_URL")} = ${chalk.default.white(`http://localhost:${backendPort}`)}`);
+			}
+			const runDevCmd = getPMCommands(detectPackageManager(projectRoot)).run("dev");
+			const frontendChild = (0, execa.execa)(runDevCmd[0], runDevCmd.slice(1), {
+				cwd: frontendDir,
+				stdio: [
+					"inherit",
+					"pipe",
+					"pipe"
+				],
+				env: frontendEnv,
+				shell: true,
+				detached: process.platform !== "win32"
+			});
+			frontendChild.catch(() => {});
+			frontendChild.stdout?.on("data", (data) => {
+				data.toString().split("\n").filter(Boolean).forEach((line) => {
+					console.log(`${chalk.default.magenta.bold("[admin]")} ${line}`);
+					const cleanLine = stripAnsi(line);
+					const urlMatch = cleanLine.match(/(http:\/\/(?:localhost|127\.0\.0\.1):\d+)/);
+					if (cleanLine.includes("Local:") && urlMatch) {
+						frontendUrl = urlMatch[1];
+						printSummary();
+					}
+				});
+			});
+			frontendChild.stderr?.on("data", (data) => {
+				data.toString().split("\n").filter(Boolean).forEach((line) => {
+					console.log(`${chalk.default.magenta.bold("[admin]")} ${line}`);
+				});
+			});
+			children.push(frontendChild);
+		}
+		if (!frontendOnly && backendDir) {
+			const tsxBin = resolveTsx(projectRoot);
+			if (!tsxBin) {
+				const addCmd = [
+					...getPMCommands(detectPackageManager(projectRoot)).install,
+					"-D",
+					"tsx"
+				].join(" ");
+				console.error(chalk.default.red("  ✗ Could not find tsx binary for backend."));
+				console.error(chalk.default.gray(`    Install it with: ${addCmd}`));
+				process.exit(1);
+			}
+			const envFile = findEnvFile(projectRoot);
+			const env = { ...process.env };
+			if (envFile) env.DOTENV_CONFIG_PATH = envFile;
+			env.PORT = String(startPort);
+			console.log(`  ${chalk.default.cyan("▶")} Backend:  ${chalk.default.gray(backendDir)}`);
+			console.log(`  ${chalk.default.gray("↳ PORT")} = ${chalk.default.white(String(startPort))}`);
+			/** Whether the frontend has been launched (we only launch it once). */
+			let frontendLaunched = false;
+			if (shouldGenerate) {
+				console.log(chalk.default.gray("  → Ensuring schema and SDK are generated on start..."));
+				try {
+					const activePlugin = getActiveBackendPlugin(backendDir);
+					const pluginCli = activePlugin ? resolvePluginCliScript(backendDir, activePlugin) : null;
+					if (pluginCli) await (0, execa.execa)(tsxBin, [
+						pluginCli,
+						"schema",
+						"generate"
+					], {
+						cwd: backendDir,
+						stdio: "inherit",
+						env
+					});
+					const sdkCmd = getPMCommands(detectPackageManager(projectRoot)).exec("rebase", ["generate-sdk"]);
+					await (0, execa.execa)(sdkCmd[0], sdkCmd.slice(1), {
+						cwd: projectRoot,
+						stdio: "inherit",
+						env
+					});
+					console.log(chalk.default.green("  ✓ Initial schema and SDK generated successfully.\n"));
+				} catch (err) {
+					console.error(chalk.default.red(`  ✗ Initial schema/SDK generation failed: ${err instanceof Error ? err.message : err}\n`));
+				}
+				const collectionsDir = path.default.join(projectRoot, "config", "collections");
+				if (fs.default.existsSync(collectionsDir)) {
+					let watchDebounce = null;
+					fs.default.watch(collectionsDir, { recursive: true }, (eventType, filename) => {
+						if (!filename || filename.startsWith(".") || filename.endsWith(".tmp")) return;
+						if (watchDebounce) clearTimeout(watchDebounce);
+						watchDebounce = setTimeout(async () => {
+							console.log(chalk.default.yellow(`\n  🔄 Collection change detected (${filename}). Regenerating schema & SDK...`));
+							try {
+								const activePlugin = getActiveBackendPlugin(backendDir);
+								const pluginCli = activePlugin ? resolvePluginCliScript(backendDir, activePlugin) : null;
+								if (pluginCli) await (0, execa.execa)(tsxBin, [
+									pluginCli,
+									"schema",
+									"generate"
+								], {
+									cwd: backendDir,
+									stdio: "inherit",
+									env
+								});
+								const sdkCmd = getPMCommands(detectPackageManager(projectRoot)).exec("rebase", ["generate-sdk"]);
+								await (0, execa.execa)(sdkCmd[0], sdkCmd.slice(1), {
+									cwd: projectRoot,
+									stdio: "inherit",
+									env
+								});
+								console.log(chalk.default.green("  ✓ Schema & SDK regenerated successfully. Hono will reload."));
+							} catch (err) {
+								console.error(chalk.default.red(`  ✗ Failed to regenerate schema/SDK: ${err instanceof Error ? err.message : err}`));
+							}
+						}, 300);
+					});
+				}
+			}
+			const watchArgs = [
+				"watch",
+				"--conditions",
+				"development",
+				"src/index.ts"
+			];
+			if (!shouldGenerate) {
+				watchArgs.splice(1, 0, `--watch="${path.default.join("..", "config", "**", "*")}"`);
+				const collectionsDir = path.default.join(projectRoot, "config", "collections");
+				if (fs.default.existsSync(collectionsDir)) {
+					let driftDebounce = null;
+					fs.default.watch(collectionsDir, { recursive: true }, (_eventType, filename) => {
+						if (!filename || filename.startsWith(".") || filename.endsWith(".tmp")) return;
+						if (driftDebounce) clearTimeout(driftDebounce);
+						driftDebounce = setTimeout(() => {
+							console.log([
+								"",
+								chalk.default.yellow("  ┌──────────────────────────────────────────────────────────────┐"),
+								chalk.default.yellow("  │  ⚠️  Collection file changed: ") + chalk.default.white(filename.padEnd(31)) + chalk.default.yellow("│"),
+								chalk.default.yellow("  │                                                              │"),
+								chalk.default.yellow("  │  Your schema may be out of sync. Run:                        │"),
+								chalk.default.yellow("  │    ") + chalk.default.cyan("rebase schema generate") + chalk.default.yellow("   regenerate Drizzle schema        │"),
+								chalk.default.yellow("  │    ") + chalk.default.cyan("rebase db push        ") + chalk.default.yellow("   sync schema to database          │"),
+								chalk.default.yellow("  │    ") + chalk.default.cyan("rebase doctor         ") + chalk.default.yellow("   check for drift                  │"),
+								chalk.default.yellow("  │                                                              │"),
+								chalk.default.yellow("  │  TIP: Use ") + chalk.default.bold("rebase dev --generate") + chalk.default.yellow(" for auto-regeneration        │"),
+								chalk.default.yellow("  └──────────────────────────────────────────────────────────────┘"),
+								""
+							].join("\n"));
+						}, 500);
+					});
+				}
+			}
+			const backendChild = (0, execa.execa)(tsxBin, watchArgs, {
+				cwd: backendDir,
+				stdio: [
+					"inherit",
+					"pipe",
+					"pipe"
+				],
+				env,
+				shell: true,
+				detached: process.platform !== "win32"
+			});
+			backendChild.catch(() => {});
+			backendChild.stdout?.on("data", (data) => {
+				data.toString().split("\n").filter(Boolean).forEach((line) => {
+					console.log(`${chalk.default.cyan.bold("[backend]")}  ${line}`);
+					const serverMatch = stripAnsi(line).match(/Server running at http:\/\/(?:localhost|127\.0\.0\.1):(\d+)/);
+					if (serverMatch) {
+						resolvedBackendPort = parseInt(serverMatch[1], 10);
+						backendUrl = "started";
+						printSummary();
+						const urlFile = path.default.join(projectRoot, ".rebase-dev-url");
+						fs.default.writeFileSync(urlFile, `http://localhost:${resolvedBackendPort}`, "utf-8");
+						const portFile = path.default.join(projectRoot, DEV_PORT_FILENAME);
+						fs.default.writeFileSync(portFile, String(resolvedBackendPort), "utf-8");
+						if (!backendOnly && frontendDir && !frontendLaunched) {
+							frontendLaunched = true;
+							startFrontend(resolvedBackendPort);
+						}
+					}
+				});
+			});
+			backendChild.stderr?.on("data", (data) => {
+				data.toString().split("\n").filter(Boolean).forEach((line) => {
+					console.log(`${chalk.default.cyan.bold("[backend]")}  ${line}`);
+				});
+			});
+			children.push(backendChild);
+		} else if (!frontendOnly && !backendDir) console.warn(chalk.default.yellow("  ⚠ No backend/ directory found, skipping backend."));
+		if (!backendOnly && frontendDir && (frontendOnly || !backendDir)) startFrontend(null);
+		else if (!backendOnly && !frontendDir) console.warn(chalk.default.yellow("  ⚠ No frontend/ directory found, skipping frontend."));
+		if (children.length === 0) {
+			console.error(chalk.default.red("  ✗ Nothing to start. Check your project structure."));
+			process.exit(1);
+		}
+		console.log("");
+		console.log(chalk.default.gray("  Press Ctrl+C to stop all servers."));
+		console.log("");
+		await Promise.all(children.map((child) => new Promise((resolve) => {
+			child.finally(() => resolve());
+		})));
+	}
+	function printDevHelp() {
+		console.log(`
+${chalk.default.bold("rebase dev")} — Start the development server
 
-${chalk.green.bold("Usage")}
+${chalk.default.green.bold("Usage")}
   rebase dev [options]
 
-${chalk.green.bold("Options")}
-  ${chalk.blue("--backend-only, -b")}   Only start the backend server
-  ${chalk.blue("--frontend-only, -f")}  Only start the frontend server
-  ${chalk.blue("--port, -p")}           Backend port (default: auto-detected per project)
-  ${chalk.blue("--generate, -g")}        Enable automatic schema and SDK generation on startup and file changes
+${chalk.default.green.bold("Options")}
+  ${chalk.default.blue("--backend-only, -b")}   Only start the backend server
+  ${chalk.default.blue("--frontend-only, -f")}  Only start the frontend server
+  ${chalk.default.blue("--port, -p")}           Backend port (default: auto-detected per project)
+  ${chalk.default.blue("--generate, -g")}        Enable automatic schema and SDK generation on startup and file changes
 
-${chalk.green.bold("Description")}
+${chalk.default.green.bold("Description")}
   Starts both the backend (tsx watch + Hono) and frontend (Vite)
   dev servers concurrently with color-coded output prefixes.
 
@@ -1178,102 +1354,115 @@ ${chalk.green.bold("Description")}
   and file changes. Pass --generate (-g) or set REBASE_AUTO_GENERATE=true
   in your environment to enable it.
 `);
-  }
-  async function buildCommand() {
-    const projectRoot = requireProjectRoot();
-    const pm = detectPackageManager(projectRoot);
-    const cmds = getPMCommands(pm);
-    const buildCmd = cmds.runAll("build");
-    console.log(`${chalk.bold("Rebase")} — Building all workspaces with ${chalk.cyan(pm)}...
-`);
-    try {
-      await execa.execa(buildCmd[0], buildCmd.slice(1), {
-        cwd: projectRoot,
-        stdio: "inherit"
-      });
-    } catch {
-      console.error(chalk.red("\n✗ Build failed."));
-      process.exit(1);
-    }
-  }
-  async function startCommand() {
-    const projectRoot = requireProjectRoot();
-    const pm = detectPackageManager(projectRoot);
-    const cmds = getPMCommands(pm);
-    const startCmd = cmds.runWorkspace("backend", "start");
-    const envFile = findEnvFile(projectRoot);
-    const env = { ...process.env };
-    if (envFile) {
-      env.DOTENV_CONFIG_PATH = envFile;
-    }
-    console.log(`${chalk.bold("Rebase")} — Starting backend server...
-`);
-    try {
-      await execa.execa(startCmd[0], startCmd.slice(1), {
-        cwd: projectRoot,
-        stdio: "inherit",
-        env
-      });
-    } catch {
-      console.error(chalk.red("\n✗ Failed to start server."));
-      process.exit(1);
-    }
-  }
-  async function authCommand(subcommand, rawArgs) {
-    if (!subcommand || subcommand === "--help") {
-      printAuthHelp();
-      return;
-    }
-    switch (subcommand) {
-      case "reset-password":
-        await resetPassword(rawArgs);
-        break;
-      default:
-        console.error(chalk.red(`Unknown auth command: ${subcommand}`));
-        console.log("");
-        printAuthHelp();
-        process.exit(1);
-    }
-  }
-  async function resetPassword(rawArgs) {
-    const args = arg(
-      {
-        "--email": String,
-        "--password": String,
-        "-e": "--email",
-        "-p": "--password"
-      },
-      {
-        argv: rawArgs.slice(4),
-        // skip "node rebase auth reset-password"
-        permissive: true
-      }
-    );
-    const email = args["--email"] || args._[0];
-    const newPassword = args["--password"] || args._[1];
-    if (!email) {
-      console.error(chalk.red("✗ Email is required."));
-      console.log("");
-      console.log(chalk.gray("  Usage: rebase auth reset-password <email> [new-password]"));
-      console.log(chalk.gray("         rebase auth reset-password --email user@example.com --password NewPass123!"));
-      process.exit(1);
-    }
-    const projectRoot = requireProjectRoot();
-    const backendDir = requireBackendDir(projectRoot);
-    const tsxBin = resolveTsx(projectRoot);
-    if (!tsxBin) {
-      console.error(chalk.red("✗ Could not find tsx binary."));
-      process.exit(1);
-    }
-    const envFile = findEnvFile(projectRoot);
-    const env = { ...process.env };
-    if (envFile) {
-      env.DOTENV_CONFIG_PATH = envFile;
-    }
-    env.REBASE_RESET_EMAIL = email;
-    env.REBASE_RESET_PASSWORD = newPassword || "NewPassword123!";
-    env.REBASE_ENV_FILE_PATH = envFile || path.join(projectRoot, ".env");
-    const scriptContent = `
+	}
+	//#endregion
+	//#region src/commands/build.ts
+	/**
+	* CLI command: rebase build
+	*
+	* Runs the build script in all workspace packages.
+	* Automatically detects the package manager (pnpm or npm) and
+	* uses the correct workspace-aware command.
+	*/
+	async function buildCommand() {
+		const projectRoot = requireProjectRoot();
+		const pm = detectPackageManager(projectRoot);
+		const buildCmd = getPMCommands(pm).runAll("build");
+		console.log(`${chalk.default.bold("Rebase")} — Building all workspaces with ${chalk.default.cyan(pm)}...\n`);
+		try {
+			await (0, execa.execa)(buildCmd[0], buildCmd.slice(1), {
+				cwd: projectRoot,
+				stdio: "inherit"
+			});
+		} catch {
+			console.error(chalk.default.red("\n✗ Build failed."));
+			process.exit(1);
+		}
+	}
+	//#endregion
+	//#region src/commands/start.ts
+	/**
+	* CLI command: rebase start
+	*
+	* Starts the backend server in production mode.
+	* Automatically detects the package manager (pnpm or npm) and
+	* runs the start script in the backend workspace.
+	*/
+	async function startCommand() {
+		const projectRoot = requireProjectRoot();
+		const startCmd = getPMCommands(detectPackageManager(projectRoot)).runWorkspace("backend", "start");
+		const envFile = findEnvFile(projectRoot);
+		const env = { ...process.env };
+		if (envFile) env.DOTENV_CONFIG_PATH = envFile;
+		console.log(`${chalk.default.bold("Rebase")} — Starting backend server...\n`);
+		try {
+			await (0, execa.execa)(startCmd[0], startCmd.slice(1), {
+				cwd: projectRoot,
+				stdio: "inherit",
+				env
+			});
+		} catch {
+			console.error(chalk.default.red("\n✗ Failed to start server."));
+			process.exit(1);
+		}
+	}
+	//#endregion
+	//#region src/commands/auth.ts
+	/**
+	* CLI command: rebase auth <action>
+	*
+	* Subcommands:
+	*   reset-password — Reset a user's password
+	*/
+	async function authCommand(subcommand, rawArgs) {
+		if (!subcommand || subcommand === "--help") {
+			printAuthHelp();
+			return;
+		}
+		switch (subcommand) {
+			case "reset-password":
+				await resetPassword(rawArgs);
+				break;
+			default:
+				console.error(chalk.default.red(`Unknown auth command: ${subcommand}`));
+				console.log("");
+				printAuthHelp();
+				process.exit(1);
+		}
+	}
+	async function resetPassword(rawArgs) {
+		const args = (0, arg.default)({
+			"--email": String,
+			"--password": String,
+			"-e": "--email",
+			"-p": "--password"
+		}, {
+			argv: rawArgs.slice(4),
+			permissive: true
+		});
+		const email = args["--email"] || args._[0];
+		const newPassword = args["--password"] || args._[1];
+		if (!email) {
+			console.error(chalk.default.red("✗ Email is required."));
+			console.log("");
+			console.log(chalk.default.gray("  Usage: rebase auth reset-password <email> [new-password]"));
+			console.log(chalk.default.gray("         rebase auth reset-password --email user@example.com --password NewPass123!"));
+			process.exit(1);
+		}
+		const projectRoot = requireProjectRoot();
+		const backendDir = requireBackendDir(projectRoot);
+		const tsxBin = resolveTsx(projectRoot);
+		if (!tsxBin) {
+			console.error(chalk.default.red("✗ Could not find tsx binary."));
+			process.exit(1);
+		}
+		const envFile = findEnvFile(projectRoot);
+		const env = { ...process.env };
+		if (envFile) env.DOTENV_CONFIG_PATH = envFile;
+		env.REBASE_RESET_EMAIL = email;
+		env.REBASE_RESET_PASSWORD = newPassword || "NewPassword123!";
+		env.REBASE_ENV_FILE_PATH = envFile || path.default.join(projectRoot, ".env");
+		const scriptContent = `
 import { createPostgresDatabaseConnection } from "@rebasepro/server-postgresql";
 import { hashPassword } from "@rebasepro/server-core";
 import { eq } from "drizzle-orm";
@@ -1318,7 +1507,7 @@ async function resetPassword() {
 
     if (result.length > 0) {
         console.log("✅ Password reset for: " + result[0].email);
-        ${!newPassword ? 'console.log("   New password: " + newPassword);' : ""}
+        ${!newPassword ? "console.log(\"   New password: \" + newPassword);" : ""}
     } else {
         console.log("✗ User not found: " + email);
     }
@@ -1327,249 +1516,433 @@ async function resetPassword() {
 
 resetPassword().catch(console.error);
 `;
-    const tmpScriptPath = path.join(backendDir, ".tmp-reset-password.ts");
-    fs.writeFileSync(tmpScriptPath, scriptContent, "utf-8");
-    console.log("");
-    console.log(chalk.bold("  🔑 Rebase Auth — Reset Password"));
-    console.log("");
-    console.log(`  ${chalk.gray("Email:")} ${email}`);
-    if (newPassword) {
-      console.log(`  ${chalk.gray("Password:")} ${"*".repeat(newPassword.length)}`);
-    }
-    console.log("");
-    const child = child_process.spawn(tsxBin, [tmpScriptPath], {
-      cwd: backendDir,
-      stdio: "inherit",
-      env
-    });
-    return new Promise((resolve) => {
-      child.on("close", (code) => {
-        try {
-          fs.unlinkSync(tmpScriptPath);
-        } catch {
-        }
-        if (code !== 0) {
-          process.exit(code ?? 1);
-        }
-        resolve();
-      });
-    });
-  }
-  function printAuthHelp() {
-    console.log(`
-${chalk.bold("rebase auth")} — Authentication management commands
+		const tmpScriptPath = path.default.join(backendDir, ".tmp-reset-password.ts");
+		fs.default.writeFileSync(tmpScriptPath, scriptContent, "utf-8");
+		console.log("");
+		console.log(chalk.default.bold("  🔑 Rebase Auth — Reset Password"));
+		console.log("");
+		console.log(`  ${chalk.default.gray("Email:")} ${email}`);
+		if (newPassword) console.log(`  ${chalk.default.gray("Password:")} ${"*".repeat(newPassword.length)}`);
+		console.log("");
+		const child = (0, child_process.spawn)(tsxBin, [tmpScriptPath], {
+			cwd: backendDir,
+			stdio: "inherit",
+			env
+		});
+		return new Promise((resolve) => {
+			child.on("close", (code) => {
+				try {
+					fs.default.unlinkSync(tmpScriptPath);
+				} catch {}
+				if (code !== 0) process.exit(code ?? 1);
+				resolve();
+			});
+		});
+	}
+	function printAuthHelp() {
+		console.log(`
+${chalk.default.bold("rebase auth")} — Authentication management commands
 
-${chalk.green.bold("Usage")}
-  rebase auth ${chalk.blue("<command>")} [options]
+${chalk.default.green.bold("Usage")}
+  rebase auth ${chalk.default.blue("<command>")} [options]
 
-${chalk.green.bold("Commands")}
-  ${chalk.blue.bold("reset-password")}    Reset a user's password
+${chalk.default.green.bold("Commands")}
+  ${chalk.default.blue.bold("reset-password")}    Reset a user's password
 
-${chalk.green.bold("reset-password Options")}
-  ${chalk.blue("--email, -e")}        User's email address
-  ${chalk.blue("--password, -p")}     New password (default: NewPassword123!)
+${chalk.default.green.bold("reset-password Options")}
+  ${chalk.default.blue("--email, -e")}        User's email address
+  ${chalk.default.blue("--password, -p")}     New password (default: NewPassword123!)
 
-${chalk.green.bold("Examples")}
+${chalk.default.green.bold("Examples")}
   rebase auth reset-password user@example.com
   rebase auth reset-password --email user@example.com --password MyNewPass!
 `);
-  }
-  async function doctorCommand(rawArgs) {
-    const projectRoot = requireProjectRoot();
-    const backendDir = requireBackendDir(projectRoot);
-    const activePlugin = getActiveBackendPlugin(backendDir);
-    if (!activePlugin) {
-      console.error(chalk.red("✗ Could not detect an active database plugin."));
-      console.error(chalk.gray("  Make sure a package like @rebasepro/server-postgresql is installed in backend/package.json."));
-      process.exit(1);
-    }
-    const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
-    if (!pluginCli) {
-      console.error(chalk.red(`✗ Could not find CLI entry point for ${activePlugin}.`));
-      process.exit(1);
-    }
-    const envFile = findEnvFile(projectRoot);
-    const env = { ...process.env };
-    if (envFile) {
-      env.DOTENV_CONFIG_PATH = envFile;
-    }
-    try {
-      const isTs = pluginCli.endsWith(".ts");
-      if (isTs) {
-        const tsxBin = resolveTsx(projectRoot);
-        if (!tsxBin) {
-          console.error(chalk.red("✗ Could not find tsx binary."));
-          process.exit(1);
-        }
-        await execa.execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
-          cwd: backendDir,
-          stdio: "inherit",
-          env
-        });
-      } else {
-        await execa.execa("node", [pluginCli, ...rawArgs.slice(2)], {
-          cwd: backendDir,
-          stdio: "inherit",
-          env
-        });
-      }
-    } catch {
-      process.exit(1);
-    }
-  }
-  const __filename$1 = url.fileURLToPath(typeof document === "undefined" && typeof location === "undefined" ? require("url").pathToFileURL(__filename).href : typeof document === "undefined" ? location.href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href);
-  const __dirname$1 = path.dirname(__filename$1);
-  function getVersion() {
-    try {
-      const pkgPath = path.resolve(__dirname$1, "../package.json");
-      if (fs.existsSync(pkgPath)) {
-        return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
-      }
-    } catch {
-    }
-    return "unknown";
-  }
-  async function entry(args) {
-    const parsedArgs = arg(
-      {
-        "--version": Boolean,
-        "--help": Boolean,
-        "-v": "--version",
-        "-h": "--help"
-      },
-      {
-        argv: args.slice(2),
-        permissive: true
-      }
-    );
-    if (parsedArgs["--version"]) {
-      console.log(getVersion());
-      return;
-    }
-    const command = parsedArgs._[0];
-    const subcommand = parsedArgs._[1];
-    const namespacedCommands = ["schema", "db", "dev", "build", "start", "auth", "doctor"];
-    if (!command || parsedArgs["--help"] && !namespacedCommands.includes(command)) {
-      printHelp();
-      return;
-    }
-    const effectiveSubcommand = parsedArgs["--help"] ? "--help" : subcommand;
-    switch (command) {
-      case "init":
-        await createRebaseApp(args);
-        break;
-      case "generate-sdk": {
-        const sdkArgs = arg(
-          {
-            "--collections-dir": String,
-            "--output": String,
-            "-c": "--collections-dir",
-            "-o": "--output"
-          },
-          {
-            argv: args.slice(3),
-            permissive: true
-          }
-        );
-        await generateSdkCommand({
-          collectionsDir: sdkArgs["--collections-dir"] || "./config/collections",
-          output: sdkArgs["--output"] || "./generated/sdk",
-          cwd: process.cwd()
-        });
-        break;
-      }
-      case "schema":
-        await schemaCommand(effectiveSubcommand, args);
-        break;
-      case "db":
-        await dbCommand(effectiveSubcommand, args);
-        break;
-      case "dev":
-        await devCommand(args);
-        break;
-      case "build":
-        await buildCommand();
-        break;
-      case "start":
-        await startCommand();
-        break;
-      case "auth":
-        await authCommand(effectiveSubcommand, args);
-        break;
-      case "doctor":
-        await doctorCommand(args);
-        break;
-      default:
-        console.log(chalk.red(`Unknown command: ${command}`));
-        console.log("");
-        printHelp();
-    }
-  }
-  function printHelp() {
-    console.log(`
-${chalk.bold("Rebase CLI")} — Developer tools for Rebase projects
+	}
+	//#endregion
+	//#region src/commands/doctor.ts
+	/**
+	* CLI command: rebase doctor
+	*
+	* Detects three-way schema drift between collection definitions,
+	* the generated Drizzle schema, and the live PostgreSQL database.
+	*/
+	async function doctorCommand(rawArgs) {
+		const projectRoot = requireProjectRoot();
+		const backendDir = requireBackendDir(projectRoot);
+		const activePlugin = getActiveBackendPlugin(backendDir);
+		if (!activePlugin) {
+			console.error(chalk.default.red("✗ Could not detect an active database plugin."));
+			console.error(chalk.default.gray("  Make sure a package like @rebasepro/server-postgresql is installed in backend/package.json."));
+			process.exit(1);
+		}
+		const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
+		if (!pluginCli) {
+			console.error(chalk.default.red(`✗ Could not find CLI entry point for ${activePlugin}.`));
+			process.exit(1);
+		}
+		const envFile = findEnvFile(projectRoot);
+		const env = { ...process.env };
+		if (envFile) env.DOTENV_CONFIG_PATH = envFile;
+		try {
+			if (pluginCli.endsWith(".ts")) {
+				const tsxBin = resolveTsx(projectRoot);
+				if (!tsxBin) {
+					console.error(chalk.default.red("✗ Could not find tsx binary."));
+					process.exit(1);
+				}
+				await (0, execa.execa)(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+					cwd: backendDir,
+					stdio: "inherit",
+					env
+				});
+			} else await (0, execa.execa)("node", [pluginCli, ...rawArgs.slice(2)], {
+				cwd: backendDir,
+				stdio: "inherit",
+				env
+			});
+		} catch {
+			process.exit(1);
+		}
+	}
+	//#endregion
+	//#region src/commands/skills.ts
+	var __filename$1 = (0, url.fileURLToPath)({}.url);
+	var __dirname$1 = path.default.dirname(__filename$1);
+	/** Supported agent environments and their target directories. */
+	var AGENTS = {
+		cursor: {
+			label: "Cursor",
+			detectDir: ".cursor",
+			targetDir: ".cursor/rules",
+			/** Cursor uses .mdc files (Markdown with Context). */
+			transformFile: (skillName, content) => ({
+				fileName: `${skillName}.mdc`,
+				content
+			})
+		},
+		claude: {
+			label: "Claude Code",
+			detectDir: ".claude",
+			targetDir: ".claude/skills",
+			/** Claude Code uses the standard SKILL.md format in subdirectories. */
+			transformFile: (skillName, content) => ({
+				fileName: path.default.join(skillName, "SKILL.md"),
+				content
+			})
+		},
+		windsurf: {
+			label: "Windsurf",
+			detectDir: ".windsurf",
+			targetDir: ".windsurf/rules",
+			/** Windsurf uses plain .md files. */
+			transformFile: (skillName, content) => ({
+				fileName: `${skillName}.md`,
+				content
+			})
+		},
+		gemini: {
+			label: "Gemini CLI / Antigravity",
+			detectDir: ".agents",
+			targetDir: ".agents/skills",
+			/** Gemini uses the standard SKILL.md format in subdirectories. */
+			transformFile: (skillName, content) => ({
+				fileName: path.default.join(skillName, "SKILL.md"),
+				content
+			})
+		}
+	};
+	function findParentDir(currentDir, targetName) {
+		const root = path.default.parse(currentDir).root;
+		while (currentDir && currentDir !== root) {
+			if (path.default.basename(currentDir) === targetName) return currentDir;
+			currentDir = path.default.dirname(currentDir);
+		}
+		return null;
+	}
+	/** Resolve the path to the bundled skills directory. */
+	function getSkillsSourceDir() {
+		const cliRoot = findParentDir(__dirname$1, "cli");
+		if (cliRoot) {
+			const dir = path.default.join(cliRoot, "skills");
+			if (fs.default.existsSync(dir)) return dir;
+		}
+		const distSkills = path.default.resolve(__dirname$1, "../../skills");
+		if (fs.default.existsSync(distSkills)) return distSkills;
+		throw new Error("Could not find bundled skills directory. Make sure the CLI was built with `pnpm build`.");
+	}
+	/** Read all skill directories and return their names + content. */
+	function loadSkills(skillsDir) {
+		const entries = fs.default.readdirSync(skillsDir, { withFileTypes: true });
+		const skills = [];
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			const skillMdPath = path.default.join(skillsDir, entry.name, "SKILL.md");
+			if (!fs.default.existsSync(skillMdPath)) continue;
+			skills.push({
+				name: entry.name,
+				content: fs.default.readFileSync(skillMdPath, "utf-8")
+			});
+		}
+		return skills;
+	}
+	/** Detect which agent environments already exist in the project. */
+	function detectAgents(projectDir) {
+		const detected = [];
+		for (const [key, agent] of Object.entries(AGENTS)) if (fs.default.existsSync(path.default.join(projectDir, agent.detectDir))) detected.push(key);
+		return detected;
+	}
+	/** Install skills for a specific agent into the project directory. */
+	function installForAgent(agentKey, skills, projectDir) {
+		const agent = AGENTS[agentKey];
+		const targetBase = path.default.join(projectDir, agent.targetDir);
+		fs.default.mkdirSync(targetBase, { recursive: true });
+		let count = 0;
+		for (const skill of skills) {
+			const { fileName, content } = agent.transformFile(skill.name, skill.content);
+			const targetPath = path.default.join(targetBase, fileName);
+			fs.default.mkdirSync(path.default.dirname(targetPath), { recursive: true });
+			fs.default.writeFileSync(targetPath, content, "utf-8");
+			count++;
+		}
+		return count;
+	}
+	async function skillsCommand(subcommand, _args) {
+		switch (subcommand) {
+			case "install":
+				await skillsInstall();
+				break;
+			case "--help":
+			case void 0:
+				printSkillsHelp();
+				break;
+			default:
+				console.log(chalk.default.red(`Unknown skills subcommand: ${subcommand}`));
+				console.log("");
+				printSkillsHelp();
+		}
+	}
+	async function skillsInstall() {
+		const projectDir = process.cwd();
+		let skillsDir;
+		try {
+			skillsDir = getSkillsSourceDir();
+		} catch (err) {
+			console.error(`${chalk.default.red.bold("ERROR")} ${err instanceof Error ? err.message : String(err)}`);
+			process.exit(1);
+		}
+		const skills = loadSkills(skillsDir);
+		if (skills.length === 0) {
+			console.error(`${chalk.default.red.bold("ERROR")} No skills found in ${skillsDir}`);
+			process.exit(1);
+		}
+		let agents = detectAgents(projectDir);
+		if (agents.length === 0) {
+			const choices = Object.entries(AGENTS).map(([key, agent]) => ({
+				name: agent.label,
+				value: key,
+				checked: false
+			}));
+			const { selectedAgents } = await inquirer.default.prompt([{
+				type: "checkbox",
+				name: "selectedAgents",
+				message: "No AI agent configuration detected. Which agents do you use?",
+				choices,
+				validate: (input) => {
+					if (input.length === 0) return "Please select at least one agent.";
+					return true;
+				}
+			}]);
+			agents = selectedAgents;
+		}
+		console.log("");
+		console.log(chalk.default.gray(`  Found ${chalk.default.white(skills.length)} Rebase skills`));
+		console.log("");
+		for (const agentKey of agents) {
+			const agent = AGENTS[agentKey];
+			const count = installForAgent(agentKey, skills, projectDir);
+			console.log(`  ${chalk.default.green("✓")} ${chalk.default.bold(agent.label)} — ${count} skills installed to ${chalk.default.gray(agent.targetDir)}`);
+		}
+		console.log("");
+		console.log(chalk.default.gray("  Skills are project-local. Commit them to share with your team."));
+		console.log(chalk.default.gray("  Re-run this command anytime to update to the latest skills."));
+		console.log("");
+	}
+	function printSkillsHelp() {
+		console.log(`
+${chalk.default.bold("rebase skills")} — Manage AI agent skills
+
+${chalk.default.green.bold("Usage")}
+  rebase skills ${chalk.default.blue("<subcommand>")}
+
+${chalk.default.green.bold("Subcommands")}
+  ${chalk.default.blue.bold("install")}    Install Rebase agent skills for your AI coding assistant
+               Supports: Cursor, Claude Code, Windsurf, Gemini CLI, Antigravity
 
-${chalk.green.bold("Usage")}
-  rebase ${chalk.blue("<command>")} [options]
+${chalk.default.green.bold("Examples")}
+  ${chalk.default.cyan("rebase skills install")}
+`);
+	}
+	//#endregion
+	//#region src/cli.ts
+	var __filename = (0, url.fileURLToPath)({}.url);
+	var __dirname = path.default.dirname(__filename);
+	function getVersion() {
+		try {
+			const pkgPath = path.default.resolve(__dirname, "../package.json");
+			if (fs.default.existsSync(pkgPath)) return JSON.parse(fs.default.readFileSync(pkgPath, "utf-8")).version;
+		} catch {}
+		return "unknown";
+	}
+	async function entry(args) {
+		const parsedArgs = (0, arg.default)({
+			"--version": Boolean,
+			"--help": Boolean,
+			"-v": "--version",
+			"-h": "--help"
+		}, {
+			argv: args.slice(2),
+			permissive: true
+		});
+		if (parsedArgs["--version"]) {
+			console.log(getVersion());
+			return;
+		}
+		const command = parsedArgs._[0];
+		const subcommand = parsedArgs._[1];
+		if (!command || parsedArgs["--help"] && ![
+			"schema",
+			"db",
+			"dev",
+			"build",
+			"start",
+			"auth",
+			"doctor",
+			"skills"
+		].includes(command)) {
+			printHelp();
+			return;
+		}
+		const effectiveSubcommand = parsedArgs["--help"] ? "--help" : subcommand;
+		switch (command) {
+			case "init":
+				await createRebaseApp(args);
+				break;
+			case "generate-sdk": {
+				const sdkArgs = (0, arg.default)({
+					"--collections-dir": String,
+					"--output": String,
+					"-c": "--collections-dir",
+					"-o": "--output"
+				}, {
+					argv: args.slice(3),
+					permissive: true
+				});
+				await generateSdkCommand({
+					collectionsDir: sdkArgs["--collections-dir"] || "./config/collections",
+					output: sdkArgs["--output"] || "./generated/sdk",
+					cwd: process.cwd()
+				});
+				break;
+			}
+			case "schema":
+				await schemaCommand(effectiveSubcommand, args);
+				break;
+			case "db":
+				await dbCommand(effectiveSubcommand, args);
+				break;
+			case "dev":
+				await devCommand(args);
+				break;
+			case "build":
+				await buildCommand();
+				break;
+			case "start":
+				await startCommand();
+				break;
+			case "auth":
+				await authCommand(effectiveSubcommand, args);
+				break;
+			case "doctor":
+				await doctorCommand(args);
+				break;
+			case "skills":
+				await skillsCommand(effectiveSubcommand, args);
+				break;
+			default:
+				console.log(chalk.default.red(`Unknown command: ${command}`));
+				console.log("");
+				printHelp();
+		}
+	}
+	function printHelp() {
+		console.log(`
+${chalk.default.bold("Rebase CLI")} — Developer tools for Rebase projects
+
+${chalk.default.green.bold("Usage")}
+  rebase ${chalk.default.blue("<command>")} [options]
 
-${chalk.green.bold("Commands")}
-  ${chalk.blue.bold("init")}                    Create a new Rebase project
-  ${chalk.blue.bold("dev")}                     Start the development server
-  ${chalk.blue.bold("build")}                   Build all workspace packages
-  ${chalk.blue.bold("start")}                   Start the backend server ${chalk.gray("(production)")}
+${chalk.default.green.bold("Commands")}
+  ${chalk.default.blue.bold("init")}                    Create a new Rebase project
+  ${chalk.default.blue.bold("dev")}                     Start the development server
+  ${chalk.default.blue.bold("build")}                   Build all workspace packages
+  ${chalk.default.blue.bold("start")}                   Start the backend server ${chalk.default.gray("(production)")}
 
-${chalk.green.bold("Schema")}
-  ${chalk.blue.bold("schema generate")}         Generate Drizzle schema from collections
-  ${chalk.blue.bold("schema introspect")}       Introspect database → Rebase collections
-  ${chalk.blue.bold("schema")} ${chalk.gray("--help")}           Show schema command help
+${chalk.default.green.bold("Schema")}
+  ${chalk.default.blue.bold("schema generate")}         Generate Drizzle schema from collections
+  ${chalk.default.blue.bold("schema introspect")}       Introspect database → Rebase collections
+  ${chalk.default.blue.bold("schema")} ${chalk.default.gray("--help")}           Show schema command help
 
-${chalk.green.bold("Database")}
-  ${chalk.blue.bold("db push")}                 Apply schema directly to database ${chalk.gray("(dev)")}
-  ${chalk.blue.bold("db generate")}             Generate SQL migration files
-  ${chalk.blue.bold("db migrate")}              Run pending migrations
-  ${chalk.blue.bold("db studio")}               Open Drizzle Studio
-  ${chalk.blue.bold("db")} ${chalk.gray("--help")}               Show database command help
+${chalk.default.green.bold("Database")}
+  ${chalk.default.blue.bold("db push")}                 Apply schema directly to database ${chalk.default.gray("(dev)")}
+  ${chalk.default.blue.bold("db generate")}             Generate SQL migration files
+  ${chalk.default.blue.bold("db migrate")}              Run pending migrations
+  ${chalk.default.blue.bold("db studio")}               Open Drizzle Studio
+  ${chalk.default.blue.bold("db")} ${chalk.default.gray("--help")}               Show database command help
 
-${chalk.green.bold("SDK")}
-  ${chalk.blue.bold("generate-sdk")}            Generate a typed JS SDK from collections
+${chalk.default.green.bold("SDK")}
+  ${chalk.default.blue.bold("generate-sdk")}            Generate a typed JS SDK from collections
 
-${chalk.green.bold("Auth")}
-  ${chalk.blue.bold("auth reset-password")}     Reset a user's password
-  ${chalk.blue.bold("auth")} ${chalk.gray("--help")}              Show auth command help
+${chalk.default.green.bold("Auth")}
+  ${chalk.default.blue.bold("auth reset-password")}     Reset a user's password
+  ${chalk.default.blue.bold("auth")} ${chalk.default.gray("--help")}              Show auth command help
 
-${chalk.green.bold("Diagnostics")}
-  ${chalk.blue.bold("doctor")}                  Detect schema drift between collections, schema, and DB
+${chalk.default.green.bold("Diagnostics")}
+  ${chalk.default.blue.bold("doctor")}                  Detect schema drift between collections, schema, and DB
 
-${chalk.green.bold("Options")}
-  ${chalk.blue("--version, -v")}   Show version number
-  ${chalk.blue("--help, -h")}      Show this help message
+${chalk.default.green.bold("AI Agent Skills")}
+  ${chalk.default.blue.bold("skills install")}           Install Rebase agent skills for your AI coding assistant
 
-${chalk.gray("Documentation: https://rebase.pro/docs")}
+${chalk.default.green.bold("Options")}
+  ${chalk.default.blue("--version, -v")}   Show version number
+  ${chalk.default.blue("--help, -h")}      Show this help message
+
+${chalk.default.gray("Documentation: https://rebase.pro/docs")}
 `);
-  }
-  exports2.authCommand = authCommand;
-  exports2.buildCommand = buildCommand;
-  exports2.configureEnvFile = configureEnvFile;
-  exports2.createRebaseApp = createRebaseApp;
-  exports2.dbCommand = dbCommand;
-  exports2.detectPackageManager = detectPackageManager;
-  exports2.devCommand = devCommand;
-  exports2.doctorCommand = doctorCommand;
-  exports2.entry = entry;
-  exports2.findBackendDir = findBackendDir;
-  exports2.findEnvFile = findEnvFile;
-  exports2.findFrontendDir = findFrontendDir;
-  exports2.findProjectRoot = findProjectRoot;
-  exports2.generateSdkCommand = generateSdkCommand;
-  exports2.getActiveBackendPlugin = getActiveBackendPlugin;
-  exports2.getPMCommands = getPMCommands;
-  exports2.requireBackendDir = requireBackendDir;
-  exports2.requireProjectRoot = requireProjectRoot;
-  exports2.resolveLocalBin = resolveLocalBin;
-  exports2.resolvePluginCliScript = resolvePluginCliScript;
-  exports2.resolveTsx = resolveTsx;
-  exports2.schemaCommand = schemaCommand;
-  exports2.startCommand = startCommand;
-  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
-}));
-//# sourceMappingURL=index.cjs.map
+	}
+	//#endregion
+	exports.authCommand = authCommand;
+	exports.buildCommand = buildCommand;
+	exports.configureEnvFile = configureEnvFile;
+	exports.createRebaseApp = createRebaseApp;
+	exports.dbCommand = dbCommand;
+	exports.detectPackageManager = detectPackageManager;
+	exports.devCommand = devCommand;
+	exports.doctorCommand = doctorCommand;
+	exports.entry = entry;
+	exports.findBackendDir = findBackendDir;
+	exports.findEnvFile = findEnvFile;
+	exports.findFrontendDir = findFrontendDir;
+	exports.findProjectRoot = findProjectRoot;
+	exports.generateSdkCommand = generateSdkCommand;
+	exports.getActiveBackendPlugin = getActiveBackendPlugin;
+	exports.getPMCommands = getPMCommands;
+	exports.requireBackendDir = requireBackendDir;
+	exports.requireProjectRoot = requireProjectRoot;
+	exports.resolveLocalBin = resolveLocalBin;
+	exports.resolvePluginCliScript = resolvePluginCliScript;
+	exports.resolveTsx = resolveTsx;
+	exports.schemaCommand = schemaCommand;
+	exports.startCommand = startCommand;
+});
+
+//# sourceMappingURL=index.cjs.map