vibes-plug 1.0.0

package/skills/bun-runtime-expert/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: bun-runtime-expert
+description: "Expert guide for Bun JavaScript/TypeScript runtime. Use when building, testing, or deploying applications with Bun / Panduan ahli untuk runtime JavaScript/TypeScript Bun. Digunakan saat membuat, menguji, atau meluncurkan aplikasi dengan Bun."
+author: "Roedy Rustam"
+---
+
+# Bun Runtime Expert
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+Expert-level guidance for building high-performance applications with the Bun JavaScript/TypeScript runtime (v1.1+). Covers Bun's built-in HTTP server, database clients, bundler, test runner, package manager, and Node.js migration strategies.
+
+### Trigger Conditions
+- Use when scaffolding a new project with Bun as the runtime.
+- Use when building HTTP servers or APIs with `Bun.serve()`.
+- Use when querying databases with `Bun.sql` (PostgreSQL, MySQL, SQLite).
+- Use when interacting with S3-compatible object storage via `Bun.s3`.
+- Use when bundling frontend or backend code with `bun build`.
+- Use when writing tests with `bun:test`.
+- Use when migrating an existing Node.js project to Bun.
+- Use when optimizing package installation speed or lockfile management.
+
+### Core Architecture
+
+#### Why Bun?
+Bun is a batteries-included JavaScript/TypeScript runtime that replaces Node.js, npm, Webpack/Vite, and Jest in a single binary:
+
+| Capability | Bun Built-in | Node.js Equivalent |
+|---|---|---|
+| Runtime | `bun run` | `node` |
+| Package Manager | `bun install` | `npm` / `pnpm` / `yarn` |
+| Bundler | `bun build` | Webpack / Vite / esbuild |
+| Test Runner | `bun test` | Jest / Vitest |
+| HTTP Server | `Bun.serve()` | Express / Fastify |
+| SQL Client | `Bun.sql` | `pg` / `mysql2` / `better-sqlite3` |
+| S3 Client | `Bun.s3` | `@aws-sdk/client-s3` |
+| Redis Client | Built-in | `ioredis` |
+| TypeScript | Native (zero config) | `ts-node` / `tsx` |
+| `.env` loading | Native | `dotenv` |
+
+### Quick Start
+
+#### 1. Install Bun
+```bash
+# macOS / Linux
+curl -fsSL https://bun.sh/install | bash
+
+# Windows (PowerShell)
+powershell -c "irm bun.sh/install.ps1 | iex"
+
+# Verify installation
+bun --version
+```
+
+#### 2. Initialize a New Project
+```bash
+bun init
+```
+This generates `package.json`, `tsconfig.json`, and an `index.ts` entry point. TypeScript works out of the box with zero configuration.
+
+#### 3. Install Dependencies
+```bash
+# Install all dependencies (10-100x faster than npm)
+bun install
+
+# Add a package
+bun add hono zod drizzle-orm
+
+# Add dev dependency
+bun add -d @types/bun vitest
+```
+
+### Bun.serve() — High-Performance HTTP Server
+`Bun.serve()` is a zero-dependency HTTP server with built-in TLS, WebSocket support, and hot module reloading.
+
+#### Basic HTTP Server
+```typescript
+Bun.serve({
+  port: 3000,
+  fetch(req) {
+    const url = new URL(req.url);
+    if (url.pathname === '/api/health') {
+      return Response.json({ status: 'ok', runtime: 'bun' });
+    }
+    return new Response('Not Found', { status: 404 });
+  },
+});
+```
+
+### Bun.sql — Unified Database Client
+Zero-dependency SQL client supporting PostgreSQL, MySQL/MariaDB, and SQLite via tagged template literals.
+
+#### PostgreSQL
+```typescript
+import { sql } from 'bun';
+const users = await sql`SELECT * FROM users WHERE active = ${true}`;
+```
+
+### Best Practices
+- **Performance:** Use `Bun.serve()` directly or Hono for HTTP — avoid Express (slower compat layer). Use `Bun.file()` for efficient file I/O.
+- **Security:** Always parameterize queries via template literals in `Bun.sql` (automatically prevents SQL injection).
+- **Testing:** Use `bun:test` — it's Jest-compatible and significantly faster.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+Panduan tingkat ahli untuk membangun aplikasi berkinerja tinggi menggunakan runtime JavaScript/TypeScript Bun (v1.1+). Mencakup server HTTP bawaan, klien database, bundler, test runner, package manager, dan strategi migrasi dari Node.js.
+
+### Kondisi Pemicu
+- Gunakan saat merancang proyek baru menggunakan Bun sebagai runtime.
+- Gunakan saat membangun server HTTP atau API dengan `Bun.serve()`.
+- Gunakan saat melakukan query database dengan `Bun.sql` (PostgreSQL, MySQL, SQLite).
+- Gunakan saat berinteraksi dengan object storage yang kompatibel dengan S3 via `Bun.s3`.
+- Gunakan saat membundel kode frontend atau backend dengan `bun build`.
+- Gunakan saat menulis pengujian (testing) menggunakan `bun:test`.
+- Gunakan saat memigrasikan proyek Node.js ke Bun.
+- Gunakan saat mengoptimalkan kecepatan instalasi paket atau manajemen lockfile.
+
+### Arsitektur Inti
+
+#### Mengapa Bun?
+Bun adalah runtime JavaScript/TypeScript serba ada yang menggantikan Node.js, npm, Webpack/Vite, dan Jest dalam satu berkas biner tunggal:
+
+| Kemampuan | Bawaan Bun | Setara di Node.js |
+|---|---|---|
+| Runtime | `bun run` | `node` |
+| Package Manager | `bun install` | `npm` / `pnpm` / `yarn` |
+| Bundler | `bun build` | Webpack / Vite / esbuild |
+| Test Runner | `bun test` | Jest / Vitest |
+| HTTP Server | `Bun.serve()` | Express / Fastify |
+| SQL Client | `Bun.sql` | `pg` / `mysql2` / `better-sqlite3` |
+| S3 Client | `Bun.s3` | `@aws-sdk/client-s3` |
+| Redis Client | Built-in | `ioredis` |
+| TypeScript | Native (tanpa config) | `ts-node` / `tsx` |
+| `.env` loading | Native | `dotenv` |
+
+### Memulai Cepat
+
+#### 1. Instal Bun
+```bash
+# Windows (PowerShell)
+powershell -c "irm bun.sh/install.ps1 | iex"
+
+# macOS / Linux
+curl -fsSL https://bun.sh/install | bash
+
+# Verifikasi instalasi
+bun --version
+```
+
+#### 2. Inisialisasi Proyek Baru
+```bash
+bun init
+```
+Ini menghasilkan `package.json`, `tsconfig.json`, dan file entry point `index.ts`. TypeScript langsung berfungsi tanpa konfigurasi tambahan.
+
+#### 3. Instal Dependensi
+```bash
+# Mengmenginstal semua dependensi (10-100x lebih cepat dari npm)
+bun install
+
+# Menambahkan paket
+bun add hono zod drizzle-orm
+
+# Menambahkan dev dependency
+bun add -d @types/bun vitest
+```
+
+### Bun.serve() — HTTP Server Berkinerja Tinggi
+`Bun.serve()` adalah server HTTP tanpa dependensi eksternal dengan dukungan TLS bawaan, WebSocket, dan hot module reloading.
+
+#### Server HTTP Dasar
+```typescript
+Bun.serve({
+  port: 3000,
+  fetch(req) {
+    const url = new URL(req.url);
+    if (url.pathname === '/api/health') {
+      return Response.json({ status: 'ok', runtime: 'bun' });
+    }
+    return new Response('Not Found', { status: 404 });
+  },
+});
+```
+
+### Bun.sql — Klien Database Terpadu
+Klien SQL tanpa dependensi eksternal yang mendukung PostgreSQL, MySQL/MariaDB, dan SQLite melalui tagged template literals.
+
+#### PostgreSQL
+```typescript
+import { sql } from 'bun';
+const users = await sql`SELECT * FROM users WHERE active = ${true}`;
+```
+
+### Praktik Terbaik
+- **Performa:** Gunakan `Bun.serve()` secara langsung atau bersama Hono — hindari Express (karena lapisan kompatibilitasnya lebih lambat). Gunakan `Bun.file()` untuk I/O file yang efisien.
+- **Keamanan:** Selalu gunakan parameterisasi query melalui template literals di `Bun.sql` untuk mencegah SQL Injection secara otomatis.
+- **Pengujian:** Gunakan `bun:test` yang kompatibel dengan Jest namun jauh lebih cepat.
+
+---
+
+### Limitations / Batasan
+- Use this skill only when the task involves the Bun runtime specifically.
+- Bun's Node.js compatibility is extensive but not 100%. Always verify critical `node:*` API usage.

