@dewtech/dare-cli 2.11.0 → 2.12.0

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

@@ -11,63 +11,142 @@ Executa uma task específica do `DARE/dare-dag.yaml` seguindo o Ralph Loop.
 
 ## O que fazer
 
-1. **Leia `DARE/BLUEPRINT.md`** — obrigatório antes de qualquer implementação
-
-2. **Leia a task especificada** em `DARE/dare-dag.yaml`:
-   - Extraia `subtask_prompt`
-   - Verifique `complexity` (LOW/MED/HIGH)
-   - Liste `depends_on`
-
-3. **Verifique dependências:**
-   - Todas as tasks em `depends_on` devem ter status `DONE` em `DARE/TASKS.md`
-   - Se alguma estiver `PENDING`, alerte o usuário (a menos que `--force`)
-   - Se alguma estiver `FAILED`, recuse executar
-
-4. **Implemente a task** seguindo o `subtask_prompt`:
-   - Siga padrões do `CLAUDE.md`
-   - Crie/modifique arquivos conforme spec
-   - Adicione testes
-   - Implemente validações de segurança
-
-5. **Execute o Ralph Loop:**
-   - **Build:** compile sem erros
-   - **Test:** todos os testes passando (incluindo os novos)
-   - **Lint:** sem warnings
-
-6. **Atualize `DARE/TASKS.md`:**
-   - Mude status para `DONE`
-   - Adicione duração e tokens consumidos se possível
-
-7. **Crie artifact em `DARE/EXECUTION/task-<id>.md`:**
-   ```markdown
-   # Task <id>: <título>
-   
-   ## Status: ✅ DONE
-   ## Duração: <ms>
-   
-   ## Arquivos criados/modificados
-   - path/to/file1.ts
-   - path/to/file2.test.ts
-   
-   ## Testes
-   - ✅ test_should_x
-   - ✅ test_should_y
-   
-   ## Ralph Loop
-   - ✅ Build
-   - ✅ Test
-   - ✅ Lint
-   ```
-
-8. **Sugira a próxima task** disponível (com dependências satisfeitas)
+### 1. Leia `DARE/BLUEPRINT.md` — obrigatório
+
+Antes de qualquer implementação. Foque em:
+- Stack técnica e versões (seção 2)
+- Validation gates da stack (seção 7)
+- Controles de segurança mapeados (seção 8)
+
+### 2. Leia a task em `DARE/dare-dag.yaml` e `DARE/EXECUTION/task-<id>.md`
+
+- `subtask_prompt` — instrução self-contained da task
+- `complexity` — LOW/MED/HIGH (define rigor do Ralph Loop)
+- `depends_on` — verifique status antes de executar
+- Spec em `EXECUTION/task-<id>.md` — objetivo, arquivos, validation gates
+
+### 3. Verifique dependências
+
+- Todas as tasks em `depends_on` devem ter status `DONE` em `DARE/TASKS.md`
+- Se alguma estiver `PENDING` → alerte o usuário (a menos que `--force`)
+- Se alguma estiver `FAILED` → recuse executar e informe
+
+### 4. Implemente a task
+
+- Siga padrões do `CLAUDE.md` e da spec em `EXECUTION/task-<id>.md`
+- Crie/modifique arquivos conforme seção "Arquivos a criar/modificar"
+- Implemente testes com assertions reais (não `assertTrue(true)`)
+- Aplique os controles de segurança listados na seção 5 da spec
+
+### 5. Execute o Ralph Loop (obrigatório antes de DONE)
+
+Se qualquer etapa falhar, leia o erro, corrija e reexecute. **Não marque DONE sem todos os gates verdes.**
+
+#### 5.1 Build
+```bash
+# Rust: cargo build
+# Node: npm run build
+# Python: python -m py_compile **/*.py  (ou mypy para tipo)
+# PHP: php artisan config:cache
+# Go: go build ./...
+```
+
+#### 5.2 Test
+```bash
+# Rust: cargo test --workspace
+# Node: npm test
+# Python: pytest
+# PHP: php artisan test
+# Go: go test ./...
+```
+
+#### 5.3 Lint
+```bash
+# Rust: cargo clippy -- -D warnings
+# Node: npx eslint src --max-warnings=0
+# Python: ruff check .
+# PHP: ./vendor/bin/phpstan analyse
+# Go: golangci-lint run
+```
+
+#### 5.4 Auditoria de Dependências
+
+**Execute SEMPRE que esta task adicionar ou atualizar dependências externas.**
+
+```bash
+# Node.js / npm
+npm audit --audit-level=high
+# Se houver vulnerabilidades corrigíveis:
+npm audit fix
+
+# Rust / Cargo
+cargo audit
+# Para auto-fix (bumpa versões compatíveis):
+cargo update  # depois verificar Cargo.lock
+
+# Python / pip
+pip-audit
+# Para instalar: pip install pip-audit
+# Fix: atualizar versão no requirements.txt / pyproject.toml
+
+# PHP / Composer
+composer audit
+# Fix: composer update --with-all-dependencies [pacote]
+```
+
+> **Gate obrigatório:** a task só pode ser marcada como DONE se não houver CVE de nível HIGH ou CRITICAL nas dependências do projeto. CVEs de nível MODERATE devem ser documentados com justificativa se não puderem ser corrigidos imediatamente.
+
+#### 5.5 Verificação de Secrets (para tasks que mexem em configuração ou CI)
+
+```bash
+# Verificar se não há secrets hardcoded antes de commitar
+# Procurar padrões comuns:
+grep -rn "password\s*=\s*['\"][^'\"]" src/ || true
+grep -rn "api_key\s*=\s*['\"][^'\"]" src/ || true
+grep -rn "secret\s*=\s*['\"][^'\"]" src/ || true
+# Use git-secrets ou trufflehog se disponível no projeto
+```
+
+### 6. Atualize `DARE/TASKS.md`
+
+Mude o status para `DONE` e adicione duração se souber.
+
+### 7. Crie artifact em `DARE/EXECUTION/task-<id>.md`
+
+```markdown
+# Task <id>: <título>
+
+## Status: ✅ DONE
+## Duração: <estimativa>
+
+## Arquivos criados/modificados
+- path/to/file1.ts
+- path/to/file2.test.ts
+
+## Testes
+- ✅ test_should_x_when_y
+- ✅ test_should_return_401_when_unauthenticated
+
+## Ralph Loop
+- ✅ Build
+- ✅ Test
+- ✅ Lint
+- ✅ Auditoria de deps (se aplicável)
+
+## Segurança
+- ✅ Input validation aplicada
+- ✅ Autenticação/autorização verificada
+- ✅ Sem secrets em código
+```
+
+### 8. Sugira a próxima task disponível
+
+Liste as tasks com `depends_on` satisfeito e status `PENDING`. Indique qual rodar com `/dare-execute <id>`.
 
 ## Modo Paralelo
 
