maestro-bundle 1.0.0

package/templates/bundle-jhipster-monorepo/AGENTS.md

@@ -0,0 +1,227 @@
+# Projeto: JHipster Monorepo
+
+Você está construindo uma aplicação monolítica com JHipster. Backend em Java/Spring Boot, frontend em Angular, banco PostgreSQL, tudo em um único repositório.
+
+## Specification-Driven Development (SDD)
+
+Este projeto usa **GitHub Spec Kit** para governança. Antes de implementar qualquer demanda:
+
+1. Rodar `/speckit.constitution` — se `.spec/constitution.md` não existir
+2. Rodar `/speckit.specify` — descrever O QUE e POR QUÊ (não como)
+3. Rodar `/speckit.plan` — arquitetura e decisões técnicas
+4. Rodar `/speckit.tasks` — quebrar em tasks atômicas
+5. Rodar `/speckit.implement` — executar as tasks
+
+Nunca pular direto para código. Spec primeiro, código depois.
+
+## References
+
+Documentos de referência que o agente deve consultar quando necessário:
+
+- `references/jhipster-jdl-guide.md` — Guia completo de JDL
+- `references/spring-boot-patterns.md` — Padrões Spring Boot
+- `references/angular-patterns.md` — Padrões Angular no JHipster
+- `references/liquibase-guide.md` — Guia de migrations Liquibase
+
+## Stack do projeto
+
+- **Backend:** Java 21 + Spring Boot 3.x (gerado pelo JHipster)
+- **Frontend:** Angular 17+ com TypeScript
+- **Banco:** PostgreSQL
+- **Cache:** Ehcache ou Redis
+- **Migrations:** Liquibase (padrão JHipster)
+- **Auth:** JWT (padrão JHipster) ou OAuth2/Keycloak
+- **Testes:** JUnit 5 + Mockito (back), Jest + Cypress (front)
+- **Build:** Maven ou Gradle
+- **API docs:** Swagger/OpenAPI (auto-gerado)
+
+## Estrutura JHipster Monorepo
+
+```
+project/
+├── src/
+│   ├── main/
+│   │   ├── java/com/empresa/projeto/
+│   │   │   ├── domain/                  # Entidades JPA (enriquecer com DDD)
+│   │   │   │   ├── Demand.java
+│   │   │   │   ├── Task.java
+│   │   │   │   └── enumeration/
+│   │   │   ├── repository/              # Spring Data JPA repositories
+│   │   │   ├── service/                 # Services (use cases)
+│   │   │   │   ├── dto/                 # DTOs
+│   │   │   │   ├── mapper/             # MapStruct mappers
+│   │   │   │   └── impl/
+│   │   │   ├── web/rest/               # REST controllers
+│   │   │   ├── config/                 # Spring configs
+│   │   │   └── security/              # Security configs
+│   │   ├── resources/
+│   │   │   ├── config/
+│   │   │   │   ├── application.yml
+│   │   │   │   ├── application-dev.yml
+│   │   │   │   └── application-prod.yml
+│   │   │   └── config/liquibase/       # Migrations
+│   │   └── webapp/                     # Angular app
+│   │       ├── app/
+│   │       │   ├── entities/           # Entity CRUD modules
+│   │       │   ├── shared/             # Shared components
+│   │       │   ├── core/               # Core services
+│   │       │   └── layouts/            # Page layouts
+│   │       └── content/               # Assets
+│   └── test/
+│       ├── java/                       # JUnit tests
+│       └── javascript/                 # Jest tests
+├── .jhipster/                          # JDL entity definitions
+│   ├── Demand.json
+│   └── Task.json
+├── jhipster-jdl.jdl                   # JDL model file
+├── pom.xml                            # Maven
+└── package.json                       # Frontend deps
+```
+
+## Padrões de código
+
+### Java
+- Máximo 500 linhas por classe
+- Records para DTOs imutáveis (Java 21)
+- Optional ao invés de null returns
+- Streams API para coleções (não loops imperativos)
+- Google Java Style Guide
+- Lombok apenas para: `@Slf4j`, `@RequiredArgsConstructor`. Evitar `@Data`.
+- Nunca `@Autowired` em campo — usar constructor injection
+
+### Angular
+- Strict mode habilitado
+- Standalone components (Angular 17+)
+- Signals para estado reativo quando possível
+- Lazy loading por rota/feature
+- Reactive Forms com validação
+
+## JDL — Modelo de entidades
+
+Usar JDL para definir entidades e gerar código:
+
+```jdl
+entity Demand {
+    description TextBlob required
+    status DemandStatus required
+    priority Priority required
+    createdAt Instant required
+    completedAt Instant
+}
+
+entity Task {
+    description String required maxlength(500)
+    status TaskStatus required
+    branchName String maxlength(100)
+    startedAt Instant
+    completedAt Instant
+}
+
+enum DemandStatus {
+    CREATED, PLANNED, IN_PROGRESS, COMPLETED, CANCELLED
+}
+
+enum TaskStatus {
+    PENDING, IN_PROGRESS, COMPLETED, FAILED
+}
+
+enum Priority {
+    LOW, MEDIUM, HIGH, CRITICAL
+}
+
+relationship OneToMany {
+    Demand{tasks} to Task{demand required}
+}
+
+paginate Demand, Task with pagination
+dto * with mapstruct
+service * with serviceImpl
+```
+
+## Enriquecer JHipster com DDD
+
+O JHipster gera entidades anêmicas por padrão. Enriqueça com comportamento:
+
+```java
+// NÃO FAZER — entidade anêmica (padrão JHipster)
+public class Demand {
+    private String description;
+    private DemandStatus status;
+    // apenas getters/setters
+}
+
+// FAZER — entidade rica
+public class Demand {
+    private String description;
+    private DemandStatus status;
+    private List<Task> tasks = new ArrayList<>();
+
+    public List<Task> decompose(TaskPlanner planner) {
+        if (this.status != DemandStatus.CREATED) {
+            throw new DemandAlreadyDecomposedException(this.id);
+        }
+        this.tasks = planner.plan(this.description);
+        this.status = DemandStatus.PLANNED;
+        return Collections.unmodifiableList(this.tasks);
+    }
+
+    public void startTask(Long taskId) {
+        Task task = findTaskOrThrow(taskId);
+        long activeCount = tasks.stream()
+            .filter(t -> t.getStatus() == TaskStatus.IN_PROGRESS)
+            .count();
+        if (activeCount >= 3) {
+            throw new TooManyActiveTasksException();
+        }
+        task.start();
+    }
+}
+```
+
+## Liquibase — Migrations
+
+Sempre gerar changeset para mudanças de schema:
+
+```xml
+<changeSet id="20260327-1" author="dev">
+    <createTable tableName="demand">
+        <column name="id" type="bigint" autoIncrement="true">
+            <constraints primaryKey="true"/>
+        </column>
+        <column name="description" type="clob">
+            <constraints nullable="false"/>
+        </column>
+        <column name="status" type="varchar(20)">
+            <constraints nullable="false"/>
+        </column>
+        <column name="created_at" type="timestamp">
+            <constraints nullable="false"/>
+        </column>
+    </createTable>
+</changeSet>
+```
+
+## Testes
+
+- **JUnit 5:** Testar services e entidades enriquecidas
+- **MockMvc:** Testar controllers (status codes, validação)
+- **Testcontainers:** Integração com PostgreSQL real
+- **Jest:** Componentes Angular
+- **Cypress:** E2E flows
+- Cobertura mínima: 80%
+
+## Git
+
+- Commits: `feat(demand): adicionar decomposição automática`
+- Branches: `feature/<entity>-<descricao>`
+- Nunca alterar arquivos gerados do JHipster sem necessidade
+- Regenerar com `jhipster import-jdl` quando mudar modelo
+
+## O que NÃO fazer
+
+- Não editar manualmente arquivos que o JHipster regenera (liquibase gerado, webpack config)
+- Não colocar regras de negócio no REST controller
+- Não usar `@Transactional` em todo lugar — só onde necessário
+- Não criar services genéricos "God class"
+- Não ignorar DTOs — nunca expor entidade JPA na API
+- Não usar Lombok `@Data` (gera equals/hashCode perigoso com JPA)

