dotnet-sherlock-mcp

Sherlock MCP para .NET

Sherlock MCP para .NET é um servidor abrangente de Model Context Protocol (MCP) que fornece capacidades profundas de introspecção para assemblies .NET. Ele permite que Modelos de Linguagem de Grande Escala (LLMs) analisem e entendam seu código .NET com precisão, entregando respostas precisas e conscientes do contexto para cenários complexos de desenvolvimento.

Esta ferramenta é essencial para desenvolvedores que desejam aproveitar as capacidades de LLM para:

• Análise profunda de código - Entendendo arquiteturas .NET complexas e dependências
• Informações precisas de tipos - Obtendo metadados detalhados sobre tipos, membros e suas assinaturas
• Documentação automatizada - Extraindo e utilizando documentação XML e atributos
• Ferramentas personalizadas - Construindo ferramentas sofisticadas que interagem com assemblies .NET
• Geração de código - Criando código preciso baseado em estruturas de tipos existentes

Principais Recursos

• Servidor MCP Abrangente: Fornece 40 ferramentas especializadas para análise de assemblies .NET, com um perfil opcional de 20 ferramentas core
• Introspecção Avançada de Assemblies: Análise profunda baseada em reflexão de tipos, membros e metadados
• Análise Rica de Membros: Inspeção detalhada de métodos, propriedades, campos, eventos e construtores
• Filtragem e Paginação Inteligentes: Filtragem avançada por nome/atributos com paginação eficiente para grandes conjuntos de dados
• Integração de Documentação XML: Extração automática de resumo, parâmetros, retornos e observações
• Otimizado para Desempenho: Cache, paginação e processamento eficiente de memória
• API JSON Estável: Envelopes consistentes com versionamento e códigos de erro estruturados
• .NET 9.0 Nativo: Construído na plataforma .NET mais recente com recursos modernos de C#
• Integração de Projetos: Análise de soluções e arquivos de projeto com resolução de dependências
• Prompts de Fluxo de Trabalho: explore_package, explain_type e who_calls prompts fornecem pontos de entrada com um clique para fluxos de trabalho comuns de análise
• SDK MCP Atual: Construído em ModelContextProtocol 2.1.0 (GA)
• Especificação MCP Atual: Fala a revisão do protocolo 2026-07-28, e negocia automaticamente para baixo para clientes em revisões anteriores

Novidades na Versão 2.14.0

• Plugin Claude Code: /plugin marketplace add jcucci/dotnet-sherlock-mcp e /plugin install sherlock@dotnet-sherlock-mcp instalam o servidor mais uma habilidade que ensina aos agentes o fluxo de trabalho Sherlock. Veja Plugin Claude Code.
• get_type_members e perfis de ferramentas: uma lista paginada e filtrável de ferramentas lista cada tipo de membro, e --profile core / SHERLOCK_TOOL_PROFILE=core reduz a superfície para as ferramentas essenciais. As ferramentas de membros por tipo estão obsoletas.
• Saída estruturada e orientação de erros: as ferramentas principais de navegação publicam um outputSchema e retornam structuredContent, e chamadas com falha carregam isError: true com candidatos "você quis dizer" e sugestões de correção.
• Cancelamento, progresso e elicitação: varreduras longas podem ser canceladas e relatam progresso, e um nome de tipo simples ambíguo solicita que o cliente escolha. Veja CHANGELOG.md para detalhes completos.

Instalação

Executar com dnx (.NET 10 SDK)

Com o SDK .NET 10, dnx baixa o pacote do NuGet e o executa diretamente — sem etapa de instalação:

dnx -v q --yes Sherlock.MCP.Server@2.14.0

--yes pula o prompt de confirmação interativo, que um cliente MCP iniciando o servidor via stdio não pode responder. -v q impede que dnx imprima um aviso "Ignorando verificação de assinatura do pacote NuGet." no stdout na primeira vez que baixa uma versão, o que de outra forma corromperia o fluxo MCP e falharia nessa primeira conexão. Ambos são opções dnx, então devem vir antes do id do pacote; qualquer coisa depois é passada para o servidor. Fixar a versão mantém as execuções reproduzíveis; aumente quando quiser atualizar. O pacote é publicado com o tipo de pacote McpServer, então também é listado como um servidor MCP no NuGet.org.

Instalar como ferramenta global