package/skills/ci-cd-devops-architect/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: ci-cd-devops-architect
+description: "Expert guide for continuous integration, deployment pipelines, Docker, Kubernetes, and Infrastructure as Code (IaC) / Panduan ahli untuk CI/CD dan infrastruktur."
+author: "Antigravity"
+---
+
+# CI/CD & DevOps Architect / Arsitek CI/CD & DevOps
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+Expert-level skill for designing and maintaining CI/CD pipelines (GitHub Actions, GitLab CI) and managing infrastructure using Docker, Kubernetes, and Terraform.
+
+### Instructions
+- **Automate Everything**: Ensure tests, linting, formatting, and security scans run on every PR. Block merges if pipelines fail.
+- **Immutable Artifacts**: Build a Docker image once and deploy the exact same image to Staging and Production. Pass environment variables dynamically at runtime, not build time.
+- **Infrastructure as Code**: Keep all infrastructure configurations (Terraform, K8s manifests) in version control. Avoid manual changes via the cloud provider's web console.
+- **Secrets Management**: Never commit secrets to the repository. Use secure vaults like GitHub Secrets, AWS Secrets Manager, or HashiCorp Vault, and inject them securely into the environment.
+- **Zero-Downtime Deployments**: Utilize deployment strategies like rolling updates or blue-green deployments to ensure application availability during releases.
+
+### Trigger Conditions
+Active whenever the user is creating GitHub Actions, configuring Dockerfiles, writing Terraform scripts, or setting up deployment pipelines.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Skill tingkat ahli untuk merancang dan memelihara *pipeline* CI/CD (GitHub Actions, GitLab CI) dan mengelola infrastruktur menggunakan Docker, Kubernetes, dan Terraform.
+
+### Instruksi
+- **Otomatisasi Semuanya**: Pastikan pengujian (tests), *linting*, pemformatan, dan pemindaian keamanan berjalan di setiap *Pull Request* (PR). Blokir penggabungan kode (merge) jika *pipeline* gagal.
+- **Artifak Imutabel**: Build *image* Docker satu kali dan *deploy* image yang sama persis ke Staging dan Produksi. Operkan variabel lingkungan (environment variables) secara dinamis saat *runtime*, bukan saat *build time*.
+- **Infrastructure as Code (IaC)**: Simpan semua konfigurasi infrastruktur (Terraform, manifes K8s) di kontrol versi. Hindari perubahan manual melalui *web console* dari penyedia cloud.
+- **Manajemen Rahasia (Secrets)**: Jangan pernah melakukan *commit* untuk *secrets* ke repositori. Gunakan *vault* yang aman seperti GitHub Secrets, AWS Secrets Manager, atau HashiCorp Vault, dan injeksikan dengan aman ke dalam sistem.
+- **Deployment Tanpa Downtime**: Manfaatkan strategi *deployment* seperti pembaruan bergulir (*rolling updates*) atau *blue-green deployments* untuk memastikan ketersediaan aplikasi selama rilis.
+
+### Kondisi Pemicu
+Aktif setiap kali pengguna sedang membuat GitHub Actions, mengkonfigurasi Dockerfile, menulis skrip Terraform, atau mengatur *pipeline deployment*.

