trainerroad-cli 0.1.0

package/src/commands/power.mjs

@@ -0,0 +1,111 @@
+export async function commandPowerRanking(flags, deps) {
+  const { resolveQueryContext, requirePrivateContext, isJsonMode, writeOutput } = deps;
+  const context = await resolveQueryContext(flags);
+  requirePrivateContext(context, "power-ranking");
+
+  const records = await context.client.getPowerRanking(
+    context.memberInfo.memberId,
+    context.memberInfo.username,
+  );
+  const payload = {
+    mode: "private",
+    generatedAt: new Date().toISOString(),
+    command: "power-ranking",
+    member: { memberId: context.memberInfo.memberId, username: context.memberInfo.username },
+    count: records.length,
+    records,
+  };
+
+  if (!isJsonMode(flags)) {
+    await writeOutput(payload, flags, (value) => {
+      const lines = [`Power ranking entries: ${value.count}`];
+      for (const item of value.records) {
+        const watts = item?.wattsRanking?.value ?? null;
+        const wattsPct = item?.wattsRanking?.percentile ?? null;
+        const wkg = item?.wattsPerKgRanking?.value ?? null;
+        const wkgPct = item?.wattsPerKgRanking?.percentile ?? null;
+        lines.push(
+          `- ${item.duration}s | watts=${watts ?? "n/a"} (pct=${wattsPct ?? "n/a"}) | w/kg=${wkg ?? "n/a"} (pct=${wkgPct ?? "n/a"})`,
+        );
+      }
+      return lines.join("\n");
+    });
+    return;
+  }
+  await writeOutput(payload, { ...flags, json: !flags.jsonl });
+}
+
+export async function commandPowerRecords(flags, deps) {
+  const {
+    resolveQueryContext,
+    requirePrivateContext,
+    normalizeDateOnlyInput,
+    isoDateShift,
+    requirePositiveInteger,
+    toBoolean,
+    compactPersonalRecord,
+    isJsonMode,
+    writeOutput,
+    toIsoDate,
+  } = deps;
+  const context = await resolveQueryContext(flags);
+  requirePrivateContext(context, "power-records");
+
+  const startDate = normalizeDateOnlyInput(flags["start-date"], "2013-05-10");
+  const endDate = normalizeDateOnlyInput(flags["end-date"], isoDateShift(0));
+  const rowType = requirePositiveInteger(flags["row-type"], 101);
+  const indoorOnly = toBoolean(flags["indoor-only"], false);
+  const slot = requirePositiveInteger(flags.slot, 1);
+  const limit = requirePositiveInteger(flags.limit, 25);
+  const full = toBoolean(flags.full, false);
+
+  const raw = await context.client.getPersonalRecordsForDateRange(
+    context.memberInfo.memberId,
+    context.memberInfo.username,
+    { startDate, endDate, rowType, indoorOnly, slot },
+  );
+
+  const allRecords = Array.isArray(raw?.results?.[0]?.personalRecords)
+    ? raw.results[0].personalRecords
+    : [];
+  const rankedByWatts = [...allRecords].sort((a, b) => (b?.Watts ?? 0) - (a?.Watts ?? 0));
+  const selectedRaw = full ? allRecords : rankedByWatts.slice(0, limit);
+  const records = full ? selectedRaw : selectedRaw.map((item) => compactPersonalRecord(item));
+
+  const payload = {
+    mode: "private",
+    generatedAt: new Date().toISOString(),
+    command: "power-records",
+    member: { memberId: context.memberInfo.memberId, username: context.memberInfo.username },
+    query: { startDate, endDate, rowType, indoorOnly, slot, limit, full },
+    totalRecords: allRecords.length,
+    count: records.length,
+    records,
+    results: full ? raw?.results ?? [] : undefined,
+  };
+
+  if (!isJsonMode(flags)) {
+    await writeOutput(payload, flags, (value) => {
+      const lines = [
+        `Power records: returned ${value.count} of ${value.totalRecords}`,
+        `Range: ${value.query.startDate}..${value.query.endDate} | rowType=${value.query.rowType} | indoorOnly=${value.query.indoorOnly}`,
+      ];
+      for (const item of value.records) {
+        const workoutDate = item?.workoutDate ?? item?.WorkoutDate ?? null;
+        const seconds = item?.seconds ?? item?.Seconds ?? null;
+        const watts = item?.watts ?? item?.Watts ?? null;
+        const name = item?.workoutRecordName ?? item?.WorkoutRecordName ?? "(unknown)";
+        const dateLabel = workoutDate ? toIsoDate(workoutDate) : "(unknown-date)";
+        lines.push(
+          `- ${dateLabel} ${seconds}s ${watts}W | ride=${name}`,
+        );
+      }
+      if (!value.query.full) {
+        lines.push("Tip: add --full --json for complete personal-record payload.");
+      }
+      return lines.join("\n");
+    });
+    return;
+  }
+  await writeOutput(payload, { ...flags, json: !flags.jsonl });
+}

