dotnet-sherlock-mcp

Sherlock MCP para .NET

Sherlock MCP para .NET es un servidor integral del Protocolo de Contexto de Modelos (MCP) que proporciona capacidades profundas de introspección para ensamblados .NET. Permite que los Modelos de Lenguaje de Aprendizaje (LLMs) analicen y comprendan tu código .NET con precisión, ofreciendo respuestas precisas y conscientes del contexto para escenarios de desarrollo complejos.

Esta herramienta es esencial para desarrolladores que quieren aprovechar las capacidades de los LLM para:

• Análisis profundo de código - Comprender arquitecturas .NET complejas y dependencias
• Información precisa de tipos - Obtener metadatos detallados sobre tipos, miembros y sus firmas
• Documentación automatizada - Extraer y utilizar documentación XML y atributos
• Herramientas personalizadas - Construir herramientas sofisticadas que interactúan con ensamblados .NET
• Generación de código - Crear código preciso basado en estructuras de tipos existentes

Características Clave

• Servidor MCP Integral: Proporciona 40 herramientas especializadas para análisis de ensamblados .NET, con un perfil opcional de 20 herramientas core
• Introspección Avanzada de Ensamblados: Análisis profundo basado en reflexión de tipos, miembros y metadatos
• Análisis Enriquecido de Miembros: Inspección detallada de métodos, propiedades, campos, eventos y constructores
• Filtrado y Paginación Inteligente: Filtrado avanzado por nombre/atributos con paginación eficiente para grandes conjuntos de datos
• Integración de Documentación XML: Extracción automática de resúmenes, parámetros, valores de retorno y observaciones
• Optimizado para Rendimiento: Caché, paginación y procesamiento eficiente de memoria
• API JSON Estable: Envoltorios consistentes con versionado y códigos de error estructurados
• Nativo .NET 9.0: Construido sobre la última plataforma .NET con características modernas de C#
• Integración de Proyectos: Análisis de soluciones y archivos de proyecto con resolución de dependencias
• Indicaciones de Flujo de Trabajo: Las indicaciones explore_package, explain_type y who_calls ofrecen puntos de entrada de un clic para flujos de trabajo de análisis comunes
• SDK MCP Actual: Construido sobre ModelContextProtocol 2.1.0 (GA)
• Especificación MCP Actual: Habla la revisión de protocolo 2026-07-28, y negocia automáticamente hacia abajo para clientes en revisiones anteriores

Novedades en 2.14.0

• Plugin de Claude Code: /plugin marketplace add jcucci/dotnet-sherlock-mcp y /plugin install sherlock@dotnet-sherlock-mcp instalan el servidor más una habilidad que enseña a los agentes el flujo de trabajo de Sherlock. Ver Plugin de Claude Code.
• get_type_members y perfiles de herramientas: una lista paginada y filtrable de herramientas enumera cada tipo de miembro, y --profile core / SHERLOCK_TOOL_PROFILE=core reduce la superficie a las herramientas esenciales. Las herramientas de miembros por tipo están obsoletas.
• Salida estructurada y guía de errores: las herramientas principales de navegación publican un outputSchema y devuelven structuredContent, y las llamadas fallidas llevan isError: true con candidatos de "quisiste decir" y sugerencias de corrección.
• Cancelación, progreso y obtención de información: los escaneos largos se pueden cancelar y reportan progreso, y un nombre de tipo simple ambiguo solicita al cliente que elija. Ver CHANGELOG.md para detalles completos.

Instalación

Ejecutar con dnx (SDK .NET 10)

Con el SDK .NET 10, dnx descarga el paquete de NuGet y lo ejecuta directamente — sin paso de instalación:

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

