@rebasepro/cli 0.0.1-canary.4d4fb3e → 0.0.1-canary.5584634

package/dist/commands/cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/dev.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctorCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/generate_sdk.d.ts

@@ -1,7 +1,7 @@
 /**
  * CLI command: generate-sdk
  *
- * Reads collection definitions from a specified directory (default: ./shared/collections),
+ * 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.

package/dist/commands/init.d.ts

@@ -4,5 +4,7 @@ export interface InitOptions {
     installDeps: boolean;
     targetDirectory: string;
     templateDirectory: string;
+    databaseUrl?: string;
+    introspect?: boolean;
 }
 export declare function createRebaseApp(rawArgs: string[]): Promise<void>;

package/dist/commands/init.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.cjs

@@ -89,16 +89,31 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
         default: true
       });
     }
+    questions.push({
+      type: "input",
+      name: "databaseUrl",
+      message: "Enter your PostgreSQL database connection string (leave blank to use a local default):",
+      default: ""
+    });
+    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 projectName = nameArg || answers.projectName;
-    const targetDirectory = path.resolve(process.cwd(), projectName);
+    const targetDirectory = path.resolve(process.cwd(), nameArg || answers.projectName);
+    const projectName = path.basename(targetDirectory);
     const templateDirectory = path.resolve(cliRoot, "templates", "template");
     return {
       projectName,
       git: args["--git"] || answers.git || false,
       installDeps: args["--install"] || answers.installDeps || false,
       targetDirectory,
-      templateDirectory
+      templateDirectory,
+      databaseUrl: answers.databaseUrl?.trim() || void 0,
+      introspect: answers.introspect || false
     };
   }
   async function createProject(options) {
@@ -136,20 +151,27 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
     if (fs.existsSync(envTemplatePath) && !fs.existsSync(envPath)) {
       fs.renameSync(envTemplatePath, 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(
-        "postgresql://rebase:password@localhost:5432/rebase",
-        `postgresql://rebase:${dbPassword}@localhost:5432/rebase`
-      );
       envContent = envContent.replace(
         "change-this-to-a-secure-random-string",
         jwtSecret
       );
-      envContent += `
+      if (options.databaseUrl) {
+        envContent = envContent.replace(
+          "postgresql://rebase:password@localhost:5432/rebase",
+          options.databaseUrl
+        );
+      } else {
+        const dbPassword = crypto.randomBytes(16).toString("hex");
+        envContent = envContent.replace(
+          "postgresql://rebase:password@localhost:5432/rebase",
+          `postgresql://rebase:${dbPassword}@localhost:5432/rebase`
+        );
+        envContent += `
 # Docker Compose Database Password
 POSTGRES_PASSWORD=${dbPassword}
 `;
+      }
       fs.writeFileSync(envPath, envContent, "utf-8");
     }
     if (options.git) {
@@ -173,6 +195,26 @@ POSTGRES_PASSWORD=${dbPassword}
         console.warn(chalk.yellow("  Warning: Failed to install dependencies. You may need to run `pnpm install` manually."));
       }
     }
+    if (options.introspect) {
+      console.log("");
+      if (options.installDeps) {
+        console.log(chalk.gray("  Introspecting database and generating collections..."));
+        console.log("");
+        try {
+          await execa("pnpm", ["exec", "rebase", "schema", "introspect"], {
+            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 `pnpm exec rebase schema introspect` manually after setup."));
+        }
+      } else {
+        console.warn(chalk.yellow("  Skipping introspection because dependencies were not installed."));
+        console.warn(chalk.yellow("  Run `pnpm install` then `pnpm exec rebase schema introspect` manually."));
+      }
+    }
     console.log("");
     console.log(`${chalk.green.bold("✓")} Project ${chalk.bold(options.projectName)} created successfully!`);
     console.log("");
@@ -183,12 +225,19 @@ POSTGRES_PASSWORD=${dbPassword}
       console.log(`  ${chalk.cyan("pnpm install")}`);
     }
     console.log("");
-    console.log(chalk.gray("  # Set up your database connection in .env"));
-    console.log(chalk.gray("  # Then run:"));
+    if (options.databaseUrl) {
+      console.log(chalk.gray("  # Your database is configured! Start the dev server:"));
+    } else {
+      console.log(chalk.gray("  # A local database configuration has been generated in .env"));
+      console.log(chalk.gray("  # If using the included docker-compose.yml, start it with:"));
+      console.log(`  ${chalk.cyan("docker compose up -d")}`);
+      console.log("");
+      console.log(chalk.gray("  # Then start the dev server:"));
+    }
     console.log("");
     console.log(`  ${chalk.cyan("pnpm dev")}`);
     console.log("");
-    console.log(chalk.gray("This starts both the backend (Express + PostgreSQL)") + chalk.gray(" and the frontend (Vite + React) concurrently."));
+    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"));
@@ -199,14 +248,63 @@ POSTGRES_PASSWORD=${dbPassword}
       "package.json",
       "frontend/package.json",
       "backend/package.json",
-      "shared/package.json",
+      "config/package.json",
       "frontend/index.html"
     ];
+    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 getPackageVersion = async (pkgName) => {
+      if (versionCache.has(pkgName)) return versionCache.get(pkgName);
+      let versionToUse = cliVersion;
+      try {
+        const { stdout } = await execa("npm", ["--loglevel", "error", "info", `${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("npm", ["--loglevel", "error", "info", `${pkgName}@${tag}`, "version"]);
+          if (!stdout.trim()) throw new Error("Not found");
+          versionToUse = stdout.trim();
+        } catch {
+          try {
+            const { stdout } = await execa("npm", ["--loglevel", "error", "info", 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;
-      let content = fs.readFileSync(fullPath, "utf-8");
-      content = content.replace(/\{\{PROJECT_NAME\}\}/g, options.projectName);
+      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");
     }
   }
@@ -318,7 +416,7 @@ Expected a default export of EntityCollection[] or an object with named collecti
     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 { 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>({"));
@@ -345,7 +443,7 @@ Expected a default export of EntityCollection[] or an object with named collecti
           }
         } catch {
         }
-        if (fs.existsSync(path.join(dir, "backend")) && fs.existsSync(path.join(dir, "shared"))) {
+        if (fs.existsSync(path.join(dir, "backend")) && fs.existsSync(path.join(dir, "config"))) {
           return dir;
         }
       }
@@ -362,7 +460,10 @@ Expected a default export of EntityCollection[] or an object with named collecti
     if (!fs.existsSync(pkgPath)) return null;
     try {
       const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      const deps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
       for (const dep of Object.keys(deps)) {
         if (dep.startsWith("@rebasepro/server-") && dep !== "@rebasepro/server-core") {
           return dep;
@@ -377,6 +478,7 @@ Expected a default export of EntityCollection[] or an object with named collecti
       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")
     ];
@@ -473,13 +575,13 @@ Expected a default export of EntityCollection[] or an object with named collecti
           console.error(chalk.red("✗ Could not find tsx binary."));
           process.exit(1);
         }
-        await execa(tsxBin, [pluginCli, "schema", subcommand, ...rawArgs.slice(2)], {
+        await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
           cwd: backendDir,
           stdio: "inherit",
           env
         });
       } else {
-        await execa("node", [pluginCli, "schema", subcommand, ...rawArgs.slice(2)], {
+        await execa("node", [pluginCli, ...rawArgs.slice(2)], {
           cwd: backendDir,
           stdio: "inherit",
           env
@@ -499,11 +601,15 @@ ${chalk.green.bold("Usage")}
 ${chalk.green.bold("Commands")}
   ${chalk.gray("(Commands are provided by your active database driver plugin)")}
   ${chalk.blue.bold("generate")}    Generate Schema from collection definitions
+  ${chalk.blue.bold("introspect")}  Introspect an existing database to generate collection definitions
 
 ${chalk.green.bold("generate Options")}
   ${chalk.blue("--collections, -c")}  Path to collections directory
   ${chalk.blue("--output, -o")}       Output path for generated schema
   ${chalk.blue("--watch, -w")}        Watch for changes and regenerate automatically
+
+${chalk.green.bold("introspect Options")}
+  ${chalk.blue("--output, -o")}       Output directory for generated collection files
 `);
   }
   async function dbCommand(subcommand, rawArgs) {
@@ -537,13 +643,13 @@ ${chalk.green.bold("generate Options")}
           console.error(chalk.red("✗ Could not find tsx binary."));
           process.exit(1);
         }
-        await execa(tsxBin, [pluginCli, "db", subcommand, ...rawArgs.slice(2)], {
+        await execa(tsxBin, [pluginCli, ...rawArgs.slice(2)], {
           cwd: backendDir,
           stdio: "inherit",
           env
         });
       } else {
-        await execa("node", [pluginCli, "db", subcommand, ...rawArgs.slice(2)], {
+        await execa("node", [pluginCli, ...rawArgs.slice(2)], {
           cwd: backendDir,
           stdio: "inherit",
           env
@@ -581,6 +687,27 @@ ${chalk.green.bold("Examples")}
   rebase db branch create feature_auth
 `);
   }
+  const DEV_PORT_FILENAME = ".rebase-dev-port";
+  function getProjectPort(projectRoot) {
+    let hash = 0;
+    for (let i = 0; i < projectRoot.length; i++) {
+      hash = (hash << 5) - hash + projectRoot.charCodeAt(i) | 0;
+    }
+    return 3001 + Math.abs(hash) % 999;
+  }
+  function resolveStartPort(projectRoot, explicitPort) {
+    if (explicitPort) return explicitPort;
+    if (process.env.PORT) return parseInt(process.env.PORT, 10);
+    try {
+      const portFile = path.join(projectRoot, DEV_PORT_FILENAME);
+      if (fs.existsSync(portFile)) {
+        const saved = parseInt(fs.readFileSync(portFile, "utf-8").trim(), 10);
+        if (saved > 0 && saved < 65536) return saved;
+      }
+    } catch {
+    }
+    return getProjectPort(projectRoot);
+  }
   async function devCommand(rawArgs) {
     const args = arg(
       {
@@ -608,6 +735,7 @@ ${chalk.green.bold("Examples")}
     const frontendDir = findFrontendDir(projectRoot);
     const backendOnly = args["--backend-only"] || false;
     const frontendOnly = args["--frontend-only"] || false;
+    const startPort = resolveStartPort(projectRoot, args["--port"]);
     console.log("");
     console.log(chalk.bold("  🚀 Rebase Dev Server"));
     console.log("");
@@ -616,6 +744,7 @@ ${chalk.green.bold("Examples")}
     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;
@@ -628,7 +757,7 @@ ${chalk.green.bold("Examples")}
         console.log(chalk.cyan("│   ✨ Rebase Admin App is ready!                            │"));
         const cleanUrl = stripAnsi(frontendUrl);
         const paddedUrl = cleanUrl.padEnd(40);
-        console.log(chalk.cyan(`│   👉 Frontend URL: `) + chalk.white(paddedUrl) + chalk.cyan(`│`));
+        console.log(chalk.cyan("│   👉 Frontend URL: ") + chalk.white(paddedUrl) + chalk.cyan("│"));
         console.log(chalk.cyan("│                                                            │"));
         console.log(chalk.cyan("└────────────────────────────────────────────────────────────┘"));
         console.log("");
@@ -636,15 +765,74 @@ ${chalk.green.bold("Examples")}
       }, 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.killed) {
-          child.kill("SIGTERM");
+        if (child.pid && !child.killed) {
+          try {
+            if (process.platform === "win32") {
+              execa.commandSync(`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 frontendChild = execa(
+        "pnpm",
+        ["run", "dev"],
+        {
+          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) {
@@ -657,22 +845,19 @@ ${chalk.green.bold("Examples")}
       if (envFile) {
         env.DOTENV_CONFIG_PATH = envFile;
       }
-      if (args["--port"]) {
-        env.PORT = String(args["--port"]);
-      }
-      path.join(backendDir, "src", "index.ts");
-      const watchDirs = [
-        `--watch="${path.join("..", "shared", "**", "*")}"`
-      ];
+      env.PORT = String(startPort);
       console.log(`  ${chalk.cyan("▶")} Backend:  ${chalk.gray(backendDir)}`);
+      console.log(`  ${chalk.gray("↳ PORT")} = ${chalk.white(String(startPort))}`);
+      let frontendLaunched = false;
       const backendChild = execa(
         tsxBin,
-        ["watch", ...watchDirs, "--conditions", "development", "src/index.ts"],
+        ["watch", `--watch="${path.join("..", "config", "**", "*")}"`, "--conditions", "development", "src/index.ts"],
         {
           cwd: backendDir,
           stdio: ["inherit", "pipe", "pipe"],
           env,
-          shell: true
+          shell: true,
+          detached: process.platform !== "win32"
         }
       );
       backendChild.catch(() => {
@@ -682,9 +867,19 @@ ${chalk.green.bold("Examples")}
         lines.forEach((line) => {
           console.log(`${chalk.cyan.bold("[backend]")}  ${line}`);
           const cleanLine = stripAnsi(line);
-          if (cleanLine.includes("Server running at http://")) {
+          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);
+            }
           }
         });
       });
@@ -698,39 +893,8 @@ ${chalk.green.bold("Examples")}
     } else if (!frontendOnly && !backendDir) {
       console.warn(chalk.yellow("  ⚠ No backend/ directory found, skipping backend."));
     }
-    if (!backendOnly && frontendDir) {
-      console.log(`  ${chalk.magenta("▶")} Frontend: ${chalk.gray(frontendDir)}`);
-      const frontendChild = execa(
-        "pnpm",
-        ["run", "dev"],
-        {
-          cwd: frontendDir,
-          stdio: ["inherit", "pipe", "pipe"],
-          env: process.env,
-          shell: true
-        }
-      );
-      frontendChild.catch(() => {
-      });
-      frontendChild.stdout?.on("data", (data) => {
-        const lines = data.toString().split("\n").filter(Boolean);
-        lines.forEach((line) => {
-          console.log(`${chalk.magenta.bold("[frontend]")} ${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("[frontend]")} ${line}`);
-        });
-      });
-      children.push(frontendChild);
+    if (!backendOnly && frontendDir && (frontendOnly || !backendDir)) {
+      startFrontend(null);
     } else if (!backendOnly && !frontendDir) {
       console.warn(chalk.yellow("  ⚠ No frontend/ directory found, skipping frontend."));
     }
@@ -759,11 +923,19 @@ ${chalk.green.bold("Usage")}
 ${chalk.green.bold("Options")}
   ${chalk.blue("--backend-only, -b")}   Only start the backend server
   ${chalk.blue("--frontend-only, -f")}  Only start the frontend server
-  ${chalk.blue("--port, -p")}           Backend port (default: 3001)
+  ${chalk.blue("--port, -p")}           Backend port (default: auto-detected per project)
 
 ${chalk.green.bold("Description")}
-  Starts both the backend (tsx watch + Express) and frontend (Vite)
+  Starts both the backend (tsx watch + Hono) and frontend (Vite)
   dev servers concurrently with color-coded output prefixes.
+
+  Each project automatically receives a unique default port derived
+  from its directory path, preventing collisions when running multiple
+  Rebase instances simultaneously.
+
+  If the assigned port is already in use, the server will automatically
+  try the next available port. The frontend is started only after the
+  backend is ready, and VITE_API_URL is injected automatically.
 `);
   }
   async function authCommand(subcommand, rawArgs) {
@@ -900,6 +1072,49 @@ ${chalk.green.bold("Examples")}
   rebase auth reset-password --email user@example.com --password MyNewPass!
 `);
   }
+  async function doctorCommand(rawArgs) {
+    const projectRoot = requireProjectRoot();
+    const backendDir = requireBackendDir(projectRoot);
+    const activePlugin = getActiveBackendPlugin(backendDir);
+    if (!activePlugin) {
+      console.error(chalk.red("✗ Could not detect an active database plugin."));
+      console.error(chalk.gray("  Make sure a package like @rebasepro/server-postgresql is installed in backend/package.json."));
+      process.exit(1);
+    }
+    const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
+    if (!pluginCli) {
+      console.error(chalk.red(`✗ Could not find CLI entry point for ${activePlugin}.`));
+      process.exit(1);
+    }
+    const envFile = findEnvFile(projectRoot);
+    const env = { ...process.env };
+    if (envFile) {
+      env.DOTENV_CONFIG_PATH = envFile;
+    }
+    try {
+      const isTs = pluginCli.endsWith(".ts");
+      if (isTs) {
+        const tsxBin = resolveTsx(projectRoot);
+        if (!tsxBin) {
+          console.error(chalk.red("✗ Could not find tsx binary."));
+          process.exit(1);
+        }
+        await execa(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 __filename$1 = url.fileURLToPath(typeof document === "undefined" && typeof location === "undefined" ? require("url").pathToFileURL(__filename).href : typeof document === "undefined" ? location.href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href);
   const __dirname$1 = path.dirname(__filename$1);
   function getVersion() {
@@ -931,7 +1146,7 @@ ${chalk.green.bold("Examples")}
     }
     const command = parsedArgs._[0];
     const subcommand = parsedArgs._[1];
-    const namespacedCommands = ["schema", "db", "dev", "auth"];
+    const namespacedCommands = ["schema", "db", "dev", "auth", "doctor"];
     if (!command || parsedArgs["--help"] && !namespacedCommands.includes(command)) {
       printHelp();
       return;
@@ -941,7 +1156,7 @@ ${chalk.green.bold("Examples")}
       case "init":
         await createRebaseApp(args);
         break;
-      case "generate-sdk":
+      case "generate-sdk": {
         const sdkArgs = arg(
           {
             "--collections-dir": String,
@@ -955,11 +1170,12 @@ ${chalk.green.bold("Examples")}
           }
         );
         await generateSdkCommand({
-          collectionsDir: sdkArgs["--collections-dir"] || "./shared/collections",
+          collectionsDir: sdkArgs["--collections-dir"] || "./config/collections",
           output: sdkArgs["--output"] || "./generated/sdk",
           cwd: process.cwd()
         });
         break;
+      }
       case "schema":
         await schemaCommand(effectiveSubcommand, args);
         break;
@@ -972,6 +1188,9 @@ ${chalk.green.bold("Examples")}
       case "auth":
         await authCommand(effectiveSubcommand, args);
         break;
+      case "doctor":
+        await doctorCommand(args);
+        break;
       default:
         console.log(chalk.red(`Unknown command: ${command}`));
         console.log("");
@@ -1008,6 +1227,9 @@ ${chalk.green.bold("Auth")}
   ${chalk.blue.bold("auth reset-password")}     Reset a user's password
   ${chalk.blue.bold("auth")} ${chalk.gray("--help")}              Show auth command help
 
+${chalk.green.bold("Diagnostics")}
+  ${chalk.blue.bold("doctor")}                  Detect schema drift between collections, schema, and DB
+
 ${chalk.green.bold("Options")}
   ${chalk.blue("--version, -v")}   Show version number
   ${chalk.blue("--help, -h")}      Show this help message