AGENTS.md

Available skills (managed by gh-copilot-curate — do not edit by hand)

Run gh copilot-curate list to see installed plugins; run gh copilot-curate update to refresh.

dotnet-msbuild

• Analyzing MSBuild Failures with Binary Logs — skill — Use MSBuild's built-in binlog replay to convert binary logs into searchable text logs, then analyze with standard tools (grep, cat, head, tail, find).
• Build Performance Baseline & Optimization — skill — Before optimizing a build, you need a baseline. Without measurements, optimization is guesswork. This skill covers how to establish baselines and apply systematic optimization techniques.
• Detecting OutputPath and IntermediateOutputPath Clashes — skill — This skill helps identify when multiple MSBuild project evaluations share the same OutputPath or IntermediateOutputPath. This is a common source of build failures including:
• Generate Binary Logs — skill — Pass the /bl switch when running any MSBuild-based command. This is a non-negotiable requirement for all .NET builds.
• Including Generated Files Into Your Build — skill — Files generated during the build are generally ignored by the build process. This leads to confusing results such as: - Generated files not being included in the output directory - Generated source files not being compiled - Globs not capturing files created during the build
• MSBuild Anti-Pattern Catalog — skill — A numbered catalog of common MSBuild anti-patterns. Each entry follows the format:
• MSBuild Modernization: Legacy to SDK-style Migration — skill — Legacy indicators:
• MSBuild Server for CLI Caching — skill — Use the MSBuild Server to cache evaluation results across CLI builds, matching the performance advantage Visual Studio gets from its long-lived MSBuild process.
• Misleading ResolveProjectReferences Time — skill — Prevent misguided optimization of ResolveProjectReferences by explaining that its reported time is wall-clock wait time, not CPU work.
• Organizing Build Infrastructure with Directory.Build Files — skill — Understanding which file to use is critical. They differ in when they are imported during evaluation:
• SKILL — skill — - /maxcpucount (or -m): number of worker nodes (processes) - Default: 1 node (sequential!). Always use -m for parallel builds - Recommended: -m without a number = use all logical processors - Each node builds one project at a time - Projects are scheduled based on dependency graph
• SKILL — skill — 1. Generate a binlog: dotnet build /bl:{} -m 2. Replay to diagnostic log with performance summary: bash dotnet msbuild build.binlog -noconlog -fl -flp:v=diag;logfile=full.log;performancesummary 3. Read the performance summary (at the end of full.log): bash grep "Target Performance Summary\|Task Performance Summary" -A 50 full.log 4. Find expensive targets and tasks: The PerformanceSummary section lists all targets/tasks sorted by cumulative time 5. Check for node utilization: grep for scheduling and node messages bash grep -i "node.*assigned\|building with\|scheduler" full.log | head -30 6. Check analyzers: grep for analyzer timing bash grep -i "analyzer.*elapsed\|Total analyzer execution time\|CompilerAnalyzerDriver" full.log
• SKILL — skill — For a comprehensive overview of MSBuild's evaluation and execution model, see Build process overview.
• SKILL — skill — MSBuild's incremental build mechanism allows targets to be skipped when their outputs are already up to date, dramatically reducing build times on subsequent runs.
• Build Performance Agent — agent — You are a specialized agent for diagnosing and optimizing MSBuild build performance. You actively run builds, analyze binlogs, and provide data-driven optimization recommendations.
• MSBuild Code Review Agent — agent — You are a specialized agent that reviews MSBuild project files for quality, correctness, and adherence to modern best practices. You actively scan files and produce actionable recommendations.
• MSBuild Expert Agent — agent — You are an expert in MSBuild, the Microsoft Build Engine used by .NET and Visual Studio. You help developers run builds, diagnose build failures, optimize build performance, and resolve common MSBuild issues.

dotnet-test

