dotnet-coverage-mcp

Ein MCP-Server (Model Context Protocol), der KI-Assistenten – Claude Code, Gemini CLI und andere – direkten Zugriff auf .NET-Testabdeckungswerkzeuge gibt. Führen Sie dotnet test aus, parsen Sie Cobertura-XML, identifizieren Sie nicht abgedeckte Verzweigungen, vergleichen Sie die Abdeckung zwischen Läufen und fügen Sie Testcode hinzu – alles über stdio.

Zweck

Dieser Server ermöglicht es einem KI-Assistenten, Unit-Tests auszuführen, Abdeckungsdaten zu sammeln und Ergebnisse zu analysieren – ganz ohne den Chat zu verlassen. Statt dotnet test manuell auszuführen und Berichte zu parsen, kann die KI die Tools des Servers direkt aufrufen, um:

• Quelldateien zu entdecken und intelligente Stapel nach Zeilenbudget zu erstellen

• Eine gefilterte Reihe von Tests auszuführen und Abdeckung zu sammeln

• Kompakte, KI-optimierte Abdeckungszusammenfassungen zu lesen (Methoden-Level-Zeilen-/Verzweigungsraten)

• Die Abdeckung pro Datei gegen eine konfigurierbare Zielrate zu prüfen (Standard 80%)

• Nicht abgedeckte Verzweigungen als strukturiertes JSON zu identifizieren

• Die Abdeckung zwischen Läufen zu vergleichen, um nur das zu sehen, was sich geändert hat

• Neuen Testcode an eine bestehende Testdatei mit atomaren Schreibvorgängen anzuhängen

Related MCP server: codecov-mcp-server

So funktioniert es

Der Server startet als Konsolenprozess und kommuniziert über stdio mit dem MCP-Protokoll. Ein MCP-kompatibler Client (Claude Code, Gemini CLI usw.) startet den Prozess und ruft seine Tools auf, als wären sie Funktionen.

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

Verfügbare Tools

Stapel-Workflow

Für Projekte mit vielen Quelldateien ist der empfohlene Workflow:

1. Entdecken – Rufen Sie GetSourceFiles für einen Ordner oder ein .csproj auf, um alle Dateien und intelligente Stapel zu erhalten

2. Einmal ausführen – Rufen Sie RunTestsWithCoverage mit einem breiten Filter (z. B. *) auf, um Abdeckung über alle Dateien zu sammeln

3. Pro Datei prüfen – Rufen Sie GetFileCoverage für jede Datei im aktuellen Stapel auf (sofortiges XML-Parsing, kein erneuter Testlauf)

4. Fokussieren – Wählen Sie die 3 Methoden mit der niedrigsten Verzweigungsabdeckung und rufen Sie GetUncoveredBranches für jede auf

5. Tests schreiben – Verwenden Sie AppendTestCode, um Testmethoden hinzuzufügen

6. Erneut ausführen und vergleichen – Führen Sie Tests einmal aus, rufen Sie GetCoverageDiff auf, um Verbesserungen zu überprüfen

7. Wiederholen – Fahren Sie fort, bis die Stapeldateien die Zielrate (Standard 80%) erreichen oder 3 Zyklen ohne Verbesserung, dann wechseln Sie zum nächsten Stapel

Dies minimiert dotnet test-Aufrufe (den Hauptengpass) und verfolgt gleichzeitig den Fortschritt pro Datei.

Parallelität

Mehrere KI-Agenten können parallel laufen, indem sie jedem Toolaufruf eine sessionId übergeben, die ihre Abdeckungsartefakte isoliert:

• Isolierte Ausgabeverzeichnisse – RunTestsWithCoverage erstellt TestResults-{hash}/ und coveragereport-{hash}/ pro Sitzung, wodurch verhindert wird, dass ein Agent die XML eines anderen mitten im Parsen löscht

• Bereichsbezogene Zustandsdateien – Der Abdeckungszustand wird in .mcp-coverage/.coverage-state-{hash} geschrieben, sodass ResolveCoberturaPath die korrekte XML für jede Sitzung auflöst

• Bereichsbezogene Basislinien – GetCoverageDiff speichert Basislinien als .coverage-prev-{hash}.xml pro Sitzung

• Atomare Schreibvorgänge – Alle Dateischreibvorgänge (Zustandsdateien und Testcode) verwenden Schreiben-in-Temp-Dann-Umbenennen, um Beschädigungen durch Wettlaufsituationen oder Prozessabstürze zu verhindern

Einschränkung – Build-Ausgaben sind nicht sitzungsbezogen. sessionId isoliert Abdeckungsartefakte, nicht den .NET-Build. dotnet test kompiliert das Zielprojekt in seine gemeinsamen obj/- und bin/-Verzeichnisse, die nicht pro Sitzung sind. Wenn also zwei Agenten RunTestsWithCoverage gegen dasselbe Testprojekt gleichzeitig ausführen, kollidieren sie bei diesen Ausgaben und schlagen mit buildError fehl (z. B. CS2012: Die Datei wird von einem anderen Prozess verwendet). Führen Sie parallele Agenten gegen verschiedene Testprojekte aus oder auf separaten Arbeitskopien des Repos. Mehrere Agenten auf einem Projekt sind in Ordnung, solange ihre dotnet test-Builds sich nicht überlappen.

