workspace-architect 1.3.0

package/assets/prompts/kotlin-mcp-server-generator.prompt.md

@@ -0,0 +1,449 @@
+---
+mode: agent
+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/assets/prompts/kotlin-springboot.prompt.md

@@ -0,0 +1,71 @@
+---
+mode: 'agent'
+tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems', 'search']
+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/assets/prompts/mcp-copilot-studio-server-generator.prompt.md

@@ -0,0 +1,118 @@
+---
+description: Generate a complete MCP server implementation optimized for Copilot Studio integration with proper schema constraints and streamable HTTP support
+mode: agent
+---
+
+# Power Platform MCP Connector Generator
+
+Generate a complete Power Platform custom connector with Model Context Protocol (MCP) integration for Microsoft Copilot Studio. This prompt creates all necessary files following Power Platform connector standards with MCP streamable HTTP support.
+
+## Instructions
+
+Create a complete MCP server implementation that:
+
+1. **Uses Copilot Studio MCP Pattern:**
+   - Implement `x-ms-agentic-protocol: mcp-streamable-1.0`
+   - Support JSON-RPC 2.0 communication protocol
+   - Provide streamable HTTP endpoint at `/mcp`
+   - Follow Power Platform connector structure
+
+2. **Schema Compliance Requirements:**
+   - **NO reference types** in tool inputs/outputs (filtered by Copilot Studio)
+   - **Single type values only** (not arrays of multiple types)
+   - **Avoid enum inputs** (interpreted as string, not enum)
+   - Use primitive types: string, number, integer, boolean, array, object
+   - Ensure all endpoints return full URIs
+
+3. **MCP Components to Include:**
+   - **Tools**: Functions for the language model to call (✅ Supported in Copilot Studio)
+   - **Resources**: File-like data outputs from tools (✅ Supported in Copilot Studio - must be tool outputs to be accessible)
+   - **Prompts**: Predefined templates for specific tasks (❌ Not yet supported in Copilot Studio)
+
+4. **Implementation Structure:**
+   ```
+   /apiDefinition.swagger.json  (Power Platform connector schema)
+   /apiProperties.json         (Connector metadata and configuration)
+   /script.csx                 (Custom code transformations and logic)
+   /server/                    (MCP server implementation)
+   /tools/                     (Individual MCP tools)
+   /resources/                 (MCP resource handlers)
+   ```
+
+## Context Variables
+
+- **Server Purpose**: [Describe what the MCP server should accomplish]
+- **Tools Needed**: [List of specific tools to implement]  
+- **Resources**: [Types of resources to provide]
+- **Authentication**: [Auth method: none, api-key, oauth2]
+- **Host Environment**: [Azure Function, Express.js, FastAPI, etc.]
+- **Target APIs**: [External APIs to integrate with]
+
+## Expected Output
+
+Generate:
+
+1. **apiDefinition.swagger.json** with:
+   - Proper `x-ms-agentic-protocol: mcp-streamable-1.0`
+   - MCP endpoint at POST `/mcp`
+   - Compliant schema definitions (no reference types)
+   - McpResponse and McpErrorResponse definitions
+
+2. **apiProperties.json** with:
+   - Connector metadata and branding
+   - Authentication configuration
+   - Policy templates if needed
+
+3. **script.csx** with:
+   - Custom C# code for request/response transformations
+   - MCP JSON-RPC message handling logic
+   - Data validation and processing functions
+   - Error handling and logging capabilities
+
+4. **MCP Server Code** with:
+   - JSON-RPC 2.0 request handler
+   - Tool registration and execution
+   - Resource management (as tool outputs)
+   - Proper error handling
+   - Copilot Studio compatibility checks
+
+5. **Individual Tools** that:
+   - Accept only primitive type inputs
+   - Return structured outputs
+   - Include resources as outputs when needed
+   - Provide clear descriptions for Copilot Studio
+
+6. **Deployment Configuration** for:
+   - Power Platform environment
+   - Copilot Studio agent integration
+   - Testing and validation
+
+## Validation Checklist
+
+Ensure generated code:
+- [ ] No reference types in schemas
+- [ ] All type fields are single types
+- [ ] Enum handling via string with validation
+- [ ] Resources available through tool outputs
+- [ ] Full URI endpoints
+- [ ] JSON-RPC 2.0 compliance
+- [ ] Proper x-ms-agentic-protocol header
+- [ ] McpResponse/McpErrorResponse schemas
+- [ ] Clear tool descriptions for Copilot Studio
+- [ ] Generative Orchestration compatible
+
+## Example Usage
+
+```yaml
+Server Purpose: Customer data management and analysis
+Tools Needed: 
+  - searchCustomers
+  - getCustomerDetails
+  - analyzeCustomerTrends
+Resources:
+  - Customer profiles
+  - Analysis reports
+Authentication: oauth2
+Host Environment: Azure Function
+Target APIs: CRM System REST API
+```