Loading ToolBench
JetBrains IDE MCP server for Minecraft modding, providing bytecode inspection, source navigation, refactoring, and mappings lookup tools
MixinMCP demonstrates solid tool design with explicit schemas, detailed descriptions, and clear parameter documentation. All 6 tools have non-empty descriptions (avg ~250 chars, within baseline 194 chars). Input schemas are fully specified with types and descriptions. Tool names follow verb_noun convention (mixin_class_bytecode, mixin_sync_project, mixin_mappings_lookup, mixin_change_signature, mixin_extract_method). However, output schemas are not documented, LLMs cannot predict response structure. Error handling is present but lacks recovery guidance (e.g., 'Class not found' errors don't suggest next steps). Parameter descriptions are thorough but some lack explicit constraints (e.g., timeoutMs accepts 'max 600000' but no min stated). Tool composition is strong: each tool has one clear responsibility, and parameter naming is consistent (className, methodName, filePath). Security is well-handled: no credentials exposed, destructive operations clearly marked (DESTRUCTIVE risk tags). Descriptions are LLM-optimized and include prerequisites and usage context.
Change a Java method's signature with every call site and override updated: rename, change return type or visibility, and add/remove/reorder/retype parameters in one atomic refactoring. 'parametersJson' is a JSON array string describing the complete new parameter list in order, e.g. '[{"oldIndex":0},{"oldIndex":-1,"name":"count","type":"int","defaultValue":"0"}]'; omit it to keep parameters unchanged. Each entry either references an existing parameter by 0-based oldIndex (name/type override the old ones when given) or declares a new parameter with oldIndex=-1, which requires name, type, and defaultValue (the expression inserted at every existing call site). Existing parameters omitted from the list are removed everywhere. Overloads are disambiguated with parameterTypes or methodDescriptor. Java sources only. On conflicts, each is reported with its file and tagged [library] or [source]; ignoreConflicts=true proceeds anyway, same as the IDE conflict dialog's Continue button. dryRun=true reports usages and conflicts without modifying anything.
Returns bytecode-level class overview including synthetic methods, lambda targets, method descriptors, and access flags. Use this tool when decompiled source hides the real method names you need for mixin targets. filter: all (default), synthetic (only compiler-generated: lambdas, bridges, access methods), methods, fields. includeInstructions: javap -c style bytecode per method (large output). Use filter=synthetic to discover lambda mixin target names (e.g. lambda$tick$0). module: pin resolution to one module's classpath when the class has multiple variants; accepts exact or dot-boundary suffix module names (e.g. common.main, MyMod.neoforge.main). jarPath: read the class straight from any jar on disk instead of the classpath (a mod in a modpack folder; no build change needed; relative paths resolve against the project directory); className is still the dot FQCN, and module must be omitted. For method-level bytecode use mixin_method_bytecode. Works on project classes after a build. If the IDE is indexing, the call waits for indexing to finish rather than failing (jarPath lookups never wait).
Output schemas not documented. LLMs cannot predict response structure or plan downstream tool calls. mixin_class_bytecode returns bytecode analysis, mixin_ide_status returns IDE state, but response fields are not specified.
Error handling lacks recovery guidance. 'Class not found' and 'Gradle resolve failed' errors do not suggest next steps (e.g., 'Try mixin_sync_project()' or 'Check build.gradle'). Errors should guide LLM recovery.
mixin_ide_status description is truncated ('...and the linked Gradle roots th'). Full description is not visible in source. Cannot assess completeness.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | A | 81 | 2026-07-28+ | v2 |
Extract a range of Java statements or a single expression into a new method, replacing the fragment with a call. IntelliJ's control-flow analysis derives the parameters, return value, and thrown exceptions, which is exactly the part manual extraction gets wrong. startLine/endLine are 1-based, inclusive, and taken whole, so align them with statement boundaries. To extract a sub-expression rather than whole lines, pass expression=<its exact source text> (whitespace-insensitive), disambiguating repeats with occurrenceIndex (0-based, document order); a non-matching expression lists the selectable expressions with their positions. visibility defaults to private. makeStatic=true passes referenced fields as parameters where possible, makeStatic=false refuses a static result, omitted lets the analysis decide. Name clashes in the target class are reported as conflicts tagged [library] or [source]; ignoreConflicts=true proceeds anyway. Java sources only. dryRun=true reports the derived signature and target class without modifying anything. newMethodName is the name of the method to create (methodName is accepted as an alias).
Reports whether the IDE can answer classpath questions right now: dumb mode (indexing), a Gradle resolve or project-data import in flight and how long ago it started, the last sync outcome with its error text, and the linked Gradle roots th
Convert a Minecraft class/method/field name between mapping namespaces (mojmap, yarn, intermediary, srg, obf). Downloads mappings on demand into ~/.cache/mixinmcp/mappings/. MC version is auto-detected from the open project's gradle.properties if not given. Symbol input uses internal (JVM) form but accepts '.' as a package separator. Classes: 'net.minecraft.world.level.Level'. Methods: 'net.minecraft.world.level.Level.addFreshEntity(Lnet/minecraft/world/entity/Entity;)Z' (descriptor optional — all overloads listed if omitted). Fields: 'net.minecraft.world.level.Level.entities:Lnet/minecraft/world/entity/Entity;' (type optional).
Trigger a Gradle project sync (re-import) so dependency, source-root, and decompilation-cache changes reach the IDE; call it after editing build files or running genDependencySources. projectPath: the Gradle root to sync; defaults to the IDE project directory, accepts either separator form, and must be a linked Gradle root or a directory inside one (the error lists the linked roots). wait (default true) blocks until the resolve and the project-data import that follows it finish, up to timeoutMs (default 90000, max 600000; the resolve can take several seconds to start), then reports success, failure with the error text, cancellation, or timeout; wait=false returns as soon as the resolve has started, or after 30s if it has not, and the sync continues in the background (poll mixin_ide_status). Maven projects are not supported by this tool; use the IDE's Maven reload.
Numeric parameter constraints incomplete. timeoutMs states 'max 600000' but no minimum. mixin_extract_method startLine/endLine are '1-based, inclusive' but no max stated. Unbounded ranges invite invalid LLM input.
Destructive operations (mixin_change_signature, mixin_extract_method) lack dry-run confirmation pattern. Both support dryRun=true, but descriptions do not emphasize this as a safety step before destructive execution.