@nickchristensen/cliftin 1.0.2

package/dist/lib/repositories/exercises.js

@@ -0,0 +1,280 @@
+import { sql } from 'kysely';
+import { formatEquipmentDisplayName, formatExerciseDisplayName, formatMuscleLabel } from '../names.js';
+import { appleSecondsToIso, dateRangeToAppleSeconds } from '../time.js';
+import { convertDisplayWeightToKg, convertKgToDisplayVolume, convertKgToDisplayWeight, resolveExerciseWeightUnit, } from '../units.js';
+import { resolveIdOrName } from './selectors.js';
+import { getWorkoutDetail } from './workouts.js';
+function asBool(value) {
+    return value === 1;
+}
+function renderSelectorCandidateList(candidates) {
+    return candidates
+        .map((candidate) => ({
+        id: candidate.id,
+        name: formatExerciseDisplayName(candidate.name, asBool(candidate.isUserCreated)),
+    }))
+        .map((candidate) => `${candidate.id}:${candidate.name}`)
+        .join(', ');
+}
+export async function resolveExerciseSelector(db, selector) {
+    if (/^\d+$/.test(selector))
+        return Number(selector);
+    const normalizedSelector = selector.toLowerCase().trim();
+    const rows = await db
+        .selectFrom('ZEXERCISEINFORMATION')
+        .select(['Z_PK as id', 'ZISUSERCREATED as isUserCreated', 'ZNAME as name'])
+        .where('ZSOFTDELETED', 'is not', 1)
+        .execute();
+    const exact = rows.filter((row) => {
+        const rawName = (row.name ?? '').toLowerCase();
+        const displayName = formatExerciseDisplayName(row.name, asBool(row.isUserCreated)).toLowerCase();
+        return rawName === normalizedSelector || displayName === normalizedSelector;
+    });
+    if (exact.length === 1)
+        return exact[0].id;
+    if (exact.length > 1) {
+        throw new Error(`Selector "${selector}" is ambiguous: ${renderSelectorCandidateList(exact)}`);
+    }
+    const partial = rows.filter((row) => {
+        const rawName = (row.name ?? '').toLowerCase();
+        const displayName = formatExerciseDisplayName(row.name, asBool(row.isUserCreated)).toLowerCase();
+        return rawName.includes(normalizedSelector) || displayName.includes(normalizedSelector);
+    });
+    if (partial.length === 1)
+        return partial[0].id;
+    if (partial.length > 1) {
+        throw new Error(`Selector "${selector}" is ambiguous: ${renderSelectorCandidateList(partial)}`);
+    }
+    throw new Error(`No records found for selector: ${selector}`);
+}
+export async function listExercises(db, filters) {
+    const nameLike = filters.name ? `%${filters.name}%` : undefined;
+    const normalizedNameLike = filters.name ? `%${filters.name.toLowerCase().replaceAll('_', ' ')}%` : undefined;
+    let query = db
+        .selectFrom('ZEXERCISEINFORMATION as ei')
+        .leftJoin('ZEQUIPMENT2 as eq', 'eq.Z_PK', 'ei.ZEQUIPMENT')
+        .leftJoin('ZEXERCISECONFIGURATION as ec', 'ec.ZINFORMATION', 'ei.Z_PK')
+        .leftJoin('ZEXERCISERESULT as er', 'er.ZCONFIGURATION', 'ec.Z_PK')
+        .leftJoin('ZWORKOUTRESULT as wr', 'wr.Z_PK', 'er.ZWORKOUT')
+        .select([
+        'ei.Z_PK as id',
+        'ei.ZNAME as name',
+        'ei.ZISUSERCREATED as isUserCreated',
+        'ei.ZMUSCLES as primaryMuscles',
+        'ei.ZSECONDARYMUSCLES as secondaryMuscles',
+        'ei.ZTIMERBASED as timerBased',
+        'ei.ZSUPPORTSONEREPMAX as supports1RM',
+        'eq.ZNAME as equipment',
+        'eq.ZID as equipmentId',
+        (eb) => eb.fn.max('wr.ZSTARTDATE').as('lastPerformed'),
+        (eb) => eb.fn.count('wr.Z_PK').distinct().as('timesPerformed'),
+    ])
+        .where('ei.ZSOFTDELETED', 'is not', 1)
+        .groupBy(['ei.Z_PK', 'eq.ZNAME', 'eq.ZID'])
+        .orderBy('ei.ZNAME', 'asc');
+    if (nameLike && normalizedNameLike) {
+        query = query.where((eb) => eb.or([
+            eb('ei.ZNAME', 'like', nameLike),
+            sql `lower(replace(ei.ZNAME, '_', ' ')) like ${normalizedNameLike}`,
+        ]));
+    }
+    if (filters.muscle) {
+        query = query.where((eb) => eb.or([eb('ei.ZMUSCLES', 'like', `%${filters.muscle}%`), eb('ei.ZSECONDARYMUSCLES', 'like', `%${filters.muscle}%`)]));
+    }
+    if (filters.equipment) {
+        query = query.where((eb) => eb.or([eb('eq.ZNAME', 'like', `%${filters.equipment}%`), eb('eq.ZID', 'like', `%${filters.equipment}%`)]));
+    }
+    const rows = await query.execute();
+    const summaries = rows.map((row) => ({
+        equipment: formatEquipmentDisplayName(row.equipment, row.equipmentId),
+        id: row.id,
+        lastPerformed: appleSecondsToIso(row.lastPerformed),
+        name: formatExerciseDisplayName(row.name, asBool(row.isUserCreated)),
+        primaryMuscles: formatMuscleLabel(row.primaryMuscles),
+        secondaryMuscles: formatMuscleLabel(row.secondaryMuscles),
+        supports1RM: asBool(row.supports1RM),
+        timerBased: asBool(row.timerBased),
+        timesPerformed: Number(row.timesPerformed),
+    }));
+    const sort = filters.sort ?? 'name';
+    if (sort === 'timesPerformed') {
+        summaries.sort((a, b) => b.timesPerformed - a.timesPerformed || a.id - b.id);
+        return summaries;
+    }
+    if (sort === 'lastPerformed') {
+        summaries.sort((a, b) => {
+            if (a.lastPerformed === b.lastPerformed)
+                return a.id - b.id;
+            if (a.lastPerformed === null)
+                return 1;
+            if (b.lastPerformed === null)
+                return -1;
+            return b.lastPerformed.localeCompare(a.lastPerformed);
+        });
+        return summaries;
+    }
+    summaries.sort((a, b) => {
+        const aName = (a.name ?? '').toLowerCase();
+        const bName = (b.name ?? '').toLowerCase();
+        if (aName === bName)
+            return a.id - b.id;
+        return aName.localeCompare(bName);
+    });
+    return summaries;
+}
+export async function getExerciseHistoryRows(db, exerciseId, filters) {
+    const unitPreference = await resolveExerciseWeightUnit(db, exerciseId);
+    const dateRange = dateRangeToAppleSeconds({ from: filters.from, to: filters.to });
+    const minWeightKg = filters.minWeight === undefined ? undefined : convertDisplayWeightToKg(filters.minWeight, unitPreference);
+    const maxWeightKg = filters.maxWeight === undefined ? undefined : convertDisplayWeightToKg(filters.maxWeight, unitPreference);
+    let query = db
+        .selectFrom('ZWORKOUTRESULT as wr')
+        .innerJoin('ZEXERCISERESULT as er', 'er.ZWORKOUT', 'wr.Z_PK')
+        .innerJoin('ZEXERCISECONFIGURATION as ec', 'ec.Z_PK', 'er.ZCONFIGURATION')
+        .innerJoin('ZEXERCISEINFORMATION as ei', 'ei.Z_PK', 'ec.ZINFORMATION')
+        .leftJoin('ZROUTINE as r', 'r.Z_PK', 'wr.ZROUTINE')
+        .leftJoin('ZPERIOD as per', 'per.Z_PK', 'r.ZPERIOD')
+        .leftJoin('ZWORKOUTPLAN as pDirect', 'pDirect.Z_PK', 'r.ZWORKOUTPLAN')
+        .leftJoin('ZWORKOUTPLAN as pFromPeriod', 'pFromPeriod.Z_PK', 'per.ZWORKOUTPLAN')
+        .leftJoin('ZGYMSETRESULT as gs', 'gs.ZEXERCISE', 'er.Z_PK')
+        .select([
+        'wr.Z_PK as workoutId',
+        'wr.ZSTARTDATE as startDate',
+        'wr.ZROUTINENAME as routineNameFromResult',
+        'r.ZNAME as routineNameFromPlan',
+        (eb) => eb.fn.count('gs.Z_PK').as('sets'),
+        (eb) => eb.fn.coalesce(eb.fn.sum('gs.ZREPS'), eb.val(0)).as('totalReps'),
+        (eb) => eb.fn.max('gs.ZREPS').as('topReps'),
+        (eb) => eb.fn.max('gs.ZWEIGHT').as('topWeight'),
+        (eb) => eb.fn.coalesce(eb.fn.sum('gs.ZVOLUME'), eb.val(0)).as('volume'),
+    ])
+        .where('ei.Z_PK', '=', exerciseId)
+        .groupBy(['wr.Z_PK', 'wr.ZSTARTDATE', 'wr.ZROUTINENAME', 'r.ZNAME'])
+        .orderBy('wr.ZSTARTDATE', 'desc');
+    if (filters.program) {
+        const programId = await resolveIdOrName(db, 'ZWORKOUTPLAN', filters.program);
+        query = query.where((eb) => eb.or([eb('r.ZWORKOUTPLAN', '=', programId), eb('per.ZWORKOUTPLAN', '=', programId)]));
+    }
+    if (filters.routine) {
+        const routineId = await resolveIdOrName(db, 'ZROUTINE', filters.routine);
+        query = query.where('wr.ZROUTINE', '=', routineId);
+    }
+    if (dateRange.from !== undefined)
+        query = query.where('wr.ZSTARTDATE', '>=', dateRange.from);
+    if (dateRange.to !== undefined)
+        query = query.where('wr.ZSTARTDATE', '<=', dateRange.to);
+    if (filters.minReps !== undefined)
+        query = query.having((eb) => eb.fn.max('gs.ZREPS'), '>=', filters.minReps);
+    if (filters.maxReps !== undefined)
+        query = query.having((eb) => eb.fn.max('gs.ZREPS'), '<=', filters.maxReps);
+    if (minWeightKg !== undefined)
+        query = query.having((eb) => eb.fn.max('gs.ZWEIGHT'), '>=', minWeightKg);
+    if (maxWeightKg !== undefined)
+        query = query.having((eb) => eb.fn.max('gs.ZWEIGHT'), '<=', maxWeightKg);
+    if (filters.limit !== undefined)
+        query = query.limit(filters.limit);
+    const rows = await query.execute();
+    const normalized = rows.map((row) => ({
+        date: appleSecondsToIso(row.startDate),
+        routine: row.routineNameFromResult ?? row.routineNameFromPlan,
+        sets: Number(row.sets),
+        topReps: row.topReps,
+        topWeight: convertKgToDisplayWeight(row.topWeight, unitPreference),
+        totalReps: Number(row.totalReps),
+        volume: convertKgToDisplayVolume(Number(row.volume), unitPreference) ?? 0,
+        workoutId: row.workoutId,
+    }));
+    return normalized;
+}
+export async function getExerciseHistoryWithSetsRows(db, exerciseId, filters) {
+    const summaryRows = await getExerciseHistoryRows(db, exerciseId, filters);
+    if (summaryRows.length === 0)
+        return [];
+    const workouts = await Promise.all(summaryRows.map((summary) => getWorkoutDetail(db, summary.workoutId)));
+    const workoutsById = new Map(workouts.map((workout) => [workout.id, workout]));
+    return summaryRows.map((summary) => {
+        const workout = workoutsById.get(summary.workoutId);
+        const exercise = workout?.exercises.find((entry) => entry.exerciseId === exerciseId);
+        return {
+            date: summary.date,
+            routine: summary.routine,
+            sets: (exercise?.sets ?? []).map((set) => ({
+                reps: set.reps,
+                setId: set.id,
+                timeSeconds: set.timeSeconds,
+                volume: set.volume,
+                weight: set.weight,
+            })),
+            topReps: summary.topReps,
+            topWeight: summary.topWeight,
+            totalReps: summary.totalReps,
+            volume: summary.volume,
+            workoutId: summary.workoutId,
+        };
+    });
+}
+export async function getExerciseDetail(db, exerciseId, historyLimit = 3) {
+    const row = await db
+        .selectFrom('ZEXERCISEINFORMATION as ei')
+        .leftJoin('ZEQUIPMENT2 as eq', 'eq.Z_PK', 'ei.ZEQUIPMENT')
+        .select([
+        'ei.Z_PK as id',
+        'ei.ZNAME as name',
+        'ei.ZISUSERCREATED as isUserCreated',
+        'ei.ZMUSCLES as primaryMuscles',
+        'ei.ZSECONDARYMUSCLES as secondaryMuscles',
+        'ei.ZDEFAULTPROGRESSMETRIC as defaultProgressMetric',
+        'ei.ZPERCEPTIONSCALE as perceptionScale',
+        'ei.ZTIMERBASED as timerBased',
+        'ei.ZSUPPORTSONEREPMAX as supports1RM',
+        'eq.ZNAME as equipment',
+        'eq.ZID as equipmentId',
+    ])
+        .where('ei.Z_PK', '=', exerciseId)
+        .executeTakeFirst();
+    if (!row)
+        throw new Error(`Exercise not found: ${exerciseId}`);
+    const routineRows = await db
+        .selectFrom('Z_12ROUTINES as j')
+        .innerJoin('ZEXERCISECONFIGURATION as ec', 'ec.Z_PK', 'j.Z_12EXERCISES')
+        .innerJoin('ZROUTINE as r', 'r.Z_PK', 'j.Z_28ROUTINES')
+        .select(['r.ZNAME as routineName'])
+        .where('ec.ZINFORMATION', '=', exerciseId)
+        .where('r.ZSOFTDELETED', 'is not', 1)
+        .groupBy('r.ZNAME')
+        .orderBy('r.ZNAME', 'asc')
+        .execute();
+    const workoutCountRow = await db
+        .selectFrom('ZEXERCISERESULT as er')
+        .innerJoin('ZEXERCISECONFIGURATION as ec', 'ec.Z_PK', 'er.ZCONFIGURATION')
+        .select((eb) => eb.fn.count('er.ZWORKOUT').distinct().as('totalWorkouts'))
+        .where('ec.ZINFORMATION', '=', exerciseId)
+        .executeTakeFirst();
+    const latestHistory = await getExerciseHistoryRows(db, exerciseId, { limit: 1 });
+    return {
+        defaultProgressMetric: row.defaultProgressMetric,
+        equipment: formatEquipmentDisplayName(row.equipment, row.equipmentId),
+        id: row.id,
+        lastHistoryEntry: latestHistory[0] ?? null,
+        name: formatExerciseDisplayName(row.name, asBool(row.isUserCreated)),
+        perceptionScale: row.perceptionScale,
+        primaryMuscles: formatMuscleLabel(row.primaryMuscles),
+        recentRoutines: routineRows.map((routine) => routine.routineName ?? '(unnamed)').slice(0, historyLimit),
+        secondaryMuscles: formatMuscleLabel(row.secondaryMuscles),
+        supports1RM: asBool(row.supports1RM),
+        timerBased: asBool(row.timerBased),
+        totalRoutines: routineRows.length,
+        totalWorkouts: Number(workoutCountRow?.totalWorkouts ?? 0),
+    };
+}
+export async function getLastPerformedExerciseSnapshot(db, exerciseId) {
+    const latestHistory = await getExerciseHistoryRows(db, exerciseId, { limit: 1 });
+    const latest = latestHistory[0];
+    if (!latest)
+        return null;
+    const workout = await getWorkoutDetail(db, latest.workoutId);
+    const exercise = workout.exercises.find((entry) => entry.exerciseId === exerciseId);
+    if (!exercise)
+        return null;
+    return { exercise, workout };
+}

