@ngxtm/devkit 3.4.0 → 3.4.1

package/rules/java/micronaut-reactive/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: Micronaut Reactive
+description: Reactive types, HTTP clients, and non-blocking patterns.
+metadata:
+  labels: [java, micronaut, reactive]
+  triggers:
+    files: ['**/*.java']
+    keywords: [Flux, Mono, Reactive, HttpClient, '@Client', Publisher, Flowable]
+---
+
+# Micronaut Reactive Standards
+
+## Reactive Controllers
+
+```java
+@Controller("/users")
+public class UserController {
+
+    @Get("/{id}")
+    public Mono<User> findById(Long id) {
+        return userService.findById(id);
+    }
+
+    @Get(produces = MediaType.TEXT_EVENT_STREAM)
+    public Flux<User> stream() {
+        return userService.streamAll();
+    }
+}
+```
+
+## Declarative HTTP Client
+
+```java
+@Client("order-service")
+public interface OrderClient {
+
+    @Get("/orders/{userId}")
+    Flux<Order> getOrders(Long userId);
+
+    @Post("/orders")
+    Mono<Order> createOrder(@Body CreateOrderRequest request);
+}
+```
+
+## Low-Level Client
+
+```java
+@Singleton
+public class ExternalApiService {
+
+    private final HttpClient httpClient;
+
+    public ExternalApiService(@Client("https://api.external.com") HttpClient httpClient) {
+        this.httpClient = httpClient;
+    }
+
+    public Mono<ExternalData> fetchData(String id) {
+        return Mono.from(httpClient.retrieve(
+            HttpRequest.GET("/data/" + id),
+            ExternalData.class
+        ));
+    }
+}
+```
+
+## References
+
+- [HTTP Client Patterns](references/http-client-patterns.md) - Retry, fallback, timeout

package/rules/java/micronaut-reactive/references/REFERENCE.md

@@ -0,0 +1,12 @@
+# Micronaut Reactive References
+
+## References
+
+- [**HTTP Client Patterns**](http-client-patterns.md) - Declarative clients, retry, fallback
+
+## Quick Checks
+
+- [ ] Use @Client for declarative HTTP clients
+- [ ] Mono for single values, Flux for streams
+- [ ] Configure timeouts and retries
+- [ ] Non-blocking I/O throughout

package/rules/java/quarkus-core/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: Quarkus Core
+description: CDI dependency injection, configuration, dev mode, and extensions.
+metadata:
+  labels: [java, quarkus, di, configuration]
+  triggers:
+    files: ['**/*.java', 'application.properties', 'pom.xml']
+    keywords: [Quarkus, '@Inject', '@ApplicationScoped', '@ConfigProperty', Arc, QuarkusApplication]
+---
+
+# Quarkus Core Standards
+
+## CDI (ArC) Dependency Injection
+
+```java
+@ApplicationScoped
+public class UserService {
+
+    @Inject
+    UserRepository userRepository;
+
+    @Inject
+    @ConfigProperty(name = "app.max-users", defaultValue = "1000")
+    int maxUsers;
+
+    public User findById(Long id) {
+        return userRepository.findById(id);
+    }
+}
+
+// Bean scopes
+@ApplicationScoped  // Single instance per application
+@RequestScoped      // Per HTTP request
+@Singleton          // Like ApplicationScoped but not proxied
+@Dependent          // New instance each injection
+```
+
+## Configuration
+
+```java
+@ConfigMapping(prefix = "app")
+public interface AppConfig {
+    String name();
+    int maxConnections();
+    Optional<String> description();
+    DatabaseConfig database();
+
+    interface DatabaseConfig {
+        String url();
+        String username();
+    }
+}
+
+// Usage
+@Inject
+AppConfig config;
+```
+
+```properties
+# application.properties
+app.name=MyApp
+app.max-connections=100
+app.database.url=jdbc:postgresql://localhost/db
+app.database.username=admin
+
+# Profile-specific
+%dev.app.database.url=jdbc:h2:mem:test
+%prod.app.database.url=${DB_URL}
+```
+
+## Dev Mode
+
+```bash
+# Live reload
+./mvnw quarkus:dev
+
+# Continuous testing
+./mvnw quarkus:dev -Dquarkus.test.continuous-testing=enabled
+
+# Dev UI at http://localhost:8080/q/dev
+```
+
+## References
+
+- [CDI Patterns](references/cdi-patterns.md) - Producers, qualifiers, interceptors

