dotnet-sherlock-mcp

The single-file.cursorrulesformat isdeprecated(and silently ignored in Cursor's Agent mode). Add a Project Rule at.cursor/rules/sherlock.mdcinstead:

For tools that follow the cross-editorAGENTS.mdconvention, the same short pointer works — drop the Claude Code snippet above into yourAGENTS.md.

For system-wide usage, add to your global agent settings:

For .NET work, use the Sherlock MCP tools (snake_case) to analyze assemblies, types, and members instead of guessing. Start lean and opt into projection='full' only when you need detail.

Below are compact prompt snippets you can paste into your chat to get productive fast. Adjust paths to your local DLLs.

You have access to an MCP server named "sherlock" that can analyze .NET assemblies. Prefer these tools for .NET questions and include short reasoning for which tool you chose. Ask me for the assembly path if missing.

Analyze: /absolute/path/to/MyLib/bin/Debug/net9.0/MyLib.dll Type: MyNamespace.MyType List methods, including non-public, filter name contains "Async", include attributes, return JSON.

Use GetXmlDocsForMember on /abs/path/MyLib.dll, type MyNamespace.MyType, member TryParse. Summarize the summary + params.

List types from /abs/path/MyLib.dll; then get type info for the first result and list its nested types.

Use GetTypeMethods on /abs/path/MyLib.dll, type MyNamespace.MyType, sortBy name, sortOrder asc, skip 0, take 25, hasAttributeContains Obsolete.

Browse lean, then get detail (projection)

On /abs/path/MyLib.dll, run GetTypeMethods for MyNamespace.MyType with the default summary projection to see signatures. Then re-call GetTypeMethods with projection='full' only for the methods I name to get their parameters and attributes.

On /abs/path/MyLib.dll: FindImplementationsOf MyNamespace.IMyService. Then FindReferencesTo that interface with analysisDepth='il' to find callers, and GetMethodCalls on the most relevant method to see what it invokes.

Tool names:MCP clients call these tools insnake_case—GetTypeMethods→get_type_methods,SearchMembers→search_members, and so on. The PascalCase names used throughout this README match the underlying C# methods and the tool descriptions your client displays.

- AnalyzeAssembly: Complete assembly overview with public types and metadata
- GetAssemblyInfo: Assembly-level metadata — identity/version, target framework, and referenced assemblies (projection=fulladds all assembly attributes)
- FindAssemblyByClassName: Locate assemblies containing specific class names
- FindAssemblyByFileName: Find assemblies by file name in common build paths
- FindAssemblyByNugetPackage: Resolve a DLL from the local NuGet cache by package id (optionalversion/tfm)

- GetTypesFromAssembly: List all public types with metadata (paginated)
- AnalyzeType: Comprehensive type analysis with all members
- GetTypeInfo: Detailed type metadata (accessibility, generics, nested types)
- GetTypeHierarchy: Inheritance chain and interface implementations
- GetGenericTypeInfo: Generic parameters, arguments, and variance information
- GetTypeAttributes: Custom attributes declared on types
- GetNestedTypes: Nested type declarations

Member Analysis (Filterable & Paginated)

- GetAllTypeMembers: All members across all categories
- GetTypeMethods: Method signatures, overloads, and metadata
- GetTypeProperties: Property details including getters/setters and indexers
- GetTypeFields: Field information including constants and readonly fields
- GetTypeEvents: Event declarations with handler types
- GetTypeConstructors: Constructor signatures and parameters
- AnalyzeMethod: Deep method analysis with overloads and attributes

- SearchMembers: Search a whole assembly for members whose name contains a fragment — the entry point when you know a member name but not its declaring type. Filter bymemberKinds(method|property|field|event|type).

- FindImplementationsOf: Types implementing an interface or deriving from a base class (open-generic match supported)
- FindMethodsReturning: Methods whose return type matches a given type (open-generic match supported)
- FindExtensionMethodsFor: Extension methods that extend a given type (scans static classes bythis-parameter)
- FindReferencesTo: Broader sweep across parameters, fields, properties, events, and generic arguments; passanalysisDepth='il'to also resolve inbound callers from method bodies

- GetMethodCalls: Read a method's IL body to list what it calls and which fields it touches — the "what does this method do?" question signature-level tools can't answer (aggregates across overloads; use.ctor/.cctorfor constructors)

- GetMemberAttributes: Attributes for specific members
- GetParameterAttributes: Parameter-level attribute information

- GetXmlDocsForType: Extract type-level XML documentation
- GetXmlDocsForMember: Member-specific documentation (summary/params/returns/remarks)

- AnalyzeSolution: Parse .sln files and enumerate projects
- AnalyzeProject: Project metadata, references, and build configuration
- GetProjectOutputPaths: Resolve output directories for different configurations
- ResolvePackageReferences: Map NuGet packages to cached assemblies
- FindDepsJsonDependencies: Parse deps.json for runtime dependencies

- GetRuntimeOptions: Current server configuration and defaults
- UpdateRuntimeOptions: Modify pagination, caching, and search behavior

All member analysis tools support comprehensive filtering and pagination:

- caseSensitive(bool): Case-sensitive type/member matching
- nameContains(string): Filter by member name substring
- hasAttributeContains(string): Filter by attribute type substring
- includePublic/includeNonPublic(bool): Visibility filtering
- includeStatic/includeInstance(bool): Member type filtering

- skip/take(int): Standard offset pagination
- maxItems(int): Maximum results per request (default 50;FindReferencesTodefaults to 25)
- continuationToken(string): Token-based pagination for large datasets
- sortBy/sortOrder(string): Sort by name/access in asc/desc order

Most enumerating tools default to a leansummaryprojection and let you opt into the heavierfullpayload only when you need it. Reach forfulldeliberately —summaryis usually enough to decide your next call.

- Supports full names (Namespace.Type), simple names (Type), and nested types (Outer+Inner)
- Case sensitivity controlled bycaseSensitiveparameter
- Automatic fallback resolution for ambiguous type names

All tools return a stable JSON envelope: