@maestro-ai/mcp-server 1.2.0 → 2.0.0

package/dist/content/skills/specialist-desenvolvimento-backend/SKILL.md

@@ -0,0 +1,288 @@
+---
+name: specialist-desenvolvimento-backend
+description: Implementação de services, controllers e testes seguindo clean code.
+allowed-tools: Read, Write, Edit, Glob, Grep
+---
+
+# Desenvolvimento e Vibe Coding Estruturado · Skill do Especialista
+
+## Missão
+Construir serviços backend alinhados ao contrato, com testes e qualidade, usando IA como pair programmer estruturado.
+
+## Quando ativar
+- Fase: Fase 11 · Desenvolvimento Backend
+- Workflows recomendados: /implementar-historia, /corrigir-bug, /refatorar-codigo
+- Use quando precisar para histórias backend, integrações ou refatorações de serviços.
+
+## Inputs obrigatórios
+- Design Doc (`docs/03-ux/design-doc.md`)
+- Modelo de Domínio (`docs/04-modelo/modelo-dominio.md`)
+- Arquitetura (`docs/06-arquitetura/arquitetura.md`)
+- Contrato de API (`docs/09-api/contrato-api.md`)
+- Backlog/História (`docs/08-backlog/`)
+
+## Outputs gerados
+- Services, controllers e entities
+- Testes unitários e de integração
+- DTOs e types
+- Documentação de API
+
+## Quality Gate
+- Código segue padrões do projeto
+- Testes unitários implementados (> 80% cobertura)
+- Testes de integração (fluxos críticos)
+- Sem warnings/erros de linter
+- Code review realizado
+- PR pronto para merge
+
+## Vibe Coding Estruturado: Fluxo por Blocos
+
+Para **cada história de usuário**, implemente em **blocos ordenados** com validação entre cada um:
+
+### Ordem de Implementação
+
+| # | Bloco | O que fazer | Validação |
+|---|-------|-------------|-----------|
+| 1 | **DTO/Types** | Definir contratos de entrada/saída | Lint |
+| 2 | **Entity** | Criar/alterar entidade (se necessário) | Lint |
+| 3 | **Repository** | Camada de dados | Lint |
+| 4 | **Service** | Regra de negócio | Testes unitários + Coverage ≥80% |
+| 5 | **Controller** | Endpoints/handlers | Lint |
+| 6 | **Testes E2E** | Fluxo completo | Todos passando |
+
+> **REGRA:** Só avance para o próximo bloco após validar o atual.
+
+### Fluxo Visual
+```
+US-007: Criar pedido
+
+┌─────┐   ┌────────┐   ┌──────┐   ┌─────────┐   ┌──────────┐
+│ DTO │ → │ Entity │ → │ Repo │ → │ Service │ → │Controller│
+└──┬──┘   └───┬────┘   └──┬───┘   └────┬────┘   └────┬─────┘
+   │          │           │            │              │
+   ▼          ▼           ▼            ▼              ▼
+[lint]     [lint]      [lint]    [testes+cov]     [lint]
+   ✓          ✓           ✓            ✓              ✓
+```
+
+## Prompts por Camada
+
+### Bloco 1: DTO/Types
+```text
+Stack: [STACK]
+Arquitetura: [PADRÃO]
+História: [COLE HISTÓRIA]
+
+Gere APENAS os DTOs/Types:
+- CreateXxxDto (entrada)
+- XxxResponseDto (saída)
+- Validações com decorators
+
+Não gere service, controller ou qualquer outra camada.
+```
+
+### Bloco 2: Entity
+```text
+DTOs já definidos:
+[COLE DTOS]
+
+Gere APENAS a entidade/model para [NOME]:
+- Campos com tipos
+- Relacionamentos
+- Decorators de ORM
+
+Não gere repository nem service.
+```
+
+### Bloco 3: Repository
+```text
+Entity já definida:
+[COLE ENTITY]
+
+Gere APENAS o repository para [NOME]:
+- Métodos CRUD
+- Queries específicas
+- Tipagem forte
+
+Não gere service nem controller.
+```
+
+### Bloco 4: Service + Testes
+```text
+DTOs e Repository implementados:
+[COLE]
+
+Gere o SERVICE para [HISTÓRIA]:
+- Regra de negócio
+- Validações
+- Tratamento de erros
+
+TAMBÉM gere TESTES UNITÁRIOS:
+- Caso de sucesso
+- Entradas inválidas
+- Casos de borda
+```
+
+### Bloco 5: Controller
+```text
+Service implementado e testado:
+[COLE SERVICE]
+
+Gere APENAS o controller:
+- Rotas e verbos HTTP
+- Validação via DTO
+- Mapeamento de erros
+- Documentação Swagger
+```
+
+### Bloco 6: Testes E2E
+```text
+Controller e Service implementados.
+
+Gere testes de integração/E2E:
+- Happy path completo
+- Erro de validação
+- Erro de negócio
+```
+
+## Guardrails Críticos
+
+### NUNCA Faça
+- **NUNCA** pule blocos do fluxo
+- **NUNCA** avance sem validar o bloco atual
+- **NUNCA** gere código sem testes (services)
+- **NUNCA** ignore warnings do linter
+
+### SEMPRE Faça
+- **SEMPRE** consulte o Design Doc antes de implementar
+- **SEMPRE** siga o mapa de navegação definido
+- **SEMPRE** respeite os fluxos de usuário mapeados
+- **SEMPRE** valide cobertura ≥ 80% para services
+
+### Checklist por Bloco
+Antes de avançar para o próximo bloco:
+- [ ] Testes passando (`npm test`)
+- [ ] Lint ok (`npm run lint`)
+- [ ] Coverage ≥ 80% (para service)
+- [ ] Código revisado
+
+## Stack Guidelines por Linguagem
+
+### Node.js + TypeScript
+```typescript
+// DTO com decorators
+class CreateUserDto {
+  @IsEmail()
+  email: string;
+  
+  @IsString()
+  @MinLength(3)
+  name: string;
+}
+
+// Service com injeção de dependência
+@Injectable()
+export class UserService {
+  constructor(
+    @InjectRepository(User)
+    private userRepository: Repository<User>
+  ) {}
+}
+```
+
+### Python + FastAPI
+```python
+# Pydantic models
+class CreateUserRequest(BaseModel):
+    email: EmailStr
+    name: constr(min_length=3)
+
+# Service pattern
+class UserService:
+    def __init__(self, user_repo: UserRepository):
+        self.user_repo = user_repo
+```
+
+### Java + Spring Boot
+```java
+// DTO com validações
+public record CreateUserRequest(
+    @NotBlank @Email String email,
+    @NotBlank @Size(min = 3) String name
+) {}
+
+// Service com @Service
+@Service
+public class UserService {
+    private final UserRepository userRepository;
+}
+```
+
+## Context Flow
+
+### Artefatos Obrigatórios para Iniciar
+Cole no início:
+1. Design Doc completo com wireframes
+2. Modelo de domínio com entidades
+3. Arquitetura com stack definida
+4. Contrato de API (se existir)
+5. História atual do backlog
+
+### Prompt de Continuação
+```
+Atue como Engenheiro Backend Sênior.
+
+Contexto do projeto:
+[COLE docs/CONTEXTO.md]
+
+Design Doc:
+[COLE docs/03-ux/design-doc.md]
+
+Modelo de Domínio:
+[COLE docs/04-modelo/modelo-dominio.md]
+
+Arquitetura:
+[COLE docs/06-arquitetura/arquitetura.md]
+
+História atual:
+[COLE HISTÓRIA DO BACKLOG]
+
+Preciso implementar esta história seguindo o fluxo estruturado.
+```
+
+### Ao Concluir Cada História
+1. **Valide todos os blocos** usando checklist
+2. **Execute testes completos** (unitários + integração)
+3. **Verifique coverage** ≥ 80%
+4. **Faça code review** dos artefatos
+5. **Prepare PR** para merge
+
+## Métricas de Qualidade
+
+### Indicadores Obrigatórios
+- **Coverage:** ≥ 80% para services
+- **Lint:** Zero warnings/errors
+- **Test Pass Rate:** 100%
+- **Build Time:** < 2 minutos
+- **Bundle Size:** Monitorar regressões
+
+### Metas de Qualidade
+- Coverage: ≥ 85%
+- Lint: Zero issues
+- Test Pass Rate: 100%
+- Performance: < 200ms por request
+
+## Skills complementares
+- `clean-code`
+- `nodejs-best-practices`
+- `python-patterns`
+- `api-patterns`
+- `database-design`
+
+## Referências essenciais
+- **Especialista original:** `content/specialists/Especialista em Desenvolvimento e Vibe Coding Estruturado.md`
+- **Artefatos alvo:**
+  - Services, controllers e entities
+  - Testes unitários e de integração
+  - DTOs e types
+  - Documentação de API

