devskill 2.0.6 → 2.0.8

package/skills/java-add-graalvm-native-image-support/SKILL.md

@@ -0,0 +1,449 @@
+---
+name: java-add-graalvm-native-image-support
+description: 'GraalVM Native Image expert that adds native image support to Java applications, builds the project, analyzes build errors, applies fixes, and iterates until successful compilation using Oracle best practices.'
+---
+
+# GraalVM Native Image Agent
+
+You are an expert in adding GraalVM native image support to Java applications. Your goal is to:
+
+1. Analyze the project structure and identify the build tool (Maven or Gradle)
+2. Detect the framework (Spring Boot, Quarkus, Micronaut, or generic Java)
+3. Add appropriate GraalVM native image configuration
+4. Build the native image
+5. Analyze any build errors or warnings
+6. Apply fixes iteratively until the build succeeds
+
+## Your Approach
+
+Follow Oracle's best practices for GraalVM native images and use an iterative approach to resolve issues.
+
+### Step 1: Analyze the Project
+
+- Check if `pom.xml` exists (Maven) or `build.gradle`/`build.gradle.kts` exists (Gradle)
+- Identify the framework by checking dependencies:
+  - Spring Boot: `spring-boot-starter` dependencies
+  - Quarkus: `quarkus-` dependencies
+  - Micronaut: `micronaut-` dependencies
+- Check for existing GraalVM configuration
+
+### Step 2: Add Native Image Support
+
+#### For Maven Projects
+
+Add the GraalVM Native Build Tools plugin within a `native` profile in `pom.xml`:
+
+```xml
+<profiles>
+  <profile>
+    <id>native</id>
+    <build>
+      <plugins>
+        <plugin>
+          <groupId>org.graalvm.buildtools</groupId>
+          <artifactId>native-maven-plugin</artifactId>
+          <version>[latest-version]</version>
+          <extensions>true</extensions>
+          <executions>
+            <execution>
+              <id>build-native</id>
+              <goals>
+                <goal>compile-no-fork</goal>
+              </goals>
+              <phase>package</phase>
+            </execution>
+          </executions>
+          <configuration>
+            <imageName>${project.artifactId}</imageName>
+            <mainClass>${main.class}</mainClass>
+            <buildArgs>
+              <buildArg>--no-fallback</buildArg>
+            </buildArgs>
+          </configuration>
+        </plugin>
+      </plugins>
+    </build>
+  </profile>
+</profiles>
+```
+
+For Spring Boot projects, ensure the Spring Boot Maven plugin is in the main build section:
+
+```xml
+<build>
+  <plugins>
+    <plugin>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-maven-plugin</artifactId>
+    </plugin>
+  </plugins>
+</build>
+```
+
+#### For Gradle Projects
+
+Add the GraalVM Native Build Tools plugin to `build.gradle`:
+
+```groovy
+plugins {
+  id 'org.graalvm.buildtools.native' version '[latest-version]'
+}
+
+graalvmNative {
+  binaries {
+    main {
+      imageName = project.name
+      mainClass = application.mainClass.get()
+      buildArgs.add('--no-fallback')
+    }
+  }
+}
+```
+
+Or for Kotlin DSL (`build.gradle.kts`):
+
+```kotlin
+plugins {
+  id("org.graalvm.buildtools.native") version "[latest-version]"
+}
+
+graalvmNative {
+  binaries {
+    named("main") {
+      imageName.set(project.name)
+      mainClass.set(application.mainClass.get())
+      buildArgs.add("--no-fallback")
+    }
+  }
+}
+```
+
+### Step 3: Build the Native Image
+
+Run the appropriate build command:
+
+**Maven:**
+```sh
+mvn -Pnative native:compile
+```
+
+**Gradle:**
+```sh
+./gradlew nativeCompile
+```
+
+**Spring Boot (Maven):**
+```sh
+mvn -Pnative spring-boot:build-image
+```
+
+**Quarkus (Maven):**
+```sh
+./mvnw package -Pnative
+```
+
+**Micronaut (Maven):**
+```sh
+./mvnw package -Dpackaging=native-image
+```
+
+### Step 4: Analyze Build Errors
+
+Common issues and solutions:
+
+#### Reflection Issues
+If you see errors about missing reflection configuration, create or update `src/main/resources/META-INF/native-image/reflect-config.json`:
+
+```json
+[
+  {
+    "name": "com.example.YourClass",
+    "allDeclaredConstructors": true,
+    "allDeclaredMethods": true,
+    "allDeclaredFields": true
+  }
+]
+```
+
+#### Resource Access Issues
+For missing resources, create `src/main/resources/META-INF/native-image/resource-config.json`:
+
+```json
+{
+  "resources": {
+    "includes": [
+      {"pattern": "application.properties"},
+      {"pattern": ".*\\.yml"},
+      {"pattern": ".*\\.yaml"}
+    ]
+  }
+}
+```
+
+#### JNI Issues
+For JNI-related errors, create `src/main/resources/META-INF/native-image/jni-config.json`:
+
+```json
+[
+  {
+    "name": "com.example.NativeClass",
+    "methods": [
+      {"name": "nativeMethod", "parameterTypes": ["java.lang.String"]}
+    ]
+  }
+]
+```
+
+#### Dynamic Proxy Issues
+For dynamic proxy errors, create `src/main/resources/META-INF/native-image/proxy-config.json`:
+
+```json
+[
+  ["com.example.Interface1", "com.example.Interface2"]
+]
+```
+
+### Step 5: Iterate Until Success
+
+- After each fix, rebuild the native image
+- Analyze new errors and apply appropriate fixes
+- Use the GraalVM tracing agent to automatically generate configuration:
+  ```sh
+  java -agentlib:native-image-agent=config-output-dir=src/main/resources/META-INF/native-image -jar target/app.jar
+  ```
+- Continue until the build succeeds without errors
+
+### Step 6: Verify the Native Image
+
+Once built successfully:
+- Test the native executable to ensure it runs correctly
+- Verify startup time improvements
+- Check memory footprint
+- Test all critical application paths
+
+## Framework-Specific Considerations
+
+### Spring Boot
+- Spring Boot 3.0+ has excellent native image support
+- Ensure you're using compatible Spring Boot version (3.0+)
+- Most Spring libraries provide GraalVM hints automatically
+- Test with Spring AOT processing enabled
+
+**When to Add Custom RuntimeHints:**
+
+Create a `RuntimeHintsRegistrar` implementation only if you need to register custom hints:
+
+```java
+import org.springframework.aot.hint.RuntimeHints;
+import org.springframework.aot.hint.RuntimeHintsRegistrar;
+
+public class MyRuntimeHints implements RuntimeHintsRegistrar {
+    @Override
+    public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
+        // Register reflection hints
+        hints.reflection().registerType(
+            MyClass.class,
+            hint -> hint.withMembers(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS,
+                                     MemberCategory.INVOKE_DECLARED_METHODS)
+        );
+
+        // Register resource hints
+        hints.resources().registerPattern("custom-config/*.properties");
+
+        // Register serialization hints
+        hints.serialization().registerType(MySerializableClass.class);
+    }
+}
+```
+
+Register it in your main application class:
+
+```java
+@SpringBootApplication
+@ImportRuntimeHints(MyRuntimeHints.class)
+public class Application {
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+}
+```
+
+**Common Spring Boot Native Image Issues:**
+
+1. **Logback Configuration**: Add to `application.properties`:
+   ```properties
+   # Disable Logback's shutdown hook in native images
+   logging.register-shutdown-hook=false
+   ```
+
+   If using custom Logback configuration, ensure `logback-spring.xml` is in resources and add to `RuntimeHints`:
+   ```java
+   hints.resources().registerPattern("logback-spring.xml");
+   hints.resources().registerPattern("org/springframework/boot/logging/logback/*.xml");
+   ```
+
+2. **Jackson Serialization**: For custom Jackson modules or types, register them:
+   ```java
+   hints.serialization().registerType(MyDto.class);
+   hints.reflection().registerType(
+       MyDto.class,
+       hint -> hint.withMembers(
+           MemberCategory.DECLARED_FIELDS,
+           MemberCategory.INVOKE_DECLARED_CONSTRUCTORS
+       )
+   );
+   ```
+
+   Add Jackson mix-ins to reflection hints if used:
+   ```java
+   hints.reflection().registerType(MyMixIn.class);
+   ```
+
+3. **Jackson Modules**: Ensure Jackson modules are on the classpath:
+   ```xml
+   <dependency>
+       <groupId>com.fasterxml.jackson.datatype</groupId>
+       <artifactId>jackson-datatype-jsr310</artifactId>
+   </dependency>
+   ```
+
+### Quarkus
+- Quarkus is designed for native images with zero configuration in most cases
+- Use `@RegisterForReflection` annotation for reflection needs
+- Quarkus extensions handle GraalVM configuration automatically
+
+**Common Quarkus Native Image Tips:**
+
+1. **Reflection Registration**: Use annotations instead of manual configuration:
+   ```java
+   @RegisterForReflection(targets = {MyClass.class, MyDto.class})
+   public class ReflectionConfiguration {
+   }
+   ```
+
+   Or register entire packages:
+   ```java
+   @RegisterForReflection(classNames = {"com.example.package.*"})
+   ```
+
+2. **Resource Inclusion**: Add to `application.properties`:
+   ```properties
+   quarkus.native.resources.includes=config/*.json,templates/**
+   quarkus.native.additional-build-args=--initialize-at-run-time=com.example.RuntimeClass
+   ```
+
+3. **Database Drivers**: Ensure you're using Quarkus-supported JDBC extensions:
+   ```xml
+   <dependency>
+       <groupId>io.quarkus</groupId>
+       <artifactId>quarkus-jdbc-postgresql</artifactId>
+   </dependency>
+   ```
+
+4. **Build-Time vs Runtime Initialization**: Control initialization with:
+   ```properties
+   quarkus.native.additional-build-args=--initialize-at-build-time=com.example.BuildTimeClass
+   quarkus.native.additional-build-args=--initialize-at-run-time=com.example.RuntimeClass
+   ```
+
+5. **Container Image Build**: Use Quarkus container-image extensions:
+   ```properties
+   quarkus.native.container-build=true
+   quarkus.native.builder-image=mandrel
+   ```
+
+### Micronaut
+- Micronaut has built-in GraalVM support with minimal configuration
+- Use `@ReflectionConfig` and `@Introspected` annotations as needed
+- Micronaut's ahead-of-time compilation reduces reflection requirements
+
+**Common Micronaut Native Image Tips:**
+
+1. **Bean Introspection**: Use `@Introspected` for POJOs to avoid reflection:
+   ```java
+   @Introspected
+   public class MyDto {
+       private String name;
+       private int value;
+       // getters and setters
+   }
+   ```
+
+   Or enable package-wide introspection in `application.yml`:
+   ```yaml
+   micronaut:
+     introspection:
+       packages:
+         - com.example.dto
+   ```
+
+2. **Reflection Configuration**: Use declarative annotations:
+   ```java
+   @ReflectionConfig(
+       type = MyClass.class,
+       accessType = ReflectionConfig.AccessType.ALL_DECLARED_CONSTRUCTORS
+   )
+   public class MyConfiguration {
+   }
+   ```
+
+3. **Resource Configuration**: Add resources to native image:
+   ```java
+   @ResourceConfig(
+       includes = {"application.yml", "logback.xml"}
+   )
+   public class ResourceConfiguration {
+   }
+   ```
+
+4. **Native Image Configuration**: In `build.gradle`:
+   ```groovy
+   graalvmNative {
+       binaries {
+           main {
+               buildArgs.add("--initialize-at-build-time=io.micronaut")
+               buildArgs.add("--initialize-at-run-time=io.netty")
+               buildArgs.add("--report-unsupported-elements-at-runtime")
+           }
+       }
+   }
+   ```
+
+5. **HTTP Client Configuration**: For Micronaut HTTP clients, ensure netty is properly configured:
+   ```yaml
+   micronaut:
+     http:
+       client:
+         read-timeout: 30s
+   netty:
+     default:
+       allocator:
+         max-order: 3
+   ```
+
+## Best Practices
+
+- **Start Simple**: Build with `--no-fallback` to catch all native image issues
+- **Use Tracing Agent**: Run your application with the GraalVM tracing agent to automatically discover reflection, resources, and JNI requirements
+- **Test Thoroughly**: Native images behave differently than JVM applications
+- **Minimize Reflection**: Prefer compile-time code generation over runtime reflection
+- **Profile Memory**: Native images have different memory characteristics
+- **CI/CD Integration**: Add native image builds to your CI/CD pipeline
+- **Keep Dependencies Updated**: Use latest versions for better GraalVM compatibility
+
+## Troubleshooting Tips
+
+1. **Build Fails with Reflection Errors**: Use the tracing agent or add manual reflection configuration
+2. **Missing Resources**: Ensure resource patterns are correctly specified in `resource-config.json`
+3. **ClassNotFoundException at Runtime**: Add the class to reflection configuration
+4. **Slow Build Times**: Consider using build caching and incremental builds
+5. **Large Image Size**: Use `--gc=serial` (default) or `--gc=epsilon` (no-op GC for testing) and analyze dependencies
+
+## References
+
+- [GraalVM Native Image Documentation](https://www.graalvm.org/latest/reference-manual/native-image/)
+- [Spring Boot Native Image Guide](https://docs.spring.io/spring-boot/docs/current/reference/html/native-image.html)
+- [Quarkus Building Native Images](https://quarkus.io/guides/building-native-image)
+- [Micronaut GraalVM Support](https://docs.micronaut.io/latest/guide/index.html#graal)
+- [GraalVM Reachability Metadata](https://github.com/oracle/graalvm-reachability-metadata)
+- [Native Build Tools](https://graalvm.github.io/native-build-tools/latest/index.html)

package/skills/java-add-graalvm-native-image-support/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/java-add-graalvm-native-image-support`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24

package/skills/java-docs/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/java-docs/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: java-docs
+description: 'Ensure that Java types are documented with Javadoc comments and follow best practices for documentation.'
+---
+
+# Java Documentation (Javadoc) Best Practices
+
+- Public and protected members should be documented with Javadoc comments.
+- It is encouraged to document package-private and private members as well, especially if they are complex or not self-explanatory.
+- The first sentence of the Javadoc comment is the summary description. It should be a concise overview of what the method does and end with a period.
+- Use `@param` for method parameters. The description starts with a lowercase letter and does not end with a period.
+- Use `@return` for method return values.
+- Use `@throws` or `@exception` to document exceptions thrown by methods.
+- Use `@see` for references to other types or members.
+- Use `{@inheritDoc}` to inherit documentation from base classes or interfaces.
+  - Unless there is major behavior change, in which case you should document the differences.
+- Use `@param <T>` for type parameters in generic types or methods.
+- Use `{@code}` for inline code snippets.
+- Use `<pre>{@code ... }</pre>` for code blocks.
+- Use `@since` to indicate when the feature was introduced (e.g., version number).
+- Use `@version` to specify the version of the member.
+- Use `@author` to specify the author of the code.
+- Use `@deprecated` to mark a member as deprecated and provide an alternative.

package/skills/java-docs/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/java-docs`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24

package/skills/java-junit/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/java-junit/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: java-junit
+description: 'Get best practices for JUnit 5 unit testing, including data-driven tests'
+---
+
+# JUnit 5+ Best Practices
+
+Your goal is to help me write effective unit tests with JUnit 5, covering both standard and data-driven testing approaches.
+
+## Project Setup
+
+- Use a standard Maven or Gradle project structure.
+- Place test source code in `src/test/java`.
+- Include dependencies for `junit-jupiter-api`, `junit-jupiter-engine`, and `junit-jupiter-params` for parameterized tests.
+- Use build tool commands to run tests: `mvn test` or `gradle test`.
+
+## Test Structure
+
+- Test classes should have a `Test` suffix, e.g., `CalculatorTest` for a `Calculator` class.
+- Use `@Test` for test methods.
+- Follow the Arrange-Act-Assert (AAA) pattern.
+- Name tests using a descriptive convention, like `methodName_should_expectedBehavior_when_scenario`.
+- Use `@BeforeEach` and `@AfterEach` for per-test setup and teardown.
+- Use `@BeforeAll` and `@AfterAll` for per-class setup and teardown (must be static methods).
+- Use `@DisplayName` to provide a human-readable name for test classes and methods.
+
+## Standard Tests
+
+- Keep tests focused on a single behavior.
+- Avoid testing multiple conditions in one test method.
+- Make tests independent and idempotent (can run in any order).
+- Avoid test interdependencies.
+
+## Data-Driven (Parameterized) Tests
+
+- Use `@ParameterizedTest` to mark a method as a parameterized test.
+- Use `@ValueSource` for simple literal values (strings, ints, etc.).
+- Use `@MethodSource` to refer to a factory method that provides test arguments as a `Stream`, `Collection`, etc.
+- Use `@CsvSource` for inline comma-separated values.
+- Use `@CsvFileSource` to use a CSV file from the classpath.
+- Use `@EnumSource` to use enum constants.
+
+## Assertions
+
+- Use the static methods from `org.junit.jupiter.api.Assertions` (e.g., `assertEquals`, `assertTrue`, `assertNotNull`).
+- For more fluent and readable assertions, consider using a library like AssertJ (`assertThat(...).is...`).
+- Use `assertThrows` or `assertDoesNotThrow` to test for exceptions.
+- Group related assertions with `assertAll` to ensure all assertions are checked before the test fails.
+- Use descriptive messages in assertions to provide clarity on failure.
+
+## Mocking and Isolation
+
+- Use a mocking framework like Mockito to create mock objects for dependencies.
+- Use `@Mock` and `@InjectMocks` annotations from Mockito to simplify mock creation and injection.
+- Use interfaces to facilitate mocking.
+
+## Test Organization
+
+- Group tests by feature or component using packages.
+- Use `@Tag` to categorize tests (e.g., `@Tag("fast")`, `@Tag("integration")`).
+- Use `@TestMethodOrder(MethodOrderer.OrderAnnotation.class)` and `@Order` to control test execution order when strictly necessary.
+- Use `@Disabled` to temporarily skip a test method or class, providing a reason.
+- Use `@Nested` to group tests in a nested inner class for better organization and structure.

package/skills/java-junit/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/java-junit`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24

package/skills/java-mcp-server-generator/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.