package/templates/bundle-jhipster-monorepo/skills/clean-architecture/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: clean-architecture
+description: Implementar Clean Architecture com camadas de domínio, aplicação e infraestrutura. Use quando for criar módulos, organizar código em camadas, separar regras de negócio de infraestrutura, ou estruturar um projeto novo.
+---
+
+# Clean Architecture
+
+## Camadas
+
+```
+┌──────────────────────────────┐
+│         API / CLI            │  ← Controllers, Routers
+├──────────────────────────────┤
+│        APPLICATION           │  ← Use Cases, DTOs
+├──────────────────────────────┤
+│          DOMAIN              │  ← Entities, VOs, Events, Repos (interface)
+├──────────────────────────────┤
+│       INFRASTRUCTURE         │  ← DB, HTTP clients, Frameworks
+└──────────────────────────────┘
+
+Dependency Rule: setas apontam para DENTRO (infra → domain)
+Domain NUNCA importa de infrastructure
+```
+
+## Domain Layer
+
+```python
+# domain/entities/demand.py
+class Demand:
+    def __init__(self, id: DemandId, description: str):
+        self._id = id
+        self._description = description
+        self._status = DemandStatus.CREATED
+        self._events: list[DomainEvent] = []
+
+    def decompose(self, planner: TaskPlanner) -> list[Task]:
+        if self._status != DemandStatus.CREATED:
+            raise DemandAlreadyDecomposedException(self._id)
+        tasks = planner.plan(self._description)
+        self._status = DemandStatus.PLANNED
+        self._events.append(DemandDecomposed(self._id, [t.id for t in tasks]))
+        return tasks
+
+    @property
+    def pending_events(self) -> list[DomainEvent]:
+        return list(self._events)
+
+# domain/repositories/demand_repository.py (PORT - apenas interface)
+class DemandRepository(ABC):
+    @abstractmethod
+    def find_by_id(self, id: DemandId) -> Demand: ...
+    @abstractmethod
+    def save(self, demand: Demand) -> None: ...
+```
+
+## Application Layer
+
+```python
+# application/use_cases/decompose_demand.py
+class DecomposeDemand:
+    def __init__(self, repo: DemandRepository, planner: TaskPlanner, event_bus: EventBus):
+        self._repo = repo
+        self._planner = planner
+        self._event_bus = event_bus
+
+    def execute(self, demand_id: str) -> DecomposeDemandOutput:
+        demand = self._repo.find_by_id(DemandId(demand_id))
+        tasks = demand.decompose(self._planner)
+        self._repo.save(demand)
+        for event in demand.pending_events:
+            self._event_bus.publish(event)
+        return DecomposeDemandOutput(tasks=[TaskDTO.from_entity(t) for t in tasks])
+```
+
+## Infrastructure Layer
+
+```python
+# infrastructure/persistence/pg_demand_repository.py (ADAPTER)
+class PgDemandRepository(DemandRepository):
+    def __init__(self, session: Session):
+        self._session = session
+
+    def find_by_id(self, id: DemandId) -> Demand:
+        model = self._session.query(DemandModel).get(str(id))
+        if not model:
+            raise DemandNotFoundException(id)
+        return self._to_entity(model)
+
+    def save(self, demand: Demand) -> None:
+        model = self._to_model(demand)
+        self._session.merge(model)
+        self._session.commit()
+```
+
+## Regra de ouro
+
+Use Case orquestra → Entity contém regra → Repository persiste
+
+Nunca colocar regra de negócio no Controller, Repository ou "Service" genérico.

