hevy-coach 0.2.0 → 1.0.0

package/dist/src-BxQx3e_u.mjs

@@ -0,0 +1,651 @@
+import { HevyApiError, HevyNetworkError, MAX_PAGE_SIZE, MAX_TEMPLATE_PAGE_SIZE, createHevyClient } from "@furkantanyol/hevy-client";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+//#region src/utils/response.ts
+function jsonResponse(data) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(data, null, 2)
+	}] };
+}
+function textResponse(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function errorResponse(error) {
+	return {
+		content: [{
+			type: "text",
+			text: `Error: ${describeError(error)}`
+		}],
+		isError: true
+	};
+}
+/** Wraps a tool handler so any thrown error becomes an MCP error result the LLM can read. */
+function safe(handler) {
+	return async (args) => {
+		try {
+			return await handler(args);
+		} catch (error) {
+			return errorResponse(error);
+		}
+	};
+}
+function describeError(error) {
+	if (error instanceof HevyApiError) {
+		const code = error.code ? ` (${error.code})` : "";
+		return `Hevy API ${error.status}${code}: ${error.message}`;
+	}
+	if (error instanceof HevyNetworkError) return `Could not reach Hevy: ${error.message}`;
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/tools/schemas.ts
+const DEFAULT_PAGE_SIZE = 5;
+const SET_TYPES = [
+	"warmup",
+	"normal",
+	"failure",
+	"dropset"
+];
+const RPE_VALUES = [
+	6,
+	7,
+	7.5,
+	8,
+	8.5,
+	9,
+	9.5,
+	10
+];
+const pageSchema = {
+	page: z.coerce.number().int().gte(1).default(1).describe("1-based page number"),
+	pageSize: z.coerce.number().int().gte(1).lte(MAX_PAGE_SIZE).default(DEFAULT_PAGE_SIZE).describe(`Items per page, max ${MAX_PAGE_SIZE} (Hevy limit)`)
+};
+const templatePageSchema = {
+	page: z.coerce.number().int().gte(1).default(1),
+	pageSize: z.coerce.number().int().gte(1).lte(MAX_TEMPLATE_PAGE_SIZE).default(MAX_TEMPLATE_PAGE_SIZE)
+};
+const isoDateTime = (label) => z.string().min(1).describe(`${label} as ISO 8601, e.g. 2026-09-09T18:30:00Z`);
+const ymdDate = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be YYYY-MM-DD").describe("Calendar date, YYYY-MM-DD");
+const nullableNumber = z.coerce.number().nullable().optional();
+const nullableInt = z.coerce.number().int().nullable().optional();
+const setFields = {
+	type: z.enum(SET_TYPES).default("normal"),
+	weight_kg: nullableNumber.describe("Weight in kg (metric only)"),
+	reps: nullableInt,
+	distance_meters: nullableInt,
+	duration_seconds: nullableInt,
+	custom_metric: nullableNumber.describe("Floors or steps for stair machines")
+};
+const workoutSetSchema = z.object({
+	...setFields,
+	rpe: z.literal(RPE_VALUES).nullable().optional().describe("Rate of perceived exertion, 6 to 10 in half steps")
+});
+const routineSetSchema = z.object({
+	...setFields,
+	rep_range: z.object({
+		start: z.coerce.number().int(),
+		end: z.coerce.number().int()
+	}).nullable().optional().describe("Target rep range, e.g. {start: 8, end: 12}")
+});
+const exerciseTemplateId = z.string().min(1).describe("Hevy exercise template id, e.g. \"D04AC939\". Resolve names with batch-find-exercises first.");
+const workoutExerciseSchema = z.object({
+	exercise_template_id: exerciseTemplateId,
+	superset_id: nullableInt.describe("Same integer on every exercise in one superset; null otherwise"),
+	notes: z.string().optional(),
+	sets: z.array(workoutSetSchema).min(1)
+});
+const routineExerciseSchema = z.object({
+	exercise_template_id: exerciseTemplateId,
+	superset_id: nullableInt.describe("Same integer on every exercise in one superset; null otherwise"),
+	rest_seconds: nullableInt.describe("Rest between sets in seconds"),
+	notes: z.string().optional().describe("Coaching cue shown in the app"),
+	sets: z.array(routineSetSchema).min(1)
+});
+//#endregion
+//#region src/tools/body-measurements.ts
+const metric = z.coerce.number().nullable().optional();
+const measurementFields = {
+	weight_kg: metric,
+	lean_mass_kg: metric,
+	fat_percent: metric,
+	neck_cm: metric,
+	shoulder_cm: metric,
+	chest_cm: metric,
+	left_bicep_cm: metric,
+	right_bicep_cm: metric,
+	left_forearm_cm: metric,
+	right_forearm_cm: metric,
+	abdomen: metric.describe("cm"),
+	waist: metric.describe("cm"),
+	hips: metric.describe("cm"),
+	left_thigh: metric.describe("cm"),
+	right_thigh: metric.describe("cm"),
+	left_calf: metric.describe("cm"),
+	right_calf: metric.describe("cm")
+};
+function registerBodyMeasurementTools(server, client) {
+	server.registerTool("get-body-measurements", {
+		description: "List body measurements (weight, body fat %, circumferences in cm), newest first.",
+		inputSchema: pageSchema
+	}, safe(async ({ page, pageSize }) => {
+		const result = await client.bodyMeasurements.list({
+			page,
+			pageSize
+		});
+		return result.body_measurements.length ? jsonResponse(result) : textResponse("No body measurements found.");
+	}));
+	server.registerTool("get-body-measurement", {
+		description: "Get the body measurement logged on one date.",
+		inputSchema: { date: ymdDate }
+	}, safe(async ({ date }) => jsonResponse(await client.bodyMeasurements.get(date))));
+	server.registerTool("log-body-measurement", {
+		description: "Log or overwrite the body measurement for a date. Provide any subset of fields; kg and cm only. Overwriting replaces every field for that date, so include all values you want kept.",
+		inputSchema: {
+			date: ymdDate,
+			...measurementFields
+		}
+	}, safe(async (measurement) => {
+		await client.bodyMeasurements.upsert(measurement);
+		return textResponse(`Body measurement saved for ${measurement.date}.`);
+	}));
+}
+//#endregion
+//#region src/tools/coaching.ts
+const MAX_SUMMARY_WORKOUTS = 50;
+const MAX_PROGRESSION_SESSIONS = 20;
+const TOP_EXERCISES = 15;
+const MS_PER_MINUTE = 6e4;
+const MS_PER_DAY = 864e5;
+const DAYS_PER_WEEK = 7;
+const EPLEY_DIVISOR = 30;
+const LIBRARY_CACHE_TTL_MS = 5 * MS_PER_MINUTE;
+const RPE_INCREASE = 7;
+const RPE_HOLD = 8;
+const RPE_DECREASE = 9.5;
+const round1 = (n) => Math.round(n * 10) / 10;
+const epley1RM = (weightKg, reps) => weightKg * (1 + reps / EPLEY_DIVISOR);
+const isWorking = (set) => set.type !== "warmup";
+function registerCoachingTools(server, client) {
+	server.registerTool("analyze-workout", {
+		description: `Compare a completed workout with the planned session and get per-exercise adaptation recommendations
+(increase_weight / maintain_then_increase / hold_weight / decrease_weight) based on reps hit and average RPE.
+Call after each workout to drive progressive overload. Exercise names must match Hevy titles.`,
+		inputSchema: {
+			workoutId: z.string().min(1).describe("Id of the completed workout"),
+			plannedExercises: z.array(z.object({
+				name: z.string().describe("Exercise title exactly as in Hevy"),
+				targetSets: z.number().int(),
+				targetReps: z.number().int(),
+				targetWeightKg: z.number().nullable(),
+				targetRpe: z.number().nullable()
+			})).describe("The planned exercises for this session")
+		}
+	}, safe(async ({ workoutId, plannedExercises }) => jsonResponse(analyzeWorkoutPerformance(await client.workouts.get(workoutId), plannedExercises))));
+	server.registerTool("get-training-summary", {
+		description: `Aggregate the last N workouts: sessions, working sets, average duration, days between sessions,
+sessions per week and the most frequent exercises with set counts. Use for weekly reviews and volume checks.`,
+		inputSchema: { workoutCount: z.coerce.number().int().gte(1).lte(MAX_SUMMARY_WORKOUTS).default(10).describe("How many recent workouts to include") }
+	}, safe(async ({ workoutCount }) => {
+		const workouts = await recentWorkouts(client, workoutCount);
+		return workouts.length ? jsonResponse(generateTrainingSummary(workouts)) : textResponse("No workouts found.");
+	}));
+	server.registerTool("get-exercise-progression", {
+		description: `Session-by-session progression for one exercise: max weight, max reps, volume, estimated 1RM (Epley),
+best set, all-time best and trend (improving / plateau / declining). Use to spot PRs and plateaus.`,
+		inputSchema: {
+			exerciseTemplateId,
+			sessions: z.coerce.number().int().gte(1).lte(MAX_PROGRESSION_SESSIONS).default(10).describe("Most recent sessions to include")
+		}
+	}, safe(async ({ exerciseTemplateId, sessions }) => {
+		const history = await client.exerciseHistory.get(exerciseTemplateId);
+		if (!history.length) return textResponse("No history found for this exercise.");
+		return jsonResponse(analyzeExerciseProgression(history, sessions));
+	}));
+	server.registerTool("find-exercise", {
+		description: "Search the exercise library by name or muscle group and get id + title for every match, shortest title first. For 2+ names use batch-find-exercises.",
+		inputSchema: { query: z.string().min(1).describe("Exercise name or muscle group, e.g. 'incline press' or 'hamstrings'") }
+	}, safe(async ({ query }) => {
+		const matches = searchExercises(await loadLibrary(client), query);
+		if (!matches.length) return textResponse(`No exercises found matching "${query}".`);
+		return jsonResponse({
+			query,
+			matches: matches.length,
+			exercises: matches
+		});
+	}));
+	server.registerTool("batch-find-exercises", {
+		description: `Resolve many exercise names to Hevy template ids in ONE call. Exact title match wins, otherwise the shortest title containing the query.
+Returns {found, total, missing, results: {name: {id, title} | null}}. Always use this before create-routine or create-workout.`,
+		inputSchema: { queries: z.array(z.string().min(1)).min(1).describe("Exercise names to look up") }
+	}, safe(async ({ queries }) => {
+		const library = await loadLibrary(client);
+		const results = Object.fromEntries(queries.map((q) => [q, findBestMatch(library, q)]));
+		const missing = queries.filter((q) => !results[q]);
+		return jsonResponse({
+			found: queries.length - missing.length,
+			total: queries.length,
+			missing,
+			results
+		});
+	}));
+}
+let libraryCache;
+/** Call after creating a custom exercise so lookups see it immediately. */
+function invalidateLibrary() {
+	libraryCache = void 0;
+}
+async function loadLibrary(client) {
+	if (libraryCache && libraryCache.expires > Date.now()) return libraryCache.templates;
+	const templates = await client.exerciseTemplates.listAll();
+	libraryCache = {
+		expires: Date.now() + LIBRARY_CACHE_TTL_MS,
+		templates
+	};
+	return templates;
+}
+const normalise = (text) => text.toLowerCase().replace(/[\s_]+/g, " ").trim();
+const byTitleLength = (a, b) => a.title.length - b.title.length;
+/** Exact normalised title match first; otherwise the shortest title containing the query. */
+function findBestMatch(library, query) {
+	const q = normalise(query);
+	const exact = library.find((t) => normalise(t.title) === q);
+	if (exact) return {
+		id: exact.id,
+		title: exact.title
+	};
+	const partial = library.filter((t) => normalise(t.title).includes(q)).sort(byTitleLength)[0];
+	return partial ? {
+		id: partial.id,
+		title: partial.title
+	} : null;
+}
+function searchExercises(library, query) {
+	const q = normalise(query);
+	return library.filter((t) => normalise(t.title).includes(q) || normalise(t.primary_muscle_group).includes(q) || t.secondary_muscle_groups.some((m) => normalise(m).includes(q))).sort(byTitleLength).map((t) => ({
+		id: t.id,
+		title: t.title
+	}));
+}
+async function recentWorkouts(client, count) {
+	const workouts = [];
+	for (let page = 1; workouts.length < count; page++) {
+		const result = await client.workouts.list({
+			page,
+			pageSize: MAX_PAGE_SIZE
+		});
+		workouts.push(...result.workouts);
+		if (page >= result.page_count) break;
+	}
+	return workouts.slice(0, count);
+}
+/** "All reps hit" means every working set reached the target, so the weakest set decides. */
+function recommend(plan, minReps, sets, avgRpe) {
+	if (!plan) return "maintain";
+	const hitReps = minReps >= plan.targetReps;
+	const hitSets = sets >= plan.targetSets;
+	if (hitReps && hitSets && avgRpe !== null && avgRpe <= RPE_INCREASE) return "increase_weight";
+	if (hitReps && hitSets && avgRpe !== null && avgRpe <= RPE_HOLD) return "maintain_then_increase";
+	if (!hitReps && avgRpe !== null && avgRpe >= RPE_DECREASE) return "decrease_weight";
+	if (!hitReps) return "hold_weight";
+	return "maintain";
+}
+function analyzeWorkoutPerformance(workout, planned) {
+	const sameName = (a, b) => a.toLowerCase() === b.toLowerCase();
+	const exerciseResults = workout.exercises.map((actual) => {
+		const plan = planned.find((p) => sameName(p.name, actual.title));
+		const workingSets = actual.sets.filter(isWorking);
+		const rated = workingSets.filter((s) => s.rpe !== null);
+		const totalReps = workingSets.reduce((sum, s) => sum + (s.reps ?? 0), 0);
+		const avgRpe = rated.length ? rated.reduce((sum, s) => sum + (s.rpe ?? 0), 0) / rated.length : null;
+		const repsPerSet = workingSets.length ? totalReps / workingSets.length : 0;
+		const minReps = workingSets.length ? Math.min(...workingSets.map((s) => s.reps ?? 0)) : 0;
+		return {
+			exercise: actual.title,
+			planned: plan ? {
+				sets: plan.targetSets,
+				reps: plan.targetReps,
+				weightKg: plan.targetWeightKg,
+				rpe: plan.targetRpe
+			} : null,
+			actual: {
+				setsCompleted: workingSets.length,
+				avgRepsPerSet: round1(repsPerSet),
+				minReps,
+				totalReps,
+				maxWeightKg: Math.max(0, ...workingSets.map((s) => s.weight_kg ?? 0)),
+				avgRpe: avgRpe === null ? null : round1(avgRpe)
+			},
+			recommendation: recommend(plan, minReps, workingSets.length, avgRpe),
+			notes: actual.notes
+		};
+	});
+	const skipped = planned.filter((p) => !workout.exercises.some((a) => sameName(a.title, p.name)));
+	return {
+		workoutId: workout.id,
+		title: workout.title,
+		date: workout.start_time,
+		durationMinutes: Math.round((new Date(workout.end_time).getTime() - new Date(workout.start_time).getTime()) / MS_PER_MINUTE),
+		totalWorkingSets: workout.exercises.reduce((sum, ex) => sum + ex.sets.filter(isWorking).length, 0),
+		exerciseResults,
+		skippedExercises: skipped.map((e) => e.name),
+		overallAdherence: planned.length ? Math.round((planned.length - skipped.length) / planned.length * 100) : 100
+	};
+}
+function generateTrainingSummary(workouts) {
+	const dates = workouts.map((w) => new Date(w.start_time).getTime()).sort((a, b) => a - b);
+	const gaps = dates.slice(1).map((t, i) => (t - (dates[i] ?? t)) / MS_PER_DAY);
+	const avgDaysBetween = gaps.length ? round1(gaps.reduce((a, b) => a + b, 0) / gaps.length) : 0;
+	const durations = workouts.map((w) => (new Date(w.end_time).getTime() - new Date(w.start_time).getTime()) / MS_PER_MINUTE);
+	const sessionsByExercise = /* @__PURE__ */ new Map();
+	for (const workout of workouts) {
+		const seenInWorkout = /* @__PURE__ */ new Set();
+		for (const exercise of workout.exercises) {
+			const entry = sessionsByExercise.get(exercise.title) ?? {
+				sessions: 0,
+				totalSets: 0
+			};
+			if (!seenInWorkout.has(exercise.title)) entry.sessions++;
+			seenInWorkout.add(exercise.title);
+			entry.totalSets += exercise.sets.filter(isWorking).length;
+			sessionsByExercise.set(exercise.title, entry);
+		}
+	}
+	const topExercises = [...sessionsByExercise.entries()].sort(([, a], [, b]) => b.sessions - a.sessions).slice(0, TOP_EXERCISES).map(([name, stats]) => ({
+		name,
+		...stats
+	}));
+	const isoDay = (ms) => ms === void 0 ? void 0 : new Date(ms).toISOString().slice(0, 10);
+	return {
+		period: {
+			from: isoDay(dates[0]),
+			to: isoDay(dates[dates.length - 1])
+		},
+		totalSessions: workouts.length,
+		totalWorkingSets: [...sessionsByExercise.values()].reduce((sum, e) => sum + e.totalSets, 0),
+		avgSessionDurationMinutes: durations.length ? Math.round(durations.reduce((a, b) => a + b, 0) / durations.length) : 0,
+		avgDaysBetweenSessions: avgDaysBetween,
+		sessionsPerWeek: avgDaysBetween > 0 ? round1(DAYS_PER_WEEK / avgDaysBetween) : 0,
+		topExercises
+	};
+}
+function summariseSession(workingSets) {
+	const first = workingSets[0];
+	const bestSet = workingSets.reduce((best, s) => {
+		const e1rm = epley1RM(s.weight_kg ?? 0, s.reps ?? 0);
+		return e1rm > best.e1rm ? {
+			weight: s.weight_kg ?? 0,
+			reps: s.reps ?? 0,
+			e1rm
+		} : best;
+	}, {
+		weight: first.weight_kg ?? 0,
+		reps: first.reps ?? 0,
+		e1rm: epley1RM(first.weight_kg ?? 0, first.reps ?? 0)
+	});
+	return {
+		date: first.workout_start_time.slice(0, 10),
+		workingSets: workingSets.length,
+		maxWeightKg: Math.max(...workingSets.map((s) => s.weight_kg ?? 0)),
+		maxReps: Math.max(...workingSets.map((s) => s.reps ?? 0)),
+		totalVolume: Math.round(workingSets.reduce((sum, s) => sum + (s.weight_kg ?? 0) * (s.reps ?? 0), 0)),
+		estimated1RM: round1(bestSet.e1rm),
+		bestSet: {
+			weightKg: bestSet.weight,
+			reps: bestSet.reps
+		}
+	};
+}
+/**
+* History is flat (one row per set). Groups by workout, oldest first, and reports the last `limit`
+* sessions. Weighted exercises trend on estimated 1RM; bodyweight exercises (no load) on max reps.
+*/
+function analyzeExerciseProgression(history, limit = Number.POSITIVE_INFINITY) {
+	const byWorkout = /* @__PURE__ */ new Map();
+	for (const entry of history) {
+		if (entry.set_type === "warmup") continue;
+		const sets = byWorkout.get(entry.workout_id) ?? [];
+		sets.push(entry);
+		byWorkout.set(entry.workout_id, sets);
+	}
+	const allSessions = [...byWorkout.values()].filter((sets) => sets.length > 0).sort((a, b) => a[0].workout_start_time.localeCompare(b[0].workout_start_time)).map(summariseSession);
+	const sessions = allSessions.slice(-limit);
+	const trendMetric = allSessions.some((s) => s.estimated1RM > 0) ? "estimated1RM" : "maxReps";
+	const latest = sessions[sessions.length - 1]?.[trendMetric] ?? 0;
+	const earliest = sessions[0]?.[trendMetric] ?? 0;
+	return {
+		sessionCount: sessions.length,
+		sessions,
+		allTimeBestE1RM: Math.max(0, ...allSessions.map((s) => s.estimated1RM)),
+		trendMetric,
+		progression: round1(latest - earliest),
+		trend: latest > earliest ? "improving" : latest === earliest ? "plateau" : "declining"
+	};
+}
+//#endregion
+//#region src/tools/exercises.ts
+const EXERCISE_TYPES = [
+	"weight_reps",
+	"reps_only",
+	"bodyweight_reps",
+	"bodyweight_assisted_reps",
+	"duration",
+	"weight_duration",
+	"distance_duration",
+	"short_distance_weight"
+];
+const EQUIPMENT = [
+	"none",
+	"barbell",
+	"dumbbell",
+	"kettlebell",
+	"machine",
+	"plate",
+	"resistance_band",
+	"suspension",
+	"other"
+];
+const MUSCLE_GROUPS = [
+	"abdominals",
+	"shoulders",
+	"biceps",
+	"triceps",
+	"forearms",
+	"quadriceps",
+	"hamstrings",
+	"calves",
+	"glutes",
+	"abductors",
+	"adductors",
+	"lats",
+	"upper_back",
+	"traps",
+	"lower_back",
+	"chest",
+	"cardio",
+	"neck",
+	"full_body",
+	"other"
+];
+function registerExerciseTools(server, client) {
+	server.registerTool("get-exercise-templates", {
+		description: "Browse the exercise library page by page (up to 100 per page): id, title, type, muscle groups, equipment. Prefer batch-find-exercises when you know the names.",
+		inputSchema: templatePageSchema
+	}, safe(async ({ page, pageSize }) => {
+		const result = await client.exerciseTemplates.list({
+			page,
+			pageSize
+		});
+		return result.exercise_templates.length ? jsonResponse(result) : textResponse("No exercise templates found.");
+	}));
+	server.registerTool("get-exercise-template", {
+		description: "Get one exercise template by id: title, measurement type, muscle groups, equipment.",
+		inputSchema: { exerciseTemplateId }
+	}, safe(async ({ exerciseTemplateId }) => jsonResponse(await client.exerciseTemplates.get(exerciseTemplateId))));
+	server.registerTool("get-exercise-history", {
+		description: "Every logged set for one exercise, newest workout first, flat (one row per set with workout id, date, weight, reps, RPE, set type). Use get-exercise-progression for trends.",
+		inputSchema: {
+			exerciseTemplateId,
+			startDate: z.string().optional().describe("Inclusive start, YYYY-MM-DD or ISO 8601"),
+			endDate: z.string().optional().describe("Inclusive end, YYYY-MM-DD or ISO 8601")
+		}
+	}, safe(async ({ exerciseTemplateId, startDate, endDate }) => jsonResponse(await client.exerciseHistory.get(exerciseTemplateId, {
+		startDate,
+		endDate
+	}))));
+	server.registerTool("create-exercise-template", {
+		description: "Create a custom exercise in the user's library. Check batch-find-exercises first to avoid duplicating a built-in exercise. The response id is NOT an exercise_template_id: after creating, call batch-find-exercises with the title to get the id to use in routines and workouts.",
+		inputSchema: {
+			title: z.string().min(1),
+			exercise_type: z.enum(EXERCISE_TYPES).describe("How the exercise is measured"),
+			muscle_group: z.enum(MUSCLE_GROUPS).describe("Primary muscle group"),
+			other_muscles: z.array(z.enum(MUSCLE_GROUPS)).optional().describe("Secondary muscle groups"),
+			equipment_category: z.enum(EQUIPMENT)
+		}
+	}, safe(async (exercise) => {
+		const created = await client.exerciseTemplates.create(exercise);
+		invalidateLibrary();
+		return jsonResponse(created);
+	}));
+}
+//#endregion
+//#region src/tools/routines.ts
+const folderId = z.coerce.number().int().nullable().optional().describe("Routine folder id from get-routine-folders; null or omitted for the default 'My Routines'");
+function registerRoutineTools(server, client) {
+	server.registerTool("get-routines", {
+		description: "List saved routines (workout templates) with their exercises and target sets.",
+		inputSchema: pageSchema
+	}, safe(async ({ page, pageSize }) => {
+		const result = await client.routines.list({
+			page,
+			pageSize
+		});
+		return result.routines.length ? jsonResponse(result) : textResponse("No routines found.");
+	}));
+	server.registerTool("get-routine", {
+		description: "Get one routine by id with every exercise and set.",
+		inputSchema: { routineId: z.string().min(1) }
+	}, safe(async ({ routineId }) => jsonResponse(await client.routines.get(routineId))));
+	server.registerTool("create-routine", {
+		description: "Create a routine in the user's Hevy app. WORKFLOW: call batch-find-exercises with all exercise names first, then pass the returned ids here. Free Hevy accounts are limited to 4 routines (409 routine-limit-exceeded).",
+		inputSchema: {
+			title: z.string().min(1),
+			folder_id: folderId,
+			notes: z.string().optional().describe("Routine-level notes shown in the app"),
+			exercises: z.array(routineExerciseSchema).min(1)
+		}
+	}, safe(async ({ folder_id, ...routine }) => jsonResponse(await client.routines.create({
+		...routine,
+		folder_id: folder_id ?? null
+	}))));
+	server.registerTool("update-routine", {
+		description: "Replace a routine by id: title, notes and every exercise and set are overwritten. Omit folder_id to keep the current folder, pass null to move it to 'My Routines'. Fetch it with get-routine first if you only want to change part of it.",
+		inputSchema: {
+			routineId: z.string().min(1),
+			title: z.string().min(1),
+			folder_id: folderId,
+			notes: z.string().optional(),
+			exercises: z.array(routineExerciseSchema).min(1)
+		}
+	}, safe(async ({ routineId, folder_id, ...routine }) => jsonResponse(await client.routines.update(routineId, {
+		...routine,
+		...folder_id === void 0 ? {} : { folder_id }
+	}))));
+	server.registerTool("get-routine-folders", {
+		description: "List routine folders (e.g. one per training block).",
+		inputSchema: pageSchema
+	}, safe(async ({ page, pageSize }) => jsonResponse(await client.routineFolders.list({
+		page,
+		pageSize
+	}))));
+	server.registerTool("get-routine-folder", {
+		description: "Get one routine folder by id.",
+		inputSchema: { folderId: z.coerce.number().int().gte(1) }
+	}, safe(async ({ folderId }) => jsonResponse(await client.routineFolders.get(folderId))));
+	server.registerTool("create-routine-folder", {
+		description: "Create a routine folder, e.g. 'Block 2 - Hypertrophy'. New folders appear at the top of the list.",
+		inputSchema: { title: z.string().min(1) }
+	}, safe(async ({ title }) => jsonResponse(await client.routineFolders.create(title))));
+}
+//#endregion
+//#region src/tools/users.ts
+function registerUserTools(server, client) {
+	server.registerTool("get-user-info", {
+		description: "Get the authenticated Hevy user's profile: id, display name and public profile URL.",
+		inputSchema: {}
+	}, safe(async () => jsonResponse(await client.user.info())));
+}
+//#endregion
+//#region src/tools/workouts.ts
+const workoutFields = {
+	title: z.string().min(1),
+	description: z.string().optional(),
+	start_time: isoDateTime("Start time"),
+	end_time: isoDateTime("End time"),
+	is_private: z.boolean().default(false),
+	exercises: z.array(workoutExerciseSchema).min(1)
+};
+function registerWorkoutTools(server, client) {
+	server.registerTool("get-workouts", {
+		description: "List logged workouts, newest first, with exercises, sets, weights, reps and RPE. Paginated; use get-training-summary for aggregates over many workouts.",
+		inputSchema: pageSchema
+	}, safe(async ({ page, pageSize }) => {
+		const result = await client.workouts.list({
+			page,
+			pageSize
+		});
+		return result.workouts.length ? jsonResponse(result) : textResponse("No workouts found.");
+	}));
+	server.registerTool("get-workout", {
+		description: "Get one logged workout by id with every exercise and set.",
+		inputSchema: { workoutId: z.string().min(1) }
+	}, safe(async ({ workoutId }) => jsonResponse(await client.workouts.get(workoutId))));
+	server.registerTool("get-workout-count", {
+		description: "Total number of workouts the user has logged.",
+		inputSchema: {}
+	}, safe(async () => jsonResponse({ workout_count: await client.workouts.count() })));
+	server.registerTool("get-workout-events", {
+		description: "Workouts changed since an ISO timestamp, newest first, as 'updated' (full workout) or 'deleted' (id only) events. Use for syncing; omit `since` for everything.",
+		inputSchema: {
+			...pageSchema,
+			since: z.string().optional().describe("ISO 8601 timestamp; defaults to the beginning of time")
+		}
+	}, safe(async ({ page, pageSize, since }) => jsonResponse(await client.workouts.events({
+		page,
+		pageSize,
+		since
+	}))));
+	server.registerTool("create-workout", {
+		description: "Log a completed workout in Hevy. Needs title, ISO start/end times and exercises with sets. Resolve exercise names to ids with batch-find-exercises first.",
+		inputSchema: workoutFields
+	}, safe(async (workout) => jsonResponse(await client.workouts.create(workout))));
+	server.registerTool("update-workout", {
+		description: "Replace a logged workout by id. All fields are overwritten, including every exercise and set.",
+		inputSchema: {
+			workoutId: z.string().min(1),
+			...workoutFields
+		}
+	}, safe(async ({ workoutId, ...workout }) => jsonResponse(await client.workouts.update(workoutId, workout))));
+}
+//#endregion
+//#region src/index.ts
+const SERVER_VERSION = "1.0.0";
+function createServer(options) {
+	const server = new McpServer({
+		name: "hevy-coach",
+		version: SERVER_VERSION
+	});
+	const client = createHevyClient(options);
+	registerUserTools(server, client);
+	registerWorkoutTools(server, client);
+	registerRoutineTools(server, client);
+	registerExerciseTools(server, client);
+	registerBodyMeasurementTools(server, client);
+	registerCoachingTools(server, client);
+	return server;
+}
+//#endregion
+export { createServer as n, SERVER_VERSION as t };