workspace-architect 1.3.0

package/assets/prompts/dotnet-best-practices.prompt.md

@@ -0,0 +1,84 @@
+---
+mode: 'agent'
+description: 'Ensure .NET/C# code meets best practices for the solution/project.'
+---
+# .NET/C# Best Practices
+
+Your task is to ensure .NET/C# code in ${selection} meets the best practices specific to this solution/project. This includes:
+
+## Documentation & Structure
+
+- Create comprehensive XML documentation comments for all public classes, interfaces, methods, and properties
+- Include parameter descriptions and return value descriptions in XML comments
+- Follow the established namespace structure: {Core|Console|App|Service}.{Feature}
+
+## Design Patterns & Architecture
+
+- Use primary constructor syntax for dependency injection (e.g., `public class MyClass(IDependency dependency)`)
+- Implement the Command Handler pattern with generic base classes (e.g., `CommandHandler<TOptions>`)
+- Use interface segregation with clear naming conventions (prefix interfaces with 'I')
+- Follow the Factory pattern for complex object creation.
+
+## Dependency Injection & Services
+
+- Use constructor dependency injection with null checks via ArgumentNullException
+- Register services with appropriate lifetimes (Singleton, Scoped, Transient)
+- Use Microsoft.Extensions.DependencyInjection patterns
+- Implement service interfaces for testability
+
+## Resource Management & Localization
+
+- Use ResourceManager for localized messages and error strings
+- Separate LogMessages and ErrorMessages resource files
+- Access resources via `_resourceManager.GetString("MessageKey")`
+
+## Async/Await Patterns
+
+- Use async/await for all I/O operations and long-running tasks
+- Return Task or Task<T> from async methods
+- Use ConfigureAwait(false) where appropriate
+- Handle async exceptions properly
+
+## Testing Standards
+
+- Use MSTest framework with FluentAssertions for assertions
+- Follow AAA pattern (Arrange, Act, Assert)
+- Use Moq for mocking dependencies
+- Test both success and failure scenarios
+- Include null parameter validation tests
+
+## Configuration & Settings
+
+- Use strongly-typed configuration classes with data annotations
+- Implement validation attributes (Required, NotEmptyOrWhitespace)
+- Use IConfiguration binding for settings
+- Support appsettings.json configuration files
+
+## Semantic Kernel & AI Integration
+
+- Use Microsoft.SemanticKernel for AI operations
+- Implement proper kernel configuration and service registration
+- Handle AI model settings (ChatCompletion, Embedding, etc.)
+- Use structured output patterns for reliable AI responses
+
+## Error Handling & Logging
+
+- Use structured logging with Microsoft.Extensions.Logging
+- Include scoped logging with meaningful context
+- Throw specific exceptions with descriptive messages
+- Use try-catch blocks for expected failure scenarios
+
+## Performance & Security
+
+- Use C# 12+ features and .NET 8 optimizations where applicable
+- Implement proper input validation and sanitization
+- Use parameterized queries for database operations
+- Follow secure coding practices for AI/ML operations
+
+## Code Quality
+
+- Ensure SOLID principles compliance
+- Avoid code duplication through base classes and utilities
+- Use meaningful names that reflect domain concepts
+- Keep methods focused and cohesive
+- Implement proper disposal patterns for resources

package/assets/prompts/dotnet-design-pattern-review.prompt.md

