@richhaase/c2 0.1.1

package/src/commands/setup.ts

@@ -0,0 +1,94 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { C2Client } from "../api/client.ts";
+import {
+  type Config,
+  configDir,
+  defaultConfig,
+  ensureDirs,
+  loadConfig,
+  parseGoalDate,
+  saveConfig,
+} from "../config.ts";
+import { formatMeters } from "../display.ts";
+
+function maskToken(token: string): string {
+  if (token.length <= 4) return token;
+  return "·".repeat(token.length - 4) + token.slice(-4);
+}
+
+function promptValue(label: string, current: string, mask = false): string {
+  const display = current ? ` [${mask ? maskToken(current) : current}]` : "";
+  const input = prompt(`${label}${display}:`);
+  return (input ?? "").trim() || current;
+}
+
+export function registerSetup(program: Command): void {
+  program
+    .command("setup")
+    .description("Configure token, goal, and preferences")
+    .action(async () => {
+      let cfg: Config;
+      try {
+        cfg = await loadConfig();
+      } catch (err) {
+        console.error(`Warning: could not load existing config: ${(err as Error).message}`);
+        console.error("Starting from defaults.");
+        cfg = defaultConfig();
+      }
+
+      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);
+      if (!Number.isNaN(parsed) && parsed > 0) {
+        cfg.goal.target_meters = parsed;
+      }
+
+      // Goal dates
+      const startInput = promptValue("Goal start date (YYYY-MM-DD)", cfg.goal.start_date);
+      try {
+        parseGoalDate(startInput);
+        cfg.goal.start_date = startInput;
+      } catch {
+        console.log(`Invalid date "${startInput}", keeping previous value.`);
+      }
+
+      const endInput = promptValue("Goal end date (YYYY-MM-DD)", cfg.goal.end_date);
+      try {
+        parseGoalDate(endInput);
+        cfg.goal.end_date = endInput;
+      } catch {
+        console.log(`Invalid date "${endInput}", keeping previous value.`);
+      }
+
+      // Save
+      await ensureDirs();
+      await saveConfig(cfg);
+      console.log(`\nConfig written to ${join(configDir(), "config.json")}`);
+
+      if (!cfg.goal.start_date || !cfg.goal.end_date) {
+        console.log(
+          "\nNote: Goal dates not set. Commands like `c2 status` require start/end dates.",
+        );
+      }
+
+      // Verify token
+      if (cfg.api.token) {
+        console.log("Verifying token...");
+        try {
+          const client = C2Client.fromConfig(cfg);
+          const user = await client.getUser();
+          console.log(`Authenticated as: ${user.username} (ID: ${user.id})`);
+        } catch (err) {
+          console.error(`Warning: could not verify token: ${(err as Error).message}`);
+        }
+      }
+    });
+}

package/src/commands/status.ts

@@ -0,0 +1,57 @@
+import type { Command } from "commander";
+import { loadConfig } from "../config.ts";
+import { formatMeters, formatMetersPerWeek, formatPercent } from "../display.ts";
+import { calendarDay } from "../models.ts";
+import { computeGoalProgress, mondayOf, workoutsInRange } from "../stats.ts";
+import { readWorkouts } from "../storage.ts";
+
+export function registerStatus(program: Command): void {
+  program
+    .command("status")
+    .description("Show progress toward your distance goal")
+    .action(async () => {
+      const cfg = await loadConfig();
+      if (!cfg.goal.start_date || !cfg.goal.end_date) {
+        console.error("Goal dates not configured. Run `c2 setup` to set start and end dates.");
+        process.exit(1);
+      }
+      const workouts = await readWorkouts();
+      if (workouts.length === 0) {
+        console.log("No workouts found. Run `c2 sync` first.");
+        return;
+      }
+      const goal = computeGoalProgress(workouts, cfg);
+
+      console.log(`Goal: ${formatMeters(goal.target)}m`);
+      console.log(`Season start: ${cfg.goal.start_date}`);
+      console.log(
+        `Progress: ${formatMeters(goal.totalMeters)} / ${formatMeters(goal.target)} (${formatPercent(goal.progress)})`,
+      );
+      console.log(`Weeks elapsed: ${goal.weeksElapsed} / ${goal.totalWeeks}`);
+      console.log(`Required pace: ${formatMetersPerWeek(goal.requiredPace)}`);
+      console.log();
+
+      const today = new Date();
+      console.log("Last 4 weeks:");
+      for (let i = 0; i < 4; i++) {
+        const weekStart = mondayOf(today);
+        weekStart.setDate(weekStart.getDate() - i * 7);
+        const weekEnd = new Date(weekStart);
+        weekEnd.setDate(weekEnd.getDate() + 7);
+
+        const weekWorkouts = workoutsInRange(workouts, weekStart, weekEnd);
+        const meters = weekWorkouts.reduce((sum, w) => sum + w.distance, 0);
+        const sessions = new Set(weekWorkouts.map(calendarDay)).size;
+
+        const mm = String(weekStart.getMonth() + 1).padStart(2, "0");
+        const dd = String(weekStart.getDate()).padStart(2, "0");
+        console.log(`  Week of ${mm}/${dd}: ${formatMeters(meters)} (${sessions} sessions)`);
+      }
+      console.log();
+
+      if (goal.weeksElapsed > 0) {
+        const indicator = goal.onPace ? "on pace \u2713" : "behind pace \u2717";
+        console.log(`Current avg: ${formatMetersPerWeek(goal.currentAvgPace)} \u2014 ${indicator}`);
+      }
+    });
+}

