Add mcaf-dotnet-resharper-clt skill

KSemenenko · KSemenenko · commit 65d3884edd4c · 2026-03-08T14:54:37.000+01:00
diff --git a/README.md b/README.md
@@ -115,7 +115,7 @@ Platform-specific bundles can stay small and still be explicit.
 For example, a typical .NET repo baseline can install `mcaf-dotnet` as the entry skill, `mcaf-dotnet-features`, `mcaf-solution-governance`, `mcaf-testing`, exactly one of `mcaf-dotnet-xunit`, `mcaf-dotnet-tunit`, or `mcaf-dotnet-mstest`, plus `mcaf-dotnet-quality-ci`, `mcaf-dotnet-complexity`, `mcaf-solid-maintainability`, `mcaf-architecture-overview`, and `mcaf-ci-cd`.
 In that setup, `mcaf-dotnet` knows when to open the more specific .NET skills, the repo-root lowercase `.editorconfig` is the default source of truth for formatting and analyzer severity, and `AGENTS.md` records the exact `dotnet build`, `dotnet test`, `dotnet format`, `analyze`, and coverage commands. Nested `.editorconfig` files are allowed when they serve a clear subtree-specific purpose, such as stricter domain rules, generated-code handling, test-specific conventions, or legacy-code containment.
 For .NET code changes, the task is not done when tests are green if the repo also configured formatters, analyzers, coverage, architecture tests, or security gates. Agents should run the repo-defined post-change quality pass before completion.
-If the repo standardizes on concrete tools, install the matching tool skills as well. Typical open or free .NET additions include `mcaf-dotnet-format`, `mcaf-dotnet-code-analysis`, `mcaf-dotnet-analyzer-config`, `mcaf-dotnet-stylecop-analyzers`, `mcaf-dotnet-roslynator`, `mcaf-dotnet-meziantou-analyzer`, `mcaf-dotnet-cloc`, `mcaf-dotnet-coverlet`, `mcaf-dotnet-profiling`, `mcaf-dotnet-quickdup`, `mcaf-dotnet-reportgenerator`, `mcaf-dotnet-stryker`, `mcaf-dotnet-netarchtest`, `mcaf-dotnet-archunitnet`, `mcaf-dotnet-semgrep`, and `mcaf-dotnet-csharpier`. `mcaf-dotnet-codeql` stays available, but should be chosen only when its hosting and licensing model fits the repository.
+If the repo standardizes on concrete tools, install the matching tool skills as well. Typical open or free .NET additions include `mcaf-dotnet-format`, `mcaf-dotnet-code-analysis`, `mcaf-dotnet-analyzer-config`, `mcaf-dotnet-stylecop-analyzers`, `mcaf-dotnet-roslynator`, `mcaf-dotnet-meziantou-analyzer`, `mcaf-dotnet-cloc`, `mcaf-dotnet-coverlet`, `mcaf-dotnet-profiling`, `mcaf-dotnet-quickdup`, `mcaf-dotnet-reportgenerator`, `mcaf-dotnet-resharper-clt`, `mcaf-dotnet-stryker`, `mcaf-dotnet-netarchtest`, `mcaf-dotnet-archunitnet`, `mcaf-dotnet-semgrep`, and `mcaf-dotnet-csharpier`. `mcaf-dotnet-codeql` stays available, but should be chosen only when its hosting and licensing model fits the repository.
 
 ### 2.5 Context Rules
 
diff --git a/TUTORIAL.md b/TUTORIAL.md
@@ -151,6 +151,7 @@ Add tool-specific .NET skills only when the repo standardizes on them:
 - `mcaf-dotnet-profiling`
 - `mcaf-dotnet-quickdup`
 - `mcaf-dotnet-reportgenerator`
+- `mcaf-dotnet-resharper-clt`
 - `mcaf-dotnet-roslynator`
 - `mcaf-dotnet-semgrep`
 - `mcaf-dotnet-stryker`