Em qualquer SDK suportado (.NET 8 ou posterior), instale a ferramenta global do NuGet (adiciona sherlock-mcp ao seu PATH):

dotnet tool install -g Sherlock.MCP.Server

Alternativamente, durante o desenvolvimento, você pode executar o servidor localmente:

dotnet run --project src/server/Sherlock.MCP.Server.csproj

Configure Seu Cliente MCP

O Sherlock executa como um servidor MCP padrão que se comunica via stdio.

Plugin Claude Code

Este repositório também é um mercado de plugins Claude Code. O plugin sherlock agrupa o servidor (iniciado com dnx, então precisa do SDK .NET 10) e uma habilidade que ensina ao agente o fluxo de trabalho localizar → orientar → aprofundar → relacionamentos:

/plugin marketplace add jcucci/dotnet-sherlock-mcp
/plugin install sherlock@dotnet-sherlock-mcp

O plugin inicia o servidor com o perfil de ferramentas core, que corresponde às ferramentas que a habilidade cobre. Para expor todas as ferramentas, defina SHERLOCK_TOOL_PROFILE=full no ambiente a partir do qual o Claude Code é iniciado.

Cada usuário executa esses comandos uma vez; reinicie o Claude Code (ou execute /reload-plugins) depois. Para obter um novo lançamento, execute /plugin marketplace update dotnet-sherlock-mcp. Se você registrou anteriormente o Sherlock com claude mcp add, remova essa entrada (claude mcp remove sherlock) para que as ferramentas não sejam carregadas duas vezes.

Configuração de equipe

Para oferecer o plugin a todos que trabalham em um repositório, confirme o seguinte no .claude/settings.json desse repositório. O Claude Code solicita que cada colega de equipe o instale quando confiam na pasta, então ninguém precisa digitar os comandos acima:

{
  "extraKnownMarketplaces": {
    "dotnet-sherlock-mcp": {
      "source": {
        "source": "github",
        "repo": "jcucci/dotnet-sherlock-mcp"
      }
    }
  },
  "enabledPlugins": {
    "sherlock@dotnet-sherlock-mcp": true
  }
}

Os colegas de equipe ainda precisam do SDK .NET 10 em seu PATH para dnx.

Usando dnx

• Claude Code:

claude mcp add sherlock -- dnx -v q --yes Sherlock.MCP.Server@2.14.0

• VS Code (.vscode/mcp.json):

{
  "servers": {
    "sherlock": {
      "type": "stdio",
      "command": "dnx",
      "args": ["-v", "q", "--yes", "Sherlock.MCP.Server@2.14.0"]
    }
  }
}

Usando a ferramenta global

• Cursor: Configurações → MCP / Ferramentas personalizadas → Adicionar ferramenta → Comando: sherlock-mcp
• Claude Desktop / outros clientes MCP: Adicione uma entrada de servidor apontando para o comando sherlock-mcp. Exemplo de entrada JSON (consulte a documentação do seu cliente para localização/formato exato do arquivo):

{
  "servers": {
    "sherlock": {
      "command": "sherlock-mcp"
    }
  }
}

Nenhum argumento é necessário. O servidor registra automaticamente todas as ferramentas quando iniciado.

Perfis de ferramentas

Listas grandes de ferramentas custam contexto e descoberta aos agentes (o Claude Code muda para Pesquisa de Ferramentas adiada quando as descrições das ferramentas crescem além de aproximadamente 10% da janela de contexto). O Sherlock pode iniciar com uma superfície menor:

Perfil	Ferramentas	Conteúdo
full (padrão)	40	Todas as ferramentas, incluindo as ferramentas obsoletas de membros por tipo
core	20	Descoberta (find_assembly_by_class_name, find_assembly_by_file_name, find_assembly_by_nuget_package, get_project_output_paths, open_assembly), orientação (get_assembly_info, get_types_from_assembly, get_type_info, get_type_hierarchy), membros e documentação (get_type_members, search_members, analyze_method, get_xml_docs_for_type, get_xml_docs_for_member) e relacionamentos (find_implementations_of, find_methods_returning, find_extension_methods_for, find_references_to, get_method_calls) e descompilação (decompile_member)

Selecione um perfil com o argumento --profile ou a variável de ambiente SHERLOCK_TOOL_PROFILE (o argumento vence). Um nome de perfil desconhecido interrompe o servidor com um erro.

