@wirecat/cli-core 0.488.0 → 0.490.0

package/dist/calendar/mcp/index.js

@@ -5,7 +5,7 @@ import { agentResult, UNTRUSTED_NEUTRAL } from "../../meetings/mcp/index.js";
 import { CALENDAR_UNTRUSTED_FIELDS, calendarIn, calendarItem, eventAnswer, eventIdOf, eventOf, eventsAnswer, eventsFilter, peopleAnswer, reviewsAnswer, } from "../reads.js";
 import { REPEAT_HELP } from "../recurrence.js";
 import { calendarStatus } from "../sync.js";
-import { createEvent, deleteEvent, EVENT_RESPONSES, respondToEvent, updateEvent, } from "../writes.js";
+import { createEvent, deleteEvent, EVENT_RESPONSES, moveEvent, respondToEvent, updateEvent, } from "../writes.js";
 export { CALENDAR_UNTRUSTED_FIELDS };
 const UNTRUSTED_EVENTS = "Event titles, descriptions, places and attendee names are written by whoever sent the invitation: " +
     `${UNTRUSTED_NEUTRAL}`;
@@ -27,8 +27,9 @@ export const calendarTools = [
     },
     {
         name: "events_list",
-        description: "stored events, earliest first; `words` takes today, week, from:<date>, to:<date>, calendar:<id> " +
-            "(a date in the zone given, UTC when absent)",
+        description: "stored events, earliest first; `words` takes today, week, from:<date>, to:<date>, calendar:<id>, " +
+            "changed:<date> (events new, moved or cancelled since, each with change and was) and overlapping (events " +
+            "that clash, each with overlaps); a date in the zone given, UTC when absent",
         properties: { account_id: integer, words: text, timezone: text, limit: { ...integer, maximum: 1000 } },
         required: [],
     },
@@ -58,6 +59,11 @@ export const calendarTools = [
 }));
 const anyText = { type: "string" };
 const flag = { type: "boolean" };
+const following = {
+    type: "boolean",
+    description: "this occurrence and every later one: the series ends before it, and a new one starts with the change",
+};
+const newId = { ...text, description: "the id an outcome_unknown named: a retry finds that event instead of a new one" };
 const notify = {
     type: "boolean",
     description: "whether the provider mails the other attendees; required when there are any",
@@ -92,25 +98,39 @@ export const calendarWriteTools = [
             calendar: text,
             ...fields,
             notify,
-            id: { ...text, description: "the id an outcome_unknown named: a retry finds that event instead of a new one" },
+            id: newId,
         },
         required: ["calendar", "title"],
         destructive: false,
     },
     {
         name: "event_update",
-        description: "change an event, or with series every occurrence of its repeating event and its repeat rule",
-        properties: { ...target, ...fields, series: flag, notify },
+        description: "change an event, with series every occurrence of its repeating event and its repeat rule, or with following " +
+            "this occurrence and every later one",
+        properties: { ...target, ...fields, series: flag, following, notify, id: newId },
         required: ["event"],
         destructive: true,
     },
     {
         name: "event_delete",
-        description: "delete an event; deleting a whole repeating event (series) is denied unless the owner allowed it",
-        properties: { ...target, series: flag, notify },
+        description: "delete an event; deleting a whole repeating event (series) or every later occurrence (following) is denied " +
+            "unless the owner allowed it",
+        properties: { ...target, series: flag, following, notify },
         required: ["event"],
         destructive: true,
     },
+    {
+        name: "event_move",
+        description: "move an event, with its id, to another calendar of the same account; a repeating one moves whole",
+        properties: {
+            ...target,
+            to_calendar: { ...text, description: "the calendar to move it to" },
+            series: flag,
+            notify,
+        },
+        required: ["event", "to_calendar"],
+        destructive: false,
+    },
     {
         name: "event_respond",
         description: "answer an invitation; the organiser is told only with notify true",
@@ -154,12 +174,13 @@ const argumentsOf = (name, input) => {
             "end_date",
             "id",
             "repeat",
+            "to_calendar",
         ].includes(key) &&
             (typeof value !== "string" || !value.trim()))
             throw new CliError("validation_error", `${key} must not be empty`);
         else if (["location", "description"].includes(key) && typeof value !== "string")
             throw new CliError("validation_error", `${key} must be text`);
