SharpTools: Roslyn Powered C# Analysis & Modification MCP Server

SharpTools is a robust service designed to empower AI agents with advanced capabilities for understanding, analyzing, and modifying C# codebases. It leverages the .NET Compiler Platform (Roslyn) to provide deep static analysis and precise code manipulation, going far beyond simple text-based operations.

SharpTools is designed to give AI the same insights and tools a human developer relies on, leading to more intelligent and reliable code assistance. It is effectively a simple IDE, made for an AI user.

Due to the comprehensive nature of the suite, it can almost be used completely standalone for editing existing C# solutions. If you use the SSE server and port forward your router, I think it's even possible to have Claude's web chat ui connect to this and have it act as a full coding assistant.

Prompts

The included Identity Prompt is my personal C# coding assistant prompt, and it works well in combination with this suite. You're welcome to use it as is, modify it to match your preferences, or omit it entirely.

In VS Code, set it as your copilot-instructions.md to have it included in every interaction.

The Tool Use Prompt is fomulated specifically for Github Copilot's Agent mode. It overrides specific sections within the Copilot Agent System Prompt so that it avoids the built in tools.

It is available as an MCP prompt as well, so within Copilot, you just need to type /mcp, and it should show up as an option.

Something similar will be necessary for other coding assistants to prevent them from using their own default editing tools.

I recommend crafting custom tool use prompts for each agent you use this with, based on their individual system prompts.

Note

This is a personal project, slapped together over a few weeks, and built in no small part by its own tools. It generally works well as it is, but the code is still fairly ugly, and some of the features are still quirky (like removing newlines before and after overwritten members).

I intend to maintain and improve it for as long as I am using it, and I welcome feedback and contributions as a part of that.

Features

Dynamic Project Structure Mapping: Generates a "map" of the solution, detailing namespaces and types, with complexity-adjusted resolution.
Contextual Navigation Aids: Provides simplified call graphs and dependency trees for local code understanding.
Token Efficient Operation Designed to provide only the highest signal context at every step to keep your agent on track longer without being overwhelmed or requiring summarization.
- All indentation is omitted in returned code, saving roughly 10% of tokens without affecting performance on the smartest models.
- FQN based navigation means the agent rarely needs to read unrelated code.
FQN Fuzzy Matching: Intelligently resolves potentially imprecise or incomplete Fully Qualified Names (FQNs) to exact Roslyn symbols.
Comprehensive Source Resolution: Retrieves source code for symbols from:
- Local solution files.
- External libraries via SourceLink.
- Embedded PDBs.
- Decompilation (ILSpy-based) as a fallback.
Precise, Roslyn-Based Modifications: Enables surgical code changes (add/overwrite/rename/move members, find/replace) rather than simple text manipulation.
Automated Git Integration:
- Creates dedicated, timestamped sharptools/ branches for all modifications.
- Automatically commits every code change with a descriptive message.
- Offers a Git-powered Undo for the last modification.
Concise AI Feedback Loop:
- Confirms changes with precise diffs instead of full code blocks.
- Provides immediate, in-tool compilation error reports after modifications.
Proactive Code Quality Analysis:
- Detects and warns about high code complexity (cyclomatic, cognitive).
- Identifies semantically similar code to flag potential duplicates upon member addition.
Broad Project Support:
- Runs on Windows and Linux (and probably Mac)
- Can analyze projects targeting any .NET version, from Framework to Core to 5+
- Compatible with both modern SDK-style and legacy C# project formats.
- Respects .editorconfig settings for consistent code formatting.
MCP Server Interface: Exposes tools via Model Context Protocol (MCP) through:
- Server-Sent Events (SSE) for remote clients.
- Standard I/O (Stdio) for local process communication.

Exposed Tools

SharpTools exposes a variety of "SharpTool_*" functions via MCP. Here's a brief overview categorized by their respective service files:

Solution Tools

SharpTool_LoadSolution: Initializes the workspace with a given .sln file. This is the primary entry point.
SharpTool_LoadProject: Provides a detailed structural overview of a specific project within the loaded solution, including namespaces and types, to aid AI understanding of the project's layout.