package/dist/content/skills/specialist-desenvolvimento-backend/mcp_functions/README.md

@@ -0,0 +1,17 @@
+# Funções MCP - Desenvolvimento Backend
+
+**Versão:** 2.0
+
+Este diretório contém **referências** para implementação das funções MCP.
+
+## Funções
+
+1. **init_backend_implementation** - Inicializar estrutura backend
+2. **validate_backend_quality** - Validar código e testes
+3. **process_backend_to_integration** - Preparar para integração
+
+Ver `MCP_INTEGRATION.md` para documentação completa.
+
+---
+
+**Arquitetura:** Skills Descritivas + Automação MCP

package/dist/content/skills/specialist-desenvolvimento-backend/resources/checklists/backend-validation.md

@@ -0,0 +1,44 @@
+# Checklist de Validação - Desenvolvimento Backend
+
+**Score Mínimo:** 75/100 pontos
+
+---
+
+## Arquitetura (25 pontos)
+
+- [ ] **[10 pts]** Clean Architecture implementada
+- [ ] **[8 pts]** SOLID principles seguidos
+- [ ] **[7 pts]** Dependency Injection configurada
+
+## Implementação (30 pontos)
+
+- [ ] **[10 pts]** Endpoints conforme contrato
+- [ ] **[8 pts]** Lógica de negócio implementada
+- [ ] **[7 pts]** Validação de entrada (DTOs)
+- [ ] **[5 pts]** Error handling robusto
+
+## Frontend-First (Obrigatório)
+
+- [ ] **Contrato API validado** - CONT-XXX aprovado antes do BE
+- [ ] **Mocks existentes** - handlers/servidor mock gerados do contrato
+
+## Testes (25 pontos)
+
+- [ ] **[10 pts]** Testes unitários (>80% coverage)
+- [ ] **[8 pts]** Testes de integração passando
+- [ ] **[7 pts]** Edge cases cobertos
+
+## Segurança (20 pontos)
+
+- [ ] **[6 pts]** Autenticação implementada
+- [ ] **[5 pts]** Autorização por roles
+- [ ] **[5 pts]** Sanitização de entrada
+- [ ] **[4 pts]** SQL injection prevenido
+
+---
+
+**Thresholds:**
+- **>= 85:** ✅ Excelente
+- **75-84:** ✅ Bom
+- **70-74:** ⚠️ Aceitável
+- **< 70:** ❌ Bloqueado

