@rebasepro/cli 0.4.0 → 0.6.0

package/dist/index.es.js

@@ -11,711 +11,863 @@ import { fileURLToPath } from "url";
 import crypto from "crypto";
 import { generateSDK } from "@rebasepro/sdk-generator";
 import { execSync, spawn } from "child_process";
+//#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.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";
+	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";
 }
+/** 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],
-      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:*"
-  };
+	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:*"
+	};
 }
-const access = promisify(fs.access);
-const __filename$2 = fileURLToPath(import.meta.url);
-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;
+//#endregion
+//#region src/commands/init.ts
+var access = promisify(fs.access);
+var __filename$2 = fileURLToPath(import.meta.url);
+var __dirname$2 = path.dirname(__filename$2);
+function findParentDir$1(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");
+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(`
+	console.log(`
 ${chalk.bold("Rebase")} — Create a new project 🚀
 `);
-  const pm = detectPackageManager();
-  const options = await promptForOptions(rawArgs, pm);
-  await createProject(options);
+	await createProject(await promptForOptions(rawArgs, detectPackageManager()));
 }
 async function promptForOptions(rawArgs, pm) {
-  const args = arg(
-    {
-      "--git": Boolean,
-      "--install": Boolean,
-      "--database-url": String,
-      "--introspect": Boolean,
-      "--yes": Boolean,
-      "-g": "--git",
-      "-i": "--install",
-      "-y": "--yes"
-    },
-    {
-      argv: rawArgs.slice(3),
-      // skip "node", "rebase", "init"
-      permissive: true
-    }
-  );
-  const nameArg = args._[0];
-  const isNonInteractive = args["--yes"] || false;
-  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,
-      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 (!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,
-    pm,
-    pmCommands
-  };
+	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),
+		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 projectName = nameArg || "my-rebase-app";
+		const targetDirectory = path.resolve(process.cwd(), projectName);
+		const templateDirectory = path.resolve(cliRoot, "templates", "template");
+		const pmCommands = getPMCommands(pm);
+		return {
+			projectName: path.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.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 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 replacePlaceholders(options);
-  await configureEnvFile(options.targetDirectory, options.databaseUrl);
-  if (options.git) {
-    console.log(chalk.gray("  Initializing git repository..."));
-    try {
-      await 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(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(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("");
+	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 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("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(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(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("");
+	console.log(chalk.bold("🤖 AI Agent Skills"));
+	console.log("");
+	console.log(chalk.gray("  Install Rebase agent skills for your AI coding assistant:"));
+	console.log("");
+	console.log(`  ${chalk.cyan("rebase skills install")}  ${chalk.gray("or")}  ${chalk.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.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;
+		}
+		for (const file of [
+			"posts.ts",
+			"authors.ts",
+			"tags.ts",
+			"index.ts"
+		]) {
+			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(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(viewBin, ["view", `${pkgName}@${tag}`, "version"]);
-        if (!stdout.trim()) throw new Error("Not found");
-        versionToUse = stdout.trim();
-      } catch {
-        try {
-          const { stdout } = await 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");
-  }
+	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)) cliVersion = JSON.parse(fs.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 execa(viewBin, [
+				"view",
+				`${pkgName}@${cliVersion}`,
+				"version"
+			]);
+			if (!stdout.trim()) throw new Error("Not found");
+			versionToUse = stdout.trim();
+		} catch {
+			try {
+				const { stdout } = await 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 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);
-  });
+	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;
+	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");
-  }
+	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\nDATABASE_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");
+	}
 }
+//#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.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.`
-  );
+	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 {
+		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.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 mod = jitiInstance(path.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.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.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");
-  }
+	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");
+	}
 }
+/**
+* Main entry point for the generate-sdk command.
+*/
 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 = 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("");
+	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 = 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("");
 }
+//#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.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;
+	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)) {
+					if (pkg.workspaces.some((w) => w === "backend" || w.includes("backend"))) return dir;
+				}
+			} catch {}
+			if (fs.existsSync(path.join(dir, "backend")) && fs.existsSync(path.join(dir, "config"))) return dir;
+		}
+		dir = path.dirname(dir);
+	}
+	return null;
 }
