ReSharper Command Line Tools

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

Read the nearest
```
AGENTS.md
```
and confirm scope and constraints.
Run this skill's
```
Workflow
```
through the
```
Ralph Loop
```
until outcomes are acceptable.
Return the
```
Required Result Format
```
with concrete artifacts and verification evidence.

Workflow

Prefer solution-level runs when possible so ReSharper can resolve references and apply full inspections.
Build the solution before
```
jb cleanupcode
```
when working at solution scope.
Use
```
jb inspectcode
```
first to surface issues before editing anything broad.
Treat surfaced issues as mandatory fixes when this gate is enabled for the repo; do not just dump a report and stop.

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

Keep durable ReSharper settings in the team-shared solution layer and commit the solution
```
.DotSettings
```
file when policy changes.
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:

Detect current state:

rg --files -g '.config/dotnet-tools.json' -g '*.sln.DotSettings'

```
dotnet tool list --local
```
```
dotnet tool list --global
```
```
command -v jb
```

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

Verify the installed commands resolve correctly:
- ```
jb inspectcode --help
```
- ```
jb cleanupcode --help
```

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"

If the repo needs stable settings, save them into the solution team-shared layer and commit
```
YourSolution.sln.DotSettings
```
.
Run
```
jb inspectcode
```
once, fix or triage the surfaced issues, rerun it, and return
```
status: configured
```
or
```
status: improved
```
.
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.

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
Execute one planned step and produce a concrete delta.
Review the result and capture findings with actionable next fixes.
Apply fixes in small batches and rerun the relevant checks or review steps.
Update the plan after each iteration.
Repeat until outcomes are acceptable or only explicit exceptions remain.
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

```
references/resharper-clt.md
```
```
references/commands.md
```
```
references/config.md
```

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."

dotnet-resharper-clt

NPX Install

Tags

SKILL.md Content