bunkit-cli 0.4.2 → 0.5.0

package/dist/index.js

@@ -23958,7 +23958,17 @@ var ProjectConfigSchema = exports_external.object({
   path: exports_external.string(),
   features: exports_external.array(exports_external.string()).optional(),
   git: exports_external.boolean().default(true),
-  install: exports_external.boolean().default(true)
+  install: exports_external.boolean().default(true),
+  database: exports_external.enum(["postgres-drizzle", "supabase", "sqlite-drizzle", "none"]).optional(),
+  codeQuality: exports_external.enum(["ultracite", "biome"]).default("ultracite"),
+  tsStrictness: exports_external.enum(["strict", "moderate", "loose"]).default("strict"),
+  uiLibrary: exports_external.enum(["shadcn", "none"]).optional(),
+  cssFramework: exports_external.enum(["tailwind", "vanilla", "css-modules"]).optional(),
+  testing: exports_external.enum(["bun-test", "vitest", "none"]).default("bun-test"),
+  docker: exports_external.boolean().default(false),
+  cicd: exports_external.boolean().default(false),
+  envExample: exports_external.boolean().default(true),
+  pathAliases: exports_external.boolean().default(true)
 });
 var FeatureConfigSchema = exports_external.object({
   name: exports_external.enum(["auth", "database", "ui", "payments", "email", "storage"]),
@@ -24094,7 +24104,17 @@ function createTemplateContext(config) {
     description: `Project created with bunkit`,
     license: "MIT",
     features: config.features || [],
-    supportsTypeScript: true
+    supportsTypeScript: true,
+    database: config.database,
+    codeQuality: config.codeQuality,
+    tsStrictness: config.tsStrictness,
+    uiLibrary: config.uiLibrary,
+    cssFramework: config.cssFramework,
+    testing: config.testing,
+    docker: config.docker,
+    cicd: config.cicd,
+    envExample: config.envExample,
+    pathAliases: config.pathAliases
   };
 }
 // ../core/src/install.ts
@@ -24112,7 +24132,7 @@ async function installDependencies(cwd, packages) {
     throw error;
   }
 }
-// src/commands/init.real.ts
+// src/commands/init.enhanced.ts
 var import_picocolors4 = __toESM(require_picocolors(), 1);
 
 // ../templates/src/render.ts