--yes omite el mensaje de confirmación interactivo, que un cliente MCP que lanza el servidor a través de stdio no puede responder. -v q evita que dnx imprima un aviso de "Omitiendo verificación de firma de paquete NuGet." en la salida estándar la primera vez que descarga una versión, lo que de otro modo corrompería el flujo MCP y fallaría esa primera conexión. Ambas son opciones de dnx, por lo que deben ir antes del id del paquete; cualquier cosa después se pasa al servidor. Fijar la versión mantiene los lanzamientos reproducibles; actualízala cuando quieras mejorar. El paquete se publica con el tipo de paquete McpServer, por lo que también aparece listado como servidor MCP en NuGet.org.

Instalar como herramienta global

En cualquier SDK compatible (.NET 8 o posterior), instala la herramienta global desde NuGet (agrega sherlock-mcp a tu PATH):

dotnet tool install -g Sherlock.MCP.Server

Alternativamente, durante el desarrollo puedes ejecutar el servidor localmente:

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

Configurar Tu Cliente MCP

Sherlock se ejecuta como un servidor MCP estándar que se comunica a través de stdio.

Plugin de Claude Code

Este repositorio también es un mercado de plugins de Claude Code. El plugin sherlock incluye el servidor (lanzado con dnx, por lo que necesita el SDK .NET 10) y una habilidad que enseña al agente el flujo de trabajo localizar → orientar → profundizar → relaciones:

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

El plugin inicia el servidor con el perfil de herramientas core, que coincide con las herramientas que cubre la habilidad. Para exponer todas las herramientas, establece SHERLOCK_TOOL_PROFILE=full en el entorno desde el que se lanza Claude Code.

Cada usuario ejecuta estos comandos una vez; reinicia Claude Code (o ejecuta /reload-plugins) después. Para obtener una nueva versión, ejecuta /plugin marketplace update dotnet-sherlock-mcp. Si previamente registraste Sherlock con claude mcp add, elimina esa entrada (claude mcp remove sherlock) para que las herramientas no se carguen dos veces.

Configuración de equipo

Para ofrecer el plugin a todos los que trabajan en un repositorio, confirma lo siguiente en el .claude/settings.json de ese repositorio. Claude Code solicita a cada compañero que lo instale cuando confían en la carpeta, para que nadie tenga que escribir los comandos anteriores:

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

Los compañeros aún necesitan el SDK .NET 10 en su 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 la herramienta global

• Cursor: Configuración → MCP / Herramientas personalizadas → Agregar herramienta → Comando: sherlock-mcp
• Claude Desktop / otros clientes MCP: Agrega una entrada de servidor que apunte al comando sherlock-mcp. Ejemplo de entrada JSON (consulta la documentación de tu cliente para la ubicación/formato exacto del archivo):

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

No se requieren argumentos. El servidor registra automáticamente todas las herramientas al iniciarse.

Perfiles de herramientas

Las listas grandes de herramientas cuestan contexto y descubribilidad a los agentes (Claude Code cambia a Búsqueda de Herramientas diferida una vez que las descripciones de herramientas crecen más allá de aproximadamente el 10% de la ventana de contexto). Sherlock puede iniciarse con una superficie más pequeña:

Perfil	Herramientas	Contenido
full (predeterminado)	40	Todas las herramientas, incluidas las herramientas de miembros por tipo obsoletas
core	20	Descubrimiento (find_assembly_by_class_name, find_assembly_by_file_name, find_assembly_by_nuget_package, get_project_output_paths, open_assembly), orientación (get_assembly_info, get_types_from_assembly, get_type_info, get_type_hierarchy), miembros y documentación (get_type_members, search_members, analyze_method, get_xml_docs_for_type, get_xml_docs_for_member) y relaciones (find_implementations_of, find_methods_returning, find_extension_methods_for, find_references_to, get_method_calls) y descompilación (decompile_member)

Selecciona un perfil con el argumento --profile o la variable de entorno SHERLOCK_TOOL_PROFILE (el argumento gana). Un nombre de perfil desconocido detiene el servidor con un error.

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

Auto-Configuración para Proyectos .NET

