maestro-bundle 1.0.0

package/templates/bundle-jhipster-microservices/skills/ddd-tactical/SKILL.md

@@ -0,0 +1,138 @@
+---
+name: ddd-tactical
+description: Implementar padrões táticos do DDD - Entities, Value Objects, Aggregates, Domain Events, Repositories e Domain Services. Use quando for modelar domínio, criar entidades ricas, ou aplicar DDD no código.
+---
+
+# DDD Tático
+
+## Value Objects
+
+Imutáveis, comparados por valor, contêm validação.
+
+```python
+@dataclass(frozen=True)
+class Email:
+    value: str
+
+    def __post_init__(self):
+        if not re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', self.value):
+            raise InvalidEmailException(self.value)
+
+@dataclass(frozen=True)
+class ComplianceScore:
+    value: float
+
+    def __post_init__(self):
+        if not 0 <= self.value <= 100:
+            raise ValueError("Score deve ser entre 0 e 100")
+
+    def is_passing(self) -> bool:
+        return self.value >= 80.0
+
+    def __str__(self) -> str:
+        return f"{self.value:.1f}%"
+```
+
+## Entities
+
+Identidade única, mutáveis, contêm comportamento.
+
+```python
+class Task:
+    def __init__(self, id: TaskId, description: str, agent_type: AgentType):
+        self._id = id
+        self._description = description
+        self._agent_type = agent_type
+        self._status = TaskStatus.PENDING
+        self._started_at: datetime | None = None
+        self._completed_at: datetime | None = None
+
+    def start(self) -> None:
+        if self._status != TaskStatus.PENDING:
+            raise TaskNotPendingException(self._id)
+        self._status = TaskStatus.IN_PROGRESS
+        self._started_at = datetime.now()
+
+    def complete(self, result: TaskResult) -> None:
+        if self._status != TaskStatus.IN_PROGRESS:
+            raise TaskNotInProgressException(self._id)
+        self._status = TaskStatus.COMPLETED
+        self._completed_at = datetime.now()
+
+    @property
+    def duration(self) -> timedelta | None:
+        if self._started_at and self._completed_at:
+            return self._completed_at - self._started_at
+        return None
+```
+
+## Aggregates
+
+Cluster de entities com uma raiz que protege invariantes.
+
+```python
+class Demand:  # Aggregate Root
+    """Demand é a raiz. Tasks só são acessadas via Demand."""
+
+    def add_task(self, task: Task) -> None:
+        if len(self._tasks) >= 20:
+            raise TooManyTasksException("Máximo 20 tasks por demanda")
+        self._tasks.append(task)
+
+    def start_task(self, task_id: TaskId) -> None:
+        task = self._find_task(task_id)
+        # Verificar invariante: não ter mais de 3 tasks simultâneas
+        active = [t for t in self._tasks if t.status == TaskStatus.IN_PROGRESS]
+        if len(active) >= 3:
+            raise TooManyActiveTasksException()
+        task.start()
+```
+
+## Domain Events
+
+Notificam que algo aconteceu no domínio.
+
+```python
+@dataclass(frozen=True)
+class DomainEvent:
+    occurred_at: datetime = field(default_factory=datetime.now)
+
+@dataclass(frozen=True)
+class TaskCompleted(DomainEvent):
+    task_id: TaskId
+    agent_id: AgentId
+    branch_name: str
+    duration_seconds: float
+
+@dataclass(frozen=True)
+class ComplianceViolationDetected(DomainEvent):
+    agent_id: AgentId
+    bundle_name: str
+    violations: list[str]
+    severity: str  # "warning" | "critical"
+```
+
+## Domain Services
+
+Lógica que não pertence a uma única entidade.
+
+```python
+class TeamRecruitmentService:
+    def recruit_for_demand(self, demand: Demand, available: list[Agent]) -> AgentTeam:
+        complexity = demand.assess_complexity()
+        required = self._determine_roles(complexity)
+        team = AgentTeam()
+        for role in required:
+            agent = next((a for a in available if a.type == role and a.is_available), None)
+            if not agent:
+                raise NoAvailableAgentException(role)
+            team.add(agent)
+        return team
+```
+
+## Ordem de prioridade para regras
+
+1. **Value Object** — validação e comportamento simples
+2. **Entity** — regras que envolvem estado da entidade
+3. **Domain Service** — regras que envolvem múltiplas entidades
+4. **Use Case** — orquestração (NÃO contém regras)

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