{
  "servers": {
    "sherlock": {
      "command": "sherlock-mcp",
      "args": ["--profile", "core"]
      // or: "env": { "SHERLOCK_TOOL_PROFILE": "core" }
    }
  }
}

Configuração Automática para Projetos .NET

Normalmente você não precisa colar nada. O Sherlock envia suas diretrizes de uso no campo MCP instructions retornado na inicialização, e a maioria dos clientes MCP (incluindo Claude Code) exibe isso ao agente automaticamente — então as diretrizes permanecem corretas e versionadas com o pacote, sem copiar e colar para manter.

Os trechos abaixo são reforço opcional. Mantenha-os curtos e baseados em princípios, em vez de enumerar nomes de ferramentas e fluxos de trabalho: uma lista estática colada no seu repositório ficará desatualizada conforme as ferramentas do Sherlock evoluem, enquanto as descrições das próprias ferramentas (e o instructions do servidor) sempre correspondem à versão que você está executando.

Os nomes das ferramentas são expostos em snake_case (get_type_members, search_members, …); os nomes dos argumentos permanecem em camelCase (projection, nameContains).

Claude Code (CLAUDE.md)

Se você instalou o plugin Claude Code, sua habilidade já cobre isso. Caso contrário, você pode adicionar um ponteiro curto e opcional ao CLAUDE.md do seu projeto:

## .NET Assembly Analysis

Use the Sherlock MCP tools (`get_type_members`, `search_members`, …) for .NET type/assembly
questions instead of guessing. Locate DLLs with the `find_assembly_by_*` / `get_project_output_paths`
tools rather than hardcoding bin paths. Start lean — `search_members` or `get_types_from_assembly`,
then drill in — and pass `projection='full'` only when you need parameters/attributes/modifiers.
The tools' own descriptions cover the specifics.

Cursor (.cursor/rules)

O formato de arquivo único .cursorrules está obsoleto (e silenciosamente ignorado no modo Agente do Cursor). Adicione uma Regra de Projeto em .cursor/rules/sherlock.mdc:

---
description: Use Sherlock MCP for .NET assembly/type analysis
alwaysApply: true
---

- Prefer the Sherlock MCP tools (snake_case, e.g. `get_type_members`, `search_members`) over guessing about .NET APIs.
- Find DLLs with `find_assembly_by_*` / `get_project_output_paths`; don't hardcode `bin/Debug/<tfm>/*.dll`.
- Start lean (`search_members` / `get_types_from_assembly`); request `projection='full'` only when you need parameters/attributes/modifiers.

Outros agentes (AGENTS.md)

Para ferramentas que seguem a convenção AGENTS.md entre editores, o mesmo ponteiro curto funciona — coloque o trecho do Claude Code acima no seu AGENTS.md.

Configuração global

Para uso em todo o sistema, adicione às suas configurações globais de agente:

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.

Como Fazer Prompts

Abaixo estão trechos compactos de prompts que você pode colar no seu chat para ser produtivo rapidamente. Ajuste os caminhos para seus DLLs locais.

Configuração geral

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.

Enumerar membros para um tipo

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.

Obter documentação XML para um membro

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

Encontrar tipos e aprofundar

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

Ajustar paginação e filtros

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

Navegar enxuto, depois obter detalhes (projeção)

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

Rastrear relacionamentos e locais de chamada

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.

Visão Geral das Ferramentas

Nomes das ferramentas: Os clientes MCP chamam essas ferramentas em snake_case — GetTypeMembers → get_type_members, SearchMembers → search_members, e assim por diante. Os nomes em PascalCase usados ao longo deste README correspondem aos métodos C# subjacentes e às descrições de ferramentas que seu cliente exibe.

Descoberta e Análise de Assemblies