package/src/commands/timeline.mjs

@@ -0,0 +1,74 @@
+function summarizePrivateTimeline(memberInfo, timeline) {
+  return {
+    mode: "private",
+    generatedAt: new Date().toISOString(),
+    member: { memberId: memberInfo.memberId, username: memberInfo.username },
+    counts: {
+      activities: timeline.activities.length,
+      plannedActivities: timeline.plannedActivities.length,
+      events: timeline.events.length,
+    },
+  };
+}
+
+function summarizePublicTimeline(targetUsername, publicDays, today) {
+  return {
+    mode: "public",
+    generatedAt: new Date().toISOString(),
+    member: { username: targetUsername },
+    counts: {
+      days: publicDays.length,
+      rideDays: publicDays.filter((d) => d.hasRides || d.tss > 0).length,
+      futurePlannedDays: publicDays.filter((d) => d.date >= today && d.plannedTssTotal > 0).length,
+    },
+    limitations: [
+      "Public mode does not expose detailed workout records.",
+      "Use authenticated private mode for full workout detail.",
+    ],
+  };
+}
+
+export async function commandTimeline(flags, deps) {
+  const { resolveQueryContext, isJsonMode, writeOutput, sortByDateAsc, isoDateShift } = deps;
+  const context = await resolveQueryContext(flags);
+  if (context.mode === "private") {
+    const payload = {
+      ...summarizePrivateTimeline(context.memberInfo, context.timeline),
+      timeline: flags.full ? context.timeline : undefined,
+    };
+    if (!isJsonMode(flags) && !flags.full) {
+      await writeOutput(payload, flags, (value) => {
+        return [
+          `Mode: ${value.mode}`,
+          `User: ${value.member.username} (${value.member.memberId})`,
+          `Activities: ${value.counts.activities}`,
+          `Planned: ${value.counts.plannedActivities}`,
+          `Events: ${value.counts.events}`,
+          "Tip: add --json for machine output or --full --json for full payload.",
+        ].join("\n");
+      });
+      return;
+    }
+    await writeOutput(payload, { ...flags, json: !flags.jsonl });
+    return;
+  }
+
+  const payload = {
+    ...summarizePublicTimeline(context.targetUsername, context.publicDays, isoDateShift(0)),
+    days: flags.full ? sortByDateAsc(context.publicDays) : undefined,
+  };
+  if (!isJsonMode(flags) && !flags.full) {
+    await writeOutput(payload, flags, (value) => {
+      return [
+        `Mode: ${value.mode}`,
+        `Profile: ${value.member.username}`,
+        `Total days: ${value.counts.days}`,
+        `Ride days: ${value.counts.rideDays}`,
+        `Future planned days: ${value.counts.futurePlannedDays}`,
+        `Limitations: ${value.limitations.join(" ")}`,
+      ].join("\n");
+    });
+    return;
+  }
+  await writeOutput(payload, { ...flags, json: !flags.jsonl });
+}

package/src/commands/weight-history.mjs

