create-luff-app 1.0.6 → 2.0.0

package/NOTES.md

@@ -1,44 +1,50 @@
-# Luff Boilerplate
+# 📘 LUFF. Operational Manual
 
-This repository contains a full-stack Next.js + Node.js Microservices architecture boilerplate, ready for local execution and seamless Kubernetes (K8s) deployment via ArgoCD.
+<p align="center">
+  <img src="https://img.shields.io/badge/Mode-Local_Dev-6366f1?style=for-the-badge" />
+  <img src="https://img.shields.io/badge/Mode-Kubernetes-34d399?style=for-the-badge" />
+  <img src="https://img.shields.io/badge/CI/CD-GitHub_Actions-f59e0b?style=for-the-badge" />
+</p>
 
-Everything is containerized, fully configured for Google OAuth authentication, and automatically validated with CI/CD.
+> Everything you need to run, deploy, and maintain the LUFF. ecosystem — from local dev to production Kubernetes.
 
 ---
 
-## 🚀 1. Initial Setup Required
+## 🚀 1. Initial Setup
 
-Before running this project for the first time, you must configure your environment locally.
+### Prerequisites
 
-### Prerequisites:
+| Tool | Version | Purpose |
+|:---:|:---:|:---|
+| Node.js | `≥ 20.x` | Runtime for all services |
+| Docker Desktop | `≥ 24.x` | Database containers |
+| kubectl | Latest | Kubernetes management |
+| ArgoCD | Latest | GitOps agent (K8s mode only) |
 
-- **Node.js** (v20+)
-- **Docker** and **Docker Desktop / Minikube**
-- **kubectl** (connected to your local Kubernetes cluster)
-- **ArgoCD** (must be installed on your local Kubernetes cluster)
-
-### Step 1: Install Dependencies & Setup Env Files
-
-We have an automated setup script that installs NPM packages and copies the required `.env.example` files to `.env`.
+### One-Time Setup
 
 ```bash
-npm run setup
+npm run setup    # Installs packages + copies .env files
 ```
 
-Wait for `npm install` and Husky to finish.
+---
 
-### Step 2: Configure Environment Variables
+## ⚙️ 2. Environment Variables
 
-You MUST explicitly provide Google OAuth credentials and URLs for the frontend build and backend authentication to work. Check these three `.env` files and verify their values.
+You **must** configure these `.env` files before the app will fully function:
 
-**1. `frontend/.env`**
+<details>
+<summary><b>frontend/.env</b></summary>
 
 ```env
 NEXT_PUBLIC_API_URL=http://localhost:4000
 NEXT_PUBLIC_GOOGLE_CLIENT_ID=your_client_id.apps.googleusercontent.com
+NEXT_PUBLIC_RAZORPAY_KEY_ID=rzp_test_your_id
 ```
+</details>
 
-**2. `backend/auth/.env`**
+<details>
+<summary><b>backend/auth/.env</b></summary>
 
 ```env
 PORT=4001
@@ -46,18 +52,24 @@ JWT_SECRET="your-jwt-secret-change-in-production"
 GOOGLE_CLIENT_ID=your_client_id.apps.googleusercontent.com
 GOOGLE_CLIENT_SECRET=your_client_secret
 FRONTEND_URL=http://localhost:3000
+DATABASE_URL="postgresql://postgres:postgres@localhost:5433/auth_db"
 NODE_ENV=development
 ```
+</details>
 
-**3. `backend/posts/.env`**
+<details>
+<summary><b>backend/posts/.env</b></summary>
 
 ```env
 PORT=4002
 JWT_SECRET="your-jwt-secret"
+DATABASE_URL="postgresql://postgres:postgres@localhost:5434/posts_db"
 NODE_ENV=development
 ```
+</details>
 
-**4. `backend/payment/.env`**
+<details>
+<summary><b>backend/payment/.env</b></summary>
 
 ```env
 PORT=4003
@@ -67,150 +79,130 @@ DATABASE_URL="postgresql://postgres:postgres@localhost:5435/payment_db"
 JWT_SECRET="your-jwt-secret"
 NODE_ENV=development
 ```