package/rules/java/quarkus-core/references/REFERENCE.md

@@ -0,0 +1,12 @@
+# Quarkus Core References
+
+## References
+
+- [**CDI Patterns**](cdi-patterns.md) - Producers, qualifiers, interceptors, events
+
+## Quick Checks
+
+- [ ] Use @ApplicationScoped for services (not @Singleton)
+- [ ] Use @ConfigMapping for type-safe configuration
+- [ ] Profile configs with %dev, %prod prefixes
+- [ ] Dev mode for live reload during development

package/rules/java/quarkus-reactive/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: Quarkus Reactive
+description: Mutiny reactive types, reactive routes, and non-blocking I/O.
+metadata:
+  labels: [java, quarkus, reactive, mutiny]
+  triggers:
+    files: ['**/*.java']
+    keywords: [Mutiny, Uni, Multi, '@Route', reactive, SmallRye, '@NonBlocking']
+---
+
+# Quarkus Reactive Standards
+
+## Mutiny Types
+
+```java
+// Uni - 0 or 1 item (like CompletableFuture)
+public Uni<User> findById(Long id) {
+    return Uni.createFrom().item(() -> repository.findById(id))
+        .onFailure().recoverWithItem(User.unknown());
+}
+
+// Multi - 0 to N items (like Stream)
+public Multi<User> streamAll() {
+    return Multi.createFrom().items(repository.findAll().stream())
+        .filter(User::isActive);
+}
+
+// Transformations
+Uni<String> name = findById(1L)
+    .map(User::getName)
+    .onItem().ifNull().failWith(new NotFoundException());
+
+// Combining
+Uni<UserProfile> profile = Uni.combine().all()
+    .unis(findUser(id), findOrders(id), findPreferences(id))
+    .with((user, orders, prefs) -> new UserProfile(user, orders, prefs));
+```
+
+## Reactive REST Endpoints
+
+```java
+@Path("/users")
+public class UserResource {
+
+    @GET
+    @Path("/{id}")
+    public Uni<User> get(@PathParam("id") Long id) {
+        return userService.findById(id);
+    }
+
+    @GET
+    @Produces(MediaType.SERVER_SENT_EVENTS)
+    public Multi<User> stream() {
+        return userService.streamAll();
+    }
+
+    @POST
+    public Uni<Response> create(CreateUserRequest request) {
+        return userService.create(request)
+            .map(user -> Response.created(URI.create("/users/" + user.id())).build());
+    }
+}
+```
+
+## References
+
+- [Mutiny Patterns](references/mutiny-patterns.md) - Error handling, timeouts, combining

package/rules/java/quarkus-reactive/references/REFERENCE.md

@@ -0,0 +1,12 @@
+# Quarkus Reactive References
+
+## References
+
+- [**Mutiny Patterns**](mutiny-patterns.md) - Combining Uni/Multi, error handling, timeouts
+
+## Quick Checks
+
+- [ ] Use Uni for single async result
+- [ ] Use Multi for streaming
+- [ ] Non-blocking for I/O operations
+- [ ] Proper error recovery with onFailure()

