@dewtech/dare-cli 2.16.0 → 3.0.0

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

@@ -0,0 +1,75 @@
+# /dare-dna
+
+Camada semântica da extração de DNA do projeto. Roda **depois** do comando `dare dna`, que já varreu
+o código e extraiu os fatos de convenção. Sua função é **transformar fatos em regras acionáveis** —
+o "como esse codebase faz as coisas" que uma nova feature deve respeitar.
+
+## Como usar
+
+```
+/dare-dna                 # preenche o PROJECT-DNA.md gerado por `dare dna`
+```
+
+> Pré-requisito: rodar `dare dna` antes (gera `DARE/PROJECT-DNA.md` e `DARE/dna-facts.json`).
+> Se não existirem, instrua o usuário a rodar `dare dna` primeiro.
+
+## Quando usar
+
+- Projeto **legado** que vai adotar o DARE para novas features, sem reescrever o existente.
+- Acabou de rodar `dare dna` e o `PROJECT-DNA.md` tem seções `<!-- AGENT -->` em aberto.
+- O objetivo é um **ruleset** que faça o agente seguir o padrão da casa, não o default genérico.
+
+## O que fazer
+
+### 1. Carregar os fatos (não re-varrer tudo)
+
+- Leia `DARE/dna-facts.json` — fonte determinística (tooling, naming, camadas, testes, libs, commits).
+- Abra **2-5 arquivos representativos por camada** (um controller, um service, um model, um teste) para
+  inferir os padrões que o CLI não detecta (tratamento de erro, validação, estilo de teste).
+
+### 2. Preencher `DARE/PROJECT-DNA.md`
+
+Substitua cada bloco `<!-- AGENT: ... -->`:
+
+- **Convenções de Nomenclatura** — confirme o estilo detectado e documente exceções (ex.: componentes
+  em PascalCase, utilitários em kebab).
+- **Arquitetura & Camadas** — nomeie o padrão com confiança (MVC / Layered / Hexagonal) e escreva as
+  **regras de onde cada coisa mora** (ex.: "controllers só orquestram; regra de negócio vai em services;
+  acesso a dados só em repositories").
+- **Padrões de Teste** — onde os testes ficam, naming, assertions reais (não `expect(true)`), uso de
+  mocks/fixtures.
+- **Tratamento de Erros & Validação** — como o projeto trata erros (exceptions, Result/Either, try/catch)
+  e valida inputs. Dê **exemplos concretos** do código real.
+- **Regras de Ouro do Projeto** — liste o que **SEMPRE** e o que **NUNCA** fazer neste codebase.
+- **⚠️ Incertezas / Inconsistências** — convenções ambíguas/misturadas que o humano precisa decidir.
+
+**Não toque** nos fatos determinísticos já preenchidos pelo CLI (tooling, tabela de naming, libs).
+
+### 3. Apresentar ao usuário
+
+Resumo: arquitetura nomeada, principais regras de ouro, inconsistências encontradas. Reforce que o
+`PROJECT-DNA.md` vira referência para `/dare-feature-design` e `/dare-execute` respeitarem o legado.
+
+## Regras de ouro
+
+1. **Descritivo, não aspiracional** — documente como o código É, não como deveria ser.
+2. **Exemplos reais** — cite arquivos/trechos do próprio projeto nas regras.
+3. **Sinalize inconsistência** — se o legado mistura padrões, diga isso em "⚠️ Incertezas", não invente um padrão único.
+4. **Não re-varra** — os fatos já estão em `dna-facts.json`.
+5. **Preserve o determinístico** — não reescreva tooling/naming/libs gerados pelo CLI.
+
+## Antipatterns
+
+| AP | Antipattern | Por quê |
+|---|---|---|
+| AP-01 | Documentar o padrão "ideal" em vez do real | O agente vai gerar código fora do estilo do legado |
+| AP-02 | Forçar um padrão único onde o legado é inconsistente | Esconde a realidade; melhor sinalizar a incerteza |
+| AP-03 | Reescrever os fatos determinísticos do CLI | Quebra a fonte de verdade |
+| AP-04 | Regras vagas ("siga boas práticas") | Inúteis — o valor está na regra específica do projeto |
+| AP-05 | Ignorar os testes existentes ao descrever o estilo de teste | Nova feature nasce inconsistente |
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method. DNA do projeto (brownfield). Pareia com o comando `dare dna`.

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