+</details>
 
-### Step 3: Kubernetes Secrets
+<details>
+<summary><b>backend/ai-service/.env</b></summary>
 
-```bash
-# App, Auth & Posts Secrets (...)
-
-# Create Payment Secrets
-kubectl create secret generic payment-secrets \
-  --from-literal=database-url="postgresql://postgres:postgres@payment-db-service:5432/payment_db" \
-  --from-literal=razorpay-key-id="your_key" \
-  --from-literal=razorpay-key-secret="your_secret" \
-  --from-literal=jwt-secret="your-jwt-secret"
+```env
+PORT=4004
+GEMINI_API_KEY=your_gemini_api_key
+UPSTASH_VECTOR_REST_URL=https://your-index.upstash.io
+UPSTASH_VECTOR_REST_TOKEN=your_token
+JWT_SECRET="your-jwt-secret"
+NODE_ENV=development
 ```
+</details>
 
 ---
 
-## 🌟 2. How To Run Locally
+## 🖥️ 3. Running the Project
 
-We support two modes of development:
-
-### 1. Native Mode (Recommended)
-
-This is the fastest loop. Run everything directly on your machine:
+### Option A: Native Mode (Recommended for Dev)
 
 ```bash
 npm run run-local
 ```
 
-This script handles:
-
-- Stopping K8s port conflicts
-- Starting local Docker DBs
-- Running all services via `npm run dev`
-
-### 2. Kubernetes Mode (GitOps)
-
-Follow this if you want to test the full K8s stack:
-
-1. **Build & Deploy**: `npm run run-k8s build`
-2. **Access Dashboard**: `npm run argo`
-3. **Connect Ports**: `npm run access`
-
-We utilize ArgoCD as the GitOps agent. It constantly monitors your main branch's `k8s/` folder and applies the configuration locally.
+Handles everything: clears port conflicts, starts Docker DBs, launches all services.
 
-### Step 1: Tell ArgoCD to watch your directory
+### Option B: Kubernetes Mode (Production)
 
-Apply the custom Application configuration directly:
+```mermaid
+flowchart LR
+  A[Build] --> B[Tag]
+  B --> C[ArgoCD]
+  C --> D[Deploy]
+  D --> E[Forward]
+```
 
 ```bash
+# 1. Tell ArgoCD to watch your repo
 kubectl apply -f argocd/application.yaml
-```
-
-### Step 2: Build the Local Images (Automated)
 
-Your Kubernetes `Deployment` manifests are configured to pull from `ghcr.io/luff-org/...` with an `IfNotPresent` pull policy. To run the images locally exactly as they are configured in your manifests, **we have created an automation script**.
-
-This script pulls your `.env` Client ID, tags images according to your current commit SHA (what ArgoCD expects), and restarts the Kubernetes pods.
-
-```bash
+# 2. Build & deploy locally
 ./scripts/deploy-local.sh
-```
-
-### Step 3: Port Forwarding
 
-Because we are working locally, we must manually expose K8s services to `localhost`:
-
-```bash
-# Terminal 1 - For the Frontend Application
+# 3. Forward ports to localhost
 kubectl port-forward svc/frontend-service 3000:3000
-
-# Terminal 2 - For the API Gateway (Backend)
 kubectl port-forward svc/api-gateway 4000:4000
 ```
 
-Visit `http://localhost:3000` — Your Google OAuth login will be functioning seamlessly.
-
----
+### Kubernetes Secrets
 