Normalmente no necesitas pegar nada. Sherlock incluye su guía de uso en el campo instructions de MCP devuelto al inicializar, y la mayoría de los clientes MCP (incluido Claude Code) la muestran al agente automáticamente — por lo que la guía se mantiene correcta y versionada con el paquete, sin copiar y pegar que mantener.

Los fragmentos a continuación son refuerzo opcional. Mantenlos cortos y basados en principios en lugar de enumerar nombres de herramientas y flujos de trabajo: una lista estática pegada en tu repositorio se desactualizará a medida que evolucionen las herramientas de Sherlock, mientras que las descripciones de las propias herramientas (y el instructions del servidor) siempre coinciden con la versión que estás ejecutando.

Los nombres de herramientas se exponen en snake_case (get_type_members, search_members, …); los nombres de argumentos permanecen en camelCase (projection, nameContains).

Claude Code (CLAUDE.md)

Si instalaste el plugin de Claude Code, su habilidad ya cubre esto. De lo contrario, puedes agregar un puntero corto y opcional al CLAUDE.md de tu proyecto:

## .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)

El formato de archivo único .cursorrules está obsoleto (y se ignora silenciosamente en el modo Agente de Cursor). Agrega una Regla de Proyecto en .cursor/rules/sherlock.mdc en su lugar:

---
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.

Otros agentes (AGENTS.md)

Para herramientas que siguen la convención AGENTS.md entre editores, el mismo puntero corto funciona — coloca el fragmento de Claude Code anterior en tu AGENTS.md.

Configuración global

Para uso en todo el sistema, agrega a tu configuración global 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.

Cómo Indicarle

A continuación hay fragmentos de indicaciones compactos que puedes pegar en tu chat para ser productivo rápidamente. Ajusta las rutas a tus DLLs locales.

Configuración general

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 miembros de un 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.

Obtener documentación XML de un miembro

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

Encontrar tipos y profundizar

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

Ajustar paginación y filtros

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

Navegar ligero, luego obtener detalle (proyección)

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 relaciones y sitios de llamada

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.

Resumen de Herramientas

Nombres de herramientas: Los clientes MCP llaman a estas herramientas en snake_case — GetTypeMembers → get_type_members, SearchMembers → search_members, y así sucesivamente. Los nombres en PascalCase utilizados en todo este README coinciden con los métodos C# subyacentes y las descripciones de herramientas que muestra tu cliente.

Descubrimiento y Análisis de Ensamblados

• OpenAssembly: Devuelve un identificador corto asm_… para pasar como assemblyHandle en lugar de assemblyPath en cualquier herramienta que acepte un ensamblado. El identificador lleva additionalAssemblies también, persiste entre reinicios del servidor (en handles.json bajo SHERLOCK_STATE_DIR, por defecto la carpeta sherlock de datos locales de aplicación del usuario) y está fijado a la compilación actual: después de una recompilación, las llamadas fallan con StaleAssemblyHandle hasta que se vuelva a abrir
• AnalyzeAssembly: Resumen completo del ensamblado con tipos públicos y metadatos
• GetAssemblyInfo: Metadatos a nivel de ensamblado — identidad/versión, marco de destino y ensamblados referenciados (projection=full agrega todos los atributos del ensamblado)
• FindAssemblyByClassName: Localiza ensamblados que declaran un tipo público por nombre simple, completo o anidado; omite obj/, ref/, refint/, node_modules/, packages/, TestResults/ y directorios de puntos, y clasifica las coincidencias bin/ primero
• FindAssemblyByFileName: Encuentra ensamblados por nombre de archivo bajo un directorio raíz, con las mismas exclusiones y clasificación
• FindAssemblyByNugetPackage: Resuelve una DLL desde la caché local de NuGet por id de paquete (version/tfm opcional)

Introspección de Tipos

