Przejdź do treści
Biblioteka skilli
Programowanie · Integracja z narzędziem

sherlock

/sherlock

Sprawdza skompilowane zespoły .NET przez narzędzia MCP: składowe typów, sygnatury, implementacje interfejsów i wywołania metod.

Licencja
MIT
Ostatnia zmiana repozytorium
05.10.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 05.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Sprawdza skompilowane zespoły .NET przez narzędzia MCP: składowe typów, sygnatury, implementacje interfejsów i wywołania metod.

Wyzwalacze z opisu

s members, a method
Oryginalny opis (EN)

Inspect compiled .NET assemblies with the Sherlock MCP tools. Use when a task needs facts about a .NET API - a type's members, a method's signature or overloads, which types implement an interface, who calls a method, what a NuGet package exposes - or before writing C# against a library you have not verified. Prefer this over guessing from memory or reading decompiled source.

Jak działa

  1. 1. Locate the assembly
  2. 2. Orient cheaply
  3. 3. Drill in, narrow to wide
  4. 4. Relationships
  5. 5. Recovering from errors
  6. 6. Resource links
  7. 7. More tools on demand
Sekcje z nagłówków SKILL.md, w oryginale · 83 linii, 819 słów
Podgląd SKILL.md
---
name: sherlock
description: Inspect compiled .NET assemblies with the Sherlock MCP tools. Use when a task needs facts about a .NET API - a type's members, a method's signature or overloads, which types implement an interface, who calls a method, what a NuGet package exposes - or before writing C# against a library you have not verified. Prefer this over guessing from memory or reading decompiled source.
---

# Sherlock: .NET assembly introspection

Sherlock reads real assemblies (your build output or the NuGet cache) via metadata-only reflection, so its answers match the exact version the project compiles against. Reach for it whenever correctness depends on an API's actual shape.

Tool names are snake_case; argument names are camelCase.

## 1. Locate the assembly

Every tool takes an assembly path. Find it rather than guessing:

- `find_assembly_by_class_name` - you know a type name but not which DLL holds it.
- `find_assembly_by_nuget_package` - resolve a package (and version) from the local NuGet cache.
- `get_project_output_paths` - the build output DLL of a `.csproj`.
- `find_assembly_by_file_name` - you know the DLL name.

Never hardcode `bin/Debug/<tfm>/...`; the target framework and configuration vary.

When you will make several calls against the same assembly, call `open_assembly` once and pass the returned `assemblyHandle` (a short `asm_…` id) instead of `assemblyPath`. The handle also carries any `additionalAssemblies` you opened it with.

## 2. Orient cheaply

- `get_assembly_info` - identity, target framework, references.
- `search_members` - you know a member name fragment but not its declaring type (narrow with `memberKinds`).
- `get_types_from_assembly` - browse types, paginated.

## 3. Drill in, narrow to wide

1. `get_type_info` - kind, base type, interfaces, accessibility, member counts.
2. `get_type_members` filtered by `kinds`, `nameContains` or `hasAttributeContains`. The default `summary` projection returns `{ kind, name, signature }`, and the C# signature already carries return type, parameters and modifiers.
3. Re-call with `projection='full'` only for the few members where you need structured parameters, attributes or modifier flags.
4. `analyze_method` for one method's overloads; `get_xml_docs_for_type` / `get_xml_docs_for_member` for documentation; `get_type_hierarchy` for the inheritance chain (`format='mermaid'` for a class diagram).

Start with a small `maxItems` and page with `continuationToken` instead of fetching everything.

## 4. Relationships

- `find_implementations_of` - implementers of an interface or subclasses of a base type (open generics match).
- `find_methods_returning` - factories and accessors that produce a type.
- `find_extension_methods_for` - extension methods targeting a type.
- `find_references_to` - where a type is used; add `analysisDepth='il'` to include callers found in method bodies.
- `get_method_calls` - what a method body calls and which fields it touches (use `.ctor` / `.cctor` for constructors). `format='mermaid'` with `depth` draws a call-graph flowchart.
- `get_member_source` - a member's original source (comments, real names) from its PDB or Source Link; falls back to decompiled C# and says so in `origin`/`note`. Prefer it over `decompile_member` for reading a body.
- `decompile_member` - a member's body as decompiled C#. Returns every overload unless `parameterTypes` (e.g. `string,int`) narrows it; long output is paged by line, so follow `continuationToken` while `truncated` is true.