package/dist/content/skills/specialist-desenvolvimento-backend/resources/examples/backend-examples.md

@@ -0,0 +1,109 @@
+# Exemplos Práticos - Desenvolvimento Backend
+
+## Exemplo 1: CRUD Completo (NestJS)
+
+**Controller:**
+```typescript
+@Controller('users')
+export class UsersController {
+  constructor(private usersService: UsersService) {}
+
+  @Get()
+  findAll(@Query() query: PaginationDto) {
+    return this.usersService.findAll(query);
+  }
+
+  @Post()
+  create(@Body() dto: CreateUserDto) {
+    return this.usersService.create(dto);
+  }
+}
+```
+
+**Service:**
+```typescript
+@Injectable()
+export class UsersService {
+  constructor(private usersRepo: UsersRepository) {}
+
+  async create(dto: CreateUserDto): Promise<User> {
+    const user = this.usersRepo.create(dto);
+    return this.usersRepo.save(user);
+  }
+}
+```
+
+**Repository:**
+```typescript
+@Injectable()
+export class UsersRepository extends Repository<User> {
+  async findByEmail(email: string): Promise<User | null> {
+    return this.findOne({ where: { email } });
+  }
+}
+```
+
+---
+
+## Exemplo 2: Authentication Service
+
+**Service:**
+```typescript
+@Injectable()
+export class AuthService {
+  async login(dto: LoginDto): Promise<{ token: string }> {
+    const user = await this.usersService.validateUser(dto);
+    const token = this.jwtService.sign({ sub: user.id });
+    return { token };
+  }
+}
+```
+
+---
+
+## Exemplo 3: Payment Integration
+
+**Service:**
+```typescript
+@Injectable()
+export class PaymentService {
+  async processPayment(dto: PaymentDto): Promise<PaymentResult> {
+    const charge = await this.stripeClient.charges.create({
+      amount: dto.amount,
+      currency: 'usd',
+      source: dto.token,
+    });
+    return { success: true, chargeId: charge.id };
+  }
+}
+```
+
+---
+
+## Exemplo 4: Background Jobs
+
+**Processor:**
+```typescript
+@Processor('emails')
+export class EmailProcessor {
+  @Process('send')
+  async sendEmail(job: Job<SendEmailDto>) {
+    await this.emailService.send(job.data);
+  }
+}
+```
+
+---
+
+## Exemplo 5: Caching Layer
+
+**Service:**
+```typescript
+@Injectable()
+export class ProductsService {
+  @Cacheable('products', 3600)
+  async findAll(): Promise<Product[]> {
+    return this.productsRepo.find();
+  }
+}
+```

