workspace-architect 1.3.0

package/assets/instructions/copilot-thought-logging.instructions.md

@@ -0,0 +1,62 @@
+---
+applyTo: '**'
+description: 'See process Copilot is following where you can edit this to reshape the interaction or save when follow up may be needed'
+---
+
+# Copilot Process tracking Instructions
+
+**ABSOLUTE MANDATORY RULES:**
+- You must review these instructions in full before executing any steps to understand the full instructions guidelines.
+- You must follow these instructions exactly as specified without deviation.
+- Do not keep repeating status updates while processing or explanations unless explicitly required. This is bad and will flood Copilot session context.
+- NO phase announcements (no "# Phase X" headers in output)
+- Phases must be executed one at a time and in the exact order specified.
+- NO combining of phases in one response
+- NO skipping of phases
+- NO verbose explanations or commentary
+- Only output the exact text specified in phase instructions
+
+# Phase 1: Initialization
+
+- Create file `\Copilot-Processing.md` in workspace root
+- Populate `\Copilot-Processing.md` with user request details
+- Work silently without announcements until complete.
+- When this phase is complete keep mental note of this that <Phase 1> is done and does not need to be repeated.
+
+# Phase 2: Planning
+
+- Generate an action plan into the `\Copilot-Processing.md` file.
+- Generate detailed and granular task specific action items to be used for tracking each action plan item with todo/complete status in the file `\Copilot-Processing.md`.
+- This should include:
+  - Specific tasks for each action item in the action plan as a phase.
+  - Clear descriptions of what needs to be done
+  - Any dependencies or prerequisites for each task
+  - Ensure tasks are granular enough to be executed one at a time
+- Work silently without announcements until complete.
+- When this phase is complete keep mental note of this that <Phase 2> is done and does not need to be repeated.
+
+# Phase 3: Execution
+
+- Execute action items from the action plan in logical groupings/phases
+- Work silently without announcements until complete.
+- Update file `\Copilot-Processing.md` and mark the action item(s) as complete in the tracking.
+- When a phase is complete keep mental note of this that the specific phase from `\Copilot-Processing.md` is done and does not need to be repeated.
+- Repeat this pattern until all action items are complete
+
+# Phase 4: Summary
+
+- Add summary to `\Copilot-Processing.md`
+- Work silently without announcements until complete.
+- Execute only when ALL actions complete
+- Inform user: "Added final summary to `\Copilot-Processing.md`."
+- Remind user to review the summary and confirm completion of the process then to remove the file when done so it is not added to the repository.
+
+**ENFORCEMENT RULES:**
+- NEVER write "# Phase X" headers in responses
+- NEVER repeat the word "Phase" in output unless explicitly required
+- NEVER provide explanations beyond the exact text specified
+- NEVER combine multiple phases in one response
+- NEVER continue past current phase without user input
+- If you catch yourself being verbose, STOP and provide only required output
+- If you catch yourself about to skip a phase, STOP and go back to the correct phase
+- If you catch yourself combining phases, STOP and perform only the current phase

package/assets/instructions/csharp-ja.instructions.md

