@unbrained/pm-cli 2026.7.3 → 2026.7.5

package/dist/cli-bundle/chunks/chunk-KL22PY6L.js

@@ -0,0 +1,915 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="8a196747-196e-5ef6-9526-cf12c153df00")}catch(e){}}();
+import {
+  collectRuntimeFilterValues,
+  matchesRuntimeFilters
+} from "./chunk-YSAH5FY5.js";
+import {
+  parseIntegerLimit,
+  parsePriority,
+  parseType
+} from "./chunk-YFIE7YK6.js";
+import {
+  listAllFrontMatterLight
+} from "./chunk-57C2RLW5.js";
+import {
+  normalizeStatusInput
+} from "./chunk-HK72NWAD.js";
+import {
+  compareTimestampStrings,
+  nowIso,
+  resolveIsoOrRelative
+} from "./chunk-FJRKQREY.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings
+} from "./chunk-US3T3W5J.js";
+import {
+  EXIT_CODE,
+  getSettingsPath,
+  levenshteinDistanceWithinLimit,
+  pathExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry,
+  weekdayOrderIndex
+} from "./chunk-YD5FML7K.js";
+
+// dist/cli/commands/calendar.js
+import { encode as encodeToon } from "@toon-format/toon";
+var CALENDAR_VIEW_VALUES = ["agenda", "day", "week", "month"];
+var CALENDAR_OUTPUT_VALUES = ["markdown", "toon", "json"];
+var UTC_DAY_TO_WEEKDAY = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+var DEFAULT_RECURRENCE_LOOKAHEAD_DAYS = 365;
+var DEFAULT_RECURRENCE_LOOKBACK_DAYS = 365;
+var DEFAULT_EVENTS_ONLY_LOOKAHEAD_DAYS = 28;
+var MAX_RECURRENCE_OCCURRENCES = 1e3;
+function parseNonNegativeInteger(raw, label) {
+  if (raw === void 0)
+    return void 0;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new PmCliError(`${label} must be a non-negative integer`, EXIT_CODE.USAGE);
+  }
+  return parsed;
+}
+function parseIncludeSources(raw) {
+  if (!raw) {
+    return /* @__PURE__ */ new Set(["deadlines", "reminders", "events"]);
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "all") {
+    return /* @__PURE__ */ new Set(["deadlines", "reminders", "events"]);
+  }
+  const values = normalized.split(/[|,]/).map((value) => value.trim()).filter((value) => value.length > 0);
+  if (values.length === 0) {
+    throw new PmCliError("Calendar include filter must not be empty", EXIT_CODE.USAGE);
+  }
+  const include = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (value === "deadlines" || value === "deadline") {
+      include.add("deadlines");
+      continue;
+    }
+    if (value === "reminders" || value === "reminder") {
+      include.add("reminders");
+      continue;
+    }
+    if (value === "events" || value === "event" || value === "scheduled") {
+      include.add("events");
+      continue;
+    }
+    throw new PmCliError("Calendar include filter must be deadlines|reminders|events|scheduled|all", EXIT_CODE.USAGE);
+  }
+  return include;
+}
+function suggestClosestChoice(value, choices) {
+  let best;
+  for (const choice of choices) {
+    const distance = levenshteinDistanceWithinLimit(value, choice, 2);
+    if (distance !== null && (best === void 0 || distance < best.distance)) {
+      best = { choice, distance };
+    }
+  }
+  return best?.choice;
+}
+function parseView(raw) {
+  if (!raw)
+    return "agenda";
+  const normalized = raw.trim().toLowerCase();
+  if (!CALENDAR_VIEW_VALUES.includes(normalized)) {
+    const suggestion = suggestClosestChoice(normalized, CALENDAR_VIEW_VALUES);
+    throw new PmCliError(`Calendar view must be one of ${CALENDAR_VIEW_VALUES.join("|")}${suggestion ? `. Did you mean "${suggestion}"?` : "."}`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseOutputFormat(raw) {
+  if (!raw)
+    return void 0;
+  const normalized = raw.trim().toLowerCase();
+  if (!CALENDAR_OUTPUT_VALUES.includes(normalized)) {
+    const suggestion = suggestClosestChoice(normalized, CALENDAR_OUTPUT_VALUES);
+    throw new PmCliError(`Calendar format must be one of ${CALENDAR_OUTPUT_VALUES.join("|")}${suggestion ? `. Did you mean "${suggestion}"?` : "."}`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function resolveCalendarOutputFormat(options, global) {
+  const commandFormat = parseOutputFormat(options.format);
+  if (global.json && commandFormat && commandFormat !== "json") {
+    throw new PmCliError("Cannot combine --json with --format markdown|toon", EXIT_CODE.USAGE);
+  }
+  if (global.json) {
+    return "json";
+  }
+  return commandFormat ?? "markdown";
+}
+function parseStatus(raw, statusRegistry) {
+  if (raw === void 0)
+    return void 0;
+  const normalized = normalizeStatusInput(raw, statusRegistry);
+  if (!normalized) {
+    const allowedStatuses = statusRegistry.definitions.map((definition) => definition.id);
+    throw new PmCliError(`Calendar status filter must be one of ${allowedStatuses.join("|")}`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseAssigneeFilter(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (!normalized) {
+    throw new PmCliError("Calendar assignee filter must be one of assigned|unassigned", EXIT_CODE.USAGE);
+  }
+  if (normalized !== "assigned" && normalized !== "unassigned") {
+    throw new PmCliError(`Invalid calendar assignee filter "${raw}". Allowed: assigned|unassigned`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function toUtcDayKey(timestamp) {
+  return new Date(timestamp).toISOString().slice(0, 10);
+}
+function toLocalDayKey(timestamp, timezone) {
+  if (!timezone || timezone === "UTC") {
+    return toUtcDayKey(timestamp);
+  }
+  try {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    }).formatToParts(new Date(timestamp));
+    const year = parts.find((part) => part.type === "year")?.value;
+    const month = parts.find((part) => part.type === "month")?.value;
+    const day = parts.find((part) => part.type === "day")?.value;
+    if (year && month && day) {
+      return `${year}-${month}-${day}`;
+    }
+  } catch {
+  }
+  return toUtcDayKey(timestamp);
+}
+function startOfUtcDay(timestamp) {
+  const date = new Date(timestamp);
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), 0, 0, 0, 0)).toISOString();
+}
+function addUtcDays(timestamp, days) {
+  const date = new Date(timestamp);
+  return new Date(date.getTime() + days * 24 * 60 * 60 * 1e3).toISOString();
+}
+function startOfUtcWeekMonday(timestamp) {
+  const base = new Date(startOfUtcDay(timestamp));
+  const day = base.getUTCDay();
+  const delta = day === 0 ? -6 : 1 - day;
+  return addUtcDays(base.toISOString(), delta);
+}
+function startOfUtcMonth(timestamp) {
+  const date = new Date(timestamp);
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1, 0, 0, 0, 0)).toISOString();
+}
+function startOfNextUtcMonth(timestamp) {
+  const date = new Date(timestamp);
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1, 0, 0, 0, 0)).toISOString();
+}
+function maxTimestamp(left, right) {
+  return compareTimestampStrings(left, right) >= 0 ? left : right;
+}
+function toSortedCountRecord(values) {
+  return Object.fromEntries([...values.entries()].sort(([left], [right]) => left.localeCompare(right)));
+}
+function incrementCount(values, key) {
+  values.set(key, (values.get(key) ?? 0) + 1);
+}
+function formatRecurrenceRuleForSummary(rule) {
+  if (!rule) {
+    return null;
+  }
+  const parts = [`freq=${rule.freq}`];
+  if (rule.interval !== void 0) {
+    parts.push(`interval=${rule.interval}`);
+  }
+  if (rule.count !== void 0) {
+    parts.push(`count=${rule.count}`);
+  }
+  if (rule.until) {
+    parts.push(`until=${rule.until}`);
+  }
+  if (rule.by_weekday && rule.by_weekday.length > 0) {
+    const weekdays = [...rule.by_weekday].sort((left, right) => weekdayOrderIndex(left) - weekdayOrderIndex(right));
+    parts.push(`by_weekday=${weekdays.join("|")}`);
+  }
+  if (rule.by_month_day && rule.by_month_day.length > 0) {
+    const monthDays = [...rule.by_month_day].sort((left, right) => left - right);
+    parts.push(`by_month_day=${monthDays.join("|")}`);
+  }
+  if (rule.exdates && rule.exdates.length > 0) {
+    const exdates = [...rule.exdates].sort((left, right) => left.localeCompare(right));
+    parts.push(`exdates=${exdates.join("|")}`);
+  }
+  return parts.join(",");
+}
+function buildUtcTimestamp(year, month, day, timeSource) {
+  const candidate = new Date(Date.UTC(year, month, day, timeSource.getUTCHours(), timeSource.getUTCMinutes(), timeSource.getUTCSeconds(), timeSource.getUTCMilliseconds()));
+  if (candidate.getUTCFullYear() !== year || candidate.getUTCMonth() !== month || candidate.getUTCDate() !== day) {
+    return void 0;
+  }
+  return candidate.toISOString();
+}
+function weekdayToken(timestamp) {
+  return UTC_DAY_TO_WEEKDAY[new Date(timestamp).getUTCDay()];
+}
+function normalizeInstantKey(timestamp) {
+  const parsed = Date.parse(timestamp);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+function buildExcludedInstantSet(exdates) {
+  const excluded = /* @__PURE__ */ new Set();
+  for (const exdate of exdates ?? []) {
+    const instantKey = normalizeInstantKey(exdate);
+    if (instantKey) {
+      excluded.add(instantKey);
+    }
+  }
+  return excluded;
+}
+function buildRecurringEventWindow(start, end, nowValue, lookbackDays, lookaheadDays) {
+  const windowStart = start ?? addUtcDays(nowValue, -(lookbackDays ?? DEFAULT_RECURRENCE_LOOKBACK_DAYS));
+  const windowEnd = end ?? addUtcDays(start ?? nowValue, lookaheadDays ?? DEFAULT_RECURRENCE_LOOKAHEAD_DAYS);
+  return {
+    start: windowStart,
+    end: compareTimestampStrings(windowEnd, windowStart) > 0 ? windowEnd : addUtcDays(windowStart, 1)
+  };
+}
+function buildRecurrenceExpansionContext(startAt, recurrence, window, occurrenceLimit) {
+  const recurrenceWeekdays = recurrence.by_weekday !== void 0 ? [...recurrence.by_weekday] : [weekdayToken(startAt)];
+  const recurrenceMonthDays = recurrence.by_month_day !== void 0 ? [...recurrence.by_month_day] : [new Date(startAt).getUTCDate()];
+  return {
+    startAt,
+    startDate: new Date(startAt),
+    window,
+    maxOccurrences: occurrenceLimit ?? MAX_RECURRENCE_OCCURRENCES,
+    interval: recurrence.interval ?? 1,
+    countLimit: recurrence.count ?? Number.POSITIVE_INFINITY,
+    until: recurrence.until,
+    excluded: buildExcludedInstantSet(recurrence.exdates),
+    weekdayFilter: recurrence.by_weekday !== void 0 ? new Set(recurrence.by_weekday) : void 0,
+    monthDayFilter: recurrence.by_month_day !== void 0 ? new Set(recurrence.by_month_day) : void 0,
+    sortedWeekdays: [...new Set(recurrenceWeekdays)].sort((left, right) => weekdayOrderIndex(left) - weekdayOrderIndex(right)),
+    sortedMonthDays: [...new Set(recurrenceMonthDays)].sort((left, right) => left - right),
+    occurrences: [],
+    produced: 0
+  };
+}
+function consumeRecurrenceCandidate(context, candidateAt) {
+  if (compareTimestampStrings(candidateAt, context.startAt) < 0) {
+    return "continue";
+  }
+  if (context.until && compareTimestampStrings(candidateAt, context.until) > 0) {
+    return "stop";
+  }
+  if (compareTimestampStrings(candidateAt, context.window.end) >= 0) {
+    return "stop";
+  }
+  if (context.excluded.has(candidateAt)) {
+    return "continue";
+  }
+  context.produced += 1;
+  if (compareTimestampStrings(candidateAt, context.window.start) >= 0) {
+    context.occurrences.push(candidateAt);
+  }
+  return context.produced >= context.countLimit || context.occurrences.length >= context.maxOccurrences ? "stop" : "continue";
+}
+function recurrenceDayMatchesFilters(context, candidateAt) {
+  const candidateWeekday = weekdayToken(candidateAt);
+  const candidateMonthDay = new Date(candidateAt).getUTCDate();
+  const weekdayMatches = !context.weekdayFilter || context.weekdayFilter.has(candidateWeekday);
+  const monthDayMatches = !context.monthDayFilter || context.monthDayFilter.has(candidateMonthDay);
+  return weekdayMatches && monthDayMatches;
+}
+function expandDailyOccurrences(context) {
+  let candidateAt = context.startAt;
+  for (let iteration = 0; iteration < context.maxOccurrences; iteration += 1) {
+    if (recurrenceDayMatchesFilters(context, candidateAt) && consumeRecurrenceCandidate(context, candidateAt) === "stop") {
+      break;
+    }
+    candidateAt = addUtcDays(candidateAt, context.interval);
+  }
+  return context.occurrences;
+}
+function buildWeeklyCandidateAt(context, candidateWeekStart, weekday) {
+  const dayOffset = weekdayOrderIndex(weekday);
+  const candidateDay = addUtcDays(candidateWeekStart, dayOffset);
+  const dayDate = new Date(candidateDay);
+  return new Date(Date.UTC(dayDate.getUTCFullYear(), dayDate.getUTCMonth(), dayDate.getUTCDate(), context.startDate.getUTCHours(), context.startDate.getUTCMinutes(), context.startDate.getUTCSeconds(), context.startDate.getUTCMilliseconds())).toISOString();
+}
+function expandWeeklyOccurrences(context) {
+  const weekStart = startOfUtcWeekMonday(context.startAt);
+  for (let step = 0; step < context.maxOccurrences; step += 1) {
+    const candidateWeekStart = addUtcDays(weekStart, step * context.interval * 7);
+    for (const weekday of context.sortedWeekdays) {
+      const candidateAt = buildWeeklyCandidateAt(context, candidateWeekStart, weekday);
+      if (!recurrenceDayMatchesFilters(context, candidateAt)) {
+        continue;
+      }
+      if (consumeRecurrenceCandidate(context, candidateAt) === "stop") {
+        return context.occurrences;
+      }
+    }
+  }
+  return context.occurrences;
+}
+function expandMonthlyOccurrences(context) {
+  const startYear = context.startDate.getUTCFullYear();
+  const startMonth = context.startDate.getUTCMonth();
+  for (let step = 0; step < context.maxOccurrences; step += 1) {
+    const monthAnchor = new Date(Date.UTC(startYear, startMonth + step * context.interval, 1, 0, 0, 0, 0));
+    for (const monthDay of context.sortedMonthDays) {
+      const candidateAt = buildUtcTimestamp(monthAnchor.getUTCFullYear(), monthAnchor.getUTCMonth(), monthDay, context.startDate);
+      if (!candidateAt || !recurrenceDayMatchesFilters(context, candidateAt)) {
+        continue;
+      }
+      if (consumeRecurrenceCandidate(context, candidateAt) === "stop") {
+        return context.occurrences;
+      }
+    }
+  }
+  return context.occurrences;
+}
+function expandYearlyOccurrences(context) {
+  const year = context.startDate.getUTCFullYear();
+  const month = context.startDate.getUTCMonth();
+  for (let step = 0; step < context.maxOccurrences; step += 1) {
+    const candidateYear = year + step * context.interval;
+    for (const monthDay of context.sortedMonthDays) {
+      const candidateAt = buildUtcTimestamp(candidateYear, month, monthDay, context.startDate);
+      if (!candidateAt || !recurrenceDayMatchesFilters(context, candidateAt)) {
+        continue;
+      }
+      if (consumeRecurrenceCandidate(context, candidateAt) === "stop") {
+        return context.occurrences;
+      }
+    }
+  }
+  return context.occurrences;
+}
+function expandRecurringOccurrences(startAt, recurrence, window, occurrenceLimit) {
+  const context = buildRecurrenceExpansionContext(startAt, recurrence, window, occurrenceLimit);
+  if (recurrence.freq === "daily") {
+    return expandDailyOccurrences(context);
+  }
+  if (recurrence.freq === "weekly") {
+    return expandWeeklyOccurrences(context);
+  }
+  if (recurrence.freq === "monthly") {
+    return expandMonthlyOccurrences(context);
+  }
+  return expandYearlyOccurrences(context);
+}
+function sortEvents(values) {
+  return [...values].sort((a, b) => {
+    const byAt = compareTimestampStrings(a.at, b.at);
+    if (byAt !== 0)
+      return byAt;
+    const byPriority = a.item_priority - b.item_priority;
+    if (byPriority !== 0)
+      return byPriority;
+    const byId = a.item_id.localeCompare(b.item_id);
+    if (byId !== 0)
+      return byId;
+    const byKind = a.kind.localeCompare(b.kind);
+    if (byKind !== 0)
+      return byKind;
+    const byEventTitle = String(a.event_title).localeCompare(String(b.event_title));
+    if (byEventTitle !== 0)
+      return byEventTitle;
+    return String(a.reminder_text).localeCompare(String(b.reminder_text));
+  });
+}
+function buildItemCalendarRowBase(item) {
+  return {
+    item_id: item.id,
+    item_title: item.title,
+    item_type: item.type,
+    item_status: item.status,
+    item_priority: item.priority,
+    item_assignee: item.assignee ?? null,
+    item_deadline: item.deadline ?? null,
+    item_tags: item.tags
+  };
+}
+function buildDeadlineRow(item) {
+  if (!item.deadline) {
+    return null;
+  }
+  return {
+    at: item.deadline,
+    date: toUtcDayKey(item.deadline),
+    kind: "deadline",
+    reminder_text: null,
+    event_title: null,
+    event_end: null,
+    event_location: null,
+    event_all_day: null,
+    event_timezone: null,
+    event_recurring: null,
+    event_recurrence_rule: null,
+    ...buildItemCalendarRowBase(item),
+    item_deadline: item.deadline
+  };
+}
+function buildReminderRows(item) {
+  return (item.reminders ?? []).map((reminder) => ({
+    at: reminder.at,
+    date: toUtcDayKey(reminder.at),
+    kind: "reminder",
+    reminder_text: reminder.text,
+    event_title: null,
+    event_end: null,
+    event_location: null,
+    event_all_day: null,
+    event_timezone: null,
+    event_recurring: null,
+    event_recurrence_rule: null,
+    ...buildItemCalendarRowBase(item)
+  }));
+}
+function recurringDurationMs(startAt, endAt) {
+  if (!endAt) {
+    return null;
+  }
+  const duration = Date.parse(endAt) - Date.parse(startAt);
+  return Number.isFinite(duration) && duration > 0 ? duration : null;
+}
+function eventOccurrenceEnd(occurrenceAt, event, durationMs) {
+  return event.recurrence && durationMs !== null ? new Date(new Date(occurrenceAt).getTime() + durationMs).toISOString() : event.end_at ?? null;
+}
+function buildScheduledEventRows(item, event, recurringWindow, occurrenceLimit) {
+  const recurrenceRuleSummary = formatRecurrenceRuleForSummary(event.recurrence);
+  const durationMs = recurringDurationMs(event.start_at, event.end_at);
+  const occurrences = event.recurrence ? expandRecurringOccurrences(event.start_at, event.recurrence, recurringWindow, occurrenceLimit) : [event.start_at];
+  return occurrences.map((occurrenceAt) => ({
+    at: occurrenceAt,
+    // All-day events are timezone-agnostic calendar dates: bucket by the
+    // literal start date. Timed events bucket by their local day in the
+    // event's timezone (defaults to UTC when unset).
+    date: event.all_day === true ? occurrenceAt.slice(0, 10) : toLocalDayKey(occurrenceAt, event.timezone),
+    kind: "event",
+    reminder_text: event.description ?? null,
+    event_title: event.title ?? item.title,
+    event_end: eventOccurrenceEnd(occurrenceAt, event, durationMs),
+    event_location: event.location ?? null,
+    event_all_day: event.all_day ?? null,
+    event_timezone: event.timezone ?? null,
+    event_recurring: event.recurrence ? true : false,
+    event_recurrence_rule: recurrenceRuleSummary,
+    ...buildItemCalendarRowBase(item)
+  }));
+}
+function buildEventSeed(items, recurringWindow, includeSources, occurrenceLimit) {
+  const events = [];
+  for (const item of items) {
+    const deadlineRow = includeSources.has("deadlines") ? buildDeadlineRow(item) : null;
+    if (deadlineRow) {
+      events.push(deadlineRow);
+    }
+    if (includeSources.has("reminders")) {
+      events.push(...buildReminderRows(item));
+    }
+    for (const event of includeSources.has("events") ? item.events ?? [] : []) {
+      events.push(...buildScheduledEventRows(item, event, recurringWindow, occurrenceLimit));
+    }
+  }
+  return sortEvents(events);
+}
+function filterItems(items, options, typeRegistry, statusRegistry, runtimeFieldFilters) {
+  const typeFilter = parseType(options.type, typeRegistry);
+  const tagFilter = options.tag?.trim().toLowerCase();
+  const priorityFilter = parsePriority(options.priority);
+  const statusFilter = parseStatus(options.status, statusRegistry);
+  const assigneeFilter = options.assignee?.trim();
+  const assigneeModeFilter = parseAssigneeFilter(options.assigneeFilter);
+  const sprintFilter = options.sprint?.trim();
+  const releaseFilter = options.release?.trim();
+  if (assigneeFilter && (assigneeFilter.toLowerCase() === "none" || assigneeFilter.toLowerCase() === "null")) {
+    throw new PmCliError('--assignee no longer accepts "none" or "null". Use --assignee-filter unassigned.', EXIT_CODE.USAGE);
+  }
+  if (assigneeFilter !== void 0 && assigneeModeFilter === "unassigned") {
+    throw new PmCliError("Cannot combine --assignee with --assignee-filter unassigned", EXIT_CODE.USAGE);
+  }
+  return items.filter((item) => itemMatchesCalendarFilters(item, {
+    typeFilter,
+    tagFilter,
+    priorityFilter,
+    statusFilter,
+    assigneeFilter,
+    assigneeModeFilter,
+    sprintFilter,
+    releaseFilter,
+    runtimeFieldFilters
+  }));
+}
+function itemMatchesCalendarFilters(item, filters) {
+  return itemMatchesCalendarIdentityFilters(item, filters) && itemMatchesCalendarOwnerFilters(item, filters) && matchesRuntimeFilters(item, filters.runtimeFieldFilters);
+}
+function itemMatchesCalendarIdentityFilters(item, filters) {
+  if (filters.typeFilter && item.type !== filters.typeFilter)
+    return false;
+  if (filters.tagFilter && !item.tags.some((tag) => tag.trim().toLowerCase() === filters.tagFilter))
+    return false;
+  if (filters.priorityFilter !== void 0 && item.priority !== filters.priorityFilter)
+    return false;
+  if (filters.statusFilter && item.status !== filters.statusFilter)
+    return false;
+  return true;
+}
+function itemMatchesCalendarOwnerFilters(item, filters) {
+  if (filters.assigneeModeFilter === "assigned" && !item.assignee)
+    return false;
+  if (filters.assigneeModeFilter === "unassigned" && item.assignee)
+    return false;
+  if (filters.assigneeFilter !== void 0 && item.assignee !== filters.assigneeFilter)
+    return false;
+  if (filters.sprintFilter !== void 0 && item.sprint !== filters.sprintFilter)
+    return false;
+  if (filters.releaseFilter !== void 0 && item.release !== filters.releaseFilter)
+    return false;
+  return true;
+}
+function includeEventInWindow(event, start, end) {
+  if (start && compareTimestampStrings(event.at, start) < 0) {
+    return false;
+  }
+  if (end && compareTimestampStrings(event.at, end) >= 0) {
+    return false;
+  }
+  return true;
+}
+function resolveCalendarBoundaryInput(raw, nowValue, fieldLabel) {
+  if (raw.trim().toLowerCase() === "today") {
+    return startOfUtcDay(nowValue);
+  }
+  return resolveIsoOrRelative(raw, new Date(nowValue), fieldLabel);
+}
+function buildRange(view, options, nowValue) {
+  const anchor = options.date ? resolveCalendarBoundaryInput(options.date, nowValue, "--date") : nowValue;
+  const includePast = options.past === true;
+  const fullPeriodRequested = options.fullPeriod === true;
+  const from = options.from ? resolveCalendarBoundaryInput(options.from, nowValue, "--from") : void 0;
+  const to = options.to ? resolveCalendarBoundaryInput(options.to, nowValue, "--to") : void 0;
+  if (from && to && compareTimestampStrings(from, to) >= 0) {
+    throw new PmCliError("Calendar --from must be before --to", EXIT_CODE.USAGE);
+  }
+  if (view !== "agenda" && (options.from !== void 0 || options.to !== void 0)) {
+    throw new PmCliError("--from and --to are only supported for --view agenda", EXIT_CODE.USAGE);
+  }
+  if (view === "agenda") {
+    return buildAgendaRange(anchor, options, nowValue, includePast, fullPeriodRequested, from, to);
+  }
+  if (view === "day") {
+    const dayStart = startOfUtcDay(anchor);
+    return buildFixedPeriodRange(anchor, nowValue, includePast, fullPeriodRequested, dayStart, addUtcDays(dayStart, 1));
+  }
+  if (view === "week") {
+    const weekStart = startOfUtcWeekMonday(anchor);
+    return buildFixedPeriodRange(anchor, nowValue, includePast, fullPeriodRequested, weekStart, addUtcDays(weekStart, 7));
+  }
+  const monthStart = startOfUtcMonth(anchor);
+  return buildFixedPeriodRange(anchor, nowValue, includePast, fullPeriodRequested, monthStart, startOfNextUtcMonth(anchor));
+}
+function buildAgendaRange(anchor, options, nowValue, includePast, fullPeriodRequested, from, to) {
+  if (fullPeriodRequested) {
+    throw new PmCliError("--full-period is only supported for --view day|week|month. For agenda windows, use --from and --to.", EXIT_CODE.USAGE);
+  }
+  return {
+    anchor,
+    start: from ?? (options.date ? anchor : includePast ? void 0 : nowValue),
+    end: to,
+    fullPeriod: false
+  };
+}
+function buildFixedPeriodRange(anchor, nowValue, includePast, fullPeriodRequested, periodStart, periodEnd) {
+  const fullPeriod = includePast || fullPeriodRequested;
+  return {
+    anchor,
+    start: fullPeriod ? periodStart : maxTimestamp(periodStart, nowValue),
+    end: periodEnd,
+    periodStart,
+    periodEnd,
+    fullPeriod
+  };
+}
+function bucketEventsByDay(events) {
+  const dayMap = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const list = dayMap.get(event.date) ?? [];
+    list.push(event);
+    dayMap.set(event.date, list);
+  }
+  return [...dayMap.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([date, dayEvents]) => ({
+    date,
+    count: dayEvents.length,
+    events: sortEvents(dayEvents)
+  }));
+}
+function summarize(events) {
+  const itemIds = /* @__PURE__ */ new Set();
+  const byType = /* @__PURE__ */ new Map();
+  const byStatus = /* @__PURE__ */ new Map();
+  let deadlines = 0;
+  let reminders = 0;
+  let scheduled = 0;
+  let recurringEvents = 0;
+  for (const event of events) {
+    itemIds.add(event.item_id);
+    incrementCount(byType, event.item_type);
+    incrementCount(byStatus, event.item_status);
+    if (event.kind === "deadline") {
+      deadlines += 1;
+    } else if (event.kind === "reminder") {
+      reminders += 1;
+    } else {
+      scheduled += 1;
+      if (event.event_recurring === true) {
+        recurringEvents += 1;
+      }
+    }
+  }
+  return {
+    events: events.length,
+    items: itemIds.size,
+    deadlines,
+    reminders,
+    scheduled,
+    by_kind: {
+      deadline: deadlines,
+      reminder: reminders,
+      event: scheduled
+    },
+    by_type: toSortedCountRecord(byType),
+    by_status: toSortedCountRecord(byStatus),
+    recurring_events: recurringEvents
+  };
+}
+function formatWindow(range) {
+  const start = range.start ?? "unbounded";
+  const end = range.end ?? "unbounded";
+  return `${start} -> ${end}`;
+}
+function formatClock(timestamp, timezone) {
+  if (timezone && timezone !== "UTC") {
+    try {
+      const parts = new Intl.DateTimeFormat("en-GB", {
+        timeZone: timezone,
+        hour: "2-digit",
+        minute: "2-digit",
+        hourCycle: "h23"
+      }).formatToParts(new Date(timestamp));
+      const hour = parts.find((part) => part.type === "hour")?.value;
+      const minute = parts.find((part) => part.type === "minute")?.value;
+      if (hour && minute) {
+        return `${hour}:${minute}`;
+      }
+    } catch {
+    }
+  }
+  return `${new Date(timestamp).toISOString().slice(11, 16)}Z`;
+}
+function formatSummaryCountRecord(values) {
+  const entries = Object.entries(values);
+  if (entries.length === 0) {
+    return "empty";
+  }
+  return entries.map(([key, value]) => `${key}=${value}`).join(", ");
+}
+function formatEventEnd(event) {
+  if (!event.event_end) {
+    return null;
+  }
+  if (event.event_all_day === true) {
+    return event.event_end.slice(0, 10);
+  }
+  if (event.date === toLocalDayKey(event.event_end, event.event_timezone)) {
+    return formatClock(event.event_end, event.event_timezone);
+  }
+  return event.event_end;
+}
+function formatEventLine(event) {
+  const core = `${formatClock(event.at, event.event_timezone)} [${event.kind}] ${event.item_id} type=${event.item_type} p${event.item_priority} ${event.item_status} ${event.item_title}`;
+  if (event.kind === "reminder") {
+    const reminderText = event.reminder_text ?? "";
+    return `${core} \u2014 ${reminderText} reminder=${JSON.stringify(reminderText)}`;
+  }
+  if (event.kind === "event") {
+    const details = [];
+    const title = event.event_title ?? event.item_title;
+    const titleDiffers = event.event_title !== null && event.event_title !== event.item_title;
+    if (titleDiffers) {
+      details.push(title);
+      details.push(`title=${JSON.stringify(title)}`);
+    }
+    if (event.event_recurring) {
+      details.push("(recurring)");
+      details.push("recurring=true");
+    }
+    const end = formatEventEnd(event);
+    if (end) {
+      details.push(`end=${end}`);
+    }
+    if (event.event_all_day !== null) {
+      details.push(`all_day=${event.event_all_day ? "true" : "false"}`);
+    }
+    if (event.event_timezone) {
+      details.push(`timezone=${event.event_timezone}`);
+    }
+    if (event.event_location) {
+      details.push(`@ ${event.event_location}`);
+      details.push(`location=${JSON.stringify(event.event_location)}`);
+    }
+    if (event.event_recurrence_rule) {
+      details.push(`recurrence=${event.event_recurrence_rule}`);
+    }
+    if (event.reminder_text) {
+      details.push(`description=${JSON.stringify(event.reminder_text)}`);
+    }
+    return `${core} \u2014 ${details.join(" ")}`;
+  }
+  return core;
+}
+function renderCalendarMarkdown(result) {
+  const lines = [];
+  lines.push(`# pm calendar (${result.view})`);
+  lines.push("");
+  lines.push(`- now: ${result.now}`);
+  lines.push(`- window: ${formatWindow(result.range)}`);
+  if (result.range.period_start && result.range.period_end) {
+    lines.push(`- period: ${result.range.period_start} -> ${result.range.period_end}`);
+    lines.push(`- period-mode: ${result.range.full_period ? "full-period" : "active-window"}`);
+  }
+  lines.push(`- events: ${result.summary.events} (deadlines: ${result.summary.deadlines}, reminders: ${result.summary.reminders}, scheduled: ${result.summary.scheduled})`);
+  lines.push(`- items: ${result.summary.items}`);
+  lines.push(`- by-kind: ${formatSummaryCountRecord(result.summary.by_kind)}`);
+  lines.push(`- by-type: ${formatSummaryCountRecord(result.summary.by_type)}`);
+  lines.push(`- by-status: ${formatSummaryCountRecord(result.summary.by_status)}`);
+  lines.push(`- recurring-events: ${result.summary.recurring_events}`);
+  lines.push("");
+  if (result.events.length === 0) {
+    lines.push("No calendar events matched the selected filters.");
+    return lines.join("\n");
+  }
+  for (const day of result.days) {
+    lines.push(`## ${day.date} (${day.count})`);
+    for (const event of day.events) {
+      lines.push(`- ${formatEventLine(event)}`);
+    }
+    lines.push("");
+  }
+  if (result.warnings && result.warnings.length > 0) {
+    lines.push("### warnings");
+    for (const warning of result.warnings) {
+      lines.push(`- ${warning}`);
+    }
+    lines.push("");
+  }
+  return trimTrailingNewlines(lines.join("\n"));
+}
+function renderCalendarToon(result) {
+  return encodeToon(result);
+}
+function trimTrailingNewlines(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "\n") {
+    end -= 1;
+  }
+  return value.slice(0, end);
+}
+function resolveCalendarExecutionInputs(options) {
+  const nowValue = nowIso();
+  const view = parseView(options.view);
+  const rangeBounds = buildRange(view, options, nowValue);
+  const limit = parseIntegerLimit(options.limit);
+  const includeSources = parseIncludeSources(options.include);
+  const explicitLookahead = parseNonNegativeInteger(options.recurrenceLookaheadDays, "Calendar recurrence lookahead days");
+  const recurrenceLookbackDays = parseNonNegativeInteger(options.recurrenceLookbackDays, "Calendar recurrence lookback days");
+  const occurrenceLimit = parseNonNegativeInteger(options.occurrenceLimit, "Calendar occurrence limit");
+  if (occurrenceLimit !== void 0 && occurrenceLimit < 1) {
+    throw new PmCliError("Calendar occurrence limit must be >= 1", EXIT_CODE.USAGE);
+  }
+  const eventsOnly = includeSources.has("events") && !includeSources.has("deadlines") && !includeSources.has("reminders");
+  const hasExplicitBounds = options.to !== void 0 || explicitLookahead !== void 0 || recurrenceLookbackDays !== void 0 || occurrenceLimit !== void 0;
+  const eventsOnlyCapApplied = eventsOnly && !hasExplicitBounds;
+  return {
+    nowValue,
+    view,
+    rangeBounds,
+    limit,
+    includeSources,
+    occurrenceLimit,
+    recurrenceLookaheadDays: eventsOnlyCapApplied ? DEFAULT_EVENTS_ONLY_LOOKAHEAD_DAYS : explicitLookahead,
+    recurrenceLookbackWindowDays: eventsOnlyCapApplied && recurrenceLookbackDays === void 0 ? 0 : recurrenceLookbackDays,
+    eventsOnlyCapApplied
+  };
+}
+function appendCalendarCapWarning(warnings, capApplied) {
+  if (!capApplied) {
+    return;
+  }
+  warnings.push(`recurring_events_default_cap_applied:lookback=0d,lookahead=${DEFAULT_EVENTS_ONLY_LOOKAHEAD_DAYS}d -- use --recurrence-lookback-days/--recurrence-lookahead-days or --to for wider range`);
+}
+function buildCalendarFiltersResult(options, runtimeFieldFilters) {
+  return {
+    type: options.type ?? null,
+    tag: options.tag ?? null,
+    priority: options.priority ?? null,
+    status: options.status ?? null,
+    assignee: options.assignee ?? null,
+    assignee_filter: options.assigneeFilter ?? null,
+    sprint: options.sprint ?? null,
+    release: options.release ?? null,
+    runtime_filters: runtimeFieldFilters,
+    limit: options.limit ?? null,
+    include: options.include ?? null,
+    full_period: options.fullPeriod === true ? "true" : null,
+    recurrence_lookahead_days: options.recurrenceLookaheadDays ?? null,
+    recurrence_lookback_days: options.recurrenceLookbackDays ?? null,
+    occurrence_limit: options.occurrenceLimit ?? null
+  };
+}
+function buildCalendarRangeResult(options, rangeBounds) {
+  return {
+    start: rangeBounds.start ?? null,
+    end: rangeBounds.end ?? null,
+    period_start: rangeBounds.periodStart ?? null,
+    period_end: rangeBounds.periodEnd ?? null,
+    full_period: rangeBounds.fullPeriod,
+    past: options.past === true,
+    from: options.from ?? null,
+    to: options.to ?? null
+  };
+}
+async function runCalendar(options, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  const inputs = resolveCalendarExecutionInputs(options);
+  const settings = await readSettings(pmRoot);
+  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
+  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
+  const runtimeFieldFilters = collectRuntimeFilterValues(options, runtimeFieldRegistry, "calendar");
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const listWarnings = [];
+  appendCalendarCapWarning(listWarnings, inputs.eventsOnlyCapApplied);
+  const items = await listAllFrontMatterLight(pmRoot, settings.item_format, typeRegistry.type_to_folder, listWarnings, settings.schema);
+  const filteredItems = filterItems(items, options, typeRegistry, statusRegistry, runtimeFieldFilters);
+  const recurringWindow = buildRecurringEventWindow(inputs.rangeBounds.start, inputs.rangeBounds.end, inputs.nowValue, inputs.recurrenceLookbackWindowDays, inputs.recurrenceLookaheadDays);
+  const seededEvents = buildEventSeed(filteredItems, recurringWindow, inputs.includeSources, inputs.occurrenceLimit);
+  const rangedEvents = seededEvents.filter((event) => includeEventInWindow(event, inputs.rangeBounds.start, inputs.rangeBounds.end));
+  const limitedEvents = inputs.limit === void 0 ? rangedEvents : rangedEvents.slice(0, inputs.limit);
+  const days = bucketEventsByDay(limitedEvents);
+  const warnings = [...new Set(listWarnings)].sort((left, right) => left.localeCompare(right));
+  return {
+    view: inputs.view,
+    output_default: "markdown",
+    now: inputs.nowValue,
+    anchor: inputs.rangeBounds.anchor,
+    range: buildCalendarRangeResult(options, inputs.rangeBounds),
+    filters: buildCalendarFiltersResult(options, runtimeFieldFilters),
+    summary: summarize(limitedEvents),
+    events: limitedEvents,
+    days,
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+
+export {
+  resolveCalendarOutputFormat,
+  renderCalendarMarkdown,
+  renderCalendarToon,
+  runCalendar
+};
+//# sourceMappingURL=chunk-KL22PY6L.js.map
+
+//# debugId=8a196747-196e-5ef6-9526-cf12c153df00