@@ -0,0 +1,97 @@
+---
+name: jhipster-angular
+description: Desenvolver frontend Angular no Gateway JHipster que consome múltiplos microsserviços. Use quando precisar criar telas que agregam dados de vários serviços, ou customizar o frontend do Gateway.
+---
+
+# JHipster Angular — Microservices
+
+## Diferença do Monorepo
+
+No microservices, o Angular fica no **Gateway**. Ele não sabe que existem múltiplos serviços — o Gateway roteia transparentemente.
+
+```
+Browser → Gateway:8080/api/demands → demand-service:8081/api/demands
+Browser → Gateway:8080/api/agents  → agent-service:8082/api/agents
+```
+
+Do ponto de vista do Angular, tudo é uma API só.
+
+## Services que agregam dados
+
+```typescript
+// dashboard.service.ts — agrega dados de múltiplos serviços (via gateway)
+@Injectable({ providedIn: 'root' })
+export class DashboardService {
+  constructor(
+    private demandService: DemandService,
+    private agentService: AgentService,
+    private trackingService: TrackingService,
+  ) {}
+
+  getMetrics(): Observable<DashboardMetrics> {
+    return forkJoin({
+      activeDemands: this.demandService.countByStatus('IN_PROGRESS'),
+      activeAgents: this.agentService.countByStatus('BUSY'),
+      completedToday: this.trackingService.getCompletedToday(),
+      complianceRate: this.trackingService.getComplianceRate(),
+    });
+  }
+}
+```
+
+## Tratamento de falha parcial
+
+Se um serviço estiver fora do ar, mostrar o que conseguir:
+
+```typescript
+getMetrics(): Observable<DashboardMetrics> {
+  return forkJoin({
+    activeDemands: this.demandService.countByStatus('IN_PROGRESS').pipe(
+      catchError(() => of({ count: -1 }))  // -1 = indisponível
+    ),
+    activeAgents: this.agentService.countByStatus('BUSY').pipe(
+      catchError(() => of({ count: -1 }))
+    ),
+  });
+}
+```
+
+```html
+<div *ngIf="metrics.activeDemands.count >= 0; else unavailable">
+  {{ metrics.activeDemands.count }}
+</div>
+<ng-template #unavailable>
+  <span class="text-muted">Indisponível</span>
+</ng-template>
+```
+
+## WebSocket para real-time
+
+```typescript
+// No Gateway, conectar via STOMP
+@Injectable({ providedIn: 'root' })
+export class WebSocketService {
+  private stompClient: RxStomp;
+
+  connect(): void {
+    this.stompClient = new RxStomp();
+    this.stompClient.configure({
+      brokerURL: `ws://${location.host}/websocket`,
+    });
+    this.stompClient.activate();
+  }
+
+  onAgentEvent(): Observable<TrackingEvent> {
+    return this.stompClient.watch('/topic/tracking').pipe(
+      map(msg => JSON.parse(msg.body))
+    );
+  }
+}
+```
+
+## Regras
+
+- Frontend no Gateway, não nos serviços
+- Tratar falha de serviços individuais gracefully
+- Usar `forkJoin` para agregar, `catchError` para resiliência
+- Lazy loading por módulo/feature

package/templates/bundle-jhipster-microservices/skills/jhipster-docker-k8s/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: jhipster-docker-k8s
+description: Deploy de microsserviços JHipster com Docker Compose (dev) e Kubernetes/K3s (prod). Use quando precisar containerizar serviços JHipster, criar docker-compose, ou fazer deploy em K8s.
+---
+
+# Docker & Kubernetes para JHipster Microservices
+
+## Docker Compose — Dev
+
+```bash
+# Gerar docker-compose via JHipster
+jhipster docker-compose
+
+# Ou usar o gerado pelo JDL deployment
+```
+
+```yaml
+# docker-compose/docker-compose.yml
+services:
+  gateway:
+    image: gateway:latest
+    ports:
+      - "8080:8080"
+    environment:
+      - SPRING_PROFILES_ACTIVE=dev
+      - SPRING_CLOUD_CONSUL_HOST=consul
+    depends_on:
+      - consul
+      - keycloak
+
+  demand-service:
+    image: demand-service:latest
+    environment:
+      - SPRING_PROFILES_ACTIVE=dev
+      - SPRING_CLOUD_CONSUL_HOST=consul
+      - SPRING_DATASOURCE_URL=jdbc:postgresql://demand-db:5432/demand
+    depends_on:
+      - demand-db
+      - consul
+      - kafka
+
+  demand-db:
+    image: postgres:16
+    environment:
+      POSTGRES_DB: demand
+      POSTGRES_USER: demand
+      POSTGRES_PASSWORD: demand
+
+  agent-service:
+    image: agent-service:latest
+    environment:
+      - SPRING_PROFILES_ACTIVE=dev
+      - SPRING_CLOUD_CONSUL_HOST=consul
+      - SPRING_DATASOURCE_URL=jdbc:postgresql://agent-db:5432/agent
+    depends_on:
+      - agent-db
+      - consul
+      - kafka
+
+  agent-db:
+    image: postgres:16
+    environment:
+      POSTGRES_DB: agent
+      POSTGRES_USER: agent
+      POSTGRES_PASSWORD: agent
+
+  consul:
+    image: consul:1.15
+    ports:
+      - "8500:8500"
+    command: agent -server -bootstrap -ui -client=0.0.0.0
+
+  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
+
+  zookeeper:
+    image: confluentinc/cp-zookeeper:7.5.0
+    environment:
+      ZOOKEEPER_CLIENT_PORT: 2181
+
+  keycloak:
+    image: quay.io/keycloak/keycloak:23.0
+    ports:
+      - "9080:8080"
+    environment:
+      KEYCLOAK_ADMIN: admin
+      KEYCLOAK_ADMIN_PASSWORD: admin
+    command: start-dev --import-realm
+    volumes:
+      - ./keycloak-realm.json:/opt/keycloak/data/import/realm.json
+```
+
+## Kubernetes — Prod
+
+```bash
+# Gerar manifests via JHipster
+jhipster kubernetes
+```
+
+### Deployment por serviço
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: demand-service
+  namespace: maestro
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: demand-service
+  template:
+    spec:
+      containers:
+        - name: demand-service
+          image: registry.local/demand-service:1.0.0
+          ports:
+            - containerPort: 8081
+          resources:
+            requests:
+              memory: "512Mi"
+              cpu: "500m"
+            limits:
+              memory: "1Gi"
+              cpu: "1000m"
+          readinessProbe:
+            httpGet:
+              path: /management/health/readiness
+              port: 8081
+            initialDelaySeconds: 30
+          livenessProbe:
+            httpGet:
+              path: /management/health/liveness
+              port: 8081
+            initialDelaySeconds: 60
+          env:
+            - name: SPRING_PROFILES_ACTIVE
+              value: prod
+            - name: SPRING_DATASOURCE_URL
+              valueFrom:
+                secretKeyRef:
+                  name: demand-service-db
+                  key: url
+```
+
+## Build de imagens
+
+```bash
+# Build com Jib (padrão JHipster, sem Docker daemon)
+./mvnw -ntp verify -DskipTests jib:dockerBuild -Pprod
+
+# Ou com Docker
+docker build -t demand-service:1.0.0 .
+```
+
+## Comandos úteis
+
+```bash
+# Dev: subir tudo
+docker-compose -f docker-compose/docker-compose.yml up -d
+
+# Dev: ver logs de um serviço
+docker-compose logs -f demand-service
+
+# Prod: deploy
+kubectl apply -f k8s/
+
+# Prod: rollback
+kubectl rollout undo deployment/demand-service -n maestro
+
+# Prod: escalar
+kubectl scale deployment demand-service --replicas=3 -n maestro
+```

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

