maestro-bundle 1.0.0

package/templates/bundle-jhipster-microservices/skills/jhipster-kafka/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: jhipster-kafka
+description: Configurar Apache Kafka no JHipster para comunicação assíncrona entre microsserviços com eventos de domínio. Use quando precisar de messaging, eventos entre serviços, ou processamento assíncrono.
+---
+
+# Kafka no JHipster Microservices
+
+## Setup
+
+```yaml
+# docker-compose/kafka.yml
+services:
+  zookeeper:
+    image: confluentinc/cp-zookeeper:7.5.0
+    environment:
+      ZOOKEEPER_CLIENT_PORT: 2181
+
+  kafka:
+    image: confluentinc/cp-kafka:7.5.0
+    depends_on:
+      - zookeeper
+    ports:
+      - "9092:9092"
+    environment:
+      KAFKA_BROKER_ID: 1
+      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
+      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://localhost:9092
+      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
+      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
+```
+
+## Tópicos por domínio
+
+| Tópico | Producer | Consumer | Evento |
+|---|---|---|---|
+| `demand-events` | demand-service | agent-service, tracking-service | DemandCreated, DemandDecomposed |
+| `agent-events` | agent-service | demand-service, tracking-service | AgentAllocated, TaskCompleted |
+| `bundle-events` | bundle-service | agent-service | BundleUpdated, SkillAdded |
+| `tracking-events` | tracking-service | gateway (WebSocket) | MetricsUpdated |
+
+## Eventos de domínio
+
+```java
+// Evento base
+public sealed interface DomainEvent permits DemandCreated, DemandDecomposed, TaskCompleted {
+    String eventId();
+    Instant occurredAt();
+    String aggregateId();
+}
+
+// Eventos específicos
+public record DemandCreated(
+    String eventId,
+    Instant occurredAt,
+    String aggregateId,
+    String description,
+    String priority
+) implements DomainEvent {}
+
+public record TaskCompleted(
+    String eventId,
+    Instant occurredAt,
+    String aggregateId,
+    Long taskId,
+    Long agentId,
+    String branchName,
+    double durationSeconds
+) implements DomainEvent {}
+```
+
+## Producer
+
+```java
+@Service
+@RequiredArgsConstructor
+public class DemandEventProducer {
+
+    private final KafkaTemplate<String, DomainEvent> kafkaTemplate;
+
+    public void publish(DomainEvent event) {
+        kafkaTemplate.send("demand-events", event.aggregateId(), event)
+            .whenComplete((result, ex) -> {
+                if (ex != null) {
+                    log.error("Failed to publish event {}", event.eventId(), ex);
+                } else {
+                    log.info("Published {} to partition {}", event.eventId(),
+                        result.getRecordMetadata().partition());
+                }
+            });
+    }
+}
+```
+
+## Consumer com idempotência
+
+```java
+@Service
+@RequiredArgsConstructor
+public class DemandEventConsumer {
+
+    private final ProcessedEventRepository processedEventRepo;
+    private final AgentAllocationService allocationService;
+
+    @KafkaListener(topics = "demand-events", groupId = "agent-service")
+    public void onDemandEvent(DomainEvent event) {
+        // Idempotência: ignorar evento já processado
+        if (processedEventRepo.existsById(event.eventId())) {
+            log.info("Event {} already processed, skipping", event.eventId());
+            return;
+        }
+
+        switch (event) {
+            case DemandDecomposed e -> allocationService.allocateForDemand(e);
+            case DemandCreated e -> log.info("Demand created: {}", e.aggregateId());
+            default -> log.warn("Unknown event type: {}", event.getClass().getSimpleName());
+        }
+
+        processedEventRepo.save(new ProcessedEvent(event.eventId(), Instant.now()));
+    }
+}
+```
+
+## Dead Letter Queue
+
+```yaml
+spring:
+  cloud:
+    stream:
+      kafka:
+        bindings:
+          demandEvents-in-0:
+            consumer:
+              enableDlq: true
+              dlqName: demand-events-dlq
+              autoCommitOnError: false
+```
+
+## Regras
+
+- Um tópico por bounded context (não por entidade)
+- Consumers DEVEM ser idempotentes
+- DLQ para eventos que falharam
+- Events são imutáveis (records)
+- Incluir `eventId` e `occurredAt` em todo evento
+- Consumer group = nome do serviço

