@richhaase/c2 0.1.1

package/src/models.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test";
+import type { Workout } from "./models.ts";
+import { calendarDay, pace500m, pace500mSeconds, parsedDate } from "./models.ts";
+
+function makeWorkout(overrides: Partial<Workout> = {}): Workout {
+  return {
+    id: 1,
+    user_id: 1,
+    date: "2026-03-07 09:21:00",
+    distance: 5500,
+    type: "rower",
+    time: 19122,
+    time_formatted: "31:52.2",
+    ...overrides,
+  };
+}
+
+describe("parsedDate", () => {
+  test("parses workout date string", () => {
+    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.getDate()).toBe(7);
+    expect(d.getHours()).toBe(9);
+    expect(d.getMinutes()).toBe(21);
+  });
+});
+
+describe("calendarDay", () => {
+  test("extracts date portion", () => {
+    const w = makeWorkout({ date: "2026-03-07 09:21:00" });
+    expect(calendarDay(w)).toBe("2026-03-07");
+  });
+});
+
+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);
+  });
+
+  test("returns 0 for zero distance", () => {
+    const w = makeWorkout({ distance: 0 });
+    expect(pace500mSeconds(w)).toBe(0);
+  });
+
+  test("returns 0 for zero time", () => {
+    const w = makeWorkout({ time: 0 });
+    expect(pace500mSeconds(w)).toBe(0);
+  });
+});
+
+describe("pace500m", () => {
+  test("formats pace as M:SS.S", () => {
+    const w = makeWorkout({ distance: 5500, time: 19122 });
+    expect(pace500m(w)).toBe("2:53.8");
+  });
+
+  test("returns dash for zero values", () => {
+    const w = makeWorkout({ distance: 0, time: 0 });
+    expect(pace500m(w)).toBe("-");
+  });
+
+  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");
+  });
+});

package/src/models.ts

@@ -0,0 +1,93 @@
+export interface HeartRate {
+  average?: number;
+  min?: number;
+  max?: number;
+}
+
+/** A single result from the Concept2 Logbook API. Time is in tenths of a second. */
+export interface Workout {
+  id: number;
+  user_id: number;
+  date: string; // "2026-03-02 17:41:00"
+  timezone?: string;
+  distance: number;
+  type: string; // "rower"
+  time: number; // tenths of a second
+  time_formatted: string;
+  workout_type?: string;
+  source?: string;
+  weight_class?: string;
+  stroke_rate?: number;
+  stroke_count?: number;
+  calories_total?: number;
+  drag_factor?: number;
+  heart_rate?: HeartRate;
+  stroke_data?: boolean;
+  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
+}
+
+export interface UserProfile {
+  id: number;
+  username: string;
+  first_name?: string;
+  last_name?: string;
+  email?: string;
+}
+
+export interface UserResponse {
+  data: UserProfile;
+}
+
+export interface Pagination {
+  total: number;
+  count: number;
+  per_page: number;
+  current_page: number;
+  total_pages: number;
+}
+
+export interface ResultsMeta {
+  pagination?: Pagination;
+}
+
+export interface ResultsResponse {
+  data: Workout[];
+  meta?: ResultsMeta;
+}
+
+/** API wraps stroke data in {"data": [...]} */
+export interface StrokeDataResponse {
+  data: StrokeData[];
+}
+
+const TENTHS_PER_SECOND = 10;
+const PACE_DISTANCE = 500;
+
+export function parsedDate(w: Workout): Date {
+  return new Date(w.date.replace(" ", "T"));
+}
+
+export function calendarDay(w: Workout): string {
+  return w.date.slice(0, 10);
+}
+
+export function pace500mSeconds(w: Workout): number {
+  if (w.distance === 0 || w.time === 0) return 0;
+  return (w.time / TENTHS_PER_SECOND) * (PACE_DISTANCE / w.distance);
+}
+
+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 `${mins}:${rem.toFixed(1).padStart(4, "0")}`;
+}

