@dewtech/dare-cli 2.16.0 → 3.0.0

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.

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

@@ -0,0 +1,149 @@
+# /dare-frontend-design
+
+Arquitetura frontend DARE para projetos React e Vue. Detecta god components, fetch inline em JSX/template, e gera scaffold DARE-compliant.
+
+## Como usar
+
+```
+/dare-frontend-design                    # audita projeto atual
+/dare-frontend-design lint               # roda checks AP-01 a AP-06
+/dare-frontend-design scaffold <página>  # gera Page + Container + Hook + Presentational
+```
+
+## Arquitetura
+
+```
+Page  →  Container (lógica)  →  Presentational (puro)
+           ↑
+        Hook (fetch + cache)
+```
+
+## As 4 regras
+
+### 1. Componente < 300 linhas
+
+Se passar de 300, quebrar em sub-componentes, hooks ou helpers.
+
+### 2. Zero `fetch()` em JSX/template
+
+Use TanStack Query (React/Vue), SWR ou similar. Hook devolve `{ data, isLoading, error }`.
+
+### 3. Error Boundary em cada Page
+
+React: `<ErrorBoundary>` wrapping rotas.
+Vue: `onErrorCaptured` em layout/page-level.
+
+### 4. Bundle size monitorado
+
+`rollup-plugin-visualizer`, `webpack-bundle-analyzer`. Limite por chunk (ex: <300KB inicial).
+
+## Métricas obrigatórias
+
+| ID | Métrica |
+|---|---|
+| M-01 | 100% de componentes < 300 linhas |
+| M-02 | 0 `fetch()` direto em JSX/template |
+| M-03 | 100% de páginas com error boundary |
+| M-04 | Bundle config presente |
+
+## Antipatterns
+
+| AP | Antipattern | Correção |
+|---|---|---|
+| AP-01 | God component (>300 linhas) | Quebrar em sub-componentes + hooks |
+| AP-02 | Fetch em JSX | Mover para hook |
+| AP-03 | Booleanos isLoading espalhados | Discriminated union de estados |
+| AP-04 | Sem error boundary | Wrap em `<ErrorBoundary>` |
+| AP-05 | Estilo inline pesado | CSS module/styled |
+| AP-06 | Props drilling profundo | Context/Zustand/Pinia |
+
+## O que fazer
+
+### Passo 1: Detectar god components
+
+```bash
+find src/ -name "*.tsx" -o -name "*.vue" | xargs wc -l | sort -rn | head -20
+```
+
+### Passo 2: Detectar fetch inline
+
+```bash
+grep -rn "fetch(\|axios\." src/components/ src/pages/
+```
+
+### Passo 3: Migrar para hooks de dados
+
+```tsx
+// Antes
+function UserList() {
+  const [users, setUsers] = useState([]);
+  useEffect(() => { fetch('/api/users').then(r => r.json()).then(setUsers); }, []);
+  return <ul>{users.map(...)}</ul>;
+}
+
+// Depois
+function UserList() {
+  const { data, isLoading, error } = useUsers();
+  if (isLoading) return <Spinner />;
+  if (error) return <ErrorMessage error={error} />;
+  return <ul>{data.map(...)}</ul>;
+}
+
+function useUsers() {
+  return useQuery({ queryKey: ['users'], queryFn: () => api.users.list() });
+}
+```
+
+### Passo 4: Error boundaries
+
+```tsx
+// React
+class ErrorBoundary extends React.Component { ... }
+
+<ErrorBoundary fallback={<ErrorPage />}>
+  <UserList />
+</ErrorBoundary>
+```
+
+```vue
+<!-- Vue -->
+<script setup>
+import { onErrorCaptured } from 'vue';
+onErrorCaptured((err) => { logError(err); return false; });
+</script>
+```
+
+### Passo 5: Bundle analyzer
+
+```typescript
+// vite.config.ts
+import { visualizer } from 'rollup-plugin-visualizer';
+export default {
+  plugins: [visualizer({ open: false, gzipSize: true })],
+  build: { chunkSizeWarningLimit: 300 }
+};
+```
+
+## Stack recomendada
+
+| Camada | React | Vue |
+|---|---|---|
+| Roteamento | React Router / Next | Vue Router / Nuxt |
+| Estado server | TanStack Query | TanStack Vue Query |
+| Estado client | Zustand / Jotai | Pinia |
+| Styling | Tailwind / CSS Modules | Tailwind / SCSS |
+| Testes | Vitest + Testing Library | Vitest + Testing Library |
+
+## Saída esperada
+
+Reporte:
+- Top 10 componentes com mais linhas
+- Lista de `fetch()`/`axios` inline em componentes
+- Páginas sem error boundary
+- Configuração de bundle (presente/ausente)
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method.

