@dewtech/dare-cli 3.3.0 → 3.4.0

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

@@ -1,75 +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`.
+# /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

@@ -1,207 +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.
+# /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.