@dewtech/dare-cli 2.17.0 → 3.1.0

package/templates/ide/claude/.claude/commands/dare-telemetry.md

@@ -0,0 +1,132 @@
+# /dare-telemetry
+
+Rastreia tokens e modelos de IA usados em cada etapa do Método DARE. Atualiza `DARE/TELEMETRY.md` com modelo, tokens, tempo e tentativas (Ralph Loop) por comando.
+
+## Como usar
+
+```
+/dare-telemetry                    # gera relatório completo
+/dare-telemetry append <comando>   # adiciona entrada do último comando
+/dare-telemetry report             # gera resumo + custo estimado
+```
+
+## Diferença com `/dare-quality-telemetry`
+
+- **`/dare-telemetry`** — uso de IA (modelos, tokens, tempo)
+- **`/dare-quality-telemetry`** — métricas de qualidade das skills (M-01 a M-04)
+
+## Modelos rastreáveis
+
+| Modelo | Provider | Melhor para |
+|---|---|---|
+| Claude Opus 4.7 | Anthropic | Design, blueprint, security review |
+| Claude Sonnet 4.5 | Anthropic | Execução de tasks |
+| GPT-4 Turbo | OpenAI | Tarefas gerais |
+| Gemini 2.0 Flash | Google | Tasks simples, batch |
+| Ollama (local) | Self-hosted | Dados sensíveis |
+
+## Estrutura `DARE/TELEMETRY.md`
+
+```markdown
+# Telemetria do Projeto
+
+## Resumo Executivo
+- Projeto: [Nome]
+- Tokens totais: 147,909 in / 38,250 out
+- Modelos: Opus 4.7, Sonnet 4.5
+- Tempo total: ~31 min
+- Custo estimado: $2.63
+
+## Detalhamento por Etapa
+
+### 1. Design
+- Timestamp, Modelo, Tokens in/out, Tempo, Comando, Resultado
+
+### 2. Blueprint
+- (idem)
+
+### 3. Tasks
+- (idem) + número de tasks geradas
+
+### 4. Execute Tasks
+Por task:
+- task-001 — Migration
+  - Modelo, Tokens, Tempo
+  - Tentativas Ralph Loop: 1
+  - Status: ✓
+
+## Análise
+
+| Etapa | Tokens in/out | % | Tempo |
+|---|---|---|---|
+
+## Custo estimado
+
+| Modelo | In | Out | $/M in | $/M out | Total |
+|---|---|---|---|---|---|
+```
+
+## O que fazer
+
+### Passo 1: Após cada comando DARE
+
+Adicione entrada com:
+- Timestamp (`date -u +%FT%TZ`)
+- Modelo do agente
+- Tokens estimados in/out (pegar do output se disponível, perguntar se não)
+- Tempo de execução
+- Comando exato executado
+- Resultado (arquivo gerado, número de tasks, etc.)
+- Observações qualitativas
+
+### Passo 2: Para `/dare-execute` de cada task
+
+Rastreie especialmente:
+- **Tentativas no Ralph Loop** — se >2, task precisa refinamento do spec
+- Status (Sucesso/Falha)
+
+### Passo 3: Recompilar análise
+
+A cada 5 tasks ou release, atualize a seção Análise com totais.
+
+### Passo 4: Custo
+
+Use tabela de preços oficial (varia por modelo). Tokens in vs out têm preços diferentes — não some os dois.
+
+## Otimizações recomendadas
+
+1. **Modelo certo para tarefa**:
+   - Opus → design/blueprint/security
+   - 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. **Ralph Loop alto = spec 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 |
+| AP-03 | Ignorar Ralph Loop alto | Specs ruins acumulam |
+| AP-04 | Não auditar modelo (compliance) | Risco regulatório |
+
+## Capturando tokens no Claude Code
+
+- `/cost` exibe tokens da sessão atual
+- Modelo aparece no rodapé do terminal
+- Em CI, use `--debug` ou `--telemetry-output` se disponível
+
+## Saída esperada
+
+Markdown completo do `DARE/TELEMETRY.md` atualizado, com:
+- Nova entrada do último comando
+- Análise agregada refrescada
+- Custo total recalculado
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method.