Analysis Tools

SharpTool_GetMembers: Lists members (methods, properties, etc.) of a type, including signatures and XML documentation.
SharpTool_ViewDefinition: Displays the source code of a symbol (class, method, etc.), including contextual information like call graphs or type references.
SharpTool_ListImplementations: Finds all implementations of an interface/abstract method or derived classes of a base class.
SharpTool_FindReferences: Locates all usages of a symbol across the solution, providing contextual code snippets.
SharpTool_SearchDefinitions: Performs a regex-based search across symbol declarations and signatures in both source code and compiled assemblies.
SharpTool_ManageUsings: Reads or overwrites using directives in a document.
SharpTool_ManageAttributes: Reads or overwrites attributes on a specific declaration.
SharpTool_AnalyzeComplexity: Performs complexity analysis (cyclomatic, cognitive, coupling, etc.) on methods, classes, or projects.
~~(Disabled) SharpTool_GetAllSubtypes: Recursively lists all nested members of a type.~~
~~(Disabled) SharpTool_ViewInheritanceChain: Shows the inheritance hierarchy for a type.~~
~~(Disabled) SharpTool_ViewCallGraph: Displays incoming and outgoing calls for a method.~~
~~(Disabled) SharpTool_FindPotentialDuplicates: Finds semantically similar methods or classes.~~

Document Tools

SharpTool_ReadRawFromRoslynDocument: Reads the raw content of a file (indentation omitted).
SharpTool_CreateRoslynDocument: Creates a new file with specified content.
SharpTool_OverwriteRoslynDocument: Overwrites an existing file with new content.
SharpTool_ReadTypesFromRoslynDocument: Lists all types and their members defined within a specific source file.

Modification Tools

SharpTool_AddMember: Adds a new member (method, property, field, nested type, etc.) to a specified type.
SharpTool_OverwriteMember: Replaces the definition of an existing member or type with new code, or deletes it.
SharpTool_RenameSymbol: Renames a symbol and updates all its references throughout the solution.
SharpTool_FindAndReplace: Performs regex-based find and replace operations within a specified symbol's declaration or across files matching a glob pattern.
SharpTool_MoveMember: Moves a member from one type/namespace to another.
SharpTool_Undo: Reverts the last applied change using Git integration.
~~(Disabled) SharpTool_ReplaceAllReferences: Replaces all references to a symbol with specified C# code.~~

Package Tools

~~(Disabled) SharpTool_AddOrModifyNugetPackage: Adds or updates a NuGet package reference in a project file.~~

Misc Tools

SharpTool_RequestNewTool: Allows the AI to request new tools or features, logging the request for human review.

Prerequisites

.NET 8+ SDK for running the server
The .NET SDK of your target solution

Building

To build the entire solution:

dotnet build SharpTools.sln

This will build all services and server applications.

Running the Servers

SSE Server (HTTP)

The SSE server hosts the tools on an HTTP endpoint.

# Navigate to the SseServer project directory
cd SharpTools.SseServer

# Run with default options (port 3001)
dotnet run

# Run with specific options
dotnet run -- --port 3005 --log-file ./logs/mcp-sse-server.log --log-level Debug

Key Options:

--port <number>: Port to listen on (default: 3001).
--log-file <path>: Path to a log file.
--log-level <level>: Minimum log level (Verbose, Debug, Information, Warning, Error, Fatal).
--load-solution <path>: Path to a .sln file to load on startup. Useful for manual testing. It is recommended to let the AI run the LoadSolution tool instead, as it returns some useful information.

Stdio Server

The Stdio server communicates over standard input/output.

Configure it in your MCP client of choice. VSCode Copilot example:

"mcp": {
    "servers": {
        "SharpTools": {
            "type": "stdio",
            "command": "/path/to/repo/SharpToolsMCP/SharpTools.StdioServer/bin/Debug/net8.0/SharpTools.StdioServer",
            "args": [
                "--log-directory",
                "/var/log/sharptools/",
                "--log-level",
                "Debug",
            ]
        }
    }
},