@dewtech/dare-cli 2.17.0 → 3.1.0

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

@@ -0,0 +1,207 @@
+# /dare-docker
+
+Containerização DARE com Dockerfile e docker-compose seguros, performantes e idiomáticos. Multi-stage, usuário não-root, healthchecks, redes isoladas.
+
+## Como usar
+
+```
+/dare-docker                        # detecta stack e gera Dockerfile + compose + .dockerignore
+/dare-docker dockerfile             # só Dockerfile
+/dare-docker compose                # só docker-compose.yml
+/dare-docker review                 # audita Dockerfile/compose existente
+```
+
+## Padrões para Dockerfile
+
+### 1. Multi-stage build (obrigatório)
+
+Separe build (compiladores) de runtime (artefato + libs mínimas).
+
+### 2. Imagens base
+
+- Alpine ou distroless quando possível
+- Tag explícita (`php:8.3-fpm-alpine`, nunca `latest`)
+- Pin de versão
+
+### 3. Usuário não-root
+
+```dockerfile
+RUN adduser -D -u 1000 appuser
+USER appuser
+```
+
+### 4. Cache de camadas
+
+Ordem: FROM → install deps → COPY deps lockfile → install deps → COPY src → build.
+
+### 5. Limpeza na mesma camada
+
+```dockerfile
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends pkg && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+```
+
+## Padrões por stack
+
+### PHP/Laravel
+```dockerfile
+FROM php:8.3-fpm-alpine
+RUN docker-php-ext-install pdo_pgsql opcache bcmath
+WORKDIR /var/www/html
+COPY composer.json composer.lock ./
+RUN composer install --no-dev --no-interaction --optimize-autoloader
+COPY . .
+USER www-data
+EXPOSE 9000
+CMD ["php-fpm"]
+```
+
+### Python/FastAPI
+```dockerfile
+FROM python:3.11-slim
+RUN useradd -m -u 1000 appuser
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY --chown=appuser:appuser . .
+USER appuser
+EXPOSE 8000
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
+```
+
+### Go
+```dockerfile
+FROM golang:1.22-alpine AS builder
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o /server ./cmd/server
+
+FROM scratch
+COPY --from=builder /server /server
+EXPOSE 8080
+USER 1000:1000
+ENTRYPOINT ["/server"]
+```
+
+### Node/Vue (estático)
+```dockerfile
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM nginx:alpine
+COPY --from=builder /app/dist /usr/share/nginx/html
+EXPOSE 80
+```
+
+### Rust
+```dockerfile
+FROM rust:1.80-alpine AS builder
+RUN apk add --no-cache musl-dev
+WORKDIR /app
+COPY Cargo.toml Cargo.lock ./
+COPY src ./src
+RUN cargo build --release
+
+FROM alpine:3.20
+RUN adduser -D -u 1000 appuser
+COPY --from=builder /app/target/release/myapp /usr/local/bin/myapp
+USER appuser
+EXPOSE 8080
+CMD ["myapp"]
+```
+
+## docker-compose.yml
+
+```yaml
+services:
+  api:
+    build: .
+    ports: ["8080:8080"]
+    env_file: .env
+    depends_on:
+      postgres: { condition: service_healthy }
+    networks: [internal]
+
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_PASSWORD: ${DB_PASSWORD}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      retries: 5
+    networks: [internal]
+
+volumes:
+  postgres_data:
+networks:
+  internal:
+```
+
+## .dockerignore
+
+```
+.git/
+.github/
+node_modules/
+vendor/
+target/
+dist/
+.env
+.env.local
+*.log
+tests/
+DARE/
+README.md
+docs/
+```
+
+## Checklist
+
+| Critério | OK |
+|---|---|
+| Multi-stage build | [ ] |
+| Usuário não-root no runtime | [ ] |
+| Tag explícita (não `latest`) | [ ] |
+| `.dockerignore` presente | [ ] |
+| Healthcheck nos serviços DB/cache | [ ] |
+| Volumes nomeados | [ ] |
+| Sem senha hardcoded no compose | [ ] |
+| Cache de camadas otimizado | [ ] |
+
+## Antipatterns
+
+| AP | Antipattern |
+|---|---|
+| AP-01 | Rodar como root |
+| AP-02 | Tag `latest` |
+| AP-03 | `COPY . .` antes de install deps |
+| AP-04 | Senha em compose |
+| AP-05 | Mono-container (DB + app) |
+| AP-06 | `version: '3'` em compose (deprecated) |
+| AP-07 | Sem healthcheck no DB |
+| AP-08 | Sem `.dockerignore` |
+
+## O que fazer
+
+1. Detectar stack (`composer.json`, `package.json`, `Cargo.toml`, etc.)
+2. Gerar Dockerfile usando o template correspondente
+3. Gerar `docker-compose.yml` com healthchecks
+4. Gerar `.dockerignore`
+5. Validar: `docker build .`, `docker compose config`, `docker compose up`
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method.

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