@@ -0,0 +1,114 @@
+---
+description: 'C# アプリケーション構築指針 by @tsubakimoto'
+applyTo: '**/*.cs'
+---
+
+# C# アプリケーション開発
+
+## C# の指針
+- 常に最新の C# を使用します。現在は C# 14 の機能です。
+- 各関数に対して明確で簡潔なコメントを書きます。
+
+## 全般ガイドライン
+- コード変更のレビューでは、確信度の高い提案のみを行います。
+- なぜその設計判断をしたのかという理由を含むコメントなど、保守性の高い実践に沿ってコードを書きます。
+- エッジケースに対応し、明確な例外処理を書きます。
+- ライブラリや外部依存については、用途と目的をコメントで明記します。
+
+## 命名規則
+
+- コンポーネント名、メソッド名、公開メンバーには PascalCase を使用します。
+- プライベートフィールドとローカル変数には camelCase を使用します。
+- インターフェイス名は "I" を接頭辞にします（例: IUserService）。
+
+## フォーマット
+
+- `.editorconfig` で定義されたコードフォーマットスタイルを適用します。
+- ファイルスコープの namespace 宣言と 1 行の using ディレクティブを推奨します。
+- 任意のコード ブロック（if、for、while、foreach、using、try など）の開始波括弧の前に改行を入れます。
+- メソッドの最終 return 文は独立した行に配置します。
+- 可能な限りパターンマッチングと switch 式を使用します。
+- メンバー名参照には文字列リテラルではなく `nameof` を使用します。
+- すべての公開 API に XML ドキュメントコメントを作成します。可能であれば `<example>` と `<code>` も含めます。
+
+## プロジェクトのセットアップと構成
+
+- 適切なテンプレートで新規 .NET プロジェクトを作成する手順を案内します。
+- 生成される各ファイルとフォルダーの目的を説明し、プロジェクト構造の理解を助けます。
+- フィーチャーフォルダーやドメイン駆動設計（DDD）による整理方法を示します。
+- モデル、サービス、データ アクセス層による責務分離を示します。
+- ASP.NET Core 10 における Program.cs と構成システム、そして環境別設定を説明します。
+
+## Nullable 参照型
+
+- 変数は非 null で宣言し、エントリポイントで `null` を検査します。
+- `== null` や `!= null` ではなく、常に `is null` または `is not null` を使用します。
+- C# の null 注釈を信頼し、型システムが値の非 null を保証している場合は不要な null チェックを追加しません。
+
+## データ アクセス パターン
+
+- Entity Framework Core を用いたデータアクセス層の実装を案内します。
+- 開発および本番における選択肢（SQL Server、SQLite、In-Memory）を説明します。
+- リポジトリパターンの実装と、それが有効となる場面を示します。
+- データベースマイグレーションとデータシーディングの実装方法を示します。
+- 一般的なパフォーマンス問題を避ける効率的なクエリパターンを説明します。
+
+## 認証と認可
+
+- JWT ベアラートークンを用いた認証の実装を案内します。
+- ASP.NET Core に関連する OAuth 2.0 および OpenID Connect の概念を説明します。
+- ロールベースおよびポリシーベースの認可の実装方法を示します。
+- Microsoft Entra ID（旧 Azure AD）との統合を示します。
+- コントローラーベース API と Minimal API の双方を一貫して保護する方法を説明します。
+
+## 検証とエラー処理
+
+- データ注釈と FluentValidation を用いたモデル検証の実装を案内します。
+- 検証パイプラインと、検証応答のカスタマイズ方法を説明します。
+- ミドルウェアを用いたグローバル例外処理戦略を示します。
+- API 全体で一貫したエラー応答を作成する方法を示します。
+- 標準化されたエラー応答のための Problem Details（RFC 7807）の実装を説明します。
+
+## API のバージョニングとドキュメント
+
+- API バージョニング戦略の実装とその解説を案内します。
+- 適切なドキュメントを伴う Swagger / OpenAPI の実装を示します。
+- エンドポイント、パラメーター、応答、認証の文書化方法を示します。
+- コントローラーベース API と Minimal API の双方でのバージョニングを説明します。
+- 利用者に役立つ有意義な API ドキュメントの作成を案内します。
+
+## ロギングと監視
+
+- Serilog などを用いた構造化ロギングの実装を案内します。
+- ログレベルと、それぞれを使用すべき場面を説明します。
+- テレメトリ収集のための Application Insights との統合を示します。
+- リクエスト追跡のためのカスタムテレメトリと相関 ID の実装方法を示します。
+- API のパフォーマンス、エラー、利用パターンの監視方法を説明します。
+
+## テスト
+
+- アプリケーションの重要な経路には必ずテストケースを含めます。
+- 単体テストの作成を案内します。
+- "Act"、"Arrange"、"Assert" のコメントは記述しません。
+- 近傍ファイルの既存スタイル（テストメソッド名や大文字/小文字）に合わせます。
+- API エンドポイントの統合テスト手法を説明します。
+- 効率的なテストのために依存関係をモックする方法を示します。
+- 認証および認可ロジックのテスト方法を示します。
+- API 開発に適用するテスト駆動開発（TDD）の原則を説明します。
+
+## パフォーマンス最適化
+
+- キャッシュ戦略（インメモリ、分散、レスポンスキャッシュ）の実装を案内します。
+- 非同期プログラミングパターンと、それが API のパフォーマンスにおいて重要である理由を説明します。
+- 大規模データセット向けのページング、フィルタリング、ソートを示します。
+- 圧縮などのパフォーマンス最適化の実装方法を示します。
+- API パフォーマンスの測定とベンチマーク方法を説明します。
+
+## デプロイと DevOps
+
+- .NET の組み込みコンテナーサポート（`dotnet publish --os linux --arch x64 -p:PublishProfile=DefaultContainer`）を用いた API のコンテナー化を案内します。
+- 手動で Dockerfile を作成する方法と、.NET のコンテナー公開機能の違いを説明します。
+- .NET アプリケーション向け CI/CD パイプラインを説明します。
+- Azure App Service、Azure Container Apps、その他のホスティングオプションへのデプロイを示します。
+- ヘルスチェックと Readiness Probe の実装方法を示します。
+- 各デプロイ段階における環境固有の構成を説明します。