-## 🔄 3. What To Do Whenever You Run This Afterwards
-
-When returning to development on a new day, you **DO NOT** need to repeat the secret configuration or ArgoCD setup. You just have to build any new changes and run your port-forwards.
+```bash
+# Auth secrets
+kubectl create secret generic auth-secrets \
+  --from-literal=database-url="postgresql://postgres:postgres@auth-db-service:5432/auth_db" \
+  --from-literal=google-client-id="your_id" \
+  --from-literal=google-client-secret="your_secret" \
+  --from-literal=jwt-secret="your-jwt-secret"
 
-1. **Commit your code to Git**: Or ArgoCD will desync!
-2. **Run the Automation Script**: To push the newest changes directly to your local cluster:
-   ```bash
-   ./scripts/deploy-local.sh
-   ```
-3. **Start your tunnels**:
-   ```bash
-   kubectl port-forward svc/frontend-service 3000:3000
-   kubectl port-forward svc/api-gateway 4000:4000
-   ```
+# Payment secrets
+kubectl create secret generic payment-secrets \
+  --from-literal=database-url="postgresql://postgres:postgres@payment-db-service:5432/payment_db" \
+  --from-literal=razorpay-key-id="your_key" \
+  --from-literal=razorpay-key-secret="your_secret" \
+  --from-literal=jwt-secret="your-jwt-secret"
 
-_(Alternatively, if you only want to develop quickly on your host machine WITHOUT Kubernetes, you can bypass Docker altogether by running `npm run dev` in the root folder!)_
+# AI secrets
+kubectl create secret generic ai-secrets \
+  --from-literal=gemini-api-key="your_gemini_key" \
+  --from-literal=upstash-vector-rest-url="your_url" \
+  --from-literal=upstash-vector-rest-token="your_token" \
+  --from-literal=jwt-secret="your-jwt-secret"
+```
 
 ---
 
-## 🤖 4. Ensuring Automation Works (GitHub Actions CI/CD)
-
-Whenever you push to `main` on GitHub, our unified pipeline (`.github/workflows/pipeline.yml`) runs automatically.
-
-**To ensure this workflow succeeds on the cloud:**
-You MUST add your `GOOGLE_CLIENT_ID` to GitHub Secrets. Failure to do so means the Cloud-built Docker image will have an empty Google Client ID baked into its statically-generated frontend!
-
-**Go to GitHub**:
+## 🔄 4. Daily Development Workflow
 
-1. Open Repository > `Settings`
-2. Navigate to `Secrets and variables` > `Actions`
-3. Click `New repository secret`
-4. **Name**: `GOOGLE_CLIENT_ID`
-5. **Secret**: `your_client_id.apps.googleusercontent.com`
-6. Click **Add secret**.
+> After initial setup, you **don't** need to reconfigure secrets or ArgoCD.
 
-_(The frontend URL and other runtime variables are dynamically passed, but Next.js `NEXT_PUBLIC_` variables are physically built into the Docker image, so this is strictly required!)\_
+| Mode | Daily Steps |
+|:---|:---|
+| **Native** | Just run `npm run run-local` |
+| **K8s** | `./scripts/deploy-local.sh` → Port forward |
 
 ---
 
-## 🎨 5. Personalization & Customization (For New Users)
+## 🤖 5. CI/CD Pipeline
 
-If you are cloning this boilerplate to start your own project, you need to update a few hardcoded values to point to your own GitHub Organization and Repository.
-
-### Step 1: Search and Replace
-
-Search the entire repository for `luff-org` and replace it with your own **GitHub Username** or **Organization Name** (in lowercase).
+```mermaid
+flowchart LR
+  Push --> CI[Actions]
+  CI --> Lint
+  Lint --> Build
+  Build --> GHCR
+  GHCR --> Argo[ArgoCD]
+  Argo --> K8s
+```
 
-- **Impacts**: K8s image paths, Docker tags, and CI/CD registry paths.
+> **⚠️ Important**: Add `GOOGLE_CLIENT_ID` to GitHub Repository Secrets. Next.js `NEXT_PUBLIC_` variables are baked into the Docker image at build time.
 
-### Step 2: Update ArgoCD Repo URL
+### Adding the GitHub Secret
 
