Agenten stärken
Der eigene Befehl des Herausgebers. Kein PlugMCP-Endpunkt.
Host a copy with our keys and logs.
docker run -i --rm ghcr.io/mikhailhal/ariadne:0.4.0Claude Code hat keinen Installationslink für einen lokalen Befehl. Kopieren Sie den Befehl unten und führen Sie ihn in einem Terminal aus.
claude mcp add io.github.mikhailhal-ariadne -- docker run -i --rm ghcr.io/mikhailhal/ariadne:0.4.0In einem Terminal ausführen.
{ "mcpServers": { "io.github.mikhailhal-ariadne": { "command": "docker", "args": [ "run", "-i", "--rm", "ghcr.io/mikhailhal/ariadne:0.4.0" ] } }}claude_desktop_config.json
Remote-URL oder ein Befehl auf Ihrem Rechner? Worin sich die beiden Installationen unterscheiden
Auf PlugMCP ausführen
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
StartenVom Herausgeber
ariadne is an MCP (Model Context Protocol) server that provides AI agents with the ability to identify affected tests. Powered by sazanami, it analyzes code changes and returns only the tests that need to be run.
[!IMPORTANT]
⚠️ MUST READ: Speed over Completeness
Returns only the unit tests affected by your current Kotlin/Android code changes.
ariadne is built for the agent inner loop — edit, verify, commit — where fast feedback matters more than exhaustive selection. Static analysis cannot trace every execution path: reflection, DI frameworks, and data-flow indirection (e.g., Flux/MVI dispatch) can hide dependencies from any affected-test-selection tool, not just ariadne.
Always keep a final line of defense in CI. Run the full test suite (or a conservative selection) before merging. ariadne narrows what an agent runs while iterating; it is not a replacement for CI.
When ariadne detects changes it cannot analyze (build scripts, resources, unscanned source sets), it says so explicitly in the tool response instead of silently reporting "no affected tests".
git diff internallybrew install mikhailhal/tap/ariadne
Then register it with your MCP client — for Claude Code:
claude mcp add ariadne -- ariadne
Or add to your MCP client configuration manually (e.g., Claude Desktop):
{
"mcpServers": {
"ariadne": {
"command": "ariadne"
}
}
}
docker run -i --rm -v /path/to/project:/workspace ghcr.io/mikhailhal/ariadne
Mount the project you want analyzed and pass /workspace as project_path.
The image is also listed in the official MCP Registry as io.github.MikhailHal/ariadne.
Download ariadne-<version>-all.jar from Releases (requires JDK 21+) and configure your client with "command": "java", "args": ["-jar", "/path/to/ariadne-<version>-all.jar"].
git clone --recursive https://github.com/MikhailHal/ariadne.git
cd ariadne
./gradlew shadowJar # fat JAR: build/libs/ariadne-<version>-all.jar
Once configured, AI agents can use the get_affected_tests tool:
get_affected_testsParameters:
project_path (required) — Path to the Kotlin projectscope (optional, deep | shallow, default deep) — how far back to look:
deep — all changes since base_branch (committed and uncommitted). Safest; the whole branch is covered so nothing you already committed slips through unverified. May select more tests.shallow — uncommitted changes only (diff against HEAD). Fastest, for the tight edit loop. Verifying already-committed work is left to the caller. base_branch is ignored.base_branch (optional, deep scope only) — Branch to compare against. When omitted, ariadne uses the repository's default branch (origin/HEAD). If that is not set (e.g. a repo with no remote), it returns an error asking you to pass base_branch explicitly rather than guessing.Returns:
Agent request:
{
"name": "get_affected_tests",
"arguments": {
"project_path": "/path/to/your/kotlin/project"
}
}
Response:
com.example.UserServiceTest.testCreateUser
com.example.UserRepositoryTest.testSave
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ MCP Client │ ──▶ │ ariadne │ ──▶ │ sazanami │
│ (Agent) │ │ (MCP Server)│ │ (Analysis) │
└─────────────┘ └─────────────┘ └─────────────┘
│
▼
┌─────────────┐
│ git diff │
└─────────────┘
git diff --unified=0 against base branchMeasured against Now in Android (Google's reference Android app — 34 modules, ~268 Kotlin files):
Verified patterns include repositories behind project interfaces, a library-interface
override (androidx.datastore.Serializer), operator fun invoke use cases,
@Composable functions, extension mappers, ViewModel property-initializer chains,
and callable references. Two representative results:
core:common's asResult() selects 14 tests across three modules,
including ViewModel tests reachable only through val uiState = ...stateIn(...)PopulatedNewsResource.asExternalModel() selects 14 tests,
including 11 repository tests reachable only through .map(Type::mapper) chainsEvery unit-test class in Now in Android was measured by changing a function in the class it tests and checking whether that test class was selected:
Robolectric turned out not to be a barrier: those tests call the composable
themselves (setContent { NiaTheme { ... } }), so the call exists in the source.
What decides coverage is not the test runner but whether the test's own code
contains the call.
The rule of thumb: if the framework calls your code instead of your test calling it, ariadne cannot connect them. These are limits of static analysis, not bugs — plan your CI safety net around them:
Full audit notes: sazanami#29, sazanami#38.
settings.gradle(.kts) includes,
enumerates src/<sourceSet>/{kotlin,java} layouts, and reads project(":x") /
type-safe accessor dependencies from build files. Dynamic includes,
projectDir remapping, custom srcDirs, and dependencies injected by convention
plugins are not detected — see #1Copyright 2025 ariadne contributors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
See LICENSE for the full text.
Returns only the unit tests affected by your current Kotlin/Android code changes.
{ "mcpServers": { "io.github.mikhailhal-ariadne": { "command": "docker", "args": [ "run", "-i", "--rm", "ghcr.io/mikhailhal/ariadne:0.4.0" ] } }}Tools
Noch keine Tool-Liste. Remote-Server erhalten eine nach dem ersten Health-Check.
FAQ
Kopieren Sie auf dieser Seite die stdio-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.
In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.
Ariadne läuft lokal über stdio.
Zuletzt geprüft: 2026-11-09. Returns only the unit tests affected by your current Kotlin/Android code changes.