create-enterprise-next 0.1.0 → 0.2.0

package/dist/index.js

@@ -2,8 +2,8 @@
 
 // src/index.ts
 import { Command as Command2 } from "commander";
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
 
 // src/cli/flags.ts
@@ -47,6 +47,20 @@ var projectConfigSchema = z.object({
       path: ["database"]
     });
   }
+  if (data.orm === "drizzle" && data.database === "mongo") {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Drizzle ORM does not support MongoDB.",
+      path: ["database"]
+    });
+  }
+  if (data.monorepo && data.packageManager !== "pnpm") {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Monorepo setup is only supported with pnpm package manager.",
+      path: ["packageManager"]
+    });
+  }
 });
 
 // src/cli/flags.ts
@@ -426,13 +440,1761 @@ async function runInteractivePrompts(partial) {
   };
 }
 
-// src/utils/logger.ts
+// src/generate/generate-project.ts
+import * as clack2 from "@clack/prompts";
+
+// src/generate/context.ts
+function createGenerationContext(config, cwd = process.cwd()) {
+  return {
+    config,
+    cwd,
+    targetDir: config.projectName.startsWith("/") ? config.projectName : `${cwd}/${config.projectName}`,
+    manifest: {
+      dependencies: {},
+      devDependencies: {},
+      scripts: {},
+      rootDependencies: {},
+      rootDevDependencies: {},
+      rootScripts: {},
+      env: {},
+      files: /* @__PURE__ */ new Map()
+    }
+  };
+}
+function addDependency(context, name, version) {
+  context.manifest.dependencies[name] = version;
+}
+function addDevDependency(context, name, version) {
+  context.manifest.devDependencies[name] = version;
+}
+function addScript(context, name, command) {
+  context.manifest.scripts[name] = command;
+}
+function addRootDevDependency(context, name, version) {
+  context.manifest.rootDevDependencies[name] = version;
+}
+function addEnv(context, key, defaultValue = "") {
+  context.manifest.env[key] = defaultValue;
+}
+function addAppFile(context, relativePath, content) {
+  const normalizedPath = context.config.monorepo ? `apps/web/${relativePath}` : relativePath;
+  context.manifest.files.set(normalizedPath, content);
+}
+function addProjectFile(context, relativePath, content) {
+  context.manifest.files.set(relativePath, content);
+}
+
+// src/generate/filesystem.ts
+import fs3 from "fs/promises";
+import { existsSync } from "fs";
+import path3 from "path";
+function safeResolve(targetDir, relativePath) {
+  const absoluteTarget = path3.resolve(targetDir);
+  const resolved = path3.resolve(absoluteTarget, relativePath);
+  const relative = path3.relative(absoluteTarget, resolved);
+  if (relative.startsWith("..") || path3.isAbsolute(relative)) {
+    throw new Error(`Directory traversal detected: "${relativePath}" resolves outside of target directory "${absoluteTarget}".`);
+  }
+  return resolved;
+}
+async function ensureDirectory(targetDir, relativePath) {
+  const resolved = safeResolve(targetDir, relativePath);
+  await fs3.mkdir(resolved, { recursive: true });
+  return resolved;
+}
+async function writeFile(targetDir, relativePath, content) {
+  const resolved = safeResolve(targetDir, relativePath);
+  await fs3.mkdir(path3.dirname(resolved), { recursive: true });
+  await fs3.writeFile(resolved, content, "utf-8");
+}
+async function directoryIsEmpty(targetDir, relativePath) {
+  const resolved = safeResolve(targetDir, relativePath);
+  if (!existsSync(resolved)) {
+    return true;
+  }
+  const files = await fs3.readdir(resolved);
+  const nonHiddenFiles = files.filter((f) => !f.startsWith("."));
+  return nonHiddenFiles.length === 0;
+}
+
+// src/generate/dependencies.ts
+var dependencyVersions = {
+  // Base
+  next: "^15.1.0",
+  react: "^19.0.0",
+  "react-dom": "^19.0.0",
+  typescript: "^5.7.2",
+  "@types/react": "^19.0.0",
+  "@types/react-dom": "^19.0.0",
+  "@types/node": "^20.11.30",
+  eslint: "^9.16.0",
+  "eslint-config-next": "^15.1.0",
+  // Styling
+  tailwindcss: "^3.4.15",
+  postcss: "^8.4.49",
+  autoprefixer: "^10.4.20",
+  "styled-components": "^6.1.13",
+  // Auth
+  "@clerk/nextjs": "^6.9.6",
+  "next-auth": "^5.0.0-beta.25",
+  "@auth0/nextjs-auth0": "^3.5.0",
+  // ORM
+  prisma: "^6.1.0",
+  "@prisma/client": "^6.1.0",
+  "drizzle-orm": "^0.38.2",
+  "drizzle-kit": "^0.30.1",
+  pg: "^8.13.1",
+  "@types/pg": "^8.11.10",
+  mysql2: "^3.11.5",
+  "better-sqlite3": "^11.7.0",
+  "@types/better-sqlite3": "^11.6.0",
+  // State Management
+  zustand: "^5.0.2",
+  "@reduxjs/toolkit": "^2.5.0",
+  "react-redux": "^9.2.0",
+  jotai: "^2.11.0",
+  // Testing
+  vitest: "^2.1.8",
+  "@vitejs/plugin-react": "^4.3.4",
+  jsdom: "^25.0.1",
+  jest: "^29.7.0",
+  "jest-environment-jsdom": "^29.7.0",
+  "@testing-library/react": "^16.1.0",
+  "@testing-library/jest-dom": "^6.6.3",
+  "ts-jest": "^29.2.5",
+  "ts-node": "^10.9.2",
+  "@types/jest": "^29.5.14",
+  "@playwright/test": "^1.49.1",
+  cypress: "^13.16.1",
+  // Monorepo
+  turbo: "^2.3.3"
+};
+
+// src/generate/base/index.ts
+async function generateBaseProject(context) {
+  const { config } = context;
+  const ext = config.typescript ? "tsx" : "jsx";
+  const jsExt = config.typescript ? "ts" : "js";
+  addDependency(context, "next", dependencyVersions["next"]);
+  addDependency(context, "react", dependencyVersions["react"]);
+  addDependency(context, "react-dom", dependencyVersions["react-dom"]);
+  addDevDependency(context, "eslint", dependencyVersions["eslint"]);
+  addDevDependency(context, "eslint-config-next", dependencyVersions["eslint-config-next"]);
+  if (config.typescript) {
+    addDevDependency(context, "typescript", dependencyVersions["typescript"]);
+    addDevDependency(context, "@types/react", dependencyVersions["@types/react"]);
+    addDevDependency(context, "@types/react-dom", dependencyVersions["@types/react-dom"]);
+    addDevDependency(context, "@types/node", dependencyVersions["@types/node"]);
+  }
+  if (config.typescript) {
+    addAppFile(context, "next-env.d.ts", `/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information
+`);
+  }
+  if (config.typescript) {
+    addAppFile(
+      context,
+      "tsconfig.json",
+      JSON.stringify(
+        {
+          compilerOptions: {
+            target: "ES2022",
+            lib: ["dom", "dom.iterable", "esnext"],
+            allowJs: true,
+            skipLibCheck: true,
+            strict: true,
+            noEmit: true,
+            esModuleInterop: true,
+            module: "esnext",
+            moduleResolution: "bundler",
+            resolveJsonModule: true,
+            isolatedModules: true,
+            jsx: "preserve",
+            incremental: true,
+            plugins: [
+              {
+                name: "next"
+              }
+            ],
+            paths: {
+              "@/*": ["./src/*"]
+            }
+          },
+          include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+          exclude: ["node_modules"]
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+  const nextConfigOptions = [];
+  if (config.docker) {
+    nextConfigOptions.push('  output: "standalone",');
+  }
+  if (config.styling === "styled-components") {
+    nextConfigOptions.push("  compiler: {\n    styledComponents: true,\n  },");
+  }
+  const nextConfigContent = config.typescript ? `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+${nextConfigOptions.join("\n")}
+};
+
+export default nextConfig;
+` : `/** @type {import('next').NextConfig} */
+const nextConfig = {
+${nextConfigOptions.join("\n")}
+};
+
+export default nextConfig;
+`;
+  addAppFile(context, `next.config.${jsExt}`, nextConfigContent);
+  addAppFile(
+    context,
+    "eslint.config.mjs",
+    `import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+});
+
+const eslintConfig = [
+  ...compat.extends("next/core-web-vitals"),
+  ${config.typescript ? '...compat.extends("next/typescript"),' : ""}
+];
+
+export default eslintConfig;
+`
+  );
+  addProjectFile(
+    context,
+    ".gitignore",
+    `# dependencies
+/node_modules
+/.pnpm-store
+
+# testing
+/coverage
+/cypress/videos
+/cypress/screenshots
+/playwright-report
+/test-results
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# local env files
+.env*.local
+.env
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+`
+  );
+  const layoutImports = [];
+  let childrenWrapped = "{children}";
+  if (config.styling === "styled-components") {
+    layoutImports.push("import StyledComponentsRegistry from '@/lib/registry';");
+    childrenWrapped = `<StyledComponentsRegistry>${childrenWrapped}</StyledComponentsRegistry>`;
+  }
+  if (config.auth === "clerk") {
+    layoutImports.push("import { ClerkProvider } from '@clerk/nextjs';");
+    childrenWrapped = `<ClerkProvider>${childrenWrapped}</ClerkProvider>`;
+  } else if (config.auth === "auth0") {
+    layoutImports.push("import { UserProvider } from '@auth0/nextjs-auth0/client';");
+    childrenWrapped = `<UserProvider>${childrenWrapped}</UserProvider>`;
+  }
+  if (config.stateManagement === "redux") {
+    layoutImports.push("import StoreProvider from './StoreProvider';");
+    childrenWrapped = `<StoreProvider>${childrenWrapped}</StoreProvider>`;
+  } else if (config.stateManagement === "jotai") {
+    layoutImports.push("import JotaiProvider from './JotaiProvider';");
+    childrenWrapped = `<JotaiProvider>${childrenWrapped}</JotaiProvider>`;
+  }
+  const layoutContent = `${config.typescript ? 'import type { Metadata } from "next";\n' : ""}import "./globals.css";
+${layoutImports.join("\n")}
+
+export const metadata${config.typescript ? ": Metadata" : ""} = {
+  title: "${config.projectName}",
+  description: "Generated by create-enterprise-next",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body>
+        ${childrenWrapped}
+      </body>
+    </html>
+  );
+}
+`;
+  addAppFile(context, `src/app/layout.${ext}`, layoutContent);
+  const testingLabel = config.testing.length > 0 ? config.testing.join(", ") : "None";
+  const modules = [
+    `<li><strong>Styling:</strong> ${config.styling}</li>`,
+    `<li><strong>Authentication:</strong> ${config.auth}</li>`,
+    `<li><strong>ORM:</strong> ${config.orm} (${config.database || "None"})</li>`,
+    `<li><strong>Testing:</strong> ${testingLabel}</li>`,
+    `<li><strong>State Management:</strong> ${config.stateManagement}</li>`,
+    `<li><strong>CI Setup:</strong> ${config.ci}</li>`,
+    `<li><strong>Docker Configuration:</strong> ${config.docker ? "Enabled" : "Disabled"}</li>`,
+    `<li><strong>Monorepo Structure:</strong> ${config.monorepo ? "Enabled" : "Disabled"}</li>`,
+    `<li><strong>Package Manager:</strong> ${config.packageManager}</li>`
+  ].join("\n            ");
+  let pageContent = "";
+  if (config.styling === "tailwind") {
+    pageContent = `export default function Page() {
+  return (
+    <main className="flex min-h-screen flex-col items-center justify-center bg-slate-950 text-white p-6">
+      <div className="max-w-2xl text-center space-y-6">
+        <h1 className="text-4xl font-extrabold tracking-tight bg-clip-text text-transparent bg-gradient-to-r from-blue-400 to-emerald-400">
+          create-enterprise-next
+        </h1>
+        <p className="text-lg text-slate-400">
+          Your enterprise Next.js foundation is ready.
+        </p>
+        <div className="mt-8 p-6 bg-slate-900 rounded-xl border border-slate-800 text-left">
+          <h2 className="text-xl font-semibold mb-4 text-slate-200">Enabled Modules</h2>
+          <ul className="grid grid-cols-1 md:grid-cols-2 gap-3 text-sm text-slate-400">
+            ${modules}
+          </ul>
+        </div>
+      </div>
+    </main>
+  );
+}
+`;
+  } else if (config.styling === "styled-components") {
+    pageContent = `import styled from 'styled-components';
+
+const Container = styled.main\`
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  min-height: 100vh;
+  background-color: #020617;
+  color: #ffffff;
+  padding: 24px;
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+\`;
+
+const Title = styled.h1\`
+  font-size: 36px;
+  font-weight: 800;
+  margin-bottom: 12px;
+  background: linear-gradient(to right, #60a5fa, #34d399);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+\`;
+
+const Subtitle = styled.p\`
+  font-size: 18px;
+  color: #94a3b8;
+  margin-bottom: 32px;
+\`;
+
+const ModuleCard = styled.div\`
+  background-color: #0f172a;
+  border: 1px solid #1e293b;
+  border-radius: 12px;
+  padding: 24px;
+  max-width: 600px;
+  width: 100%;
+  text-align: left;
+\`;
+
+const CardTitle = styled.h2\`
+  font-size: 20px;
+  font-weight: 600;
+  margin-bottom: 16px;
+  color: #e2e8f0;
+\`;
+
+const ModuleList = styled.ul\`
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 12px;
+  list-style: none;
+  padding: 0;
+  margin: 0;
+  color: #94a3b8;
+  font-size: 14px;
+
+  @media (min-width: 768px) {
+    grid-template-columns: 1fr 1fr;
+  }
+\`;
+
+export default function Page() {
+  return (
+    <Container>
+      <Title>create-enterprise-next</Title>
+      <Subtitle>Your enterprise Next.js foundation is ready.</Subtitle>
+      <ModuleCard>
+        <CardTitle>Enabled Modules</CardTitle>
+        <ModuleList>
+          ${modules}
+        </ModuleList>
+      </ModuleCard>
+    </Container>
+  );
+}
+`;
+  } else {
+    pageContent = `import styles from './page.module.css';
+
+export default function Page() {
+  return (
+    <main className={styles.main}>
+      <div className={styles.container}>
+        <h1 className={styles.title}>create-enterprise-next</h1>
+        <p className={styles.subtitle}>Your enterprise Next.js foundation is ready.</p>
+        <div className={styles.card}>
+          <h2 className={styles.cardTitle}>Enabled Modules</h2>
+          <ul className={styles.list}>
+            ${modules}
+          </ul>
+        </div>
+      </div>
+    </main>
+  );
+}
+`;
+  }
+  addAppFile(context, `src/app/page.${ext}`, pageContent);
+}
+
+// src/generate/base/readme.ts
+function generateReadme(context) {
+  const { config } = context;
+  const pm = config.packageManager;
+  const pmRun = pm === "yarn" ? "yarn" : `${pm} run`;
+  const pmInstall = pm === "yarn" ? "yarn" : `${pm} install`;
+  let content = `# ${config.projectName}
+
+`;
+  content += `This is an enterprise-grade Next.js application scaffolded with \`create-enterprise-next\`.
+
+`;
+  content += `## Tech Stack
+
+`;
+  content += `- **Framework:** Next.js (App Router)
+`;
+  content += `- **Language:** ${config.typescript ? "TypeScript" : "JavaScript"}
+`;
+  content += `- **Styling:** ${config.styling}
+`;
+  content += `- **Authentication:** ${config.auth}
+`;
+  content += `- **ORM:** ${config.orm}${config.database ? ` (${config.database})` : ""}
+`;
+  content += `- **State Management:** ${config.stateManagement}
+`;
+  content += `- **Testing:** ${config.testing.join(", ") || "None"}
+`;
+  content += `- **CI Pipeline:** ${config.ci}
+`;
+  content += `- **Docker:** ${config.docker ? "Yes" : "No"}
+`;
+  content += `- **Monorepo:** ${config.monorepo ? "Yes" : "No"}
+
+`;
+  content += `## Getting Started
+
+`;
+  content += `### 1. Install Dependencies
+
+`;
+  content += `\`\`\`bash
+${pmInstall}
+\`\`\`
+
+`;
+  if (config.orm !== "none") {
+    content += `### 2. Database Setup
+
+`;
+    content += `Ensure your database is running and the \`DATABASE_URL\` is defined in your \`.env\` file.
+
+`;
+    content += `Generate ORM client:
+`;
+    content += `\`\`\`bash
+${pmRun} db:generate
+\`\`\`
+
+`;
+    content += `Push schema / run migrations:
+`;
+    content += `\`\`\`bash
+${pmRun} db:migrate
+\`\`\`
+
+`;
+  }
+  content += `### 3. Run Development Server
+
+`;
+  content += `\`\`\`bash
+${pm} dev
+\`\`\`
+
+`;
+  content += `Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+`;
+  if (config.testing.length > 0) {
+    content += `## Testing
+
+`;
+    if (config.testing.includes("vitest")) {
+      content += `- **Vitest:** Run unit/integration tests: \`${pmRun} test:vitest\` (or \`${pmRun} test\`)
+`;
+    }
+    if (config.testing.includes("jest")) {
+      content += `- **Jest:** Run unit/integration tests: \`${pmRun} test:jest\` (or \`${pmRun} test\`)
+`;
+    }
+    if (config.testing.includes("playwright")) {
+      content += `- **Playwright:** Run end-to-end tests: \`${pmRun} test:e2e\`
+`;
+    }
+    if (config.testing.includes("cypress")) {
+      content += `- **Cypress:** Run Cypress: \`${pmRun} test:cypress\` / \`${pmRun} cypress:open\`
+`;
+    }
+    content += `
+`;
+  }
+  if (config.docker) {
+    content += `## Docker
+
+`;
+    content += `Build the production Docker image:
+`;
+    content += `\`\`\`bash
+docker build -t ${config.projectName} .
+\`\`\`
+
+`;
+    content += `Run the container:
+`;
+    content += `\`\`\`bash
+docker run -p 3000:3000 ${config.projectName}
+\`\`\`
+
+`;
+  }
+  if (config.auth !== "none") {
+    content += `## Authentication Setup
+
+`;
+    if (config.auth === "clerk") {
+      content += `This project uses Clerk for authentication. Configure your credentials in \`.env.local\`:
+`;
+      content += `- \`NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY\`
+`;
+      content += `- \`CLERK_SECRET_KEY\`
+`;
+    } else if (config.auth === "next-auth") {
+      content += `This project uses NextAuth.js. Configure \`AUTH_SECRET\` in \`.env.local\`.
+`;
+    } else if (config.auth === "auth0") {
+      content += `This project uses Auth0. Configure \`AUTH0_SECRET\`, \`AUTH0_BASE_URL\`, and client variables in \`.env.local\`.
+`;
+    }
+    content += `
+`;
+  }
+  addAppFile(context, "README.md", content);
+}
+
+// src/generate/features/styling/index.ts
+async function generateStyling(context) {
+  const { config } = context;
+  const ext = config.typescript ? "tsx" : "jsx";
+  if (config.styling === "tailwind") {
+    addDevDependency(context, "tailwindcss", dependencyVersions["tailwindcss"]);
+    addDevDependency(context, "postcss", dependencyVersions["postcss"]);
+    addDevDependency(context, "autoprefixer", dependencyVersions["autoprefixer"]);
+    addAppFile(
+      context,
+      "postcss.config.mjs",
+      `const config = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};
+export default config;
+`
+    );
+    const tailwindConfigContent = config.typescript ? `import type { Config } from "tailwindcss";
+
+const config: Config = {
+  content: [
+    "./src/pages/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/app/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+};
+export default config;
+` : `/** @type {import('tailwindcss').Config} */
+const config = {
+  content: [
+    "./src/pages/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/app/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+};
+export default config;
+`;
+    addAppFile(context, `tailwind.config.${config.typescript ? "ts" : "js"}`, tailwindConfigContent);
+    addAppFile(
+      context,
+      "src/app/globals.css",
+      `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`
+    );
+  } else if (config.styling === "css-modules") {
+    addAppFile(
+      context,
+      "src/app/globals.css",
+      `body {
+  margin: 0;
+  padding: 0;
+  background-color: #020617;
+  color: #ffffff;
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+}
+`
+    );
+    addAppFile(
+      context,
+      "src/app/page.module.css",
+      `.main {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  min-height: 100vh;
+  background-color: #020617;
+  color: #ffffff;
+  padding: 24px;
+}
+.container {
+  text-align: center;
+  max-width: 640px;
+}
+.title {
+  font-size: 36px;
+  font-weight: 800;
+  margin-bottom: 12px;
+  background: linear-gradient(to right, #60a5fa, #34d399);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+}
+.subtitle {
+  font-size: 18px;
+  color: #94a3b8;
+  margin-bottom: 32px;
+}
+.card {
+  background-color: #0f172a;
+  border: 1px solid #1e293b;
+  border-radius: 12px;
+  padding: 24px;
+  text-align: left;
+}
+.cardTitle {
+  font-size: 20px;
+  font-weight: 600;
+  margin-bottom: 16px;
+  color: #e2e8f0;
+}
+.list {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 12px;
+  list-style: none;
+  padding: 0;
+  margin: 0;
+  color: #94a3b8;
+  font-size: 14px;
+}
+@media (min-width: 768px) {
+  .list {
+    grid-template-columns: 1fr 1fr;
+  }
+}
+`
+    );
+  } else if (config.styling === "styled-components") {
+    addDependency(context, "styled-components", dependencyVersions["styled-components"]);
+    addAppFile(
+      context,
+      "src/app/globals.css",
+      `body {
+  margin: 0;
+  padding: 0;
+  background-color: #020617;
+  color: #ffffff;
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+}
+`
+    );
+    const registryContent = config.typescript ? `'use client';
+
+import React, { useState } from 'react';
+import { useServerInsertedHTML } from 'next/navigation';
+import { ServerStyleSheet, StyleSheetManager } from 'styled-components';
+
+export default function StyledComponentsRegistry({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  const [jsxStyleSheet] = useState(() => new ServerStyleSheet());
+
+  useServerInsertedHTML(() => {
+    const styles = jsxStyleSheet.getStyleElement();
+    jsxStyleSheet.instance.clearTag();
+    return <>{styles}</>;
+  });
+
+  if (typeof window !== 'undefined') return <>{children}</>;
+
+  return (
+    <StyleSheetManager sheet={jsxStyleSheet.instance}>
+      {children}
+    </StyleSheetManager>
+  );
+}
+` : `'use client';
+
+import React, { useState } from 'react';
+import { useServerInsertedHTML } from 'next/navigation';
+import { ServerStyleSheet, StyleSheetManager } from 'styled-components';
+
+export default function StyledComponentsRegistry({ children }) {
+  const [jsxStyleSheet] = useState(() => new ServerStyleSheet());
+
+  useServerInsertedHTML(() => {
+    const styles = jsxStyleSheet.getStyleElement();
+    jsxStyleSheet.instance.clearTag();
+    return <>{styles}</>;
+  });
+
+  if (typeof window !== 'undefined') return <>{children}</>;
+
+  return (
+    <StyleSheetManager sheet={jsxStyleSheet.instance}>
+      {children}
+    </StyleSheetManager>
+  );
+}
+`;
+    addAppFile(context, `src/lib/registry.${ext}`, registryContent);
+  }
+}
+
+// src/generate/features/auth/index.ts
+async function generateAuthentication(context) {
+  const { config } = context;
+  const jsExt = config.typescript ? "ts" : "js";
+  if (config.auth === "none") {
+    return;
+  }
+  if (config.auth === "clerk") {
+    addDependency(context, "@clerk/nextjs", dependencyVersions["@clerk/nextjs"]);
+    addEnv(context, "NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY");
+    addEnv(context, "CLERK_SECRET_KEY");
+    addEnv(context, "NEXT_PUBLIC_CLERK_SIGN_IN_URL", "/sign-in");
+    addEnv(context, "NEXT_PUBLIC_CLERK_SIGN_UP_URL", "/sign-up");
+    const middlewareContent = `import { clerkMiddleware } from "@clerk/nextjs/server";
+
+export default clerkMiddleware();
+
+export const config = {
+  matcher: [
+    // Skip Next.js internals and all static files, unless found in search params
+    '/((?!_next|[^?]*\\\\.[\\\\w]+$|_next/image|_next/static|favicon.ico).*)',
+    // Always run for API routes
+    '/(api|trpc)(.*)',
+  ],
+};
+`;
+    addAppFile(context, `src/middleware.${jsExt}`, middlewareContent);
+  } else if (config.auth === "next-auth") {
+    addDependency(context, "next-auth", dependencyVersions["next-auth"]);
+    addEnv(context, "AUTH_SECRET");
+    addEnv(context, "AUTH_URL", "http://localhost:3000");
+    const authConfigContent = `import NextAuth from "next-auth";
+
+export const { handlers, auth, signIn, signOut } = NextAuth({
+  providers: [],
+});
+`;
+    addAppFile(context, `src/auth.${jsExt}`, authConfigContent);
+    const routeContent = `import { handlers } from "@/auth";
+export const { GET, POST } = handlers;
+`;
+    addAppFile(context, `src/app/api/auth/[...nextauth]/route.${jsExt}`, routeContent);
+    const middlewareContent = `export { auth as middleware } from "@/auth";
+`;
+    addAppFile(context, `src/middleware.${jsExt}`, middlewareContent);
+  } else if (config.auth === "auth0") {
+    addDependency(context, "@auth0/nextjs-auth0", dependencyVersions["@auth0/nextjs-auth0"]);
+    addEnv(context, "AUTH0_SECRET");
+    addEnv(context, "AUTH0_BASE_URL", "http://localhost:3000");
+    addEnv(context, "AUTH0_ISSUER_BASE_URL");
+    addEnv(context, "AUTH0_CLIENT_ID");
+    addEnv(context, "AUTH0_CLIENT_SECRET");
+    const routeContent = `import { handleAuth } from '@auth0/nextjs-auth0';
+export const GET = handleAuth();
+`;
+    addAppFile(context, `src/app/api/auth/[auth0]/route.${jsExt}`, routeContent);
+  }
+}
+
+// src/generate/features/orm/index.ts
+async function generateOrm(context) {
+  const { config } = context;
+  const jsExt = config.typescript ? "ts" : "js";
+  if (config.orm === "none") {
+    return;
+  }
+  if (config.orm === "prisma") {
+    addDependency(context, "@prisma/client", dependencyVersions["@prisma/client"]);
+    addDevDependency(context, "prisma", dependencyVersions["prisma"]);
+    addScript(context, "db:generate", "prisma generate");
+    addScript(context, "db:migrate", "prisma migrate dev");
+    addScript(context, "db:studio", "prisma studio");
+    let prismaProvider = "postgresql";
+    let defaultDbUrl = "";
+    if (config.database === "mysql") {
+      prismaProvider = "mysql";
+    } else if (config.database === "sqlite") {
+      prismaProvider = "sqlite";
+      defaultDbUrl = "file:./dev.db";
+    } else if (config.database === "mongo") {
+      prismaProvider = "mongodb";
+    }
+    addEnv(context, "DATABASE_URL", defaultDbUrl);
+    const schemaContent = `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${prismaProvider}"
+  url      = env("DATABASE_URL")
+}
+`;
+    addProjectFile(context, "prisma/schema.prisma", schemaContent);
+    const clientContent = config.typescript ? `import { PrismaClient } from '@prisma/client';
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+export const db = globalForPrisma.prisma ?? new PrismaClient();
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = db;
+` : `import { PrismaClient } from '@prisma/client';
+
+const globalForPrisma = globalThis;
+
+export const db = globalForPrisma.prisma ?? new PrismaClient();
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = db;
+`;
+    addAppFile(context, `src/lib/db.${jsExt}`, clientContent);
+  }
+  if (config.orm === "drizzle") {
+    addDependency(context, "drizzle-orm", dependencyVersions["drizzle-orm"]);
+    addDevDependency(context, "drizzle-kit", dependencyVersions["drizzle-kit"]);
+    addScript(context, "db:generate", "drizzle-kit generate");
+    addScript(context, "db:migrate", "drizzle-kit migrate");
+    addScript(context, "db:studio", "drizzle-kit studio");
+    let drizzleDialect = "postgresql";
+    let defaultDbUrl = "";
+    if (config.database === "postgres") {
+      drizzleDialect = "postgresql";
+      addDependency(context, "pg", dependencyVersions["pg"]);
+      if (config.typescript) {
+        addDevDependency(context, "@types/pg", dependencyVersions["@types/pg"]);
+      }
+    } else if (config.database === "mysql") {
+      drizzleDialect = "mysql";
+      addDependency(context, "mysql2", dependencyVersions["mysql2"]);
+    } else if (config.database === "sqlite") {
+      drizzleDialect = "sqlite";
+      addDependency(context, "better-sqlite3", dependencyVersions["better-sqlite3"]);
+      if (config.typescript) {
+        addDevDependency(context, "@types/better-sqlite3", dependencyVersions["@types/better-sqlite3"]);
+      }
+      defaultDbUrl = "sqlite.db";
+    }
+    addEnv(context, "DATABASE_URL", defaultDbUrl);
+    const drizzleConfigContent = `import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  schema: './src/db/schema.${jsExt}',
+  out: './drizzle',
+  dialect: '${drizzleDialect}',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+`;
+    addAppFile(context, `drizzle.config.${jsExt}`, drizzleConfigContent);
+    addAppFile(context, `src/db/schema.${jsExt}`, "// Define your database schema here\n");
+    let clientContent = "";
+    if (config.database === "postgres") {
+      clientContent = `import { drizzle } from 'drizzle-orm/node-postgres';
+import pg from 'pg';
+import * as schema from './schema';
+
+const pool = new pg.Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+export const db = drizzle(pool, { schema });
+`;
+    } else if (config.database === "mysql") {
+      clientContent = `import { drizzle } from 'drizzle-orm/mysql2';
+import mysql from 'mysql2/promise';
+import * as schema from './schema';
+
+const pool = mysql.createPool({
+  uri: process.env.DATABASE_URL,
+});
+
+export const db = drizzle(pool, { schema });
+`;
+    } else if (config.database === "sqlite") {
+      clientContent = `import { drizzle } from 'drizzle-orm/better-sqlite3';
+import Database from 'better-sqlite3';
+import * as schema from './schema';
+
+const sqlite = new Database(process.env.DATABASE_URL || 'sqlite.db');
+export const db = drizzle(sqlite, { schema });
+`;
+    }
+    addAppFile(context, `src/db/index.${jsExt}`, clientContent);
+  }
+}
+
+// src/generate/features/state-management/index.ts
+async function generateStateManagement(context) {
+  const { config } = context;
+  const ext = config.typescript ? "tsx" : "jsx";
+  const jsExt = config.typescript ? "ts" : "js";
+  if (config.stateManagement === "none") {
+    return;
+  }
+  if (config.stateManagement === "zustand") {
+    addDependency(context, "zustand", dependencyVersions["zustand"]);
+    const storeContent = config.typescript ? `import { create } from 'zustand';
+
+interface CounterState {
+  count: number;
+  increment: () => void;
+  decrement: () => void;
+}
+
+export const useCounterStore = create<CounterState>((set) => ({
+  count: 0,
+  increment: () => set((state) => ({ count: state.count + 1 })),
+  decrement: () => set((state) => ({ count: state.count - 1 })),
+}));
+` : `import { create } from 'zustand';
+
+export const useCounterStore = create((set) => ({
+  count: 0,
+  increment: () => set((state) => ({ count: state.count + 1 })),
+  decrement: () => set((state) => ({ count: state.count - 1 })),
+}));
+`;
+    addAppFile(context, `src/stores/counter-store.${jsExt}`, storeContent);
+  } else if (config.stateManagement === "redux") {
+    addDependency(context, "@reduxjs/toolkit", dependencyVersions["@reduxjs/toolkit"]);
+    addDependency(context, "react-redux", dependencyVersions["react-redux"]);
+    const storeContent = config.typescript ? `import { configureStore } from '@reduxjs/toolkit';
+
+export const makeStore = () => {
+  return configureStore({
+    reducer: {},
+  });
+};
+
+export type AppStore = ReturnType<typeof makeStore>;
+export type RootState = ReturnType<AppStore['getState']>;
+export type AppDispatch = AppStore['dispatch'];
+` : `import { configureStore } from '@reduxjs/toolkit';
+
+export const makeStore = () => {
+  return configureStore({
+    reducer: {},
+  });
+};
+`;
+    addAppFile(context, `src/lib/store.${jsExt}`, storeContent);
+    const providerContent = config.typescript ? `'use client';
+import { useRef } from 'react';
+import { Provider } from 'react-redux';
+import { makeStore, AppStore } from '../lib/store';
+
+export default function StoreProvider({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  const storeRef = useRef<AppStore>(undefined);
+  if (!storeRef.current) {
+    storeRef.current = makeStore();
+  }
+
+  return <Provider store={storeRef.current}>{children}</Provider>;
+}
+` : `'use client';
+import { useRef } from 'react';
+import { Provider } from 'react-redux';
+import { makeStore } from '../lib/store';
+
+export default function StoreProvider({ children }) {
+  const storeRef = useRef();
+  if (!storeRef.current) {
+    storeRef.current = makeStore();
+  }
+
+  return <Provider store={storeRef.current}>{children}</Provider>;
+}
+`;
+    addAppFile(context, `src/app/StoreProvider.${ext}`, providerContent);
+  } else if (config.stateManagement === "jotai") {
+    addDependency(context, "jotai", dependencyVersions["jotai"]);
+    const providerContent = config.typescript ? `'use client';
+import { Provider } from 'jotai';
+
+export default function JotaiProvider({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return <Provider>{children}</Provider>;
+}
+` : `'use client';
+import { Provider } from 'jotai';
+
+export default function JotaiProvider({ children }) {
+  return <Provider>{children}</Provider>;
+}
+`;
+    addAppFile(context, `src/app/JotaiProvider.${ext}`, providerContent);
+  }
+}
+
+// src/generate/features/testing/index.ts
+async function generateTesting(context) {
+  const { config } = context;
+  const ext = config.typescript ? "tsx" : "jsx";
+  const jsExt = config.typescript ? "ts" : "js";
+  const hasVitest = config.testing.includes("vitest");
+  const hasJest = config.testing.includes("jest");
+  const hasPlaywright = config.testing.includes("playwright");
+  const hasCypress = config.testing.includes("cypress");
+  if (config.testing.length === 0) {
+    return;
+  }
+  const pmRun = config.packageManager === "yarn" ? "yarn" : `${config.packageManager} run`;
+  if (hasVitest) {
+    addDevDependency(context, "vitest", dependencyVersions["vitest"]);
+    addDevDependency(context, "@vitejs/plugin-react", dependencyVersions["@vitejs/plugin-react"]);
+    addDevDependency(context, "jsdom", dependencyVersions["jsdom"]);
+    addDevDependency(context, "@testing-library/react", dependencyVersions["@testing-library/react"]);
+    addDevDependency(context, "@testing-library/jest-dom", dependencyVersions["@testing-library/jest-dom"]);
+    addScript(context, "test:vitest", "vitest run");
+    const vitestConfig = `import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+import path from 'path';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: 'jsdom',
+    globals: true,
+    setupFiles: ['./vitest.setup.${jsExt}'],
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+});
+`;
+    addAppFile(context, `vitest.config.${jsExt}`, vitestConfig);
+    addAppFile(context, `vitest.setup.${jsExt}`, `import '@testing-library/jest-dom';
+`);
+  }
+  if (hasJest) {
+    addDevDependency(context, "jest", dependencyVersions["jest"]);
+    addDevDependency(context, "jest-environment-jsdom", dependencyVersions["jest-environment-jsdom"]);
+    addDevDependency(context, "@testing-library/react", dependencyVersions["@testing-library/react"]);
+    addDevDependency(context, "@testing-library/jest-dom", dependencyVersions["@testing-library/jest-dom"]);
+    if (config.typescript) {
+      addDevDependency(context, "ts-jest", dependencyVersions["ts-jest"]);
+      addDevDependency(context, "ts-node", dependencyVersions["ts-node"]);
+      addDevDependency(context, "@types/jest", dependencyVersions["@types/jest"]);
+    }
+    addScript(context, "test:jest", "jest");
+    const jestConfig = config.typescript ? `import type { Config } from 'jest';
+
+const config: Config = {
+  preset: 'ts-jest',
+  testEnvironment: 'jest-environment-jsdom',
+  setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+    '\\\\.css$': 'identity-obj-proxy',
+  },
+};
+
+export default config;
+` : `/** @type {import('jest').Config} */
+const config = {
+  testEnvironment: 'jest-environment-jsdom',
+  setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+    '\\\\.css$': 'identity-obj-proxy',
+  },
+};
+
+export default config;
+`;
+    addAppFile(context, `jest.config.${jsExt}`, jestConfig);
+    addAppFile(context, `jest.setup.${jsExt}`, `import '@testing-library/jest-dom';
+`);
+  }
+  if (hasVitest || hasJest) {
+    const cleanSmokeTest = `import { render, screen } from '@testing-library/react';
+import Page from './page';
+
+test('renders welcome page', () => {
+  render(<Page />);
+  const heading = screen.getByRole('heading', { level: 1 });
+  expect(heading).toBeInTheDocument();
+});
+`;
+    addAppFile(context, `src/app/page.test.${ext}`, cleanSmokeTest);
+  }
+  if (hasPlaywright) {
+    addDevDependency(context, "@playwright/test", dependencyVersions["@playwright/test"]);
+    addScript(context, "test:e2e", "playwright test");
+    const devCommand = config.packageManager === "npm" ? "npm run dev" : `${config.packageManager} dev`;
+    const playwrightConfig = `import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests/e2e',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: 'html',
+  use: {
+    baseURL: 'http://localhost:3000',
+    trace: 'on-first-retry',
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+  ],
+  webServer: {
+    command: '${devCommand}',
+    url: 'http://localhost:3000',
+    reuseExistingServer: !process.env.CI,
+  },
+});
+`;
+    addAppFile(context, `playwright.config.${jsExt}`, playwrightConfig);
+    const playwrightSmokeTest = `import { test, expect } from '@playwright/test';
+
+test('should display home page', async ({ page }) => {
+  await page.goto('/');
+  await expect(page.locator('h1')).toContainText('create-enterprise-next');
+});
+`;
+    addAppFile(context, `tests/e2e/smoke.spec.${jsExt}`, playwrightSmokeTest);
+  }
+  if (hasCypress) {
+    addDevDependency(context, "cypress", dependencyVersions["cypress"]);
+    addScript(context, "test:cypress", "cypress run");
+    addScript(context, "cypress:open", "cypress open");
+    const cypressConfig = `import { defineConfig } from 'cypress';
+
+export default defineConfig({
+  e2e: {
+    baseUrl: 'http://localhost:3000',
+    supportFile: false,
+  },
+});
+`;
+    addAppFile(context, `cypress.config.${jsExt}`, cypressConfig);
+    const cypressSmokeTest = `describe('Smoke Test', () => {
+  it('should display home page', () => {
+    cy.visit('/');
+    cy.get('h1').should('contain', 'create-enterprise-next');
+  });
+});
+`;
+    addAppFile(context, `cypress/e2e/smoke.cy.${jsExt}`, cypressSmokeTest);
+  }
+  if (hasVitest && hasJest) {
+    addScript(context, "test", `${pmRun} test:vitest && ${pmRun} test:jest`);
+  } else if (hasVitest) {
+    addScript(context, "test", `${pmRun} test:vitest`);
+  } else if (hasJest) {
+    addScript(context, "test", `${pmRun} test:jest`);
+  }
+}
+
+// src/generate/features/ci/index.ts
+async function generateCi(context) {
+  const { config } = context;
+  if (config.ci === "none") {
+    return;
+  }
+  const pm = config.packageManager;
+  const hasTesting = config.testing.length > 0;
+  let installCmd = "npm ci";
+  let runPrefix = "npm run";
+  let cacheName = "npm";
+  if (pm === "pnpm") {
+    installCmd = "pnpm install";
+    runPrefix = "pnpm run";
+    cacheName = "pnpm";
+  } else if (pm === "yarn") {
+    installCmd = "yarn install";
+    runPrefix = "yarn";
+    cacheName = "yarn";
+  } else if (pm === "bun") {
+    installCmd = "bun install";
+    runPrefix = "bun run";
+    cacheName = "bun";
+  }
+  if (config.ci === "github-actions") {
+    let steps = `      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+`;
+    if (pm === "pnpm") {
+      steps += `
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 9
+`;
+    } else if (pm === "bun") {
+      steps += `
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+`;
+    }
+    if (pm === "npm" || pm === "yarn") {
+      steps += `          cache: '${cacheName}'
+`;
+    }
+    steps += `
+      - name: Install dependencies
+        run: ${installCmd}
+
+      - name: Lint
+        run: ${runPrefix} lint
+`;
+    if (config.typescript) {
+      steps += `
+      - name: Typecheck
+        run: ${runPrefix} typecheck
+`;
+    }
+    if (hasTesting) {
+      steps += `
+      - name: Run tests
+        run: ${runPrefix} test
+`;
+    }
+    steps += `
+      - name: Build
+        run: ${runPrefix} build
+`;
+    const workflowContent = `name: CI
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+
+    steps:
+${steps}
+`;
+    addProjectFile(context, ".github/workflows/ci.yml", workflowContent);
+  }
+  if (config.ci === "gitlab-ci") {
+    let beforeScript = "";
+    let image = "node:20";
+    if (pm === "pnpm") {
+      beforeScript = `  - corepack enable pnpm
+  - pnpm install
+`;
+    } else if (pm === "bun") {
+      image = "oven/bun:latest";
+      beforeScript = `  - bun install
+`;
+    } else if (pm === "yarn") {
+      beforeScript = `  - yarn install
+`;
+    } else {
+      beforeScript = `  - npm ci
+`;
+    }
+    let scriptSteps = `    - ${runPrefix} lint
+`;
+    if (config.typescript) {
+      scriptSteps += `    - ${runPrefix} typecheck
+`;
+    }
+    if (hasTesting) {
+      scriptSteps += `    - ${runPrefix} test
+`;
+    }
+    scriptSteps += `    - ${runPrefix} build`;
+    const gitlabContent = `image: ${image}
+
+cache:
+  paths:
+    - node_modules/
+    ${pm === "pnpm" ? "- .pnpm-store/" : ""}
+
+stages:
+  - validate
+
+validate_job:
+  stage: validate
+  before_script:
+${beforeScript}
+  script:
+${scriptSteps}
+`;
+    addProjectFile(context, ".gitlab-ci.yml", gitlabContent);
+  }
+}
+
+// src/generate/features/docker/index.ts
+async function generateDocker(context) {
+  const { config } = context;
+  if (!config.docker) {
+    return;
+  }
+  const dockerfileContent = `# Multi-stage production Dockerfile for Next.js standalone output
+FROM node:20-alpine AS base
+
+# Stage 1: Install dependencies
+FROM base AS deps
+RUN apk add --no-cache libc6-compat
+WORKDIR /app
+
+# Copy lockfiles and package definitions
+COPY package.json yarn.lock* package-lock.json* pnpm-lock.yaml* bun.lockb* ./
+
+RUN \\
+  if [ -f pnpm-lock.yaml ]; then corepack enable pnpm && pnpm i --frozen-lockfile; \\
+  elif [ -f package-lock.json ]; then npm ci; \\
+  elif [ -f yarn.lock ]; then yarn --frozen-lockfile; \\
+  elif [ -f bun.lockb ]; then bun install --frozen-lockfile; \\
+  else echo "Warning: No lockfile found. Installing normal dependencies." && npm install; \\
+  fi
+
+# Stage 2: Build the application
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+
+# Disable Next.js telemetry during build
+ENV NEXT_TELEMETRY_DISABLED=1
+
+RUN \\
+  if [ -f pnpm-lock.yaml ]; then corepack enable pnpm && pnpm run build; \\
+  elif [ -f package-lock.json ]; then npm run build; \\
+  elif [ -f yarn.lock ]; then yarn build; \\
+  elif [ -f bun.lockb ]; then bun run build; \\
+  else npm run build; \\
+  fi
+
+# Stage 3: Production runner
+FROM base AS runner
+WORKDIR /app
+
+ENV NODE_ENV=production
+ENV NEXT_TELEMETRY_DISABLED=1
+
+RUN addgroup --system --gid 1001 nodejs
+RUN adduser --system --uid 1001 nextjs
+
+# Copy static assets and public directory
+COPY --from=builder /app/public ./public
+
+# Setup prerender cache directory permissions
+RUN mkdir .next
+RUN chown nextjs:nodejs .next
+
+# Leverage output traces to reduce image size (standalone output copy)
+COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
+COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
+
+USER nextjs
+
+EXPOSE 3000
+ENV PORT=3000
+ENV HOSTNAME="0.0.0.0"
+
+CMD ["node", "server.js"]
+`;
+  const dockerignoreContent = `node_modules
+.next
+out
+build
+.dockerignore
+Dockerfile
+.git
+.github
+.gitlab-ci.yml
+README.md
+`;
+  addAppFile(context, "Dockerfile", dockerfileContent);
+  addAppFile(context, ".dockerignore", dockerignoreContent);
+}
+
+// src/generate/features/monorepo/index.ts
+async function generateMonorepo(context) {
+  const { config } = context;
+  if (!config.monorepo) {
+    return;
+  }
+  addRootDevDependency(context, "turbo", dependencyVersions["turbo"]);
+  const workspaceContent = `packages:
+  - 'apps/*'
+  - 'packages/*'
+`;
+  addProjectFile(context, "pnpm-workspace.yaml", workspaceContent);
+  const turboContent = {
+    $schema: "https://turbo.build/schema.json",
+    tasks: {
+      build: {
+        dependsOn: ["^build"],
+        outputs: [".next/**", "!.next/cache/**"]
+      },
+      lint: {},
+      typecheck: {}
+    }
+  };
+  addProjectFile(context, "turbo.json", JSON.stringify(turboContent, null, 2) + "\n");
+  const configPkg = {
+    name: "@enterprise/config",
+    version: "0.0.0",
+    private: true
+  };
+  addProjectFile(context, "packages/config/package.json", JSON.stringify(configPkg, null, 2) + "\n");
+  const typesPkg = {
+    name: "@enterprise/types",
+    version: "0.0.0",
+    private: true
+  };
+  addProjectFile(context, "packages/types/package.json", JSON.stringify(typesPkg, null, 2) + "\n");
+  const uiPkg = {
+    name: "@enterprise/ui",
+    version: "0.0.0",
+    private: true
+  };
+  addProjectFile(context, "packages/ui/package.json", JSON.stringify(uiPkg, null, 2) + "\n");
+}
+
+// src/generate/package-json.ts
+function compilePackageJsons(context) {
+  const { config, manifest } = context;
+  const sortKeys = (obj) => {
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+      sorted[key] = obj[key];
+    }
+    return sorted;
+  };
+  const appScripts = {
+    dev: "next dev",
+    build: "next build",
+    start: "next start",
+    lint: "next lint",
+    ...manifest.scripts
+  };
+  if (config.typescript) {
+    appScripts.typecheck = "tsc --noEmit";
+  }
+  const appPkg = {
+    name: config.monorepo ? "web" : config.projectName,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: sortKeys(appScripts),
+    dependencies: sortKeys(manifest.dependencies),
+    devDependencies: sortKeys(manifest.devDependencies)
+  };
+  if (config.monorepo) {
+    context.manifest.files.set(
+      "apps/web/package.json",
+      JSON.stringify(appPkg, null, 2) + "\n"
+    );
+    const rootScripts = {
+      dev: "turbo dev",
+      build: "turbo build",
+      lint: "turbo lint",
+      ...manifest.rootScripts
+    };
+    if (config.typescript) {
+      rootScripts.typecheck = "turbo typecheck";
+    }
+    const rootPkg = {
+      name: config.projectName,
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      workspaces: ["apps/*", "packages/*"],
+      scripts: sortKeys(rootScripts),
+      dependencies: sortKeys(manifest.rootDependencies),
+      devDependencies: sortKeys(manifest.rootDevDependencies)
+    };
+    context.manifest.files.set(
+      "package.json",
+      JSON.stringify(rootPkg, null, 2) + "\n"
+    );
+  } else {
+    context.manifest.files.set(
+      "package.json",
+      JSON.stringify(appPkg, null, 2) + "\n"
+    );
+  }
+}
+
+// src/generate/summary.ts
 import pc2 from "picocolors";
+function printGenerationSummary(context) {
+  const { config } = context;
+  const getTestingLabel = () => {
+    if (config.testing.length === 0) return "None";
+    return config.testing.map((t) => {
+      if (t === "vitest") return "Vitest";
+      if (t === "jest") return "Jest";
+      if (t === "playwright") return "Playwright";
+      if (t === "cypress") return "Cypress";
+      return t;
+    }).join(", ");
+  };
+  const getStylingLabel = () => {
+    if (config.styling === "tailwind") return "Tailwind CSS";
+    if (config.styling === "css-modules") return "CSS Modules";
+    if (config.styling === "styled-components") return "Styled Components";
+    return config.styling;
+  };
+  const getAuthLabel = () => {
+    if (config.auth === "none") return "None";
+    if (config.auth === "clerk") return "Clerk";
+    if (config.auth === "next-auth") return "NextAuth.js";
+    if (config.auth === "auth0") return "Auth0";
+    return config.auth;
+  };
+  const getOrmLabel = () => {
+    if (config.orm === "none") return "None";
+    if (config.orm === "prisma") return "Prisma";
+    if (config.orm === "drizzle") return "Drizzle";
+    return config.orm;
+  };
+  const getDbLabel = () => {
+    if (!config.database) return "None";
+    if (config.database === "postgres") return "PostgreSQL";
+    if (config.database === "mysql") return "MySQL";
+    if (config.database === "sqlite") return "SQLite";
+    if (config.database === "mongo") return "MongoDB";
+    return config.database;
+  };
+  const getCiLabel = () => {
+    if (config.ci === "none") return "None";
+    if (config.ci === "github-actions") return "GitHub Actions";
+    if (config.ci === "gitlab-ci") return "GitLab CI";
+    return config.ci;
+  };
+  const getStateLabel = () => {
+    if (config.stateManagement === "none") return "None";
+    if (config.stateManagement === "zustand") return "Zustand";
+    if (config.stateManagement === "redux") return "Redux Toolkit";
+    if (config.stateManagement === "jotai") return "Jotai";
+    return config.stateManagement;
+  };
+  console.log("\n" + pc2.green("\u2714 Project created successfully") + "\n");
+  console.log(`  ${pc2.bold("Project:")}         ${config.projectName}`);
+  console.log(`  ${pc2.bold("Language:")}        ${config.typescript ? "TypeScript" : "JavaScript"}`);
+  console.log(`  ${pc2.bold("Framework:")}       Next.js (App Router)`);
+  console.log(`  ${pc2.bold("Styling:")}         ${getStylingLabel()}`);
+  console.log(`  ${pc2.bold("Auth:")}            ${getAuthLabel()}`);
+  console.log(`  ${pc2.bold("ORM:")}             ${getOrmLabel()}`);
+  if (config.orm !== "none") {
+    console.log(`  ${pc2.bold("Database:")}        ${getDbLabel()}`);
+  }
+  console.log(`  ${pc2.bold("State Mgmt:")}      ${getStateLabel()}`);
+  console.log(`  ${pc2.bold("Testing:")}         ${getTestingLabel()}`);
+  console.log(`  ${pc2.bold("CI:")}              ${getCiLabel()}`);
+  console.log(`  ${pc2.bold("Docker:")}          ${config.docker ? "Yes" : "No"}`);
+  console.log(`  ${pc2.bold("Monorepo:")}        ${config.monorepo ? "Yes (Turborepo)" : "No"}`);
+  console.log(`  ${pc2.bold("Package Mgr:")}     ${config.packageManager}`);
+  console.log();
+  console.log(pc2.cyan("Next steps:"));
+  console.log();
+  console.log(`  cd ${config.projectName}`);
+  const pm = config.packageManager;
+  if (pm === "npm") {
+    console.log(`  npm install`);
+    console.log(`  npm run dev`);
+  } else if (pm === "pnpm") {
+    console.log(`  pnpm install`);
+    console.log(`  pnpm dev`);
+  } else if (pm === "yarn") {
+    console.log(`  yarn`);
+    console.log(`  yarn dev`);
+  } else if (pm === "bun") {
+    console.log(`  bun install`);
+    console.log(`  bun dev`);
+  }
+  console.log();
+}
+
+// src/generate/generate-project.ts
+function compileEnvExample(context) {
+  const keys = Object.keys(context.manifest.env);
+  let content = "# Environment Variables\n\n";
+  if (keys.length === 0) {
+    content += "# No environment variables required for this setup.\n";
+  } else {
+    for (const key of keys) {
+      content += `${key}=${context.manifest.env[key] || ""}
+`;
+    }
+  }
+  addAppFile(context, ".env.example", content);
+}
+async function generateProject(config, cwd) {
+  const context = createGenerationContext(config, cwd);
+  const { targetDir, manifest } = context;
+  const s = clack2.spinner();
+  s.start("Initializing project structure");
+  try {
+    s.message("Configuring base Next.js templates");
+    await generateBaseProject(context);
+    s.message("Configuring styling");
+    await generateStyling(context);
+    s.message("Configuring authentication");
+    await generateAuthentication(context);
+    s.message("Configuring database & ORM");
+    await generateOrm(context);
+    s.message("Configuring state management");
+    await generateStateManagement(context);
+    s.message("Configuring testing suites");
+    await generateTesting(context);
+    s.message("Configuring CI workflows");
+    await generateCi(context);
+    s.message("Configuring Docker environment");
+    await generateDocker(context);
+    s.message("Configuring monorepo structures");
+    await generateMonorepo(context);
+    generateReadme(context);
+    compileEnvExample(context);
+    compilePackageJsons(context);
+    s.message("Validating destination directory");
+    const isTargetEmpty = await directoryIsEmpty(targetDir, ".");
+    if (!isTargetEmpty) {
+      throw new Error(`Destination directory "${targetDir}" is not empty.`);
+    }
+    s.message("Writing files to disk");
+    await ensureDirectory(targetDir, ".");
+    for (const [relPath, content] of manifest.files.entries()) {
+      await writeFile(targetDir, relPath, content);
+    }
+    s.stop("Project configuration completed successfully");
+    printGenerationSummary(context);
+  } catch (error) {
+    s.stop("Generation failed", 1);
+    throw error;
+  }
+}
+
+// src/utils/logger.ts
+import pc3 from "picocolors";
 var logger = {
-  info: (msg) => console.log(pc2.blue("\u2139 ") + msg),
-  success: (msg) => console.log(pc2.green("\u2714 ") + msg),
-  warn: (msg) => console.warn(pc2.yellow("\u26A0 ") + msg),
-  error: (msg) => console.error(pc2.red("\u2716 ") + msg),
+  info: (msg) => console.log(pc3.blue("\u2139 ") + msg),
+  success: (msg) => console.log(pc3.green("\u2714 ") + msg),
+  warn: (msg) => console.warn(pc3.yellow("\u26A0 ") + msg),
+  error: (msg) => console.error(pc3.red("\u2716 ") + msg),
   log: (msg) => console.log(msg)
 };
 
@@ -440,10 +2202,10 @@ var logger = {
 function getPackageVersion() {
   try {
     const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path3.dirname(__filename);
-    const pkgPath = path3.resolve(__dirname, "../package.json");
-    if (fs3.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    const __dirname = path4.dirname(__filename);
+    const pkgPath = path4.resolve(__dirname, "../package.json");
+    if (fs4.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
       if (pkg.version) return pkg.version;
     }
   } catch {
@@ -479,8 +2241,7 @@ async function main() {
         console.log(JSON.stringify(config, null, 2));
         process.exit(0);
       }
-      console.log(JSON.stringify(config, null, 2));
-      logger.success("Config resolved \u2014 scaffolding logic not yet implemented");
+      await generateProject(config);
     } catch (err) {
       logger.error(err instanceof Error ? err.message : String(err));
       process.exit(1);