Pass `additionalAssemblies` to search across several DLLs.

To upgrade a package or review a release, `compare_api_surface` diffs two versions (`left` = old, `right` = new; each an assembly path, a handle, or `Package.Id@1.2.3` from the NuGet cache). The default summary returns counts and the breaking changes with reasons; `projection='full'` lists every addition and change.

## 5. Recovering from errors

Failed calls return `isError: true` with JSON guidance. Follow it rather than retrying blindly:

- `TypeNotFound` / `MemberNotFound`: retry with a name from `recommendedParams.candidates`.
- `AmbiguousTypeName`: the simple name matched several types; use one of the full names offered (or answer the client's selection prompt).
- Response too large: lower `maxItems`, keep `projection='summary'`, page with `continuationToken`.
- `DependencyNotFound`: point at the build-output copy of the assembly so its dependencies sit beside it.
- Results look stale after a rebuild: pass `noCache=true`.
- `StaleAssemblyHandle` or `UnknownAssemblyHandle`: call `open_assembly` again, with the paths in `recommendedParams` when given. If the error lists `details.missingFiles`, the assembly was moved or deleted: locate it again first.

Use full type names (`Namespace.Type`, nested as `Outer+Inner`) whenever you know them.

## 6. Resource links

`search_members`, `get_types_from_assembly` and the `find_*` tools also return `sherlock://assembly/{path}/type/{fullName}` resource links. Reading one gives the same payload as `get_type_info` without another tool call.

## 7. More tools on demand

The plugin starts Sherlock with its core tools. More are grouped and loaded only when you need them:

| Group | Load it to |
|---|---|
| `frameworks` | list ASP.NET Core endpoints and routes, dependency-injection registrations, EF Core entities, MediatR handlers |
| `project` | inspect solution and project structure, package references, the restored NuGet package graph |
| `metadata` | list an assembly's types with counts, generic constraints, nested types, type/member/parameter attributes |
| `decompile` | decompile a whole type to C# |
| `config` | read or change server runtime options |
| `legacy` | use the deprecated per-kind member listings |

- `load_tools` with no arguments lists each group's tools and whether it is loaded; `load_tools` with `groups=['frameworks']` adds them.
- If the new tools don't show up in your tool list, call them through `invoke_tool` with `name` and `arguments`.
- Results may include `hints[]` (`{ tool, reason, group }`) pointing at a related tool. When `group` is set and the tool isn't in your list, load that group first.

Wersje

RepozytoriumWynikLicencja
Ta strona · jcucci/dotnet-sherlock-mcp90MIT
wilbeibi/claude-toolkit90MIT

Migawka bazy z 13.11.2026 · wersja paczki 29bd7f462fd7 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100ilspy-decompile
    Pozwala poznać szczegóły implementacji kodu .NET przez dekompilację assemblies: wewnętrzne działanie API, źródła pakietów NuGet, implementacja frameworka i skompilowane pliki binarne .NET.
  • 100ilspy-decompile
    Wyjaśnia wewnętrzne działanie kodu .NET przez dekompilację zestawów: API frameworka, źródła pakietów NuGet i skompilowane binaria.
  • 100csharp-decompile
    Dekompiluje zestawy .NET, aby sprawdzić typy i implementacje, debugować zewnętrzne biblioteki i oglądać kod IL, np. przy zachowaniu zależności NuGet.
  • 100dotnet-inspect
    Odpytuje API .NET w pakietach NuGet, bibliotekach platformy i plikach lokalnych: szuka typów, wylicza powierzchnie API, porównuje wersje oraz znajduje metody rozszerzające i implementacje.
  • 100sherlock-investigator
    Analizuje zdjęcia i szacuje lokalizację, jak w grze GeoGuessr, weryfikując kandydatów narzędziami mapowymi.
  • 100cellar
    Wyszukuje publiczne API zależności JVM (Scala 3, Scala 2, Java) z terminala: sygnatury typów, składowe, dokumentację i źródła jako Markdown, bez rozpakowywania JAR-ów.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.