package/dist/lib/repositories/programs.d.ts

@@ -0,0 +1,6 @@
+import { Kysely } from 'kysely';
+import { DatabaseSchema } from '../db.js';
+import { ProgramDetailTree, ProgramSummary } from '../types.js';
+export declare function listPrograms(db: Kysely<DatabaseSchema>): Promise<ProgramSummary[]>;
+export declare function resolveProgramSelector(db: Kysely<DatabaseSchema>, selector: string | undefined, activeOnly: boolean): Promise<number>;
+export declare function getProgramDetail(db: Kysely<DatabaseSchema>, programId: number): Promise<ProgramDetailTree>;

package/dist/lib/repositories/programs.js

@@ -0,0 +1,217 @@
+import { formatExerciseDisplayName } from '../names.js';
+import { normalizeRpe } from '../rpe.js';
+import { appleSecondsToIso } from '../time.js';
+import { convertKgToDisplayWeight, resolveProgramWeightUnit } from '../units.js';
+import { resolveIdOrName } from './selectors.js';
+function asBool(value) {
+    return value === 1;
+}
+export async function listPrograms(db) {
+    const selectedProgram = await db
+        .selectFrom('ZWORKOUTPROGRAMSINFO as info')
+        .innerJoin('ZWORKOUTPLAN as plan', 'plan.ZID', 'info.ZSELECTEDWORKOUTPROGRAMID')
+        .select('plan.Z_PK as id')
+        .where('info.ZSELECTEDWORKOUTPROGRAMID', 'is not', null)
+        .executeTakeFirst();
+    const rows = await db
+        .selectFrom('ZWORKOUTPLAN')
+        .select([
+        'Z_PK as id',
+        'ZNAME as name',
+        'ZISCURRENT as isActive',
+        'ZISTEMPLATE as isTemplate',
+        'ZDATEADDED as dateAdded',
+    ])
+        .where('ZSOFTDELETED', 'is not', 1)
+        .orderBy('ZDATEADDED', 'desc')
+        .execute();
+    return rows.map((row) => ({
+        dateAdded: appleSecondsToIso(row.dateAdded),
+        id: row.id,
+        isActive: selectedProgram ? row.id === selectedProgram.id : asBool(row.isActive),
+        isTemplate: asBool(row.isTemplate),
+        name: row.name ?? '(unnamed)',
+    }));
+}
+export async function resolveProgramSelector(db, selector, activeOnly) {
+    if (activeOnly) {
+        const selectedProgram = await db
+            .selectFrom('ZWORKOUTPROGRAMSINFO as info')
+            .innerJoin('ZWORKOUTPLAN as plan', 'plan.ZID', 'info.ZSELECTEDWORKOUTPROGRAMID')
+            .select('plan.Z_PK as id')
+            .where('info.ZSELECTEDWORKOUTPROGRAMID', 'is not', null)
+            .executeTakeFirst();
+        if (selectedProgram)
+            return selectedProgram.id;
+        const fallbackRows = await db
+            .selectFrom('ZWORKOUTPLAN')
+            .select(['Z_PK as id'])
+            .where('ZISCURRENT', '=', 1)
+            .execute();
+        if (fallbackRows.length !== 1) {
+            throw new Error(`Expected exactly one active program. Found ${fallbackRows.length} via ZISCURRENT and no selected program in ZWORKOUTPROGRAMSINFO.`);
+        }
+        return fallbackRows[0].id;
+    }
+    if (!selector)
+        throw new Error('Program selector is required unless --active/--current is set.');
+    const programId = await resolveIdOrName(db, 'ZWORKOUTPLAN', selector);
+    const nonDeleted = await db
+        .selectFrom('ZWORKOUTPLAN')
+        .select('Z_PK as id')
+        .where('Z_PK', '=', programId)
+        .where('ZSOFTDELETED', 'is not', 1)
+        .executeTakeFirst();
+    if (!nonDeleted)
+        throw new Error(`Program ${programId} is soft-deleted and hidden from CLI output.`);
+    return programId;
+}
+export async function getProgramDetail(db, programId) {
+    const unitPreference = await resolveProgramWeightUnit(db, programId);
+    const selectedProgram = await db
+        .selectFrom('ZWORKOUTPROGRAMSINFO as info')
+        .innerJoin('ZWORKOUTPLAN as plan', 'plan.ZID', 'info.ZSELECTEDWORKOUTPROGRAMID')
+        .select('plan.Z_PK as id')
+        .where('info.ZSELECTEDWORKOUTPROGRAMID', 'is not', null)
+        .executeTakeFirst();
+    const programRow = await db
+        .selectFrom('ZWORKOUTPLAN')
+        .select([
+        'Z_PK as id',
+        'ZNAME as name',
+        'ZISCURRENT as isActive',
+        'ZISTEMPLATE as isTemplate',
+        'ZDATEADDED as dateAdded',
+    ])
+        .where('Z_PK', '=', programId)
+        .where('ZSOFTDELETED', 'is not', 1)
+        .executeTakeFirst();
+    if (!programRow)
+        throw new Error(`Program not found: ${programId}`);
+    const weeks = await db
+        .selectFrom('ZPERIOD')
+        .select(['Z_PK as id'])
+        .where('ZWORKOUTPLAN', '=', programId)
+        .orderBy('Z_FOK_WORKOUTPLAN', 'asc')
+        .orderBy('Z_PK', 'asc')
+        .execute();
+    const routines = await db
+        .selectFrom('ZROUTINE as r')
+        .leftJoin('ZPERIOD as p', 'p.Z_PK', 'r.ZPERIOD')
+        .select(['r.Z_PK as id', 'r.ZNAME as name', 'r.ZPERIOD as weekId'])
+        .where((eb) => eb.or([eb('p.ZWORKOUTPLAN', '=', programId), eb('r.ZWORKOUTPLAN', '=', programId)]))
+        .where('r.ZSOFTDELETED', 'is not', 1)
+        .orderBy('r.Z_FOK_PERIOD', 'asc')
+        .orderBy('r.Z_PK', 'asc')
+        .execute();
+    const exercises = await db
+        .selectFrom('ZROUTINE as r')
+        .leftJoin('ZPERIOD as p', 'p.Z_PK', 'r.ZPERIOD')
+        .leftJoin('Z_12ROUTINES as j', 'j.Z_28ROUTINES', 'r.Z_PK')
+        .leftJoin('ZEXERCISECONFIGURATION as ec', 'ec.Z_PK', 'j.Z_12EXERCISES')
+        .leftJoin('ZEXERCISEINFORMATION as ei', 'ei.Z_PK', 'ec.ZINFORMATION')
+        .select([
+        'r.Z_PK as routineId',
+        'ec.Z_PK as exerciseConfigId',
+        'j.Z_FOK_12EXERCISES as routineExerciseOrder',
+        'ec.ZSETS as plannedSets',
+        'ec.ZREPS as plannedReps',
+        'ec.ZWEIGHT as plannedWeight',
+        'ec.ZTIME as plannedTimeSeconds',
+        'ei.Z_PK as exerciseId',
+        'ei.ZISUSERCREATED as isUserCreated',
+        'ei.ZNAME as exerciseName',
+    ])
+        .where((eb) => eb.or([eb('p.ZWORKOUTPLAN', '=', programId), eb('r.ZWORKOUTPLAN', '=', programId)]))
+        .where('r.ZSOFTDELETED', 'is not', 1)
+        .where('ec.Z_PK', 'is not', null)
+        .orderBy('r.Z_PK', 'asc')
+        .orderBy('j.Z_FOK_12EXERCISES', 'asc')
+        .orderBy('ec.Z_PK', 'asc')
+        .execute();
+    const exerciseConfigIds = exercises
+        .map((exercise) => exercise.exerciseConfigId)
+        .filter((value) => value !== null);
+    const setRows = exerciseConfigIds.length === 0
+        ? []
+        : await db
+            .selectFrom('ZSETCONFIGURATION')
+            .select([
+            'Z_PK as id',
+            'ZEXERCISECONFIGURATION as exerciseConfigId',
+            'ZREPS as reps',
+            'ZRPE as rpe',
+            'ZWEIGHT as weight',
+            'ZTIME as timeSeconds',
+        ])
+            .where('ZEXERCISECONFIGURATION', 'in', exerciseConfigIds)
+            .orderBy('ZSETINDEX', 'asc')
+            .execute();
+    const setsByExerciseConfig = new Map();
+    for (const row of setRows) {
+        if (row.exerciseConfigId === null)
+            continue;
+        const current = setsByExerciseConfig.get(row.exerciseConfigId) ?? [];
+        current.push({
+            id: row.id,
+            reps: row.reps,
+            rpe: normalizeRpe(row.rpe),
+            timeSeconds: row.timeSeconds,
+            weight: convertKgToDisplayWeight(row.weight, unitPreference),
+        });
+        setsByExerciseConfig.set(row.exerciseConfigId, current);
+    }
+    const exercisesByRoutine = new Map();
+    for (const row of exercises) {
+        if (row.exerciseConfigId === null)
+            continue;
+        const current = exercisesByRoutine.get(row.routineId) ?? [];
+        const explicitSets = setsByExerciseConfig.get(row.exerciseConfigId) ?? [];
+        const fallbackSet = explicitSets.length > 0
+            ? explicitSets
+            : Array.from({ length: Math.max(row.plannedSets ?? 1, 1) }, () => ({
+                id: null,
+                reps: row.plannedReps,
+                rpe: null,
+                timeSeconds: row.plannedTimeSeconds,
+                weight: convertKgToDisplayWeight(row.plannedWeight, unitPreference),
+            }));
+        current.push({
+            exerciseConfigId: row.exerciseConfigId,
+            id: row.exerciseId,
+            name: formatExerciseDisplayName(row.exerciseName, asBool(row.isUserCreated)),
+            plannedReps: row.plannedReps,
+            plannedSets: row.plannedSets,
+            plannedTimeSeconds: row.plannedTimeSeconds,
+            plannedWeight: convertKgToDisplayWeight(row.plannedWeight, unitPreference),
+            sets: fallbackSet,
+        });
+        exercisesByRoutine.set(row.routineId, current);
+    }
+    const routinesByWeek = new Map();
+    for (const routine of routines) {
+        if (routine.weekId === null)
+            continue;
+        const current = routinesByWeek.get(routine.weekId) ?? [];
+        current.push({
+            exercises: exercisesByRoutine.get(routine.id) ?? [],
+            id: routine.id,
+            name: routine.name,
+        });
+        routinesByWeek.set(routine.weekId, current);
+    }
+    const weekTree = weeks.map((week) => ({
+        id: week.id,
+        routines: routinesByWeek.get(week.id) ?? [],
+    }));
+    return {
+        program: {
+            dateAdded: appleSecondsToIso(programRow.dateAdded),
+            id: programRow.id,
+            isActive: selectedProgram ? programRow.id === selectedProgram.id : asBool(programRow.isActive),
+            isTemplate: asBool(programRow.isTemplate),
+            name: programRow.name ?? '(unnamed)',
+        },
+        weeks: weekTree,
+    };
+}