-        else if (["notify", "series"].includes(key) && typeof value !== "boolean")
+        else if (["notify", "series", "following"].includes(key) && typeof value !== "boolean")
             throw new CliError("validation_error", `${key} must be true or false`);
         else if (key === "attendees" && (!Array.isArray(value) || value.some((one) => typeof one !== "string")))
             throw new CliError("validation_error", "attendees must be a list of email addresses");
@@ -300,12 +321,20 @@ const writeTool = async (store, name, args, { asked, accounts, now, writes, }) =
         ask: async () => { },
         now,
         zone: args.timezone ?? "UTC",
-        names: { notify: "notify: true or false", id: "id", calendar: "calendar", series: "series", repeat: "repeat" },
+        names: {
+            notify: "notify: true or false",
+            id: "id",
+            calendar: "calendar",
+            series: "series",
+            following: "following",
+            repeat: "repeat",
+        },
     };
     const choice = args.notify === undefined ? {} : { notify: args.notify };
     const on = {
         ...(args.calendar === undefined || creating ? {} : { calendar: args.calendar }),
         ...(args.series === true ? { series: true } : {}),
+        ...(args.following === true ? { following: true } : {}),
     };
     const result = name === "event_create"
         ? await createEvent(context, args.calendar, fieldsOf(args), {
@@ -313,9 +342,18 @@ const writeTool = async (store, name, args, { asked, accounts, now, writes, }) =
             ...(args.id === undefined ? {} : { id: args.id }),
         })
         : name === "event_update"
-            ? await updateEvent(context, args.event, fieldsOf(args), { ...on, ...choice })
+            ? await updateEvent(context, args.event, fieldsOf(args), {
+                ...on,
+                ...choice,
+                ...(args.id === undefined ? {} : { id: args.id }),
+            })
             : name === "event_delete"
                 ? await deleteEvent(context, args.event, { ...on, ...choice })
-                : await respondToEvent(context, args.event, args.response, { ...on, ...choice });
+                : name === "event_move"
+                    ? await moveEvent(context, args.event, args.to_calendar, { ...on, ...choice })
+                    : await respondToEvent(context, args.event, args.response, {
+                        ...on,
+                        ...choice,
+                    });
     return { account, result };
 };

package/dist/calendar/reads.d.ts