package/templates/ide/claude/.claude/commands/skill-fastapi-api.md

@@ -0,0 +1,205 @@
+# /skill-fastapi-api
+
+Padrões DARE para APIs REST em Python + FastAPI + Pydantic v2 + SQLAlchemy 2.0 async. Routers, dependency injection, schemas Pydantic, OAuth2+JWT, slowapi rate limit, pytest+httpx, OpenAPI auto-gerado.
+
+## Como usar
+
+```
+/skill-fastapi-api                          # audita projeto FastAPI
+/skill-fastapi-api scaffold users           # gera router + service + repo + schemas
+/skill-fastapi-api migrate-validation       # extrai validação manual para Pydantic
+```
+
+## Stack canônica
+
+- Python 3.11+ com type hints obrigatórios
+- FastAPI 0.115+ (async/await)
+- Pydantic v2
+- SQLAlchemy 2.0 async + asyncpg
+- alembic (migrations)
+- passlib + argon2
+- python-jose ou PyJWT
+- slowapi (rate limit)
+- pytest + pytest-asyncio + httpx
+- ruff + mypy
+
+## Estrutura
+
+```
+app/
+├── main.py
+├── core/{config.py, security.py}
+├── api/{deps.py, v1/{users.py, auth.py}}
+├── services/
+├── repositories/
+├── models/        ← SQLAlchemy ORM
+├── schemas/       ← Pydantic DTOs
+└── tests/
+```
+
+## Router (Handler)
+
+```python
+@router.post("/users", response_model=UserOut, status_code=201)
+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(409, "User already exists")
+```
+
+## Schemas (Pydantic v2)
+
+```python
+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}
+```
+
+## Service
+
+```python
+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),
+        )
+```
+
+## Repository (SQLAlchemy 2.0)
+
+```python
+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
+```
+
+## Auth (OAuth2 + JWT)
+
+```python
+from passlib.hash import argon2
+from jose import jwt
+
+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)
+    return jwt.encode({"sub": sub, "exp": expire}, settings.JWT_SECRET, algorithm="HS256")
+```
+
+## Rate limit (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, ...):
+    ...
+```
+
+## Settings
+
+```python
+class Settings(BaseSettings):
+    DATABASE_URL: str
+    JWT_SECRET: str
+    model_config = SettingsConfigDict(env_file=".env")
+
+settings = Settings()
+```
+
+## Testes
+
+```python
+@pytest.mark.asyncio
+async def test_create_user(client: AsyncClient, admin_token: str):
+    res = await client.post("/v1/users",
+        json={"email": "jane@example.com", "name": "Jane", "password": "longsecret123"},
+        headers={"Authorization": f"Bearer {admin_token}"})
+    assert res.status_code == 201
+
+@pytest.mark.asyncio
+async def test_duplicate_email(client, admin_token):
+    await client.post("/v1/users", json={...}, headers={...})
+    res = await client.post("/v1/users", json={...}, headers={...})
+    assert res.status_code == 409
+```
+
+## Antipatterns
+
+| AP | Antipattern | Correção |
+|---|---|---|
+| AP-01 | SQLAlchemy no router | Repository via Depends |
+| AP-02 | Validação manual | Pydantic schema |
+| AP-03 | Lógica no router | Service |
+| AP-04 | `return user` 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 | Senha em response | `response_model=UserOut` sem password |
+| AP-08 | Sem `from_attributes=True` | adicionar no model_config |
+
+## Segurança (com `/dare-security`)
+
+- Argon2 via passlib
+- JWT HS256 (`JWT_SECRET ≥ 32 bytes`) ou RS256
+- Headers middleware (HSTS, X-Frame-Options)
+- CORS específico
+- Rate limit em login + APIs públicas
+
+## CI
+
+```bash
+ruff check .
+ruff format --check .
+mypy app
+pytest --cov=app --cov-fail-under=80
+pip-audit
+```
+
+## O que fazer
+
+1. Audit:
+   ```bash
+   grep -rn "db\.execute" app/api/
+   grep -rn "request\.json()" app/api/
+   ```
+2. `request.json()` → Pydantic schema
+3. Lógica em router > 5 linhas → Service
+4. SQLAlchemy em router → Repository
+5. Configurar `slowapi`, settings via env, OpenAPI customizado
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method.

package/templates/ide/claude/.claude/commands/skill-go-gin-api.md

@@ -0,0 +1,232 @@
+# /skill-go-gin-api
+
+Padrões DARE para APIs REST em Go + Gin (ou stdlib net/http) + sqlc + PostgreSQL. Handlers, services, repositories, middleware, validador, JWT, rate limit, swag OpenAPI.
+
+## Como usar
+
+```
+/skill-go-gin-api                          # audita projeto Go
+/skill-go-gin-api scaffold users           # gera handler + service + repo + sqlc query
+/skill-go-gin-api migrate-validation       # extrai json.Unmarshal manual para binding tags
+```
+
+## Stack canônica
+
+- Go 1.22+ (slog, errors.Is/As, generics)
+- Gin (preferido) ou stdlib net/http
+- sqlc (queries seguras geradas de SQL)
+- pgx v5
+- go-playground/validator (via Gin binding tags)
+- golang-jwt/jwt v5
+- swaggo/swag (OpenAPI)
+- testify + httptest
+- golangci-lint + govulncheck
+
+## Estrutura
+
+```
+cmd/server/main.go
+internal/
+├── handlers/       ← Handler
+├── services/       ← Service
+├── repositories/   ← Repository (sqlc)
+├── domain/         ← Models + erros sentinela
+├── middleware/
+└── config/
+db/
+├── migrations/     ← golang-migrate
+└── queries/        ← .sql para sqlc
+sqlc.yaml
+```
+
+## Handler
+
+```go
+// @Summary Create user
+// @Router /users [post]
+func (h *UserHandler) Create(c *gin.Context) {
+    var dto CreateUserDTO
+    if err := c.ShouldBindJSON(&dto); err != nil {
+        c.JSON(400, gin.H{"error": err.Error()})
+        return
+    }
+    user, err := h.register.Execute(c.Request.Context(), dto.ToService())
+    if err != nil {
+        if errors.Is(err, domain.ErrUserAlreadyExists) {
+            c.JSON(409, gin.H{"error": "USER_EXISTS"})
+            return
+        }
+        c.JSON(500, gin.H{"error": "INTERNAL"})
+        return
+    }
+    c.JSON(201, ToUserResponse(user))
+}
+```
+
+## DTO
+
+```go
+type CreateUserDTO struct {
+    Email    string `json:"email" binding:"required,email"`
+    Name     string `json:"name" binding:"required,min=1,max=255"`
+    Password string `json:"password" binding:"required,min=12"`
+}
+```
+
+## Service
+
+```go
+type RegisterUser struct {
+    repo *repositories.UserRepository
+}
+
+func (s *RegisterUser) Execute(ctx context.Context, in RegisterUserInput) (*domain.User, error) {
+    exists, err := s.repo.ExistsByEmail(ctx, in.Email)
+    if err != nil { return nil, err }
+    if exists { return nil, domain.ErrUserAlreadyExists }
+    return s.repo.Create(ctx, repositories.CreateUserParams{
+        Email: in.Email,
+        Name:  in.Name,
+        PasswordHash: hashPassword(in.Password),
+    })
+}
+```
+
+## Repository (sqlc)
+
+```sql
+-- db/queries/users.sql
+-- name: ExistsUserByEmail :one
+SELECT EXISTS(SELECT 1 FROM users WHERE email = $1);
+
+-- name: CreateUser :one
+INSERT INTO users (email, name, password_hash) VALUES ($1, $2, $3)
+RETURNING id, email, name, created_at;
+```
+
+```go
+type UserRepository struct { q *sqlc.Queries }
+func (r *UserRepository) ExistsByEmail(ctx context.Context, email string) (bool, error) {
+    return r.q.ExistsUserByEmail(ctx, email)
+}
+```
+
+## Domain (erros sentinela)
+
+```go
+var (
+    ErrUserAlreadyExists = errors.New("user already exists")
+    ErrUserNotFound      = errors.New("user not found")
+)
+```
+
+## Middleware (JWT)
+
+```go
+func AuthRequired(secret []byte) gin.HandlerFunc {
+    return func(c *gin.Context) {
+        tokenStr := strings.TrimPrefix(c.GetHeader("Authorization"), "Bearer ")
+        token, err := jwt.Parse(tokenStr, func(t *jwt.Token) (any, error) { return secret, nil })
+        if err != nil || !token.Valid {
+            c.AbortWithStatusJSON(401, gin.H{"error": "Unauthorized"})
+            return
+        }
+        c.Set("user_id", token.Claims.(jwt.MapClaims)["sub"])
+        c.Next()
+    }
+}
+```
+
+## Rate limit
+
+```go
+import "github.com/gin-contrib/limit"
+router.Use(limit.MaxAllowed(20))
+login := router.Group("/auth").Use(myRateLimiter("5/15m"))
+```
+
+## OpenAPI (swag)
+
+```bash
+swag init -g cmd/server/main.go -o docs
+```
+
+```go
+import _ "myapp/docs"
+router.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
+router.GET("/openapi.json", func(c *gin.Context) { c.File("docs/swagger.json") })
+```
+
+## Testes
+
+```go
+// Service unit
+func TestCreateUser(t *testing.T) {
+    repo := &mocks.UserRepository{}
+    repo.On("ExistsByEmail", mock.Anything, "jane@example.com").Return(false, nil)
+    repo.On("Create", mock.Anything, mock.Anything).Return(&domain.User{ID: 1}, nil)
+    svc := services.NewRegisterUser(repo)
+    user, err := svc.Execute(ctx, ...)
+    require.NoError(t, err)
+}
+
+// Handler via httptest
+func TestUserHandlerCreate(t *testing.T) {
+    r := gin.New()
+    r.POST("/users", h.Create)
+    w := httptest.NewRecorder()
+    req := httptest.NewRequest("POST", "/users", strings.NewReader(`{...}`))
+    r.ServeHTTP(w, req)
+    assert.Equal(t, 201, w.Code)
+}
+```
+
+## Antipatterns
+
+| AP | Antipattern | Correção |
+|---|---|---|
+| AP-01 | `database/sql` no handler | Repository + sqlc |
+| AP-02 | Validação manual | `binding:` tags |
+| AP-03 | Lógica no handler | Service |
+| AP-04 | Retornar `db.User` direto | DTO `UserResponse` |
+| AP-05 | Secret hardcoded | `os.Getenv` ou viper |
+| AP-06 | Sem rate limit em login | middleware |
+| AP-07 | `panic` em handler | recovery middleware |
+| AP-08 | Context não propagado | sempre `ctx context.Context` |
+| AP-09 | SQL com `fmt.Sprintf` | sqlc / parametrizado |
+| AP-10 | `errors.New` espalhado | sentinela em domain/errors.go |
+
+## Segurança (com `/dare-security`)
+
+- Argon2 (`golang.org/x/crypto/argon2`)
+- JWT HS256 com secret ≥32 bytes, ou RS256
+- `gin-contrib/cors` com origens específicas
+- Rate limit em login
+
+## CI
+
+```bash
+go vet ./...
+golangci-lint run
+go test ./... -race -cover
+govulncheck ./...
+```
+
+## O que fazer
+
+1. Audit:
+   ```bash
+   grep -rn "database/sql" internal/handlers/
+   grep -rn "json.Unmarshal" internal/handlers/
+   grep -rn "fmt.Sprintf.*SELECT" internal/
+   ```
+2. `json.Unmarshal` → struct com `binding:`
+3. Lógica em handler > 5 linhas → Service
+4. SQL em handler → sqlc query + Repository
+5. Configurar middleware auth + rate limit + swag
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method.