Ohne sessionId verwenden die Tools gemeinsame Standardwerte – sicher für den Einzelagenten-Einsatz.

Anforderungen

• .NET 9.0 SDK (oder höher) – https://dotnet.microsoft.com/download

• reportgenerator globales Tool – der Server ruft es auf, um Abdeckungsberichte zu rendern (im Install-Schritt unten installiert)

• Ein MCP-kompatibler Client (Claude Code, Gemini CLI usw.)

• COVERAGE_MCP_ALLOWED_ROOT – empfohlen. Setzen Sie es auf Ihre Repository-Wurzel, um den Dateisystemzugriff jedes Tools auf diesen Teilbaum zu beschränken. Jeder Pfad, der vom Client außerhalb dieser Wurzel übergeben wird, wird mit pathNotAllowed abgelehnt. Wenn nicht gesetzt, protokolliert der Server einmal eine Warnung und akzeptiert jeden Pfad (abwärtskompatibel, aber nicht für gemeinsame Umgebungen empfohlen).

  export COVERAGE_MCP_ALLOWED_ROOT=/path/to/your/repo

Installieren

Installieren Sie den Server als globales .NET-Tool von NuGet:

dotnet tool install --global dotnet-coverage-mcp

Der Server hängt vom globalen Tool reportgenerator ab, um Abdeckungsberichte zu rendern – installieren Sie es ebenfalls:

dotnet tool install --global dotnet-reportgenerator-globaltool

Nach der Installation ist der Befehl dotnet-coverage-mcp auf Ihrem PATH.

Build & Ausführen (aus dem Quellcode)

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

# Restore dependencies
dotnet restore

# Build
dotnet build

# Run
dotnet run

Der Server startet und wartet auf MCP-Nachrichten über stdin/stdout.

MCP-Client-Konfiguration

Nach der Installation des globalen Tools (dotnet tool install --global dotnet-coverage-mcp), registrieren Sie den Server bei Ihrem MCP-Client. Setzen Sie COVERAGE_MCP_ALLOWED_ROOT auf das Repository, auf dem der Server arbeiten soll.

Claude Code

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

Claude Desktop

Fügen Sie zu claude_desktop_config.json hinzu (Einstellungen → Entwickler → Konfiguration bearbeiten):

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

Cursor

Fügen Sie zu ~/.cursor/mcp.json (global) oder .cursor/mcp.json (pro Projekt) hinzu:

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

VS Code (GitHub Copilot)

Fügen Sie zu .vscode/mcp.json hinzu:

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

Aus dem Quellcode ausführen

Um aus dem Quellcode statt des globalen Tools auszuführen, verwenden Sie dotnet run:

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

Oder zeigen Sie direkt auf die kompilierte ausführbare Datei:

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

Tool-Parameter

GetSourceFiles

RunTestsWithCoverage

GetCoverageSummary

GetFileCoverage

GetUncoveredBranches

GetCoverageDiff

AppendTestCode

CleanupSession

Zustandsdateien

Alle Zustandsdateien werden in ein .mcp-coverage/-Unterverzeichnis im Arbeitsverzeichnis geschrieben, sodass das Projektstammverzeichnis sauber bleibt. Fügen Sie .mcp-coverage/ zur .gitignore des Ziel-Repositorys hinzu.

Plugin (Skills & Agent)

Dieses Repository enthält ein plugin/-Verzeichnis mit Claude-Code-Fähigkeiten und einer Agent-Definition für geführte Testabdeckungs-Workflows:

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

Die Fähigkeiten unterstützen NUnit, xUnit und MSTest mit framework-agnostischen Referenzdokumenten in references/unit.md und references/integration.md.

Abhängigkeiten

Sicherheit

dotnet-coverage-mcp läuft als lokaler stdio-Prozess und validiert jedes Tool-Argument gegen COVERAGE_MCP_ALLOWED_ROOT, um den Dateisystemzugriff einzuschränken. Siehe SECURITY.md für das Bedrohungsmodell, Härtungsempfehlungen und wie Sie eine Schwachstelle melden.

Beiträge

Beiträge sind willkommen. Siehe CONTRIBUTING.md für Entwicklungseinrichtung, Pull-Request-Richtlinien und Code-Konventionen. Nennenswerte Änderungen werden in CHANGELOG.md verfolgt.

Veröffentlichung

Nur für Maintainer – der Release-Prozess, die NuGet-Veröffentlichung und die MCP-Registry-Einreichung sind in RELEASING.md dokumentiert.