package/src/sessions.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from "bun:test";
+import type { Workout } from "./models.ts";
+import { groupIntoSessions, sessionCount } from "./sessions.ts";
+
+function makeWorkout(id: number, date: string, distance: number): Workout {
+  return {
+    id,
+    user_id: 1,
+    date,
+    distance,
+    type: "rower",
+    time: Math.round(distance * 3.5),
+    time_formatted: "0:00.0",
+  };
+}
+
+describe("groupIntoSessions", () => {
+  test("groups 3 workouts on same day into 1 session", () => {
+    const workouts = [
+      makeWorkout(1, "2026-03-07 09:21:00", 1000),
+      makeWorkout(2, "2026-03-07 09:45:00", 2500),
+      makeWorkout(3, "2026-03-07 09:53:00", 1000),
+    ];
+    const sessions = groupIntoSessions(workouts);
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0]!.date).toBe("2026-03-07");
+    expect(sessions[0]!.totalDistance).toBe(4500);
+    expect(sessions[0]!.workouts).toHaveLength(3);
+  });
+
+  test("keeps different days as separate sessions", () => {
+    const workouts = [
+      makeWorkout(1, "2026-03-05 10:00:00", 5000),
+      makeWorkout(2, "2026-03-07 09:00:00", 5000),
+    ];
+    const sessions = groupIntoSessions(workouts);
+    expect(sessions).toHaveLength(2);
+    expect(sessions[0]!.date).toBe("2026-03-05");
+    expect(sessions[1]!.date).toBe("2026-03-07");
+  });
+
+  test("sorts sessions by date", () => {
+    const workouts = [
+      makeWorkout(2, "2026-03-07 09:00:00", 5000),
+      makeWorkout(1, "2026-03-05 10:00:00", 5000),
+    ];
+    const sessions = groupIntoSessions(workouts);
+    expect(sessions[0]!.date).toBe("2026-03-05");
+    expect(sessions[1]!.date).toBe("2026-03-07");
+  });
+
+  test("single workout produces single session", () => {
+    const workouts = [makeWorkout(1, "2026-03-07 09:00:00", 5500)];
+    const sessions = groupIntoSessions(workouts);
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0]!.totalDistance).toBe(5500);
+    expect(sessions[0]!.workouts).toHaveLength(1);
+  });
+
+  test("empty input returns empty array", () => {
+    expect(groupIntoSessions([])).toEqual([]);
+  });
+});
+
+describe("sessionCount", () => {
+  test("counts unique calendar days", () => {
+    const workouts = [
+      makeWorkout(1, "2026-03-07 09:21:00", 1000),
+      makeWorkout(2, "2026-03-07 09:45:00", 2500),
+      makeWorkout(3, "2026-03-07 09:53:00", 1000),
+      makeWorkout(4, "2026-03-05 14:00:00", 5000),
+    ];
+    expect(sessionCount(workouts)).toBe(2);
+  });
+
+  test("returns 0 for empty list", () => {
+    expect(sessionCount([])).toBe(0);
+  });
+});

package/src/sessions.ts