• GetTypesFromAssembly: Lista todos los tipos públicos con metadatos (paginado)
• AnalyzeType (obsoleto): Metadatos de tipo más todos los miembros; usa GetTypeInfo + GetTypeMembers projection=full
• GetTypeInfo: Metadatos detallados de tipo (accesibilidad, genéricos, tipos anidados)
• GetTypeHierarchy: Cadena de herencia e implementaciones de interfaces
• GetGenericTypeInfo: Parámetros genéricos, argumentos e información de varianza
• GetTypeAttributes: Atributos personalizados declarados en tipos
• GetNestedTypes: Declaraciones de tipos anidados

Análisis de Miembros (Filtrable y Paginado)

• GetTypeMembers: Métodos, propiedades, campos, eventos y constructores de un tipo en una lista paginada. Reduce con kinds (method|property|field|event|constructor), nameContains y hasAttributeContains; los elementos summary son { kind, name, signature }, projection=full agrega los campos estructurados de cada tipo
• AnalyzeMethod: Análisis profundo de métodos con sobrecargas y atributos
• Obsoletas, mantenidas por una o dos versiones: GetTypeMethods, GetTypeProperties, GetTypeFields, GetTypeEvents, GetTypeConstructors (usa GetTypeMembers con kinds) y GetAllTypeMembers (usa GetTypeMembers projection=full)

Búsqueda de Miembros

• SearchMembers: Busca en todo un ensamblado miembros cuyo nombre contenga un fragmento — el punto de entrada cuando conoces un nombre de miembro pero no su tipo declarante. Filtra por memberKinds (method|property|field|event|type).

Búsqueda Inversa

• FindImplementationsOf: Tipos que implementan una interfaz o derivan de una clase base (coincidencia genérica abierta compatible)
• FindMethodsReturning: Métodos cuyo tipo de retorno coincide con un tipo dado (coincidencia genérica abierta compatible)
• FindExtensionMethodsFor: Métodos de extensión que extienden un tipo dado (escanea clases estáticas por el parámetro this)
• FindReferencesTo: Barrido más amplio a través de parámetros, campos, propiedades, eventos y argumentos genéricos; pase analysisDepth='il' para también resolver llamadores entrantes desde cuerpos de métodos

Análisis de IL

• GetMethodCalls: Lee el cuerpo IL de un método para listar qué llama y qué campos toca — la pregunta "¿qué hace este método?" que las herramientas a nivel de firma no pueden responder (agrega entre sobrecargas; use .ctor/.cctor para constructores)

Descompilación

• DecompileMember: Descompila un miembro (método, propiedad, campo, evento o constructor) a C# con ICSharpCode.Decompiler. Devuelve cada sobrecarga del nombre, o una sobrecarga cuando se da parameterTypes (por ejemplo, string,int; una cadena vacía selecciona la sobrecarga sin parámetros). Use .ctor/.cctor para constructores
• DecompileType: Descompila un tipo completo a C#. No está en el perfil core; prefiera DecompileMember

Ambas herramientas paginan su fuente por línea: maxLines (predeterminado 400, máximo 5000) limita el tamaño de página, una página también se detiene temprano una vez que alcanza aproximadamente 90,000 caracteres para que siempre quepa en el límite de respuesta, y cada página informa startLine, lineCount, totalLines, truncated y un continuationToken para la siguiente página. Las líneas de más de 2,000 caracteres se recortan con un marcador /* … more characters clipped */ y se cuentan en clippedLines. Pase additionalAssemblies (o use un assemblyHandle abierto con ellos) cuando las dependencias vivan fuera de la carpeta del ensamblado; sus carpetas se buscan al resolver tipos referenciados y sus sellos de archivo son parte de la clave de caché. La descompilación completa se almacena en caché por sello de archivo, por lo que las páginas posteriores son económicas. Un tipo que el ensamblado solo reenvía (por ejemplo, System.String en una fachada System.Runtime.dll) devuelve TypeForwarded con el ensamblado definidor en recommendedParams.

