aigroup-workflow 2.1.2 → 2.2.0

package/skills/spring-boot-engineer/SKILL.md

@@ -1,195 +0,0 @@
----
-name: spring-boot-engineer
-description: Generates Spring Boot 3.x configurations, creates REST controllers, implements Spring Security 6 authentication flows, sets up Spring Data JPA repositories, and configures reactive WebFlux endpoints. Use when building Spring Boot 3.x applications, microservices, or reactive Java applications; invoke for Spring Data JPA, Spring Security 6, WebFlux, Spring Cloud integration, Java REST API design, or Microservices Java architecture.
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: backend
-  triggers: Spring Boot, Spring Framework, Spring Cloud, Spring Security, Spring Data JPA, Spring WebFlux, Microservices Java, Java REST API, Reactive Java
-  role: specialist
-  scope: implementation
-  output-format: code
-  related-skills: java-architect, database-optimizer, microservices-architect, devops-engineer
----
-
-# Spring Boot Engineer
-
-## Core Workflow
-
-1. **Analyze requirements** — Identify service boundaries, APIs, data models, security needs
-2. **Design architecture** — Plan microservices, data access, cloud integration, security; confirm design before coding
-3. **Implement** — Create services with constructor injection and layered architecture (see Quick Start below)
-4. **Secure** — Add Spring Security, OAuth2, method security, CORS configuration; verify security rules compile and pass tests. If compilation or tests fail: review error output, fix the failing rule or configuration, and re-run before proceeding
-5. **Test** — Write unit, integration, and slice tests; run `./mvnw test` (or `./gradlew test`) and confirm all pass before proceeding. If tests fail: review the stack trace, isolate the failing assertion or component, fix the issue, and re-run the full suite
-6. **Deploy** — Configure health checks and observability via Actuator; validate `/actuator/health` returns `UP`. If health is `DOWN`: check the `components` detail in the response, resolve the failing component (e.g., datasource, broker), and re-validate
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| Web Layer | `references/web.md` | Controllers, REST APIs, validation, exception handling |
-| Data Access | `references/data.md` | Spring Data JPA, repositories, transactions, projections |
-| Security | `references/security.md` | Spring Security 6, OAuth2, JWT, method security |
-| Cloud Native | `references/cloud.md` | Spring Cloud, Config, Discovery, Gateway, resilience |
-| Testing | `references/testing.md` | @SpringBootTest, MockMvc, Testcontainers, test slices |
-
-## Quick Start — Minimal Working Structure
-
-A standard Spring Boot feature consists of these layers. Use these as copy-paste starting points.
-
-### Entity
-
-```java
-@Entity
-@Table(name = "products")
-public class Product {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-
-    @NotBlank
-    private String name;
-
-    @DecimalMin("0.0")
-    private BigDecimal price;
-
-    // getters / setters or use @Data (Lombok)
-}
-```
-
-### Repository
-
-```java
-public interface ProductRepository extends JpaRepository<Product, Long> {
-    List<Product> findByNameContainingIgnoreCase(String name);
-}
-```
-
-### Service (constructor injection)
-
-```java
-@Service
-public class ProductService {
-    private final ProductRepository repo;
-
-    public ProductService(ProductRepository repo) { // constructor injection — no @Autowired
-        this.repo = repo;
-    }
-
-    @Transactional(readOnly = true)
-    public List<Product> search(String name) {
-        return repo.findByNameContainingIgnoreCase(name);
-    }
-
-    @Transactional
-    public Product create(ProductRequest request) {
-        var product = new Product();
-        product.setName(request.name());
-        product.setPrice(request.price());
-        return repo.save(product);
-    }
-}
-```
-
-### REST Controller
-
-```java
-@RestController
-@RequestMapping("/api/v1/products")
-@Validated
-public class ProductController {
-    private final ProductService service;
-
-    public ProductController(ProductService service) {
-        this.service = service;
-    }
-
-    @GetMapping
-    public List<Product> search(@RequestParam(defaultValue = "") String name) {
-        return service.search(name);
-    }
-
-    @PostMapping
-    @ResponseStatus(HttpStatus.CREATED)
-    public Product create(@Valid @RequestBody ProductRequest request) {
-        return service.create(request);
-    }
-}
-```
-
-### DTO (record)
-
-```java
-public record ProductRequest(
-    @NotBlank String name,
-    @DecimalMin("0.0") BigDecimal price
-) {}
-```
-
-### Global Exception Handler
-
-```java
-@RestControllerAdvice
-public class GlobalExceptionHandler {
-    @ExceptionHandler(MethodArgumentNotValidException.class)
-    @ResponseStatus(HttpStatus.BAD_REQUEST)
-    public Map<String, String> handleValidation(MethodArgumentNotValidException ex) {
-        return ex.getBindingResult().getFieldErrors().stream()
-            .collect(Collectors.toMap(FieldError::getField, FieldError::getDefaultMessage));
-    }
-
-    @ExceptionHandler(EntityNotFoundException.class)
-    @ResponseStatus(HttpStatus.NOT_FOUND)
-    public Map<String, String> handleNotFound(EntityNotFoundException ex) {
-        return Map.of("error", ex.getMessage());
-    }
-}
-```
-
-### Test Slice
-
-```java
-@WebMvcTest(ProductController.class)
-class ProductControllerTest {
-    @Autowired MockMvc mockMvc;
-    @MockBean ProductService service;
-
-    @Test
-    void createProduct_validRequest_returns201() throws Exception {
-        var product = new Product(); product.setName("Widget"); product.setPrice(BigDecimal.TEN);
-        when(service.create(any())).thenReturn(product);
-
-        mockMvc.perform(post("/api/v1/products")
-                .contentType(MediaType.APPLICATION_JSON)
-                .content("""{"name":"Widget","price":10.0}"""))
-            .andExpect(status().isCreated())
-            .andExpect(jsonPath("$.name").value("Widget"));
-    }
-}
-```
-
-## Constraints
-
-### MUST DO
-
-| Rule | Correct Pattern |
-|------|----------------|
-| Constructor injection | `public MyService(Dep dep) { this.dep = dep; }` |
-| Validate API input | `@Valid @RequestBody MyRequest req` on every mutating endpoint |
-| Type-safe config | `@ConfigurationProperties(prefix = "app")` bound to a record/class |
-| Appropriate stereotype | `@Service` for business logic, `@Repository` for data, `@RestController` for HTTP |
-| Transaction scope | `@Transactional` on multi-step writes; `@Transactional(readOnly = true)` on reads |
-| Hide internals | Catch domain exceptions in `@RestControllerAdvice`; return problem details, not stack traces |
-| Externalize secrets | Use environment variables or Spring Cloud Config — never `application.properties` |
-
-### MUST NOT DO
-- Use field injection (`@Autowired` on fields)
-- Skip input validation on API endpoints
-- Use `@Component` when `@Service`/`@Repository`/`@Controller` applies
-- Mix blocking and reactive code (e.g., calling `.block()` inside a WebFlux chain)
-- Store secrets or credentials in `application.properties`/`application.yml`
-- Hardcode URLs, credentials, or environment-specific values
-- Use deprecated Spring Boot 2.x patterns (e.g., `WebSecurityConfigurerAdapter`)