package/templates/ide/claude/.claude/commands/dare-laravel-api.md

@@ -0,0 +1,211 @@
+# /dare-laravel-api
+
+Padrões DARE para APIs REST em Laravel 11 + PHP 8.3. Strict Types, FormRequests, Services, Resources, Repositories, Eloquent + casts, tratamento global de exceções, testes Pest, PHPStan/Larastan nível 8.
+
+## Como usar
+
+```
+/dare-laravel-api                          # audita projeto Laravel
+/dare-laravel-api scaffold users           # gera CRUD com camadas
+/dare-laravel-api migrate-controllers      # extrai lógica de Controllers para Services
+```
+
+## Stack canônica
+
+- PHP 8.3 com `declare(strict_types=1);` em todo arquivo
+- Laravel 11.x modo API
+- PostgreSQL 16 ou MySQL 8
+- Pest para testes (ou PHPUnit 11)
+- PHPStan + Larastan nível 8
+- Pint para formatação
+- Sanctum para auth
+
+## Layered Design
+
+| Camada | Pasta Laravel |
+|---|---|
+| Handler | `app/Http/Controllers/` |
+| Service | `app/Services/` |
+| Repository | `app/Repositories/` |
+| Model | `app/Models/` |
+| Presenter | `app/Http/Resources/` |
+
+## Controllers (Handler)
+
+```php
+<?php declare(strict_types=1);
+
+namespace App\Http\Controllers;
+
+use App\Http\Requests\StoreUserRequest;
+use App\Http\Resources\UserResource;
+use App\Services\RegisterUser;
+
+final class UserApiController extends Controller
+{
+    public function __construct(private RegisterUser $service) {}
+
+    public function store(StoreUserRequest $request): UserResource
+    {
+        $user = $this->service->execute($request->validated());
+        return new UserResource($user);
+    }
+}
+```
+
+Regras:
+- Apenas: recebe → valida via FormRequest → chama Service → retorna Resource
+- NUNCA: query Eloquent, lógica de negócio, validação inline
+
+## FormRequests
+
+```php
+final class StoreUserRequest extends FormRequest
+{
+    public function authorize(): bool { return $this->user()->can('create', User::class); }
+
+    public function rules(): array {
+        return [
+            'email' => ['required', 'email', 'unique:users,email'],
+            'password' => ['required', 'string', 'min:12'],
+        ];
+    }
+}
+```
+
+## Services
+
+Uma operação por classe:
+
+```php
+final class RegisterUser
+{
+    public function __construct(private UserRepository $users) {}
+
+    public function execute(array $data): User
+    {
+        if ($this->users->existsByEmail($data['email'])) {
+            throw new UserAlreadyExistsException();
+        }
+        return $this->users->create([...$data, 'password' => Hash::make($data['password'])]);
+    }
+}
+```
+
+## Repositories
+
+```php
+final class UserRepository
+{
+    public function existsByEmail(string $email): bool {
+        return User::where('email', $email)->exists();
+    }
+    public function create(array $data): User {
+        return User::create($data);
+    }
+}
+```
+
+## Resources
+
+Nunca retorne Model direto:
+
+```php
+final class UserResource extends JsonResource
+{
+    public function toArray($request): array {
+        return [
+            'id' => $this->id,
+            'email' => $this->email,
+            'createdAt' => $this->created_at?->toIso8601String(),
+        ];
+    }
+}
+```
+
+## Exceções globais (`bootstrap/app.php`)
+
+```php
+->withExceptions(function (Exceptions $exceptions) {
+    $exceptions->render(fn (UserAlreadyExistsException $e) =>
+        response()->json(['error' => 'User exists', 'code' => 'USER_EXISTS'], 409));
+})
+```
+
+## Transações
+
+```php
+DB::transaction(function () use ($data) {
+    $user = User::create($data);
+    UserProfile::create([...]);
+});
+```
+
+## Testes Pest
+
+```php
+it('cria usuário com sucesso', function () {
+    $this->actingAs(User::factory()->admin()->create())
+         ->postJson('/api/users', ['email' => 'jane@example.com', 'name' => 'Jane', 'password' => 'longsecret123'])
+         ->assertCreated();
+});
+
+it('rejeita email duplicado', function () {
+    User::factory()->create(['email' => 'taken@example.com']);
+    $this->actingAs(User::factory()->admin()->create())
+         ->postJson('/api/users', ['email' => 'taken@example.com', ...])
+         ->assertStatus(409);
+});
+```
+
+Cobertura mínima por endpoint: 200/201, 422, 401/403, 404.
+
+## Antipatterns
+
+| AP | Antipattern | Correção |
+|---|---|---|
+| AP-01 | `$request->validate()` no Controller | FormRequest |
+| AP-02 | Query Eloquent no Controller | Repository |
+| AP-03 | Lógica no Controller | Service |
+| AP-04 | Retornar Model direto | JsonResource |
+| AP-05 | `$guarded = []` | `$fillable` explícito |
+| AP-06 | Sem `declare(strict_types=1)` | Adicionar no topo |
+| AP-07 | Múltiplas inserções sem transaction | `DB::transaction()` |
+| AP-08 | `bcrypt()` default cost | `Hash::make($pwd, ['rounds' => 12])` |
+
+## Validação no CI
+
+```bash
+./vendor/bin/phpstan analyse --level=8
+./vendor/bin/pint --test
+./vendor/bin/pest --coverage --min=80
+```
+
+## O que fazer
+
+1. Audit:
+   ```bash
+   grep -rn "request()->validate" app/Http/Controllers/
+   grep -rn "::where\|::find" app/Http/Controllers/
+   ./vendor/bin/phpstan analyse --level=8
+   ```
+2. Para cada `$request->validate(...)` → FormRequest com `php artisan make:request`
+3. Para cada Controller com lógica > 10 linhas → Service
+4. Para cada query Eloquent em Controller → Repository
+5. Substituir `return $user` por `return new UserResource($user)`
+6. Adicionar `declare(strict_types=1);` em todo arquivo
+
+## Segurança (combinar com `/dare-security`)
+
+- Hash com `Hash::make($pwd, ['rounds' => 12])` ou Argon2
+- Sanctum para SPA/mobile
+- `ThrottleRequests` middleware
+- Headers de segurança (HSTS, X-Frame, CSP) em middleware
+- CORS específico, nunca `*` em produção
+- `$fillable` SEMPRE, nunca `$guarded = []`
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method.

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

