@wirecat/cli-core 0.474.0 → 0.475.0

package/CHANGELOG.md

@@ -5,6 +5,21 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
+## Unreleased
+
+## 0.475.0 — 29.10.2026
+
+### Fixed
+
+- **`events list` matches all-day events by their dates** (WC-TIME-5). An all-day event is stored as midnight in its
+  calendar's zone, so an owner in another zone got the next day's all-day event in `from:2026-11-02 to:2026-11-02`.
+  `eventsFilter` now also sets `fromDate` / `toDate` (the window's local days, `toDate` exclusive), and both event
+  stores compare an all-day event's `start_date` / `end_date` with them. Timed events, and a filter without the dates,
+  match as before.
+- **`events list` reports `hasMore`.** It was always false; it is now true when another event follows the page (also
+  across accounts in the MCP `events_list`). `listed()` takes an optional `{ limit, hasMore }`.
+- **`people list` says when it counted only its first 1000 events**, with `meta: { complete: true, truncated: true }`.
+
 ## 0.474.0 — 29.10.2026
 
 ### Fixed

package/dist/calendar/mcp/index.js

@@ -209,14 +209,20 @@ export const callCalendarTool = async (store, name, input, { accountIds, failure
                 break;
             case "events_list": {
                 const words = typeof args.words === "string" ? args.words.trim().split(/\s+/u) : [];
-                const lists = await Promise.all(accounts.map(async (accountId) => (await eventsAnswer(store, await eventsFilter(words, {
+                const limit = args.limit ?? 100;
+                const lists = await Promise.all(accounts.map(async (accountId) => eventsAnswer(store, await eventsFilter(words, {
                     store,
                     accountId,
                     zone: args.timezone ?? "UTC",
                     now,
-                }).then((filter) => filter && { ...filter, limit: args.limit ?? 100 }))).items));
-                const items = lists.flat().sort((a, b) => (a.starts_at ?? "").localeCompare(b.starts_at ?? ""));
-                answer = listed(items.slice(0, args.limit ?? 100));
+                }).then((filter) => filter && { ...filter, limit }))));
+                const items = lists
+                    .flatMap((one) => one.items)
+                    .sort((a, b) => (a.starts_at ?? "").localeCompare(b.starts_at ?? ""));
+                answer = listed(items.slice(0, limit), {
+                    limit,
+                    hasMore: items.length > limit || lists.some((one) => one.hasMore),
+                });
                 break;
             }
             case "event_show":

package/dist/calendar/reads.d.ts

@@ -109,6 +109,8 @@ export declare const peopleAnswer: (store: EventStore, accountId: number, option
     filter?: EventFilter;
     personOf?: PersonOfEmail;
 }) => Promise<{
+    limit: number;
+    hasMore: boolean;
     items: {
         email: string;
         name: string | null;
@@ -120,11 +122,30 @@ export declare const peopleAnswer: (store: EventStore, accountId: number, option
         person: string | null;
     }[];
     page: number;
+} | {
     limit: number;
     hasMore: boolean;
+    items: {
+        email: string;
+        name: string | null;
+        response: import("../meetings/event-store.js").ParticipantResponse | null;
+        organizer: boolean;
+        optional: boolean;
+        resource: boolean;
+        self: boolean;
+        person: string | null;
+        events: number;
+    }[];
+    page: number;
+    meta: {
+        complete: boolean;
+        truncated: boolean;
+    };
 }>;
 /** Open link choices, with each candidate event's title and time so the owner can pick. */
 export declare const reviewsAnswer: (store: EventStore) => Promise<{
+    limit: number;
+    hasMore: boolean;
     items: {
         id: string;
         entry_id: string;
@@ -136,8 +157,6 @@ export declare const reviewsAnswer: (store: EventStore) => Promise<{
         }[];
     }[];
     page: number;
-    limit: number;
-    hasMore: boolean;
     accounts: string;
 }>;
 export declare const resolveAnswer: (store: EventStore, review: string, choice: string, now: number) => Promise<{
@@ -146,6 +165,8 @@ export declare const resolveAnswer: (store: EventStore, review: string, choice:
     chosen: string | null;
 }>;
 export declare const eventsAnswer: (store: EventStore, filter: EventFilter | null) => Promise<{
+    limit: number;
+    hasMore: boolean;
     items: {
         id: string;
         event_series_id: string | null;
@@ -165,6 +186,4 @@ export declare const eventsAnswer: (store: EventStore, filter: EventFilter | nul
         untrusted?: string[] | undefined;
     }[];
     page: number;
-    limit: number;
-    hasMore: boolean;
 }>;

package/dist/calendar/reads.js

@@ -93,6 +93,10 @@ export const eventsFilter = async (words, context) => {
     }
     if (!timed)
         filter.from = day(today);
+    if (filter.from !== undefined)
+        filter.fromDate = localDate(filter.from, context.zone);
+    if (filter.to !== undefined)
+        filter.toDate = plusDays(localDate(filter.to - 1, context.zone), 1);
     return filter;
 };
 /**
@@ -169,13 +173,23 @@ export const eventAnswer = async (details, personOf) => ({
         changed_at: new Date(one.createdAt).toISOString(),
     })),
 });
+const EVENTS_COUNTED = 1000;
+/** One page of events, and whether another follows; probed with one row, since a store reads at most 1000. */
+const page = async (store, filter) => {
+    const rows = await store.events(filter);
+    const limit = filter.limit ?? 100;
+    const hasMore = rows.length === limit &&
+        (await store.events({ ...filter, offset: (filter.offset ?? 0) + limit, limit: 1 })).length > 0;
+    return { rows, limit, hasMore };
+};
 /** One event's attendees, or everyone attending the events of the filter, with how many of them each attends. */
 export const peopleAnswer = async (store, accountId, options) => {
     if (options.event !== undefined)
         return listed(await attendees((await eventOf(store, accountId, options.event)).participants, options.personOf));
     const counted = new Map();
     const mine = await calendarIds(store, accountId);
-    for (const event of await store.events({ ...options.filter, accountId, limit: 1000 })) {
+    const { rows, hasMore } = await page(store, { ...options.filter, accountId, limit: EVENTS_COUNTED });
+    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 : []) {
@@ -190,9 +204,10 @@ export const peopleAnswer = async (store, accountId, options) => {
         }
     }
     const people = await attendees([...counted.values()].map(({ participant }) => participant), options.personOf);
-    return listed(people
+    const answer = listed(people
         .map((one) => ({ ...one, events: counted.get(one.email)?.events ?? 0 }))
         .sort((a, b) => b.events - a.events || a.email.localeCompare(b.email)));
+    return hasMore ? { ...answer, meta: { complete: true, truncated: true } } : answer;
 };
 /** Open link choices, with each candidate event's title and time so the owner can pick. */
 export const reviewsAnswer = async (store) => {
@@ -226,4 +241,9 @@ export const resolveAnswer = async (store, review, choice, now) => {
         chosen: resolved.chosenId === null ? null : `event:${resolved.chosenId}`,
     };
 };
-export const eventsAnswer = async (store, filter) => listed(filter === null ? [] : (await store.events(filter)).map(eventItem));
+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 });
+};

package/dist/calendar/testing/memory.js

@@ -409,8 +409,14 @@ export const memoryEventStore = () => {
             const has = (event, check) => entries.some((one) => one.eventId === event.id && check(one));
             return [...events.values()]
                 .filter((event) => event.deletedAt === null &&
-                (filter.from === undefined || (event.endsAt ?? (event.startsAt ?? 0) + 1) > filter.from) &&
-                (filter.to === undefined || (event.startsAt !== null && event.startsAt < filter.to)) &&
+                (filter.from === undefined ||
+                    (event.allDay && filter.fromDate !== undefined
+                        ? has(event, (one) => (one.endDate ?? "") > (filter.fromDate ?? ""))
+                        : (event.endsAt ?? (event.startsAt ?? 0) + 1) > filter.from)) &&
+                (filter.to === undefined ||
+                    (event.allDay && filter.toDate !== undefined
+                        ? has(event, (one) => one.startDate !== null && one.startDate < (filter.toDate ?? ""))
+                        : event.startsAt !== null && event.startsAt < filter.to)) &&
                 (filter.calendarId === undefined || has(event, (one) => one.calendarId === filter.calendarId)) &&
                 (filter.accountId === undefined ||
                     has(event, (one) => calendarOf(one.calendarId).accountId === filter.accountId)) &&

package/dist/meetings/event-store.d.ts

@@ -181,6 +181,10 @@ export interface EventFilter {
     from?: number;
     /** Events that start before this instant. */
     to?: number;
+    /** All-day events, which have dates and no instant, ending after this local day (`YYYY-MM-DD`); `from` without it. */
+    fromDate?: string;
+    /** All-day events starting before this local day (exclusive); `to` without it. */
+    toDate?: string;
     accountId?: number;
     calendarId?: number;
     /** Events whose entries list one of this person's contacts. */

package/dist/meetings/reads.d.ts

@@ -10,17 +10,20 @@ export declare class MeetingError extends CliError {
 }
 export declare const positiveInteger: (value: unknown) => number;
 export declare const meetingShow: (store: MeetingStore, id: number, accountId?: number) => Promise<MeetingDetails>;
-export declare const listed: <T>(items: T[]) => {
-    items: T[];
-    page: number;
+export declare const listed: <T>(items: T[], page?: {
+    limit: number;
+    hasMore: boolean;
+}) => {
     limit: number;
     hasMore: boolean;
+    items: T[];
+    page: number;
 };
 export declare const meetingPeople: (store: MeetingStore & Partial<MeetingParticipantSearchStore>, query: string, accountId?: number, options?: Omit<MeetingParticipantSearchOptions, "accountId">) => Promise<{
-    items: import("./model.js").Participant[];
-    page: number;
     limit: number;
     hasMore: boolean;
+    items: import("./model.js").Participant[];
+    page: number;
 } | {
     schema_version: 1;
     kind: "meeting_participants";
@@ -76,8 +79,8 @@ export declare const meetingDetailsAnswer: (store: MeetingStore, id: number, acc
 export declare const meetingTranscriptAnswer: (store: MeetingStore, id: number, accountId?: number, options?: TranscriptReadOptions) => Promise<MeetingListBody<MeetingTranscriptItem>>;
 export declare const meetingSummaryAnswer: (store: MeetingStore, id: number, accountId?: number) => Promise<MeetingListBody<MeetingSummaryItem>>;
 export declare const meetingsSearch: (store: MeetingStore, query: string, filter?: MeetingFilter) => Promise<{
-    items: import("./store.js").SearchHit[];
-    page: number;
     limit: number;
     hasMore: boolean;
+    items: import("./store.js").SearchHit[];
+    page: number;
 }>;

package/dist/meetings/reads.js

@@ -33,7 +33,11 @@ export const meetingShow = async (store, id, accountId) => {
         throw new MeetingError("not_found", "meeting not found");
     return details;
 };
-export const listed = (items) => ({ items, page: 1, limit: items.length, hasMore: false });
+export const listed = (items, page = { limit: items.length, hasMore: false }) => ({
+    items,
+    page: 1,
+    ...page,
+});
 export const meetingPeople = async (store, query, accountId, options = {}) => {
     if (accountId === undefined)
         validateMeetingParticipantQuery(query);

package/dist/store/sqlite/calendar.js

@@ -542,14 +542,19 @@ export const eventStoreOver = (context) => {
             const clauses = ["e.deleted_at IS NULL"];
             const params = [];
             const entries = (extra) => `EXISTS (SELECT 1 FROM calendar_entries ce JOIN calendars c ON c.id = ce.calendar_id WHERE ce.event_id = e.id AND ${extra})`;
-            if (filter.from !== undefined) {
-                clauses.push("coalesce(e.ends_at, e.starts_at + 1) > ?");
-                params.push(filter.from);
-            }
-            if (filter.to !== undefined) {
-                clauses.push("e.starts_at < ?");
-                params.push(filter.to);
-            }
+            const dated = (column, date, instant, at) => {
+                if (at === undefined)
+                    return;
+                if (date === undefined) {
+                    clauses.push(instant);
+                    params.push(at);
+                    return;
+                }
+                clauses.push(`(CASE WHEN e.all_day = 1 THEN EXISTS (SELECT 1 FROM calendar_entries ce WHERE ce.event_id = e.id AND ce.${column}) ELSE ${instant} END)`);
+                params.push(date, at);
+            };
+            dated("end_date > ?", filter.fromDate, "coalesce(e.ends_at, e.starts_at + 1) > ?", filter.from);
+            dated("start_date < ?", filter.toDate, "e.starts_at < ?", filter.to);
             if (filter.calendarId !== undefined) {
                 clauses.push(entries("ce.calendar_id = ?"));
                 params.push(filter.calendarId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.474.0",
+  "version": "0.475.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",