-Para executar múltiplas tasks em paralelo, use o CLI direto:
 ```bash
 dare execute --parallel --runner claude
 ```
 
-Isto executa tasks por rank topológico, respeitando `depends_on`.
-
 $ARGUMENTS

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

@@ -0,0 +1,232 @@
+# /dare-security
+
+Guia completo de segurança para todas as fases do DARE. Use para: revisar o DESIGN/BLUEPRINT com foco em segurança, implementar controles em uma task específica, ou auditar o projeto existente.
+
+## Como usar
+
+```
+/dare-security                        # auditoria geral do projeto
+/dare-security task-005               # revisar segurança de uma task específica
+/dare-security design                 # revisar DARE/DESIGN.md com lente de segurança
+/dare-security deps                   # auditar dependências vulneráveis agora
+```
+
+## Aplicação por fase
+
+### `/dare-security design` — Revisar DESIGN.md
+
+Leia `DARE/DESIGN.md` e verifique:
+- [ ] Seção RS-* com requisitos de segurança numerados existe
+- [ ] RS-01 (validação de entrada), RS-02 (hash/criptografia), RS-03 (controle de acesso), RS-04 (auditoria de deps), RS-05 (secrets) presentes
+- [ ] Riscos de segurança identificados com mitigações (SSRF, Injection, Auth bypass...)
+- [ ] Fora do escopo não omite itens de segurança críticos para v1
+
+### `/dare-security deps` — Auditar dependências
+
+Execute o comando de auditoria da stack do projeto:
+
+```bash
+# Detectar stack automaticamente e rodar
+npm audit --audit-level=high         # se package.json presente
+cargo audit                          # se Cargo.toml presente
+pip-audit                            # se requirements.txt / pyproject.toml presente
+composer audit                       # se composer.json presente
+govulncheck ./...                    # se go.mod presente
+```
+
+**Critério:** CVE HIGH ou CRITICAL = reportar ao usuário com versão afetada, CVE ID e versão corrigida disponível. Propor o fix (bump de versão ou substituição de pacote).
+
+**Auto-fix quando seguro:**
+```bash
+npm audit fix                        # Node — corrige sem breaking changes
+cargo update                         # Rust — bumpa dentro das constraints do Cargo.toml
+pip install --upgrade [pacote]       # Python — atualizar pacote específico
+```
+
+---
+
+## OWASP Top 10 — Referência Rápida por Stack
+
+### A01 — Broken Access Control
+
+```typescript
+// Node/NestJS — guard + policy
+@UseGuards(JwtAuthGuard, PoliciesGuard)
+@CheckPolicies(ability => ability.can(Action.Update, Post))
+async update(@Param('id') id: string, @CurrentUser() user: User) {
+  // ORM já filtra por ownership via policy
+}
+```
+
+```python
+# FastAPI — dependency injection para verificar ownership
+async def get_post_or_403(post_id: str, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    post = db.query(Post).filter(Post.id == post_id, Post.author_id == current_user.id).first()
+    if not post:
+        raise HTTPException(403)
+    return post
+```
+
+```rust
+// Rust/Axum — extractor verifica ownership
+async fn update_post(
+    State(db): State<Pool<Postgres>>,
+    claims: Claims,  // extraído do JWT
+    Path(post_id): Path<Uuid>,
+    Json(body): Json<UpdatePostBody>,
+) -> Result<Json<Post>, AppError> {
+    let post = sqlx::query_as!(Post,
+        "SELECT * FROM posts WHERE id = $1 AND author_id = $2",
+        post_id, claims.sub  // filtra por owner
+    ).fetch_one(&db).await?;
+    // ...
+}
+```
+
+### A02 — Cryptographic Failures
+
+```typescript
+// Node — Argon2 via @node-rs/argon2
+import { hash, verify } from '@node-rs/argon2';
+const hashed = await hash(password);             // hash
+const valid = await verify(hashed, password);    // verify
+```
+
+```python
+# Python — passlib com Argon2
+from passlib.hash import argon2
+hashed = argon2.hash(password)
+valid = argon2.verify(password, hashed)
+```
+
+```rust
+// Rust — argon2 crate
+use argon2::{Argon2, PasswordHash, PasswordHasher, PasswordVerifier, password_hash::SaltString};
+let salt = SaltString::generate(&mut OsRng);
+let hash = Argon2::default().hash_password(password.as_bytes(), &salt)?.to_string();
+```
+
+### A03 — Injection
+
+```typescript
+// TypeScript/Prisma — parametrizado por padrão
+const user = await prisma.user.findFirst({ where: { email } }); // ✅
+
+// NestJS — nunca QueryBuilder com interpolação
+.where(`user.email = '${email}'`)  // ❌
+.where('user.email = :email', { email })  // ✅
+```
+
+```python
+# SQLAlchemy — sempre parametrizado
+db.execute(select(User).where(User.email == email))  # ✅
+db.execute(f"SELECT * FROM users WHERE email = '{email}'")  # ❌
+```
+
+### A06 — Vulnerable Components (Ralph Loop obrigatório)
+
+```bash
+# Adicionar ao pipeline CI (GitHub Actions):
+- name: Security audit
+  run: |
+    npm audit --audit-level=high     # Node
+    # ou cargo audit                 # Rust
+    # ou pip-audit                   # Python
+    # ou composer audit              # PHP
+```
+
+### A07 — Authentication Failures
+
+```typescript
+// Rate limiting com @nestjs/throttler
+@Throttle({ default: { limit: 5, ttl: 900000 } })  // 5 req / 15 min
+@Post('login')
+async login() { ... }
+
+// JWT: access token curto, refresh com rotação
+const accessToken = jwt.sign(payload, secret, { expiresIn: '15m' });
+const refreshToken = jwt.sign({ sub: userId }, refreshSecret, { expiresIn: '7d' });
+// Salvar refresh token hash no DB para invalidação no logout
+```
+
+### Prompt Injection (projetos com LLM)
+
+```python
+# Nunca concatenar input do usuário diretamente na instrução do sistema
+system_prompt = f"Você é um assistente. {user_input}"  # ❌ CRÍTICO
+
+# Separar claramente instrução de dados:
+messages = [
+    {"role": "system", "content": "Você é um assistente. Responda apenas sobre o documento fornecido."},
+    {"role": "user", "content": f"<documento>{sanitize(user_document)}</documento>\n\nPergunta: {sanitize(user_question)}"}
+]
+# Sanitize: remova ou escape sequências como "Ignore as instruções acima"
+```
+
+---
+
+## Gestão de Secrets
+
+### O que nunca commitar
+
+```bash
+# Configure git-secrets ou detect-secrets:
+pip install detect-secrets
+detect-secrets scan > .secrets.baseline
+
+# Padrões críticos a bloquear:
+# password = "..."
+# api_key = "..."
+# DATABASE_URL com credenciais
+# AWS_SECRET_ACCESS_KEY
+# private_key
+```
+
+### Estrutura correta
+
+```
+.env              ← valores reais (no .gitignore)
+.env.example      ← template sem valores (commitado)
+```
+
+```bash
+# .env.example — sempre commitado, sem valores reais
+DATABASE_URL=postgres://user:password@localhost:5432/dbname
+JWT_SECRET=your-secret-here-min-32-chars
+STRIPE_SECRET_KEY=sk_test_...
+```
+
+---
+
+## Headers de Segurança HTTP
+
+```typescript
+// NestJS — helmet middleware
+import helmet from 'helmet';
+app.use(helmet());
+app.use(helmet.hsts({ maxAge: 31536000, includeSubDomains: true }));
+```
+
+```python
+# FastAPI — middleware de headers
+from starlette.middleware.base import BaseHTTPMiddleware
+class SecurityHeadersMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request, call_next):
+        response = await call_next(request)
+        response.headers["X-Frame-Options"] = "DENY"
+        response.headers["X-Content-Type-Options"] = "nosniff"
+        response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains"
+        return response
+```
+
+```rust
+// Axum — layer de headers de segurança
+use tower_http::set_header::SetResponseHeaderLayer;
+let app = Router::new()
+    .layer(SetResponseHeaderLayer::overriding(
+        header::X_FRAME_OPTIONS,
+        HeaderValue::from_static("DENY"),
+    ));
+```
+
+$ARGUMENTS

