kavoru 0.1.0 → 0.3.0

package/README.md

@@ -16,24 +16,54 @@ Equivalent to `bunx --bun kavoru` (Bun runs the `kavoru` binary from the npm pac
 
 ### Options
 
-| Flag | Description |
-| --- | --- |
-| `-h, --help` | Show help |
-| `-V, --version` | Show CLI version |
-| `-f, --force` | Scaffold into a non-empty directory |
-| `--no-install` | Skip `bun install` |
+| Flag                | Description                                              |
+| ------------------- | -------------------------------------------------------- |
+| `-h, --help`        | Show help                                                |
+| `-V, --version`     | Show CLI version                                         |
+| `-f, --force`       | Scaffold into a non-empty directory                      |
+| `--no-install`      | Skip `bun install`                                       |
 | `--repo owner/name` | Override template repo (default: `mertthesamael/Kavoru`) |
-| `--branch name` | Template branch (default: `master`) |
+| `--branch name`     | Template branch (default: `master`)                      |
+| `--minimal`         | Core only — health, OpenAPI, response envelope           |
+| `--features list`   | Comma-separated features to include                      |
+| `--no-features list`| Comma-separated features to exclude (default: all on)    |
+
+### Optional features
+
+During setup you can pick which integrations to scaffold. Core is always included: health routes, OpenAPI at `/help`, CORS, and the JSON response envelope.
+
+| ID          | Feature                |
+| ----------- | ---------------------- |
+| `auth`      | JWT authentication     |
+| `prisma`    | Prisma + PostgreSQL    |
+| `otel`      | OpenTelemetry          |
+| `sentry`    | Sentry + Spotlight     |
+| `kafka`     | Kafka producer/consumer|
+| `websocket` | WebSocket realtime     |
+| `resend`    | Resend email           |
+| `cron`      | Cron jobs              |
+| `docker`    | Dockerfile + Compose     |
+
+Interactive mode (TTY) shows a checkbox menu (↑↓ move, Space toggle, Enter confirm). Non-interactive runs use the full stack unless you pass flags.
 
 ### Examples
 
 ```bash
-# Interactive (prompts for project name)
+# Interactive (prompts for project name + feature toggles)
 bunx kavoru
 
 # Current directory
 bunx kavoru .
 
+# Minimal API skeleton
+bunx kavoru my-api --minimal
+
+# Pick specific features
+bunx kavoru my-api --features auth,prisma,otel,sentry
+
+# Full stack minus Kafka and Docker
+bunx kavoru my-api --no-features kafka,docker
+
 # Custom template fork (local dev)
 bunx kavoru demo --repo your-user/Kavoru --no-install
 ```
@@ -52,31 +82,6 @@ bun link
 bunx kavoru my-test-app
 ```
 
-## Publish to npm
-
-1. Ensure the [Kavoru](https://github.com/mertthesamael/Kavoru) template repo is public on `master`.
-2. Create a **Granular Access Token** at [npm → Access Tokens](https://www.npmjs.com/settings/~/tokens) with:
-   - **Bypass two-factor authentication** — checked (required for first publish without 2FA)
-   - **Packages** — All packages, **Read and write**
-3. Configure auth (do not commit the token):
-
-   ```bash
-   echo "//registry.npmjs.org/:_authToken=YOUR_TOKEN" > ~/.npmrc
-   unset NPM_CONFIG_TOKEN
-   npm whoami
-   ```
-
-4. Publish: `npm publish` (or `bun publish`)
-
-The `bin/kavoru.js` shim uses `#!/usr/bin/env bun` so `bunx kavoru` runs with Bun.
-
-## What the CLI does
-
-1. Shallow-clones the GitHub template (or downloads a zip if `git` is missing)
-2. Removes `.git` so the new project starts fresh
-3. Sets `package.json` `name`, copies `.env` from `.env.example`, and adjusts default service IDs
-4. Runs `bun install` (unless `--no-install`)
-
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kavoru",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Scaffold a new Kavoru (Elysia + Bun) backend from the official template",
   "type": "module",
   "bin": {

package/src/args.ts

@@ -8,6 +8,9 @@ export type CliOptions = {
   force: boolean;
   repo: string;
   branch: string;
+  minimal: boolean;
+  features: string | undefined;
+  noFeatures: string[];
 };
 
 const HELP = `\
@@ -25,10 +28,18 @@ Options:
   --no-install       Skip "bun install" after scaffolding
   --repo <owner/name>  GitHub template repo (default: mertthesamael/Kavoru)
   --branch <name>    Template branch (default: master)
+  --minimal          Core only (health, OpenAPI, response envelope)
+  --features <list>  Comma-separated features to include (default: all)
+  --no-features <list>  Comma-separated features to exclude
+
+Features:
+  auth, prisma, otel, sentry, kafka, websocket, resend, cron, docker
 
 Examples:
   bunx kavoru my-api
-  bunx kavoru .
+  bunx kavoru my-api --minimal
+  bunx kavoru my-api --features auth,prisma,otel
+  bunx kavoru my-api --no-features kafka,docker,resend
 `;
 
 export function parseArgs(argv: string[]): CliOptions {
@@ -40,6 +51,9 @@ export function parseArgs(argv: string[]): CliOptions {
     force: false,
     repo: "mertthesamael/Kavoru",
     branch: "master",
+    minimal: false,
+    features: undefined,
+    noFeatures: [],
   };
 
   const positional: string[] = [];
@@ -64,6 +78,25 @@ export function parseArgs(argv: string[]): CliOptions {
       case "--no-install":
         options.install = false;
         break;
+      case "--minimal":
+        options.minimal = true;
+        break;
+      case "--features": {
+        const value = argv[++i];
+        if (!value) throw new Error("--features requires a comma-separated list.");
+        options.features = value;
+        break;
+      }
+      case "--no-features": {
+        const value = argv[++i];
+        if (!value) {
+          throw new Error("--no-features requires a comma-separated list.");
+        }
+        options.noFeatures.push(
+          ...value.split(",").map((part) => part.trim()).filter(Boolean),
+        );
+        break;
+      }
       case "--repo": {
         const value = argv[++i];
         if (!value) throw new Error("--repo requires a value (owner/name).");
@@ -88,6 +121,10 @@ export function parseArgs(argv: string[]): CliOptions {
     options.targetDir = positional[0];
   }
 
+  if (options.minimal && options.features) {
+    throw new Error("Use either --minimal or --features, not both.");
+  }
+
   return options;
 }
 

package/src/cli.ts

@@ -5,7 +5,17 @@ import path from "node:path";
 import * as readline from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import type { CliOptions } from "./args";
+import {
+  ALL_FEATURES,
+  MINIMAL_FEATURES,
+  applyFeatures,
+  formatFeatureSelection,
+  parseFeatureExcludeList,
+  parseFeatureIncludeList,
+  type FeatureSelection,
+} from "./features";
 import { log } from "./log";
+import { promptFeatureSelection } from "./prompts";
 import {
   customizeProject,
   fetchTemplate,
@@ -49,6 +59,38 @@ async function copyTemplateIntoTarget(
   }
 }
 
+export function resolveFeatureSelection(options: CliOptions): FeatureSelection {
+  if (options.minimal) {
+    return { ...MINIMAL_FEATURES };
+  }
+
+  if (options.features) {
+    return parseFeatureIncludeList(options.features);
+  }
+
+  if (options.noFeatures.length > 0) {
+    return parseFeatureExcludeList(options.noFeatures, ALL_FEATURES);
+  }
+
+  return { ...ALL_FEATURES };
+}
+
+async function resolveFeatureSelectionInteractive(
+  options: CliOptions,
+): Promise<FeatureSelection> {
+  const fromFlags = resolveFeatureSelection(options);
+  const hasExplicitFlags =
+    options.minimal ||
+    options.features !== undefined ||
+    options.noFeatures.length > 0;
+
+  if (hasExplicitFlags || !process.stdin.isTTY || !process.stdout.isTTY) {
+    return fromFlags;
+  }
+
+  return promptFeatureSelection(fromFlags);
+}
+
 export async function runCli(options: CliOptions): Promise<void> {
   let targetArg = options.targetDir;
 
@@ -77,15 +119,18 @@ export async function runCli(options: CliOptions): Promise<void> {
     );
   }
 
+  const featureSelection = await resolveFeatureSelectionInteractive(options);
   const source = resolveTemplateSource(options.repo, options.branch);
   const tempDir = path.join(os.tmpdir(), `kavoru-${Date.now()}`);
 
   log.info(`Creating Kavoru project "${packageName}"`);
+  log.info(`Features: ${formatFeatureSelection(featureSelection)}`);
 
   try {
     await fetchTemplate(source, tempDir);
     await removeGitMetadata(tempDir);
     await customizeProject(tempDir, packageName);
+    await applyFeatures(tempDir, featureSelection, packageName);
     await copyTemplateIntoTarget(tempDir, targetDir);
 
     if (options.install) {

package/src/features.ts

@@ -0,0 +1,630 @@
+import { rm } from "node:fs/promises";
+import path from "node:path";
+import { log } from "./log";
+
+export type FeatureId =
+  | "auth"
+  | "prisma"
+  | "otel"
+  | "sentry"
+  | "kafka"
+  | "websocket"
+  | "resend"
+  | "cron"
+  | "docker";
+
+export type FeatureSelection = Record<FeatureId, boolean>;
+
+export type FeatureDef = {
+  id: FeatureId;
+  label: string;
+  description: string;
+};
+
+export const FEATURES: FeatureDef[] = [
+  {
+    id: "auth",
+    label: "JWT Authentication",
+    description: "Bearer auth, sign-in route, protected routes",
+  },
+  {
+    id: "prisma",
+    label: "Prisma + PostgreSQL",
+    description: "Prisma 7 config, migrations, seed scripts",
+  },
+  {
+    id: "otel",
+    label: "OpenTelemetry",
+    description: "OTLP tracing with Bun-compatible exporter",
+  },
+  {
+    id: "sentry",
+    label: "Sentry + Spotlight",
+    description: "Error monitoring and local Spotlight UI",
+  },
+  {
+    id: "kafka",
+    label: "Kafka",
+    description: "Producer, consumer, and example HTTP endpoints",
+  },
+  {
+    id: "websocket",
+    label: "WebSockets",
+    description: "Validated real-time connections with rooms",
+  },
+  {
+    id: "resend",
+    label: "Resend Email",
+    description: "Transactional email via sendEmail()",
+  },
+  {
+    id: "cron",
+    label: "Cron Jobs",
+    description: "Scheduled tasks via @elysiajs/cron",
+  },
+  {
+    id: "docker",
+    label: "Docker",
+    description: "Dockerfile and Docker Compose stack",
+  },
+];
+
+export const FEATURE_IDS = FEATURES.map((feature) => feature.id);
+
+export const ALL_FEATURES: FeatureSelection = Object.fromEntries(
+  FEATURE_IDS.map((id) => [id, true]),
+) as FeatureSelection;
+
+export const MINIMAL_FEATURES: FeatureSelection = Object.fromEntries(
+  FEATURE_IDS.map((id) => [id, false]),
+) as FeatureSelection;
+
+const FEATURE_PATHS: Record<FeatureId, string[]> = {
+  auth: [
+    "src/modules/signin",
+    "src/modules/protected",
+    "src/middleware/auth.ts",
+    "src/infra/auth",
+    "src/constants/jwt.ts",
+    "src/models/schemas/signin.ts",
+  ],
+  prisma: ["prisma.config.ts", "src/infra/prisma"],
+  otel: ["src/infra/telemetry"],
+  sentry: [
+    "src/infra/sentry",
+    "src/constants/sentry.ts",
+    "__tests__/sentry.test.ts",
+  ],
+  kafka: [
+    "src/modules/kafka",
+    "src/infra/kafka",
+    "src/models/schemas/kafka.ts",
+    "__tests__/kafka.test.ts",
+  ],
+  websocket: [
+    "src/modules/realtime",
+    "src/models/schemas/realtime.ts",
+    "__tests__/realtime.test.ts",
+  ],
+  resend: ["src/infra/resend"],
+  cron: ["src/schedules"],
+  docker: ["Dockerfile", "docker-compose.yaml"],
+};
+
+const FEATURE_DEPENDENCIES: Partial<
+  Record<FeatureId, { dependencies?: string[]; devDependencies?: string[] }>
+> = {
+  auth: { dependencies: ["@elysiajs/bearer", "@elysiajs/jwt"] },
+  prisma: {
+    dependencies: ["@prisma/adapter-pg", "@prisma/client"],
+    devDependencies: ["prisma"],
+  },
+  otel: {
+    dependencies: [
+      "@elysiajs/opentelemetry",
+      "@opentelemetry/exporter-trace-otlp-http",
+      "@opentelemetry/otlp-transformer",
+      "@opentelemetry/sdk-trace-node",
+    ],
+  },
+  sentry: { dependencies: ["@sentry/elysia"] },
+  kafka: { dependencies: ["kafkajs"] },
+  resend: { dependencies: ["resend"] },
+  cron: { dependencies: ["@elysiajs/cron"] },
+};
+
+const FEATURE_SCRIPTS: Partial<Record<FeatureId, string[]>> = {
+  otel: ["otel:view", "otel:tui"],
+  sentry: ["sentry:spotlight"],
+  prisma: ["seed"],
+};
+
+function enabledFeatures(selection: FeatureSelection): FeatureId[] {
+  return FEATURE_IDS.filter((id) => selection[id]);
+}
+
+function disabledFeatures(selection: FeatureSelection): FeatureId[] {
+  return FEATURE_IDS.filter((id) => !selection[id]);
+}
+
+export function parseFeatureIncludeList(input: string): FeatureSelection {
+  const normalized = input.trim().toLowerCase();
+  if (!normalized || normalized === "all") return { ...ALL_FEATURES };
+  if (normalized === "minimal" || normalized === "none") {
+    return { ...MINIMAL_FEATURES };
+  }
+
+  const requested = normalized
+    .split(",")
+    .map((part) => part.trim())
+    .filter(Boolean);
+
+  const unknown = requested.filter(
+    (id) => !FEATURE_IDS.includes(id as FeatureId),
+  );
+  if (unknown.length > 0) {
+    throw new Error(
+      `Unknown feature(s): ${unknown.join(", ")}. Valid: ${FEATURE_IDS.join(", ")}`,
+    );
+  }
+
+  const selection = { ...MINIMAL_FEATURES };
+  for (const id of requested) {
+    selection[id as FeatureId] = true;
+  }
+  return selection;
+}
+
+export function parseFeatureExcludeList(
+  excluded: string[],
+  base: FeatureSelection = ALL_FEATURES,
+): FeatureSelection {
+  const selection = { ...base };
+  const unknown: string[] = [];
+
+  for (const raw of excluded) {
+    const id = raw.trim().toLowerCase();
+    if (!id) continue;
+    if (!FEATURE_IDS.includes(id as FeatureId)) {
+      unknown.push(id);
+      continue;
+    }
+    selection[id as FeatureId] = false;
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(
+      `Unknown feature(s): ${unknown.join(", ")}. Valid: ${FEATURE_IDS.join(", ")}`,
+    );
+  }
+
+  return selection;
+}
+
+export function formatFeatureSelection(selection: FeatureSelection): string {
+  const enabled = enabledFeatures(selection);
+  if (enabled.length === 0) return "core only";
+  return enabled.join(", ");
+}
+
+async function removePaths(projectDir: string, relativePaths: string[]) {
+  for (const relativePath of relativePaths) {
+    await rm(path.join(projectDir, relativePath), {
+      recursive: true,
+      force: true,
+    });
+  }
+}
+
+async function readText(projectDir: string, relativePath: string) {
+  const file = Bun.file(path.join(projectDir, relativePath));
+  if (!(await file.exists())) return null;
+  return file.text();
+}
+
+async function writeText(
+  projectDir: string,
+  relativePath: string,
+  content: string,
+) {
+  await Bun.write(path.join(projectDir, relativePath), content);
+}
+
+function removeImportLines(content: string, modules: string[]) {
+  let next = content;
+  for (const modulePath of modules) {
+    const escaped = modulePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    next = next.replace(
+      new RegExp(`^import .* from ["']${escaped}["'];?\\r?\\n`, "gm"),
+      "",
+    );
+  }
+  return next;
+}
+
+function removeUseLines(content: string, identifiers: string[]) {
+  let next = content;
+  for (const identifier of identifiers) {
+    next = next.replace(
+      new RegExp(`^\\s*\\.use\\(${identifier}\\)\\r?\\n`, "gm"),
+      "",
+    );
+  }
+  return next;
+}
+
+async function patchModulesIndex(
+  projectDir: string,
+  selection: FeatureSelection,
+) {
+  const relativePath = "src/modules/index.ts";
+  const current = await readText(projectDir, relativePath);
+  if (!current) return;
+
+  let content = current;
+  if (!selection.sentry) {
+    content = removeImportLines(content, ["../infra/sentry"]);
+    content = removeUseLines(content, ["withSentry"]);
+  }
+  if (!selection.otel) {
+    content = removeImportLines(content, ["../infra/telemetry"]);
+    content = removeUseLines(content, ["withOpenTelemetry"]);
+  }
+
+  content = content.replace(/app\s+\.use\(/g, "app\n    .use(");
+
+  await writeText(projectDir, relativePath, content);
+}
+
+async function patchEntryIndex(projectDir: string, selection: FeatureSelection) {
+  const imports = [
+    selection.sentry
+      ? 'import { initSentry, flushSentry } from "./infra/sentry";'
+      : null,
+    selection.kafka
+      ? 'import { startKafka, stopKafka } from "./infra/kafka";'
+      : null,
+    'import { HttpServer } from "./server/index";',
+    'import { logger } from "./common/logger";',
+    selection.kafka ? 'import { InternalServerError } from "elysia";' : null,
+  ].filter(Boolean) as string[];
+
+  const body: string[] = [];
+
+  if (selection.sentry) {
+    body.push("", "initSentry();");
+  }
+
+  body.push("", "const server = new HttpServer();", "");
+
+  if (selection.kafka) {
+    body.push(
+      "void server.start().then(async () => {",
+      "  try {",
+      "    await startKafka();",
+      "  } catch (error) {",
+      '    logger.error("Failed to start Kafka", { error });',
+      '    throw new InternalServerError("Failed to start Kafka");',
+      "  }",
+      "});",
+    );
+  } else {
+    body.push("void server.start();");
+  }
+
+  body.push(
+    "",
+    "const shutdown = (signal: string) => {",
+    "  return async () => {",
+    "    logger.warn(`Received ${signal}, shutting down`);",
+    "    await server.stop();",
+  );
+
+  if (selection.kafka) {
+    body.push("    await stopKafka();");
+  }
+  if (selection.sentry) {
+    body.push("    await flushSentry();");
+  }
+
+  body.push(
+    "    process.exit(0);",
+    "  };",
+    "};",
+    "",
+    'process.on("SIGINT", () => void shutdown("SIGINT")());',
+    'process.on("SIGTERM", () => void shutdown("SIGTERM")());',
+    "",
+  );
+
+  await writeText(projectDir, "src/index.ts", [...imports, ...body].join("\n"));
+}
+
+async function patchServerIndex(projectDir: string, selection: FeatureSelection) {
+  const relativePath = "src/server/index.ts";
+  const current = await readText(projectDir, relativePath);
+  if (!current) return;
+
+  let content = current;
+
+  if (selection.cron) {
+    content = content.replace(
+      /\/\/import \{ schedules \} from "\.\.\/schedules";.*\n/,
+      'import { schedules } from "../schedules";\n',
+    );
+    content = content.replace(
+      /\/\/\.use\(schedules\);.*\n/,
+      "    .use(schedules);\n",
+    );
+  } else {
+    content = content.replace(
+      /^import \{ schedules \} from "\.\.\/schedules";\n/m,
+      "",
+    );
+    content = content.replace(/^\s*\.use\(schedules\);\n/m, "");
+  }
+
+  if (!selection.websocket) {
+    content = content.replace(
+      /new Elysia\(\{\s*websocket:\s*\{\s*idleTimeout:\s*120,\s*\},\s*\}\)/,
+      "new Elysia()",
+    );
+  }
+
+  await writeText(projectDir, relativePath, content);
+}
+
+async function patchPackageJson(
+  projectDir: string,
+  selection: FeatureSelection,
+) {
+  const pkgPath = path.join(projectDir, "package.json");
+  const pkgFile = Bun.file(pkgPath);
+  if (!(await pkgFile.exists())) return;
+
+  const pkg = (await pkgFile.json()) as {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+  };
+
+  for (const featureId of disabledFeatures(selection)) {
+    const deps = FEATURE_DEPENDENCIES[featureId];
+    if (deps?.dependencies) {
+      for (const name of deps.dependencies) {
+        delete pkg.dependencies?.[name];
+      }
+    }
+    if (deps?.devDependencies) {
+      for (const name of deps.devDependencies) {
+        delete pkg.devDependencies?.[name];
+      }
+    }
+
+    const scripts = FEATURE_SCRIPTS[featureId];
+    if (scripts) {
+      for (const scriptName of scripts) {
+        delete pkg.scripts?.[scriptName];
+      }
+    }
+  }
+
+  if (!selection.prisma && pkg.scripts) {
+    pkg.scripts.start = "bun run src/index.ts";
+  }
+
+  await Bun.write(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+}
+
+export function buildEnvExample(
+  packageName: string,
+  selection: FeatureSelection,
+): string {
+  const lines = ["NODE_ENV=development", "PORT=3131", ""];
+
+  if (selection.prisma) {
+    lines.push(
+      "DATABASE_URL=postgresql://user:password@localhost:5432/your_database",
+      "",
+    );
+  }
+
+  if (selection.otel) {
+    lines.push(
+      "# OpenTelemetry (optional in production; enabled by default in development)",
+      "# Terminal 1: bun run otel:view",
+      "# Terminal 2: bun run dev",
+      "# Disable locally: OTEL_EXPORTER_OTLP_ENDPOINT=",
+      "OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318/v1/traces",
+      `OTEL_SERVICE_NAME=${packageName}`,
+      "",
+    );
+  }
+
+  if (selection.sentry) {
+    lines.push(
+      "# Sentry Spotlight (local UI — enabled by default in development)",
+      "# Terminal 1: bun run sentry:spotlight",
+      "# Terminal 2: bun run dev",
+      "# Disable locally: SENTRY_SPOTLIGHT=false",
+      "SENTRY_SPOTLIGHT=true",
+      "",
+      "# Sentry cloud (optional — events also go to sentry.io when set)",
+      "# SENTRY_DSN=https://examplePublicKey@o0.ingest.sentry.io/0",
+      "# SENTRY_TRACES_SAMPLE_RATE=1.0",
+      "",
+    );
+  }
+
+  if (selection.kafka) {
+    lines.push(
+      "# Kafka (enabled by default in development; disabled in test)",
+      "# Start broker: docker compose up -d kafka",
+      "# Host dev uses EXTERNAL listener on port 9094",
+      "# KAFKA_ENABLED=false",
+      "KAFKA_BROKERS=localhost:9094",
+      `KAFKA_CLIENT_ID=${packageName}`,
+      `KAFKA_GROUP_ID=${packageName}-consumer`,
+      "KAFKA_TOPIC=elysia.events",
+      "",
+    );
+  }
+
+  if (selection.resend) {
+    lines.push(
+      "# Resend (disabled when RESEND_API_KEY is unset; always disabled in test)",
+      "# Create an API key: https://resend.com/api-keys",
+      "# RESEND_ENABLED=false",
+      "# RESEND_API_KEY=re_xxxxxxxx",
+      "# RESEND_FROM=Acme <onboarding@resend.dev>",
+      "",
+    );
+  }
+
+  return `${lines.join("\n").trimEnd()}\n`;
+}
+
+async function patchEnvExample(
+  projectDir: string,
+  selection: FeatureSelection,
+  packageName = "kavoru",
+) {
+  const content = buildEnvExample(packageName, selection);
+  await writeText(projectDir, ".env.example", content);
+  await writeText(projectDir, ".env", content);
+}
+
+async function patchDockerfile(projectDir: string, selection: FeatureSelection) {
+  if (!selection.docker) return;
+
+  const relativePath = "Dockerfile";
+  const current = await readText(projectDir, relativePath);
+  if (!current) return;
+
+  let content = current;
+  if (!selection.prisma) {
+    content = content.replace(/^\s*COPY prisma\.config\.ts \.\/.*\n/m, "");
+    content = content.replace(/^\s*ENV DATABASE_URL=\$\{DATABASE_URL\}\n/m, "");
+    content = content.replace(/^\s*RUN bunx prisma db pull\n/m, "");
+    content = content.replace(/^\s*RUN bunx prisma generate\n/m, "");
+  }
+
+  await writeText(projectDir, relativePath, content);
+}
+
+function generateDockerCompose(selection: FeatureSelection): string {
+  const appDependsOn = selection.kafka
+    ? `    depends_on:
+      kafka:
+        condition: service_started
+    environment:
+      KAFKA_BROKERS: kafka:9092
+`
+    : "";
+
+  const kafkaService = selection.kafka
+    ? `
+  kafka:
+    image: bitnami/kafka:3.9
+    ports:
+      - "9094:9094"
+    environment:
+      KAFKA_CFG_NODE_ID: "0"
+      KAFKA_CFG_PROCESS_ROLES: controller,broker
+      KAFKA_CFG_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093,EXTERNAL://:9094
+      KAFKA_CFG_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,EXTERNAL://localhost:9094
+      KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,EXTERNAL:PLAINTEXT
+      KAFKA_CFG_CONTROLLER_QUORUM_VOTERS: 0@kafka:9093
+      KAFKA_CFG_CONTROLLER_LISTENER_NAMES: CONTROLLER
+      KAFKA_CFG_INTER_BROKER_LISTENER_NAME: PLAINTEXT
+      ALLOW_PLAINTEXT_LISTENER: "yes"
+    networks:
+      - app_network
+    restart: unless-stopped
+`
+    : "";
+
+  const jaegerService = selection.otel
+    ? `
+  jaeger:
+    image: jaegertracing/all-in-one:1.62
+    ports:
+      - "16686:16686"
+      - "4318:4318"
+    environment:
+      COLLECTOR_OTLP_ENABLED: "true"
+    networks:
+      - app_network
+    restart: unless-stopped
+`
+    : "";
+
+  return `services:
+  app:
+    build:
+      context: .
+      target: build
+      args:
+        PORT: \${PORT:-3131}
+    command: /app/server
+    volumes:
+      - ./src:/app/src
+    networks:
+      app_network:
+        aliases:
+          - app
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    expose:
+      - "\${PORT}"
+    restart: unless-stopped
+    env_file:
+      - .env
+${appDependsOn}    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:\${PORT}/healthz"]
+      interval: 600s
+      timeout: 300s
+      retries: 1
+      start_period: 40s
+${kafkaService}${jaegerService}
+networks:
+  app_network:
+    name: app_network
+    driver: bridge
+
+version: "3.8"
+`;
+}
+
+async function patchDockerCompose(
+  projectDir: string,
+  selection: FeatureSelection,
+) {
+  if (!selection.docker) return;
+  await writeText(projectDir, "docker-compose.yaml", generateDockerCompose(selection));
+}
+
+export async function applyFeatures(
+  projectDir: string,
+  selection: FeatureSelection,
+  packageName = "kavoru",
+): Promise<void> {
+  const disabled = disabledFeatures(selection);
+  log.step(`Applying feature selection (${formatFeatureSelection(selection)})`);
+
+  for (const featureId of disabled) {
+    await removePaths(projectDir, FEATURE_PATHS[featureId]);
+  }
+
+  await patchModulesIndex(projectDir, selection);
+  await patchEntryIndex(projectDir, selection);
+  await patchServerIndex(projectDir, selection);
+  await patchPackageJson(projectDir, selection);
+  await patchEnvExample(projectDir, selection, packageName);
+  await patchDockerfile(projectDir, selection);
+  await patchDockerCompose(projectDir, selection);
+
+  if (disabled.length > 0) {
+    log.success("Feature selection applied");
+  }
+}

package/src/prompts.ts

@@ -0,0 +1,185 @@
+import { stdin, stdout } from "node:process";
+import {
+  ALL_FEATURES,
+  FEATURES,
+  MINIMAL_FEATURES,
+  type FeatureId,
+  type FeatureSelection,
+  formatFeatureSelection,
+} from "./features";
+
+const ESC = "\x1b";
+const dim = `${ESC}[2m`;
+const reset = `${ESC}[0m`;
+const cyan = `${ESC}[36m`;
+
+function cloneSelection(selection: FeatureSelection): FeatureSelection {
+  return { ...selection };
+}
+
+type KeyAction =
+  | "up"
+  | "down"
+  | "toggle"
+  | "confirm"
+  | "all"
+  | "minimal"
+  | "interrupt";
+
+const KEY_UP = ESC + "[A";
+const KEY_DOWN = ESC + "[B";
+const KEY_UP_ALT = ESC + "OA";
+const KEY_DOWN_ALT = ESC + "OB";
+
+function parseKeyInput(data: string): KeyAction | null {
+  if (data === "\u0003") return "interrupt";
+  if (data === "\r" || data === "\n") return "confirm";
+  if (data === " ") return "toggle";
+  if (data === "a" || data === "A") return "all";
+  if (data === "m" || data === "M") return "minimal";
+  if (data === KEY_UP || data === KEY_UP_ALT) return "up";
+  if (data === KEY_DOWN || data === KEY_DOWN_ALT) return "down";
+  return null;
+}
+
+function createKeyReader(onKey: (action: KeyAction) => void) {
+  let pending = "";
+
+  const onData = (chunk: string) => {
+    pending += chunk;
+
+    while (pending.length > 0) {
+      if (pending === ESC) return;
+
+      if (pending.startsWith(ESC)) {
+        if (pending.length < 3) return;
+
+        const action = parseKeyInput(pending.slice(0, 3));
+        if (action) {
+          pending = pending.slice(3);
+          onKey(action);
+          continue;
+        }
+
+        if (pending.startsWith(ESC + "O") && pending.length < 3) return;
+
+        pending = pending.slice(1);
+        continue;
+      }
+
+      const action = parseKeyInput(pending[0] ?? "");
+      pending = pending.slice(1);
+      if (action) onKey(action);
+    }
+  };
+
+  return onData;
+}
+
+function renderCheckboxMenu(
+  selection: FeatureSelection,
+  activeIndex: number,
+  lineCount: number,
+): number {
+  const lines: string[] = [
+    `${cyan}◆${reset} Select optional features ${dim}(↑↓ move · Space toggle · Enter confirm)${reset}`,
+    `${dim}  a = all · m = minimal${reset}`,
+    "",
+  ];
+
+  FEATURES.forEach((feature, index) => {
+    const isActive = index === activeIndex;
+    const pointer = isActive ? `${cyan}❯${reset}` : " ";
+    const mark = selection[feature.id] ? "x" : " ";
+    const label = isActive ? `${cyan}${feature.label}${reset}` : feature.label;
+    lines.push(
+      ` ${pointer} [${mark}] ${label.padEnd(22)} ${dim}${feature.description}${reset}`,
+    );
+  });
+
+  lines.push("", ` ${dim}Selected: ${formatFeatureSelection(selection)}${reset}`);
+
+  if (lineCount > 0) {
+    stdout.write(`${ESC}[${lineCount}A`);
+  }
+
+  for (const line of lines) {
+    stdout.write(`${ESC}[2K${ESC}[0G${line}\n`);
+  }
+
+  return lines.length;
+}
+
+function restoreTerminal(onData: (chunk: string) => void) {
+  stdin.off("data", onData);
+  if (stdin.isTTY) {
+    stdin.setRawMode(false);
+  }
+  stdin.pause();
+  stdout.write(`${ESC}[?25h`);
+}
+
+export async function promptFeatureSelection(
+  initial: FeatureSelection = ALL_FEATURES,
+): Promise<FeatureSelection> {
+  if (!stdin.isTTY || !stdout.isTTY) {
+    return cloneSelection(initial);
+  }
+
+  const selection = cloneSelection(initial);
+  let activeIndex = 0;
+  let lineCount = 0;
+
+  stdout.write(`${ESC}[?25l`);
+
+  if (stdin.isTTY) {
+    stdin.setRawMode(true);
+  }
+  stdin.resume();
+  stdin.setEncoding("utf8");
+
+  return new Promise((resolve, reject) => {
+    const onKey = (action: KeyAction) => {
+      switch (action) {
+        case "up":
+          activeIndex =
+            (activeIndex - 1 + FEATURES.length) % FEATURES.length;
+          lineCount = renderCheckboxMenu(selection, activeIndex, lineCount);
+          break;
+        case "down":
+          activeIndex = (activeIndex + 1) % FEATURES.length;
+          lineCount = renderCheckboxMenu(selection, activeIndex, lineCount);
+          break;
+        case "toggle": {
+          const feature = FEATURES[activeIndex];
+          if (!feature) break;
+          selection[feature.id as FeatureId] = !selection[feature.id as FeatureId];
+          lineCount = renderCheckboxMenu(selection, activeIndex, lineCount);
+          break;
+        }
+        case "all":
+          Object.assign(selection, ALL_FEATURES);
+          lineCount = renderCheckboxMenu(selection, activeIndex, lineCount);
+          break;
+        case "minimal":
+          Object.assign(selection, MINIMAL_FEATURES);
+          lineCount = renderCheckboxMenu(selection, activeIndex, lineCount);
+          break;
+        case "confirm":
+          restoreTerminal(onData);
+          stdout.write("\n");
+          resolve(selection);
+          break;
+        case "interrupt":
+          restoreTerminal(onData);
+          stdout.write("\n");
+          reject(new Error("Feature selection cancelled."));
+          break;
+      }
+    };
+
+    const onData = createKeyReader(onKey);
+    stdin.on("data", onData);
+    lineCount = renderCheckboxMenu(selection, activeIndex, 0);
+  });
+}

package/src/template.ts

@@ -130,21 +130,6 @@ export async function customizeProject(
   pkg.name = packageName;
   await Bun.write(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
 
-  const envExamplePath = path.join(projectDir, ".env.example");
-  const envExample = Bun.file(envExamplePath);
-  if (await envExample.exists()) {
-    let envText = await envExample.text();
-    envText = envText
-      .replace(/^OTEL_SERVICE_NAME=kavoru$/m, `OTEL_SERVICE_NAME=${packageName}`)
-      .replace(/^KAFKA_CLIENT_ID=kavoru$/m, `KAFKA_CLIENT_ID=${packageName}`)
-      .replace(
-        /^KAFKA_GROUP_ID=kavoru-consumer$/m,
-        `KAFKA_GROUP_ID=${packageName}-consumer`,
-      );
-    await Bun.write(envExamplePath, envText);
-    await Bun.write(path.join(projectDir, ".env"), envText);
-  }
-
   const modulesIndex = path.join(projectDir, "src", "modules", "index.ts");
   const modulesFile = Bun.file(modulesIndex);
   if (await modulesFile.exists()) {