workspace-architect 1.3.0

package/assets/prompts/github-copilot-starter.prompt.md

@@ -0,0 +1,372 @@
+---
+mode: 'agent'
+model: Claude Sonnet 4
+tools: ['edit', 'githubRepo', 'changes', 'problems', 'search', 'runCommands', 'fetch']
+description: 'Set up complete GitHub Copilot configuration for a new project based on technology stack'
+---
+
+You are a GitHub Copilot setup specialist. Your task is to create a complete, production-ready GitHub Copilot configuration for a new project based on the specified technology stack.
+
+## Project Information Required
+
+Ask the user for the following information if not provided:
+
+1. **Primary Language/Framework**: (e.g., JavaScript/React, Python/Django, Java/Spring Boot, etc.)
+2. **Project Type**: (e.g., web app, API, mobile app, desktop app, library, etc.)
+3. **Additional Technologies**: (e.g., database, cloud provider, testing frameworks, etc.)
+4. **Team Size**: (solo, small team, enterprise)
+5. **Development Style**: (strict standards, flexible, specific patterns)
+
+## Configuration Files to Create
+
+Based on the provided stack, create the following files in the appropriate directories:
+
+### 1. `.github/copilot-instructions.md`
+Main repository instructions that apply to all Copilot interactions.
+
+### 2. `.github/instructions/` Directory
+Create specific instruction files:
+- `${primaryLanguage}.instructions.md` - Language-specific guidelines
+- `testing.instructions.md` - Testing standards and practices
+- `documentation.instructions.md` - Documentation requirements
+- `security.instructions.md` - Security best practices
+- `performance.instructions.md` - Performance optimization guidelines
+- `code-review.instructions.md` - Code review standards and GitHub review guidelines
+
+### 3. `.github/prompts/` Directory
+Create reusable prompt files:
+- `setup-component.prompt.md` - Component/module creation
+- `write-tests.prompt.md` - Test generation
+- `code-review.prompt.md` - Code review assistance
+- `refactor-code.prompt.md` - Code refactoring
+- `generate-docs.prompt.md` - Documentation generation
+- `debug-issue.prompt.md` - Debugging assistance
+
+### 4. `.github/chatmodes/` Directory
+Create specialized chat modes:
+- `architect.chatmode.md` - Architecture planning mode
+- `reviewer.chatmode.md` - Code review mode
+- `debugger.chatmode.md` - Debugging mode
+
+**Chat Mode Attribution**: When using content from awesome-copilot chatmodes, add attribution comments:
+```markdown
+<!-- Based on/Inspired by: https://github.com/github/awesome-copilot/blob/main/chatmodes/[filename].chatmode.md -->
+```
+
+### 5. `.github/workflows/` Directory
+Create Coding Agent workflow file:
+- `copilot-setup-steps.yml` - GitHub Actions workflow for Coding Agent environment setup
+
+**CRITICAL**: The workflow MUST follow this exact structure:
+- Job name MUST be `copilot-setup-steps` 
+- Include proper triggers (workflow_dispatch, push, pull_request on the workflow file)
+- Set appropriate permissions (minimum required)
+- Customize steps based on the technology stack provided
+
+## Content Guidelines
+
+For each file, follow these principles:
+
+**MANDATORY FIRST STEP**: Always use the fetch tool to research existing patterns before creating any content:
+1. **Fetch from awesome-copilot collections**: https://github.com/github/awesome-copilot/blob/main/docs/README.collections.md
+2. **Fetch specific instruction files**: https://raw.githubusercontent.com/github/awesome-copilot/main/instructions/[relevant-file].instructions.md
+3. **Check for existing patterns** that match the technology stack
+
+**Primary Approach**: Reference and adapt existing instructions from awesome-copilot repository:
+- **Use existing content** when available - don't reinvent the wheel
+- **Adapt proven patterns** to the specific project context
+- **Combine multiple examples** if the stack requires it
+- **ALWAYS add attribution comments** when using awesome-copilot content
+
+**Attribution Format**: When using content from awesome-copilot, add this comment at the top of the file:
+```markdown
+<!-- Based on/Inspired by: https://github.com/github/awesome-copilot/blob/main/instructions/[filename].instructions.md -->
+```
+
+**Examples:**
+```markdown
+<!-- Based on: https://github.com/github/awesome-copilot/blob/main/instructions/react.instructions.md -->
+---
+applyTo: "**/*.jsx,**/*.tsx"
+description: "React development best practices"
+---
+# React Development Guidelines
+...
+```
+
+```markdown
+<!-- Inspired by: https://github.com/github/awesome-copilot/blob/main/instructions/java.instructions.md -->
+<!-- and: https://github.com/github/awesome-copilot/blob/main/instructions/spring-boot.instructions.md -->
+---
+applyTo: "**/*.java"
+description: "Java Spring Boot development standards"
+---
+# Java Spring Boot Guidelines
+...
+```
+
+**Secondary Approach**: If no awesome-copilot instructions exist, create **SIMPLE GUIDELINES ONLY**:
+- **High-level principles** and best practices (2-3 sentences each)
+- **Architectural patterns** (mention patterns, not implementation)
+- **Code style preferences** (naming conventions, structure preferences)
+- **Testing strategy** (approach, not test code)
+- **Documentation standards** (format, requirements)
+
+**STRICTLY AVOID in .instructions.md files:**
+- ❌ **Writing actual code examples or snippets**
+- ❌ **Detailed implementation steps**
+- ❌ **Test cases or specific test code**
+- ❌ **Boilerplate or template code**
+- ❌ **Function signatures or class definitions**
+- ❌ **Import statements or dependency lists**
+
+**CORRECT .instructions.md content:**
+- ✅ **"Use descriptive variable names and follow camelCase"**
+- ✅ **"Prefer composition over inheritance"**
+- ✅ **"Write unit tests for all public methods"**
+- ✅ **"Use TypeScript strict mode for better type safety"**
+- ✅ **"Follow the repository's established error handling patterns"**
+
+**Research Strategy with fetch tool:**
+1. **Check awesome-copilot first** - Always start here for ALL file types
+2. **Look for exact tech stack matches** (e.g., React, Node.js, Spring Boot)
+3. **Look for general matches** (e.g., frontend chatmodes, testing prompts, review modes)
+4. **Check awesome-copilot collections** for curated sets of related files
+5. **Adapt community examples** to project needs
+6. **Only create custom content** if nothing relevant exists
+
+**Fetch these awesome-copilot directories:**
+- **Instructions**: https://github.com/github/awesome-copilot/tree/main/instructions
+- **Prompts**: https://github.com/github/awesome-copilot/tree/main/prompts  
+- **Chat Modes**: https://github.com/github/awesome-copilot/tree/main/chatmodes
+- **Collections**: https://github.com/github/awesome-copilot/blob/main/docs/README.collections.md
+
+**Awesome-Copilot Collections to Check:**
+- **Frontend Web Development**: React, Angular, Vue, TypeScript, CSS frameworks
+- **C# .NET Development**: Testing, documentation, and best practices  
+- **Java Development**: Spring Boot, Quarkus, testing, documentation
+- **Database Development**: PostgreSQL, SQL Server, and general database best practices
+- **Azure Development**: Infrastructure as Code, serverless functions
+- **Security & Performance**: Security frameworks, accessibility, performance optimization
+
+## File Structure Standards
+
+Ensure all files follow these conventions:
+
+```
+project-root/
+├── .github/
+│   ├── copilot-instructions.md
+│   ├── instructions/
+│   │   ├── [language].instructions.md
+│   │   ├── testing.instructions.md
+│   │   ├── documentation.instructions.md
+│   │   ├── security.instructions.md
+│   │   ├── performance.instructions.md
+│   │   └── code-review.instructions.md
+│   ├── prompts/
+│   │   ├── setup-component.prompt.md
+│   │   ├── write-tests.prompt.md
+│   │   ├── code-review.prompt.md
+│   │   ├── refactor-code.prompt.md
+│   │   ├── generate-docs.prompt.md
+│   │   └── debug-issue.prompt.md
+│   ├── chatmodes/
+│   │   ├── architect.chatmode.md
+│   │   ├── reviewer.chatmode.md
+│   │   └── debugger.chatmode.md
+│   └── workflows/
+│       └── copilot-setup-steps.yml
+```
+
+## YAML Frontmatter Template
+
+Use this frontmatter structure for all files:
+
+**Instructions (.instructions.md):**
+```yaml
+---
+applyTo: "**/*.ts,**/*.tsx"
+---
+# Project coding standards for TypeScript and React
+
+Apply the [general coding guidelines](./general-coding.instructions.md) to all code.
+
+## TypeScript Guidelines
+- Use TypeScript for all new code
+- Follow functional programming principles where possible
+- Use interfaces for data structures and type definitions
+- Prefer immutable data (const, readonly)
+- Use optional chaining (?.) and nullish coalescing (??) operators
+
+## React Guidelines
+- Use functional components with hooks
+- Follow the React hooks rules (no conditional hooks)
+- Use React.FC type for components with children
+- Keep components small and focused
+- Use CSS modules for component styling
+
+```
+
+**Prompts (.prompt.md):**
+```yaml
+---
+mode: 'agent'
+model: Claude Sonnet 4
+tools: ['githubRepo', 'codebase']
+description: 'Generate a new React form component'
+---
+Your goal is to generate a new React form component based on the templates in #githubRepo contoso/react-templates.
+
+Ask for the form name and fields if not provided.
+
+Requirements for the form:
+* Use form design system components: [design-system/Form.md](../docs/design-system/Form.md)
+* Use `react-hook-form` for form state management:
+* Always define TypeScript types for your form data
+* Prefer *uncontrolled* components using register
+* Use `defaultValues` to prevent unnecessary rerenders
+* Use `yup` for validation:
+* Create reusable validation schemas in separate files
+* Use TypeScript types to ensure type safety
+* Customize UX-friendly validation rules
+
+```
+
+**Chat Modes (.chatmode.md):**
+```yaml
+---
+description: Generate an implementation plan for new features or refactoring existing code.
+tools: ['codebase', 'fetch', 'findTestFiles', 'githubRepo', 'search', 'usages']
+model: Claude Sonnet 4
+---
+# Planning mode instructions
+You are in planning mode. Your task is to generate an implementation plan for a new feature or for refactoring existing code.
+Don't make any code edits, just generate a plan.
+
+The plan consists of a Markdown document that describes the implementation plan, including the following sections:
+
+* Overview: A brief description of the feature or refactoring task.
+* Requirements: A list of requirements for the feature or refactoring task.
+* Implementation Steps: A detailed list of steps to implement the feature or refactoring task.
+* Testing: A list of tests that need to be implemented to verify the feature or refactoring task.
+
+```
+
+## Execution Steps
+
+1. **Analyze the provided technology stack**
+2. **Create the directory structure**
+3. **Generate main copilot-instructions.md with project-wide standards**
+4. **Create language-specific instruction files using awesome-copilot references**
+5. **Generate reusable prompts for common development tasks**
+6. **Set up specialized chat modes for different development scenarios**
+7. **Create the GitHub Actions workflow for Coding Agent** (`copilot-setup-steps.yml`)
+8. **Validate all files follow proper formatting and include necessary frontmatter**
+
+## Post-Setup Instructions
+
+After creating all files, provide the user with:
+
+1. **VS Code setup instructions** - How to enable and configure the files
+2. **Usage examples** - How to use each prompt and chat mode
+3. **Customization tips** - How to modify files for their specific needs
+4. **Testing recommendations** - How to verify the setup works correctly
+
+## Quality Checklist
+
+Before completing, verify:
+- [ ] All files have proper YAML frontmatter
+- [ ] Language-specific best practices are included
+- [ ] Files reference each other appropriately using Markdown links
+- [ ] Prompts include relevant tools and variables
+- [ ] Instructions are comprehensive but not overwhelming
+- [ ] Security and performance considerations are addressed
+- [ ] Testing guidelines are included
+- [ ] Documentation standards are clear
+- [ ] Code review standards are defined
+
+## Workflow Template Structure
+
+The `copilot-setup-steps.yml` workflow MUST follow this exact format and KEEP IT SIMPLE:
+
+```yaml
+name: "Copilot Setup Steps"
+on:
+  workflow_dispatch:
+  push:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+  pull_request:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+jobs:
+  # The job MUST be called `copilot-setup-steps` or it will not be picked up by Copilot.
+  copilot-setup-steps:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+      # Add ONLY basic technology-specific setup steps here
+```
+
+**KEEP WORKFLOWS SIMPLE** - Only include essential steps:
+
+**Node.js/JavaScript:**
+```yaml
+- name: Set up Node.js
+  uses: actions/setup-node@v4
+  with:
+    node-version: "20"
+    cache: "npm"
+- name: Install dependencies
+  run: npm ci
+- name: Run linter
+  run: npm run lint
+- name: Run tests
+  run: npm test
+```
+
+**Python:**
+```yaml
+- name: Set up Python
+  uses: actions/setup-python@v4
+  with:
+    python-version: "3.11"
+- name: Install dependencies
+  run: pip install -r requirements.txt
+- name: Run linter
+  run: flake8 .
+- name: Run tests
+  run: pytest
+```
+
+**Java:**
+```yaml
+- name: Set up JDK
+  uses: actions/setup-java@v4
+  with:
+    java-version: "17"
+    distribution: "temurin"
+- name: Build with Maven
+  run: mvn compile
+- name: Run tests
+  run: mvn test
+```
+
+**AVOID in workflows:**
+- ❌ Complex configuration setups
+- ❌ Multiple environment configurations
+- ❌ Advanced tooling setup
+- ❌ Custom scripts or complex logic
+- ❌ Multiple package managers
+- ❌ Database setup or external services
+
+**INCLUDE only:**
+- ✅ Language/runtime setup
+- ✅ Basic dependency installation
+- ✅ Simple linting (if standard)
+- ✅ Basic test running
+- ✅ Standard build commands

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

