@the-bearded-bear/claude-craft 3.0.0

package/Dev/i18n/pt/Python/checklists/pre-commit.md

@@ -0,0 +1,358 @@
+# Checklist Pré-Commit
+
+## Antes de Cada Commit
+
+### 1. Qualidade do Código
+
+- [ ] **Linting** - Código segue os padrões
+  ```bash
+  make lint
+  # ou
+  ruff check src/ tests/
+  ```
+
+- [ ] **Formatação** - Código formatado adequadamente
+  ```bash
+  make format-check
+  # ou
+  black --check src/ tests/
+  isort --check src/ tests/
+  ```
+
+- [ ] **Verificação de Tipos** - Sem erros de tipo
+  ```bash
+  make type-check
+  # ou
+  mypy src/
+  ```
+
+- [ ] **Segurança** - Sem vulnerabilidades óbvias
+  ```bash
+  make security-check
+  # ou
+  bandit -r src/ -ll
+  ```
+
+### 2. Testes
+
+- [ ] **Todos os testes passam**
+  ```bash
+  make test
+  # ou
+  pytest tests/
+  ```
+
+- [ ] **Novos testes escritos** para novo código
+  - [ ] Testes unitários para nova lógica
+  - [ ] Testes de integração se necessário
+  - [ ] Testes E2E se fluxo crítico
+
+- [ ] **Cobertura mantida** (> 80%)
+  ```bash
+  make test-cov
+  # ou
+  pytest --cov=src --cov-report=term
+  ```
+
+- [ ] **Testes relevantes** para bugs corrigidos
+  - [ ] Teste reproduz o bug (deve falhar antes da correção)
+  - [ ] Teste passa após a correção
+
+### 3. Padrões de Código
+
+- [ ] **PEP 8** respeitado
+  - [ ] Máximo 88 caracteres por linha
+  - [ ] Imports organizados (stdlib, third-party, local)
+  - [ ] Sem espaços em branco no final
+
+- [ ] **Type hints** em todas as funções públicas
+  ```python
+  def my_function(param: str) -> int:
+      """Docstring."""
+      pass
+  ```
+
+- [ ] **Docstrings** estilo Google
+  ```python
+  def function(arg1: str, arg2: int) -> bool:
+      """
+      Linha de resumo.
+
+      Args:
+          arg1: Descrição
+          arg2: Descrição
+
+      Returns:
+          Descrição
+
+      Raises:
+          ValueError: Se condição
+      """
+      pass
+  ```
+
+- [ ] **Convenções de nomenclatura**
+  - [ ] Classes: PascalCase
+  - [ ] Funções/variáveis: snake_case
+  - [ ] Constantes: UPPER_CASE
+  - [ ] Privados: _prefixado
+
+### 4. Arquitetura
+
+- [ ] **Arquitetura Limpa** respeitada
+  - [ ] Domínio não depende de nada
+  - [ ] Dependências apontam para dentro
+  - [ ] Protocols para abstrações
+
+- [ ] **SOLID** aplicado
+  - [ ] Single Responsibility
+  - [ ] Open/Closed
+  - [ ] Liskov Substitution
+  - [ ] Interface Segregation
+  - [ ] Dependency Inversion
+
+- [ ] **KISS, DRY, YAGNI**
+  - [ ] Solução simples
+  - [ ] Sem duplicação
+  - [ ] Sem código desnecessário
+
+### 5. Segurança
+
+- [ ] **Sem secrets** hardcoded no código
+  - [ ] Sem senhas
+  - [ ] Sem chaves de API
+  - [ ] Sem tokens
+
+- [ ] **Variáveis de ambiente**
+  - [ ] Adicionadas ao `.env.example` se novas
+  - [ ] Documentadas no README se necessário
+
+- [ ] **Validação de entrada**
+  - [ ] Todas as entradas validadas (Pydantic)
+  - [ ] Sem SQL injection (queries parametrizadas)
+  - [ ] Sem XSS injection
+
+- [ ] **Dados sensíveis**
+  - [ ] Senhas com hash (bcrypt)
+  - [ ] PII protegido
+  - [ ] Logs não contêm dados sensíveis
+
+### 6. Banco de Dados
+
+- [ ] **Migração** criada se mudança de schema
+  ```bash
+  make db-migrate msg="Descrição"
+  # ou
+  alembic revision --autogenerate -m "Descrição"
+  ```
+
+- [ ] **Migração testada**
+  - [ ] Upgrade funciona
+  - [ ] Downgrade funciona
+  - [ ] Sem perda de dados
+
+- [ ] **Índices** adicionados se necessário
+  - [ ] Em colunas frequentemente pesquisadas
+  - [ ] Em chaves estrangeiras
+
+### 7. Performance
+
+- [ ] **Queries N+1** evitadas
+  - [ ] Uso de joinedload/selectinload se necessário
+  - [ ] Sem queries em loops
+
+- [ ] **Paginação** para listas grandes
+  - [ ] Limit/offset implementado
+  - [ ] Sem carregamento de milhares de itens
+
+- [ ] **Cache** se apropriado
+  - [ ] Cache para dados acessados frequentemente
+  - [ ] Invalidação de cache gerenciada
+
+### 8. Logging & Monitoramento
+
+- [ ] **Logging apropriado**
+  - [ ] Nível correto (DEBUG, INFO, WARNING, ERROR)
+  - [ ] Mensagens claras e informativas
+  - [ ] Contexto adicionado (user_id, request_id, etc.)
+
+- [ ] **Sem print()** - usar logger
+  ```python
+  # ❌ Ruim
+  print(f"User {user_id} created")
+
+  # ✅ Bom
+  logger.info(f"User created", extra={"user_id": user_id})
+  ```
+
+- [ ] **Exceções logadas**
+  ```python
+  try:
+      risky_operation()
+  except Exception as e:
+      logger.error(f"Operation failed: {e}", exc_info=True)
+      raise
+  ```
+
+### 9. Documentação
+
+- [ ] **Comentários no código** para lógica complexa
+  - [ ] Sem comentários óbvios
+  - [ ] Explicação do "por quê", não do "o quê"
+
+- [ ] **README** atualizado se necessário
+  - [ ] Novas funcionalidades documentadas
+  - [ ] Instruções de configuração atualizadas
+  - [ ] Variáveis de ambiente documentadas
+
+- [ ] **Docs da API** atualizadas
+  - [ ] Novos endpoints documentados
+  - [ ] Exemplos fornecidos
+  - [ ] Erros documentados
+
+### 10. Git
+
+- [ ] **Mensagem de commit** segue Conventional Commits
+  ```
+  type(scope): assunto
+
+  corpo
+
+  rodapé
+  ```
+  - Tipos: feat, fix, docs, style, refactor, test, chore
+  - Assunto: imperativo, minúsculas, sem ponto
+  - Corpo: opcional, detalhes da mudança
+  - Rodapé: breaking changes, closes issues
+
+- [ ] **Commit atômico**
+  - [ ] Um commit = uma mudança lógica
+  - [ ] Sem commits gigantes
+  - [ ] Sem commits "WIP" ou "fix"
+
+- [ ] **Arquivos temporários** não incluídos
+  - [ ] Sem .pyc, __pycache__
+  - [ ] Sem .env (apenas .env.example)
+  - [ ] Sem arquivos de IDE
+
+### 11. Dependências
+
+- [ ] **Novas dependências** justificadas
+  - [ ] Realmente necessária?
+  - [ ] Sem alternativa nas deps existentes?
+  - [ ] Biblioteca mantida e segura?
+
+- [ ] **Lock file** atualizado
+  ```bash
+  poetry lock
+  # ou
+  uv lock
+  ```
+
+- [ ] **Versão fixada** corretamente
+  - [ ] Não versões muito amplas (`*`)
+  - [ ] Compatível com outras deps
+
+### 12. Limpeza
+
+- [ ] **Código morto** removido
+  - [ ] Sem código comentado
+  - [ ] Sem funções não utilizadas
+  - [ ] Sem imports não utilizados
+
+- [ ] **Código de debug** removido
+  - [ ] Sem breakpoint()
+  - [ ] Sem prints de debug
+  - [ ] Sem TODO/FIXME (ou criar issue)
+
+- [ ] **Logs de console** removidos
+  - [ ] Sem print() de debug
+  - [ ] Logs apropriados utilizados
+
+## Comando de Verificação Rápida
+
+```bash
+# Comando único para verificar tudo
+make quality && make test-cov
+```
+
+## Hook de Pre-commit
+
+Para automatizar, use hooks de pre-commit:
+
+```bash
+# .pre-commit-config.yaml já configurado
+pre-commit install
+
+# Executar manualmente
+pre-commit run --all-files
+```
+
+## Se Algo Falhar
+
+### Erros de Linting
+
+```bash
+# Auto-corrigir o que pode ser corrigido
+make lint-fix
+# ou
+ruff check --fix src/ tests/
+```
+
+### Erros de Formatação
+
+```bash
+# Auto-formatar
+make format
+# ou
+black src/ tests/
+isort src/ tests/
+```
+
+### Testes Falhando
+
+```bash
+# Executar testes em modo verbose para debug
+pytest -vv tests/
+
+# Executar teste específico
+pytest tests/path/to/test.py::test_function -vv
+
+# Ver stdout/stderr
+pytest -s tests/
+```
+
+### Erros de Tipo
+
+```bash
+# Ver erros detalhados
+mypy src/ --show-error-codes
+
+# Ignorar temporariamente (evitar!)
+# type: ignore[error-code]
+```
+
+## Exceções
+
+### Hotfix Urgente
+
+Se hotfix urgente de produção:
+- [ ] Testes mínimos passam
+- [ ] Correção verificada manualmente
+- [ ] PR criado imediatamente depois
+- [ ] TODO criado para melhorar testes
+
+### Commit WIP
+
+Se realmente necessário (evitar):
+- [ ] Commit em branch separada
+- [ ] Prefixado com `WIP:`
+- [ ] Fazer squash antes do merge para main
+
+## Checklist Rápida (Mínimo)
+
+- [ ] `make lint` ✅
+- [ ] `make type-check` ✅
+- [ ] `make test` ✅
+- [ ] Mensagem de commit válida ✅
+- [ ] Sem secrets ✅

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