@@ -0,0 +1,51 @@
+import { compactWeightRecord } from "../lib/planning-normalizers.mjs";
+
+export async function commandWeightHistory(flags, deps) {
+  const {
+    resolveQueryContext,
+    requirePrivateContext,
+    applyAgentRecordFilters,
+    toRecordsOnlyPayload,
+    isJsonMode,
+    writeOutput,
+    hasAgentRecordTransforms,
+  } = deps;
+
+  const context = await resolveQueryContext(flags);
+  requirePrivateContext(context, "weight-history");
+
+  const raw = await context.client.getWeightHistory(
+    context.memberInfo.memberId,
+    context.memberInfo.username,
+  );
+  const records = (Array.isArray(raw) ? raw : []).map((record) => compactWeightRecord(record));
+  const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(records, flags);
+
+  const payload = {
+    mode: "private",
+    generatedAt: new Date().toISOString(),
+    command: "weight-history",
+    filters: filterSummary,
+    member: { memberId: context.memberInfo.memberId, username: context.memberInfo.username },
+    count: filteredRecords.length,
+    records: filteredRecords,
+  };
+  const outputPayload = flags["records-only"] ? toRecordsOnlyPayload(payload) : payload;
+
+  if (!isJsonMode(flags)) {
+    await writeOutput(outputPayload, flags, (value) => {
+      const lines = [`Weight history (${value.count})`];
+      if (hasAgentRecordTransforms(flags) || flags["records-only"]) {
+        for (const item of value.records) lines.push(`- ${JSON.stringify(item)}`);
+        if (value.filters) lines.push(`Filter output: ${value.filters.outputCount}/${value.filters.inputCount}`);
+        return lines.join("\n");
+      }
+      for (const record of value.records) {
+        lines.push(`- ${record.dateOnly ?? "(unknown-date)"} ${record.value ?? "n/a"} (units=${record.units ?? "n/a"})`);
+      }
+      return lines.join("\n");
+    });
+    return;
+  }
+  await writeOutput(outputPayload, { ...flags, json: !flags.jsonl });
+}

package/src/commands/workouts.mjs

