npm - create-luff-app - Versions diffs - 1.0.7 → 2.0.1 - Mend

create-luff-app 1.0.7 → 2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/NOTES.md CHANGED Viewed

@@ -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,124 @@ 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
+%%{init: {'theme':'dark','themeVariables':{'fontSize':'10px'}}}%%
+flowchart LR
+  A[Build] --> B[Tag] --> C[ArgoCD] --> D[Deploy] --> 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
+%%{init: {'theme':'dark','themeVariables':{'fontSize':'10px'}}}%%
+flowchart LR
+  Push --> CI[Actions] --> Lint --> Build --> Reg[GHCR] --> Argo[ArgoCD] --> 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 CHANGED Viewed

@@ -1,191 +1,218 @@
-# 💨 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.
+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
-## 📝 Operational Notes
+```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
+```
-For detailed troubleshooting on database connections, Kubernetes local setup, and Docker build fixes, see [NOTES.md](./NOTES.md).
+> 🧠 **AI Users**: Add your `GEMINI_API_KEY` and Upstash Vector keys to `backend/ai-service/.env`
 ---
-## 🏗️ Architecture
-```text
-                    ┌─────────────┐
-                    │  API Gateway│  :4000
-                    │  (Express)  │
-                    └──────┬──────┘
-                           │
-         ┌─────────────────┼─────────────────┐
-         │                 │                 │
-   ┌─────┴─────┐     ┌─────┴─────┐     ┌─────┴─────┐
-   │   Auth    │     │   Posts   │     │  Payment  │
-   │  Service  │:4001│  Service  │:4002│  Service  │:4003
-   │ (Express) │     │ (Express) │     │ (Express) │
-   └─────┬─────┘     └─────┬─────┘     └─────┬─────┘
-         │                 │                 │
-   ┌─────┴─────┐     ┌─────┴─────┐     ┌─────┴─────┐
-   │  Auth DB  │     │  Posts DB │     │Payment DB │
-   │ (Postgres)│     │ (Postgres)│     │(Postgres) │
-   └───────────┘     └───────────┘     └───────────┘
-             ┌─────────────────────────────┐
-             │        Frontend App         │
-             │          (Next.js)          │
-             │            :3000            │
-             └─────────────────────────────┘
+## 🏗️ What Gets Scaffolded
+```
+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
 ```
 ---
-## 🛠️ Tech Stack
+## 📡 Service Directory
-| Layer        | Technology                                        |
-| :----------- | :------------------------------------------------ |
-| **Frontend** | Next.js 14 (App Router), TailwindCSS, React Query |
-| **Backend**  | Node.js, Express, TypeScript                      |
-| **Database** | PostgreSQL, Prisma ORM                            |
-| **Payment**  | Integrated Stripe/Internal Payment Logic          |
-| **Auth**     | Google OAuth (PostMessage flow), JWT              |
-| **Monorepo** | Turborepo, npm workspaces                         |
-| **Infra**    | Docker, Kubernetes (ArgoCD ready)                 |
-| **Quality**  | ESLint, Prettier, Husky, Commitlint               |
-| **Toast**    | Sonner (Premium Notifications)                    |
+| | 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 |
 ---
-## ⚡ Local Development Setup
-Follow these steps to get your environment running from scratch.
-### 1. Prerequisites
-Ensure you have the following installed:
+## 🧠 AI Feature (Opt-In)
-- **Node.js**: `v20.x` or higher
-- **Docker**: For running databases locally
+During scaffolding, the CLI asks:
-### 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
 ```
-### 3. Environment & Databases
-We provide a setup script to automate `.env` creation:
-```bash
-# Automatically creates .env files from .env.example
-npm run setup
-# Spin up PostgreSQL instances via Docker
-docker compose -f docker/docker-compose.yml up auth-db posts-db -d
+✨ Would you like to enable the AI Chatbot feature (RAG + Gemini)? (y/n)
 ```
