saas-init 1.0.0

package/dist/index.js

@@ -0,0 +1,765 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { execSync } from "child_process";
+import * as p7 from "@clack/prompts";
+
+// src/types.ts
+import { z } from "zod";
+var projectConfigSchema = z.object({
+  name: z.string().min(1),
+  outDir: z.string().min(1),
+  auth: z.enum(["clerk", "nextauth", "supabase"]),
+  database: z.enum(["postgres", "sqlite", "supabase"]),
+  payments: z.enum(["stripe", "lemonsqueezy"]).nullable(),
+  email: z.enum(["resend", "postmark"]).nullable()
+});
+
+// src/prompts/project.ts
+import path from "path";
+import * as p from "@clack/prompts";
+function isValidNpmName(value) {
+  if (!value) return "Project name is required";
+  if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(value) && !/^[a-z0-9]$/.test(value)) {
+    return "Name must be lowercase, contain only letters, digits, and hyphens";
+  }
+  return true;
+}
+async function promptProject() {
+  const name = await p.text({
+    message: "Project name",
+    placeholder: "my-app",
+    validate: (value) => {
+      const result = isValidNpmName(value);
+      if (result !== true) return result;
+    }
+  });
+  if (p.isCancel(name)) {
+    p.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const outDir = await p.text({
+    message: "Output directory",
+    placeholder: `./${name}`,
+    defaultValue: `./${name}`,
+    validate: (value) => {
+      const resolved = path.resolve(value || `./${name}`);
+      const cwd = path.resolve(process.cwd());
+      if (!resolved.startsWith(cwd + path.sep) && resolved !== cwd) {
+        return "Output directory must be inside the current working directory";
+      }
+    }
+  });
+  if (p.isCancel(outDir)) {
+    p.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  return { name, outDir: path.resolve(outDir || `./${name}`) };
+}
+
+// src/prompts/auth.ts
+import * as p2 from "@clack/prompts";
+async function promptAuth() {
+  const auth = await p2.select({
+    message: "Auth provider",
+    options: [
+      { value: "clerk", label: "Clerk" },
+      { value: "nextauth", label: "NextAuth" },
+      { value: "supabase", label: "Supabase Auth" }
+    ]
+  });
+  if (p2.isCancel(auth)) {
+    p2.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  return { auth };
+}
+
+// src/prompts/database.ts
+import * as p3 from "@clack/prompts";
+async function promptDatabase() {
+  const database = await p3.select({
+    message: "Database",
+    options: [
+      { value: "postgres", label: "Postgres" },
+      { value: "sqlite", label: "SQLite" },
+      { value: "supabase", label: "Supabase" }
+    ]
+  });
+  if (p3.isCancel(database)) {
+    p3.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  return { database };
+}
+
+// src/prompts/payments.ts
+import * as p4 from "@clack/prompts";
+async function promptPayments() {
+  const payments = await p4.select({
+    message: "Payments provider",
+    options: [
+      { value: "stripe", label: "Stripe" },
+      { value: "lemonsqueezy", label: "Lemon Squeezy" },
+      { value: "none", label: "Skip" }
+    ]
+  });
+  if (p4.isCancel(payments)) {
+    p4.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  return { payments: payments === "none" ? null : payments };
+}
+
+// src/prompts/email.ts
+import * as p5 from "@clack/prompts";
+async function promptEmail() {
+  const email = await p5.select({
+    message: "Email provider",
+    options: [
+      { value: "resend", label: "Resend" },
+      { value: "postmark", label: "Postmark" },
+      { value: "none", label: "Skip" }
+    ]
+  });
+  if (p5.isCancel(email)) {
+    p5.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  return { email: email === "none" ? null : email };
+}
+
+// src/prompts/summary.ts
+import * as p6 from "@clack/prompts";
+async function promptSummary(config) {
+  const lines = [
+    `  name:      ${config.name}`,
+    `  outDir:    ${config.outDir}`,
+    `  auth:      ${config.auth}`,
+    `  database:  ${config.database}`,
+    `  payments:  ${config.payments ?? "none"}`,
+    `  email:     ${config.email ?? "none"}`
+  ];
+  p6.note(lines.join("\n"), "Project configuration");
+  const confirmed = await p6.confirm({ message: "Generate project?" });
+  if (p6.isCancel(confirmed) || confirmed === false) {
+    p6.cancel("Aborted");
+    process.exit(0);
+  }
+}
+
+// src/generators/index.ts
+import fs13 from "fs-extra";
+
+// src/generators/base.ts
+import path4 from "path";
+import fs2 from "fs-extra";
+
+// src/utils/files.ts
+import fs from "fs-extra";
+import path2 from "path";
+
+// src/utils/template.ts
+function replaceVars(content, vars) {
+  return content.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    return Object.prototype.hasOwnProperty.call(vars, key) ? vars[key] ?? match : match;
+  });
+}
+
+// src/utils/files.ts
+async function writeTemplate(templatePath, destPath, vars) {
+  try {
+    const content = await fs.readFile(templatePath, "utf-8");
+    const substituted = replaceVars(content, vars);
+    await fs.ensureDir(path2.dirname(destPath));
+    await fs.writeFile(destPath, substituted, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to write template from ${templatePath} to ${destPath}: ${message}`);
+  }
+}
+async function appendEnv(destPath, vars) {
+  const envFile = path2.join(destPath, ".env.example");
+  let existing = "";
+  if (await fs.pathExists(envFile)) {
+    existing = await fs.readFile(envFile, "utf-8");
+  }
+  const existingKeys = new Set(
+    existing.split("\n").filter((line) => !line.trimStart().startsWith("#") && line.includes("=")).map((line) => line.substring(0, line.indexOf("=")).trim()).filter(Boolean)
+  );
+  const newLines = Object.entries(vars).filter(([key]) => !existingKeys.has(key)).map(([key, value]) => `${key}=${value}`);
+  if (newLines.length === 0) return;
+  const toAppend = existing.endsWith("\n") || existing === "" ? newLines.join("\n") + "\n" : "\n" + newLines.join("\n") + "\n";
+  await fs.appendFile(envFile, toAppend, "utf-8");
+}
+
+// src/utils/deps.ts
+function mergeDeps(base, additions) {
+  return { ...base, ...additions };
+}
+
+// src/utils/paths.ts
+import path3 from "path";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+function findTemplatesRoot() {
+  let dir = path3.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 10; i++) {
+    const candidate = path3.join(dir, "templates");
+    if (existsSync(candidate)) return candidate;
+    const parent = path3.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error("Could not find templates directory");
+}
+var TEMPLATES_ROOT = findTemplatesRoot();
+
+// src/generators/base.ts
+var TEMPLATES_DIR = path4.join(TEMPLATES_ROOT, "base");
+async function generate(config, outDir) {
+  const vars = { name: config.name };
+  const files = [
+    ["app/layout.tsx", "app/layout.tsx"],
+    ["app/page.tsx", "app/page.tsx"],
+    ["app/globals.css", "app/globals.css"],
+    ["next.config.ts", "next.config.ts"],
+    ["tsconfig.json", "tsconfig.json"],
+    ["package.json", "package.json"],
+    [".gitignore", ".gitignore"],
+    ["postcss.config.mjs", "postcss.config.mjs"],
+    ["lib/utils.ts", "lib/utils.ts"],
+    ["components.json", "components.json"]
+  ];
+  await Promise.all(
+    files.map(
+      ([templateFile, destFile]) => writeTemplate(
+        path4.join(TEMPLATES_DIR, templateFile),
+        path4.join(outDir, destFile),
+        vars
+      )
+    )
+  );
+  const pkgPath = path4.join(outDir, "package.json");
+  const pkg = await fs2.readJson(pkgPath);
+  pkg.dependencies = mergeDeps(pkg.dependencies ?? {}, {
+    clsx: "^2.0.0",
+    "tailwind-merge": "^2.0.0"
+  });
+  pkg.devDependencies = mergeDeps(pkg.devDependencies ?? {}, {
+    tailwindcss: "^4.0.0",
+    "@tailwindcss/postcss": "^4.0.0"
+  });
+  await fs2.writeJson(pkgPath, pkg, { spaces: 2 });
+}
+
+// src/generators/auth/clerk.ts
+import path5 from "path";
+import fs3 from "fs-extra";
+var TEMPLATES_DIR2 = path5.join(TEMPLATES_ROOT, "auth/clerk");
+async function generate2(config, outDir) {
+  const files = [
+    ["middleware.ts", "middleware.ts"],
+    ["app/sign-in/[[...sign-in]]/page.tsx", "app/sign-in/[[...sign-in]]/page.tsx"],
+    ["app/sign-up/[[...sign-up]]/page.tsx", "app/sign-up/[[...sign-up]]/page.tsx"]
+  ];
+  await Promise.all(
+    files.map(
+      ([templateFile, destFile]) => writeTemplate(
+        path5.join(TEMPLATES_DIR2, templateFile),
+        path5.join(outDir, destFile),
+        {}
+      )
+    )
+  );
+  const pkgPath = path5.join(outDir, "package.json");
+  const pkg = await fs3.readJson(pkgPath);
+  pkg.dependencies = mergeDeps(pkg.dependencies ?? {}, {
+    "@clerk/nextjs": "^6.0.0"
+  });
+  await fs3.writeJson(pkgPath, pkg, { spaces: 2 });
+  await appendEnv(outDir, {
+    NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY: "pk_CHANGE_ME_clerk_publishable_key",
+    CLERK_SECRET_KEY: "sk_CHANGE_ME_clerk_secret_key"
+  });
+}
+
+// src/generators/auth/nextauth.ts
+import path6 from "path";
+import fs4 from "fs-extra";
+var TEMPLATES_DIR3 = path6.join(TEMPLATES_ROOT, "auth/nextauth");
+async function generate3(config, outDir) {
+  const files = [
+    ["app/api/auth/route.ts", "app/api/auth/[...nextauth]/route.ts"],
+    ["auth.ts", "auth.ts"]
+  ];
+  await Promise.all(
+    files.map(
+      ([templateFile, destFile]) => writeTemplate(
+        path6.join(TEMPLATES_DIR3, templateFile),
+        path6.join(outDir, destFile),
+        {}
+      )
+    )
+  );
+  const pkgPath = path6.join(outDir, "package.json");
+  const pkg = await fs4.readJson(pkgPath);
+  pkg.dependencies = mergeDeps(pkg.dependencies ?? {}, {
+    "next-auth": "^5.0.0-beta.25"
+  });
+  await fs4.writeJson(pkgPath, pkg, { spaces: 2 });
+  await appendEnv(outDir, {
+    AUTH_SECRET: "your_auth_secret_here",
+    AUTH_URL: "http://localhost:3000"
+  });
+}
+
+// src/generators/auth/supabase-auth.ts
+import path7 from "path";
+import fs5 from "fs-extra";
+var TEMPLATES_DIR4 = path7.join(TEMPLATES_ROOT, "auth/supabase");
+async function generate4(config, outDir) {
+  const files = [
+    ["utils/supabase/client.ts", "utils/supabase/client.ts"],
+    ["utils/supabase/server.ts", "utils/supabase/server.ts"],
+    ["middleware.ts", "middleware.ts"]
+  ];
+  await Promise.all(
+    files.map(
+      ([templateFile, destFile]) => writeTemplate(
+        path7.join(TEMPLATES_DIR4, templateFile),
+        path7.join(outDir, destFile),
+        {}
+      )
+    )
+  );
+  const pkgPath = path7.join(outDir, "package.json");
+  const pkg = await fs5.readJson(pkgPath);
+  pkg.dependencies = mergeDeps(pkg.dependencies ?? {}, {
+    "@supabase/ssr": "^0.5.0",
+    "@supabase/supabase-js": "^2.0.0"
+  });
+  await fs5.writeJson(pkgPath, pkg, { spaces: 2 });
+  await appendEnv(outDir, {
+    NEXT_PUBLIC_SUPABASE_URL: "https://your-project.supabase.co",
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: "your_supabase_anon_key"
+  });
+}
+
+// src/generators/database/postgres.ts
+import path8 from "path";
+import fs6 from "fs-extra";
+var TEMPLATES_DIR5 = path8.join(TEMPLATES_ROOT, "database/postgres");
+async function generate5(config, outDir) {
+  const files = [
+    ["drizzle.config.ts", "drizzle.config.ts"],
+    ["db/schema.ts", "db/schema.ts"],
+    ["db/index.ts", "db/index.ts"]
+  ];
+  await Promise.all(
+    files.map(
+      ([templateFile, destFile]) => writeTemplate(
+        path8.join(TEMPLATES_DIR5, templateFile),
+        path8.join(outDir, destFile),
+        {}
+      )
+    )
+  );
+  const pkgPath = path8.join(outDir, "package.json");
+  const pkg = await fs6.readJson(pkgPath);
+  pkg.dependencies = mergeDeps(pkg.dependencies ?? {}, {
+    "drizzle-orm": "^0.30.0",
+    postgres: "^3.4.0"
+  });
+  pkg.devDependencies = mergeDeps(pkg.devDependencies ?? {}, {
+    "drizzle-kit": "^0.20.0"
+  });
+  await fs6.writeJson(pkgPath, pkg, { spaces: 2 });
+  await appendEnv(outDir, {
+    DATABASE_URL: "postgresql://user:password@localhost:5432/mydb"
+  });
+}
+
+// src/generators/database/sqlite.ts
+import path9 from "path";
+import fs7 from "fs-extra";
+var TEMPLATES_DIR6 = path9.join(TEMPLATES_ROOT, "database/sqlite");
+async function generate6(config, outDir) {
+  const files = [
+    ["drizzle.config.ts", "drizzle.config.ts"],
+    ["db/schema.ts", "db/schema.ts"],
+    ["db/index.ts", "db/index.ts"]
+  ];
+  await Promise.all(
+    files.map(
+      ([templateFile, destFile]) => writeTemplate(
+        path9.join(TEMPLATES_DIR6, templateFile),
+        path9.join(outDir, destFile),
+        {}
+      )
+    )
+  );
+  const pkgPath = path9.join(outDir, "package.json");
+  const pkg = await fs7.readJson(pkgPath);
+  pkg.dependencies = mergeDeps(pkg.dependencies ?? {}, {
+    "drizzle-orm": "^0.30.0",
+    "better-sqlite3": "^9.0.0"
+  });
+  pkg.devDependencies = mergeDeps(pkg.devDependencies ?? {}, {
+    "drizzle-kit": "^0.20.0",
+    "@types/better-sqlite3": "^9.0.0"
+  });
+  await fs7.writeJson(pkgPath, pkg, { spaces: 2 });
+}
+
+// src/generators/database/supabase-db.ts
+import path10 from "path";
+import fs8 from "fs-extra";
+var TEMPLATES_DIR7 = path10.join(TEMPLATES_ROOT, "database/supabase");
+async function generate7(config, outDir) {
+  await writeTemplate(
+    path10.join(TEMPLATES_DIR7, "utils/supabase/db.ts"),
+    path10.join(outDir, "utils/supabase/db.ts"),
+    {}
+  );
+  if (config.auth !== "supabase") {
+    await writeTemplate(
+      path10.join(TEMPLATES_DIR7, "utils/supabase/client.ts"),
+      path10.join(outDir, "utils/supabase/client.ts"),
+      {}
+    );
+  }
+  const pkgPath = path10.join(outDir, "package.json");
+  const pkg = await fs8.readJson(pkgPath);
+  pkg.dependencies = mergeDeps(pkg.dependencies ?? {}, {
+    "@supabase/supabase-js": "^2.0.0"
+  });
+  await fs8.writeJson(pkgPath, pkg, { spaces: 2 });
+  await appendEnv(outDir, {
+    NEXT_PUBLIC_SUPABASE_URL: "https://your-project.supabase.co",
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: "your_supabase_anon_key"
+  });
+}
+
+// src/generators/payments/stripe.ts
+import path11 from "path";
+import fs9 from "fs-extra";
+var TEMPLATES_DIR8 = path11.join(TEMPLATES_ROOT, "payments/stripe");
+async function generate8(config, outDir) {
+  const files = [
+    ["lib/stripe.ts", "lib/stripe.ts"],
+    ["app/api/webhooks/stripe/route.ts", "app/api/webhooks/stripe/route.ts"]
+  ];
+  await Promise.all(
+    files.map(
+      ([templateFile, destFile]) => writeTemplate(
+        path11.join(TEMPLATES_DIR8, templateFile),
+        path11.join(outDir, destFile),
+        {}
+      )
+    )
+  );
+  const pkgPath = path11.join(outDir, "package.json");
+  const pkg = await fs9.readJson(pkgPath);
+  pkg.dependencies = mergeDeps(pkg.dependencies ?? {}, {
+    stripe: "^14.0.0"
+  });
+  await fs9.writeJson(pkgPath, pkg, { spaces: 2 });
+  await appendEnv(outDir, {
+    STRIPE_SECRET_KEY: "sk_CHANGE_ME_stripe_secret_key",
+    STRIPE_WEBHOOK_SECRET: "whsec_CHANGE_ME_webhook_secret"
+  });
+}
+
+// src/generators/payments/lemonsqueezy.ts
+import path12 from "path";
+import fs10 from "fs-extra";
+var TEMPLATES_DIR9 = path12.join(TEMPLATES_ROOT, "payments/lemonsqueezy");
+async function generate9(config, outDir) {
+  const files = [
+    ["lib/lemonsqueezy.ts", "lib/lemonsqueezy.ts"],
+    ["app/api/webhooks/lemonsqueezy/route.ts", "app/api/webhooks/lemonsqueezy/route.ts"]
+  ];
+  await Promise.all(
+    files.map(
+      ([templateFile, destFile]) => writeTemplate(
+        path12.join(TEMPLATES_DIR9, templateFile),
+        path12.join(outDir, destFile),
+        {}
+      )
+    )
+  );
+  const pkgPath = path12.join(outDir, "package.json");
+  const pkg = await fs10.readJson(pkgPath);
+  pkg.dependencies = mergeDeps(pkg.dependencies ?? {}, {
+    "@lemonsqueezy/lemonsqueezy.js": "^3.0.0"
+  });
+  await fs10.writeJson(pkgPath, pkg, { spaces: 2 });
+  await appendEnv(outDir, {
+    LEMONSQUEEZY_API_KEY: "CHANGE_ME_lemonsqueezy_api_key",
+    LEMONSQUEEZY_WEBHOOK_SECRET: "CHANGE_ME_webhook_secret"
+  });
+}
+
+// src/generators/email/resend.ts
+import path13 from "path";
+import fs11 from "fs-extra";
+var TEMPLATES_DIR10 = path13.join(TEMPLATES_ROOT, "email/resend");
+async function generate10(config, outDir) {
+  await writeTemplate(
+    path13.join(TEMPLATES_DIR10, "lib/email.ts"),
+    path13.join(outDir, "lib/email.ts"),
+    {}
+  );
+  const pkgPath = path13.join(outDir, "package.json");
+  const pkg = await fs11.readJson(pkgPath);
+  pkg.dependencies = mergeDeps(pkg.dependencies ?? {}, {
+    resend: "^4.0.0"
+  });
+  await fs11.writeJson(pkgPath, pkg, { spaces: 2 });
+  await appendEnv(outDir, {
+    RESEND_API_KEY: "re_your_resend_api_key"
+  });
+}
+
+// src/generators/email/postmark.ts
+import path14 from "path";
+import fs12 from "fs-extra";
+var TEMPLATES_DIR11 = path14.join(TEMPLATES_ROOT, "email/postmark");
+async function generate11(config, outDir) {
+  await writeTemplate(
+    path14.join(TEMPLATES_DIR11, "lib/email.ts"),
+    path14.join(outDir, "lib/email.ts"),
+    {}
+  );
+  const pkgPath = path14.join(outDir, "package.json");
+  const pkg = await fs12.readJson(pkgPath);
+  pkg.dependencies = mergeDeps(pkg.dependencies ?? {}, {
+    postmark: "^4.0.0"
+  });
+  await fs12.writeJson(pkgPath, pkg, { spaces: 2 });
+  await appendEnv(outDir, {
+    POSTMARK_API_TOKEN: "your_postmark_server_api_token"
+  });
+}
+
+// src/generators/landing.ts
+import path15 from "path";
+var TEMPLATES_DIR12 = path15.join(TEMPLATES_ROOT, "landing");
+async function generate12(config, outDir) {
+  const vars = {
+    name: config.name,
+    tagline: "Your tagline here",
+    problemStatement: "The core problem you solve",
+    feature1: "Feature one",
+    feature2: "Feature two",
+    feature3: "Feature three",
+    price: "99",
+    problem1Title: "Wasted time on setup",
+    problem1Body: "Every new project means hours of boilerplate before you can build the actual thing.",
+    problem2Title: "Inconsistent foundations",
+    problem2Body: "Without a standard stack, every project diverges and maintenance gets harder.",
+    problem3Title: "Slow time to first user",
+    problem3Body: "The longer it takes to go live, the longer you wait for real feedback.",
+    testimonial1Quote: "This saved us weeks of setup time. We shipped our first paying customer in under 48 hours.",
+    testimonial1Name: "Alex Johnson",
+    testimonial1Role: "Founder, Acme Corp",
+    testimonial2Quote: "The best investment I made this year. Auth, payments, and emails all working out of the box.",
+    testimonial2Name: "Sarah Chen",
+    testimonial2Role: "CTO, Startup Inc",
+    testimonial3Quote: "I have tried every boilerplate out there. This one actually ships production-ready code.",
+    testimonial3Name: "Marcus Williams",
+    testimonial3Role: "Indie Hacker",
+    stage1Body: "You get your first win immediately. Setup takes minutes, results come the same day.",
+    stage2Body: "Each day builds on the last. Your results compound and momentum grows steadily.",
+    stage3Body: "You now have a clear competitive advantage. The gap between you and others widens.",
+    stage4Body: "You are operating at 10x your previous capacity. Results that used to take months happen in days."
+  };
+  const componentFiles = [
+    "components/Hero.tsx",
+    "components/ProblemAgitate.tsx",
+    "components/ValueStack.tsx",
+    "components/SocialProof.tsx",
+    "components/Transformation.tsx",
+    "components/SecondaryCTA.tsx",
+    "components/Footer.tsx"
+  ];
+  await Promise.all(
+    componentFiles.map(
+      (file) => writeTemplate(
+        path15.join(TEMPLATES_DIR12, file),
+        path15.join(outDir, file),
+        vars
+      )
+    )
+  );
+  await writeTemplate(
+    path15.join(TEMPLATES_DIR12, "app/page.tsx"),
+    path15.join(outDir, "app/page.tsx"),
+    vars
+  );
+}
+
+// src/generators/docker.ts
+import path16 from "path";
+var TEMPLATES_DIR13 = path16.join(TEMPLATES_ROOT, "docker");
+async function generate13(config, outDir) {
+  const vars = { name: config.name };
+  await Promise.all([
+    writeTemplate(
+      path16.join(TEMPLATES_DIR13, "Dockerfile"),
+      path16.join(outDir, "Dockerfile"),
+      vars
+    ),
+    writeTemplate(
+      path16.join(TEMPLATES_DIR13, ".dockerignore"),
+      path16.join(outDir, ".dockerignore"),
+      vars
+    ),
+    writeTemplate(
+      path16.join(TEMPLATES_DIR13, "docker-compose.yml"),
+      path16.join(outDir, "docker-compose.yml"),
+      vars
+    )
+  ]);
+}
+
+// src/generators/github.ts
+import path17 from "path";
+var TEMPLATES_DIR14 = path17.join(TEMPLATES_ROOT, "github");
+async function generate14(config, outDir) {
+  const vars = { name: config.name };
+  await writeTemplate(
+    path17.join(TEMPLATES_DIR14, ".github", "workflows", "ci.yml"),
+    path17.join(outDir, ".github", "workflows", "ci.yml"),
+    vars
+  );
+  await appendEnv(outDir, {
+    VERCEL_TOKEN: "",
+    VERCEL_ORG_ID: "",
+    VERCEL_PROJECT_ID: ""
+  });
+}
+
+// src/generators/index.ts
+async function generate15(config) {
+  const { outDir } = config;
+  const dirExistedBefore = await fs13.pathExists(outDir);
+  try {
+    await fs13.ensureDir(outDir);
+    const testFile = ".writability-check";
+    await fs13.writeFile(`${outDir}/${testFile}`, "");
+    await fs13.remove(`${outDir}/${testFile}`);
+  } catch {
+    throw new Error(`Output directory "${outDir}" is not writable or cannot be created. Check permissions and try again.`);
+  }
+  const authGenerators = {
+    clerk: generate2,
+    nextauth: generate3,
+    supabase: generate4
+  };
+  const databaseGenerators = {
+    postgres: generate5,
+    sqlite: generate6,
+    supabase: generate7
+  };
+  const paymentsGenerators = {
+    stripe: generate8,
+    lemonsqueezy: generate9
+  };
+  const emailGenerators = {
+    resend: generate10,
+    postmark: generate11
+  };
+  try {
+    await generate(config, outDir);
+    await generate12(config, outDir);
+    const authGenerator = authGenerators[config.auth];
+    if (!authGenerator) {
+      throw new Error(`No generator found for auth provider: ${config.auth}`);
+    }
+    await authGenerator(config, outDir);
+    const databaseGenerator = databaseGenerators[config.database];
+    if (!databaseGenerator) {
+      throw new Error(`No generator found for database provider: ${config.database}`);
+    }
+    await databaseGenerator(config, outDir);
+    if (config.payments !== null) {
+      const paymentsGenerator = paymentsGenerators[config.payments];
+      if (!paymentsGenerator) {
+        throw new Error(`No generator found for payments provider: ${config.payments}`);
+      }
+      await paymentsGenerator(config, outDir);
+    }
+    if (config.email !== null) {
+      const emailGenerator = emailGenerators[config.email];
+      if (!emailGenerator) {
+        throw new Error(`No generator found for email provider: ${config.email}`);
+      }
+      await emailGenerator(config, outDir);
+    }
+    await generate13(config, outDir);
+    await generate14(config, outDir);
+  } catch (err) {
+    if (!dirExistedBefore) {
+      await fs13.remove(outDir);
+    } else {
+      const { log: log2 } = await import("@clack/prompts");
+      log2.warn(`Generation failed. The directory "${outDir}" may be in a partial state.`);
+    }
+    throw err;
+  }
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  p7.intro("saas-init");
+  const { name, outDir } = await promptProject();
+  const { auth } = await promptAuth();
+  const { database } = await promptDatabase();
+  const { payments } = await promptPayments();
+  const { email } = await promptEmail();
+  const rawConfig = { name, outDir, auth, database, payments, email };
+  const parsed = projectConfigSchema.safeParse(rawConfig);
+  if (!parsed.success) {
+    p7.cancel(`Invalid configuration: ${parsed.error.message}`);
+    process.exit(1);
+  }
+  const config = parsed.data;
+  await promptSummary(config);
+  const spinner2 = p7.spinner();
+  spinner2.start("Generating project files");
+  try {
+    await generate15(config);
+  } catch (error) {
+    spinner2.stop("Generation failed");
+    const message = error instanceof Error ? error.message : String(error);
+    p7.cancel(`Generation failed: ${message}`);
+    process.exit(1);
+  }
+  spinner2.stop("Files generated");
+  const install = await p7.confirm({ message: "Install dependencies now?" });
+  if (!p7.isCancel(install) && install) {
+    const installSpinner = p7.spinner();
+    installSpinner.start("Installing dependencies");
+    try {
+      execSync("pnpm install", { cwd: outDir, stdio: "inherit" });
+      installSpinner.stop("Dependencies installed");
+    } catch (error) {
+      installSpinner.stop("Failed to install dependencies");
+      const message = error instanceof Error ? error.message : String(error);
+      p7.log.error(`pnpm install failed: ${message}`);
+      p7.log.warn("Run `pnpm install` manually in your project directory to install dependencies");
+    }
+  }
+  p7.outro(`Done! Your project is ready at ${outDir}`);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("saas-init").description("CLI scaffolding tool for production-ready SaaS projects").version("1.0.0");
+program.command("init").description("Scaffold a new SaaS project").action(initCommand);
+program.parse();