@@ -0,0 +1,38 @@
+import type { Workout } from "./models.ts";
+import { calendarDay } from "./models.ts";
+
+export interface Session {
+  date: string; // "2026-03-07"
+  workouts: Workout[];
+  totalDistance: number;
+  totalTime: number; // tenths of seconds
+}
+
+export function groupIntoSessions(workouts: Workout[]): Session[] {
+  const byDay = new Map<string, Workout[]>();
+
+  for (const w of workouts) {
+    const day = calendarDay(w);
+    const existing = byDay.get(day);
+    if (existing) {
+      existing.push(w);
+    } else {
+      byDay.set(day, [w]);
+    }
+  }
+
+  return Array.from(byDay.entries())
+    .map(([date, ws]) => ({
+      date,
+      workouts: ws.sort((a, b) => a.date.localeCompare(b.date)),
+      totalDistance: ws.reduce((sum, w) => sum + w.distance, 0),
+      totalTime: ws.reduce((sum, w) => sum + w.time, 0),
+    }))
+    .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

@@ -0,0 +1,161 @@
+import { describe, expect, test } from "bun:test";
+import type { Config } from "./config.ts";
+import { defaultConfig } from "./config.ts";
+import type { Workout } from "./models.ts";
+import { buildWeekSummaries, computeGoalProgress, mondayOf, workoutsInRange } from "./stats.ts";
+
+function makeWorkout(id: number, date: string, distance: number, time?: number): Workout {
+  return {
+    id,
+    user_id: 1,
+    date,
+    distance,
+    type: "rower",
+    time: time ?? Math.round(distance * 3.5),
+    time_formatted: "0:00.0",
+  };
+}
+
+function makeGoalConfig(overrides: Partial<Config["goal"]> = {}): Config {
+  const cfg = defaultConfig();
+  cfg.goal = {
+    ...cfg.goal,
+    start_date: "2026-01-01",
+    end_date: "2026-12-31",
+    target_meters: 1_000_000,
+    ...overrides,
+  };
+  return cfg;
+}
+
+describe("mondayOf", () => {
+  test("monday returns same date", () => {
+    const d = new Date(2026, 2, 2); // Mon Mar 2
+    const m = mondayOf(d);
+    expect(m.getDay()).toBe(1); // Monday
+    expect(m.getDate()).toBe(2);
+  });
+
+  test("wednesday returns previous monday", () => {
+    const d = new Date(2026, 2, 4); // Wed Mar 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 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 m = mondayOf(d);
+    expect(m.getDay()).toBe(1);
+    expect(m.getTime()).toBeLessThanOrEqual(d.getTime());
+  });
+});
+
+describe("workoutsInRange", () => {
+  test("filters workouts within date range", () => {
+    const workouts = [
+      makeWorkout(1, "2026-01-15 10:00:00", 5000),
+      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 result = workoutsInRange(workouts, from, to);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.id).toBe(2);
+  });
+
+  test("returns empty for no matches", () => {
+    const workouts = [makeWorkout(1, "2026-06-15 10:00:00", 5000)];
+    const from = new Date(2026, 0, 1);
+    const to = new Date(2026, 1, 1);
+    expect(workoutsInRange(workouts, from, to)).toHaveLength(0);
+  });
+});
+
+describe("buildWeekSummaries", () => {
+  test("buckets workouts into correct weeks", () => {
+    const now = new Date(2026, 2, 7); // Sat Mar 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
+    ];
+    const summaries = buildWeekSummaries(workouts, now, 2);
+    expect(summaries).toHaveLength(2);
+    expect(summaries[0]!.meters).toBe(6000);
+    expect(summaries[1]!.meters).toBe(5000);
+  });
+
+  test("counts sessions as unique days", () => {
+    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
+    ];
+    const summaries = buildWeekSummaries(workouts, now, 1);
+    expect(summaries[0]!.meters).toBe(6000);
+    expect(summaries[0]!.sessions).toBe(2); // 2 unique days
+  });
+
+  test("returns empty summaries for no workouts", () => {
+    const now = new Date(2026, 2, 7);
+    const summaries = buildWeekSummaries([], now, 4);
+    expect(summaries).toHaveLength(4);
+    expect(summaries.every((s) => s.meters === 0)).toBe(true);
+  });
+});
+
+describe("computeGoalProgress", () => {
+  test("computes progress for mid-season", () => {
+    const cfg = makeGoalConfig();
+    const workouts = [
+      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 goal = computeGoalProgress(workouts, cfg, now);
+    expect(goal.totalMeters).toBe(200_000);
+    expect(goal.target).toBe(1_000_000);
+    expect(goal.progress).toBeCloseTo(0.2, 2);
+    expect(goal.remainingMeters).toBe(800_000);
+    expect(goal.weeksElapsed).toBeGreaterThan(0);
+  });
+
+  test("clamps remainingMeters to 0 when goal exceeded", () => {
+    const cfg = makeGoalConfig({ target_meters: 100_000 });
+    const workouts = [makeWorkout(1, "2026-03-01 10:00:00", 150_000)];
+    const now = new Date(2026, 2, 7);
+    const goal = computeGoalProgress(workouts, cfg, now);
+    expect(goal.remainingMeters).toBe(0);
+    expect(goal.progress).toBeGreaterThan(1);
+  });
+
+  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
+    ];
+    const now = new Date(2026, 2, 7);
+    const goal = computeGoalProgress(workouts, cfg, now);
+    expect(goal.totalMeters).toBe(100_000);
+  });
+
+  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 goal = computeGoalProgress(workouts, cfg, now);
+    expect(goal.weeksElapsed).toBe(0);
+    expect(goal.currentAvgPace).toBe(0);
+  });
+});

