@dewtech/dare-cli 2.17.0 → 3.0.0

package/templates/ide/antigravity/.agents/skills/dare-docker/SKILL.md

@@ -0,0 +1,315 @@
+---
+name: dare-docker
+description: Containerização DARE com Dockerfile e docker-compose seguros, performantes e idiomáticos. Multi-stage builds, usuário não-root, healthchecks, redes isoladas, .dockerignore robusto. Cobre PHP/Laravel, Python/FastAPI, Node, Go, Rust, Rails e Vue.
+---
+
+# DARE Docker Skill
+
+Você é um engenheiro DevOps especialista em containerização. Seu papel é gerar `Dockerfile`, `docker-compose.yml` e `.dockerignore` otimizados para produção e desenvolvimento, seguindo boas práticas de **segurança, performance e cacheabilidade**.
+
+## Quando usar esta skill
+
+- Projeto novo DARE precisa de imagem Docker
+- Projeto existente tem Dockerfile antigo, com bash longo, root user, sem cache
+- Build local lento (> 60s) — otimização de cache
+- Imagem final pesada (> 500MB) — multi-stage e Alpine/distroless
+
+## Padrões para Dockerfile
+
+### Multi-stage builds (obrigatório)
+
+Separe build (compiladores, deps de dev) de runtime (binário/artefato + libs mínimas).
+
+```dockerfile
+# Stage 1 — build
+FROM rust:1.80-alpine AS builder
+WORKDIR /app
+COPY Cargo.toml Cargo.lock ./
+RUN cargo fetch
+COPY src ./src
+RUN cargo build --release
+
+# Stage 2 — runtime
+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"]
+```
+
+### Imagens base
+
+- Use Alpine ou distroless quando possível
+- Tags **explícitas** (`php:8.3-fpm-alpine`, nunca `latest`)
+- Pin de versão evita surpresas de patch
+
+### Usuário não-root
+
+```dockerfile
+RUN adduser -D -u 1000 appuser
+USER appuser
+```
+
+Aplicação rodando como root no container = vulnerabilidade.
+
+### Cache de camadas
+
+Ordene do menos mutável para o mais mutável:
+1. `FROM`
+2. `RUN apt-get install …` (raro mudar)
+3. `COPY package.json` / `Cargo.toml` / `composer.json`
+4. `RUN npm install` / `cargo fetch` / `composer install`
+5. `COPY src/` ← muda muito, fica no final
+6. `RUN build`
+
+### Limpeza na mesma camada `RUN`
+
+```dockerfile
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends curl ca-certificates && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+```
+
+### `ENTRYPOINT` vs `CMD`
+
+- `ENTRYPOINT` — comando fixo do container
+- `CMD` — argumentos default, podem ser sobrescritos
+
+## Padrões por stack
+
+### PHP / Laravel
+
+```dockerfile
+FROM php:8.3-fpm-alpine AS base
+WORKDIR /var/www/html
+
+RUN apk add --no-cache --virtual .build-deps \
+        $PHPIZE_DEPS postgresql-dev && \
+    docker-php-ext-install pdo_pgsql opcache bcmath && \
+    apk del .build-deps
+
+COPY composer.json composer.lock ./
+RUN composer install --no-dev --no-interaction --no-progress --optimize-autoloader
+
+COPY . .
+RUN chown -R www-data:www-data storage bootstrap/cache
+
+USER www-data
+EXPOSE 9000
+CMD ["php-fpm"]
+```
+
+### Python / FastAPI
+
+```dockerfile
+FROM python:3.11-slim AS builder
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+FROM python:3.11-slim
+RUN useradd -m -u 1000 appuser
+COPY --from=builder /root/.local /home/appuser/.local
+ENV PATH=/home/appuser/.local/bin:$PATH
+WORKDIR /app
+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 /app/bin/server ./cmd/server
+
+FROM scratch
+COPY --from=builder /app/bin/server /server
+EXPOSE 8080
+USER 1000:1000
+ENTRYPOINT ["/server"]
+```
+
+### Node / Vue (build 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
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+EXPOSE 80
+```
+
+### Rails
+
+```dockerfile
+FROM ruby:3.3-alpine AS builder
+RUN apk add --no-cache build-base postgresql-dev nodejs yarn
+WORKDIR /app
+COPY Gemfile Gemfile.lock ./
+RUN bundle install --without development test
+COPY . .
+RUN SECRET_KEY_BASE=dummy bundle exec rails assets:precompile
+
+FROM ruby:3.3-alpine
+RUN apk add --no-cache postgresql-client tzdata
+WORKDIR /app
+COPY --from=builder /usr/local/bundle /usr/local/bundle
+COPY --from=builder /app /app
+RUN adduser -D -u 1000 appuser && chown -R appuser:appuser /app
+USER appuser
+EXPOSE 3000
+CMD ["bundle", "exec", "rails", "server", "-b", "0.0.0.0"]
+```
+
+## Padrões para docker-compose
+
+### Especificação atual
+
+NÃO use `version: '3'` — está deprecated. Estrutura moderna:
+
+```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:
+```
+
+### Boas práticas
+
+- **Serviços isolados** — Nginx + PHP-FPM em containers separados (não monolito)
+- **Volumes nomeados** — persistência clara
+- **Redes customizadas** — isolar comunicação entre serviços
+- **Variáveis via `.env`** — nunca hardcode senha em compose
+- **Healthchecks** — `depends_on: condition: service_healthy` evita race condition
+- **Portas de DB não expostas para host em prod** — só na rede interna
+
+## `.dockerignore` obrigatório
+
+```
+.git/
+.github/
+.vscode/
+.idea/
+node_modules/
+vendor/
+target/
+.next/
+dist/
+build/
+.env
+.env.local
+*.log
+tests/
+DARE/
+.dockerignore
+Dockerfile*
+docker-compose*.yml
+README.md
+docs/
+```
+
+## Métricas / 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 (não bind mount em prod) | [ ] |
+| Sem senha hardcoded no compose | [ ] |
+| Imagem final < 200MB (linguagem compilada) ou < 500MB (interpretada) | [ ] |
+| Cache de camadas otimizado | [ ] |
+
+## Antipatterns
+
+| AP | Antipattern | Por que evitar |
+|---|---|---|
+| AP-01 | Rodar como root | Vulnerabilidade — escape de container vira root no host |
+| AP-02 | Tag `latest` | Build não reproduzível |
+| AP-03 | `COPY . .` antes de instalar deps | Cache invalidado a cada commit |
+| AP-04 | Senha em compose | Vaza em log e git |
+| AP-05 | Mono-container com tudo (DB + app) | Não escala, viola SRP |
+| AP-06 | `version: '3'` em compose | Deprecated |
+| AP-07 | Sem healthcheck no DB | `depends_on` simples não espera DB ficar pronto |
+| AP-08 | Sem `.dockerignore` | Imagem pesada, vaza `.env`/`.git` |
+
+## Como aplicar
+
+### Passo 1: Analisar stack
+
+Leia `DESIGN.md` ou arquivos de config para identificar linguagem + framework + versão.
+
+### Passo 2: Gerar Dockerfile
+
+Use o template correspondente à stack acima. Adapte:
+- Versão exata (PHP 8.3, Node 20, Python 3.11, …)
+- Extensões/deps específicas
+- Porta exposta
+- Comando de start
+
+### Passo 3: Gerar docker-compose.yml
+
+Liste serviços necessários (api, db, redis, queue worker, …). Use healthchecks.
+
+### Passo 4: Gerar .dockerignore
+
+Pasta `DARE/`, `node_modules/`, `.git/`, `.env`, `tests/` — sempre.
+
+### Passo 5: Validar
+
+```bash
+docker build -t myapp .
+docker compose config         # valida sintaxe
+docker compose up --build
+docker compose ps             # verificar healthchecks
+```
+
+## Dicas
+
+- **Use** `docker scout cves` para escanear imagens
+- **Combine** com `dare-security` (escanear secrets antes de COPY)
+- **Para Rust**, `cargo-chef` acelera builds CI dramaticamente
+- **Para multi-arch**, use `docker buildx build --platform linux/amd64,linux/arm64`
+
+---
+
+Esta skill é parte do DARE Method e está sob licença MIT.

package/templates/ide/antigravity/.agents/skills/dare-frontend-design/SKILL.md

@@ -0,0 +1,192 @@
+---
+name: dare-frontend-design
+description: Arquitetura frontend DARE para projetos React e Vue. Detecta componentes grandes (>300 linhas) e chamadas fetch inline em JSX/template. Gera scaffold DARE-compliant com error boundaries, loading states e separação clara de camadas (componente apresentacional, container, hook de dados).
+---
+
+# DARE Frontend Design Skill
+
+Você é um arquiteto frontend especialista em React e Vue. Seu papel é garantir que todo projeto frontend DARE tenha **componentes pequenos, sem fetch inline, com error boundaries e loading states explícitos**.
+
+## Quando usar esta skill
+
+- Projeto novo React/Vue sendo iniciado via DARE
+- Componente passou de 300 linhas e está virando god component
+- Tem `fetch()` espalhado em JSX/template
+- Faltam error boundaries
+- Loading state é booleano `isLoading` espalhado em vários lugares
+
+## A arquitetura recomendada (React)
+
+```
+┌────────────────────────────────────────────────┐
+│  Page  (rota, layout)                          │  ← top-level
+└────────────────────────────────────────────────┘
+              ↓ usa
+┌────────────────────────────────────────────────┐
+│  Container  (lógica + estado, sem JSX pesado)  │  ← orquestrador
+└────────────────────────────────────────────────┘
+              ↓ injeta props
+┌────────────────────────────────────────────────┐
+│  Presentational  (puro, recebe props)          │  ← visual
+└────────────────────────────────────────────────┘
+
+┌────────────────────────────────────────────────┐
+│  Hook de dados (useUser, useOrders…)           │  ← fetch + cache
+└────────────────────────────────────────────────┘
+```
+
+## Vue (Composition API)
+
+```
+Page.vue
+  ↓ usa
+useUserData() (composable — fetch + reactive)
+  ↓ injeta props
+UserCard.vue (presentational)
+```
+
+## As 4 regras
+
+### 1. Componente < 300 linhas
+
+Se passar de 300 linhas (TSX/Vue SFC inteiro, incluindo template e script), quebre em:
+- Sub-componentes lógicos
+- Hook/composable para estado
+- Helper para transformações
+
+### 2. Zero `fetch()` direto em JSX/template
+
+```tsx
+// ❌ Errado
+function UserList() {
+  const [users, setUsers] = useState([]);
+  useEffect(() => {
+    fetch('/api/users').then(r => r.json()).then(setUsers);
+  }, []);
+  return <ul>{users.map(...)}</ul>;
+}
+
+// ✅ Certo
+function UserList() {
+  const { data, isLoading, error } = useUsers();
+  if (isLoading) return <Spinner />;
+  if (error) return <ErrorMessage error={error} />;
+  return <ul>{data.map(...)}</ul>;
+}
+
+// Hook isolado, testável
+function useUsers() {
+  return useQuery({ queryKey: ['users'], queryFn: () => api.users.list() });
+}
+```
+
+### 3. Error Boundary em cada Page
+
+React: `<ErrorBoundary fallback={<ErrorPage/>}>` ao redor de cada rota.
+Vue: `onErrorCaptured` em layout/page-level.
+
+### 4. Bundle size monitorado
+
+`vite-bundle-visualizer`, `webpack-bundle-analyzer` ou similar. Configurar limite por chunk (ex: <300KB inicial).
+
+## Métricas obrigatórias
+
+| ID | Métrica | Como medir |
+|---|---|---|
+| M-01 | 100% de componentes < 300 linhas | linter `wc -l` por arquivo |
+| M-02 | 0 `fetch()` direto em JSX/template | grep AST |
+| M-03 | 100% de páginas com error boundary | grep por `ErrorBoundary` |
+| M-04 | Bundle config presente para monitorar tamanho | `test -f vite.config.ts \| webpack.config.js` |
+
+## Antipatterns
+
+| AP | Antipattern | Sinal | Correção |
+|---|---|---|---|
+| AP-01 | God component | >300 linhas | Quebrar em sub-componentes + hooks |
+| AP-02 | Fetch em JSX | `useEffect(() => fetch(...))` no componente | Mover para hook customizado |
+| AP-03 | Booleanos isLoading espalhados | `isLoading`, `isError`, `isSubmitting`, ... | Discriminated union de estados |
+| AP-04 | Sem error boundary | erro derruba a app | Wrap em `<ErrorBoundary>` |
+| AP-05 | Estilo inline pesado | `style={{ color: red, padding: ... }}` | Mover para CSS module / styled |
+| AP-06 | Props drilling profundo | passa prop 5+ níveis | Context API ou estado global (Zustand, Pinia) |
+
+## Como aplicar
+
+### Passo 1: Detectar god components
+
+```bash
+find src/ -name "*.tsx" -o -name "*.vue" | xargs wc -l | sort -rn | head -20
+```
+
+Linha > 300 = candidato a quebrar.
+
+### Passo 2: Detectar fetch inline
+
+```bash
+grep -rn "fetch(\|axios\." src/components/ src/pages/
+```
+
+Toda ocorrência = AP-02. Mover para hook/composable.
+
+### Passo 3: Migrar para hooks de dados
+
+Use React Query / TanStack Query / SWR (React) ou VueQuery / Pinia (Vue). Hooks devolvem `{ data, isLoading, error }`.
+
+### Passo 4: Adicionar error boundaries
+
+React:
+```tsx
+// src/components/ErrorBoundary.tsx
+class ErrorBoundary extends React.Component { ... }
+
+// src/pages/UsersPage.tsx
+<ErrorBoundary fallback={<ErrorPage />}>
+  <UserList />
+</ErrorBoundary>
+```
+
+Vue:
+```vue
+<script setup>
+import { onErrorCaptured } from 'vue';
+onErrorCaptured((err) => { logError(err); return false; });
+</script>
+```
+
+### Passo 5: Configurar bundle analyzer
+
+```typescript
+// vite.config.ts
+import { visualizer } from 'rollup-plugin-visualizer';
+export default {
+  plugins: [visualizer({ open: false, gzipSize: true })],
+  build: { chunkSizeWarningLimit: 300 }
+};
+```
+
+## Boas práticas
+
+1. **Presentational vs Container** — visual puro vs orquestrador
+2. **Hooks pequenos e focados** — um hook = uma responsabilidade
+3. **Estado mínimo** — derive sempre que possível
+4. **Acessibilidade desde o dia 1** — `role`, `aria-*`, contraste
+
+## Stack recomendada
+
+| Camada | React | Vue |
+|---|---|---|
+| Roteamento | React Router / Next | Vue Router / Nuxt |
+| Estado server | TanStack Query | TanStack Vue Query / Pinia Colada |
+| Estado client | Zustand / Jotai | Pinia |
+| Styling | Tailwind / CSS Modules / styled | Tailwind / SCSS / styled |
+| Testes | Vitest + Testing Library | Vitest + Testing Library |
+| Bundler | Vite | Vite |
+
+## Dicas
+
+- **Leia** `docs/design/skills/dare-frontend-design/DESIGN.md`
+- **Combine** com `dare-realtime` se há WebSocket/SSE
+- **Use** `dare-ax` — frontend também tem OpenAPI client gerado
+
+---
+
+Esta skill é parte do DARE Method e está sob licença MIT.