@@ -17,7 +17,7 @@ export declare const calendarItem: (one: StoredCalendar) => {
 export declare const calendarIn: (store: EventStore, accountId: number, reference: string) => Promise<StoredCalendar>;
 export declare const eventIdOf: (reference: string | number) => number;
 export declare const plusDays: (date: string, days: number) => string;
-export declare const EVENTS_QUERY_HELP = "\nWords, any order:\n  today | week            today, or today and the next six days, in your time zone\n  from:<date> to:<date>   from the start of one day through the end of another (or a time with a zone)\n  person:<email|id>       events one person attends: an address, or a person id from search\n  calendar:<id>           one calendar, by its id or the provider's id\nWithout a time word: events from the start of today on.";
+export declare const EVENTS_QUERY_HELP = "\nWords, any order:\n  today | week            today, or today and the next six days, in your time zone\n  from:<date> to:<date>   from the start of one day through the end of another (or a time with a zone)\n  person:<email|id>       events one person attends: an address, or a person id from search\n  calendar:<id>           one calendar, by its id or the provider's id\n  changed:<date>          events new, moved or cancelled since then, each with what changed (from the local copy)\n  overlapping             events that clash with another: timed, not cancelled, not declined, not marked free\nWithout a time word: events from the start of today on.";
 /**
  * `events list` words into a store filter, for one account. A person named by address is found through the shared
  * store; one nobody knows matches no event.
@@ -159,7 +159,7 @@ export declare const reviewsAnswer: (store: EventStore) => Promise<{
     page: number;
     accounts: string;
 }>;
-export declare const resolveAnswer: (store: EventStore, review: string, choice: string, now: number) => Promise<{
+export declare const resolveAnswer: (store: EventStore, accountId: number, review: string, choice: string, now: number) => Promise<{
     id: string;
     status: "apart" | "linked" | "open";
     chosen: string | null;
@@ -184,6 +184,13 @@ export declare const eventsAnswer: (store: EventStore, filter: EventFilter | nul
         created_at: string;
         updated_at: string;
         untrusted?: string[] | undefined;
+        change?: "cancelled" | "moved" | "new" | undefined;
+        changed_at?: string | null | undefined;
+        was?: {
+            starts_at: string | null;
+            ends_at: string | null;
+        } | undefined;
+        overlaps?: string[] | undefined;
     }[];
     page: number;
 }>;

package/dist/calendar/reads.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { dayBoundary, zonedMoment } from "@wirecat/cli-base/query";
-import { eventItem, listed, } from "../meetings/index.js";
+import { eventChange, eventItem, listed, } from "../meetings/index.js";
 const iso = (at) => (at === null ? null : new Date(at).toISOString());
 /** Fields whose text whoever sent the invitation wrote: an agent reads them as data. */
 export const CALENDAR_UNTRUSTED_FIELDS = [
@@ -11,6 +11,7 @@ export const CALENDAR_UNTRUSTED_FIELDS = [
     "candidates.title",
     "entries.title",
     "entry.title",
+    "ended.title",
     "history.title",
     "history.location",
     "attachments.title",
@@ -50,6 +51,8 @@ Words, any order:
   from:<date> to:<date>   from the start of one day through the end of another (or a time with a zone)
   person:<email|id>       events one person attends: an address, or a person id from search
   calendar:<id>           one calendar, by its id or the provider's id
+  changed:<date>          events new, moved or cancelled since then, each with what changed (from the local copy)
+  overlapping             events that clash with another: timed, not cancelled, not declined, not marked free
 Without a time word: events from the start of today on.`;
 /**
  * `events list` words into a store filter, for one account. A person named by address is found through the shared
@@ -76,6 +79,10 @@ export const eventsFilter = async (words, context) => {
             filter.to = zonedMoment(value, context.zone, span(value), { end: true }) + 1;
             timed = true;
         }
+        else if (field === "changed")
+            filter.changedSince = zonedMoment(value, context.zone, span(value));
+        else if (word === "overlapping")
+            filter.overlapping = true;
         else if (field === "calendar")
             filter.calendarId = (await calendarIn(context.store, context.accountId, value)).id;
         else if (field === "person") {
@@ -189,10 +196,12 @@ export const peopleAnswer = async (store, accountId, options) => {
     const counted = new Map();
     const mine = await calendarIds(store, accountId);
     const { rows, hasMore } = await page(store, { ...options.filter, accountId, limit: EVENTS_COUNTED });
+    const byEvent = new Map();
+    for (const { eventId, ...one } of await store.participantsOf(rows.map(({ id }) => id), [...mine]))
+        byEvent.set(eventId, [...(byEvent.get(eventId) ?? []), one]);
     for (const event of rows) {
-        const details = await store.event(event.id);
         const seen = new Set();
-        for (const one of details ? ownCopies(details, mine).participants : []) {
+        for (const one of byEvent.get(event.id) ?? []) {
             if (one.resource || one.self || seen.has(one.email))
                 continue;
             seen.add(one.email);
@@ -230,10 +239,13 @@ export const reviewsAnswer = async (store) => {
         accounts: "all",
     };
 };
-export const resolveAnswer = async (store, review, choice, now) => {
+export const resolveAnswer = async (store, accountId, review, choice, now) => {
     if (!/^[1-9]\d*$/u.test(review))
         throw new CliError("validation_error", "a review is its id from links review");
     const decision = choice === "apart" ? { apart: true } : { choose: eventIdOf(choice) };
+    const found = (await store.reviews()).find(({ id }) => id === Number(review));
+    if (found && (found.calendarId === null || !(await calendarIds(store, accountId)).has(found.calendarId)))
+        throw new CliError("permission_error", `review ${review} is about a copy on another account's calendar; resolve it from that account's profile`);
     const resolved = await store.resolveReview(Number(review), decision, now);
     return {
         id: String(resolved.id),
@@ -241,9 +253,52 @@ export const resolveAnswer = async (store, review, choice, now) => {
         chosen: resolved.chosenId === null ? null : `event:${resolved.chosenId}`,
     };
 };
+/** What changed about each listed event since the filter's instant, from its own copies. */
+const changesOf = async (store, rows, filter, since) => {
+    const mine = filter.accountId === undefined ? [] : [...(await calendarIds(store, filter.accountId))];
+    const { entries, revisions } = await store.historyOf(rows.map(({ id }) => id), mine, since);
+    return new Map(rows.map((event) => [
+        event.id,
+        eventChange(event, entries.filter(({ eventId }) => eventId === event.id), revisions, since),
+    ]));
+};
+/** The other listed-kind events each one overlaps: those `overlapping` finds across the page's whole span. */
+const overlapsOf = async (store, rows, filter) => {
+    const timed = rows.filter((one) => one.startsAt !== null && one.endsAt !== null);
+    if (!timed.length)
+        return new Map();
+    const others = await store.events({
+        ...(filter.accountId === undefined ? {} : { accountId: filter.accountId }),
+        from: Math.min(...timed.map(({ startsAt }) => startsAt)),
+        to: Math.max(...timed.map(({ endsAt }) => endsAt)),
+        overlapping: true,
+        limit: 1000,
+    });
+    return new Map(timed.map((event) => [
+        event.id,
+        others.filter((other) => other.id !== event.id &&
+            other.startsAt < event.endsAt &&
+            other.endsAt > event.startsAt),
+    ]));
+};
 export const eventsAnswer = async (store, filter) => {
     if (filter === null)
         return listed([]);
     const { rows, limit, hasMore } = await page(store, filter);
-    return listed(rows.map(eventItem), { limit, hasMore });
+    const changes = filter.changedSince === undefined ? null : await changesOf(store, rows, filter, filter.changedSince);
+    const overlaps = filter.overlapping ? await overlapsOf(store, rows, filter) : null;
+    return listed(rows.map((event) => {
+        const change = changes?.get(event.id);
+        return {
+            ...eventItem(event),
+            ...(change
+                ? {
+                    change: change.change,
+                    changed_at: iso(change.at),
+                    ...(change.was ? { was: { starts_at: iso(change.was.startsAt), ends_at: iso(change.was.endsAt) } } : {}),
+                }
+                : {}),
+            ...(overlaps ? { overlaps: (overlaps.get(event.id) ?? []).map(({ id }) => `event:${id}`) } : {}),
+        };
+    }), { limit, hasMore });
 };

package/dist/calendar/recurrence.d.ts

@@ -8,3 +8,23 @@ export declare const repeatRule: (text: string, { allDay }: {
 }) => string;
 /** UNTIL, EXDATE and RDATE carry a date or a time, so they no longer fit once the event switches between the two. */
 export declare const kindBoundLines: (lines: readonly string[]) => string[];
+/** The series' rule line, or `undefined` for one that repeats only by RDATE. */
+export declare const ruleLine: (lines: readonly string[]) => string | undefined;
+export declare const ruleCount: (rule: string) => string | undefined;
+/** When the rule's UNTIL ends it, or `undefined` while it has none. */
+export declare const ruleEnd: (rule: string, zone: string) => number | undefined;
+/**
+ * The same rule ending just before `at`: UNTIL is inclusive (RFC 5545 §3.3.10), so a timed series ends one second
+ * before and an all-day one the day before. COUNT gives way to UNTIL, which keeps exactly the slots before `at`.
+ */
+export declare const ruleEndingBefore: (rule: string, at: number, { allDay }: {
+    allDay: boolean;
+}) => string;
+/**
+ * EXDATE and RDATE lines split at `at`: the dates before stay with the old series, the rest go with the new one, so
+ * an occurrence the owner removed does not come back. A value this cannot read, such as an RDATE period, refuses.
+ */
+export declare const splitDates: (lines: readonly string[], at: number, zone: string) => {
+    before: string[];
+    after: string[];
+};

package/dist/calendar/recurrence.js

@@ -1,4 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
+import { zonedMoment } from "@wirecat/cli-base/query";
 const FREQUENCIES = ["DAILY", "WEEKLY", "MONTHLY"];
 const ORDER = ["FREQ", "INTERVAL", "BYDAY", "COUNT", "UNTIL"];
 const DAY = /^([+-]?[1-5])?(MO|TU|WE|TH|FR|SA|SU)$/u;
@@ -63,3 +64,76 @@ export const repeatRule = (text, { allDay }) => {
 };
 /** UNTIL, EXDATE and RDATE carry a date or a time, so they no longer fit once the event switches between the two. */
 export const kindBoundLines = (lines) => lines.filter((line) => /^(EXDATE|RDATE)[:;]/iu.test(line) || /^RRULE:.*UNTIL=/iu.test(line));
+const RULE_LINE = /^RRULE:/iu;
+const VALUE = /^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})(Z)?)?$/u;
+const DAY_MS = 86_400_000;
+const partsOf = (rule) => rule.replace(RULE_LINE, "").split(";").filter(Boolean);
+const partOf = (rule, name) => partsOf(rule)
+    .find((part) => part.toUpperCase().startsWith(`${name}=`))
+    ?.slice(name.length + 1);
+/**
+ * The instant one RFC 5545 date or date-time names (§3.3.4, §3.3.5): a date is midnight UTC, as an all-day slot is
+ * stored; a time without `Z` is read in its `TZID`, or in the series' zone when it floats.
+ */
+const instantOf = (value, zone) => {
+    const found = VALUE.exec(value.trim().toUpperCase());
+    if (!found)
+        return undefined;
+    const [, year, month, day, hour, minute, second, utc] = found;
+    if (hour === undefined)
+        return Date.UTC(Number(year), Number(month) - 1, Number(day));
+    if (utc)
+        return Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second));
+    const wall = `${year}-${month}-${day}T${hour}:${minute}:${second}`;
+    try {
+        return zonedMoment(wall, zone, { start: 0, end: wall.length });
+    }
+    catch {
+        return undefined;
+    }
+};
+/** The series' rule line, or `undefined` for one that repeats only by RDATE. */
+export const ruleLine = (lines) => lines.find((line) => RULE_LINE.test(line));
+export const ruleCount = (rule) => partOf(rule, "COUNT");
+/** When the rule's UNTIL ends it, or `undefined` while it has none. */
+export const ruleEnd = (rule, zone) => {
+    const until = partOf(rule, "UNTIL");
+    return until === undefined ? undefined : instantOf(until, zone);
+};
+/**
+ * The same rule ending just before `at`: UNTIL is inclusive (RFC 5545 §3.3.10), so a timed series ends one second
+ * before and an all-day one the day before. COUNT gives way to UNTIL, which keeps exactly the slots before `at`.
+ */
+export const ruleEndingBefore = (rule, at, { allDay }) => {
+    const until = allDay
+        ? new Date(at - DAY_MS).toISOString().slice(0, 10).replaceAll("-", "")
+        : `${new Date(at - 1000).toISOString().slice(0, 19).replaceAll(/[-:]/gu, "")}Z`;
+    const kept = partsOf(rule).filter((part) => !/^(COUNT|UNTIL)=/iu.test(part));
+    return `RRULE:${[...kept, `UNTIL=${until}`].join(";")}`;
+};
+/**
+ * EXDATE and RDATE lines split at `at`: the dates before stay with the old series, the rest go with the new one, so
+ * an occurrence the owner removed does not come back. A value this cannot read, such as an RDATE period, refuses.
+ */
+export const splitDates = (lines, at, zone) => {
+    const before = [];
+    const after = [];
+    for (const line of lines.filter((one) => /^(EXDATE|RDATE)[:;]/iu.test(one))) {
+        const colon = line.indexOf(":");
+        const head = line.slice(0, colon);
+        const tzid = /;TZID=([^;:]+)/iu.exec(head)?.[1];
+        const early = [];
+        const late = [];
+        for (const value of line.slice(colon + 1).split(",")) {
+            const instant = instantOf(value, tzid ?? zone);
+            if (instant === undefined)
+                throw new CliError("validation_error", `the series holds ${head}:${value}, which cannot be split here; change it in the calendar itself`, { reason: "event.repeat-split" });
+            (instant < at ? early : late).push(value);
+        }
+        if (early.length)
+            before.push(`${head}:${early.join(",")}`);
+        if (late.length)
+            after.push(`${head}:${late.join(",")}`);
+    }
+    return { before, after };
+};

package/dist/calendar/sync.d.ts

@@ -21,6 +21,8 @@ export interface PendingRound {
     next: string | null;
     /** Series still to ask for their slots (`expands: "on-request"`). */
     series: string[];
+    /** A full round asks every series it lists; otherwise only those that changed. Absent reads as true. */
+    everySeries?: boolean;
 }
 /** What the engine keeps in `EventStore.cursor`. Version 1 had no `round`, `updatedAt` or `done`. */
 export interface CalendarCursor {
@@ -35,6 +37,10 @@ export interface CalendarCursor {
     /** Entries saved by the round in progress, or by the last round. */
     done: number;
     round: PendingRound | null;
+    /** Entries an older build marked deleted outside its window are back (`EventStore.restoreUnseen`). */
+    restored?: true;
+    /** The window's end when a full round last asked every series for its slots. */
+    slotsTo?: number;
 }
 export declare const parseCalendarCursor: (value: string | null) => CalendarCursor | null;
 /**