@@ -0,0 +1,334 @@
+---
+mode: agent
+description: 'Generate a complete Go MCP server project with proper structure, dependencies, and implementation using the official github.com/modelcontextprotocol/go-sdk.'
+---
+
+# Go MCP Server Project Generator
+
+Generate a complete, production-ready Model Context Protocol (MCP) server project in Go.
+
+## Project Requirements
+
+You will create a Go MCP server with:
+
+1. **Project Structure**: Proper Go module layout
+2. **Dependencies**: Official MCP SDK and necessary packages
+3. **Server Setup**: Configured MCP server with transports
+4. **Tools**: At least 2-3 useful tools with typed inputs/outputs
+5. **Error Handling**: Proper error handling and context usage
+6. **Documentation**: README with setup and usage instructions
+7. **Testing**: Basic test structure
+
+## Template Structure
+
+```
+myserver/
+├── go.mod
+├── go.sum
+├── main.go
+├── tools/
+│   ├── tool1.go
+│   └── tool2.go
+├── resources/
+│   └── resource1.go
+├── config/
+│   └── config.go
+├── README.md
+└── main_test.go
+```
+
+## go.mod Template
+
+```go
+module github.com/yourusername/{{PROJECT_NAME}}
+
+go 1.23
+
+require (
+    github.com/modelcontextprotocol/go-sdk v1.0.0
+)
+```
+
+## main.go Template
+
+```go
+package main
+
+import (
+    "context"
+    "log"
+    "os"
+    "os/signal"
+    "syscall"
+
+    "github.com/modelcontextprotocol/go-sdk/mcp"
+    "github.com/yourusername/{{PROJECT_NAME}}/config"
+    "github.com/yourusername/{{PROJECT_NAME}}/tools"
+)
+
+func main() {
+    cfg := config.Load()
+    
+    ctx, cancel := context.WithCancel(context.Background())
+    defer cancel()
+
+    // Handle graceful shutdown
+    sigCh := make(chan os.Signal, 1)
+    signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
+    go func() {
+        <-sigCh
+        log.Println("Shutting down...")
+        cancel()
+    }()
+
+    // Create server
+    server := mcp.NewServer(
+        &mcp.Implementation{
+            Name:    cfg.ServerName,
+            Version: cfg.Version,
+        },
+        &mcp.Options{
+            Capabilities: &mcp.ServerCapabilities{
+                Tools:     &mcp.ToolsCapability{},
+                Resources: &mcp.ResourcesCapability{},
+                Prompts:   &mcp.PromptsCapability{},
+            },
+        },
+    )
+
+    // Register tools
+    tools.RegisterTools(server)
+
+    // Run server
+    transport := &mcp.StdioTransport{}
+    if err := server.Run(ctx, transport); err != nil {
+        log.Fatalf("Server error: %v", err)
+    }
+}
+```
+
+## tools/tool1.go Template
+
+```go
+package tools
+
+import (
+    "context"
+    "fmt"
+
+    "github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+type Tool1Input struct {
+    Param1 string `json:"param1" jsonschema:"required,description=First parameter"`
+    Param2 int    `json:"param2,omitempty" jsonschema:"description=Optional second parameter"`
+}
+
+type Tool1Output struct {
+    Result string `json:"result" jsonschema:"description=The result of the operation"`
+    Status string `json:"status" jsonschema:"description=Operation status"`
+}
+
+func Tool1Handler(ctx context.Context, req *mcp.CallToolRequest, input Tool1Input) (
+    *mcp.CallToolResult,
+    Tool1Output,
+    error,
+) {
+    // Validate input
+    if input.Param1 == "" {
+        return nil, Tool1Output{}, fmt.Errorf("param1 is required")
+    }
+
+    // Check context
+    if ctx.Err() != nil {
+        return nil, Tool1Output{}, ctx.Err()
+    }
+
+    // Perform operation
+    result := fmt.Sprintf("Processed: %s", input.Param1)
+
+    return nil, Tool1Output{
+        Result: result,
+        Status: "success",
+    }, nil
+}
+
+func RegisterTool1(server *mcp.Server) {
+    mcp.AddTool(server,
+        &mcp.Tool{
+            Name:        "tool1",
+            Description: "Description of what tool1 does",
+        },
+        Tool1Handler,
+    )
+}
+```
+
+## tools/registry.go Template
+
+```go
+package tools
+
+import "github.com/modelcontextprotocol/go-sdk/mcp"
+
+func RegisterTools(server *mcp.Server) {
+    RegisterTool1(server)
+    RegisterTool2(server)
+    // Register additional tools here
+}
+```
+
+## config/config.go Template
+
+```go
+package config
+
+import "os"
+
+type Config struct {
+    ServerName string
+    Version    string
+    LogLevel   string
+}
+
+func Load() *Config {
+    return &Config{
+        ServerName: getEnv("SERVER_NAME", "{{PROJECT_NAME}}"),
+        Version:    getEnv("VERSION", "v1.0.0"),
+        LogLevel:   getEnv("LOG_LEVEL", "info"),
+    }
+}
+
+func getEnv(key, defaultValue string) string {
+    if value := os.Getenv(key); value != "" {
+        return value
+    }
+    return defaultValue
+}
+```
+
+## main_test.go Template
+
+```go
+package main
+
+import (
+    "context"
+    "testing"
+
+    "github.com/yourusername/{{PROJECT_NAME}}/tools"
+)
+
+func TestTool1Handler(t *testing.T) {
+    ctx := context.Background()
+    input := tools.Tool1Input{
+        Param1: "test",
+        Param2: 42,
+    }
+
+    result, output, err := tools.Tool1Handler(ctx, nil, input)
+    if err != nil {
+        t.Fatalf("Tool1Handler failed: %v", err)
+    }
+
+    if output.Status != "success" {
+        t.Errorf("Expected status 'success', got '%s'", output.Status)
+    }
+
+    if result != nil {
+        t.Error("Expected result to be nil")
+    }
+}
+```
+
+## README.md Template
+
+```markdown
+# {{PROJECT_NAME}}
+
+A Model Context Protocol (MCP) server built with Go.
+
+## Description
+
+{{PROJECT_DESCRIPTION}}
+
+## Installation
+
+\`\`\`bash
+go mod download
+go build -o {{PROJECT_NAME}}
+\`\`\`
+
+## Usage
+
+Run the server with stdio transport:
+
+\`\`\`bash
+./{{PROJECT_NAME}}
+\`\`\`
+
+## Configuration
+
+Configure via environment variables:
+
+- `SERVER_NAME`: Server name (default: "{{PROJECT_NAME}}")
+- `VERSION`: Server version (default: "v1.0.0")
+- `LOG_LEVEL`: Logging level (default: "info")
+
+## Available Tools
+
+### tool1
+{{TOOL1_DESCRIPTION}}
+
+**Input:**
+- `param1` (string, required): First parameter
+- `param2` (int, optional): Second parameter
+
+**Output:**
+- `result` (string): Operation result
+- `status` (string): Status of the operation
+
+## Development
+
+Run tests:
+
+\`\`\`bash
+go test ./...
+\`\`\`
+
+Build:
+
+\`\`\`bash
+go build -o {{PROJECT_NAME}}
+\`\`\`
+
+## License
+
+MIT
+```
+
+## Generation Instructions
+
+When generating a Go MCP server:
+
+1. **Initialize Module**: Create `go.mod` with proper module path
+2. **Structure**: Follow the template directory structure
+3. **Type Safety**: Use structs with JSON schema tags for all inputs/outputs
+4. **Error Handling**: Validate inputs, check context, wrap errors
+5. **Documentation**: Add clear descriptions and examples
+6. **Testing**: Include at least one test per tool
+7. **Configuration**: Use environment variables for config
+8. **Logging**: Use structured logging (log/slog)
+9. **Graceful Shutdown**: Handle signals properly
+10. **Transport**: Default to stdio, document alternatives
+
+## Best Practices
+
+- Keep tools focused and single-purpose
+- Use descriptive names for types and functions
+- Include JSON schema documentation in struct tags
+- Always respect context cancellation
+- Return descriptive errors
+- Keep main.go minimal, logic in packages
+- Write tests for tool handlers
+- Document all exported functions