package/assets/instructions/csharp-ko.instructions.md

@@ -0,0 +1,77 @@
+---
+description: 'C# 애플리케이션 개발을 위한 코드 작성 규칙 by @jgkim999'
+applyTo: '**/*.cs'
+---
+
+# C# 코드 작성 규칙
+
+## 명명 규칙 (Naming Conventions)
+
+일관된 명명 규칙은 코드 가독성의 핵심입니다. Microsoft의 가이드라인을 따르는 것을 권장합니다.
+
+| 요소 | 명명 규칙 | 예시 |
+|------|-----------|------|
+| 인터페이스 | 접두사 'I' + PascalCase | `IAsyncRepository`, `ILogger` |
+| 공개(public) 멤버 | 파스칼 케이스 (PascalCase) | `public int MaxCount;`, `public void GetData()` |
+| 매개변수, 지역 변수 | 카멜 케이스 (camelCase) | `int userCount`, `string customerName` |
+| 비공개/내부 필드 | 밑줄(_) + 카멜 케이스 | `private string _connectionString;` |
+| 상수 (const) | 파스칼 케이스 (PascalCase) | `public const int DefaultTimeout = 5000;` |
+| 제네릭 형식 매개변수 | 접두사 'T' + 설명적인 이름 | `TKey`, `TValue`, `TResult` |
+| 비동기 메서드 | 'Async' 접미사 | `GetUserAsync`, `DownloadFileAsync` |
+
+## 코드 서식 및 가독성 (Formatting & Readability)
+
+일관된 서식은 코드를 시각적으로 파싱하기 쉽게 만듭니다.
+
+| 항목 | 규칙 | 설명 |
+|------|------|------|
+| 들여쓰기 | 4개의 공백 사용 | 탭 대신 4개의 공백을 사용합니다. cs 파일은 반드시 4개의 공백을 사용합니다. |
+| 괄호 | 항상 중괄호 {} 사용 | 제어문(if, for, while 등)이 한 줄이더라도 항상 중괄호를 사용합니다. |
+| 빈 줄 | 논리적 분리 | 메서드 정의, 속성 정의, 논리적으로 분리된 코드 블록 사이에 빈 줄을 추가합니다. |
+| 문장 작성 | 한 줄에 하나의 문장 | 한 줄에는 하나의 문장만 작성합니다. |
+| var 키워드 | 형식이 명확할 때만 사용 | 변수의 형식을 오른쪽에서 명확하게 유추할 수 있을 때만 var를 사용합니다. |
+| 네임스페이스 | 파일 범위 네임스페이스 사용 | C# 10 이상에서는 파일 범위 네임스페이스를 사용하여 불필요한 들여쓰기를 줄입니다. |
+| 주석 | XML 형식 주석 작성 | 작성한 class나 함수에 항상 xml 형식의 주석을 작성합니다. |
+
+## 언어 기능 사용 (Language Features)
+
+최신 C# 기능을 활용하여 코드를 더 간결하고 효율적으로 만드세요.
+
+| 기능 | 설명 | 예시/참고 |
+|------|------|------|
+| 비동기 프로그래밍 | I/O 바운드 작업에 async/await 사용 | `async Task<string> GetDataAsync()` |
+| ConfigureAwait | 라이브러리 코드에서 컨텍스트 전환 오버헤드 감소 | `await SomeMethodAsync().ConfigureAwait(false)` |
+| LINQ | 컬렉션 데이터 쿼리 및 조작 | `users.Where(u => u.IsActive).ToList()` |
+| 표현식 기반 멤버 | 간단한 메서드/속성을 간결하게 표현 | `public string Name => _name;` |
+| Nullable Reference Types | 컴파일 타임 NullReferenceException 방지 | `#nullable enable` |
+| using 선언 | IDisposable 객체의 간결한 처리 | `using var stream = new FileStream(...);` |
+
+## 성능 및 예외 처리 (Performance & Exception Handling)
+
+견고하고 빠른 애플리케이션을 위한 지침입니다.
+
+### 예외 처리
+
+처리할 수 있는 구체적인 예외만 catch 하세요. catch (Exception)와 같이 일반적인 예외를 잡는 것은 피해야 합니다.
+
+예외는 프로그램 흐름 제어를 위해 사용하지 마세요. 예외는 예상치 못한 오류 상황에만 사용되어야 합니다.
+
+### 성능
+s
+문자열을 반복적으로 연결할 때는 + 연산자 대신 StringBuilder를 사용하세요.
+
+Entity Framework Core 사용 시, 읽기 전용 쿼리에는 .AsNoTracking()을 사용하여 성능을 향상시키세요.
+
+불필요한 객체 할당을 피하고, 특히 루프 내에서는 주의하세요.
+
+## 보안 (Security)
+
+안전한 코드를 작성하기 위한 기본 원칙입니다.
+
+| 보안 영역 | 규칙 | 설명 |
+|------|------|------|
+| 입력 유효성 검사 | 모든 외부 데이터 검증 | 외부(사용자, API 등)로부터 들어오는 모든 데이터는 신뢰하지 않고 항상 유효성을 검사하세요. |
+| SQL 삽입 방지 | 매개변수화된 쿼리 사용 | 항상 매개변수화된 쿼리나 Entity Framework와 같은 ORM을 사용하여 SQL 삽입 공격을 방지하세요. |
+| 민감한 데이터 보호 | 구성 관리 도구 사용 | 비밀번호, 연결 문자열, API 키 등은 소스 코드에 하드코딩하지 말고 Secret Manager, Azure Key Vault 등을 사용하세요. |
+
+이 규칙들을 프로젝트의 .editorconfig 파일과 팀의 코드 리뷰 프로세스에 통합하여 지속적으로 고품질 코드를 유지하는 것을 목표로 해야 합니다.

