create-genia-os 2.0.0 → 2.1.1

package/template/.genia/contexts/api-patterns.md

@@ -0,0 +1,134 @@
+# Contexto: API Patterns
+
+> Principios de design de API e tomada de decisao.
+
+## Mapa de Conteudo
+
+| Topico | Quando Usar |
+|--------|-------------|
+| REST vs GraphQL vs tRPC | Escolher tipo de API |
+| Resource naming, HTTP methods | Design REST |
+| Envelope pattern, error format | Estrutura de resposta |
+| Schema design | GraphQL |
+| Type safety | TS fullstack |
+
+## Arvore de Decisao: Escolher Tipo de API
+
+```
+Projeto → TypeScript monorepo?
+├── Sim → tRPC (type safety end-to-end)
+│
+└── Nao → Clientes diversos?
+    ├── Sim → REST (universal, cacheable)
+    │
+    └── Nao → Queries complexas?
+        ├── Sim → GraphQL (flexivel, self-documenting)
+        └── Nao → REST (simples, padrao da industria)
+```
+
+## REST Design
+
+### Naming de Recursos
+```
+GET    /users           # Lista
+GET    /users/{id}      # Detalhe
+POST   /users           # Criar
+PUT    /users/{id}      # Atualizar (completo)
+PATCH  /users/{id}      # Atualizar (parcial)
+DELETE /users/{id}      # Remover
+```
+
+### Status Codes
+| Code | Uso |
+|------|-----|
+| 200 | OK - Sucesso |
+| 201 | Created - Recurso criado |
+| 204 | No Content - Deletado |
+| 400 | Bad Request - Input invalido |
+| 401 | Unauthorized - Nao autenticado |
+| 403 | Forbidden - Sem permissao |
+| 404 | Not Found - Recurso nao existe |
+| 422 | Unprocessable - Validacao falhou |
+| 500 | Internal Error - Erro do servidor |
+
+## Formato de Resposta
+
+### Sucesso
+```json
+{
+  "data": { ... },
+  "meta": {
+    "pagination": { "page": 1, "total": 100 }
+  }
+}
+```
+
+### Erro
+```json
+{
+  "error": {
+    "code": "VALIDATION_ERROR",
+    "message": "Email invalido",
+    "details": [
+      { "field": "email", "message": "Formato invalido" }
+    ]
+  }
+}
+```
+
+## Paginacao
+
+### Offset-based
+```
+GET /users?page=2&limit=20
+```
+
+### Cursor-based (recomendado para grandes volumes)
+```
+GET /users?cursor=abc123&limit=20
+```
+
+## Versionamento
+
+| Metodo | Exemplo | Uso |
+|--------|---------|-----|
+| URI | `/v1/users` | Mais comum, facil |
+| Header | `Accept: application/vnd.api.v1+json` | Mais limpo |
+| Query | `/users?version=1` | Nao recomendado |
+
+## Autenticacao
+
+| Metodo | Quando Usar |
+|--------|-------------|
+| JWT | SPAs, mobile apps |
+| API Keys | Servicos, integracao |
+| OAuth 2.0 | Login social, terceiros |
+| Session | Apps tradicionais |
+
+## Rate Limiting
+
+### Headers de Resposta
+```
+X-RateLimit-Limit: 100
+X-RateLimit-Remaining: 95
+X-RateLimit-Reset: 1640995200
+```
+
+## Anti-Patterns
+
+| NAO Fazer | Fazer |
+|-----------|-------|
+| `/getUsers` | `GET /users` |
+| `/createUser` | `POST /users` |
+| Retornar 200 para erros | Usar status codes corretos |
+| Expor erros internos | Mensagens genericas |
+| Pular rate limiting | Sempre limitar |
+
+## Checklist
+
+- [ ] Escolhi estilo de API para o contexto?
+- [ ] Formato de resposta consistente?
+- [ ] Estrategia de versionamento?
+- [ ] Autenticacao definida?
+- [ ] Rate limiting planejado?
+- [ ] Documentacao (OpenAPI)?

package/template/.genia/contexts/nextjs-react.md