-Open `argocd/application.yaml` and update the `repoURL` to point to your new fork or repository:
+1. Repository → **Settings** → **Secrets and variables** → **Actions**
+2. Click **New repository secret**
+3. Name: `GOOGLE_CLIENT_ID` → Value: `your_client_id.apps.googleusercontent.com`
 
-```yaml
-repoURL: https://github.com/YOUR_ORG/YOUR_REPO.git
-```
+---
 
-### Step 3: Update Production API URL
+## 🎨 6. Customization Guide
 
-Open `.github/workflows/pipeline.yml` and update the `NEXT_PUBLIC_API_URL` under the `Build & Push` job to your actual production domain:
+When forking for your own project, search and replace these values:
 
-```yaml
-build-args: |
-  NEXT_PUBLIC_API_URL=https://api.your-actual-domain.com
-```
+| Find | Replace With | Affects |
+|:---|:---|:---|
+| `luff-org` | Your GitHub org (lowercase) | K8s images, Docker tags, CI/CD |
+| `Luff-Org` | Your GitHub org | Git URLs, ArgoCD config |
+| `Luff-Boilerplate` | Your repo name | Clone URLs, package names |
 
-### Step 4: Database Names & Secrets
+### Key Files to Update
 
-If you change the service names or database names in the `k8s/` manifests, remember to update the corresponding `DATABASE_URL` strings in your **Kubernetes Secrets** (Step 1.3 above).
+| File | What to Change |
+|:---|:---|
+| `argocd/application.yaml` | `repoURL` → your repository |
+| `.github/workflows/pipeline.yml` | `NEXT_PUBLIC_API_URL` → your domain |
+| `k8s/*.yaml` | Image paths → your registry |
+| All `DATABASE_URL` strings | If you rename databases |

package/README.md

@@ -1,189 +1,138 @@
-# 💨 Luff Microservices Boilerplate
+# 🚀 create-luff-app
 
