@the-bearded-bear/claude-craft 3.0.0

package/Dev/i18n/pt/Python/commands/check-code-quality.md

@@ -0,0 +1,174 @@
+---
+description: Verificar Qualidade do Código Python
+argument-hint: [arguments]
+---
+
+# Verificar Qualidade do Código Python
+
+## Argumentos
+
+$ARGUMENTS (opcional: caminho para o projeto a analisar)
+
+## MISSÃO
+
+Realizar uma auditoria completa da qualidade do código do projeto Python verificando conformidade com PEP8, tipagem, legibilidade e melhores práticas definidas nas regras do projeto.
+
+### Passo 1: Padrões de Codificação PEP8
+
+Verificar conformidade com convenções Python:
+- [ ] Nomenclatura: snake_case para funções/variáveis, PascalCase para classes
+- [ ] Indentação: 4 espaços (sem tabs)
+- [ ] Comprimento de linha: máximo 88 caracteres (Black)
+- [ ] Imports: organizados (stdlib, third-party, local) e ordenados
+- [ ] Espaços: ao redor de operadores, após vírgulas
+- [ ] Docstrings: presentes para módulos, classes, funções públicas
+
+**Comando**: Executar `docker run --rm -v $(pwd):/app python:3.11 python -m flake8 /app --max-line-length=88`
+
+**Referência**: `rules/03-coding-standards.md` seção "PEP 8 Compliance"
+
+### Passo 2: Type Hints e MyPy
+
+Verificar uso de tipagem estática:
+- [ ] Type hints em todos os parâmetros de função
+- [ ] Type hints em valores de retorno
+- [ ] Anotações para atributos de classe
+- [ ] Uso de `typing` para tipos complexos (Optional, Union, List, Dict)
+- [ ] Sem erros de MyPy em modo strict
+
+**Comando**: Executar `docker run --rm -v $(pwd):/app python:3.11 python -m mypy /app --strict`
+
+**Referência**: `rules/03-coding-standards.md` seção "Type Hints"
+
+### Passo 3: Linting com Ruff
+
+Analisar código com Ruff (substitui Flake8, isort, pydocstyle):
+- [ ] Sem imports não utilizados
+- [ ] Sem variáveis não utilizadas
+- [ ] Sem código morto (código inacessível)
+- [ ] Complexidade ciclomática aceitável (<10)
+- [ ] Regras de segurança respeitadas (regras S)
+
+**Comando**: Executar `docker run --rm -v $(pwd):/app python:3.11 pip install ruff && ruff check /app`
+
+**Referência**: `rules/06-tooling.md` seção "Linting and Formatting"
+
+### Passo 4: Formatação com Black
+
+Verificar consistência de formatação:
+- [ ] Código formatado com Black
+- [ ] Configuração do Black em pyproject.toml
+- [ ] Sem diferenças após `black --check`
+- [ ] Comprimento de linha consistente (88 caracteres)
+
+**Comando**: Executar `docker run --rm -v $(pwd):/app python:3.11 pip install black && black --check /app`
+
+**Referência**: `rules/06-tooling.md` seção "Code Formatting"
+
+### Passo 5: Princípios KISS, DRY, YAGNI
+
+Analisar simplicidade e clareza do código:
+- [ ] Funções curtas (<20 linhas idealmente)
+- [ ] Sem duplicação de código (DRY)
+- [ ] Sem over-engineering (YAGNI)
+- [ ] Nomenclatura explícita e auto-documentada
+- [ ] Único nível de abstração por função
+- [ ] Returns antecipados para reduzir complexidade
+
+**Referência**: `rules/05-kiss-dry-yagni.md`
+
+### Passo 6: Comentários e Documentação
+
+Avaliar qualidade da documentação:
+- [ ] Docstrings estilo Google ou NumPy
+- [ ] Comentários apenas para "por quê", não "o quê"
+- [ ] README.md completo com setup e uso
+- [ ] Sem código comentado (usar git)
+- [ ] Documentação de decisões arquiteturais importantes
+
+**Referência**: `rules/03-coding-standards.md` seção "Documentation"
+
+### Passo 7: Tratamento de Erros
+
+Verificar robustez do código:
+- [ ] Exceções específicas (não Exception genérico)
+- [ ] Sem `pass` silencioso em except
+- [ ] Mensagens de erro informativas
+- [ ] Validação de entrada do usuário
+- [ ] Gerenciamento adequado de recursos (context managers)
+
+**Referência**: `rules/03-coding-standards.md` seção "Error Handling"
+
+### Passo 8: Calcular Pontuação
+
+Atribuição de pontos (de 25):
+- PEP8 e formatação: 5 pontos
+- Type hints e MyPy: 5 pontos
+- Ruff linting: 4 pontos
+- KISS/DRY/YAGNI: 4 pontos
+- Documentação: 4 pontos
+- Tratamento de erros: 3 pontos
+
+## FORMATO DE SAÍDA
+
+```
+AUDITORIA DE QUALIDADE DO CÓDIGO PYTHON
+================================
+
+PONTUAÇÃO GERAL: XX/25
+
+PONTOS FORTES:
+- [Lista de boas práticas observadas]
+
+MELHORIAS:
+- [Lista de melhorias menores]
+
+PROBLEMAS CRÍTICOS:
+- [Lista de violações sérias de padrões]
+
+DETALHES POR CATEGORIA:
+
+1. PEP8 E FORMATAÇÃO (XX/5)
+   Status: [Conformidade com padrões Python]
+   Erros Flake8: XX
+   Diferenças Black: XX arquivos
+
+2. TYPE HINTS (XX/5)
+   Status: [Cobertura de tipagem estática]
+   Erros MyPy: XX
+   Cobertura: XX%
+
+3. RUFF LINTING (XX/4)
+   Status: [Qualidade do código]
+   Avisos: XX
+   Imports Não Utilizados: XX
+   Complexidade Máxima: XX
+
+4. KISS/DRY/YAGNI (XX/4)
+   Status: [Simplicidade e clareza]
+   Funções >20 linhas: XX
+   Código Duplicado: XX instâncias
+
+5. DOCUMENTAÇÃO (XX/4)
+   Status: [Qualidade da documentação]
+   Docstrings Faltando: XX
+   Cobertura: XX%
+
+6. TRATAMENTO DE ERROS (XX/3)
+   Status: [Robustez do código]
+   Exceções Genéricas: XX
+   `except pass`: XX
+
+TOP 3 AÇÕES PRIORITÁRIAS:
+1. [Ação mais crítica para melhorar qualidade]
+2. [Segunda ação prioritária]
+3. [Terceira ação prioritária]
+```
+
+## NOTAS
+
+- Executar todas as ferramentas de linting disponíveis no projeto
+- Usar Docker para abstrair do ambiente local
+- Fornecer exemplos de arquivos/linhas problemáticos
+- Sugerir correções automatizáveis (hooks de pre-commit)
+- Priorizar quick wins (formatação automática) vs refatoração profunda

