dotnet-coverage-mcp

Un servidor MCP (Model Context Protocol) que brinda a los asistentes de IA — Claude Code, Gemini CLI y otros — acceso directo a las herramientas de cobertura de pruebas de .NET. Ejecuta dotnet test, analiza XML de Cobertura, identifica ramas no cubiertas, compara la cobertura entre ejecuciones y añade código de prueba, todo a través de stdio.

Propósito

Este servidor permite que un asistente de IA ejecute pruebas unitarias, recopile datos de cobertura y analice resultados, todo sin salir del chat. En lugar de ejecutar manualmente dotnet test y analizar informes, la IA puede llamar directamente a las herramientas del servidor para:

• Descubrir archivos fuente y crear lotes inteligentes según el presupuesto de líneas

• Ejecutar un conjunto filtrado de pruebas y recopilar cobertura

• Leer resúmenes de cobertura compactos y optimizados para IA (tasas de línea/rama a nivel de método)

• Verificar la cobertura por archivo contra una tasa objetivo configurable (80% por defecto)

• Identificar ramas no cubiertas como JSON estructurado

• Comparar la cobertura entre ejecuciones para ver solo lo que cambió

• Añadir nuevo código de prueba a un archivo de prueba existente con escrituras atómicas

Related MCP server: codecov-mcp-server

Cómo funciona

El servidor se inicia como un proceso de consola y se comunica a través de stdio usando el protocolo MCP. Un cliente compatible con MCP (Claude Code, Gemini CLI, etc.) lanza el proceso y llama a sus herramientas como si fueran funciones.

AI Client  <--stdio/MCP-->  dotnet-coverage-mcp  <--shell-->  dotnet test + reportgenerator

Herramientas disponibles

Flujo de trabajo por lotes

Para proyectos con muchos archivos fuente, el flujo de trabajo recomendado es:

1. Descubrir — Llama a GetSourceFiles en una carpeta o .csproj para obtener todos los archivos y lotes inteligentes

2. Ejecutar una vez — Llama a RunTestsWithCoverage con un filtro amplio (p. ej., *) para recopilar cobertura en todos los archivos

3. Verificar por archivo — Llama a GetFileCoverage para cada archivo del lote actual (análisis XML instantáneo, sin re-ejecutar pruebas)

4. Enfocar — Elige los 3 métodos con menor cobertura de ramas y llama a GetUncoveredBranches para cada uno

5. Escribir pruebas — Usa AppendTestCode para añadir métodos de prueba

6. Re-ejecutar y comparar — Ejecuta las pruebas una vez, llama a GetCoverageDiff para verificar la mejora

7. Repetir — Continúa hasta que los archivos del lote cumplan la tasa objetivo (80% por defecto) o 3 ciclos sin mejora, luego pasa al siguiente lote

Esto minimiza las invocaciones de dotnet test (el principal cuello de botella) mientras sigue el progreso por archivo.

Concurrencia

Varios agentes de IA pueden ejecutarse en paralelo pasando un sessionId a cada llamada de herramienta, lo que aísla sus artefactos de cobertura:

• Directorios de salida aislados — RunTestsWithCoverage crea TestResults-{hash}/ y coveragereport-{hash}/ por sesión, evitando que un agente elimine el XML de otro durante el análisis

• Archivos de estado acotados — El estado de cobertura se escribe en .mcp-coverage/.coverage-state-{hash}, por lo que ResolveCoberturaPath resuelve el XML correcto para cada sesión

• Líneas base acotadas — GetCoverageDiff almacena líneas base como .coverage-prev-{hash}.xml por sesión

• Escrituras atómicas — Todas las escrituras de archivos (archivos de estado y código de prueba) usan escribir-a-temporal-luego-renombrar para evitar la corrupción por condiciones de carrera o fallos del proceso

Limitación: los resultados de compilación no están acotados por sesión. sessionId aísla los artefactos de cobertura, no la compilación de .NET. dotnet test compila el proyecto de destino en sus obj/ y bin/ compartidos, que no son por sesión, por lo que dos agentes que ejecutan RunTestsWithCoverage contra el mismo proyecto de prueba al mismo tiempo chocan en esos resultados y fallan con buildError (p. ej., CS2012: el archivo está siendo usado por otro proceso). Ejecuta agentes en paralelo contra proyectos de prueba diferentes, o en copias de trabajo separadas del repositorio. Varios agentes en un solo proyecto están bien siempre que sus compilaciones de dotnet test no se superpongan.

Sin sessionId, las herramientas usan valores predeterminados compartidos: seguro para uso de un solo agente.

Requisitos

• .NET 9.0 SDK (o posterior) — https://dotnet.microsoft.com/download

• Herramienta global reportgenerator — el servidor la invoca para renderizar informes de cobertura (instalada en el paso Instalación a continuación)

• Un cliente compatible con MCP (Claude Code, Gemini CLI, etc.)