@@ -0,0 +1,210 @@
+# Contexto: Next.js & React
+
+> Patterns de performance e boas praticas para Next.js e React.
+
+## Eliminando Waterfalls
+
+### Problema: Requests Sequenciais
+```typescript
+// ERRADO - waterfall
+const user = await getUser(id);
+const posts = await getPosts(user.id);
+const comments = await getComments(posts);
+```
+
+### Solucao: Parallelizar
+```typescript
+// CORRETO - paralelo
+const [user, posts] = await Promise.all([
+  getUser(id),
+  getPosts(id)
+]);
+```
+
+## Bundle Size Optimization
+
+### Code Splitting
+```typescript
+// Dynamic imports
+const HeavyComponent = dynamic(() => import('./Heavy'), {
+  loading: () => <Skeleton />
+});
+```
+
+### Tree Shaking
+```typescript
+// ERRADO - importa tudo
+import _ from 'lodash';
+
+// CORRETO - importa so o necessario
+import debounce from 'lodash/debounce';
+```
+
+## Server-Side Performance
+
+### Streaming
+```typescript
+// app/page.tsx
+export default function Page() {
+  return (
+    <main>
+      <Header />
+      <Suspense fallback={<Loading />}>
+        <SlowComponent />
+      </Suspense>
+    </main>
+  );
+}
+```
+
+### Caching
+```typescript
+// Revalidate a cada hora
+export const revalidate = 3600;
+
+// Ou fetch com cache
+const data = await fetch(url, {
+  next: { revalidate: 3600 }
+});
+```
+
+## Client-Side Data Fetching
+
+### SWR ou React Query
+```typescript
+import useSWR from 'swr';
+
+function Profile() {
+  const { data, error, isLoading } = useSWR('/api/user', fetcher);
+
+  if (isLoading) return <Loading />;
+  if (error) return <Error />;
+  return <User data={data} />;
+}
+```
+
+## Re-render Optimization
+
+### useMemo para calculos pesados
+```typescript
+const expensiveValue = useMemo(() => {
+  return heavyCalculation(data);
+}, [data]);
+```
+
+### useCallback para funcoes
+```typescript
+const handleClick = useCallback(() => {
+  doSomething(id);
+}, [id]);
+```
+
+### React.memo para componentes
+```typescript
+const Card = React.memo(function Card({ user }) {
+  return <div>{user.name}</div>;
+});
+```
+
+## Rendering Performance
+
+### Keys corretas
+```typescript
+// ERRADO - index como key
+{items.map((item, i) => <Item key={i} />)}
+
+// CORRETO - id unico
+{items.map(item => <Item key={item.id} />)}
+```
+
+### Virtualizacao para listas longas
+```typescript
+import { FixedSizeList } from 'react-window';
+
+<FixedSizeList
+  height={400}
+  itemCount={1000}
+  itemSize={35}
+>
+  {Row}
+</FixedSizeList>
+```
+
+## JavaScript Performance
+
+### Debounce inputs
+```typescript
+const debouncedSearch = useDebouncedCallback(
+  (value) => search(value),
+  300
+);
+```
+
+### Web Workers para calculos pesados
+```typescript
+const worker = new Worker('/worker.js');
+worker.postMessage(heavyData);
+worker.onmessage = (e) => setResult(e.data);
+```
+
+## Advanced Patterns
+
+### Server Components
+```typescript
+// Componente servidor (default no App Router)
+async function Posts() {
+  const posts = await db.posts.findMany(); // Direto no banco!
+  return <PostList posts={posts} />;
+}
+```
+
+### Server Actions
+```typescript
+async function submitForm(formData: FormData) {
+  'use server';
+  await db.users.create({ data: formData });
+}
+```
+
+### Parallel Routes
+```typescript
+// app/@dashboard/page.tsx
+// app/@sidebar/page.tsx
+// Carregam em paralelo
+```
+
+## Image Optimization
+
+```typescript
+import Image from 'next/image';
+
+<Image
+  src="/hero.jpg"
+  width={1200}
+  height={600}
+  placeholder="blur"
+  priority // Para imagens above-the-fold
+/>
+```
+
+## Font Optimization
+
+```typescript
+import { Inter } from 'next/font/google';
+
+const inter = Inter({
+  subsets: ['latin'],
+  display: 'swap',
+});
+```
+
+## Checklist de Performance
+
+- [ ] Requests em paralelo (Promise.all)?
+- [ ] Code splitting implementado?
+- [ ] Imagens otimizadas (next/image)?
+- [ ] Fontes otimizadas (next/font)?
+- [ ] Caching configurado?
+- [ ] Listas virtualizadas?
+- [ ] Memos apropriados?
+- [ ] Bundle analisado?

package/template/.genia/contexts/projeto.md