Atributos y Metadatos

• GetMemberAttributes: Atributos para miembros específicos
• GetParameterAttributes: Información de atributos a nivel de parámetro

Documentación XML

• GetXmlDocsForType: Extrae documentación XML a nivel de tipo
• GetXmlDocsForMember: Documentación específica de miembros (resumen/parámetros/retornos/comentarios)

Análisis de Proyectos y Soluciones

• AnalyzeSolution: Analiza archivos .sln y enumera proyectos
• AnalyzeProject: Metadatos de proyecto, referencias y configuración de compilación
• GetProjectOutputPaths: Resuelve directorios de salida para diferentes configuraciones
• ResolvePackageReferences: Mapea paquetes NuGet a ensamblados en caché
• FindDepsJsonDependencies: Analiza deps.json para dependencias de tiempo de ejecución

Configuración y Tiempo de Ejecución

• GetRuntimeOptions: Configuración actual del servidor y valores predeterminados
• UpdateRuntimeOptions: Modifica el comportamiento de paginación, caché y búsqueda

Recursos

Tres plantillas de recursos permiten a los clientes obtener un solo tipo, entrada de documentación o paquete en caché sin otra llamada de herramienta. Cada variable está codificada en porcentaje.

• sherlock://assembly/{path}/type/{fullName}: Metadatos de tipo, la misma carga útil que get_type_info
• sherlock://assembly/{path}/docs/{memberId}: Documentación XML para un id de documentación como T:Ns.Type o M:Ns.Type.Method(System.String)
• sherlock://nuget/{packageId}/{version}: El ensamblado al que se resuelve una versión de paquete NuGet en caché, la misma carga útil que find_assembly_by_nuget_package

search_members, get_types_from_assembly y las herramientas de búsqueda inversa find_* devuelven un resource_link al recurso de tipo para cada tipo distinto en la página, después del bloque de texto JSON. resources/read lleva sugerencias de caché privadas; un URI cuyo ensamblado, tipo, id de documento o paquete no existe falla con -32602.

Las variables de plantilla admiten completion/complete, devolviendo como máximo 100 valores:

