maestro-bundle 1.0.0

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

@@ -0,0 +1,141 @@
+---
+name: jhipster-entities
+description: Criar e gerenciar entidades JHipster com JDL, relationships, enums, validações e geração de código. Use quando precisar criar entidades, definir modelo de dados, ou gerar código com JHipster.
+---
+
+# JHipster Entities
+
+## Fluxo
+
+```
+1. Definir entidade no JDL
+2. Rodar jhipster import-jdl
+3. Enriquecer entidade gerada com comportamento DDD
+4. Ajustar Liquibase changeset se necessário
+5. Criar/ajustar testes
+```
+
+## JDL — Sintaxe
+
+```jdl
+entity NomeDaEntidade {
+    campo TipoDoCampo validacao
+}
+```
+
+### Tipos disponíveis
+| Tipo JDL | Java | DB |
+|---|---|---|
+| String | String | varchar(255) |
+| Integer | Integer | integer |
+| Long | Long | bigint |
+| Float | Float | float |
+| Double | Double | double |
+| BigDecimal | BigDecimal | decimal |
+| Boolean | Boolean | boolean |
+| LocalDate | LocalDate | date |
+| Instant | Instant | timestamp |
+| ZonedDateTime | ZonedDateTime | timestamp |
+| Duration | Duration | bigint |
+| UUID | UUID | uuid |
+| Blob | byte[] | blob |
+| AnyBlob | byte[] | blob |
+| ImageBlob | byte[] | blob |
+| TextBlob | String | clob |
+
+### Validações
+```jdl
+entity Product {
+    name String required minlength(3) maxlength(100)
+    price BigDecimal required min(0)
+    description TextBlob
+    active Boolean required
+    sku String required unique pattern(/^[A-Z]{3}-[0-9]{4}$/)
+}
+```
+
+### Relationships
+```jdl
+relationship OneToMany {
+    Department{employees} to Employee{department(name) required}
+}
+
+relationship ManyToMany {
+    Project{members(login)} to User with builtInEntity
+}
+
+relationship OneToOne {
+    Employee{address} to Address with jpaDerivedIdentifier
+}
+```
+
+### Enums
+```jdl
+enum Status {
+    ACTIVE("Ativo"),
+    INACTIVE("Inativo"),
+    SUSPENDED("Suspenso")
+}
+```
+
+## Gerar código
+
+```bash
+# Gerar a partir do JDL
+jhipster import-jdl jhipster-jdl.jdl
+
+# Gerar entidade individual
+jhipster entity Demand
+```
+
+## Enriquecer com DDD
+
+Após gerar, adicionar comportamento à entidade:
+
+```java
+@Entity
+@Table(name = "demand")
+public class Demand implements Serializable {
+
+    // Campos gerados pelo JHipster (manter)
+    @Id
+    @GeneratedValue(strategy = GenerationType.SEQUENCE)
+    private Long id;
+
+    @NotNull
+    @Lob
+    private String description;
+
+    @NotNull
+    @Enumerated(EnumType.STRING)
+    private DemandStatus status;
+
+    @OneToMany(mappedBy = "demand", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Task> tasks = new ArrayList<>();
+
+    // ADICIONAR — comportamento rico
+    public void addTask(Task task) {
+        if (this.tasks.size() >= 20) {
+            throw new BusinessException("Máximo 20 tasks por demanda");
+        }
+        this.tasks.add(task);
+        task.setDemand(this);
+    }
+
+    public void removeTask(Task task) {
+        this.tasks.remove(task);
+        task.setDemand(null);
+    }
+
+    public boolean isCompletable() {
+        return this.tasks.stream().allMatch(t -> t.getStatus() == TaskStatus.COMPLETED);
+    }
+
+    public void complete() {
+        if (!isCompletable()) {
+            throw new BusinessException("Nem todas as tasks foram concluídas");
+        }
+        this.status = DemandStatus.COMPLETED;
+    }
+}
+```