@@ -0,0 +1,124 @@
+# /dare-layered-design
+
+Enforce arquitetura estrita de 4 camadas (Handlers, Services, Repositories, Models) em projetos DARE — independente de linguagem.
+
+## Como usar
+
+```
+/dare-layered-design                        # audita projeto atual
+/dare-layered-design lint                   # roda checks AP-01 a AP-06
+/dare-layered-design scaffold <recurso>     # gera CRUD com camadas corretas
+```
+
+## As 4 camadas
+
+```
+Handler  →  Service  →  Repository  →  Model
+(HTTP)      (negócio)   (I/O)         (domínio)
+```
+
+### Handler
+- Recebe request, valida input, chama um Service, retorna response
+- **Nunca** acessa Repository direto, **nunca** instancia Service com `new`
+
+### Service
+- Implementa uma operação de negócio (`RegisterUser`, `RefundPayment`)
+- Orquestra Repositories
+- **Nunca** sabe sobre HTTP, **nunca** faz SQL inline
+
+### Repository
+- Abstrai persistência (DB, cache, API externa)
+- Retorna Model ou primitivo
+- **Nunca** retorna HTTP status, **nunca** lança exceção de domínio
+
+### Model
+- Entidade pura do domínio
+- **Nunca** importa Repository/Service/Handler
+
+## Métricas obrigatórias
+
+| ID | Métrica |
+|---|---|
+| M-01 | 100% dos Services têm testes unitários (sem DB/HTTP real) |
+| M-02 | 0% de chamadas Handler→Repository direto |
+| M-03 | 100% dos Handlers usam injeção (sem `new Service()`) |
+| M-04 | 100% dos Repositories são agnósticos das camadas superiores |
+
+## Tabela por linguagem
+
+| Camada | Laravel | NestJS | FastAPI | Rails | Rust | Go |
+|---|---|---|---|---|---|---|
+| Handler | `Http/Controllers/` | `*.controller.ts` | `routers/` | `app/controllers/` | `handlers/` | `handlers/` |
+| Service | `Services/` | `*.service.ts` | `services/` | `app/services/` | `services/` | `services/` |
+| Repository | `Repositories/` | `*.repository.ts` | `repositories/` | `app/repositories/` | `repositories/` | `repositories/` |
+| Model | `Models/` | `entities/` | `models/` | `app/models/` | `domain/` | `models/` |
+
+## Antipatterns
+
+| AP | Antipattern | Sinal |
+|---|---|---|
+| AP-01 | Handler→Repository direto | `controller.repo.find()` |
+| AP-02 | Service com SQL inline | `db.query()` em Service |
+| AP-03 | Repository lança exceção de domínio | `throw UserNotFound` |
+| AP-04 | Model importa Service | acoplamento invertido |
+| AP-05 | God Service (>20 métodos) | `UserService.everything()` |
+| AP-06 | Fat Controller (>100 linhas) | lógica em Handler |
+
+## O que fazer
+
+### Passo 1: Mapear camadas existentes
+
+Liste as pastas atuais e classifique cada uma como Handler, Service, Repository, Model ou "indefinido". Indefinido = candidato a refactor.
+
+### Passo 2: Detectar violações com grep
+
+```bash
+# AP-01: Handler→Repository direto
+grep -rn "Repository" src/controllers/    # Laravel/NestJS
+grep -rn "Repository" app/controllers/    # Rails
+
+# AP-02: SQL inline em Service
+grep -rn "SELECT\\|INSERT\\|UPDATE\\|DELETE" src/services/
+
+# AP-03: Exceção de domínio em Repository
+grep -rn "throw.*NotFound\\|raise.*NotFound" src/repositories/
+```
+
+### Passo 3: Quebrar God Service
+
+Para cada Service com >20 métodos, separe em vários services nomeados por operação:
+- `UserService.register()` → `RegisterUser`
+- `UserService.resetPassword()` → `ResetPassword`
+- `UserService.delete()` → `DeleteUser`
+
+### Passo 4: Cobrir Services com testes unitários
+
+Service não depende de DB nem HTTP real — Repository é mockado:
+
+```typescript
+const repo = { findByEmail: jest.fn().mockResolvedValue({id: 1}) };
+const sut = new RegisterUserService(repo as any);
+await expect(sut.execute(...)).rejects.toThrow();
+```
+
+### Passo 5: Adicionar lint no CI
+
+```yaml
+- name: Layered design lint
+  run: |
+    grep -rn "Repository" src/controllers/ && exit 1 || true
+    grep -rn "new .*Service" src/controllers/ && exit 1 || true
+```
+
+## Saída esperada
+
+Reporte numerado por antipattern (AP-01 a AP-06):
+- Quantas violações por arquivo
+- Sugestão concreta de refactor para cada uma
+- Lista de Services sem cobertura unitária
+
+$ARGUMENTS
+
+---
+
+Skill MIT — parte do DARE Method. Inspirado em "Layered Design for Ruby on Rails Applications" de Vladimir Dementyev (Evil Martians).