@@ -0,0 +1,18 @@
+# Contexto: {{PROJECT_NAME}}
+
+> Carregue com: `@load-context {{PROJECT_NAME}}`
+
+## Sobre o Projeto
+
+- **Nome**: {{PROJECT_NAME}}
+- **Equipe**: {{TEAM_NAME}}
+- **Stack**: {{STACK}}
+
+## Recursos Principais
+
+_Adicione aqui as informações de contexto do seu projeto:_
+_APIs, autenticação, endpoints, banco de dados, etc._
+
+## Links Úteis
+
+- GitHub: https://github.com/{{GITHUB_USER}}/{{GITHUB_REPO}}

package/template/.genia/contexts/supabase.md

@@ -0,0 +1,152 @@
+# Contexto: Supabase
+
+> Base de conhecimento para integracao com Supabase.
+
+## Configuracao
+
+### Credenciais
+```
+URL: [ver .env - SUPABASE_URL]
+API Key: [ver .env - SUPABASE_KEY]
+Service Key: [ver .env - SUPABASE_SERVICE_KEY]
+```
+
+## Cliente Python
+
+### Instalacao
+```bash
+pip install supabase
+```
+
+### Inicializacao
+```python
+from supabase import create_client
+
+supabase = create_client(
+    supabase_url=os.getenv("SUPABASE_URL"),
+    supabase_key=os.getenv("SUPABASE_KEY")
+)
+```
+
+## Operacoes CRUD
+
+### Select
+```python
+# Todos os registros
+data = supabase.table("tabela").select("*").execute()
+
+# Com filtro
+data = supabase.table("tabela").select("*").eq("coluna", valor).execute()
+
+# Com ordenacao
+data = supabase.table("tabela").select("*").order("coluna", desc=True).execute()
+
+# Com limite
+data = supabase.table("tabela").select("*").limit(10).execute()
+
+# Colunas especificas
+data = supabase.table("tabela").select("id, nome, email").execute()
+```
+
+### Insert
+```python
+data = supabase.table("tabela").insert({
+    "coluna1": "valor1",
+    "coluna2": "valor2"
+}).execute()
+
+# Bulk insert
+data = supabase.table("tabela").insert([
+    {"col": "val1"},
+    {"col": "val2"}
+]).execute()
+```
+
+### Update
+```python
+data = supabase.table("tabela").update({
+    "coluna": "novo_valor"
+}).eq("id", 123).execute()
+```
+
+### Delete
+```python
+data = supabase.table("tabela").delete().eq("id", 123).execute()
+```
+
+## Filtros
+
+| Metodo | SQL | Uso |
+|--------|-----|-----|
+| eq | = | .eq("col", val) |
+| neq | != | .neq("col", val) |
+| gt | > | .gt("col", val) |
+| gte | >= | .gte("col", val) |
+| lt | < | .lt("col", val) |
+| lte | <= | .lte("col", val) |
+| like | LIKE | .like("col", "%val%") |
+| ilike | ILIKE | .ilike("col", "%val%") |
+| in_ | IN | .in_("col", [1,2,3]) |
+| is_ | IS | .is_("col", None) |
+
+## RPC (Functions)
+
+```python
+# Chamar funcao
+data = supabase.rpc("nome_funcao", {"param": "valor"}).execute()
+```
+
+## Storage
+
+```python
+# Upload
+supabase.storage.from_("bucket").upload("path/file.pdf", file_content)
+
+# Download
+data = supabase.storage.from_("bucket").download("path/file.pdf")
+
+# URL publica
+url = supabase.storage.from_("bucket").get_public_url("path/file.pdf")
+```
+
+## Auth
+
+```python
+# Sign up
+supabase.auth.sign_up({"email": "...", "password": "..."})
+
+# Sign in
+supabase.auth.sign_in_with_password({"email": "...", "password": "..."})
+
+# Sign out
+supabase.auth.sign_out()
+
+# Get user
+user = supabase.auth.get_user()
+```
+
+## Gotchas
+1. Usar service key para operacoes admin
+2. RLS (Row Level Security) afeta queries com api key
+3. Timestamps em ISO 8601
+4. UUIDs para IDs
+
+## Patterns
+
+### Upsert
+```python
+data = supabase.table("tabela").upsert({
+    "id": 123,
+    "coluna": "valor"
+}).execute()
+```
+
+### Count
+```python
+count = supabase.table("tabela").select("*", count="exact").execute()
+print(count.count)
+```
+
+---
+
+*Contexto carregado automaticamente quando detectado uso de Supabase.*

package/template/.genia/contexts/whatsapp-cloud.md