+/**
+* Locate the backend directory within the project root.
+*/
 function findBackendDir(projectRoot) {
-  const backendDir = path.join(projectRoot, "backend");
-  return fs.existsSync(backendDir) ? backendDir : null;
+	const backendDir = path.join(projectRoot, "backend");
+	return fs.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.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;
+	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;
 }
+/**
+* Resolve the active plugin's CLI script.
+*/
 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;
+	const candidates = [
+		path.join(backendDir, "node_modules", pluginName, "src", "cli.ts"),
+		path.join(backendDir, "node_modules", pluginName, "dist", "cli.js"),
+		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;
 }
+/**
+* Locate the frontend directory within the project root.
+*/
 function findFrontendDir(projectRoot) {
-  const frontendDir = path.join(projectRoot, "frontend");
-  return fs.existsSync(frontendDir) ? frontendDir : null;
+	const frontendDir = path.join(projectRoot, "frontend");
+	return fs.existsSync(frontendDir) ? frontendDir : null;
 }
+/**
+* Find the .env file. Checks the project root first, then backend.
+*/
 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;
+	const candidates = [path.join(projectRoot, ".env"), path.join(projectRoot, "backend", ".env")];
+	for (const candidate of candidates) if (fs.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.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 = execSync(`which ${binName}`, { encoding: "utf-8" }).trim();
-    if (globalPath && fs.existsSync(globalPath)) return globalPath;
-  } catch {
-  }
-  return null;
+	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 = execSync(`which ${binName}`, { encoding: "utf-8" }).trim();
+		if (globalPath && fs.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");
+	return resolveLocalBin(projectRoot, "tsx");
 }
+/**
+* Require the project root or exit with a helpful error.
+*/
 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;
+	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;
 }
+/**
+* Require the backend directory or exit with a helpful error.
+*/
 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;
+	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;
 }