package/skills/spring-boot-engineer/references/cloud.md

@@ -1,498 +0,0 @@
-# Cloud Native - Spring Cloud
-
-## Spring Cloud Config Server
-
-```java
-// Config Server
-@SpringBootApplication
-@EnableConfigServer
-public class ConfigServerApplication {
-    public static void main(String[] args) {
-        SpringApplication.run(ConfigServerApplication.class, args);
-    }
-}
-
-// application.yml
-server:
-  port: 8888
-
-spring:
-  cloud:
-    config:
-      server:
-        git:
-          uri: https://github.com/example/config-repo
-          default-label: main
-          search-paths: '{application}'
-          username: ${GIT_USERNAME}
-          password: ${GIT_PASSWORD}
-        native:
-          search-locations: classpath:/config
-  security:
-    user:
-      name: config-user
-      password: ${CONFIG_PASSWORD}
-
-// Config Client
-@SpringBootApplication
-public class ClientApplication {
-    public static void main(String[] args) {
-        SpringApplication.run(ClientApplication.class, args);
-    }
-}
-
-// application.yml (Config Client)
-spring:
-  application:
-    name: user-service
-  config:
-    import: "configserver:http://localhost:8888"
-  cloud:
-    config:
-      username: config-user
-      password: ${CONFIG_PASSWORD}
-      fail-fast: true
-      retry:
-        max-attempts: 6
-        initial-interval: 1000
-```
-
-## Dynamic Configuration Refresh
-
-```java
-@RestController
-@RefreshScope
-public class ConfigController {
-    @Value("${app.feature.enabled:false}")
-    private boolean featureEnabled;
-
-    @Value("${app.max-connections:100}")
-    private int maxConnections;
-
-    @GetMapping("/config")
-    public Map<String, Object> getConfig() {
-        return Map.of(
-            "featureEnabled", featureEnabled,
-            "maxConnections", maxConnections
-        );
-    }
-}
-
-// Refresh configuration via Actuator endpoint:
-// POST /actuator/refresh
-```
-
-## Service Discovery - Eureka
-
-```java
-// Eureka Server
-@SpringBootApplication
-@EnableEurekaServer
-public class EurekaServerApplication {
-    public static void main(String[] args) {
-        SpringApplication.run(EurekaServerApplication.class, args);
-    }
-}
-
-// application.yml (Eureka Server)
-server:
-  port: 8761
-
-eureka:
-  instance:
-    hostname: localhost
-  client:
-    register-with-eureka: false
-    fetch-registry: false
-    service-url:
-      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
-
-// Eureka Client
-@SpringBootApplication
-@EnableDiscoveryClient
-public class UserServiceApplication {
-    public static void main(String[] args) {
-        SpringApplication.run(UserServiceApplication.class, args);
-    }
-}
-
-// application.yml (Eureka Client)
-spring:
-  application:
-    name: user-service
-
-eureka:
-  client:
-    service-url:
-      defaultZone: http://localhost:8761/eureka/
-    registry-fetch-interval-seconds: 5
-  instance:
-    prefer-ip-address: true
-    lease-renewal-interval-in-seconds: 10
-    lease-expiration-duration-in-seconds: 30
-```
-
-## Spring Cloud Gateway
-
-```java
-@SpringBootApplication
-public class GatewayApplication {
-    public static void main(String[] args) {
-        SpringApplication.run(GatewayApplication.class, args);
-    }
-
-    @Bean
-    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
-        return builder.routes()
-            .route("user-service", r -> r
-                .path("/api/users/**")
-                .filters(f -> f
-                    .rewritePath("/api/users/(?<segment>.*)", "/users/${segment}")
-                    .addRequestHeader("X-Gateway", "Spring-Cloud-Gateway")
-                    .circuitBreaker(config -> config
-                        .setName("userServiceCircuitBreaker")
-                        .setFallbackUri("forward:/fallback/users")
-                    )
-                    .retry(config -> config
-                        .setRetries(3)
-                        .setStatuses(HttpStatus.SERVICE_UNAVAILABLE)
-                    )
-                )
-                .uri("lb://user-service")
-            )
-            .route("order-service", r -> r
-                .path("/api/orders/**")
-                .filters(f -> f
-                    .rewritePath("/api/orders/(?<segment>.*)", "/orders/${segment}")
-                    .requestRateLimiter(config -> config
-                        .setRateLimiter(redisRateLimiter())
-                        .setKeyResolver(userKeyResolver())
-                    )
-                )
-                .uri("lb://order-service")
-            )
-            .build();
-    }
-
-    @Bean
-    public RedisRateLimiter redisRateLimiter() {
-        return new RedisRateLimiter(10, 20); // replenishRate, burstCapacity
-    }
-
-    @Bean
-    public KeyResolver userKeyResolver() {
-        return exchange -> Mono.just(
-            exchange.getRequest().getHeaders().getFirst("X-User-Id")
-        );
-    }
-}
-
-// application.yml (Gateway)
-spring:
-  cloud:
-    gateway:
-      discovery:
-        locator:
-          enabled: true
-          lower-case-service-id: true
-      default-filters:
-        - DedupeResponseHeader=Access-Control-Allow-Origin
-      globalcors:
-        cors-configurations:
-          '[/**]':
-            allowed-origins: "*"
-            allowed-methods:
-              - GET
-              - POST
-              - PUT
-              - DELETE
-            allowed-headers: "*"
-```
-
-## Circuit Breaker - Resilience4j
-
-```java
-@Service
-@RequiredArgsConstructor
-public class ExternalApiService {
-    private final WebClient webClient;
-
-    @CircuitBreaker(name = "externalApi", fallbackMethod = "getFallbackData")
-    @Retry(name = "externalApi")
-    @RateLimiter(name = "externalApi")
-    public Mono<ExternalData> getData(String id) {
-        return webClient
-            .get()
-            .uri("/data/{id}", id)
-            .retrieve()
-            .bodyToMono(ExternalData.class)
-            .timeout(Duration.ofSeconds(3));
-    }
-
-    private Mono<ExternalData> getFallbackData(String id, Exception e) {
-        log.warn("Fallback triggered for id: {}, error: {}", id, e.getMessage());
-        return Mono.just(new ExternalData(id, "Fallback data", LocalDateTime.now()));
-    }
-}
-
-// application.yml
-resilience4j:
-  circuitbreaker:
-    instances:
-      externalApi:
-        register-health-indicator: true
-        sliding-window-size: 10
-        minimum-number-of-calls: 5
-        permitted-number-of-calls-in-half-open-state: 3
-        automatic-transition-from-open-to-half-open-enabled: true
-        wait-duration-in-open-state: 5s
-        failure-rate-threshold: 50
-        event-consumer-buffer-size: 10
-
-  retry:
-    instances:
-      externalApi:
-        max-attempts: 3
-        wait-duration: 1s
-        enable-exponential-backoff: true
-        exponential-backoff-multiplier: 2
-
-  ratelimiter:
-    instances:
-      externalApi:
-        limit-for-period: 10
-        limit-refresh-period: 1s
-        timeout-duration: 0s
-```
-
-## Distributed Tracing - Micrometer Tracing
-
-```java
-// application.yml
-management:
-  tracing:
-    sampling:
-      probability: 1.0
-  zipkin:
-    tracing:
-      endpoint: http://localhost:9411/api/v2/spans
-
-logging:
-  pattern:
-    level: "%5p [${spring.application.name:},%X{traceId:-},%X{spanId:-}]"
-
-// Custom spans
-@Service
-@RequiredArgsConstructor
-public class OrderService {
-    private final Tracer tracer;
-    private final OrderRepository orderRepository;
-
-    public Order processOrder(OrderRequest request) {
-        Span span = tracer.nextSpan().name("processOrder").start();
-        try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
-            span.tag("order.type", request.type());
-            span.tag("order.items", String.valueOf(request.items().size()));
-
-            // Business logic
-            Order order = createOrder(request);
-
-            span.event("order.created");
-            return order;
-        } finally {
-            span.end();
-        }
-    }
-}
-```
-
-## Load Balancing with Spring Cloud LoadBalancer
-
-```java
-@Configuration
-@LoadBalancerClient(name = "user-service", configuration = UserServiceLoadBalancerConfig.class)
-public class LoadBalancerConfiguration {
-}
-
-@Configuration
-public class UserServiceLoadBalancerConfig {
-
-    @Bean
-    public ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(
-            LoadBalancerClientFactory clientFactory,
-            ObjectProvider<LoadBalancerProperties> properties) {
-        return new RandomLoadBalancer(
-            clientFactory.getLazyProvider("user-service", ServiceInstanceListSupplier.class),
-            "user-service"
-        );
-    }
-}
-
-@Service
-@RequiredArgsConstructor
-public class UserClientService {
-    private final WebClient.Builder webClientBuilder;
-
-    public Mono<User> getUser(Long id) {
-        return webClientBuilder
-            .baseUrl("http://user-service")
-            .build()
-            .get()
-            .uri("/users/{id}", id)
-            .retrieve()
-            .bodyToMono(User.class);
-    }
-}
-```
-
-## Health Checks & Actuator
-
-```java
-@Component
-public class CustomHealthIndicator implements HealthIndicator {
-
-    @Override
-    public Health health() {
-        boolean serviceUp = checkExternalService();
-
-        if (serviceUp) {
-            return Health.up()
-                .withDetail("externalService", "Available")
-                .withDetail("timestamp", LocalDateTime.now())
-                .build();
-        } else {
-            return Health.down()
-                .withDetail("externalService", "Unavailable")
-                .withDetail("error", "Connection timeout")
-                .build();
-        }
-    }
-
-    private boolean checkExternalService() {
-        // Check external dependency
-        return true;
-    }
-}
-
-// application.yml
-management:
-  endpoints:
-    web:
-      exposure:
-        include: health,info,metrics,prometheus
-  endpoint:
-    health:
-      show-details: always
-      probes:
-        enabled: true
-  health:
-    livenessState:
-      enabled: true
-    readinessState:
-      enabled: true
-  metrics:
-    export:
-      prometheus:
-        enabled: true
-    tags:
-      application: ${spring.application.name}
-```
-
-## Kubernetes Deployment
-
-```yaml
-# deployment.yaml
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: user-service
-spec:
-  replicas: 3
-  selector:
-    matchLabels:
-      app: user-service
-  template:
-    metadata:
-      labels:
-        app: user-service
-    spec:
-      containers:
-      - name: user-service
-        image: user-service:1.0.0
-        ports:
-        - containerPort: 8080
-        env:
-        - name: SPRING_PROFILES_ACTIVE
-          value: "kubernetes"
-        - name: JAVA_OPTS
-          value: "-Xmx512m -Xms256m"
-        livenessProbe:
-          httpGet:
-            path: /actuator/health/liveness
-            port: 8080
-          initialDelaySeconds: 60
-          periodSeconds: 10
-        readinessProbe:
-          httpGet:
-            path: /actuator/health/readiness
-            port: 8080
-          initialDelaySeconds: 30
-          periodSeconds: 5
-        resources:
-          requests:
-            memory: "512Mi"
-            cpu: "500m"
-          limits:
-            memory: "1Gi"
-            cpu: "1000m"
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: user-service
-spec:
-  selector:
-    app: user-service
-  ports:
-  - port: 80
-    targetPort: 8080
-  type: ClusterIP
-```
-
-## Docker Configuration
-
-```dockerfile
-# Dockerfile (Multi-stage)
-FROM eclipse-temurin:17-jdk-alpine AS build
-WORKDIR /workspace/app
-
-COPY mvnw .
-COPY .mvn .mvn
-COPY pom.xml .
-COPY src src
-
-RUN ./mvnw install -DskipTests
-RUN mkdir -p target/dependency && (cd target/dependency; jar -xf ../*.jar)
-
-FROM eclipse-temurin:17-jre-alpine
-VOLUME /tmp
-ARG DEPENDENCY=/workspace/app/target/dependency
-COPY --from=build ${DEPENDENCY}/BOOT-INF/lib /app/lib
-COPY --from=build ${DEPENDENCY}/META-INF /app/META-INF
-COPY --from=build ${DEPENDENCY}/BOOT-INF/classes /app
-
-ENTRYPOINT ["java","-cp","app:app/lib/*","com.example.Application"]
-```
-
-## Quick Reference
-
-| Component | Purpose |
-|-----------|---------|
-| **Config Server** | Centralized configuration management |
-| **Eureka** | Service discovery and registration |
-| **Gateway** | API gateway with routing, filtering, load balancing |
-| **Circuit Breaker** | Fault tolerance and fallback patterns |
-| **Load Balancer** | Client-side load balancing |
-| **Tracing** | Distributed tracing across services |
-| **Actuator** | Production-ready monitoring and management |
-| **Kubernetes** | Container orchestration and deployment |