package/templates/ide/claude/CLAUDE.md

@@ -10,9 +10,9 @@ Você é o Claude Code, assistente de desenvolvimento seguindo o método DARE:
 ## Regras Fundamentais
 - Sempre leia `DARE/BLUEPRINT.md` antes de implementar qualquer feature
 - Atualize o status em `DARE/TASKS.md` ao concluir cada task
-- Nunca pule o Ralph Loop (build → test → lint) antes de marcar uma task como DONE
+- Nunca pule o Ralph Loop (build → test → lint → audit) antes de marcar uma task como DONE
 - Aprovação humana obrigatória antes de merge para a branch principal
-- Use os slash commands `/dare-design`, `/dare-blueprint`, `/dare-execute`, `/dare-tasks`, `/dare-rust-leptos`, `/dare-rust-workspace`
+- Use os slash commands `/dare-design`, `/dare-blueprint`, `/dare-execute`, `/dare-tasks`, `/dare-security`, `/dare-rust-leptos`, `/dare-rust-workspace`
 
 ## Estrutura do Projeto
 ```
@@ -105,14 +105,42 @@ Quando habilitado, o MCP Server expõe queries de contexto em `http://localhost:
 ## Ralph Loop (obrigatório antes de DONE)
 
 1. **Build** — compile e verifique erros