package/rules/java/spring-batch/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: Spring Batch
+description: Job configuration, chunk processing, readers, writers, processors, and job execution.
+metadata:
+  labels: [java, spring-boot, batch, etl]
+  triggers:
+    files: ['**/*Batch*.java', '**/*Job*.java', '**/*Step*.java']
+    keywords: [Job, Step, ItemReader, ItemWriter, ItemProcessor, JobBuilder, StepBuilder, Chunk, Tasklet]
+---
+
+# Spring Batch Standards
+
+## Job Configuration
+
+```java
+@Configuration
+@RequiredArgsConstructor
+public class UserExportJobConfig {
+
+    private final JobRepository jobRepository;
+    private final PlatformTransactionManager transactionManager;
+
+    @Bean
+    public Job userExportJob(Step exportStep) {
+        return new JobBuilder("userExportJob", jobRepository)
+            .incrementer(new RunIdIncrementer())
+            .start(exportStep)
+            .build();
+    }
+
+    @Bean
+    public Step exportStep(
+            ItemReader<User> reader,
+            ItemProcessor<User, UserDto> processor,
+            ItemWriter<UserDto> writer) {
+        return new StepBuilder("exportStep", jobRepository)
+            .<User, UserDto>chunk(100, transactionManager)
+            .reader(reader)
+            .processor(processor)
+            .writer(writer)
+            .faultTolerant()
+            .skipLimit(10)
+            .skip(DataAccessException.class)
+            .build();
+    }
+}
+```
+
+## Reader/Processor/Writer
+
+```java
+@Bean
+public JpaPagingItemReader<User> userReader(EntityManagerFactory emf) {
+    return new JpaPagingItemReaderBuilder<User>()
+        .name("userReader")
+        .entityManagerFactory(emf)
+        .queryString("SELECT u FROM User u WHERE u.status = 'ACTIVE'")
+        .pageSize(100)
+        .build();
+}
+
+@Bean
+public ItemProcessor<User, UserDto> userProcessor() {
+    return user -> new UserDto(user.getId(), user.getName(), user.getEmail());
+}
+
+@Bean
+public FlatFileItemWriter<UserDto> userWriter() {
+    return new FlatFileItemWriterBuilder<UserDto>()
+        .name("userWriter")
+        .resource(new FileSystemResource("output/users.csv"))
+        .delimited()
+        .names("id", "name", "email")
+        .build();
+}
+```
+
+## Job Execution
+
+```java
+@Service
+@RequiredArgsConstructor
+public class JobLauncherService {
+
+    private final JobLauncher jobLauncher;
+    private final Job userExportJob;
+
+    public void runExport(String date) throws Exception {
+        JobParameters params = new JobParametersBuilder()
+            .addString("date", date)
+            .addLong("time", System.currentTimeMillis())
+            .toJobParameters();
+
+        JobExecution execution = jobLauncher.run(userExportJob, params);
+        log.info("Job status: {}", execution.getStatus());
+    }
+}
+```
+
+## References
+
+- [Chunk Processing](references/chunk-processing.md) - Sizing, transactions, error handling

package/rules/java/spring-batch/references/REFERENCE.md

@@ -0,0 +1,12 @@
+# Spring Batch References
+
+## References
+
+- [**Chunk Processing**](chunk-processing.md) - Chunk sizing, transaction boundaries, skip/retry
+
+## Quick Checks
+
+- [ ] Use JobBuilder/StepBuilder (not deprecated *BuilderFactory)
+- [ ] Set appropriate chunk size (100-1000)
+- [ ] Configure skip/retry for fault tolerance
+- [ ] Use RunIdIncrementer for re-runnable jobs

package/rules/java/spring-boot-architecture/SKILL.md

