@riligar/agents-kit 1.15.0 → 1.17.0

package/.agent/skills/riligar-dev-database/references/queries.md

@@ -0,0 +1,173 @@
+# Queries — Drizzle
+
+## Imports Comuns
+
+```javascript
+import { db } from '../database/db'
+import { users, posts } from '../database/schema'
+import { eq, and, or, desc, asc } from 'drizzle-orm'
+```
+
+## Select
+
+### Básico
+
+```javascript
+// Todos os registros
+const allUsers = await db.select().from(users)
+
+// Campos específicos
+const names = await db.select({
+    id: users.id,
+    name: users.name,
+}).from(users)
+```
+
+### Filtrar
+
+```javascript
+// Por campo único
+const [user] = await db.select().from(users).where(eq(users.id, userId)).limit(1)
+
+// Múltiplos filtros (AND)
+const results = await db.select().from(users).where(
+    and(
+        eq(users.active, true),
+        eq(users.plan, 'pro')
+    )
+)
+
+// OR
+const results = await db.select().from(users).where(
+    or(eq(users.id, '1'), eq(users.id, '2'))
+)
+```
+
+### Ordenar e Paginar
+
+```javascript
+const page = await db.select().from(posts)
+    .orderBy(desc(posts.createdAt))
+    .limit(10)
+    .offset(pageIndex * 10)
+```
+
+## Insert
+
+```javascript
+// Básico
+await db.insert(users).values({ name: 'Dan', email: 'dan@email.com' })
+
+// Com retorno
+const [user] = await db.insert(users)
+    .values({ name: 'Dan', email: 'dan@email.com' })
+    .returning()
+
+// Múltiplos
+await db.insert(users).values([
+    { name: 'Dan', email: 'dan@email.com' },
+    { name: 'Ana', email: 'ana@email.com' },
+])
+
+// Upsert (conflict handling)
+await db.insert(users)
+    .values({ id: '1', name: 'Dan' })
+    .onConflictDoUpdate({
+        target: users.id,
+        set: { name: 'Dan', updatedAt: new Date() },
+    })
+```
+
+## Update
+
+```javascript
+await db.update(users)
+    .set({ name: 'Mr. Dan', updatedAt: new Date() })
+    .where(eq(users.id, userId))
+
+// Com retorno
+const [updated] = await db.update(users)
+    .set({ plan: 'pro' })
+    .where(eq(users.id, userId))
+    .returning()
+```
+
+## Delete
+
+```javascript
+await db.delete(users).where(eq(users.id, userId))
+
+// Com retorno
+const [deleted] = await db.delete(users)
+    .where(eq(users.id, userId))
+    .returning()
+```
+
+## Queries com Relações
+
+Quando tiver relações definidas no schema, use `db.query` em vez de `db.select`:
+
+```javascript
+// Usuário com todos os posts
+const user = await db.query.users.findOne({
+    where: eq(users.id, userId),
+    with: {
+        posts: true,
+    },
+})
+
+// Posts com autor
+const posts = await db.query.posts.findMany({
+    with: {
+        author: true,
+    },
+    orderBy: desc(posts.createdAt),
+    limit: 10,
+})
+
+// Nesting profundo
+const user = await db.query.users.findOne({
+    where: eq(users.id, userId),
+    with: {
+        posts: {
+            with: {
+                comments: true,
+            },
+        },
+    },
+})
+```
+
+## Padrão de Serviço
+
+Sempre encapsule queries em serviços:
+
+```javascript
+// services/user.js
+import { db } from '../database/db'
+import { users } from '../database/schema'
+import { eq } from 'drizzle-orm'
+
+export async function getUserById(id) {
+    const [user] = await db.select().from(users).where(eq(users.id, id)).limit(1)
+    return user ?? null
+}
+
+export async function createUser(data) {
+    const [user] = await db.insert(users).values(data).returning()
+    return user
+}
+
+export async function updateUser(id, data) {
+    const [user] = await db.update(users)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(users.id, id))
+        .returning()
+    return user ?? null
+}
+
+export async function deleteUser(id) {
+    const [user] = await db.delete(users).where(eq(users.id, id)).returning()
+    return user ?? null
+}
+```

