@trainheroic-unofficial/athlete-mcp 1.7.1 → 1.7.3

package/dist/server.mjs

@@ -169,6 +169,26 @@ const loggedSetSchema = z.object({
 * always sequential).
 */
 const loggedSetWithSlotSchema = loggedSetSchema.extend({ slot: z.number().int().min(1).max(10).optional() });
+function requireUniqueExerciseIds(results, ctx) {
+	const seen = /* @__PURE__ */ new Set();
+	results.forEach((result, index) => {
+		const id = String(result.savedWorkoutSetExerciseId).replace(/^0+(?=\d)/u, "");
+		if (seen.has(id)) ctx.addIssue({
+			code: "custom",
+			message: `savedWorkoutSetExerciseId ${id} appears more than once; combine its sets into one result.`,
+			path: [index, "savedWorkoutSetExerciseId"]
+		});
+		seen.add(id);
+	});
+}
+const loggedExerciseResultsSchema = z.array(z.object({
+	savedWorkoutSetExerciseId: idArgSchema,
+	sets: z.array(loggedSetWithSlotSchema).min(1)
+})).min(1).superRefine(requireUniqueExerciseIds);
+const prescribedExerciseResultsSchema = z.array(z.object({
+	savedWorkoutSetExerciseId: idArgSchema,
+	sets: z.array(loggedSetSchema).min(1)
+})).min(1).superRefine(requireUniqueExerciseIds);
 /**
 * 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`
@@ -180,20 +200,14 @@ const loggedSetWithSlotSchema = loggedSetSchema.extend({ slot: z.number().int().
 const logSetArgsSchema = z.object({
 	date: dateString,
 	savedWorkoutSetId: idArgSchema,
-	results: z.array(z.object({
-		savedWorkoutSetExerciseId: idArgSchema,
-		sets: z.array(loggedSetWithSlotSchema).min(1)
-	})).min(1)
+	results: loggedExerciseResultsSchema
 });
 logSetArgsSchema.extend({ athleteId: idArgSchema });
 z.object({
 	date: dateString,
 	savedWorkoutSetId: idArgSchema,
 	athleteId: idArgSchema,
-	results: z.array(z.object({
-		savedWorkoutSetExerciseId: idArgSchema,
-		sets: z.array(loggedSetSchema).min(1)
-	})).min(1)
+	results: prescribedExerciseResultsSchema
 });
 /**
 * Args for the coach per-athlete exercise swap: replace the exercise prescribed in one of a
@@ -1129,6 +1143,75 @@ function presentExerciseHistory(detail) {
 	};
 }
 //#endregion
+//#region ../js/src/exercise-set-payload.ts
+function slotData(exercise, key) {
+	const value = exercise?.[key];
+	return value === void 0 || value === null ? "" : String(value);
+}
+function slotIsActive(exercise, slot, targeted = false) {
+	return targeted || slotData(exercise, `param_1_data_${slot}`) !== "" || slotData(exercise, `param_2_data_${slot}`) !== "" || coerceInt(exercise?.[`param_${slot}_made`]) === 1;
+}
+/** True when an existing saved-copy exercise has at least one active slot and all are performed. */
+function exerciseIsFullyLogged(exercise) {
+	let anyActive = false;
+	for (let slot = 1; slot <= 10; slot += 1) {
+		if (!slotIsActive(exercise, slot)) continue;
+		anyActive = true;
+		if (coerceInt(exercise[`param_${slot}_made`]) !== 1) return false;
+	}
+	return anyActive;
+}
+/**
+* Build the typed body for `PUT /1.0/{role}/savedworkoutsetexercise/{id}`.
+*
+* A log marks only slots carrying reps as performed. The exercise completes only when every active
+* slot is performed; active slots are prescribed values, prior performed values, or slots targeted
+* by this write. Untargeted performed slots carry over, while untouched prescription values are
+* blanked so TrainHeroic cannot fabricate performed results from them. A prescription replaces the
+* full payload and never marks slots or the exercise complete.
+*/
+function buildExerciseSetPayload(savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, results, mode, existing) {
+	if (results.length > 10) throw new Error(`At most 10 sets are supported per exercise; got ${results.length}.`);
+	const bySlot = /* @__PURE__ */ new Map();
+	results.forEach((set, index) => {
+		const slot = set.slot ?? index + 1;
+		if (slot < 1 || slot > 10) throw new Error(`Set slot ${slot} is out of range; slots are 1–10.`);
+		if (bySlot.has(slot)) throw new Error(`Two sets target slot ${slot}; each slot can be written once.`);
+		bySlot.set(slot, set);
+	});
+	const logging = mode === "log";
+	const body = {
+		id: savedWorkoutSetExerciseId,
+		saved_workout_set_id: savedWorkoutSetId,
+		workout_set_exercise_id: workoutSetExerciseId,
+		completed: 0
+	};
+	let anyMade = false;
+	let allActiveSlotsMade = true;
+	for (let slot = 1; slot <= 10; slot += 1) {
+		const target = bySlot.get(slot);
+		let param1 = "";
+		let param2 = "";
+		let made = 0;
+		if (target) {
+			param1 = target.param1 === void 0 ? "" : String(target.param1);
+			param2 = target.param2 === void 0 ? "" : String(target.param2);
+			made = logging && param1 !== "" ? 1 : 0;
+		} else if (logging && coerceInt(existing?.[`param_${slot}_made`]) === 1) {
+			param1 = slotData(existing, `param_1_data_${slot}`);
+			param2 = slotData(existing, `param_2_data_${slot}`);
+			made = 1;
+		}
+		anyMade ||= made === 1;
+		if (slotIsActive(existing, slot, target !== void 0) && made !== 1) allActiveSlotsMade = false;
+		body[`param_${slot}_made`] = made;
+		body[`param_1_data_${slot}`] = param1;
+		body[`param_2_data_${slot}`] = param2;
+	}
+	body.completed = logging && anyMade && allActiveSlotsMade ? 1 : 0;
+	return body;
+}
+//#endregion
 //#region ../js/src/athlete-set-write.ts
 /**
 * Coerce the loosely-typed `results` from a validated log/prescribe args object into the SDK's
@@ -1154,102 +1237,25 @@ function toSetResults(results) {
 	});
 }
 /**
-* Build the body for `PUT /1.0/{role}/savedworkoutsetexercise/{id}`. The body uses snake_case
-* keys matching the live API response shape. Each set slot (1-10) carries `param_1_data_N` /
-* `param_2_data_N` string values plus a `param_N_made` flag.
-*
-* `mode` selects which write this is — the same endpoint serves both:
-*   - `"log"`: the values ARE a performed result, so `param_N_made` is 1 where the slot has data
-*     and the exercise `completed` flag is 1 when any set has logged data.
-*   - `"prescribe"`: the values are prescribed targets, written with every `param_N_made` and
-*     `completed` left at 0 so the set is not marked done. This matches what the app sends when a
-*     coach edits an athlete's prescribed reps/weight.
-*
-* Each set fills a 1-based slot: its explicit `slot`, or its sequential position in `results`
-* when `slot` is omitted. A `log` carrying the live exercise record in `existing` keeps the slots
-* it does not write that were ALREADY performed (`param_N_made === 1`), so logging a second part of
-* a set does not wipe the earlier-logged sets. A slot holding only un-logged prescription pre-fill
-* (`param_N_made === 0`) is left blank rather than carried over: marking the set completed makes
-* the server flag every data-bearing slot performed, so preserving that pre-fill would fabricate
-* sets the athlete never did. The prescription is unaffected (it lives in the separate `workout`
-* copy, not this saved copy). A `prescribe` ignores `existing` and replaces the whole prescription.
-*
-* Only `savedWorkoutSetExerciseId`, `savedWorkoutSetId`, and `workoutSetExerciseId` are
-* required from the live exercise record; everything else is derived from `results` and the
-* preserved slots of `existing`.
-*
-* Exported for unit testing — callers should use `logAthleteSet` / `prescribeForAthlete` instead.
+* Whether every exercise in a saved workout set is fully logged — either completed by its projected
+* payload in this call (`projectedCompletion`) or already carrying made flags for every active slot.
+* This gates the set-completion PUT so a partial exercise cannot close a superset/circuit and cause
+* TrainHeroic to backfill its omitted slots or untouched siblings.
 */
-function buildExerciseSetPayload(savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, results, mode, existing) {
-	if (results.length > 10) throw new Error(`At most 10 sets are supported per exercise; got ${results.length}.`);
-	const bySlot = /* @__PURE__ */ new Map();
-	results.forEach((set, i) => {
-		const slot = set.slot ?? i + 1;
-		if (slot < 1 || slot > 10) throw new Error(`Set slot ${slot} is out of range; slots are 1–10.`);
-		if (bySlot.has(slot)) throw new Error(`Two sets target slot ${slot}; each slot can be written once.`);
-		bySlot.set(slot, set);
-	});
-	const performed = mode === "log";
-	const carryOver = performed && existing !== void 0;
-	const body = {
-		id: savedWorkoutSetExerciseId,
-		saved_workout_set_id: savedWorkoutSetId,
-		workout_set_exercise_id: workoutSetExerciseId
-	};
-	let anyMade = false;
-	for (let i = 1; i <= 10; i += 1) {
-		const target = bySlot.get(i);
-		let p1;
-		let p2;
-		let made;
-		if (target) {
-			p1 = target.param1 !== void 0 ? String(target.param1) : "";
-			p2 = target.param2 !== void 0 ? String(target.param2) : "";
-			made = performed && (p1 !== "" || p2 !== "") ? 1 : 0;
-		} else if (carryOver && coerceInt(existing?.[`param_${i}_made`]) === 1) {
-			p1 = existingSlotData(existing, `param_1_data_${i}`);
-			p2 = existingSlotData(existing, `param_2_data_${i}`);
-			made = 1;
-		} else {
-			p1 = "";
-			p2 = "";
-			made = 0;
-		}
-		if (made === 1) anyMade = true;
-		body[`param_${i}_made`] = made;
-		body[`param_1_data_${i}`] = p1;
-		body[`param_2_data_${i}`] = p2;
-	}
-	body.completed = performed && anyMade ? 1 : 0;
-	return body;
-}
-/** Read a saved-copy slot value (`param_1_data_N` / `param_2_data_N`) as the string the body uses. */
-function existingSlotData(existing, key) {
-	const v = existing?.[key];
-	return v === void 0 || v === null ? "" : String(v);
-}
-/** True when a saved-copy exercise already carries a performed slot (any `param_N_made` === 1). */
-function exerciseHasLoggedData(ex) {
-	for (let i = 1; i <= 10; i += 1) if (coerceInt(ex[`param_${i}_made`]) === 1) return true;
-	return false;
-}
-/** True when a result carries at least one non-empty param value (so it produces a performed slot). */
-function resultHasData(result) {
-	return result.sets.some((s) => s.param1 !== void 0 && String(s.param1) !== "" || s.param2 !== void 0 && String(s.param2) !== "");
-}
-/**
-* Whether every exercise in a saved workout set now has logged data — either written with data in
-* this call (`loggedIds`) or already carrying a performed slot. Gates the set-completion PUT: a
-* superset/circuit stays open until the last exercise is logged, so completing it on a partial log
-* does not flip its still-empty siblings to "done". An exercise written with only empty values does
-* not count (it would not be marked performed), so an all-empty log never completes the set.
-*/
-function isSetFullyLogged(exercises, loggedIds) {
+function isSetFullyLogged(exercises, projectedCompletion) {
 	return exercises.every((ex) => {
 		const id = coerceInt(ex.id);
-		return id !== null && loggedIds.has(id) || exerciseHasLoggedData(ex);
+		if (id !== null && projectedCompletion.has(id)) return projectedCompletion.get(id) === true;
+		return exerciseIsFullyLogged(ex);
 	});
 }
+function assertUniqueExerciseResults(results) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const result of results) {
+		if (seen.has(result.savedWorkoutSetExerciseId)) throw new Error(`savedWorkoutSetExerciseId ${result.savedWorkoutSetExerciseId} appears more than once; combine its sets into one result.`);
+		seen.add(result.savedWorkoutSetExerciseId);
+	}
+}
 /**
 * Locate the target saved workout set across all program workouts on the given day.
 * Returns the `savedWorkoutId`, the matching set's `workoutSetExercises` array so callers
@@ -1422,9 +1428,11 @@ async function swapAthleteExercise(client, args) {
 */
 async function writeSetResults(client, target, workouts, savedWorkoutSetId, results, mode) {
 	const { exercises, rawSet } = findSavedWorkoutSet(workouts, savedWorkoutSetId);
+	assertUniqueExerciseResults(results);
 	const suffix = target.role === "coach" ? `/${target.athleteId}` : "";
 	const extra = target.role === "coach" ? { athleteId: target.athleteId } : {};
 	let exercisesWritten = 0;
+	const projectedCompletion = /* @__PURE__ */ new Map();
 	for (const result of results) {
 		const ex = exercises.find((e) => coerceInt(e.id) === result.savedWorkoutSetExerciseId);
 		if (!ex) {
@@ -1445,11 +1453,12 @@ async function writeSetResults(client, target, workouts, savedWorkoutSetId, resu
 			const readOnly = target.role === "coach" && (res.status === 401 || res.status === 403) ? ` Athlete ${target.athleteId} appears to be read-only for changes — TrainHeroic's seeded demo/sample athletes return ${res.status} here; writes only persist for real (invited) athletes.` : "";
 			throw new Error(`Failed to write exercise ${result.savedWorkoutSetExerciseId} (HTTP ${res.status}).${readOnly}`);
 		}
+		projectedCompletion.set(result.savedWorkoutSetExerciseId, body.completed === 1);
 		exercisesWritten += 1;
 	}
 	let setCompleted = false;
 	if (mode === "log") {
-		if (isSetFullyLogged(exercises, new Set(results.filter(resultHasData).map((r) => r.savedWorkoutSetExerciseId)))) {
+		if (isSetFullyLogged(exercises, projectedCompletion)) {
 			const setBody = {
 				...buildSetCompletePayload(rawSet, exercises.map((e) => coerceInt(e.id)).filter((n) => n !== null), true),
 				...extra
@@ -2052,7 +2061,7 @@ function registerAthleteTrainingTools(server, ctx) {
 }
 //#endregion
 //#region package.json
-var version = "1.7.1";
+var version = "1.7.3";
 //#endregion
 //#region src/server.ts
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainheroic-unofficial/athlete-mcp",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -21,15 +21,15 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^4.4.3",
-    "@trainheroic-unofficial/core": "1.7.1",
-    "@trainheroic-unofficial/js": "1.7.1"
+    "@trainheroic-unofficial/core": "1.7.3",
+    "@trainheroic-unofficial/js": "1.7.3"
   },
   "devDependencies": {
-    "@types/node": "^26.0.1",
+    "@types/node": "^26.1.0",
     "tsdown": "^0.22.3",
-    "tsx": "^4.22.4",
+    "tsx": "^4.23.0",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.10"
   },
   "scripts": {
     "start": "tsx src/server.ts",