review_minestom_design

Review Minestom feature designs to ensure alignment with platform patterns for managers, instances, events, schedulers, and threading.

Instructions

Use this when you want Minestom-specific design feedback that checks whether a proposed feature aligns with the platform’s manager, instance, event, scheduler, and threading patterns.

Input Schema

TableJSON Schema

Name	Required	Description	Default
`designNotes`	Yes	Free-form design notes or a proposed implementation approach to review.
`featureType`	Yes	The kind of Minestom feature the notes describe.

Implementation Reference

src/minestom/planning.ts:148-231 (handler)

The handler implementation for the review_minestom_design tool.

}).server(async (args) => {
	const { designNotes, featureType } =
		reviewMinestomDesignInputSchema.parse(args);
	const blueprint = getFeatureBlueprint(featureType);
	const loweredNotes = designNotes.toLowerCase();

	const strengths = blueprint.designChecks
		.filter((check) =>
			check.keywords.some((keyword) => loweredNotes.includes(keyword)),
		)
		.map((check) => check.strength);

	const gaps = blueprint.designChecks
		.filter(
			(check) =>
				!check.keywords.some((keyword) => loweredNotes.includes(keyword)),
		)
		.map((check) => check.gap);

	const riskyAssumptions: string[] = [];

	if (
		loweredNotes.includes("async") &&
		!/(acquirable|scheduler|taskschedule|executiontype|sync)/.test(loweredNotes)
	) {
		riskyAssumptions.push(
			"The design mentions async work without explaining how Minestom-owned state is reacquired or handed back safely.",
		);
	}

	if (
		featureType === "instance-setup" &&
		loweredNotes.includes("per-player") &&
		!loweredNotes.includes("sharedinstance")
	) {
		riskyAssumptions.push(
			"Per-player world semantics are mentioned without clarifying whether `SharedInstance` or a separate `InstanceContainer` owns that state.",
		);
	}

	if (
		featureType === "scheduled-task" &&
		!/(cancel|shutdown|stop)/.test(loweredNotes)
	) {
		riskyAssumptions.push(
			"The design does not explain who cancels or tears down the scheduled task when the feature stops.",
		);
	}

	if (
		featureType === "server-bootstrap" &&
		!/(instance|spawn|asyncplayerconfigurationevent)/.test(loweredNotes)
	) {
		riskyAssumptions.push(
			"The bootstrap notes do not make the initial player-to-instance flow explicit.",
		);
	}

	const fitAssessment =
		strengths.length >= Math.max(blueprint.designChecks.length - 1, 2)
			? "strong"
			: strengths.length >= 2
				? "partial"
				: "weak";

	const recommendedApis = getApisBySymbols(blueprint.keyApiSymbols).map(
		(api) => ({
			javadocUrl: api.javadocUrl,
			packageName: api.packageName,
			symbol: api.symbol,
		}),
	);

	return reviewMinestomDesignOutputSchema.parse({
		featureType,
		fitAssessment,
		gaps,
		recommendedApis,
		recommendedTopics: [blueprint.primaryTopic, ...blueprint.supportingTopics],
		riskyAssumptions,
		strengths,
		threadTickConcerns: blueprint.threadSafetyNotes,
	});
});

src/minestom/planning.ts:114-140 (schema)

Input and output schemas for review_minestom_design.

const reviewMinestomDesignInputSchema = z.object({
	designNotes: z
		.string()
		.describe(
			"Free-form design notes or a proposed implementation approach to review.",
		),
	featureType: minestomFeatureTypeSchema.describe(
		"The kind of Minestom feature the notes describe.",
	),
});

const reviewMinestomDesignOutputSchema = z.object({
	featureType: minestomFeatureTypeSchema,
	fitAssessment: reviewAssessmentSchema,
	gaps: z.array(z.string()),
	recommendedApis: z.array(
		z.object({
			javadocUrl: z.string().url(),
			packageName: z.string(),
			symbol: z.string(),
		}),
	),
	recommendedTopics: z.array(minestomTopicSchema),
	riskyAssumptions: z.array(z.string()),
	strengths: z.array(z.string()),
	threadTickConcerns: z.array(z.string()),
});

src/minestom/planning.ts:142-147 (registration)

Definition and registration of the review_minestom_design tool.

export const reviewMinestomDesignTool: TanStackServerTool = toolDefinition({
	description:
		"Use this when you want Minestom-specific design feedback that checks whether a proposed feature aligns with the platform’s manager, instance, event, scheduler, and threading patterns.",
	inputSchema: reviewMinestomDesignInputSchema,
	name: "review_minestom_design",
	outputSchema: reviewMinestomDesignOutputSchema,

Minestom MCP Server