package/templates/bundle-jhipster-monorepo/skills/jhipster-liquibase/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: jhipster-liquibase
+description: Gerenciar migrations de banco com Liquibase no JHipster. Use quando precisar criar tabelas, alterar schema, adicionar colunas, ou criar índices.
+---
+
+# Liquibase no JHipster
+
+## Estrutura
+
+```
+src/main/resources/config/liquibase/
+├── master.xml                    # Arquivo principal (lista todos os changelogs)
+├── changelog/
+│   ├── 00000000000000_initial_schema.xml
+│   ├── 20260327100000_added_entity_Demand.xml
+│   ├── 20260327100100_added_entity_Task.xml
+│   └── 20260327120000_added_column_priority.xml
+└── data/
+    ├── authority.csv             # Dados iniciais
+    └── user.csv
+```
+
+## Criar changeset
+
+### Nova tabela
+```xml
+<changeSet id="20260327-1" author="dev">
+    <createTable tableName="demand">
+        <column name="id" type="bigint" autoIncrement="true">
+            <constraints primaryKey="true" nullable="false"/>
+        </column>
+        <column name="description" type="clob">
+            <constraints nullable="false"/>
+        </column>
+        <column name="status" type="varchar(20)">
+            <constraints nullable="false"/>
+        </column>
+        <column name="priority" type="varchar(20)">
+            <constraints nullable="false"/>
+        </column>
+        <column name="created_at" type="timestamp">
+            <constraints nullable="false"/>
+        </column>
+        <column name="completed_at" type="timestamp"/>
+    </createTable>
+
+    <createIndex indexName="idx_demand_status" tableName="demand">
+        <column name="status"/>
+    </createIndex>
+</changeSet>
+```
+
+### Adicionar coluna
+```xml
+<changeSet id="20260327-2" author="dev">
+    <addColumn tableName="demand">
+        <column name="requester" type="varchar(100)">
+            <constraints nullable="false"/>
+        </column>
+    </addColumn>
+</changeSet>
+```
+
+### Foreign key
+```xml
+<changeSet id="20260327-3" author="dev">
+    <addForeignKeyConstraint
+        baseTableName="task"
+        baseColumnNames="demand_id"
+        constraintName="fk_task_demand"
+        referencedTableName="demand"
+        referencedColumnNames="id"/>
+</changeSet>
+```
+
+## Regras
+
+- IDs de changeset: `YYYYMMDD-N` (data + sequencial)
+- Nunca modificar changeset já executado em produção
+- Sempre adicionar rollback:
+```xml
+<changeSet id="20260327-1" author="dev">
+    <addColumn tableName="demand">
+        <column name="priority" type="varchar(20)"/>
+    </addColumn>
+    <rollback>
+        <dropColumn tableName="demand" columnName="priority"/>
+    </rollback>
+</changeSet>
+```
+- Testar migration com `./mvnw liquibase:updateSQL` antes de rodar
+- Registrar no `master.xml`:
+```xml
+<include file="config/liquibase/changelog/20260327120000_added_column_priority.xml" relativeToChangelogFile="false"/>
+```

package/templates/bundle-jhipster-monorepo/skills/jhipster-security/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: jhipster-security
+description: Configurar segurança no JHipster com JWT, OAuth2, roles e permissões. Use quando precisar implementar autenticação, autorização, roles, ou proteger endpoints.
+---
+
+# JHipster Security
+
+## JWT (padrão monorepo)
+
+O JHipster gera JWT automaticamente. Customizar:
+
+### Proteger endpoints por role
+
+```java
+@Configuration
+public class SecurityConfiguration {
+
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+        http
+            .authorizeHttpRequests(auth -> auth
+                .requestMatchers("/api/public/**").permitAll()
+                .requestMatchers("/api/admin/**").hasAuthority(AuthoritiesConstants.ADMIN)
+                .requestMatchers("/api/demands/**").hasAnyAuthority(
+                    AuthoritiesConstants.USER, AuthoritiesConstants.ADMIN)
+                .requestMatchers("/api/agents/**").hasAuthority("ROLE_AGENT")
+                .requestMatchers("/api/**").authenticated()
+            );
+        return http.build();
+    }
+}
+```
+
+### Criar roles customizadas
+
+```java
+public final class AuthoritiesConstants {
+    public static final String ADMIN = "ROLE_ADMIN";
+    public static final String USER = "ROLE_USER";
+    public static final String AGENT = "ROLE_AGENT";        // Agentes AI
+    public static final String TECH_LEAD = "ROLE_TECH_LEAD"; // Aprovador de merge
+}
+```
+
+### Segurança no método
+
+```java
+@Service
+public class DemandServiceImpl implements DemandService {
+
+    @PreAuthorize("hasAuthority('ROLE_TECH_LEAD')")
+    public void approveMerge(Long demandId) {
+        // Somente tech lead pode aprovar merge
+    }
+
+    @PreAuthorize("#login == authentication.name or hasAuthority('ROLE_ADMIN')")
+    public DemandDTO findByUser(String login) {
+        // Usuário vê só suas demands, admin vê todas
+    }
+}
+```
+
+## OAuth2 + Keycloak (recomendado para microservices)
+
+```yaml
+# application.yml
+spring:
+  security:
+    oauth2:
+      client:
+        provider:
+          oidc:
+            issuer-uri: http://keycloak:9080/realms/jhipster
+        registration:
+          oidc:
+            client-id: web_app
+            client-secret: web_app
+            scope: openid,profile,email
+```
+
+## Checklist de segurança
+
+- [ ] Rate limiting nos endpoints públicos
+- [ ] CORS configurado corretamente (não `*` em prod)
+- [ ] CSRF habilitado para browser, desabilitado para API
+- [ ] Secrets em variáveis de ambiente, nunca no código
+- [ ] Senhas com BCrypt (padrão JHipster)
+- [ ] Audit trail para operações críticas
+- [ ] HTTPS em produção

package/templates/bundle-jhipster-monorepo/skills/jhipster-spring/SKILL.md