+//#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.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(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
-        cwd: backendDir,
-        stdio: "inherit",
-        env
-      });
-    } else {
-      await execa("node", [pluginCli, ...rawArgs.slice(2)], {
-        cwd: backendDir,
-        stdio: "inherit",
-        env
-      });
-    }
-  } catch {
-    process.exit(1);
-  }
+	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 {
+		if (pluginCli.endsWith(".ts")) {
+			const tsxBin = resolveTsx(projectRoot);
+			if (!tsxBin) {
+				console.error(chalk.red("✗ Could not find tsx binary."));
+				process.exit(1);
+			}
+			await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+				cwd: backendDir,
+				stdio: "inherit",
+				env
+			});
+		} else await execa("node", [pluginCli, ...rawArgs.slice(2)], {
+			cwd: backendDir,
+			stdio: "inherit",
+			env
+		});
+	} catch {
+		process.exit(1);
+	}
 }
 function printSchemaHelp() {
-  console.log(`
+	console.log(`
 ${chalk.bold("rebase schema")} — Schema management commands
 
 ${chalk.green.bold("Usage")}
@@ -735,55 +887,55 @@ ${chalk.green.bold("introspect Options")}
   ${chalk.blue("--output, -o")}       Output directory for generated collection files
 `);
 }
+//#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.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(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
-        cwd: backendDir,
-        stdio: "inherit",
-        env
-      });
-    } else {
-      await execa("node", [pluginCli, ...rawArgs.slice(2)], {
-        cwd: backendDir,
-        stdio: "inherit",
-        env
-      });
-    }
-  } catch {
-    process.exit(1);
-  }
+	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 {
+		if (pluginCli.endsWith(".ts")) {
+			const tsxBin = resolveTsx(projectRoot);
+			if (!tsxBin) {
+				console.error(chalk.red("✗ Could not find tsx binary."));
+				process.exit(1);
+			}
+			await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+				cwd: backendDir,
+				stdio: "inherit",
+				env
+			});
+		} else await execa("node", [pluginCli, ...rawArgs.slice(2)], {
+			cwd: backendDir,
+			stdio: "inherit",
+			env
+		});
+	} catch {
+		process.exit(1);
+	}
 }
 function printDbHelp() {
-  console.log(`
+	console.log(`
 ${chalk.bold("rebase db")} — Database management commands
 
 ${chalk.green.bold("Usage")}
@@ -809,300 +961,337 @@ ${chalk.green.bold("Examples")}
   rebase db branch create feature_auth
 `);
 }
-const DEV_PORT_FILENAME = ".rebase-dev-port";
+//#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;
+	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.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);
+	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") {
-            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(
-      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(tsxBin, [pluginCli, "schema", "generate"], {
-            cwd: backendDir,
-            stdio: "inherit",
-            env
-          });
-        }
-        await 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(tsxBin, [pluginCli, "schema", "generate"], {
-                  cwd: backendDir,
-                  stdio: "inherit",
-                  env
-                });
-              }
-              await 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(
-      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());
-      })
-    )
-  );
+	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),
+		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;
+	/** 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.cyan("┌────────────────────────────────────────────────────────────┐"));
+			console.log(chalk.cyan("│                                                            │"));
+			console.log(chalk.cyan("│   ✦ Rebase Admin App is ready!                             │"));
+			const paddedUrl = stripAnsi(frontendUrl).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") 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.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 runDevCmd = getPMCommands(detectPackageManager(projectRoot)).run("dev");
+		const frontendChild = 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.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.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.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))}`);
+		/** Whether the frontend has been launched (we only launch it once). */
+		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(tsxBin, [
+					pluginCli,
+					"schema",
+					"generate"
+				], {
+					cwd: backendDir,
+					stdio: "inherit",
+					env
+				});
+				const sdkCmd = getPMCommands(detectPackageManager(projectRoot)).exec("rebase", ["generate-sdk"]);
+				await execa(sdkCmd[0], sdkCmd.slice(1), {
+					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}\n`));
+			}
+			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(`\n  🔄 Collection change detected (${filename}). Regenerating schema & SDK...`));
+						try {
+							const activePlugin = getActiveBackendPlugin(backendDir);
+							const pluginCli = activePlugin ? resolvePluginCliScript(backendDir, activePlugin) : null;
+							if (pluginCli) await execa(tsxBin, [
+								pluginCli,
+								"schema",
+								"generate"
+							], {
+								cwd: backendDir,
+								stdio: "inherit",
+								env
+							});
+							const sdkCmd = getPMCommands(detectPackageManager(projectRoot)).exec("rebase", ["generate-sdk"]);
+							await execa(sdkCmd[0], sdkCmd.slice(1), {
+								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 collectionsDir = path.join(projectRoot, "config", "collections");
+			if (fs.existsSync(collectionsDir)) {
+				let driftDebounce = null;
+				fs.watch(collectionsDir, { recursive: true }, (_eventType, filename) => {
+					if (!filename || filename.startsWith(".") || filename.endsWith(".tmp")) return;
+					if (driftDebounce) clearTimeout(driftDebounce);
+					driftDebounce = setTimeout(() => {
+						console.log([
+							"",
+							chalk.yellow("  ┌──────────────────────────────────────────────────────────────┐"),
+							chalk.yellow("  │  ⚠️  Collection file changed: ") + chalk.white(filename.padEnd(31)) + chalk.yellow("│"),
+							chalk.yellow("  │                                                              │"),
+							chalk.yellow("  │  Your schema may be out of sync. Run:                        │"),
+							chalk.yellow("  │    ") + chalk.cyan("rebase schema generate") + chalk.yellow("   regenerate Drizzle schema        │"),
+							chalk.yellow("  │    ") + chalk.cyan("rebase db push        ") + chalk.yellow("   sync schema to database          │"),
+							chalk.yellow("  │    ") + chalk.cyan("rebase doctor         ") + chalk.yellow("   check for drift                  │"),
+							chalk.yellow("  │                                                              │"),
+							chalk.yellow("  │  TIP: Use ") + chalk.bold("rebase dev --generate") + chalk.yellow(" for auto-regeneration        │"),
+							chalk.yellow("  └──────────────────────────────────────────────────────────────┘"),
+							""
+						].join("\n"));
+					}, 500);
+				});
+			}
+		}
+		const backendChild = 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.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.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) => {
+			data.toString().split("\n").filter(Boolean).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(`
+	console.log(`
 ${chalk.bold("rebase dev")} — Start the development server
 
 ${chalk.green.bold("Usage")}
@@ -1131,101 +1320,114 @@ ${chalk.green.bold("Description")}
   in your environment to enable it.
 `);
 }
