@maestro-ai/mcp-server 1.2.0 → 2.1.0

package/dist/content/skills/specialist-arquitetura-software/resources/checklists/architecture-validation.md

@@ -0,0 +1,180 @@
+# Checklist de Validação - Arquitetura de Software
+
+## Checklist de Qualidade Obrigatória
+
+### 1. Documentação Completa
+- [ ] **Sumário Executivo** claro e conciso
+- [ ] **Visão Arquitetural** bem definida
+- [ ] **Stack Tecnológica** justificada
+- [ ] **Diagramas C4** completos (níveis 1-3)
+- [ ] **ADRs** para decisões críticas
+- [ ] **SLO/SLI** definidos e mensuráveis
+- [ ] **Roadmap** de implementação claro
+
+### 2. Arquitetura C4
+- [ ] **Contexto (Nível 1)**: Sistema e limites definidos
+- [ ] **Containers (Nível 2)**: Principais componentes mapeados
+- [ ] **Componentes (Nível 3)**: Detalhes internos definidos
+- [ ] **Fluxos de dados** claramente identificados
+- [ ] **Integrações externas** documentadas
+- [ ] **Stakeholders** mapeados
+
+### 3. Stack Tecnológica
+- [ ] **Frontend**: Framework, linguagem, estilos definidos
+- [ ] **Backend**: Runtime, framework, ORM definidos
+- [ ] **Database**: Tipo, motor, cache definidos
+- [ ] **Infraestrutura**: Cloud, containers, CI/CD definidos
+- [ ] **Monitoramento**: Logs, métricas, tracing definidos
+- [ ] **Segurança**: Autenticação, autorização, criptografia definidas
+
+### 4. Decisões Arquiteturais (ADRs)
+- [ ] **ADR-001**: Padrão arquitetural documentado
+- [ ] **ADR-002**: Stack tecnológica justificada
+- [ ] **ADR-003**: Estratégia de deploy definida
+- [ ] **Status**: Todos ADRs com status claro
+- [ ] **Contexto**: Problemas bem descritos
+- [ ] **Consequências**: Impactos analisados
+
+### 5. Segurança
+- [ ] **Autenticação**: Estratégia definida (JWT/OAuth2/etc)
+- [ ] **Autorização**: Modelo RBAC implementado
+- [ ] **Dados Sensíveis**: Mapeados e protegidos
+- [ ] **Compliance**: Requisitos regulatórios atendidos
+- [ ] **Infraestrutura**: Rede, secrets, WAF definidos
+- [ ] **Monitoramento**: Logs de segurança configurados
+
+### 6. Performance e Escalabilidade
+- [ ] **SLAs**: Acordos de nível de serviço definidos
+- [ ] **Cache Strategy**: Estratégia de cache definida
+- [ ] **CDN**: Content delivery network planejada
+- [ ] **Auto-scaling**: Estratégia de escala automática
+- [ ] **Load Balancing**: Balanceamento de carga definido
+- [ ] **Bottlenecks**: Pontos de gargalo identificados
+
+### 7. Monitoramento e Observabilidade
+- [ ] **Logs**: Estrutura e centralização definidas
+- [ ] **Métricas**: Business e technical metrics definidas
+- [ ] **SLI/SLO**: Indicadores e objetivos de serviço
+- [ ] **Dashboards**: Painéis configurados
+- [ ] **Alerting**: Regras de alerta definidas
+- [ ] **Tracing**: Distributed tracing implementado
+
+### 8. Riscos e Mitigações
+- [ ] **Riscos Técnicos**: Identificados e mitigados
+- [ ] **Riscos de Negócio**: Identificados e mitigados
+- [ ] **Probabilidade**: Avaliada corretamente
+- [ ] **Impacto**: Avaliado corretamente
+- [ ] **Mitigação**: Estratégias definidas
+- [ ] **Contingência**: Planos de contingência
+
+### 9. Implementação
+- [ ] **Fase 1 (MVP)**: Módulos e deadline definidos
+- [ ] **Fase 2 (Expansão)**: Módulos e deadline definidos
+- [ ] **Fase 3 (Maturidade)**: Módulos e deadline definidos
+- [ ] **Dependencies**: Dependências mapeadas
+- [ ] **Resources**: Recursos necessários identificados
+- [ ] **Timeline**: Realista e alcançável
+
+### 10. Qualidade e Consistência
+- [ ] **Formato**: Consistente com template padrão
+- [ ] **Linguagem**: Clara e profissional
+- [ ] **Terminologia**: Consistente em todo documento
+- [ ] **Referências**: Cruzadas com outros artefatos
+- [ ] **Versionamento**: Versão e data atualizadas
+- [ ] **Aprovação**: Revisores e aprovações documentadas
+
+## Critérios de Score
+
+### Pontuação por Categoria (0-10 pontos)
+1. **Documentação**: 0-10 pontos
+2. **Arquitetura C4**: 0-10 pontos
+3. **Stack Tecnológica**: 0-10 pontos
+4. **ADRs**: 0-10 pontos
+5. **Segurança**: 0-10 pontos
+6. **Performance**: 0-10 pontos
+7. **Monitoramento**: 0-10 pontos
+8. **Riscos**: 0-10 pontos
+9. **Implementação**: 0-10 pontos
+10. **Qualidade**: 0-10 pontos
+
+### Score Mínimo para Aprovação
+- **Score Total**: ≥ 75 pontos (média 7.5 por categoria)
+- **Sem categoria crítica**: < 5 pontos
+- **Documentação mínima**: Todas seções obrigatórias preenchidas
+
+## Validação Automática (via MCP)
+
+### Checks Estruturais
+```python
+def validate_architecture_structure(architecture_path):
+    checks = {
+        'has_summary': check_section_exists('## Sumário Executivo'),
+        'has_c4_diagrams': check_section_exists('## 2. Arquitetura C4'),
+        'has_stack': check_section_exists('## 3. Stack Tecnológica'),
+        'has_adrs': check_section_exists('## 4. Decisões Arquiteturais'),
+        'has_security': check_section_exists('## 5. Segurança'),
+        'has_performance': check_section_exists('## 6. Performance'),
+        'has_monitoring': check_section_exists('## 7. Monitoramento'),
+        'has_risks': check_section_exists('## 8. Riscos'),
+        'has_roadmap': check_section_exists('## 9. Roadmap'),
+        'has_checklist': check_section_exists('## Checklist de Qualidade')
+    }
+    return checks
+```
+
+### Checks de Qualidade
+```python
+def validate_architecture_quality(architecture_path):
+    quality_checks = {
+        'word_count': count_words() > 1000,
+        'has_checkboxes': count_checkboxes() > 50,
+        'has_sections': count_sections() >= 10,
+        'has_adrs': count_adrs() >= 3,
+        'has_slos': count_slos() >= 5,
+        'completeness': calculate_completeness() > 0.8
+    }
+    return quality_checks
+```
+
+## Processo de Validação
+
+### 1. Validação Estrutural
+- Verificar se todas seções obrigatórias existem
+- Verificar se checkboxes estão preenchidas
+- Verificar se formato está correto
+
+### 2. Validação de Conteúdo
+- Verificar se decisões são justificadas
+- Verificar se riscos são mitigados
+- Verificar se SLOs são realistas
+
+### 3. Validação de Consistência
+- Verificar se terminologia é consistente
+- Verificar se referências cruzadas funcionam
+- Verificar se alinhamento com outros artefatos
+
+### 4. Validação de Qualidade
+- Calcular score de qualidade
+- Verificar se atinge threshold mínimo
+- Gerar relatório de validação
+
+## Guardrails Críticos
+
+### Não Avançar Se:
+- Score < 75 pontos
+- Sem diagramas C4
+- Sem ADRs para decisões críticas
+- Sem estratégia de segurança
+- Sem SLOs definidos
+
+### Alertas de Atenção:
+- Score entre 60-75 pontos
+- SLOs irreais
+- Riscos não mitigados
+- Stack não justificada
+
+### Recomendações de Melhoria:
+- Adicionar mais detalhes técnicos
+- Incluir exemplos específicos
+- Refinar SLOs com base em benchmarks
+- Adicionar mais ADRs para decisões secundárias