package/skills/cloud-hosting-expert/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: cloud-hosting-expert
+description: "Expert guide for deploying SaaS applications with multiple entry points on modern edge and serverless platforms like Vercel and Cloudflare / Panduan ahli untuk mendeploy aplikasi SaaS dengan multiple entry points di platform edge dan serverless modern seperti Vercel dan Cloudflare."
+author: "Roedy Rustam"
+---
+
+# Cloud Hosting Expert (2026 Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+Expert guide for deploying SaaS applications and their multiple entry points (landing page, app, super admin subdomain) on modern edge and serverless platforms. Covers Vercel, Cloudflare Workers & Pages, Railway, Fly.io, and **Cloudflare Workers AI** for AI-powered edge workloads.
+
+### Trigger Conditions
+- Deploying a Next.js, Hono, or Astro application to Vercel, Cloudflare, or Railway.
+- Configuring custom domains and subdomain routing (e.g., `app.domain.com`, `admin.domain.com`).
+- Setting up Edge Middleware for multi-tenant tenant identification.
+- Deploying AI inference workloads to **Cloudflare Workers AI**.
+- Deploying long-running backend services to **Railway** or **Fly.io**.
+- Implementing CDN caching strategies for SaaS applications.
+
+### Platform Selection Guide (2026)
+
+| Platform | Best For | Free Tier | Cold Start |
+|---|---|---|---|
+| **Vercel** | Next.js, static, serverless functions | ✅ | ~200ms |
+| **Cloudflare Workers** | Ultra-low latency APIs, edge logic | ✅ (100k req/day) | ~0ms |
+| **Cloudflare Pages** | Static + full-stack (via Workers) | ✅ | ~0ms |
+| **Railway** | Node.js/Go/Python long-running services, Bun | ✅ (5$/mo credit) | None |
+| **Fly.io** | Docker containers, global distribution | ✅ (3 shared VMs) | ~500ms |
+| **Render** | Node.js/Go/Python persistent services | ✅ (spins down) | ~30s |
+
+### Multi-Entry Point Deployment Architecture
+
+For SaaS applications, separate deployments for each entry point:
+```
+myapp.com         → Vercel (Marketing/Landing — Next.js static)
+app.myapp.com     → Vercel (SaaS App — Next.js dynamic)
+admin.myapp.com   → Vercel (Super Admin — Next.js, restricted access)
+api.myapp.com     → Railway/Fly.io (Backend API — long-running)
+cdn.myapp.com     → Cloudflare R2 (Static assets & user uploads)
+```
+
+### Vercel — Next.js Deployment
+
+#### Multi-Domain Configuration
+```json
+// vercel.json
+{
+  "rewrites": [
+    { "source": "/(.*)", "destination": "/$1" }
+  ],
+  "headers": [
+    {
+      "source": "/(.*)",
+      "headers": [
+        { "key": "X-Content-Type-Options", "value": "nosniff" },
+        { "key": "X-Frame-Options", "value": "DENY" },
+        { "key": "Strict-Transport-Security", "value": "max-age=63072000; includeSubDomains; preload" }
+      ]
+    }
+  ]
+}
+```
+
+#### Edge Middleware for Tenant Routing
+```typescript
+// middleware.ts — runs at the edge before every request
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+
+export function middleware(request: NextRequest) {
+  const hostname = request.headers.get('host') ?? '';
+  const subdomain = hostname.split('.')[0];
+
+  // Route admin subdomain — enforce strict auth check
+  if (subdomain === 'admin') {
+    const adminToken = request.cookies.get('admin-session')?.value;
+    if (!adminToken) {
+      return NextResponse.redirect(new URL('/login', request.url));
+    }
+  }
+
+  // Identify tenant from subdomain for multi-tenant apps
+  if (subdomain !== 'www' && subdomain !== 'app' && subdomain !== 'admin') {
+    const response = NextResponse.next();
+    response.headers.set('x-tenant-slug', subdomain);
+    return response;
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
+};
+```
+
+### Cloudflare Workers — Edge APIs
+
+#### Hono on Cloudflare Workers
+```typescript
+// src/index.ts
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { rateLimit } from '@/middleware/rateLimit';
+
+const app = new Hono<{ Bindings: Env }>();
+
+app.use('*', cors({ origin: ['https://app.myapp.com'] }));
+app.use('/api/*', rateLimit(100)); // 100 req/min via KV
+
+app.get('/api/health', (c) => c.json({ status: 'ok', region: c.env.CF_REGION }));
+
+app.get('/api/data', async (c) => {
+  // Access Cloudflare D1 (SQLite at edge)
+  const result = await c.env.DB.prepare('SELECT * FROM items LIMIT 20').all();
+  return c.json(result.results);
+});
+
+export default app;
+```
+
+#### Cloudflare Workers AI (On-Device Edge Inference)
+Run AI models directly at Cloudflare's edge — no external API calls needed:
+```typescript
+export default {
+  async fetch(request: Request, env: Env) {
+    const { text } = await request.json() as { text: string };
+
+    // Run Llama 3 or Mistral at the edge
+    const response = await env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
+      messages: [
+        { role: 'system', content: 'You are a helpful assistant.' },
+        { role: 'user', content: text }
+      ],
+      stream: true,
+    });
+
+    return new Response(response, {
+      headers: { 'Content-Type': 'text/event-stream' }
+    });
+  }
+};
+```
+
+Available models on Workers AI:
+- `@cf/meta/llama-3.1-8b-instruct` — Fast general-purpose chat
+- `@cf/mistral/mistral-7b-instruct-v0.2` — Fast instruction model
+- `@cf/baai/bge-small-en-v1.5` — Text embedding (for RAG)
+- `@cf/stabilityai/stable-diffusion-xl-base-1.0` — Image generation
+
+### Railway — Bun / Node.js Long-Running Services
+```dockerfile
+# Dockerfile for Railway (Bun runtime)
+FROM oven/bun:1.2-alpine
+WORKDIR /app
+COPY package.json bun.lockb ./
+RUN bun install --frozen-lockfile
+COPY . .
+EXPOSE 3000
+CMD ["bun", "run", "src/server.ts"]
+```
+
+```toml
+# railway.toml
+[build]
+builder = "DOCKERFILE"
+
+[deploy]
+startCommand = "bun run src/server.ts"
+healthcheckPath = "/health"
+healthcheckTimeout = 10
+restartPolicyType = "ON_FAILURE"
+```
+
+### Environment Variables & Secrets Management
+- **Vercel**: Use Vercel's built-in secrets panel — supports preview/production scoping.
+- **Cloudflare**: Use `wrangler secret put SECRET_NAME` or the dashboard.
+- **Railway**: Use Railway's variable groups for shared secrets across services.
+- **Never** commit `.env` files — use `.env.example` as documentation only.
+
+### Caching Strategy
+```typescript
+// Vercel: Cache API responses at the edge
+export async function GET() {
+  const data = await fetchData();
+  return Response.json(data, {
+    headers: {
+      'Cache-Control': 'public, s-maxage=60, stale-while-revalidate=300',
+    }
+  });
+}
+
+// Cloudflare: Use Cache API
+const cache = caches.default;
+const cached = await cache.match(request);
+if (cached) return cached;
+```
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan ahli untuk men-deploy aplikasi SaaS dan multiple entry points-nya (landing page, aplikasi, subdomain super admin) di platform edge dan serverless modern. Mencakup Vercel, Cloudflare Workers & Pages, Railway, Fly.io, dan **Cloudflare Workers AI** untuk workload AI di edge.
+
+### Kondisi Pemicu
+- Men-deploy aplikasi Next.js, Hono, atau Astro ke Vercel, Cloudflare, atau Railway.
+- Mengonfigurasi domain kustom dan routing subdomain.
+- Menyiapkan Edge Middleware untuk identifikasi tenant multi-tenant.
+- Men-deploy workload inferensi AI ke **Cloudflare Workers AI**.
+- Men-deploy layanan backend long-running ke **Railway** atau **Fly.io**.
+
+### Panduan Pemilihan Platform (2026)
+
+Pilih Vercel untuk Next.js dan aplikasi full-stack. Cloudflare Workers untuk API dengan latensi ultra-rendah dan logika edge. Railway/Fly.io untuk layanan backend long-running (Node.js, Bun, Go, Python). Cloudflare R2 untuk penyimpanan objek (pengganti S3 yang lebih murah).
+
+### Arsitektur Deployment Multi-Entry Point
+
+Pisahkan deployment untuk setiap entry point SaaS:
+- `domain.com` → Landing page (Vercel, statis)
+- `app.domain.com` → Aplikasi SaaS (Vercel, dinamis)
+- `admin.domain.com` → Dashboard Super Admin (Vercel, akses terbatas)
+- `api.domain.com` → Backend API (Railway/Fly.io, long-running)
+- `cdn.domain.com` → Aset statis & upload pengguna (Cloudflare R2)
+
+### Edge Middleware (Vercel)
+Gunakan `middleware.ts` untuk routing tenant berdasarkan subdomain dan perlindungan rute admin — berjalan di edge sebelum setiap permintaan.
+
+### Cloudflare Workers AI
+Jalankan model AI (Llama 3.1, Mistral, BGE embedding) langsung di edge Cloudflare — tanpa panggilan API eksternal, latensi sangat rendah, dan ditagih per token.
+
+### Railway — Layanan Long-Running
+Gunakan Railway untuk backend yang tidak cocok dengan model serverless (WebSocket, background job, koneksi database persisten). Mendukung Bun, Node.js, Go, Python, Rust dengan deployment otomatis dari GitHub.
+
+### Manajemen Environment Variable & Secret
+Gunakan panel secret bawaan di masing-masing platform. Jangan pernah commit file `.env` — gunakan `.env.example` sebagai dokumentasi saja.

