@riligar/agents-kit 1.16.0 → 1.17.0

package/.agent/skills/riligar-design-system/references/design-system.md

@@ -104,10 +104,3 @@ Ao pedir código ou design para uma IA, use este formato:
 - **Modais:** Devem ter um backdrop com blur (`backdrop-blur-sm`) e fundo branco sólido. Sem cabeçalhos coloridos.
 - **Dashboards:** Devem privilegiar números grandes (Big Numbers) em monocromia, com rótulos pequenos abaixo. Gráficos devem ser limpos, sem grid lines pesadas.
 
----
-
-## 🤖 Integração com Gemini CLI
-
-Este repositório possui uma **Skill do Gemini CLI** configurada em [`riligar-design-system/SKILL.md`](../SKILL.md). Ao usar o Gemini CLI neste repositório, o agente aplicará automaticamente estas diretrizes a qualquer código ou design gerado.
-
-Para saber como usar, veja o [README principal](../../README.md).

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

@@ -0,0 +1,45 @@
+---
+name: riligar-dev-database
+description: Database patterns for RiLiGar using Drizzle ORM + bun:sqlite. Use when setting up database connections, defining schemas, creating migrations, or writing queries. Covers SQLite on Fly.io volumes with the drizzle-kit workflow.
+---
+
+# Database — Drizzle + bun:sqlite
+
+> SQLite nativo no Bun. Zero drivers externos. Base de dados no volume do Fly.io (`/app/data`).
+
+## Referências
+
+| Arquivo | Quando usar |
+| --- | --- |
+| [connection.md](references/connection.md) | Setup inicial: instalação, db.js, drizzle.config |
+| [schema.md](references/schema.md) | Definir tabelas, tipos de colunas, relações |
+| [migrations.md](references/migrations.md) | Criar e executar migrations com drizzle-kit |
+| [queries.md](references/queries.md) | Select, insert, update, delete, queries com relações |
+
+## Quick Start
+
+```javascript
+// database/db.js
+import { drizzle } from 'drizzle-orm/bun-sqlite'
+import Database from 'bun:sqlite'
+
+const sqlite = new Database(process.env.DB_PATH ?? './data/database.db')
+const db = drizzle({ client: sqlite })
+
+export { db }
+```
+
+## Regras
+
+- **Caminho do banco:** `/app/data/database.db` em produção (volume Fly.io). `./data/database.db` em desenvolvimento.
+- **Migrations sempre:** Use `drizzle-kit generate` + `drizzle-kit migrate`. Nunca edite migrations à mão.
+- **Schema único:** Todas as tabelas em `database/schema.js`.
+- **Migrations no startup:** Use `migrate()` no `index.js` antes de `.listen()`.
+
+## Related Skills
+
+| Need | Skill |
+| --- | --- |
+| **Backend (Elysia)** | @[.agent/skills/riligar-dev-manager] |
+| **Payments (Stripe)** | @[.agent/skills/riligar-infra-stripe] |
+| **Infrastructure** | @[.agent/skills/riligar-infra-fly] |

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

@@ -0,0 +1,74 @@
+# Database Connection
+
+## Installation
+
+```bash
+bun add drizzle-orm
+bun add -d drizzle-kit
+```
+
+No additional drivers needed — `bun:sqlite` is built into Bun.
+
+## db.js
+
+```javascript
+// database/db.js
+import { drizzle } from 'drizzle-orm/bun-sqlite'
+import Database from 'bun:sqlite'
+
+const sqlite = new Database(process.env.DB_PATH ?? './data/database.db')
+const db = drizzle({ client: sqlite })
+
+export { db }
+```
+
+- Em **desenvolvimento**: `DB_PATH` não é definido → usa `./data/database.db`
+- Em **produção** (Fly.io): `fly secrets set DB_PATH=/app/data/database.db`
+
+## drizzle.config.js
+
+```javascript
+// drizzle.config.js (na raiz do projeto)
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+    dialect: 'sqlite',
+    schema: './database/schema.js',
+    out: './database/migrations',
+    dbCredentials: {
+        url: process.env.DB_PATH ?? './data/database.db',
+    },
+})
+```
+
+## Migrations no Startup
+
+No `index.js`, execute migrations antes de iniciar o servidor:
+
+```javascript
+// index.js
+import { migrate } from 'drizzle-orm/bun-sqlite/migrator'
+import { db } from './database/db'
+
+await migrate(db, { migrationsFolder: './database/migrations' })
+
+// ... resto do setup
+const app = new Elysia()
+    .use(routes)
+    .listen(3000)
+```
+
+Isso garante que o banco esteja sempre atualizado quando o servidor inicia no Fly.io.
+
+## Estrutura de Arquivos
+
+```
+database/
+├── db.js              # Conexão (drizzle + bun:sqlite)
+├── schema.js          # Todas as tabelas e relações
+└── migrations/
+    ├── 0000_*.sql     # Migrations geradas pelo drizzle-kit
+    ├── 0001_*.sql
+    └── meta/
+        └── _journal.json
+```

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

