workspace-architect 1.3.0 → 1.5.0

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

@@ -1,756 +0,0 @@
----
-description: 'Generate a complete Model Context Protocol server project in Java using the official MCP Java SDK with reactive streams and optional Spring Boot integration.'
-mode: agent
----
-
-# Java MCP Server Generator
-
-Generate a complete, production-ready MCP server in Java using the official Java SDK with Maven or Gradle.
-
-## Project Generation
-
-When asked to create a Java MCP server, generate a complete project with this structure:
-
-```
-my-mcp-server/
-├── pom.xml (or build.gradle.kts)
-├── src/
-│   ├── main/
-│   │   ├── java/
-│   │   │   └── com/example/mcp/
-│   │   │       ├── McpServerApplication.java
-│   │   │       ├── config/
-│   │   │       │   └── ServerConfiguration.java
-│   │   │       ├── tools/
-│   │   │       │   ├── ToolDefinitions.java
-│   │   │       │   └── ToolHandlers.java
-│   │   │       ├── resources/
-│   │   │       │   ├── ResourceDefinitions.java
-│   │   │       │   └── ResourceHandlers.java
-│   │   │       └── prompts/
-│   │   │           ├── PromptDefinitions.java
-│   │   │           └── PromptHandlers.java
-│   │   └── resources/
-│   │       └── application.properties (if using Spring)
-│   └── test/
-│       └── java/
-│           └── com/example/mcp/
-│               └── McpServerTest.java
-└── README.md
-```
-
-## Maven pom.xml Template
-
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
-         http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>com.example</groupId>
-    <artifactId>my-mcp-server</artifactId>
-    <version>1.0.0</version>
-    <packaging>jar</packaging>
-
-    <name>My MCP Server</name>
-    <description>Model Context Protocol server implementation</description>
-
-    <properties>
-        <java.version>17</java.version>
-        <maven.compiler.source>17</maven.compiler.source>
-        <maven.compiler.target>17</maven.compiler.target>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <mcp.version>0.14.1</mcp.version>
-        <slf4j.version>2.0.9</slf4j.version>
-        <logback.version>1.4.11</logback.version>
-        <junit.version>5.10.0</junit.version>
-    </properties>
-
-    <dependencies>
-        <!-- MCP Java SDK -->
-        <dependency>
-            <groupId>io.modelcontextprotocol.sdk</groupId>
-            <artifactId>mcp</artifactId>
-            <version>${mcp.version}</version>
-        </dependency>
-
-        <!-- Logging -->
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-api</artifactId>
-            <version>${slf4j.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>ch.qos.logback</groupId>
-            <artifactId>logback-classic</artifactId>
-            <version>${logback.version}</version>
-        </dependency>
-
-        <!-- Testing -->
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <version>${junit.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>io.projectreactor</groupId>
-            <artifactId>reactor-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.11.0</version>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-surefire-plugin</artifactId>
-                <version>3.1.2</version>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>3.5.0</version>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                        <configuration>
-                            <transformers>
-                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                    <mainClass>com.example.mcp.McpServerApplication</mainClass>
-                                </transformer>
-                            </transformers>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-</project>
-```
-
-## Gradle build.gradle.kts Template
-
-```kotlin
-plugins {
-    id("java")
-    id("application")
-}
-
-group = "com.example"
-version = "1.0.0"
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_17
-    targetCompatibility = JavaVersion.VERSION_17
-}
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    // MCP Java SDK
-    implementation("io.modelcontextprotocol.sdk:mcp:0.14.1")
-    
-    // Logging
-    implementation("org.slf4j:slf4j-api:2.0.9")
-    implementation("ch.qos.logback:logback-classic:1.4.11")
-    
-    // Testing
-    testImplementation("org.junit.jupiter:junit-jupiter:5.10.0")
-    testImplementation("io.projectreactor:reactor-test:3.5.0")
-}
-
-application {
-    mainClass.set("com.example.mcp.McpServerApplication")
-}
-
-tasks.test {
-    useJUnitPlatform()
-}
-```
-
-## McpServerApplication.java Template
-
-```java
-package com.example.mcp;
-
-import com.example.mcp.tools.ToolHandlers;
-import com.example.mcp.resources.ResourceHandlers;
-import com.example.mcp.prompts.PromptHandlers;
-import io.mcp.server.McpServer;
-import io.mcp.server.McpServerBuilder;
-import io.mcp.server.transport.StdioServerTransport;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import reactor.core.Disposable;
-
-public class McpServerApplication {
-    
-    private static final Logger log = LoggerFactory.getLogger(McpServerApplication.class);
-    
-    public static void main(String[] args) {
-        log.info("Starting MCP Server...");
-        
-        try {
-            McpServer server = createServer();
-            StdioServerTransport transport = new StdioServerTransport();
-            
-            // Start server
-            Disposable serverDisposable = server.start(transport).subscribe();
-            
-            // Graceful shutdown
-            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
-                log.info("Shutting down MCP server");
-                serverDisposable.dispose();
-                server.stop().block();
-            }));
-            
-            log.info("MCP Server started successfully");
-            
-            // Keep running
-            Thread.currentThread().join();
-            
-        } catch (Exception e) {
-            log.error("Failed to start MCP server", e);
-            System.exit(1);
-        }
-    }
-    
-    private static McpServer createServer() {
-        McpServer server = McpServerBuilder.builder()
-            .serverInfo("my-mcp-server", "1.0.0")
-            .capabilities(capabilities -> capabilities
-                .tools(true)
-                .resources(true)
-                .prompts(true))
-            .build();
-        
-        // Register handlers
-        ToolHandlers.register(server);
-        ResourceHandlers.register(server);
-        PromptHandlers.register(server);
-        
-        return server;
-    }
-}
-```
-
-## ToolDefinitions.java Template
-
-```java
-package com.example.mcp.tools;
-
-import io.mcp.json.JsonSchema;
-import io.mcp.server.tool.Tool;
-
-import java.util.List;
-
-public class ToolDefinitions {
-    
-    public static List<Tool> getTools() {
-        return List.of(
-            createGreetTool(),
-            createCalculateTool()
-        );
-    }
-    
-    private static Tool createGreetTool() {
-        return Tool.builder()
-            .name("greet")
-            .description("Generate a greeting message")
-            .inputSchema(JsonSchema.object()
-                .property("name", JsonSchema.string()
-                    .description("Name to greet")
-                    .required(true)))
-            .build();
-    }
-    
-    private static Tool createCalculateTool() {
-        return Tool.builder()
-            .name("calculate")
-            .description("Perform mathematical calculations")
-            .inputSchema(JsonSchema.object()
-                .property("operation", JsonSchema.string()
-                    .description("Operation to perform")
-                    .enumValues(List.of("add", "subtract", "multiply", "divide"))
-                    .required(true))
-                .property("a", JsonSchema.number()
-                    .description("First operand")
-                    .required(true))
-                .property("b", JsonSchema.number()
-                    .description("Second operand")
-                    .required(true)))
-            .build();
-    }
-}
-```
-
-## ToolHandlers.java Template
-
-```java
-package com.example.mcp.tools;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import io.mcp.server.McpServer;
-import io.mcp.server.tool.ToolResponse;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import reactor.core.publisher.Mono;
-
-public class ToolHandlers {
-    
-    private static final Logger log = LoggerFactory.getLogger(ToolHandlers.class);
-    
-    public static void register(McpServer server) {
-        // Register tool list handler
-        server.addToolListHandler(() -> {
-            log.debug("Listing available tools");
-            return Mono.just(ToolDefinitions.getTools());
-        });
-        
-        // Register greet handler
-        server.addToolHandler("greet", ToolHandlers::handleGreet);
-        
-        // Register calculate handler
-        server.addToolHandler("calculate", ToolHandlers::handleCalculate);
-    }
-    
-    private static Mono<ToolResponse> handleGreet(JsonNode arguments) {
-        log.info("Greet tool called");
-        
-        if (!arguments.has("name")) {
-            return Mono.just(ToolResponse.error()
-                .message("Missing 'name' parameter")
-                .build());
-        }
-        
-        String name = arguments.get("name").asText();
-        String greeting = "Hello, " + name + "! Welcome to MCP.";
-        
-        log.debug("Generated greeting for: {}", name);
-        
-        return Mono.just(ToolResponse.success()
-            .addTextContent(greeting)
-            .build());
-    }
-    
-    private static Mono<ToolResponse> handleCalculate(JsonNode arguments) {
-        log.info("Calculate tool called");
-        
-        if (!arguments.has("operation") || !arguments.has("a") || !arguments.has("b")) {
-            return Mono.just(ToolResponse.error()
-                .message("Missing required parameters")
-                .build());
-        }
-        
-        String operation = arguments.get("operation").asText();
-        double a = arguments.get("a").asDouble();
-        double b = arguments.get("b").asDouble();
-        
-        double result;
-        switch (operation) {
-            case "add":
-                result = a + b;
-                break;
-            case "subtract":
-                result = a - b;
-                break;
-            case "multiply":
-                result = a * b;
-                break;
-            case "divide":
-                if (b == 0) {
-                    return Mono.just(ToolResponse.error()
-                        .message("Division by zero")
-                        .build());
-                }
-                result = a / b;
-                break;
-            default:
-                return Mono.just(ToolResponse.error()
-                    .message("Unknown operation: " + operation)
-                    .build());
-        }
-        
-        log.debug("Calculation: {} {} {} = {}", a, operation, b, result);
-        
-        return Mono.just(ToolResponse.success()
-            .addTextContent("Result: " + result)
-            .build());
-    }
-}
-```
-
-## ResourceDefinitions.java Template
-
-```java
-package com.example.mcp.resources;
-
-import io.mcp.server.resource.Resource;
-
-import java.util.List;
-
-public class ResourceDefinitions {
-    
-    public static List<Resource> getResources() {
-        return List.of(
-            Resource.builder()
-                .name("Example Data")
-                .uri("resource://data/example")
-                .description("Example resource data")
-                .mimeType("application/json")
-                .build(),
-            Resource.builder()
-                .name("Configuration")
-                .uri("resource://config")
-                .description("Server configuration")
-                .mimeType("application/json")
-                .build()
-        );
-    }
-}
-```
-
-## ResourceHandlers.java Template
-
-```java
-package com.example.mcp.resources;
-
-import io.mcp.server.McpServer;
-import io.mcp.server.resource.ResourceContent;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import reactor.core.publisher.Mono;
-
-import java.time.Instant;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-public class ResourceHandlers {
-    
-    private static final Logger log = LoggerFactory.getLogger(ResourceHandlers.class);
-    private static final Map<String, Boolean> subscriptions = new ConcurrentHashMap<>();
-    
-    public static void register(McpServer server) {
-        // Register resource list handler
-        server.addResourceListHandler(() -> {
-            log.debug("Listing available resources");
-            return Mono.just(ResourceDefinitions.getResources());
-        });
-        
-        // Register resource read handler
-        server.addResourceReadHandler(ResourceHandlers::handleRead);
-        
-        // Register resource subscribe handler
-        server.addResourceSubscribeHandler(ResourceHandlers::handleSubscribe);
-        
-        // Register resource unsubscribe handler
-        server.addResourceUnsubscribeHandler(ResourceHandlers::handleUnsubscribe);
-    }
-    
-    private static Mono<ResourceContent> handleRead(String uri) {
-        log.info("Reading resource: {}", uri);
-        
-        switch (uri) {
-            case "resource://data/example":
-                String jsonData = String.format(
-                    "{\"message\":\"Example resource data\",\"timestamp\":\"%s\"}",
-                    Instant.now()
-                );
-                return Mono.just(ResourceContent.text(jsonData, uri, "application/json"));
-                
-            case "resource://config":
-                String config = "{\"serverName\":\"my-mcp-server\",\"version\":\"1.0.0\"}";
-                return Mono.just(ResourceContent.text(config, uri, "application/json"));
-                
-            default:
-                log.warn("Unknown resource requested: {}", uri);
-                return Mono.error(new IllegalArgumentException("Unknown resource URI: " + uri));
-        }
-    }
-    
-    private static Mono<Void> handleSubscribe(String uri) {
-        log.info("Client subscribed to resource: {}", uri);
-        subscriptions.put(uri, true);
-        return Mono.empty();
-    }
-    
-    private static Mono<Void> handleUnsubscribe(String uri) {
-        log.info("Client unsubscribed from resource: {}", uri);
-        subscriptions.remove(uri);
-        return Mono.empty();
-    }
-}
-```
-
-## PromptDefinitions.java Template
-
-```java
-package com.example.mcp.prompts;
-
-import io.mcp.server.prompt.Prompt;
-import io.mcp.server.prompt.PromptArgument;
-
-import java.util.List;
-
-public class PromptDefinitions {
-    
-    public static List<Prompt> getPrompts() {
-        return List.of(
-            Prompt.builder()
-                .name("code-review")
-                .description("Generate a code review prompt")
-                .argument(PromptArgument.builder()
-                    .name("language")
-                    .description("Programming language")
-                    .required(true)
-                    .build())
-                .argument(PromptArgument.builder()
-                    .name("focus")
-                    .description("Review focus area")
-                    .required(false)
-                    .build())
-                .build()
-        );
-    }
-}
-```
-
-## PromptHandlers.java Template
-
-```java
-package com.example.mcp.prompts;
-
-import io.mcp.server.McpServer;
-import io.mcp.server.prompt.PromptMessage;
-import io.mcp.server.prompt.PromptResult;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import reactor.core.publisher.Mono;
-
-import java.util.List;
-import java.util.Map;
-
-public class PromptHandlers {
-    
-    private static final Logger log = LoggerFactory.getLogger(PromptHandlers.class);
-    
-    public static void register(McpServer server) {
-        // Register prompt list handler
-        server.addPromptListHandler(() -> {
-            log.debug("Listing available prompts");
-            return Mono.just(PromptDefinitions.getPrompts());
-        });
-        
-        // Register prompt get handler
-        server.addPromptGetHandler(PromptHandlers::handleCodeReview);
-    }
-    
-    private static Mono<PromptResult> handleCodeReview(String name, Map<String, String> arguments) {
-        log.info("Getting prompt: {}", name);
-        
-        if (!name.equals("code-review")) {
-            return Mono.error(new IllegalArgumentException("Unknown prompt: " + name));
-        }
-        
-        String language = arguments.getOrDefault("language", "Java");
-        String focus = arguments.getOrDefault("focus", "general quality");
-        
-        String description = "Code review for " + language + " with focus on " + focus;
-        
-        List<PromptMessage> messages = List.of(
-            PromptMessage.user("Please review this " + language + " code with focus on " + focus + "."),
-            PromptMessage.assistant("I'll review the code focusing on " + focus + ". Please share the code."),
-            PromptMessage.user("Here's the code to review: [paste code here]")
-        );
-        
-        log.debug("Generated code review prompt for {} ({})", language, focus);
-        
-        return Mono.just(PromptResult.builder()
-            .description(description)
-            .messages(messages)
-            .build());
-    }
-}
-```
-
-## McpServerTest.java Template
-
-```java
-package com.example.mcp;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-import io.mcp.server.McpServer;
-import io.mcp.server.McpSyncServer;
-import io.mcp.server.tool.ToolResponse;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-class McpServerTest {
-    
-    private McpSyncServer syncServer;
-    private ObjectMapper objectMapper;
-    
-    @BeforeEach
-    void setUp() {
-        McpServer server = createTestServer();
-        syncServer = server.toSyncServer();
-        objectMapper = new ObjectMapper();
-    }
-    
-    private McpServer createTestServer() {
-        // Same setup as main application
-        McpServer server = McpServerBuilder.builder()
-            .serverInfo("test-server", "1.0.0")
-            .capabilities(cap -> cap.tools(true))
-            .build();
-        
-        // Register handlers
-        ToolHandlers.register(server);
-        
-        return server;
-    }
-    
-    @Test
-    void testGreetTool() {
-        ObjectNode args = objectMapper.createObjectNode();
-        args.put("name", "Java");
-        
-        ToolResponse response = syncServer.callTool("greet", args);
-        
-        assertFalse(response.isError());
-        assertEquals(1, response.getContent().size());
-        assertTrue(response.getContent().get(0).getText().contains("Java"));
-    }
-    
-    @Test
-    void testCalculateTool() {
-        ObjectNode args = objectMapper.createObjectNode();
-        args.put("operation", "add");
-        args.put("a", 5);
-        args.put("b", 3);
-        
-        ToolResponse response = syncServer.callTool("calculate", args);
-        
-        assertFalse(response.isError());
-        assertTrue(response.getContent().get(0).getText().contains("8"));
-    }
-    
-    @Test
-    void testDivideByZero() {
-        ObjectNode args = objectMapper.createObjectNode();
-        args.put("operation", "divide");
-        args.put("a", 10);
-        args.put("b", 0);
-        
-        ToolResponse response = syncServer.callTool("calculate", args);
-        
-        assertTrue(response.isError());
-    }
-}
-```
-
-## README.md Template
-
-```markdown
-# My MCP Server
-
-A Model Context Protocol server built with Java and the official MCP Java SDK.
-
-## Features
-
-- ✅ Tools: greet, calculate
-- ✅ Resources: example data, configuration
-- ✅ Prompts: code-review
-- ✅ Reactive Streams with Project Reactor
-- ✅ Structured logging with SLF4J
-- ✅ Full test coverage
-
-## Requirements
-
-- Java 17 or later
-- Maven 3.6+ or Gradle 7+
-
-## Build
-
-### Maven
-```bash
-mvn clean package
-```
-
-### Gradle
-```bash
-./gradlew build
-```
-
-## Run
-
-### Maven
-```bash
-java -jar target/my-mcp-server-1.0.0.jar
-```
-
-### Gradle
-```bash
-./gradlew run
-```
-
-## Testing
-
-### Maven
-```bash
-mvn test
-```
-
-### Gradle
-```bash
-./gradlew test
-```
-
-## Integration with Claude Desktop
-
-Add to `claude_desktop_config.json`:
-
-```json
-{
-  "mcpServers": {
-    "my-mcp-server": {
-      "command": "java",
-      "args": ["-jar", "/path/to/my-mcp-server-1.0.0.jar"]
-    }
-  }
-}
-```
-
-## License
-
-MIT
-```
-
-## Generation Instructions
-
-1. **Ask for project name and package**
-2. **Choose build tool** (Maven or Gradle)
-3. **Generate all files** with proper package structure
-4. **Use Reactive Streams** for async handlers
-5. **Include comprehensive logging** with SLF4J
-6. **Add tests** for all handlers
-7. **Follow Java conventions** (camelCase, PascalCase)
-8. **Include error handling** with proper responses
-9. **Document public APIs** with Javadoc
-10. **Provide both sync and async** examples