@richhaase/c2 0.3.2 → 0.4.0

package/src/commands/data.ts

@@ -0,0 +1,172 @@
+import { sep } from "node:path";
+import type { Command } from "commander";
+import { loadConfig, saveConfig } from "../config.ts";
+import { inspectDataDir, moveStore, storeSummary } from "../data.ts";
+import { formatMeters } from "../display.ts";
+import { runDoctor } from "../doctor.ts";
+import { printJSON } from "../envelope.ts";
+import { compactNotes } from "../notes.ts";
+import { canonicalRoot, dataPaths, pathsFor } from "../paths.ts";
+
+export function registerData(program: Command): void {
+  const data = program.command("data").description("Manage the c2 data store");
+
+  data
+    .command("info")
+    .description("Show data store location and contents")
+    .option("--json", "output as JSON")
+    .action(async (opts: { json?: boolean }) => {
+      const cfg = await loadConfig();
+      const paths = dataPaths(cfg);
+      const inspection = await inspectDataDir(paths);
+
+      if (inspection.state === "missing") {
+        console.error(`No data store at ${paths.root}. Run \`c2 setup\` or \`c2 sync\` first.`);
+        process.exit(1);
+      }
+      if (inspection.state === "foreign") {
+        console.error(
+          `${paths.root} exists but is not a c2 data store. Fix data_dir via \`c2 setup\`.`,
+        );
+        process.exit(1);
+      }
+      if (inspection.state === "empty") {
+        console.error(
+          `${paths.root} is an empty directory, not yet a data store. Run \`c2 sync\` to initialize it.`,
+        );
+        process.exit(1);
+      }
+
+      const summary = await storeSummary(paths);
+      const legacyStore = summary.schemaVersion == null && summary.workouts > 0;
+      const lastSync = summary.lastSync ?? (legacyStore ? (cfg.sync.last_sync ?? null) : null);
+      if (opts.json) {
+        printJSON("c2.data.info.v1", {
+          root: paths.root,
+          state: inspection.state,
+          writable: inspection.writable,
+          schema_version: summary.schemaVersion,
+          last_sync: lastSync,
+          workouts: summary.workouts,
+          first_date: summary.firstDate || null,
+          last_date: summary.lastDate || null,
+          stroke_files: summary.strokeFiles,
+          notes: summary.notes,
+        });
+        return;
+      }
+
+      console.log(`Data store: ${paths.root}`);
+      console.log(`Schema version: ${summary.schemaVersion ?? "(no meta.json — legacy store)"}`);
+      console.log(`Last sync: ${lastSync ?? "never"}`);
+      console.log(
+        `Workouts: ${formatMeters(summary.workouts)}${summary.firstDate ? ` (${summary.firstDate} → ${summary.lastDate})` : ""}`,
+      );
+      console.log(`Stroke files: ${formatMeters(summary.strokeFiles)}`);
+      console.log(`Notes: ${formatMeters(summary.notes)}`);
+    });
+
+  data
+    .command("compact")
+    .description("Archive notes older than 7 days into yearly files")
+    .action(async () => {
+      const cfg = await loadConfig();
+      const paths = dataPaths(cfg);
+      const inspection = await inspectDataDir(paths);
+      if (inspection.state !== "store") {
+        console.error(`${paths.root} is not a c2 data store; nothing to compact.`);
+        process.exit(1);
+      }
+      if (!inspection.writable) {
+        console.error(`Cannot write to ${paths.root}.`);
+        process.exit(1);
+      }
+      const result = await compactNotes(paths, new Date());
+      for (const year of result.skippedYears) {
+        console.error(
+          `Warning: notes/archive/${year}.jsonl could not be safely rewritten; notes left loose (run \`c2 data doctor\`).`,
+        );
+      }
+      if (result.archived > 0) {
+        console.log(
+          `Compacted ${result.archived} note${result.archived === 1 ? "" : "s"} into ${result.years.map((y) => `notes/archive/${y}.jsonl`).join(", ")}.`,
+        );
+      } else if (result.skippedYears.length === 0) {
+        console.log("Nothing to compact.");
+      }
+      if (result.skippedYears.length > 0) {
+        process.exit(1);
+      }
+    });
+
+  data
+    .command("doctor")
+    .description("Validate the data store and report problems")
+    .action(async () => {
+      const cfg = await loadConfig();
+      const paths = dataPaths(cfg);
+      const inspection = await inspectDataDir(paths);
+      if (inspection.state !== "store") {
+        console.error(`No data store at ${paths.root}.`);
+        process.exit(1);
+      }
+      const report = await runDoctor(paths);
+      if (report.issues.length === 0) {
+        console.log(`OK — ${report.checkedFiles} files checked, no problems found.`);
+        return;
+      }
+      console.error(
+        `${report.issues.length} problem${report.issues.length === 1 ? "" : "s"} found:`,
+      );
+      for (const issue of report.issues) {
+        console.error(`  - ${issue}`);
+      }
+      process.exit(1);
+    });
+
+  data
+    .command("move <dir>")
+    .description("Relocate the data store and update config")
+    .action(async (dir: string) => {
+      const cfg = await loadConfig();
+      const from = pathsFor(await canonicalRoot(cfg.data_dir));
+      const source = await inspectDataDir(from);
+      if (source.state !== "store") {
+        console.error(`${from.root} is not a c2 data store; nothing to move.`);
+        process.exit(1);
+      }
+
+      const to = pathsFor(await canonicalRoot(dir));
+      if (to.root === from.root) {
+        console.error("Target is the current data directory.");
+        process.exit(1);
+      }
+      if (to.root.startsWith(from.root + sep) || from.root.startsWith(to.root + sep)) {
+        console.error("Target must not be inside the current data directory (or contain it).");
+        process.exit(1);
+      }
+
+      let copied: { files: number; bytes: number };
+      try {
+        copied = await moveStore(from, to);
+      } catch (err) {
+        console.error(`Error: ${(err as Error).message}`);
+        process.exit(1);
+      }
+      try {
+        cfg.data_dir = to.root;
+        await saveConfig(cfg);
+      } catch (err) {
+        console.error(`Error: copy completed but config update failed: ${(err as Error).message}`);
+        console.error(
+          `Set data_dir to ${to.root} in ~/.config/c2/config.json manually, or remove ${to.root} and retry.`,
+        );
+        process.exit(1);
+      }
+      console.log(
+        `Copied ${copied.files} files (${formatMeters(copied.bytes)} bytes) to ${to.root}`,
+      );
+      console.log(`Config updated: data_dir = ${to.root}`);
+      console.log(`Old data left at ${from.root} — remove it manually once satisfied.`);
+    });
+}