@@ -0,0 +1,87 @@
+---
+name: jhipster-entities
+description: Criar e gerenciar entidades JHipster com JDL para microsserviços, incluindo relações cross-service e DTOs compartilhados. Use quando precisar criar entidades, definir modelo de dados, ou gerar código em microsserviços.
+---
+
+# JHipster Entities — Microservices
+
+## Regra fundamental
+
+Em microsserviços, **entidades pertencem a um único serviço**. Relacionamentos cross-service usam IDs, não foreign keys.
+
+## JDL com microservice assignment
+
+```jdl
+/* demand-service entities */
+entity Demand {
+    description TextBlob required
+    status DemandStatus required
+    priority Priority required
+    createdAt Instant required
+}
+
+entity Task {
+    description String required maxlength(500)
+    status TaskStatus required
+    agentId Long             // ID do agente (outro serviço), não FK
+    branchName String
+}
+
+relationship OneToMany {
+    Demand{tasks} to Task{demand required}
+}
+
+microservice Demand, Task with demandService
+
+/* agent-service entities */
+entity Agent {
+    name String required
+    type AgentType required
+    status AgentStatus required
+    worktreePath String
+}
+
+entity AgentTeam {
+    demandId Long required   // ID da demand (outro serviço), não FK
+}
+
+relationship ManyToMany {
+    AgentTeam{agents} to Agent
+}
+
+microservice Agent, AgentTeam with agentService
+```
+
+## Comunicação cross-service
+
+Quando `Task` referencia `Agent` (outro serviço):
+
+```java
+// NO demand-service — Task.java
+@Entity
+public class Task {
+    // ...
+    private Long agentId;  // Apenas o ID, não a entidade Agent
+
+    // Para obter dados do Agent, chamar agent-service via Feign
+}
+
+// NO demand-service — DemandService
+@Service
+public class DemandServiceImpl {
+    private final AgentServiceClient agentClient;
+
+    public TaskDetailDTO getTaskDetail(Long taskId) {
+        Task task = taskRepository.findById(taskId).orElseThrow();
+        AgentDTO agent = agentClient.getAgent(task.getAgentId()); // Feign call
+        return new TaskDetailDTO(task, agent);
+    }
+}
+```
+
+## Regras
+
+- Entidade pertence a UM serviço
+- Cross-service: guardar apenas o ID, nunca FK real
+- Para exibir dados de outro serviço: Feign Client ou evento Kafka
+- Nunca compartilhar entities entre serviços (duplicar DTOs se necessário)

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