@@ -0,0 +1,84 @@
+---
+description: Verificação de Async Python
+argument-hint: [arguments]
+---
+
+# Verificação de Async Python
+
+## Argumentos
+
+$ARGUMENTS (opcional: caminho para analisar)
+
+## MISSÃO
+
+Analisar o uso de código assíncrono no projeto Python e identificar problemas com padrões async/await, chamadas bloqueantes e problemas de performance.
+
+### Passo 1: Identificar Funções Async
+
+```bash
+# Encontrar todas as funções async
+rg "async def" --type py
+
+# Encontrar uso de await
+rg "await " --type py
+```
+
+Verificar:
+- [ ] Funções async declaradas adequadamente
+- [ ] Await usado para chamadas async
+- [ ] Sem código bloqueante em funções async
+- [ ] Tratamento adequado de exceções em async
+
+### Passo 2: Detectar Chamadas Bloqueantes
+
+```python
+# Chamadas bloqueantes comuns a evitar em async:
+- time.sleep()        # Usar asyncio.sleep()
+- requests.get()      # Usar httpx ou aiohttp
+- open()              # Usar aiofiles
+- db.execute()        # Usar driver de BD async
+```
+
+### Passo 3: Verificar Padrões Async
+
+```python
+# Bons padrões
+async def fetch_data(url: str) -> dict:
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+        return response.json()
+
+# Verificar:
+- [ ] async with para context managers
+- [ ] await para operações async
+- [ ] asyncio.gather() para tarefas concorrentes
+- [ ] Tratamento adequado de erros com try/except
+```
+
+### Passo 4: Gerar Relatório
+
+```
+ANÁLISE DE CÓDIGO ASYNC
+=====================================
+
+FUNÇÕES ASYNC: XX
+INSTRUÇÕES AWAIT: XX
+CHAMADAS BLOQUEANTES ENCONTRADAS: XX
+
+PROBLEMAS DETECTADOS:
+
+1. Chamada bloqueante em função async
+   Arquivo: app/services/user.py:45
+   Problema: Usando time.sleep() em vez de asyncio.sleep()
+   Correção: Substituir por asyncio.sleep()
+
+2. Await faltando
+   Arquivo: app/api/endpoints.py:78
+   Problema: Função async chamada sem await
+   Correção: Adicionar palavra-chave await
+
+RECOMENDAÇÕES:
+- Substituir chamadas bloqueantes por alternativas async
+- Usar asyncio.gather() para operações concorrentes
+- Adicionar tratamento adequado de timeout
+```

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