package/dist/lib/repositories/selectors.d.ts

@@ -0,0 +1,3 @@
+import { Kysely } from 'kysely';
+import { DatabaseSchema } from '../db.js';
+export declare function resolveIdOrName(db: Kysely<DatabaseSchema>, table: 'ZEXERCISEINFORMATION' | 'ZROUTINE' | 'ZWORKOUTPLAN', selector: string): Promise<number>;

package/dist/lib/repositories/selectors.js

@@ -0,0 +1,35 @@
+import { sql } from 'kysely';
+function isNumeric(value) {
+    return /^\d+$/.test(value);
+}
+function renderCandidateList(candidates) {
+    return candidates.map((candidate) => `${candidate.id}:${candidate.name}`).join(', ');
+}
+const asIdName = (rows) => rows.map((row) => ({ id: row.id, name: row.name ?? '(unnamed)' }));
+export async function resolveIdOrName(db, table, selector) {
+    if (isNumeric(selector))
+        return Number(selector);
+    const exact = await db
+        .selectFrom(table)
+        .select(['Z_PK as id', 'ZNAME as name'])
+        .where(sql `lower(ZNAME) = ${selector.toLowerCase()}`)
+        .execute();
+    if (exact.length === 1)
+        return exact[0].id;
+    if (exact.length > 1) {
+        const candidates = asIdName(exact);
+        throw new Error(`Selector "${selector}" is ambiguous: ${renderCandidateList(candidates)}`);
+    }
+    const partial = await db
+        .selectFrom(table)
+        .select(['Z_PK as id', 'ZNAME as name'])
+        .where(sql `lower(ZNAME) like ${`%${selector.toLowerCase()}%`}`)
+        .execute();
+    if (partial.length === 1)
+        return partial[0].id;
+    if (partial.length > 1) {
+        const candidates = asIdName(partial);
+        throw new Error(`Selector "${selector}" is ambiguous: ${renderCandidateList(candidates)}`);
+    }
+    throw new Error(`No records found for selector: ${selector}`);
+}

package/dist/lib/repositories/workouts.d.ts

@@ -0,0 +1,13 @@
+import { Kysely } from 'kysely';
+import { DatabaseSchema } from '../db.js';
+import { WorkoutDetail, WorkoutSummary } from '../types.js';
+export type WorkoutFilters = {
+    from?: string;
+    limit?: number;
+    on?: string;
+    program?: string;
+    routine?: string;
+    to?: string;
+};
+export declare function listWorkouts(db: Kysely<DatabaseSchema>, filters: WorkoutFilters): Promise<WorkoutSummary[]>;
+export declare function getWorkoutDetail(db: Kysely<DatabaseSchema>, workoutId: number): Promise<WorkoutDetail>;