@@ -0,0 +1,96 @@
+---
+name: jhipster-gateway
+description: Configurar o JHipster Gateway com Spring Cloud Gateway, roteamento, rate limiting e frontend Angular. Use quando precisar configurar rotas do gateway, load balancing, ou CORS entre serviços.
+---
+
+# JHipster Gateway
+
+## O que é
+
+O Gateway é o ponto de entrada único. Ele roteia requests para os microsserviços, serve o frontend Angular e gerencia autenticação.
+
+## Roteamento
+
+```yaml
+# application.yml
+spring:
+  cloud:
+    gateway:
+      routes:
+        - id: demand-service
+          uri: lb://demand-service
+          predicates:
+            - Path=/api/demands/**,/api/tasks/**
+        - id: agent-service
+          uri: lb://agent-service
+          predicates:
+            - Path=/api/agents/**,/api/teams/**
+        - id: tracking-service
+          uri: lb://tracking-service
+          predicates:
+            - Path=/api/tracking/**,/api/events/**
+      default-filters:
+        - TokenRelay
+```
+
+## Rate Limiting no Gateway
+
+```yaml
+spring:
+  cloud:
+    gateway:
+      routes:
+        - id: demand-service
+          uri: lb://demand-service
+          predicates:
+            - Path=/api/demands/**
+          filters:
+            - name: RequestRateLimiter
+              args:
+                redis-rate-limiter.replenishRate: 10
+                redis-rate-limiter.burstCapacity: 20
+                key-resolver: "#{@userKeyResolver}"
+```
+
+```java
+@Bean
+public KeyResolver userKeyResolver() {
+    return exchange -> Mono.just(
+        exchange.getRequest().getHeaders().getFirst("Authorization") != null
+            ? exchange.getRequest().getHeaders().getFirst("Authorization")
+            : exchange.getRequest().getRemoteAddress().getAddress().getHostAddress()
+    );
+}
+```
+
+## CORS
+
+```java
+@Bean
+public CorsWebFilter corsFilter() {
+    CorsConfiguration config = new CorsConfiguration();
+    config.setAllowedOrigins(List.of("http://localhost:4200", "https://maestro.local"));
+    config.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE", "OPTIONS"));
+    config.setAllowedHeaders(List.of("*"));
+    config.setAllowCredentials(true);
+
+    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+    source.registerCorsConfiguration("/api/**", config);
+    return new CorsWebFilter(source);
+}
+```
+
+## Health check dos serviços
+
+```yaml
+management:
+  endpoints:
+    web:
+      exposure:
+        include: health,info,gateway
+  endpoint:
+    gateway:
+      enabled: true
+```
+
+Acessar `GET /actuator/gateway/routes` para ver rotas ativas.