@richhaase/c2 0.2.1 → 0.3.0

package/README.md

@@ -60,6 +60,20 @@ c2 log
 c2 log -n 25
 ```
 
+Interval workouts are tagged with `[IVL rest M:SS.S]` so they're visually
+distinct from continuous pieces. The rest duration is surfaced because, for
+interval workouts, the displayed time (`time_formatted`) is elapsed time
+including rest, while the displayed pace is correctly computed from work
+time only. For example:
+
+```
+04/11   5,000m   28:35.4   2:51.5/500m  24spm  112bpm  107df
+04/11   3,000m   20:22.6   2:23.8/500m  30spm  152bpm  108df  [IVL rest 6:00.0]
+```
+
+The second row is 6x500m with ~1 min rest between reps: 20:22.6 elapsed =
+14:22.6 work + 6:00 rest. The `2:23.8/500m` pace is the work pace.
+
 ### Goal Progress
 
 Track progress toward your distance goal:
@@ -116,6 +130,10 @@ c2 export --from 2026-01-01 --to 2026-03-01
 c2 export -f jsonl > workouts.jsonl
 ```
 
+The CSV export includes `workout_type`, `rest_time_tenths`, and
+`rest_distance` columns so interval workouts are fully distinguishable from
+continuous pieces without having to consult the full JSON export.
+
 ## Configuration
 
 Config lives at `~/.config/c2/config.json`. Created automatically on `c2 setup`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@richhaase/c2",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "CLI tool for syncing and analyzing Concept2 rowing data",
   "keywords": [
     "concept2",
@@ -28,10 +28,10 @@
     "release": "bun run check && npm version"
   },
   "dependencies": {
-    "commander": "^14.0.0"
+    "commander": "^14.0.3"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.6",
+    "@biomejs/biome": "^2.4.10",
     "@types/bun": "^1.3.9"
   },
   "files": [

package/src/commands/export.ts

@@ -20,47 +20,54 @@ export function escapeCSV(s: string): string {
   return s;
 }
 
-function exportCSV(workouts: Workout[]): void {
-  const header = [
-    "id",
-    "date",
-    "distance",
-    "time_tenths",
-    "time_formatted",
-    "pace_500m",
-    "stroke_rate",
-    "stroke_count",
-    "calories",
-    "drag_factor",
-    "hr_avg",
-    "hr_min",
-    "hr_max",
-    "workout_type",
-    "machine_type",
-    "comments",
+export const CSV_HEADER = [
+  "id",
+  "date",
+  "distance",
+  "time_tenths",
+  "time_formatted",
+  "pace_500m",
+  "stroke_rate",
+  "stroke_count",
+  "calories",
+  "drag_factor",
+  "hr_avg",
+  "hr_min",
+  "hr_max",
+  "workout_type",
+  "rest_time_tenths",
+  "rest_distance",
+  "machine_type",
+  "comments",
+] as const;
+
+export function buildCSVRow(w: Workout): string[] {
+  return [
+    String(w.id),
+    w.date,
+    String(w.distance),
+    String(w.time),
+    w.time_formatted,
+    pace500m(w),
+    String(w.stroke_rate ?? ""),
+    String(w.stroke_count ?? ""),
+    String(w.calories_total ?? ""),
+    String(w.drag_factor ?? ""),
+    w.heart_rate?.average ? String(w.heart_rate.average) : "",
+    w.heart_rate?.min ? String(w.heart_rate.min) : "",
+    w.heart_rate?.max ? String(w.heart_rate.max) : "",
+    w.workout_type ?? "",
+    w.rest_time != null ? String(w.rest_time) : "",
+    w.rest_distance != null ? String(w.rest_distance) : "",
+    w.type ?? "",
+    escapeCSV(w.comments ?? ""),
   ];
-  console.log(header.join(","));
+}
 
+function exportCSV(workouts: Workout[]): void {
+  console.log(CSV_HEADER.join(","));
   for (const w of workouts) {
-    const row = [
-      String(w.id),
-      w.date,
-      String(w.distance),
-      String(w.time),
-      w.time_formatted,
-      pace500m(w),
-      String(w.stroke_rate ?? ""),
-      String(w.stroke_count ?? ""),
-      String(w.calories_total ?? ""),
-      String(w.drag_factor ?? ""),
-      w.heart_rate?.average ? String(w.heart_rate.average) : "",
-      w.heart_rate?.min ? String(w.heart_rate.min) : "",
-      w.heart_rate?.max ? String(w.heart_rate.max) : "",
-      w.workout_type ?? "",
-      w.type ?? "",
-      escapeCSV(w.comments ?? ""),
-    ];
-    console.log(row.join(","));
+    console.log(buildCSVRow(w).join(","));
   }
 }
 

package/src/commands/report.ts

@@ -386,10 +386,6 @@ function buildProjection(goal: GoalProgress, workouts: Workout[]): string {
       </div>
     </div>
   </div>
-  <div style="margin-top: 16px; padding: 12px; background: #21262d; border-radius: 6px; font-size: 13px; line-height: 1.8;">
-    <strong style="color: #f0f6fc;">The path forward:</strong>
-    ${sessionsPerWeek} sessions/week at ${formatMeters(avgSessionDist)}m avg = ${formatMeters(Math.round(parseFloat(sessionsPerWeek as string) * avgSessionDist))}m/week.
-  </div>
 </div>`;
 }
 

package/src/display.test.ts

@@ -1,12 +1,32 @@
 import { describe, expect, test } from "bun:test";
 import {
+  formatIntervalTag,
   formatMeters,
   formatMetersPerWeek,
   formatPercent,
+  formatWorkoutLine,
   paceArrow,
   sparkBar,
   trendArrow,
 } from "./display.ts";
+import type { Workout } from "./models.ts";
+
+function makeWorkout(overrides: Partial<Workout> = {}): Workout {
+  return {
+    id: 1,
+    user_id: 1,
+    date: "2026-04-09 07:00:00",
+    distance: 5000,
+    type: "rower",
+    time: 17155,
+    time_formatted: "28:35.4",
+    workout_type: "FixedDistanceSplits",
+    stroke_rate: 24,
+    heart_rate: { average: 112 },
+    drag_factor: 107,
+    ...overrides,
+  };
+}
 
 describe("formatMeters", () => {
   test.each([
@@ -82,3 +102,85 @@ describe("paceArrow", () => {
     expect(paceArrow(170, 180)).toBe("\u2193");
   });
 });
+
+describe("formatIntervalTag", () => {
+  test("returns empty string for a continuous piece", () => {
+    const w = makeWorkout({ workout_type: "FixedDistanceSplits" });
+    expect(formatIntervalTag(w)).toBe("");
+  });
+
+  test("returns tag with rest duration for interval workout", () => {
+    const w = makeWorkout({
+      workout_type: "FixedDistanceInterval",
+      rest_time: 3600,
+    });
+    expect(formatIntervalTag(w)).toBe("[IVL rest 6:00.0]");
+  });
+
+  test("returns bare [IVL] when rest_time is missing but type is Interval", () => {
+    const w = makeWorkout({ workout_type: "FixedDistanceInterval" });
+    expect(formatIntervalTag(w)).toBe("[IVL]");
+  });
+
+  test("detects interval via rest_distance alone", () => {
+    const w = makeWorkout({
+      workout_type: undefined,
+      rest_distance: 660,
+    });
+    expect(formatIntervalTag(w)).toBe("[IVL]");
+  });
+});
+
+describe("formatWorkoutLine", () => {
+  test("formats a continuous piece without an interval tag", () => {
+    const w = makeWorkout({
+      date: "2026-04-09 07:00:00",
+      distance: 5000,
+      time: 17155,
+      time_formatted: "28:35.4",
+      workout_type: "FixedDistanceSplits",
+      stroke_rate: 24,
+      heart_rate: { average: 112 },
+      drag_factor: 107,
+    });
+    const line = formatWorkoutLine(w, "01/02");
+    expect(line).toContain("04/09");
+    expect(line).toContain("5,000m");
+    expect(line).toContain("28:35.4");
+    expect(line).toContain("2:51.6/500m");
+    expect(line).toContain("24spm");
+    expect(line).toContain("112bpm");
+    expect(line).toContain("107df");
+    expect(line).not.toContain("[IVL");
+  });
+
+  test("appends [IVL rest M:SS.S] tag for interval workouts", () => {
+    // Real 2026-04-11 session: 6x500m, 14:22.6 work, 6:00 rest.
+    const w = makeWorkout({
+      date: "2026-04-11 09:14:00",
+      distance: 3000,
+      time: 8626,
+      time_formatted: "20:22.6",
+      workout_type: "FixedDistanceInterval",
+      rest_time: 3600,
+      rest_distance: 660,
+      stroke_rate: 30,
+      heart_rate: { average: 152 },
+      drag_factor: 108,
+    });
+    const line = formatWorkoutLine(w, "01/02");
+    expect(line).toContain("[IVL rest 6:00.0]");
+    // Pace comes from work time, not elapsed — must be 2:23.8, not 3:23.8.
+    expect(line).toContain("2:23.8/500m");
+  });
+
+  test("handles missing stroke_rate / heart_rate / drag_factor gracefully", () => {
+    const w = makeWorkout({
+      stroke_rate: undefined,
+      heart_rate: undefined,
+      drag_factor: undefined,
+    });
+    const line = formatWorkoutLine(w, "01/02");
+    expect(line).toContain("    -");
+  });
+});

package/src/display.ts

@@ -1,5 +1,5 @@
 import type { Workout } from "./models.ts";
-import { pace500m, parsedDate } from "./models.ts";
+import { formatSeconds, isIntervalWorkout, pace500m, parsedDate, restSeconds } from "./models.ts";
 
 export function formatMeters(m: number): string {
   return m.toLocaleString("en-US");
@@ -32,6 +32,22 @@ export function formatDate(d: Date, fmt: string): string {
   return `${mm}/${dd}`;
 }
 
+/**
+ * Format an interval-workout marker suffix for `formatWorkoutLine`.
+ *
+ * For interval workouts, appends a compact `[IVL rest M:SS.S]` tag that
+ * flags the workout as intervals and reports the total rest duration so
+ * the reader can reconcile `time_formatted` (elapsed including rest)
+ * against `pace500m` (work-only pace). For non-interval workouts, returns
+ * an empty string.
+ */
+export function formatIntervalTag(w: Workout): string {
+  if (!isIntervalWorkout(w)) return "";
+  const rest = restSeconds(w);
+  if (rest > 0) return `[IVL rest ${formatSeconds(rest)}]`;
+  return "[IVL]";
+}
+
 export function formatWorkoutLine(w: Workout, dateFormat: string): string {
   const d = parsedDate(w);
   const dateStr = formatDate(d, dateFormat);
@@ -40,8 +56,10 @@ export function formatWorkoutLine(w: Workout, dateFormat: string): string {
   const spm = w.stroke_rate ? `${w.stroke_rate}spm` : "-";
   const hr = w.heart_rate?.average && w.heart_rate.average > 0 ? `${w.heart_rate.average}bpm` : "-";
   const df = w.drag_factor ? `${w.drag_factor}df` : "-";
+  const tag = formatIntervalTag(w);
+  const tagSuffix = tag ? `  ${tag}` : "";
 
-  return `${dateStr}  ${distance.padStart(7)}  ${w.time_formatted.padStart(8)}  ${pace.padStart(7)}/500m  ${spm.padStart(5)}  ${hr.padStart(6)}  ${df.padStart(4)}`;
+  return `${dateStr}  ${distance.padStart(7)}  ${w.time_formatted.padStart(8)}  ${pace.padStart(7)}/500m  ${spm.padStart(5)}  ${hr.padStart(6)}  ${df.padStart(4)}${tagSuffix}`;
 }
 
 export function sparkBar(value: number, max: number): string {

package/src/export.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { escapeCSV, filterByDate } from "./commands/export.ts";
+import { buildCSVRow, CSV_HEADER, escapeCSV, filterByDate } from "./commands/export.ts";
 import type { Workout } from "./models.ts";
 
 function makeWorkout(id: number, date: string, distance: number): Workout {
@@ -68,3 +68,81 @@ describe("filterByDate", () => {
     expect(result).toHaveLength(3);
   });
 });
+
+describe("CSV_HEADER", () => {
+  test("includes rest_time_tenths and rest_distance columns", () => {
+    expect(CSV_HEADER).toContain("rest_time_tenths");
+    expect(CSV_HEADER).toContain("rest_distance");
+  });
+
+  test("includes workout_type column", () => {
+    expect(CSV_HEADER).toContain("workout_type");
+  });
+});
+
+describe("buildCSVRow", () => {
+  test("row length matches header length", () => {
+    const w = makeWorkout(1, "2026-01-15 10:00:00", 5000);
+    const row = buildCSVRow(w);
+    expect(row).toHaveLength(CSV_HEADER.length);
+  });
+
+  test("leaves rest columns empty for a continuous piece", () => {
+    const w: Workout = {
+      id: 1,
+      user_id: 1,
+      date: "2026-04-09 07:00:00",
+      distance: 5000,
+      type: "rower",
+      time: 17155,
+      time_formatted: "28:35.4",
+      workout_type: "FixedDistanceSplits",
+    };
+    const row = buildCSVRow(w);
+    const restTimeIdx = CSV_HEADER.indexOf("rest_time_tenths");
+    const restDistanceIdx = CSV_HEADER.indexOf("rest_distance");
+    expect(row[restTimeIdx]).toBe("");
+    expect(row[restDistanceIdx]).toBe("");
+  });
+
+  test("populates rest columns for an interval workout", () => {
+    const w: Workout = {
+      id: 2,
+      user_id: 1,
+      date: "2026-04-11 09:14:00",
+      distance: 3000,
+      type: "rower",
+      time: 8626,
+      time_formatted: "20:22.6",
+      workout_type: "FixedDistanceInterval",
+      rest_time: 3600,
+      rest_distance: 660,
+    };
+    const row = buildCSVRow(w);
+    const workoutTypeIdx = CSV_HEADER.indexOf("workout_type");
+    const restTimeIdx = CSV_HEADER.indexOf("rest_time_tenths");
+    const restDistanceIdx = CSV_HEADER.indexOf("rest_distance");
+    expect(row[workoutTypeIdx]).toBe("FixedDistanceInterval");
+    expect(row[restTimeIdx]).toBe("3600");
+    expect(row[restDistanceIdx]).toBe("660");
+  });
+
+  test("preserves explicit zero rest_time", () => {
+    const w: Workout = {
+      id: 3,
+      user_id: 1,
+      date: "2026-04-09 07:00:00",
+      distance: 5000,
+      type: "rower",
+      time: 17155,
+      time_formatted: "28:35.4",
+      rest_time: 0,
+      rest_distance: 0,
+    };
+    const row = buildCSVRow(w);
+    const restTimeIdx = CSV_HEADER.indexOf("rest_time_tenths");
+    const restDistanceIdx = CSV_HEADER.indexOf("rest_distance");
+    expect(row[restTimeIdx]).toBe("0");
+    expect(row[restDistanceIdx]).toBe("0");
+  });
+});

package/src/models.test.ts

@@ -1,6 +1,15 @@
 import { describe, expect, test } from "bun:test";
 import type { Workout } from "./models.ts";
-import { calendarDay, pace500m, pace500mSeconds, parsedDate } from "./models.ts";
+import {
+  calendarDay,
+  formatSeconds,
+  isIntervalWorkout,
+  pace500m,
+  pace500mSeconds,
+  parsedDate,
+  restSeconds,
+  workSeconds,
+} from "./models.ts";
 
 function makeWorkout(overrides: Partial<Workout> = {}): Workout {
   return {
@@ -69,4 +78,96 @@ describe("pace500m", () => {
     // 3706 / 10 * 500 / 1000 = 185.3
     expect(pace500m(w)).toBe("3:05.3");
   });
+
+  test("uses work time (not elapsed) for interval workout pace", () => {
+    // Real 2026-04-11 session: 6x500m, 14:22.6 work, 6:00 rest.
+    // API returns `time: 8626` tenths (work), `time_formatted: "20:22.6"` (elapsed).
+    // Pace must be computed from `time`, not `time_formatted`.
+    const w = makeWorkout({
+      distance: 3000,
+      time: 8626,
+      time_formatted: "20:22.6",
+      workout_type: "FixedDistanceInterval",
+      rest_time: 3600,
+      rest_distance: 660,
+    });
+    // 8626 / 10 * 500 / 3000 = 143.77
+    expect(pace500m(w)).toBe("2:23.8");
+  });
+});
+
+describe("isIntervalWorkout", () => {
+  test("returns false for a continuous piece", () => {
+    const w = makeWorkout({
+      workout_type: "FixedDistanceSplits",
+    });
+    expect(isIntervalWorkout(w)).toBe(false);
+  });
+
+  test("returns true for FixedDistanceInterval workout_type", () => {
+    const w = makeWorkout({ workout_type: "FixedDistanceInterval" });
+    expect(isIntervalWorkout(w)).toBe(true);
+  });
+
+  test("returns true for FixedTimeInterval workout_type", () => {
+    const w = makeWorkout({ workout_type: "FixedTimeInterval" });
+    expect(isIntervalWorkout(w)).toBe(true);
+  });
+
+  test("returns true when rest_time > 0 even without workout_type", () => {
+    const w = makeWorkout({ rest_time: 3600 });
+    expect(isIntervalWorkout(w)).toBe(true);
+  });
+
+  test("returns true when rest_distance > 0 even without workout_type", () => {
+    const w = makeWorkout({ rest_distance: 660 });
+    expect(isIntervalWorkout(w)).toBe(true);
+  });
+
+  test("returns false when rest_time is explicitly 0", () => {
+    const w = makeWorkout({
+      workout_type: "FixedDistanceSplits",
+      rest_time: 0,
+      rest_distance: 0,
+    });
+    expect(isIntervalWorkout(w)).toBe(false);
+  });
+
+  test("returns false when workout_type is missing and no rest", () => {
+    const w = makeWorkout({});
+    expect(isIntervalWorkout(w)).toBe(false);
+  });
+});
+
+describe("restSeconds", () => {
+  test("returns 0 when rest_time is undefined", () => {
+    const w = makeWorkout({});
+    expect(restSeconds(w)).toBe(0);
+  });
+
+  test("converts tenths to seconds", () => {
+    const w = makeWorkout({ rest_time: 3600 });
+    expect(restSeconds(w)).toBe(360);
+  });
+});
+
+describe("workSeconds", () => {
+  test("converts time tenths to seconds", () => {
+    // 8626 tenths = 862.6 seconds = 14:22.6
+    const w = makeWorkout({ time: 8626 });
+    expect(workSeconds(w)).toBe(862.6);
+  });
+});
+
+describe("formatSeconds", () => {
+  test.each([
+    [0, "0:00.0"],
+    [-5, "0:00.0"],
+    [5.5, "0:05.5"],
+    [65.3, "1:05.3"],
+    [360, "6:00.0"],
+    [862.6, "14:22.6"],
+  ])("formatSeconds(%f) = %s", (input, expected) => {
+    expect(formatSeconds(input)).toBe(expected);
+  });
 });

package/src/models.ts

@@ -4,17 +4,30 @@ export interface HeartRate {
   max?: number;
 }
 
-/** A single result from the Concept2 Logbook API. Time is in tenths of a second. */
+/**
+ * A single result from the Concept2 Logbook API.
+ *
+ * Time fields are in tenths of a second. For interval workouts (those with
+ * `rest_time > 0` or a `workout_type` containing "Interval"):
+ * - `time` is **work time only** (total across all reps, excluding rest)
+ * - `time_formatted` is **elapsed time including rest**
+ * - `distance` is total work meters (excluding rest rowing)
+ *
+ * This means pace (`time / distance`) is correctly work pace, but
+ * `time_formatted` cannot be used for pace math on interval workouts.
+ * Use `isIntervalWorkout()` to classify and `restSeconds()` to recover
+ * elapsed vs work time when needed.
+ */
 export interface Workout {
   id: number;
   user_id: number;
   date: string; // "2026-03-02 17:41:00"
   timezone?: string;
-  distance: number;
+  distance: number; // meters of work (rest rowing NOT included)
   type: string; // "rower"
-  time: number; // tenths of a second
-  time_formatted: string;
-  workout_type?: string;
+  time: number; // tenths of a second of work time (rest NOT included)
+  time_formatted: string; // elapsed time including rest for interval workouts
+  workout_type?: string; // e.g., "FixedDistanceSplits", "FixedDistanceInterval"
   source?: string;
   weight_class?: string;
   stroke_rate?: number;
@@ -23,6 +36,10 @@ export interface Workout {
   drag_factor?: number;
   heart_rate?: HeartRate;
   stroke_data?: boolean;
+  /** Total rest time across all rest intervals, in tenths of a second. */
+  rest_time?: number;
+  /** Total meters rowed during rest intervals (easy rowing between reps). */
+  rest_distance?: number;
   comments?: string;
 }
 
@@ -87,7 +104,43 @@ export function pace500mSeconds(w: Workout): number {
 export function pace500m(w: Workout): string {
   const secs = pace500mSeconds(w);
   if (secs === 0) return "-";
-  const mins = Math.floor(secs / 60);
-  const rem = secs - mins * 60;
+  return formatSeconds(secs);
+}
+
+/**
+ * Returns true if this workout is an interval workout — i.e., multiple
+ * work reps separated by rest. Interval workouts have `time` as work time
+ * only and `time_formatted` as elapsed time including rest.
+ *
+ * Detection is inclusive: any of the following is sufficient.
+ * - `workout_type` contains "Interval" (the Concept2 API's own classification)
+ * - `rest_time` is > 0
+ * - `rest_distance` is > 0
+ */
+export function isIntervalWorkout(w: Workout): boolean {
+  if (w.workout_type?.includes("Interval")) return true;
+  if (w.rest_time != null && w.rest_time > 0) return true;
+  if (w.rest_distance != null && w.rest_distance > 0) return true;
+  return false;
+}
+
+/** Total rest time in seconds (0 when not an interval workout). */
+export function restSeconds(w: Workout): number {
+  return (w.rest_time ?? 0) / TENTHS_PER_SECOND;
+}
+
+/** Total work time (excluding rest) in seconds. */
+export function workSeconds(w: Workout): number {
+  return w.time / TENTHS_PER_SECOND;
+}
+
+/**
+ * Format a duration in seconds as `M:SS.S` (matching the Concept2 API's
+ * `time_formatted` style). Returns `"0:00.0"` for zero.
+ */
+export function formatSeconds(totalSeconds: number): string {
+  if (totalSeconds <= 0) return "0:00.0";
+  const mins = Math.floor(totalSeconds / 60);
+  const rem = totalSeconds - mins * 60;
   return `${mins}:${rem.toFixed(1).padStart(4, "0")}`;
 }