package/skills/coderabbit/SKILL.md

@@ -0,0 +1,192 @@
+---
+name: coderabbit
+description: "AI-powered automated code review, PR summarization, and interactive developer feedback / Review kode otomatis berbasis AI, ringkasan PR, dan umpan balik developer interaktif."
+author: "Roedy Rustam"
+---
+
+# CodeRabbit (2026 Edition — CodeRabbit 2.x)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+Expert guide for configuring and leveraging **CodeRabbit 2.x** — AI-powered automated code review, pull request summarization, and interactive developer feedback. Covers configuration, custom review rules, integration with CI/CD, and agentic review mode.
+
+### Trigger Conditions
+- Setting up CodeRabbit on a GitHub or GitLab repository.
+- Configuring custom review rules for your tech stack.
+- Using CodeRabbit's agentic mode for deep architectural reviews.
+- Integrating CodeRabbit feedback into CI/CD quality gates.
+- Writing CodeRabbit-compatible custom instructions in `.coderabbit.yaml`.
+
+### CodeRabbit 2.x Key Features
+
+| Feature | Description |
+|---|---|
+| **PR Summary** | Auto-generates structured PR description with walkthrough |
+| **Line-by-line Review** | Inline comments with specific fix suggestions |
+| **Agentic Review** | Deep analysis spanning multiple files for architectural issues |
+| **Learnable Rules** | Learns from review dismissals and approvals over time |
+| **CI Integration** | Blocks PR merge if critical issues found |
+| **Chat Mode** | Ask CodeRabbit questions about the PR in review thread |
+
+### Configuration (`.coderabbit.yaml`)
+
+```yaml
+# .coderabbit.yaml — place in repository root
+version: "2"
+language: "en-US"
+tone_instructions: "Be concise and direct. Prioritize security and performance issues."
+
+reviews:
+  auto_review:
+    enabled: true
+    drafts: false           # Don't review draft PRs
+    base_branches: ["main", "develop"]
+
+  profile: "chill"          # assertive | chill | default
+  request_changes_workflow: false
+  high_level_summary: true
+  commit_message_instructions: "Use Conventional Commits format: feat/fix/chore/docs"
+
+  # Ignore paths from review
+  path_filters:
+    - "!**/*.lock"
+    - "!**/migrations/**"
+    - "!**/generated/**"
+    - "!**/__snapshots__/**"
+
+  # Stack-specific review instructions
+  path_instructions:
+    - path: "apps/api/**"
+      instructions: |
+        - Check for missing input validation (Zod schemas required on all handlers)
+        - Flag any database queries without proper RLS consideration
+        - Ensure all async functions have try/catch or error boundaries
+        - Check for N+1 query patterns (missing .include() or DataLoader usage)
+    - path: "apps/web/**"
+      instructions: |
+        - Check for missing `key` props in .map() renders
+        - Flag `useEffect` without proper cleanup functions
+        - Check for missing `alt` attributes on images
+        - Verify Server Actions are properly validated with Zod
+    - path: "apps/admin/**"
+      instructions: |
+        - All admin routes must verify isSuperAdmin === true
+        - Flag any direct DB access without service role client
+        - Check for proper audit logging on destructive operations
+
+  # Custom review rules for the entire codebase
+  instructions: |
+    Review with these priorities:
+    1. SECURITY: SQL injection, XSS, auth bypass, exposed secrets
+    2. CORRECTNESS: Logic bugs, off-by-one errors, type unsafety
+    3. PERFORMANCE: N+1 queries, unnecessary re-renders, bundle size
+    4. MAINTAINABILITY: Code duplication, naming, SOLID violations
+    5. STYLE: Only comment if it's a significant clarity issue
+
+# PR summary format
+summary:
+  auto_title_placeholder: "🤖 AI Title"
+  description: |-
+    ## Summary
+    <!-- Concise description of what changed -->
+    
+    ## Changes
+    <!-- Structured list by area -->
+    
+    ## Testing
+    <!-- What was tested -->
+
+# Enable chat for interactive Q&A
+chat:
+  auto_reply: true
+```
+
+### Agentic Review Mode (CodeRabbit 2.x)
+CodeRabbit 2.x introduces **agentic review** — deep analysis that can read multiple files, run tools, and understand architectural context:
+
+```
+# Trigger agentic review in PR comment:
+@coderabbitai review
+
+# Ask specific questions:
+@coderabbitai What is the security impact of changes in apps/api/src/routes/users.ts?
+@coderabbitai Can you generate a test for the createWorkspace function?
+@coderabbitai Is there a N+1 query issue in this PR?
+@coderabbitai Summarize the architecture changes in this PR
+```
+
+### CI/CD Integration (GitHub Actions)
+```yaml
+# .github/workflows/pr-quality.yml
+name: PR Quality Gate
+
+on: [pull_request]
+
+jobs:
+  coderabbit-review:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Wait for CodeRabbit Review
+        uses: coderabbit-ai/wait-for-review@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          min-approvals: 1
+          block-on-critical: true  # Block merge if critical issues found
+```
+
+### CodeRabbit vs Manual Review — Best Practices
+- **CodeRabbit first**: Let it run before human reviewers — catches the obvious issues.
+- **Human focus**: After CodeRabbit, humans focus on business logic, architecture intent, and product decisions.
+- **Teach it**: Dismiss false positives with an explanation — CodeRabbit learns your patterns.
+- **Custom instructions**: Invest time in `path_instructions` for your specific stack — dramatically improves relevance.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan ahli untuk mengonfigurasi dan memanfaatkan **CodeRabbit 2.x** — review kode otomatis bertenaga AI, ringkasan pull request, dan umpan balik developer interaktif. Mencakup konfigurasi, aturan review kustom, integrasi dengan CI/CD, dan mode review agentik.
+
+### Kondisi Pemicu
+- Menyiapkan CodeRabbit di repositori GitHub atau GitLab.
+- Mengonfigurasi aturan review kustom untuk tech stack Anda.
+- Menggunakan mode agentik CodeRabbit untuk review arsitektur mendalam.
+- Mengintegrasikan umpan balik CodeRabbit ke dalam quality gate CI/CD.
+- Menulis instruksi kustom yang kompatibel dengan CodeRabbit di `.coderabbit.yaml`.
+
+### Fitur Utama CodeRabbit 2.x
+
+| Fitur | Deskripsi |
+|---|---|
+| **Ringkasan PR** | Membuat deskripsi PR terstruktur otomatis dengan walkthrough |
+| **Review Baris per Baris** | Komentar inline dengan saran perbaikan spesifik |
+| **Review Agentik** | Analisis mendalam yang mencakup banyak file untuk masalah arsitektur |
+| **Aturan yang Dapat Dipelajari** | Belajar dari penolakan dan persetujuan review dari waktu ke waktu |
+| **Integrasi CI** | Memblokir merge PR jika masalah kritis ditemukan |
+| **Mode Chat** | Tanyakan pertanyaan kepada CodeRabbit di thread review |
+
+### Konfigurasi (`.coderabbit.yaml`)
+Tempatkan `.coderabbit.yaml` di root repositori. Konfigurasi kunci:
+- `reviews.profile`: `assertive` (ketat), `chill` (santai), `default`.
+- `reviews.path_instructions`: Instruksi review kustom per direktori — sangat berguna untuk menerapkan standar spesifik stack.
+- `reviews.path_filters`: Kecualikan file lock, migrasi, kode yang dihasilkan dari review.
+- `reviews.instructions`: Aturan global untuk seluruh codebase dengan prioritas eksplisit.
+
+### Mode Review Agentik (CodeRabbit 2.x)
+Mode agentik memungkinkan CodeRabbit membaca banyak file, menjalankan tool, dan memahami konteks arsitektur. Picu dengan `@coderabbitai review` di komentar PR atau ajukan pertanyaan spesifik tentang dampak keamanan, masalah N+1, atau perubahan arsitektur.
+
+### Integrasi CI/CD (GitHub Actions)
+Gunakan action `coderabbit-ai/wait-for-review@v1` untuk menunggu review selesai dan memblokir merge jika masalah kritis ditemukan.
+
+### CodeRabbit vs Review Manual — Best Practices
+- **CodeRabbit dulu**: Biarkan berjalan sebelum reviewer manusia — menangkap masalah yang jelas.
+- **Fokus manusia**: Setelah CodeRabbit, manusia fokus pada logika bisnis, niat arsitektur, dan keputusan produk.
+- **Ajarkan**: Tolak false positive dengan penjelasan — CodeRabbit belajar pola Anda.
+- **Instruksi kustom**: Investasikan waktu di `path_instructions` untuk stack spesifik Anda — meningkatkan relevansi secara dramatis.