devskill 2.0.7 → 2.0.8

package/skills/kotlin-mcp-server-generator/SKILL.md

@@ -0,0 +1,449 @@
+---
+name: kotlin-mcp-server-generator
+description: 'Generate a complete Kotlin MCP server project with proper structure, dependencies, and implementation using the official io.modelcontextprotocol:kotlin-sdk library.'
+---
+
+# Kotlin MCP Server Project Generator
+
+Generate a complete, production-ready Model Context Protocol (MCP) server project in Kotlin.
+
+## Project Requirements
+
+You will create a Kotlin MCP server with:
+
+1. **Project Structure**: Gradle-based Kotlin project layout
+2. **Dependencies**: Official MCP SDK, Ktor, and kotlinx libraries
+3. **Server Setup**: Configured MCP server with transports
+4. **Tools**: At least 2-3 useful tools with typed inputs/outputs
+5. **Error Handling**: Proper exception handling and validation
+6. **Documentation**: README with setup and usage instructions
+7. **Testing**: Basic test structure with coroutines
+
+## Template Structure
+
+```
+myserver/
+├── build.gradle.kts
+├── settings.gradle.kts
+├── gradle.properties
+├── src/
+│   ├── main/
+│   │   └── kotlin/
+│   │       └── com/example/myserver/
+│   │           ├── Main.kt
+│   │           ├── Server.kt
+│   │           ├── config/
+│   │           │   └── Config.kt
+│   │           └── tools/
+│   │               ├── Tool1.kt
+│   │               └── Tool2.kt
+│   └── test/
+│       └── kotlin/
+│           └── com/example/myserver/
+│               └── ServerTest.kt
+└── README.md
+```
+
+## build.gradle.kts Template
+
+```kotlin
+plugins {
+    kotlin("jvm") version "2.1.0"
+    kotlin("plugin.serialization") version "2.1.0"
+    application
+}
+
+group = "com.example"
+version = "1.0.0"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation("io.modelcontextprotocol:kotlin-sdk:0.7.2")
+    
+    // Ktor for transports
+    implementation("io.ktor:ktor-server-netty:3.0.0")
+    implementation("io.ktor:ktor-client-cio:3.0.0")
+    
+    // Serialization
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
+    
+    // Coroutines
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
+    
+    // Logging
+    implementation("io.github.oshai:kotlin-logging-jvm:7.0.0")
+    implementation("ch.qos.logback:logback-classic:1.5.12")
+    
+    // Testing
+    testImplementation(kotlin("test"))
+    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.9.0")
+}
+
+application {
+    mainClass.set("com.example.myserver.MainKt")
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+
+kotlin {
+    jvmToolchain(17)
+}
+```
+
+## settings.gradle.kts Template
+
+```kotlin
+rootProject.name = "{{PROJECT_NAME}}"
+```
+
+## Main.kt Template
+
+```kotlin
+package com.example.myserver
+
+import io.modelcontextprotocol.kotlin.sdk.server.StdioServerTransport
+import kotlinx.coroutines.runBlocking
+import io.github.oshai.kotlinlogging.KotlinLogging
+
+private val logger = KotlinLogging.logger {}
+
+fun main() = runBlocking {
+    logger.info { "Starting MCP server..." }
+    
+    val config = loadConfig()
+    val server = createServer(config)
+    
+    // Use stdio transport
+    val transport = StdioServerTransport()
+    
+    logger.info { "Server '${config.name}' v${config.version} ready" }
+    server.connect(transport)
+}
+```
+
+## Server.kt Template
+
+```kotlin
+package com.example.myserver
+
+import io.modelcontextprotocol.kotlin.sdk.server.Server
+import io.modelcontextprotocol.kotlin.sdk.server.ServerOptions
+import io.modelcontextprotocol.kotlin.sdk.Implementation
+import io.modelcontextprotocol.kotlin.sdk.ServerCapabilities
+import com.example.myserver.tools.registerTools
+
+fun createServer(config: Config): Server {
+    val server = Server(
+        serverInfo = Implementation(
+            name = config.name,
+            version = config.version
+        ),
+        options = ServerOptions(
+            capabilities = ServerCapabilities(
+                tools = ServerCapabilities.Tools(),
+                resources = ServerCapabilities.Resources(
+                    subscribe = true,
+                    listChanged = true
+                ),
+                prompts = ServerCapabilities.Prompts(listChanged = true)
+            )
+        )
+    ) {
+        config.description
+    }
+    
+    // Register all tools
+    server.registerTools()
+    
+    return server
+}
+```
+
+## Config.kt Template
+
+```kotlin
+package com.example.myserver.config
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Config(
+    val name: String = "{{PROJECT_NAME}}",
+    val version: String = "1.0.0",
+    val description: String = "{{PROJECT_DESCRIPTION}}"
+)
+
+fun loadConfig(): Config {
+    return Config(
+        name = System.getenv("SERVER_NAME") ?: "{{PROJECT_NAME}}",
+        version = System.getenv("VERSION") ?: "1.0.0",
+        description = System.getenv("DESCRIPTION") ?: "{{PROJECT_DESCRIPTION}}"
+    )
+}
+```
+
+## Tool1.kt Template
+
+```kotlin
+package com.example.myserver.tools
+
+import io.modelcontextprotocol.kotlin.sdk.server.Server
+import io.modelcontextprotocol.kotlin.sdk.CallToolRequest
+import io.modelcontextprotocol.kotlin.sdk.CallToolResult
+import io.modelcontextprotocol.kotlin.sdk.TextContent
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
+import kotlinx.serialization.json.putJsonObject
+import kotlinx.serialization.json.putJsonArray
+
+fun Server.registerTool1() {
+    addTool(
+        name = "tool1",
+        description = "Description of what tool1 does",
+        inputSchema = buildJsonObject {
+            put("type", "object")
+            putJsonObject("properties") {
+                putJsonObject("param1") {
+                    put("type", "string")
+                    put("description", "First parameter")
+                }
+                putJsonObject("param2") {
+                    put("type", "integer")
+                    put("description", "Optional second parameter")
+                }
+            }
+            putJsonArray("required") {
+                add("param1")
+            }
+        }
+    ) { request: CallToolRequest ->
+        // Extract and validate parameters
+        val param1 = request.params.arguments["param1"] as? String
+            ?: throw IllegalArgumentException("param1 is required")
+        val param2 = (request.params.arguments["param2"] as? Number)?.toInt() ?: 0
+        
+        // Perform tool logic
+        val result = performTool1Logic(param1, param2)
+        
+        CallToolResult(
+            content = listOf(
+                TextContent(text = result)
+            )
+        )
+    }
+}
+
+private fun performTool1Logic(param1: String, param2: Int): String {
+    // Implement tool logic here
+    return "Processed: $param1 with value $param2"
+}
+```
+
+## tools/ToolRegistry.kt Template
+
+```kotlin
+package com.example.myserver.tools
+
+import io.modelcontextprotocol.kotlin.sdk.server.Server
+
+fun Server.registerTools() {
+    registerTool1()
+    registerTool2()
+    // Register additional tools here
+}
+```
+
+## ServerTest.kt Template
+
+```kotlin
+package com.example.myserver
+
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+
+class ServerTest {
+    
+    @Test
+    fun `test server creation`() = runTest {
+        val config = Config(
+            name = "test-server",
+            version = "1.0.0",
+            description = "Test server"
+        )
+        
+        val server = createServer(config)
+        
+        assertEquals("test-server", server.serverInfo.name)
+        assertEquals("1.0.0", server.serverInfo.version)
+    }
+    
+    @Test
+    fun `test tool1 execution`() = runTest {
+        val config = Config()
+        val server = createServer(config)
+        
+        // Test tool execution
+        // Note: You'll need to implement proper testing utilities
+        // for calling tools in the server
+    }
+}
+```
+
+## README.md Template
+
+```markdown
+# {{PROJECT_NAME}}
+
+A Model Context Protocol (MCP) server built with Kotlin.
+
+## Description
+
+{{PROJECT_DESCRIPTION}}
+
+## Requirements
+
+- Java 17 or higher
+- Kotlin 2.1.0
+
+## Installation
+
+Build the project:
+
+\`\`\`bash
+./gradlew build
+\`\`\`
+
+## Usage
+
+Run the server with stdio transport:
+
+\`\`\`bash
+./gradlew run
+\`\`\`
+
+Or build and run the jar:
+
+\`\`\`bash
+./gradlew installDist
+./build/install/{{PROJECT_NAME}}/bin/{{PROJECT_NAME}}
+\`\`\`
+
+## Configuration
+
+Configure via environment variables:
+
+- `SERVER_NAME`: Server name (default: "{{PROJECT_NAME}}")
+- `VERSION`: Server version (default: "1.0.0")
+- `DESCRIPTION`: Server description
+
+## Available Tools
+
+### tool1
+{{TOOL1_DESCRIPTION}}
+
+**Input:**
+- `param1` (string, required): First parameter
+- `param2` (integer, optional): Second parameter
+
+**Output:**
+- Text result of the operation
+
+## Development
+
+Run tests:
+
+\`\`\`bash
+./gradlew test
+\`\`\`
+
+Build:
+
+\`\`\`bash
+./gradlew build
+\`\`\`
+
+Run with auto-reload (development):
+
+\`\`\`bash
+./gradlew run --continuous
+\`\`\`
+
+## Multiplatform
+
+This project uses Kotlin Multiplatform and can target JVM, Wasm, and iOS.
+See `build.gradle.kts` for platform configuration.
+
+## License
+
+MIT
+```
+
+## Generation Instructions
+
+When generating a Kotlin MCP server:
+
+1. **Gradle Setup**: Create proper `build.gradle.kts` with all dependencies
+2. **Package Structure**: Follow Kotlin package conventions
+3. **Type Safety**: Use data classes and kotlinx.serialization
+4. **Coroutines**: All operations should be suspending functions
+5. **Error Handling**: Use Kotlin exceptions and validation
+6. **JSON Schemas**: Use `buildJsonObject` for tool schemas
+7. **Testing**: Include coroutine test utilities
+8. **Logging**: Use kotlin-logging for structured logging
+9. **Configuration**: Use data classes and environment variables
+10. **Documentation**: KDoc comments for public APIs
+
+## Best Practices
+
+- Use suspending functions for all async operations
+- Leverage Kotlin's null safety and type system
+- Use data classes for structured data
+- Apply kotlinx.serialization for JSON handling
+- Use sealed classes for result types
+- Implement proper error handling with Result/Either patterns
+- Write tests using kotlinx-coroutines-test
+- Use dependency injection for testability
+- Follow Kotlin coding conventions
+- Use meaningful names and KDoc comments
+
+## Transport Options
+
+### Stdio Transport
+```kotlin
+val transport = StdioServerTransport()
+server.connect(transport)
+```
+
+### SSE Transport (Ktor)
+```kotlin
+embeddedServer(Netty, port = 8080) {
+    mcp {
+        Server(/*...*/) { "Description" }
+    }
+}.start(wait = true)
+```
+
+## Multiplatform Configuration
+
+For multiplatform projects, add to `build.gradle.kts`:
+
+```kotlin
+kotlin {
+    jvm()
+    js(IR) { nodejs() }
+    wasmJs()
+    
+    sourceSets {
+        commonMain.dependencies {
+            implementation("io.modelcontextprotocol:kotlin-sdk:0.7.2")
+        }
+    }
+}
+```