package/src/commands/sync.ts

@@ -0,0 +1,68 @@
+import type { Command } from "commander";
+import { C2Client } from "../api/client.ts";
+import { ensureDirs, loadConfig, saveConfig } from "../config.ts";
+import type { Workout } from "../models.ts";
+import { appendWorkouts, hasStrokeData, workoutCount, writeStrokeData } from "../storage.ts";
+
+async function syncStrokes(client: C2Client, workouts: Workout[]): Promise<number> {
+  let count = 0;
+  let failures = 0;
+  for (const w of workouts) {
+    if (!w.stroke_data || (await hasStrokeData(w.id))) continue;
+    try {
+      const strokes = await client.getStrokes(w.id);
+      if (strokes.length > 0) {
+        await writeStrokeData(w.id, strokes);
+        count++;
+      }
+    } catch (err) {
+      failures++;
+      console.error(
+        `Warning: failed to fetch strokes for workout ${w.id}: ${(err as Error).message}`,
+      );
+      if (failures >= 3) {
+        console.error("Too many failures, skipping remaining stroke data.");
+        break;
+      }
+    }
+  }
+  return count;
+}
+
+export function registerSync(program: Command): void {
+  program
+    .command("sync")
+    .description("Pull new workouts from the API")
+    .action(async () => {
+      const cfg = await loadConfig();
+      if (!cfg.api.token) {
+        console.error("No API token configured. Run `c2 setup` first.");
+        process.exit(1);
+      }
+      await ensureDirs();
+
+      const client = C2Client.fromConfig(cfg);
+      const from = cfg.sync.last_sync ?? "";
+
+      if (from) {
+        console.log(`Syncing workouts since ${from}...`);
+      } else {
+        console.log("First sync \u2014 pulling all workouts...");
+      }
+
+      const workouts = await client.getAllResults(from, "");
+      const written = await appendWorkouts(workouts);
+      console.log(`Fetched ${workouts.length} workouts, ${written} new.`);
+
+      const strokeCount = await syncStrokes(client, workouts);
+      if (strokeCount > 0) {
+        console.log(`Fetched stroke data for ${strokeCount} workouts.`);
+      }
+
+      cfg.sync.last_sync = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+      await saveConfig(cfg);
+
+      const total = await workoutCount();
+      console.log(`Total workouts: ${total}`);
+    });
+}

package/src/commands/trend.ts