@@ -0,0 +1,41 @@
+---
+mode: 'agent'
+description: 'Review the C#/.NET code for design pattern implementation and suggest improvements.'
+---
+# .NET/C# Design Pattern Review
+
+Review the C#/.NET code in ${selection} for design pattern implementation and suggest improvements for the solution/project. Do not make any changes to the code, just provide a review.
+
+## Required Design Patterns
+
+- **Command Pattern**: Generic base classes (`CommandHandler<TOptions>`), `ICommandHandler<TOptions>` interface, `CommandHandlerOptions` inheritance, static `SetupCommand(IHost host)` methods
+- **Factory Pattern**: Complex object creation service provider integration
+- **Dependency Injection**: Primary constructor syntax, `ArgumentNullException` null checks, interface abstractions, proper service lifetimes
+- **Repository Pattern**: Async data access interfaces provider abstractions for connections
+- **Provider Pattern**: External service abstractions (database, AI), clear contracts, configuration handling
+- **Resource Pattern**: ResourceManager for localized messages, separate .resx files (LogMessages, ErrorMessages)
+
+## Review Checklist
+
+- **Design Patterns**: Identify patterns used. Are Command Handler, Factory, Provider, and Repository patterns correctly implemented? Missing beneficial patterns?
+- **Architecture**: Follow namespace conventions (`{Core|Console|App|Service}.{Feature}`)? Proper separation between Core/Console projects? Modular and readable?
+- **.NET Best Practices**: Primary constructors, async/await with Task returns, ResourceManager usage, structured logging, strongly-typed configuration?
+- **GoF Patterns**: Command, Factory, Template Method, Strategy patterns correctly implemented?
+- **SOLID Principles**: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion violations?
+- **Performance**: Proper async/await, resource disposal, ConfigureAwait(false), parallel processing opportunities?
+- **Maintainability**: Clear separation of concerns, consistent error handling, proper configuration usage?
+- **Testability**: Dependencies abstracted via interfaces, mockable components, async testability, AAA pattern compatibility?
+- **Security**: Input validation, secure credential handling, parameterized queries, safe exception handling?
+- **Documentation**: XML docs for public APIs, parameter/return descriptions, resource file organization?
+- **Code Clarity**: Meaningful names reflecting domain concepts, clear intent through patterns, self-explanatory structure?
+- **Clean Code**: Consistent style, appropriate method/class size, minimal complexity, eliminated duplication?
+
+## Improvement Focus Areas
+
+- **Command Handlers**: Validation in base class, consistent error handling, proper resource management
+- **Factories**: Dependency configuration, service provider integration, disposal patterns
+- **Providers**: Connection management, async patterns, exception handling and logging
+- **Configuration**: Data annotations, validation attributes, secure sensitive value handling
+- **AI/ML Integration**: Semantic Kernel patterns, structured output handling, model configuration
+
+Provide specific, actionable recommendations for improvements aligned with the project's architecture and .NET best practices.

package/assets/prompts/dotnet-upgrade.prompt.md

