devskill 2.0.7 → 2.0.8

package/skills/issue-fields-migration/references/labels-api.md

@@ -0,0 +1,74 @@
+# Labels API Reference
+
+Reference for GitHub Labels REST API endpoints used in the label migration flow.
+
+## List Labels in a Repository
+
+```
+GET /repos/{owner}/{repo}/labels
+```
+
+Returns all labels defined on a repository. Paginated (max 100 per page).
+
+**CLI shortcut:**
+
+```bash
+gh label list -R {owner}/{repo} --limit 1000 --json name,color,description
+```
+
+**Response fields:** `id`, `node_id`, `url`, `name`, `description`, `color`, `default`.
+
+## List Issues by Label
+
+```
+GET /repos/{owner}/{repo}/issues?labels={label_name}&state=all&per_page=100
+```
+
+Returns issues (and pull requests) matching the label. Filter out PRs by checking `pull_request` field is absent.
+
+**CLI shortcut:**
+
+```bash
+gh issue list -R {owner}/{repo} --label "{label_name}" --state all \
+  --json number,title,labels --limit 1000
+```
+
+The `gh issue list` command automatically excludes PRs.
+
+**Pagination:** use `--limit` in CLI or `page` query param in REST. For repos with >1000 matching issues, use cursor-based pagination via Link headers.
+
+## Remove a Label from an Issue
+
+```
+DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{label_name}
+```
+
+Removes a single label from an issue. Returns `200 OK` with the remaining labels on the issue.
+
+**Important:** URL-encode label names with spaces or special characters:
+- `good first issue` → `good%20first%20issue`
+- `bug/critical` → `bug%2Fcritical`
+
+**CLI shortcut:**
+
+```bash
+gh api /repos/{owner}/{repo}/issues/{number}/labels/{label_name} -X DELETE
+```
+
+## Add a Label to an Issue
+
+```
+POST /repos/{owner}/{repo}/issues/{issue_number}/labels
+```
+
+Body: `{"labels": ["label1", "label2"]}`
+
+Not typically needed for migration, but useful for rollback scenarios.
+
+## Notes
+
+- Labels are repo-scoped. The same label name can exist independently in different repos.
+- There is no MCP tool for listing repo labels. Use `gh label list` or the REST API.
+- The MCP tool `mcp__github__list_issues` supports a `labels` filter for fetching issues by label.
+- Label names are case-insensitive for matching purposes, but the API preserves the original casing.
+- Maximum labels per issue: no hard limit, but practically dozens.

package/skills/issue-fields-migration/references/projects-api.md

@@ -0,0 +1,116 @@
+# Projects V2 API Reference (for Migration)
+
+This reference covers the subset of the Projects V2 API needed for field migration: discovering project fields and reading item values.
+
+## List Project Fields
+
+### Via MCP Tool
+
+```
+mcp__github__projects_list(
+  owner: "{org}",
+  project_number: {n},
+  method: "list_project_fields"
+)
+```
+
+### Via GraphQL
+
+```bash
+gh api graphql -f query='
+  query {
+    organization(login: "ORG") {
+      projectV2(number: N) {
+        fields(first: 30) {
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            ... on ProjectV2Field {
+              id
+              name
+              dataType
+            }
+            ... on ProjectV2SingleSelectField {
+              id
+              name
+              dataType
+              options { id name }
+            }
+            ... on ProjectV2IterationField {
+              id
+              name
+              dataType
+            }
+          }
+        }
+      }
+    }
+  }'
+```
+
+### Field Data Types
+
+| dataType | Description | Migrates to |
+|----------|-------------|-------------|
+| TEXT | Free-form text | `text` issue field |
+| SINGLE_SELECT | Dropdown with options | `single_select` issue field |
+| NUMBER | Numeric value | `number` issue field |
+| DATE | Date value | `date` issue field |
+| ITERATION | Sprint/iteration cycles | No equivalent (skip) |
+
+## List Project Items (with field values)
+
+### Via MCP Tool
+
+```
+mcp__github__projects_list(
+  owner: "{org}",
+  project_number: {n},
+  method: "list_project_items"
+)
+```
+
+Returns paginated results. Each item includes:
+- Item type (ISSUE, DRAFT_ISSUE, PULL_REQUEST)
+- Content reference (repo owner, repo name, issue number)
+- Field values for all project fields
+
+### Via GraphQL
+
+```bash
+gh api graphql -f query='
+  query($cursor: String) {
+    organization(login: "ORG") {
+      projectV2(number: N) {
+        items(first: 100, after: $cursor) {
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            type
+            content {
+              ... on Issue {
+                number
+                repository { nameWithOwner }
+              }
+            }
+            fieldValues(first: 20) {
+              pageInfo { hasNextPage endCursor }
+              nodes {
+                ... on ProjectV2ItemFieldTextValue { text field { ... on ProjectV2Field { name } } }
+                ... on ProjectV2ItemFieldSingleSelectValue { name field { ... on ProjectV2SingleSelectField { name } } }
+                ... on ProjectV2ItemFieldNumberValue { number field { ... on ProjectV2Field { name } } }
+                ... on ProjectV2ItemFieldDateValue { date field { ... on ProjectV2Field { name } } }
+              }
+            }
+          }
+        }
+      }
+    }
+  }' -f cursor="$CURSOR"
+```
+
+### Important Notes for Migration
+
+- **Pagination**: projects can have up to 10,000 items. Always paginate using `pageInfo.hasNextPage` and `pageInfo.endCursor`.
+- **Draft items**: items with `type: DRAFT_ISSUE` have no real issue attached. Skip these during migration.
+- **Pull requests**: items with `type: PULL_REQUEST` are PRs, not issues. Issue fields apply to issues only. Skip these.
+- **Cross-repo**: a single project can contain issues from many repositories. Group items by repo to batch repo ID lookups.
+- **Field value access**: each field value node type is different (`ProjectV2ItemFieldTextValue`, `ProjectV2ItemFieldSingleSelectValue`, etc.). Handle each type.

package/skills/java-add-graalvm-native-image-support/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-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.