• OpenAssembly: Retorna um identificador curto asm_… para passar como assemblyHandle em vez de assemblyPath em qualquer ferramenta que aceite um assembly. O identificador carrega additionalAssemblies também, persiste entre reinicializações do servidor (em handles.json sob SHERLOCK_STATE_DIR, padrão na pasta sherlock de dados locais do aplicativo do usuário) e é fixado ao build atual: após uma recompilação, as chamadas falham com StaleAssemblyHandle até que seja reaberto
• AnalyzeAssembly: Visão geral completa do assembly com tipos públicos e metadados
• GetAssemblyInfo: Metadados em nível de assembly — identidade/versão, estrutura de destino e assemblies referenciados (projection=full adiciona todos os atributos do assembly)
• FindAssemblyByClassName: Localiza assemblies que declaram um tipo público por nome simples, completo ou aninhado; ignora obj/, ref/, refint/, node_modules/, packages/, TestResults/ e diretórios de ponto, e classifica correspondências bin/ primeiro
• FindAssemblyByFileName: Encontra assemblies por nome de arquivo sob um diretório raiz, com as mesmas exclusões e classificação
• FindAssemblyByNugetPackage: Resolve um DLL do cache NuGet local por id do pacote (version/tfm opcional)

Introspecção de Tipos

• GetTypesFromAssembly: Lista todos os tipos públicos com metadados (paginado)
• AnalyzeType (obsoleto): Metadados de tipo mais todos os membros; use GetTypeInfo + GetTypeMembers projection=full
• GetTypeInfo: Metadados detalhados de tipo (acessibilidade, genéricos, tipos aninhados)
• GetTypeHierarchy: Cadeia de herança e implementações de interface
• GetGenericTypeInfo: Parâmetros genéricos, argumentos e informações de variância
• GetTypeAttributes: Atributos personalizados declarados em tipos
• GetNestedTypes: Declarações de tipos aninhados

Análise de Membros (Filtrável e Paginada)

• GetTypeMembers: Métodos, propriedades, campos, eventos e construtores de um tipo em uma lista paginada. Refine com kinds (method|property|field|event|constructor), nameContains e hasAttributeContains; itens summary são { kind, name, signature }, projection=full adiciona os campos estruturados de cada tipo
• AnalyzeMethod: Análise profunda de métodos com sobrecargas e atributos
• Obsoleto, mantido por um lançamento ou dois: GetTypeMethods, GetTypeProperties, GetTypeFields, GetTypeEvents, GetTypeConstructors (use GetTypeMembers com kinds) e GetAllTypeMembers (use GetTypeMembers projection=full)

Pesquisa de Membros

• SearchMembers: Pesquisa um assembly inteiro por membros cujo nome contém um fragmento — o ponto de entrada quando você sabe o nome de um membro, mas não seu tipo declarante. Filtre por memberKinds (method|property|field|event|type).

Reverse Lookup

• FindImplementationsOf: Tipos que implementam uma interface ou derivam de uma classe base (correspondência open-generic suportada)
• FindMethodsReturning: Métodos cujo tipo de retorno corresponde a um tipo fornecido (correspondência open-generic suportada)
• FindExtensionMethodsFor: Métodos de extensão que estendem um tipo fornecido (verifica classes estáticas pelo parâmetro this)
• FindReferencesTo: Varredura mais ampla por parâmetros, campos, propriedades, eventos e argumentos genéricos; passe analysisDepth='il' para também resolver chamadores de entrada nos corpos dos métodos

Análise de IL

• GetMethodCalls: Lê o corpo IL de um método para listar o que ele chama e quais campos ele acessa — a pergunta "o que este método faz?" que ferramentas baseadas em assinatura não conseguem responder (agrega entre sobrecargas; use .ctor/.cctor para construtores)

Decompilação

• DecompileMember: Decompila um membro (método, propriedade, campo, evento ou construtor) para C# com ICSharpCode.Decompiler. Retorna todas as sobrecargas do nome, ou uma única sobrecarga quando parameterTypes é fornecido (ex.: string,int; uma string vazia seleciona a sobrecarga sem parâmetros). Use .ctor/.cctor para construtores
• DecompileType: Decompila um tipo inteiro para C#. Não está no perfil core; prefira DecompileMember

Ambas as ferramentas paginam o código-fonte por linha: maxLines (padrão 400, máximo 5000) limita o tamanho da página; uma página também para antes ao atingir cerca de 90.000 caracteres para caber sempre no limite de resposta, e cada página informa startLine, lineCount, totalLines, truncated e um continuationToken para a próxima página. Linhas com mais de 2.000 caracteres são truncadas com um marcador /* … more characters clipped */ e contadas em clippedLines. Passe additionalAssemblies (ou use um assemblyHandle aberto com eles) quando as dependências estiverem fora da pasta do assembly; as pastas delas são pesquisadas ao resolver tipos referenciados e seus carimbos de arquivo fazem parte da chave de cache. A decompilação completa é armazenada em cache pelo carimbo do arquivo, então páginas posteriores são baratas. Um tipo que o assembly apenas encaminha (ex.: System.String em um facade System.Runtime.dll) retorna TypeForwarded com o assembly definidor em recommendedParams.