@@ -0,0 +1,116 @@
+---
+name: ".NET Upgrade Analysis Prompts"
+description: "Ready-to-use prompts for comprehensive .NET framework upgrade analysis and execution"
+prompts:
+---
+  # Project Discovery & Assessment
+  - name: "Project Classification Analysis"
+    prompt: "Identify all projects in the solution and classify them by type (`.NET Framework`, `.NET Core`, `.NET Standard`). Analyze each `.csproj` for its current `TargetFramework` and SDK usage."
+  
+  - name: "Dependency Compatibility Review"
+    prompt: "Review external and internal dependencies for framework compatibility. Determine the upgrade complexity based on dependency graph depth."
+  
+  - name: "Legacy Package Detection"
+    prompt: "Identify legacy `packages.config` projects needing migration to `PackageReference` format."
+
+  # Upgrade Strategy & Sequencing
+  - name: "Project Upgrade Ordering"
+    prompt: "Recommend a project upgrade order from least to most dependent components. Suggest how to isolate class library upgrades before API or Azure Function migrations."
+  
+  - name: "Incremental Strategy Planning"
+    prompt: "Propose an incremental upgrade strategy with rollback checkpoints. Evaluate the use of **Upgrade Assistant** or **manual upgrades** based on project structure."
+  
+  - name: "Progress Tracking Setup"
+    prompt: "Generate an upgrade checklist for tracking build, test, and deployment readiness across all projects."
+
+  # Framework Targeting & Code Adjustments
+  - name: "Target Framework Selection"
+    prompt: "Suggest the correct `TargetFramework` for each project (e.g., `net8.0`). Review and update deprecated SDK or build configurations."
+  
+  - name: "Code Modernization Analysis"
+    prompt: "Identify code patterns needing modernization (e.g., `WebHostBuilder` → `HostBuilder`). Suggest replacements for deprecated .NET APIs and third-party libraries."
+  
+  - name: "Async Pattern Conversion"
+    prompt: "Recommend conversion of synchronous calls to async where appropriate for improved performance and scalability."
+
+  # NuGet & Dependency Management
+  - name: "Package Compatibility Analysis"
+    prompt: "Analyze outdated or incompatible NuGet packages and suggest compatible versions. Identify third-party libraries that lack .NET 8 support and provide migration paths."
+  
+  - name: "Shared Dependency Strategy"
+    prompt: "Recommend strategies for handling shared dependency upgrades across projects. Evaluate usage of legacy packages and suggest alternatives in Microsoft-supported namespaces."
+  
+  - name: "Transitive Dependency Review"
+    prompt: "Review transitive dependencies and potential version conflicts after upgrade. Suggest resolution strategies for dependency conflicts."
+
+  # CI/CD & Build Pipeline Updates
+  - name: "Pipeline Configuration Analysis"
+    prompt: "Analyze YAML build definitions for SDK version pinning and recommend updates. Suggest modifications for `UseDotNet@2` and `NuGetToolInstaller` tasks."
+  
+  - name: "Build Pipeline Modernization"
+    prompt: "Generate updated build pipeline snippets for .NET 8 migration. Recommend validation builds on feature branches before merging to main."
+  
+  - name: "CI Automation Enhancement"
+    prompt: "Identify opportunities to automate test and build verification in CI pipelines. Suggest strategies for continuous integration validation."
+
+  # Testing & Validation
+  - name: "Build Validation Strategy"
+    prompt: "Propose validation checks to ensure the upgraded solution builds and runs successfully. Recommend automated test execution for unit and integration suites post-upgrade."
+  
+  - name: "Service Integration Verification"
+    prompt: "Generate validation steps to verify logging, telemetry, and service connectivity. Suggest strategies for verifying backward compatibility and runtime behavior."
+  
+  - name: "Deployment Readiness Check"
+    prompt: "Recommend UAT deployment verification steps before production rollout. Create comprehensive testing scenarios for upgraded components."
+
+  # Breaking Change Analysis
+  - name: "API Deprecation Detection"
+    prompt: "Identify deprecated APIs or removed namespaces between target versions. Suggest automated scanning using `.NET Upgrade Assistant` and API Analyzer."
+  
+  - name: "API Replacement Strategy"
+    prompt: "Recommend replacement APIs or libraries for known breaking areas. Review configuration changes such as `Startup.cs` → `Program.cs` refactoring."
+  
+  - name: "Regression Testing Focus"
+    prompt: "Suggest regression testing scenarios focused on upgraded API endpoints or services. Create test plans for critical functionality validation."
+
+  # Version Control & Commit Strategy
+  - name: "Branching Strategy Planning"
+    prompt: "Recommend branching strategy for safe upgrade with rollback capability. Generate commit templates for partial and complete project upgrades."
+  
+  - name: "PR Structure Optimization"
+    prompt: "Suggest best practices for creating structured PRs (`Upgrade to .NET [Version]`). Identify tagging strategies for PRs involving breaking changes."
+  
+  - name: "Code Review Guidelines"
+    prompt: "Recommend peer review focus areas (build, test, and dependency validation). Create checklists for effective upgrade reviews."
+
+  # Documentation & Communication
+  - name: "Upgrade Documentation Strategy"
+    prompt: "Suggest how to document each project's framework change in the PR. Propose automated release note generation summarizing upgrades and test results."
+  
+  - name: "Stakeholder Communication"
+    prompt: "Recommend communicating version upgrades and migration timelines to consumers. Generate documentation templates for dependency updates and validation results."
+  
+  - name: "Progress Tracking Systems"
+    prompt: "Suggest maintaining an upgrade summary dashboard or markdown checklist. Create templates for tracking upgrade progress across multiple projects."
+
+  # Tools & Automation
+  - name: "Upgrade Tool Selection"
+    prompt: "Recommend when and how to use: `.NET Upgrade Assistant`, `dotnet list package --outdated`, `dotnet migrate`, and `graph.json` dependency visualization."
+  
+  - name: "Analysis Script Generation"
+    prompt: "Generate scripts or prompts for analyzing dependency graphs before upgrading. Propose AI-assisted prompts for Copilot to identify upgrade issues automatically."
+  
+  - name: "Multi-Repository Validation"
+    prompt: "Suggest how to validate automation output across multiple repositories. Create standardized validation workflows for enterprise-scale upgrades."
+
+  # Final Validation & Delivery
+  - name: "Final Solution Validation"
+    prompt: "Generate validation steps to confirm the final upgraded solution passes all validation checks. Suggest production deployment verification steps post-upgrade."
+  
+  - name: "Deployment Readiness Confirmation"
+    prompt: "Recommend generating final test results and build artifacts. Create a checklist summarizing completion across projects (builds/tests/deployment)."
+  
+  - name: "Release Documentation"
+    prompt: "Generate a release note summarizing framework changes and CI/CD updates. Create comprehensive upgrade summary documentation."
+
+---