package/src/stats.ts

@@ -0,0 +1,150 @@
+import type { Config } from "./config.ts";
+import { parseGoalDate } from "./config.ts";
+import type { Workout } from "./models.ts";
+import { calendarDay, pace500mSeconds, parsedDate } from "./models.ts";
+
+export interface WeekSummary {
+  weekStart: Date;
+  meters: number;
+  sessions: number;
+  paceSum: number;
+  paceCount: number;
+  spmSum: number;
+  spmCount: number;
+  hrSum: number;
+  hrCount: number;
+}
+
+export interface GoalProgress {
+  target: number;
+  totalMeters: number;
+  progress: number; // ratio 0–1
+  weeksElapsed: number;
+  totalWeeks: number;
+  remainingMeters: number;
+  remainingWeeks: number;
+  requiredPace: number; // meters/week needed going forward
+  currentAvgPace: number; // meters/week so far
+  onPace: boolean;
+}
+
+export function mondayOf(t: Date): Date {
+  const d = new Date(t.getFullYear(), t.getMonth(), t.getDate());
+  const offset = (d.getDay() + 6) % 7;
+  d.setDate(d.getDate() - offset);
+  return d;
+}
+
+export function workoutsInRange(workouts: Workout[], from: Date, to: Date): Workout[] {
+  return workouts.filter((w) => {
+    const t = parsedDate(w);
+    return t >= from && t < to;
+  });
+}
+
+export function buildWeekSummaries(workouts: Workout[], now: Date, weeks: number): WeekSummary[] {
+  const thisMonday = mondayOf(now);
+  const cutoff = new Date(thisMonday);
+  cutoff.setDate(cutoff.getDate() - (weeks - 1) * 7);
+
+  const summaries: WeekSummary[] = [];
+  for (let i = 0; i < weeks; i++) {
+    const ws = new Date(thisMonday);
+    ws.setDate(ws.getDate() - (weeks - 1 - i) * 7);
+    summaries.push({
+      weekStart: ws,
+      meters: 0,
+      sessions: 0,
+      paceSum: 0,
+      paceCount: 0,
+      spmSum: 0,
+      spmCount: 0,
+      hrSum: 0,
+      hrCount: 0,
+    });
+  }
+
+  const daysByWeek = new Map<number, Set<string>>();
+
+  for (const w of workouts) {
+    const t = new Date(w.date.replace(" ", "T"));
+    if (t < cutoff || t > now) continue;
+
+    const monday = mondayOf(t);
+    const idx = Math.floor((monday.getTime() - cutoff.getTime()) / (1000 * 60 * 60 * 24 * 7));
+    if (idx < 0 || idx >= weeks) continue;
+
+    const ws = summaries[idx]!;
+    ws.meters += w.distance;
+
+    if (!daysByWeek.has(idx)) daysByWeek.set(idx, new Set());
+    daysByWeek.get(idx)!.add(calendarDay(w));
+
+    const pace = pace500mSeconds(w);
+    if (pace > 0) {
+      ws.paceSum += pace;
+      ws.paceCount++;
+    }
+    if (w.stroke_rate && w.stroke_rate > 0) {
+      ws.spmSum += w.stroke_rate;
+      ws.spmCount++;
+    }
+    if (w.heart_rate?.average && w.heart_rate.average > 0) {
+      ws.hrSum += w.heart_rate.average;
+      ws.hrCount++;
+    }
+  }
+
+  for (const [idx, days] of daysByWeek) {
+    summaries[idx]!.sessions = days.size;
+  }
+
+  return summaries;
+}
+
+export function computeGoalProgress(workouts: Workout[], cfg: Config, now?: Date): GoalProgress {
+  const target = cfg.goal.target_meters;
+  const start = parseGoalDate(cfg.goal.start_date);
+  const end = parseGoalDate(cfg.goal.end_date);
+  const today = now ?? new Date();
+
+  let totalMeters = 0;
+  for (const w of workouts) {
+    const t = parsedDate(w);
+    if (t >= start && t <= end) {
+      totalMeters += w.distance;
+    }
+  }
+
+  const progress = totalMeters / target;
+  const totalDays = (end.getTime() - start.getTime()) / (1000 * 60 * 60 * 24);
+  const totalWeeks = Math.ceil(totalDays / 7);
+
+  let weeksElapsed = 0;
+  if (today > start) {
+    weeksElapsed = Math.floor((today.getTime() - start.getTime()) / (1000 * 60 * 60 * 24 * 7));
+  }
+
+  let remainingMeters = target - totalMeters;
+  if (remainingMeters < 0) remainingMeters = 0;
+  let remainingWeeks = totalWeeks - weeksElapsed;
+  if (remainingWeeks < 1) remainingWeeks = 1;
+  const requiredPace = Math.floor(remainingMeters / remainingWeeks);
+
+  const currentAvgPace = weeksElapsed > 0 ? Math.floor(totalMeters / weeksElapsed) : 0;
+  const targetWeekly = target / totalWeeks;
+  const onPace = currentAvgPace >= targetWeekly;
+
+  return {
+    target,
+    totalMeters,
+    progress,
+    weeksElapsed,
+    totalWeeks,
+    remainingMeters,
+    remainingWeeks,
+    requiredPace,
+    currentAvgPace,
+    onPace,
+  };
+}

