@rebasepro/cli 0.0.1-canary.d44c30b → 0.0.1-canary.e17585f

package/dist/commands/build.d.ts

@@ -0,0 +1 @@
+export declare function buildCommand(): Promise<void>;

package/dist/commands/init.d.ts

@@ -1,8 +1,16 @@
+import type { PackageManager, PMCommands } from "../utils/package-manager";
 export interface InitOptions {
     projectName: string;
     git: boolean;
     installDeps: boolean;
     targetDirectory: string;
     templateDirectory: string;
+    databaseUrl?: string;
+    introspect?: boolean;
+    /** Detected package manager (pnpm or npm). */
+    pm: PackageManager;
+    /** Command helpers for the detected PM. */
+    pmCommands: PMCommands;
 }
 export declare function createRebaseApp(rawArgs: string[]): Promise<void>;
+export declare function configureEnvFile(targetDirectory: string, databaseUrl?: string): void;

package/dist/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function startCommand(): Promise<void>;

package/dist/index.cjs

@@ -20,6 +20,45 @@
     return Object.freeze(n);
   }
   const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(os);
+  function detectPackageManager(targetDir) {
+    const userAgent = process.env.npm_config_user_agent ?? "";
+    if (userAgent.startsWith("npm/")) return "npm";
+    if (userAgent.startsWith("pnpm/")) return "pnpm";
+    if (targetDir) {
+      if (fs.existsSync(path.join(targetDir, "package-lock.json"))) return "npm";
+      if (fs.existsSync(path.join(targetDir, "pnpm-lock.yaml"))) return "pnpm";
+    }
+    const cwd = process.cwd();
+    if (cwd !== targetDir) {
+      if (fs.existsSync(path.join(cwd, "package-lock.json"))) return "npm";
+      if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+    }
+    return "pnpm";
+  }
+  function getPMCommands(pm) {
+    if (pm === "npm") {
+      return {
+        name: "npm",
+        install: ["npm", "install"],
+        run: (script) => ["npm", "run", script],
+        exec: (bin, args) => ["npx", bin, ...args],
+        view: (pkg, field) => ["npm", "view", pkg, field],
+        runAll: (script) => ["npm", "run", script, "--workspaces", "--if-present"],
+        runWorkspace: (workspace, script) => ["npm", "run", script, "-w", workspace],
+        workspaceProtocol: "*"
+      };
+    }
+    return {
+      name: "pnpm",
+      install: ["pnpm", "install"],
+      run: (script) => ["pnpm", "run", script],
+      exec: (bin, args) => ["pnpm", "exec", bin, ...args],
+      view: (pkg, field) => ["pnpm", "view", pkg, field],
+      runAll: (script) => ["pnpm", "-r", "run", script],
+      runWorkspace: (workspace, script) => ["pnpm", "--filter", workspace, script],
+      workspaceProtocol: "workspace:*"
+    };
+  }
   const access = util.promisify(fs.access);
   const copy = util.promisify(ncp);
   const __filename$2 = url.fileURLToPath(typeof document === "undefined" && typeof location === "undefined" ? require("url").pathToFileURL(__filename).href : typeof document === "undefined" ? location.href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href);
@@ -39,10 +78,11 @@
     console.log(`
 ${chalk.bold("Rebase")} — Create a new project 🚀
 `);
-    const options = await promptForOptions(rawArgs);
+    const pm = detectPackageManager();
+    const options = await promptForOptions(rawArgs, pm);
     await createProject(options);
   }