+//#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 cmds = getPMCommands(pm);
-  const buildCmd = cmds.runAll("build");
-  console.log(`${chalk.bold("Rebase")} — Building all workspaces with ${chalk.cyan(pm)}...
-`);
-  try {
-    await execa(buildCmd[0], buildCmd.slice(1), {
-      cwd: projectRoot,
-      stdio: "inherit"
-    });
-  } catch {
-    console.error(chalk.red("\n✗ Build failed."));
-    process.exit(1);
-  }
+	const projectRoot = requireProjectRoot();
+	const pm = detectPackageManager(projectRoot);
+	const buildCmd = getPMCommands(pm).runAll("build");
+	console.log(`${chalk.bold("Rebase")} — Building all workspaces with ${chalk.cyan(pm)}...\n`);
+	try {
+		await execa(buildCmd[0], buildCmd.slice(1), {
+			cwd: projectRoot,
+			stdio: "inherit"
+		});
+	} catch {
+		console.error(chalk.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 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(startCmd[0], startCmd.slice(1), {
-      cwd: projectRoot,
-      stdio: "inherit",
-      env
-    });
-  } catch {
-    console.error(chalk.red("\n✗ Failed to start server."));
-    process.exit(1);
-  }
+	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.bold("Rebase")} — Starting backend server...\n`);
+	try {
+		await execa(startCmd[0], startCmd.slice(1), {
+			cwd: projectRoot,
+			stdio: "inherit",
+			env
+		});
+	} catch {
+		console.error(chalk.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.red(`Unknown auth command: ${subcommand}`));
-      console.log("");
-      printAuthHelp();
-      process.exit(1);
-  }
+	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 = `
+	const args = arg({
+		"--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.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 = `
 import { createPostgresDatabaseConnection } from "@rebasepro/server-postgresql";
 import { hashPassword } from "@rebasepro/server-core";
 import { eq } from "drizzle-orm";
@@ -1270,7 +1472,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);
     }
@@ -1279,36 +1481,31 @@ 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 = 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();
-    });
-  });
+	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 = 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(`
+	console.log(`
 ${chalk.bold("rebase auth")} — Authentication management commands
 
 ${chalk.green.bold("Usage")}
@@ -1326,139 +1523,324 @@ ${chalk.green.bold("Examples")}
   rebase auth reset-password --email user@example.com --password MyNewPass!
 `);
 }
+//#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.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(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
-        cwd: backendDir,
-        stdio: "inherit",
-        env
-      });
-    } else {
-      await execa("node", [pluginCli, ...rawArgs.slice(2)], {
-        cwd: backendDir,
-        stdio: "inherit",
-        env
-      });
-    }
-  } catch {
-    process.exit(1);
-  }
+	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 {
+		if (pluginCli.endsWith(".ts")) {
+			const tsxBin = resolveTsx(projectRoot);
+			if (!tsxBin) {
+				console.error(chalk.red("✗ Could not find tsx binary."));
+				process.exit(1);
+			}
+			await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
+				cwd: backendDir,
+				stdio: "inherit",
+				env
+			});
+		} else await execa("node", [pluginCli, ...rawArgs.slice(2)], {
+			cwd: backendDir,
+			stdio: "inherit",
+			env
+		});
+	} catch {
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/commands/skills.ts
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = path.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.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.join(skillName, "SKILL.md"),
+			content
+		})
+	}
+};
+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 __filename$1 = fileURLToPath(import.meta.url);
-const __dirname$1 = path.dirname(__filename$1);
+/** Resolve the path to the bundled skills directory. */
+function getSkillsSourceDir() {
+	const cliRoot = findParentDir(__dirname$1, "cli");
+	if (cliRoot) {
+		const dir = path.join(cliRoot, "skills");
+		if (fs.existsSync(dir)) return dir;
+	}
+	const distSkills = path.resolve(__dirname$1, "../../skills");
+	if (fs.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.readdirSync(skillsDir, { withFileTypes: true });
+	const skills = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const skillMdPath = path.join(skillsDir, entry.name, "SKILL.md");
+		if (!fs.existsSync(skillMdPath)) continue;
+		skills.push({
+			name: entry.name,
+			content: fs.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.existsSync(path.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.join(projectDir, agent.targetDir);
+	fs.mkdirSync(targetBase, { recursive: true });
+	let count = 0;
+	for (const skill of skills) {
+		const { fileName, content } = agent.transformFile(skill.name, skill.content);
+		const targetPath = path.join(targetBase, fileName);
+		fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+		fs.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.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.red.bold("ERROR")} ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+	const skills = loadSkills(skillsDir);
+	if (skills.length === 0) {
+		console.error(`${chalk.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.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.gray(`  Found ${chalk.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.green("✓")} ${chalk.bold(agent.label)} — ${count} skills installed to ${chalk.gray(agent.targetDir)}`);
+	}
+	console.log("");
+	console.log(chalk.gray("  Skills are project-local. Commit them to share with your team."));
+	console.log(chalk.gray("  Re-run this command anytime to update to the latest skills."));
+	console.log("");
+}
+function printSkillsHelp() {
+	console.log(`
+${chalk.bold("rebase skills")} — Manage AI agent skills
+
+${chalk.green.bold("Usage")}
+  rebase skills ${chalk.blue("<subcommand>")}
+
+${chalk.green.bold("Subcommands")}
+  ${chalk.blue.bold("install")}    Install Rebase agent skills for your AI coding assistant
+               Supports: Cursor, Claude Code, Windsurf, Gemini CLI, Antigravity
+
+${chalk.green.bold("Examples")}
+  ${chalk.cyan("rebase skills install")}
+`);
+}
+//#endregion
+//#region src/cli.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
 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";
