@wirecat/cli-core 0.452.0 → 0.454.0

package/dist/services/events-search.js

@@ -0,0 +1,131 @@
+import { CliError } from "@wirecat/cli-base";
+import { kindIn } from "../domain/providers.js";
+import { meaningFloor } from "../embeddings/models.js";
+import { excerpt } from "./excerpt.js";
+import { localModel, RRF_K, storeQuery, withLocal } from "./notes-search.js";
+import { plainQueryWords } from "./notes-title-tier.js";
+const MAX_EVENTS_OFFSET = 1000;
+const iso = (at) => (at === null ? null : new Date(at).toISOString());
+/** The stored ids of the calendar accounts named; a name the store does not hold reads nothing. */
+const accountIdsOf = async (store, accounts) => {
+    const held = await store.accounts.storedAccounts();
+    return held
+        .filter((one) => accounts.some(({ provider, account }) => one.provider === provider && one.account === account))
+        .map(({ id }) => String(id));
+};
+/** The calendar accounts the store holds: every account whose provider is of the `events` kind. */
+export const calendarAccounts = async (store) => (await store.accounts.storedAccounts())
+    .filter(({ provider }) => kindIn(provider) === "events")
+    .map(({ provider, account }) => ({ provider, account }));
+export const foundEvent = (hit, query, foundBy) => ({
+    ref: hit.ref,
+    provider: hit.account?.provider ?? null,
+    account: hit.account?.account ?? null,
+    title: hit.event.title,
+    starts_at: iso(hit.event.startsAt),
+    ends_at: iso(hit.event.endsAt),
+    all_day: hit.event.allDay === true,
+    status: hit.event.status ?? null,
+    location: hit.event.location,
+    ...(hit.url ? { url: hit.url } : {}),
+    excerpt: excerpt(hit.text || (hit.event.title ?? ""), query),
+    occurrences: hit.occurrences,
+    updated_at: new Date(hit.event.updatedAt).toISOString(),
+    found_by: foundBy,
+});
+/** How deep each half is read before the two are merged. */
+const CANDIDATES = 50;
+/** Events nearest in meaning to plain words, one per series, best first; only events already embedded are found. */
+const nearestEvents = async (store, words, { limit, accountIds, env, command, embedders, }) => {
+    const { model, directory, key } = localModel(undefined, env, command);
+    if (!(await store.calendar.embedded(key, accountIds ? { accountIds } : {})))
+        throw new CliError("not_found", `no event has vectors of ${model.id} yet, so only words were matched`);
+    const [vector] = await withLocal(model, directory, undefined, (embedder) => embedder.embed([words], "query"), embedders);
+    const floor = meaningFloor(key);
+    return (await store.calendar.nearest(key, vector, { limit, ...(accountIds ? { accountIds } : {}) })).filter(({ score }) => score > floor);
+};
+/** One hit per series, whichever half found it. */
+const keyOf = ({ event }) => event.eventSeriesId === null ? `e${event.id}` : `s${event.eventSeriesId}`;
+/**
+ * Calendar events by words and, when the local text model is there and the query is plain words, by meaning, merged
+ * by reciprocal rank: title, cleaned description, place and attendees' names. The occurrences of one series are one
+ * hit. Working location, focus time, out of office, birthdays and busy-only slots are never found.
+ */
+export const searchEvents = async (store, query, { limit = 20, offset = 0, accounts, exact, newest, timezone, signal, candidates, env, command, embedders, } = {}) => {
+    if (!query.trim())
+        throw new CliError("validation_error", "say what to find in the events");
+    const { root, stemmer } = await storeQuery(store, query, {
+        ...(exact ? { exact: true } : {}),
+        ...(timezone === undefined ? {} : { timezone }),
+    });
+    const accountIds = accounts === undefined ? undefined : await accountIdsOf(store, accounts);
+    if (accountIds?.length === 0)
+        return { query, by: "words", hits: [], has_more: false };
+    const words = plainQueryWords(query);
+    const window = offset + limit;
+    let meaningSkipped;
+    let meaning;
+    if (exact)
+        meaningSkipped = "--exact searches words as written";
+    else if (newest)
+        meaningSkipped = "newest first orders by time";
+    else if (words === undefined)
+        meaningSkipped = "the query has fields or operators, which meaning cannot follow";
+    else
+        try {
+            meaning = await nearestEvents(store, words, {
+                limit: Math.max(window, CANDIDATES),
+                ...(accountIds ? { accountIds } : {}),
+                ...(env === undefined ? {} : { env }),
+                ...(command === undefined ? {} : { command }),
+                ...(embedders === undefined ? {} : { embedders }),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof CliError && error.code === "not_found"))
+                throw error;
+            meaningSkipped = error.message;
+        }
+    const found = await store.calendar.search({
+        root,
+        limit: meaning === undefined ? limit : Math.max(window, CANDIDATES),
+        offset: meaning === undefined ? offset : 0,
+        ...(accountIds === undefined ? {} : { accountIds }),
+        ...(newest ? { newest: true } : {}),
+        ...(stemmer ? { stemmer } : {}),
+        ...(signal ? { signal } : {}),
+        ...(candidates === undefined ? {} : { candidates }),
+    });
+    const truncated = found.truncated ? { truncated: true } : {};
+    const by = meaning === undefined ? "words" : "words and meaning";
+    const skipped = meaningSkipped === undefined ? {} : { meaning_skipped: meaningSkipped };
+    if (meaning === undefined)
+        return {
+            query,
+            by,
+            ...skipped,
+            hits: found.items.map((hit) => foundEvent(hit, query, ["words"])),
+            has_more: found.hasMore,
+            ...(found.hasMore && window <= MAX_EVENTS_OFFSET ? { next_offset: window } : {}),
+            ...truncated,
+        };
+    const ranked = new Map();
+    const add = (list, half) => list.forEach((hit, rank) => {
+        const held = ranked.get(keyOf(hit)) ?? { hit, score: 0, by: [] };
+        held.score += 1 / (RRF_K + rank + 1);
+        held.by.push(half);
+        ranked.set(keyOf(hit), held);
+    });
+    add(found.items, "words");
+    add(meaning, "meaning");
+    const ordered = [...ranked.values()].sort((a, b) => b.score - a.score);
+    const hasMore = ordered.length > window || found.hasMore;
+    return {
+        query,
+        by,
+        hits: ordered.slice(offset, window).map(({ hit, by: halves }) => foundEvent(hit, query, halves)),
+        has_more: hasMore,
+        ...(hasMore && window <= MAX_EVENTS_OFFSET ? { next_offset: window } : {}),
+        ...truncated,
+    };
+};

