@richhaase/c2 0.3.1 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@richhaase/c2",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "CLI tool for syncing and analyzing Concept2 rowing data",
   "keywords": [
     "concept2",

package/src/commands/export.ts

@@ -101,7 +101,6 @@ export function registerExport(program: Command): void {
         process.exit(1);
       }
 
-      // Sort oldest first for export
       workouts.sort((a, b) => a.date.localeCompare(b.date));
 
       switch (opts.format) {

package/src/commands/report.ts

@@ -194,7 +194,6 @@ ${rows}
 }
 
 function buildWeeklyTrends(summaries: WeekSummary[]): string {
-  // Find best volume week and best pace week for highlighting
   let bestVolume = 0;
   let bestPace = Infinity;
   for (const ws of summaries) {
@@ -224,7 +223,6 @@ function buildWeeklyTrends(summaries: WeekSummary[]): string {
     })
     .join("\n");
 
-  // Pace trend summary
   const firstPace = summaries.find((w) => w.paceCount > 0);
   const lastPace = [...summaries].reverse().find((w) => w.paceCount > 0);
   let trendNote = "";
@@ -261,7 +259,6 @@ function buildRecentWorkouts(workouts: Workout[], count: number): string {
   const sorted = [...workouts].sort((a, b) => b.date.localeCompare(a.date));
   const recent = sorted.slice(0, count).reverse();
 
-  // Detect same-day groups for session-aware formatting
   const dayCounts = new Map<string, number>();
   for (const w of recent) {
     const day = calendarDay(w);
@@ -278,7 +275,6 @@ function buildRecentWorkouts(workouts: Workout[], count: number): string {
       const spm = w.stroke_rate ?? "-";
       const hr = w.heart_rate?.average ?? "-";
 
-      // If multiple workouts on same day, annotate
       const multiDay = (dayCounts.get(day) || 0) > 1;
       if (!multiDay) {
         return `      <tr>
@@ -290,16 +286,14 @@ function buildRecentWorkouts(workouts: Workout[], count: number): string {
       </tr>`;
       }
 
-      // Session-aware: short warmup/cooldown get muted style
       const isShort = w.distance <= 1500;
-      const isHard = paceS > 0 && paceS < 160; // sub-2:40 is hard
+      const isHard = paceS > 0 && paceS < 160;
       let annotation = "";
       let rowStyle = "";
       let paceStyle = "";
       let hrStyle = "";
 
       if (isShort && !isHard) {
-        // Likely warmup or cooldown — check position
         const dayWorkouts = recent
           .filter((r) => calendarDay(r) === day)
           .sort((a, b) => a.date.localeCompare(b.date));

package/src/commands/setup.ts

@@ -39,11 +39,9 @@ export function registerSetup(program: Command): void {
 
       console.log("Concept2 CLI Setup\n");
 
-      // Token
       const token = promptValue("API token (from log.concept2.com)", cfg.api.token, true);
       cfg.api.token = token;
 
-      // Goal target
       const targetDisplay = formatMeters(cfg.goal.target_meters);
       const targetInput = promptValue("Goal target meters", targetDisplay);
       const parsed = parseInt(targetInput.replace(/,/g, ""), 10);
@@ -51,7 +49,6 @@ export function registerSetup(program: Command): void {
         cfg.goal.target_meters = parsed;
       }
 
-      // Goal dates
       const startInput = promptValue("Goal start date (YYYY-MM-DD)", cfg.goal.start_date);
       try {
         parseGoalDate(startInput);
@@ -68,7 +65,6 @@ export function registerSetup(program: Command): void {
         console.log(`Invalid date "${endInput}", keeping previous value.`);
       }
 
-      // Save
       await ensureDirs();
       await saveConfig(cfg);
       console.log(`\nConfig written to ${join(configDir(), "config.json")}`);
@@ -79,7 +75,6 @@ export function registerSetup(program: Command): void {
         );
       }
 
-      // Verify token
       if (cfg.api.token) {
         console.log("Verifying token...");
         try {

package/src/config.test.ts

@@ -5,7 +5,7 @@ describe("parseGoalDate", () => {
   test("parses valid date string", () => {
     const d = parseGoalDate("2026-03-07");
     expect(d.getFullYear()).toBe(2026);
-    expect(d.getMonth()).toBe(2); // March = 2
+    expect(d.getMonth()).toBe(2);
     expect(d.getDate()).toBe(7);
   });
 

package/src/display.test.ts

@@ -155,7 +155,6 @@ describe("formatWorkoutLine", () => {
   });
 
   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,
@@ -170,7 +169,6 @@ describe("formatWorkoutLine", () => {
     });
     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");
   });
 

package/src/display.ts

@@ -14,7 +14,6 @@ export function formatMetersPerWeek(m: number): string {
 }
 
 export function formatDate(d: Date, fmt: string): string {
-  // Go-style reference time: "01/02" means month/day
   if (fmt === "01/02" || fmt === "%m/%d") {
     const mm = String(d.getMonth() + 1).padStart(2, "0");
     const dd = String(d.getDate()).padStart(2, "0");
@@ -26,21 +25,11 @@ export function formatDate(d: Date, fmt: string): string {
     const dd = String(d.getDate()).padStart(2, "0");
     return `${y}-${mm}-${dd}`;
   }
-  // Fallback: MM/DD
   const mm = String(d.getMonth() + 1).padStart(2, "0");
   const dd = String(d.getDate()).padStart(2, "0");
   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);
@@ -81,5 +70,5 @@ export function trendArrow(prev: number, curr: number): string {
 
 export function paceArrow(prev: number, curr: number): string {
   if (prev === 0) return " ";
-  return trendArrow(curr, prev); // reversed: lower pace is better
+  return trendArrow(curr, prev);
 }

package/src/index.ts

@@ -23,7 +23,6 @@ registerTrend(program);
 registerExport(program);
 registerReport(program);
 
-// Default to `report` when run with no subcommand
 const args = process.argv.slice(2);
 const knownCommands = program.commands.map((c) => c.name());
 const hasSubcommand = args.some((a) => knownCommands.includes(a));

package/src/models.test.ts

@@ -29,7 +29,7 @@ describe("parsedDate", () => {
     const w = makeWorkout({ date: "2026-03-07 09:21:00" });
     const d = parsedDate(w);
     expect(d.getFullYear()).toBe(2026);
-    expect(d.getMonth()).toBe(2); // March = 2 (0-indexed)
+    expect(d.getMonth()).toBe(2);
     expect(d.getDate()).toBe(7);
     expect(d.getHours()).toBe(9);
     expect(d.getMinutes()).toBe(21);
@@ -47,7 +47,6 @@ describe("pace500mSeconds", () => {
   test("computes pace for normal workout", () => {
     const w = makeWorkout({ distance: 5500, time: 19122 });
     const pace = pace500mSeconds(w);
-    // 19122 / 10 * 500 / 5500 = 173.836...
     expect(pace).toBeCloseTo(173.836, 2);
   });
 
@@ -75,14 +74,10 @@ describe("pace500m", () => {
 
   test("formats 3+ minute pace correctly", () => {
     const w = makeWorkout({ distance: 1000, time: 3706 });
-    // 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,
@@ -91,7 +86,6 @@ describe("pace500m", () => {
       rest_time: 3600,
       rest_distance: 660,
     });
-    // 8626 / 10 * 500 / 3000 = 143.77
     expect(pace500m(w)).toBe("2:23.8");
   });
 });
@@ -153,7 +147,6 @@ describe("restSeconds", () => {
 
 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);
   });

package/src/models.ts

@@ -4,30 +4,16 @@ export interface HeartRate {
   max?: number;
 }
 
-/**
- * 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"
+  date: string;
   timezone?: string;
-  distance: number; // meters of work (rest rowing NOT included)
-  type: string; // "rower"
-  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"
+  distance: number;
+  type: string;
+  time: number;
+  time_formatted: string;
+  workout_type?: string;
   source?: string;
   weight_class?: string;
   stroke_rate?: number;
@@ -36,19 +22,17 @@ 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;
 }
 
 export interface StrokeData {
-  t?: number; // cumulative time
-  d?: number; // cumulative distance
-  p?: number; // pace
-  spm?: number; // strokes per minute
-  hr?: number; // heart rate
+  t?: number;
+  d?: number;
+  p?: number;
+  spm?: number;
+  hr?: number;
 }
 
 export interface UserProfile {
@@ -80,7 +64,6 @@ export interface ResultsResponse {
   meta?: ResultsMeta;
 }
 
-/** API wraps stroke data in {"data": [...]} */
 export interface StrokeDataResponse {
   data: StrokeData[];
 }
@@ -107,16 +90,6 @@ export function pace500m(w: Workout): string {
   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;
@@ -124,20 +97,14 @@ export function isIntervalWorkout(w: Workout): boolean {
   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);

package/src/sessions.ts

@@ -2,10 +2,10 @@ import type { Workout } from "./models.ts";
 import { calendarDay } from "./models.ts";
 
 export interface Session {
-  date: string; // "2026-03-07"
+  date: string;
   workouts: Workout[];
   totalDistance: number;
-  totalTime: number; // tenths of seconds
+  totalTime: number;
 }
 
 export function groupIntoSessions(workouts: Workout[]): Session[] {
@@ -31,7 +31,6 @@ export function groupIntoSessions(workouts: Workout[]): Session[] {
     .sort((a, b) => a.date.localeCompare(b.date));
 }
 
-/** Count unique calendar days (sessions) in a list of workouts. */
 export function sessionCount(workouts: Workout[]): number {
   const days = new Set(workouts.map(calendarDay));
   return days.size;

package/src/stats.test.ts

@@ -30,28 +30,28 @@ function makeGoalConfig(overrides: Partial<Config["goal"]> = {}): Config {
 
 describe("mondayOf", () => {
   test("monday returns same date", () => {
-    const d = new Date(2026, 2, 2); // Mon Mar 2
+    const d = new Date(2026, 2, 2);
     const m = mondayOf(d);
-    expect(m.getDay()).toBe(1); // Monday
+    expect(m.getDay()).toBe(1);
     expect(m.getDate()).toBe(2);
   });
 
   test("wednesday returns previous monday", () => {
-    const d = new Date(2026, 2, 4); // Wed Mar 4
+    const d = new Date(2026, 2, 4);
     const m = mondayOf(d);
     expect(m.getDay()).toBe(1);
     expect(m.getDate()).toBe(2);
   });
 
   test("sunday returns previous monday", () => {
-    const d = new Date(2026, 2, 8); // Sun Mar 8
+    const d = new Date(2026, 2, 8);
     const m = mondayOf(d);
     expect(m.getDay()).toBe(1);
     expect(m.getDate()).toBe(2);
   });
 
   test("handles month boundary", () => {
-    const d = new Date(2026, 2, 1); // Mar 1
+    const d = new Date(2026, 2, 1);
     const m = mondayOf(d);
     expect(m.getDay()).toBe(1);
     expect(m.getTime()).toBeLessThanOrEqual(d.getTime());
@@ -65,8 +65,8 @@ describe("workoutsInRange", () => {
       makeWorkout(2, "2026-02-15 10:00:00", 5000),
       makeWorkout(3, "2026-03-15 10:00:00", 5000),
     ];
-    const from = new Date(2026, 1, 1); // Feb 1
-    const to = new Date(2026, 2, 1); // Mar 1
+    const from = new Date(2026, 1, 1);
+    const to = new Date(2026, 2, 1);
     const result = workoutsInRange(workouts, from, to);
     expect(result).toHaveLength(1);
     expect(result[0]!.id).toBe(2);
@@ -82,10 +82,10 @@ describe("workoutsInRange", () => {
 
 describe("buildWeekSummaries", () => {
   test("buckets workouts into correct weeks", () => {
-    const now = new Date(2026, 2, 7); // Sat Mar 7
+    const now = new Date(2026, 2, 7);
     const workouts = [
-      makeWorkout(1, "2026-03-02 10:00:00", 5000), // Mon of current week
-      makeWorkout(2, "2026-02-23 10:00:00", 6000), // Previous week
+      makeWorkout(1, "2026-03-02 10:00:00", 5000),
+      makeWorkout(2, "2026-02-23 10:00:00", 6000),
     ];
     const summaries = buildWeekSummaries(workouts, now, 2);
     expect(summaries).toHaveLength(2);
@@ -97,12 +97,12 @@ describe("buildWeekSummaries", () => {
     const now = new Date(2026, 2, 7);
     const workouts = [
       makeWorkout(1, "2026-03-02 09:00:00", 1000),
-      makeWorkout(2, "2026-03-02 10:00:00", 2000), // same day
-      makeWorkout(3, "2026-03-04 10:00:00", 3000), // different day
+      makeWorkout(2, "2026-03-02 10:00:00", 2000),
+      makeWorkout(3, "2026-03-04 10:00:00", 3000),
     ];
     const summaries = buildWeekSummaries(workouts, now, 1);
     expect(summaries[0]!.meters).toBe(6000);
-    expect(summaries[0]!.sessions).toBe(2); // 2 unique days
+    expect(summaries[0]!.sessions).toBe(2);
   });
 
   test("returns empty summaries for no workouts", () => {
@@ -120,7 +120,7 @@ describe("computeGoalProgress", () => {
       makeWorkout(1, "2026-03-01 10:00:00", 100_000),
       makeWorkout(2, "2026-02-01 10:00:00", 100_000),
     ];
-    const now = new Date(2026, 2, 7); // Mar 7
+    const now = new Date(2026, 2, 7);
     const goal = computeGoalProgress(workouts, cfg, now);
     expect(goal.totalMeters).toBe(200_000);
     expect(goal.target).toBe(1_000_000);
@@ -141,9 +141,9 @@ describe("computeGoalProgress", () => {
   test("excludes workouts outside goal date range", () => {
     const cfg = makeGoalConfig();
     const workouts = [
-      makeWorkout(1, "2025-12-01 10:00:00", 50_000), // before start
-      makeWorkout(2, "2026-03-01 10:00:00", 100_000), // in range
-      makeWorkout(3, "2027-02-01 10:00:00", 50_000), // after end
+      makeWorkout(1, "2025-12-01 10:00:00", 50_000),
+      makeWorkout(2, "2026-03-01 10:00:00", 100_000),
+      makeWorkout(3, "2027-02-01 10:00:00", 50_000),
     ];
     const now = new Date(2026, 2, 7);
     const goal = computeGoalProgress(workouts, cfg, now);
@@ -153,9 +153,48 @@ describe("computeGoalProgress", () => {
   test("before start date: weeksElapsed is 0", () => {
     const cfg = makeGoalConfig({ start_date: "2026-06-01" });
     const workouts: Workout[] = [];
-    const now = new Date(2026, 2, 7); // before start
+    const now = new Date(2026, 2, 7);
     const goal = computeGoalProgress(workouts, cfg, now);
     expect(goal.weeksElapsed).toBe(0);
     expect(goal.currentAvgPace).toBe(0);
   });
+
+  test("currentAvgPace uses recent 4-week window, not lifetime", () => {
+    const cfg = makeGoalConfig();
+    const workouts = [
+      makeWorkout(1, "2026-01-05 10:00:00", 5_000),
+      makeWorkout(2, "2026-01-12 10:00:00", 8_000),
+      makeWorkout(3, "2026-01-19 10:00:00", 11_000),
+      makeWorkout(4, "2026-03-09 10:00:00", 20_000),
+      makeWorkout(5, "2026-03-16 10:00:00", 20_000),
+      makeWorkout(6, "2026-03-23 10:00:00", 20_000),
+      makeWorkout(7, "2026-03-30 10:00:00", 20_000),
+    ];
+    const now = new Date(2026, 3, 6, 18);
+    const goal = computeGoalProgress(workouts, cfg, now);
+    expect(goal.currentAvgPace).toBe(20_000);
+  });
+
+  test("currentAvgPace ignores workouts before the recent window", () => {
+    const cfg = makeGoalConfig();
+    const workouts = [
+      makeWorkout(1, "2026-01-05 10:00:00", 100_000),
+      makeWorkout(2, "2026-03-23 10:00:00", 15_000),
+      makeWorkout(3, "2026-03-30 10:00:00", 15_000),
+    ];
+    const now = new Date(2026, 3, 6, 18);
+    const goal = computeGoalProgress(workouts, cfg, now);
+    expect(goal.currentAvgPace).toBe(7_500);
+  });
+
+  test("currentAvgPace excludes the current in-progress week", () => {
+    const cfg = makeGoalConfig();
+    const workouts = [
+      makeWorkout(1, "2026-04-06 10:00:00", 20_000),
+      makeWorkout(2, "2026-04-13 06:55:00", 5_500),
+    ];
+    const now = new Date(2026, 3, 13, 18);
+    const goal = computeGoalProgress(workouts, cfg, now);
+    expect(goal.currentAvgPace).toBe(5_000);
+  });
 });

package/src/stats.ts

@@ -18,16 +18,18 @@ export interface WeekSummary {
 export interface GoalProgress {
   target: number;
   totalMeters: number;
-  progress: number; // ratio 0–1
+  progress: number;
   weeksElapsed: number;
   totalWeeks: number;
   remainingMeters: number;
   remainingWeeks: number;
-  requiredPace: number; // meters/week needed going forward
-  currentAvgPace: number; // meters/week so far
+  requiredPace: number;
+  currentAvgPace: number;
   onPace: boolean;
 }
 
+const RECENT_WEEKS = 4;
+
 export function mondayOf(t: Date): Date {
   const d = new Date(t.getFullYear(), t.getMonth(), t.getDate());
   const offset = (d.getDay() + 6) % 7;
@@ -132,7 +134,23 @@ export function computeGoalProgress(workouts: Workout[], cfg: Config, now?: Date
   if (remainingWeeks < 1) remainingWeeks = 1;
   const requiredPace = Math.floor(remainingMeters / remainingWeeks);
 
-  const currentAvgPace = weeksElapsed > 0 ? Math.floor(totalMeters / weeksElapsed) : 0;
+  let currentAvgPace = 0;
+  if (weeksElapsed > 0) {
+    const thisMonday = mondayOf(today);
+    const recentStart = new Date(thisMonday);
+    recentStart.setDate(recentStart.getDate() - RECENT_WEEKS * 7);
+    const windowStart = recentStart < start ? start : recentStart;
+    const windowMs = thisMonday.getTime() - windowStart.getTime();
+    const weeksInWindow = Math.max(1, Math.round(windowMs / (1000 * 60 * 60 * 24 * 7)));
+    let recentMeters = 0;
+    for (const w of workouts) {
+      const t = parsedDate(w);
+      if (t >= windowStart && t < thisMonday) {
+        recentMeters += w.distance;
+      }
+    }
+    currentAvgPace = Math.floor(recentMeters / weeksInWindow);
+  }
   const targetWeekly = target / totalWeeks;
   const onPace = currentAvgPace >= targetWeekly;