@@ -0,0 +1,176 @@
+# Contexto: WhatsApp Cloud API
+
+> Base de conhecimento para integracao com WhatsApp Cloud API (Meta).
+
+## Configuracao
+
+### Credenciais
+```
+Base URL: https://graph.facebook.com/v21.0
+Phone Number ID: [ver .env - WA_PHONE_NUMBER_ID]
+Access Token: [ver .env - WA_ACCESS_TOKEN]
+Verify Token: [ver .env - WA_VERIFY_TOKEN]
+```
+
+## Enviar Mensagens
+
+### Mensagem de Texto
+```python
+import requests
+
+url = f"https://graph.facebook.com/v21.0/{PHONE_NUMBER_ID}/messages"
+headers = {
+    "Authorization": f"Bearer {ACCESS_TOKEN}",
+    "Content-Type": "application/json"
+}
+data = {
+    "messaging_product": "whatsapp",
+    "recipient_type": "individual",
+    "to": "5511999999999",
+    "type": "text",
+    "text": {
+        "preview_url": False,
+        "body": "Mensagem aqui"
+    }
+}
+response = requests.post(url, headers=headers, json=data)
+```
+
+### Template
+```python
+data = {
+    "messaging_product": "whatsapp",
+    "to": "5511999999999",
+    "type": "template",
+    "template": {
+        "name": "nome_template",
+        "language": {"code": "pt_BR"},
+        "components": [
+            {
+                "type": "body",
+                "parameters": [
+                    {"type": "text", "text": "valor1"},
+                    {"type": "text", "text": "valor2"}
+                ]
+            }
+        ]
+    }
+}
+```
+
+### Imagem
+```python
+data = {
+    "messaging_product": "whatsapp",
+    "to": "5511999999999",
+    "type": "image",
+    "image": {
+        "link": "https://url-da-imagem.jpg"
+    }
+}
+```
+
+### Documento
+```python
+data = {
+    "messaging_product": "whatsapp",
+    "to": "5511999999999",
+    "type": "document",
+    "document": {
+        "link": "https://url-do-documento.pdf",
+        "filename": "arquivo.pdf"
+    }
+}
+```
+
+### Botoes Interativos
+```python
+data = {
+    "messaging_product": "whatsapp",
+    "to": "5511999999999",
+    "type": "interactive",
+    "interactive": {
+        "type": "button",
+        "body": {"text": "Escolha uma opcao:"},
+        "action": {
+            "buttons": [
+                {"type": "reply", "reply": {"id": "btn1", "title": "Opcao 1"}},
+                {"type": "reply", "reply": {"id": "btn2", "title": "Opcao 2"}}
+            ]
+        }
+    }
+}
+```
+
+## Webhook
+
+### Verificacao
+```python
+@app.get("/webhook")
+def verify_webhook(hub_mode: str, hub_verify_token: str, hub_challenge: str):
+    if hub_mode == "subscribe" and hub_verify_token == VERIFY_TOKEN:
+        return int(hub_challenge)
+    return {"error": "Invalid token"}, 403
+```
+
+### Receber Mensagens
+```python
+@app.post("/webhook")
+def receive_message(payload: dict):
+    entry = payload.get("entry", [{}])[0]
+    changes = entry.get("changes", [{}])[0]
+    value = changes.get("value", {})
+
+    messages = value.get("messages", [])
+    for msg in messages:
+        from_number = msg.get("from")
+        msg_type = msg.get("type")
+
+        if msg_type == "text":
+            text = msg.get("text", {}).get("body")
+        elif msg_type == "interactive":
+            button_reply = msg.get("interactive", {}).get("button_reply", {})
+            button_id = button_reply.get("id")
+
+    return {"status": "ok"}
+```
+
+## Status de Mensagem
+
+### Marcar como Lida
+```python
+data = {
+    "messaging_product": "whatsapp",
+    "status": "read",
+    "message_id": "wamid.xxx"
+}
+requests.post(url, headers=headers, json=data)
+```
+
+## Gotchas
+1. Telefone com codigo do pais (5511...)
+2. Templates precisam ser aprovados
+3. Janela de 24h para mensagens normais
+4. Fora da janela, so templates
+5. Media precisa ser URL publica ou upload
+
+## Rate Limits
+- 80 mensagens/segundo (Business)
+- 1000 mensagens/dia (free tier)
+
+## Templates
+
+### Criar Template
+Via Business Manager ou API
+
+### Estrutura
+```
+Header (opcional): texto, imagem, documento, video
+Body (obrigatorio): texto com {{1}}, {{2}}...
+Footer (opcional): texto
+Buttons (opcional): ate 3 botoes
+```
+
+---
+
+*Contexto carregado automaticamente quando detectado uso de WhatsApp.*