Atributos e Metadados

• GetMemberAttributes: Atributos para membros específicos
• GetParameterAttributes: Informações de atributos no nível de parâmetro

Documentação XML

• GetXmlDocsForType: Extrai documentação XML no nível de tipo
• GetXmlDocsForMember: Documentação específica de membro (summary/params/returns/remarks)

Análise de Projeto e Solução

• AnalyzeSolution: Analisa arquivos .sln e enumera projetos
• AnalyzeProject: Metadados de projeto, referências e configuração de build
• GetProjectOutputPaths: Resolve diretórios de saída para diferentes configurações
• ResolvePackageReferences: Mapeia pacotes NuGet para assemblies em cache
• FindDepsJsonDependencies: Analisa deps.json para dependências de runtime

Configuração e Runtime

• GetRuntimeOptions: Configuração atual do servidor e padrões
• UpdateRuntimeOptions: Modifica paginação, cache e comportamento de busca

Recursos

Três modelos de recurso permitem que clientes busquem um único tipo, entrada de documentação ou pacote em cache sem outra chamada de ferramenta. Cada variável é codificada em percent-encoding.

• sherlock://assembly/{path}/type/{fullName}: Metadados de tipo, o mesmo payload de get_type_info
• sherlock://assembly/{path}/docs/{memberId}: Documentação XML para um id de documentação como T:Ns.Type ou M:Ns.Type.Method(System.String)
• sherlock://nuget/{packageId}/{version}: O assembly para o qual uma versão de pacote NuGet em cache resolve, o mesmo payload de find_assembly_by_nuget_package

search_members, get_types_from_assembly e as ferramentas de reverse lookup find_* retornam um resource_link para o recurso de tipo para cada tipo distinto na página, após o bloco de texto JSON. resources/read carrega dicas privadas de cache; uma URI cujo assembly, tipo, id de documento ou pacote não existe falha com -32602.

Variáveis de modelo suportam completion/complete, retornando no máximo 100 valores:

