andypgray/resharper-cli-mcp
JetBrains ReSharper command-line inspection and cleanup for C#, over MCP. Unofficial — not affiliated with or endorsed by JetBrains.
Changelog
All notable changes to this project are documented in this file.
The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
Unreleased
1.8.1 - 2026-11-15
Changed
- The install docs name .NET 10 or later as the requirement. The package targets .NET 10 with
RollForward=Major, so a machine with only a newer major runtime runs it on that one, and CI runs the test suite on .NET 11 as well as .NET 10. - The README and
llms-install.mdname a limit of the Claude Code plugin. In a repository whoseglobal.jsonpins an SDK older than .NET 10,dotnet dnxruns under that SDK, which has nodnxcommand, so the server does not start. The global tool, installed from a directory outside the repository, starts there. - The file log keeps 31 daily files rather than 7. The limit counts files, not days: a day on which nothing is logged writes no file, so the files on disk can span more than 31 days.
- A failure writing a cleanup's solution filter is logged at
Warning, with the filter's path and the exception. Before, only the tool result recorded it; that result is unchanged.
Fixed
- The setup guide names the file as the server's only log. It said diagnostics also go to stderr, where the server has never written a line.
- The server no longer reads or watches
appsettings.jsonand the host's other default settings files in the directory it is started from, which for an MCP client is the repository. The host starts with its defaults off, since the server reads none of that configuration. The watch was a recursive file watcher over that directory, and a burst of writes there could make it raise an unobservedInvalidOperationException("Somebody else set the _disposable field"), which the log recorded as an error. - The note on an inspect that reports compilation errors names a third cause: a
jbolder than the project's C# version reports the newer syntax as.CSharpErrorsthe compiler does not. The note names thejbversion in use and gives updating it as the cure (dotnet tool update -g JetBrains.ReSharper.GlobalToolsfor the global tool), ahead ofresharper_reset_cache, which cannot help there; the reset tool's description says the same. On a net11.0 project using C# 15,jb2026.2.4.1 reported nine such errors and 2026.3.0 none (measured 2026-11-14). resharper_cleanuploads the whole solution when a file's directory does not prove which project compiles it: another project compiles it too (a linked file, a shared project, a glob, or a project in a directory above), its own project removes or updates it with aCompileitem, turns default items off or is not an SDK project, the file is not a.csfile under a.csprojor a.vbfile under a.vbproj(a.razorfile reaches compilation throughContentitems, which are not read), or a project imports a file from the NuGet package folder. A filtered cleanup of such a file could load a project that does not compile it and rewrite nothing. The setup guide lists every case, and notes that a cleanup of a file two projects compile can still remove ausingonly one of them needs.
1.8.0 - 2026-10-31
Added
resharper_cleanuploads only the projects its files belong to and every project those reference, through a solution filter the server writes, rather than the whole solution. The rewritten bytes are the same, and the load is smaller: measured on one machine on 2026-10-30, a warm one-file cleanup of a 25-project solution that loaded 4 projects took a median of 30 s against 38 s for the whole solution, over four alternating runs of each.RESHARPER_MCP_CLEANUP_FILTER=offturns it off. A cleanup with a wildcard entry, a file no project owns, or a project reference or import that needs MSBuild to evaluate still loads the whole solution; the setup guide lists every such case.
Fixed
-
A solution filter (
.slnf) given assolutionPathorJB_SOLUTION_PATHreads its settings file and declared cleanup profile from the solution itssolution.pathnames, which is the solution whose settingsjbmounts. It used to look for a.slnf.DotSettingsthat never exists, so cleanup fell back toBuilt-in: Full Cleanup, which strips named arguments. A filter that will not parse, or that names a solution that is not there, is now an error naming the file. Working-directory discovery still picks only a.slnor.slnx. -
The duration a run's progress and timeout messages quote for the last cold or seeded run comes from a run of the same tool. A cold cleanup's duration used to be quoted to a cold inspection and the other way round, though the two differ by minutes on the same solution. A cleanup through a solution filter records and quotes no duration, since the projects it loads change from call to call. Durations recorded by earlier versions are read as an inspection's.
-
An inspection report's
Generatedline is written in the invariant culture, so it reads the same on every machine. Under th-TH it gave the year in the Buddhist calendar (2569 for 2026), and under da-DK and fi-FI it gave the time as09.30.15. The character counts in the detail-reduction and truncation notes and the timestamps in the diagnostic log are also written in the invariant culture. Under da-DK the notes gave the default 25,000-character limit as25.000.
1.7.2 - 2026-10-21
Changed
-
The
resharper_inspectandresharper_cleanupdescriptions name the work each tool does in the words a request uses: warnings, errors, suggestions and lint for inspect; formatting, code style and unused usings for cleanup. Claude Code loads tool schemas on demand and finds a tool by searching its name and description, so a request worded that way now reaches the right tool. -
resharper_cleanup's description no longer says a call costs the same whatever the file count, and the README and the setup guide no longer sayfilesnever changes what a run costs. Every cleanup pays for the solution-wide analysis, and on a warm cache its time then grows with the files it rewrites. Measured over 100 warm cleanups of one solution on one machine at 1.7.1, the median was 50 s for one to three files, 105 s for 11 to 30 and 160 s for more than 30, and a cleanup of every file in the solution took 779 s. The one-call-per-task rule stands.
Fixed
-
A run killed at the cap on a warm cache was told that the cause was almost always a cold cache, that scoping the next call would not help, and that a retry would resume. A warm
resharper_inspectis now told that its analysis outgrew the cap and that raising the cap is the fix. A warmresharper_cleanupis told that its time grows with the files it rewrites, to narrow or splitfilesbefore raising the cap. Aresharper_cleanupkilled at the cap on any cache state is now told that files it reached before it was stopped may already have been rewritten. The cold-cache diagnosis is otherwise unchanged. -
A
resharper_cleanupcall that leaves outfilesis refused withMissing required parameter "files" on "resharper_cleanup". Valid: files, profile, solutionPath.Such a call failed with the MCP SDK's missing-parameter error, which the server logged as an unexpected failure. The check reads the tool'srequiredlist from the same input schema the unknown-key check reads, and runs after it, so a misspeltfileis still named as the unknown key.files: []andfiles: nullstill getAt least one file must be specified.
1.7.1 - 2026-10-05
Changed
-
resharper_cleanuplabels a wildcard entry(pattern, not hashed)where 1.7.0 said(pattern, not tracked). Next to a file path,not trackedread as git's untracked state. The summary's header countshashed file(s), the files the server compared before and after the run, and a wildcard is never one of them. -
The README opens with what the server adds over running
jbfrom a shell, then states run times and their limits, and lists the MCP clients in one table of where the entry goes. The full entry for every client, now including Visual Studio, Rider and Junie, and the Codex CLI, is inllms-install.md. The Cursor and LM Studio install buttons are now shields.io badges. nuget.org renders images only from an allowlist of hosts, and it showed neither of the earlier button images on the package page.
Fixed
-
PRIVACY.mdand the README's Privacy Policy said the diagnostic log was the only thing the server writes. It also writes the inspection reports that areportargument asks for, and deletes them after seven days. It also keeps bookkeeping files in ReSharper's cache directory, which record each solution's path, thejbbuild that ran it and how long its runs took. Both texts now name all three. Nothing leaves the machine, as before. -
The README and the setup guide said a reduced inspection result still names every file. From the
Mediumlevel down it names only the files with the most issues. Every issue and every file is still counted at every level, which is what the guide now says. The Claude Desktop bundle's description said runs after the first take tens of seconds. It now says they are several times faster, as the README does, because a warm run's time depends on the machine and the solution. -
An argument key that differs from a parameter name only in case is refused instead of dropped. The server refuses a
tools/callargument whose key matches no parameter, and names the valid ones. It compared keys without regard to case, but the MCP SDK binds each argument by its exact name. So a key such asFilespassed the check and was never bound.resharper_cleanupthen failed with the SDK's missing-parameter error, which the server logged as an unexpected failure.Severityonresharper_inspectwas ignored, and the run used the default. Keys must now match a parameter name exactly, andFilesis refused withValid: files, profile, solutionPath.A tool name in the wrong case now always gets the SDK's unknown-tool error, which reaches the client as a JSON-RPC error rather than a tool result, and the server no longer logs it as a tool failure. -
resharper_cleanup's one-line summary no longer prints a zero count. The summary takes that form when a per-file list does not fit the output budget. A run given only wildcards read(0 unchanged, 0 unknown, 2 pattern(s) not listed.)there, and now reads(2 pattern(s) not listed.). When cleanup changed every named file, the line now ends at the count. The forms that list files already left a zero count out. -
resharper_cleanupno longer counts a file it could not read as one it compared. A named file that another process held locked, or that was otherwise unreadable before or after the run, was counted in the total. Three such files reported0 of 3 file(s) changed on diskabout files the server never compared. The count now covers only the files hashed both times. When wildcards or unreadable files leave it short of the entries given, the header sayshashed file(s)where 1.7.0 saidnamed file(s). When no named file could be read, the header gives no count and says the server cannot tell whetherjbchanged them. -
The pre-warm now runs when the warm marker is under an hour old but names a different
jbbuild. It checked only the marker's age, so after ajbupdate it skipped a cache thatjbhad to rebuild. The first call then paid for the rebuild. It now applies the build check that the cache-state line and the choice of seeding donor already use. -
A running server now notices a
jbupdated in place and reports the new build. The server ranjb inspectcode --versiononce per process. On a standard install, both places it looks forjblead to thedotnet toolshim, which starts whichever build is installed. Afterdotnet tool update -g JetBrains.ReSharper.GlobalTools, a running server ran the newjbunder the old version. Its cache-state line readwarmwhilejbrebuilt the cache, and it recorded the old version against the cache the new build wrote. A server started later then read that cache asstaleand recorded a warm run as the solution's cold duration. Each call now compares the write time and size of~/.dotnet/tools/jband of the firstjbonPATHwith their values at the last probe, and probes again when either has changed. A call already queued whenjbis replaced still records the build its own probe reported, so the call after it can report the cache asstaleonce. -
The server now keeps the output it read from
jbwhen a process thatjbstarted still holds that output open afterjbexits. The server waits for that output until the call's time limit, and at the limit it dropped what it had already read. A failed run's error then quoted nothing thatjbwrote to standard error. Thejb inspectcode --versionprobe rejected a workingjbas reporting no version. The call still waits until that limit, which is the run cap for a run and 30 seconds for the probe.
1.7.0 - 2026-09-08
Added
resharper_reset_cachereclaims the cache of a checkout that has been deleted. A cache generation is addressed by the hash of the solution's absolute path, so a removed worktree, clone or copied directory leaves one behind that nothing rebuilds and nothing reuses; passing that old path assolutionPathnow drops it, where before the call failed because no file was there. The ownership proof is unchanged — the same hash of the same string — and generations belonging to other checkouts are still named and left where they are. A reclaim writes no cold-rebuild record, since there is no next run against that path to keep cold and the record would deny the seeding to a checkout created there later.JB_SOLUTION_PATHand working-directory discovery still require a file that exists, and so doresharper_inspectandresharper_cleanup.
Changed
-
resharper_reset_cachenames the checkout each cache generation it left alone belongs to. A generation is named by a one-way hash of a solution path, so a report listing the ones it did not touch was listing directories nobody could act on. The warm marker now records the solution path its run was against, as a third line, and the report reads that back:last warmed for "<path>", with, which no longer existswhere the checkout is gone, followed by the call that reclaims it. A generation stamped by an earlier release reads aslast warmed by a run that recorded no pathuntil the next successful run against it rewrites the marker, and one no successful run ever stamped — a run killed at the cap, or ajbstarted outside this server's queue — reads asno successful run on record. -
A warm run's opening line, progress message and timeout message no longer quote what the last warm run took, and no warm figure is recorded. Measured over 31 warm runs on two solutions between 2026-08-22 and 2026-08-28: the quoted figure correlated with the next run's actual duration at 0.02, landed within a factor of two 9 times in 31, and was out by a median of 119 s against a median actual of 78 s — the error is the size of the quantity. The cause is structural rather than tuning, since a warm run's cost is set by how much source changed since the last one and nothing here observes that; a running median over the same data was no better. Cold and seeded are unchanged, the gap there being minutes against seconds. A
warmline an earlier release wrote into the cost record is left where it is and ignored. -
The setup guide records what a pre-warm running in another server process costs a call queued behind it, because the number on its own reads worse than it is. Measured once in seven days of two sessions on one repository: a call queued 168 s behind the other session's pre-warm of the same solution, then ran warm in 54 s. The pass was building the very cache the call then used, so what the call paid over running cold itself was at most that warm run, less whatever in-flight work a cancel would have thrown away — which is why there is no cross-process stand-down, only the in-process one that has always been there.
-
resharper_cleanup's description now states why one batched call is the rule: every call analyses the whole solution before it rewrites anything, whatever the file count.resharper_inspect'sfilesargument no longer describes itself as scoping the analysis, which it does not — it narrows the findings, and the analysis behind them stays solution-wide. Measured over eight days of ordinary use on two solutions on one machine at 1.6.0, a scoped inspect ran to a median of 269 s (n=10) against 272 s solution-wide (n=27), and a one-file cleanup to 102 s (n=14) against 113 s for ten files or more (n=19). The setup guide carries the same figures. -
The configuration guide now states the rule behind cleanup's silent reverts — a formatting choice no settings layer records is not protected — and adds line joining beside named arguments as its second worked instance. Measured 2026-09-07 against JetBrains Cleanup Code 2026.2.1 under
Built-in: Full Cleanup: a hand-wrapped single-argument lambda call came back as one 123-character line, and settingWRAP_LINEStoFalsedid not prevent it, because that setting governs whether the formatter adds breaks at the margin rather than whether it keeps the ones already written. The join proved intermittent — four consecutive runs joined, twenty-one later ones across every settings combination tried did not — so the guide names no knob for it. The two levers that held in every run are documented instead:// @formatter:off…// @formatter:onaround the region, and extracting the argument to a local so there is no break left to revert. The README carries the rule for readers.
Fixed
-
Calls against different solutions in one server process no longer run their
jbprocesses side by side. A run is a whole-solution, multi-core analysis however narrow the report is, so two of them share the machine rather than the work — and the cross-process cache lock cannot see it, because two solutions are two cache generations and it lets both through. Measured on one machine on 2026-09-04: four cleanups issued a second apart against four solutions ran 367, 413, 476 and 616 seconds, where three were one-file cleanups that take 24 to 50 seconds alone and the slowest crossed the 600-second default cap. Calls are now admitted in arrival order, so a fan-out completes in the order it was issued, and the wait has no cap of its own — the run ahead is one of this server's own and is already ended by the run cap. A call serving that wait out reports it aswaiting for this server's other jb run to finish (it runs one at a time). Two limits: it reaches no further than the process, so another session's server and ajbyou start yourself still run beside it; andresharper_reset_cacheis deliberately outside it, since it spawns nojbat all. -
A
jbthat is installed but too slow to answer is no longer reported as one that is missing. Each candidate is probed withjb inspectcode --versionunder a 30-second cap, and a machine loaded enough — several large solutions analysed at once — can push a probe past it. The cause is contention rather than a broken candidate, so it tends to reach every candidate at once, and the install instructions that followed named a remedy that could not work. Any candidate that starts proves the tool is installed, whether it was killed at the cap or exited non-zero, so those instructions now appear only when no candidate could be started at all. A timed-out probe reports the cap it hit and that retrying is the remedy; one that ran and failed points at the probe command to run by hand. The cap is unchanged at 30 seconds, and the setup guide states the same split. -
resharper_inspectnow names afilesentry that resolves to no file, instead of answering as though the whole scope had been inspected. It reports rather than fails: the tool is read-only, nothing was mutated, and a scoped run is measured to take about as long as a solution-wide one, so failing the call would charge a second full run for what a note gives away free.jb's own behaviour when every entry misses has changed between releases; what no release reports is the partial case, where some entries match,jbexits 0 with their findings, and says nothing about the rest. The note vouches for nothing beyond that: a path that does exist can still match nothing, becausejbmatches the files that belong to a project in the solution, and it says so. -
The note
resharper_inspectleads with when it reports compilation errors now leads with the build, and makes the cache reset conditional on what the build says. Two things produce those errors and the cheaper one is much the commoner: a checkout that was never built, or whose packages were never restored, where every unresolved reference reports at once. The note used to spend most of itself on the other branch, a stale ReSharper index, and closed with the reset as an unconditional instruction — which on an unbuilt checkout drops the cache, blocks the seeding a sibling checkout would have provided, and buys a cold analysis on top of the build that was needed anyway. The reset's own cost is now stated where it is offered.resharper_reset_cache's description carries the same gate, and the setup guide names the unrestored-package origin beside the stale-index one. -
resharper_inspectno longer appends aDETAIL REDUCEDnote to a run that found nothing. The listing isNo issues found.at every detail level, so passingdetailreduced nothing — but the note fired on the level rather than on the reduction, and told the caller that totals and the top rules were all that survived a listing that never existed, closing with an offer to write the findings to a file when there are none. Asking for a report on the same run still writes and names the file, without the claim that the response below it was shortened to fit a budget. -
resharper_cleanupno longer reports0 of 0 file(s) changed on diskwhen everyfilesentry is a wildcard. A count is a measurement: the server hashes each named file before and after the run, and a pattern is expanded byjbagainst the solution model, so there is nothing to hash and nothing to count. An all-wildcard run now says so and confirms thatjbcleaned what the patterns matched; a run mixing the two counts the named files and says the count is over those. A run of named files only reads exactly as it always has. -
A
filesentry longer than the operating system's path limit is now reported as naming no file, rather than failing the call with an error that names nothing. Every entry is resolved to decide whether it exists and translated into the relative spellingjb's--includematches, and both steps already passed a string the path APIs refuse through to the validation that reports it — but only for an embedded null, which raises a different exception type from an over-long path. A call carrying one failed where the same call one character shorter reported the entry. Windows only: on Unix the same resolution is managed code with no length to fail on.
Security
- The Dockerfile's two base images are pinned by digest, so a build of it resolves to the
mcr.microsoft.com/dotnet/sdkanddotnet/runtimelayers the pin names rather than to whatever the10.0tag points at that day. A digest goes stale silently, so.github/dependabot.ymlgained adockerecosystem entry that bumps both weekly — without it the pin would freeze the image on an unpatched base. This is the introspection image MCP directories build to readtools/list; the .NET global tool is packed and published without it.
1.6.0 - 2026-08-30
Added
-
An MCP Bundle (
.mcpb) for Claude Desktop, attached to each release alongside the package. Claude Desktop installs local MCP servers from a bundle rather than from a config file: download it, double click it, and set Solution file to the.slnor.slnxto analyse, which is what tells the server where to look when it is started outside your repository. The bundle holds the server as a framework-dependent publish, 1.6 MB packed at 1.5.0, and still needs the .NET 10 runtime and the ReSharper Command Line Tools installed: a self-contained publish would carry the runtime to remove a prerequisite that installingjbalready implies, sincejbis itself a .NET global tool. The bundle ships with the same SLSA build provenance as the package, verifiable withgh attestation verify. -
A Privacy Policy section in the README, and a Retention section in
PRIVACY.md. The README section states what the server collects (nothing), where the results go, and what the local log holds; the retention statement names the 7-file rolling window on its own rather than inside the paragraph about where logs live.PRIVACY.mdnow covers all three distribution channels, the new bundle included. -
The project icon in the three channels that render one. The NuGet package now sets
PackageIconand packs the 512 px render, which nuget.org draws in listings and serves as the page'sog:image;.mcp/server.jsondeclares aniconsarray pointing at the same renders in this repository, for the MCP registry and the directories that read it; and the server sends an icon inserverInfooninitialize, which clients supporting the 2025-11-25 icons specification display beside the server. None of the three substitutes for another — a NuGet icon reaches neither the registry nor a client's MCP UI. The handshake icon is the 128 px render embedded in the assembly and sent as adata:URI: this server speaks stdio, so it listens on no authority for a client to match a remote icon against, and it has no install path that survives a tool install, adnxcache and a container image alike. It costs about 2.5 KB of base64 once per session and no network fetch. -
A Cline block in the README's "Other clients" section. Cline stores its servers in
cline_mcp_settings.json, which its MCP Servers panel opens under Configure MCP Servers, and runs the same command with no arguments as every other client documented there.llms-install.mdalready carried the block; the README did not. -
A
.cursor-plugin/plugin.json, the manifest Cursor reads. It names the project icon already committed inassets/, which is what a directory or marketplace listing renders. The icon cannot travel in the rootplugin.json: the Agent Plugins schema that file declares setsadditionalProperties: falseand defines nologoproperty, so a logo there would make the manifest invalid against its own$schema. Cursor's schema defines one, taking a path relative to the repository root. The new manifest declares aversionas well, and the release workflow now checks it against the tag, because cursor.directory imports a missing version as1.0.0rather than leaving it blank. Cursor reads the launcher from the rootmcp.json, which is unchanged, and the Claude Code manifest under.claude-plugin/is untouched. -
A
--stdioargument, for launchers that allocate a terminal. The server reads stdin being a terminal as "a person ran this at a prompt" and prints a short message instead of starting, which is right for a person and wrong for a harness that allocates a pseudo-terminal around the pipe it then speaks MCP over. Measured in a container whose stdin was a pseudo-terminal: the message, an exit code of 0 and no MCP output at all, so the run looks successful from outside while the handshake never happened.--stdiostates the intent the terminal check reads wrongly, and the message now names it. Nothing changes for a client that starts the server over pipes, which is every client the README documents. -
A
Dockerfileand aglama.jsonat the repository root. The image builds the server and speaks stdio, so a directory that introspects a server by running it can complete an MCP handshake and readtools/list,resources/listandprompts/list. It installs no JetBrains software: the ReSharper command-line tools are not redistributable, sojbis absent from the image and every tool call in it reports that. It is not a way to run the server against a solution — the global tool in the Quickstart is.glama.jsonnames the repository's maintainer for the listing at glama.ai. -
An Agent Plugins manifest pair at the repository root,
plugin.jsonandmcp.json, so hosts that read that specification — Cursor among them — can install the server without hand-written configuration. The launcher names an exact version the way the Claude Code plugin's does, and the release workflow now checks that pin against the tag alongside the five version fields it already checked. The rootplugin.jsondeliberately declares noversion: the schema makes it optional, nothing installs from it, and a field nothing reads is a field that drifts. Claude Code users are unaffected — its own manifest under.claude-plugin/is unchanged, and the two live side by side. -
A
gemini-extension.json, so the server installs as a Gemini CLI extension. Its launcher names the same exact package version the other manifests name, and both its fields join the set the release workflow checks against the tag. The extension name has to equal the repository directory name, which is why it readsresharper-cli-mcprather than the shorter server key the configuration examples use. -
README setup for Visual Studio, Rider and Junie, and the Codex CLI, in a new "Other clients" section. Visual Studio reads an
.mcp.jsonbeside the solution, so a checked-in file registers the server for everyone working on it; Junie reads~/.junie/mcp/mcp.json, and Rider's AI Assistant takes the same JSON. JetBrains ships no MCP directory anywhere in its ecosystem, so for the IDEs this server's users are most likely to be running, the README is the whole route. The one-click row gains Visual Studio and LM Studio buttons beside the VS Code and Cursor ones. -
An
lhm.plugin.json, the manifest a LobeHub listing is published from. It records the three tools with their titles, hints and argument schemas, both guide resources and thederive_style_guideprompt, captured from the running server rather than transcribed. Itsversionis the listing's own and does not track the server's: the format carries no launcher, so there is no package version in it to keep in step with a release. -
An
llms-install.mdat the repository root: the install path written as a checklist, from the twodotnet tool installcommands through a configuration block for Claude Code, VS Code, Cursor and Cline, to what to do when a call is slow. Point an agent at it and it can install and register the server without a human reading the README first. It is also the file the Cline marketplace requires by that exact name. The README keeps the short version and now links it. -
The MCP registry manifest declares the nine environment variables the server reads, each with the description the README carries, and links the project website. Directories that render a server's configuration surface had nothing to render before, so a reader arriving from one had no way to see that the cache directory or the run cap could be moved without opening the README. Nothing about running the server changes: the file is published by
mcp-publisher, so the additions reach the registry with the next release rather than immediately.
Changed
- The Claude Code plugin launches an exact server version rather than whatever NuGet holds at the
time. Its
dotnet dnxargument now namesZphil.ReSharperCli@<version>, so the marketplace commit a user installs determines the server code that runs; two installs of one commit, weeks apart, no longer execute different builds. The plugin manifest's ownversionmoves with it, because Claude Code ships an installed plugin an update only when that field changes — pinning the launcher alone would have stranded every existing install on its install-time version. Runclaude plugin update resharper-cli-mcp@resharper-cli-mcpto pick up a newer server. Both fields are release-time version sites now, checked against the tag before anything reaches NuGet.
Fixed
-
Progress notifications now carry counters that increase in the order the notifications were written. The counter was assigned before the send, and the send was started without being awaited, so two notifications milliseconds apart could race for the transport and arrive with their numbers transposed. MCP asks one thing of
progress: that it increase, so a client enforcing that was within its rights to reject or mis-render the pair. A client that renders the message text and ignores the counter, which is the common case today, saw nothing wrong. Each notification is now numbered inside the send that carries it, and one send finishes before the next starts. The ten-second heartbeat behind them emits one beat at a time as well: .NET's timer does not serialize its own callbacks, so a loaded machine could run two at once and report a run's elapsed time going backwards. -
resharper_inspectno longer fails a whole run over a single malformed file path injb's report. A SARIF result whosefile://URI the runtime cannot parse — a malformed host, an embedded null — raised an error that reached the caller as a fault in this server, discarding every issue the run had found after the minutes it took to find them. Such a URI is now passed through as written, the same way a plain path already was, and the result is reported alongside the rest.
1.5.0 - 2026-08-26
Added
-
MCP progress notifications from
resharper_inspectandresharper_cleanup. A run in flight reports itself every ten seconds: the wait for another run on the same cache, then the cache statejbopened, then a running count of the files it has analysed, each message carrying the elapsed time and the run cap. A caller can now see a run approaching the cap and raiseRESHARPER_MCP_TIMEOUT_SECSbefore the call fails. Both the ten-second beat and the per-file count come off one timer, so a cold run that names 1,332 files sends about fifty notifications rather than 1,332, and the interior gaps injb's own output — measured at up to 42 seconds mid-stream — are covered by the same mechanism. Notifications reach only a client that sends aprogressToken; one that does not gets an unchanged result, and the parameter stays out of the advertised tool schema. There is no percentage:jbannounces no file count up front and its two sweeps report different totals for one solution, so a bar would be measuring the cap rather than the work. The background pre-warm reports nothing, having no caller to report to. -
resharper_reset_cachereports its queue wait as MCP progress. A reset takes the same per-solution run lock ajbrun does, so it can queue behind another session's analysis for up to the full wait budget — and until now it did so silently, since a reset spawns nojbto stream. It now sends the same ten-second heartbeat the analysis tools send while queued, readingcache reset on App.slnx: waiting for another run on this solution's ReSharper cache — 2 minutes 3 seconds, and goes quiet once it holds the lock, because the deletes take moments and a beat past that point would describe a wait that had ended. The messages name no run cap, since a reset spends none of the run budget. Notifications reach only a client that sends aprogressToken; the tool's schema, its result, and its log line are unchanged. -
A run's progress lines and its timeout message can name what the last comparable run of this solution cost. The heartbeat says how long a run has been going against the cap, but nothing said how long this solution usually takes — the other half of telling slow from stuck. A
jbrun that exits cleanly now records its duration in a sidecar beside the warm marker, keyed by the cache state it started from —cold,seeded, orwarm— because one remembered number would lie: a single measured solution ran 497 seconds cold, 456 seeded, and 39 warm. Where a figure is recorded, the cache-state clause carries it —cold (none on disk; the last cold run took 8 minutes 17 seconds)— on both the opening log line and the progress messages sent whilejbloads the solution, and the timeout message addsThe last cold run of this solution took 8 minutes 17 seconds.beside the advice it already gives. Queue time is excluded from the recorded duration; a run against a part-built cache records and quotes nothing, since two resumptions of differently killed runs are not comparable; a freshly seeded checkout quotes nothing until a run of its own finishes; andresharper_reset_cacheclears the record along with the warm marker. With no figure recorded, every line reads byte-for-byte as it did. -
The warm marker records the
jbbuild that wrote it, and a cache another build wrote reads asstalerather thanwarm. Measured across the 2026.2.0.2 → 2026.2.1 patch bump, on a static tree and a fresh cache home: the old build's cold run took 116 seconds, the new build's first run over that same generation took 220, and its immediate second run took 64 —jbgets no warm-run value from an earlier build's cache and does cold-shaped work rebuilding it in place, while the cache-state line promised a minute. The line now readsstale (cache written by jb 2026.2.0.2, this is 2026.2.1, and jb rebuilds it), the recorded-cost quote switches to the cold figure for the same reason, and a sibling checkout whose cache an earlier build wrote is passed over as a seeding donor. A marker written before this release names no build and reads as stale until the next clean run rewrites it. JetBrains ships roughly thirty stable releases a year, so an upgrade is routine rather than rare. -
A
reportargument onresharper_inspect. Set it toMarkdownand the complete itemised findings are written to a file, which the response names above the summary it already returned. This is the way to get every finding with its own message out of a solution-wide run: such a run always exceeds the output budget, and the rendering that fits collapses issues repeating a rule within a file to one example. It is off by default, and markdown is the only format —jbwrites one report per run and this server needs the SARIF to build the summary, so XML, HTML or raw SARIF would each cost a second full run. The file lands under the system temp directory, in a directory the server owns, and is deleted once it is 7 days old. -
A
detailargument onresharper_inspect, naming the most detailed level its response may use —Fulldown to a one-lineMinimal. Until now the only way to reach the rollup was to overflow the output budget and let the ladder fall into it. It caps rather than pins: rendering starts at the level named and still steps below it when the result does not fit, so nothing is chopped mid-line, and theDETAIL REDUCEDnote says which of the two happened. A level that was asked for no longer suggests narrowing the scan, since the caller has just done that. Thejbrun is unaffected — the same analysis, the same issues, fewer of them spelt out — andFull, the default, leaves every existing response byte-for-byte as it was. Pairs withreport:detail=Minimal report=Markdowngives a one-line verdict in the response and every finding in the file. -
The file log records what each call did to the ReSharper cache. At
Information, ajbrun is bracketed by two lines: one as it starts, naming whether the cache was warm, cold, part-built or dropped by a reset and how long the run queued behind another, and one as it ends, with the exit code and the duration. Cache transplants state whether they seeded and why not when they declined, and a seeded run reports the donor's size and how long the copy took. A cache reset says what it dropped. A pre-warm names how its pass ended —Warmed,Failed,Cappedfor one killed at the run cap,Cancelledfor one a tool call took the cache generation back from, andSkippedonly when nojbstarted at all. Raise the level withRESHARPER_MCP_LOG_LEVEL=Information; the default staysWarning. -
A startup line naming the version, process id, cache home, resolved run cap and pre-warm setting, so the configuration a server is actually running under can be read rather than inferred.
-
A
runcolumn: a four-digit counter over one process, carried by every line one tool call or one pre-warm pass causes. Concurrent work shares the daily log file, and this is what reads it apart. Lines belonging to no run — startup, shutdown — show----. -
One
Debugline perjbcandidate probed during discovery, naming the candidate, what it answered and how long the probe took. A candidate that fails before a later one succeeds left no trace at any level: the common case isjbmissing from thePATHan MCP client hands its child, so discovery falls through to~/.dotnet/tools, and the probe that failed first escapes before the process lines are written. Its cost reached the reader only as an unexplained delay ahead of the first call. -
A README badge naming the latest stable ReSharper command-line tools release the daily contract check verified. The check publishes the version it tested as Shields endpoint JSON on a workflow-owned
badgesbranch — green when the run held on every runner, red naming the version that did not — and a dispatch that pins a version or opts into prereleases leaves the badge alone.
Changed
- The timeout message no longer promises that a retry "resumes rather than starting over" without evidence. A run killed having analysed forty files and one killed at 1,200 read identically before; the message now names the count when it has one, and keeps the general wording when it does not. The log line for a run killed at the cap carries the same count.
- The pre-warm's outcome moved from
DebugtoInformation, pairing with the start it already logged. AtInformationa log previously showed pre-warms beginning and never ending. ModelContextProtocolandMicrosoft.Hostingare held atWarning, soInformationcarries what this server did rather than framework chatter. The per-request timing the MCP SDK used to supply is replaced by this server's own run lines.- Every log line now carries the class that wrote it. Most previously came from a static logger that bypassed the logging pipeline and rendered with an empty source field.
- The README opens with the cache lifecycle the server runs over
jb(the run queue, checkout seeding, the background pre-warm, cache reset, and output sizing) before installation, and drops the detail theresharper://guides/setupandresharper://guides/configurationresources already carry. - The README and the setup guide no longer claim warm runs "finish in seconds", which no measured run supported. Cache durations are stated as properties of the machine and the solution (cold takes minutes, warm is several times faster, and warm cost does not track file count), with the guidance to time your own solution rather than extrapolate from its size. The seeded-cache premium is likewise stated as a cost that grows with the donor's size and the checkouts' drift, not as a number.
Fixed
- A server killed outright — as happens when the tool binary is replaced under a running session — no longer
strands the
jbit had going. A strandedjbkeeps the ReSharper cache generation open after the OS has released the dead server's queue lock, so the next run reads the queue as free, starts anyway, andjbforks a second empty generation rather than waiting: that run does cold-cache work, and the fork stays on disk and is counted in the cache from then on. A shutdown the client asks for was never affected — the server already waits for a speculativejbto let go before exiting. Each platform now gets the strongest primitive it offers, and they are not equivalent. On Windows a job object withKILL_ON_JOB_CLOSEcoversjband everythingjbstarts, and holds through a kill no in-process handler can intercept. On Linuxsetpriv --pdeathsig SIGKILLcoversjbitself but not a worker it forks afterwards, and needs util-linux 2.33 or later. macOS has no equivalent and keeps the previous behaviour, as does any machine where the primitive cannot be set up. The startup line names the guarantee in force asorphan guard, andresharper_reset_cachestill clears a fork already on disk.
1.4.0 - 2026-08-16
Changed
- Seeding a fresh checkout's cache from a warm copy of the same repository now also fires where the
checkout holds the part-built remnant of a run that never finished — until now the deliberate rule
was that any existing generation is left alone, and in the field that rule meant the feature never fired
at all. The shape is circular: the first run on a new checkout is exactly the one long enough to hit the
cap, and the moment it is killed it leaves a stunted cache behind; from then on there is a generation
there, so every later call declines to seed and resumes the stunted one instead. A reset was no remedy
either, since it records that the next run is meant to be cold. What separates a cache worth keeping from
those leftovers is the marker every successful run leaves beside its generation: a marker means hands
off — any marker, including the empty form older versions wrote — and no marker at all means no run
against that path ever finished. Nothing is deleted until the whole copy has been made and is standing
beside the remnant, so a copy that fails or is cancelled leaves the remnant exactly where it was and the
run resumes it as before.
resharper_reset_cacheis unchanged and still outranks all of this: a reset is a request for a cold rebuild, and it is honoured until a run against that solution succeeds. One bounded residual: a checkout analysed only byjbdirectly, never through this server, has no marker for the server to read, so its cache reads as leftovers and can be replaced by a copy — costing one re-key, once. Measured on a real remnant: a 21 MB generation left by a run killed two days earlier was replaced by a 277 MB copy of the warm checkout beside it, and the call it had been blocking returned in 456 s where the same call had previously been killed at the cap having produced nothing.
Fixed
--settingsis no longer passed for a settings filejbdiscovers on its own — the{solution}.DotSettingsbeside the solution, or the machine-wideGlobalSettingsStorage.DotSettingswhen no adjacent file exists. The flag is not additive: it mounts its file as a Custom layer above ReSharper's whole layer stack, so passing an already-discovered file silently demoted every project's own{project}.csproj.DotSettings— the layer that outranks the solution's on a directjbrun, and exactly how a repo narrows a rule for one project. Measured on a solution carrying such a layer: a directjbrun reported 0 findings and this server reported 83, every one of them scoped away by the project layer it had demoted. The global case was the same bug one level up, and worse for being personal configuration: in a repo with no.sln.DotSettings, a machine-wide IDE preferences file outranked every layer the repo checked in. Both tools now agree with a direct run, and--settingsis reserved for the case it exists for — aJB_SETTINGS_PATHnaming a filejbcannot find itself. One visible side effect: a{solution}.DotSettings.usernow outranks{solution}.DotSettings, which isjb's own default and matches the IDE.resharper_reset_cacheno longer queues behind the background cache pre-warm. The rule that a call you are waiting on outranks speculative work was written into the code that runsjb, so the one tool that runs nojbat all was the one it never covered: a reset took the queue lock directly and waited its turn — for up to the whole run cap, behind a pass rebuilding exactly what it had been called to delete. That precedence now belongs to the callers rather than to the spawn, and is taken by everything you are waiting on whether or not it runsjb. Reclaiming is faster than queueing but not instant: the cache generation comes free only once the cancelledjbhas been killed and reaped, so a reset can still spend a second or two on the lock — against minutes before. Admitted that quickly, it can also meet a dyingjbstill holding memory-mapped cache files, so a delete the filesystem refuses is now retried briefly before being reported.- A call that cancels the background pre-warm is no longer denied the warm cache it was about to be seeded
from. Cancelling kills the speculative
jband the killed run keeps its place in the queue until that process tree has been reaped — up to five seconds — while the call went looking for a cache to copy after waiting only two. Where the two are different solutions the call's own queue place is uncontended and granted at once, so it arrived early, found the cache it wanted still held by the run it had just killed, and did what it does at any other doubt: declined silently and took the cold run seeding exists to avoid. That is the fresh-worktree case the seeding was built for. The wait is now derived from the reap rather than set beside it, so the two cannot drift apart again. - A
filesentry written as an absolute path now reachesjbin a spelling it can match.--includetakes "a set of relative paths" and wildcards —jb's own help text — and matches them against the solution model rather than against the disk, so an absolute path arrived as a pattern that could never hit.resharper_cleanupshowed it as exit code 3 andNo items were found to cleanup; measured in the field, 27 absolute paths cleaned nothing while the same 27 passed relative to the solution root cleaned every one.resharper_inspectwas quieter and worse:jbexits 0 having matched nothing, so a scan that looked at no file at all came back asNo issues found.Both tools now translate an absolute entry against the solution root on the way tojb, which is what makes the documented "relative to the solution root, or absolute" true rather than aspirational. An entry with no relative form — one on another volume — is passed as it was written, and cleanup's report still echoes the path you asked for rather than the translated one. - A
resharper_cleanuprun thatjbexits non-zero on is now reported as a failed pass. The wording is the fix:jb's own isNo items were found to cleanup, and an error quoting that verbatim reads as "nothing needed changing" to an agent that has just edited the files it named — which is how a whole cleanup pass came to be skipped after 27 edits. The error now says outright that no file was cleaned up, lists the--includepatternsjbwas given (the translated spelling, which is the one thing the caller cannot otherwise see), and names what still causes a run to match nothing: a file that is on disk but belongs to no project in the solution. A run killed at the ten-minute cap keeps its own message — it may already have rewritten files, so it cannot claim otherwise.
1.3.0 - 2026-08-13
Added
resharper_reset_cachedrops the solution's ReSharper cache generations, so the next inspection or cleanup rebuilds its analysis from cold. ReSharper's solution-wide index can miss invalidating the consumers of a declaration you reshaped, and it then reportsCannot resolve symbolin files nobody edited while the compiler and the test suite stay green — indefinitely, because re-running returns the identical set. The ReSharper CLI exposes no cache-invalidation option of its own (--caches-homeonly chooses where caches live), and this server picks that directory, so the operation belongs here. It takes the same queue lock the analysis tools take, and holds it across the delete: a reset waits for ajbrun in flight rather than deleting the cache underneath it, and a run starting meanwhile waits for the reset — which deleting the directories by hand cannot do. It also reclaims the cold generations a concurrentjbforks and abandons. It drops only what provably belongs to the solution it was pointed at:jb's directory names record a hash of the solution's full path, which the server reproduces, so a cache home shared by two checkouts of one repository is ordinary — the generations carrying another path's hash are named in the report and left where they are, and a hash matching nothing deletes nothing.- A solution with no ReSharper cache is now seeded from a warm one belonging to another copy of the same
solution, before the run that would otherwise build it from cold.
jbkeys a cache generation by the solution's absolute path, so every freshgit worktree— or clone, or copied directory — is cold however much analysis of the same code sits beside it in the cache home, and the pre-warm cannot cover it: it warms whatever solution the server's directory resolves, while a session working in a worktree passes its ownsolutionPathon every call. That leaves the one case where a cold run is guaranteed as also the one most likely to exceed the cap and come back as a timeout. Nothing inside a cache binds it to a path —jbvalidates a generation against its own format version and rebuilds it in place when that does not match — so the copy is either accepted and re-keyed by the run that opens it or discarded exactly as an absent cache would be. Re-keying is not free: it costsjbabout a minute, near enough the same on a small solution as on a large one, in exchange for the difference between a cold analysis and a warm one. That makes this a decisive win where a cold run would have passed the cap and a poor trade on a solution that goes cold in a minute anyway, which is worth knowing before reading the copy as free speed. Two guardrails keep it honest. The generation to copy is named by the marker a successful run writes rather than derived fromjb's undocumented directory naming, so if that naming ever changes there is no name to record, no donor to find, and the feature switches itself off instead of copying to a directory nothing will read. And a reset still means cold:resharper_reset_cacheleaves a record that suppresses seeding entirely until a run against that solution succeeds, so the tool for getting rid of a bad index cannot be undone by an optimisation. Everything else about it is best-effort and silent — no donor, a donor anotherjbcurrently holds, a copy that fails part way, or a generation already in place (a stunted one included) all end in the cold run the call was going to have. - An inspection result that contains compilation errors now leads with a note saying how to read them: build the solution, and if the compiler accepts the code the index is stale and the errors are phantoms that will repeat on every re-run. It names the resolved cache directory, which the caller cannot derive, and the tool that clears it. The note states the discriminator rather than a conclusion — this server cannot tell a phantom from a genuine compilation error, and an agent mid-edit usually has the real kind. Like the configuration warnings, it is charged to the output budget before the result is rendered, so it survives every step of detail reduction.
- The
resharper://guides/setupresource gains a "Phantom compilation errors" section covering the same ground at length: the signature, the build test that identifies it, the cure, and why--no-buildis not the cause —jbbuilds its solution model from source for a solution's own projects and resolves declarations added since the last build without one.
Changed
- Each
jbrun is now capped at 10 minutes rather than 5, and the newRESHARPER_MCP_TIMEOUT_SECSmoves that cap (in seconds, default600, clamped to 60–86,400; anything unreadable falls back to the default). It takes the server's own prefix rather thanJB_, because that is the line the existing variables already draw: everyJB_one becomes somethingjbis told, and this one arms a kill timerjbnever learns about. Seconds rather than minutes so a cap can be pitched just above a run you have timed, and a cap that is not a round number of minutes is reported back the way you set it — a run stopped at 455 seconds says "7 minutes 35 seconds", not "8 minutes". The old cap sat inside the normal working range of a cold whole-solution analysis rather than beyond it, so it killed runs that were making steady progress. Nothing outside this server ever asked for it either — an MCP client's own tool-call limit is far longer — which means a timeout here has always been this server's own choice, and is now one you can change. The same value bounds the queue wait, so a call stays bounded by wait + run. - A run that hits the cap now says whose cap it is, names the variable that raises it, and heads off the
retry that cannot work:
jbanalyses the whole solution whatever the report is scoped to, so narrowing a retry withfilesmakes it no faster. The setup guide previously advised exactly that; it no longer does. - A tool call that hits the run cap now arms another background cache pre-warm, against the solution that
timed out. Previously the first tool call to reach the runner retired speculative work for the life of the
process, so the moment it was worth most — the cache part-built, the error advising a retry, the user idle
reading it — was exactly the moment the server had guaranteed it would never run again. Measurement
settled the assumption that advice rests on: a run killed at the cap does leave a cache a retry resumes
from, and the resumed run reports the same issues a clean cold run does. It does not resume from exactly
where it stopped, though — whatever was in flight when it was killed is redone — so several capped runs
still cost appreciably more than one run allowed to finish, and raising
RESHARPER_MCP_TIMEOUT_SECSremains the fix when a cold analysis simply takes longer than the cap. The pre-warm still runs one pass at a time, still stands down while a real call is in flight, and re-arms on nothing else: not a timer, not each message, and never on its own timeout.
Fixed
- A background cache pre-warm that runs out of that budget is an ordinary skip rather than an unexpected failure. Speculative work has nobody waiting on it, and a solution large enough to exceed the cap from cold is precisely the one pre-warming exists for, so it no longer logs a warning for its own best case.
1.2.1 - 2026-08-07
Fixed
- A
.DotSettingsfile that ReSharper reads happily no longer turns the declared-cleanup-profile feature off. The profile a solution declares was read with a strict XML parser, and ReSharper's own settings reader is more forgiving than the XML spec — most visibly about comment content, where a--inside<!-- … -->is illegal XML that ReSharper andjbaccept without complaint. One such comment in a settings file meant everyresharper_cleanupcall that omittedprofilesilently appliedBuilt-in: Full Cleanupinstead of the profile the repo had declared — measured in the field, and the broader profile strips exactly the named arguments a narrowed profile is usually defined to protect. A file that fails a strict parse is now retried with its comments discarded, so it reads asjbreads it. A well-formed file takes the same path it always did and cannot be affected by the retry. - Configuration that was silently dropped is now reported in the tool result instead of only in a log file.
A settings file this server cannot read at all makes
resharper_cleanuplead with a warning naming the file and the fault: the fallback profile has already rewritten the files by the time the result is rendered, so it is not something to leave in a log.resharper_inspectstays quiet about that one —jbreceived the settings file and parses it itself, so inspection severities are unaffected. The other case,JB_SETTINGS_PATHnaming a file that does not exist, drops the settings from the run entirely and so is reported by both tools. The warning is charged to the output budget before the result is rendered, so it survives every step of detail reduction and the total stays within budget as before. - A
fileselement that joins several paths —["a.cs, b.cs"]where["a.cs", "b.cs"]was meant — now works on both tools instead of throwing the call away. It is a mistake the array parameter invites, and it failed in two different ways:resharper_cleanuprejected the joined string as a file that does not exist, whileresharper_inspecthanded it tojbas one pattern, matched nothing, and reported "No issues found." — a clean bill of health for a scan that never looked at the files asked for. Elements are now split on;and,at the tool edge, with surrounding whitespace trimmed. An element that names a file that really is on disk is never reinterpreted, so a legitimateFoo,Bar.csstill cleans up and splitting can only rescue a call that was otherwise certain to fail; and when a fragment does not exist, the error names that fragment rather than the whole joined string.
1.2.0 - 2026-08-05
Added
- The server now warms the ReSharper cache in the background as soon as a client connects, so the cold
run a session's first call would otherwise pay for happens during the idle minutes before it. It targets
exactly the solution a call with no
solutionPathwould find and does nothing when there is none, runs at most once per session, and is skipped when anyjbrun against that solution's cache succeeded within the last hour — a real tool call refreshes that just as a pre-warm does, so working in a repo does not earn its next session a redundant analysis. A tool call arriving while one is in flight cancels it and takes the cache, waiting only forjbto be killed and reaped rather than for the run to finish, so within one server process pre-warming can never make a call slower. Across processes it can: a pre-warm in another server cannot be cancelled, so a call there queues behind it exactly as it queues behind another session's real call. It is a full solution analysis, andRESHARPER_MCP_PREWARM=offturns it off. Being honest about the size of this: it does not make warm runs faster — 1.1.1's run serialization did that — it moves the cold cost off the first call and onto session start.
Changed
- A solution-wide
resharper_inspectnow comes back complete instead of cut off. Previously a result over the output budget was chopped at a line boundary, so the tail of the list simply vanished and the only remedy was to re-run more narrowly — and the budget was usually spent on near-duplicates: one real run returned 150 issues across 24 files, 120 of them the same rule repeated across four DTO files, each message naming a different property. That run now returns complete at about 30% of its former size, every issue counted and every file named. Issues repeating a rule within a file collapse to one line carrying their line numbers and one example message (`NotAccessedPositionalProperty.Global` [WARNING] x30, lines 13-42), and if that is still too large the response steps down further — the eight most-affected files, then a rules-and-files rollup, then a one-line summary — each step naming itself in aDETAIL REDUCEDnote. A truncated result was an incomplete list of issues; a reduced one is complete but less detailed, so it is safe to conclude from. A scan already within budget is byte-for-byte unchanged, and hard truncation remains only as a last-resort backstop.resharper_cleanup, which has degraded this way since 1.0.2, now describes its own reduction per level in the same note rather than a generic one.
Fixed
- Two sessions working on one solution no longer make each other slow, or leave stale caches behind.
ReSharper lets only one
jbat a time use a solution's cache, and a second one that tries does not wait — it silently forks an empty copy of the cache and starts from cold. Both runs then pay the cold-cache cost, and the one that lost the race usually times out: in a measured case it had covered 79 of a solution's 208 files by the time the run holding the warm cache had finished all 208. The forked copy is permanent, too, at a few hundred megabytes each. Calls against one solution now queue for the warm cache instead of forking, across every client on the machine, since it is the cache that is contended rather than the server. A call waits up to 5 minutes for a run already in flight before starting its own 5-minute run; if that wait runs out, the error says a run against that solution is already going rather than starting a second one. Nothing changes when only one call is running. - A broken
jbinstallation is no longer mistaken for a working one, and no longer stops the search. An installation was accepted on the strength of its probe exiting cleanly, so one that exited 0 without printing a version was adopted and then failed on the first real call; worse, one that printed nothing at all ended discovery with an unhandled error rather than moving on. Both now count as a failed candidate, so the search continues to the next location and, when none work, ends at the same message naming everything it tried and how to install the ReSharper command line tools.
1.1.1 - 2026-08-01
Changed
- Moved to version 2.0.0 of the MCP C# SDK, which implements the 2026-07-28 protocol revision. A client
that speaks it discovers the server through
server/discoverrather than theinitializehandshake and holds no session, reaching the same two tools, prompt, and guide resources with the same schemas and the same argument handling. Clients on earlier revisions are unaffected: aninitializehandshake returns exactly what it returned before.
1.1.0 - 2026-07-27
Added
- Claude Code plugin install. This repository doubles as a single-plugin marketplace, so
/plugin marketplace add andypgray/resharper-cli-mcpfollowed by/plugin install resharper-cli-mcp@resharper-cli-mcpbrings up both tools, thederive_style_guideprompt, and both guide resources without hand-editing.mcp.json. The plugin starts the server withdotnet dnx, which fetches the package from NuGet on first use, so there is nodotnet tool installstep for the wrapper itself, and it points ReSharper's caches at the plugin's own data directory rather than your source tree. A new PRIVACY.md states what the server does and does not send anywhere: nothing leaves the machine. resharper://guides/setupMCP resource — an on-demand guide to running the server, as opposed to configuring ReSharper: installing and locatingjb(PATH, then~/.dotnet/tools, because the child process an MCP client starts often does not inherit the shell'sPATH), which solution a call runs against and why discovery is top-level-only with no parent walk, why the first call is slow and what the 5-minute cap means, howMAX_MCP_OUTPUT_TOKENScaps output and why a truncated inspection is an incomplete list of issues rather than a clean solution, every environment variable, and where logs go. Two guides rather than one broadened one: each names a single routing condition, so a "why did this time out?" pull does not also load 8 KB of.DotSettingsprose, and vice versa.
Changed
- The always-loaded server instructions are down from 1,960 to 992 bytes (−49%) — a measured 262 fewer
resident tokens in every session that connects this server, including the majority that never call a
tool. Clients that defer tool schemas (Claude Code 2.1.220 and later) keep only tool names resident and
fetch each schema on demand, but server instructions still ride verbatim in every session's system
prompt, so the instructions now carry only the cross-tool routing that no single schema can state: which
tool is read-only, the call-cleanup-once-at-the-end batching rule, that cleanup cannot change behavior
and so needs no re-inspect or rebuild, and one conditional signpost per guide resource. The per-tool
restatements, the
filesglob syntax, theseverityvalue list (already carried by the schema'senumarray), solution discovery, the cold-cache note, and the timeout all moved into the tool schemas and the two guide resources. The unofficial-wrapper notice moved too: it stays where a human reads it — the NuGet description, the README's first paragraph, and.mcp/server.json— and still travels to agents in both guide resources and in the server title negotiated oninitialize. No behavior change. - Tool parameter descriptions gained the gotchas that left the instructions, at per-fetch instead of
per-session cost:
solutionPathnow records that it overridesJB_SOLUTION_PATHand working-directory discovery (and no longer says "to analyze", which was never right for the mutating tool),resharper_inspect'sfilesshows the glob format, itsseveritywarns thatErroris ReSharper's compilation-error level rather than a tier of high-priority warnings so raising to it usually reports nothing, andresharper_cleanup'sfilesrecords that a non-wildcard path that does not exist fails the whole call before anything is rewritten. - The
resharper://guides/configurationresource and its description now scope themselves explicitly to what ReSharper enforces and point onward toresharper://guides/setupfor anything about running the server. resharper_cleanupnow takes its default profile from the solution instead of always falling back toBuilt-in: Full Cleanup. With noprofileargument it uses the profile named under/Default/CodeStyle/CodeCleanup/SilentCleanupProfile/@EntryValuein the resolved settings file — ReSharper's own "profile to use when nobody picks one" — andBuilt-in: Full Cleanuponly when no settings file declares one. This is what makes a repo-wide narrowing stick: a repo that defined a profile to protect a deliberate style had to get every caller to pass its name, and an agent that did not know the profile existed silently got Full Cleanup and the rewrite the profile was meant to prevent. Theprofileargument still overrides, per call. An unreadable or malformed settings file degrades to the built-in default with a warning rather than failing the call.- The
resharper://guides/configurationresource gains the profile-resolution order, the fact that a cleanup profile is a full enumeration rather than a diff against a built-in (an omitted task reads as off), why an inspection severity provably cannot reach cleanup (cleanup overrides the severity of every rule its enabled modules need), and that the trailing newline at EOF is an editorconfig-only knob with no.DotSettingsequivalent. - Solution, settings, and cleanup-profile discovery now runs on every call instead of being cached per
solution for the life of the server process. Without this the declared-profile feature above could not
be adopted in the session that adopts it: an agent following the configuration guide would write the
SilentCleanupProfileentry, callresharper_cleanup, and still get Full Cleanup from the cached pre-edit config — the exact rewrite the profile was defined to prevent — until the client restarted the server. Thejb inspectcode --versionprobe, the one genuinely expensive step, is still cached for the process; what now repeats is a directory enumeration, a few existence checks, and a small XML read, against ajbrun that takes seconds to minutes. - The
derive_style_guideprompt teaches declaring the profile underSilentCleanupProfilerather than passingprofileon every call, and warns that a profile is a full enumeration of tasks rather than a diff against a built-in — it is the surface most likely to author the.sln.DotSettingsthe rest of this release reads.
Fixed
- A blank
profileargument (""or whitespace) no longer reaches jb as--profile=and fails the run. It now reads as unspecified and falls through to the solution's declared profile, matching how a blank declared profile already read; a padded name is trimmed. The rule has one definition, shared by both entry points. - A blank entry in
resharper_cleanup'sfilesnow fails as a user error naming the offending position, instead of surfacing anArgumentExceptionfrom path resolution as an internal server error.
1.0.2 - 2026-07-15
Added
resharper://guides/configurationMCP resource — an on-demand guide to how ReSharper configuration works: inspection severities driveresharper_inspectwhile the cleanup profile drivesresharper_cleanup(two independent axes — hiding an inspection does not stop cleanup), how to protect a deliberate style from cleanup, settings and.editorconfigdiscovery, and the.DotSettingskey shapes. The always-loaded server instructions carry only a short signpost pointing at it.
Changed
resharper_cleanupnow reports which files it actually changed on disk, hashing each concrete file before and after the run and classifying it as changed, unchanged, status-unknown, or a wildcard pattern — instead of a bare "completed" line that hid whether cleanup rewrote a file. Solution-wide runs degrade the per-file detail progressively to stay within the output budget. Purely observational: the cleanup itself is unchanged.
1.0.1 - 2026-07-10
Fixed
- Package the MCP manifest at
.mcp/server.json. It was landing at.mcp//server.json(a double slash) because the csprojPackagePathused a backslash and packing runs on Linux, so nuget.org could not generate the VS Code MCP server configuration. No change to server behavior.
1.0.0 - 2026-07-09
Initial public release — an MCP stdio server wrapping JetBrains' ReSharper Command Line Tools. Unofficial; not affiliated with or endorsed by JetBrains.
Added
resharper_inspecttool — runs ReSharper InspectCode over the solution and returns the issues grouped by file (read-only). Scope with afilesglob and filter byseverity.resharper_cleanuptool — runs ReSharper CleanupCode to reformat and normalize the given files in place, using a named cleanupprofile.derive_style_guideprompt — walks an agent through deriving an intentional,.editorconfig-first ReSharper/StyleCop style guide for a legacy codebase, validated withresharper_inspect.- Solution, settings, and
jbdiscovery from the working directory or theJB_SOLUTION_PATH,JB_SETTINGS_PATH,JB_CACHE_HOME,JB_EXTENSIONS, andJB_EXTENSION_SOURCEenvironment variables. - Output truncation honoring the client's
MAX_MCP_OUTPUT_TOKENSbudget. - Ships as a .NET global tool and MCP server (
PackAsTool+PackageType=McpServer), published to NuGet with SLSA build provenance and registered on the MCP registry.