package/dist/content/skills/specialist-desenvolvimento-backend/resources/reference/backend-guide.md

@@ -0,0 +1,86 @@
+# Guia Completo - Desenvolvimento Backend
+
+## Clean Architecture
+
+### Camadas
+1. **Controllers:** Rotas HTTP
+2. **Services:** Lógica de negócio
+3. **Repositories:** Acesso a dados
+4. **Entities:** Modelos de domínio
+
+### Fluxo
+```
+Request → Controller → Service → Repository → Database
+Response ← Controller ← Service ← Repository ← Database
+```
+
+---
+
+## SOLID Principles
+
+- **S**ingle Responsibility
+- **O**pen/Closed
+- **L**iskov Substitution
+- **I**nterface Segregation
+- **D**ependency Inversion
+
+---
+
+## NestJS Best Practices
+
+### DTOs com Validação
+```typescript
+export class CreateUserDto {
+  @IsString()
+  @MinLength(3)
+  name: string;
+
+  @IsEmail()
+  email: string;
+}
+```
+
+### Error Handling
+```typescript
+throw new BadRequestException('Invalid email');
+throw new NotFoundException('User not found');
+throw new UnauthorizedException('Invalid credentials');
+```
+
+---
+
+## Testing Strategies
+
+### Unit Tests
+```typescript
+describe('UsersService', () => {
+  it('should create user', async () => {
+    const dto = { name: 'John', email: 'john@example.com' };
+    const result = await service.create(dto);
+    expect(result).toBeDefined();
+  });
+});
+```
+
+### Integration Tests
+```typescript
+describe('Users (e2e)', () => {
+  it('/users (POST)', () => {
+    return request(app.getHttpServer())
+      .post('/users')
+      .send({ name: 'John', email: 'john@example.com' })
+      .expect(201);
+  });
+});
+```
+
+---
+
+## Security Hardening
+
+- JWT Authentication
+- Role-based Authorization
+- Input Sanitization
+- SQL Injection Prevention
+- Rate Limiting
+- CORS Configuration