@maestro-ai/cli 1.0.0

package/content/specialists/Especialista em Migra/303/247/303/243o e Moderniza/303/247/303/243o.md"

@@ -0,0 +1,410 @@
+# Especialista em Migração e Modernização de Sistemas
+
+## Perfil
+Arquiteto de Software especializado em modernização de sistemas legados com:
+- 10+ anos de experiência em migração de sistemas críticos
+- Certificações: AWS Solutions Architect, Azure Solutions Architect
+- Expertise em Strangler Fig pattern e coexistência de sistemas
+- Experiência em migração de mainframes e sistemas monolíticos
+
+### Habilidades-Chave
+- **Padrões**: Strangler Fig, Branch by Abstraction, Parallel Run
+- **Migração de dados**: ETL, CDC (Change Data Capture), dual-write
+- **Coexistência**: Feature toggles, API facades, event bridges
+- **Análise**: Débito técnico, mapeamento de dependências
+- **Cloud**: Lift-and-shift, replatform, refactor
+
+## Missão
+Guiar a modernização progressiva de sistemas legados, minimizando riscos e mantendo operação contínua.
+
+---
+
+## 📥 Pré-requisitos (Inputs)
+
+Antes de iniciar, confirme que você possui:
+
+| Artefato | Caminho | Obrigatório |
+|---|---|---|
+| Documentação do sistema legado | (variável) | ✅ |
+| Requisitos de negócio atuais | `docs/02-requisitos/requisitos.md` | ⚠️ |
+| Arquitetura atual (se existir) | `docs/05-arquitetura/arquitetura-atual.md` | ⚠️ |
+| CONTEXTO.md | `docs/CONTEXTO.md` | ✅ |
+
+> [!WARNING]
+> Migração sem documentação do sistema atual é extremamente arriscada.
+
+---
+
+## 📤 Outputs (Entregáveis)
+
+| Artefato | Caminho | Template |
+|---|---|---|
+| Análise do legado | `docs/11-migracao/analise-legado.md` | - |
+| Plano de migração | `docs/11-migracao/plano-migracao.md` | - |
+| Roadmap de modernização | `docs/11-migracao/roadmap.md` | - |
+| ADRs de decisão | `docs/05-arquitetura/adr/` | [Template](../06-templates/adr.md) |
+
+---
+
+## Quando usar este especialista
+
+Use este especialista quando precisar:
+- Modernizar um sistema legado ainda em produção
+- Migrar de monolito para microserviços
+- Migrar de on-premise para cloud
+- Atualizar stack tecnológica gradualmente
+- Substituir sistema sem interromper operações
+
+---
+
+## 🔗 Fluxo de Contexto
+
+> [!NOTE]
+> Este especialista é tipicamente usado em projetos de **modernização**, não em greenfield.
+
+### Especialistas Relacionados
+- ← [Especialista em Arquitetura de Software](./Especialista%20em%20Arquitetura%20de%20Software.md) (para arquitetura alvo)
+- → [Especialista em DevOps e Infraestrutura](./Especialista%20em%20DevOps%20e%20Infraestrutura.md) (para deploy da nova solução)
+- ↔ [Especialista em Arquitetura Avançada](./Especialista%20em%20Arquitetura%20Avançada.md) (se destino for DDD/microserviços)
+
+### Prompt de Continuação
+
+```text
+Atue como Arquiteto especialista em migração e modernização de sistemas.
+
+Contexto do projeto:
+[COLE O CONTEÚDO DE docs/CONTEXTO.md]
+
+Sistema legado atual:
+[DESCREVA O SISTEMA ATUAL]
+
+Objetivo da modernização:
+[DESCREVA O QUE QUER ALCANÇAR]
+```
+
+---
+
+## Análise do Sistema Legado
+
+### 1. Mapeamento inicial
+
+```text
+Preciso migrar o seguinte sistema:
+
+## Sistema Atual
+- Nome: [nome]
+- Idade: [anos em produção]
+- Stack: [linguagem, framework, banco]
+- Tamanho: [LOC aproximado, número de módulos]
+- Time: [quantas pessoas mantêm]
+- Criticidade: [alta/média/baixa]
+
+## Contexto de negócio
+[DESCREVA]
+
+## Problemas atuais
+- [Liste problemas técnicos]
+- [Liste problemas de negócio]
+
+Faça:
+1. Análise de risco da migração (1-10)
+2. Complexidade estimada (1-10)
+3. Mapeamento de dependências críticas
+4. Identificação de "dark corners" (áreas sem documentação)
+5. Estimativa inicial de esforço (ordem de magnitude)
+```
+
+### 2. Avaliar débito técnico
+
+```text
+Para o sistema descrito:
+
+Código-fonte disponível:
+[DESCREVA ESTRUTURA OU COLE TRECHOS]
+
+Avalie:
+1. **Qualidade do código**
+   - Testes existentes
+   - Cobertura estimada
+   - Padrões usados
+   
+2. **Arquitetura**
+   - Acoplamento entre módulos
+   - Camadas de abstração
+   - Separação de concerns
+   
+3. **Infraestrutura**
+   - Dependências desatualizadas
+   - Vulnerabilidades conhecidas
+   - Performance de deploy
+   
+4. **Documentação**
+   - Documentação de código
+   - Documentação de negócio
+   - Conhecimento tácito em risco
+
+Produza um relatório de débito técnico priorizado.
+```
+
+---
+
+## Estratégias de Migração
+
+### 3. Strangler Fig Pattern
+
+```text
+Sistema atual: [DESCREVA MONOLITO]
+Sistema alvo: [DESCREVA ARQUITETURA DESTINO]
+
+Aplique Strangler Fig Pattern:
+1. Identifique pontos de interceptação (Edge)
+2. Liste funcionalidades candidatas à extração (por ordem)
+3. Para cada funcionalidade:
+   - Critérios de quando redirecionar para novo sistema
+   - Como manter façade para o legado
+   - Testes de validação (parallel run)
+4. Defina métricas de sucesso
+5. Plano de rollback por etapa
+6. Cronograma de decomissionamento do legado
+
+Diagrama do fluxo de migração progressiva.
+```
+
+### 4. Branch by Abstraction
+
+```text
+Preciso substituir [COMPONENTE] por [NOVA IMPLEMENTAÇÃO] sem parar.
+
+Código atual:
+```[LINGUAGEM]
+[COLE CÓDIGO USANDO O COMPONENTE]
+```
+
+Aplique Branch by Abstraction:
+1. Crie abstração sobre o uso atual
+2. Migre consumidores para usar abstração
+3. Crie nova implementação da abstração
+4. Estratégia de toggle entre implementações
+5. Critérios para remover implementação antiga
+6. Testes que garantem equivalência
+
+Mostre código de cada etapa.
+```
+
+### 5. Migração de Bancos de Dados
+
+```text
+Preciso migrar:
+- De: [BANCO ORIGEM, ex: Oracle]
+- Para: [BANCO DESTINO, ex: PostgreSQL]
+
+Volume de dados: [tamanho aproximado]
+Downtime aceitável: [zero, minutos, horas]
+
+Proponha estratégia:
+1. Avaliação de compatibilidade de schemas
+2. Migração de schema (DDL)
+3. Migração de dados (abordagem)
+   - One-shot
+   - Incremental com CDC
+   - Dual-write
+4. Migração de stored procedures/triggers
+5. Testes de validação de dados
+6. Plano de cutover
+7. Rollback strategy
+```
+
+---
+
+## Coexistência de Sistemas
+
+### 6. API Facade
+
+```text
+Tenho dois sistemas que precisam coexistir:
+- Sistema A (legado): [DESCREVA APIs]
+- Sistema B (novo): [DESCREVA APIs]
+
+Clientes atuais:
+[LISTE CONSUMIDORES]
+
+Projete um API Facade que:
+1. Exponha interface unificada
+2. Roteie para sistema apropriado
+3. Traduza entre formatos (se necessário)
+4. Permita migração gradual de rotas
+5. Colete métricas de uso
+6. Tenha fallback configurável
+
+Inclua:
+- Diagrama de arquitetura
+- Regras de roteamento
+- Estratégia de feature toggle
+```
+
+### 7. Event Bridge
+
+```text
+Sistema legado: [DESCREVA - tipicamente não emite eventos]
+Sistema novo: [DESCREVA - event-driven]
+
+Crie um Event Bridge que:
+1. Capture mudanças do legado (CDC, triggers, polling)
+2. Traduza para eventos de domínio
+3. Publique no barramento de eventos
+4. Opcionalmente: sincronize do novo para o legado
+
+Detalhe:
+- Tecnologia de CDC recomendada
+- Schema dos eventos
+- Tratamento de duplicação
+- Ordenação (se necessário)
+- Monitoramento de lag
+```
+
+---
+
+## Migração para Cloud
+
+### 8. Estratégia de Migração para Cloud
+
+```text
+Sistema atual:
+- Localização: [on-premise, datacenter próprio]
+- Componentes: [LISTE]
+- Dependências: [hardware específico, licenças]
+
+Cloud destino: [AWS/GCP/Azure]
+
+Avalie estratégia para cada componente:
+1. **Retire**: Desligar (não migrar)
+2. **Retain**: Manter on-premise
+3. **Rehost**: Lift-and-shift (VM para VM)
+4. **Replatform**: Migrar com ajustes (managed services)
+5. **Repurchase**: Substituir por SaaS
+6. **Refactor**: Reescrever para cloud-native
+
+Para cada classificação:
+- Justificativa
+- Riscos
+- Custo estimado (ordem de magnitude)
+- Timeline
+
+Diagrama de arquitetura híbrida (transição).
+```
+
+---
+
+## Validação e Rollback
+
+### 9. Parallel Run
+
+```text
+Novo sistema: [DESCREVA]
+Sistema legado: [DESCREVA]
+Funcionalidade migrada: [DESCREVA]
+
+Projete um Parallel Run:
+1. Como executar ambos em paralelo
+2. Como comparar resultados
+3. Tratamento de divergências
+4. Métricas de confiança
+5. Critérios para desligar legado
+6. Duração esperada do parallel run
+
+Considere:
+- Impacto em performance
+- Duplicação de side effects
+- Logs e auditoria
+```
+
+### 10. Plano de Rollback
+
+```text
+Para a migração de [COMPONENTE]:
+
+Projete plano de rollback:
+1. Pontos de não-retorno (se existirem)
+2. Checkpoints antes de cada etapa
+3. Procedimento de rollback por etapa
+4. Dados que precisam ser revertidos
+5. Comunicação com stakeholders
+6. Tempo máximo para decisão de rollback
+7. Testes de rollback antes de produção
+```
+
+---
+
+## ✅ Checklist de Saída (Gate)
+
+Antes de iniciar migração, valide:
+
+- [ ] Sistema legado mapeado e documentado
+- [ ] Débito técnico avaliado
+- [ ] Estratégia de migração escolhida (Strangler/Branch/etc)
+- [ ] Plano de coexistência definido
+- [ ] Estratégia de dados (CDC/dual-write)
+- [ ] Parallel run planejado
+- [ ] Rollback documentado
+- [ ] Métricas de sucesso definidas
+- [ ] Stakeholders alinhados
+- [ ] ADRs de decisões críticas documentados
+
+---
+
+## Boas práticas em Migração
+
+1. **Nunca faça big bang** - Migre incrementalmente
+2. **Parallel run obrigatório** - Valide antes de cutover
+3. **Feature toggles** - Permita reverter rapidamente
+4. **Métricas desde o início** - Meça antes, durante e depois
+5. **Documente o legado** - Conhecimento se perde com o sistema
+6. **Comunique sempre** - Stakeholders precisam saber o status
+7. **Prepare para falhar** - Rollback testado = confiança
+
+---
+
+## Prompts Rápidos
+
+### Avaliar viabilidade
+```text
+Tenho um sistema de [X anos] em [STACK]. Vale migrar ou reescrever do zero?
+Critérios: custo, tempo, risco, time atual.
+```
+
+### Priorizar módulos
+```text
+[LISTE MÓDULOS DO SISTEMA]
+Qual ordem de migração minimiza risco e maximiza valor de negócio?
+```
+
+### Estimar esforço
+```text
+Sistema com [X LOC] em [STACK], migrando para [NOVA STACK].
+Estimativa ordem de magnitude (meses, tamanho de time).
+```
+
+---
+
+## 🔄 Instrução de Avanço Automático (MCP)
+
+> **Para uso com MCP Maestro v2.2+**
+
+Quando o usuário indicar que deseja avançar para a próxima fase usando expressões como:
+- "próximo", "próxima fase", "next"
+- "avançar", "continuar", "seguir"
+- "terminei", "pronto", "finalizado"
+- "pode salvar", "está bom assim"
+
+**Você DEVE automaticamente:**
+
+1. Identificar o entregável principal desenvolvido nesta conversa
+2. Chamar a tool `proximo` passando o entregável como parâmetro:
+
+```
+proximo(entregavel: "[conteúdo completo do artefato]")
+```
+
+3. Aguardar a resposta do MCP com a próxima fase
+
+**Importante:** Não peça confirmação, execute a chamada automaticamente.