package/src/storage.ts

@@ -0,0 +1,75 @@
+import { appendFile, readFile, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { dataDir } from "./config.ts";
+import type { StrokeData, Workout } from "./models.ts";
+
+function workoutsPath(): string {
+  return join(dataDir(), "workouts.jsonl");
+}
+
+function strokesPath(workoutId: number): string {
+  return join(dataDir(), "strokes", `${workoutId}.jsonl`);
+}
+
+export async function readWorkouts(): Promise<Workout[]> {
+  try {
+    const text = await readFile(workoutsPath(), "utf-8");
+    return text
+      .split("\n")
+      .filter((line) => line.trim() !== "")
+      .map((line) => JSON.parse(line) as Workout);
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return [];
+    throw err;
+  }
+}
+
+export async function appendWorkouts(newWorkouts: Workout[]): Promise<number> {
+  const existing = await readWorkouts();
+  const seen = new Set(existing.map((w) => w.id));
+
+  const toWrite = newWorkouts.filter((w) => !seen.has(w.id));
+  if (toWrite.length === 0) return 0;
+
+  const lines = `${toWrite.map((w) => JSON.stringify(w)).join("\n")}\n`;
+  await appendFile(workoutsPath(), lines, "utf-8");
+  return toWrite.length;
+}
+
+export async function workoutCount(): Promise<number> {
+  try {
+    const text = await readFile(workoutsPath(), "utf-8");
+    return text.split("\n").filter((line) => line.trim() !== "").length;
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return 0;
+    throw err;
+  }
+}
+
+export async function hasStrokeData(workoutId: number): Promise<boolean> {
+  try {
+    await stat(strokesPath(workoutId));
+    return true;
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw err;
+  }
+}
+
+export async function writeStrokeData(workoutId: number, strokes: StrokeData[]): Promise<void> {
+  const lines = `${strokes.map((s) => JSON.stringify(s)).join("\n")}\n`;
+  await writeFile(strokesPath(workoutId), lines, "utf-8");
+}
+
+export async function readStrokeData(workoutId: number): Promise<StrokeData[]> {
+  try {
+    const text = await readFile(strokesPath(workoutId), "utf-8");
+    return text
+      .split("\n")
+      .filter((line) => line.trim() !== "")
+      .map((line) => JSON.parse(line) as StrokeData);
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return [];
+    throw err;
+  }
+}