package/src/commands/docs.ts

@@ -0,0 +1,184 @@
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import type { Command } from "commander";
+import { loadConfig } from "../config.ts";
+import { ensureStoreForWrite, rejectForeignStore } from "../data.ts";
+import { printJSON } from "../envelope.ts";
+import { isValidYMD } from "../models.ts";
+import type { DataPaths } from "../paths.ts";
+import { dataPaths } from "../paths.ts";
+
+async function readContent(source: string | undefined): Promise<string> {
+  if (source != null && source !== "-") {
+    return readFile(source, "utf-8");
+  }
+  return new Response(Bun.stdin.stream()).text();
+}
+
+async function readIfExists(path: string): Promise<string | null> {
+  try {
+    return await readFile(path, "utf-8");
+  } catch (err: unknown) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === "ENOENT" || code === "ENOTDIR") return null;
+    throw err;
+  }
+}
+
+function registerDoc(
+  program: Command,
+  name: "plan" | "playbook",
+  description: string,
+  pathOf: (paths: DataPaths) => string,
+): void {
+  const doc = program.command(name).description(description);
+
+  doc
+    .command("show")
+    .description(`Print the ${name}`)
+    .action(async () => {
+      const cfg = await loadConfig();
+      const paths = dataPaths(cfg);
+      const foreign = await rejectForeignStore(paths);
+      if (foreign != null) {
+        console.error(foreign);
+        process.exit(1);
+      }
+      const content = await readIfExists(pathOf(paths));
+      if (content == null) {
+        console.error(`No ${name} recorded yet. Set one with \`c2 ${name} set <file|->\`.`);
+        process.exit(1);
+      }
+      process.stdout.write(content);
+    });
+
+  doc
+    .command("set [file]")
+    .description(`Replace the ${name} from a file or stdin`)
+    .action(async (file: string | undefined) => {
+      const content = await readContent(file);
+      if (content.trim() === "") {
+        console.error(`Error: refusing to save an empty ${name}.`);
+        process.exit(1);
+      }
+      const cfg = await loadConfig();
+      const paths = dataPaths(cfg);
+      const storeError = await ensureStoreForWrite(paths, new Date());
+      if (storeError != null) {
+        console.error(storeError);
+        process.exit(1);
+      }
+      const target = pathOf(paths);
+      await writeFile(target, content.endsWith("\n") ? content : `${content}\n`, "utf-8");
+      console.log(`${name} updated (${content.length} chars).`);
+    });
+}
+
+export function registerDocs(program: Command): void {
+  registerDoc(program, "plan", "Training plan (managed document)", (p) => p.plan);
+  registerDoc(
+    program,
+    "playbook",
+    "Coaching knowledge playbook (managed document)",
+    (p) => p.playbook,
+  );
+
+  const narrative = program.command("narrative").description("Dated coaching report narratives");
+
+  narrative
+    .command("add <date> [file]")
+    .description("Save the narrative for a date (YYYY-MM-DD) from a file or stdin")
+    .action(async (date: string, file: string | undefined) => {
+      if (!isValidYMD(date)) {
+        console.error(`Error: invalid date "${date}" (expected YYYY-MM-DD).`);
+        process.exit(1);
+      }
+      const content = await readContent(file);
+      if (content.trim() === "") {
+        console.error("Error: refusing to save an empty narrative.");
+        process.exit(1);
+      }
+      const cfg = await loadConfig();
+      const paths = dataPaths(cfg);
+      const storeError = await ensureStoreForWrite(paths, new Date());
+      if (storeError != null) {
+        console.error(storeError);
+        process.exit(1);
+      }
+      await writeFile(
+        paths.narrativeFile(date),
+        content.endsWith("\n") ? content : `${content}\n`,
+        "utf-8",
+      );
+      console.log(`Narrative saved for ${date}.`);
+    });
+
+  narrative
+    .command("show [date]")
+    .description("Print the narrative for a date (latest if omitted)")
+    .action(async (date: string | undefined) => {
+      const cfg = await loadConfig();
+      const paths = dataPaths(cfg);
+      const foreign = await rejectForeignStore(paths);
+      if (foreign != null) {
+        console.error(foreign);
+        process.exit(1);
+      }
+      let target = date;
+      if (target != null && !isValidYMD(target)) {
+        console.error(`Error: invalid date "${target}" (expected YYYY-MM-DD).`);
+        process.exit(1);
+      }
+      if (target == null) {
+        const dates = await listNarratives(paths);
+        target = dates[dates.length - 1];
+        if (target == null) {
+          console.error("No narratives recorded yet.");
+          process.exit(1);
+        }
+      }
+      const content = await readIfExists(paths.narrativeFile(target));
+      if (content == null) {
+        console.error(`No narrative for ${target}.`);
+        process.exit(1);
+      }
+      process.stdout.write(content);
+    });
+
+  narrative
+    .command("list")
+    .description("List narrative dates")
+    .option("--json", "output as JSON")
+    .action(async (opts: { json?: boolean }) => {
+      const cfg = await loadConfig();
+      const paths = dataPaths(cfg);
+      const foreign = await rejectForeignStore(paths);
+      if (foreign != null) {
+        console.error(foreign);
+        process.exit(1);
+      }
+      const dates = await listNarratives(paths);
+      if (opts.json) {
+        printJSON("c2.narratives.v1", { count: dates.length, dates });
+        return;
+      }
+      if (dates.length === 0) {
+        console.log("No narratives recorded yet.");
+        return;
+      }
+      for (const d of dates) {
+        console.log(d);
+      }
+    });
+}
+
+export async function listNarratives(paths: DataPaths): Promise<string[]> {
+  try {
+    return (await readdir(paths.reportsDir))
+      .filter((f) => f.endsWith(".md"))
+      .map((f) => f.slice(0, -3))
+      .filter((d) => isValidYMD(d))
+      .sort();
+  } catch {
+    return [];
+  }
+}