• .NET Test Framework Reference — skill — Language-specific detection patterns for .NET test frameworks (MSTest, xUnit, NUnit, TUnit).
• Assertion Diversity Analysis — skill — Analyze test code in any supported language to measure how varied and meaningful the assertions are. Produce a metrics report that reveals whether tests verify different facets of correctness — not just "output equals X" but also structure, exceptions, state transitions, side effects, and invariants.
• CRAP Score Analysis — skill — Calculate CRAP (Change Risk Anti-Patterns) scores for .NET methods to identify code that is both complex and undertested.
• Code Testing Extensions — skill — This skill provides access to language-specific guidance files used by the code-testing pipeline. Call this skill to get the file paths, then read the relevant file for your target language.
• Code Testing Generation Skill — skill — An AI-powered skill that generates comprehensive, workable unit tests for any programming language using a coordinated multi-agent pipeline.
• Coverage Analysis — skill — Raw coverage percentages answer "what code was executed?" — they don't answer what you actually need to know:
• Detect Static Dependencies — skill — Scan a C# codebase for calls to hard-to-test static APIs and produce a ranked report showing which statics appear most frequently, which files are most affected, and which abstractions already exist in the .NET ecosystem to replace them.
• Generate Testability Wrappers — skill — Generate wrapper interfaces, default implementations, and DI service registration code for untestable static dependencies. For statics that already have .NET built-in abstractions (TimeProvider, IHttpClientFactory), guide adoption of the built-in. For statics without built-in alternatives, generate custom minimal wrappers.
• Grade Tests — skill — Grade a curated list of test methods and produce a compact, PR-comment-friendly report: one row per test method with a letter grade, a score band, and a one-line note explaining the grade. The skill does not discover tests on its own — the caller (typically a PR automation workflow or a human reviewer holding a specific list) provides the test methods to grade.
• MSTest v1/v2 -> v3 Migration — skill — Migrate a test project from MSTest v1 (assembly references) or MSTest v2 (NuGet 1.x-2.x) to MSTest v3. MSTest v3 is not binary compatible with v1/v2 -- libraries compiled against v1/v2 must be recompiled.
• MSTest v3 -> v4 Migration — skill — Migrate a test project from MSTest v3 to MSTest v4. The outcome is a project using MSTest v4 that builds cleanly, passes tests, and accounts for every source-incompatible and behavioral change. MSTest v4 is not binary compatible with MSTest v3 -- any library compiled against v3 must be recompiled against v4.
• MTP Hot Reload for Iterative Test Fixing — skill — Set up and use Microsoft Testing Platform hot reload to rapidly iterate fixes on failing tests without rebuilding between each change.
• Migrate Static to Wrapper — skill — Perform mechanical, codemod-style replacement of static dependency call sites with calls to injected wrapper interfaces or built-in abstractions. Operates on a bounded scope (single file, project, or namespace) so migrations can be done incrementally.
• Run .NET Tests — skill — Detect the test platform and framework, run tests, and apply filters using dotnet test.
• Test Analysis Extensions — skill — This skill provides access to per-language reference files used by the polyglot test analysis skills. Call this skill to get the list of available extension files, then read the one matching the target codebase's language and test framework.
• Test Anti-Pattern Detection — skill — Quick, pragmatic analysis of test code in any supported language for anti-patterns and quality issues that undermine test reliability, maintainability, and diagnostic value.
• Test Filter Syntax Reference — skill — Filter syntax depends on the platform and test framework.
• Test Gap Analysis via Pseudo-Mutation — skill — Analyze production code in any supported language by reasoning about hypothetical mutations and checking whether existing tests would catch them. This reveals blind spots where tests pass but would continue to pass even if the code were broken.
• Test Platform and Framework Detection — skill — Determine which test platform (VSTest or Microsoft.Testing.Platform) and which test framework (MSTest, xUnit, NUnit, TUnit) a project uses.
• Test Smell Detection — skill — Deep formal audit of test code in any supported language using an academic test smell taxonomy. Detects symptoms of bad design or implementation decisions that make tests harder to understand, more fragile, less effective at catching bugs, or more expensive to maintain. Produces a severity-ranked report with specific locations and actionable fixes.
• Test Trait Tagging — skill — Analyze an existing test suite in any supported language and apply a standardized set of trait tags to each test method, giving teams visibility into their test distribution (positive vs. negative, critical-path coverage, smoke tests, etc.).
• VSTest -> Microsoft.Testing.Platform Migration — skill — Migrate a .NET test solution from VSTest to Microsoft.Testing.Platform (MTP). The outcome is a solution where all test projects run on MTP, dotnet test works correctly, and CI/CD pipelines are updated.
• Writing MSTest Tests — skill — Help users write effective, modern unit tests with MSTest 3.x/4.x using current APIs and best practices.
• xUnit -> MSTest Migration — skill — Migrate a .NET test project from xUnit.net (v2 or v3) to MSTest v4. The outcome is a project that:
• xunit.v3 Migration — skill — Migrate .NET test projects from xUnit.net v2 to xUnit.net v3. The outcome is a solution where all test projects reference xunit.v3.* packages, compiles cleanly, and all tests pass with the same results as before migration.
• Builder Agent — agent — You build/compile projects and report the results. You are polyglot — you work with any programming language.
• Fixer Agent — agent — You fix compilation errors in code files. You are polyglot — you work with any programming language.
• Linter Agent — agent — You format code and fix style issues. You are polyglot — you work with any programming language.
• Test Generator Agent — agent — You coordinate test generation using the Research-Plan-Implement (RPI) pipeline. You are polyglot — you work with any programming language.
• Test Implementer — agent — You implement a single phase from the test plan. You are polyglot — you work with any programming language.
• Test Migration Agent — agent — You are a .NET test migration agent. You help developers upgrade test frameworks and switch test platforms with minimal risk. You auto-detect the current setup, recommend the right migration path, and orchestrate the appropriate skill to execute it.
• Test Planner — agent — You create detailed test implementation plans based on research findings. You are polyglot — you work with any programming language.
• Test Quality Auditor Agent — agent — You are a polyglot test quality auditor. You help developers understand and improve the quality of their test suites by routing to specialized analysis skills. Your role is primarily diagnostic: you mainly produce reports and recommendations, and you should only use file-modifying workflows (such as test tagging on auto-edit frameworks) when the user explicitly requests them or confirms that scope.
• Test Researcher — agent — You research codebases to understand what needs testing and how to test it. You are polyglot — you work with any programming language.
• Testability Migration Agent — agent — You are a testability migration agent for .NET codebases. Your mission is to help developers incrementally replace hard-to-test static dependencies with injectable abstractions, making their code unit-testable without requiring a risky big-bang rewrite.
• Tester Agent — agent — You run tests and report the results. You are polyglot — you work with any programming language.