@trainheroic-unofficial/athlete-mcp 0.6.5 → 1.1.0

package/dist/server.mjs

@@ -152,6 +152,14 @@ z.object({
 	endDate: dateString
 });
 /**
+* One entered set: the value of each parameter slot (param 1 / param 2 — e.g. reps / weight).
+* Shared by every logging write so the per-set shape is defined once.
+*/
+const loggedSetSchema = z.object({
+	param1: z.union([z.number(), z.string()]).optional(),
+	param2: z.union([z.number(), z.string()]).optional()
+});
+/**
 * Args for the set-logging write. `date` (the workout's day) locates the saved
 * workout via the range endpoint; `savedWorkoutSetId` picks the set to complete; `results`
 * gives, per exercise in it, the entered value of each set (param 1 / param 2 by entry slot).
@@ -161,13 +169,25 @@ const logSetArgsSchema = z.object({
 	savedWorkoutSetId: idArgSchema,
 	results: z.array(z.object({
 		savedWorkoutSetExerciseId: idArgSchema,
-		sets: z.array(z.object({
-			param1: z.union([z.number(), z.string()]).optional(),
-			param2: z.union([z.number(), z.string()]).optional()
-		})).min(1)
+		sets: z.array(loggedSetSchema).min(1)
 	})).min(1)
 });
 logSetArgsSchema.extend({ athleteId: idArgSchema });
+/**
+* Args for logging a whole session by exercise (rather than by saved-workout-set id). Each
+* exercise carries its entered sets and an optional 1-based `order`. The athlete path creates
+* or reuses a personal session for the date and logs against it; the coach path resolves each
+* exercise to a set already prescribed on that date and logs against that.
+*/
+const logSessionArgsSchema = z.object({
+	date: dateString,
+	exercises: z.array(z.object({
+		exerciseId: idArgSchema,
+		order: z.number().int().positive().optional(),
+		sets: z.array(loggedSetSchema).min(1)
+	})).min(1)
+});
+logSessionArgsSchema.extend({ athleteId: idArgSchema });
 z.looseObject({
 	title: z.string().min(1),
 	param_1_type: z.number().optional(),
@@ -654,6 +674,15 @@ function fetchExerciseStats(client, exerciseId, userId, date) {
 function fetchAthleteWorkouts(client, startDate, endDate) {
 	return getArray(client, `/3.0/athlete/programworkout/range?startDate=${startDate}&endDate=${endDate}`, "athlete workouts");
 }
+/**
+* A coach's view of a roster athlete's scheduled + completed workouts in an inclusive
+* YYYY-MM-DD window (`/3.0/coach/athlete/programworkout/range/{athleteId}`). Returns the same
+* `ProgramWorkout[]` shape as `fetchAthleteWorkouts`, so the same presenters and
+* `findSavedWorkoutSet` apply — it just reads another athlete's data through the coach surface.
+*/
+function fetchCoachAthleteWorkouts(client, athleteId, startDate, endDate) {
+	return getArray(client, `/3.0/coach/athlete/programworkout/range/${athleteId}?startDate=${startDate}&endDate=${endDate}`, "coach athlete workouts");
+}
 function fetchLeaderboard(client, workoutId, opts = {}) {
 	const qs = new URLSearchParams();
 	if (opts.page !== void 0) qs.set("page", String(opts.page));
@@ -988,6 +1017,23 @@ async function logAthleteSet(client, args) {
 	return writeSetResults(client, { role: "athlete" }, await fetchAthleteWorkouts(client, args.date, args.date), args.savedWorkoutSetId, args.results);
 }
 /**
+* Coach "Log for Athlete": record set results for a roster athlete on their behalf, via the
+* coach surface — `PUT /1.0/coach/savedworkoutsetexercise/{id}/{athleteId}` (the data write)
+* then `PUT /1.0/coach/savedworkoutset/{id}/{athleteId}` (mark complete). Same two-step
+* contract as {@link logAthleteSet}; the bodies are identical except each is stamped with
+* `athleteId`. The day is located through the coach range endpoint for that athlete.
+*
+* NOTE: TrainHeroic's seeded *demo* athletes are read-only for results and return 401 on the
+* data-write step; real (invited) athletes accept it.
+*/
+async function logForAthlete(client, args) {
+	const workouts = await fetchCoachAthleteWorkouts(client, args.athleteId, args.date, args.date);
+	return writeSetResults(client, {
+		role: "coach",
+		athleteId: args.athleteId
+	}, workouts, args.savedWorkoutSetId, args.results);
+}
+/**
 * Shared two-step set-log write behind {@link logAthleteSet} and {@link logForAthlete}.
 * `target` selects the surface: `athlete` writes `/1.0/athlete/...`; `coach` writes
 * `/1.0/coach/...{athleteId}` and stamps `athleteId` into each body. Step 1 PUTs each
@@ -1073,6 +1119,114 @@ async function addExercisesToWorkout(client, workoutId, exercises) {
 	if (!res.ok) throw new Error(`Add exercises to workout failed (HTTP ${res.status}).`);
 	return res.data;
 }
+/**
+* Find a personal-calendar session already on the given day. The range marks these with
+* `personal_cal === true`; the addable id is the program workout's `workout_id`. Returns the
+* first one's workoutId, or null when the day has no personal session.
+*/
+function findPersonalSessionWorkoutId(workouts) {
+	for (const pw of workouts) {
+		const rec = pw;
+		if (rec.personal_cal === true) {
+			const workoutId = coerceInt(rec.workout_id);
+			if (workoutId !== null) return workoutId;
+		}
+	}
+	return null;
+}
+/**
+* Map the `addExercisesToWorkout` response (an array of saved sets) to per-exercise saved ids.
+* Each set's `id` is a savedWorkoutSetId; each `savedWorkoutSetExercises[].id` is a
+* savedWorkoutSetExerciseId and `.exerciseId` is the catalog exercise id that was added.
+*/
+function indexAddedExercises(added) {
+	const out = [];
+	const sets = Array.isArray(added) ? added : [];
+	for (const s of sets) {
+		if (!isRecord(s)) continue;
+		const savedWorkoutSetId = coerceInt(s.id);
+		if (savedWorkoutSetId === null) continue;
+		const exercises = Array.isArray(s.savedWorkoutSetExercises) ? s.savedWorkoutSetExercises : [];
+		for (const ex of exercises) {
+			if (!isRecord(ex)) continue;
+			const savedWorkoutSetExerciseId = coerceInt(ex.id);
+			const exerciseId = coerceInt(ex.exerciseId ?? ex.exercise_id);
+			if (savedWorkoutSetExerciseId === null || exerciseId === null) continue;
+			out.push({
+				exerciseId,
+				savedWorkoutSetId,
+				savedWorkoutSetExerciseId
+			});
+		}
+	}
+	return out;
+}
+/** Group resolved exercises by saved set and write each set via the given log target. */
+async function logResolvedExercises(client, target, date, resolved) {
+	const bySet = /* @__PURE__ */ new Map();
+	for (const r of resolved) {
+		const list = bySet.get(r.savedWorkoutSetId) ?? [];
+		list.push({
+			savedWorkoutSetExerciseId: r.savedWorkoutSetExerciseId,
+			sets: [...r.sets]
+		});
+		bySet.set(r.savedWorkoutSetId, list);
+	}
+	const out = [];
+	for (const [savedWorkoutSetId, results] of bySet) {
+		const written = target.role === "coach" ? await logForAthlete(client, {
+			athleteId: target.athleteId,
+			date,
+			savedWorkoutSetId,
+			results
+		}) : await logAthleteSet(client, {
+			date,
+			savedWorkoutSetId,
+			results
+		});
+		out.push(written);
+	}
+	return out;
+}
+/**
+* Log a whole session for the logged-in athlete by exercise, with no pre-existing prescription
+* required. Reuses a personal session already on the date when one exists (the API marks these
+* `personal_cal`), otherwise creates one; then adds the exercises and logs their entered sets.
+* This is the "log whatever I just did" path — extra accessory work, a makeup lift, an off-plan
+* gym session.
+*/
+async function logAdHocSession(client, args) {
+	if (args.exercises.length === 0) throw new Error("Provide at least one exercise to log.");
+	const existing = findPersonalSessionWorkoutId(await fetchAthleteWorkouts(client, args.date, args.date));
+	const created = existing === null;
+	const workoutId = existing ?? (await createPersonalWorkout(client, args.date)).workoutId;
+	const withOrder = args.exercises.map((e, i) => ({
+		...e,
+		order: e.order ?? i + 1
+	}));
+	const index = indexAddedExercises(await addExercisesToWorkout(client, workoutId, withOrder.map((e) => ({
+		exerciseId: e.exerciseId,
+		order: e.order
+	}))));
+	const consumed = /* @__PURE__ */ new Set();
+	const resolved = withOrder.map((e) => {
+		const hit = index.find((m) => m.exerciseId === e.exerciseId && !consumed.has(m.savedWorkoutSetExerciseId));
+		if (!hit) throw new Error(`Could not place exercise ${e.exerciseId} into the session after adding it. The add-exercises response did not return a saved set for it.`);
+		consumed.add(hit.savedWorkoutSetExerciseId);
+		return {
+			exerciseId: e.exerciseId,
+			savedWorkoutSetId: hit.savedWorkoutSetId,
+			savedWorkoutSetExerciseId: hit.savedWorkoutSetExerciseId,
+			sets: e.sets
+		};
+	});
+	const sets = await logResolvedExercises(client, { role: "athlete" }, args.date, resolved);
+	return {
+		date: args.date,
+		created,
+		sets
+	};
+}
 /** Flatten `/v5/exercises/{id}/history` into PRs + a session time-series. */
 function presentExerciseHistory(detail) {
 	return {
@@ -1280,8 +1434,40 @@ function registerSessionTools(server, ctx) {
 		return jsonResult(await addExercisesToWorkout(ctx.client, toId(workoutId), mapped), { hint: "Each top-level id is a savedWorkoutSetId; savedWorkoutSetExercises[].id is the savedWorkoutSetExerciseId for athlete_log_set." });
 	}));
 }
-/** The gated set-logging write. */
+/** Map validated logSession exercises to the SDK's SessionExercise[] (ids coerced, slots trimmed). */
+function mapSessionExercises(exercises) {
+	return exercises.map((e) => {
+		const sets = e.sets.map((s) => {
+			const slot = {};
+			if (s.param1 !== void 0) slot.param1 = s.param1;
+			if (s.param2 !== void 0) slot.param2 = s.param2;
+			return slot;
+		});
+		const mapped = {
+			exerciseId: toId(e.exerciseId),
+			sets
+		};
+		if (e.order !== void 0) mapped.order = e.order;
+		return mapped;
+	});
+}
+/** The gated set-logging writes (by saved-set id, and the by-exercise ad-hoc session). */
 function registerLogTool(server, ctx) {
+	server.registerTool("athlete_log_session", {
+		title: "Log a whole session by exercise",
+		description: "Athlete-facing write for logging what you actually did, with NO coach-scheduled workout required — use this for off-plan training (accessory work, a makeup lift, an unplanned gym session). Give a YYYY-MM-DD date and a list of exercises, each with its entered sets (param1/param2, e.g. reps/weight). It reuses a personal session already on that date or creates one, then logs the sets. Get each exerciseId from athlete_exercises. To log against a workout a coach already scheduled, use athlete_log_set instead. Requires confirmation (elicitation or confirm:true).",
+		inputSchema: {
+			...logSessionArgsSchema.shape,
+			confirm: z.boolean().optional()
+		},
+		annotations: DESTRUCTIVE
+	}, ({ date, exercises, confirm }, extra) => attempt(async () => {
+		if (!await confirmGate(server, extra.requestId, `Log a session of ${exercises.length} exercise(s) on ${date}? This writes to your coach-visible training log.`, confirm)) return errorResult(NOT_CONFIRMED);
+		return jsonResult(await logAdHocSession(ctx.client, {
+			date,
+			exercises: mapSessionExercises(exercises)
+		}));
+	}));
 	server.registerTool("athlete_log_set", {
 		title: "Log completed set results",
 		description: "Athlete-facing write: record entered results (reps/weight per set) for a saved workout set on a given day, marking the set completed. Writes to the athlete's (coach-visible) training log and shows in exercise history. Get savedWorkoutSetId + savedWorkoutSetExerciseId from athlete_workouts (raw:true). Requires confirmation (elicitation or confirm:true).",
@@ -1335,7 +1521,7 @@ function registerAthleteTrainingTools(server, ctx) {
 }
 //#endregion
 //#region package.json
-var version = "0.6.5";
+var version = "1.1.0";
 //#endregion
 //#region src/server.ts
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainheroic-unofficial/athlete-mcp",
-  "version": "0.6.5",
+  "version": "1.1.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -21,8 +21,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^4.4.3",
-    "@trainheroic-unofficial/core": "0.6.5",
-    "@trainheroic-unofficial/js": "0.6.5"
+    "@trainheroic-unofficial/core": "1.1.0",
+    "@trainheroic-unofficial/js": "1.1.0"
   },
   "devDependencies": {
     "@types/node": "^26.0.0",