package/dist/content/skills/specialist-arquitetura-software/resources/examples/architecture-examples.md

@@ -0,0 +1,239 @@
+# Exemplos de Arquitetura de Software
+
+## Exemplo 1: E-commerce Platform
+
+### Input: Requisitos do Negócio
+- Plataforma de e-commerce com 100k usuários
+- Catálogo de 50k produtos
+- Picos de 10k requisições/segundo
+- Integração com pagamento e logística
+
+### Output: Arquitetura Definida
+
+#### Stack Tecnológica
+```
+Frontend: Next.js + TypeScript + Tailwind CSS
+Backend: Node.js + Express + Prisma
+Database: PostgreSQL + Redis
+Infrastructure: AWS + Docker + Kubernetes
+```
+
+#### Arquitetura C4
+```
+Context: Web App + Mobile App + Admin Panel
+Containers: Frontend + Backend API + Database + Cache
+Components: Auth + Products + Orders + Payments + Shipping
+```
+
+#### ADRs Principais
+```
+ADR-001: Microservices vs Monolith → Monolith Modular
+ADR-002: Database Choice → PostgreSQL + Redis
+ADR-003: Deployment Strategy → Blue-Green on Kubernetes
+```
+
+#### SLOs
+```
+API Response Time: p95 < 200ms
+System Availability: > 99.9%
+Concurrent Users: 10k
+Error Rate: < 0.1%
+```
+
+---
+
+## Exemplo 2: SaaS Analytics Platform
+
+### Input: Requisitos Técnicos
+- Dashboard em tempo real
+- Processamento de big data
+- Multi-tenant architecture
+- API-first design
+
+### Output: Arquitetura Definida
+
+#### Stack Tecnológica
+```
+Frontend: React + TypeScript + D3.js
+Backend: Python + FastAPI + SQLAlchemy
+Database: PostgreSQL + ClickHouse + Redis
+Infrastructure: GCP + Docker + Terraform
+```
+
+#### Arquitetura C4
+```
+Context: Web App + API + Data Pipeline
+Containers: Frontend + API Gateway + Services + Data Warehouse
+Components: Auth + Analytics + Reporting + Data Processing
+```
+
+#### ADRs Principais
+```
+ADR-001: Multi-tenant Strategy → Database per Tenant
+ADR-002: Real-time Processing → Kafka + ClickHouse
+ADR-003: API Design → GraphQL + REST
+```
+
+#### SLOs
+```
+Dashboard Load Time: < 3 seconds
+Data Processing Latency: < 30 seconds
+API Response Time: p95 < 500ms
+System Availability: > 99.5%
+```
+
+---
+
+## Exemplo 3: Mobile Banking App
+
+### Input: Requisitos de Segurança
+- Aplicação bancária mobile
+- Transações financeiras
+- Compliance regulatório
+- Alta segurança
+
+### Output: Arquitetura Definida
+
+#### Stack Tecnológica
+```
+Frontend: React Native + TypeScript
+Backend: Java + Spring Boot + JPA
+Database: PostgreSQL + Redis
+Infrastructure: AWS + Docker + Vault
+```
+
+#### Arquitetura C4
+```
+Context: Mobile App + Admin Panel + Core Banking
+Containers: Mobile App + API Gateway + Services + Database
+Components: Auth + Accounts + Transactions + Notifications
+```
+
+#### ADRs Principais
+```
+ADR-001: Security Architecture → Zero Trust + MFA
+ADR-002: Database Design → Immutable Ledger
+ADR-003: API Security → OAuth2 + JWT + Rate Limiting
+```
+
+#### SLOs
+```
+Transaction Processing: < 2 seconds
+App Launch Time: < 3 seconds
+API Response Time: p95 < 300ms
+System Availability: > 99.99%
+```
+
+---
+
+## Padrões de Decisão Arquitetural
+
+### 1. Escolha de Stack
+```
+Se (Web Application) → React + Node.js + PostgreSQL
+Se (Mobile Application) → React Native + Node.js + PostgreSQL
+Se (Data Processing) → Python + FastAPI + PostgreSQL + ClickHouse
+Se (Enterprise) → Java + Spring Boot + PostgreSQL
+```
+
+### 2. Padrão de Arquitetura
+```
+Se (Time < 10) → Monolith Modular
+Se (Time > 10) → Microservices
+Se (Real-time) → Event-Driven
+Se (Batch Processing) → ETL Pipeline
+```
+
+### 3. Estratégia de Deploy
+```
+Se (Cloud Native) → Kubernetes + Helm
+Se (Simple Deploy) → Docker + Docker Compose
+Se (Enterprise) → Terraform + Kubernetes
+Se (Serverless) → Lambda + API Gateway
+```
+
+### 4. Estratégia de Banco
+```
+Se (Transactional) → PostgreSQL + Redis
+Se (Analytics) → PostgreSQL + ClickHouse
+Se (Simple Cache) → Redis
+Se (Multi-tenant) → PostgreSQL per Tenant
+```
+
+---
+
+## Anti-Patterns a Evitar
+
+### 1. Arquitetura
+```
+❌ Microservices prematuro
+✅ Monolith modular primeiro
+
+❌ Over-engineering
+✅ Simplicidade evolutiva
+
+❌ Single point of failure
+✅ Alta disponibilidade
+```
+
+### 2. Stack Tecnológica
+```
+❌ Tecnologias muito novas
+✅ Tecnologias maduras e estáveis
+
+❌ Muitas tecnologias diferentes
+✅ Stack coesa e consistente
+
+❌ Ignorar performance
+✅ Performance-first design
+```
+
+### 3. SLOs
+```
+❌ SLOs irreais
+✅ SLOs alcançáveis
+
+❌ Sem monitoramento
+✅ Observabilidade completa
+
+❌ Sem error budget
+✅ Gerenciamento de risco
+```
+
+---
+
+## Templates Reutilizáveis
+
+### Template de ADR
+```markdown
+# ADR-XXX: [Título]
+
+## Status
+Proposed
+
+## Contexto
+[Problema]
+
+## Decisão
+[Solução]
+
+## Consequências
+[Impactos]
+```
+
+### Template de SLO
+```markdown
+## [Componente] SLOs
+- Response Time: p95 < [valor]ms
+- Availability: > [valor]%
+- Error Rate: < [valor]%
+```
+
+### Template de Stack
+```markdown
+### [Categoria]
+- **Primary:** [Tecnologia principal]
+- **Secondary:** [Tecnologia secundária]
+- **Tooling:** [Ferramentas]
+- **Testing:** [Testes]
+```