@maestro-ai/cli 1.0.0

package/content/prompts/desenvolvimento/code-review.md

@@ -0,0 +1,301 @@
+# Prompt: Code Review Automatizado
+
+> **Quando usar**: Durante Pull Requests ou revisão de código
+> **Especialista**: [Desenvolvimento Backend](../../02-especialistas/Especialista%20em%20Desenvolvimento%20e%20Vibe%20Coding%20Estruturado.md) ou Tech Lead
+> **Nível**: Médio
+
+---
+
+## Fluxo de Contexto
+
+Antes de usar este prompt, tenha em mãos:
+- Código a ser revisado (diff ou arquivo completo)
+- Contexto do projeto e padrões existentes
+
+Após revisão, crie comentários inline no PR ou salve em:
+- Comentários no sistema de versionamento (GitHub, GitLab)
+
+---
+
+## Prompt Completo
+
+```text
+Atue como desenvolvedor sênior realizando code review.
+
+## Contexto do Projeto
+
+[BREVE DESCRIÇÃO DO PROJETO E STACK]
+
+## Padrões do Projeto
+
+- Linguagem: [TypeScript/Python/Java/etc]
+- Framework: [NestJS/FastAPI/Spring/etc]
+- Style Guide: [Airbnb/Google/PEP8/etc]
+- Arquitetura: [Clean/Hexagonal/MVC/etc]
+- Padrões específicos: [Liste convenções do projeto]
+
+## Código para Revisar
+
+```[LINGUAGEM]
+[COLE O CÓDIGO - Pode ser diff ou arquivo completo]
+```
+
+## Tipo de Mudança
+
+- [ ] Nova feature
+- [ ] Bug fix
+- [ ] Refactoring
+- [ ] Performance
+- [ ] Documentação
+
+---
+
+## Sua Missão
+
+Realize um code review completo analisando:
+
+### 1. Categorize os Comentários
+
+Use prefixos para categorizar:
+- 🔴 **BLOCKER**: Erro crítico, impede aprovação
+- 🟡 **WARN**: Problema que deveria ser corrigido
+- 🟢 **SUGGESTION**: Melhoria opcional
+- 💬 **QUESTION**: Dúvida que precisa esclarecimento
+- 👍 **PRAISE**: Destaque positivo
+
+### 2. Checklist de Revisão
+
+#### Correção
+- [ ] Código faz o que deveria fazer?
+- [ ] Edge cases tratados?
+- [ ] Erros tratados adequadamente?
+- [ ] Null/undefined handling?
+
+#### Legibilidade
+- [ ] Nomes de variáveis/funções claros?
+- [ ] Código autoexplicativo ou comentado?
+- [ ] Magic numbers/strings evitados?
+- [ ] Complexidade ciclomática aceitável?
+
+#### Manutenibilidade
+- [ ] DRY (Don't Repeat Yourself)?
+- [ ] Single Responsibility?
+- [ ] Baixo acoplamento?
+- [ ] Testável?
+
+#### Performance
+- [ ] N+1 queries evitados?
+- [ ] Loops desnecessários?
+- [ ] Memória bem gerenciada?
+- [ ] Operações bloqueantes?
+
+#### Segurança
+- [ ] Input sanitizado?
+- [ ] Dados sensíveis protegidos?
+- [ ] Authorization verificada?
+- [ ] Logs sem dados sensíveis?
+
+#### Testes
+- [ ] Testes unitários incluídos?
+- [ ] Casos de erro testados?
+- [ ] Coverage adequado?
+
+### 3. Formato dos Comentários
+
+Para cada comentário, inclua:
+- Linha(s) afetada(s)
+- Categoria (BLOCKER/WARN/SUGGESTION)
+- Problema identificado
+- Sugestão de correção com código
+
+### 4. Resumo
+
+No final, forneça:
+- Aprovado / Aprovar com mudanças / Solicitar mudanças
+- Lista priorizada das mudanças necessárias
+- Pontos positivos do código
+```
+
+---
+
+## Exemplo de Uso
+
+```text
+Atue como desenvolvedor sênior realizando code review.
+
+## Contexto do Projeto
+
+API de agendamento para salões de beleza, NestJS.
+
+## Padrões do Projeto
+
+- Linguagem: TypeScript
+- Framework: NestJS
+- Style Guide: ESLint + Prettier
+- Arquitetura: Clean Architecture
+- Padrões: Injeção de dependência, DTOs, Repository pattern
+
+## Código para Revisar
+
+```typescript
+@Controller('agendamentos')
+export class AgendamentoController {
+  constructor(private agendamentoService: any) {}
+
+  @Post()
+  async criar(@Body() body) {
+    if (!body.clienteId) {
+      throw new Error('Cliente obrigatorio');
+    }
+    
+    const result = await this.agendamentoService.criar(body);
+    console.log('Agendamento criado:', result.id);
+    return result;
+  }
+  
+  @Get()
+  async listar() {
+    const agendamentos = await this.agendamentoService.repository.findAll();
+    return agendamentos;
+  }
+}
+```
+
+## Tipo de Mudança
+
+- [x] Nova feature
+```
+
+---
+
+## Resposta Esperada
+
+### Comentários de Código
+
+**Linha 3**
+🔴 **BLOCKER**: Tipo `any` para o serviço
+
+O uso de `any` quebra a tipagem e pode causar bugs em runtime.
+
+```typescript
+// ❌ Antes
+constructor(private agendamentoService: any) {}
+
+// ✅ Depois
+constructor(private readonly agendamentoService: AgendamentoService) {}
+```
+
+---
+
+**Linha 6**
+🔴 **BLOCKER**: Body sem tipagem e validação
+
+Sem DTO, não há validação de input, vulnerável a payloads maliciosos.
+
+```typescript
+// ❌ Antes
+async criar(@Body() body) {
+
+// ✅ Depois
+async criar(@Body() dto: CriarAgendamentoDto) {
+```
+
+E criar o DTO:
+```typescript
+export class CriarAgendamentoDto {
+  @IsUUID()
+  clienteId: string;
+  
+  @IsDate()
+  dataHora: Date;
+}
+```
+
+---
+
+**Linha 7-9**
+🟡 **WARN**: Validação manual no controller
+
+Validação deveria estar no DTO com class-validator, não manual.
+
+```typescript
+// ❌ Antes (validação manual)
+if (!body.clienteId) {
+  throw new Error('Cliente obrigatorio');
+}
+
+// ✅ Depois (remover, DTO com @IsNotEmpty() cuida disso)
+```
+
+---
+
+**Linha 12**
+🔴 **BLOCKER**: Console.log em código de produção
+
+Logs devem usar o sistema de logging do NestJS.
+
+```typescript
+// ❌ Antes
+console.log('Agendamento criado:', result.id);
+
+// ✅ Depois
+this.logger.log(`Agendamento criado: ${result.id}`);
+```
+
+---
+
+**Linha 17**
+🔴 **BLOCKER**: Acesso direto ao repository do service
+
+Controller acessando `service.repository` viola encapsulamento.
+
+```typescript
+// ❌ Antes
+const agendamentos = await this.agendamentoService.repository.findAll();
+
+// ✅ Depois
+const agendamentos = await this.agendamentoService.listar();
+```
+
+---
+
+**Linha 16**
+🟡 **WARN**: Endpoint sem paginação
+
+Listar todos os registros pode ser problemático com muitos dados.
+
+```typescript
+// ✅ Sugerir
+@Get()
+async listar(@Query() query: PaginacaoDto) {
+  return this.agendamentoService.listar(query.page, query.limit);
+}
+```
+
+---
+
+### Resumo
+
+**Decisão**: 🔴 **Solicitar mudanças**
+
+**Prioridade de Correções:**
+1. Tipar service e remover `any`
+2. Criar DTO com class-validator
+3. Remover console.log
+4. Não acessar repository diretamente
+5. Adicionar paginação
+
+**Pontos Positivos:**
+- Estrutura básica de controller correta
+- Uso de async/await adequado
+
+---
+
+## Checklist Pós-Geração
+
+- [ ] Todos os BLOCKERs corrigidos
+- [ ] WARNs revisados e priorizados
+- [ ] Sugestões consideradas
+- [ ] Testes adicionados se necessário
+- [ ] Código refatorado aprovado
+- [ ] PR atualizado com correções