@@ -0,0 +1,436 @@
+export async function commandFuture(flags, deps) {
+  const {
+    requireNumber,
+    normalizeDateOnlyInput,
+    isoDateShift,
+    resolveQueryContext,
+    filterFuturePlanned,
+    applyAgentRecordFilters,
+    toRecordsOnlyPayload,
+    isJsonMode,
+    writeOutput,
+    hasAgentRecordTransforms,
+    toIsoDateFromPlanned,
+    sortByDateAsc,
+  } = deps;
+
+  const days = requireNumber(flags.days, 60);
+  const fromDate = normalizeDateOnlyInput(flags.from, isoDateShift(0));
+  const toDate = normalizeDateOnlyInput(flags.to, isoDateShift(days));
+  if (toDate < fromDate) {
+    throw new Error(`Invalid range: --to (${toDate}) is before --from (${fromDate}).`);
+  }
+
+  const context = await resolveQueryContext(flags);
+  if (context.mode === "private") {
+    const subset = filterFuturePlanned(context.timeline.plannedActivities, fromDate, toDate);
+    let records = subset;
+    if (flags.details) {
+      records = await context.client.getPlannedActivitiesByIds(
+        context.memberInfo.memberId,
+        context.memberInfo.username,
+        subset.map((item) => item.id),
+      );
+    }
+    const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(records, flags);
+
+    const payload = {
+      mode: "private",
+      generatedAt: new Date().toISOString(),
+      command: "future",
+      query: { fromDate, toDate, days, details: Boolean(flags.details) },
+      filters: filterSummary,
+      member: { memberId: context.memberInfo.memberId, username: context.memberInfo.username },
+      count: filteredRecords.length,
+      records: filteredRecords,
+    };
+    const outputPayload = flags["records-only"] ? toRecordsOnlyPayload(payload) : payload;
+
+    if (!isJsonMode(flags)) {
+      await writeOutput(outputPayload, flags, (value) => {
+        const lines = [`Future workouts (${value.count}) ${value.query.fromDate}..${value.query.toDate}`];
+        if (hasAgentRecordTransforms(flags)) {
+          for (const item of value.records) lines.push(`- ${JSON.stringify(item)}`);
+          lines.push(`Filter output: ${value.filters.outputCount}/${value.filters.inputCount}`);
+          return lines.join("\n");
+        }
+        for (const item of value.records) {
+          if (flags.details) {
+            lines.push(
+              `- ${toIsoDateFromPlanned(item)} ${item.name || "(untitled)"} | id=${item.id} | tss=${item.tss} | duration=${item.durationInSeconds}s`,
+            );
+          } else {
+            lines.push(`- ${toIsoDateFromPlanned(item)} id=${item.id} type=${item.type} tss=${item.tss}`);
+          }
+        }
+        return lines.join("\n");
+      });
+      return;
+    }
+    await writeOutput(outputPayload, { ...flags, json: !flags.jsonl });
+    return;
+  }
+
+  const records = sortByDateAsc(
+    context.publicDays.filter(
+      (day) => day.date >= fromDate && day.date <= toDate && day.plannedTssTotal > 0,
+    ),
+  );
+  const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(records, flags);
+  const payload = {
+    mode: "public",
+    generatedAt: new Date().toISOString(),
+    command: "future",
+    query: { fromDate, toDate, days, details: Boolean(flags.details) },
+    filters: filterSummary,
+    member: { username: context.targetUsername },
+    count: filteredRecords.length,
+    records: filteredRecords,
+    limitations: [
+      "Public mode returns day-level planned TSS only.",
+      "Detailed workout names/durations are unavailable in public mode.",
+    ],
+  };
+  const outputPayload = flags["records-only"] ? toRecordsOnlyPayload(payload) : payload;
+
+  if (!isJsonMode(flags)) {
+    await writeOutput(outputPayload, flags, (value) => {
+      const lines = [
+        `Future plan signal (${value.count}) ${value.query.fromDate}..${value.query.toDate} [public mode]`,
+      ];
+      if (hasAgentRecordTransforms(flags)) {
+        for (const item of value.records) lines.push(`- ${JSON.stringify(item)}`);
+        lines.push(`Filter output: ${value.filters.outputCount}/${value.filters.inputCount}`);
+        lines.push(`Limitations: ${value.limitations.join(" ")}`);
+        return lines.join("\n");
+      }
+      for (const day of value.records) {
+        lines.push(
+          `- ${day.date} plannedTss=${day.plannedTssTotal} (TR=${day.plannedTssTrainerRoad}, other=${day.plannedTssOther})`,
+        );
+      }
+      lines.push(`Limitations: ${value.limitations.join(" ")}`);
+      return lines.join("\n");
+    });
+    return;
+  }
+  await writeOutput(outputPayload, { ...flags, json: !flags.jsonl });
+}
+
+export async function commandPast(flags, deps) {
+  const {
+    requireNumber,
+    normalizeDateOnlyInput,
+    isoDateShift,
+    resolveQueryContext,
+    filterPastActivities,
+    applyAgentRecordFilters,
+    toRecordsOnlyPayload,
+    isJsonMode,
+    writeOutput,
+    hasAgentRecordTransforms,
+    sortByDateDesc,
+  } = deps;
+
+  const days = requireNumber(flags.days, 60);
+  const limit = requireNumber(flags.limit, 30);
+  const fromDate = normalizeDateOnlyInput(flags.from, isoDateShift(-days));
+  const toDate = normalizeDateOnlyInput(flags.to, isoDateShift(0));
+  if (toDate < fromDate) {
+    throw new Error(`Invalid range: --to (${toDate}) is before --from (${fromDate}).`);
+  }
+
+  const context = await resolveQueryContext(flags);
+  if (context.mode === "private") {
+    const filtered = filterPastActivities(context.timeline.activities, fromDate, toDate).slice(0, limit);
+    if (!flags.details) {
+      const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(filtered, flags);
+      const payload = {
+        mode: "private",
+        generatedAt: new Date().toISOString(),
+        command: "past",
+        query: { fromDate, toDate, days, limit, details: false },
+        filters: filterSummary,
+        member: { memberId: context.memberInfo.memberId, username: context.memberInfo.username },
+        count: filteredRecords.length,
+        records: filteredRecords,
+      };
+      const outputPayload = flags["records-only"] ? toRecordsOnlyPayload(payload) : payload;
+      if (!isJsonMode(flags)) {
+        await writeOutput(outputPayload, flags, (value) => {
+          const lines = [`Past workouts (${value.count}) ${value.query.fromDate}..${value.query.toDate}`];
+          if (hasAgentRecordTransforms(flags)) {
+            for (const item of value.records) lines.push(`- ${JSON.stringify(item)}`);
+            lines.push(`Filter output: ${value.filters.outputCount}/${value.filters.inputCount}`);
+            return lines.join("\n");
+          }
+          for (const item of value.records) {
+            lines.push(`- ${item.started} id=${item.id} type=${item.type} tss=${item.tss}`);
+          }
+          return lines.join("\n");
+        });
+        return;
+      }
+      await writeOutput(outputPayload, { ...flags, json: !flags.jsonl });
+      return;
+    }
+
+    const ids = filtered.map((item) => item.id);
+    const details = await context.client.getActivitiesByIds(
+      context.memberInfo.memberId,
+      context.memberInfo.username,
+      ids,
+    );
+    const personalRecords = await context.client.getPersonalRecordsByActivityIds(
+      context.memberInfo.memberId,
+      context.memberInfo.username,
+      ids,
+    );
+    const detailRecords = details.map((item) => ({
+      ...item,
+      personalRecordCount: Array.isArray(personalRecords[item.id]) ? personalRecords[item.id].length : 0,
+    }));
+    const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(detailRecords, flags);
+    const payload = {
+      mode: "private",
+      generatedAt: new Date().toISOString(),
+      command: "past",
+      query: { fromDate, toDate, days, limit, details: true },
+      filters: filterSummary,
+      member: { memberId: context.memberInfo.memberId, username: context.memberInfo.username },
+      count: filteredRecords.length,
+      records: filteredRecords,
+      personalRecords,
+    };
+    const outputPayload = flags["records-only"] ? toRecordsOnlyPayload(payload) : payload;
+
+    if (!isJsonMode(flags)) {
+      await writeOutput(outputPayload, flags, (value) => {
+        const lines = [
+          `Past workouts detailed (${value.count}) ${value.query.fromDate}..${value.query.toDate}`,
+        ];
+        if (hasAgentRecordTransforms(flags)) {
+          for (const item of value.records) lines.push(`- ${JSON.stringify(item)}`);
+          lines.push(`Filter output: ${value.filters.outputCount}/${value.filters.inputCount}`);
+          return lines.join("\n");
+        }
+        for (const item of value.records) {
+          lines.push(
+            `- ${new Date(item.started).toISOString()} ${item.name} | id=${item.id} | tss=${item.tss} | duration=${item.durationInSeconds}s | prs=${item.personalRecordCount}`,
+          );
+        }
+        return lines.join("\n");
+      });
+      return;
+    }
+    await writeOutput(outputPayload, { ...flags, json: !flags.jsonl });
+    return;
+  }
+
+  const records = sortByDateDesc(
+    context.publicDays.filter(
+      (day) => day.date >= fromDate && day.date <= toDate && (day.hasRides || day.tss > 0),
+    ),
+  ).slice(0, limit);
+  const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(records, flags);
+  const payload = {
+    mode: "public",
+    generatedAt: new Date().toISOString(),
+    command: "past",
+    query: { fromDate, toDate, days, limit, details: Boolean(flags.details) },
+    filters: filterSummary,
+    member: { username: context.targetUsername },
+    count: filteredRecords.length,
+    records: filteredRecords,
+    limitations: [
+      "Public mode returns day-level historical load signals only.",
+      "Detailed completed workout records are unavailable in public mode.",
+    ],
+  };
+  const outputPayload = flags["records-only"] ? toRecordsOnlyPayload(payload) : payload;
+
+  if (!isJsonMode(flags)) {
+    await writeOutput(outputPayload, flags, (value) => {
+      const lines = [
+        `Past load signal (${value.count}) ${value.query.fromDate}..${value.query.toDate} [public mode]`,
+      ];
+      if (hasAgentRecordTransforms(flags)) {
+        for (const item of value.records) lines.push(`- ${JSON.stringify(item)}`);
+        lines.push(`Filter output: ${value.filters.outputCount}/${value.filters.inputCount}`);
+        lines.push(`Limitations: ${value.limitations.join(" ")}`);
+        return lines.join("\n");
+      }
+      for (const day of value.records) {
+        lines.push(
+          `- ${day.date} tss=${day.tss} (TR=${day.tssTrainerRoad}, other=${day.tssOther}) hasRides=${day.hasRides}`,
+        );
+      }
+      lines.push(`Limitations: ${value.limitations.join(" ")}`);
+      return lines.join("\n");
+    });
+    return;
+  }
+  await writeOutput(outputPayload, { ...flags, json: !flags.jsonl });
+}
+
+export async function commandToday(flags, deps) {
+  const {
+    normalizeDateOnlyInput,
+    isoDateShift,
+    resolveQueryContext,
+    filterFuturePlanned,
+    filterPastActivities,
+    applyAgentRecordFilters,
+    toRecordsOnlyPayload,
+    isJsonMode,
+    writeOutput,
+    hasAgentRecordTransforms,
+    toIsoDateFromPlanned,
+  } = deps;
+
+  const today = normalizeDateOnlyInput(flags.date, isoDateShift(0));
+  const context = await resolveQueryContext(flags);
+
+  if (context.mode === "private") {
+    const plannedToday = filterFuturePlanned(context.timeline.plannedActivities, today, today);
+    const activitiesToday = filterPastActivities(context.timeline.activities, today, today);
+    let plannedRecords = plannedToday;
+    let activityRecords = activitiesToday;
+    let personalRecords = {};
+
+    if (flags.details) {
+      plannedRecords = await context.client.getPlannedActivitiesByIds(
+        context.memberInfo.memberId,
+        context.memberInfo.username,
+        plannedToday.map((item) => item.id),
+      );
+      activityRecords = await context.client.getActivitiesByIds(
+        context.memberInfo.memberId,
+        context.memberInfo.username,
+        activitiesToday.map((item) => item.id),
+      );
+      personalRecords = await context.client.getPersonalRecordsByActivityIds(
+        context.memberInfo.memberId,
+        context.memberInfo.username,
+        activitiesToday.map((item) => item.id),
+      );
+    }
+
+    const records = [
+      ...plannedRecords.map((item) => ({ recordType: "planned", ...item })),
+      ...activityRecords.map((item) => ({
+        recordType: "completed",
+        ...item,
+        personalRecordCount: Array.isArray(personalRecords[item.id]) ? personalRecords[item.id].length : 0,
+      })),
+    ];
+    const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(records, flags);
+
+    const payload = {
+      mode: "private",
+      generatedAt: new Date().toISOString(),
+      command: "today",
+      query: { date: today, details: Boolean(flags.details) },
+      filters: filterSummary,
+      member: { memberId: context.memberInfo.memberId, username: context.memberInfo.username },
+      counts: { planned: plannedRecords.length, completed: activityRecords.length },
+      planned: plannedRecords,
+      completed: activityRecords,
+      personalRecords,
+      count: filteredRecords.length,
+      records: filteredRecords,
+    };
+    const outputPayload = flags["records-only"] ? toRecordsOnlyPayload(payload) : payload;
+
+    if (!isJsonMode(flags)) {
+      await writeOutput(outputPayload, flags, (value) => {
+        const lines = [`Today (${value.query?.date ?? today})`];
+        if (value.counts) {
+          lines.push(`Planned: ${value.counts.planned}`);
+          lines.push(`Completed: ${value.counts.completed}`);
+        }
+        if (
+          hasAgentRecordTransforms(flags) ||
+          flags["records-only"] ||
+          !Array.isArray(value.planned) ||
+          !Array.isArray(value.completed)
+        ) {
+          lines.push(`Filtered records: ${value.count}`);
+          for (const item of value.records) lines.push(`- ${JSON.stringify(item)}`);
+          if (value.filters) {
+            lines.push(`Filter output: ${value.filters.outputCount}/${value.filters.inputCount}`);
+          }
+          return lines.join("\n");
+        }
+        for (const item of value.planned) {
+          if (flags.details) {
+            lines.push(`- planned ${toIsoDateFromPlanned(item)} ${item.name || "(untitled)"} | tss=${item.tss}`);
+          } else {
+            lines.push(`- planned id=${item.id} type=${item.type} tss=${item.tss}`);
+          }
+        }
+        for (const item of value.completed) {
+          if (flags.details) {
+            const prs = Array.isArray(value.personalRecords[item.id]) ? value.personalRecords[item.id].length : 0;
+            lines.push(`- completed ${new Date(item.started).toISOString()} ${item.name} | tss=${item.tss} | prs=${prs}`);
+          } else {
+            lines.push(`- completed ${item.started} id=${item.id} type=${item.type} tss=${item.tss}`);
+          }
+        }
+        return lines.join("\n");
+      });
+      return;
+    }
+    await writeOutput(outputPayload, { ...flags, json: !flags.jsonl });
+    return;
+  }
+
+  const day = context.publicDays.find((item) => item.date === today) ?? null;
+  const records = day ? [day] : [];
+  const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(records, flags);
+  const payload = {
+    mode: "public",
+    generatedAt: new Date().toISOString(),
+    command: "today",
+    query: { date: today, details: Boolean(flags.details) },
+    filters: filterSummary,
+    member: { username: context.targetUsername },
+    counts: { days: day ? 1 : 0 },
+    day,
+    count: filteredRecords.length,
+    records: filteredRecords,
+    limitations: [
+      "Public mode provides day-level load/plan signal only.",
+      "No workout-level detail without authentication.",
+    ],
+  };
+  const outputPayload = flags["records-only"] ? toRecordsOnlyPayload(payload) : payload;
+
+  if (!isJsonMode(flags)) {
+    await writeOutput(outputPayload, flags, (value) => {
+      const dayCandidate =
+        value.day ?? (Array.isArray(value.records) && value.records.length === 1 ? value.records[0] : null);
+      if (!dayCandidate && !hasAgentRecordTransforms(flags) && !flags["records-only"]) {
+        return `Today (${value.query?.date ?? today}) [public mode]\n- No day-level record returned.`;
+      }
+      if (hasAgentRecordTransforms(flags)) {
+        const lines = [`Today (${value.query?.date ?? today}) [public mode]`, `Filtered records: ${value.count}`];
+        for (const item of value.records) lines.push(`- ${JSON.stringify(item)}`);
+        if (value.filters) {
+          lines.push(`Filter output: ${value.filters.outputCount}/${value.filters.inputCount}`);
+        }
+        lines.push(`Limitations: ${value.limitations.join(" ")}`);
+        return lines.join("\n");
+      }
+      return [
+        `Today (${value.query?.date ?? today}) [public mode]`,
+        `- tss=${dayCandidate.tss} (TR=${dayCandidate.tssTrainerRoad}, other=${dayCandidate.tssOther})`,
+        `- plannedTss=${dayCandidate.plannedTssTotal} (TR=${dayCandidate.plannedTssTrainerRoad}, other=${dayCandidate.plannedTssOther})`,
+        `- hasRides=${dayCandidate.hasRides}`,
+        `Limitations: ${value.limitations.join(" ")}`,
+      ].join("\n");
+    });
+    return;
+  }
+  await writeOutput(outputPayload, { ...flags, json: !flags.jsonl });
+}