@el-j/magic-helix-plugins 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/java/{index.js → index.mjs}

@@ -1,5 +1,6 @@
-import { B as o } from "../BasePlugin-6wv0hYJ9.js";
-class d extends o {
+import * as o from "node:path";
+import { B as l } from "../BasePlugin-6wv0hYJ9.js";
+class m extends l {
   constructor() {
     super(...arguments), this.name = "java", this.displayName = "Java", this.version = "3.0.0", this.priority = 75;
   }
@@ -11,7 +12,14 @@ class d extends o {
       {
         name: "java-core",
         tags: ["java"],
-        content: `# Java Development Guidelines
+        content: () => this.loadTemplateFromFile(
+          o.join(__dirname, "templates/lang-java.md")
+        ).then((e) => e || this.getJavaFallbackTemplate())
+      }
+    ];
+  }
+  getJavaFallbackTemplate() {
+    return `# Java Development Guidelines
 
 This project uses Java.
 
@@ -33,9 +41,7 @@ This project uses Java.
 ## Testing
 - Write JUnit tests
 - Use Mockito for mocking
-- Aim for good test coverage`
-      }
-    ];
+- Aim for good test coverage`;
   }
   getDependencyTagMap() {
     return {
@@ -54,38 +60,38 @@ This project uses Java.
         manifestFile: "pom.xml",
         projectPath: e
       };
-    const n = t.match(/<artifactId>([^<]+)<\/artifactId>/), s = t.match(/<description>([^<]+)<\/description>/), a = {}, i = t.matchAll(
+    const i = t.match(/<artifactId>([^<]+)<\/artifactId>/), n = t.match(/<description>([^<]+)<\/description>/), s = {}, a = t.matchAll(
       /<dependency>[\s\S]*?<groupId>([^<]+)<\/groupId>[\s\S]*?<artifactId>([^<]+)<\/artifactId>[\s\S]*?(?:<version>([^<]+)<\/version>)?/g
     );
-    for (const r of i)
-      a[`${r[1]}:${r[2]}`] = r[3] || "*";
+    for (const r of a)
+      s[`${r[1]}:${r[2]}`] = r[3] || "*";
     return {
       language: "Java",
-      name: n?.[1] || this.getProjectName(e),
-      description: s?.[1],
-      dependencies: a,
+      name: i?.[1] || this.getProjectName(e),
+      description: n?.[1],
+      dependencies: s,
       manifestFile: "pom.xml",
       projectPath: e
     };
   }
   detectGradle(e) {
-    const t = this.fileExists(e, "build.gradle") ? "build.gradle" : "build.gradle.kts", n = this.readFile(e, t), s = {};
-    if (n) {
-      const a = n.matchAll(
+    const t = this.fileExists(e, "build.gradle") ? "build.gradle" : "build.gradle.kts", i = this.readFile(e, t), n = {};
+    if (i) {
+      const s = i.matchAll(
         /(?:implementation|api|testImplementation)\s*['"]([^:'"]+):([^:'"]+):?([^'"]*)['"]/g
       );
-      for (const i of a)
-        s[`${i[1]}:${i[2]}`] = i[3] || "*";
+      for (const a of s)
+        n[`${a[1]}:${a[2]}`] = a[3] || "*";
     }
     return {
       language: "Java/Kotlin",
       name: this.getProjectName(e),
-      dependencies: s,
+      dependencies: n,
       manifestFile: t,
       projectPath: e
     };
   }
 }
 export {
-  d as JavaPlugin
+  m as JavaPlugin
 };

package/dist/java/templates/build-gradle.md

@@ -0,0 +1,102 @@
+# Gradle Build Tool Instructions
+
+## Project Structure
+```
+project/
+├── build.gradle or build.gradle.kts
+├── settings.gradle or settings.gradle.kts
+├── gradle/
+│   └── wrapper/
+├── src/
+│   ├── main/
+│   │   ├── java/ or kotlin/
+│   │   └── resources/
+│   └── test/
+│       ├── java/ or kotlin/
+│       └── resources/
+└── build/
+```
+
+## Common Commands
+
+```bash
+# Build lifecycle
+./gradlew clean           # Clean build artifacts
+./gradlew build           # Full build with tests
+./gradlew assemble        # Build without tests
+./gradlew test            # Run tests
+./gradlew check           # Run all checks
+
+# Spring Boot
+./gradlew bootRun         # Run application
+./gradlew bootJar         # Create executable JAR
+
+# Dependency management
+./gradlew dependencies    # Show dependency tree
+./gradlew dependencyUpdates  # Check for updates (with plugin)
+```
+
+## Docker Optimization
+
+### Layer Caching Strategy
+```dockerfile
+# Download dependencies in separate layer
+FROM gradle:8.5-jdk17 AS deps
+WORKDIR /app
+COPY build.gradle.kts settings.gradle.kts ./
+COPY gradle ./gradle
+RUN gradle dependencies --no-daemon
+
+# Build application
+FROM deps AS build
+COPY src ./src
+RUN gradle bootJar --no-daemon
+
+# Runtime
+FROM eclipse-temurin:17-jre-alpine
+COPY --from=build /app/build/libs/*.jar app.jar
+CMD ["java", "-jar", "app.jar"]
+```
+
+## Kotlin DSL (build.gradle.kts)
+
+```kotlin
+plugins {
+    id("org.springframework.boot") version "3.2.0"
+    id("io.spring.dependency-management") version "1.1.4"
+    kotlin("jvm") version "1.9.20"
+    kotlin("plugin.spring") version "1.9.20"
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation("org.springframework.boot:spring-boot-starter-web")
+    implementation("org.jetbrains.kotlin:kotlin-reflect")
+    testImplementation("org.springframework.boot:spring-boot-starter-test")
+}
+
+tasks.withType<Test> {
+    useJUnitPlatform()
+}
+```
+
+## Best Practices
+
+- Use Gradle Wrapper (./gradlew) for consistent builds
+- Prefer Kotlin DSL for type safety
+- Use version catalogs for dependency management
+- Leverage buildSrc for shared build logic
+- Enable Gradle daemon for faster builds
+- Use `--parallel` for multi-module projects
+
+## Performance Tips
+
+```kotlin
+// gradle.properties
+org.gradle.caching=true
+org.gradle.parallel=true
+org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=512m
+```

package/dist/java/templates/build-maven.md

@@ -0,0 +1,86 @@
+# Maven Build Tool Instructions
+
+## Project Structure
+```
+project/
+├── pom.xml
+├── src/
+│   ├── main/
+│   │   ├── java/
+│   │   └── resources/
+│   └── test/
+│       ├── java/
+│       └── resources/
+└── target/
+```
+
+## Common Commands
+
+```bash
+# Build lifecycle
+./mvnw clean              # Clean build artifacts
+./mvnw compile            # Compile source code
+./mvnw test               # Run tests
+./mvnw package            # Package as JAR/WAR
+./mvnw install            # Install to local repo
+./mvnw deploy             # Deploy to remote repo
+
+# Spring Boot
+./mvnw spring-boot:run    # Run application
+
+# Dependency management
+./mvnw dependency:tree    # Show dependency tree
+./mvnw dependency:resolve # Download dependencies
+./mvnw versions:display-dependency-updates  # Check for updates
+```
+
+## Docker Optimization
+
+### Layer Caching Strategy
+```dockerfile
+# Download dependencies in separate layer
+FROM maven:3.9-eclipse-temurin-17 AS deps
+WORKDIR /app
+COPY pom.xml .
+RUN mvn dependency:go-offline
+
+# Build application
+FROM deps AS build
+COPY src ./src
+RUN mvn package -DskipTests
+
+# Runtime
+FROM eclipse-temurin:17-jre-alpine
+COPY --from=build /app/target/*.jar app.jar
+CMD ["java", "-jar", "app.jar"]
+```
+
+## Best Practices
+
+- Use Maven Wrapper (./mvnw) for consistent builds
+- Define dependency versions in `<dependencyManagement>`
+- Use Spring Boot BOM for version management
+- Leverage profiles for different environments
+- Keep plugins up to date
+
+## POM Configuration Tips
+
+```xml
+<properties>
+    <java.version>17</java.version>
+    <maven.compiler.source>17</maven.compiler.source>
+    <maven.compiler.target>17</maven.compiler.target>
+</properties>
+
+<dependencyManagement>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-dependencies</artifactId>
+            <version>${spring-boot.version}</version>
+            <type>pom</type>
+            <scope>import</scope>
+        </dependency>
+    </dependencies>
+</dependencyManagement>
+```

package/dist/java/templates/framework-spring-boot.md

@@ -0,0 +1,179 @@
+# Spring Boot Framework Instructions
+
+## Architecture Patterns
+
+### Layered Architecture
+```
+Controller → Service → Repository → Database
+```
+
+### Controller Layer
+```java
+@RestController
+@RequestMapping("/api/users")
+public class UserController {
+    
+    private final UserService userService;
+    
+    public UserController(UserService userService) {
+        this.userService = userService;
+    }
+    
+    @GetMapping("/{id}")
+    public ResponseEntity<User> getUser(@PathVariable Long id) {
+        return userService.findById(id)
+            .map(ResponseEntity::ok)
+            .orElse(ResponseEntity.notFound().build());
+    }
+}
+```
+
+### Service Layer
+```java
+@Service
+public class UserService {
+    
+    private final UserRepository repository;
+    
+    @Transactional
+    public User createUser(User user) {
+        return repository.save(user);
+    }
+}
+```
+
+### Repository Layer
+```java
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+    Optional<User> findByEmail(String email);
+}
+```
+
+## Configuration
+
+### application.yml
+```yaml
+spring:
+  datasource:
+    url: jdbc:postgresql://localhost:5432/mydb
+    username: ${DB_USER}
+    password: ${DB_PASSWORD}
+  jpa:
+    hibernate:
+      ddl-auto: validate
+    properties:
+      hibernate:
+        dialect: org.hibernate.dialect.PostgreSQLDialect
+  
+server:
+  port: 8080
+```
+
+## Docker Best Practices
+
+### Optimized Dockerfile
+```dockerfile
+FROM eclipse-temurin:17-jre-alpine
+WORKDIR /app
+
+# Add non-root user
+RUN addgroup -S spring && adduser -S spring -G spring
+USER spring:spring
+
+COPY --chown=spring:spring target/*.jar app.jar
+
+# JVM optimization for containers
+ENV JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0"
+
+EXPOSE 8080
+ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]
+```
+
+### Health Checks
+```yaml
+# docker-compose.yml
+services:
+  app:
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+```
+
+## Production Readiness
+
+### Actuator Endpoints
+```xml
+<dependency>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-actuator</artifactId>
+</dependency>
+```
+
+### Security
+```java
+@Configuration
+@EnableWebSecurity
+public class SecurityConfig {
+    
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+        http
+            .authorizeHttpRequests(auth -> auth
+                .requestMatchers("/actuator/health").permitAll()
+                .anyRequest().authenticated()
+            )
+            .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt);
+        return http.build();
+    }
+}
+```
+
+## Testing
+
+### Integration Tests
+```java
+@SpringBootTest
+@AutoConfigureMockMvc
+class UserControllerIntegrationTest {
+    
+    @Autowired
+    private MockMvc mockMvc;
+    
+    @Test
+    void shouldGetUser() throws Exception {
+        mockMvc.perform(get("/api/users/1"))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.name").value("John"));
+    }
+}
+```
+
+### Test Containers
+```java
+@Testcontainers
+@SpringBootTest
+class RepositoryIntegrationTest {
+    
+    @Container
+    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15-alpine");
+    
+    @DynamicPropertySource
+    static void configureProperties(DynamicPropertyRegistry registry) {
+        registry.add("spring.datasource.url", postgres::getJdbcUrl);
+        registry.add("spring.datasource.username", postgres::getUsername);
+        registry.add("spring.datasource.password", postgres::getPassword);
+    }
+}
+```
+
+## Performance
+
+- Use connection pooling (HikariCP is default)
+- Enable HTTP/2
+- Use caching (@Cacheable, @CacheEvict)
+- Implement pagination for large datasets
+- Use async processing with @Async where appropriate
+- Monitor with Micrometer metrics

package/dist/java/templates/lang-java.md

@@ -0,0 +1,78 @@
+# Java/Kotlin Language Instructions
+
+## Project Type
+- Language: Java/Kotlin
+- Build Tool: {Maven|Gradle}
+- Framework: {Spring Boot|Micronaut|Quarkus|None}
+
+## Build Commands
+
+### Maven
+```bash
+./mvnw clean install    # Build project
+./mvnw test            # Run tests
+./mvnw spring-boot:run # Run Spring Boot app
+```
+
+### Gradle
+```bash
+./gradlew build        # Build project
+./gradlew test         # Run tests
+./gradlew bootRun      # Run Spring Boot app
+```
+
+## Code Conventions
+
+### Java
+- Follow Java naming conventions (PascalCase for classes, camelCase for methods)
+- Use meaningful variable names
+- Prefer immutability where possible
+- Use Optional for nullable values
+- Handle exceptions appropriately
+
+### Kotlin
+- Use data classes for DTOs
+- Leverage null safety features
+- Use extension functions appropriately
+- Prefer immutability (val over var)
+- Use scope functions (let, apply, run, with)
+
+## Docker Optimization
+
+### Multi-stage Dockerfile Example (Maven)
+```dockerfile
+FROM maven:3.9-eclipse-temurin-17 AS build
+WORKDIR /app
+COPY pom.xml .
+RUN mvn dependency:go-offline
+COPY src ./src
+RUN mvn clean package -DskipTests
+
+FROM eclipse-temurin:17-jre-alpine
+WORKDIR /app
+COPY --from=build /app/target/*.jar app.jar
+EXPOSE 8080
+ENTRYPOINT ["java", "-jar", "app.jar"]
+```
+
+### JVM Tuning for Containers
+```bash
+# Use container-aware JVM flags
+java -XX:+UseContainerSupport \
+     -XX:MaxRAMPercentage=75.0 \
+     -XX:InitialRAMPercentage=50.0 \
+     -jar app.jar
+```
+
+## Testing
+
+- Use JUnit 5 for unit tests
+- Use Mockito for mocking
+- Use Testcontainers for integration tests
+- Maintain test coverage >80%
+
+## Dependencies
+
+- Keep dependencies up to date
+- Use dependency management (Maven BOM, Gradle platform)
+- Scan for vulnerabilities regularly

package/dist/java/templates/lang-kotlin.md

@@ -0,0 +1,88 @@
+# Kotlin Specific Instructions
+
+## Language Features
+
+### Null Safety
+```kotlin
+// Use nullable types explicitly
+val name: String? = null
+val length = name?.length ?: 0
+
+// Safe calls
+user?.address?.city
+```
+
+### Data Classes
+```kotlin
+data class User(
+    val id: Long,
+    val name: String,
+    val email: String
+)
+```
+
+### Extension Functions
+```kotlin
+fun String.toSnakeCase(): String = 
+    this.replace(Regex("([a-z])([A-Z])"), "$1_$2").lowercase()
+```
+
+### Coroutines (Async)
+```kotlin
+suspend fun fetchData(): Data {
+    return withContext(Dispatchers.IO) {
+        // IO operation
+    }
+}
+```
+
+## Spring Boot with Kotlin
+
+### Controller Example
+```kotlin
+@RestController
+@RequestMapping("/api/users")
+class UserController(private val userService: UserService) {
+    
+    @GetMapping("/{id}")
+    fun getUser(@PathVariable id: Long): User {
+        return userService.findById(id)
+    }
+}
+```
+
+### Service with Coroutines
+```kotlin
+@Service
+class UserService(private val repository: UserRepository) {
+    
+    suspend fun findAllAsync(): List<User> = 
+        withContext(Dispatchers.IO) {
+            repository.findAll()
+        }
+}
+```
+
+## Best Practices
+
+- Use `val` over `var` for immutability
+- Leverage sealed classes for state management
+- Use `when` expressions instead of multiple `if-else`
+- Apply scope functions appropriately (let, run, apply, also, with)
+- Use destructuring for data classes
+- Prefer sequences for large collections
+
+## Build Configuration
+
+### build.gradle.kts
+```kotlin
+plugins {
+    kotlin("jvm") version "1.9.20"
+    kotlin("plugin.spring") version "1.9.20"
+}
+
+dependencies {
+    implementation("org.jetbrains.kotlin:kotlin-stdlib")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core")
+}
+```