package/.agent/skills/riligar-dev-database/references/schema.md

@@ -0,0 +1,106 @@
+# Schema — Drizzle SQLite
+
+## Definição Básica
+
+```javascript
+// database/schema.js
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'
+import { relations } from 'drizzle-orm'
+
+export const users = sqliteTable('users', {
+    id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+    email: text('email').notNull().unique(),
+    name: text('name'),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+    updatedAt: integer('updated_at', { mode: 'timestamp' }),
+})
+```
+
+## Tipos de Colunas
+
+| Tipo | Uso | Exemplo |
+| --- | --- | --- |
+| `text()` | Strings, UUIDs, JSON | `text('name').notNull()` |
+| `integer()` | Números, booleans, timestamps | `integer('age')` |
+| `real()` | Decimais (float) | `real('price')` |
+| `blob()` | Dados binários | `blob('avatar')` |
+| `numeric()` | Valores numéricos precisos | `numeric('amount')` |
+
+### Modes do `integer()`
+
+```javascript
+integer('count')                                // número
+integer('active', { mode: 'boolean' })          // boolean (0/1)
+integer('created_at', { mode: 'timestamp' })    // Date (segundos)
+integer('created_at', { mode: 'timestamp_ms' }) // Date (milissegundos)
+```
+
+### JSON via `text()`
+
+```javascript
+text('metadata', { mode: 'json' })  // armazena JSON como text
+```
+
+## Primary Key
+
+```javascript
+// UUID (padrão RiLiGar)
+id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+
+// Auto-increment (quando necessário)
+id: integer('id').primaryKey({ autoIncrement: true }),
+```
+
+## Foreign Keys
+
+```javascript
+export const posts = sqliteTable('posts', {
+    id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+    authorId: text('author_id').notNull().references(() => users.id),
+    title: text('title').notNull(),
+    body: text('body'),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+})
+```
+
+## Relações
+
+Relações são definidas separadamente do schema — são apenas para queries, não afetam o banco:
+
+```javascript
+export const usersRelations = relations(users, ({ many }) => ({
+    posts: many(posts),
+}))
+
+export const postsRelations = relations(posts, ({ one }) => ({
+    author: one(users, {
+        fields: [posts.authorId],
+        references: [users.id],
+    }),
+}))
+```
+
+### Many-to-Many (via junction table)
+
+```javascript
+export const usersToGroups = sqliteTable('users_to_groups', {
+    userId: text('user_id').notNull().references(() => users.id),
+    groupId: text('group_id').notNull().references(() => groups.id),
+})
+
+export const usersRelations = relations(users, ({ many }) => ({
+    groups: many(usersToGroups),
+}))
+
+export const groupsRelations = relations(groups, ({ many }) => ({
+    users: many(usersToGroups),
+}))
+```
+
+## Defaults e Constraints
+
+```javascript
+plan: text('plan').default('free'),
+active: integer('active', { mode: 'boolean' }).default(true),
+createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+```

package/.agent/skills/riligar-dev-manager/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: riligar-dev-backend
+name: riligar-dev-manager
 description: Elysia backend development patterns for Bun. Use when building APIs, routes, plugins, validation, middleware, and error handling with Elysia framework.
 ---
 
@@ -10,10 +10,7 @@ description: Elysia backend development patterns for Bun. Use when building APIs
 ## Mandatory Guidelines
 
 > [!IMPORTANT]
-> All work in this skill MUST adhere to:
->
-> - @[.agent/skills/riligar-dev-clean-code] (Clean Code Standards)
-> - @[.agent/skills/riligar-tech-stack] (Tech Stack - Bun, Elysia, SQLite, Drizzle)
+> All work in this skill MUST adhere to rules em `.agent/rules/` — clean-code, code-style, javascript-only, naming-conventions.
 
 ## Quick Reference
 
