Minestom MCP Server

Instructions

Implementation Reference

• src/minestom/build.ts:846-925 (handler)

  The core logic for inspecting a Minestom build, collecting build files, detecting build tools, and parsing module structures.

  export async function inspectMinestomBuild(repoRootInput?: string) {
  	const repoRoot = path.resolve(repoRootInput ?? process.cwd());
  	const buildFiles = await collectBuildFiles(repoRoot);
  	const wrapperFiles = await collectWrapperFiles(repoRoot);
  	const moduleMap = new Map<string, BuildTextFile[]>();
  
  	for (const file of buildFiles) {
  		const moduleRoot = resolveModuleRoot(file.relativePath);
  		const existing = moduleMap.get(moduleRoot) ?? [];
  		existing.push(file);
  		moduleMap.set(moduleRoot, existing);
  	}
  
  	const modules = Array.from(moduleMap.entries())
  		.map(([moduleRoot, files]) => {
  			const moduleWrapperFiles = wrapperFiles.filter((wrapperFile) => {
  				return moduleRoot === "."
  					? !wrapperFile.includes("/")
  					: wrapperFile.startsWith(`${moduleRoot}/`);
  			});
  			const buildTool = detectBuildTool(files.map((file) => file.relativePath));
  
  			if (buildTool === "gradle") {
  				return createGradleModule(moduleRoot, files, moduleWrapperFiles);
  			}
  
  			if (buildTool === "maven") {
  				return createMavenModule(moduleRoot, files, moduleWrapperFiles);
  			}
  
  			return {
  				buildFiles: files.map((file) => file.relativePath),
  				buildTool: "unknown" as const,
  				commands: [],
  				dependencies: [],
  				moduleRoot,
  				notes: [
  					"Build files were detected, but they did not resolve cleanly to a Gradle or Maven module.",
  				],
  				plugins: [],
  				variables: [],
  				wrapperFiles: moduleWrapperFiles,
  			};
  		})
  		.sort((left, right) => left.moduleRoot.localeCompare(right.moduleRoot));
  
  	const notes = [];
  	const primaryModuleRoot = modules.find(
  		(module) => module.buildTool !== "unknown",
  	)?.moduleRoot;
  
  	if (modules.length === 0) {
  		notes.push(
  			"No Gradle or Maven build files were detected in the inspected directory tree.",
  		);
  	}
  
  	if (
  		modules.some(
  			(module) => module.buildTool === "gradle" && module.versionCatalog,
  		)
  	) {
  		notes.push(
  			"Gradle version catalogs are parsed from `gradle/libs.versions.toml` when present.",
  		);
  	}
  
  	if (modules.some((module) => module.buildTool === "maven")) {
  		notes.push(
  			"Maven parsing includes pom dependencies, plugins, properties, and wrapper-aware command suggestions.",
  		);
  	}
  
  	return minestomBuildInspectionSchema.parse({
  		modules,
  		notes,
  		primaryModuleRoot,
  		repoRoot,
  	});
  }

• src/minestom/build.ts:936-945 (registration)

  Registration of the 'inspect_minestom_build' MCP tool using TanStackServerTool.

  export const inspectMinestomBuildTool: TanStackServerTool = toolDefinition({
  	description:
  		"Use this when you want Gradle or Maven specific interpretation for a Minestom workspace, including dependencies, plugins, wrapper commands, and variables from build files or version catalogs.",
  	inputSchema: inspectMinestomBuildInputSchema,
  	name: "inspect_minestom_build",
  	outputSchema: minestomBuildInspectionSchema,
  }).server(async (args) => {
  	const { repoRoot } = inspectMinestomBuildInputSchema.parse(args);
  	return inspectMinestomBuild(repoRoot);
  });

• src/minestom/build.ts:927-934 (schema)

  Input schema definition for the inspect_minestom_build tool.

  const inspectMinestomBuildInputSchema = z.object({
  	repoRoot: z
  		.string()
  		.optional()
  		.describe(
  			"Absolute or relative path to the Minestom workspace to inspect. Defaults to the current working directory.",
  		),
  });