@@ -1,152 +1,152 @@
-# /dare-execute
-
-Executa uma task específica do `DARE/dare-dag.yaml` seguindo o Ralph Loop.
-
-## Como usar
-
-```
-/dare-execute task-001
-/dare-execute task-003 --force
-```
-
-## O que fazer
-
-### 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
-
-```bash
-dare execute --parallel --runner claude
-```
-
-$ARGUMENTS
+# /dare-execute
+
+Executa uma task específica do `DARE/dare-dag.yaml` seguindo o Ralph Loop.
+
+## Como usar
+
+```
+/dare-execute task-001
+/dare-execute task-003 --force
+```
+
+## O que fazer
+
+### 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
+
+```bash
+dare execute --parallel --runner claude
+```
+
+$ARGUMENTS

package/templates/ide/claude/.claude/commands/dare-feature-design.md

@@ -0,0 +1,147 @@
+# /dare-feature-design
+
+Analisa um projeto existente e gera `DARE/DESIGN-Feature-[Nome].md` focado apenas em adicionar uma nova feature, respeitando a arquitetura legada.
+
+## Como usar
+
+```
+/dare-feature-design                                        # interativo
+/dare-feature-design "Adicionar 2FA via TOTP no login"      # com descrição
+```
+
+## Quando usar
+
+- Projeto já existe e usuário pede para adicionar uma feature
+- Projeto não nasceu com Método DARE, mas vai adotar para novas funcionalidades
+- Feature é grande o suficiente para precisar de planejamento (não é fix de uma linha)
+
+## O que fazer
+
+### 1. Análise de contexto (obrigatória)
+
+Antes de propor qualquer coisa, leia o projeto:
+
+- **Stack** — `composer.json` / `package.json` / `Cargo.toml` / `go.mod` / `requirements.txt`
+- **Arquitetura** — MVC, Hexagonal, CQRS? Layered? Onde moram Controllers, Services, Repositories?
+- **Banco de dados** — leia migrations existentes para entender esquema da feature
+- **Dependências chave** — auth (Sanctum, JWT, Devise?), permissões (Spatie, Pundit?), forms, ORM
+- **Convenções** — naming, estrutura de pastas, padrões de teste
+
+### 2. Entender a feature
+
+- **Valor de negócio** — qual problema do usuário resolve?
+- **Novos endpoints / telas** — quais?
+- **Conexão com o existente** — usa que módulos? quem chama?
+- **Dados novos vs existentes** — tabela nova ou só colunas?
+
+### 3. Avaliar impacto e segurança
+
+- **Arquivos novos** — controllers, services, repositories, components a criar
+- **Arquivos modificados** — quais existentes vão precisar mudar?
+- **Banco de dados** — migrations + scripts de seed?
+- **Segurança específica (OWASP)** — auth, autorização por recurso, validação, rate limit
+- **Performance** — query nova é cara? cache? índice?
+
+### 4. Gerar `DARE/DESIGN-Feature-[Nome].md`
+
+Estrutura obrigatória:
+
+```markdown
+# Feature Design: [Nome da Feature]
+
+## Contexto no Projeto Existente
+Resumo de como a feature se encaixa no ecossistema atual.
+
+## Objetivos da Feature
+- [O-01] [objetivo 1 com métrica]
+- [O-02] [objetivo 2 com métrica]
+
+## Stakeholders
+| Papel | Pessoa/Time | Interesse |
+|---|---|---|
+
+## Análise de Impacto
+
+### Novos Arquivos
+- `app/Controllers/TwoFactorController.php`
+- `app/Services/EnrollTotp.php`
+- `app/Models/UserMfaSecret.php`
+
+### Arquivos Modificados
+- `app/Controllers/AuthController.php` — adiciona challenge step
+- `routes/api.php` — novas rotas
+
+### Banco de Dados
+- Nova tabela `user_mfa_secrets`
+- Coluna `users.mfa_enabled` (boolean default false)
+
+## Requisitos Funcionais
+| ID | Requisito | Prioridade | Critério de aceite |
+|---|---|---|---|
+| RF-01 | … | MUST | … |
+
+## Segurança Específica (OWASP)
+- **A01 (Access Control):** [como filtra por owner]
+- **A02 (Crypto):** [TOTP secret cifrado at rest]
+- **A03 (Injection):** [validações]
+- **A07 (Auth):** [rate limit no challenge]
+
+## Restrições e Cuidados
+- **NÃO alterar:** [partes do código legado intocáveis]
+- **Compatibilidade:** [usuários antigos sem MFA continuam funcionando]
+- **Migrations:** [reversível? safe em produção sem downtime?]
+
+## Estratégia de Rollout
+- Feature flag `feature.mfa_enabled` default off
+- Habilitar para 1% → 10% → 100%
+- Rollback = desabilitar flag
+
+## Métricas de Sucesso
+- M-01: % de usuários com MFA habilitado após 30 dias
+- M-02: queda em logins fraudulentos
+- M-03: 0 incidentes de lockout de conta legítima
+
+## Riscos e Mitigações
+| Risco | Probabilidade | Impacto | Mitigação |
+|---|---|---|---|
+
+## Fora do Escopo (v1)
+- WebAuthn (apenas TOTP)
+- Backup codes (próxima iteração)
+
+## Próximas Etapas
+1. Revisar e aprovar este Feature Design
+2. Rodar `/dare-blueprint` apontando para este arquivo
+3. Gerar tasks com `/dare-tasks`
+```
+
+### 5. Pedir aprovação
+
+Apresente o documento ao usuário. Mostre especialmente:
+- Os arquivos que serão modificados (impacto no legado)
+- A análise de segurança específica
+- O que NÃO será mudado
+
+## Regras de ouro para features em projetos existentes
+
+1. **Siga os padrões locais** — adapte a feature ao padrão existente, mesmo que você ache que poderia ser melhor (refactor é outra história)
+2. **Isolamento máximo** — mantenha o impacto no legado o mínimo possível
+3. **Testes nascem com a feature** — mesmo que o legado não tenha testes, a nova feature DEVE nascer com testes isolados
+4. **Segurança inegociável** — aplique OWASP na feature nova, mesmo que o legado seja inseguro
+5. **Feature flag quando possível** — permite rollout gradual e rollback fácil
+
+## Antipatterns
+
+| AP | Antipattern | Por quê |
+|---|---|---|
+| AP-01 | Refatorar legado junto com feature | Aumenta blast radius e dificulta revisão |
+| AP-02 | Ignorar padrões existentes | Feature vira "ilha" inconsistente |
+| AP-03 | Feature sem teste porque "legado não tem" | Perpetua o problema |
+| AP-04 | Modificar o que não é necessário | Bug introduzido em código não relacionado |
+| AP-05 | Pular análise de impacto | Surpresas em produção |
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method.