@@ -0,0 +1,206 @@
+---
+name: Spring Boot Architecture
+description: Application structure, auto-configuration, profiles, bean lifecycle, and configuration properties.
+metadata:
+  labels: [java, spring-boot, architecture, configuration]
+  triggers:
+    files: ['**/Application.java', '**/*Configuration.java', 'application.yml', 'application.properties', 'application-*.yml']
+    keywords: [SpringBootApplication, Configuration, Bean, Profile, AutoConfiguration, ConfigurationProperties, EnableAutoConfiguration]
+---
+
+# Spring Boot Architecture Standards
+
+## Application Entry Point
+
+```java
+@SpringBootApplication
+public class Application {
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+}
+
+// @SpringBootApplication combines:
+// @Configuration - source of bean definitions
+// @EnableAutoConfiguration - auto-configure based on classpath
+// @ComponentScan - scan for components in this package and below
+```
+
+## Configuration Classes
+
+```java
+@Configuration
+public class AppConfig {
+
+    @Bean
+    public RestTemplate restTemplate(RestTemplateBuilder builder) {
+        return builder
+            .setConnectTimeout(Duration.ofSeconds(5))
+            .setReadTimeout(Duration.ofSeconds(30))
+            .build();
+    }
+
+    @Bean
+    @ConditionalOnProperty(name = "app.feature.enabled", havingValue = "true")
+    public FeatureService featureService() {
+        return new FeatureServiceImpl();
+    }
+}
+
+// Conditional beans
+@ConditionalOnProperty(...)      // Based on property
+@ConditionalOnClass(...)         // Based on class presence
+@ConditionalOnMissingBean(...)   // If no other bean exists
+@ConditionalOnBean(...)          // If another bean exists
+@ConditionalOnExpression(...)    // SpEL expression
+```
+
+## Configuration Properties
+
+```java
+@ConfigurationProperties(prefix = "app")
+@Validated
+public record AppProperties(
+    @NotBlank String name,
+    @NotNull Duration timeout,
+    @Valid DatabaseProperties database
+) {
+    public record DatabaseProperties(
+        String host,
+        int port,
+        @NotBlank String username
+    ) {}
+}
+
+// Enable in configuration
+@Configuration
+@EnableConfigurationProperties(AppProperties.class)
+public class AppConfig {}
+
+// Usage
+@Service
+public class MyService {
+    private final AppProperties props;
+
+    public MyService(AppProperties props) {
+        this.props = props;
+    }
+}
+```
+
+```yaml
+# application.yml
+app:
+  name: my-application
+  timeout: 30s
+  database:
+    host: localhost
+    port: 5432
+    username: admin
+```
+
+## Profiles
+
+```yaml
+# application.yml (default)
+spring:
+  profiles:
+    active: dev
+
+---
+spring:
+  config:
+    activate:
+      on-profile: dev
+server:
+  port: 8080
+logging:
+  level:
+    root: DEBUG
+
+---
+spring:
+  config:
+    activate:
+      on-profile: prod
+server:
+  port: 80
+logging:
+  level:
+    root: INFO
+```
+
+```java
+// Profile-specific beans
+@Configuration
+@Profile("dev")
+public class DevConfig {
+    @Bean
+    public DataSource dataSource() {
+        return new EmbeddedDatabaseBuilder()
+            .setType(EmbeddedDatabaseType.H2)
+            .build();
+    }
+}
+
+@Configuration
+@Profile("prod")
+public class ProdConfig {
+    @Bean
+    public DataSource dataSource(DataSourceProperties props) {
+        return DataSourceBuilder.create()
+            .url(props.getUrl())
+            .username(props.getUsername())
+            .password(props.getPassword())
+            .build();
+    }
+}
+```
+
+## Bean Lifecycle
+
+```java
+@Component
+public class MyComponent implements InitializingBean, DisposableBean {
+
+    @PostConstruct
+    public void init() {
+        // Called after dependency injection
+    }
+
+    @Override
+    public void afterPropertiesSet() {
+        // Called after properties set
+    }
+
+    @PreDestroy
+    public void cleanup() {
+        // Called before destruction
+    }
+
+    @Override
+    public void destroy() {
+        // Called on shutdown
+    }
+}
+
+// Or with @Bean
+@Bean(initMethod = "init", destroyMethod = "cleanup")
+public MyService myService() {
+    return new MyService();
+}
+```
+
+## Best Practices
+
+1. **Use @ConfigurationProperties** over @Value for type-safe configuration
+2. **Profiles for environment-specific** config, not feature flags
+3. **Externalize configuration** - never hardcode secrets
+4. **Use record classes** for immutable configuration properties
+5. **Validate configuration** with @Validated and Jakarta constraints
+6. **Auto-configuration order** matters - use @AutoConfigureAfter/@AutoConfigureBefore
+
+## References
+
+- [Auto-Configuration](references/auto-configuration.md) - Custom auto-config, conditions
+- [Configuration Properties](references/configuration-properties.md) - Binding, validation, relaxed binding

package/rules/java/spring-boot-architecture/references/REFERENCE.md

@@ -0,0 +1,15 @@
+# Spring Boot Architecture References
+
+## References
+
+- [**Auto-Configuration**](auto-configuration.md) - Custom auto-config, conditional beans, ordering
+- [**Configuration Properties**](configuration-properties.md) - Type-safe binding, validation, nested properties
+
+## Quick Checks
+
+- [ ] @SpringBootApplication on main class
+- [ ] Use @ConfigurationProperties over @Value
+- [ ] Validate configuration with @Validated
+- [ ] Use profiles for environment differences
+- [ ] Never hardcode secrets - externalize configuration
+- [ ] Use records for immutable configuration