create-stackrjs 1.4.0

package/dist/index.js

@@ -0,0 +1,1135 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createRequire } from "module";
+
+// src/shared/registry.ts
+var REGISTRY = {
+  architecture: [
+    { value: "monolith", label: "Monolith", status: "stable" },
+    // The microservices bundle ships its own Postgres data layer.
+    { value: "microservices", label: "Microservices", status: "stable", requires: { database: ["postgres"] } }
+  ],
+  database: [
+    { value: "postgres", label: "PostgreSQL", status: "stable" },
+    { value: "mysql", label: "MySQL", status: "stable" },
+    // MongoDB pairs with the Mongoose ODM (Prisma/Drizzle here are SQL-only).
+    { value: "mongodb", label: "MongoDB", status: "stable", requires: { orm: ["mongoose"] } }
+  ],
+  orm: [
+    { value: "prisma", label: "Prisma", status: "stable" },
+    // Drizzle is SQL-only: no MongoDB.
+    { value: "drizzle", label: "Drizzle", status: "stable", requires: { database: ["postgres", "mysql"] } },
+    // Mongoose is MongoDB-only.
+    { value: "mongoose", label: "Mongoose", status: "stable", requires: { database: ["mongodb"] } }
+  ],
+  auth: [
+    { value: "nextauth", label: "NextAuth (Auth.js)", status: "stable" },
+    // Clerk is hosted auth, independent of the chosen ORM/database.
+    { value: "clerk", label: "Clerk", status: "stable" },
+    // Supabase Auth is backed by a Supabase Postgres project.
+    { value: "supabase", label: "Supabase Auth", status: "stable", requires: { database: ["postgres"] } },
+    // Better Auth ships with its own Prisma schema + adapter.
+    { value: "better-auth", label: "Better Auth", status: "stable", requires: { orm: ["prisma"] } }
+  ],
+  styling: [
+    { value: "tailwind", label: "Tailwind CSS", status: "stable" },
+    // shadcn ships the full Tailwind stack plus the shadcn/ui components.
+    { value: "shadcn", label: "shadcn/ui (+ Tailwind)", status: "stable" }
+  ],
+  interfaces: [
+    // The auth portal works with every provider: NextAuth gets the credentials
+    // pages (ORM-specific server actions as an overlay); Clerk/Supabase/Better Auth
+    // already ship their own login/register/account pages.
+    {
+      value: "auth-pages",
+      label: "Auth portal (login / register / reset)",
+      status: "stable"
+    },
+    // Dashboard + admin read user data through a per-auth `@/server/account`
+    // adapter. The DB-backed adapters (NextAuth / Better Auth) use Prisma, so both
+    // interfaces require it; Clerk/Supabase read from their own APIs but still
+    // generate against a Prisma app database.
+    {
+      value: "dashboard",
+      label: "User dashboard",
+      status: "stable",
+      requires: { orm: ["prisma"] }
+    },
+    {
+      value: "admin",
+      label: "Admin / back-office",
+      status: "stable",
+      requires: { orm: ["prisma"] }
+    },
+    { value: "landing", label: "Landing page", status: "stable" }
+  ]
+};
+var DIMENSIONS = Object.keys(REGISTRY);
+var OPTION_LABELS = Object.fromEntries(
+  DIMENSIONS.flatMap((d) => REGISTRY[d].map((o) => [o.value, o.label]))
+);
+var optionLabel = (value) => OPTION_LABELS[value] ?? value;
+var ALL_VALUES = Object.fromEntries(
+  DIMENSIONS.map((d) => [d, REGISTRY[d].map((o) => o.value)])
+);
+var STABLE_VALUES = Object.fromEntries(
+  DIMENSIONS.map((d) => [d, REGISTRY[d].filter((o) => o.status === "stable").map((o) => o.value)])
+);
+var DEFAULT_VALUES = Object.fromEntries(
+  DIMENSIONS.map((d) => [d, (REGISTRY[d].find((o) => o.status === "stable") ?? REGISTRY[d][0]).value])
+);
+function findOption(dimension, value) {
+  return REGISTRY[dimension].find((o) => o.value === value);
+}
+
+// src/cli/flags.ts
+var SUPPORTED = STABLE_VALUES;
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "architecture",
+  "database",
+  "orm",
+  "auth",
+  "styling",
+  "interfaces"
+]);
+function parseArgs(argv) {
+  const result = { positionals: [], yes: false, help: false, version: false };
+  const positionals = [];
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (!token.startsWith("-")) {
+      positionals.push(token);
+      continue;
+    }
+    let key = token.replace(/^--?/, "");
+    let value;
+    const eq = key.indexOf("=");
+    if (eq !== -1) {
+      value = key.slice(eq + 1);
+      key = key.slice(0, eq);
+    }
+    switch (key) {
+      case "help":
+      case "h":
+        result.help = true;
+        break;
+      case "version":
+      case "v":
+        result.version = true;
+        break;
+      case "yes":
+      case "y":
+        result.yes = true;
+        break;
+      case "ci":
+        result.yes = true;
+        result.install = false;
+        result.git = false;
+        break;
+      case "install":
+        result.install = true;
+        break;
+      case "no-install":
+        result.install = false;
+        break;
+      case "git":
+        result.git = true;
+        break;
+      case "no-git":
+        result.git = false;
+        break;
+      default: {
+        if (VALUE_FLAGS.has(key)) {
+          if (value === void 0) value = argv[++i];
+          if (key === "interfaces") {
+            result.interfaces = (value ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+          } else {
+            result[key] = value;
+          }
+        }
+      }
+    }
+  }
+  result.positionals = positionals;
+  return result;
+}
+
+// src/cli/create.ts
+import { promises as fs7 } from "fs";
+import path22 from "path";
+import * as p2 from "@clack/prompts";
+
+// src/utils/paths.ts
+import { fileURLToPath } from "url";
+import path from "path";
+function getTemplateDir() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, "..", "template");
+}
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var logger = {
+  info: (msg) => console.log(msg),
+  success: (msg) => console.log(pc.green(msg)),
+  warn: (msg) => console.log(pc.yellow(msg)),
+  error: (msg) => console.error(pc.red(msg)),
+  dim: (msg) => console.log(pc.dim(msg))
+};
+
+// src/helpers/scaffoldProject.ts
+import { promises as fs6 } from "fs";
+import path20 from "path";
+
+// src/utils/copyTemplate.ts
+import { promises as fs } from "fs";
+import path2 from "path";
+function restoreFilename(name) {
+  return name.startsWith("_") ? "." + name.slice(1) : name;
+}
+async function copyTemplate(srcDir, destDir) {
+  const entries = await fs.readdir(srcDir, { withFileTypes: true });
+  await fs.mkdir(destDir, { recursive: true });
+  for (const entry of entries) {
+    const srcPath = path2.join(srcDir, entry.name);
+    const destPath = path2.join(destDir, restoreFilename(entry.name));
+    if (entry.isDirectory()) {
+      await copyTemplate(srcPath, destPath);
+    } else {
+      await fs.mkdir(path2.dirname(destPath), { recursive: true });
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+// src/utils/packageJson.ts
+import { promises as fs2 } from "fs";
+function addDependencies(pkg, deps) {
+  pkg.dependencies = { ...pkg.dependencies, ...deps };
+}
+function addDevDependencies(pkg, deps) {
+  pkg.devDependencies = { ...pkg.devDependencies, ...deps };
+}
+function addScripts(pkg, scripts) {
+  pkg.scripts = { ...pkg.scripts, ...scripts };
+}
+function sortRecord(record) {
+  return Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
+}
+function finalizePackageJson(pkg) {
+  return {
+    ...pkg,
+    dependencies: sortRecord(pkg.dependencies),
+    devDependencies: sortRecord(pkg.devDependencies)
+  };
+}
+async function mergePackageDependencies(pkgPath, deps, devDeps) {
+  const pkg = JSON.parse(await fs2.readFile(pkgPath, "utf8"));
+  pkg.dependencies = sortRecord({ ...pkg.dependencies, ...deps });
+  pkg.devDependencies = sortRecord({ ...pkg.devDependencies, ...devDeps });
+  await fs2.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+}
+
+// src/utils/env.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+function addEnv(env, entry) {
+  const existing = env.findIndex((e) => e.key === entry.key);
+  if (existing === -1) {
+    env.push(entry);
+  } else {
+    env[existing] = entry;
+  }
+}
+function renderEnvFile(env, useExampleValues) {
+  const lines = [
+    "# Generated by Stackr. Adjust values as needed.",
+    ""
+  ];
+  for (const entry of env) {
+    if (entry.comment) lines.push(`# ${entry.comment}`);
+    const value = useExampleValues ? entry.exampleValue ?? entry.value : entry.value;
+    lines.push(`${entry.key}=${value}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function writeEnvFiles(projectDir, env) {
+  await fs3.writeFile(path3.join(projectDir, ".env"), renderEnvFile(env, false), "utf8");
+  await fs3.writeFile(
+    path3.join(projectDir, ".env.example"),
+    renderEnvFile(env, true),
+    "utf8"
+  );
+}
+
+// src/installers/database.ts
+import path4 from "path";
+var CONFIG = {
+  postgres: {
+    dir: "postgres",
+    url: "postgresql://postgres:postgres@localhost:5432/app?schema=public",
+    comment: "Postgres connection string (matches the bundled docker-compose.yml)"
+  },
+  mysql: {
+    dir: "mysql",
+    url: "mysql://root:root@localhost:3306/app",
+    comment: "MySQL connection string (matches the bundled docker-compose.yml)"
+  },
+  mongodb: {
+    dir: "mongodb",
+    url: "mongodb://localhost:27017/app",
+    comment: "MongoDB connection string (matches the bundled docker-compose.yml)"
+  }
+};
+var databaseInstaller = async (ctx) => {
+  const config = CONFIG[ctx.selections.database];
+  if (!config) return;
+  await copyTemplate(path4.join(ctx.templateDir, "extras", "databases", config.dir), ctx.projectDir);
+  addEnv(ctx.env, { key: "DATABASE_URL", value: config.url, comment: config.comment });
+};
+
+// src/installers/prisma.ts
+import path6 from "path";
+
+// src/utils/prismaSchema.ts
+import path5 from "path";
+import { promises as fs4 } from "fs";
+var PROVIDER = {
+  postgres: "postgresql",
+  mysql: "mysql"
+};
+async function setPrismaProvider(projectDir, database) {
+  const provider = PROVIDER[database];
+  if (!provider || provider === "postgresql") return;
+  const schemaPath = path5.join(projectDir, "prisma", "schema.prisma");
+  const schema = await fs4.readFile(schemaPath, "utf8");
+  await fs4.writeFile(
+    schemaPath,
+    schema.replace('provider = "postgresql"', `provider = "${provider}"`),
+    "utf8"
+  );
+}
+
+// src/installers/prisma.ts
+var ADAPTER = {
+  postgres: {
+    deps: { "@prisma/adapter-pg": "^7.8.0", pg: "^8.13.1" },
+    devDeps: { "@types/pg": "^8.11.10" }
+  },
+  mysql: {
+    deps: { "@prisma/adapter-mariadb": "^7.8.0" },
+    devDeps: {}
+  }
+};
+var prismaInstaller = async (ctx) => {
+  await copyTemplate(path6.join(ctx.templateDir, "extras", "prisma", "base"), ctx.projectDir);
+  await setPrismaProvider(ctx.projectDir, ctx.selections.database);
+  const engine = ctx.selections.database === "mysql" ? "mysql" : "postgres";
+  await copyTemplate(path6.join(ctx.templateDir, "extras", "prisma", engine), ctx.projectDir);
+  const adapter = ADAPTER[engine];
+  addDependencies(ctx.pkg, { "@prisma/client": "^7.8.0", ...adapter.deps });
+  addDevDependencies(ctx.pkg, { prisma: "^7.8.0", dotenv: "^16.4.7", ...adapter.devDeps });
+  addScripts(ctx.pkg, {
+    "db:push": "prisma db push",
+    "db:migrate": "prisma migrate dev",
+    "db:studio": "prisma studio",
+    // Ensure the client is generated after install and before `next build`.
+    postinstall: "prisma generate"
+  });
+};
+
+// src/installers/drizzle.ts
+import path7 from "path";
+var DRIVER = {
+  postgres: {
+    deps: { pg: "^8.13.1" },
+    devDeps: { "@types/pg": "^8.11.10" }
+  },
+  mysql: {
+    deps: { mysql2: "^3.12.0" },
+    devDeps: {}
+  }
+};
+var drizzleInstaller = async (ctx) => {
+  const dialect = ctx.selections.database === "mysql" ? "mysql" : "postgres";
+  await copyTemplate(path7.join(ctx.templateDir, "extras", "drizzle", dialect), ctx.projectDir);
+  const driver = DRIVER[dialect];
+  addDependencies(ctx.pkg, { "drizzle-orm": "^0.38.3", ...driver.deps });
+  addDevDependencies(ctx.pkg, { "drizzle-kit": "^0.30.1", dotenv: "^16.4.7", ...driver.devDeps });
+  addScripts(ctx.pkg, {
+    "db:push": "drizzle-kit push",
+    "db:generate": "drizzle-kit generate",
+    "db:studio": "drizzle-kit studio"
+  });
+};
+
+// src/installers/mongoose.ts
+import path8 from "path";
+var mongooseInstaller = async (ctx) => {
+  await copyTemplate(path8.join(ctx.templateDir, "extras", "mongoose"), ctx.projectDir);
+  addDependencies(ctx.pkg, { mongoose: "^8.9.3" });
+};
+
+// src/installers/nextauth.ts
+import path9 from "path";
+import { randomBytes } from "crypto";
+var nextauthInstaller = async (ctx) => {
+  await copyTemplate(path9.join(ctx.templateDir, "extras", "nextauth"), ctx.projectDir);
+  const overlay = `nextauth-${ctx.selections.orm}`;
+  await copyTemplate(path9.join(ctx.templateDir, "extras", overlay), ctx.projectDir);
+  addDependencies(ctx.pkg, {
+    "next-auth": "^5.0.0-beta.25",
+    bcryptjs: "^2.4.3",
+    zod: "^3.24.1"
+  });
+  if (ctx.selections.orm === "prisma") {
+    addDependencies(ctx.pkg, { "@auth/prisma-adapter": "^2.7.4" });
+  }
+  addDevDependencies(ctx.pkg, { "@types/bcryptjs": "^2.4.6" });
+  addEnv(ctx.env, {
+    key: "AUTH_SECRET",
+    value: randomBytes(32).toString("base64"),
+    exampleValue: "generate-with-openssl-rand-base64-32",
+    comment: "Secret used by Auth.js to encrypt JWTs. Keep this private."
+  });
+};
+
+// src/installers/better-auth.ts
+import path10 from "path";
+import { promises as fs5 } from "fs";
+import { randomBytes as randomBytes2 } from "crypto";
+var ADAPTER_PROVIDER = {
+  postgres: "postgresql",
+  mysql: "mysql"
+};
+var betterAuthInstaller = async (ctx) => {
+  await copyTemplate(path10.join(ctx.templateDir, "extras", "better-auth"), ctx.projectDir);
+  await setPrismaProvider(ctx.projectDir, ctx.selections.database);
+  const provider = ADAPTER_PROVIDER[ctx.selections.database] ?? "postgresql";
+  if (provider !== "postgresql") {
+    const authPath = path10.join(ctx.projectDir, "src", "server", "auth.ts");
+    const auth = await fs5.readFile(authPath, "utf8");
+    await fs5.writeFile(authPath, auth.replace('provider: "postgresql"', `provider: "${provider}"`), "utf8");
+  }
+  addDependencies(ctx.pkg, { "better-auth": "^1.2.7" });
+  addEnv(ctx.env, {
+    key: "BETTER_AUTH_SECRET",
+    value: randomBytes2(32).toString("base64"),
+    exampleValue: "generate-with-openssl-rand-base64-32",
+    comment: "Secret Better Auth uses to sign sessions. Keep this private."
+  });
+  addEnv(ctx.env, {
+    key: "BETTER_AUTH_URL",
+    value: "http://localhost:3000",
+    comment: "Base URL of the app (used by Better Auth for callbacks)."
+  });
+};
+
+// src/installers/clerk.ts
+import path11 from "path";
+var clerkInstaller = async (ctx) => {
+  await copyTemplate(path11.join(ctx.templateDir, "extras", "clerk"), ctx.projectDir);
+  addDependencies(ctx.pkg, { "@clerk/nextjs": "^6.9.6" });
+  addEnv(ctx.env, {
+    key: "NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY",
+    // Valid-format placeholder (decodes to clerk.example.com$) so the app builds.
+    value: "pk_test_Y2xlcmsuZXhhbXBsZS5jb20k",
+    exampleValue: "pk_test_xxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+    comment: "Clerk publishable key (from the Clerk dashboard)."
+  });
+  addEnv(ctx.env, {
+    key: "CLERK_SECRET_KEY",
+    value: "sk_test_clerk-placeholder-secret-replace-me",
+    exampleValue: "sk_test_xxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+    comment: "Clerk secret key (from the Clerk dashboard). Keep this private."
+  });
+  addEnv(ctx.env, {
+    key: "NEXT_PUBLIC_CLERK_SIGN_IN_URL",
+    value: "/sign-in",
+    comment: "Route to the custom sign-in page."
+  });
+  addEnv(ctx.env, {
+    key: "NEXT_PUBLIC_CLERK_SIGN_UP_URL",
+    value: "/sign-up",
+    comment: "Route to the custom sign-up page."
+  });
+};
+
+// src/installers/supabase.ts
+import path12 from "path";
+var supabaseInstaller = async (ctx) => {
+  await copyTemplate(path12.join(ctx.templateDir, "extras", "supabase"), ctx.projectDir);
+  addDependencies(ctx.pkg, {
+    "@supabase/supabase-js": "^2.47.10",
+    "@supabase/ssr": "^0.5.2"
+  });
+  addEnv(ctx.env, {
+    key: "NEXT_PUBLIC_SUPABASE_URL",
+    value: "https://your-project.supabase.co",
+    exampleValue: "https://your-project.supabase.co",
+    comment: "Supabase project URL (Project Settings \u2192 API)."
+  });
+  addEnv(ctx.env, {
+    key: "NEXT_PUBLIC_SUPABASE_ANON_KEY",
+    value: "your-supabase-anon-key",
+    exampleValue: "your-supabase-anon-key",
+    comment: "Supabase anon/public key (Project Settings \u2192 API)."
+  });
+};
+
+// src/installers/tailwind.ts
+import path13 from "path";
+var TAILWIND_DEV_DEPS = {
+  tailwindcss: "^3.4.17",
+  postcss: "^8.4.49",
+  autoprefixer: "^10.4.20"
+};
+var tailwindInstaller = async (ctx) => {
+  const webDir = path13.join(ctx.projectDir, ctx.layout.webRoot);
+  await copyTemplate(path13.join(ctx.templateDir, "extras", "tailwind"), webDir);
+  if (ctx.layout.multiService) {
+    await mergePackageDependencies(path13.join(webDir, "package.json"), {}, TAILWIND_DEV_DEPS);
+  } else {
+    addDevDependencies(ctx.pkg, TAILWIND_DEV_DEPS);
+  }
+};
+
+// src/installers/shadcn.ts
+import path14 from "path";
+var SHADCN_DEPS = {
+  "class-variance-authority": "^0.7.1",
+  clsx: "^2.1.1",
+  "tailwind-merge": "^2.6.0",
+  "lucide-react": "^0.469.0"
+};
+var SHADCN_DEV_DEPS = {
+  tailwindcss: "^3.4.17",
+  postcss: "^8.4.49",
+  autoprefixer: "^10.4.20",
+  "tailwindcss-animate": "^1.0.7"
+};
+var shadcnInstaller = async (ctx) => {
+  const webDir = path14.join(ctx.projectDir, ctx.layout.webRoot);
+  await copyTemplate(path14.join(ctx.templateDir, "extras", "shadcn"), webDir);
+  if (ctx.layout.multiService) {
+    await mergePackageDependencies(path14.join(webDir, "package.json"), SHADCN_DEPS, SHADCN_DEV_DEPS);
+  } else {
+    addDependencies(ctx.pkg, SHADCN_DEPS);
+    addDevDependencies(ctx.pkg, SHADCN_DEV_DEPS);
+  }
+};
+
+// src/installers/auth-pages.ts
+import path15 from "path";
+var authPagesInstaller = async (ctx) => {
+  if (ctx.selections.auth !== "nextauth") return;
+  await copyTemplate(path15.join(ctx.templateDir, "extras", "auth-pages"), ctx.projectDir);
+  const overlay = `auth-pages-${ctx.selections.orm}`;
+  await copyTemplate(path15.join(ctx.templateDir, "extras", overlay), ctx.projectDir);
+};
+
+// src/installers/account.ts
+import path16 from "path";
+var accountAdapterInstaller = async (ctx) => {
+  await copyTemplate(
+    path16.join(ctx.templateDir, "extras", `account-${ctx.selections.auth}`),
+    ctx.projectDir
+  );
+  if (ctx.selections.interfaces.includes("admin")) {
+    addEnv(ctx.env, {
+      key: "ADMIN_EMAILS",
+      value: "",
+      exampleValue: "you@example.com,teammate@example.com",
+      comment: "Comma-separated emails granted ADMIN access on the /admin page."
+    });
+  }
+  if (ctx.selections.auth === "supabase") {
+    addEnv(ctx.env, {
+      key: "SUPABASE_SERVICE_ROLE_KEY",
+      value: "your-supabase-service-role-key",
+      exampleValue: "your-supabase-service-role-key",
+      comment: "Supabase service-role key (Project Settings \u2192 API). Server-only; bypasses RLS."
+    });
+  }
+};
+
+// src/installers/dashboard.ts
+import path17 from "path";
+var dashboardInstaller = async (ctx) => {
+  await copyTemplate(path17.join(ctx.templateDir, "extras", "dashboard"), ctx.projectDir);
+};
+
+// src/installers/admin.ts
+import path18 from "path";
+var adminInstaller = async (ctx) => {
+  await copyTemplate(path18.join(ctx.templateDir, "extras", "admin"), ctx.projectDir);
+};
+
+// src/installers/landing.ts
+import path19 from "path";
+var landingInstaller = async (ctx) => {
+  await copyTemplate(path19.join(ctx.templateDir, "extras", "landing"), ctx.projectDir);
+};
+
+// src/installers/microservices.ts
+import { randomBytes as randomBytes3 } from "crypto";
+var microservicesInstaller = (ctx) => {
+  addEnv(ctx.env, {
+    key: "DATABASE_URL",
+    value: "postgresql://postgres:postgres@localhost:5432/app?schema=public",
+    comment: "Postgres connection string (compose overrides the host to `db`)."
+  });
+  addEnv(ctx.env, {
+    key: "AUTH_SECRET",
+    value: randomBytes3(32).toString("base64"),
+    exampleValue: "generate-with-openssl-rand-base64-32",
+    comment: "Secret the API service uses to sign session JWTs. Keep this private."
+  });
+};
+
+// src/installers/index.ts
+function resolveInstallers(selections) {
+  const installers = [];
+  if (selections.architecture === "microservices") {
+    installers.push(microservicesInstaller);
+    if (selections.styling === "tailwind") installers.push(tailwindInstaller);
+    if (selections.styling === "shadcn") installers.push(shadcnInstaller);
+    return installers;
+  }
+  installers.push(databaseInstaller);
+  if (selections.orm === "prisma") installers.push(prismaInstaller);
+  if (selections.orm === "drizzle") installers.push(drizzleInstaller);
+  if (selections.orm === "mongoose") installers.push(mongooseInstaller);
+  if (selections.auth === "nextauth") installers.push(nextauthInstaller);
+  if (selections.auth === "better-auth") installers.push(betterAuthInstaller);
+  if (selections.auth === "clerk") installers.push(clerkInstaller);
+  if (selections.auth === "supabase") installers.push(supabaseInstaller);
+  if (selections.styling === "tailwind") installers.push(tailwindInstaller);
+  if (selections.styling === "shadcn") installers.push(shadcnInstaller);
+  if (selections.interfaces.includes("auth-pages")) installers.push(authPagesInstaller);
+  if (selections.interfaces.includes("dashboard") || selections.interfaces.includes("admin")) {
+    installers.push(accountAdapterInstaller);
+  }
+  if (selections.interfaces.includes("dashboard")) installers.push(dashboardInstaller);
+  if (selections.interfaces.includes("admin")) installers.push(adminInstaller);
+  if (selections.interfaces.includes("landing")) installers.push(landingInstaller);
+  return installers;
+}
+
+// src/shared/layout.ts
+var LAYOUTS = {
+  monolith: { webRoot: ".", serverRoot: ".", multiService: false },
+  microservices: { webRoot: "apps/web", serverRoot: "services/api", multiService: true }
+};
+function getLayout(architecture) {
+  return LAYOUTS[architecture];
+}
+
+// src/helpers/generateReadme.ts
+function generateReadme(selections) {
+  const interfaces = selections.interfaces.length ? selections.interfaces.map((i) => `- ${optionLabel(i)}`).join("\n") : "- _(none)_";
+  const dbEngine = { postgres: "Postgres", mysql: "MySQL", mongodb: "MongoDB" }[selections.database] ?? "Postgres";
+  const gettingStarted = selections.architecture === "microservices" ? microservicesGettingStarted() : monolithGettingStarted(dbEngine, selections.orm);
+  return `# ${selections.projectName}
+
+Generated with [Stackr](https://github.com/) \u2014 a runnable full-stack Next.js starter.
+
+## Stack
+
+- **Architecture:** ${optionLabel(selections.architecture)}
+- **Database:** ${optionLabel(selections.database)}
+- **ORM:** ${optionLabel(selections.orm)}
+- **Auth:** ${optionLabel(selections.auth)}
+- **Styling:** ${optionLabel(selections.styling)}
+
+### Interfaces
+
+${interfaces}
+
+${gettingStarted}`;
+}
+function monolithGettingStarted(dbEngine, orm) {
+  const schemaStep = orm === "prisma" ? "\n# 3. Create the database schema\nnpx prisma migrate dev --name init\n" : orm === "drizzle" ? "\n# 3. Create the database schema\nnpm run db:push\n" : "";
+  const dbScriptRows = orm === "prisma" ? "| `npm run db:migrate` | Run Prisma migrations |\n| `npm run db:studio` | Open Prisma Studio |\n" : orm === "drizzle" ? "| `npm run db:push` | Push the schema to the database |\n| `npm run db:studio` | Open Drizzle Studio |\n" : "";
+  return `## Getting started
+
+\`\`\`bash
+# 1. Start a local ${dbEngine} (requires Docker)
+docker compose up -d
+
+# 2. Install dependencies
+npm install
+${schemaStep}
+# Run the app
+npm run dev
+\`\`\`
+
+Then open [http://localhost:3000](http://localhost:3000).
+
+- Register a new account at \`/register\`, then sign in at \`/login\`.
+- \`/account\` is a protected route.
+
+## Environment
+
+Copy \`.env.example\` to \`.env\` and adjust as needed. A working \`.env\` with a
+generated \`AUTH_SECRET\` was already created for you.
+
+## Scripts
+
+| Script | Description |
+| ------ | ----------- |
+| \`npm run dev\` | Start the dev server |
+| \`npm run build\` | Production build |
+${dbScriptRows}| \`npm run typecheck\` | Type-check without emitting |
+`;
+}
+function microservicesGettingStarted() {
+  return `## Architecture
+
+This is an npm-workspaces monorepo split into independent services:
+
+| Path | Service | Description |
+| ---- | ------- | ----------- |
+| \`apps/web\` | web | Next.js front-end (App Router) |
+| \`services/api\` | api | Standalone [Hono](https://hono.dev) REST API: Prisma + Postgres, session auth |
+| \`gateway\` | gateway | nginx reverse proxy \u2014 one public origin, \`/api/*\` \u2192 api, everything else \u2192 web |
+
+The browser talks only to the gateway; the gateway forwards \`/api/*\` to the API
+service (prefix stripped) and all other routes to the web app.
+
+## Getting started (local dev)
+
+\`\`\`bash
+# 1. Start a local Postgres (requires Docker)
+docker compose up -d db
+
+# 2. Install dependencies for every workspace
+npm install
+
+# 3. Create the database schema (runs in services/api)
+npm run db:migrate
+
+# 4. Run the web app and the API together
+npm run dev
+\`\`\`
+
+- web: [http://localhost:3000](http://localhost:3000) \xB7 api: [http://localhost:3001](http://localhost:3001)
+- Register at \`/register\`, then sign in at \`/login\`; \`/account\` is protected.
+
+## Running the full stack with the gateway
+
+\`\`\`bash
+docker compose up -d --build
+\`\`\`
+
+Then open [http://localhost:8080](http://localhost:8080) \u2014 the gateway in front of
+web + api + Postgres.
+
+## Environment
+
+Copy \`.env.example\` to \`.env\` and adjust as needed. A working \`.env\` with a
+generated \`AUTH_SECRET\` was already created for you.
+
+## Scripts (root)
+
+| Script | Description |
+| ------ | ----------- |
+| \`npm run dev\` | Start every workspace (web + api) |
+| \`npm run build\` | Build every workspace |
+| \`npm run db:migrate\` | Run Prisma migrations in the API service |
+| \`npm run db:studio\` | Open Prisma Studio for the API database |
+| \`npm run compose:up\` | Start the full stack via docker-compose |
+`;
+}
+
+// src/helpers/scaffoldProject.ts
+function architectureBase(templateDir, selections) {
+  if (selections.architecture === "microservices") {
+    return path20.join(templateDir, "architectures", "microservices");
+  }
+  return path20.join(templateDir, "base");
+}
+function withImpliedInterfaces(selections) {
+  const wantsAccount = selections.interfaces.includes("dashboard") || selections.interfaces.includes("admin");
+  const needsPortal = selections.auth === "nextauth" && wantsAccount && !selections.interfaces.includes("auth-pages");
+  if (!needsPortal) return selections;
+  return { ...selections, interfaces: ["auth-pages", ...selections.interfaces] };
+}
+async function scaffoldProject(templateDir, projectDir, inputSelections) {
+  const selections = withImpliedInterfaces(inputSelections);
+  await fs6.mkdir(projectDir, { recursive: true });
+  await copyTemplate(architectureBase(templateDir, selections), projectDir);
+  const pkgPath = path20.join(projectDir, "package.json");
+  const pkg = JSON.parse(await fs6.readFile(pkgPath, "utf8"));
+  pkg.name = selections.projectName;
+  const env = [];
+  const layout = getLayout(selections.architecture);
+  const ctx = { projectDir, templateDir, selections, layout, pkg, env };
+  for (const installer of resolveInstallers(selections)) {
+    await installer(ctx);
+  }
+  await fs6.writeFile(pkgPath, JSON.stringify(finalizePackageJson(pkg), null, 2) + "\n", "utf8");
+  await writeEnvFiles(projectDir, env);
+  await fs6.writeFile(
+    path20.join(projectDir, "README.md"),
+    generateReadme(selections),
+    "utf8"
+  );
+}
+
+// src/helpers/installDependencies.ts
+import { spawn } from "child_process";
+function installDependencies(projectDir) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("npm", ["install"], {
+      cwd: projectDir,
+      stdio: "inherit",
+      // npm is a .cmd shim on Windows; shell:true resolves it correctly.
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`npm install exited with code ${code}`));
+    });
+  });
+}
+
+// src/helpers/initGit.ts
+import { spawn as spawn2 } from "child_process";
+function run(cmd, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(cmd, args, {
+      cwd,
+      stdio: "ignore",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+async function initGit(projectDir) {
+  try {
+    if (await run("git", ["init"], projectDir) !== 0) return false;
+    await run("git", ["add", "-A"], projectDir);
+    await run("git", ["commit", "-m", "Initial commit from Stackr"], projectDir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/helpers/logNextSteps.ts
+import path21 from "path";
+function logNextSteps({ projectDir, selections, depsInstalled }) {
+  const rel = path21.relative(process.cwd(), projectDir) || ".";
+  const steps = [`cd ${rel}`];
+  if (selections.architecture === "microservices") {
+    steps.push("docker compose up -d db     # start local Postgres");
+    if (!depsInstalled) steps.push("npm install                 # installs every workspace");
+    steps.push("npm run db:migrate          # migrate the API database");
+    steps.push("npm run dev                 # web + api together");
+  } else {
+    const engineLabel = {
+      postgres: "Postgres",
+      mysql: "MySQL",
+      mongodb: "MongoDB"
+    };
+    if (engineLabel[selections.database]) {
+      steps.push(`docker compose up -d        # start local ${engineLabel[selections.database]}`);
+    }
+    if (!depsInstalled) {
+      steps.push("npm install");
+    }
+    if (selections.orm === "prisma") {
+      steps.push("npx prisma migrate dev --name init");
+    } else if (selections.orm === "drizzle") {
+      steps.push("npm run db:push           # create the schema with Drizzle");
+    }
+    steps.push("npm run dev");
+  }
+  console.log("");
+  console.log(pc.bold("Next steps:"));
+  for (const step of steps) {
+    console.log("  " + pc.cyan(step));
+  }
+  console.log("");
+  return steps;
+}
+
+// src/cli/wizard.ts
+import * as p from "@clack/prompts";
+
+// src/shared/compat.ts
+function selectedValues(selection, dimension) {
+  const raw = selection[dimension];
+  if (raw === void 0) return [];
+  return Array.isArray(raw) ? raw : [raw];
+}
+function conflict(selection, dimension, value) {
+  const own = findOption(dimension, value);
+  for (const other of DIMENSIONS) {
+    if (other === dimension) continue;
+    for (const otherValue of selectedValues(selection, other)) {
+      const forward = own?.requires?.[other];
+      if (forward && !forward.includes(otherValue)) return [other, otherValue];
+      const backward = findOption(other, otherValue)?.requires?.[dimension];
+      if (backward && !backward.includes(value)) return [other, otherValue];
+    }
+  }
+  return void 0;
+}
+function resolveAvailability(selection) {
+  const out = {};
+  for (const dimension of DIMENSIONS) {
+    out[dimension] = REGISTRY[dimension].map((option) => {
+      const clash = conflict(selection, dimension, option.value);
+      const generatable = option.status === "stable";
+      let reason;
+      if (clash) {
+        reason = `incompatible with ${clash[0]} "${optionLabel(clash[1])}"`;
+      } else if (!generatable) {
+        reason = "coming soon";
+      }
+      return { value: option.value, enabled: !clash, generatable, reason };
+    });
+  }
+  return out;
+}
+function validateCompat(selection) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dimension of DIMENSIONS) {
+    for (const value of selectedValues(selection, dimension)) {
+      const clash = conflict(selection, dimension, value);
+      if (!clash) continue;
+      const key = [dimension, value, clash[0], clash[1]].sort().join("|");
+      if (seen.has(key)) continue;
+      seen.add(key);
+      errors.push(
+        `${dimension} "${optionLabel(value)}" is incompatible with ${clash[0]} "${optionLabel(clash[1])}".`
+      );
+    }
+  }
+  return errors;
+}
+
+// src/cli/wizard.ts
+function bail() {
+  p.cancel("Operation cancelled.");
+  process.exit(0);
+}
+function unwrap(value) {
+  if (p.isCancel(value)) bail();
+  return value;
+}
+function buildOptions(dimension, selection) {
+  const availability = resolveAvailability(selection)[dimension];
+  return REGISTRY[dimension].map((option) => {
+    const a = availability.find((x) => x.value === option.value);
+    return { value: option.value, label: option.label, hint: a.reason };
+  });
+}
+function isSelectable(dimension, value, selection) {
+  const a = resolveAvailability(selection)[dimension].find((x) => x.value === value);
+  return a.enabled && a.generatable;
+}
+async function selectDimension(message, dimension, selection) {
+  for (; ; ) {
+    const value = unwrap(
+      await p.select({
+        message,
+        options: buildOptions(dimension, selection),
+        initialValue: DEFAULT_VALUES[dimension]
+      })
+    );
+    if (isSelectable(dimension, value, selection)) return value;
+    const reason = resolveAvailability(selection)[dimension].find((x) => x.value === value).reason;
+    p.log.warn(`"${optionLabel(value)}" is ${reason}. Please pick another.`);
+  }
+}
+async function runWizard(defaults) {
+  p.intro("Stackr \u2014 scaffold a runnable full-stack Next.js project");
+  const projectName = unwrap(
+    await p.text({
+      message: "Project name?",
+      placeholder: "my-app",
+      initialValue: defaults.projectName,
+      validate: (v) => {
+        if (!v) return "Please enter a project name.";
+        if (!/^[a-z0-9][a-z0-9-_.]*$/i.test(v)) return "Use letters, numbers, '-', '_' or '.'.";
+        return void 0;
+      }
+    })
+  );
+  const selection = {};
+  selection.architecture = await selectDimension("Architecture?", "architecture", selection);
+  selection.database = await selectDimension("Database?", "database", selection);
+  selection.orm = await selectDimension("ORM / data layer?", "orm", selection);
+  selection.auth = await selectDimension("Authentication?", "auth", selection);
+  selection.styling = await selectDimension("Styling?", "styling", selection);
+  const picked = unwrap(
+    await p.multiselect({
+      message: "Pre-built interfaces? (space to toggle)",
+      options: buildOptions("interfaces", selection),
+      initialValues: ["auth-pages"],
+      required: false
+    })
+  );
+  const interfaces = [];
+  for (const value of picked) {
+    if (isSelectable("interfaces", value, selection)) interfaces.push(value);
+    else {
+      const reason = resolveAvailability(selection).interfaces.find((x) => x.value === value).reason;
+      p.log.warn(`Skipping "${optionLabel(value)}" \u2014 ${reason}.`);
+    }
+  }
+  selection.interfaces = interfaces;
+  return {
+    projectName,
+    architecture: selection.architecture,
+    database: selection.database,
+    orm: selection.orm,
+    auth: selection.auth,
+    styling: selection.styling,
+    interfaces
+  };
+}
+
+// src/cli/selections.ts
+function projectNameFromArgs(args) {
+  const positionals = [...args.positionals];
+  if (positionals[0] === "create") positionals.shift();
+  return positionals[0];
+}
+function selectionsFromFlags(args) {
+  return {
+    projectName: projectNameFromArgs(args) ?? "my-app",
+    architecture: args.architecture ?? "monolith",
+    database: args.database ?? "postgres",
+    orm: args.orm ?? "prisma",
+    auth: args.auth ?? "nextauth",
+    styling: args.styling ?? "tailwind",
+    interfaces: args.interfaces ?? ["auth-pages"]
+  };
+}
+function validateSelections(s) {
+  const errors = [];
+  const check = (dim, value) => {
+    if (!SUPPORTED[dim].includes(value)) {
+      errors.push(
+        `${dim} "${value}" is not supported yet (currently generatable: ${SUPPORTED[dim].join(", ")}).`
+      );
+    }
+  };
+  check("architecture", s.architecture);
+  check("database", s.database);
+  check("orm", s.orm);
+  check("auth", s.auth);
+  check("styling", s.styling);
+  for (const i of s.interfaces) check("interfaces", i);
+  errors.push(...validateCompat(s));
+  return errors;
+}
+
+// src/cli/create.ts
+async function isEmptyDir(dir) {
+  try {
+    const entries = await fs7.readdir(dir);
+    return entries.length === 0;
+  } catch (err) {
+    if (err.code === "ENOENT") return true;
+    throw err;
+  }
+}
+async function runCreate(args) {
+  const selections = args.yes ? selectionsFromFlags(args) : await runWizard({ projectName: projectNameFromArgs(args) });
+  const errors = validateSelections(selections);
+  if (errors.length > 0) {
+    logger.error("\nStackr can't generate that stack yet:\n");
+    for (const e of errors) logger.error("  \u2022 " + e);
+    logger.dim("\nTry the v1 path: --architecture monolith --database postgres --orm prisma --auth nextauth --styling tailwind\n");
+    process.exit(1);
+  }
+  const projectDir = path22.resolve(process.cwd(), selections.projectName);
+  if (!await isEmptyDir(projectDir)) {
+    logger.error(`
+Target directory "${selections.projectName}" exists and is not empty. Aborting.`);
+    process.exit(1);
+  }
+  const spinner2 = p2.spinner();
+  spinner2.start("Scaffolding project");
+  try {
+    await scaffoldProject(getTemplateDir(), projectDir, selections);
+    spinner2.stop("Project scaffolded");
+  } catch (err) {
+    spinner2.stop("Scaffolding failed");
+    throw err;
+  }
+  let depsInstalled = false;
+  if (args.install !== false) {
+    const installSpinner = p2.spinner();
+    installSpinner.start("Installing dependencies (npm install)");
+    try {
+      await installDependencies(projectDir);
+      installSpinner.stop("Dependencies installed");
+      depsInstalled = true;
+    } catch {
+      installSpinner.stop("Dependency install skipped (run npm install manually)");
+    }
+  }
+  if (args.git !== false) {
+    if (await initGit(projectDir)) logger.dim("Initialized git repository.");
+  }
+  logger.success(`
+\u2714 Created ${pc.bold(selections.projectName)} (${optionLabel(selections.architecture)})`);
+  logNextSteps({ projectDir, selections, depsInstalled });
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var HELP = `
+create-stackrjs \u2014 scaffold a runnable full-stack Next.js project.
+
+Usage:
+  npm create stackrjs@latest [name] -- [options]
+  npx create-stackrjs [name] [options]
+
+Options:
+  --architecture <a>   monolith            (monorepo/microservices/bff: coming soon)
+  --database <db>      postgres            (mysql/sqlite/mongodb: coming soon)
+  --orm <orm>          prisma              (drizzle/mongoose: coming soon)
+  --auth <auth>        nextauth            (clerk/supabase/jwt: coming soon)
+  --styling <s>        tailwind            (css-modules/styled-components/shadcn: coming soon)
+  --interfaces <list>  comma-separated; v1: auth-pages
+  -y, --yes            skip the wizard, use flags + defaults
+  --ci                 non-interactive: implies --yes --no-install --no-git
+  --no-install         do not run npm install
+  --no-git             do not initialize a git repository
+  -h, --help           show this help
+  -v, --version        show version
+
+Examples:
+  npm create stackrjs@latest my-app
+  npx create-stackrjs my-app --yes
+  npx create-stackrjs demo --ci
+`;
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.version) {
+    console.log(version);
+    return;
+  }
+  if (args.help) {
+    console.log(HELP);
+    return;
+  }
+  await runCreate(args);
+}
+main().catch((err) => {
+  logger.error("\n" + (err instanceof Error ? err.stack ?? err.message : String(err)));
+  process.exit(1);
+});