package/src/commands/export.ts

@@ -1,6 +1,9 @@
 import type { Command } from "commander";
+import { loadConfig } from "../config.ts";
+import { printJSON } from "../envelope.ts";
 import type { Workout } from "../models.ts";
-import { pace500m } from "../models.ts";
+import { isValidYMD, pace500m } from "../models.ts";
+import { dataPaths } from "../paths.ts";
 import { readWorkouts } from "../storage.ts";
 
 export function filterByDate(workouts: Workout[], from: string, to: string): Workout[] {
@@ -72,7 +75,7 @@ function exportCSV(workouts: Workout[]): void {
 }
 
 function exportJSON(workouts: Workout[]): void {
-  console.log(JSON.stringify(workouts, null, 2));
+  printJSON("c2.export.v1", { count: workouts.length, workouts });
 }
 
 function exportJSONL(workouts: Workout[]): void {
@@ -89,7 +92,22 @@ export function registerExport(program: Command): void {
     .option("--from <date>", "filter workouts from date (YYYY-MM-DD)")
     .option("--to <date>", "filter workouts to date (YYYY-MM-DD)")
     .action(async (opts: { format: string; from?: string; to?: string }) => {
-      let workouts = await readWorkouts();
+      for (const [flag, value] of [
+        ["--from", opts.from],
+        ["--to", opts.to],
+      ] as const) {
+        if (value && !isValidYMD(value)) {
+          console.error(`Error: invalid ${flag} date "${value}" (expected YYYY-MM-DD).`);
+          process.exit(1);
+        }
+      }
+      if (!["csv", "json", "jsonl"].includes(opts.format)) {
+        console.error(`Unsupported format "${opts.format}": must be csv, json, or jsonl`);
+        process.exit(1);
+      }
+
+      const cfg = await loadConfig();
+      let workouts = await readWorkouts(dataPaths(cfg));
       if (workouts.length === 0) {
         console.error("No workouts found. Run `c2 sync` first.");
         process.exit(1);
@@ -98,7 +116,6 @@ export function registerExport(program: Command): void {
       workouts = filterByDate(workouts, opts.from ?? "", opts.to ?? "");
       if (workouts.length === 0) {
         console.error("No workouts match the specified date range.");
-        process.exit(1);
       }
 
       workouts.sort((a, b) => a.date.localeCompare(b.date));
@@ -113,9 +130,6 @@ export function registerExport(program: Command): void {
         case "jsonl":
           exportJSONL(workouts);
           break;
-        default:
-          console.error(`Unsupported format "${opts.format}": must be csv, json, or jsonl`);
-          process.exit(1);
       }
     });
 }

package/src/commands/log.ts

@@ -1,31 +1,62 @@
 import type { Command } from "commander";
 import { loadConfig } from "../config.ts";
-import { formatWorkoutLine } from "../display.ts";
+import { formatWorkoutLine, workoutJSON } from "../display.ts";
+import { printJSON } from "../envelope.ts";
+import { isValidYMD } from "../models.ts";
+import { dataPaths } from "../paths.ts";
 import { readWorkouts } from "../storage.ts";
+import { filterByDate } from "./export.ts";
 
 export function registerLog(program: Command): void {
   program
     .command("log")
     .description("Show recent workouts")
     .option("-n, --count <n>", "number of workouts to display", "10")
-    .action(async (opts: { count: string }) => {
+    .option("--from <date>", "only workouts on or after date (YYYY-MM-DD)")
+    .option("--to <date>", "only workouts on or before date (YYYY-MM-DD)")
+    .option("--json", "output as JSON")
+    .action(async (opts: { count: string; from?: string; to?: string; json?: boolean }) => {
       const cfg = await loadConfig();
-      const workouts = await readWorkouts();
-      if (workouts.length === 0) {
-        console.log("No workouts found. Run `c2 sync` first.");
-        return;
-      }
+      const paths = dataPaths(cfg);
 
-      workouts.sort((a, b) => b.date.localeCompare(a.date));
+      for (const [flag, value] of [
+        ["--from", opts.from],
+        ["--to", opts.to],
+      ] as const) {
+        if (value && !isValidYMD(value)) {
+          console.error(`Error: invalid ${flag} date "${value}" (expected YYYY-MM-DD).`);
+          process.exit(1);
+        }
+      }
 
       const count = parseInt(opts.count, 10);
       if (Number.isNaN(count) || count < 1) {
         console.error("Error: --count must be a positive integer.");
         process.exit(1);
       }
-      const n = Math.min(count, workouts.length);
-      for (const w of workouts.slice(0, n)) {
-        console.log(formatWorkoutLine(w, cfg.display.date_format));
+
+      const all = await readWorkouts(paths);
+      const workouts = filterByDate(all, opts.from ?? "", opts.to ?? "");
+      workouts.sort((a, b) => b.date.localeCompare(a.date));
+      const shown = workouts.slice(0, Math.min(count, workouts.length));
+
+      if (opts.json) {
+        printJSON("c2.log.v1", { count: shown.length, workouts: shown.map(workoutJSON) });
+        return;
+      }
+
+      if (all.length === 0) {
+        console.log("No workouts found. Run `c2 sync` first.");
+        return;
+      }
+      if (shown.length === 0) {
+        console.log("No workouts match the specified date range.");
+        return;
+      }
+
+      for (const w of shown) {
+        const line = formatWorkoutLine(w, cfg.display.date_format);
+        console.log(w.comments ? `${line}  — ${w.comments}` : line);
       }
     });
 }