@@ -0,0 +1,70 @@
+# Migrations — drizzle-kit
+
+## Fluxo Padrão
+
+```
+1. Edite database/schema.js
+2. bun run db:generate    → gera migration SQL
+3. bun run db:migrate     → aplica no banco
+```
+
+## Scripts no package.json
+
+```javascript
+{
+    "scripts": {
+        "db:generate": "drizzle-kit generate",
+        "db:migrate": "drizzle-kit migrate",
+        "db:push": "drizzle-kit push",
+        "db:studio": "drizzle-kit studio"
+    }
+}
+```
+
+## Comandos
+
+### Gerar migration
+
+```bash
+bun run db:generate
+```
+
+Compara o schema atual com o último snapshot. Gera um arquivo `.sql` em `database/migrations/`. Pergunta se algum campo foi renomeado (vs criado novo + deletado).
+
+### Aplicar migrations
+
+```bash
+bun run db:migrate
+```
+
+Lê as migrations não aplicadas, executa em ordem. Mantém histórico no banco.
+
+### Push (apenas desenvolvimento)
+
+```bash
+bun run db:push
+```
+
+Aplica mudanças diretamente no banco sem gerar arquivos de migration. Útil durante prototipage rápido. **Nunca use em produção.**
+
+### Studio (GUI)
+
+```bash
+bun run db:studio
+```
+
+Abre uma interface visual para explorar e editar dados no banco.
+
+## Migrations Programáticas (Startup)
+
+Em produção, as migrations são executadas automaticamente no startup da aplicação:
+
+```javascript
+// index.js
+import { migrate } from 'drizzle-orm/bun-sqlite/migrator'
+import { db } from './database/db'
+
+await migrate(db, { migrationsFolder: './database/migrations' })
+```
+
+Isso garante que o banco esteja sempre atualizado quando o servidor inicia no Fly.io.

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

@@ -115,6 +115,7 @@ console.log(`Server running at ${app.server?.url}`)
 | Need | Skill |
 | --- | --- |
 | **Authentication** | @[.agent/skills/riligar-dev-auth-elysia] |
+| **Database** | @[.agent/skills/riligar-dev-database] |
 | **Infrastructure** | @[.agent/skills/riligar-infra-fly] |
 
 ## Decision Checklist

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

@@ -1,11 +1,11 @@
 ---
 name: riligar-infra-cloudfare
-description: "Setup domains in Cloudflare with DNS for Clerk, Vercel, and email routing. Use when adding new domains, configuring DNS records, or setting up email redirects."
+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, Clerk integration, Vercel deployment, email routing, and R2 storage.
+Automate Cloudflare workflows: DNS setup, email routing, and R2 storage.
 
 ## Prerequisites
 
@@ -38,13 +38,6 @@ wrangler login
 wrangler whoami
 ```
 
-### Other Tools
-```bash
-# Vercel CLI (required)
-bun add -g vercel
-vercel login
-```
-
 ## Workflow
 
 When setting up a new domain, follow these steps:
@@ -53,10 +46,8 @@ When setting up a new domain, follow these steps:
 
 Ask the user for:
 1. **Domain name** (e.g., `example.com`)
-2. **Clerk DNS records** (paste from Clerk dashboard)
-3. **Vercel project name** (e.g., `my-app`)
-4. **Email addresses** to create (e.g., `contact`, `support`)
-5. **Redirect target email** (e.g., `me@gmail.com`)
+2. **Email addresses** to create (e.g., `contact`, `support`)
+3. **Redirect target email** (e.g., `me@gmail.com`)
 
 ### Step 2: Get Zone ID
 
@@ -70,74 +61,7 @@ curl -X GET "https://api.cloudflare.com/client/v4/zones?name=DOMAIN" \
 wrangler pages project list  # Shows associated zones
 ```
 