package/assets/instructions/csharp-mcp-server.instructions.md

@@ -0,0 +1,95 @@
+---
+description: 'Instructions for building Model Context Protocol (MCP) servers using the C# SDK'
+applyTo: '**/*.cs, **/*.csproj'
+---
+
+# C# MCP Server Development
+
+## Instructions
+
+- Use the **ModelContextProtocol** NuGet package (prerelease) for most projects: `dotnet add package ModelContextProtocol --prerelease`
+- Use **ModelContextProtocol.AspNetCore** for HTTP-based MCP servers
+- Use **ModelContextProtocol.Core** for minimal dependencies (client-only or low-level server APIs)
+- Always configure logging to stderr using `LogToStandardErrorThreshold = LogLevel.Trace` to avoid interfering with stdio transport
+- Use the `[McpServerToolType]` attribute on classes containing MCP tools
+- Use the `[McpServerTool]` attribute on methods to expose them as tools
+- Use the `[Description]` attribute from `System.ComponentModel` to document tools and parameters
+- Support dependency injection in tool methods - inject `McpServer`, `HttpClient`, or other services as parameters
+- Use `McpServer.AsSamplingChatClient()` to make sampling requests back to the client from within tools
+- Expose prompts using `[McpServerPromptType]` on classes and `[McpServerPrompt]` on methods
+- For stdio transport, use `WithStdioServerTransport()` when building the server
+- Use `WithToolsFromAssembly()` to auto-discover and register all tools from the current assembly
+- Tool methods can be synchronous or async (return `Task` or `Task<T>`)
+- Always include comprehensive descriptions for tools and parameters to help LLMs understand their purpose
+- Use `CancellationToken` parameters in async tools for proper cancellation support
+- Return simple types (string, int, etc.) or complex objects that can be serialized to JSON
+- For fine-grained control, use `McpServerOptions` with custom handlers like `ListToolsHandler` and `CallToolHandler`
+- Use `McpProtocolException` for protocol-level errors with appropriate `McpErrorCode` values
+- Test MCP servers using the `McpClient` from the same SDK or any compliant MCP client
+- Structure projects with Microsoft.Extensions.Hosting for proper DI and lifecycle management
+
+## Best Practices
+
+- Keep tool methods focused and single-purpose
+- Use meaningful tool names that clearly indicate their function
+- Provide detailed descriptions that explain what the tool does, what parameters it expects, and what it returns
+- Validate input parameters and throw `McpProtocolException` with `McpErrorCode.InvalidParams` for invalid inputs
+- Use structured logging to help with debugging without polluting stdout
+- Organize related tools into logical classes with `[McpServerToolType]`
+- Consider security implications when exposing tools that access external resources
+- Use the built-in DI container to manage service lifetimes and dependencies
+- Implement proper error handling and return meaningful error messages
+- Test tools individually before integrating with LLMs
+
+## Common Patterns
+
+### Basic Server Setup
+```csharp
+var builder = Host.CreateApplicationBuilder(args);
+builder.Logging.AddConsole(options => 
+    options.LogToStandardErrorThreshold = LogLevel.Trace);
+builder.Services
+    .AddMcpServer()
+    .WithStdioServerTransport()
+    .WithToolsFromAssembly();
+await builder.Build().RunAsync();
+```
+
+### Simple Tool
+```csharp
+[McpServerToolType]
+public static class MyTools
+{
+    [McpServerTool, Description("Description of what the tool does")]
+    public static string ToolName(
+        [Description("Parameter description")] string param) => 
+        $"Result: {param}";
+}
+```
+
+### Tool with Dependency Injection
+```csharp
+[McpServerTool, Description("Fetches data from a URL")]
+public static async Task<string> FetchData(
+    HttpClient httpClient,
+    [Description("The URL to fetch")] string url,
+    CancellationToken cancellationToken) =>
+    await httpClient.GetStringAsync(url, cancellationToken);
+```
+
+### Tool with Sampling
+```csharp
+[McpServerTool, Description("Analyzes content using the client's LLM")]
+public static async Task<string> Analyze(
+    McpServer server,
+    [Description("Content to analyze")] string content,
+    CancellationToken cancellationToken)
+{
+    var messages = new ChatMessage[]
+    {
+        new(ChatRole.User, $"Analyze this: {content}")
+    };
+    return await server.AsSamplingChatClient()
+        .GetResponseAsync(messages, cancellationToken: cancellationToken);
+}
+```