@@ -62,6 +59,16 @@ src/
     └── logger.js      # Request logging
 ```
 
+## Dependencies
+
+| Pacote | Versão | Descrição |
+|---|---|---|
+| `bun` | latest | Runtime |
+| `elysia` | latest | Framework HTTP |
+| `bun:sqlite` | builtin | SQLite driver |
+| `drizzle-orm` | latest | ORM |
+| `bun:s3` | latest | S3/R2 Storage |
+
 ## Core Patterns
 
 ### Route Plugin
@@ -109,9 +116,7 @@ console.log(`Server running at ${app.server?.url}`)
 | --- | --- |
 | **Authentication** | @[.agent/skills/riligar-dev-auth-elysia] |
 | **Database** | @[.agent/skills/riligar-dev-database] |
-| **Tech Stack** | @[.agent/skills/riligar-tech-stack] |
-| **Clean Code** | @[.agent/skills/riligar-dev-clean-code] |
-| **Infrastructure** | @[.agent/skills/riligar-infrastructure] |
+| **Infrastructure** | @[.agent/skills/riligar-infra-fly] |
 
 ## Decision Checklist
 

package/.agent/skills/riligar-dev-website/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: riligar-dev-landing-page
+name: riligar-dev-website
 description: Specialist in High-Conversion Landing Pages using RiLiGar Design System. Use for: (1) Creating marketing/sales pages, (2) Structuring conversion flows (AIDA/PAS), (3) Implementing high-trust components (Hero, Social Proof, Pricing), (4) Writing persuasive copy.
 ---
 

package/.agent/skills/riligar-dev-website-seo/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: riligar-dev-seo
+name: riligar-dev-website-seo
 description: Implementação de infraestrutura de SEO técnico seguindo a stack RiLiGar (React, Vite, Bun, Elysia). Use para configurar sitemaps, robots.txt, meta tags, OpenGraph, dados estruturados (JSON-LD) e URLs canônicas.
 ---
 

package/.agent/skills/riligar-infra-cloudfare/SKILL.md

@@ -0,0 +1,350 @@
+---
+name: riligar-infra-cloudfare
+description: "Setup domains in Cloudflare with DNS, email routing, and R2 storage. Use when adding new domains, configuring DNS records, or setting up email redirects."
+---
+
+# Cloudflare Setup
+
+Automate Cloudflare workflows: DNS setup, email routing, and R2 storage.
+
+## Prerequisites
+
+### Authentication (Choose One)
+
+**Option 1: API Token (Recommended)**
+```bash
+# Add to .env.local
+CLOUDFLARE_API_TOKEN="your-api-token"
+CLOUDFLARE_ACCOUNT_ID="your-account-id"
+```
+
+Create token at: https://dash.cloudflare.com/profile/api-tokens
+Required permissions:
+- Zone:DNS:Edit
+- Zone:Zone:Read
+- Email Routing Addresses:Edit
+- Email Routing Rules:Edit
+- Account:R2:Edit (for R2 storage)
+
+**Option 2: Wrangler CLI**
+```bash
+# Install wrangler
+bun add -g wrangler
+
+# Login (opens browser)
+wrangler login
+
+# Verify
+wrangler whoami
+```
+
+## Workflow
+
+When setting up a new domain, follow these steps:
+
+### Step 1: Gather Information
+
+Ask the user for:
+1. **Domain name** (e.g., `example.com`)
+2. **Email addresses** to create (e.g., `contact`, `support`)
+3. **Redirect target email** (e.g., `me@gmail.com`)
+
+### Step 2: Get Zone ID
+
+```bash
+# If using API token
+curl -X GET "https://api.cloudflare.com/client/v4/zones?name=DOMAIN" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
+  -H "Content-Type: application/json" | jq '.result[0].id'
+
+# If using wrangler
+wrangler pages project list  # Shows associated zones
+```
+
+### Step 3: Setup Email Routing
+
+First, enable email routing for the zone (do this in Cloudflare dashboard first time).
+
+Then create routing rules:
+
+```bash
+# Create destination address (must be verified first)
+curl -X POST "https://api.cloudflare.com/client/v4/accounts/ACCOUNT_ID/email/routing/addresses" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  --data '{
+    "email": "your-main-email@gmail.com"
+  }'
+
+# Create routing rule for contact@domain.com
+curl -X POST "https://api.cloudflare.com/client/v4/zones/ZONE_ID/email/routing/rules" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  --data '{
+    "name": "Forward contact",
+    "enabled": true,
+    "matchers": [{"type": "literal", "field": "to", "value": "contact@DOMAIN"}],
+    "actions": [{"type": "forward", "value": ["your-main-email@gmail.com"]}]
+  }'
+```
+
+Required MX records for email routing:
+```bash
+# MX records for Cloudflare Email Routing
+curl -X POST "https://api.cloudflare.com/client/v4/zones/ZONE_ID/dns_records" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  --data '{
+    "type": "MX",
+    "name": "@",
+    "content": "route1.mx.cloudflare.net",
+    "priority": 69,
+    "ttl": 1
+  }'
+
+curl -X POST "https://api.cloudflare.com/client/v4/zones/ZONE_ID/dns_records" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  --data '{
+    "type": "MX",
+    "name": "@",
+    "content": "route2.mx.cloudflare.net",
+    "priority": 46,
+    "ttl": 1
+  }'
+
+curl -X POST "https://api.cloudflare.com/client/v4/zones/ZONE_ID/dns_records" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  --data '{
+    "type": "MX",
+    "name": "@",
+    "content": "route3.mx.cloudflare.net",
+    "priority": 89,
+    "ttl": 1
+  }'
+
+# TXT record for SPF
+curl -X POST "https://api.cloudflare.com/client/v4/zones/ZONE_ID/dns_records" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  --data '{
+    "type": "TXT",
+    "name": "@",
+    "content": "v=spf1 include:_spf.mx.cloudflare.net ~all",
+    "ttl": 1
+  }'
+```
+
+### Step 4: Verification Checklist
+
+After setup, verify:
+
+```bash
+# List all DNS records
+curl -X GET "https://api.cloudflare.com/client/v4/zones/ZONE_ID/dns_records" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" | jq '.result[] | {type, name, content}'
+
+# Test email routing (send test email to contact@DOMAIN)
+```
+
+## Interactive Prompts Template
+
+When running `/cloudflare`, ask:
+
+```
+What domain are you setting up?
+> example.com
+
+What email addresses should I create? (comma-separated)
+> contact, support, hello
+
+What email should these redirect to?
+> myemail@gmail.com
+```
+
+## Common DNS Record Types
+
+| Type | Use Case | Proxied |
+|------|----------|---------|
+| A | Root domain to IP | Yes (production) |
+| CNAME | Subdomain to hostname | Yes (production) |
+| TXT | Verification, SPF | N/A |
+| MX | Email routing | N/A |
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| Zone not found | Domain must be added to Cloudflare first |
+| DNS propagation slow | Wait 5-10 minutes, check with `dig` |
+| Email not forwarding | Verify destination email first |
+
+## Useful Commands
+
+```bash
+# Check DNS propagation
+dig DOMAIN +short
+dig DOMAIN MX +short
+dig DOMAIN TXT +short
+
+# List zones in account
+curl -X GET "https://api.cloudflare.com/client/v4/zones" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" | jq '.result[] | {name, id}'
+
+# Delete a DNS record
+curl -X DELETE "https://api.cloudflare.com/client/v4/zones/ZONE_ID/dns_records/RECORD_ID" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN"
+```
+
+---
+
+# R2 Storage Setup
+
+Setup R2 buckets for file storage: user uploads, static assets, backups.
+
+## R2 Workflow
+
+### Step 1: Determine Use Case
+
+Ask the user:
+```
+What do you want to do with R2?
+1. Create new bucket (full setup)
+2. Configure existing bucket (CORS, public access)
+3. Setup custom domain for bucket
+```
+
+### Step 2: Gather Bucket Info
+
+```
+Bucket name?
+> my-app-uploads
+
+What will this bucket store?
+1. User uploads (images, files) - needs CORS + presigned URLs
+2. Static assets (public CDN) - needs public access
+3. Backups (private) - no public access
+> 1
+
+Custom domain? (optional, press enter to skip)
+> uploads.myapp.com
+```
+
+### Step 3: Create Bucket
+
+```bash
+# Create bucket via wrangler
+wrangler r2 bucket create my-app-uploads
+
+# Or via API
+curl -X PUT "https://api.cloudflare.com/client/v4/accounts/{account_id}/r2/buckets" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  --data '{"name": "my-app-uploads", "locationHint": "wnam"}'
+```
+
+### Step 4: Configure CORS (for user uploads)
+
+Create `cors.json`:
+```json
+{
+  "corsRules": [
+    {
+      "allowedOrigins": ["https://myapp.com", "http://localhost:3000"],
+      "allowedMethods": ["GET", "PUT", "POST", "DELETE", "HEAD"],
+      "allowedHeaders": ["*"],
+      "exposeHeaders": ["ETag", "Content-Length"],
+      "maxAgeSeconds": 3600
+    }
+  ]
+}
+```
+
+Apply CORS:
+```bash
+wrangler r2 bucket cors put my-app-uploads --file=cors.json
+```
+
+### Step 5: Setup Public Access (for static assets)
+
+Option A: Enable R2.dev subdomain (via dashboard)
+- Go to R2 > Bucket > Settings > Public access
+
+Option B: Custom domain:
+```bash
+# Add CNAME record
+curl -X POST "https://api.cloudflare.com/client/v4/zones/ZONE_ID/dns_records" \
+  -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  --data '{
+    "type": "CNAME",
+    "name": "uploads",
+    "content": "{account_id}.r2.cloudflarestorage.com",
+    "ttl": 1,
+    "proxied": true
+  }'
+```
+
+Then enable custom domain in R2 bucket settings.
+
+### Step 6: Generate S3 API Credentials (for SDK access)
+
+1. Go to R2 > Manage R2 API Tokens
+2. Create token with Object Read & Write
+3. Add to `.env.local`:
+
+```bash
+R2_ACCESS_KEY_ID="your-access-key"
+R2_SECRET_ACCESS_KEY="your-secret-key"
+R2_ENDPOINT="https://{account_id}.r2.cloudflarestorage.com"
+R2_BUCKET_NAME="my-app-uploads"
+```
+
+## R2 Quick Commands
+
+```bash
+# List buckets
+wrangler r2 bucket list
+
+# Create bucket
+wrangler r2 bucket create BUCKET_NAME
+
+# Delete bucket
+wrangler r2 bucket delete BUCKET_NAME
+
+# List objects
+wrangler r2 object list BUCKET_NAME
+
+# Upload file
+wrangler r2 object put BUCKET_NAME/path/file.png --file=./local.png
+
+# View CORS config
+wrangler r2 bucket cors get BUCKET_NAME
+```
+
+## R2 Use Case Presets
+
+| Use Case | CORS | Public | Custom Domain |
+|----------|------|--------|---------------|
+| User uploads | Yes | No | Optional |
+| Static assets/CDN | No | Yes | Recommended |
+| Backups | No | No | No |
+| Public downloads | No | Yes | Optional |
+
+## R2 Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| CORS error in browser | Add domain to allowedOrigins |
+| 403 Forbidden | Check API token has R2:Edit permission |
+| Custom domain not working | Ensure CNAME is proxied (orange cloud) |
+| Upload fails | Verify Content-Type header matches file |
+
+---
+
+## References
+
+- **[Cloudflare API Reference](references/cloudflare-api.md)**: Auth tokens, zone operations, DNS endpoints
+- **[Email Routing](references/email-routing.md)**: Email forwarding setup and configuration
+- **[R2 Storage](references/r2-storage.md)**: Bucket management, CORS, presigned URLs