@@ -187,6 +188,7 @@ The website build generates this list from the actual folders under `skills/`.
 - `mcaf-dotnet-quality-ci` — [Folder](https://github.com/managedcode/MCAF/blob/main/skills/mcaf-dotnet-quality-ci), [Raw SKILL](https://raw.githubusercontent.com/managedcode/MCAF/main/skills/mcaf-dotnet-quality-ci/SKILL.md)
 - `mcaf-dotnet-quickdup` — [Folder](https://github.com/managedcode/MCAF/blob/main/skills/mcaf-dotnet-quickdup), [Raw SKILL](https://raw.githubusercontent.com/managedcode/MCAF/main/skills/mcaf-dotnet-quickdup/SKILL.md)
 - `mcaf-dotnet-reportgenerator` — [Folder](https://github.com/managedcode/MCAF/blob/main/skills/mcaf-dotnet-reportgenerator), [Raw SKILL](https://raw.githubusercontent.com/managedcode/MCAF/main/skills/mcaf-dotnet-reportgenerator/SKILL.md)
+- `mcaf-dotnet-resharper-clt` — [Folder](https://github.com/managedcode/MCAF/blob/main/skills/mcaf-dotnet-resharper-clt), [Raw SKILL](https://raw.githubusercontent.com/managedcode/MCAF/main/skills/mcaf-dotnet-resharper-clt/SKILL.md)
 - `mcaf-dotnet-roslynator` — [Folder](https://github.com/managedcode/MCAF/blob/main/skills/mcaf-dotnet-roslynator), [Raw SKILL](https://raw.githubusercontent.com/managedcode/MCAF/main/skills/mcaf-dotnet-roslynator/SKILL.md)
 - `mcaf-dotnet-semgrep` — [Folder](https://github.com/managedcode/MCAF/blob/main/skills/mcaf-dotnet-semgrep), [Raw SKILL](https://raw.githubusercontent.com/managedcode/MCAF/main/skills/mcaf-dotnet-semgrep/SKILL.md)
 - `mcaf-dotnet-stryker` — [Folder](https://github.com/managedcode/MCAF/blob/main/skills/mcaf-dotnet-stryker), [Raw SKILL](https://raw.githubusercontent.com/managedcode/MCAF/main/skills/mcaf-dotnet-stryker/SKILL.md)
diff --git a/skills/mcaf-dotnet-quality-ci/references/quality-toolchain.md b/skills/mcaf-dotnet-quality-ci/references/quality-toolchain.md
@@ -49,6 +49,7 @@ These tools are worth adding once the baseline is stable:
 | Mutation testing | `Stryker.NET` | `mcaf-dotnet-stryker` | Verifies that tests actually catch faults | Best on libraries and critical domains, not every PR path |
 | Architecture tests | `NetArchTest.Rules` | `mcaf-dotnet-netarchtest` | Simple, fluent architectural rules in tests | Good for layered or clean architecture policies |
 | Architecture tests | `ArchUnitNET` | `mcaf-dotnet-archunitnet` | Richer architecture assertions across xUnit, MSTest, and TUnit | Heavier than NetArchTest but more expressive |
+| Deep inspections and cleanup | `JetBrains ReSharper Command Line Tools` | `mcaf-dotnet-resharper-clt` | Powerful ReSharper inspections plus cleanup profiles in CI or local runs | Free official JetBrains CLI package; keep shared policy in solution `.DotSettings` |
 | Security scanning | `Semgrep CE` | `mcaf-dotnet-semgrep` | Fast OSS static analysis across many languages | Community Edition is file/function-scoped for security analysis |
 | Security scanning | `CodeQL` | `mcaf-dotnet-codeql` | Deep GitHub-native query-based analysis | Open ecosystem with private-repo hosting caveats |
 | Opinionated formatter | `CSharpier` | `mcaf-dotnet-csharpier` | Fast one-style formatter for C# and XML | Use only if the repo wants a formatter owner beyond `dotnet format` |
@@ -93,7 +94,7 @@ Use the exact commands from `AGENTS.md`. The usual checked-in flow is:
 4. focused `test`
 5. broader `test`
 6. `coverage` and report generation when configured
-7. extra configured gates such as Roslynator, StyleCop, Meziantou, architecture tests, Semgrep, CodeQL, CSharpier, or Stryker
+7. extra configured gates such as Roslynator, StyleCop, Meziantou, ReSharper CLT, architecture tests, Semgrep, CodeQL, CSharpier, or Stryker
 
 Run only the gates the repo actually enabled.
 
@@ -138,6 +139,9 @@ dotnet stryker
 - [Stryker.NET](https://github.com/stryker-mutator/stryker-net)
 - [NetArchTest](https://github.com/BenMorris/NetArchTest)
 - [ArchUnitNET](https://github.com/TNG/ArchUnitNET)
+- [ReSharper command line tools](https://www.jetbrains.com/help/resharper/ReSharper_Command_Line_Tools.html)
+- [CleanupCode](https://www.jetbrains.com/help/resharper/CleanupCode.html)
+- [InspectCode](https://www.jetbrains.com/help/resharper/InspectCode.html)
 - [CodeQL code scanning](https://docs.github.com/en/code-security/code-scanning/introduction-to-code-scanning/about-code-scanning-with-codeql)
 - [Semgrep](https://github.com/semgrep/semgrep)
 - [CSharpier](https://github.com/belav/csharpier)
diff --git a/skills/mcaf-dotnet-resharper-clt/SKILL.md b/skills/mcaf-dotnet-resharper-clt/SKILL.md
@@ -0,0 +1,129 @@
+---
+name: mcaf-dotnet-resharper-clt
+description: "Use the free official JetBrains ReSharper Command Line Tools for .NET repositories. Use when a repo wants powerful `jb inspectcode` inspections, `jb cleanupcode` cleanup profiles, solution-level `.DotSettings` enforcement, or a stronger CLI quality gate for C# than the default SDK analyzers alone."
+compatibility: "Requires a .NET solution or project; works best when the repo keeps shared ReSharper settings in solution `.DotSettings` files and records exact commands in `AGENTS.md`."
+---
+
+# MCAF: .NET ReSharper CLT
+
+## Trigger On
+
+- the repo uses or wants ReSharper Command Line Tools
+- the team wants `jb inspectcode` or `jb cleanupcode`
+- the user asks for stronger C# inspections, cleanup profiles, or ReSharper-based CI gates
+
+## Value
+
+- produce a concrete project delta: code, docs, config, tests, CI, or review artifact
+- reduce ambiguity through explicit planning, verification, and final validation skills
+- leave reusable project context so future tasks are faster and safer
+
+## Do Not Use For
+
+- replacing tests with inspection output
+- ad-hoc formatting-only work when the repo intentionally standardizes on another formatter
+- repos that do not want JetBrains settings or CLT-based gates in their workflow
+
+## Inputs
+
+- the nearest `AGENTS.md`
+- the target `.sln`, `.csproj`, or bounded file set
+- repo-root `.editorconfig`
+- solution shared settings such as `YourSolution.sln.DotSettings`
+
+## Quick Start
+
+1. Read the nearest `AGENTS.md` and confirm scope and constraints.
+2. Run this skill's `Workflow` through the `Ralph Loop` until outcomes are acceptable.
+3. Return the `Required Result Format` with concrete artifacts and verification evidence.
+
+## Workflow
+
+1. Prefer solution-level runs when possible so ReSharper can resolve references and apply full inspections.
+2. Build the solution before `jb cleanupcode` when working at solution scope.
+3. Use `jb inspectcode` first to surface issues before editing anything broad.
+4. Treat surfaced issues as mandatory fixes when this gate is enabled for the repo; do not just dump a report and stop.
+5. Use `jb cleanupcode` with an explicit cleanup profile:
+   - `Built-in: Full Cleanup`
+   - `Built-in: Reformat Code`
+   - `Built-in: Reformat & Apply Syntax Style`
+   - or a checked-in custom profile
+6. Keep durable ReSharper settings in the team-shared solution layer and commit the solution `.DotSettings` file when policy changes.
+7. Re-run `jb inspectcode` after cleanup or fixes, then run the repo's normal quality pass and tests.
+
+## Bootstrap When Missing
+
+If ReSharper Command Line Tools are not available yet:
+
+1. Detect current state:
+   - `rg --files -g '.config/dotnet-tools.json' -g '*.sln.DotSettings'`
+   - `dotnet tool list --local`
+   - `dotnet tool list --global`
+   - `command -v jb`
+2. Choose the install path deliberately:
+   - preferred repo-local install for reproducible CI:
+     - `dotnet new tool-manifest` (if missing)
+     - `dotnet tool install JetBrains.ReSharper.GlobalTools`
+   - global fallback:
+     - `dotnet tool install --global JetBrains.ReSharper.GlobalTools`
+3. Verify the installed commands resolve correctly:
+   - `jb inspectcode --help`
+   - `jb cleanupcode --help`
+4. Record exact commands in `AGENTS.md`, for example:
+   - `dotnet build MySolution.sln -c Release`
+   - `jb inspectcode MySolution.sln -o=artifacts/inspectcode.sarif`
+   - `jb cleanupcode MySolution.sln --profile="Built-in: Full Cleanup"`
+5. If the repo needs stable settings, save them into the solution team-shared layer and commit `YourSolution.sln.DotSettings`.
+6. Run `jb inspectcode` once, fix or triage the surfaced issues, rerun it, and return `status: configured` or `status: improved`.
+7. If the repo intentionally excludes ReSharper CLT from its toolchain, return `status: not_applicable`.
+
+## Deliver
+
+- explicit `jb inspectcode` and `jb cleanupcode` commands
+- durable ReSharper settings in shared solution config
+- a quality gate that surfaces issues which are then fixed, not ignored
+
+## Validate
+
+- the target solution or project builds before solution-wide cleanup
+- `jb inspectcode` output is reviewed and acted on
+- cleanup profiles and shared settings are explicit
+- tests and the wider quality pass still run after ReSharper-driven fixes
+
+## Ralph Loop
+
+Use the Ralph Loop for every task, including docs, architecture, testing, and tooling work.
+
+1. Plan first (mandatory):
+   - analyze current state
+   - define target outcome, constraints, and risks
+   - write a detailed execution plan
+   - list final validation skills to run at the end, with order and reason
+2. Execute one planned step and produce a concrete delta.
+3. Review the result and capture findings with actionable next fixes.
+4. Apply fixes in small batches and rerun the relevant checks or review steps.
+5. Update the plan after each iteration.
+6. Repeat until outcomes are acceptable or only explicit exceptions remain.
+7. If a dependency is missing, bootstrap it or return `status: not_applicable` with explicit reason and fallback path.
+
+### Required Result Format
+
+- `status`: `complete` | `clean` | `improved` | `configured` | `not_applicable` | `blocked`
+- `plan`: concise plan and current iteration step
+- `actions_taken`: concrete changes made
+- `validation_skills`: final skills run, or skipped with reasons
+- `verification`: commands, checks, or review evidence summary
+- `remaining`: top unresolved items or `none`
+
+For setup-only requests with no execution, return `status: configured` and exact next commands.
+
+## Load References
+
+- read `references/resharper-clt.md` first
+
+## Example Requests
+
+- "Add ReSharper CLI inspections to this .NET repo."
+- "Run InspectCode and fix what it finds."
+- "Set up CleanupCode with a shared profile."
+- "Use JetBrains ReSharper command line tools in CI."
diff --git a/skills/mcaf-dotnet-resharper-clt/references/resharper-clt.md b/skills/mcaf-dotnet-resharper-clt/references/resharper-clt.md
@@ -0,0 +1,136 @@
+# JetBrains ReSharper Command Line Tools
+
+## What This Skill Uses
+
+This skill standardizes on the free official JetBrains package `JetBrains.ReSharper.GlobalTools`, exposed through the `jb` command.
+
+Primary commands:
+
+- `jb inspectcode`
+- `jb cleanupcode`
+
+Use this skill when the repo intentionally wants stronger ReSharper inspections and cleanup than the default SDK analyzers alone.
+
+## Official Docs
+
+- ReSharper Command Line Tools:
+  - https://www.jetbrains.com/help/resharper/ReSharper_Command_Line_Tools.html
+- CleanupCode:
+  - https://www.jetbrains.com/help/resharper/CleanupCode.html
+- InspectCode:
+  - https://www.jetbrains.com/help/resharper/InspectCode.html
+
+## Installation Paths
+
+Preferred repo-local install for reproducible CI:
+
+```bash
+dotnet new tool-manifest
+dotnet tool install JetBrains.ReSharper.GlobalTools
+dotnet tool restore
+```
+
+Global fallback:
+
+```bash
+dotnet tool install --global JetBrains.ReSharper.GlobalTools
+```
+
+Verify the commands:
+
+```bash
+jb inspectcode --help
+jb cleanupcode --help
+```
+
+## Shared Settings
+
+If the repo uses ReSharper CLI as a real gate, keep durable settings in the solution team-shared layer and commit the resulting file:
+
+- `YourSolution.sln.DotSettings`
+
+This is where cleanup profiles and many inspection settings become durable for the rest of the team.
+
+Do not rely on user-specific settings files for repo policy.
+
+## InspectCode
+
+Use `InspectCode` to surface problems that must then be fixed.
+
+Basic run:
+
+```bash
+jb inspectcode YourSolution.sln -o=artifacts/inspectcode.sarif
+```
+
+Important details from the official docs:
+
+- starting with ReSharper 2024.1, SARIF is the default output format
+- XML is still available through `-f="xml"`
+- output path is controlled through `-o` or `--output`
+
+Examples:
+
+```bash
+jb inspectcode YourSolution.sln -o=artifacts/inspectcode.sarif
+jb inspectcode YourSolution.sln -f=Html -o=artifacts/inspectcode.html
+jb inspectcode YourSolution.sln -f=Xml -o=artifacts/inspectcode.xml
+```
+
+Use `InspectCode` before and after cleanup or code fixes so you can prove the issue count actually moved in the right direction.
+
+## CleanupCode
+
+Use `CleanupCode` to apply a selected cleanup profile over a solution, project, or bounded file set.
+
+Solution-wide run:
+
+```bash
+jb cleanupcode YourSolution.sln --profile="Built-in: Full Cleanup"
+```
+
+Focused reformat-only run:
+
+```bash
+jb cleanupcode YourSolution.sln --profile="Built-in: Reformat Code"
+```
+
+Useful profile options from the official docs:
+
+- `Built-in: Full Cleanup`
+- `Built-in: Reformat Code`
+- `Built-in: Reformat & Apply Syntax Style`
+
+Useful scope controls:
+
+- `--include`
+- `--exclude`
+
+Example:
+
+```bash
+jb cleanupcode YourSolution.sln --profile="Built-in: Reformat & Apply Syntax Style" --include="src/**/*.cs"
+```
+
+Important official note:
+
+- build the solution first when running solution-wide cleanup, otherwise binary references may not resolve correctly
+
+## Recommended Flow
+
+1. Build the solution in `Release`.
+2. Run `jb inspectcode`.
+3. Fix or clean up the surfaced issues.
+4. Run `jb cleanupcode` with an explicit profile.
+5. Run `jb inspectcode` again.
+6. Run the repo's analyzers and tests.
+
+## Gate Policy
+
+If the repo enables ReSharper CLI as a quality gate:
+
+- surfaced issues are not informational only
+- the task is not done while the agreed blocking issues remain
+- cleanup must be followed by tests and broader verification
+
+Do not stop at generating a SARIF file.
diff --git a/skills/mcaf-dotnet/SKILL.md b/skills/mcaf-dotnet/SKILL.md
@@ -54,7 +54,7 @@ compatibility: "Requires a .NET solution or project; respects root and local `AG
    - `mcaf-dotnet-quality-ci`
    - `mcaf-dotnet-analyzer-config`
    - `mcaf-dotnet-complexity`
-   - tool-specific skills such as `mcaf-dotnet-format`, `mcaf-dotnet-roslynator`, `mcaf-dotnet-stylecop-analyzers`, `mcaf-dotnet-meziantou-analyzer`, `mcaf-dotnet-coverlet`, `mcaf-dotnet-reportgenerator`, `mcaf-dotnet-netarchtest`, `mcaf-dotnet-archunitnet`, `mcaf-dotnet-semgrep`, `mcaf-dotnet-codeql`, `mcaf-dotnet-csharpier`, and `mcaf-dotnet-stryker`
+   - tool-specific skills such as `mcaf-dotnet-format`, `mcaf-dotnet-roslynator`, `mcaf-dotnet-stylecop-analyzers`, `mcaf-dotnet-meziantou-analyzer`, `mcaf-dotnet-coverlet`, `mcaf-dotnet-reportgenerator`, `mcaf-dotnet-resharper-clt`, `mcaf-dotnet-netarchtest`, `mcaf-dotnet-archunitnet`, `mcaf-dotnet-semgrep`, `mcaf-dotnet-codeql`, `mcaf-dotnet-csharpier`, and `mcaf-dotnet-stryker`
 4. Route design and structure through:
    - `mcaf-solid-maintainability` for SOLID, SRP, cohesion, and maintainability limits
    - `mcaf-architecture-overview` when system or module boundaries, contracts, or architecture docs need work
@@ -67,7 +67,7 @@ compatibility: "Requires a .NET solution or project; respects root and local `AG
    - focused `test`
    - broader `test`
    - `coverage` and report generation when configured
-   - extra configured gates such as Roslynator, StyleCop, Meziantou, NetArchTest, ArchUnitNET, Semgrep, CodeQL, CSharpier, or Stryker
+   - extra configured gates such as Roslynator, StyleCop, Meziantou, ReSharper CLT, NetArchTest, ArchUnitNET, Semgrep, CodeQL, CSharpier, or Stryker
 7. If the repo does not define these commands clearly, tighten `AGENTS.md` before continuing so later agents stop guessing.
 8. Do not introduce preview language features unless the repo explicitly opts into preview in project or MSBuild settings.
 
diff --git a/skills/mcaf-dotnet/references/skill-routing.md b/skills/mcaf-dotnet/references/skill-routing.md
@@ -14,7 +14,7 @@ Use `mcaf-dotnet` as the entry skill when a task spans more than one .NET concer
 | .NET quality gates, analyzer stack, coverage, mutation, or security gate selection | `mcaf-dotnet-quality-ci` |
 | repo-root `.editorconfig` authoring and analyzer severity ownership | `mcaf-dotnet-analyzer-config` |
 | complex methods, maintainability metrics, and coupling thresholds | `mcaf-dotnet-complexity` |
-| one concrete tool such as Roslynator, StyleCop, Coverlet, ReportGenerator, Semgrep, or CSharpier | the exact tool skill |
+| one concrete tool such as Roslynator, StyleCop, Coverlet, ReportGenerator, ReSharper CLT, Semgrep, or CSharpier | the exact tool skill |
 | SOLID-driven refactors and maintainability-limit enforcement | `mcaf-solid-maintainability` |
 | architecture map or boundary documentation | `mcaf-architecture-overview` |
 | architecture rules in executable tests | `mcaf-dotnet-netarchtest` or `mcaf-dotnet-archunitnet` |
diff --git a/skills/mcaf-dotnet/references/task-flow.md b/skills/mcaf-dotnet/references/task-flow.md
