@nickchristensen/cliftin 1.0.2

package/README.md

@@ -0,0 +1,206 @@
+cliftin
+=================
+
+CLIftin: A read-only CLI for Liftin'
+
+
+[![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
+[![Version](https://img.shields.io/npm/v/cliftin.svg)](https://npmjs.org/package/cliftin)
+[![Downloads/week](https://img.shields.io/npm/dw/cliftin.svg)](https://npmjs.org/package/cliftin)
+
+
+<!-- toc -->
+* [Usage](#usage)
+* [Commands](#commands)
+<!-- tocstop -->
+# Usage
+<!-- usage -->
+```sh-session
+$ npm install -g @nickchristensen/cliftin
+$ cliftin COMMAND
+running command...
+$ cliftin (--version)
+@nickchristensen/cliftin/1.0.2 darwin-arm64 node-v25.6.0
+$ cliftin --help [COMMAND]
+USAGE
+  $ cliftin COMMAND
+...
+```
+<!-- usagestop -->
+# Commands
+<!-- commands -->
+* [`cliftin exercises list`](#cliftin-exercises-list)
+* [`cliftin exercises show SELECTOR`](#cliftin-exercises-show-selector)
+* [`cliftin help [COMMAND]`](#cliftin-help-command)
+* [`cliftin programs list`](#cliftin-programs-list)
+* [`cliftin programs show [SELECTOR]`](#cliftin-programs-show-selector)
+* [`cliftin workouts list`](#cliftin-workouts-list)
+* [`cliftin workouts show WORKOUTID`](#cliftin-workouts-show-workoutid)
+
+## `cliftin exercises list`
+
+List exercises
+
+```
+USAGE
+  $ cliftin exercises list [--json] [--equipment <value>] [--muscle <value>] [--name <value>] [--sort
+    name|lastPerformed|timesPerformed]
+
+FLAGS
+  --equipment=<value>  Filter by equipment name
+  --muscle=<value>     Filter by muscle group
+  --name=<value>       Filter by name contains
+  --sort=<option>      [default: name]
+                       <options: name|lastPerformed|timesPerformed>
+
+GLOBAL FLAGS
+  --json  Format output as json.
+
+DESCRIPTION
+  List exercises
+```
+
+_See code: [src/commands/exercises/list.ts](https://github.com/nickchristensen/cliftin/blob/v1.0.2/src/commands/exercises/list.ts)_
+
+## `cliftin exercises show SELECTOR`
+
+Show one exercise detail and history
+
+```
+USAGE
+  $ cliftin exercises show SELECTOR [--json] [--all | --limit <value>] [--from <value>] [--max-reps <value>]
+    [--max-weight <value>] [--min-reps <value>] [--min-weight <value>] [--program <value>] [--routine <value>] [--to
+    <value>]
+
+ARGUMENTS
+  SELECTOR  exercise id or name
+
+FLAGS
+  --all                 Return all matching history rows (no limit)
+  --from=<value>        History start date YYYY-MM-DD
+  --limit=<value>       History row limit (default: 100)
+  --max-reps=<value>    History max top reps
+  --max-weight=<value>  History max top weight
+  --min-reps=<value>    History min top reps
+  --min-weight=<value>  History min top weight
+  --program=<value>     History filter by program id or name
+  --routine=<value>     History filter by routine id or name
+  --to=<value>          History end date YYYY-MM-DD
+
+GLOBAL FLAGS
+  --json  Format output as json.
+
+DESCRIPTION
+  Show one exercise detail and history
+```
+
+_See code: [src/commands/exercises/show.ts](https://github.com/nickchristensen/cliftin/blob/v1.0.2/src/commands/exercises/show.ts)_
+
+## `cliftin help [COMMAND]`
+
+Display help for cliftin.
+
+```
+USAGE
+  $ cliftin help [COMMAND...] [-n]
+
+ARGUMENTS
+  [COMMAND...]  Command to show help for.
+
+FLAGS
+  -n, --nested-commands  Include all nested commands in the output.
+
+DESCRIPTION
+  Display help for cliftin.
+```
+
+_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.2.37/src/commands/help.ts)_
+
+## `cliftin programs list`
+
+List programs
+
+```
+USAGE
+  $ cliftin programs list [--json]
+
+GLOBAL FLAGS
+  --json  Format output as json.
+
+DESCRIPTION
+  List programs
+```
+
+_See code: [src/commands/programs/list.ts](https://github.com/nickchristensen/cliftin/blob/v1.0.2/src/commands/programs/list.ts)_
+
+## `cliftin programs show [SELECTOR]`
+
+Show one program hierarchy
+
+```
+USAGE
+  $ cliftin programs show [SELECTOR] [--json] [--active] [--current]
+
+ARGUMENTS
+  [SELECTOR]  program id or name
+
+FLAGS
+  --active   Show active program detail
+  --current  Alias for --active
+
+GLOBAL FLAGS
+  --json  Format output as json.
+
+DESCRIPTION
+  Show one program hierarchy
+```
+
+_See code: [src/commands/programs/show.ts](https://github.com/nickchristensen/cliftin/blob/v1.0.2/src/commands/programs/show.ts)_
+
+## `cliftin workouts list`
+
+List workouts
+
+```
+USAGE
+  $ cliftin workouts list [--json] [--limit <value> | --all] [--on <value> | --from <value> | --to <value>]
+    [--program <value>] [--routine <value>]
+
+FLAGS
+  --all              Return all matching workouts (no limit)
+  --from=<value>     Start date YYYY-MM-DD
+  --limit=<value>    Limit workouts (default: 25)
+  --on=<value>       Single date YYYY-MM-DD
+  --program=<value>  Filter by program id or name
+  --routine=<value>  Filter by routine id or name
+  --to=<value>       End date YYYY-MM-DD
+
+GLOBAL FLAGS
+  --json  Format output as json.
+
+DESCRIPTION
+  List workouts
+```
+
+_See code: [src/commands/workouts/list.ts](https://github.com/nickchristensen/cliftin/blob/v1.0.2/src/commands/workouts/list.ts)_
+
+## `cliftin workouts show WORKOUTID`
+
+Show one workout with exercises and sets
+
+```
+USAGE
+  $ cliftin workouts show WORKOUTID [--json]
+
+ARGUMENTS
+  WORKOUTID  workout id
+
+GLOBAL FLAGS
+  --json  Format output as json.
+
+DESCRIPTION
+  Show one workout with exercises and sets
+```
+
+_See code: [src/commands/workouts/show.ts](https://github.com/nickchristensen/cliftin/blob/v1.0.2/src/commands/workouts/show.ts)_
+<!-- commandsstop -->

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
+
+import {execute} from '@oclif/core'
+
+await execute({development: true, dir: import.meta.url})

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import {execute} from '@oclif/core'
+
+await execute({dir: import.meta.url})

package/dist/commands/exercises/list.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class Exercises extends Command {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static sortOptions: readonly ["name", "lastPerformed", "timesPerformed"];
+    static flags: {
+        equipment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        muscle: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sort: import("@oclif/core/interfaces").OptionFlag<"name" | "lastPerformed" | "timesPerformed", import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown | void>;
+}

package/dist/commands/exercises/list.js

@@ -0,0 +1,54 @@
+import { Command, Flags } from '@oclif/core';
+import { closeDb, openDb } from '../../lib/db.js';
+import { renderTable } from '../../lib/output.js';
+import { listExercises } from '../../lib/repositories/exercises.js';
+function formatMusclesCell(primaryMuscles, secondaryMuscles) {
+    const primary = primaryMuscles ?? 'n/a';
+    if (!secondaryMuscles)
+        return primary;
+    const secondaryLines = secondaryMuscles
+        .split(',')
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .join('\n');
+    return `${primary}\n${secondaryLines}`;
+}
+export default class Exercises extends Command {
+    static description = 'List exercises';
+    static enableJsonFlag = true;
+    static sortOptions = ['name', 'lastPerformed', 'timesPerformed'];
+    static flags = {
+        equipment: Flags.string({ description: 'Filter by equipment name' }),
+        muscle: Flags.string({ description: 'Filter by muscle group' }),
+        name: Flags.string({ description: 'Filter by name contains' }),
+        sort: Flags.option({
+            default: 'name',
+            options: Exercises.sortOptions,
+        })(),
+    };
+    async run() {
+        const { flags } = await this.parse(Exercises);
+        const context = openDb();
+        try {
+            const exercises = await listExercises(context.db, {
+                equipment: flags.equipment,
+                muscle: flags.muscle,
+                name: flags.name,
+                sort: flags.sort,
+            });
+            if (this.jsonEnabled())
+                return exercises;
+            this.log(renderTable(exercises.map((exercise) => ({
+                equipment: exercise.equipment,
+                id: exercise.id,
+                lastPerformed: exercise.lastPerformed,
+                muscles: formatMusclesCell(exercise.primaryMuscles, exercise.secondaryMuscles),
+                name: exercise.name,
+                timesPerformed: exercise.timesPerformed,
+            }))));
+        }
+        finally {
+            await closeDb(context);
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Command } from '@oclif/core';
+export default class ExercisesShow extends Command {
+    static args: {
+        selector: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        from: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'max-reps': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'max-weight': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'min-reps': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'min-weight': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        program: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        routine: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        to: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown | void>;
+}

package/dist/commands/exercises/show.js

@@ -0,0 +1,140 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { format, isValid, parseISO } from 'date-fns';
+import { closeDb, openDb } from '../../lib/db.js';
+import { toJsonErrorPayload } from '../../lib/json-error.js';
+import { renderTable } from '../../lib/output.js';
+import { getExerciseDetail, getExerciseHistoryRows, getExerciseHistoryWithSetsRows, getLastPerformedExerciseSnapshot, resolveExerciseSelector, } from '../../lib/repositories/exercises.js';
+import { resolveExerciseWeightUnit, resolveGlobalWeightUnit, weightUnitLabel, withWeightUnit } from '../../lib/units.js';
+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');
+}
+function toHistoryFilters(flags) {
+    return {
+        from: flags.from,
+        limit: flags.all ? undefined : (flags.limit ?? 100),
+        maxReps: flags['max-reps'],
+        maxWeight: flags['max-weight'],
+        minReps: flags['min-reps'],
+        minWeight: flags['min-weight'],
+        program: flags.program,
+        routine: flags.routine,
+        to: flags.to,
+    };
+}
+export default class ExercisesShow extends Command {
+    static args = {
+        selector: Args.string({ description: 'exercise id or name', required: true }),
+    };
+    static description = 'Show one exercise detail and history';
+    static enableJsonFlag = true;
+    static flags = {
+        all: Flags.boolean({ description: 'Return all matching history rows (no limit)', exclusive: ['limit'] }),
+        from: Flags.string({ description: 'History start date YYYY-MM-DD' }),
+        limit: Flags.integer({ description: 'History row limit (default: 100)', exclusive: ['all'] }),
+        'max-reps': Flags.integer({ description: 'History max top reps' }),
+        'max-weight': Flags.integer({ description: 'History max top weight' }),
+        'min-reps': Flags.integer({ description: 'History min top reps' }),
+        'min-weight': Flags.integer({ description: 'History min top weight' }),
+        program: Flags.string({ description: 'History filter by program id or name' }),
+        routine: Flags.string({ description: 'History filter by routine id or name' }),
+        to: Flags.string({ description: 'History end date YYYY-MM-DD' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ExercisesShow);
+        const parsedFlags = flags;
+        const context = openDb();
+        try {
+            const exerciseId = await resolveExerciseSelector(context.db, args.selector);
+            const detail = await getExerciseDetail(context.db, exerciseId);
+            const historyFilters = toHistoryFilters(parsedFlags);
+            const historyRows = await getExerciseHistoryRows(context.db, exerciseId, historyFilters);
+            const lastPerformedSnapshot = await getLastPerformedExerciseSnapshot(context.db, detail.id);
+            if (this.jsonEnabled()) {
+                const historyUnitPreference = await resolveExerciseWeightUnit(context.db, exerciseId);
+                const history = (await getExerciseHistoryWithSetsRows(context.db, exerciseId, historyFilters)).map((row) => ({
+                    ...row,
+                    sets: row.sets.map((set) => ({
+                        ...set,
+                        weight: withWeightUnit(set.weight, historyUnitPreference),
+                    })),
+                    topWeight: withWeightUnit(row.topWeight, historyUnitPreference),
+                }));
+                return {
+                    defaultProgressMetric: detail.defaultProgressMetric,
+                    equipment: detail.equipment,
+                    history,
+                    id: detail.id,
+                    name: detail.name,
+                    perceptionScale: detail.perceptionScale,
+                    primaryMuscles: detail.primaryMuscles,
+                    recentRoutines: detail.recentRoutines,
+                    secondaryMuscles: detail.secondaryMuscles,
+                    supports1RM: detail.supports1RM,
+                    timerBased: detail.timerBased,
+                    totalRoutines: detail.totalRoutines,
+                    totalWorkouts: detail.totalWorkouts,
+                };
+            }
+            this.log(`[${detail.id}] ${detail.name ?? '(unnamed)'}`);
+            this.log(`Primary muscles: ${detail.primaryMuscles ?? 'n/a'}`);
+            this.log(`Secondary muscles: ${detail.secondaryMuscles ?? 'n/a'}`);
+            this.log(`Equipment: ${detail.equipment ?? 'n/a'}`);
+            this.log(`Timer based: ${detail.timerBased}`);
+            this.log(`Supports 1RM: ${detail.supports1RM}`);
+            this.log(`Workouts tracked: ${detail.totalWorkouts}`);
+            this.log(`Routines present in: ${detail.totalRoutines}`);
+            this.log(`Recent routines: ${detail.recentRoutines.join(', ') || 'n/a'}`);
+            this.log('');
+            this.log('Last performed');
+            if (!lastPerformedSnapshot) {
+                this.log('(no rows)');
+                return;
+            }
+            const unitPreference = await resolveGlobalWeightUnit(context.db);
+            const unitLabel = weightUnitLabel(unitPreference);
+            this.log(`[${lastPerformedSnapshot.workout.id}] ${lastPerformedSnapshot.workout.routine ?? 'Workout'}`);
+            this.log(`Program: ${lastPerformedSnapshot.workout.program ?? 'n/a'}`);
+            this.log(`Date: ${formatWorkoutDate(lastPerformedSnapshot.workout.date)}`);
+            this.log('');
+            this.log(renderTable(lastPerformedSnapshot.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}`,
+            }))));
+            this.log('');
+            this.log('History');
+            const historyUnitPreference = await resolveExerciseWeightUnit(context.db, exerciseId);
+            const historyUnitLabel = weightUnitLabel(historyUnitPreference);
+            if (historyRows.length === 0) {
+                this.log('(no rows)');
+                return;
+            }
+            this.log(renderTable(historyRows.map((row) => ({
+                date: row.date,
+                id: row.workoutId,
+                routine: row.routine,
+                sets: row.sets,
+                topReps: row.topReps,
+                topWeight: row.topWeight === null ? null : `${row.topWeight} ${historyUnitLabel}`,
+                totalReps: row.totalReps,
+                volume: row.volume,
+            }))));
+        }
+        catch (error) {
+            if (this.jsonEnabled())
+                return toJsonErrorPayload(error);
+            throw error;
+        }
+        finally {
+            await closeDb(context);
+        }
+    }
+}

package/dist/commands/programs/list.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Programs extends Command {
+    static description: string;
+    static enableJsonFlag: boolean;
+    run(): Promise<unknown | void>;
+}

package/dist/commands/programs/list.js

@@ -0,0 +1,27 @@
+import { Command } from '@oclif/core';
+import { closeDb, openDb } from '../../lib/db.js';
+import { renderTable } from '../../lib/output.js';
+import { listPrograms } from '../../lib/repositories/programs.js';
+export default class Programs extends Command {
+    static description = 'List programs';
+    static enableJsonFlag = true;
+    async run() {
+        await this.parse(Programs);
+        const context = openDb();
+        try {
+            const programs = await listPrograms(context.db);
+            if (this.jsonEnabled())
+                return programs;
+            this.log(renderTable(programs.map((program) => ({
+                dateAdded: program.dateAdded,
+                id: program.id,
+                isActive: program.isActive,
+                isTemplate: program.isTemplate,
+                name: program.name,
+            }))));
+        }
+        finally {
+            await closeDb(context);
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class ProgramsShow extends Command {
+    static args: {
+        selector: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    static flags: {
+        active: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        current: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<unknown | void>;
+}

package/dist/commands/programs/show.js

@@ -0,0 +1,71 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { closeDb, openDb } from '../../lib/db.js';
+import { serializeProgramDetailWithWeightUnits } from '../../lib/json-weight.js';
+import { renderTable } from '../../lib/output.js';
+import { getProgramDetail, resolveProgramSelector } from '../../lib/repositories/programs.js';
+import { resolveProgramWeightUnit, weightUnitLabel } from '../../lib/units.js';
+function buildProgramRows(weeks, unitLabel) {
+    return weeks.flatMap((week, weekIndex) => week.routines.flatMap((routine, routineIndex) => routine.exercises.flatMap((exercise, exerciseIndex) => {
+        const headingRow = {};
+        headingRow.week = routineIndex === 0 && exerciseIndex === 0 ? `Week ${weekIndex + 1}` : '';
+        headingRow.routine = exerciseIndex === 0 ? `[${routine.id}] ${routine.name ?? '(unnamed)'}` : '';
+        headingRow.exercise = `[${exercise.id ?? exercise.exerciseConfigId}] ${exercise.name ?? '(unnamed)'}`;
+        headingRow.reps = null;
+        headingRow.rpe = null;
+        headingRow.timeSeconds = null;
+        headingRow.weight = null;
+        const setRows = exercise.sets.map((set) => {
+            const row = {};
+            row.week = '';
+            row.routine = '';
+            row.exercise = '';
+            row.reps = set.reps;
+            row.rpe = set.rpe;
+            row.timeSeconds = set.timeSeconds;
+            row.weight = set.weight === null ? null : `${set.weight} ${unitLabel}`;
+            return row;
+        });
+        return [headingRow, ...setRows];
+    })));
+}
+export default class ProgramsShow extends Command {
+    static args = {
+        selector: Args.string({ description: 'program id or name', ignoreStdin: true, required: false }),
+    };
+    static description = 'Show one program hierarchy';
+    static enableJsonFlag = true;
+    static flags = {
+        active: Flags.boolean({ description: 'Show active program detail' }),
+        current: Flags.boolean({ description: 'Alias for --active' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ProgramsShow);
+        const context = openDb();
+        try {
+            const useActive = flags.active || flags.current;
+            if (args.selector && useActive) {
+                throw new Error('Use either a selector or --active/--current, not both.');
+            }
+            if (!args.selector && !useActive) {
+                throw new Error('Provide a selector or use --active/--current.');
+            }
+            const programId = await resolveProgramSelector(context.db, args.selector, Boolean(useActive));
+            const detail = await getProgramDetail(context.db, programId);
+            const unitPreference = await resolveProgramWeightUnit(context.db, detail.program.id);
+            const unitLabel = weightUnitLabel(unitPreference);
+            if (this.jsonEnabled()) {
+                return serializeProgramDetailWithWeightUnits(detail, unitPreference);
+            }
+            this.log(`[${detail.program.id}] ${detail.program.name}`);
+            this.log(`Active: ${detail.program.isActive}  Template: ${detail.program.isTemplate}`);
+            this.log('');
+            const programRows = buildProgramRows(detail.weeks, unitLabel);
+            const renderedTable = renderTable(programRows).replace(/^\n+/, '');
+            this.log(renderedTable);
+            this.log('');
+        }
+        finally {
+            await closeDb(context);
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class Workouts extends Command {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static flags: {
+        limit: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        on: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        from: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        to: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        program: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        routine: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown | void>;
+}

package/dist/commands/workouts/list.js

@@ -0,0 +1,72 @@
+import { Command, Flags } from '@oclif/core';
+import { closeDb, openDb } from '../../lib/db.js';
+import { toJsonErrorPayload } from '../../lib/json-error.js';
+import { renderTable } from '../../lib/output.js';
+import { listWorkouts } from '../../lib/repositories/workouts.js';
+function formatDurationMinutes(durationSeconds) {
+    if (durationSeconds === null)
+        return 'n/a';
+    return `${Math.round(durationSeconds / 60)} minutes`;
+}
+export default class Workouts extends Command {
+    static description = 'List workouts';
+    static enableJsonFlag = true;
+    /* eslint-disable perfectionist/sort-objects */
+    static flags = {
+        limit: Flags.integer({ description: 'Limit workouts (default: 25)', exclusive: ['all'] }),
+        all: Flags.boolean({ description: 'Return all matching workouts (no limit)', exclusive: ['limit'] }),
+        on: Flags.string({ description: 'Single date YYYY-MM-DD', exclusive: ['from', 'to'] }),
+        from: Flags.string({ description: 'Start date YYYY-MM-DD', exclusive: ['on'] }),
+        to: Flags.string({ description: 'End date YYYY-MM-DD', exclusive: ['on'] }),
+        program: Flags.string({ description: 'Filter by program id or name' }),
+        routine: Flags.string({ description: 'Filter by routine id or name' }),
+    };
+    /* eslint-enable perfectionist/sort-objects */
+    async run() {
+        const { flags } = await this.parse(Workouts);
+        const context = openDb();
+        try {
+            const workouts = await listWorkouts(context.db, {
+                from: flags.from,
+                limit: flags.all ? undefined : (flags.limit ?? 25),
+                on: flags.on,
+                program: flags.program,
+                routine: flags.routine,
+                to: flags.to,
+            });
+            if (this.jsonEnabled()) {
+                return workouts.map((workout) => ({
+                    ...workout,
+                    duration: {
+                        unit: 'seconds',
+                        value: workout.duration,
+                    },
+                }));
+            }
+            this.log(renderTable(workouts.map((workout) => {
+                const row = {
+                    date: workout.date,
+                    duration: formatDurationMinutes(workout.duration),
+                    id: workout.id,
+                    program: workout.program,
+                    routine: workout.routine,
+                };
+                return Object.fromEntries([
+                    ['id', row.id],
+                    ['program', row.program],
+                    ['routine', row.routine],
+                    ['date', row.date],
+                    ['duration', row.duration],
+                ]);
+            })));
+        }
+        catch (error) {
+            if (this.jsonEnabled())
+                return toJsonErrorPayload(error);
+            throw error;
+        }
+        finally {
+            await closeDb(context);
+        }
+    }
+}