package/assets/prompts/editorconfig.prompt.md

@@ -0,0 +1,64 @@
+---
+title: 'EditorConfig Expert'
+description: 'Generates a comprehensive and best-practice-oriented .editorconfig file based on project analysis and user preferences.'
+mode: 'agent'
+---
+
+## 📜 MISSION
+
+You are an **EditorConfig Expert**. Your mission is to create a robust, comprehensive, and best-practice-oriented `.editorconfig` file. You will analyze the user's project structure and explicit requirements to generate a configuration that ensures consistent coding styles across different editors and IDEs. You must operate with absolute precision and provide clear, rule-by-rule explanations for your configuration choices.
+
+## 📝 DIRECTIVES
+
+1.  **Analyze Context**: Before generating the configuration, you MUST analyze the provided project structure and file types to infer the languages and technologies being used.
+2.  **Incorporate User Preferences**: You MUST adhere to all explicit user requirements. If any requirement conflicts with a common best practice, you will still follow the user's preference but make a note of the conflict in your explanation.
+3.  **Apply Universal Best Practices**: You WILL go beyond the user's basic requirements and incorporate universal best practices for `.editorconfig` files. This includes settings for character sets, line endings, trailing whitespace, and final newlines.
+4.  **Generate Comprehensive Configuration**: The generated `.editorconfig` file MUST be well-structured and cover all relevant file types found in the project. Use glob patterns (`*`, `**.js`, `**.py`, etc.) to apply settings appropriately.
+5.  **Provide Rule-by-Rule Explanation**: You MUST provide a detailed, clear, and easy-to-understand explanation for every single rule in the generated `.editorconfig` file. Explain what the rule does and why it's a best practice.
+6.  **Output Format**: The final output MUST be presented in two parts:
+    - A single, complete code block containing the `.editorconfig` file content.
+    - A "Rule-by-Rule Explanation" section using Markdown for clarity.
+
+## 🧑‍💻 USER PREFERENCES
+
+- **Indentation Style**: Use spaces, not tabs.
+- **Indentation Size**: 2 spaces.
+
+## 🚀 EXECUTION
+
+Begin by acknowledging the user's preferences. Then, proceed directly to generating the `.editorconfig` file and the detailed explanation as per the specified output format.
+
+### Example Output Structure:
+
+Here is the `.editorconfig` file tailored to your project:
+
+```editorconfig
+# .editorconfig
+
+# Top-most EditorConfig file
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+```
+
+### Rule-by-Rule Explanation
+
+- `root = true`: This is a best practice that stops the EditorConfig search in the current directory. Without it, EditorConfig would continue searching parent directories, which could lead to unexpected behavior.
+- `[*]`: This is a universal glob pattern that applies the following rules to ALL files in the project.
+- `indent_style = space`: As requested, this sets the indentation to use spaces instead of tabs.
+- `indent_size = 2`: As requested, this sets the indentation size to 2 spaces.
+- `end_of_line = lf`: This standardizes line endings to Line Feed (LF), which is the standard for macOS, Linux, and modern Windows (WSL), preventing issues with version control systems.
+- `charset = utf-8`: This sets the character encoding to UTF-8, the universal standard, ensuring files can be read and written correctly across all systems.
+- `trim_trailing_whitespace = true`: This automatically removes any whitespace characters at the end of lines, which keeps the code clean and avoids unnecessary diffs in version control.
+- `insert_final_newline = true`: This ensures that every file ends with a single newline character, a POSIX standard that prevents certain scripting and concatenation issues.
+- `[*.md]`: This glob pattern applies specific rules only to Markdown files.
+- `trim_trailing_whitespace = false`: This overrides the universal setting for Markdown files. It's disabled because trailing whitespace can be significant in Markdown (e.g., for creating hard line breaks).

package/assets/prompts/ef-core.prompt.md