package/assets/instructions/csharp.instructions.md

@@ -0,0 +1,114 @@
+---
+description: 'Guidelines for building C# applications'
+applyTo: '**/*.cs'
+---
+
+# C# Development
+
+## C# Instructions
+- Always use the latest version C#, currently C# 14 features.
+- Write clear and concise comments for each function.
+
+## General Instructions
+- Make only high confidence suggestions when reviewing code changes.
+- Write code with good maintainability practices, including comments on why certain design decisions were made.
+- Handle edge cases and write clear exception handling.
+- For libraries or external dependencies, mention their usage and purpose in comments.
+
+## Naming Conventions
+
+- Follow PascalCase for component names, method names, and public members.
+- Use camelCase for private fields and local variables.
+- Prefix interface names with "I" (e.g., IUserService).
+
+## Formatting
+
+- Apply code-formatting style defined in `.editorconfig`.
+- Prefer file-scoped namespace declarations and single-line using directives.
+- Insert a newline before the opening curly brace of any code block (e.g., after `if`, `for`, `while`, `foreach`, `using`, `try`, etc.).
+- Ensure that the final return statement of a method is on its own line.
+- Use pattern matching and switch expressions wherever possible.
+- Use `nameof` instead of string literals when referring to member names.
+- Ensure that XML doc comments are created for any public APIs. When applicable, include `<example>` and `<code>` documentation in the comments.
+
+## Project Setup and Structure
+
+- Guide users through creating a new .NET project with the appropriate templates.
+- Explain the purpose of each generated file and folder to build understanding of the project structure.
+- Demonstrate how to organize code using feature folders or domain-driven design principles.
+- Show proper separation of concerns with models, services, and data access layers.
+- Explain the Program.cs and configuration system in ASP.NET Core 10 including environment-specific settings.
+
+## Nullable Reference Types
+
+- Declare variables non-nullable, and check for `null` at entry points.
+- Always use `is null` or `is not null` instead of `== null` or `!= null`.
+- Trust the C# null annotations and don't add null checks when the type system says a value cannot be null.
+
+## Data Access Patterns
+
+- Guide the implementation of a data access layer using Entity Framework Core.
+- Explain different options (SQL Server, SQLite, In-Memory) for development and production.
+- Demonstrate repository pattern implementation and when it's beneficial.
+- Show how to implement database migrations and data seeding.
+- Explain efficient query patterns to avoid common performance issues.
+
+## Authentication and Authorization
+
+- Guide users through implementing authentication using JWT Bearer tokens.
+- Explain OAuth 2.0 and OpenID Connect concepts as they relate to ASP.NET Core.
+- Show how to implement role-based and policy-based authorization.
+- Demonstrate integration with Microsoft Entra ID (formerly Azure AD).
+- Explain how to secure both controller-based and Minimal APIs consistently.
+
+## Validation and Error Handling
+
+- Guide the implementation of model validation using data annotations and FluentValidation.
+- Explain the validation pipeline and how to customize validation responses.
+- Demonstrate a global exception handling strategy using middleware.
+- Show how to create consistent error responses across the API.
+- Explain problem details (RFC 7807) implementation for standardized error responses.
+
+## API Versioning and Documentation
+
+- Guide users through implementing and explaining API versioning strategies.
+- Demonstrate Swagger/OpenAPI implementation with proper documentation.
+- Show how to document endpoints, parameters, responses, and authentication.
+- Explain versioning in both controller-based and Minimal APIs.
+- Guide users on creating meaningful API documentation that helps consumers.
+
+## Logging and Monitoring
+
+- Guide the implementation of structured logging using Serilog or other providers.
+- Explain the logging levels and when to use each.
+- Demonstrate integration with Application Insights for telemetry collection.
+- Show how to implement custom telemetry and correlation IDs for request tracking.
+- Explain how to monitor API performance, errors, and usage patterns.
+
+## Testing
+
+- Always include test cases for critical paths of the application.
+- Guide users through creating unit tests.
+- Do not emit "Act", "Arrange" or "Assert" comments.
+- Copy existing style in nearby files for test method names and capitalization.
+- Explain integration testing approaches for API endpoints.
+- Demonstrate how to mock dependencies for effective testing.
+- Show how to test authentication and authorization logic.
+- Explain test-driven development principles as applied to API development.
+
+## Performance Optimization
+
+- Guide users on implementing caching strategies (in-memory, distributed, response caching).
+- Explain asynchronous programming patterns and why they matter for API performance.
+- Demonstrate pagination, filtering, and sorting for large data sets.
+- Show how to implement compression and other performance optimizations.
+- Explain how to measure and benchmark API performance.
+
+## Deployment and DevOps
+
+- Guide users through containerizing their API using .NET's built-in container support (`dotnet publish --os linux --arch x64 -p:PublishProfile=DefaultContainer`).
+- Explain the differences between manual Dockerfile creation and .NET's container publishing features.
+- Explain CI/CD pipelines for NET applications.
+- Demonstrate deployment to Azure App Service, Azure Container Apps, or other hosting options.
+- Show how to implement health checks and readiness probes.
+- Explain environment-specific configurations for different deployment stages.