-### Step 3: Create DNS Records for Clerk
-
-Clerk provides specific DNS records for each project. Common patterns:
-
-```bash
-# Example: 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": "clerk",
-    "content": "frontend-api.clerk.dev",
-    "ttl": 1,
-    "proxied": false
-  }'
-
-# Example: TXT record for verification
-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": "clerk-verification=xxxxx",
-    "ttl": 1
-  }'
-```
-
-### Step 4: Add Domain to Vercel
-
-```bash
-# Add domain to Vercel project
-vercel domains add DOMAIN --scope=TEAM_SLUG
-
-# Or link to specific project
-vercel domains add DOMAIN PROJECT_NAME
-```
-
-Then create Vercel DNS records:
-
-```bash
-# A record for root domain
-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": "A",
-    "name": "@",
-    "content": "76.76.21.21",
-    "ttl": 1,
-    "proxied": false
-  }'
-
-# CNAME for www subdomain
-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": "www",
-    "content": "cname.vercel-dns.com",
-    "ttl": 1,
-    "proxied": false
-  }'
-```
-
-### Step 5: Setup Email Routing
+### Step 3: Setup Email Routing
 
 First, enable email routing for the zone (do this in Cloudflare dashboard first time).
 
@@ -212,7 +136,7 @@ curl -X POST "https://api.cloudflare.com/client/v4/zones/ZONE_ID/dns_records" \
   }'
 ```
 
-### Step 6: Verification Checklist
+### Step 4: Verification Checklist
 
 After setup, verify:
 
@@ -221,9 +145,6 @@ After setup, verify:
 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}'
 
-# Check Vercel domain status
-vercel domains inspect DOMAIN
-
 # Test email routing (send test email to contact@DOMAIN)
 ```
 
@@ -235,12 +156,6 @@ When running `/cloudflare`, ask:
 What domain are you setting up?
 > example.com
 
-Paste the Clerk DNS records from your Clerk dashboard:
-> [user pastes records]
-
-What's the Vercel project name?
-> my-saas-app
-
 What email addresses should I create? (comma-separated)
 > contact, support, hello
 
@@ -252,8 +167,8 @@ What email should these redirect to?
 
 | Type | Use Case | Proxied |
 |------|----------|---------|
-| A | Root domain to IP | No (for Vercel) |
-| CNAME | Subdomain to hostname | No (for Clerk/Vercel) |
+| A | Root domain to IP | Yes (production) |
+| CNAME | Subdomain to hostname | Yes (production) |
 | TXT | Verification, SPF | N/A |
 | MX | Email routing | N/A |
 
@@ -264,8 +179,6 @@ What email should these redirect to?
 | 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 |
-| Vercel 404 | Check DNS proxied=false for Vercel records |
-| Clerk verification failed | Ensure TXT record is on root (@) |
 
 ## Useful Commands
 

package/.agent/skills/riligar-marketing-email/SKILL.md

@@ -1043,9 +1043,3 @@ If you need more context:
 
 ---
 
-## Related Skills
-
-- **onboarding-cro**: For in-app onboarding (email supports this)
-- **copywriting**: For landing pages emails link to
-- **ab-test-setup**: For testing email elements
-- **popup-cro**: For email capture popups

package/.agent/skills/riligar-marketing-seo/SKILL.md

@@ -33,7 +33,7 @@ The Feasibility Index answers one question:
 
 ---
 
-## 🔢 Programmatic SEO Feasibility Index
+## Programmatic SEO Feasibility Index
 
 ### Total Score: **0–100**
 
@@ -337,9 +337,3 @@ If triggered, **halt indexing or roll back**:
 
 ---
 
-## Related Skills
-
-- **seo-audit** – Audit programmatic pages post-launch
-- **schema-markup** – Add structured data to templates
-- **copywriting** – Improve non-templated sections
-- **analytics-tracking** – Measure performance and validate value

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@riligar/agents-kit",
-    "version": "1.16.0",
+    "version": "1.17.0",
     "publishConfig": {
         "access": "public"
     },