@girardelli/architect 2.2.0 → 4.0.0

package/__test_agent_output__/rules/02-security.md

@@ -0,0 +1,402 @@
+---
+antigravity:
+  trigger: 'always_on'
+  globs: ['**/*']
+  description: 'Regras de segurança para test-project'
+  priority: CRITICAL
+---
+
+# 🛡️ Regras de Segurança — test-project
+
+> **Segurança NÃO é feature — é requisito. Toda linha de código é superfície de ataque.**
+
+---
+
+## ⚠️ REGRA ZERO DE SEGURANÇA
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  NUNCA confiar em input do usuário.                         ║
+║  NUNCA expor detalhes internos em respostas de erro.        ║
+║  NUNCA armazenar secrets em código.                         ║
+║  NUNCA desabilitar validação "temporariamente".             ║
+║  NUNCA commitar com security warnings ignorados.            ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## 🔐 OWASP Top 10 — Checklist Obrigatório
+
+### A01: Broken Access Control
+```
+❌ PROIBIDO: Endpoint sem verificação de autorização
+❌ PROIBIDO: IDOR (Insecure Direct Object Reference) — acessar recurso de outro usuário via ID
+✅ CORRETO: RBAC (Role-Based Access Control) em TODOS os endpoints
+✅ CORRETO: Verificar ownership do recurso antes de retornar
+
+Padrão:
+1. Autenticar (quem é?)
+2. Autorizar (pode fazer isso?)
+3. Verificar ownership (esse recurso é dele?)
+4. Executar ação
+```
+
+### A02: Cryptographic Failures
+```
+❌ PROIBIDO: Senhas em plain text
+❌ PROIBIDO: HTTP para dados sensíveis
+❌ PROIBIDO: Algoritmos fracos (MD5, SHA1 para passwords)
+✅ CORRETO: bcrypt/argon2 para passwords (cost ≥ 12)
+✅ CORRETO: HTTPS everywhere (HSTS)
+✅ CORRETO: AES-256-GCM para dados em repouso
+✅ CORRETO: TLS 1.2+ para dados em trânsito
+```
+
+### A03: Injection
+```
+❌ PROIBIDO: Concatenação de strings em queries SQL
+❌ PROIBIDO: Template strings com input de usuário
+❌ PROIBIDO: eval(), exec(), Function() com input externo
+✅ CORRETO: Queries parametrizadas SEMPRE
+✅ CORRETO: ORM com bindings
+✅ CORRETO: Input sanitization na borda (controller/pipe)
+
+Exemplos:
+  ❌ `SELECT * FROM users WHERE id = '${userId}'`
+  ✅ `SELECT * FROM users WHERE id = $1` + [userId]
+  ❌ `db.query(`...WHERE name = '${name}'`)`
+  ✅ `db.query('...WHERE name = ?', [name])`
+```
+
+### A04: Insecure Design
+```
+❌ PROIBIDO: Endpoints sem rate limiting
+❌ PROIBIDO: Reset de senha via link sem expiração
+❌ PROIBIDO: Lógica de negócio sem threat model
+✅ CORRETO: STRIDE analysis antes de implementar features sensíveis
+✅ CORRETO: Rate limiting em auth endpoints (≤ 5 tentativas/minuto)
+✅ CORRETO: Tokens com expiração curta (15min access, 7d refresh)
+```
+
+### A05: Security Misconfiguration
+```
+❌ PROIBIDO: CORS com origin: '*' em produção
+❌ PROIBIDO: Debug mode em produção
+❌ PROIBIDO: Default credentials
+❌ PROIBIDO: Stack traces em respostas de erro
+✅ CORRETO: CORS restritivo (origins explícitos)
+✅ CORRETO: Headers de segurança (X-Frame-Options, CSP, X-Content-Type-Options)
+✅ CORRETO: Error handling que retorna apenas mensagem genérica ao usuário
+
+Headers obrigatórios:
+  X-Content-Type-Options: nosniff
+  X-Frame-Options: DENY
+  X-XSS-Protection: 0 (CSP substitui)
+  Content-Security-Policy: default-src 'self'
+  Strict-Transport-Security: max-age=31536000; includeSubDomains
+  Referrer-Policy: strict-origin-when-cross-origin
+```
+
+### A06: Vulnerable and Outdated Components
+```
+❌ PROIBIDO: Dependências com vulnerabilidades conhecidas
+❌ PROIBIDO: Ignorar security advisories
+✅ CORRETO: Audit regular (npm audit / pip audit / safety check)
+✅ CORRETO: Renovate/Dependabot configurado
+✅ CORRETO: Lock files commitados (package-lock.json, poetry.lock)
+
+Comandos de verificação:
+  $ npm audit
+  $ npx audit-ci --critical
+  $ npx snyk test
+```
+
+### A07: Identification and Authentication Failures
+```
+❌ PROIBIDO: Sessions sem expiração
+❌ PROIBIDO: Tokens previsíveis
+❌ PROIBIDO: Brute force sem proteção
+✅ CORRETO: JWT com algoritmo explícito (RS256 ou ES256)
+✅ CORRETO: Refresh token rotation
+✅ CORRETO: Account lockout após N tentativas
+✅ CORRETO: MFA para operações sensíveis
+
+JWT Checklist:
+  □ Algoritmo explícito (nunca 'none')
+  □ Audience (aud) verificado
+  □ Issuer (iss) verificado
+  □ Expiração (exp) curta
+  □ Secret key ≥ 256 bits
+  □ Stored em httpOnly cookie (não localStorage)
+```
+
+### A08: Software and Data Integrity Failures
+```
+❌ PROIBIDO: CI/CD sem verificação de integridade
+❌ PROIBIDO: Deserialização de dados não confiáveis
+✅ CORRETO: Subresource Integrity (SRI) para CDN scripts
+✅ CORRETO: Signed commits
+✅ CORRETO: Pipeline protegido (branch protection rules)
+```
+
+### A09: Security Logging and Monitoring Failures
+```
+❌ PROIBIDO: Ações sensíveis sem log
+❌ PROIBIDO: Logs com dados sensíveis (passwords, tokens, PII)
+✅ CORRETO: Audit log para: login, logout, password change, permission change
+✅ CORRETO: Log level adequado (WARN/ERROR para falhas de auth)
+✅ CORRETO: Alertas para atividades anômalas
+
+O que logar:
+  ✅ Quem (user ID)
+  ✅ O quê (ação)
+  ✅ Quando (timestamp UTC)
+  ✅ Onde (IP, user-agent)
+  ✅ Resultado (sucesso/falha)
+
+O que NUNCA logar:
+  ❌ Passwords (nem em debug)
+  ❌ Tokens de autenticação
+  ❌ Dados de cartão de crédito
+  ❌ PII sem necessidade
+```
+
+### A10: Server-Side Request Forgery (SSRF)
+```
+❌ PROIBIDO: Fetch de URL fornecida pelo usuário sem validação
+❌ PROIBIDO: Acesso a metadata endpoints (169.254.169.254)
+✅ CORRETO: Allowlist de domínios para requests externos
+✅ CORRETO: Validação de schema (https only)
+✅ CORRETO: Block de IPs internos/privados
+```
+
+---
+
+## 🔑 Validação de Input
+
+### NestJS — class-validator + class-transformer
+
+```typescript
+// ✅ CORRETO: DTO com validação
+import { IsString, IsEmail, MinLength, MaxLength, IsOptional } from 'class-validator';
+
+export class CreateUserDto {
+  @IsString()
+  @MinLength(2)
+  @MaxLength(100)
+  name: string;
+
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  @MinLength(8)
+  @MaxLength(128)
+  password: string;
+}
+
+// Controller com ValidationPipe
+@Post()
+@UsePipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }))
+async create(@Body() dto: CreateUserDto) { ... }
+```
+
+**Regras:**
+- `whitelist: true` — remove campos não declarados no DTO
+- `forbidNonWhitelisted: true` — retorna 400 se campo extra enviado
+- `transform: true` — converte tipos automaticamente
+- NUNCA usar `@Body()` sem DTO validado
+
+---
+
+## 🔒 Autenticação & Autorização
+
+### NestJS Auth Pattern
+
+```
+Implementação padrão:
+1. AuthGuard global para rotas protegidas
+2. @Public() decorator para rotas abertas
+3. RolesGuard para autorização
+4. CurrentUser decorator para extrair user do token
+
+Hierarquia:
+  @Public()           → Sem autenticação
+  @UseGuards(AuthGuard) → Autenticado
+  @Roles('admin')     → Autenticado + Role específica
+  @OwnerGuard()       → Autenticado + Dono do recurso
+
+Fluxo de token:
+  Login → Access Token (15min) + Refresh Token (7d, httpOnly cookie)
+  Request → AuthGuard verifica Access Token
+  Expired → Refresh endpoint gera novo par
+  Logout → Invalidar Refresh Token no banco
+```
+
+---
+
+## 🗝️ Gestão de Secrets
+
+### Regras de Secrets
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  SECRETS NUNCA NO CÓDIGO. NUNCA. SEM EXCEÇÃO.               ║
+╚══════════════════════════════════════════════════════════════╝
+
+❌ PROIBIDO:
+  - API keys hardcoded
+  - Passwords em arquivos de config
+  - Tokens em constantes
+  - Connection strings com credenciais no código
+  - .env commitado no repositório
+
+✅ CORRETO:
+  - Environment variables
+  - Secret manager (AWS SSM, Vault, GCP Secret Manager)
+  - .env.example com placeholders (sem valores reais)
+  - .gitignore com: .env, .env.local, .env.*.local
+```
+
+### .gitignore obrigatório
+
+```
+# Secrets — NUNCA commitar
+.env
+.env.local
+.env.*.local
+*.pem
+*.key
+*.p12
+credentials.json
+service-account.json
+```
+
+### Detecção de secrets no CI
+
+```bash
+# Pre-commit hook (recomendado)
+# .pre-commit-config.yaml
+repos:
+  - repo: https://github.com/gitleaks/gitleaks
+    rev: v8.18.0
+    hooks:
+      - id: gitleaks
+
+# Ou manualmente:
+gitleaks detect --source . --verbose
+git secrets --scan
+```
+
+### Padrão de configuração
+
+```typescript
+// ✅ CORRETO
+const config = {
+  database: {
+    url: process.env.DATABASE_URL,     // De environment variable
+    ssl: process.env.DB_SSL === 'true',
+  },
+  jwt: {
+    secret: process.env.JWT_SECRET,     // NUNCA hardcoded
+    expiresIn: '15m',
+  },
+};
+
+// Validação no startup — falha rápido se falta secret
+const required = ['DATABASE_URL', 'JWT_SECRET'];
+for (const key of required) {
+  if (!process.env[key]) throw new Error(\`Missing env: \${key}\`);
+}
+```
+
+---
+
+## 🚨 Security Anti-Patterns Detectados
+
+✅ Nenhum anti-pattern de segurança detectado no scan automático.\n> ⚠️ Isso NÃO significa que o projeto está seguro. Análise manual é necessária.
+
+---
+
+## ✅ Checklist de Segurança por Camada
+
+### Controller / API Layer
+```
+□ Input validado com DTO/Schema
+□ Rate limiting configurado
+□ Auth guard aplicado
+□ CORS configurado corretamente
+□ Response não expõe dados internos
+□ Error handling sem stack trace
+```
+
+### Service / Business Layer
+```
+□ Autorização verificada (ownership)
+□ Dados sensíveis criptografados
+□ Lógica de negócio com audit log
+□ Sem eval/exec com input externo
+□ Timeout em operações externas
+```
+
+### Data / Repository Layer
+```
+□ Queries parametrizadas (NUNCA concatenação)
+□ Connection pooling com limits
+□ Migrations reversíveis
+□ Dados sensíveis com encryption at rest
+□ Backup policy definida
+```
+
+### Frontend / Mobile Layer
+```
+□ XSS prevenido (sanitization)
+□ CSRF token em formulários
+□ Tokens em httpOnly cookies (não localStorage)
+□ Content Security Policy
+□ Sem secrets no bundle (NUNCA)
+□ Validação client-side + server-side
+```
+
+---
+
+## 🛡️ Threat Model (STRIDE)
+
+Antes de implementar features sensíveis, usar template STRIDE:
+
+```
+| Ameaça              | Descrição                          | Mitigação |
+|---------------------|------------------------------------|-----------|
+| Spoofing            | Alguém se passando por outro       | Auth forte, MFA |
+| Tampering           | Dados alterados em trânsito        | TLS, HMAC, checksums |
+| Repudiation         | Negar ação realizada               | Audit logs |
+| Info Disclosure     | Vazamento de dados                 | Encryption, access control |
+| Denial of Service   | Indisponibilidade                  | Rate limiting, CDN, autoscaling |
+| Elevation of Priv.  | Escalar permissões                 | Least privilege, RBAC |
+```
+
+> Template completo disponível em: `templates/THREAT-MODEL.md`
+
+---
+
+## 📊 Verificação Automatizada
+
+```bash
+# Scan de vulnerabilidades em dependências
+npm audit
+npx audit-ci --critical
+
+# Scan de secrets no código
+# (configure pre-commit hook)
+git secrets --scan
+gitleaks detect
+
+# Score de arquitetura (inclui métricas de segurança)
+architect score ./src
+architect anti-patterns ./src
+```
+
+---
+
+**Gerado por Architect v3.1 · Score: 72/100**

package/__test_agent_output__/rules/03-nestjs.md

@@ -0,0 +1,124 @@
+---
+antigravity:
+  trigger: 'always_on'
+  globs: ['**/*.ts']
+  description: 'Regras NestJS para test-project'
+  priority: HIGH
+---
+
+# ⚙️ Regras NestJS — test-project
+
+> **Padrões obrigatórios para desenvolvimento NestJS.**
+
+---
+
+## 📦 Estrutura de Módulo
+
+```
+Cada feature = 1 módulo NestJS
+
+src/modules/[feature]/
+├── [feature].module.ts           → @Module({ imports, providers, exports })
+├── [feature].controller.ts       → @Controller() — HTTP endpoints
+├── [feature].controller.spec.ts  → Testes do controller
+├── [feature].service.ts          → @Injectable() — Lógica de negócio
+├── [feature].service.spec.ts     → Testes do service
+├── dto/
+│   ├── create-[feature].dto.ts   → class-validator + class-transformer
+│   ├── update-[feature].dto.ts   → Partial<CreateDto>
+│   └── [feature]-response.dto.ts → Response shape (NUNCA entity direta)
+├── entities/
+│   └── [feature].entity.ts       → @Entity() TypeORM / Prisma model
+├── guards/                        → Guards específicos
+├── pipes/                         → Pipes customizados
+└── interfaces/                    → Interfaces do módulo
+```
+
+---
+
+## 🎯 Decorators — Uso Correto
+
+```
+@Controller()  → Routing APENAS. Sem lógica de negócio.
+@Injectable()  → Services, Repositories. Injetáveis.
+@Module()      → Agrupa components. Declara imports/exports.
+@Entity()      → Modelo de banco. NUNCA expor na API.
+
+Guards:
+  @UseGuards(AuthGuard)     → Autenticação
+  @UseGuards(RolesGuard)    → Autorização
+  @Roles('admin', 'user')   → Roles necessárias
+
+Pipes:
+  @UsePipes(ValidationPipe) → Validação de DTO
+  { whitelist: true, forbidNonWhitelisted: true, transform: true }
+
+Interceptors:
+  @UseInterceptors(LoggingInterceptor)     → Logging
+  @UseInterceptors(TransformInterceptor)   → Response shape
+```
+
+---
+
+## 🚫 Anti-Patterns NestJS
+
+```
+❌ PROIBIDO: Lógica de negócio no controller
+   → Mover para service
+
+❌ PROIBIDO: Entity como response de API
+   → Criar DTO de response
+
+❌ PROIBIDO: @Body() sem DTO validado
+   → Criar DTO com class-validator
+
+❌ PROIBIDO: Service importando Request/Response
+   → Service recebe dados puros, controller adapta
+
+❌ PROIBIDO: Circular module imports
+   → Usar forwardRef() ou extrair shared module
+
+❌ PROIBIDO: Repository no controller
+   → Controller → Service → Repository
+
+❌ PROIBIDO: try/catch genérico no controller
+   → Usar exception filters
+
+❌ PROIBIDO: console.log
+   → Usar @nestjs/common Logger ou winston
+```
+
+---
+
+## ✅ Patterns NestJS Obrigatórios
+
+```
+✅ Global validation pipe no bootstrap
+✅ Global exception filter (HttpExceptionFilter)
+✅ DTOs com class-validator para TODOS os endpoints
+✅ Config via @nestjs/config + .env
+✅ Database via TypeORM/Prisma com migrations
+✅ Auth via Passport + JWT strategy
+✅ Swagger via @nestjs/swagger + ApiProperty()
+✅ Health check endpoint (/health)
+✅ Cobertura ≥ 80%
+```
+
+---
+
+## 📋 Checklist por Endpoint
+
+```
+□ DTO de request com validação
+□ DTO de response (não entity)
+□ Guard de auth aplicado
+□ Swagger decorators (@ApiTags, @ApiOperation, @ApiResponse)
+□ Error handling (HttpException com status correto)
+□ Teste unitário do service method
+□ Teste de integração do endpoint
+□ Logging estruturado
+```
+
+---
+
+**Gerado por Architect v3.1**

package/__test_agent_output__/templates/ADR.md

@@ -0,0 +1,95 @@
+# 📋 Template: ADR — Architecture Decision Record
+
+> Use quando uma decisão técnica é significativa ou controversa.
+
+---
+
+## ADR-001: Uso de NestJS para Backend
+
+**Status:** proposed | accepted | deprecated | superseded by ADR-YYY
+**Data:** YYYY-MM-DD
+**Autores:** [quem participou da decisão]
+
+---
+
+### Contexto
+
+> Qual é o problema ou necessidade que levou a esta decisão?
+
+O projeto requer uma API REST escalável com TypeScript. Precisamos escolher um framework que:
+- Suporte TypeScript nativo
+- Tenha decorators e dependency injection
+- Tenha comunidade ativa e documentação excelente
+
+---
+
+### Decisão
+
+> O que foi decidido?
+
+Decidimos usar NestJS como framework backend principal. NestJS oferece:
+- Arquitetura modular built-in
+- Decorators para roteamento e middleware
+- Injeção de dependência nativa
+- Suporte a bancos de dados (TypeORM, Prisma, etc.)
+
+---
+
+### Alternativas Consideradas
+
+| # | Alternativa | Prós | Contras | Por que descartada |
+|---|-----------|------|---------|-------------------|
+| 1 | Express.js + middleware customizado | [prós] | [contras] | [motivo] |
+| 2 | Fastify | [prós] | [contras] | [motivo] |
+
+---
+
+### Consequências
+
+**Positivas:**
+- Arquitetura clara e escalável
+- Código mais organizado e testável
+- Comunidade ativa para suporte
+
+**Negativas:**
+- Curva de aprendizado para novos desenvolvedores
+- Overhead de dependências
+
+**Riscos:**
+- Atualização de versões major — probabilidade: média
+
+---
+
+### Notas
+
+- Revisar em 6 meses se a decisão continua válida
+
+
+---
+
+## ADR-002: Banco de Dados PostgreSQL
+
+**Status:** accepted
+**Data:** 2024-01-15
+**Autores:** [equipe técnica]
+
+### Contexto
+
+Precisamos escolher um banco de dados relacional que:
+- Suporte transações ACID
+- Tenha integração com NestJS
+- Permita escalabilidade horizontal
+
+### Decisão
+
+Escolhemos PostgreSQL como banco de dados principal por:
+- Suporte a JSON nativo
+- Excelente performance em leitura/escrita
+- Integração com TypeORM/Prisma é padrão
+
+### Alternativas Consideradas
+
+| # | Alternativa | Prós | Contras |
+|---|-----------|------|---------|
+| 1 | MySQL | Popular, estável | Menos recursos avançados |
+| 2 | MongoDB | Escalável | Sem ACID nativo, schema dinâmico |

package/__test_agent_output__/templates/BDD.md

@@ -0,0 +1,58 @@
+# 🧪 Template: BDD — Behavior-Driven Development
+
+> Um cenário para cada critério de aceite + cenários de erro + edge cases.
+
+---
+
+## Feature: Criar e Validar User.Entity
+
+```gherkin
+Feature: Criar e Validar User.Entity
+  Como usuário,
+  Quero interagir com User.Entity,
+  Para alcançar meu objetivo de negócio.
+
+  # ── Happy Path ──
+
+  Scenario: Criar User.Entity com sucesso
+    Given o usuário está no formulário de criação de User.Entity
+    And todos os campos obrigatórios estão vazios
+    When o usuário preenche os campos corretamente
+    Then a entidade é persistida no banco de dados
+    And uma mensagem de sucesso é exibida ao usuário
+
+  # ── Validações ──
+
+  Scenario: Validação de dados obrigatórios
+    Given um formulário de criação
+    When o usuário tenta enviar sem preencher campos obrigatórios
+    Then mensagens de erro são exibidas para cada campo
+
+  # ── Edge Cases ──
+
+  Scenario: Lidar com valores boundary
+    Given o sistema aceita valores de 0 a 999999.99
+    When o usuário tenta inserir um valor fora do range
+    Then um erro de validação é retornado
+
+  # ── Permissões ──
+
+  Scenario: Acesso a dados sensíveis de paciente
+    Given um profissional de saúde autenticado
+    When o profissional acessa registros de paciente
+    Then o acesso é registrado com timestamp e usuário
+    And a ação é auditada para compliance
+```
+
+---
+
+## Checklist
+
+```
+□ Cada critério de aceite tem ≥ 1 cenário
+□ Happy path coberto
+□ Error paths cobertos
+□ Edge cases cobertos
+□ Permissões/autenticação cobertos
+□ Cenários são independentes entre si
+```