• path: ensamblados cargados recientemente, luego archivos .dll/.exe y subcarpetas de la carpeta que se está escribiendo
• fullName: nombres de tipo (forma de metadatos, por ejemplo, List`1) from the assembly in the argumento de contexto path`
• memberId: ids de documentación del archivo XML junto al ensamblado path
• packageId / version: carpetas de paquetes y sus versiones (más recientes primero) en la caché local de NuGet

Prompts

Tres prompts codifican secuencias comunes de herramientas como puntos de entrada de un clic (Claude Code los lista como comandos de barra /mcp__sherlock__<name>). Cada uno devuelve un solo mensaje de usuario que guía al agente a través de las herramientas; solo llaman herramientas en el perfil core, por lo que funcionan bajo cualquier perfil.

• explore_package (packageId, version?): Resuelve el paquete desde la caché local de NuGet (versión en caché más alta cuando se omite version), se orienta en el ensamblado y resume sus tipos principales y puntos de entrada
• explain_type (assemblyPath, typeName): Jerarquía, miembros, documentos XML y usos de un tipo
• who_calls (assemblyPath, typeName, memberName, additionalAssemblies?): Llamadores entrantes de un miembro desde IL, opcionalmente a través de una lista separada por comas de otros ensamblados

assemblyPath, typeName (con assemblyPath en el contexto de finalización), packageId y version (con packageId en el contexto) admiten completion/complete de la misma manera que las variables de plantilla de recursos. prompts/list lleva las mismas sugerencias de caché públicas que tools/list.

Filtrado Avanzado y Paginación

Todas las herramientas de análisis de miembros admiten filtrado y paginación completos:

Opciones de Filtrado:

• caseSensitive (bool): Coincidencia de tipo/miembro sensible a mayúsculas
• nameContains (string): Filtrar por subcadena de nombre de miembro
• hasAttributeContains (string): Filtrar por subcadena de tipo de atributo
• includePublic / includeNonPublic (bool): Filtrado de visibilidad
• includeStatic / includeInstance (bool): Filtrado de tipo de miembro

Paginación:

• skip / take (int): Paginación de desplazamiento estándar
• maxItems (int): Máximo de resultados por solicitud (predeterminado 50; FindReferencesTo predeterminado a 25)
• continuationToken (string): Paginación basada en tokens para conjuntos de datos grandes
• sortBy / sortOrder (string): Ordenar por nombre/acceso en orden asc/desc

Forma de Respuesta (eficiencia de tokens)

La mayoría de las herramientas de enumeración usan por defecto una proyección ligera summary y le permiten optar por la carga útil más pesada full solo cuando la necesita. Recurra a full deliberadamente — summary suele ser suficiente para decidir su próxima llamada.

• projection (summary | full): compatible con GetTypesFromAssembly, GetTypeMembers, GetTypeMethods, GetAssemblyInfo, GetMethodCalls, FindImplementationsOf, FindMethodsReturning, FindExtensionMethodsFor y FindReferencesTo. summary devuelve lo suficiente para navegar (por ejemplo, { kind, name, signature } para miembros); full agrega campos estructurados (parámetros, atributos, tipo de retorno, modificadores, etc.). Nota: los GetTypeProperties/Fields/Events/Constructors obsoletos tienen una forma fija única y no aceptan projection.
• analysisDepth (signatures | il): solo FindReferencesTo. signatures (predeterminado) escanea declaraciones de miembros; il además escanea cuerpos de métodos para llamadores entrantes (más lento).
• additionalAssemblies (string[]): amplía el alcance de búsqueda para GetTypeHierarchy y las herramientas de búsqueda inversa. GetTypeHierarchy.derivedTypes permanece null hasta que pase esto.
• noCache (bool): omite la caché de respuestas para una sola llamada cuando sospecha resultados obsoletos. Cada herramienta que lee un ensamblado o proyecto almacena en caché su respuesta, clave por los sellos de archivo de sus entradas (el ensamblado y cualquier additionalAssemblies, el archivo de documento XML junto a él, o el archivo de proyecto y obj/project.assets.json), por lo que una reconstrucción o restauración la invalida automáticamente. Las búsquedas find_assembly_by_* y resolve_package_references (que leen la caché compartida de paquetes NuGet), las herramientas de configuración y manejo no se almacenan en caché. Dos casos que los sellos no detectan, donde noCache=true es la solución: un DLL de dependencia colocado junto a un ensamblado que anteriormente se resolvía solo parcialmente (las claves sellan el ensamblado, no sus hermanos), y una restauración para un proyecto cuyo project.assets.json vive fuera de obj/ (por ejemplo, UseArtifactsOutput o un BaseIntermediateOutputPath personalizado).
• assemblyHandle (string): aceptado por cada herramienta que toma assemblyPath, como alternativa a este (pase uno, no ambos). Obtenga uno de open_assembly; también proporciona el additionalAssemblies con el que se abrió, y cualquier que pase explícitamente se agrega a ellos.

Resolución de Tipos:

• Admite nombres completos (Namespace.Type), nombres simples (Type) y tipos anidados (Outer+Inner)
• Sensibilidad a mayúsculas controlada por el parámetro caseSensitive
• Resolución de respaldo automática para nombres de tipo ambiguos

Esquema de Respuesta

Todas las herramientas devuelven un sobre JSON estable:

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

El sobre se serializa como JSON compacto (sin sangría) en el bloque de contenido de texto de la herramienta. Las herramientas principales de navegación también anuncian un outputSchema de MCP y devuelven el mismo sobre como structuredContent, para que los clientes puedan validar y consumir resultados sin analizar 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 y find_references_to. Sus esquemas describen la proyección predeterminada summary; los elementos projection='full' agregan campos además de ella. Los resultados de error nunca llevan structuredContent.

Los resultados de error se marcan con el isError: true de MCP, para que los clientes puedan distinguir un fallo de un resultado sin analizar el texto. Los errores usan una forma consistente. Cada error lleva kind, version, code y message; algunos agregan details, y los errores guiados agregan un suggestion, alternativeTools o recommendedParams para apuntar al agente a un siguiente paso:

{
  "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 error:

• No encontrado: AssemblyNotFound (recommendedParams.similarFiles lista ensamblados casi coincidentes en la misma carpeta), TypeNotFound / MemberNotFound (recommendedParams.candidates lista los nombres más cercanos), MethodNotFound, PackageNotFound, VersionNotFound, XmlNotFound, ProjectNotFound, FileNotFound
• Entrada incorrecta: AmbiguousTypeName (solo para clientes que no pueden obtener; recommendedParams.candidates lista los nombres completos coincidentes), InvalidArgument, InvalidProjection, InvalidAnalysisDepth, InvalidContinuationToken
• Carga: InvalidAssembly (no es un ensamblado administrado), DependencyNotFound (un ensamblado referenciado no pudo cargarse), DependencyResolutionFailed, AccessDenied
• Límites e internos: ResponseTooLarge, InternalError

Hoja de Ruta

Las características enviadas y el trabajo planificado se resumen en src/docs/roadmap.md; la lista de verificación en vivo se rastrea en #87.

Contribuciones

Las contribuciones son bienvenidas. Este repositorio incluye un .editorconfig con preferencias modernas de C# (espacios de nombres con ámbito de archivo, miembros con cuerpo de expresión, sangría de 4 espacios).

Formato de Mensajes de Confirmación

Este proyecto usa Conventional Commits para la generación automatizada de registros de cambios. Todas las confirmaciones deben seguir este formato:

type(scope): description

Tipos válidos:

• feat - Una nueva funcionalidad
• fix - Una corrección de errores
• docs - Solo cambios de documentación
• style - Cambios de estilo de código (formato, punto y coma, etc.)
• refactor - Cambio de código que no corrige un error ni agrega una funcionalidad
• perf - Mejora de rendimiento
• test - Agregar o corregir pruebas
• build - Cambios en el sistema de compilación o dependencias
• ci - Cambios en la configuración de CI
• chore - Otros cambios que no modifican archivos de src o de prueba
• revert - Revierte una confirmación anterior

Ejemplos:

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"

Configuración de desarrollo

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

# Install git hooks for commit validation
dotnet husky install

Directrices

• Mantén los cambios pequeños y enfocados; agrega pruebas unitarias para el nuevo comportamiento.
• Sigue el sobre de respuesta y las convenciones de códigos de error al agregar herramientas.
• Ejecuta dotnet build y dotnet test localmente antes de abrir una solicitud de extracción (PR).

Creación de una versión

Los mantenedores pueden crear versiones 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 solo incrementa la versión del proyecto. Antes de enviar, incrementa ambos campos version en server.json, el version del plugin de Claude Code en plugins/sherlock/.claude-plugin/plugin.json y .claude-plugin/marketplace.json, y la versión fijada de dnx en plugins/sherlock/.mcp.json (y en este README) en la misma confirmación de versión, luego vuelve a apuntar la etiqueta a ella. server.json se empaqueta en el paquete NuGet como .mcp/server.json.

El flujo de trabajo de versión automáticamente:

1. Verificará que la etiqueta, server.json, la versión del proyecto y las versiones del plugin de Claude Code coincidan
2. Compilará y probará el proyecto
3. Creará una versión de GitHub con notas de cambios
4. Publicará el paquete NuGet y la entrada del Registro MCP

Registro MCP

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

Licencia

Sherlock MCP para .NET está licenciado bajo la Licencia MIT.