-2. **Test** — rode a suite de testes completa
-3. **Lint** — rode o linter/formatter
-4. Só marque DONE se os 3 passos passarem sem erros
+2. **Test** — rode a suite de testes completa (assertions reais, não `assertTrue(true)`)
+3. **Lint** — rode o linter/formatter sem warnings
+4. **Audit** — se a task adicionou ou atualizou dependências: `npm audit --audit-level=high` / `cargo audit` / `pip-audit` / `composer audit`
+5. Só marque DONE se **todos os 4 passos** passarem sem erros
+6. CVE HIGH/CRITICAL em deps = task FAILED até corrigir
 
 ## Segurança
 
-- Nunca exponha secrets em logs ou outputs
-- Valide e sanitize todas as entradas
-- Use proteções OWASP Top 10
-- Autenticação/autorização em todos os endpoints sensíveis
-- Rate limiting em endpoints públicos
+### Controles obrigatórios em toda implementação
+
+- **Nunca** exponha secrets, senhas, tokens ou PII em logs, respostas de erro ou stack traces
+- **Valide no servidor** toda entrada do usuário antes de qualquer processamento (OWASP A03)
+- **Controle de acesso por recurso**, não só por rota — verifique ownership (OWASP A01)
+- **Hash de senhas** com Argon2id ou Bcrypt (custo ≥ 12) — nunca MD5/SHA1/texto plano (OWASP A02)
+- **Rate limiting** em endpoints de autenticação e públicos (OWASP A07)
+- **Auditoria de dependências** sem CVE HIGH/CRITICAL antes de todo release (OWASP A06)
+- **Secrets** via variáveis de ambiente / vault — nunca hardcoded em código ou commits
+
+### Auditoria de dependências por stack
+
+```bash
+npm audit --audit-level=high     # Node — + npm audit fix para auto-corrigir
+cargo audit                      # Rust — + cargo update para bumpar
+pip-audit                        # Python — pip install pip-audit
+composer audit                   # PHP — nativo no Composer 2.4+
+govulncheck ./...                # Go — ferramenta oficial Google
+```
+
+### Headers de segurança em produção
+
+```
+Strict-Transport-Security: max-age=31536000; includeSubDomains
+X-Frame-Options: DENY
+X-Content-Type-Options: nosniff
+Content-Security-Policy: default-src 'self'
+Referrer-Policy: strict-origin-when-cross-origin
+```
+
+Use `/dare-security` para o guia completo de segurança (OWASP Top 10 completo, exemplos por stack, supply chain, prompt injection para projetos IA).