@@ -0,0 +1,112 @@
+import type { Command } from "commander";
+import { formatMeters, paceArrow, sparkBar, trendArrow } from "../display.ts";
+import { buildWeekSummaries, type WeekSummary } from "../stats.ts";
+import { readWorkouts } from "../storage.ts";
+
+function fmtDate(d: Date): string {
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${mm}/${dd}`;
+}
+
+function maxMeters(summaries: WeekSummary[]): number {
+  let max = 0;
+  for (const ws of summaries) {
+    if (ws.meters > max) max = ws.meters;
+  }
+  return max;
+}
+
+function printVolumeTrend(summaries: WeekSummary[]): void {
+  console.log("Volume (meters/week):");
+  let prevMeters = 0;
+  for (const ws of summaries) {
+    const arrow = trendArrow(prevMeters, ws.meters);
+    const bar = sparkBar(ws.meters, maxMeters(summaries));
+    console.log(
+      `  ${fmtDate(ws.weekStart)}  ${arrow} ${formatMeters(ws.meters).padStart(7)}  ${bar}  (${ws.sessions} sessions)`,
+    );
+    prevMeters = ws.meters;
+  }
+}
+
+function printPaceTrend(summaries: WeekSummary[]): void {
+  console.log("Avg Pace (/500m):");
+  let prevPace = 0;
+  for (const ws of summaries) {
+    if (ws.paceCount === 0) {
+      console.log(`  ${fmtDate(ws.weekStart)}    -`);
+      continue;
+    }
+    const avgPace = ws.paceSum / ws.paceCount;
+    const arrow = paceArrow(prevPace, avgPace);
+    const mins = Math.floor(avgPace / 60);
+    const secs = avgPace - mins * 60;
+    console.log(`  ${fmtDate(ws.weekStart)}  ${arrow} ${mins}:${secs.toFixed(1).padStart(4, "0")}`);
+    prevPace = avgPace;
+  }
+}
+
+function printSPMTrend(summaries: WeekSummary[]): void {
+  console.log("Avg Stroke Rate (spm):");
+  let prevSPM = 0;
+  for (const ws of summaries) {
+    if (ws.spmCount === 0) {
+      console.log(`  ${fmtDate(ws.weekStart)}    -`);
+      continue;
+    }
+    const avg = ws.spmSum / ws.spmCount;
+    const arrow = trendArrow(prevSPM, avg);
+    console.log(`  ${fmtDate(ws.weekStart)}  ${arrow} ${avg.toFixed(1).padStart(4)}`);
+    prevSPM = avg;
+  }
+}
+
+function printHRTrend(summaries: WeekSummary[]): void {
+  console.log("Avg Heart Rate (bpm):");
+  let hasAny = false;
+  let prevHR = 0;
+  for (const ws of summaries) {
+    if (ws.hrCount === 0) {
+      console.log(`  ${fmtDate(ws.weekStart)}    -`);
+      continue;
+    }
+    hasAny = true;
+    const avg = ws.hrSum / ws.hrCount;
+    const arrow = trendArrow(prevHR, avg);
+    console.log(`  ${fmtDate(ws.weekStart)}  ${arrow} ${avg.toFixed(1).padStart(5)}`);
+    prevHR = avg;
+  }
+  if (!hasAny) {
+    console.log("  No heart rate data available.");
+  }
+}
+
+export function registerTrend(program: Command): void {
+  program
+    .command("trend")
+    .description("Show training trends over time")
+    .option("-w, --weeks <n>", "number of weeks to display", "8")
+    .action(async (opts: { weeks: string }) => {
+      const workouts = await readWorkouts();
+      if (workouts.length === 0) {
+        console.log("No workouts found. Run `c2 sync` first.");
+        return;
+      }
+
+      const weeks = parseInt(opts.weeks, 10);
+      if (Number.isNaN(weeks) || weeks < 1) {
+        console.error("Error: --weeks must be a positive integer.");
+        process.exit(1);
+      }
+      const summaries = buildWeekSummaries(workouts, new Date(), weeks);
+
+      printVolumeTrend(summaries);
+      console.log();
+      printPaceTrend(summaries);
+      console.log();
+      printSPMTrend(summaries);
+      console.log();
+      printHRTrend(summaries);
+    });
+}

package/src/config.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+import { defaultConfig, parseGoalDate } from "./config.ts";
+
+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.getDate()).toBe(7);
+  });
+
+  test("throws on empty string", () => {
+    expect(() => parseGoalDate("")).toThrow("Invalid date");
+  });
+
+  test("throws on malformed string", () => {
+    expect(() => parseGoalDate("not-a-date")).toThrow("Invalid date");
+  });
+});
+
+describe("defaultConfig", () => {
+  test("returns expected defaults", () => {
+    const cfg = defaultConfig();
+    expect(cfg.api.base_url).toBe("https://log.concept2.com");
+    expect(cfg.api.token).toBe("");
+    expect(cfg.sync.machine_type).toBe("rower");
+    expect(cfg.goal.target_meters).toBe(1_000_000);
+    expect(cfg.goal.start_date).toBe("");
+    expect(cfg.goal.end_date).toBe("");
+    expect(cfg.display.date_format).toBe("%m/%d");
+  });
+});

package/src/config.ts

@@ -0,0 +1,64 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export interface Config {
+  api: { base_url: string; token: string };
+  sync: { last_sync?: string; machine_type: string };
+  goal: { target_meters: number; start_date: string; end_date: string };
+  display: { date_format: string };
+}
+
+export function defaultConfig(): Config {
+  return {
+    api: { base_url: "https://log.concept2.com", token: "" },
+    sync: { machine_type: "rower" },
+    goal: { target_meters: 1_000_000, start_date: "", end_date: "" },
+    display: { date_format: "%m/%d" },
+  };
+}
+
+export function configDir(): string {
+  return join(homedir(), ".config", "c2cli");
+}
+
+export function dataDir(): string {
+  return join(configDir(), "data");
+}
+
+export async function ensureDirs(): Promise<void> {
+  await mkdir(join(dataDir(), "strokes"), { recursive: true });
+}
+
+export async function loadConfig(): Promise<Config> {
+  const path = join(configDir(), "config.json");
+  const defaults = defaultConfig();
+  try {
+    const text = await readFile(path, "utf-8");
+    const parsed = JSON.parse(text) as Partial<Config>;
+    return {
+      api: { ...defaults.api, ...parsed.api },
+      sync: { ...defaults.sync, ...parsed.sync },
+      goal: { ...defaults.goal, ...parsed.goal },
+      display: { ...defaults.display, ...parsed.display },
+    };
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+      return defaults;
+    }
+    throw err;
+  }
+}
+
+export async function saveConfig(cfg: Config): Promise<void> {
+  const path = join(configDir(), "config.json");
+  await mkdir(configDir(), { recursive: true });
+  const text = JSON.stringify(cfg, null, 2);
+  await writeFile(path, `${text}\n`, "utf-8");
+}
+
+export function parseGoalDate(s: string): Date {
+  const d = new Date(`${s}T00:00:00`);
+  if (Number.isNaN(d.getTime())) throw new Error(`Invalid date: ${s}`);
+  return d;
+}

package/src/display.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from "bun:test";
+import {
+  formatMeters,
+  formatMetersPerWeek,
+  formatPercent,
+  paceArrow,
+  sparkBar,
+  trendArrow,
+} from "./display.ts";
+
+describe("formatMeters", () => {
+  test.each([
+    [0, "0"],
+    [500, "500"],
+    [1000, "1,000"],
+    [12345, "12,345"],
+    [1000000, "1,000,000"],
+  ])("formatMeters(%i) = %s", (input, expected) => {
+    expect(formatMeters(input)).toBe(expected);
+  });
+});
+
+describe("formatPercent", () => {
+  test.each([
+    [0, "0.0%"],
+    [0.5, "50.0%"],
+    [1.0, "100.0%"],
+    [0.1234, "12.3%"],
+    [0.131, "13.1%"],
+  ])("formatPercent(%f) = %s", (input, expected) => {
+    expect(formatPercent(input)).toBe(expected);
+  });
+});
+
+describe("formatMetersPerWeek", () => {
+  test("formats with unit", () => {
+    expect(formatMetersPerWeek(20212)).toBe("20,212m/week");
+  });
+});
+
+describe("sparkBar", () => {
+  test("returns empty string when max is 0", () => {
+    expect(sparkBar(100, 0)).toBe("");
+  });
+
+  test("returns full bar for max value", () => {
+    const bar = sparkBar(100, 100);
+    expect(bar).toBe("\u2588".repeat(20));
+  });
+
+  test("returns half bar for 50%", () => {
+    const bar = sparkBar(50, 100);
+    expect(bar.length).toBe(20);
+    expect(bar).toBe("\u2588".repeat(10) + "\u2591".repeat(10));
+  });
+});
+
+describe("trendArrow", () => {
+  test("returns space when prev is 0", () => {
+    expect(trendArrow(0, 100)).toBe(" ");
+  });
+
+  test("returns up arrow for increase", () => {
+    expect(trendArrow(100, 110)).toBe("\u2191");
+  });
+
+  test("returns down arrow for decrease", () => {
+    expect(trendArrow(100, 90)).toBe("\u2193");
+  });
+
+  test("returns right arrow for stable", () => {
+    expect(trendArrow(100, 101)).toBe("\u2192");
+  });
+});
+
+describe("paceArrow", () => {
+  test("reversed: lower pace shows up arrow (improvement)", () => {
+    expect(paceArrow(180, 170)).toBe("\u2191");
+  });
+
+  test("reversed: higher pace shows down arrow", () => {
+    expect(paceArrow(170, 180)).toBe("\u2193");
+  });
+});

package/src/display.ts

@@ -0,0 +1,67 @@
+import type { Workout } from "./models.ts";
+import { pace500m, parsedDate } from "./models.ts";
+
+export function formatMeters(m: number): string {
+  return m.toLocaleString("en-US");
+}
+
+export function formatPercent(ratio: number): string {
+  return `${(ratio * 100).toFixed(1)}%`;
+}
+
+export function formatMetersPerWeek(m: number): string {
+  return `${formatMeters(m)}m/week`;
+}
+
+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");
+    return `${mm}/${dd}`;
+  }
+  if (fmt === "%Y-%m-%d") {
+    const y = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    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}`;
+}
+
+export function formatWorkoutLine(w: Workout, dateFormat: string): string {
+  const d = parsedDate(w);
+  const dateStr = formatDate(d, dateFormat);
+  const distance = `${formatMeters(w.distance)}m`;
+  const pace = pace500m(w);
+  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` : "-";
+
+  return `${dateStr}  ${distance.padStart(7)}  ${w.time_formatted.padStart(8)}  ${pace.padStart(7)}/500m  ${spm.padStart(5)}  ${hr.padStart(6)}  ${df.padStart(4)}`;
+}
+
+export function sparkBar(value: number, max: number): string {
+  if (max === 0) return "";
+  const BAR_WIDTH = 20;
+  const filled = Math.round((value / max) * BAR_WIDTH);
+  return "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH - filled);
+}
+
+const TREND_THRESHOLD = 0.02;
+
+export function trendArrow(prev: number, curr: number): string {
+  if (prev === 0) return " ";
+  const diff = (curr - prev) / prev;
+  if (diff > TREND_THRESHOLD) return "\u2191";
+  if (diff < -TREND_THRESHOLD) return "\u2193";
+  return "\u2192";
+}
+
+export function paceArrow(prev: number, curr: number): string {
+  if (prev === 0) return " ";
+  return trendArrow(curr, prev); // reversed: lower pace is better
+}

package/src/export.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from "bun:test";
+import { escapeCSV, filterByDate } from "./commands/export.ts";
+import type { Workout } from "./models.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("escapeCSV", () => {
+  test("passes through plain string", () => {
+    expect(escapeCSV("hello")).toBe("hello");
+  });
+
+  test("quotes string with commas", () => {
+    expect(escapeCSV("a,b")).toBe('"a,b"');
+  });
+
+  test("escapes double quotes", () => {
+    expect(escapeCSV('say "hi"')).toBe('"say ""hi"""');
+  });
+
+  test("quotes string with newlines", () => {
+    expect(escapeCSV("line1\nline2")).toBe('"line1\nline2"');
+  });
+
+  test("handles empty string", () => {
+    expect(escapeCSV("")).toBe("");
+  });
+});
+
+describe("filterByDate", () => {
+  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),
+  ];
+
+  test("filters with both from and to", () => {
+    const result = filterByDate(workouts, "2026-02-01", "2026-02-28");
+    expect(result).toHaveLength(1);
+    expect(result[0]!.id).toBe(2);
+  });
+
+  test("filters with from only", () => {
+    const result = filterByDate(workouts, "2026-02-01", "");
+    expect(result).toHaveLength(2);
+    expect(result[0]!.id).toBe(2);
+    expect(result[1]!.id).toBe(3);
+  });
+
+  test("filters with to only", () => {
+    const result = filterByDate(workouts, "", "2026-02-28");
+    expect(result).toHaveLength(2);
+    expect(result[0]!.id).toBe(1);
+    expect(result[1]!.id).toBe(2);
+  });
+
+  test("returns all when no bounds", () => {
+    const result = filterByDate(workouts, "", "");
+    expect(result).toHaveLength(3);
+  });
+});

package/src/index.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import pkg from "../package.json";
+import { registerExport } from "./commands/export.ts";
+import { registerLog } from "./commands/log.ts";
+import { registerReport } from "./commands/report.ts";
+import { registerSetup } from "./commands/setup.ts";
+import { registerStatus } from "./commands/status.ts";
+import { registerSync } from "./commands/sync.ts";
+import { registerTrend } from "./commands/trend.ts";
+
+const program = new Command()
+  .name("c2")
+  .description("Concept2 Logbook CLI")
+  .version(pkg.version, "-v, --version");
+
+registerSetup(program);
+registerSync(program);
+registerLog(program);
+registerStatus(program);
+registerTrend(program);
+registerExport(program);
+registerReport(program);
+
+program.parseAsync(process.argv).catch((err: Error) => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});