@nickchristensen/cliftin 1.0.2

package/dist/commands/workouts/show.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class WorkoutsShow extends Command {
+    static args: {
+        workoutId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    run(): Promise<unknown | void>;
+}

package/dist/commands/workouts/show.js

@@ -0,0 +1,72 @@
+import { Args, Command } from '@oclif/core';
+import { format, isValid, parseISO } from 'date-fns';
+import { closeDb, openDb } from '../../lib/db.js';
+import { serializeWorkoutDetailWithWeightUnits } from '../../lib/json-weight.js';
+import { renderTable } from '../../lib/output.js';
+import { getWorkoutDetail } from '../../lib/repositories/workouts.js';
+import { resolveGlobalWeightUnit, weightUnitLabel } from '../../lib/units.js';
+function formatDurationMinutes(durationSeconds) {
+    if (durationSeconds === null)
+        return 'n/a';
+    return `${Math.round(durationSeconds / 60)} minutes`;
+}
+function formatWorkoutDate(dateIso) {
+    if (!dateIso)
+        return 'n/a';
+    const parsed = parseISO(dateIso);
+    if (!isValid(parsed))
+        return dateIso;
+    return format(parsed, 'yyyy-MM-dd HH:mm');
+}
+export default class WorkoutsShow extends Command {
+    static args = {
+        workoutId: Args.string({ description: 'workout id', required: true }),
+    };
+    static description = 'Show one workout with exercises and sets';
+    static enableJsonFlag = true;
+    async run() {
+        const { args } = await this.parse(WorkoutsShow);
+        const context = openDb();
+        try {
+            if (!/^\d+$/.test(args.workoutId)) {
+                throw new Error('Workout detail requires numeric workout id.');
+            }
+            const detail = await getWorkoutDetail(context.db, Number(args.workoutId));
+            const unitPreference = await resolveGlobalWeightUnit(context.db);
+            const unitLabel = weightUnitLabel(unitPreference);
+            if (this.jsonEnabled()) {
+                const serialized = serializeWorkoutDetailWithWeightUnits(detail, unitPreference);
+                const durationSeconds = serialized.duration ?? null;
+                return {
+                    ...serialized,
+                    duration: {
+                        unit: 'seconds',
+                        value: durationSeconds,
+                    },
+                };
+            }
+            this.log(`[${detail.id}] ${detail.routine ?? 'Workout'}`);
+            this.log(`Program: ${detail.program ?? 'n/a'}`);
+            this.log(`Date: ${formatWorkoutDate(detail.date)}`);
+            this.log(`Duration: ${formatDurationMinutes(detail.duration)}`);
+            for (const exercise of detail.exercises) {
+                this.log('');
+                this.log(`[${exercise.exerciseId ?? exercise.exerciseResultId}] ${exercise.name ?? '(unnamed)'}`);
+                this.log(renderTable(exercise.sets.map((set) => ({
+                    id: set.id,
+                    reps: set.reps,
+                    rpe: set.rpe,
+                    timeSeconds: set.timeSeconds,
+                    volume: set.volume,
+                    weight: set.weight === null ? null : `${set.weight} ${unitLabel}`,
+                })))
+                    .split('\n')
+                    .map((line) => `${line}`)
+                    .join('\n'));
+            }
+        }
+        finally {
+            await closeDb(context);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/lib/config.d.ts

@@ -0,0 +1 @@
+export declare function getDbPath(): string;

package/dist/lib/config.js

@@ -0,0 +1,24 @@
+import dotenv from 'dotenv';
+import { accessSync, constants } from 'node:fs';
+import { resolve } from 'node:path';
+let loaded = false;
+function loadEnv() {
+    if (loaded)
+        return;
+    dotenv.config({ path: resolve(process.cwd(), '.env.local'), quiet: true });
+    loaded = true;
+}
+export function getDbPath() {
+    loadEnv();
+    const path = process.env.LIFTIN_DB_PATH;
+    if (!path) {
+        throw new Error('Missing LIFTIN_DB_PATH. Add it to .env.local, for example: LIFTIN_DB_PATH=/Users/nick/code/cliftin/data/BelloDataModel.sqlite');
+    }
+    try {
+        accessSync(path, constants.R_OK);
+    }
+    catch {
+        throw new Error(`Database file is not readable at LIFTIN_DB_PATH=${path}`);
+    }
+    return path;
+}

package/dist/lib/db.d.ts

@@ -0,0 +1,104 @@
+import Database from 'better-sqlite3';
+import { Kysely } from 'kysely';
+export interface DatabaseSchema {
+    Z_12ROUTINES: {
+        Z_12EXERCISES: number;
+        Z_28ROUTINES: number;
+        Z_FOK_12EXERCISES: null | number;
+    };
+    ZEQUIPMENT2: {
+        Z_PK: number;
+        ZID: null | string;
+        ZMEASURMENTUNIT: null | string;
+        ZNAME: null | string;
+    };
+    ZEXERCISECONFIGURATION: {
+        Z_PK: number;
+        ZINFORMATION: null | number;
+        ZREPS: null | number;
+        ZSETS: null | number;
+        ZTIME: null | number;
+        ZWEIGHT: null | number;
+    };
+    ZEXERCISEINFORMATION: {
+        Z_PK: number;
+        ZDEFAULTPROGRESSMETRIC: null | string;
+        ZEQUIPMENT: null | number;
+        ZISUSERCREATED: null | number;
+        ZMUSCLES: null | string;
+        ZNAME: null | string;
+        ZPERCEPTIONSCALE: null | string;
+        ZSECONDARYMUSCLES: null | string;
+        ZSOFTDELETED: null | number;
+        ZSUPPORTSONEREPMAX: null | number;
+        ZTIMERBASED: null | number;
+    };
+    ZEXERCISERESULT: {
+        Z_FOK_WORKOUT: null | number;
+        Z_PK: number;
+        ZCONFIGURATION: null | number;
+        ZWORKOUT: null | number;
+    };
+    ZGYMSETRESULT: {
+        Z_FOK_EXERCISE: null | number;
+        Z_PK: number;
+        ZEXERCISE: null | number;
+        ZREPS: null | number;
+        ZRPE: null | number;
+        ZTIME: null | number;
+        ZVOLUME: null | number;
+        ZWEIGHT: null | number;
+    };
+    ZPERIOD: {
+        Z_FOK_WORKOUTPLAN: null | number;
+        Z_PK: number;
+        ZWORKOUTPLAN: null | number;
+    };
+    ZROUTINE: {
+        Z_FOK_PERIOD: null | number;
+        Z_PK: number;
+        ZNAME: null | string;
+        ZPERIOD: null | number;
+        ZSOFTDELETED: null | number;
+        ZWORKOUTPLAN: null | number;
+    };
+    ZSETCONFIGURATION: {
+        Z_PK: number;
+        ZEXERCISECONFIGURATION: null | number;
+        ZREPS: null | number;
+        ZRPE: null | number;
+        ZSETINDEX: null | number;
+        ZTIME: null | number;
+        ZWEIGHT: null | number;
+    };
+    ZSETTINGS: {
+        ZMEASURMENTUNIT: null | string;
+    };
+    ZWORKOUTPLAN: {
+        Z_PK: number;
+        ZDATEADDED: null | number;
+        ZID: Buffer | null;
+        ZISCURRENT: null | number;
+        ZISTEMPLATE: null | number;
+        ZNAME: null | string;
+        ZSOFTDELETED: null | number;
+    };
+    ZWORKOUTPROGRAMSINFO: {
+        Z_PK: number;
+        ZSECONDARYWORKOUTPROGRAMID: Buffer | null;
+        ZSELECTEDWORKOUTPROGRAMID: Buffer | null;
+    };
+    ZWORKOUTRESULT: {
+        Z_PK: number;
+        ZDURATION: null | number;
+        ZROUTINE: null | number;
+        ZROUTINENAME: null | string;
+        ZSTARTDATE: null | number;
+    };
+}
+export type DbContext = {
+    db: Kysely<DatabaseSchema>;
+    sqlite: Database.Database;
+};
+export declare function openDb(): DbContext;
+export declare function closeDb(context: DbContext): Promise<void>;

package/dist/lib/db.js

@@ -0,0 +1,15 @@
+import Database from 'better-sqlite3';
+import { Kysely, SqliteDialect } from 'kysely';
+import { getDbPath } from './config.js';
+export function openDb() {
+    const path = getDbPath();
+    const sqlite = new Database(path, { fileMustExist: true, readonly: true });
+    const db = new Kysely({
+        dialect: new SqliteDialect({ database: sqlite }),
+    });
+    return { db, sqlite };
+}
+export async function closeDb(context) {
+    await context.db.destroy();
+    context.sqlite.close();
+}

package/dist/lib/json-error.d.ts

@@ -0,0 +1,5 @@
+export declare function toJsonErrorPayload(error: unknown): {
+    error: {
+        message: string;
+    };
+};

package/dist/lib/json-error.js

@@ -0,0 +1,6 @@
+export function toJsonErrorPayload(error) {
+    if (error instanceof Error) {
+        return { error: { message: error.message } };
+    }
+    return { error: { message: String(error) } };
+}

package/dist/lib/json-weight.d.ts

@@ -0,0 +1,7 @@
+import { ExerciseHistoryRow, ProgramDetailTree, WorkoutDetail } from './types.js';
+import { UnitPreference, withWeightUnit } from './units.js';
+export declare function serializeExerciseHistoryRowsWithWeightUnits(rows: ExerciseHistoryRow[], unitPreference: UnitPreference): Array<Omit<ExerciseHistoryRow, 'topWeight'> & {
+    topWeight: ReturnType<typeof withWeightUnit>;
+}>;
+export declare function serializeProgramDetailWithWeightUnits(detail: ProgramDetailTree, unitPreference: UnitPreference): unknown;
+export declare function serializeWorkoutDetailWithWeightUnits(detail: WorkoutDetail, unitPreference: UnitPreference): unknown;

package/dist/lib/json-weight.js

@@ -0,0 +1,42 @@
+import { withWeightUnit } from './units.js';
+export function serializeExerciseHistoryRowsWithWeightUnits(rows, unitPreference) {
+    return rows.map((row) => ({
+        ...row,
+        topWeight: withWeightUnit(row.topWeight, unitPreference),
+    }));
+}
+export function serializeProgramDetailWithWeightUnits(detail, unitPreference) {
+    return {
+        ...detail,
+        weeks: detail.weeks.map((week) => ({
+            ...week,
+            routines: week.routines.map((routine) => ({
+                ...routine,
+                exercises: routine.exercises.map((exercise) => ({
+                    ...exercise,
+                    plannedWeight: withWeightUnit(exercise.plannedWeight, unitPreference),
+                    sets: exercise.sets.map((set) => ({
+                        ...set,
+                        weight: withWeightUnit(set.weight, unitPreference),
+                    })),
+                })),
+            })),
+        })),
+    };
+}
+export function serializeWorkoutDetailWithWeightUnits(detail, unitPreference) {
+    return {
+        ...detail,
+        exercises: detail.exercises.map((exercise) => ({
+            ...exercise,
+            sets: exercise.sets.map((set) => ({
+                reps: set.reps,
+                rpe: set.rpe,
+                setId: set.id,
+                timeSeconds: set.timeSeconds,
+                volume: set.volume,
+                weight: withWeightUnit(set.weight, unitPreference),
+            })),
+        })),
+    };
+}

package/dist/lib/names.d.ts

@@ -0,0 +1,5 @@
+export declare function formatIdentifierTitleCase(value: string): string;
+export declare function formatMuscleLabel(value: null | string): null | string;
+export declare function formatEquipmentDisplayName(zName: null | string, zId: null | string): null | string;
+export declare function formatExerciseName(name: string): string;
+export declare function formatExerciseDisplayName(name: null | string, isUserCreated: boolean): string;

package/dist/lib/names.js

@@ -0,0 +1,70 @@
+const PARENTHETICAL_SUFFIXES = new Set(['assisted', 'weighted']);
+const UUID_LIKE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function toTitleWord(word) {
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+}
+export function formatIdentifierTitleCase(value) {
+    const spaced = value
+        .replaceAll(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replaceAll(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .replaceAll('_', ' ')
+        .replaceAll('-', ' ')
+        .replaceAll(/\s+/g, ' ')
+        .trim();
+    if (!spaced)
+        return '';
+    return spaced
+        .split(' ')
+        .map((word) => toTitleWord(word))
+        .join(' ');
+}
+export function formatMuscleLabel(value) {
+    if (!value)
+        return null;
+    const formatted = value
+        .split(/([^a-zA-Z0-9]+)/)
+        .map((part) => (/^[a-zA-Z0-9]+$/.test(part) ? formatIdentifierTitleCase(part) : part))
+        .join('');
+    return formatted.replaceAll(/\s*,\s*/g, ', ');
+}
+function isLocalizationKey(value) {
+    const normalized = value.trim().toLowerCase();
+    return normalized.includes(':') || normalized.endsWith('_name');
+}
+function isUuidLike(value) {
+    return UUID_LIKE.test(value.trim());
+}
+export function formatEquipmentDisplayName(zName, zId) {
+    const name = zName?.trim() ?? '';
+    const id = zId?.trim() ?? '';
+    if (name && !isLocalizationKey(name)) {
+        return formatIdentifierTitleCase(name);
+    }
+    if (id && !isUuidLike(id)) {
+        return formatIdentifierTitleCase(id);
+    }
+    if (name)
+        return formatIdentifierTitleCase(name);
+    if (id)
+        return id;
+    return null;
+}
+export function formatExerciseName(name) {
+    const words = name.split('_');
+    const lastWord = words.at(-1)?.toLowerCase();
+    const shouldWrapLast = lastWord ? PARENTHETICAL_SUFFIXES.has(lastWord) : false;
+    const formattedWords = words.map((word, index) => {
+        const formatted = formatIdentifierTitleCase(word).replaceAll(' ', '-');
+        if (shouldWrapLast && index === words.length - 1)
+            return `(${formatted})`;
+        return formatted;
+    });
+    return formattedWords.join(' ');
+}
+export function formatExerciseDisplayName(name, isUserCreated) {
+    if (!name)
+        return '(unnamed)';
+    if (isUserCreated)
+        return name;
+    return formatExerciseName(name);
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,7 @@
+type TableFormatterContext = {
+    style: (...args: string[]) => string;
+};
+type TableFormatter = (this: TableFormatterContext, cellValue: unknown) => string;
+export declare const createValueFormatter: (dateFormat: string) => TableFormatter;
+export declare function renderTable(rows: Array<Record<string, unknown>>): string;
+export {};

package/dist/lib/output.js

@@ -0,0 +1,73 @@
+import { format, isValid, parseISO } from 'date-fns';
+import Table from 'tty-table';
+function formatDateString(value, dateFormat) {
+    const parsed = parseISO(value);
+    if (!isValid(parsed))
+        return null;
+    return format(parsed, dateFormat);
+}
+function valueFormatter(cellValue, dateFormat) {
+    if (cellValue === null || cellValue === undefined)
+        return '';
+    if (typeof cellValue === 'string') {
+        const formattedDate = formatDateString(cellValue, dateFormat);
+        if (formattedDate)
+            return this.style(String(formattedDate), 'magenta');
+        return cellValue;
+    }
+    if (typeof cellValue === 'number')
+        return this.style(String(cellValue), 'blue');
+    if (typeof cellValue === 'boolean') {
+        return cellValue ? this.style('✔︎', 'green', 'bold') : this.style('×', 'red', 'bold');
+    }
+    return this.style(JSON.stringify(cellValue), 'yellow');
+}
+export const createValueFormatter = (dateFormat) => function (cellValue) {
+    return valueFormatter.call(this, cellValue, dateFormat);
+};
+function toText(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    return String(value);
+}
+function visibleWidth(value) {
+    const text = toText(value);
+    return Math.max(...text
+        .split('\n')
+        .map((line) => line.length));
+}
+export function renderTable(rows) {
+    if (rows.length === 0)
+        return '(no rows)';
+    const keys = Object.keys(rows[0]);
+    const orderedKeys = keys.includes('id')
+        ? ['id', ...keys.filter((key) => key !== 'id')]
+        : keys;
+    const widths = new Map();
+    const formatter = createValueFormatter('yyyy-MM-dd HH:mm');
+    const normalizedRows = rows.map((row) => {
+        const output = {};
+        for (const key of orderedKeys) {
+            const raw = row[key];
+            output[key] = raw;
+            widths.set(key, Math.max(widths.get(key) ?? key.length, visibleWidth(raw)));
+        }
+        return output;
+    });
+    const columns = orderedKeys.map((key) => ({
+        alias: key,
+        align: 'left',
+        formatter,
+        headerAlign: 'left',
+        value: key,
+        width: (widths.get(key) ?? key.length) + 2,
+    }));
+    // eslint-disable-next-line new-cap
+    return Table(columns, normalizedRows, {
+        borderStyle: 'solid',
+        compact: true,
+        width: 'auto',
+    }).render();
+}

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

@@ -0,0 +1,30 @@
+import { Kysely } from 'kysely';
+import { DatabaseSchema } from '../db.js';
+import { ExerciseDetail, ExerciseHistoryRow, ExerciseHistoryWithSetsRow, ExerciseSummary, WorkoutDetail, WorkoutExerciseDetail } from '../types.js';
+export type ExerciseListFilters = {
+    equipment?: string;
+    muscle?: string;
+    name?: string;
+    sort?: 'lastPerformed' | 'name' | 'timesPerformed';
+};
+export type ExerciseHistoryFilters = {
+    from?: string;
+    limit?: number;
+    maxReps?: number;
+    maxWeight?: number;
+    minReps?: number;
+    minWeight?: number;
+    program?: string;
+    routine?: string;
+    to?: string;
+};
+export type ExerciseLastPerformedSnapshot = {
+    exercise: WorkoutExerciseDetail;
+    workout: WorkoutDetail;
+};
+export declare function resolveExerciseSelector(db: Kysely<DatabaseSchema>, selector: string): Promise<number>;
+export declare function listExercises(db: Kysely<DatabaseSchema>, filters: ExerciseListFilters): Promise<ExerciseSummary[]>;
+export declare function getExerciseHistoryRows(db: Kysely<DatabaseSchema>, exerciseId: number, filters: ExerciseHistoryFilters): Promise<ExerciseHistoryRow[]>;
+export declare function getExerciseHistoryWithSetsRows(db: Kysely<DatabaseSchema>, exerciseId: number, filters: ExerciseHistoryFilters): Promise<ExerciseHistoryWithSetsRow[]>;
+export declare function getExerciseDetail(db: Kysely<DatabaseSchema>, exerciseId: number, historyLimit?: number): Promise<ExerciseDetail>;
+export declare function getLastPerformedExerciseSnapshot(db: Kysely<DatabaseSchema>, exerciseId: number): Promise<ExerciseLastPerformedSnapshot | null>;