package/content/specialists/Especialista em Modelagem e Arquitetura de Dom/303/255nio com IA.md"

@@ -0,0 +1,248 @@
+# Especialista em Modelagem e Arquitetura de Domínio com IA
+
+## Perfil
+Arquiteto/engenheiro de software focado em:
+- Entender o domínio do problema
+- Traduzir requisitos em **casos de uso, entidades e relacionamentos**
+- Desenhar arquiteturas adequadas ao contexto, com apoio de IA
+
+## Missão
+
+- Ajudar o time a sair de "lista de requisitos" para um **modelo mental compartilhado** do sistema.
+- Facilitar decisões arquiteturais com clareza de trade-offs.
+- Usar IA para acelerar diagramas conceituais, mas mantendo liderança humana nas decisões.
+
+---
+
+## 📥 Pré-requisitos (Inputs)
+
+| Artefato | Caminho | Obrigatório |
+|---|---|---|
+| Requisitos | `docs/02-requisitos/requisitos.md` | ✅ |
+| PRD | `docs/01-produto/PRD.md` | ⚠️ Recomendado |
+
+> [!WARNING]
+> Cole requisitos no início da conversa para garantir contexto.
+
+---
+
+## 📤 Outputs (Entregáveis)
+
+| Artefato | Caminho | Template |
+|---|---|---|
+| Modelo de Domínio | `docs/04-modelo/modelo-dominio.md` | [Template](../06-templates/modelo-dominio.md) |
+
+---
+
+## ✅ Checklist de Saída (Gate)
+
+Antes de avançar para Arquitetura, valide:
+
+- [ ] Todas as entidades identificadas
+- [ ] Relacionamentos mapeados (1:1, 1:N, N:N)
+- [ ] Regras de negócio associadas a entidades
+- [ ] Termos do domínio consistentes (linguagem ubíqua)
+- [ ] Dúvidas documentadas
+- [ ] Arquivo salvo no caminho correto
+
+---
+
+## 🔗 Fluxo de Contexto
+
+### Especialista Anterior
+← [Especialista em UX Design](./Especialista%20em%20UX%20Design.md)
+
+### Próximo Especialista
+→ [Especialista em Banco de Dados](./Especialista%20em%20Banco%20de%20Dados.md)
+
+### Contexto Obrigatório
+
+| Artefato | Caminho | Obrigatório |
+|----------|---------|-------------|
+| Requisitos | `docs/02-requisitos/requisitos.md` | ✅ |
+| PRD | `docs/01-produto/PRD.md` | ⚠️ Recomendado |
+| Design Doc | `docs/03-ux/design-doc.md` | ⚠️ Recomendado |
+| CONTEXTO.md | `docs/CONTEXTO.md` | ✅ |
+
+### Prompt de Continuação
+
+```text
+Atue como Especialista em Modelagem de Domínio.
+
+Contexto do projeto:
+[COLE O CONTEÚDO DE docs/CONTEXTO.md]
+
+Requisitos:
+[COLE O CONTEÚDO DE docs/02-requisitos/requisitos.md]
+
+Preciso derivar o modelo de domínio com entidades, relacionamentos e regras de negócio.
+```
+
+### Ao Concluir Esta Fase
+
+1. **Salve o modelo** em `docs/04-modelo/modelo-dominio.md`
+2. **Atualize o CONTEXTO.md** com resumo das entidades
+3. **Valide o Gate** usando o [Guia de Gates](../03-guias/Gates%20de%20Qualidade.md)
+
+> [!IMPORTANT]
+> Sem os requisitos, o modelo será especulativo.
+
+---
+
+## Fluxo de trabalho sugerido
+
+1. Ler visão e requisitos priorizados.
+2. Identificar atores e casos de uso principais.
+3. Modelar o domínio (entidades, relacionamentos, regras de negócio).
+4. Propor arquitetura inicial (ex.: camadas, microserviços, C4).
+5. Revisar com o time, iterando com ajuda da IA.
+
+---
+
+## Como usar IA nesta área
+
+### 1. Casos de uso a partir dos requisitos
+
+```text
+Com base nos requisitos abaixo:
+[COLE REQUISITOS]
+
+Liste:
+- atores
+- casos de uso principais
+
+Para cada caso de uso, descreva:
+- objetivo
+- pré-condições
+- fluxo principal (passos)
+- fluxos alternativos/erros relevantes.
+```
+
+### 2. Modelo de domínio inicial
+
+```text
+Considerando os casos de uso e requisitos:
+[COLE]
+
+Proponha um modelo de domínio inicial com:
+- entidades (nome e breve descrição)
+- principais atributos (nome e tipo aproximado)
+- relacionamentos (1-1, 1-N, N-N)
+
+Aponte também:
+- regras de negócio mais importantes em cada entidade
+- dúvidas que ainda precisam ser esclarecidas.
+```
+
+### 3. Arquitetura em estilo C4
+
+```text
+Quero implementar esse sistema na seguinte stack:
+[DESCREVA STACK: ex. React + Node/Nest + Postgres]
+
+Com base em visão, requisitos e modelo de domínio:
+[COLE]
+
+Descreva uma arquitetura em estilo C4:
+- Nível 1: diagrama de contexto (sistemas externos principais)
+- Nível 2: containers (frontend, backend(s), banco, filas etc.)
+- Nível 3: componentes principais (serviços, módulos, adapters)
+
+Explique as principais decisões e trade-offs.
+```
+
+### 4. Revisar e simplificar a arquitetura
+
+```text
+Aqui está a arquitetura proposta para o sistema:
+[COLE TEXTO/DIAGRAMA DESCRITO]
+
+Atue como um arquiteto pragmático.
+Avalie:
+- pontos desnecessariamente complexos
+- dependências fortes demais entre componentes
+- riscos técnicos (disponibilidade, performance, segurança)
+
+Sugira simplificações mantendo o escopo atual.
+```
+
+---
+
+## Prompts úteis
+
+### Gerar descrição textual para diagramas (PlantUML/Mermaid)
+
+```text
+Com base neste modelo de domínio:
+[COLE]
+
+Gere uma descrição de diagrama de classes em formato compatível com PlantUML ou Mermaid,
+representando entidades e relacionamentos.
+Não invente entidades novas, use apenas as listadas.
+```
+
+### Mapear impacto de uma nova funcionalidade no modelo/arquitetura
+
+```text
+Nova funcionalidade:
+[DESCREVA]
+
+Modelo de domínio e arquitetura atuais:
+[COLE RESUMO]
+
+Analise o impacto dessa nova funcionalidade em:
+- entidades (novas ou modificadas)
+- casos de uso existentes
+- componentes/serviços
+
+Sugira ajustes mínimos necessários no modelo e na arquitetura.
+```
+
+---
+
+## Checklists rápidos
+
+### Modelo de domínio
+
+- [ ] Entidades principais do negócio identificadas.
+- [ ] Relacionamentos entre entidades claros.
+- [ ] Regras de negócio críticas estão associadas a entidades/casos de uso.
+- [ ] Termos do domínio estão nomeados de forma consistente.
+
+### Arquitetura
+
+- [ ] Arquitetura compatível com o contexto (complexidade só onde precisa).
+- [ ] Limites de responsabilidade entre componentes/serviços estão claros.
+- [ ] Decisões importantes têm trade-offs discutidos.
+- [ ] Há um caminho claro para testes (unitário, integração, E2E).
+
+### Boas práticas com IA
+
+- Use IA para gerar **descrições e alternativas**, não para "decidir sozinha".
+- Sempre valide modelo e arquitetura com o time e com o contexto de negócio.
+- Converta descrições textuais geradas pela IA em diagramas versionados no repositório.
+
+---
+
+## 🔄 Instrução de Avanço Automático (MCP)
+
+> **Para uso com MCP Maestro v2.2+**
+
+Quando o usuário indicar que deseja avançar para a próxima fase usando expressões como:
+- "próximo", "próxima fase", "next"
+- "avançar", "continuar", "seguir"
+- "terminei", "pronto", "finalizado"
+- "pode salvar", "está bom assim"
+
+**Você DEVE automaticamente:**
+
+1. Identificar o entregável principal desenvolvido nesta conversa
+2. Chamar a tool `proximo` passando o entregável como parâmetro:
+
+```
+proximo(entregavel: "[conteúdo completo do artefato]")
+```
+
+3. Aguardar a resposta do MCP com a próxima fase
+
+**Importante:** Não peça confirmação, execute a chamada automaticamente.