-[![NPM Version](https://img.shields.io/npm/v/create-luff-app?color=blue&style=flat-square)](https://www.npmjs.com/package/create-luff-app)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.4-blue?style=flat-square&logo=typescript)](https://www.typescriptlang.org/)
+<p align="center">
+  <img src="https://img.shields.io/npm/v/create-luff-app?style=for-the-badge&color=6366f1&label=npm" alt="npm" />
+  <img src="https://img.shields.io/badge/Services-6-34d399?style=for-the-badge" />
+  <img src="https://img.shields.io/badge/AI_Powered-Gemini_2.5-8E75B2?style=for-the-badge" />
+  <img src="https://img.shields.io/badge/License-MIT-green?style=for-the-badge" />
+</p>
 
-A **production-grade microservices monorepo** designed for speed, scalability, and developer experience. Built with Turborepo, Next.js, Express, Prisma, and PostgreSQL.
+> **Scaffold the entire LUFF. microservices ecosystem in one command.**  
+> Full-stack Next.js + Express + Prisma + Gemini AI + Razorpay — ready to run.
 
 ---
 
-## 🚀 Quick Start with CLI
-
-The fastest way to scaffold a new project using this boilerplate is with our official CLI:
+## ⚡ Quick Start
 
 ```bash
-npx create-luff-app <your-app-name>
+npx create-luff-app@latest my-app
 ```
 
-> [!TIP]
-> This command will clone the repository, install dependencies, and set up your project structure automatically.
-
----
-
-## 📝 Operational Notes
-
-For detailed troubleshooting on database connections, Kubernetes local setup, and Docker build fixes, see [NOTES.md](./NOTES.md).
+That's it. The CLI will:
+1. Clone the boilerplate
+2. Ask if you want **AI features** (Gemini + RAG)
+3. Install all dependencies
+4. Initialize a fresh Git repo
 
----
+### After Scaffolding
 
-## 🏗️ Architecture
-
-```text
-                    ┌─────────────┐
-                    │  API Gateway│  :4000
-                    │  (Express)  │
-                    └──────┬──────┘
-                           │
-              ┌────────────┼────────────┐
-              │                         │
-        ┌─────┴─────┐           ┌──────┴─────┐
-        │   Auth    │           │   Posts    │
-        │  Service  │  :4001    │  Service   │  :4002
-        │ (Express) │           │  (Express) │
-        └─────┬─────┘           └──────┬─────┘
-              │                         │
-        ┌─────┴─────┐           ┌──────┴─────┐
-        │  Auth DB  │           │  Posts DB  │
-        │ (Postgres)│           │ (Postgres) │
-        └───────────┘           └────────────┘
-
-            ┌─────────────────────────────┐
-            │        Frontend App         │
-            │          (Next.js)          │
-            │            :3000            │
-            └─────────────────────────────┘
+```bash
+cd my-app
+bash scripts/setup-envs.sh
+docker compose -f docker/docker-compose.yml up auth-db posts-db payment-db -d
+npm run run-local
 ```
 
----
-
-## 🛠️ Tech Stack
-
-| Layer        | Technology                                        |
-| :----------- | :------------------------------------------------ |
-| **Frontend** | Next.js 14 (App Router), TailwindCSS, React Query |
-| **Backend**  | Node.js, Express, TypeScript                      |
-| **Database** | PostgreSQL, Prisma ORM                            |
-| **Auth**     | Google OAuth (PostMessage flow), JWT              |
-| **Monorepo** | Turborepo, npm workspaces                         |
-| **Infra**    | Docker, Kubernetes (ArgoCD ready)                 |
-| **Quality**  | ESLint, Prettier, Husky, Commitlint               |
+> 🧠 **AI Users**: Add your `GEMINI_API_KEY` and Upstash Vector keys to `backend/ai-service/.env`
 
 ---
 
-## ⚡ Local Development Setup
-
-Follow these steps to get your environment running from scratch.
+## 🏗️ What Gets Scaffolded
 
-### 1. Prerequisites
-
-Ensure you have the following installed:
-
-- **Node.js**: `v20.x` or higher
-- **Docker**: For running databases locally
-
-### 2. Installation
-
-If you didn't use the CLI, clone and install manually:
-
-```bash
-git clone https://github.com/Luff-Org/Luff-Boilerplate.git
-cd Luff-Boilerplate
-npm install
+```
+my-app/
+├── frontend/                → Next.js 14 (App Router + Tailwind)
+├── backend/
+│   ├── api-gateway/         → Reverse Proxy & Rate Limiting (:4000)
+│   ├── auth/                → Google OAuth + JWT (:4001)
+│   ├── posts/               → Community CRUD (:4002)
+│   ├── payment/             → Razorpay Payments (:4003)
+│   └── ai-service/          → Gemini 2.5 AI + RAG (:4004)
+├── shared/                  → Shared types, config, logger
+├── docker/                  → Docker Compose (3 PostgreSQL DBs)
+├── k8s/                     → Kubernetes manifests (ArgoCD-ready)
+├── scripts/                 → Setup & deployment automation
+└── .github/workflows/       → CI/CD pipeline
 ```
 
-### 3. Environment & Databases
-
-We provide a setup script to automate `.env` creation:
+---
 
-```bash
-# Automatically creates .env files from .env.example
-npm run setup
+## 📡 Service Directory
 
-# Spin up PostgreSQL instances via Docker
-docker compose -f docker/docker-compose.yml up auth-db posts-db -d
-```
+| | Service | Port | Tech | What It Does |
+|:---:|:---|:---:|:---|:---|
+| 🧠 | **AI Service** | `4004` | Gemini 2.5 Flash, Upstash Vector | PDF intelligence, contextual chat, RAG |
+| 🔐 | **Auth** | `4001` | Google OAuth, JWT, Prisma | Stateless authentication |
+| 📝 | **Posts** | `4002` | Express, Prisma | Community posts with owner enforcement |
+| 💳 | **Payment** | `4003` | Razorpay SDK, Prisma | Orders, verification, transaction ledger |
+| 🛡️ | **Gateway** | `4000` | Express, http-proxy-middleware | CORS, rate-limiting, routing |
+| 🖥️ | **Frontend** | `3000` | Next.js 14, Tailwind, React Query | Premium UI with dark/light mode |
 
-### 4. Database Initialization
+---
 
-Generate Prisma clients and push schemas to your local databases:
+## 🧠 AI Feature (Opt-In)
 
-```bash
-# Auth service
-cd backend/auth && npm run db:push && npm run db:generate && cd ../..
+During scaffolding, the CLI asks:
 
-# Posts service
-cd backend/posts && npm run db:push && npm run db:generate && cd ../..
 ```
-
-### 5. Start Developing
-
-```bash
-npm run dev
+✨ Would you like to enable the AI Chatbot feature (RAG + Gemini)? (y/n)
 ```
 
-Your services will be available at:
-
-- **Web Interface**: [http://localhost:3000](http://localhost:3000)
-- **API Gateway**: [http://localhost:4000](http://localhost:4000)
-- **Auth Service**: [http://localhost:4001](http://localhost:4001)
-- **Posts Service**: [http://localhost:4002](http://localhost:4002)
-
----
-
-## 📂 Project Structure
-
-```text
-├── frontend/              # Unified Next.js application
-├── backend/
-│   ├── auth/              # Auth microservice (Google OAuth + JWT)
-│   ├── posts/             # Posts microservice (CRUD)
-│   └── api-gateway/       # Express Proxy & Rate Limiting
-├── shared/                # Shared internal packages (Types, Logger, Config)
-├── docker/                # Docker Compose configurations
-├── k8s/                   # Kubernetes manifests
-└── scripts/               # Automation & Setup scripts
+| Choice | What Happens |
+|:---:|:---|
+| **Yes** | Full AI service included — chat, PDF upload, RAG pipeline |
+| **No** | AI service is removed, gateway routes cleaned up, chat page deleted |
+
+### AI Architecture
+
+```mermaid
+flowchart LR
+  A[Upload] --> B[Parse]
+  B --> C[Embed]
+  C --> D[Store]
+  E[Query] --> F[Search]
+  D -.-> F
+  F --> G[Gemini]
+  G --> H[Answer]
 ```
 
 ---
 
-## 🔐 Google OAuth Configuration
-
-To enable authentication:
+## 🔑 Credentials Setup
 
-1. Create OAuth credentials in [Google Cloud Console](https://console.cloud.google.com/apis/credentials).
-2. Set authorized origin to `http://localhost:3000`.
-3. Update `GOOGLE_CLIENT_ID` in `backend/auth/.env` and `NEXT_PUBLIC_GOOGLE_CLIENT_ID` in `frontend/.env`.
-
----
+<details>
+<summary><b>🧠 AI — Gemini + Upstash</b></summary>
 
-## 🐳 Deployment
+| Get From | What | Put In |
+|:---|:---|:---|
+| [AI Studio](https://aistudio.google.com/app/apikey) | `GEMINI_API_KEY` | `backend/ai-service/.env` |
+| [Upstash](https://console.upstash.com/vector) | `REST_URL` + `TOKEN` | `backend/ai-service/.env` |
 
-### Docker Compose
+Create a Vector Index with **768 dimensions**.
+</details>
 
-```bash
-docker compose -f docker/docker-compose.yml up --build
-```
+<details>
+<summary><b>🔐 Auth — Google OAuth</b></summary>
 
-### Kubernetes
+| Get From | What | Put In |
+|:---|:---|:---|
+| [Cloud Console](https://console.cloud.google.com/apis/credentials) | `CLIENT_ID`, `CLIENT_SECRET` | `backend/auth/.env` + `frontend/.env` |
 
-```bash
-kubectl apply -f k8s/
-```
+Redirect URI: `http://localhost:4000/auth/callback/google`
+</details>
 
----
+<details>
+<summary><b>💳 Payments — Razorpay</b></summary>
 
-## 📜 Scripts
+| Get From | What | Put In |
+|:---|:---|:---|
+| [Razorpay](https://dashboard.razorpay.com/) | `KEY_ID`, `KEY_SECRET` | `backend/payment/.env` + `frontend/.env` |
 
-| Command         | Description                             |
-| :-------------- | :-------------------------------------- |
-| `npm run dev`   | Starts all services in development mode |
-| `npm run build` | Builds all apps and packages            |
-| `npm run setup` | Initializes environment files           |
-| `npm run lint`  | Runs linting across the monorepo        |
+Enable **Test Mode** first.
+</details>
 
 ---
 
 ## 📄 License
 
-This project is licensed under the [MIT License](LICENSE).
+[MIT](LICENSE)

package/bin/cli.js

@@ -1,9 +1,18 @@
 #!/usr/bin/env node
+/* eslint-env node */
 
 const degit = require("degit");
 const fs = require("fs");
 const path = require("path");
 const { execSync } = require("child_process");
+const readline = require("readline");
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const question = (query) => new Promise((resolve) => rl.question(query, resolve));
 
 const projectName = process.argv[2];
 
@@ -32,13 +41,36 @@ async function main() {
     const emitter = degit("Luff-Org/Luff-Boilerplate", {
       cache: false,
       force: true,
-      verbose: true
+      verbose: true,
     });
 
     await emitter.clone(projectPath);
 
     process.chdir(projectPath);
 
+    // Ask about AI Feature
+    const enableAI = await question("\x1b[33m✨ Would you like to enable the AI Chatbot feature (RAG + GPT-4o)? (y/n): \x1b[0m");
+    rl.close();
+
+    if (enableAI.toLowerCase() !== "y") {
+      console.log("\x1b[36m%s\x1b[0m", "🧹 Removing AI module...");
+      try {
+        fs.rmSync(path.join(projectPath, "backend/ai-service"), { recursive: true, force: true });
+        fs.rmSync(path.join(projectPath, "frontend/src/app/chat"), { recursive: true, force: true });
+        
+        // Clean up Gateway index.ts
+        const gatewayIndexPath = path.join(projectPath, "backend/api-gateway/src/index.ts");
+        if (fs.existsSync(gatewayIndexPath)) {
+          let content = fs.readFileSync(gatewayIndexPath, "utf8");
+          content = content.replace(/import { authProxy, postsProxy, paymentProxy, aiProxy } from '.\/routes\/proxy';/, "import { authProxy, postsProxy, paymentProxy } from './routes/proxy';");
+          content = content.replace(/\/\/ Proxy \/ai\/\* → ai service\napp\.use\('\/ai', aiProxy\);\n/, "");
+          fs.writeFileSync(gatewayIndexPath, content);
+        }
+      } catch (e) {
+        console.log("  Notice: Could not fully remove AI files, skipping.");
+      }
+    }
+
     console.log("\x1b[36m%s\x1b[0m", "🧹 Cleaning up repository history...");
 
     try {
@@ -81,11 +113,14 @@ async function main() {
     console.log("Next steps:");
     console.log(`  cd ${projectName}`);
     console.log(
-      "  docker compose -f docker/docker-compose.yml up auth-db posts-db -d"
+      "  docker compose -f docker/docker-compose.yml up auth-db posts-db payment-db -d"
     );
     console.log(
       "  set up .env files from .env.example files, can also use script > npm run setup"
     );
+    if (enableAI.toLowerCase() === 'y') {
+      console.log("\x1b[35m%s\x1b[0m", "  💡 Don't forget to add OPENAI_API_KEY and UPSTASH_VECTOR keys to backend/ai-service/.env!");
+    }
     console.log("  npm run dev");
     console.log("");
   } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-luff-app",
-  "version": "1.0.6",
+  "version": "2.0.0",
   "description": "CLI to scaffold the Luff Microservices Boilerplate",
   "bin": {
     "create-luff-app": "bin/cli.js"