create-cronus-stack 0.6.0 → 0.6.2

package/dist/scaffold.js

@@ -41,6 +41,79 @@ function cronusUiPaths(config) {
 function usesCronusUi(config) {
     return single(config, "ui") === "ui-cronus";
 }
+const SQL_DATABASES = new Set(["db-sqlite", "db-postgres", "db-mysql"]);
+const HOSTED_DB_SETUPS = new Set([
+    "dbsetup-turso",
+    "dbsetup-neon",
+    "dbsetup-supabase",
+    "dbsetup-planetscale",
+    "dbsetup-d1",
+    "dbsetup-atlas",
+]);
+function sqlDialect(config) {
+    switch (single(config, "database")) {
+        case "db-sqlite":
+            return "sqlite";
+        case "db-postgres":
+            return "postgresql";
+        case "db-mysql":
+            return "mysql";
+        default:
+            return undefined;
+    }
+}
+function emitsDrizzle(config) {
+    return (single(config, "web") === "web-next" &&
+        single(config, "orm") === "orm-drizzle" &&
+        SQL_DATABASES.has(single(config, "database") ?? ""));
+}
+function emitsBetterAuth(config) {
+    return emitsDrizzle(config) && single(config, "auth") === "auth-better-auth";
+}
+function usesImportAlias(config) {
+    return single(config, "importAlias") === "import-alias";
+}
+function sourceRoot(config) {
+    return single(config, "structure") === "structure-root" ? "" : "src/";
+}
+function dbDir(config) {
+    return `${sourceRoot(config)}db`;
+}
+function libDir(config) {
+    return `${sourceRoot(config)}lib`;
+}
+function defaultDatabaseUrl(config) {
+    switch (single(config, "database")) {
+        case "db-sqlite":
+            return "file:./data/app.db";
+        case "db-postgres":
+            return "postgres://postgres:postgres@localhost:5432/app";
+        case "db-mysql":
+            return "mysql://root:password@localhost:3306/app";
+        default:
+            return undefined;
+    }
+}
+function betterAuthProvider(config) {
+    switch (single(config, "database")) {
+        case "db-postgres":
+            return "pg";
+        case "db-mysql":
+            return "mysql";
+        default:
+            return "sqlite";
+    }
+}
+function dbModuleImport(config, subpath) {
+    const target = subpath ? `db/${subpath}` : "db";
+    return usesImportAlias(config) ? `@/${target}` : `../${target}`;
+}
+function authModuleImport(config) {
+    return usesImportAlias(config) ? "@/lib/auth" : "../../../../lib/auth";
+}
+function scriptCommand(pm, script) {
+    return pm === "npm" ? `npm run ${script}` : `${pm} ${script}`;
+}
 function packageJson(projectName, config) {
     const isNext = single(config, "web") === "web-next";
     const isCronusUi = usesCronusUi(config);
@@ -70,6 +143,25 @@ function packageJson(projectName, config) {
         add(devDeps, "@commitlint/cli", "^20.2.0");
         add(devDeps, "@commitlint/config-conventional", "^20.2.0");
     }
+    if (emitsDrizzle(config)) {
+        add(deps, "drizzle-orm", "^0.45.2");
+        add(devDeps, "drizzle-kit", "^0.31.10");
+        switch (single(config, "database")) {
+            case "db-sqlite":
+                add(deps, "better-sqlite3", "^12.0.0");
+                add(devDeps, "@types/better-sqlite3", "^9.6.0");
+                break;
+            case "db-postgres":
+                add(deps, "postgres", "^3.4.9");
+                break;
+            case "db-mysql":
+                add(deps, "mysql2", "^3.24.2");
+                break;
+        }
+    }
+    if (emitsBetterAuth(config)) {
+        add(deps, "better-auth", "^1.7.2");
+    }
     const scripts = isNext
         ? {
             dev: "next dev",
@@ -86,7 +178,12 @@ function packageJson(projectName, config) {
         scripts.lint = "biome check .";
         scripts.format = "biome format --write .";
     }
-    if (single(config, "database") !== "db-none") {
+    if (emitsDrizzle(config)) {
+        scripts["db:push"] = "drizzle-kit push";
+        scripts["db:generate"] = "drizzle-kit generate";
+        scripts["db:studio"] = "drizzle-kit studio";
+    }
+    else if (single(config, "database") !== "db-none") {
         scripts["db:push"] = 'echo "Configure the selected database/ORM before syncing schema."';
     }
     return `${JSON.stringify({
@@ -214,19 +311,95 @@ export default function RootLayout({ children }: { children: ReactNode }) {
 }
 `;
 }
-function pageTsx() {
+function fromAppImport(config, target) {
+    return usesImportAlias(config) ? `@/${target}` : `../${target}`;
+}
+function pageStatusCopy(config) {
+    if (emitsBetterAuth(config) && emitsDrizzle(config)) {
+        return `          {session ? (
+            <p className="max-w-prose text-fg-secondary">
+              Signed in as {session.user?.email}. {itemCount} items in the active workspace.
+            </p>
+          ) : (
+            <p className="max-w-prose text-fg-secondary">
+              Sign in required on this stack. Middleware redirects unsigned-in visitors to /login.
+            </p>
+          )}`;
+    }
+    if (emitsDrizzle(config)) {
+        return `          <p className="max-w-prose text-fg-secondary">
+            {itemCount} items in the database. Read KICKOFF.md before changing frameworks,
+            databases, auth, payments, or design-system rules.
+          </p>`;
+    }
+    return `          <p className="max-w-prose text-fg-secondary">
+            This app was scaffolded from the Cronus Stack Builder. Read KICKOFF.md before changing
+            frameworks, databases, auth, payments, or design-system rules.
+          </p>`;
+}
+function pageTsx(config) {
+    const withDrizzle = emitsDrizzle(config);
+    const withAuth = emitsBetterAuth(config);
+    const extraImports = [
+        withDrizzle && withAuth
+            ? 'import { count, eq } from "drizzle-orm";'
+            : withDrizzle
+                ? 'import { count } from "drizzle-orm";'
+                : undefined,
+        withAuth ? 'import { headers } from "next/headers";' : undefined,
+        withDrizzle ? `import { db } from "${fromAppImport(config, "db")}";` : undefined,
+        withDrizzle && withAuth
+            ? `import { items, member } from "${fromAppImport(config, "db/schema")}";`
+            : withDrizzle
+                ? `import { items } from "${fromAppImport(config, "db/schema")}";`
+                : undefined,
+        withAuth ? `import { auth } from "${fromAppImport(config, "lib/auth")}";` : undefined,
+    ]
+        .filter((line) => line !== undefined)
+        .join("\n");
+    const asyncKw = withDrizzle || withAuth ? "async " : "";
+    let loader = "";
+    if (withDrizzle && withAuth) {
+        loader = `  const session = await auth.api.getSession({ headers: await headers() });
+  let orgId = session?.session?.activeOrganizationId ?? null;
+  if (!orgId && session?.user?.id) {
+    const [row] = await db
+      .select({ organizationId: member.organizationId })
+      .from(member)
+      .where(eq(member.userId, session.user.id))
+      .limit(1);
+    orgId = row?.organizationId ?? null;
+  }
+  const [itemRow] = orgId
+    ? await db.select({ value: count() }).from(items).where(eq(items.workspaceId, orgId))
+    : [{ value: 0 }];
+  const itemCount = new Intl.NumberFormat("en-US").format(Number(itemRow?.value ?? 0));
+
+`;
+    }
+    else if (withDrizzle) {
+        loader = `  const [itemRow] = await db.select({ value: count() }).from(items);
+  const itemCount = new Intl.NumberFormat("en-US").format(Number(itemRow?.value ?? 0));
+
+`;
+    }
+    else if (withAuth) {
+        loader = `  const session = await auth.api.getSession({ headers: await headers() });
+
+`;
+    }
     return `import { Badge } from "@cronus-ui/ui/badge";
 import { Button } from "@cronus-ui/ui/button";
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@cronus-ui/ui/card";
-
+${extraImports ? `${extraImports}\n` : ""}
 const metrics = [
   { label: "Revenue", value: "R$ 48.2k" },
   { label: "Active users", value: "2,318" },
   { label: "NPS", value: "72" },
 ];
 
-export default function Page() {
-  return (
+export default ${asyncKw}function Page() {
+${loader}  return (
     <main className="mx-auto flex min-h-screen w-full max-w-5xl flex-col gap-8 px-6 py-12">
       <header className="flex flex-col gap-4">
         <Badge variant="primary" className="w-fit">
@@ -234,10 +407,7 @@ export default function Page() {
         </Badge>
         <div className="flex flex-col gap-3">
           <h1 className="text-4xl font-semibold tracking-tight text-fg">Your stack is ready</h1>
-          <p className="max-w-prose text-fg-secondary">
-            This app was scaffolded from the Cronus Stack Builder. Read KICKOFF.md before changing
-            frameworks, databases, auth, payments, or design-system rules.
-          </p>
+${pageStatusCopy(config)}
         </div>
         <div className="flex flex-wrap gap-3">
           <Button variant="primary">Start building</Button>
@@ -303,8 +473,12 @@ function basicIndex(projectName) {
 }
 function readme(projectName, config, unsupported) {
     const pm = packageManagerFromConfig(config);
-    const dev = pm === "npm" ? "npm run dev" : `${pm} dev`;
     const install = pm === "yarn" ? "yarn" : `${pm} install`;
+    const runLines = [install];
+    if (emitsDrizzle(config) && single(config, "database") === "db-sqlite") {
+        runLines.push(scriptCommand(pm, "db:push"));
+    }
+    runLines.push(scriptCommand(pm, "dev"));
     return `# ${projectName}
 
 Generated by \`create-cronus-stack\`.
@@ -315,8 +489,7 @@ conventions, AI capabilities, guardrails, and Definition of Done.
 ## Run
 
 \`\`\`sh
-${install}
-${dev}
+${runLines.join("\n")}
 \`\`\`
 
 ## Generated artifacts
@@ -330,16 +503,42 @@ ${unsupported.length ? `## Manual follow-up\n\n${unsupported.map((item) => `- ${
 }
 function envExample(config) {
     const lines = [];
-    if (single(config, "database") !== "db-none")
-        lines.push("DATABASE_URL=");
-    if (single(config, "auth") !== "auth-none")
+    if (single(config, "database") !== "db-none") {
+        const url = emitsDrizzle(config) ? (defaultDatabaseUrl(config) ?? "") : "";
+        lines.push(`DATABASE_URL=${url}`);
+    }
+    if (emitsBetterAuth(config)) {
+        lines.push("BETTER_AUTH_SECRET=change-me-to-a-32-character-secret");
+        lines.push("BETTER_AUTH_URL=http://localhost:3000");
+    }
+    else if (single(config, "auth") !== "auth-none") {
         lines.push("AUTH_SECRET=");
+    }
     if (single(config, "payments") !== "pay-none") {
         lines.push("PAYMENTS_SECRET_KEY=");
         lines.push("PAYMENTS_WEBHOOK_SECRET=");
     }
     return lines.length ? `${lines.join("\n")}\n` : undefined;
 }
+function gitignore(config) {
+    const lines = ["node_modules", ".next", "dist", ".env*", "!.env.example", ".DS_Store"];
+    if (emitsDrizzle(config)) {
+        lines.push("*.db", "data/", "drizzle/");
+    }
+    return `${lines.join("\n")}\n`;
+}
+function nextConfigMjs(config) {
+    const body = emitsDrizzle(config) && single(config, "database") === "db-sqlite"
+        ? `{
+  serverExternalPackages: ["better-sqlite3"],
+}`
+        : "{}";
+    return `/** @type {import('next').NextConfig} */
+const nextConfig = ${body};
+
+export default nextConfig;
+`;
+}
 function assistantIds(config) {
     const picked = new Set();
     for (const id of multi(config, "assistants")) {
@@ -354,6 +553,636 @@ function assistantIds(config) {
     }
     return [...picked];
 }
+const CATALOG_SKILL_TO_KIT = {
+    "skill-ui-add": "ui-add",
+    "skill-theme": "theme",
+    "skill-compose": "compose",
+    "skill-upgrade": "upgrade",
+    "skill-code-review": "code-review",
+    "skill-ship-pr": "ship-pr",
+    "skill-evidence-check": "evidence-check",
+};
+/** Catalog skill ids → AI Kit skills. Empty selection keeps the kit default. */
+function kitSkillsFromConfig(config) {
+    const selected = multi(config, "skills");
+    if (selected.length === 0)
+        return undefined;
+    const mapped = [];
+    for (const id of selected) {
+        const skill = CATALOG_SKILL_TO_KIT[id];
+        if (skill)
+            mapped.push(skill);
+    }
+    return mapped;
+}
+function drizzleConfig(config) {
+    const dialect = sqlDialect(config) ?? "sqlite";
+    const fallback = defaultDatabaseUrl(config) ?? "file:./data/app.db";
+    if (dialect === "sqlite") {
+        return `import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { defineConfig } from "drizzle-kit";
+
+const url = process.env.DATABASE_URL ?? "${fallback}";
+const fileFromUrl = url.startsWith("file:") ? url.slice("file:".length) : url;
+mkdirSync(dirname(fileFromUrl) || ".", { recursive: true });
+
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./${dbDir(config)}/schema.ts",
+  out: "./drizzle",
+  dbCredentials: { url },
+});
+`;
+    }
+    return `import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  dialect: "${dialect}",
+  schema: "./${dbDir(config)}/schema.ts",
+  out: "./drizzle",
+  dbCredentials: { url: process.env.DATABASE_URL ?? "${fallback}" },
+});
+`;
+}
+function sqliteAuthTables() {
+    return `
+export const user = sqliteTable("user", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  email: text("email").notNull().unique(),
+  emailVerified: integer("email_verified", { mode: "boolean" }).notNull(),
+  image: text("image"),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+});
+
+export const session = sqliteTable("session", {
+  id: text("id").primaryKey(),
+  expiresAt: integer("expires_at", { mode: "timestamp" }).notNull(),
+  token: text("token").notNull().unique(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+  ipAddress: text("ip_address"),
+  userAgent: text("user_agent"),
+  activeOrganizationId: text("active_organization_id"),
+  userId: text("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const account = sqliteTable("account", {
+  id: text("id").primaryKey(),
+  issuer: text("issuer").notNull(),
+  accountId: text("account_id").notNull(),
+  providerId: text("provider_id").notNull(),
+  userId: text("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+  accessToken: text("access_token"),
+  refreshToken: text("refresh_token"),
+  idToken: text("id_token"),
+  accessTokenExpiresAt: integer("access_token_expires_at", { mode: "timestamp" }),
+  refreshTokenExpiresAt: integer("refresh_token_expires_at", { mode: "timestamp" }),
+  scope: text("scope"),
+  password: text("password"),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+});
+
+export const verification = sqliteTable("verification", {
+  id: text("id").primaryKey(),
+  identifier: text("identifier").notNull(),
+  value: text("value").notNull(),
+  expiresAt: integer("expires_at", { mode: "timestamp" }).notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" }),
+  updatedAt: integer("updated_at", { mode: "timestamp" }),
+});
+
+export const organization = sqliteTable("organization", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  slug: text("slug").notNull().unique(),
+  logo: text("logo"),
+  metadata: text("metadata"),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+});
+
+export const member = sqliteTable("member", {
+  id: text("id").primaryKey(),
+  organizationId: text("organization_id")
+    .notNull()
+    .references(() => organization.id, { onDelete: "cascade" }),
+  userId: text("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+  role: text("role").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+});
+
+export const invitation = sqliteTable("invitation", {
+  id: text("id").primaryKey(),
+  organizationId: text("organization_id")
+    .notNull()
+    .references(() => organization.id, { onDelete: "cascade" }),
+  email: text("email").notNull(),
+  role: text("role"),
+  status: text("status").notNull(),
+  expiresAt: integer("expires_at", { mode: "timestamp" }).notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  inviterId: text("inviter_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+});
+`;
+}
+function pgAuthTables() {
+    return `
+export const user = pgTable("user", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  email: text("email").notNull().unique(),
+  emailVerified: boolean("email_verified").notNull(),
+  image: text("image"),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+});
+
+export const session = pgTable("session", {
+  id: text("id").primaryKey(),
+  expiresAt: timestamp("expires_at").notNull(),
+  token: text("token").notNull().unique(),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+  ipAddress: text("ip_address"),
+  userAgent: text("user_agent"),
+  activeOrganizationId: text("active_organization_id"),
+  userId: text("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const account = pgTable("account", {
+  id: text("id").primaryKey(),
+  issuer: text("issuer").notNull(),
+  accountId: text("account_id").notNull(),
+  providerId: text("provider_id").notNull(),
+  userId: text("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+  accessToken: text("access_token"),
+  refreshToken: text("refresh_token"),
+  idToken: text("id_token"),
+  accessTokenExpiresAt: timestamp("access_token_expires_at"),
+  refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+  scope: text("scope"),
+  password: text("password"),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+});
+
+export const verification = pgTable("verification", {
+  id: text("id").primaryKey(),
+  identifier: text("identifier").notNull(),
+  value: text("value").notNull(),
+  expiresAt: timestamp("expires_at").notNull(),
+  createdAt: timestamp("created_at"),
+  updatedAt: timestamp("updated_at"),
+});
+
+export const organization = pgTable("organization", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  slug: text("slug").notNull().unique(),
+  logo: text("logo"),
+  metadata: text("metadata"),
+  createdAt: timestamp("created_at").notNull(),
+});
+
+export const member = pgTable("member", {
+  id: text("id").primaryKey(),
+  organizationId: text("organization_id")
+    .notNull()
+    .references(() => organization.id, { onDelete: "cascade" }),
+  userId: text("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+  role: text("role").notNull(),
+  createdAt: timestamp("created_at").notNull(),
+});
+
+export const invitation = pgTable("invitation", {
+  id: text("id").primaryKey(),
+  organizationId: text("organization_id")
+    .notNull()
+    .references(() => organization.id, { onDelete: "cascade" }),
+  email: text("email").notNull(),
+  role: text("role"),
+  status: text("status").notNull(),
+  expiresAt: timestamp("expires_at").notNull(),
+  createdAt: timestamp("created_at").notNull(),
+  inviterId: text("inviter_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+});
+`;
+}
+function mysqlAuthTables() {
+    return `
+export const user = mysqlTable("user", {
+  id: varchar("id", { length: 36 }).primaryKey(),
+  name: varchar("name", { length: 255 }).notNull(),
+  email: varchar("email", { length: 255 }).notNull().unique(),
+  emailVerified: boolean("email_verified").notNull(),
+  image: text("image"),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+});
+
+export const session = mysqlTable("session", {
+  id: varchar("id", { length: 36 }).primaryKey(),
+  expiresAt: timestamp("expires_at").notNull(),
+  token: varchar("token", { length: 255 }).notNull().unique(),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+  ipAddress: text("ip_address"),
+  userAgent: text("user_agent"),
+  activeOrganizationId: varchar("active_organization_id", { length: 36 }),
+  userId: varchar("user_id", { length: 36 })
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const account = mysqlTable("account", {
+  id: varchar("id", { length: 36 }).primaryKey(),
+  issuer: varchar("issuer", { length: 255 }).notNull(),
+  accountId: varchar("account_id", { length: 255 }).notNull(),
+  providerId: varchar("provider_id", { length: 255 }).notNull(),
+  userId: varchar("user_id", { length: 36 })
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+  accessToken: text("access_token"),
+  refreshToken: text("refresh_token"),
+  idToken: text("id_token"),
+  accessTokenExpiresAt: timestamp("access_token_expires_at"),
+  refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+  scope: text("scope"),
+  password: text("password"),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull(),
+});
+
+export const verification = mysqlTable("verification", {
+  id: varchar("id", { length: 36 }).primaryKey(),
+  identifier: varchar("identifier", { length: 255 }).notNull(),
+  value: text("value").notNull(),
+  expiresAt: timestamp("expires_at").notNull(),
+  createdAt: timestamp("created_at"),
+  updatedAt: timestamp("updated_at"),
+});
+
+export const organization = mysqlTable("organization", {
+  id: varchar("id", { length: 36 }).primaryKey(),
+  name: varchar("name", { length: 255 }).notNull(),
+  slug: varchar("slug", { length: 255 }).notNull().unique(),
+  logo: text("logo"),
+  metadata: text("metadata"),
+  createdAt: timestamp("created_at").notNull(),
+});
+
+export const member = mysqlTable("member", {
+  id: varchar("id", { length: 36 }).primaryKey(),
+  organizationId: varchar("organization_id", { length: 36 })
+    .notNull()
+    .references(() => organization.id, { onDelete: "cascade" }),
+  userId: varchar("user_id", { length: 36 })
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+  role: varchar("role", { length: 255 }).notNull(),
+  createdAt: timestamp("created_at").notNull(),
+});
+
+export const invitation = mysqlTable("invitation", {
+  id: varchar("id", { length: 36 }).primaryKey(),
+  organizationId: varchar("organization_id", { length: 36 })
+    .notNull()
+    .references(() => organization.id, { onDelete: "cascade" }),
+  email: varchar("email", { length: 255 }).notNull(),
+  role: varchar("role", { length: 255 }),
+  status: varchar("status", { length: 255 }).notNull(),
+  expiresAt: timestamp("expires_at").notNull(),
+  createdAt: timestamp("created_at").notNull(),
+  inviterId: varchar("inviter_id", { length: 36 })
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+});
+`;
+}
+function drizzleSchema(config) {
+    const withAuth = emitsBetterAuth(config);
+    switch (sqlDialect(config)) {
+        case "postgresql": {
+            const imports = withAuth
+                ? 'import { boolean, integer, pgTable, text, timestamp } from "drizzle-orm/pg-core";'
+                : 'import { integer, pgTable, text } from "drizzle-orm/pg-core";';
+            const workspaceCol = withAuth
+                ? `\n  workspaceId: text("workspace_id").references(() => organization.id, { onDelete: "cascade" }),`
+                : "";
+            return `${imports}
+${withAuth ? pgAuthTables() : ""}
+export const items = pgTable("items", {
+  id: integer("id").primaryKey().generatedAlwaysAsIdentity(),
+  title: text("title").notNull(),${workspaceCol}
+});
+`;
+        }
+        case "mysql": {
+            const imports = withAuth
+                ? 'import { boolean, int, mysqlTable, text, timestamp, varchar } from "drizzle-orm/mysql-core";'
+                : 'import { int, mysqlTable, varchar } from "drizzle-orm/mysql-core";';
+            const workspaceCol = withAuth
+                ? `\n  workspaceId: varchar("workspace_id", { length: 36 }).references(() => organization.id, { onDelete: "cascade" }),`
+                : "";
+            return `${imports}
+${withAuth ? mysqlAuthTables() : ""}
+export const items = mysqlTable("items", {
+  id: int("id").autoincrement().primaryKey(),
+  title: varchar("title", { length: 255 }).notNull(),${workspaceCol}
+});
+`;
+        }
+        default: {
+            const workspaceCol = withAuth
+                ? `\n  workspaceId: text("workspace_id").references(() => organization.id, { onDelete: "cascade" }),`
+                : "";
+            return `import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+${withAuth ? sqliteAuthTables() : ""}
+export const items = sqliteTable("items", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  title: text("title").notNull(),${workspaceCol}
+});
+`;
+        }
+    }
+}
+function drizzleClient(config) {
+    const fallback = defaultDatabaseUrl(config) ?? "file:./data/app.db";
+    switch (sqlDialect(config)) {
+        case "postgresql":
+            return `import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as schema from "./schema";
+
+const url = process.env.DATABASE_URL ?? "${fallback}";
+const client = postgres(url);
+
+export const db = drizzle(client, { schema });
+`;
+        case "mysql":
+            return `import { drizzle } from "drizzle-orm/mysql2";
+import mysql from "mysql2/promise";
+import * as schema from "./schema";
+
+const url = process.env.DATABASE_URL ?? "${fallback}";
+const pool = mysql.createPool(url);
+
+export const db = drizzle(pool, { schema, mode: "default" });
+`;
+        default:
+            return `import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as schema from "./schema";
+
+const url = process.env.DATABASE_URL ?? "${fallback}";
+const fileFromUrl = url.startsWith("file:") ? url.slice("file:".length) : url;
+mkdirSync(dirname(fileFromUrl) || ".", { recursive: true });
+const sqlite = new Database(fileFromUrl);
+
+export const db = drizzle(sqlite, { schema });
+`;
+    }
+}
+function betterAuthServer(config) {
+    const provider = betterAuthProvider(config);
+    const dbImport = dbModuleImport(config);
+    const schemaImport = dbModuleImport(config, "schema");
+    return `import { betterAuth } from "better-auth";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { nextCookies } from "better-auth/next-js";
+import { organization } from "better-auth/plugins";
+import { and, eq } from "drizzle-orm";
+import { db } from "${dbImport}";
+import * as schema from "${schemaImport}";
+import {
+  invitation as invitationTable,
+  member,
+  organization as organizationTable,
+  user as userTable,
+} from "${schemaImport}";
+
+function newId(): string {
+  return crypto.randomUUID().replaceAll("-", "");
+}
+
+export const auth = betterAuth({
+  database: drizzleAdapter(db, { provider: "${provider}", schema }),
+  emailAndPassword: {
+    enabled: true,
+    sendResetPassword: async ({ url }) => {
+      console.info("Password reset URL:", url);
+    },
+  },
+  databaseHooks: {
+    session: {
+      create: {
+        before: async (session) => {
+          const [existing] = await db
+            .select({ organizationId: member.organizationId })
+            .from(member)
+            .where(eq(member.userId, session.userId))
+            .limit(1);
+          if (existing?.organizationId) {
+            return { data: { ...session, activeOrganizationId: existing.organizationId } };
+          }
+          const [owner] = await db
+            .select({ name: userTable.name, email: userTable.email })
+            .from(userTable)
+            .where(eq(userTable.id, session.userId))
+            .limit(1);
+          if (owner?.email) {
+            const [pending] = await db
+              .select({ id: invitationTable.id })
+              .from(invitationTable)
+              .where(
+                and(eq(invitationTable.email, owner.email), eq(invitationTable.status, "pending")),
+              )
+              .limit(1);
+            if (pending) return;
+          }
+          const orgId = newId();
+          const now = new Date();
+          await db.insert(organizationTable).values({
+            id: orgId,
+            name: owner?.name.trim() || "Workspace",
+            slug: \`ws-\${session.userId.slice(0, 16)}\`,
+            createdAt: now,
+          });
+          await db.insert(member).values({
+            id: newId(),
+            organizationId: orgId,
+            userId: session.userId,
+            role: "owner",
+            createdAt: now,
+          });
+          return { data: { ...session, activeOrganizationId: orgId } };
+        },
+      },
+    },
+  },
+  plugins: [
+    organization({
+      sendInvitationEmail: async (data) => {
+        const base = process.env.BETTER_AUTH_URL ?? "http://localhost:3000";
+        console.info(\`Invite \${data.email}: \${base}/accept-invitation?id=\${data.id}\`);
+      },
+    }),
+    nextCookies(),
+  ],
+  secret: process.env.BETTER_AUTH_SECRET,
+  baseURL: process.env.BETTER_AUTH_URL,
+});
+`;
+}
+function betterAuthMiddleware() {
+    return `import { NextRequest, NextResponse } from "next/server";
+import { getSessionCookie } from "better-auth/cookies";
+
+const AUTH_PAGES = ["/login", "/signup", "/forgot-password"];
+
+function invitationOf(request: NextRequest): string | null {
+  const { pathname, searchParams } = request.nextUrl;
+  return (
+    searchParams.get("invitation") ??
+    (pathname === "/accept-invitation" ? searchParams.get("id") : null)
+  );
+}
+
+export function middleware(request: NextRequest) {
+  const sessionCookie = getSessionCookie(request);
+  const path = request.nextUrl.pathname;
+  const isAuthPage = AUTH_PAGES.includes(path);
+  const invitation = invitationOf(request);
+  if (!sessionCookie && path === "/accept-invitation") {
+    const url = new URL("/signup", request.url);
+    if (invitation) url.searchParams.set("invitation", invitation);
+    return NextResponse.redirect(url);
+  }
+  if (!sessionCookie && !isAuthPage) {
+    const url = new URL("/login", request.url);
+    if (invitation) url.searchParams.set("invitation", invitation);
+    return NextResponse.redirect(url);
+  }
+  if (sessionCookie && isAuthPage) {
+    if (invitation) {
+      return NextResponse.redirect(
+        new URL(\`/accept-invitation?id=\${encodeURIComponent(invitation)}\`, request.url),
+      );
+    }
+    return NextResponse.redirect(new URL("/", request.url));
+  }
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: ["/((?!api/auth|_next/static|_next/image|favicon.ico|.*\\\\..*).*)"],
+};
+`;
+}
+function acceptInvitationPage(config) {
+    const authClientImport = fromAppImport(config, "lib/auth-client");
+    return `"use client";
+
+import { Suspense, useEffect, useState } from "react";
+import { useRouter, useSearchParams } from "next/navigation";
+import { authClient } from "${authClientImport}";
+
+function AcceptInvitation() {
+  const router = useRouter();
+  const params = useSearchParams();
+  const id = params.get("id") ?? params.get("invitation");
+  const { data: session, isPending } = authClient.useSession();
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (isPending) return;
+    if (!id) {
+      setError("Invitation is missing.");
+      return;
+    }
+    if (!session) {
+      router.replace(\`/signup?invitation=\${encodeURIComponent(id)}\`);
+      return;
+    }
+    let cancelled = false;
+    void (async () => {
+      const { data, error: acceptError } = await authClient.organization.acceptInvitation({
+        invitationId: id,
+      });
+      if (cancelled) return;
+      if (acceptError) {
+        setError(acceptError.message || "Could not accept invitation.");
+        return;
+      }
+      const orgId = data?.invitation?.organizationId ?? data?.member?.organizationId;
+      if (orgId) {
+        await authClient.organization.setActive({ organizationId: orgId });
+      }
+      try {
+        sessionStorage.removeItem("cronus-invitation");
+      } catch {
+        // ignore
+      }
+      window.location.assign("/");
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [id, isPending, router, session]);
+
+  return (
+    <main>
+      {error ? <p role="alert">{error}</p> : <p>Accepting invitation…</p>}
+    </main>
+  );
+}
+
+export default function AcceptInvitationPage() {
+  return (
+    <Suspense fallback={<main><p>Accepting invitation…</p></main>}>
+      <AcceptInvitation />
+    </Suspense>
+  );
+}
+`;
+}
+function betterAuthClient() {
+    return `import { organizationClient } from "better-auth/client/plugins";
+import { createAuthClient } from "better-auth/react";
+
+export const authClient = createAuthClient({
+  plugins: [organizationClient()],
+});
+`;
+}
+function betterAuthRoute(config) {
+    return `import { auth } from "${authModuleImport(config)}";
+import { toNextJsHandler } from "better-auth/next-js";
+
+export const { GET, POST } = toNextJsHandler(auth);
+`;
+}
 function unsupportedNotes(config) {
     const notes = [];
     if (single(config, "web") !== "web-next") {
@@ -367,10 +1196,15 @@ function unsupportedNotes(config) {
         single(config, "backend") !== "backend-fullstack-next") {
         notes.push("Add the selected dedicated backend service described in KICKOFF.md.");
     }
-    if (single(config, "database") !== "db-none") {
+    if (emitsDrizzle(config)) {
+        if (HOSTED_DB_SETUPS.has(single(config, "dbSetup") ?? "")) {
+            notes.push("Configure the selected hosted database provider; generated Drizzle files use a local DATABASE_URL.");
+        }
+    }
+    else if (single(config, "database") !== "db-none") {
         notes.push("Wire the selected database/ORM/provider before running db:push.");
     }
-    if (single(config, "auth") !== "auth-none") {
+    if (!emitsBetterAuth(config) && single(config, "auth") !== "auth-none") {
         notes.push("Implement the selected auth provider and protect mutating routes.");
     }
     if (single(config, "payments") !== "pay-none") {
@@ -388,9 +1222,6 @@ function unsupportedNotes(config) {
     if (mcpIds.includes("mcp-cronus-ui") && !usesCronusUi(config)) {
         notes.push("The cronus-ui MCP server is not generated for stacks that do not use Cronus UI.");
     }
-    if (multi(config, "skills").length > 0) {
-        notes.push("Install the selected agent skill packs in your agent environment; KICKOFF.md records the choices but the scaffold does not install external skills.");
-    }
     const unsupportedAddons = multi(config, "addons").filter((id) => id !== "addon-biome");
     if (unsupportedAddons.length > 0) {
         notes.push("Wire the selected addons manually unless noted otherwise; this generator currently scaffolds Biome config and records the rest in KICKOFF.md.");
@@ -418,7 +1249,7 @@ export function scaffoldStack(options) {
     emit("README.md", readme(projectName, config, unsupported));
     emit("KICKOFF.md", generateKickoff(config, projectName, catalog));
     emit("stack.json", `${generateStackJson(config, projectName)}\n`);
-    emit(".gitignore", "node_modules\n.next\ndist\n.env*\n!.env.example\n.DS_Store\n");
+    emit(".gitignore", gitignore(config));
     emit("tsconfig.json", tsconfig(config));
     emit(".env.example", envExample(config));
     if (single(config, "commitStyle") === "commit-conventional") {
@@ -429,13 +1260,13 @@ export function scaffoldStack(options) {
     }
     if (single(config, "web") === "web-next") {
         const isCronusUi = usesCronusUi(config);
-        emit("next.config.mjs", "/** @type {import('next').NextConfig} */\nconst nextConfig = {};\n\nexport default nextConfig;\n");
+        emit("next.config.mjs", nextConfigMjs(config));
         const app = appDir(config);
         if (isCronusUi) {
             emit("postcss.config.mjs", 'export default { plugins: { "@tailwindcss/postcss": {} } };\n');
             emit(`${app}/globals.css`, globalsCss(config));
             emit(`${app}/layout.tsx`, layoutTsx(projectName));
-            emit(`${app}/page.tsx`, pageTsx());
+            emit(`${app}/page.tsx`, pageTsx(config));
             emit("cronus-ui.json", `${JSON.stringify({
                 aliases: { ui: "@/components/ui", lib: "@/lib", blocks: "@/components/blocks" },
                 paths: cronusUiPaths(config),
@@ -448,6 +1279,18 @@ export function scaffoldStack(options) {
             emit(`${app}/layout.tsx`, neutralLayoutTsx(projectName));
             emit(`${app}/page.tsx`, neutralPageTsx(config));
         }
+        if (emitsDrizzle(config)) {
+            emit("drizzle.config.ts", drizzleConfig(config));
+            emit(`${dbDir(config)}/schema.ts`, drizzleSchema(config));
+            emit(`${dbDir(config)}/index.ts`, drizzleClient(config));
+        }
+        if (emitsBetterAuth(config)) {
+            emit(`${libDir(config)}/auth.ts`, betterAuthServer(config));
+            emit(`${libDir(config)}/auth-client.ts`, betterAuthClient());
+            emit(`${app}/api/auth/[...all]/route.ts`, betterAuthRoute(config));
+            emit(single(config, "structure") === "structure-root" ? "middleware.ts" : "src/middleware.ts", betterAuthMiddleware());
+            emit(`${app}/accept-invitation/page.tsx`, acceptInvitationPage(config));
+        }
     }
     else {
         emit("src/index.ts", basicIndex(projectName));
@@ -461,6 +1304,7 @@ export function scaffoldStack(options) {
             name: projectName,
             assistants,
             preset: "standard",
+            skills: kitSkillsFromConfig(config),
             includeCronusUi: isCronusUi,
             cronusUiMcp,
         });

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const CREATE_STACK_VERSION = "0.6.0";
+export declare const CREATE_STACK_VERSION = "0.6.2";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,2 +1,2 @@
-export const CREATE_STACK_VERSION = "0.6.0";
+export const CREATE_STACK_VERSION = "0.6.2";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-cronus-stack",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Scaffold a Cronus stack from the Cronus Stack Builder contract: app files, stack.json, KICKOFF.md, and optional AI Kit.",
   "type": "module",
   "license": "MIT",
@@ -44,8 +44,8 @@
     "prepublishOnly": "tsc -p tsconfig.json"
   },
   "dependencies": {
-    "@cronus-ui/ai-kit": "0.6.0",
-    "@cronus-ui/stack": "0.6.0"
+    "@cronus-ui/ai-kit": "0.6.2",
+    "@cronus-ui/stack": "0.6.2"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",