@murphai/murph 0.1.1 → 0.1.13

package/dist/usecases/workout-format.js

@@ -1,445 +1,265 @@
-import { readdir, readFile } from 'node:fs/promises';
-import { ID_PREFIXES, } from '@murphai/contracts';
-import { applyCanonicalWriteBatch, parseFrontmatterDocument, resolveVaultPathOnDisk, stringifyFrontmatterDocument, WORKOUT_FORMAT_DOC_TYPE, WORKOUT_FORMAT_SCHEMA_VERSION, WORKOUT_FORMATS_DIRECTORY, } from '@murphai/core';
-import { generateUlid } from '@murphai/runtime-state';
+import { workoutFormatUpsertPayloadSchema, } from '@murphai/contracts';
+import { listWorkoutFormats as listCoreWorkoutFormats, readWorkoutFormat as readCoreWorkoutFormat, upsertWorkoutFormat, } from '@murphai/core';
+import { loadJsonInputObject } from '@murphai/assistant-core/json-input';
 import { VaultCliError } from '@murphai/assistant-core/vault-cli-errors';
 import { asListEnvelope } from '@murphai/assistant-core/usecases/shared';
-import { resolveWorkoutCapture, addWorkoutRecord, } from './workout.js';
-import { compactObject, normalizeOptionalText, } from '@murphai/assistant-core/usecases/vault-usecase-helpers';
-const LOAD_UNITS = new Set(['lb', 'kg']);
-const WORKOUT_FORMAT_RECORD_ID_PATTERN = new RegExp(`^${ID_PREFIXES.workoutFormat}_[0-9A-Za-z]+$`, 'u');
-export async function saveWorkoutFormat(input) {
-    const title = normalizeOptionalText(input.name);
-    if (!title) {
-        throw new VaultCliError('contract_invalid', 'Workout format name is required.');
-    }
-    const slug = slugifyWorkoutFormatName(title);
-    if (!slug) {
-        throw new VaultCliError('contract_invalid', 'Workout format name must include at least one letter or number.');
-    }
-    const text = normalizeOptionalText(input.text);
-    if (!text) {
-        throw new VaultCliError('contract_invalid', 'Workout format text is required.');
+import { normalizeOptionalText, toVaultCliError, } from '@murphai/assistant-core/usecases/vault-usecase-helpers';
+import { addWorkoutRecord, resolveWorkoutCapture, } from './workout.js';
+import { buildWorkoutSessionFromTemplate, } from './workout-model.js';
+function requireTitle(value, label) {
+    const normalized = normalizeOptionalText(value);
+    if (!normalized) {
+        throw new VaultCliError('contract_invalid', `${label} is required.`);
     }
-    const capture = validateWorkoutFormatDefaults({
-        text,
-        durationMinutes: input.durationMinutes,
-        activityType: input.activityType,
-        distanceKm: input.distanceKm,
-    });
-    const relativePath = formatWorkoutFormatPath(slug);
-    const resolved = await resolveVaultPathOnDisk(input.vault, relativePath);
-    const existingMarkdown = await readOptionalUtf8File(resolved.absolutePath);
-    const existingRecord = existingMarkdown
-        ? parseWorkoutFormatRecord(existingMarkdown, relativePath)
-        : null;
-    const created = existingRecord === null;
-    const markdown = stringifyWorkoutFormatRecord({
-        workoutFormatId: existingRecord?.workoutFormatId ?? createWorkoutFormatId(),
-        title,
-        slug,
-        status: existingRecord?.status ?? 'active',
-        summary: existingRecord?.summary,
-        templateText: capture.note,
-        activityType: capture.activityType,
-        durationMinutes: capture.durationMinutes,
-        distanceKm: capture.distanceKm ?? undefined,
-        strengthExercises: capture.strengthExercises ?? undefined,
-        tags: existingRecord?.tags,
-        note: existingRecord?.note,
-        relativePath,
-        markdown: existingMarkdown ?? '',
-    });
-    await applyCanonicalWriteBatch({
-        vaultRoot: input.vault,
-        operationType: 'workout_format_save',
-        summary: `Save workout format ${slug}`,
-        textWrites: [
-            {
-                relativePath,
-                content: markdown,
-                overwrite: true,
-                allowExistingMatch: true,
-            },
-        ],
-    });
-    return {
-        vault: input.vault,
-        name: title,
-        slug,
-        path: relativePath,
-        created,
-    };
-}
-export async function showWorkoutFormat(vault, name) {
-    const record = await resolveWorkoutFormat(vault, name);
-    return {
-        vault,
-        entity: toWorkoutFormatEntity(record, {
-            includeMarkdown: true,
-        }),
-    };
-}
-export async function listWorkoutFormats(input) {
-    const records = await loadWorkoutFormats(input.vault);
-    const items = records.slice(0, input.limit).map((record) => toWorkoutFormatEntity(record, {
-        includeMarkdown: false,
-    }));
-    return asListEnvelope(input.vault, {
-        limit: input.limit,
-    }, items);
+    return normalized;
 }
-export async function logWorkoutFormat(input) {
-    const record = await resolveWorkoutFormat(input.vault, input.name);
-    return addWorkoutRecord({
-        vault: input.vault,
-        text: requireWorkoutFormatTemplateText(record),
-        durationMinutes: typeof input.durationMinutes === 'number'
-            ? input.durationMinutes
-            : record.durationMinutes,
-        activityType: typeof input.activityType === 'string'
-            ? input.activityType
-            : record.activityType,
-        distanceKm: typeof input.distanceKm === 'number'
-            ? input.distanceKm
-            : record.distanceKm,
-        strengthExercises: record.strengthExercises ?? null,
-        occurredAt: input.occurredAt,
-        source: input.source,
-    });
+function valueAsString(value) {
+    return typeof value === 'string' ? value : undefined;
 }
-async function loadWorkoutFormats(vault) {
-    const resolvedDirectory = await resolveVaultPathOnDisk(vault, WORKOUT_FORMATS_DIRECTORY);
-    const records = [];
-    try {
-        const entries = await readdir(resolvedDirectory.absolutePath, {
-            withFileTypes: true,
-            encoding: 'utf8',
-        });
-        for (const entry of entries) {
-            if (!entry.isFile() || !entry.name.endsWith('.md')) {
-                continue;
-            }
-            const relativePath = `${WORKOUT_FORMATS_DIRECTORY}/${entry.name}`;
-            const resolvedFile = await resolveVaultPathOnDisk(vault, relativePath);
-            const markdown = await readFile(resolvedFile.absolutePath, 'utf8');
-            records.push(parseWorkoutFormatRecord(markdown, relativePath));
-        }
-    }
-    catch (error) {
-        if (isMissingPathError(error)) {
-            return [];
-        }
-        throw error;
-    }
-    return records.sort((left, right) => left.title.localeCompare(right.title) ||
-        left.slug.localeCompare(right.slug));
+function valueAsNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
 }
-async function resolveWorkoutFormat(vault, lookup) {
-    const normalizedLookup = normalizeOptionalText(lookup);
-    if (!normalizedLookup) {
-        throw new VaultCliError('contract_invalid', 'Workout format name is required.');
-    }
-    const records = await loadWorkoutFormats(vault);
-    if (isWorkoutFormatId(normalizedLookup)) {
-        const idMatch = records.find((record) => record.workoutFormatId === normalizedLookup);
-        if (idMatch) {
-            return idMatch;
-        }
-    }
-    const directSlug = slugifyWorkoutFormatName(normalizedLookup);
-    if (directSlug) {
-        const directRecord = await readWorkoutFormatBySlug(vault, directSlug);
-        if (directRecord) {
-            return directRecord;
-        }
-    }
-    const slugMatch = records.find((record) => record.slug === normalizedLookup ||
-        (directSlug !== '' && record.slug === directSlug));
-    if (slugMatch) {
-        return slugMatch;
-    }
-    const titleMatches = records.filter((record) => record.title.toLowerCase() === normalizedLookup.toLowerCase());
-    if (titleMatches.length === 1) {
-        return titleMatches[0];
-    }
-    if (titleMatches.length > 1) {
-        throw new VaultCliError('conflict', `Multiple workout formats match "${normalizedLookup}". Use the saved slug instead.`);
-    }
-    throw new VaultCliError('not_found', `Workout format "${normalizedLookup}" was not found.`);
-}
-async function readWorkoutFormatBySlug(vault, slug) {
-    const relativePath = formatWorkoutFormatPath(slug);
-    const resolvedFile = await resolveVaultPathOnDisk(vault, relativePath);
-    const markdown = await readOptionalUtf8File(resolvedFile.absolutePath);
-    if (!markdown) {
-        return null;
-    }
-    return parseWorkoutFormatRecord(markdown, relativePath);
-}
-function parseWorkoutFormatRecord(markdown, relativePath) {
-    const parsed = parseFrontmatterDocument(markdown);
-    const attributes = parsed.attributes;
-    const schemaVersion = normalizeOptionalText(String(attributes.schemaVersion ?? ''));
-    const docType = normalizeOptionalText(String(attributes.docType ?? ''));
-    if (schemaVersion !== WORKOUT_FORMAT_SCHEMA_VERSION) {
-        throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" has an unexpected schemaVersion.`);
-    }
-    if (docType !== WORKOUT_FORMAT_DOC_TYPE) {
-        throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" has an unexpected docType.`);
+function buildTemplateFromCapture(capture) {
+    if (!capture.strengthExercises || capture.strengthExercises.length === 0) {
+        return undefined;
     }
-    const title = requireWorkoutFormatString(attributes.title, 'title', relativePath);
-    const slug = requireWorkoutFormatString(attributes.slug, 'slug', relativePath);
-    const workoutFormatId = requireWorkoutFormatString(attributes.workoutFormatId, 'workoutFormatId', relativePath);
-    const templateText = optionalWorkoutFormatString(attributes.templateText);
-    const activityType = requireWorkoutFormatString(attributes.activityType, 'activityType', relativePath);
-    const durationMinutes = optionalWorkoutFormatPositiveInteger(attributes.durationMinutes, 'durationMinutes', relativePath);
-    const distanceKm = optionalWorkoutFormatPositiveNumber(attributes.distanceKm, 'distanceKm', relativePath);
-    const strengthExercises = optionalWorkoutFormatStrengthExercises(attributes.strengthExercises, relativePath);
     return {
-        workoutFormatId,
-        title,
-        slug,
-        status: optionalWorkoutFormatString(attributes.status) ?? 'active',
-        summary: optionalWorkoutFormatString(attributes.summary),
-        templateText,
-        activityType,
-        durationMinutes,
-        distanceKm,
-        strengthExercises,
-        tags: optionalWorkoutFormatTags(attributes.tags, relativePath),
-        note: optionalWorkoutFormatString(attributes.note),
-        relativePath,
-        markdown,
+        routineNote: capture.note,
+        exercises: capture.strengthExercises.map((exercise, index) => ({
+            name: exercise.exercise,
+            order: index + 1,
+            mode: 'weight_reps',
+            ...(exercise.loadDescription
+                ? { note: exercise.loadDescription }
+                : {}),
+            plannedSets: Array.from({ length: exercise.setCount }, (_, setIndex) => ({
+                order: setIndex + 1,
+                targetReps: exercise.repsPerSet,
+                ...('load' in exercise
+                    ? {
+                        targetWeight: exercise.load,
+                        targetWeightUnit: exercise.loadUnit,
+                    }
+                    : {}),
+            })),
+        })),
     };
 }
-function stringifyWorkoutFormatRecord(record) {
-    const text = requireWorkoutFormatTemplateText(record);
-    const body = [
-        `# ${record.title}`,
-        '',
-        `- Status: ${record.status}`,
-        `- Activity type: ${record.activityType}`,
-        `- Default duration: ${record.durationMinutes ?? 'none'}${record.durationMinutes === undefined ? '' : ' min'}`,
-        `- Default distance: ${record.distanceKm ?? 'none'}${record.distanceKm === undefined ? '' : ' km'}`,
-        '',
-        ...(record.summary ? ['## Summary', '', record.summary, ''] : []),
-        ...(record.strengthExercises?.length
-            ? [
-                '## Strength Exercises',
-                '',
-                ...record.strengthExercises.map((exercise) => `- ${formatStrengthExerciseLine(exercise)}`),
-                '',
-            ]
-            : []),
-        '## Saved workout text',
-        '',
-        text,
-        '',
-        ...(record.tags?.length
-            ? ['## Tags', '', ...record.tags.map((tag) => `- ${tag}`), '']
-            : []),
-        ...(record.note ? ['## Notes', '', record.note, ''] : []),
-    ].join('\n');
-    return stringifyFrontmatterDocument({
-        attributes: compactObject({
-            schemaVersion: WORKOUT_FORMAT_SCHEMA_VERSION,
-            docType: WORKOUT_FORMAT_DOC_TYPE,
-            workoutFormatId: record.workoutFormatId,
-            slug: record.slug,
-            title: record.title,
-            status: record.status,
-            summary: record.summary,
-            activityType: record.activityType,
-            durationMinutes: record.durationMinutes,
-            distanceKm: record.distanceKm,
-            strengthExercises: record.strengthExercises,
-            tags: record.tags,
-            note: record.note,
-            templateText: text,
-        }),
-        body,
-    });
-}
-function toWorkoutFormatEntity(record, options) {
+function toWorkoutFormatEntity(record, includeMarkdown) {
     return {
         id: record.workoutFormatId,
         kind: 'workout_format',
         title: record.title,
         occurredAt: null,
         path: record.relativePath,
-        markdown: options.includeMarkdown ? record.markdown : null,
-        data: compactObject({
+        markdown: includeMarkdown ? record.markdown : null,
+        data: {
             workoutFormatId: record.workoutFormatId,
             slug: record.slug,
+            title: record.title,
+            status: record.status,
             summary: record.summary,
-            text: record.templateText,
-            templateText: record.templateText,
-            type: record.activityType,
             activityType: record.activityType,
             durationMinutes: record.durationMinutes,
             distanceKm: record.distanceKm,
             strengthExercises: record.strengthExercises,
+            template: record.template,
             tags: record.tags,
             note: record.note,
-            status: record.status,
-        }),
+            text: record.templateText,
+            templateText: record.templateText,
+        },
         links: [],
     };
 }
-function validateWorkoutFormatDefaults(input) {
+async function loadWorkoutFormats(vault) {
     try {
-        return resolveWorkoutCapture({
-            text: input.text,
-            durationMinutes: input.durationMinutes,
-            activityType: input.activityType,
-            distanceKm: input.distanceKm,
-        });
+        return await listCoreWorkoutFormats(vault);
     }
     catch (error) {
-        if (!(error instanceof VaultCliError)) {
-            throw error;
-        }
-        throw new VaultCliError(error.code, `Workout format defaults are invalid: ${error.message}`);
+        throw toWorkoutFormatCliError(error);
     }
 }
-function requireWorkoutFormatTemplateText(record) {
-    if (record.templateText) {
-        return record.templateText;
-    }
-    throw new VaultCliError('contract_invalid', `Workout format document "${record.relativePath}" is missing templateText.`);
-}
-function requireWorkoutFormatString(value, fieldName, relativePath) {
-    const normalized = normalizeOptionalText(typeof value === 'string' ? value : undefined);
-    if (!normalized) {
-        throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" is missing ${fieldName}.`);
+async function resolveWorkoutFormat(vault, lookup) {
+    const normalizedLookup = normalizeOptionalText(lookup);
+    if (!normalizedLookup) {
+        throw new VaultCliError('contract_invalid', 'Workout format lookup is required.');
     }
-    return normalized;
-}
-function optionalWorkoutFormatString(value) {
-    return typeof value === 'string' ? normalizeOptionalText(value) ?? undefined : undefined;
-}
-function optionalWorkoutFormatTags(value, relativePath) {
-    if (value === undefined || value === null) {
-        return undefined;
+    if (/^wfmt_[0-9A-Za-z]+$/u.test(normalizedLookup)) {
+        try {
+            return await readCoreWorkoutFormat({
+                vaultRoot: vault,
+                workoutFormatId: normalizedLookup,
+            });
+        }
+        catch (error) {
+            throw toWorkoutFormatCliError(error);
+        }
     }
-    if (!Array.isArray(value)) {
-        throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" has invalid tags.`);
+    const records = await loadWorkoutFormats(vault);
+    const slugMatch = records.find((record) => record.slug === normalizedLookup);
+    if (slugMatch) {
+        return slugMatch;
     }
-    const tags = [...new Set(value.map((entry) => {
-            if (typeof entry !== 'string') {
-                throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" has invalid tags.`);
-            }
-            const normalized = normalizeOptionalText(entry);
-            if (!normalized) {
-                throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" has invalid tags.`);
-            }
-            return normalized;
-        }))];
-    return tags.length > 0 ? tags : undefined;
-}
-function optionalWorkoutFormatPositiveInteger(value, fieldName, relativePath) {
-    if (value === undefined || value === null) {
-        return undefined;
+    const titleMatches = records.filter((record) => normalizeOptionalText(record.title)?.toLowerCase() === normalizedLookup.toLowerCase());
+    if (titleMatches.length > 1) {
+        throw new VaultCliError('command_failed', `Multiple workout formats match "${normalizedLookup}". Use the saved slug instead.`);
     }
-    if (!Number.isInteger(value) || Number(value) <= 0) {
-        throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" has an invalid ${fieldName}.`);
+    if (titleMatches[0]) {
+        return titleMatches[0];
     }
-    return Number(value);
+    throw new VaultCliError('not_found', `No workout format found for "${normalizedLookup}".`);
 }
-function optionalWorkoutFormatPositiveNumber(value, fieldName, relativePath) {
-    if (value === undefined || value === null) {
-        return undefined;
+function formatSchemaIssues(issues) {
+    return issues
+        .map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join('.') : 'value';
+        return `${path}: ${issue.message}`;
+    })
+        .join('; ');
+}
+function toWorkoutFormatCliError(error) {
+    if (error instanceof Error && error.message === 'workoutFormatId is required.') {
+        return new VaultCliError('contract_invalid', 'Workout format document is missing workoutFormatId.');
     }
-    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
-        throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" has an invalid ${fieldName}.`);
+    return toVaultCliError(error, {
+        VAULT_INVALID_INPUT: { code: 'contract_invalid' },
+        VAULT_INVALID_WORKOUT_FORMAT: { code: 'contract_invalid' },
+        VAULT_WORKOUT_FORMAT_MISSING: { code: 'not_found' },
+        VAULT_WORKOUT_FORMAT_CONFLICT: { code: 'command_failed' },
+    });
+}
+function normalizeStructuredWorkoutFormatPayload(payload, fallbackName) {
+    const candidate = {
+        ...payload,
+        title: valueAsString(payload.title) ?? fallbackName,
+        activityType: valueAsString(payload.activityType) ?? 'strength-training',
+    };
+    const parsed = workoutFormatUpsertPayloadSchema.safeParse(candidate);
+    if (!parsed.success) {
+        throw new VaultCliError('invalid_payload', `Workout format payload is invalid. ${formatSchemaIssues(parsed.error.issues)}`);
     }
-    return Number(value.toFixed(3));
+    return parsed.data;
 }
-function optionalWorkoutFormatStrengthExercises(value, relativePath) {
-    if (value === undefined || value === null) {
-        return undefined;
+export async function saveWorkoutFormat(input) {
+    let payload;
+    if (typeof input.inputFile === 'string') {
+        payload = normalizeStructuredWorkoutFormatPayload(await loadJsonInputObject(input.inputFile, 'workout format payload'), input.name);
     }
-    if (!Array.isArray(value)) {
-        throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" has invalid strengthExercises.`);
+    else {
+        const title = requireTitle(input.name, 'Workout format name');
+        const text = requireTitle(input.text, 'Workout format text');
+        const capture = resolveWorkoutCapture({
+            text,
+            durationMinutes: input.durationMinutes,
+            activityType: input.activityType,
+            distanceKm: input.distanceKm,
+        });
+        const template = buildTemplateFromCapture(capture);
+        payload = {
+            title,
+            status: 'active',
+            summary: undefined,
+            activityType: capture.activityType,
+            durationMinutes: capture.durationMinutes,
+            distanceKm: capture.distanceKm ?? undefined,
+            strengthExercises: capture.strengthExercises ?? undefined,
+            template,
+            note: undefined,
+            templateText: text,
+        };
     }
-    const exercises = value.map((entry, index) => {
-        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
-            throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" has invalid strengthExercises[${index}].`);
-        }
-        const exercise = requireWorkoutFormatString('exercise' in entry ? entry.exercise : undefined, `strengthExercises[${index}].exercise`, relativePath);
-        const setCount = optionalWorkoutFormatPositiveInteger('setCount' in entry ? entry.setCount : undefined, `strengthExercises[${index}].setCount`, relativePath);
-        const repsPerSet = optionalWorkoutFormatPositiveInteger('repsPerSet' in entry ? entry.repsPerSet : undefined, `strengthExercises[${index}].repsPerSet`, relativePath);
-        const load = 'load' in entry ? optionalWorkoutFormatPositiveNumber(entry.load, `strengthExercises[${index}].load`, relativePath) : undefined;
-        const loadUnit = 'loadUnit' in entry && typeof entry.loadUnit === 'string' && LOAD_UNITS.has(entry.loadUnit)
-            ? entry.loadUnit
-            : undefined;
-        const loadDescription = 'loadDescription' in entry
-            ? optionalWorkoutFormatString(entry.loadDescription)
-            : undefined;
-        if (setCount === undefined || repsPerSet === undefined) {
-            throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" has invalid strengthExercises[${index}].`);
-        }
-        if ((load === undefined) !== (loadUnit === undefined)) {
-            throw new VaultCliError('contract_invalid', `Workout format document "${relativePath}" has invalid strengthExercises[${index}].`);
-        }
-        return compactObject({
-            exercise,
-            setCount,
-            repsPerSet,
-            load,
-            loadUnit,
-            loadDescription,
+    let result;
+    try {
+        result = await upsertWorkoutFormat({
+            vaultRoot: input.vault,
+            workoutFormatId: payload.workoutFormatId,
+            slug: payload.slug,
+            title: payload.title,
+            status: payload.status,
+            summary: payload.summary,
+            activityType: payload.activityType,
+            durationMinutes: payload.durationMinutes,
+            distanceKm: payload.distanceKm,
+            strengthExercises: payload.strengthExercises,
+            template: payload.template,
+            tags: payload.tags,
+            note: payload.note,
+            templateText: payload.templateText,
         });
-    });
-    return exercises.length > 0 ? exercises : undefined;
-}
-function formatStrengthExerciseLine(exercise) {
-    const parts = [
-        `${exercise.exercise} — ${exercise.setCount} sets x ${exercise.repsPerSet} reps`,
-    ];
-    if ('load' in exercise &&
-        exercise.load !== undefined &&
-        exercise.loadUnit &&
-        LOAD_UNITS.has(exercise.loadUnit)) {
-        parts.push(`load: ${exercise.load} ${exercise.loadUnit}`);
     }
-    if (exercise.loadDescription) {
-        parts.push(exercise.loadDescription);
+    catch (error) {
+        throw toWorkoutFormatCliError(error);
     }
-    return parts.join('; ');
-}
-function slugifyWorkoutFormatName(value) {
-    return value
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/gu, '-')
-        .replace(/^-+|-+$/gu, '');
-}
-function formatWorkoutFormatPath(slug) {
-    return `${WORKOUT_FORMATS_DIRECTORY}/${slug}.md`;
+    return {
+        vault: input.vault,
+        name: result.record.title,
+        slug: result.record.slug,
+        path: result.record.relativePath,
+        created: result.created,
+    };
 }
-function isWorkoutFormatId(value) {
-    return WORKOUT_FORMAT_RECORD_ID_PATTERN.test(value);
+export async function showWorkoutFormat(vault, name) {
+    const record = await resolveWorkoutFormat(vault, name);
+    return {
+        vault,
+        entity: toWorkoutFormatEntity(record, true),
+    };
 }
-function createWorkoutFormatId() {
-    return `${ID_PREFIXES.workoutFormat}_${generateUlid()}`;
+export async function listWorkoutFormats(input) {
+    const records = await loadWorkoutFormats(input.vault);
+    const items = records.slice(0, input.limit).map((record) => toWorkoutFormatEntity(record, false));
+    return asListEnvelope(input.vault, {
+        limit: input.limit,
+    }, items);
 }
-async function readOptionalUtf8File(absolutePath) {
-    try {
-        return await readFile(absolutePath, 'utf8');
+export async function logWorkoutFormat(input) {
+    const record = await resolveWorkoutFormat(input.vault, input.name);
+    if (record.template) {
+        const templateNote = record.templateText
+            ?? record.template.routineNote
+            ?? record.title;
+        return addWorkoutRecord({
+            vault: input.vault,
+            workout: buildWorkoutSessionFromTemplate(record.template, {
+                routineId: record.workoutFormatId,
+                routineName: record.title,
+            }),
+            text: templateNote,
+            durationMinutes: typeof input.durationMinutes === 'number'
+                ? input.durationMinutes
+                : record.durationMinutes,
+            activityType: typeof input.activityType === 'string'
+                ? input.activityType
+                : record.activityType,
+            distanceKm: typeof input.distanceKm === 'number'
+                ? input.distanceKm
+                : record.distanceKm,
+            occurredAt: input.occurredAt,
+            source: input.source,
+            mediaPaths: input.mediaPaths,
+        });
     }
-    catch (error) {
-        if (isMissingPathError(error)) {
-            return null;
-        }
-        throw error;
+    if (record.templateText) {
+        return addWorkoutRecord({
+            vault: input.vault,
+            text: record.templateText,
+            durationMinutes: typeof input.durationMinutes === 'number'
+                ? input.durationMinutes
+                : record.durationMinutes,
+            activityType: typeof input.activityType === 'string'
+                ? input.activityType
+                : record.activityType,
+            distanceKm: typeof input.distanceKm === 'number'
+                ? input.distanceKm
+                : record.distanceKm,
+            strengthExercises: record.strengthExercises ?? null,
+            occurredAt: input.occurredAt,
+            source: input.source,
+            title: record.title,
+            mediaPaths: input.mediaPaths,
+        });
     }
-}
-function isMissingPathError(error) {
-    return Boolean(error &&
-        typeof error === 'object' &&
-        'code' in error &&
-        error.code === 'ENOENT');
+    throw new VaultCliError('contract_invalid', `Workout format document "${record.relativePath}" is missing templateText.`);
 }
 //# sourceMappingURL=workout-format.js.map