-### 4. Database Initialization
-Generate Prisma clients and push schemas to your local databases:
-```bash
-# Auth service
-cd backend/auth && npm run db:push && npm run db:generate && cd ../..
-# Posts service
-cd backend/posts && npm run db:push && npm run db:generate && cd ../..
+| 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
+%%{init: {'theme':'dark','themeVariables':{'fontSize':'10px'}}}%%
+flowchart LR
+  A[Upload] --> B[Parse]
+  B --> C[Embed]
+  C --> D[Store]
+  E[Query] --> F[Search]
+  D -.-> F
+  F --> G[Gemini]
+  G --> H[Answer]
 ```
-### 5. Start Developing
-```bash
-npm run dev
+## 🧬 Architecture at a Glance
+```mermaid
+%%{init: {'theme':'dark','themeVariables':{'fontSize':'19px'}}}%%
+graph LR
+  FE[FE] --> GW[API GW]
+  GW --> A[Auth]
+  GW --> P[Posts]
+  GW --> Pay[Pay]
+  GW --> AI[AI]
+  A --> AD[(AuthDB)]
+  P --> PD[(PostsDB)]
+  Pay --> PaD[(PayDB)]
+  AI --> V[(Vector)]
+  AI --> G[Gemini]
 ```
-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
+## 💳 Payment Service — Transaction Infrastructure
+<summary><b>🔍 Click to expand Payment Architecture</b></summary>
+```mermaid
+%%{init: {'theme':'dark','themeVariables':{'fontSize':'10px'}}}%%
+sequenceDiagram
+  participant U as User
+  participant F as Frontend
+  participant G as Gateway
+  participant P as Payment
+  participant R as Razorpay
+  participant DB as PayDB
+  U->>F: Buy
+  F->>G: POST /create-order
+  G->>P: Forward
+  P->>R: Create Order
+  R-->>P: order_id
+  P-->>F: order_id
+  F->>R: Checkout
+  R-->>F: Callback
+  F->>G: POST /verify
+  G->>P: Forward
+  P->>P: HMAC Check
+  P->>DB: Save
+  P-->>F: Verified
 ```
+| Route | Method | Auth | Description |
+|:---|:---:|:---:|:---|
+| `/payments/create-order` | POST | ✅ | Creates a Razorpay order with amount & currency |
+| `/payments/verify` | POST | ✅ | Verifies payment signature (HMAC-SHA256) |
+| `/payments/my-purchases` | GET | ✅ | Returns user's transaction history |
 ---
-## 🔐 Google OAuth Configuration
+## 🔐 Auth Service — Stateless Security
+<summary><b>🔍 Click to expand Authentication Flow</b></summary>
+```mermaid
+%%{init: {'theme':'dark','themeVariables':{'fontSize':'10px'}}}%%
+sequenceDiagram
+  participant U as User
+  participant F as Frontend
+  participant G as Google
+  participant A as Auth
+  participant DB as AuthDB
+  U->>F: Login
+  F->>G: OAuth Popup
+  G-->>F: Token
+  F->>A: POST /auth/google
+  A->>G: Verify
+  G-->>A: Profile
+  A->>DB: Upsert
+  A->>A: Sign JWT
+  A-->>F: JWT + User
+  F->>F: Store JWT
+```
-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>
----
+| 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` |
-## 🐳 Deployment
+Create a Vector Index with **768 dimensions**.
+</details>
-### Docker Compose
+<details>
+<summary><b>🔐 Auth — Google OAuth</b></summary>
-```bash
-docker compose -f docker/docker-compose.yml up --build
-```
+| Get From | What | Put In |
+|:---|:---|:---|
+| [Cloud Console](https://console.cloud.google.com/apis/credentials) | `CLIENT_ID`, `CLIENT_SECRET` | `backend/auth/.env` + `frontend/.env` |
-### Kubernetes
+Redirect URI: `http://localhost:4000/auth/callback/google`
+</details>
-```bash
-kubectl apply -f k8s/
-```
----
+<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 CHANGED Viewed

@@ -5,6 +5,14 @@ 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];
@@ -33,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 {
@@ -87,6 +118,9 @@ async function main() {
     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 CHANGED Viewed

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