@@ -0,0 +1,138 @@
+---
+description: Verificar Arquitetura Python
+argument-hint: [arguments]
+---
+
+# Verificar Arquitetura Python
+
+## Argumentos
+
+$ARGUMENTS (opcional: caminho para o projeto a analisar)
+
+## MISSÃO
+
+Realizar uma auditoria completa da arquitetura do projeto Python seguindo os princípios de Arquitetura Limpa e Arquitetura Hexagonal definidos nas regras do projeto.
+
+### Passo 1: Analisar Estrutura do Projeto
+
+Examinar estrutura de diretórios e identificar:
+- [ ] Presença das camadas Domain/Application/Infrastructure/Presentation
+- [ ] Separação clara entre camadas (sem dependências invertidas)
+- [ ] Organização de módulos por domínio de negócio
+- [ ] Estrutura de pacotes consistente com regras de arquitetura
+
+**Referência**: `rules/02-architecture.md` seções "Clean Architecture" e "Hexagonal Architecture"
+
+### Passo 2: Verificar Dependências Entre Camadas
+
+Analisar imports e dependências:
+- [ ] Domínio não depende de nenhuma outra camada
+- [ ] Aplicação depende apenas do Domínio
+- [ ] Infraestrutura depende apenas de Domínio e Aplicação
+- [ ] Apresentação não contém lógica de negócio
+- [ ] Regra de dependência respeitada (apenas para dentro)
+
+**Verificar**: Sem imports de camadas externas em Domain/Application
+
+### Passo 3: Interfaces e Portas
+
+Verificar implementação de portas e adaptadores:
+- [ ] Interfaces (portas) definidas em Domain/Application
+- [ ] Implementações (adaptadores) em Infrastructure
+- [ ] Uso de injeção de dependência
+- [ ] Sem acoplamento forte com frameworks externos
+
+**Referência**: `rules/02-architecture.md` seção "Ports and Adapters"
+
+### Passo 4: Entidades e Value Objects
+
+Verificar modelagem do domínio:
+- [ ] Entidades ricas com lógica de negócio encapsulada
+- [ ] Value objects imutáveis
+- [ ] Agregados delimitados adequadamente
+- [ ] Domain Events se aplicável
+- [ ] Sem lógica de infraestrutura em entidades
+
+**Referência**: `rules/02-architecture.md` seção "Domain Layer"
+
+### Passo 5: Serviços e Casos de Uso
+
+Analisar organização da lógica de aplicação:
+- [ ] Use Cases/Application Services claramente identificados
+- [ ] Um Use Case = Uma ação de negócio
+- [ ] Domain Services para lógica de negócio complexa
+- [ ] Sem lógica de negócio em controllers/handlers
+- [ ] Transações gerenciadas no nível de Application
+
+**Referência**: `rules/02-architecture.md` seção "Application Layer"
+
+### Passo 6: Princípios SOLID
+
+Verificar aplicação dos princípios SOLID:
+- [ ] Single Responsibility: Uma classe = Uma razão para mudar
+- [ ] Open/Closed: Extensão através de herança/composição, não modificação
+- [ ] Liskov Substitution: Subtipos são substituíveis
+- [ ] Interface Segregation: Interfaces específicas e mínimas
+- [ ] Dependency Inversion: Dependência de abstrações
+
+**Referência**: `rules/04-solid-principles.md`
+
+### Passo 7: Calcular Pontuação
+
+Atribuição de pontos (de 25):
+- Estrutura e separação de camadas: 6 pontos
+- Respeito às dependências: 6 pontos
+- Ports and Adapters: 4 pontos
+- Modelagem do domínio: 4 pontos
+- Use Cases e Services: 3 pontos
+- Princípios SOLID: 2 pontos
+
+## FORMATO DE SAÍDA
+
+```
+AUDITORIA DE ARQUITETURA PYTHON
+================================
+
+PONTUAÇÃO GERAL: XX/25
+
+PONTOS FORTES:
+- [Lista de pontos positivos identificados]
+
+MELHORIAS:
+- [Lista de melhorias menores]
+
+PROBLEMAS CRÍTICOS:
+- [Lista de violações sérias de arquitetura]
+
+DETALHES POR CATEGORIA:
+
+1. ESTRUTURA E CAMADAS (XX/6)
+   Status: [Detalhes da estrutura]
+
+2. DEPENDÊNCIAS (XX/6)
+   Status: [Análise de dependências]
+
+3. PORTS AND ADAPTERS (XX/4)
+   Status: [Implementação de interfaces]
+
+4. MODELAGEM DO DOMÍNIO (XX/4)
+   Status: [Qualidade de entidades e VOs]
+
+5. USE CASES (XX/3)
+   Status: [Organização da lógica de aplicação]
+
+6. PRINCÍPIOS SOLID (XX/2)
+   Status: [Aplicação dos princípios SOLID]
+
+TOP 3 AÇÕES PRIORITÁRIAS:
+1. [Ação mais crítica com impacto estimado]
+2. [Segunda ação prioritária]
+3. [Terceira ação prioritária]
+```
+
+## NOTAS
+
+- Usar `grep`, `find` e análise de código para detectar violações
+- Fornecer exemplos concretos de arquivos/classes problemáticos
+- Sugerir refatorações precisas para cada problema identificado
+- Priorizar ações baseado no impacto na manutenibilidade