-  async function promptForOptions(rawArgs) {
+  async function promptForOptions(rawArgs, pm) {
     const args = arg(
       {
         "--git": Boolean,
@@ -85,20 +125,38 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       questions.push({
         type: "confirm",
         name: "installDeps",
-        message: "Install dependencies with pnpm?",
+        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: ""
+    });
+    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");
+    const pmCommands = getPMCommands(pm);
     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,
+      pm,
+      pmCommands
     };
   }
   async function createProject(options) {
@@ -131,27 +189,7 @@ ${chalk.bold("Rebase")} — Create a new project 🚀
       process.exit(1);
     }
     await replacePlaceholders(options);
-    const envTemplatePath = path.join(options.targetDirectory, ".env.template");
-    const envPath = path.join(options.targetDirectory, ".env");
-    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 += `
-# Docker Compose Database Password
-POSTGRES_PASSWORD=${dbPassword}
-`;
-      fs.writeFileSync(envPath, envContent, "utf-8");
-    }
+    configureEnvFile(options.targetDirectory, options.databaseUrl);
     if (options.git) {
       console.log(chalk.gray("  Initializing git repository..."));
       try {
@@ -160,17 +198,40 @@ POSTGRES_PASSWORD=${dbPassword}
         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 pnpm..."));
+      console.log(chalk.gray(`  Installing dependencies with ${pm}...`));
       console.log("");
       try {
-        await execa("pnpm", ["install"], {
+        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 `pnpm install` manually."));
+        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("");
@@ -178,15 +239,23 @@ POSTGRES_PASSWORD=${dbPassword}
     console.log("");
     console.log(chalk.bold("Next steps:"));
     console.log("");
+    const runDev = pmCommands.run("dev");
     console.log(`  ${chalk.cyan("cd")} ${options.projectName}`);
     if (!options.installDeps) {
-      console.log(`  ${chalk.cyan("pnpm install")}`);
+      console.log(`  ${chalk.cyan(installCmd.join(" "))}`);
     }
     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(`  ${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("");
@@ -200,16 +269,93 @@ POSTGRES_PASSWORD=${dbPassword}
       "frontend/package.json",
       "backend/package.json",
       "config/package.json",
-      "frontend/index.html"
+      "frontend/index.html",
+      "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);
+      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;
-      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");
     }
   }
+  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) {
+        envContent = envContent.replace(
+          /^DATABASE_URL=.*$/m,
+          `DATABASE_URL=${databaseUrl}`
+        );
+      } else {
+        envContent = envContent.replace(
+          /^DATABASE_URL=.*$/m,
+          `DATABASE_URL=postgresql://rebase:${dbPassword}@localhost:5432/rebase`
+        );
+      }
+      fs.writeFileSync(envPath, envContent, "utf-8");
+    }
+  }
   async function loadCollections(collectionsDir) {
     const absDir = path.resolve(collectionsDir);
     if (!fs.existsSync(absDir)) {
@@ -362,15 +508,20 @@ 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
-      };
-      for (const dep of Object.keys(deps)) {
-        if (dep.startsWith("@rebasepro/server-") && dep !== "@rebasepro/server-core") {
-          return dep;
+      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;
@@ -380,6 +531,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")
     ];
@@ -502,11 +654,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) {
@@ -566,7 +722,6 @@ ${chalk.green.bold("Usage")}
 ${chalk.green.bold("Commands")}
   ${chalk.gray("(Commands are provided by your active database driver plugin)")}
   ${chalk.blue.bold("push")}       Apply schema directly to database (development)
-  ${chalk.blue.bold("pull")}       Introspect database → Schema
   ${chalk.blue.bold("generate")}   Generate migration files
   ${chalk.blue.bold("migrate")}    Run pending migrations
   ${chalk.blue.bold("studio")}     Open Studio viewer
@@ -697,9 +852,12 @@ ${chalk.green.bold("Examples")}
         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(
-        "pnpm",
-        ["run", "dev"],
+        runDevCmd[0],
+        runDevCmd.slice(1),
         {
           cwd: frontendDir,
           stdio: ["inherit", "pipe", "pipe"],
@@ -733,8 +891,10 @@ ${chalk.green.bold("Examples")}
     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: pnpm add -D tsx"));
+        console.error(chalk.gray(`    Install it with: ${addCmd}`));
         process.exit(1);
       }
       const envFile = findEnvFile(projectRoot);
@@ -835,6 +995,46 @@ ${chalk.green.bold("Description")}
   backend is ready, and VITE_API_URL is injected automatically.
 `);
   }
+  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);
+    }
+  }
+  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);
+    }
+  }
   async function authCommand(subcommand, rawArgs) {
     if (!subcommand || subcommand === "--help") {
       printAuthHelp();
@@ -1043,7 +1243,7 @@ ${chalk.green.bold("Examples")}
     }
     const command = parsedArgs._[0];
     const subcommand = parsedArgs._[1];
-    const namespacedCommands = ["schema", "db", "dev", "auth", "doctor"];
+    const namespacedCommands = ["schema", "db", "dev", "build", "start", "auth", "doctor"];
     if (!command || parsedArgs["--help"] && !namespacedCommands.includes(command)) {
       printHelp();
       return;
@@ -1082,6 +1282,12 @@ ${chalk.green.bold("Examples")}
       case "dev":
         await devCommand(args);
         break;
+      case "build":
+        await buildCommand();
+        break;
+      case "start":
+        await startCommand();
+        break;
       case "auth":
         await authCommand(effectiveSubcommand, args);
         break;
@@ -1104,14 +1310,16 @@ ${chalk.green.bold("Usage")}
 ${chalk.green.bold("Commands")}
   ${chalk.blue.bold("init")}                    Create a new Rebase project
   ${chalk.blue.bold("dev")}                     Start the development server
+  ${chalk.blue.bold("build")}                   Build all workspace packages
+  ${chalk.blue.bold("start")}                   Start the backend server ${chalk.gray("(production)")}
 
 ${chalk.green.bold("Schema")}
   ${chalk.blue.bold("schema generate")}         Generate Drizzle schema from collections
+  ${chalk.blue.bold("schema introspect")}       Introspect database → Rebase collections
   ${chalk.blue.bold("schema")} ${chalk.gray("--help")}           Show schema command help
 
 ${chalk.green.bold("Database")}
   ${chalk.blue.bold("db push")}                 Apply schema directly to database ${chalk.gray("(dev)")}
-  ${chalk.blue.bold("db pull")}                 Introspect database → Drizzle schema
   ${chalk.blue.bold("db generate")}             Generate SQL migration files
   ${chalk.blue.bold("db migrate")}              Run pending migrations
   ${chalk.blue.bold("db studio")}               Open Drizzle Studio
@@ -1178,6 +1386,8 @@ ${chalk.gray("Documentation: https://rebase.pro/docs")}
     }
   }
   exports2.authCommand = authCommand;
+  exports2.buildCommand = buildCommand;
+  exports2.configureEnvFile = configureEnvFile;
   exports2.createRebaseApp = createRebaseApp;
   exports2.dbCommand = dbCommand;
   exports2.devCommand = devCommand;
@@ -1198,6 +1408,7 @@ ${chalk.gray("Documentation: https://rebase.pro/docs")}
   exports2.resolvePluginCliScript = resolvePluginCliScript;
   exports2.resolveTsx = resolveTsx;
   exports2.schemaCommand = schemaCommand;
+  exports2.startCommand = startCommand;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
 }));
 //# sourceMappingURL=index.cjs.map