package/content/prompts/desenvolvimento/gerar-servico.md

@@ -0,0 +1,271 @@
+# Prompt: Gerar Serviço de Aplicação
+
+> **Quando usar**: Durante implementação, para gerar services/use cases
+> **Especialista**: [Desenvolvimento Backend](../../02-especialistas/Especialista%20em%20Desenvolvimento%20e%20Vibe%20Coding%20Estruturado.md)
+> **Nível**: Médio
+
+---
+
+## Fluxo de Contexto
+
+Antes de usar este prompt, tenha em mãos:
+- `docs/CONTEXTO.md` - Entendimento atual do projeto
+- `docs/05-arquitetura/arquitetura.md` - Arquitetura definida
+- `docs/04-modelo/modelo-dominio.md` - Entidades e regras
+
+Após gerar, salve o código em:
+- `src/application/services/` ou equivalente na sua estrutura
+
+---
+
+## Prompt Completo
+
+```text
+Atue como desenvolvedor sênior especializado em Clean Architecture.
+
+## Contexto do Projeto
+
+[COLE O CONTEÚDO DE docs/CONTEXTO.md]
+
+## Arquitetura
+
+[COLE RESUMO DA ARQUITETURA - Padrão usado, camadas]
+
+## Entidade Alvo
+
+Nome: [NOME DA ENTIDADE]
+Campos: [LISTE OS CAMPOS]
+
+## Regras de Negócio
+
+[DESCREVA AS VALIDAÇÕES E REGRAS]
+
+## Stack
+
+Linguagem: [TypeScript/Python/Java/Go/etc]
+Framework: [NestJS/FastAPI/Spring/etc]
+ORM/Database: [Prisma/TypeORM/SQLAlchemy/etc]
+
+---
+
+## Sua Missão
+
+Gere o código do serviço/classe de aplicação com:
+
+### 1. Estrutura do Serviço
+- Injeção de dependências (Repository, outros Services)
+- Tipagem correta de DTOs de entrada e saída
+
+### 2. Métodos Principais
+Para cada operação CRUD + regras específicas:
+- Assinatura com tipos
+- Documentação JSDoc/Docstring
+- Lógica do happy path
+- Tratamento de erros com exceções específicas
+- Validações de negócio
+
+### 3. Padrões a Seguir
+- Separação entre Application Service e Domain Service (se aplicável)
+- DTOs para entrada/saída (nunca expor entidade diretamente)
+- Repository interface (não implementação)
+- Unit of Work pattern para transações (se aplicável)
+
+### 4. Não Gere
+- Controllers/Rotas
+- Implementação de Repository
+- Migrations
+- Configurações de framework
+
+### 5. Formato
+Retorne código pronto para uso com:
+- Imports necessários
+- Types/Interfaces auxiliares
+- Comentários explicando decisões
+```
+
+---
+
+## Exemplo de Uso
+
+```text
+Atue como desenvolvedor sênior especializado em Clean Architecture.
+
+## Contexto do Projeto
+
+Sistema de agendamento para salões de beleza.
+
+## Arquitetura
+
+Clean Architecture com camadas: Domain, Application, Infrastructure, Interface.
+Services na camada Application orquestram casos de uso.
+
+## Entidade Alvo
+
+Nome: Agendamento
+Campos:
+- id: UUID
+- clienteId: UUID
+- servicoId: UUID
+- dataHora: DateTime
+- status: enum (PENDENTE, CONFIRMADO, CANCELADO, CONCLUIDO)
+
+## Regras de Negócio
+
+1. Não pode agendar no passado
+2. Não pode haver conflito de horário para o mesmo prestador
+3. Cancelamento só até 2h antes
+4. Após criar, enviar notificação ao cliente
+
+## Stack
+
+Linguagem: TypeScript
+Framework: NestJS
+ORM: Prisma
+```
+
+---
+
+## Resposta Esperada
+
+```typescript
+import { Injectable, ConflictException, BadRequestException } from '@nestjs/common';
+import { AgendamentoRepository } from '../ports/agendamento.repository';
+import { NotificacaoService } from './notificacao.service';
+import { CriarAgendamentoDto, AgendamentoResponseDto } from '../dtos/agendamento.dto';
+import { StatusAgendamento } from '../../domain/enums/status-agendamento.enum';
+
+/**
+ * Service responsável por orquestrar casos de uso de Agendamento.
+ * Não contém regras de domínio, apenas coordena operações.
+ */
+@Injectable()
+export class AgendamentoService {
+  constructor(
+    private readonly agendamentoRepository: AgendamentoRepository,
+    private readonly notificacaoService: NotificacaoService,
+  ) {}
+
+  /**
+   * Cria um novo agendamento validando regras de negócio.
+   * @throws BadRequestException - Data no passado
+   * @throws ConflictException - Horário já ocupado
+   */
+  async criar(dto: CriarAgendamentoDto): Promise<AgendamentoResponseDto> {
+    // Validar: não pode ser no passado
+    if (dto.dataHora < new Date()) {
+      throw new BadRequestException('Não é possível agendar no passado');
+    }
+
+    // Validar: horário disponível
+    const conflito = await this.agendamentoRepository.findByHorarioEPrestador(
+      dto.dataHora,
+      dto.prestadorId,
+    );
+    if (conflito) {
+      throw new ConflictException('Horário já ocupado para este prestador');
+    }
+
+    // Criar agendamento
+    const agendamento = await this.agendamentoRepository.create({
+      ...dto,
+      status: StatusAgendamento.PENDENTE,
+    });
+
+    // Side effect: notificar cliente
+    await this.notificacaoService.enviarConfirmacaoAgendamento(agendamento);
+
+    return AgendamentoResponseDto.fromEntity(agendamento);
+  }
+
+  /**
+   * Cancela um agendamento respeitando a regra de 2h.
+   * @throws BadRequestException - Menos de 2h para o horário
+   */
+  async cancelar(id: string, motivo: string): Promise<void> {
+    const agendamento = await this.agendamentoRepository.findById(id);
+    
+    // Validar: limite de 2h
+    const duasHorasAntes = new Date(agendamento.dataHora);
+    duasHorasAntes.setHours(duasHorasAntes.getHours() - 2);
+    
+    if (new Date() > duasHorasAntes) {
+      throw new BadRequestException(
+        'Cancelamento só é permitido até 2 horas antes do horário',
+      );
+    }
+
+    await this.agendamentoRepository.updateStatus(id, StatusAgendamento.CANCELADO);
+    await this.notificacaoService.enviarCancelamento(agendamento, motivo);
+  }
+}
+```
+
+---
+
+## Variações por Stack
+
+### Python + FastAPI
+
+```python
+from fastapi import HTTPException, status
+from app.repositories.agendamento_repository import AgendamentoRepository
+from app.services.notificacao_service import NotificacaoService
+from app.schemas.agendamento import CriarAgendamentoDto, AgendamentoResponse
+
+class AgendamentoService:
+    def __init__(
+        self,
+        repository: AgendamentoRepository,
+        notificacao: NotificacaoService,
+    ):
+        self._repository = repository
+        self._notificacao = notificacao
+
+    async def criar(self, dto: CriarAgendamentoDto) -> AgendamentoResponse:
+        if dto.data_hora < datetime.now():
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Não é possível agendar no passado"
+            )
+        # ... resto da lógica
+```
+
+### Java + Spring
+
+```java
+@Service
+@Transactional
+public class AgendamentoService {
+    
+    private final AgendamentoRepository repository;
+    private final NotificacaoService notificacao;
+    
+    public AgendamentoService(
+        AgendamentoRepository repository,
+        NotificacaoService notificacao
+    ) {
+        this.repository = repository;
+        this.notificacao = notificacao;
+    }
+    
+    public AgendamentoResponse criar(CriarAgendamentoDto dto) {
+        if (dto.getDataHora().isBefore(LocalDateTime.now())) {
+            throw new BadRequestException("Não é possível agendar no passado");
+        }
+        // ... resto da lógica
+    }
+}
+```
+
+---
+
+## Checklist Pós-Geração
+
+- [ ] Service não contém lógica de domínio complexa (mover para Domain Service se necessário)
+- [ ] Todas as dependências são injetadas (não há `new` de repositórios)
+- [ ] DTOs separados para entrada e saída
+- [ ] Exceções são específicas (não genéricas)
+- [ ] Validações de negócio estão presentes
+- [ ] Side effects (notificações, eventos) estão isolados
+- [ ] Código está tipado corretamente
+- [ ] Comentários explicam o "porquê", não o "como"