Zphil.ReSharperCli 1.0.1

resharper-cli-mcp

resharper-cli-mcp is an MCP server that runs JetBrains' ReSharper command-line tools and exposes them to C# coding agents over stdio. It is unofficial — not affiliated with or endorsed by JetBrains.

It gives an agent two things a text search cannot: a real ReSharper inspection of your solution (resharper_inspect), and ReSharper's own code cleanup applied in place (resharper_cleanup). The server shells out to a jb you install yourself, and bundles no JetBrains software.

Quickstart

The server needs the .NET 10 SDK and JetBrains' ReSharper Command Line Tools. Both install as .NET global tools, and neither needs an IDE.

dotnet tool install -g JetBrains.ReSharper.GlobalTools
dotnet tool install -g Zphil.ReSharperCli

Register the server with your MCP client under the command resharper-cli-mcp. For Claude Code, add it to .mcp.json:

{
  "mcpServers": {
    "resharper": {
      "command": "resharper-cli-mcp"
    }
  }
}

The server finds a single .sln/.slnx in its working directory. When that directory holds zero or several, set JB_SOLUTION_PATH in the config's env block or pass solutionPath on the call.

VS Code and Cursor users can add the server in one click, once both tools are installed:

Tools

Scope resharper_inspect with the files glob and raise severity (SUGGESTION, WARNING, ERROR; default WARNING) to control how much comes back. Each issue carries a file, line, severity, rule ID, and message:

Found 2 issue(s) across 1 file(s):

### /repo/src/HomeController.cs
- **Line 8** [WARNING] `RedundantUsingDirective`: Using directive is not required by the code and can be safely removed.
- **Line 24** [SUGGESTION] `FieldCanBeMadeReadOnly.Local`: Field can be made readonly.

Call resharper_cleanup once, at the end of a task, with every file you changed batched into the one call.

The first run on a solution is slow while ReSharper builds its caches under --caches-home; later runs reuse them and finish in seconds. The server caps each run at 5 minutes. If your MCP client's own tool-call timeout is shorter than a cold run needs, the client gives up first. In Claude Code, raise it with a per-server "timeout" in milliseconds in .mcp.json, or the MCP_TOOL_TIMEOUT environment variable; raising it past 5 minutes has no effect, since the server's own cap binds first.

Configuration

Set these in the MCP client config's env block. All are optional.

The solutionPath tool argument overrides JB_SOLUTION_PATH for a single call. When a result would exceed MAX_MCP_OUTPUT_TOKENS (2.5 characters per token, or 25,000 characters when unset), the server truncates at a line boundary and appends a note saying how much it dropped.

Solution discovery tries, in order: the solutionPath argument, then JB_SOLUTION_PATH, then a single .sln/.slnx in the working directory (top level only, no parent walk). Zero or several without an override is an error that names the variable to set.

Settings discovery tries, in order: JB_SETTINGS_PATH (a missing file logs a warning and falls through), then a .DotSettings file beside the solution, then GlobalSettingsStorage.DotSettings in the JetBrains shared directory, then none.

Logs roll daily under %LOCALAPPDATA%\Zphil.ReSharperCli\logs on Windows, and the platform-equivalent path elsewhere. Nothing leaves the machine.

Deriving a style guide for a legacy codebase

Adding this server to a large existing solution unlocks a second workflow: deriving an intentional ReSharper style guide from the code you already have, so an inspection flags real house-style deviations rather than un-configured defaults. The server advertises an MCP prompt, derive_style_guide (surfaced as a slash command or prompt-picker entry in clients that render prompts), that walks an agent through it.

Be clear on the division of labour: ReSharper's command-line tools have no "infer settings from code" verb, and this server does not infer settings. The agent derives the rules from evidence — the code plus whatever is already in the repo (StyleCop, analyzers, an existing .editorconfig) — and resharper_inspect validates them: scope an inspection to a representative folder, then keep or silence each noisy rule until the remaining output is all intentional. The recipe is .editorconfig-first (portable across ReSharper, StyleCop.Analyzers, Roslyn, dotnet format, and Rider), spilling only ReSharper-only knobs and cleanup-profile definitions into .sln.DotSettings. When the codebase genuinely mixes conventions, the prompt pauses and asks rather than guessing.

If a teammate has ReSharper or Rider, prefer JetBrains' first-party Detect Code Style Settings for the baseline; it is IDE-only, so this recipe is the path for headless, CI, or no-licence use, and it adds StyleCop reconciliation and severity tuning on top. See also ReSharper's Use EditorConfig and the InspectCode / CleanupCode references. The embedded prompt is the full recipe; this section is only a digest of it.

Cleanup is cosmetic

resharper_cleanup never changes behavior. Its default Built-in: Full Cleanup profile fixes formatting and style only, so an agent should write correct logic and let the cleanup pass handle the polish. There is no need to re-inspect or rebuild after it. The default profile handles all of these:

• unused usings, sorted and shortened qualified references
• indentation, spacing, line breaks, and wrapping
• var versus explicit type, per the solution's settings
• modifier order, and explicit or implicit modifiers as configured
• redundant parentheses, this. qualifiers, casts, and default values
• braces around single statements, per style
• auto-properties, readonly fields, object-creation style, trailing commas, namespace style

Keep the agent's editing effort on logic, types, naming, and architecture. For a legacy codebase where Full Cleanup would churn regions you did not touch, define a narrower profile (for example Custom: No Reordering) in the solution's .sln.DotSettings and pass its name as profile.

Cleanup reminder hook

The single end-of-task cleanup above is easy for an agent to forget. A Claude Code PostToolUse hook can nudge it toward the habit without running anything itself. Add this to .claude/settings.json:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "grep -qiE '\"file_path\"[[:space:]]*:[[:space:]]*\"[^\"]*\\.(cs|razor)\"' && printf '%s' '{\"hookSpecificOutput\":{\"hookEventName\":\"PostToolUse\",\"additionalContext\":\"When this task is done, batch every edited .cs/.razor file into one resharper_cleanup call.\"}}' || true"
          }
        ]
      }
    ]
  }
}

After each .cs/.razor edit the hook adds a one-line reminder to the agent's context; on any other file it prints nothing and does nothing. It never edits code or calls the tool, so the agent decides when to clean up. The command uses grep and printf, so it needs a POSIX shell (on Windows, Git Bash).

Contributing

Contributions are welcome. Bug reports reproduced on a public solution, MCP client-compatibility fixes, and improvements to discovery or output formatting land best. See CONTRIBUTING.md for the development setup (.NET 10 SDK) and the two-seam test architecture. To report a security issue privately, see SECURITY.md.

License

MIT; see LICENSE.

JetBrains and ReSharper are trademarks of JetBrains s.r.o. This project is an independent wrapper of their ReSharper Command Line Tools, which ship under JetBrains' own license.