@@ -0,0 +1,155 @@
+---
+name: jhipster-spring
+description: Desenvolver backend Spring Boot no JHipster com services, repositories, DTOs, MapStruct e Spring Security. Use quando precisar criar endpoints, services, ou customizar o backend JHipster.
+---
+
+# JHipster Spring Boot
+
+## Camadas no JHipster
+
+```
+Controller (web/rest/) → Service (service/) → Repository (repository/) → Entity (domain/)
+                          ↕
+                      DTO + Mapper (service/dto/ + service/mapper/)
+```
+
+## Controller — REST API
+
+```java
+@RestController
+@RequestMapping("/api/v1/demands")
+public class DemandResource {
+
+    private final DemandService demandService;
+
+    public DemandResource(DemandService demandService) {
+        this.demandService = demandService;
+    }
+
+    @GetMapping
+    public ResponseEntity<List<DemandDTO>> getAllDemands(
+            @RequestParam(required = false) DemandStatus status,
+            @org.springdoc.core.annotations.ParameterObject Pageable pageable) {
+        Page<DemandDTO> page = demandService.findAll(status, pageable);
+        return ResponseEntity.ok()
+            .headers(PaginationUtil.generatePaginationHttpHeaders(
+                ServletUriComponentsBuilder.fromCurrentRequest(), page))
+            .body(page.getContent());
+    }
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    public DemandDTO createDemand(@Valid @RequestBody CreateDemandDTO dto) {
+        return demandService.create(dto);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<DemandDTO> getDemand(@PathVariable Long id) {
+        return ResponseUtil.wrapOrNotFound(demandService.findOne(id));
+    }
+
+    @PutMapping("/{id}")
+    public DemandDTO updateDemand(@PathVariable Long id, @Valid @RequestBody UpdateDemandDTO dto) {
+        return demandService.update(id, dto);
+    }
+
+    @DeleteMapping("/{id}")
+    @ResponseStatus(HttpStatus.NO_CONTENT)
+    public void deleteDemand(@PathVariable Long id) {
+        demandService.delete(id);
+    }
+}
+```
+
+## Service — Lógica de aplicação
+
+```java
+@Service
+@Transactional
+public class DemandServiceImpl implements DemandService {
+
+    private final DemandRepository demandRepository;
+    private final DemandMapper demandMapper;
+
+    public DemandServiceImpl(DemandRepository demandRepository, DemandMapper demandMapper) {
+        this.demandRepository = demandRepository;
+        this.demandMapper = demandMapper;
+    }
+
+    @Override
+    public DemandDTO create(CreateDemandDTO dto) {
+        Demand demand = new Demand();
+        demand.setDescription(dto.description());
+        demand.setStatus(DemandStatus.CREATED);
+        demand.setPriority(dto.priority());
+        demand.setCreatedAt(Instant.now());
+        demand = demandRepository.save(demand);
+        return demandMapper.toDto(demand);
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Page<DemandDTO> findAll(DemandStatus status, Pageable pageable) {
+        if (status != null) {
+            return demandRepository.findByStatus(status, pageable).map(demandMapper::toDto);
+        }
+        return demandRepository.findAll(pageable).map(demandMapper::toDto);
+    }
+}
+```
+
+## DTO — Records (Java 21)
+
+```java
+public record CreateDemandDTO(
+    @NotBlank @Size(min = 10) String description,
+    @NotNull Priority priority
+) {}
+
+public record DemandDTO(
+    Long id,
+    String description,
+    DemandStatus status,
+    Priority priority,
+    Instant createdAt,
+    List<TaskDTO> tasks
+) {}
+```
+
+## MapStruct Mapper
+
+```java
+@Mapper(componentModel = "spring", uses = {TaskMapper.class})
+public interface DemandMapper extends EntityMapper<DemandDTO, Demand> {
+
+    @Mapping(target = "tasks", source = "tasks")
+    DemandDTO toDto(Demand demand);
+
+    @Mapping(target = "id", ignore = true)
+    @Mapping(target = "tasks", ignore = true)
+    Demand toEntity(CreateDemandDTO dto);
+}
+```
+
+## Repository — Spring Data JPA
+
+```java
+@Repository
+public interface DemandRepository extends JpaRepository<Demand, Long>, JpaSpecificationExecutor<Demand> {
+
+    Page<Demand> findByStatus(DemandStatus status, Pageable pageable);
+
+    @Query("SELECT d FROM Demand d LEFT JOIN FETCH d.tasks WHERE d.id = :id")
+    Optional<Demand> findByIdWithTasks(@Param("id") Long id);
+
+    long countByStatus(DemandStatus status);
+}
+```
+
+## Regras
+
+- Constructor injection sempre (nunca `@Autowired` em campo)
+- `@Transactional(readOnly = true)` em queries
+- `@Transactional` apenas no Service, nunca no Controller
+- DTOs na API, Entities no domínio — nunca misturar
+- Validação com Bean Validation (`@Valid`) no Controller

package/templates/bundle-jhipster-monorepo/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
+```