package/templates/bundle-jhipster-monorepo/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-monorepo/skills/jhipster-angular/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: jhipster-angular
+description: Desenvolver frontend Angular no JHipster com componentes, services, routing e formulários reativos. Use quando precisar criar telas, componentes Angular, ou customizar o frontend JHipster.
+---
+
+# JHipster Angular
+
+## Estrutura gerada pelo JHipster
+
+```
+src/main/webapp/app/
+├── entities/                    # CRUD gerado por entidade
+│   ├── demand/
+│   │   ├── demand.model.ts
+│   │   ├── demand.routes.ts
+│   │   ├── service/
+│   │   │   └── demand.service.ts
+│   │   ├── list/
+│   │   │   └── demand.component.ts
+│   │   ├── detail/
+│   │   │   └── demand-detail.component.ts
+│   │   ├── update/
+│   │   │   └── demand-update.component.ts
+│   │   └── delete/
+│   │       └── demand-delete-dialog.component.ts
+│   └── task/
+├── shared/                     # Componentes compartilhados
+│   ├── date/
+│   ├── filter/
+│   ├── pagination/
+│   └── sort/
+├── core/                       # Services core
+│   ├── auth/
+│   ├── interceptor/
+│   └── util/
+├── layouts/                    # Layouts de página
+│   ├── main/
+│   ├── navbar/
+│   └── footer/
+└── config/
+```
+
+## Customizar componentes gerados
+
+O JHipster gera CRUD básico. Customizar SEM modificar a estrutura gerada:
+
+```typescript
+// entities/demand/list/demand.component.ts
+@Component({
+  standalone: true,
+  selector: 'jhi-demand',
+  templateUrl: './demand.component.html',
+  imports: [SharedModule, RouterModule, SortDirective, SortByDirective, FormsModule],
+})
+export class DemandComponent implements OnInit {
+  demands?: IDemand[];
+  isLoading = false;
+
+  // ADICIONAR — filtros customizados
+  statusFilter: DemandStatus | null = null;
+  priorityFilter: Priority | null = null;
+
+  constructor(
+    protected demandService: DemandService,
+    protected activatedRoute: ActivatedRoute,
+    protected router: Router,
+    protected sortService: SortService,
+  ) {}
+
+  // ADICIONAR — método de filtro
+  filterByStatus(status: DemandStatus): void {
+    this.statusFilter = status;
+    this.loadDemands();
+  }
+
+  private loadDemands(): void {
+    this.isLoading = true;
+    this.demandService
+      .query({
+        page: this.page,
+        size: this.itemsPerPage,
+        sort: this.sort(),
+        'status.equals': this.statusFilter,
+        'priority.equals': this.priorityFilter,
+      })
+      .subscribe({
+        next: (res) => {
+          this.demands = res.body ?? [];
+          this.isLoading = false;
+        },
+        error: () => (this.isLoading = false),
+      });
+  }
+}
+```
+
+## Criar componentes novos (fora do CRUD gerado)
+
+```typescript
+// dashboard/dashboard.component.ts
+@Component({
+  standalone: true,
+  selector: 'app-dashboard',
+  template: `
+    <div class="row">
+      <div class="col-md-3" *ngFor="let metric of metrics">
+        <div class="card">
+          <div class="card-body text-center">
+            <h5>{{ metric.label }}</h5>
+            <h2>{{ metric.value }}</h2>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="row mt-4">
+      <div class="col-md-8">
+        <app-agent-activity-feed />
+      </div>
+      <div class="col-md-4">
+        <app-active-demands />
+      </div>
+    </div>
+  `,
+  imports: [CommonModule, AgentActivityFeedComponent, ActiveDemandsComponent],
+})
+export class DashboardComponent implements OnInit {
+  metrics: Metric[] = [];
+
+  constructor(private dashboardService: DashboardService) {}
+
+  ngOnInit(): void {
+    this.dashboardService.getMetrics().subscribe(m => this.metrics = m);
+  }
+}
+```
+
+## Reactive Forms com validação
+
+```typescript
+@Component({...})
+export class DemandUpdateComponent {
+  editForm = new FormGroup({
+    description: new FormControl('', [Validators.required, Validators.minLength(10)]),
+    priority: new FormControl<Priority>(Priority.MEDIUM, Validators.required),
+    status: new FormControl<DemandStatus>(DemandStatus.CREATED),
+  });
+
+  save(): void {
+    if (this.editForm.valid) {
+      const demand = this.editForm.getRawValue();
+      this.demandService.create(demand).subscribe({
+        next: () => this.router.navigate(['/demand']),
+        error: (err) => this.alertService.addAlert({ type: 'danger', message: err.message }),
+      });
+    }
+  }
+}
+```
+
+## Regras
+
+- Não modificar `navbar.component.ts` diretamente — usar menus configuráveis
+- Usar `SharedModule` para imports comuns
+- Lazy loading para todas as rotas de entidades
+- Usar `TranslateService` do JHipster para i18n
+- Manter compatibilidade com regeneração: marcar customizações claramente