package/skills/kotlin-mcp-server-generator/SYNC.md

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

package/skills/kotlin-springboot/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/kotlin-springboot/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: kotlin-springboot
+description: 'Get best practices for developing applications with Spring Boot and Kotlin.'
+---
+
+# Spring Boot with Kotlin Best Practices
+
+Your goal is to help me write high-quality, idiomatic Spring Boot applications using Kotlin.
+
+## Project Setup & Structure
+
+- **Build Tool:** Use Maven (`pom.xml`) or Gradle (`build.gradle`) with the Kotlin plugins (`kotlin-maven-plugin` or `org.jetbrains.kotlin.jvm`).
+- **Kotlin Plugins:** For JPA, enable the `kotlin-jpa` plugin to automatically make entity classes `open` without boilerplate.
+- **Starters:** Use Spring Boot starters (e.g., `spring-boot-starter-web`, `spring-boot-starter-data-jpa`) as usual.
+- **Package Structure:** Organize code by feature/domain (e.g., `com.example.app.order`, `com.example.app.user`) rather than by layer.
+
+## Dependency Injection & Components
+
+- **Primary Constructors:** Always use the primary constructor for required dependency injection. It's the most idiomatic and concise approach in Kotlin.
+- **Immutability:** Declare dependencies as `private val` in the primary constructor. Prefer `val` over `var` everywhere to promote immutability.
+- **Component Stereotypes:** Use `@Service`, `@Repository`, and `@RestController` annotations just as you would in Java.
+
+## Configuration
+
+- **Externalized Configuration:** Use `application.yml` for its readability and hierarchical structure.
+- **Type-Safe Properties:** Use `@ConfigurationProperties` with `data class` to create immutable, type-safe configuration objects.
+- **Profiles:** Use Spring Profiles (`application-dev.yml`, `application-prod.yml`) to manage environment-specific configurations.
+- **Secrets Management:** Never hardcode secrets. Use environment variables or a dedicated secret management tool like HashiCorp Vault or AWS Secrets Manager.
+
+## Web Layer (Controllers)
+
+- **RESTful APIs:** Design clear and consistent RESTful endpoints.
+- **Data Classes for DTOs:** Use Kotlin `data class` for all DTOs. This provides `equals()`, `hashCode()`, `toString()`, and `copy()` for free and promotes immutability.
+- **Validation:** Use Java Bean Validation (JSR 380) with annotations (`@Valid`, `@NotNull`, `@Size`) on your DTO data classes.
+- **Error Handling:** Implement a global exception handler using `@ControllerAdvice` and `@ExceptionHandler` for consistent error responses.
+
+## Service Layer
+
+- **Business Logic:** Encapsulate business logic within `@Service` classes.
+- **Statelessness:** Services should be stateless.
+- **Transaction Management:** Use `@Transactional` on service methods. In Kotlin, this can be applied to class or function level.
+
+## Data Layer (Repositories)
+
+- **JPA Entities:** Define entities as classes. Remember they must be `open`. It's highly recommended to use the `kotlin-jpa` compiler plugin to handle this automatically.
+- **Null Safety:** Leverage Kotlin's null-safety (`?`) to clearly define which entity fields are optional or required at the type level.
+- **Spring Data JPA:** Use Spring Data JPA repositories by extending `JpaRepository` or `CrudRepository`.
+- **Coroutines:** For reactive applications, leverage Spring Boot's support for Kotlin Coroutines in the data layer.
+
+## Logging
+
+- **Companion Object Logger:** The idiomatic way to declare a logger is in a companion object.
+  ```kotlin
+  companion object {
+      private val logger = LoggerFactory.getLogger(MyClass::class.java)
+  }
+  ```
+- **Parameterized Logging:** Use parameterized messages (`logger.info("Processing user {}...", userId)`) for performance and clarity.
+
+## Testing
+
+- **JUnit 5:** JUnit 5 is the default and works seamlessly with Kotlin.
+- **Idiomatic Testing Libraries:** For more fluent and idiomatic tests, consider using **Kotest** for assertions and **MockK** for mocking. They are designed for Kotlin and offer a more expressive syntax.
+- **Test Slices:** Use test slice annotations like `@WebMvcTest` or `@DataJpaTest` to test specific parts of the application.
+- **Testcontainers:** Use Testcontainers for reliable integration tests with real databases, message brokers, etc.
+
+## Coroutines & Asynchronous Programming
+
+- **`suspend` functions:** For non-blocking asynchronous code, use `suspend` functions in your controllers and services. Spring Boot has excellent support for coroutines.
+- **Structured Concurrency:** Use `coroutineScope` or `supervisorScope` to manage the lifecycle of coroutines.

package/skills/kotlin-springboot/SYNC.md

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

package/skills/legacy-circuit-mockups/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.