package/dist/services/index.d.ts

@@ -84,7 +84,7 @@ export type { ModerateOptions, ModerationService, ShownRules } from "./moderatio
 export { moderationService } from "./moderation.js";
 export type { ContactSync, PeopleService } from "./people.js";
 export { peopleService, phoneOf } from "./people.js";
-export type { ContextMessage, ContextOptions, NotReadReason, PersonContext, SharedChat, } from "./person-context.js";
+export type { ContextEvent, ContextMessage, ContextOptions, NotReadReason, PersonContext, SharedChat, } from "./person-context.js";
 export { CONTEXT_BYTES, CONTEXT_MESSAGES, identityIn, personContext } from "./person-context.js";
 export type { PersonPreparation, WaitingDialog } from "./person-preparation.js";
 export { PREPARE_BYTES, personPreparation } from "./person-preparation.js";
@@ -149,6 +149,7 @@ export type { CounterQuery, CountersService } from "./counters.js";
 export { countersService } from "./counters.js";
 export { type DocumentTarget, openPictureEmbedderFor, type PictureOptions, removePicture, savePicture, } from "./document-pictures.js";
 export type { ModelChoice } from "./embeddings.js";
+export { calendarAccounts, type EventsFound, type EventsQuery, type FoundEvent, foundEvent, searchEvents, } from "./events-search.js";
 export { createMeetingBatchReader } from "./meeting-batch.js";
 export { type MeetingCombinedHit, type MeetingCombinedRequest, searchMeetingsCombined, } from "./meeting-combined.js";
 export type { MeetingCommunicationCoverage, MeetingCommunicationExcerpt, MeetingCommunications, MeetingCommunicationsPort, MeetingCommunicationsRequest, } from "./meeting-communications-types.js";
@@ -168,7 +169,7 @@ export type { MeaningLane, MeaningSkipped } from "./messages-discovery.js";
 export { meaningLane } from "./messages-meaning.js";
 export type { QueryMetadata, SearchCoverage } from "./messages-search.js";
 export { metadataService } from "./metadata.js";
-export { embedMail, embedNotes, type FoundNote, type LinkedRecord, type NotesEmbedded, type NotesEmbedOptions, type NotesFound, type NotesFoundOf, type NotesQuery, type NotesSearchRequest, nearestNotes, searchNotes, searchNotesOf, searchNotesQuery, } from "./notes-search.js";
+export { embedEvents, embedMail, embedNotes, type FoundNote, type LinkedRecord, type NotesEmbedded, type NotesEmbedOptions, type NotesFound, type NotesFoundOf, type NotesQuery, type NotesSearchRequest, nearestNotes, searchNotes, searchNotesOf, searchNotesQuery, storeQuery, } from "./notes-search.js";
 export { type PackageUpgradeOutcome, type PackageUpgradePorts, type PackageUpgradeResult, type ServerRestarts, upgradePackage, } from "./package-upgrade.js";
 export { type PersonMeetingContext, type PersonMeetingContextItem, type PersonMeetingContextOptions, type PersonMeetingReadStore, personMeetingContext, } from "./person-meeting-context.js";
 export { privatePeopleService } from "./private-people.js";