package/templates/bundle-jhipster-microservices/skills/jhipster-registry/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: jhipster-registry
+description: Configurar service discovery com JHipster Registry (Consul ou Eureka) e configuração centralizada. Use quando precisar registrar serviços, configurar discovery, ou centralizar configurações.
+---
+
+# JHipster Registry / Service Discovery
+
+## Consul (recomendado)
+
+### Docker Compose
+```yaml
+consul:
+  image: consul:1.15
+  ports:
+    - "8500:8500"
+  command: agent -server -bootstrap -ui -client=0.0.0.0
+```
+
+### Configuração no serviço
+```yaml
+# application.yml de cada microsserviço
+spring:
+  cloud:
+    consul:
+      host: consul
+      port: 8500
+      discovery:
+        service-name: ${spring.application.name}
+        health-check-path: /management/health
+        health-check-interval: 15s
+        instance-id: ${spring.application.name}:${random.value}
+      config:
+        enabled: true
+        format: yaml
+        default-context: application
+```
+
+### Configuração centralizada no Consul
+
+Colocar configs compartilhadas no Consul KV store:
+
+```yaml
+# config/application/data no Consul KV
+spring:
+  datasource:
+    type: com.zaxxer.hikari.HikariDataSource
+    hikari:
+      maximum-pool-size: 20
+
+management:
+  endpoints:
+    web:
+      exposure:
+        include: health,info,prometheus
+```
+
+## Service-to-Service communication
+
+Cada serviço se registra automaticamente. Para chamar outro serviço:
+
+```java
+// Feign Client com discovery
+@FeignClient(name = "agent-service")
+public interface AgentServiceClient {
+    @GetMapping("/api/agents/{id}")
+    AgentDTO getAgent(@PathVariable Long id);
+}
+
+// O nome "agent-service" é resolvido via Consul/Eureka
+```
+
+## Health checks
+
+- Consul verifica `/management/health` de cada serviço
+- Se um serviço ficar unhealthy, Consul remove do registry
+- Gateway para de rotear para instâncias unhealthy automaticamente
+
+## Regras
+
+- Todo serviço DEVE se registrar no discovery
+- Health check endpoint DEVE responder em < 1s
+- Usar `instance-id` com random para permitir múltiplas instâncias
+- Configs compartilhadas no Consul KV, específicas no application.yml local

package/templates/bundle-jhipster-microservices/skills/jhipster-service/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: jhipster-service
+description: Criar e configurar um microsserviço JHipster com Spring Boot, incluindo API, banco próprio e comunicação inter-serviço. Use quando precisar criar um novo microsserviço, configurar Feign clients, ou definir APIs internas.
+---
+
+# JHipster Microservice
+
+## Criar novo serviço
+
+```bash
+# Gerar via JDL (recomendado)
+jhipster import-jdl jhipster-jdl.jdl
+
+# Ou gerar manualmente
+mkdir bundle-service && cd bundle-service
+jhipster --blueprints="" --skip-client
+```
+
+## Configuração do serviço
+
+```yaml
+# application.yml
+spring:
+  application:
+    name: bundle-service
+server:
+  port: 8084
+
+# Banco próprio (database per service)
+spring:
+  datasource:
+    url: jdbc:postgresql://localhost:5432/bundle_service
+    username: bundle
+    password: bundle
+
+# Kafka
+spring:
+  cloud:
+    stream:
+      kafka:
+        binder:
+          brokers: kafka:9092
+      bindings:
+        bundleEvents-out-0:
+          destination: bundle-events
+        demandEvents-in-0:
+          destination: demand-events
+          group: bundle-service
+```
+
+## Comunicação Síncrona — Feign
+
+```java
+@FeignClient(name = "demand-service", fallback = DemandServiceFallback.class)
+public interface DemandServiceClient {
+
+    @GetMapping("/api/demands/{id}")
+    DemandDTO getDemand(@PathVariable Long id);
+
+    @PutMapping("/api/demands/{id}/status")
+    void updateStatus(@PathVariable Long id, @RequestBody StatusUpdateDTO dto);
+}
+
+@Component
+public class DemandServiceFallback implements DemandServiceClient {
+
+    @Override
+    public DemandDTO getDemand(Long id) {
+        log.warn("Demand service unavailable for demand {}", id);
+        return null;
+    }
+
+    @Override
+    public void updateStatus(Long id, StatusUpdateDTO dto) {
+        log.warn("Cannot update demand {} status, service unavailable", id);
+        throw new ServiceUnavailableException("demand-service");
+    }
+}
+```
+
+## Comunicação Assíncrona — Kafka
+
+```java
+// Producer
+@Service
+public class BundleEventProducer {
+    private final StreamBridge streamBridge;
+
+    public void publishBundleUpdated(Bundle bundle) {
+        BundleUpdatedEvent event = new BundleUpdatedEvent(
+            bundle.getId(), bundle.getName(), bundle.getVersion()
+        );
+        streamBridge.send("bundleEvents-out-0", event);
+    }
+}
+
+// Consumer
+@Bean
+public Consumer<DemandCreatedEvent> demandEvents() {
+    return event -> {
+        log.info("Demand created: {}", event.demandId());
+        bundleService.suggestBundleForDemand(event.demandId(), event.description());
+    };
+}
+```
+
+## Padrão de API interna
+
+APIs entre serviços usam DTOs compartilhados (nunca entities):
+
+```java
+// Shared DTO — package separado ou duplicado (não compartilhar JARs)
+public record AgentAllocationRequest(
+    Long taskId,
+    AgentType requiredType,
+    String branchName
+) {}
+
+public record AgentAllocationResponse(
+    Long agentId,
+    String worktreePath,
+    String status
+) {}
+```
+
+## Regras
+
+- Cada serviço tem seu próprio banco — NUNCA acessar banco de outro
+- Falha de um serviço NÃO pode derrubar outros (circuit breaker)
+- Eventos Kafka para notificação, Feign para query
+- Idempotência em consumers Kafka (mesmo evento pode chegar 2x)