• path: assemblies carregados recentemente, depois arquivos .dll/.exe e subpastas da pasta que está sendo digitada
• fullName: nomes de tipos (forma de metadados, ex.: List`1) from the assembly in the path argumento de contexto
• memberId: ids de documentação do arquivo XML ao lado do assembly path
• packageId / version: pastas de pacotes e suas versões (mais recentes primeiro) no cache NuGet local

Prompts

Três prompts codificam sequências comuns de ferramentas como pontos de entrada de um clique (Claude Code os lista como comandos de barra /mcp__sherlock__<name>). Cada um retorna uma única mensagem de usuário que orienta o agente pelas ferramentas; eles só chamam ferramentas no perfil core, então funcionam em ambos os perfis.

• explore_package (packageId, version?): Resolve o pacote do cache NuGet local (versão em cache mais alta quando version é omitido), orienta-se no assembly e resume seus principais tipos e pontos de entrada
• explain_type (assemblyPath, typeName): Hierarquia, membros, documentos XML e usos de um tipo
• who_calls (assemblyPath, typeName, memberName, additionalAssemblies?): Chamadores de entrada de um membro a partir de IL, opcionalmente em uma lista separada por vírgulas de outros assemblies

assemblyPath, typeName (com assemblyPath no contexto de conclusão), packageId e version (com packageId no contexto) suportam completion/complete da mesma forma que as variáveis de modelo de recurso. prompts/list carrega as mesmas dicas públicas de cache que tools/list.

Filtragem Avançada e Paginação

Todas as ferramentas de análise de membros suportam filtragem e paginação abrangentes:

Opções de Filtragem:

• caseSensitive (bool): Correspondência de tipo/membro sensível a maiúsculas/minúsculas
• nameContains (string): Filtra por substring do nome do membro
• hasAttributeContains (string): Filtra por substring do tipo de atributo
• includePublic / includeNonPublic (bool): Filtragem de visibilidade
• includeStatic / includeInstance (bool): Filtragem por tipo de membro

Paginação:

• skip / take (int): Paginação padrão por deslocamento
• maxItems (int): Máximo de resultados por solicitação (padrão 50; FindReferencesTo usa padrão 25)
• continuationToken (string): Paginação baseada em token para grandes conjuntos de dados
• sortBy / sortOrder (string): Ordenação por nome/acesso em ordem asc/desc

Formato da Resposta (eficiência de tokens)

A maioria das ferramentas de enumeração usa por padrão uma projeção enxuta summary e permite que você opte pelo payload mais pesado full apenas quando precisar. Use full deliberadamente — summary geralmente é suficiente para decidir sua próxima chamada.

• projection (summary | full): suportado por GetTypesFromAssembly, GetTypeMembers, GetTypeMethods, GetAssemblyInfo, GetMethodCalls, FindImplementationsOf, FindMethodsReturning, FindExtensionMethodsFor e FindReferencesTo. summary retorna apenas o suficiente para navegar (ex.: { kind, name, signature } para membros); full adiciona campos estruturados (parâmetros, atributos, tipo de retorno, modificadores, etc.). Nota: os GetTypeProperties/Fields/Events/Constructors obsoletos têm um formato fixo único e não aceitam projection.
• analysisDepth (signatures | il): apenas FindReferencesTo. signatures (padrão) verifica declarações de membros; il adicionalmente verifica corpos de métodos para chamadores de entrada (mais lento).
• additionalAssemblies (string[]): amplia o escopo de busca para GetTypeHierarchy e as ferramentas de reverse lookup. GetTypeHierarchy.derivedTypes permanece null até que você passe isso.
• noCache (bool): ignora o cache de resposta para uma única chamada quando você suspeita de resultados obsoletos. Toda ferramenta que lê um assembly ou projeto armazena sua resposta em cache, com chave nos carimbos de arquivo de suas entradas (o assembly e qualquer additionalAssemblies, o arquivo de documento XML ao lado dele, ou o arquivo de projeto e obj/project.assets.json), então um rebuild ou restore invalida automaticamente. As buscas find_assembly_by_* e resolve_package_references (que leem o cache compartilhado de pacotes NuGet), configuração e ferramentas de handle não são armazenadas em cache. Dois casos que os carimbos não detectam, onde noCache=true é a correção: uma DLL de dependência colocada ao lado de um assembly que anteriormente resolvia apenas parcialmente (as chaves marcam o assembly, não seus irmãos), e um restore para um projeto cujo project.assets.json vive fora de obj/ (ex.: UseArtifactsOutput ou um BaseIntermediateOutputPath personalizado).
• assemblyHandle (string): aceito por toda ferramenta que recebe assemblyPath, como alternativa a ele (passe um, não ambos). Obtenha um de open_assembly; ele também fornece o additionalAssemblies com o qual foi aberto, e qualquer um que você passar explicitamente é adicionado a eles.

Resolução de Tipos:

• Suporta nomes completos (Namespace.Type), nomes simples (Type) e tipos aninhados (Outer+Inner)
• Sensibilidade a maiúsculas/minúsculas controlada pelo parâmetro caseSensitive
• Resolução automática de fallback para nomes de tipos ambíguos

Esquema de Resposta

Todas as ferramentas retornam um envelope JSON estável:

{ "kind": "type.list|member.methods|...", "version": "1.0.0", "data": { /* result */ } }

O envelope é serializado como JSON compacto (sem indentação) no bloco de conteúdo de texto da ferramenta. As ferramentas principais de navegação também anunciam um outputSchema MCP e retornam o mesmo envelope como structuredContent, para que clientes possam validar e consumir resultados sem analisar texto: search_members, get_types_from_assembly, get_type_info, get_type_members, get_type_methods, get_assembly_info, get_method_calls, decompile_member, find_implementations_of, find_methods_returning, find_extension_methods_for e find_references_to. Seus esquemas descrevem a projeção padrão summary; itens projection='full' adicionam campos por cima dela. Resultados de erro nunca carregam structuredContent.

Resultados de erro são sinalizados com o isError: true do MCP, para que clientes possam distinguir uma falha de um resultado sem analisar o texto. Erros usam um formato consistente. Todo erro carrega kind, version, code e message; alguns adicionam details, e erros guiados adicionam um suggestion, alternativeTools ou recommendedParams para apontar o agente para um próximo passo:

{
  "kind": "error",
  "version": "1.0.0",
  "code": "MethodNotFound",
  "message": "No method named 'Parse' was found on type 'MyApp.Config' in MyApp.dll.",
  "suggestion": "Verify the type and method names. Use get_type_members with kinds=method to list available methods, or set includeNonPublic=true for private methods.",
  "alternativeTools": ["get_type_members", "analyze_method"]
}

Códigos de erro:

• Não encontrado: AssemblyNotFound (recommendedParams.similarFiles lista assemblies quase correspondentes na mesma pasta), TypeNotFound / MemberNotFound (recommendedParams.candidates lista os nomes mais próximos), MethodNotFound, PackageNotFound, VersionNotFound, XmlNotFound, ProjectNotFound, FileNotFound
• Entrada inválida: AmbiguousTypeName (apenas para clientes que não conseguem elicitar; recommendedParams.candidates lista os nomes completos correspondentes), InvalidArgument, InvalidProjection, InvalidAnalysisDepth, InvalidContinuationToken
• Carregamento: InvalidAssembly (não é um assembly gerenciado), DependencyNotFound (um assembly referenciado não pôde ser carregado), DependencyResolutionFailed, AccessDenied
• Limites e internos: ResponseTooLarge, InternalError

Roadmap

Recursos entregues e trabalho planejado estão resumidos em src/docs/roadmap.md; a lista de verificação ao vivo é rastreada em #87.

Contribuindo

Contribuições são bem-vindas. Este repositório inclui um .editorconfig com preferências modernas de C# (namespaces com escopo de arquivo, membros com corpo de expressão, indentação de 4 espaços).

Formato de Mensagem de Commit

Este projeto usa Conventional Commits para geração automatizada de changelog. Todos os commits devem seguir este formato:

type(scope): description

Tipos válidos:

• feat - Um novo recurso
• fix - Uma correção de bug
• docs - Apenas alterações de documentação
• style - Alterações de estilo de código (formatação, ponto e vírgula, etc.)
• refactor - Alteração de código que não corrige um bug nem adiciona um recurso
• perf - Melhoria de desempenho
• test - Adição ou correção de testes
• build - Alterações no sistema de build ou dependências
• ci - Alterações na configuração de CI
• chore - Outras alterações que não modificam arquivos de origem ou de teste
• revert - Reverte um commit anterior

Exemplos:

git commit -m "feat(tools): add new assembly analysis tool"
git commit -m "fix: resolve null reference in type loader"
git commit -m "docs(readme): update installation instructions"

Configuração de Desenvolvimento

# Restore .NET tools (versionize, husky)
dotnet tool restore

# Install git hooks for commit validation
dotnet husky install

Diretrizes

• Mantenha as alterações pequenas e focadas; adicione testes de unidade para novos comportamentos.
• Siga as convenções de envelope de resposta e códigos de erro ao adicionar ferramentas.
• Execute dotnet build e dotnet test localmente antes de abrir um PR.

Criando um Release

Os mantenedores podem criar releases usando:

# Restore tools if not already done
dotnet tool restore

# Preview what will change
dotnet versionize --dry-run

# Create release (bumps version, updates changelog, creates git tag)
dotnet versionize

# Push changes and tag to trigger release workflow
git push --follow-tags

versionize apenas incrementa a versão do projeto. Antes de enviar, incremente ambos os campos version em server.json, o version do plugin do Claude Code em plugins/sherlock/.claude-plugin/plugin.json e .claude-plugin/marketplace.json, e a versão fixada de dnx em plugins/sherlock/.mcp.json (e neste README) no mesmo commit de release, e então aponte a tag novamente para ele. server.json é empacotado no pacote NuGet como .mcp/server.json.

O fluxo de trabalho de release automaticamente:

1. Verificará se a tag, server.json, a versão do projeto e as versões do plugin do Claude Code coincidem
2. Compilará e testará o projeto
3. Criará um GitHub Release com notas de changelog
4. Publicará o pacote NuGet e a entrada no MCP Registry

MCP Registry

mcp-name: io.github.jcucci/dotnet-sherlock-mcp

Licença

Sherlock MCP para .NET é licenciado sob a Licença MIT.