package/dist/services/index.js

@@ -111,6 +111,7 @@ export { adminStatisticsService } from "./admin-statistics.js";
 export { GAP_BOUNDS, gapsService } from "./archive-gaps.js";
 export { countersService } from "./counters.js";
 export { openPictureEmbedderFor, removePicture, savePicture, } from "./document-pictures.js";
+export { calendarAccounts, foundEvent, searchEvents, } from "./events-search.js";
 export { createMeetingBatchReader } from "./meeting-batch.js";
 export { searchMeetingsCombined, } from "./meeting-combined.js";
 export { createMeetingContextService, } from "./meeting-context.js";
@@ -126,7 +127,7 @@ export { proposeMeetingTask } from "./meeting-task-proposal.js";
 export { createTaskFromMeeting, readMeetingTask, } from "./meeting-tasks.js";
 export { meaningLane } from "./messages-meaning.js";
 export { metadataService } from "./metadata.js";
-export { embedMail, embedNotes, nearestNotes, searchNotes, searchNotesOf, searchNotesQuery, } from "./notes-search.js";
+export { embedEvents, embedMail, embedNotes, nearestNotes, searchNotes, searchNotesOf, searchNotesQuery, storeQuery, } from "./notes-search.js";
 export { upgradePackage, } from "./package-upgrade.js";
 export { personMeetingContext, } from "./person-meeting-context.js";
 export { privatePeopleService } from "./private-people.js";

package/dist/services/notes-search.d.ts

@@ -1,7 +1,10 @@
-import { type WarmEmbedders } from "../embeddings/embed.js";
+import { type Embedder, type WarmEmbedders } from "../embeddings/embed.js";
+import { type TextModel } from "../embeddings/models.js";
 import type { PictureEmbedder } from "../images/picture/embedder.js";
 import type { AppIdentity } from "../ports/app.js";
 import { type SkippedSource } from "../search/account-list.js";