@@ -24161,6 +24181,551 @@ coverage = true
 `;
   await writeFile(join(projectPath, "bunfig.toml"), bunfigContent);
 }
+// ../templates/src/generators/ultracite.ts
+async function setupUltracite(projectPath, context) {
+  const biomeConfig = `{
+  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "extends": [
+    "ultracite/core",
+    ${context.cssFramework === "tailwind" ? `"ultracite/react",
+    "ultracite/next"` : '"ultracite/react"'}
+  ],
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "ignore": [
+      "node_modules",
+      "dist",
+      "build",
+      ".next",
+      ".turbo",
+      "coverage"
+    ]
+  },
+  "formatter": {
+    "enabled": true,
+    "formatWithErrors": false,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100,
+    "lineEnding": "lf"
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "trailingCommas": "es5",
+      "semicolons": "always",
+      "arrowParentheses": "always",
+      "bracketSpacing": true,
+      "jsxQuoteStyle": "double",
+      "quoteProperties": "asNeeded"
+    }
+  },
+  "json": {
+    "formatter": {
+      "enabled": true,
+      "indentWidth": 2
+    }
+  }
+}
+`;
+  await writeFile(join(projectPath, "biome.jsonc"), biomeConfig);
+  const cursorRules = `# ${context.projectName} - Cursor AI Rules
+
+## Code Style (Ultracite)
+- Follow Biome configuration in biome.jsonc
+- Use single quotes for JavaScript/TypeScript
+- Use double quotes for JSX attributes
+- Always use semicolons
+- 2-space indentation
+- 100 character line width
+- ES5 trailing commas
+
+## TypeScript
+- Strict mode: ${context.tsStrictness === "strict" ? "enabled" : context.tsStrictness === "moderate" ? "moderate" : "disabled"}
+- Always define types explicitly for function parameters and return values
+- Use \`type\` for object types, \`interface\` for contracts
+- Prefer \`const\` assertions for literal types
+
+## React/Next.js Best Practices
+- Use Server Components by default (Next.js 16)
+- Add 'use client' only when needed (hooks, browser APIs, interactivity)
+- Always await \`params\` and \`searchParams\` in Next.js 16
+- Use descriptive variable names (no \`c\`, \`ctx\`, \`req\`, \`res\`)
+
+${context.cssFramework === "tailwind" ? `## Tailwind CSS
+- Use utility classes for styling
+- Follow mobile-first responsive design
+- Use OKLCH colors from theme when available
+- Avoid arbitrary values unless necessary` : ""}
+
+${context.database && context.database !== "none" ? `## Database (${context.database})
+- Always use Drizzle ORM for type-safe queries
+- Define schema in separate files by domain
+- Use transactions for multi-step operations
+- Always handle database errors gracefully` : ""}
+
+## File Naming
+- Pages: \`page.tsx\`, \`layout.tsx\`
+- Components: PascalCase (\`UserCard.tsx\`)
+- Utilities: camelCase (\`formatDate.ts\`)
+- Types: \`*.types.ts\` or in \`types/\` directory
+
+## Testing
+- Write tests for critical business logic
+- Use Bun's built-in test runner
+- Follow AAA pattern: Arrange, Act, Assert
+- Mock external dependencies
+
+## AI Code Generation Guidelines
+- Always generate complete, working code
+- Include error handling
+- Add TypeScript types
+- Write self-documenting code with clear names
+- Add comments only for complex logic
+- Follow the project's existing patterns
+`;
+  await writeFile(join(projectPath, ".cursorrules"), cursorRules);
+  const windsurfRules = `# ${context.projectName} - Windsurf AI Rules
+
+This project uses **Ultracite** for code quality - an AI-optimized Biome preset.
+
+## Code Quality Rules
+- Lint: \`bun run lint\`
+- Format: \`bun run format\`
+- Config: See \`biome.jsonc\`
+
+## Key Conventions
+1. **TypeScript**: ${context.tsStrictness} mode
+2. **Quotes**: Single quotes (JS/TS), double quotes (JSX)
+3. **Semicolons**: Always required
+4. **Indentation**: 2 spaces
+5. **Line width**: 100 characters
+
+## Framework-Specific
+${context.cssFramework === "tailwind" ? `- **Tailwind CSS**: Utility-first styling
+` : ""}${context.database && context.database !== "none" ? `- **Database**: ${context.database} with Drizzle ORM
+` : ""}- **Testing**: ${context.testing}
+
+## Variable Naming (CRITICAL)
+\u274C NEVER use: \`c\`, \`ctx\`, \`e\`, \`req\`, \`res\`, \`data\`, \`temp\`
+\u2705 ALWAYS use: \`context\`, \`error\`, \`request\`, \`response\`, \`userData\`, \`temporaryBuffer\`
+
+## React/Next.js 16
+- Server Components by default
+- \`'use client'\` only when necessary
+- Always \`await params\` and \`await searchParams\`
+
+Sync with \`.cursorrules\` for full AI guidelines.
+`;
+  await writeFile(join(projectPath, ".windsurfrules"), windsurfRules);
+  const claudeMd = `# ${context.projectName}
+
+AI-assisted development with Ultracite code quality.
+
+## Quick Start
+
+\`\`\`bash
+bun install
+bun dev
+\`\`\`
+
+## Code Quality
+
+This project uses **Ultracite** - an AI-optimized Biome preset that keeps code consistent across:
+- Cursor
+- Windsurf
+- Claude Code
+- Zed
+
+### Commands
+
+\`\`\`bash
+bun run lint      # Check code quality
+bun run format    # Auto-fix issues
+\`\`\`
+
+## AI Development Guidelines
+
+See \`.cursorrules\` and \`.windsurfrules\` for comprehensive AI coding guidelines.
+
+### Critical Rules
+
+1. **Descriptive Names**: No \`c\`, \`ctx\`, \`e\` - use \`context\`, \`error\`, etc.
+2. **TypeScript**: ${context.tsStrictness} mode
+3. **Server Components**: Default in Next.js 16
+4. **Error Handling**: Always handle errors gracefully
+
+## Tech Stack
+
+- **Runtime**: Bun
+- **Framework**: ${context.preset === "web" || context.preset === "full" ? "Next.js 16 + React 19" : context.preset === "api" ? "Hono" : "Minimal"}
+${context.cssFramework === "tailwind" ? `- **Styling**: Tailwind CSS 4
+` : ""}${context.database && context.database !== "none" ? `- **Database**: ${context.database}
+` : ""}${context.uiLibrary === "shadcn" ? `- **UI**: shadcn/ui
+` : ""}- **Code Quality**: Ultracite (Biome)
+- **Testing**: ${context.testing}
+`;
+  await writeFile(join(projectPath, "CLAUDE.md"), claudeMd);
+}
+async function setupBiome(projectPath, context) {
+  const biomeConfig = {
+    $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+    vcs: {
+      enabled: true,
+      clientKind: "git",
+      useIgnoreFile: true
+    },
+    files: {
+      ignore: [
+        "node_modules",
+        "dist",
+        "build",
+        ".next",
+        ".turbo",
+        "coverage"
+      ]
+    },
+    formatter: {
+      enabled: true,
+      indentStyle: "space",
+      indentWidth: 2,
+      lineWidth: 100
+    },
+    linter: {
+      enabled: true,
+      rules: {
+        recommended: true
+      }
+    },
+    javascript: {
+      formatter: {
+        quoteStyle: "single",
+        trailingCommas: "es5",
+        semicolons: "always"
+      }
+    }
+  };
+  await writeFile(join(projectPath, "biome.json"), JSON.stringify(biomeConfig, null, 2));
+}
+function getCodeQualityDependencies(codeQuality) {
+  if (codeQuality === "ultracite") {
+    return ["ultracite", "@biomejs/biome"];
+  }
+  return ["@biomejs/biome"];
+}
+
+// ../templates/src/generators/docker.ts
+async function setupDocker(projectPath, context) {
+  const dockerfile = `# Use Bun official image
+FROM oven/bun:1 AS base
+
+# Install dependencies
+FROM base AS deps
+WORKDIR /app
+COPY package.json bun.lock* ./
+RUN bun install --frozen-lockfile
+
+# Build application
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+
+${context.preset === "web" || context.preset === "full" ? `# Build Next.js app
+RUN bun run build
+` : "# No build step needed for API/minimal"}
+# Production image
+FROM base AS runner
+WORKDIR /app
+
+# Create non-root user
+RUN addgroup --system --gid 1001 bunuser && \\
+    adduser --system --uid 1001 bunuser
+
+${context.preset === "web" || context.preset === "full" ? `# Copy Next.js build
+COPY --from=builder --chown=bunuser:bunuser /app/.next/standalone ./
+COPY --from=builder --chown=bunuser:bunuser /app/.next/static ./.next/static
+COPY --from=builder --chown=bunuser:bunuser /app/public ./public
+` : `# Copy application
+COPY --from=builder --chown=bunuser:bunuser /app/src ./src
+COPY --from=builder --chown=bunuser:bunuser /app/package.json ./package.json
+`}
+USER bunuser
+
+EXPOSE 3000
+
+ENV PORT=3000
+ENV NODE_ENV=production
+
+${context.preset === "web" || context.preset === "full" ? 'CMD ["bun", "run", "start"]' : 'CMD ["bun", "run", "src/index.ts"]'}
+`;
+  await writeFile(join(projectPath, "Dockerfile"), dockerfile);
+  const dockerCompose = `version: '3.8'
+
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      ${context.database && context.database !== "none" && context.database !== "supabase" ? "- DATABASE_URL=${DATABASE_URL:-postgres://postgres:postgres@db:5432/${context.projectName}}" : ""}
+    ${context.database && context.database !== "none" && context.database !== "supabase" ? `depends_on:
+      - db` : ""}
+    restart: unless-stopped
+
+  ${context.database && context.database !== "none" && context.database !== "supabase" ? `db:
+    image: ${context.database === "sqlite-drizzle" ? "alpine:latest" : "postgres:16-alpine"}
+    ${context.database !== "sqlite-drizzle" ? `environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=${context.projectName}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"` : `volumes:
+      - sqlite_data:/data`}
+    restart: unless-stopped
+` : ""}
+${context.database && context.database !== "none" && context.database !== "supabase" ? `volumes:
+  ${context.database === "sqlite-drizzle" ? "sqlite_data:" : "postgres_data:"}` : ""}
+`;
+  await writeFile(join(projectPath, "docker-compose.yml"), dockerCompose);
+  const dockerignore = `# Dependencies
+node_modules/
+bun.lock
+
+# Build
+dist/
+build/
+.next/
+.turbo/
+
+# Environment
+.env
+.env*.local
+
+# Logs
+*.log
+npm-debug.log*
+
+# OS
+.DS_Store
+
+# IDEs
+.vscode/
+.idea/
+
+# Git
+.git/
+.gitignore
+
+# Documentation
+README.md
+CLAUDE.md
+.cursorrules
+.windsurfrules
+
+# Tests
+*.test.ts
+*.test.tsx
+*.spec.ts
+*.spec.tsx
+coverage/
+`;
+  await writeFile(join(projectPath, ".dockerignore"), dockerignore);
+}
+
+// ../templates/src/generators/cicd.ts
+async function setupGitHubActions(projectPath, context) {
+  await ensureDirectory(join(projectPath, ".github/workflows"));
+  const ciWorkflow = `name: CI
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+
+jobs:
+  lint:
+    name: Lint & Format Check
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Run linter
+        run: bun run lint
+
+  typecheck:
+    name: Type Check
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Type check
+        run: ${context.preset === "full" ? "bun run --filter '*' typecheck" : "bun run typecheck"}
+
+  ${context.testing !== "none" ? `test:
+    name: Run Tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Run tests
+        run: ${context.testing === "bun-test" ? "bun test" : "bun run test"}
+        ${context.database && context.database !== "none" ? `env:
+          DATABASE_URL: sqlite://test.db` : ""}
+` : ""}
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    needs: [lint, typecheck${context.testing !== "none" ? ", test" : ""}]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      ${context.preset === "web" || context.preset === "full" ? `- name: Build application
+        run: bun run build
+        env:
+          ${context.database === "supabase" ? `NEXT_PUBLIC_SUPABASE_URL: \${{ secrets.SUPABASE_URL }}
+          NEXT_PUBLIC_SUPABASE_ANON_KEY: \${{ secrets.SUPABASE_ANON_KEY }}
+          ` : ""}NODE_ENV: production` : ""}
+
+      ${context.docker ? `- name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: false
+          tags: ${context.projectName}:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max` : ""}
+`;
+  await writeFile(join(projectPath, ".github/workflows/ci.yml"), ciWorkflow);
+  const deployWorkflow = `# name: Deploy
+#
+# on:
+#   push:
+#     branches: [main]
+#
+# jobs:
+#   deploy:
+#     name: Deploy to Production
+#     runs-on: ubuntu-latest
+#     environment: production
+#
+#     steps:
+#       - name: Checkout code
+#         uses: actions/checkout@v4
+#
+#       - name: Setup Bun
+#         uses: oven-sh/setup-bun@v2
+#         with:
+#           bun-version: latest
+#
+#       - name: Install dependencies
+#         run: bun install --frozen-lockfile
+#
+#       - name: Build
+#         run: bun run build
+#         env:
+#           NODE_ENV: production
+#           ${context.database === "supabase" ? `NEXT_PUBLIC_SUPABASE_URL: \${{ secrets.SUPABASE_URL }}
+#           NEXT_PUBLIC_SUPABASE_ANON_KEY: \${{ secrets.SUPABASE_ANON_KEY }}` : ""}
+#
+#       # Add your deployment steps here
+#       # Examples:
+#       # - Deploy to Vercel
+#       # - Deploy to Railway
+#       # - Deploy to your own server via SSH
+#       # - Push Docker image to registry
+`;
+  await writeFile(join(projectPath, ".github/workflows/deploy.yml.example"), deployWorkflow);
+  const dependabotConfig = `version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 10
+    reviewers:
+      - "your-github-username"
+    labels:
+      - "dependencies"
+
+  ${context.docker ? `- package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    labels:
+      - "dependencies"
+      - "docker"` : ""}
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    labels:
+      - "dependencies"
+      - "ci"
+`;
+  await writeFile(join(projectPath, ".github/dependabot.yml"), dependabotConfig);
+}
+
 // ../templates/src/builders/web.ts
 async function buildWebPreset(projectPath, context) {
   await ensureDirectory(join(projectPath, "src/app"));
@@ -24234,51 +24799,226 @@ const config: Config = {
 export default config;
 `;
   await writeFile(join(projectPath, "tailwind.config.ts"), tailwindConfigContent);
-  const tsconfigContent = {
-    compilerOptions: {
+  const getTsCompilerOptions = () => {
+    const baseOptions = {
       target: "ES2017",
       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",
+      jsx: "react-jsx",
       incremental: true,
       plugins: [{ name: "next" }],
-      paths: {
-        "@/*": ["./src/*"]
-      }
-    },
-    include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+      paths: context.pathAliases ? { "@/*": ["./src/*"] } : undefined
+    };
+    if (context.tsStrictness === "strict") {
+      return {
+        ...baseOptions,
+        strict: true,
+        noUnusedLocals: true,
+        noUnusedParameters: true,
+        noFallthroughCasesInSwitch: true,
+        noImplicitReturns: true
+      };
+    }
+    if (context.tsStrictness === "moderate") {
+      return {
+        ...baseOptions,
+        strict: true,
+        noUnusedLocals: false,
+        noUnusedParameters: false
+      };
+    }
+    return {
+      ...baseOptions,
+      strict: false,
+      noImplicitAny: false
+    };
+  };
+  const tsconfigContent = {
+    compilerOptions: getTsCompilerOptions(),
+    include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/dev/types/**/*.ts"],
     exclude: ["node_modules"]
   };
   await writeFile(join(projectPath, "tsconfig.json"), JSON.stringify(tsconfigContent, null, 2));
-  const biomeContent = {
-    $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
-    vcs: {
-      enabled: true,
-      clientKind: "git",
-      useIgnoreFile: true
-    },
-    formatter: {
-      enabled: true,
-      indentStyle: "space",
-      indentWidth: 2
-    },
-    linter: {
-      enabled: true,
-      rules: {
-        recommended: true
-      }
-    }
-  };
-  await writeFile(join(projectPath, "biome.json"), JSON.stringify(biomeContent, null, 2));
+  if (context.codeQuality === "ultracite") {
+    await setupUltracite(projectPath, context);
+  } else {
+    await setupBiome(projectPath, context);
+  }
+  if (context.docker) {
+    await setupDocker(projectPath, context);
+  }
+  if (context.cicd) {
+    await setupGitHubActions(projectPath, context);
+  }
+}
+// ../templates/src/generators/database.ts
+async function setupPostgresDrizzle(projectPath, context, isMonorepo = false) {
+  const dbPath = isMonorepo ? join(projectPath, "packages/db") : join(projectPath, "src/db");
+  await ensureDirectory(join(dbPath, "schema"));
+  const drizzleConfig = `import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  schema: './src/schema/index.ts',
+  out: './drizzle',
+  dialect: 'postgresql',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+`;
+  await writeFile(join(isMonorepo ? join(projectPath, "packages/db") : projectPath, "drizzle.config.ts"), drizzleConfig);
+  const clientContent = `import { drizzle } from 'drizzle-orm/bun-postgres';
+import { Database } from 'bun:postgres';
+import * as schema from './schema';
+
+const client = new Database(process.env.DATABASE_URL!);
+export const db = drizzle(client, { schema });
+`;
+  await writeFile(join(dbPath, "index.ts"), clientContent);
+  const schemaContent = `import { pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+
+export const users = pgTable('users', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  email: text('email').notNull().unique(),
+  name: text('name'),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),
+});
+`;
+  await writeFile(join(dbPath, "schema/index.ts"), schemaContent);
+  const envExample = `# Database
+DATABASE_URL=postgresql://postgres:postgres@localhost:5432/${context.projectName}
+`;
+  await writeFile(join(projectPath, ".env.example"), envExample);
+}
+async function setupSupabase(projectPath, context, isMonorepo = false) {
+  const dbPath = isMonorepo ? join(projectPath, "packages/db") : join(projectPath, "src/db");
+  await ensureDirectory(join(dbPath, "schema"));
+  const drizzleConfig = `import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  schema: './src/schema/index.ts',
+  out: './supabase/migrations',
+  dialect: 'postgresql',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+`;
+  await writeFile(join(isMonorepo ? join(projectPath, "packages/db") : projectPath, "drizzle.config.ts"), drizzleConfig);
+  const clientContent = `import { createClient } from '@supabase/supabase-js';
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import * as schema from './schema';
+
+// Supabase client for auth, storage, realtime
+export const supabase = createClient(
+  process.env.NEXT_PUBLIC_SUPABASE_URL!,
+  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
+);
+
+// Drizzle client for type-safe database queries
+const queryClient = postgres(process.env.DATABASE_URL!);
+export const db = drizzle(queryClient, { schema });
+`;
+  await writeFile(join(dbPath, "index.ts"), clientContent);
+  const schemaContent = `import { pgTable, text, timestamp, uuid, boolean } from 'drizzle-orm/pg-core';
+
+export const users = pgTable('users', {
+  id: uuid('id').primaryKey(),
+  email: text('email').notNull().unique(),
+  name: text('name'),
+  avatarUrl: text('avatar_url'),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),
+});
+
+export const profiles = pgTable('profiles', {
+  id: uuid('id').primaryKey().references(() => users.id),
+  username: text('username').unique(),
+  bio: text('bio'),
+  website: text('website'),
+  isPublic: boolean('is_public').default(true),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),
+});
+`;
+  await writeFile(join(dbPath, "schema/index.ts"), schemaContent);
+  await ensureDirectory(join(projectPath, "supabase/migrations"));
+  const envExample = `# Supabase
+NEXT_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
+NEXT_PUBLIC_SUPABASE_ANON_KEY=your-anon-key
+DATABASE_URL=postgresql://postgres:[password]@db.your-project.supabase.co:5432/postgres
+`;
+  await writeFile(join(projectPath, ".env.example"), envExample);
+}
+async function setupSQLiteDrizzle(projectPath, context, isMonorepo = false) {
+  const dbPath = isMonorepo ? join(projectPath, "packages/db") : join(projectPath, "src/db");
+  await ensureDirectory(join(dbPath, "schema"));
+  const drizzleConfig = `import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  schema: './src/schema/index.ts',
+  out: './drizzle',
+  dialect: 'sqlite',
+  dbCredentials: {
+    url: process.env.DATABASE_URL || './local.db',
+  },
+});
+`;
+  await writeFile(join(isMonorepo ? join(projectPath, "packages/db") : projectPath, "drizzle.config.ts"), drizzleConfig);
+  const clientContent = `import { drizzle } from 'drizzle-orm/bun-sqlite';
+import { Database } from 'bun:sqlite';
+import * as schema from './schema';
+
+const sqlite = new Database(process.env.DATABASE_URL || './local.db');
+export const db = drizzle(sqlite, { schema });
+`;
+  await writeFile(join(dbPath, "index.ts"), clientContent);
+  const schemaContent = `import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+import { sql } from 'drizzle-orm';
+
+export const users = sqliteTable('users', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  email: text('email').notNull().unique(),
+  name: text('name'),
+  createdAt: integer('created_at', { mode: 'timestamp' }).default(sql\`(unixepoch())\`).notNull(),
+  updatedAt: integer('updated_at', { mode: 'timestamp' }).default(sql\`(unixepoch())\`).notNull(),
+});
+`;
+  await writeFile(join(dbPath, "schema/index.ts"), schemaContent);
+  const envExample = `# Database
+DATABASE_URL=./local.db
+`;
+  await writeFile(join(projectPath, ".env.example"), envExample);
+  const gitignoreAddition = `
+# SQLite
+*.db
+*.db-shm
+*.db-wal
+`;
+  await writeFile(join(projectPath, ".gitignore.db"), gitignoreAddition);
+}
+function getDatabaseDependencies(databaseType) {
+  switch (databaseType) {
+    case "postgres-drizzle":
+      return ["drizzle-orm", "drizzle-kit"];
+    case "supabase":
+      return ["@supabase/supabase-js", "drizzle-orm", "drizzle-kit", "postgres"];
+    case "sqlite-drizzle":
+      return ["drizzle-orm", "drizzle-kit"];
+    default:
+      return [];
+  }
 }
+
 // ../templates/src/builders/api.ts
 async function buildApiPreset(projectPath, context) {
   await ensureDirectory(join(projectPath, "src/routes"));
@@ -24287,6 +25027,9 @@ async function buildApiPreset(projectPath, context) {
 import { serve } from 'bun';
 import { logger } from 'hono/logger';
 import { cors } from 'hono/cors';
+${context.database && context.database !== "none" ? `import { db } from './db';
+import { users } from './db/schema';
+import { eq } from 'drizzle-orm';` : ""}
 
 const app = new Hono();
 
@@ -24299,6 +25042,7 @@ app.get('/', (context) => {
   return context.json({
     message: 'Welcome to ${context.projectName} API \uD83C\uDF5E',
     version: '1.0.0',
+    database: '${context.database || "none"}',
   });
 });
 
@@ -24309,6 +25053,44 @@ app.get('/health', (context) => {
   });
 });
 
+${context.database && context.database !== "none" ? `// Database example routes
+app.get('/users', async (context) => {
+  try {
+    const allUsers = await db.select().from(users);
+    return context.json({ users: allUsers });
+  } catch (error) {
+    console.error('Database error:', error);
+    return context.json({ error: 'Failed to fetch users' }, 500);
+  }
+});
+
+app.get('/users/:id', async (context) => {
+  try {
+    const id = context.req.param('id');
+    const user = await db.select().from(users).where(eq(users.id, id)).limit(1);
+
+    if (!user.length) {
+      return context.json({ error: 'User not found' }, 404);
+    }
+
+    return context.json({ user: user[0] });
+  } catch (error) {
+    console.error('Database error:', error);
+    return context.json({ error: 'Failed to fetch user' }, 500);
+  }
+});
+
+app.post('/users', async (context) => {
+  try {
+    const body = await context.req.json();
+    const newUser = await db.insert(users).values(body).returning();
+    return context.json({ user: newUser[0] }, 201);
+  } catch (error) {
+    console.error('Database error:', error);
+    return context.json({ error: 'Failed to create user' }, 500);
+  }
+});
+` : ""}
 // 404 handler
 app.notFound((context) => {
   return context.json({ error: 'Not found' }, 404);
@@ -24330,7 +25112,8 @@ serve({
   },
 });
 
-console.log('\uD83D\uDE80 API running on http://localhost:3001');
+console.log('\uD83D\uDE80 ${context.projectName} API running on http://localhost:3001');
+${context.database && context.database !== "none" ? "console.log('\uD83D\uDCCA Database:', process.env.DATABASE_URL || 'Not configured');" : ""}
 `;
   await writeFile(join(projectPath, "src/index.ts"), indexContent);
   const usersRouteContent = `import { Hono } from 'hono';
@@ -24354,8 +25137,8 @@ users.get('/:id', (context) => {
 export default users;
 `;
   await writeFile(join(projectPath, "src/routes/users.ts"), usersRouteContent);
-  const tsconfigContent = {
-    compilerOptions: {
+  const getTsCompilerOptions = () => {
+    const baseOptions = {
       lib: ["ESNext"],
       target: "ESNext",
       module: "ESNext",
@@ -24365,20 +25148,63 @@ export default users;
       allowImportingTsExtensions: true,
       verbatimModuleSyntax: true,
       noEmit: true,
-      strict: true,
       skipLibCheck: true,
-      noFallthroughCasesInSwitch: true,
-      types: ["bun-types"]
+      types: ["bun"],
+      paths: context.pathAliases ? { "@/*": ["./src/*"] } : undefined
+    };
+    if (context.tsStrictness === "strict") {
+      return {
+        ...baseOptions,
+        strict: true,
+        noUnusedLocals: true,
+        noUnusedParameters: true,
+        noFallthroughCasesInSwitch: true,
+        noImplicitReturns: true
+      };
+    }
+    if (context.tsStrictness === "moderate") {
+      return {
+        ...baseOptions,
+        strict: true,
+        noFallthroughCasesInSwitch: true
+      };
     }
+    return {
+      ...baseOptions,
+      strict: false
+    };
+  };
+  const tsconfigContent = {
+    compilerOptions: getTsCompilerOptions()
   };
   await writeFile(join(projectPath, "tsconfig.json"), JSON.stringify(tsconfigContent, null, 2));
   const bunfigContent = `[install]
 frozenLockfile = false
 
-[test]
+${context.testing !== "none" ? `[test]
 coverage = true
-`;
+` : ""}`;
   await writeFile(join(projectPath, "bunfig.toml"), bunfigContent);
+  if (context.database && context.database !== "none") {
+    if (context.database === "postgres-drizzle") {
+      await setupPostgresDrizzle(projectPath, context, false);
+    } else if (context.database === "supabase") {
+      await setupSupabase(projectPath, context, false);
+    } else if (context.database === "sqlite-drizzle") {
+      await setupSQLiteDrizzle(projectPath, context, false);
+    }
+  }
+  if (context.codeQuality === "ultracite") {
+    await setupUltracite(projectPath, context);
+  } else {
+    await setupBiome(projectPath, context);
+  }
+  if (context.docker) {
+    await setupDocker(projectPath, context);
+  }
+  if (context.cicd) {
+    await setupGitHubActions(projectPath, context);
+  }
 }
 // ../templates/src/builders/full.ts
 async function buildFullPreset(projectPath, context) {
@@ -24387,6 +25213,9 @@ async function buildFullPreset(projectPath, context) {
   await ensureDirectory(join(projectPath, "apps/api"));
   await ensureDirectory(join(projectPath, "packages/types"));
   await ensureDirectory(join(projectPath, "packages/utils"));
+  if (context.database && context.database !== "none") {
+    await ensureDirectory(join(projectPath, "packages/db"));
+  }
   const rootPackageJson = {
     name: `${context.packageName}-monorepo`,
     version: "0.0.0",
@@ -24438,7 +25267,8 @@ coverage = true
       "@types/react": "^19.1.0",
       "@types/react-dom": "^19.1.0",
       "@types/node": "^22.10.6",
-      typescript: "^5.7.2"
+      typescript: "^5.7.2",
+      tailwindcss: "^4.1.5"
     }
   };
   await writeFile(join(projectPath, "apps/web/package.json"), JSON.stringify(webPackageJson, null, 2));
@@ -24461,7 +25291,8 @@ coverage = true
       "@types/react": "^19.1.0",
       "@types/react-dom": "^19.1.0",
       "@types/node": "^22.10.6",
-      typescript: "^5.7.2"
+      typescript: "^5.7.2",
+      tailwindcss: "^4.1.5"
     }
   };
   await writeFile(join(projectPath, "apps/platform/package.json"), JSON.stringify(platformPackageJson, null, 2));
@@ -24471,7 +25302,8 @@ coverage = true
     private: true,
     scripts: {
       dev: "bun run --hot src/index.ts",
-      start: "bun run src/index.ts"
+      start: "bun run src/index.ts",
+      typecheck: "tsc --noEmit"
     },
     dependencies: {
       hono: "catalog:",
@@ -24507,6 +25339,332 @@ export interface ApiResponse<T = unknown> {
 }
 `;
   await writeFile(join(projectPath, "packages/types/src/index.ts"), typesContent);
+  const utilsPackageJson = {
+    name: `@${context.packageName}/utils`,
+    version: "0.0.0",
+    private: true,
+    main: "./src/index.ts",
+    types: "./src/index.ts"
+  };
+  await writeFile(join(projectPath, "packages/utils/package.json"), JSON.stringify(utilsPackageJson, null, 2));
+  const utilsContent = `// Shared utilities for ${context.projectName}
+
+export function formatDate(date: Date): string {
+  return new Intl.DateTimeFormat('en-US', {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+  }).format(date);
+}
+
+export function validateEmail(email: string): boolean {
+  const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;
+  return emailRegex.test(email);
+}
+
+export function generateId(): string {
+  return Math.random().toString(36).substring(2, 15);
+}
+`;
+  await writeFile(join(projectPath, "packages/utils/src/index.ts"), utilsContent);
+  await ensureDirectory(join(projectPath, "apps/web/src/app"));
+  const webLayoutContent = `import type { Metadata } from 'next';
+import './globals.css';
+
+export const metadata: Metadata = {
+  title: '${context.projectName}',
+  description: 'Enterprise SaaS built with bunkit \uD83C\uDF5E',
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}
+`;
+  await writeFile(join(projectPath, "apps/web/src/app/layout.tsx"), webLayoutContent);
+  const webPageContent = `export default function Home() {
+  return (
+    <main className="min-h-screen flex items-center justify-center bg-gradient-to-br from-blue-50 to-indigo-100">
+      <div className="text-center space-y-6 p-8">
+        <h1 className="text-6xl font-bold text-gray-900">
+          Welcome to ${context.projectName} \uD83C\uDF5E
+        </h1>
+        <p className="text-xl text-gray-600 max-w-2xl">
+          Enterprise-grade SaaS monorepo built with Next.js 16, React 19, Hono, and Bun
+        </p>
+        <div className="flex gap-4 justify-center mt-8">
+          <a
+            href="/dashboard"
+            className="px-6 py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition"
+          >
+            Get Started
+          </a>
+          <a
+            href="/docs"
+            className="px-6 py-3 bg-gray-200 text-gray-800 rounded-lg hover:bg-gray-300 transition"
+          >
+            Documentation
+          </a>
+        </div>
+      </div>
+    </main>
+  );
+}
+`;
+  await writeFile(join(projectPath, "apps/web/src/app/page.tsx"), webPageContent);
+  const webGlobalsCssContent = `@import "tailwindcss";
+
+@theme {
+  --color-primary: oklch(0.6 0.2 250);
+  --color-secondary: oklch(0.5 0.15 280);
+}
+`;
+  await writeFile(join(projectPath, "apps/web/src/app/globals.css"), webGlobalsCssContent);
+  const webNextConfigContent = `import type { NextConfig } from 'next';
+
+const nextConfig: NextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;
+`;
+  await writeFile(join(projectPath, "apps/web/next.config.ts"), webNextConfigContent);
+  const webTailwindConfigContent = `import type { Config } from 'tailwindcss';
+
+const config: Config = {
+  content: ['./src/**/*.{js,ts,jsx,tsx,mdx}'],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+};
+
+export default config;
+`;
+  await writeFile(join(projectPath, "apps/web/tailwind.config.ts"), webTailwindConfigContent);
+  const getWebTsConfig = () => {
+    const baseOptions = {
+      target: "ES2017",
+      lib: ["dom", "dom.iterable", "esnext"],
+      allowJs: true,
+      skipLibCheck: true,
+      noEmit: true,
+      esModuleInterop: true,
+      module: "esnext",
+      moduleResolution: "bundler",
+      resolveJsonModule: true,
+      isolatedModules: true,
+      jsx: "react-jsx",
+      incremental: true,
+      plugins: [{ name: "next" }],
+      paths: context.pathAliases ? { "@/*": ["./src/*"] } : undefined
+    };
+    if (context.tsStrictness === "strict") {
+      return {
+        ...baseOptions,
+        strict: true,
+        noUnusedLocals: true,
+        noUnusedParameters: true,
+        noFallthroughCasesInSwitch: true,
+        noImplicitReturns: true
+      };
+    }
+    if (context.tsStrictness === "moderate") {
+      return {
+        ...baseOptions,
+        strict: true,
+        noUnusedLocals: false,
+        noUnusedParameters: false
+      };
+    }
+    return {
+      ...baseOptions,
+      strict: false,
+      noImplicitAny: false
+    };
+  };
+  const webTsconfigContent = {
+    compilerOptions: getWebTsConfig(),
+    include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/dev/types/**/*.ts"],
+    exclude: ["node_modules"]
+  };
+  await writeFile(join(projectPath, "apps/web/tsconfig.json"), JSON.stringify(webTsconfigContent, null, 2));
+  await ensureDirectory(join(projectPath, "apps/platform/src/app"));
+  const platformLayoutContent = `import type { Metadata } from 'next';
+import './globals.css';
+
+export const metadata: Metadata = {
+  title: '${context.projectName} - Admin Dashboard',
+  description: 'Admin dashboard for ${context.projectName}',
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}
+`;
+  await writeFile(join(projectPath, "apps/platform/src/app/layout.tsx"), platformLayoutContent);
+  const platformPageContent = `export default function Dashboard() {
+  return (
+    <main className="min-h-screen bg-gray-50">
+      <div className="max-w-7xl mx-auto py-12 px-4">
+        <header className="mb-8">
+          <h1 className="text-4xl font-bold text-gray-900">
+            Admin Dashboard
+          </h1>
+          <p className="text-gray-600 mt-2">
+            Manage your ${context.projectName} platform
+          </p>
+        </header>
+
+        <div className="grid grid-cols-1 md:grid-cols-3 gap-6">
+          <div className="bg-white p-6 rounded-lg shadow">
+            <h2 className="text-xl font-semibold mb-2">Users</h2>
+            <p className="text-3xl font-bold text-blue-600">1,234</p>
+          </div>
+          <div className="bg-white p-6 rounded-lg shadow">
+            <h2 className="text-xl font-semibold mb-2">Revenue</h2>
+            <p className="text-3xl font-bold text-green-600">$12,345</p>
+          </div>
+          <div className="bg-white p-6 rounded-lg shadow">
+            <h2 className="text-xl font-semibold mb-2">Active</h2>
+            <p className="text-3xl font-bold text-purple-600">567</p>
+          </div>
+        </div>
+      </div>
+    </main>
+  );
+}
+`;
+  await writeFile(join(projectPath, "apps/platform/src/app/page.tsx"), platformPageContent);
+  const platformGlobalsCssContent = `@import "tailwindcss";
+
+@theme {
+  --color-primary: oklch(0.6 0.2 250);
+  --color-secondary: oklch(0.5 0.15 280);
+}
+`;
+  await writeFile(join(projectPath, "apps/platform/src/app/globals.css"), platformGlobalsCssContent);
+  const platformNextConfigContent = `import type { NextConfig } from 'next';
+
+const nextConfig: NextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;
+`;
+  await writeFile(join(projectPath, "apps/platform/next.config.ts"), platformNextConfigContent);
+  const platformTailwindConfigContent = `import type { Config } from 'tailwindcss';
+
+const config: Config = {
+  content: ['./src/**/*.{js,ts,jsx,tsx,mdx}'],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+};
+
+export default config;
+`;
+  await writeFile(join(projectPath, "apps/platform/tailwind.config.ts"), platformTailwindConfigContent);
+  const platformTsconfigContent = {
+    compilerOptions: getWebTsConfig(),
+    include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/dev/types/**/*.ts"],
+    exclude: ["node_modules"]
+  };
+  await writeFile(join(projectPath, "apps/platform/tsconfig.json"), JSON.stringify(platformTsconfigContent, null, 2));
+  await ensureDirectory(join(projectPath, "apps/api/src"));
+  const apiIndexContent = `import { Hono } from 'hono';
+import { serve } from 'bun';
+import { logger } from 'hono/logger';
+import { cors } from 'hono/cors';
+
+const app = new Hono();
+
+// Middleware
+app.use('*', logger());
+app.use('*', cors());
+
+// Routes
+app.get('/', (context) => {
+  return context.json({
+    message: 'Welcome to ${context.projectName} API \uD83C\uDF5E',
+    version: '1.0.0',
+  });
+});
+
+app.get('/health', (context) => {
+  return context.json({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+  });
+});
+
+app.get('/api/users', (context) => {
+  return context.json({
+    users: [
+      { id: 1, email: 'john@example.com', name: 'John Doe' },
+      { id: 2, email: 'jane@example.com', name: 'Jane Smith' },
+    ],
+  });
+});
+
+// 404 handler
+app.notFound((context) => {
+  return context.json({ error: 'Not found' }, 404);
+});
+
+// Error handler
+app.onError((error, context) => {
+  console.error(\`Error: \${error}\`);
+  return context.json({ error: 'Internal server error' }, 500);
+});
+
+// Start server
+serve({
+  fetch: app.fetch,
+  port: 3001,
+  development: {
+    hmr: true,
+    console: true,
+  },
+});
+
+console.log('\uD83D\uDE80 ${context.projectName} API running on http://localhost:3001');
+`;
+  await writeFile(join(projectPath, "apps/api/src/index.ts"), apiIndexContent);
+  const apiTsconfigContent = {
+    compilerOptions: {
+      lib: ["ESNext"],
+      target: "ESNext",
+      module: "ESNext",
+      moduleDetection: "force",
+      allowJs: true,
+      moduleResolution: "bundler",
+      allowImportingTsExtensions: true,
+      verbatimModuleSyntax: true,
+      noEmit: true,
+      strict: true,
+      skipLibCheck: true,
+      noFallthroughCasesInSwitch: true,
+      types: ["@types/bun"]
+    }
+  };
+  await writeFile(join(projectPath, "apps/api/tsconfig.json"), JSON.stringify(apiTsconfigContent, null, 2));
   const readmeContent = `# ${context.projectName}
 
 Enterprise-grade SaaS monorepo created with [bunkit](https://github.com/Arakiss/bunkit) \uD83C\uDF5E
@@ -24582,8 +25740,107 @@ Built with \u2764\uFE0F using Bun monorepo features
     exclude: ["node_modules"]
   };
   await writeFile(join(projectPath, "tsconfig.json"), JSON.stringify(tsconfigContent, null, 2));
+  if (context.database && context.database !== "none") {
+    const dbPackagePath = join(projectPath, "packages/db");
+    const dbPackageJson = {
+      name: `@${context.packageName}/db`,
+      version: "0.0.0",
+      private: true,
+      main: "./src/index.ts",
+      types: "./src/index.ts",
+      dependencies: context.database === "supabase" ? {
+        "@supabase/supabase-js": "^2.48.1",
+        "drizzle-orm": "^0.38.0",
+        postgres: "^3.4.5"
+      } : {
+        "drizzle-orm": "^0.38.0"
+      },
+      devDependencies: {
+        "drizzle-kit": "^0.30.1",
+        "@types/bun": "latest",
+        typescript: "^5.7.2"
+      }
+    };
+    await writeFile(join(dbPackagePath, "package.json"), JSON.stringify(dbPackageJson, null, 2));
+    if (context.database === "postgres-drizzle") {
+      await setupPostgresDrizzle(dbPackagePath, context, true);
+    } else if (context.database === "supabase") {
+      await setupSupabase(dbPackagePath, context, true);
+    } else if (context.database === "sqlite-drizzle") {
+      await setupSQLiteDrizzle(dbPackagePath, context, true);
+    }
+    const apiPackageJson2 = JSON.parse(await Bun.file(join(projectPath, "apps/api/package.json")).text());
+    apiPackageJson2.dependencies[`@${context.packageName}/db`] = "workspace:*";
+    await writeFile(join(projectPath, "apps/api/package.json"), JSON.stringify(apiPackageJson2, null, 2));
+  }
+  if (context.codeQuality === "ultracite") {
+    await setupUltracite(projectPath, context);
+  } else {
+    await setupBiome(projectPath, context);
+  }
+  if (context.docker) {
+    await setupDocker(projectPath, context);
+    const dockerCompose = `version: '3.8'
+
+services:
+  web:
+    build:
+      context: ./apps/web
+      dockerfile: ../../Dockerfile
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      ${context.database === "supabase" ? "- NEXT_PUBLIC_SUPABASE_URL=${SUPABASE_URL}\n      - NEXT_PUBLIC_SUPABASE_ANON_KEY=${SUPABASE_ANON_KEY}" : ""}
+    restart: unless-stopped
+
+  platform:
+    build:
+      context: ./apps/platform
+      dockerfile: ../../Dockerfile
+    ports:
+      - "3001:3000"
+    environment:
+      - NODE_ENV=production
+      ${context.database === "supabase" ? "- NEXT_PUBLIC_SUPABASE_URL=${SUPABASE_URL}\n      - NEXT_PUBLIC_SUPABASE_ANON_KEY=${SUPABASE_ANON_KEY}" : ""}
+    restart: unless-stopped
+
+  api:
+    build:
+      context: ./apps/api
+      dockerfile: ../../Dockerfile
+    ports:
+      - "3002:3001"
+    environment:
+      - NODE_ENV=production
+      ${context.database && context.database !== "none" && context.database !== "supabase" ? `- DATABASE_URL=\${DATABASE_URL}` : ""}
+    ${context.database && context.database !== "none" && context.database !== "supabase" ? `depends_on:
+      - db` : ""}
+    restart: unless-stopped
+
+  ${context.database && context.database !== "none" && context.database !== "supabase" ? `db:
+    image: ${context.database === "sqlite-drizzle" ? "alpine:latest" : "postgres:16-alpine"}
+    ${context.database !== "sqlite-drizzle" ? `environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=${context.projectName}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"` : `volumes:
+      - sqlite_data:/data`}
+    restart: unless-stopped
+` : ""}
+${context.database && context.database !== "none" && context.database !== "supabase" ? `volumes:
+  ${context.database === "sqlite-drizzle" ? "sqlite_data:" : "postgres_data:"}` : ""}
+`;
+    await writeFile(join(projectPath, "docker-compose.yml"), dockerCompose);
+  }
+  if (context.cicd) {
+    await setupGitHubActions(projectPath, context);
+  }
 }
-// src/commands/init.real.ts
+// src/commands/init.enhanced.ts
 function getOptionValue(envVar, option, defaultValue) {
   const envValue = process.env[envVar];
   if (envValue !== undefined) {
@@ -24595,7 +25852,7 @@ function getOptionValue(envVar, option, defaultValue) {
   }
   return option ?? defaultValue;
 }
-async function initCommand(options = {}) {
+async function enhancedInitCommand(options = {}) {
   const isNonInteractive = process.env.BUNKIT_NON_INTERACTIVE === "true" || options.nonInteractive === true;
   let projectName = getOptionValue("BUNKIT_PROJECT_NAME", options.name);
   if (!projectName) {
@@ -24624,7 +25881,7 @@ async function initCommand(options = {}) {
   let preset = getOptionValue("BUNKIT_PRESET", options.preset);
   if (!preset) {
     if (isNonInteractive) {
-      throw new Error("Preset is required in non-interactive mode. " + "Provide it via BUNKIT_PRESET env var or --preset flag. " + "Valid values: minimal, web, api, full");
+      throw new Error("Preset is required in non-interactive mode. " + "Provide it via BUNKIT_PRESET env var or --preset flag.");
     }
     preset = await ve({
       message: "\uD83C\uDFA8 Which preset would you like?",
@@ -24632,22 +25889,22 @@ async function initCommand(options = {}) {
         {
           value: "minimal",
           label: "\u26A1 Minimal",
-          hint: "Single repo, clean start"
+          hint: "Single file, clean start - perfect for learning Bun"
         },
         {
           value: "web",
-          label: "\uD83C\uDF10 Web",
-          hint: "Next.js 16 + React 19"
+          label: "\uD83C\uDF10 Web App",
+          hint: "Next.js 16 + React 19 - full-stack web application"
         },
         {
           value: "api",
-          label: "\uD83D\uDE80 API",
-          hint: "Hono + Bun.serve()"
+          label: "\uD83D\uDE80 API Server",
+          hint: "Hono + Bun.serve() - ultra-fast REST API"
         },
         {
           value: "full",
-          label: "\uD83D\uDCE6 Full-stack",
-          hint: "Monorepo with everything"
+          label: "\uD83D\uDCE6 Full-Stack Monorepo",
+          hint: "Web + Platform + API - enterprise SaaS setup"
         }
       ]
     });
@@ -24655,17 +25912,221 @@ async function initCommand(options = {}) {
       xe("Operation cancelled.");
       process.exit(0);
     }
-  } else {
-    const validPresets = ["minimal", "web", "api", "full"];
-    if (!validPresets.includes(preset)) {
-      throw new Error(`Invalid preset: ${preset}. Valid values: ${validPresets.join(", ")}`);
+  }
+  let database = getOptionValue("BUNKIT_DATABASE", options.database);
+  if (!database && (preset === "api" || preset === "full")) {
+    if (!isNonInteractive) {
+      database = await ve({
+        message: "\uD83D\uDDC4\uFE0F  Database setup?",
+        options: [
+          {
+            value: "postgres-drizzle",
+            label: "PostgreSQL + Drizzle ORM",
+            hint: "Production-ready, type-safe SQL database"
+          },
+          {
+            value: "supabase",
+            label: "Supabase",
+            hint: "PostgreSQL + Auth + Storage + Realtime - all-in-one"
+          },
+          {
+            value: "sqlite-drizzle",
+            label: "SQLite + Drizzle ORM",
+            hint: "Local-first, embedded database - perfect for prototypes"
+          },
+          {
+            value: "none",
+            label: "None",
+            hint: "I'll add it later"
+          }
+        ]
+      });
+      if (pD(database)) {
+        xe("Operation cancelled.");
+        process.exit(0);
+      }
+    } else {
+      database = "none";
+    }
+  }
+  let codeQuality = getOptionValue("BUNKIT_CODE_QUALITY", options.codeQuality, "ultracite");
+  if (!codeQuality) {
+    if (!isNonInteractive) {
+      codeQuality = await ve({
+        message: "\uD83E\uDD16 Code quality setup?",
+        options: [
+          {
+            value: "ultracite",
+            label: "Ultracite (Recommended)",
+            hint: "AI-optimized Biome preset - syncs rules for Cursor, Claude, Windsurf"
+          },
+          {
+            value: "biome",
+            label: "Biome",
+            hint: "Standard Biome with good defaults - fast and reliable"
+          }
+        ]
+      });
+      if (pD(codeQuality)) {
+        xe("Operation cancelled.");
+        process.exit(0);
+      }
+    } else {
+      codeQuality = "ultracite";
+    }
+  }
+  let tsStrictness = getOptionValue("BUNKIT_TS_STRICTNESS", options.tsStrictness, "strict");
+  if (!tsStrictness) {
+    if (!isNonInteractive) {
+      tsStrictness = await ve({
+        message: "\uD83D\uDD12 TypeScript strictness?",
+        options: [
+          {
+            value: "strict",
+            label: "Strict (Recommended)",
+            hint: "Maximum type safety - catches bugs early, prevents headaches"
+          },
+          {
+            value: "moderate",
+            label: "Moderate",
+            hint: "Balanced - good safety without being too rigid"
+          },
+          {
+            value: "loose",
+            label: "Loose",
+            hint: "Minimal checks - quick prototyping, migrate from JavaScript"
+          }
+        ]
+      });
+      if (pD(tsStrictness)) {
+        xe("Operation cancelled.");
+        process.exit(0);
+      }
+    } else {
+      tsStrictness = "strict";
+    }
+  }
+  let cssFramework = getOptionValue("BUNKIT_CSS_FRAMEWORK", options.cssFramework);
+  if (!cssFramework && (preset === "web" || preset === "full")) {
+    if (!isNonInteractive) {
+      cssFramework = await ve({
+        message: "\uD83C\uDFA8 CSS framework?",
+        options: [
+          {
+            value: "tailwind",
+            label: "Tailwind CSS 4 (Recommended)",
+            hint: "Utility-first, fast, modern - with OKLCH colors and @theme"
+          },
+          {
+            value: "vanilla",
+            label: "Vanilla CSS",
+            hint: "Plain CSS files - full control, no framework"
+          },
+          {
+            value: "css-modules",
+            label: "CSS Modules",
+            hint: "Scoped CSS - automatic class name generation"
+          }
+        ]
+      });
+      if (pD(cssFramework)) {
+        xe("Operation cancelled.");
+        process.exit(0);
+      }
+    } else {
+      cssFramework = "tailwind";
+    }
+  }
+  let uiLibrary = getOptionValue("BUNKIT_UI_LIBRARY", options.uiLibrary);
+  if (!uiLibrary && (preset === "web" || preset === "full") && cssFramework === "tailwind") {
+    if (!isNonInteractive) {
+      uiLibrary = await ve({
+        message: "\uD83E\uDDE9 UI component library?",
+        options: [
+          {
+            value: "shadcn",
+            label: "shadcn/ui (Recommended)",
+            hint: "64+ components, accessible, customizable - production-ready"
+          },
+          {
+            value: "none",
+            label: "None",
+            hint: "I'll build my own components"
+          }
+        ]
+      });
+      if (pD(uiLibrary)) {
+        xe("Operation cancelled.");
+        process.exit(0);
+      }
+    } else {
+      uiLibrary = "shadcn";
+    }
+  }
+  let testing = getOptionValue("BUNKIT_TESTING", options.testing, "bun-test");
+  if (!testing) {
+    if (!isNonInteractive) {
+      testing = await ve({
+        message: "\uD83E\uDDEA Testing framework?",
+        options: [
+          {
+            value: "bun-test",
+            label: "Bun Test (Recommended)",
+            hint: "Built-in, fast, Jest-compatible - no extra dependencies"
+          },
+          {
+            value: "vitest",
+            label: "Vitest",
+            hint: "Vite-powered, fast, ESM-first - popular in ecosystem"
+          },
+          {
+            value: "none",
+            label: "None",
+            hint: "I'll add testing later"
+          }
+        ]
+      });
+      if (pD(testing)) {
+        xe("Operation cancelled.");
+        process.exit(0);
+      }
+    } else {
+      testing = "bun-test";
+    }
+  }
+  let docker = getOptionValue("BUNKIT_DOCKER", options.docker, false);
+  if (docker === undefined) {
+    if (!isNonInteractive) {
+      docker = await ye({
+        message: "\uD83D\uDC33 Add Docker configuration?",
+        initialValue: false
+      });
+      if (pD(docker)) {
+        xe("Operation cancelled.");
+        process.exit(0);
+      }
+    } else {
+      docker = false;
+    }
+  }
+  let cicd = getOptionValue("BUNKIT_CICD", options.cicd, false);
+  if (cicd === undefined) {
+    if (!isNonInteractive) {
+      cicd = await ye({
+        message: "\u2699\uFE0F  Add GitHub Actions CI/CD?",
+        initialValue: false
+      });
+      if (pD(cicd)) {
+        xe("Operation cancelled.");
+        process.exit(0);
+      }
+    } else {
+      cicd = false;
     }
   }
   let shouldInstall = getOptionValue("BUNKIT_INSTALL", options.install, true);
   if (shouldInstall === undefined) {
-    if (isNonInteractive) {
-      shouldInstall = true;
-    } else {
+    if (!isNonInteractive) {
       shouldInstall = await ye({
         message: "\uD83D\uDCE5 Install dependencies?",
         initialValue: true
@@ -24674,13 +26135,13 @@ async function initCommand(options = {}) {
         xe("Operation cancelled.");
         process.exit(0);
       }
+    } else {
+      shouldInstall = true;
     }
   }
   let shouldInitGit = getOptionValue("BUNKIT_GIT", options.git, true);
   if (shouldInitGit === undefined) {
-    if (isNonInteractive) {
-      shouldInitGit = true;
-    } else {
+    if (!isNonInteractive) {
       shouldInitGit = await ye({
         message: "\uD83D\uDD27 Initialize git repository?",
         initialValue: true
@@ -24689,16 +26150,39 @@ async function initCommand(options = {}) {
         xe("Operation cancelled.");
         process.exit(0);
       }
+    } else {
+      shouldInitGit = true;
     }
   }
-  if (isNonInteractive) {
+  if (!isNonInteractive) {
     console.log(`
-\uD83D\uDCCB Configuration:`);
-    console.log(`  Project: ${import_picocolors4.default.cyan(projectName)}`);
-    console.log(`  Preset: ${import_picocolors4.default.cyan(preset)}`);
-    console.log(`  Install dependencies: ${import_picocolors4.default.cyan(shouldInstall ? "yes" : "no")}`);
-    console.log(`  Initialize git: ${import_picocolors4.default.cyan(shouldInitGit ? "yes" : "no")}`);
-    console.log("");
+` + boxen([
+      `${source_default.bold("Project:")} ${source_default.cyan(projectName)}`,
+      `${source_default.bold("Preset:")} ${source_default.cyan(preset)}`,
+      database ? `${source_default.bold("Database:")} ${source_default.cyan(database)}` : "",
+      `${source_default.bold("Code Quality:")} ${source_default.cyan(codeQuality)}`,
+      `${source_default.bold("TypeScript:")} ${source_default.cyan(tsStrictness)}`,
+      cssFramework ? `${source_default.bold("CSS:")} ${source_default.cyan(cssFramework)}` : "",
+      uiLibrary ? `${source_default.bold("UI Library:")} ${source_default.cyan(uiLibrary)}` : "",
+      `${source_default.bold("Testing:")} ${source_default.cyan(testing)}`,
+      docker ? `${source_default.bold("Docker:")} ${source_default.green("\u2713")}` : "",
+      cicd ? `${source_default.bold("CI/CD:")} ${source_default.green("\u2713")}` : ""
+    ].filter(Boolean).join(`
+`), {
+      padding: 1,
+      title: "\uD83D\uDCCB Configuration",
+      titleAlignment: "left",
+      borderColor: "cyan",
+      borderStyle: "round"
+    }));
+    const confirm = await ye({
+      message: "Proceed with this configuration?",
+      initialValue: true
+    });
+    if (pD(confirm) || !confirm) {
+      xe("Operation cancelled.");
+      process.exit(0);
+    }
   }
   const s = Y2();
   s.start("\uD83D\uDD28 Creating project structure...");
@@ -24708,7 +26192,17 @@ async function initCommand(options = {}) {
       preset,
       path: projectName,
       git: shouldInitGit,
-      install: shouldInstall
+      install: shouldInstall,
+      database,
+      codeQuality,
+      tsStrictness,
+      uiLibrary,
+      cssFramework,
+      testing,
+      docker,
+      cicd,
+      envExample: true,
+      pathAliases: true
     };
     await createProject(config);
     const projectPath = join(process.cwd(), config.path);
@@ -24728,34 +26222,40 @@ async function initCommand(options = {}) {
         await buildFullPreset(projectPath, context);
         break;
     }
+    if (database && database !== "none") {
+      s.message(`\uD83D\uDDC4\uFE0F  Setting up ${database}...`);
+    }
+    if (codeQuality === "ultracite") {
+      s.message("\uD83E\uDD16 Configuring Ultracite for AI editors...");
+    }
+    if (docker) {
+      s.message("\uD83D\uDC33 Adding Docker configuration...");
+    }
+    if (cicd) {
+      s.message("\u2699\uFE0F  Adding GitHub Actions...");
+    }
     s.stop("\u2705 Project created!");
     if (shouldInstall) {
-      const deps = getDependenciesForPreset(preset);
-      if (deps.length > 0) {
-        await installDependencies(projectPath, deps);
-      } else {
-        await installDependencies(projectPath);
+      const additionalDeps = [];
+      if (database && database !== "none") {
+        additionalDeps.push(...getDatabaseDependencies(database));
+      }
+      if (codeQuality) {
+        additionalDeps.push(...getCodeQualityDependencies(codeQuality));
       }
+      if (testing === "vitest") {
+        additionalDeps.push("vitest", "@vitest/ui");
+      }
+      if (uiLibrary === "shadcn") {
+        additionalDeps.push("class-variance-authority", "clsx", "tailwind-merge");
+      }
+      await installDependencies(projectPath, additionalDeps);
     }
     const getDevCommand = () => {
       if (preset === "full" || preset === "web")
         return "bun dev";
       return "bun run dev";
     };
-    const getPresetEmoji = () => {
-      switch (preset) {
-        case "minimal":
-          return "\u26A1";
-        case "web":
-          return "\uD83C\uDF10";
-        case "api":
-          return "\uD83D\uDE80";
-        case "full":
-          return "\uD83D\uDCE6";
-        default:
-          return "\uD83C\uDF5E";
-      }
-    };
     const nextSteps = [
       `${source_default.cyan("cd")} ${projectName}`,
       shouldInstall ? "" : `${source_default.cyan("bun install")}`,
@@ -24765,9 +26265,9 @@ async function initCommand(options = {}) {
     console.log(`
 ` + boxen(nextSteps, {
       padding: 1,
-      title: `${getPresetEmoji()} Next steps`,
+      title: "\uD83D\uDE80 Next steps",
       titleAlignment: "left",
-      borderColor: "cyan",
+      borderColor: "green",
       borderStyle: "round"
     }));
   } catch (error) {
@@ -24776,18 +26276,6 @@ async function initCommand(options = {}) {
     process.exit(1);
   }
 }
-function getDependenciesForPreset(preset) {
-  switch (preset) {
-    case "web":
-      return ["react@19.1.0", "react-dom@19.1.0", "next@16.0.0", "tailwindcss@4.1.7"];
-    case "api":
-      return ["hono@4.7.12"];
-    case "full":
-      return [];
-    default:
-      return [];
-  }
-}
 
 // src/commands/create.ts
 async function createCommand2(preset, name, options) {
@@ -24824,10 +26312,10 @@ var packageJson = await Bun.file(new URL("../package.json", import.meta.url)).js
 var VERSION = packageJson.version;
 var program2 = new Command;
 program2.name("bunkit").description("Bake production-ready apps in seconds").version(VERSION);
-program2.command("init").description("Create a new project interactively").option("--name <name>", "Project name").option("--preset <preset>", "Preset type (minimal, web, api, full)").option("--no-git", "Skip git initialization").option("--no-install", "Skip dependency installation").option("--non-interactive", "Run without prompts (requires all options)").action(async (options) => {
+program2.command("init").description("Create a new project with full customization").option("--name <name>", "Project name").option("--preset <preset>", "Preset type (minimal, web, api, full)").option("--database <database>", "Database (postgres-drizzle, supabase, sqlite-drizzle, none)").option("--code-quality <quality>", "Code quality (ultracite, biome)").option("--ts-strictness <strictness>", "TypeScript strictness (strict, moderate, loose)").option("--ui-library <library>", "UI library (shadcn, none)").option("--css-framework <framework>", "CSS framework (tailwind, vanilla, css-modules)").option("--testing <framework>", "Testing framework (bun-test, vitest, none)").option("--docker", "Add Docker configuration").option("--cicd", "Add GitHub Actions CI/CD").option("--no-git", "Skip git initialization").option("--no-install", "Skip dependency installation").option("--non-interactive", "Run without prompts (requires all options)").action(async (options) => {
   showBanner(VERSION);
   try {
-    await initCommand(options);
+    await enhancedInitCommand(options);
     Se(import_picocolors5.default.green("\u2728 Done! Your project is ready to bake! \uD83C\uDF5E"));
   } catch (error) {
     M2.error(error.message);