@dewtech/dare-cli 2.17.0 → 3.0.0

package/templates/ide/antigravity/.agents/skills/dare-telemetry/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: dare-telemetry
+description: Rastreamento de tokens e modelos de IA consumidos em cada etapa do Método DARE. Gera DARE/TELEMETRY.md com modelo usado, tokens estimados, tempo e tentativas (Ralph Loop) por comando — para auditoria, monitoramento de uso e otimização de custos.
+---
+
+# DARE Telemetry Skill
+
+Você é um especialista em observabilidade e monitoramento de uso de IA. Seu papel é rastrear consumo de tokens e modelos usados em cada etapa do DARE, mantendo `DARE/TELEMETRY.md` atualizado.
+
+> **Diferença com `dare-quality-telemetry`:**
+> - `dare-telemetry` (esta) — rastreia **uso de IA** (modelos, tokens, tempo) por comando DARE
+> - `dare-quality-telemetry` — agrega **métricas de qualidade** das skills (M-01 a M-04)
+
+## Quando usar
+
+- Ao final de cada comando DARE executado
+- Para gerar relatório periódico de uso de IA
+- Para auditoria de compliance (qual IA foi usada, onde)
+- Para otimização de custos (qual etapa consome mais)
+
+## Modelos rastreáveis
+
+Independente do IDE/agente:
+
+| Modelo | Provider | Características | Melhor para |
+|---|---|---|---|
+| Claude Opus 4.7 | Anthropic | Análise profunda, refactor longo | Design, blueprint, security review |
+| Claude Sonnet 4.5 | Anthropic | Equilíbrio velocidade/qualidade | Execução de tasks |
+| GPT-4 Turbo | OpenAI | Versátil | Tarefas gerais |
+| Gemini 2.0 Flash | Google | Ultra rápido | Tasks simples, processamento em batch |
+| Modelos locais (Ollama) | Self-hosted | Privacidade total | Dados sensíveis |
+
+## Estrutura `DARE/TELEMETRY.md`
+
+```markdown
+# Telemetria do Projeto: [Nome]
+
+## Resumo Executivo
+- **Projeto:** [Nome]
+- **Data de início:** [ISO 8601]
+- **Tokens totais processados:** [Número]
+- **Modelos utilizados:** [Lista]
+- **Tempo total de execução:** [Tempo]
+- **Custo estimado:** $[X]
+
+## Detalhamento por Etapa
+
+### 1. Design (`/dare-design`)
+- **Data/Hora:** [Timestamp]
+- **Modelo:** Claude Opus 4.7
+- **Tokens estimados (in/out):** 7,390 / 1,250
+- **Tempo de execução:** 45 segundos
+- **Comando:** `/dare-design "Criar API de autenticação"`
+- **Resultado:** DESIGN.md gerado, 12 RFs, 8 RNFs, 5 RS
+- **Observações:** [Ajustes manuais necessários, etc.]
+
+### 2. Blueprint (`/dare-blueprint`)
+- **Data/Hora:** [Timestamp]
+- **Modelo:** Claude Opus 4.7
+- **Tokens estimados (in/out):** 21,373 / 4,800
+- **Tempo:** 2 min
+- **Arquivo processado:** DARE/DESIGN.md
+- **Resultado:** BLUEPRINT.md com 8 fases, 25 tabelas, 4 diagramas Mermaid
+
+### 3. Tasks (`/dare-tasks`)
+- **Tokens estimados:** 33,912 / 8,200
+- **Tempo:** 3 min 20 seg
+- **Arquivo processado:** DARE/BLUEPRINT.md
+- **Tasks geradas:** 12
+
+### 4. Execute Tasks (`/dare-execute`)
+
+- **task-001 — Migration de Users**
+  - Modelo: Claude Sonnet 4.5
+  - Tokens: 7,801 / 2,500
+  - Tempo: 1 min 30 seg
+  - Tentativas (Ralph Loop): 1
+  - Status: ✓ Sucesso
+
+- **task-002 — AuthController**
+  - Modelo: Claude Sonnet 4.5
+  - Tokens: 11,357 / 3,200
+  - Tempo: 2 min
+  - Tentativas: 2 (1 falha por typo)
+  - Status: ✓ Sucesso
+
+## Análise
+
+| Etapa | Tokens in/out | % do total | Tempo |
+|---|---|---|---|
+| Design | 7,390 / 1,250 | 5% | 45 seg |
+| Blueprint | 21,373 / 4,800 | 15% | 2 min |
+| Tasks | 33,912 / 8,200 | 24% | 3 min 20 seg |
+| Execute (12 tasks) | 85,234 / 24,000 | 56% | 25 min |
+| **TOTAL** | **147,909 / 38,250** | **100%** | **~31 min** |
+
+## Modelos utilizados
+
+- Claude Opus 4.7: 62,675 tokens (42%) — design + blueprint + tasks
+- Claude Sonnet 4.5: 85,234 tokens (58%) — execução de tasks
+
+## Custo estimado
+
+| Modelo | Tokens in | Tokens out | $/M in | $/M out | Total |
+|---|---|---|---|---|---|
+| Opus 4.7 | 62,675 | 14,250 | $15 | $75 | $2.01 |
+| Sonnet 4.5 | 85,234 | 24,000 | $3 | $15 | $0.62 |
+| **Total** | | | | | **$2.63** |
+```
+
+## Como aplicar
+
+### Passo 1: Após `/dare-design`
+
+Adicione entrada na seção Design com:
+- Timestamp
+- Modelo do agente (perguntar ao usuário se não souber automaticamente)
+- Tokens estimados (in/out) — pegar do output do modelo se disponível
+- Tempo de execução
+- Comando executado
+- Observações qualitativas
+
+### Passo 2: Após `/dare-blueprint`
+
+Idem. Adicione tabelas e diagramas gerados como resultado.
+
+### Passo 3: Após `/dare-tasks`
+
+Inclua número de tasks geradas, complexidade média.
+
+### Passo 4: Após cada `/dare-execute`
+
+Para cada task:
+- Modelo usado
+- Tokens
+- Tempo
+- **Tentativas no Ralph Loop** (importante — se >2, task precisa refino)
+- Status (Sucesso/Falha)
+
+### Passo 5: Recompilar análise + custos
+
+A cada 5 tasks ou release, atualize a seção Análise com totais agregados.
+
+## Capturando informações do agente
+
+Cada IDE expõe diferente:
+
+**Antigravity:**
+- Modelo aparece no header da conversa
+- Tokens estimados em `?ax-debug` ou settings
+
+**Claude Code:**
+- `/cost` mostra tokens da sessão
+- Modelo no rodapé
+
+**Cursor:**
+- Barra de status canto inferior direito
+- Histórico de conversa tem detalhes por resposta
+
+## Otimizações recomendadas
+
+1. **Modelo certo para tarefa certa**
+   - Opus → design/blueprint/security review
+   - Sonnet → execução
+   - Gemini Flash → tasks simples, batch
+2. **Reutilizar contexto** — múltiplas tasks na mesma sessão economiza re-leitura
+3. **Revisar Blueprint antes de Tasks** — evita re-geração
+4. **Agrupar tasks relacionadas** — contexto reaproveitado
+5. **Ralph Loop alto = especificação ruim** — se task precisa >2 tentativas, refine BLUEPRINT.md
+
+## Antipatterns
+
+| AP | Antipattern | Por quê |
+|---|---|---|
+| AP-01 | Não rastrear telemetria | Sem dados para otimizar |
+| AP-02 | Usar Opus para tasks triviais | Desperdício de custo |
+| AP-03 | Ignorar Ralph Loop alto | Specs ruins se acumulam |
+| AP-04 | Não auditar modelo (compliance) | Risco regulatório se houver |
+
+## Dicas
+
+- **Combine** com `dare-quality-telemetry` — esta rastreia uso de IA, aquela rastreia qualidade
+- **Exporte** TELEMETRY.md para dashboard (Grafana, Notion, etc.) periodicamente
+- **Trate custo como métrica** — adicione ao Ralph Loop como gate (>$Y/feature = revisar specs)
+
+---
+
+Esta skill é parte do DARE Method e está sob licença MIT.