package/Dev/i18n/pt/Python/commands/check-compliance.md

@@ -0,0 +1,260 @@
+---
+description: Verificar Conformidade Completa Python
+argument-hint: [arguments]
+---
+
+# Verificar Conformidade Completa Python
+
+## Argumentos
+
+$ARGUMENTS (opcional: caminho para o projeto a analisar)
+
+## MISSÃO
+
+Realizar uma auditoria completa de conformidade do projeto Python orquestrando as 4 verificações principais: Arquitetura, Qualidade do Código, Testes e Segurança. Produzir um relatório consolidado com pontuação geral de 100 pontos.
+
+### Passo 1: Preparação da Auditoria
+
+Preparar ambiente de auditoria:
+- [ ] Identificar caminho do projeto a auditar
+- [ ] Verificar presença de arquivos de configuração (pyproject.toml, requirements.txt)
+- [ ] Listar diretórios principais (src/, tests/, etc.)
+- [ ] Identificar estrutura do projeto
+
+**Nota**: Se $ARGUMENTS fornecido, usar como caminho do projeto, caso contrário usar diretório atual.
+
+### Passo 2: Auditoria de Arquitetura (25 pontos)
+
+Executar verificação completa de arquitetura:
+
+**Comando**: Usar comando slash `/check-architecture` ou seguir manualmente os passos em `check-architecture.md`
+
+**Critérios Avaliados**:
+- Estrutura e separação de camadas (6 pts)
+- Respeito às dependências (6 pts)
+- Ports and Adapters (4 pts)
+- Modelagem do domínio (4 pts)
+- Use Cases e Services (3 pts)
+- Princípios SOLID (2 pts)
+
+**Referência**: `claude-commands/python/check-architecture.md`
+
+### Passo 3: Auditoria de Qualidade do Código (25 pontos)
+
+Executar verificação de qualidade do código:
+
+**Comando**: Usar comando slash `/check-code-quality` ou seguir manualmente os passos em `check-code-quality.md`
+
+**Critérios Avaliados**:
+- PEP8 e formatação (5 pts)
+- Type hints e MyPy (5 pts)
+- Ruff linting (4 pts)
+- KISS/DRY/YAGNI (4 pts)
+- Documentação (4 pts)
+- Tratamento de erros (3 pts)
+
+**Referência**: `claude-commands/python/check-code-quality.md`
+
+### Passo 4: Auditoria de Testes (25 pontos)
+
+Executar verificação de testes:
+
+**Comando**: Usar comando slash `/check-testing` ou seguir manualmente os passos em `check-testing.md`
+
+**Critérios Avaliados**:
+- Cobertura de código (7 pts)
+- Testes unitários (6 pts)
+- Testes de integração (4 pts)
+- Qualidade de assertions (3 pts)
+- Fixtures e organização (3 pts)
+- Performance (2 pts)
+
+**Referência**: `claude-commands/python/check-testing.md`
+
+### Passo 5: Auditoria de Segurança (25 pontos)
+
+Executar verificação de segurança:
+
+**Comando**: Usar comando slash `/check-security` ou seguir manualmente os passos em `check-security.md`
+
+**Critérios Avaliados**:
+- Scan Bandit (6 pts)
+- Secrets e credenciais (5 pts)
+- Validação de entrada (4 pts)
+- Dependências seguras (4 pts)
+- Tratamento de erros (3 pts)
+- Auth/Authz (2 pts)
+- Injections (1 pt)
+
+**Referência**: `claude-commands/python/check-security.md`
+
+### Passo 6: Consolidação e Pontuação Global
+
+Calcular pontuação geral e produzir relatório consolidado:
+- [ ] Somar as 4 pontuações (máx 100 pontos)
+- [ ] Identificar categorias críticas (<50%)
+- [ ] Listar todos os problemas críticos transversais
+- [ ] Priorizar ações por impacto/esforço
+- [ ] Produzir relatório final consolidado
+
+**Escala de Avaliação**:
+- 90-100: Excelente - Projeto de referência
+- 75-89: Muito Bom - Algumas melhorias menores
+- 60-74: Aceitável - Requer melhorias
+- 40-59: Insuficiente - Refatoração importante necessária
+- 0-39: Crítico - Reformulação completa necessária
+
+### Passo 7: Recomendações e Plano de Ação
+
+Produzir recomendações finais:
+- [ ] Identificar top 3 ações prioritárias em todas as categorias
+- [ ] Estimar esforço (Baixo/Médio/Alto) para cada ação
+- [ ] Estimar impacto (Baixo/Médio/Alto) para cada ação
+- [ ] Propor ordem de implementação
+- [ ] Sugerir quick wins (alta relação impacto/esforço)
+
+## FORMATO DE SAÍDA
+
+```
+AUDITORIA DE CONFORMIDADE PYTHON - RELATÓRIO COMPLETO
+=============================================
+
+PONTUAÇÃO GERAL: XX/100
+
+NÍVEL DE CONFORMIDADE: [Excelente/Muito Bom/Aceitável/Insuficiente/Crítico]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+PONTUAÇÕES POR CATEGORIA:
+
+ARQUITETURA        : XX/25  [██████████░░░░░░░░░░] XX%
+QUALIDADE CÓDIGO   : XX/25  [██████████░░░░░░░░░░] XX%
+TESTES             : XX/25  [██████████░░░░░░░░░░] XX%
+SEGURANÇA          : XX/25  [██████████░░░░░░░░░░] XX%
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+PONTOS FORTES GERAIS:
+1. [Ponto forte identificado em múltiplas categorias]
+2. [Outro ponto forte importante]
+3. [Terceiro ponto forte]
+
+MELHORIAS GERAIS:
+1. [Melhoria transversal menor]
+2. [Outra melhoria recomendada]
+3. [Terceira melhoria]
+
+PROBLEMAS CRÍTICOS:
+1. [Problema crítico #1 - categoria afetada]
+2. [Problema crítico #2 - categoria afetada]
+3. [Problema crítico #3 - categoria afetada]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+DETALHES POR CATEGORIA:
+
+┌─────────────────────────────────────────────┐
+│ ARQUITETURA (XX/25)                         │
+└─────────────────────────────────────────────┘
+
+Sub-pontuações:
+  • Estrutura e camadas     : XX/6
+  • Dependências            : XX/6
+  • Ports and Adapters      : XX/4
+  • Modelagem Domínio       : XX/4
+  • Use Cases               : XX/3
+  • Princípios SOLID        : XX/2
+
+Pontos Fortes:
+- [Pontos fortes da arquitetura]
+
+Problemas:
+- [Problemas da arquitetura]
+
+[Seções similares para Qualidade do Código, Testes e Segurança...]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+TOP 3 AÇÕES PRIORITÁRIAS (TODAS AS CATEGORIAS):
+
+1. CRÍTICO - [Ação #1]
+   Categoria : [Arquitetura/Qualidade/Testes/Segurança]
+   Impacto   : [Alto/Médio/Baixo]
+   Esforço   : [Alto/Médio/Baixo]
+   Prioridade: IMEDIATA
+
+   Descrição detalhada:
+   [Explicação do problema e solução proposta]
+
+   Arquivos afetados:
+   - [arquivo:linha]
+
+   Exemplo de correção:
+   [Código ou comando de correção]
+
+2. IMPORTANTE - [Ação #2]
+   [Mesmo formato...]
+
+3. RECOMENDADO - [Ação #3]
+   [Mesmo formato...]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+QUICK WINS (Alto Impacto / Baixo Esforço):
+
+- [Quick win #1] - Categoria: [X] - Impacto: [X] - Esforço: [X]
+- [Quick win #2] - Categoria: [X] - Impacto: [X] - Esforço: [X]
+- [Quick win #3] - Categoria: [X] - Impacto: [X] - Esforço: [X]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+PLANO DE AÇÃO RECOMENDADO:
+
+SEMANA 1 (Imediato):
+- [ ] [Ação crítica #1]
+- [ ] [Quick win prioritário]
+
+SEMANA 2-4 (Curto prazo):
+- [ ] [Ação importante #2]
+- [ ] [Outros quick wins]
+
+MÊS 2-3 (Médio prazo):
+- [ ] [Ação recomendada #3]
+- [ ] [Melhorias progressivas]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+REFERÊNCIAS:
+
+Arquitetura       : rules/02-architecture.md
+Padrões Código    : rules/03-coding-standards.md
+SOLID             : rules/04-solid-principles.md
+KISS/DRY/YAGNI    : rules/05-kiss-dry-yagni.md
+Ferramentas       : rules/06-tooling.md
+Testes            : rules/07-testing.md
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+RESUMO EXECUTIVO:
+
+[Parágrafo resumindo estado geral do projeto, principais pontos fortes,
+principais fraquezas e trajetória recomendada para melhorar
+conformidade. Mencionar se o projeto está pronto para produção,
+requer correções ou precisa de refatoração.]
+
+Recomendação Geral: [Pronto para produção / Correções menores /
+Refatoração importante / Reformulação necessária]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## NOTAS IMPORTANTES
+
+- Este comando orquestra as 4 auditorias especializadas
+- Usar Docker para todas as ferramentas de análise
+- Fornecer exemplos concretos com arquivo:linha para cada problema
+- Priorizar ações baseado na matriz Impacto/Esforço
+- Problemas de segurança são SEMPRE prioridade máxima
+- Propor correções automatizáveis (scripts, hooks de pre-commit)
+- Relatório deve ser acionável, não apenas descritivo
+- Adaptar recomendações ao contexto de negócio do projeto

package/Dev/i18n/pt/Python/commands/check-security.md

@@ -0,0 +1,207 @@
+---
+description: Verificar Segurança Python
+argument-hint: [arguments]
+---
+
+# Verificar Segurança Python
+
+## Argumentos
+
+$ARGUMENTS (opcional: caminho para o projeto a analisar)
+
+## MISSÃO
+
+Realizar uma auditoria completa de segurança do projeto Python identificando vulnerabilidades, secrets expostos e más práticas de segurança definidas nas regras do projeto.
+
+### Passo 1: Análise de Segurança com Bandit
+
+Escanear código com Bandit para detectar vulnerabilidades:
+- [ ] Sem senhas/secrets hardcoded
+- [ ] Sem uso de `eval()` ou `exec()`
+- [ ] Sem deserialização insegura (pickle)
+- [ ] Sem SQL injection (ORM ou queries parametrizadas)
+- [ ] Sem injeção de comando shell
+- [ ] Criptografia segura (não MD5/SHA1)
+
+**Comando**: Executar `docker run --rm -v $(pwd):/app python:3.11 sh -c "pip install bandit && bandit -r /app -f json"`
+
+**Referência**: `rules/06-tooling.md` seção "Security Analysis"
+
+### Passo 2: Detecção de Secrets
+
+Buscar secrets e credenciais no código:
+- [ ] Sem chaves de API no código fonte
+- [ ] Sem tokens em arquivos
+- [ ] Sem senhas em texto plano
+- [ ] Variáveis de ambiente para configuração sensível
+- [ ] .env no .gitignore
+- [ ] .env.example fornecido (sem valores reais)
+
+**Comando**: Usar grep/busca para detectar padrões de secrets
+
+**Padrões para buscar**:
+- `password\s*=\s*["'][^"']+["']`
+- `api_key\s*=\s*["'][^"']+["']`
+- `secret\s*=\s*["'][^"']+["']`
+- `token\s*=\s*["'][^"']+["']`
+
+**Referência**: `rules/03-coding-standards.md` seção "Security Best Practices"
+
+### Passo 3: Validação de Entrada do Usuário
+
+Verificar validação e sanitização de dados:
+- [ ] Validação de todas as entradas do usuário
+- [ ] Uso de Pydantic para validação
+- [ ] Sanitização de dados antes do processamento
+- [ ] Sem confiança cega em dados externos
+- [ ] Validação de tipo e formato
+- [ ] Limites no tamanho de entrada
+
+**Referência**: `rules/03-coding-standards.md` seção "Input Validation"
+
+### Passo 4: Dependências e Vulnerabilidades
+
+Analisar dependências para vulnerabilidades conhecidas:
+- [ ] Sem dependências com CVEs críticos
+- [ ] Versões de bibliotecas atualizadas
+- [ ] requirements.txt com versões fixadas
+- [ ] Uso de `pip-audit` ou `safety`
+- [ ] Sem dependências obsoletas
+
+**Comando**: Executar `docker run --rm -v $(pwd):/app python:3.11 sh -c "pip install pip-audit && pip-audit --requirement /app/requirements.txt"`
+
+**Referência**: `rules/06-tooling.md` seção "Dependency Management"
+
+### Passo 5: Gerenciamento de Erros e Logs
+
+Verificar tratamento seguro de erros:
+- [ ] Sem stack traces expostos em produção
+- [ ] Mensagens de erro genéricas para usuários
+- [ ] Logs seguros (sem dados sensíveis)
+- [ ] Sem modo debug em produção
+- [ ] Tratamento adequado de exceções
+- [ ] Logging de eventos de segurança
+
+**Referência**: `rules/03-coding-standards.md` seção "Error Handling"
+
+### Passo 6: Autenticação e Autorização
+
+Verificar segurança de autenticação:
+- [ ] Sem gerenciamento manual de senhas (usar bcrypt/argon2)
+- [ ] Tokens JWT com expiração
+- [ ] HTTPS obrigatório para endpoints sensíveis
+- [ ] Proteção CSRF se aplicável
+- [ ] Rate limiting em endpoints sensíveis
+- [ ] Validação de permissões (RBAC/ABAC)
+
+**Referência**: `rules/02-architecture.md` seção "Security Layer"
+
+### Passo 7: Configuração e Ambiente
+
+Analisar configuração de segurança:
+- [ ] Variáveis de ambiente para secrets
+- [ ] Configuração diferente por ambiente (dev/staging/prod)
+- [ ] Sem secrets em docker-compose.yml
+- [ ] Secrets em variáveis de ambiente ou vault
+- [ ] .env.example documentado
+- [ ] DEBUG=False em produção
+
+**Referência**: `rules/06-tooling.md` seção "Environment Configuration"
+
+### Passo 8: Injeção e XSS
+
+Verificar proteção contra injeções:
+- [ ] Sem SQL injection (ORM ou queries parametrizadas)
+- [ ] Escape de dados em templates
+- [ ] Sem injeção de comando (subprocess seguro)
+- [ ] Validação de caminho de arquivo (path traversal)
+- [ ] Content-Security-Policy se aplicação web
+- [ ] Sanitização de entrada HTML
+
+**Referência**: `rules/03-coding-standards.md` seção "Security Best Practices"
+
+### Passo 9: Calcular Pontuação
+
+Atribuição de pontos (de 25):
+- Bandit (vulnerabilidades): 6 pontos
+- Secrets e credenciais: 5 pontos
+- Validação de entrada: 4 pontos
+- Dependências seguras: 4 pontos
+- Tratamento de erros: 3 pontos
+- Auth/Authz: 2 pontos
+- Injection/XSS: 1 ponto
+
+## FORMATO DE SAÍDA
+
+```
+AUDITORIA DE SEGURANÇA PYTHON
+================================
+
+PONTUAÇÃO GERAL: XX/25
+
+PONTOS FORTES:
+- [Lista de boas práticas de segurança observadas]
+
+MELHORIAS:
+- [Lista de melhorias menores de segurança]
+
+PROBLEMAS CRÍTICOS:
+- [Lista de vulnerabilidades críticas a corrigir IMEDIATAMENTE]
+
+DETALHES POR CATEGORIA:
+
+1. SCAN BANDIT (XX/6)
+   Status: [Análise de vulnerabilidades]
+   Problemas Críticos: XX
+   Problemas Médios: XX
+   Problemas Baixos: XX
+
+2. SECRETS EXPOSTOS (XX/5)
+   Status: [Detecção de secrets]
+   Secrets Hardcoded: XX
+   Arquivos .env Seguros: ✅/❌
+
+3. VALIDAÇÃO DE ENTRADA (XX/4)
+   Status: [Validação e sanitização]
+   Entradas Não Validadas: XX
+   Uso de Pydantic: ✅/❌
+
+4. DEPENDÊNCIAS (XX/4)
+   Status: [Vulnerabilidades de dependências]
+   CVEs Críticos: XX
+   CVEs Médios: XX
+   Dependências Obsoletas: XX
+
+5. TRATAMENTO DE ERROS (XX/3)
+   Status: [Segurança de erros e logs]
+   Stack Traces Expostos: XX
+   Dados Sensíveis em Logs: XX
+
+6. AUTENTICAÇÃO (XX/2)
+   Status: [Auth/Authz]
+   Hashing Seguro: ✅/❌
+   JWT com Expiração: ✅/❌
+
+7. INJEÇÕES (XX/1)
+   Status: [Proteção contra injeção]
+   Riscos SQL Injection: XX
+   Riscos Command Injection: XX
+
+VULNERABILIDADES CRÍTICAS:
+[Lista detalhada de vulnerabilidades a corrigir imediatamente com arquivo:linha]
+
+TOP 3 AÇÕES PRIORITÁRIAS:
+1. [Ação de segurança mais crítica - URGENTE]
+2. [Segunda ação prioritária - IMPORTANTE]
+3. [Terceira ação prioritária - RECOMENDADO]
+```
+
+## NOTAS
+
+- Problemas de segurança DEVEM ser tratados com prioridade absoluta
+- Usar Docker para executar ferramentas de segurança
+- Fornecer arquivo e linha exatos para cada vulnerabilidade
+- Propor correções concretas para cada problema
+- Documentar riscos e impacto potencial
+- Testar correções sugeridas
+- NUNCA fazer commit de secrets no código