+	try {
+		const pkgPath = path.resolve(__dirname, "../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();
-  }
+	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];
+	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 = 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;
+		case "skills":
+			await skillsCommand(effectiveSubcommand, args);
+			break;
+		default:
+			console.log(chalk.red(`Unknown command: ${command}`));
+			console.log("");
+			printHelp();
+	}
 }
 function printHelp() {
-  console.log(`
+	console.log(`
 ${chalk.bold("Rebase CLI")} — Developer tools for Rebase projects
 
 ${chalk.green.bold("Usage")}
@@ -1492,6 +1874,9 @@ ${chalk.green.bold("Auth")}
 ${chalk.green.bold("Diagnostics")}
   ${chalk.blue.bold("doctor")}                  Detect schema drift between collections, schema, and DB
 
+${chalk.green.bold("AI Agent Skills")}
+  ${chalk.blue.bold("skills install")}           Install Rebase agent skills for your AI coding assistant
+
 ${chalk.green.bold("Options")}
   ${chalk.blue("--version, -v")}   Show version number
   ${chalk.blue("--help, -h")}      Show this help message
@@ -1499,29 +1884,7 @@ ${chalk.green.bold("Options")}
 ${chalk.gray("Documentation: https://rebase.pro/docs")}
 `);
 }
-export {
-  authCommand,
-  buildCommand,
-  configureEnvFile,
-  createRebaseApp,
-  dbCommand,
-  detectPackageManager,
-  devCommand,
-  doctorCommand,
-  entry,
-  findBackendDir,
-  findEnvFile,
-  findFrontendDir,
-  findProjectRoot,
-  generateSdkCommand,
-  getActiveBackendPlugin,
-  getPMCommands,
-  requireBackendDir,
-  requireProjectRoot,
-  resolveLocalBin,
-  resolvePluginCliScript,
-  resolveTsx,
-  schemaCommand,
-  startCommand
-};
-//# sourceMappingURL=index.es.js.map
+//#endregion
+export { authCommand, buildCommand, configureEnvFile, createRebaseApp, dbCommand, detectPackageManager, devCommand, doctorCommand, entry, findBackendDir, findEnvFile, findFrontendDir, findProjectRoot, generateSdkCommand, getActiveBackendPlugin, getPMCommands, requireBackendDir, requireProjectRoot, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand };
+
+//# sourceMappingURL=index.es.js.map