package/templates/ide/antigravity/.agents/skills/skill-fastapi-api/SKILL.md

@@ -0,0 +1,343 @@
+---
+name: skill-fastapi-api
+description: Padrões DARE para APIs REST em Python + FastAPI + Pydantic + uvicorn. Routers, dependency injection, Pydantic v2 schemas, async SQLAlchemy 2.0, autenticação OAuth2 + JWT, rate limit com slowapi, pytest + httpx, OpenAPI auto-gerado.
+---
+
+# DARE FastAPI Skill
+
+Você é um desenvolvedor sênior Python especialista em APIs REST com FastAPI. Seu objetivo é gerar código **assíncrono, fortemente tipado (Pydantic v2), com OpenAPI auto-gerado, auth/autz robustos**, seguindo Layered Design DARE.
+
+## Quando usar
+
+- Projeto FastAPI novo via DARE
+- Adicionar feature em API FastAPI existente
+- Migrar de Flask/Django para FastAPI
+- Auditar projeto FastAPI para conformidade DARE
+
+## Stack canônica
+
+- **Python 3.11+** com type hints obrigatórios
+- **FastAPI 0.115+** com async/await
+- **Pydantic v2** para schemas
+- **SQLAlchemy 2.0** async + **asyncpg** (PostgreSQL)
+- **alembic** para migrations
+- **passlib + argon2** para hash de senhas
+- **python-jose** ou **PyJWT** para JWT
+- **slowapi** para rate limiting
+- **pytest + pytest-asyncio + httpx** para testes
+- **ruff** para lint + format
+- **mypy** para type checking
+
+## Layered Design em FastAPI
+
+```
+app/
+├── main.py                       ← FastAPI app + middlewares
+├── core/
+│   ├── config.py                 ← Settings via pydantic-settings
+│   └── security.py               ← hash, JWT
+├── api/
+│   ├── deps.py                   ← Depends() comuns
+│   └── v1/
+│       ├── users.py              ← Handler (router)
+│       └── auth.py
+├── services/
+│   └── register_user.py          ← Service
+├── repositories/
+│   └── users.py                  ← Repository
+├── models/                       ← SQLAlchemy ORM
+│   └── user.py
+├── schemas/                      ← Pydantic DTOs
+│   ├── user.py
+│   └── auth.py
+└── tests/
+```
+
+## Routers (Handler)
+
+```python
+from fastapi import APIRouter, Depends, HTTPException, status
+from app.api.deps import get_current_user
+from app.schemas.user import UserCreate, UserOut
+from app.services.register_user import RegisterUser, UserAlreadyExistsError
+
+router = APIRouter(prefix="/users", tags=["users"])
+
+@router.post("", response_model=UserOut, status_code=status.HTTP_201_CREATED)
+async def create_user(
+    payload: UserCreate,
+    service: RegisterUser = Depends(),
+    _current: User = Depends(get_current_user),
+):
+    try:
+        return await service.execute(payload)
+    except UserAlreadyExistsError:
+        raise HTTPException(status_code=409, detail="User already exists")
+```
+
+Regras:
+- Apenas: valida via Pydantic → chama Service → retorna response_model
+- NUNCA: SQLAlchemy direto, lógica de negócio
+
+## Schemas (Pydantic v2)
+
+```python
+from pydantic import BaseModel, EmailStr, Field
+from datetime import datetime
+
+class UserCreate(BaseModel):
+    email: EmailStr
+    name: str = Field(min_length=1, max_length=255)
+    password: str = Field(min_length=12)
+
+class UserOut(BaseModel):
+    id: int
+    email: EmailStr
+    name: str
+    created_at: datetime
+
+    model_config = {"from_attributes": True}  # Pydantic v2 / ex-orm_mode
+```
+
+## Services
+
+```python
+from app.repositories.users import UsersRepository
+from app.core.security import hash_password
+from app.schemas.user import UserCreate
+from app.models.user import User
+
+class UserAlreadyExistsError(Exception): ...
+
+class RegisterUser:
+    def __init__(self, repo: UsersRepository = Depends()):
+        self.repo = repo
+
+    async def execute(self, payload: UserCreate) -> User:
+        if await self.repo.exists_by_email(payload.email):
+            raise UserAlreadyExistsError()
+        return await self.repo.create(
+            email=payload.email,
+            name=payload.name,
+            password_hash=hash_password(payload.password),
+        )
+```
+
+## Repositories (SQLAlchemy async 2.0)
+
+```python
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from fastapi import Depends
+from app.api.deps import get_db
+from app.models.user import User
+
+class UsersRepository:
+    def __init__(self, db: AsyncSession = Depends(get_db)):
+        self.db = db
+
+    async def exists_by_email(self, email: str) -> bool:
+        result = await self.db.execute(select(User.id).where(User.email == email))
+        return result.scalar_one_or_none() is not None
+
+    async def create(self, *, email: str, name: str, password_hash: str) -> User:
+        user = User(email=email, name=name, password_hash=password_hash)
+        self.db.add(user)
+        await self.db.commit()
+        await self.db.refresh(user)
+        return user
+```
+
+## Models (SQLAlchemy)
+
+```python
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+from datetime import datetime
+
+class Base(DeclarativeBase): ...
+
+class User(Base):
+    __tablename__ = "users"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    email: Mapped[str] = mapped_column(unique=True, index=True)
+    name: Mapped[str]
+    password_hash: Mapped[str]
+    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
+```
+
+## Auth (OAuth2 + JWT)
+
+```python
+# app/core/security.py
+from passlib.hash import argon2
+from datetime import datetime, timedelta
+from jose import jwt
+from app.core.config import settings
+
+def hash_password(p: str) -> str: return argon2.hash(p)
+def verify_password(p: str, h: str) -> bool: return argon2.verify(p, h)
+
+def create_access_token(sub: str) -> str:
+    expire = datetime.utcnow() + timedelta(minutes=15)
+    payload = {"sub": sub, "exp": expire}
+    return jwt.encode(payload, settings.JWT_SECRET, algorithm="HS256")
+```
+
+```python
+# app/api/deps.py
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import jwt, JWTError
+from app.core.config import settings
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/v1/auth/login")
+
+async def get_current_user(token: str = Depends(oauth2_scheme)) -> User:
+    try:
+        payload = jwt.decode(token, settings.JWT_SECRET, algorithms=["HS256"])
+        sub: str = payload.get("sub")
+    except JWTError:
+        raise HTTPException(status_code=401, detail="Invalid token")
+    # buscar user no DB ...
+    return user
+```
+
+## Rate limiting (slowapi)
+
+```python
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+limiter = Limiter(key_func=get_remote_address)
+app.state.limiter = limiter
+app.add_middleware(SlowAPIMiddleware)
+
+@router.post("/login")
+@limiter.limit("5/15minute")
+async def login(request: Request, ...):
+    ...
+```
+
+## OpenAPI
+
+FastAPI auto-gera em `/openapi.json`. Customize title/version/auth:
+
+```python
+app = FastAPI(
+    title="Projeto API",
+    version="1.0",
+    openapi_url="/openapi.json",
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+```
+
+## Settings (pydantic-settings)
+
+```python
+# app/core/config.py
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+class Settings(BaseSettings):
+    DATABASE_URL: str
+    JWT_SECRET: str
+    JWT_EXPIRE_MINUTES: int = 15
+    model_config = SettingsConfigDict(env_file=".env")
+
+settings = Settings()
+```
+
+## Testes
+
+```python
+# tests/test_users.py
+import pytest
+from httpx import AsyncClient
+
+@pytest.mark.asyncio
+async def test_create_user(client: AsyncClient, admin_token: str):
+    response = await client.post(
+        "/v1/users",
+        json={"email": "jane@example.com", "name": "Jane", "password": "longsecret123"},
+        headers={"Authorization": f"Bearer {admin_token}"},
+    )
+    assert response.status_code == 201
+    assert response.json()["email"] == "jane@example.com"
+
+@pytest.mark.asyncio
+async def test_duplicate_email(client: AsyncClient, admin_token: str):
+    # cria primeiro
+    await client.post("/v1/users", json={...}, headers={...})
+    # tenta de novo
+    response = await client.post("/v1/users", json={...}, headers={...})
+    assert response.status_code == 409
+```
+
+## Antipatterns
+
+| AP | Antipattern | Correção |
+|---|---|---|
+| AP-01 | SQLAlchemy direto no router | Repository injetado via Depends |
+| AP-02 | Validação manual no router | Pydantic schema |
+| AP-03 | Lógica no router | Service |
+| AP-04 | `return user` (ORM) sem response_model | `response_model=UserOut` |
+| AP-05 | Secret hardcoded | `pydantic-settings` + `.env` |
+| AP-06 | Login sem rate limit | `@limiter.limit("5/15minute")` |
+| AP-07 | `password=user.password` em response | `response_model=UserOut` sem password |
+| AP-08 | Sem `from_attributes=True` | response_model não converte ORM |
+
+## Segurança
+
+- Senhas: `argon2.hash()` (passlib)
+- JWT: HS256 com `JWT_SECRET ≥ 32 bytes`, ou RS256 com par de chaves
+- Headers: middleware com HSTS, X-Frame-Options, CSP
+- CORS específico, nunca `*`
+- Rate limit em login + APIs públicas
+- Refresh token com rotação
+
+## CI
+
+```bash
+ruff check .
+ruff format --check .
+mypy app
+pytest --cov=app --cov-fail-under=80
+pip-audit
+alembic upgrade head --sql > /dev/null   # valida migrations
+```
+
+## Como aplicar
+
+### Passo 1: Audit
+
+```bash
+grep -rn "db\.execute\|db\.query" app/api/        # AP-01
+grep -rn "request\.json()" app/api/               # AP-02
+grep -rn "JWT_SECRET\s*=\s*['\"]" app/            # AP-05
+```
+
+### Passo 2: Migrar para Pydantic schemas
+
+Para cada `request.json()` ou validação inline → schema Pydantic.
+
+### Passo 3: Extrair Services
+
+Lógica > 5 linhas no router → Service injetável.
+
+### Passo 4: Adicionar Repositories
+
+Encapsular SQLAlchemy. Router chama Service via Depends, Service chama Repository.
+
+### Passo 5: Configurar slowapi + auth
+
+`app.add_middleware(SlowAPIMiddleware)` global + `@limiter.limit` em login.
+
+## Dicas
+
+- **Combine** com `dare-docker` (Python 3.11-slim, não-root, multi-stage)
+- **Use** `dare-llm-integration` se houver Gemini/Claude (FastAPI + httpx async)
+- **Para realtime**, FastAPI tem `WebSocket` nativo + `sse-starlette`
+
+---
+
+Esta skill é parte do DARE Method e está sob licença MIT.