package/templates/bundle-jhipster-microservices/skills/testing-strategy/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: testing-strategy
+description: Implementar estratégia de testes com unitários, integração e e2e usando Pytest ou JUnit. Use quando for escrever testes, definir estratégia de testes, ou melhorar cobertura.
+---
+
+# Estratégia de Testes
+
+## Pirâmide
+
+```
+        /  E2E  \          Poucos, lentos, caros
+       /  Integr. \        Moderados
+      / Unitários   \      Muitos, rápidos, baratos
+```
+
+## Testes Unitários — Domínio
+
+Testar regras de negócio sem infraestrutura.
+
+```python
+# tests/domain/test_demand.py
+class TestDemand:
+    def test_should_decompose_new_demand(self):
+        demand = Demand(id=DemandId.generate(), description="Criar CRUD")
+        planner = FakePlanner(tasks=[Task(...), Task(...)])
+
+        tasks = demand.decompose(planner)
+
+        assert len(tasks) == 2
+        assert demand.status == DemandStatus.PLANNED
+
+    def test_should_reject_decompose_if_already_planned(self):
+        demand = Demand(id=DemandId.generate(), description="Criar CRUD")
+        demand.decompose(FakePlanner(tasks=[Task(...)]))
+
+        with pytest.raises(DemandAlreadyDecomposedException):
+            demand.decompose(FakePlanner(tasks=[]))
+
+    def test_should_not_allow_more_than_20_tasks(self):
+        demand = Demand(id=DemandId.generate(), description="Mega projeto")
+        for i in range(20):
+            demand.add_task(Task(...))
+
+        with pytest.raises(TooManyTasksException):
+            demand.add_task(Task(...))
+```
+
+## Testes Unitários — Value Objects
+
+```python
+class TestComplianceScore:
+    def test_passing_score(self):
+        score = ComplianceScore(85.0)
+        assert score.is_passing() is True
+
+    def test_failing_score(self):
+        score = ComplianceScore(60.0)
+        assert score.is_passing() is False
+
+    def test_invalid_score_raises(self):
+        with pytest.raises(ValueError):
+            ComplianceScore(150.0)
+```
+
+## Testes de Integração — Repositórios
+
+```python
+# tests/infrastructure/test_pg_demand_repository.py
+@pytest.fixture
+def db_session():
+    engine = create_engine(TEST_DATABASE_URL)
+    with Session(engine) as session:
+        yield session
+        session.rollback()
+
+class TestPgDemandRepository:
+    def test_should_save_and_find_demand(self, db_session):
+        repo = PgDemandRepository(db_session)
+        demand = Demand(id=DemandId.generate(), description="Test")
+
+        repo.save(demand)
+        found = repo.find_by_id(demand.id)
+
+        assert found.description == "Test"
+```
+
+## Naming
+
+```
+test_should_<resultado>_when_<condição>
+
+test_should_return_error_when_email_is_invalid
+test_should_decompose_demand_when_status_is_created
+test_should_reject_merge_when_conflicts_exist
+```

package/templates/bundle-jhipster-monorepo/.spec/constitution.md

@@ -0,0 +1,32 @@
+# Constitution — Projeto JHipster Monorepo
+
+## Princípios
+
+1. **Spec primeiro, código depois** — Toda demanda passa pelo fluxo SDD antes de implementação
+2. **JDL como fonte de verdade** — Modelo de entidades definido em JDL, código gerado pelo JHipster
+3. **Enriquecer, não substituir** — Entidades geradas pelo JHipster são enriquecidas com DDD, não reescritas do zero
+4. **Migrations versionadas** — Toda mudança de schema via Liquibase changeset, nunca manual
+5. **DTO na fronteira** — Nunca expor entidade JPA na API REST
+
+## Padrões de desenvolvimento
+
+### Java / Spring Boot
+- Java 21+, Records para DTOs
+- Constructor injection (nunca @Autowired em campo)
+- @Transactional apenas no Service
+- Entidades com comportamento rico (não anêmicas)
+- MapStruct para conversão Entity ↔ DTO
+
+### Angular
+- Standalone components (Angular 17+)
+- Lazy loading por rota
+- Reactive Forms com validação
+- Services para chamadas HTTP
+
+## Padrões de qualidade
+
+- Cobertura mínima: 80%
+- JUnit 5 + Mockito para backend
+- Jest + Cypress para frontend
+- Code review obrigatório
+- Commits seguem Conventional Commits