aiup-core

Plugin aiup-core from marketplace ai-unified-process-marketplace in AI-Unified-Process/marketplace. Commands read from the repo's manifest — today.

Skills (37)

• angular-ui-test

  Writes the UI-layer tests of a use case (UC-XXX) for an Angular client with Vitest and Angular's own testing idioms: TestBed component tests for the routed page, HttpTestingController for the API boundary, DI overrides for non-HTTP services, and plain service tests — in UC-XXX-<slug>.spec.ts files w

• angular-ui

  Implements the UI layer of a use case (UC-XXX) as an Angular client: standalone page and presentational components, signal() state, one hand-written HttpClient service per entity with TypeScript models that match the API layer's DTOs field by field, and routes in app.routes.ts. Consumes the Handover

• flyway-schema

  Builds the migration layer of a use case (UC-XXX) with Flyway: versioned V*.sql scripts with sequences, tables, snake_case columns, CHECK and UNIQUE constraints, and foreign keys from the entity model, placed in the migration location docs/architecture/stack.md records: a complete table, with every

• jpa-persistence-test

  Writes the persistence tests of a use case (UC-XXX) for Spring Data JPA: @DataJpaTest classes against a real database in a Testcontainers container (never H2 unless the project already tests on it), test data from Flyway test migrations, one UC<id><Name>RepositoryTest class per use case with @UseCas

• jpa-persistence

  Implements the persistence layer of a use case (UC-XXX) with Spring Data JPA and Hibernate: @Entity classes mapped onto the Flyway schema (ddl-auto=validate, never create or update), Spring Data JpaRepository interfaces, derived and @Query queries, interface and record projections, attribute convert

• playwright-e2e-test

  Writes end-to-end browser tests in TypeScript with @playwright/test for any web UI that is not Vaadin (Angular, Next.js, other client-side frameworks alike): a use case test (UC-XXX) with one test per scenario, or a test case journey (TC-XXX) that walks the whole Flow table across views with one tes

• spring-rest-test

  Writes the REST API tests of a use case (UC-XXX) in a Spring Boot application: status codes, Location headers, the JSON contract (field names, date formats), RFC 9457 Problem Details bodies, and — as the integration layer of a REST service or behind an Angular or Next.js client — every business rule

• spring-rest

  Implements the REST API layer of a use case (UC-XXX) in a Spring Boot application: @RestController endpoints on top of the service layer, request and response DTO records, @Valid input validation, error mapping to RFC 9457 Problem Details with a @RestControllerAdvice, a status code per alternative f

• spring-service-test

  Writes the service layer tests of a use case (UC-XXX) in a Spring Boot application: every business rule with its allowed and its rejected case, every alternative flow the service decides, and the main success scenario, called on the @Service directly. Uses @SpringBootTest with the real persistence l

• spring-service

  Implements the service layer of a use case (UC-XXX) in a Spring Boot application: @Service classes with constructor injection, @Transactional boundaries, the business rules with UC-XXX BR-YYY markers, domain exceptions for every rejection the API or UI turns into a message, and Bean Validation on th

• hilla-ui-test

  Writes the UI layer tests of a use case (UC-XXX) for Hilla React views with Vitest in browser mode and React Testing Library, with the generated endpoint clients mocked by vi.spyOn — no server, no database. Covers what the actor sees: rendering, form input and useForm validation, the calls the view

• hilla-ui

  Implements the UI layer of a use case (UC-XXX) with Hilla: a @BrowserCallable endpoint that delegates to the service layer, and a React/TypeScript view under src/main/frontend/views/ with file-based routing, Vaadin React components, useForm validation from the generated models, and the messages the

• jooq-persistence-test

  Writes the persistence layer tests of a use case (UC-XXX) for jOOQ repositories: integration tests against a real database (Testcontainers PostgreSQL or the project's database) with @SpringBootTest or @JooqTest, test data from Flyway test migrations, expected values from the specification and the te

• jooq-persistence

  Builds the persistence layer of a use case (UC-XXX) with jOOQ: one @Repository per aggregate with an injected DSLContext, type-safe queries against the classes jOOQ generates from the Flyway migrations, projections into Java records with Records.mapping, MULTISET for nested collections, paging and d

• vaadin-e2e-test

  Writes the end-to-end tests of a Vaadin application (Flow or Hilla) with Playwright for Java and the Drama Finder library's type-safe, accessibility-first element wrappers, against the running application. Two kinds: a use case test (UC-XXX) — one class UC<id><Name>IT with @Nested groups per alterna

• vaadin-flow-ui-test

  Writes the UI layer tests of a use case (UC-XXX) for Vaadin Flow views with Vaadin Browserless Testing — the official server-side framework that runs the view inside the JVM without a browser — covering navigation, form input and Binder validation, grid contents, dialogs, confirmations, and the noti

• vaadin-flow-ui

  Implements the UI layer of a use case (UC-XXX) as server-side Java with Vaadin Flow: @Route views inside the application layout, Grids with lazy data providers that call the service layer, forms with Binder and Bean Validation, dialogs and ConfirmDialogs, notifications with the messages the specific

• acceptance-protocol
• architecture-decision
• business-process
• entity-model
• next
• open-questions
• release-notes
• requirements
• reverse-engineer
• spec-review
• stack
• test-case-coverage
• test-case-implement
• test-case
• use-case-coverage
• use-case-diagram
• use-case-implement
• use-case-spec
• use-case-test
• user-guide

Subagents (1)

• uc-coverage-layered

  Read-only auditor that checks whether a use case (UC-XXX) or test case (TC-XXX) is completely implemented and completely tested against its specification. Use it during or after implementation and during or after writing tests: it maps every main success scenario step, alternative flow, business rul