+import { type ResolvedNode } from "../search/lucene/resolved.js";
+import { type Stemmer } from "../search/stem.js";
 import type { Link, NearestNote, Note, NoteHit } from "../store/index.js";
 import type { AccountKey, MessageStore } from "../store/store.js";
 export interface NotesSearchRequest {
@@ -19,6 +22,17 @@ export interface NotesSearchRequest {
     timezone?: string;
     signal?: AbortSignal;
 }
+/**
+ * Text in the query language messages use, parsed for a store search: `date:` read in `timezone`, and the store's
+ * stemmer when a word is stemmed.
+ */
+export declare const storeQuery: (store: MessageStore, text: string, { exact, timezone }?: {
+    exact?: boolean;
+    timezone?: string;
+}) => Promise<{
+    root: ResolvedNode;
+    stemmer?: Stemmer;
+}>;
 /** A notes search in the query language messages use, for `search notes` and `search all` to call. */
 export declare const searchNotesQuery: (store: MessageStore, request: NotesSearchRequest) => Promise<{
     items: NoteHit[];
@@ -38,9 +52,19 @@ export interface NotesEmbedded {
     /** Chunks still without a vector, when `maxChunks` stopped the run. */
     left: boolean;
 }
+export declare const localModel: (choice: string | undefined, env: NodeJS.ProcessEnv | undefined, command: string | undefined) => {
+    model: TextModel;
+    directory: string;
+    key: string;
+};
+export declare const withLocal: <T>(model: TextModel, directory: string, threads: number | undefined, work: (embedder: Embedder) => Promise<T>, shared?: Pick<WarmEmbedders, "get">) => Promise<T>;
 export declare const embedNotes: (store: MessageStore, options?: NotesEmbedOptions & {
     command?: string;
 }) => Promise<NotesEmbedded>;
+/** Embeds calendar events' pieces as notes' are embedded; the occurrences of a series share one vector. */
+export declare const embedEvents: (store: MessageStore, options?: NotesEmbedOptions & {
+    command?: string;
+}) => Promise<NotesEmbedded>;
 /** Embeds mail's chunks as notes' are embedded: same model and key, so search by meaning reads both. */
 export declare const embedMail: (store: MessageStore, options?: NotesEmbedOptions & {
     command?: string;

package/dist/services/notes-search.js

@@ -15,12 +15,13 @@ import { documentSource } from "./document-source.js";
 import { plainQueryWords, titleQuery, titleTiers } from "./notes-title-tier.js";
 import { PICTURE_FLOOR, plainWords } from "./pictures.js";
 import { listContextOf } from "./search-kind.js";
-/** A notes search in the query language messages use, for `search notes` and `search all` to call. */
-export const searchNotesQuery = async (store, request) => {
-    if (!request.text.trim())
-        throw new CliError("validation_error", "say what to find in the notes");
-    const ast = validateFields(parseLucene(request.text, { ...SEARCH_QUERY, defaultField: request.exact ? "exact" : "text" }));
-    const timezone = timezoneOf(request.timezone);
+/**
+ * Text in the query language messages use, parsed for a store search: `date:` read in `timezone`, and the store's
+ * stemmer when a word is stemmed.
+ */
+export const storeQuery = async (store, text, { exact, timezone } = {}) => {
+    const ast = validateFields(parseLucene(text, { ...SEARCH_QUERY, defaultField: exact ? "exact" : "text" }));
+    const zone = timezoneOf(timezone);
     const resolve = (node) => {
         if (node.kind === "boolean")
             return { ...node, clauses: node.clauses.map(({ occur, node }) => ({ occur, node: resolve(node) })) };
@@ -29,15 +30,25 @@ export const searchNotesQuery = async (store, request) => {
         return {
             ...node,
             resolution: {
-                date: dateRange(node.value, node.operator === "range" ? (node.upper ?? "*") : node.value, node.operator === "range" ? node.lower_inclusive === true : true, node.operator === "range" ? node.upper_inclusive === true : true, timezone, node.span),
+                date: dateRange(node.value, node.operator === "range" ? (node.upper ?? "*") : node.value, node.operator === "range" ? node.lower_inclusive === true : true, node.operator === "range" ? node.upper_inclusive === true : true, zone, node.span),
             },
         };
     };
     const stemmers = hasStems(ast.root) ? await store.searchIndex.stemmers() : undefined;
     if (stemmers === null)
         throw new CliError("validation_error", "the store asks for stemmers this tool does not know — upgrade this tool, or search exact forms with --exact", { reason: "stemmer.unknown" });
-    return store.notes.search({
+    return {
         root: resolve(ast.root),
+        ...(hasStems(ast.root) ? { stemmer: createStemmer(stemmers ?? DEFAULT_STEMMERS) } : {}),
+    };
+};
+/** A notes search in the query language messages use, for `search notes` and `search all` to call. */
+export const searchNotesQuery = async (store, request) => {
+    if (!request.text.trim())
+        throw new CliError("validation_error", "say what to find in the notes");
+    const { root, stemmer } = await storeQuery(store, request.text, request);
+    return store.notes.search({
+        root,
         limit: request.limit,
         ...(request.offset === undefined ? {} : { offset: request.offset }),
         ...(request.newest ? { newest: true } : {}),
@@ -45,7 +56,7 @@ export const searchNotesQuery = async (store, request) => {
         ...(request.withInternal ? { withInternal: true } : {}),
         ...(request.source ? { source: request.source } : {}),
         ...(request.signal ? { signal: request.signal } : {}),
-        ...(hasStems(ast.root) ? { stemmer: createStemmer(stemmers ?? DEFAULT_STEMMERS) } : {}),
+        ...(stemmer ? { stemmer } : {}),
     });
 };
 /** Chunks one batch embeds: one short transaction writes each, as for conversations. */
@@ -54,7 +65,7 @@ const NOTE_BATCH = 8;
 const downloadHint = (model, command) => command === undefined
     ? `install it with a WireCat CLI that has \`models download\` (tg, max or wa); they share the model folder`
     : `\`${command} models download ${model}\``;
-const localModel = (choice, env, command) => {
+export const localModel = (choice, env, command) => {
     const model = textModel(choice ?? DEFAULT_TEXT_MODEL);
     const directory = textModelsDirectory(env);
     if (!isTextModelInstalled(model, directory))
@@ -64,7 +75,7 @@ const localModel = (choice, env, command) => {
         });
     return { model, directory, key: vectorModelKey(model) };
 };
-const withLocal = async (model, directory, threads, work, shared) => {
+export const withLocal = async (model, directory, threads, work, shared) => {
     if (shared)
         return work(await shared.get(vectorModelKey(model), () => openEmbedder(model, directory, { threads: threads ?? defaultThreads() })));
     const embedder = await openEmbedder(model, directory, { threads: threads ?? defaultThreads() });
@@ -104,6 +115,8 @@ const embedChunks = async (store, source, { model: choice, maxChunks = Number.PO
     });
 };
 export const embedNotes = (store, options = {}) => embedChunks(store, store.notes, options);
+/** Embeds calendar events' pieces as notes' are embedded; the occurrences of a series share one vector. */
+export const embedEvents = (store, options = {}) => embedChunks(store, store.calendar, options);
 /** Embeds mail's chunks as notes' are embedded: same model and key, so search by meaning reads both. */
 export const embedMail = (store, options = {}) => embedChunks(store, store.mail, options);
 /** Notes nearest in meaning to the query, best first; only notes already embedded can be found. */

package/dist/services/person-context.d.ts

@@ -23,6 +23,18 @@ export interface SharedChat {
     kind: ChatKind;
     lastMessageAt: string | null;
 }
+/** A calendar event the person is invited to, through any contact linked to them. */
+export interface ContextEvent {
+    /** `event:<id>`: of a series, the one occurrence listed. */
+    ref: string;
+    title: string | null;
+    startsAt: string | null;
+    endsAt: string | null;
+    allDay: boolean;
+    location: string | null;
+    /** confirmed or tentative; a cancelled event is not listed. */
+    status: string | null;
+}
 /** `not_fetched`: nothing of its history was ever read into the store; `partial`: only some of it was. */
 export type NotReadReason = "not_fetched" | "partial";
 export interface PersonContext {
@@ -42,6 +54,11 @@ export interface PersonContext {
         groups: ContextMessage[];
     };
     mentions: ContextMessage[];
+    /** Calendar events they are invited to, one occurrence per series: the next ones, then the latest past ones. */
+    events: {
+        upcoming: ContextEvent[];
+        recent: ContextEvent[];
+    };
     limits: {
         messages: number;
         bytes: number;
@@ -59,6 +76,8 @@ export interface ContextOptions {
     bytes?: number;
     /** ms: nothing older. */
     since?: number;
+    /** ms: what splits upcoming events from past ones; the clock when absent. */
+    now?: number;
 }
 export declare const toContext: (key: AccountKey, message: Message, chatTitle: string | null) => ContextMessage;
 /**
@@ -74,7 +93,7 @@ export declare const readsOf: (record: PersonRecord, asked: AccountKey) => {
  * What the store knows about one person, across every identity linked to them. Reads the store
  * only: nothing is fetched, nothing marked read. Identity is by id, never by name.
  */
-export declare const personContext: (store: MessageStore, asked: AccountKey, reference: string, { messages, bytes, since }?: ContextOptions) => Promise<PersonContext>;
+export declare const personContext: (store: MessageStore, asked: AccountKey, reference: string, { messages, bytes, since, now }?: ContextOptions) => Promise<PersonContext>;
 /** `max:Ana` names a person in another messenger of this store; a reference with no prefix, this one. */
 export declare const identityIn: (store: MessageStore, asked: AccountKey, reference: string) => Promise<IdentityRef>;
 export declare const CHAT_MESSAGES = 20;

package/dist/services/person-context.js

@@ -44,6 +44,42 @@ const mailWith = async (store, key, address, limit, since) => {
     return { items, hasMore: emails.length > limit };
 };
 const newestFirst = (a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp);
+const iso = (at) => (at === null ? null : new Date(at).toISOString());
+const contextEvent = (event) => ({
+    ref: `event:${event.id}`,
+    title: event.title,
+    startsAt: iso(event.startsAt),
+    endsAt: iso(event.endsAt),
+    allDay: event.allDay === true,
+    location: event.location,
+    status: event.status ?? null,
+});
+const EVENT_PAGE = 100;
+/** A weekly meeting held for years is hundreds of occurrences; past this many rows the list stops, cut. */
+const EVENT_ROWS = 1000;
+/** Up to `limit` events of `filter`, in its order, the first occurrence of each series only and none cancelled. */
+const eventsOnce = async (store, filter, limit) => {
+    const items = [];
+    const series = new Set();
+    for (let offset = 0; offset < EVENT_ROWS; offset += EVENT_PAGE) {
+        const page = await store.calendar.events({ ...filter, limit: EVENT_PAGE, offset });
+        for (const event of page) {
+            if (event.status === "cancelled")
+                continue;
+            if (event.eventSeriesId !== null) {
+                if (series.has(event.eventSeriesId))
+                    continue;
+                series.add(event.eventSeriesId);
+            }
+            if (items.length === limit)
+                return { items, cut: true };
+            items.push(event);
+        }
+        if (page.length < EVENT_PAGE)
+            return { items, cut: false };
+    }
+    return { items, cut: true };
+};
 /**
  * The accounts each identity is read in: for the messenger asked, only the account asked about — a
  * second account of the same messenger is somebody else's view; for a linked messenger, every account
@@ -56,7 +92,7 @@ export const readsOf = (record, asked) => record.identities.flatMap((identity) =
  * What the store knows about one person, across every identity linked to them. Reads the store
  * only: nothing is fetched, nothing marked read. Identity is by id, never by name.
  */
-export const personContext = async (store, asked, reference, { messages = CONTEXT_MESSAGES, bytes = CONTEXT_BYTES, since } = {}) => {
+export const personContext = async (store, asked, reference, { messages = CONTEXT_MESSAGES, bytes = CONTEXT_BYTES, since, now = Date.now() } = {}) => {
     const found = pickPerson(reference, await store.people.people(asked.provider, { account: asked.account }));
     const record = await store.people.personOf({ provider: asked.provider, id: found.id });
     if (!record)
@@ -121,6 +157,11 @@ export const personContext = async (store, asked, reference, { messages = CONTEX
             .filter(recent));
         cut ||= named.hasMore;
     }
+    const personId = Number(record.uid);
+    const upcoming = await eventsOnce(store, { personId, from: now }, messages);
+    const upcomingIds = new Set(upcoming.items.map(({ id }) => id));
+    const past = await eventsOnce(store, { personId, to: now, newest: true, ...(since === undefined ? {} : { from: since }) }, messages);
+    cut ||= upcoming.cut || past.cut;
     direct.sort(newestFirst);
     const each = [...direct, ...beyond].sort(newestFirst);
     theirs.sort(newestFirst);
@@ -145,6 +186,10 @@ export const personContext = async (store, asked, reference, { messages = CONTEX
         },
         recent: { direct: kept.direct, groups: kept.groups },
         mentions: kept.mentions,
+        events: {
+            upcoming: upcoming.items.map(contextEvent),
+            recent: past.items.filter(({ id }) => !upcomingIds.has(id)).map(contextEvent),
+        },
         limits: { messages, bytes },
         hasMore: cut || kept.cut,
         complete: notRead.length === 0,

package/dist/services/search-all-meetings.d.ts

@@ -3,7 +3,7 @@ import type { AccountKey, MessageStore } from "../store/store.js";
 import type { SearchFound, SearchQuery } from "./messages.js";
 import type { MeaningLane } from "./messages-discovery.js";
 import { type SearchAllFound, type SearchAllItem, type SearchAllMessenger, type SearchAllRequest, type Skipped } from "./search-all.js";
-export declare const RESOURCES_SEARCHED_WITH_MEETINGS: readonly ["messages", "mail", "notes", "meetings"];
+export declare const RESOURCES_SEARCHED_WITH_MEETINGS: readonly ["messages", "mail", "notes", "events", "meetings"];
 export type ResourceWithMeetings = (typeof RESOURCES_SEARCHED_WITH_MEETINGS)[number];
 export interface MeetingSearchItem {
     kind: "meeting";

package/dist/services/search-all-meetings.js

@@ -131,7 +131,7 @@ export const searchAllIncludingMeetings = async (store, account, request, messen
     const only = request.only ?? RESOURCES_SEARCHED_WITH_MEETINGS;
     if (!only.length ||
         only.some((resource) => !RESOURCES_SEARCHED_WITH_MEETINGS.includes(resource)))
-        throw new CliError("validation_error", "only takes messages, mail, notes and meetings");
+        throw new CliError("validation_error", "only takes messages, mail, notes, events and meetings");
     if (request.meetingCursor) {
         if (only.length !== 1 || only[0] !== "meetings")
             throw new CliError("validation_error", "meeting cursor requires only: [meetings]");
@@ -261,7 +261,12 @@ const searchAllOfSource = async (store, account, source, request, messenger, sea
     const found = await searchAllIncludingMeetings(store, account, {
         ...request,
         only: read,
-        scope: { messages: named("messages"), mail: named("mail"), notes: named("notes") },
+        scope: {
+            messages: named("messages"),
+            mail: named("mail"),
+            notes: named("notes"),
+            events: named("events"),
+        },
         ...(meetings[0] ? { meetingAccount: meetings[0] } : {}),
     }, messenger, searchMessages, meaning);
     const unnamed = only

package/dist/services/search-all.d.ts

@@ -5,16 +5,16 @@ import type { AccountKey, MessageStore } from "../store/store.js";
 import type { SearchFound, SearchQuery } from "./messages.js";
 import { type MeaningLane, type MeaningSkipped } from "./messages-discovery.js";
 import type { Backend, ServerOptions, ServerSearched } from "./server-search.js";
-export declare const RESOURCES_SEARCHED: readonly ["messages", "mail", "notes"];
+export declare const RESOURCES_SEARCHED: readonly ["messages", "mail", "notes", "events"];
 export type SearchedResource = (typeof RESOURCES_SEARCHED)[number];
 export interface SearchAllItem {
-    kind: "message" | "mail" | "note" | "document";
-    /** `msg:…` for a message or a mail, `note:…` for a note. */
+    kind: "message" | "mail" | "note" | "document" | "event";
+    /** `msg:…` for a message or a mail, `note:…` for a note, `event:…` for a calendar event. */
     ref: string;
     provider: string;
     /** The account it was found in; a note's folder id, or `internal` for a note written in memo. */
     account: string;
-    /** The chat, the mail thread's subject or the note's title. */
+    /** The chat, the mail thread's subject, the note's or the event's title. */
     url?: string;
     title: string | null;
     timestamp: string;
@@ -63,6 +63,11 @@ export interface SearchAllFound {
         by: "words" | "words and meaning";
         meaningSkipped?: string;
     };
+    /** How calendar events were searched, when they were. */
+    events?: {
+        by: "words" | "words and meaning";
+        meaningSkipped?: string;
+    };
     /** How the messages were searched, when they were; never by meaning with `exact` or the server alone. */
     messages?: {
         by: "words" | "words and meaning";
@@ -79,7 +84,7 @@ export interface SearchAllRequest {
     only?: readonly SearchedResource[];
     exact?: boolean;
     timezone?: string;
-    /** For messages only; mail and notes are always the local store's. */
+    /** For messages only; mail, notes and events are always the local store's. */
     backend?: Backend;
     server?: ServerOptions;
     env?: NodeJS.ProcessEnv;
@@ -95,8 +100,8 @@ export type SearchAllMessenger = Partial<Pick<MessengerTraits, "savedChatId" | "
     hintCommand?: string | null;
 };
 /**
- * `search all`: messages, mail and notes from the local store — messages also from the messenger's
+ * `search all`: messages, mail, notes and calendar events from the local store — messages also from the messenger's
  * server, as `search messages` asks it — each list best first, merged by reciprocal rank so no
- * resource's own scores have to be compared with another's.
+ * resource's own scores have to be compared with another's. Events are read only when the store holds a calendar.
  */
 export declare const searchAll: (store: MessageStore, account: AccountKey, request: SearchAllRequest, messenger?: SearchAllMessenger, searchMessages?: (query: SearchQuery) => Promise<SearchFound>, meaning?: MeaningLane) => Promise<SearchAllFound>;

package/dist/services/search-all.js

@@ -6,11 +6,12 @@ import { runEmbedders } from "../embeddings/embed.js";
 import { DEFAULT_TEXT_MODEL } from "../embeddings/models.js";
 import { MESSAGE_PARSING } from "../search/lucene/types.js";
 import { planQuestion } from "../search/question-plan.js";
+import { calendarAccounts, searchEvents } from "./events-search.js";
 import { excerpt } from "./excerpt.js";
 import { MAX_SEARCH_OFFSET, searchStore } from "./messages-archive-search.js";
 import { nearEligible } from "./messages-discovery.js";
 import { notesScopeOf, RRF_K, searchNotes } from "./notes-search.js";
-export const RESOURCES_SEARCHED = ["messages", "mail", "notes"];
+export const RESOURCES_SEARCHED = ["messages", "mail", "notes", "events"];
 /** A query a resource cannot answer is skipped with its reason, never a failure of the whole search. */
 const skippable = (error) => error instanceof CliError && (error.code === "validation_error" || error.code === "not_found");
 /**
@@ -28,9 +29,9 @@ const filtersBeside = (text) => {
         : undefined;
 };
 /**
- * `search all`: messages, mail and notes from the local store — messages also from the messenger's
+ * `search all`: messages, mail, notes and calendar events from the local store — messages also from the messenger's
  * server, as `search messages` asks it — each list best first, merged by reciprocal rank so no
- * resource's own scores have to be compared with another's.
+ * resource's own scores have to be compared with another's. Events are read only when the store holds a calendar.
  */
 export const searchAll = async (store, account, request, messenger = {}, searchMessages = (query) => searchStore(store, account, query, messenger), meaning) => {
     if (!request.text.trim())
@@ -48,6 +49,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
     const skipped = [];
     let hasMore = false;
     let notes;
+    let events;
     let messagesBy;
     let server;
     const messagesOf = async (kind) => {
@@ -133,7 +135,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
         });
         return [...fused.values()].sort((a, b) => b.score - a.score).map(({ item }) => item);
     };
-    // Messages and notes both look up by meaning with the same model: loading it costs most of a second.
+    // Messages, notes and events all look up by meaning with the same model: loading it costs most of a second.
     const embedders = runEmbedders();
     try {
         for (const resource of only) {
@@ -172,6 +174,38 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                     ];
                     accounts.push(...read.map((account) => ({ resource, provider: "notes", account })));
                 }
+                else if (resource === "events") {
+                    const read = request.scope?.events ?? (await calendarAccounts(store));
+                    if (!read.length)
+                        continue;
+                    const found = await searchEvents(store, request.text, {
+                        limit: window,
+                        accounts: read,
+                        embedders,
+                        ...(command === undefined ? {} : { command }),
+                        ...(request.env === undefined ? {} : { env: request.env }),
+                        ...(request.exact ? { exact: true } : {}),
+                        ...(request.timezone === undefined ? {} : { timezone: request.timezone }),
+                        ...(request.signal === undefined ? {} : { signal: request.signal }),
+                    });
+                    hasMore ||= found.has_more;
+                    events = {
+                        by: found.by,
+                        ...(found.meaning_skipped === undefined ? {} : { meaningSkipped: found.meaning_skipped }),
+                    };
+                    lists.push(found.hits.map((hit) => ({
+                        kind: "event",
+                        ref: hit.ref,
+                        provider: hit.provider ?? "calendar",
+                        account: hit.account ?? "",
+                        ...(hit.url ? { url: hit.url } : {}),
+                        title: hit.title,
+                        timestamp: hit.starts_at ?? hit.updated_at,
+                        text: hit.excerpt,
+                        foundBy: hit.found_by,
+                    })));
+                    accounts.push(...read.map(({ provider, account }) => ({ resource, provider, account })));
+                }
                 else
                     lists.push(await messagesOf(resource));
                 searched.push(resource);
@@ -204,6 +238,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
         accounts,
         skipped,
         ...(notes === undefined ? {} : { notes }),
+        ...(events === undefined ? {} : { events }),
         ...(messagesBy === undefined ? {} : { messages: messagesBy }),
         ...(server === undefined ? {} : { server }),
     };

package/dist/store/index.d.ts

@@ -30,6 +30,7 @@ export type { CatalogActor, CatalogEntry, CatalogInput, CatalogQuery, CatalogSto
 export { CATALOG_QUERY } from "./sqlite/catalog.js";
 export type { ChatMetadata } from "./sqlite/chats.js";
 export type { Email, EmailAddress, EmailAttachment, EmailFacts, EmailFilter, EmailInput, EmailInThread, EmailRecipient, EmailRef, EmailThread, EmailVectorHit, Mailbox, MailboxInput, MailFilter, MailStore, SenderScore, ThreadDetails, ThreadSave, } from "./sqlite/emails.js";
+export { EVENT_FIELDS, type EventChunkToEmbed, type EventHit, type EventQuery, type EventSearch, type NearestEvent, } from "./sqlite/event-search.js";
 export type { Fact, FactInput, FactsStore } from "./sqlite/facts.js";
 export type { FileListQuery, FilesStore, StoredFile } from "./sqlite/files.js";
 export { IMPORTED_DOCUMENT_QUERY, type ImportedDocuments } from "./sqlite/imported-documents.js";

package/dist/store/index.js

@@ -16,6 +16,7 @@ export { planProjectAnnotationSnapshot } from "./project-transfer/snapshot-plan.
 export { resetAttachmentWords } from "./sqlite/attachment-texts.js";
 export { backfillNormalized, pendingNormalization } from "./sqlite/backfill.js";
 export { CATALOG_QUERY } from "./sqlite/catalog.js";
+export { EVENT_FIELDS, } from "./sqlite/event-search.js";
 export { IMPORTED_DOCUMENT_QUERY } from "./sqlite/imported-documents.js";
 export { ORGANIZATION_KINDS, PROJECT_TYPES, SCOPES } from "./sqlite/knowledge.js";
 export { NOTE_FIELDS, } from "./sqlite/note-search.js";

package/dist/store/project-transfer/request.d.ts

@@ -22,7 +22,7 @@ export declare const projectAnnotationRequest: (request: ProjectAnnotationTarget
             ref: string;
             from: string;
             to: string | null;
-            kind: "about" | "answered-by" | "assigned-to" | "blocked-by" | "created-from" | "duplicate-of" | "evidence" | "follow-up-of" | "labelled" | "links-to" | "member-of" | "related-to";
+            kind: "about" | "answered-by" | "assigned-to" | "attached" | "blocked-by" | "created-from" | "duplicate-of" | "evidence" | "follow-up-of" | "labelled" | "links-to" | "member-of" | "related-to";
             origin: "file" | "message" | "owner" | "suggested";
             anchor: string | null;
             target_text: string | null;