• COVERAGE_MCP_ALLOWED_ROOT — recomendado. Establécelo en la raíz de tu repositorio para restringir el acceso al sistema de archivos de cada herramienta a ese subárbol. Cualquier ruta pasada por el cliente fuera de esta raíz se rechaza con pathNotAllowed. Si no se establece, el servidor registra una advertencia una vez y acepta cualquier ruta (compatible con versiones anteriores, pero no recomendado para entornos compartidos).

  export COVERAGE_MCP_ALLOWED_ROOT=/path/to/your/repo

Instalación

Instala el servidor como una herramienta global de .NET desde NuGet:

dotnet tool install --global dotnet-coverage-mcp

El servidor depende de la herramienta global reportgenerator para renderizar informes de cobertura: instálala también:

dotnet tool install --global dotnet-reportgenerator-globaltool

Después de la instalación, el comando dotnet-coverage-mcp está en tu PATH.

Compilar y ejecutar (desde el código fuente)

cd <path-to-dotnet-coverage-mcp>

# Restore dependencies
dotnet restore

# Build
dotnet build

# Run
dotnet run

El servidor se iniciará y esperará mensajes MCP a través de stdin/stdout.

Configuración del cliente MCP

Después de instalar la herramienta global (dotnet tool install --global dotnet-coverage-mcp), registra el servidor con tu cliente MCP. Establece COVERAGE_MCP_ALLOWED_ROOT al repositorio en el que quieres que opere el servidor.

Claude Code

claude mcp add coverage --env COVERAGE_MCP_ALLOWED_ROOT=/path/to/your/repo -- dotnet-coverage-mcp

Claude Desktop

Añade a claude_desktop_config.json (Configuración → Desarrollador → Editar configuración):

{
  "mcpServers": {
    "coverage": {
      "command": "dotnet-coverage-mcp",
      "env": {
        "COVERAGE_MCP_ALLOWED_ROOT": "/path/to/your/repo"
      }
    }
  }
}

Cursor

Añade a ~/.cursor/mcp.json (global) o .cursor/mcp.json (por proyecto):

{
  "mcpServers": {
    "coverage": {
      "command": "dotnet-coverage-mcp",
      "env": {
        "COVERAGE_MCP_ALLOWED_ROOT": "/path/to/your/repo"
      }
    }
  }
}

VS Code (GitHub Copilot)

Añade a .vscode/mcp.json:

{
  "servers": {
    "coverage": {
      "type": "stdio",
      "command": "dotnet-coverage-mcp",
      "env": {
        "COVERAGE_MCP_ALLOWED_ROOT": "/path/to/your/repo"
      }
    }
  }
}

Ejecutar desde el código fuente

Para ejecutar desde el código fuente en lugar de la herramienta global, usa dotnet run:

{
  "mcpServers": {
    "coverage": {
      "command": "dotnet",
      "args": ["run", "--project", "<path-to-dotnet-coverage-mcp>"],
      "transport": "stdio"
    }
  }
}

O apunta directamente al ejecutable compilado:

{
  "mcpServers": {
    "coverage": {
      "command": "<path-to-dotnet-coverage-mcp>\\bin\\Debug\\net9.0\\DotNetCoverageMcp.exe",
      "transport": "stdio"
    }
  }
}

Parámetros de las herramientas

GetSourceFiles

RunTestsWithCoverage

GetCoverageSummary

GetFileCoverage

GetUncoveredBranches

GetCoverageDiff

AppendTestCode

CleanupSession

Archivos de estado

Todos los archivos de estado se escriben en un subdirectorio .mcp-coverage/ dentro del directorio de trabajo, manteniendo limpia la raíz del proyecto. Agregue .mcp-coverage/ al .gitignore del repositorio de destino.

Plugin (Skills y agente)

Este repositorio incluye un directorio plugin/ con skills de Claude Code y una definición de agente para flujos de trabajo guiados de cobertura de pruebas:

plugin/
├── plugin.json
├── agents/
│   └── test-coverage.agent.md
└── skills/
    ├── scaffold-test-files/     — Create test directories and files mirroring source structure
    ├── run-coverage/            — Run tests and view coverage reports
    ├── analyze-coverage-gaps/   — Find uncovered branches and compare diffs
    └── improve-test-coverage/   — Iterative loop to reach 80% coverage

Las skills admiten NUnit, xUnit y MSTest con documentación de referencia independiente del framework en references/unit.md y references/integration.md.

Dependencias

Seguridad

dotnet-coverage-mcp se ejecuta como un proceso stdio local y valida cada argumento de herramienta contra COVERAGE_MCP_ALLOWED_ROOT para limitar el acceso al sistema de archivos. Consulte SECURITY.md para conocer el modelo de amenazas, las recomendaciones de endurecimiento y cómo informar una vulnerabilidad.

Contribuciones

Las contribuciones son bienvenidas. Consulte CONTRIBUTING.md para la configuración de desarrollo, las pautas de solicitudes de extracción y las convenciones de código. Los cambios notables se registran en CHANGELOG.md.

Publicación

Solo para mantenedores: el proceso de lanzamiento, la publicación en NuGet y el envío al registro de MCP están documentados en RELEASING.md.