@@ -0,0 +1,76 @@
+---
+mode: 'agent'
+tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems', 'runCommands']
+description: 'Get best practices for Entity Framework Core'
+---
+
+# Entity Framework Core Best Practices
+
+Your goal is to help me follow best practices when working with Entity Framework Core.
+
+## Data Context Design
+
+- Keep DbContext classes focused and cohesive
+- Use constructor injection for configuration options
+- Override OnModelCreating for fluent API configuration
+- Separate entity configurations using IEntityTypeConfiguration
+- Consider using DbContextFactory pattern for console apps or tests
+
+## Entity Design
+
+- Use meaningful primary keys (consider natural vs surrogate keys)
+- Implement proper relationships (one-to-one, one-to-many, many-to-many)
+- Use data annotations or fluent API for constraints and validations
+- Implement appropriate navigational properties
+- Consider using owned entity types for value objects
+
+## Performance
+
+- Use AsNoTracking() for read-only queries
+- Implement pagination for large result sets with Skip() and Take()
+- Use Include() to eager load related entities when needed
+- Consider projection (Select) to retrieve only required fields
+- Use compiled queries for frequently executed queries
+- Avoid N+1 query problems by properly including related data
+
+## Migrations
+
+- Create small, focused migrations
+- Name migrations descriptively
+- Verify migration SQL scripts before applying to production
+- Consider using migration bundles for deployment
+- Add data seeding through migrations when appropriate
+
+## Querying
+
+- Use IQueryable judiciously and understand when queries execute
+- Prefer strongly-typed LINQ queries over raw SQL
+- Use appropriate query operators (Where, OrderBy, GroupBy)
+- Consider database functions for complex operations
+- Implement specifications pattern for reusable queries
+
+## Change Tracking & Saving
+
+- Use appropriate change tracking strategies
+- Batch your SaveChanges() calls
+- Implement concurrency control for multi-user scenarios
+- Consider using transactions for multiple operations
+- Use appropriate DbContext lifetimes (scoped for web apps)
+
+## Security
+
+- Avoid SQL injection by using parameterized queries
+- Implement appropriate data access permissions
+- Be careful with raw SQL queries
+- Consider data encryption for sensitive information
+- Use migrations to manage database user permissions
+
+## Testing
+
+- Use in-memory database provider for unit tests
+- Create separate testing contexts with SQLite for integration tests
+- Mock DbContext and DbSet for pure unit tests
+- Test migrations in isolated environments
+- Consider snapshot testing for model changes
+
+When reviewing my EF Core code, identify issues and suggest improvements that follow these best practices.

package/assets/prompts/finalize-agent-prompt.prompt.md

@@ -0,0 +1,27 @@
+---
+mode: 'agent'
+description: 'Finalize prompt file using the role of an AI agent to polish the prompt for the end user.'
+tools: ['edit/editFiles']
+---
+
+# Finalize Agent Prompt
+
+## Current Role
+
+You are an AI agent who knows what works best for the prompt files you have
+seen and the feedback you have received. Apply that experience to refine the
+current prompt so it aligns with proven best practices.
+
+## Requirements
+
+- A prompt file must be provided. If none accompanies the request, ask for the
+  file before proceeding.
+- Maintain the prompt’s front matter, encoding, and markdown structure while
+  making improvements.
+
+## Goal
+
+1. Read the prompt file carefully and refine its structure, wording, and
+   organization to match the successful patterns you have observed.
+2. Check for spelling, grammar, or clarity issues and correct them without
+   changing the original intent of the instructions.

package/assets/prompts/first-ask.prompt.md

@@ -0,0 +1,29 @@
+---
+description: 'Interactive, input-tool powered, task refinement workflow: interrogates scope, deliverables, constraints before carrying out the task; Requires the Joyride extension.'
+---
+
+# Act Informed: First understand together with the human, then do
+
+You are a curious and thorough AI assistant designed to help carry out tasks with high-quality, by being properly informed. You are powered by the `joyride_request_human_input` tool and you use it as a key part of your process in gathering information about the task.
+
+<refining>
+Your goal is to iteratively refine your understanding of the task by:
+
+- Understanding the task scope and objectives
+- At all times when you need clarification on details, ask specific questions to the user using the `joyride_request_human_input` tool.
+- Defining expected deliverables and success criteria
+- Perform project explorations, using available tools, to further your understanding of the task
+  - If something needs web research, do that
+- Clarifying technical and procedural requirements
+- Organizing the task into clear sections or steps
+- Ensuring your understanding of the task is as simple as it can be
+</refining>
+
+After refining and before carrying out the task:
+- Use the `joyride_request_human_input` tool to ask if the human developer has any further input.
+- Keep refining until the human has no further input.
+
+After gathering sufficient information, and having a clear understanding of the task:
+1. Show your plan to the user with redundancy kept to a minimum
+2. Create a todo list
+3. Get to work!