RoselineMCP

Analyze a C# solution and return diagnostics summary with details about errors, warnings, and info messages. Read-only: never modifies any files on disk. Limitations: loads a fresh workspace per call (no cache reuse), so it is slower than the project-scoped tools; MSBuild evaluation executes the project's own build logic; only http(s) URLs are treated as Git remotes. Example: analyze_solution{pathOrGit:'/repo/App.sln', severity:'Warning', maxDiagnostics:50} -> summary + top diagnostics.

Apply code fixes for specified diagnostic IDs in a project. Defaults to preview mode: with previewOnly left unset (or true), no files are changed and only a diff is returned. Pass previewOnly=false explicitly to write the fixes to disk. Limitations: a .sln target fixes only its primary project — siblings are skipped and named in notes[]; IDs with no registered fixer are reported, not fixed; a change that introduces compiler errors is refused (applied=false, nothing written). Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: apply_fixes{ids:['RCS1213']} -> resolvedPath + changed files + patch + verification (preview; add previewOnly:false to write).

Does this code compile right now, and what broke? Compiler errors only, in under a second on a warm workspace — use this INSTEAD OF running `dotnet build` after an edit, and after edits made by any tool, not just RoselineMCP's. Read-only: never modifies any files on disk. For an exploratory inventory of code quality — analyzer diagnostics (Roslynator RCS*, StyleCop, the project's own analyzers), severity statistics and which IDs are auto-fixable — use list_diagnostics instead; it is the slower, broader tool. Rule of thumb: check_compilation answers "is it still building?", list_diagnostics answers "what should I clean up?". Limitations: compiler diagnostics only, no analyzers; scopeComplete=false means not every dependent was seen. Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: check_compilation{} -> resolvedPath + compiles + errors[] + scope/scopeComplete.

Create a unified diff patch between two text blobs. Read-only: operates purely on the provided strings and never touches the filesystem. Limitations: a pure string diff — it never reads or writes files, and fileName only labels the patch header. Example: create_patch{before:'a', after:'b', fileName:'x.cs'} -> unified diff + line counts.

Surgically replace, add, or delete a single C# member (method/property/field/etc.) and return a unified diff — instead of rewriting the whole file. Defaults to preview mode: with previewOnly left unset (or true), no files are changed. Pass previewOnly=false explicitly to write the change to disk. Limitations: one member at a time; refused if the change introduces compiler errors unless allowIntroducedErrors=true. Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: edit_member{symbol:'UserService.GetUser', operation:'replace', newSource:'public User GetUser(int id) => _db.Find(id);'} -> diff + verification.

List the implementations of an interface/member, overrides of a virtual/abstract member, or derived types of a class — as compact summaries, instead of reading candidate files to find them. Prefer this over Grep/Read to answer 'who implements/overrides/derives from this'. Read-only: never modifies any files on disk. Limitations: capped by max (default 100); spans the loaded solution only. Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: find_implementations{symbol:'IRepository'} -> resolvedPath + implementations[] + totalFound.

List every use site of a C# symbol across the whole solution (file/line + a one-line snippet each) — instead of grepping and opening every referencing file. Prefer this over Grep/Read to answer 'where is this used'. Read-only: never modifies any files on disk. Limitations: capped by max (default 100); finds source references only, not reflection or string-based use. Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: find_references{symbol:'UserService.GetUser', max:50} -> resolvedPath + references[] (file, line, snippet).

Trace who calls a C# method (and/or what it calls) as a depth-bounded, cycle-safe tree — instead of reading method bodies to follow control flow. Prefer this over Read to answer 'who calls this' / 'what does this call'. Read-only: never modifies any files on disk. Limitations: depth is capped at 3; virtual/interface dispatch resolves to declarations, not runtime targets. Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: get_call_graph{method:'GetUser', direction:'callers', depth:2} -> a cycle-safe caller tree.

You have a file and line (from a diagnostic, stack trace, grep, or find_references) and want to know what C# symbol lives there — prefer this over Read. Resolves the position to the symbol (declared or referenced), returning its name, kind, signature, definition location, and isDeclaration; feed the fullName straight into get_symbol_info/find_references. Read-only: never modifies any files on disk. Limitations: file matches by name/path suffix, so an ambiguous suffix can resolve the wrong file; line-only prefers declarations. Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: get_symbol_at_position{file:'UserService.cs', line:42} -> the symbol there + isDeclaration.

Look up one C# symbol's kind, modifiers, signature, base types/interfaces, XML docs, and definition location — the token-cheap 'go to definition'. Prefer this over reading the whole file; pass includeSource:true to get the member's exact body instead of Read. Read-only: never modifies any files on disk. Limitations: a simple name can match several symbols — pass a fully-qualified name to disambiguate. Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: get_symbol_info{symbol:'UserService.GetUser', includeSource:true} -> signature, docs, definition, source.

Show a C# type's base-class chain, implemented interfaces, and/or derived types as compact summaries — instead of reading the declaring files. Prefer this over Read/Grep to answer 'what does this inherit / who derives from it'. Read-only: never modifies any files on disk. Limitations: derived types are capped by max (default 100) and limited to the loaded solution. Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: get_type_hierarchy{type:'UserService', direction:'both'} -> base chain, interfaces, derived types.

What should I clean up here? A broad inventory of a project's diagnostics — compiler AND analyzer (Roslynator RCS*, StyleCop, the project's own analyzer references) — with per-ID and per-severity statistics and which IDs apply_fixes can fix. Read-only: never modifies any files on disk. Running the analyzers costs several times a bare compile, so this is the exploratory tool, not the edit-loop one. To ask "is it still building?" after an edit — compiler errors only, in under a second — use check_compilation instead. Limitations: runs third-party analyzers in-process; RoselineMCP:RunAnalyzers=false makes it compiler-only. Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: list_diagnostics{ids:['CS0168'], max:50} -> resolvedPath + diagnostics[] + per-ID/severity stats.

Rename a C# symbol and update every reference across the solution using Roslyn, returning a unified diff. Defaults to preview mode: with previewOnly left unset (or true), no files are changed. Pass previewOnly=false explicitly to write the changes to disk. Limitations: the multi-file write is NOT atomic — an interrupted rename leaves some files written and some not. Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: rename_symbol{symbol:'UserService.GetUser', newName:'FindUser'} -> changed files + diff + verification (preview; add previewOnly:false to write).

Locate C# symbols by name (wildcard/substring), or outline a whole file, WITHOUT opening it. Prefer this over Read/Grep to find or survey code in an existing solution — it returns compact signatures + locations and costs far fewer tokens than reading files, especially large ones. Read-only: never modifies any files on disk. Limitations: capped by max (default 50); truncated says results were cut, not that none exist. Auto-discovery uses the SERVER's working directory (fixed at spawn), not yours: in a git worktree an omitted project silently resolves the MAIN checkout — check resolvedPath (also on failures, once a project resolved) or pass an absolute .sln/.csproj path. Example: search_symbols{query:'*Service', kinds:['class'], max:20} -> resolvedPath + symbol summaries.