@wirecat/cli-core 0.419.0 → 0.420.0

package/dist/meetings/read-answers.js

@@ -191,8 +191,12 @@ export const event = v.strictObject({
     starts_at: v.nullable(isoTime),
     ends_at: v.nullable(isoTime),
     timezone: v.nullable(text),
-    /** `auto`: made from a meeting; `owner`: made by hand. */
-    origin: v.picklist(["auto", "owner"]),
+    /** `auto`: made from a meeting; `owner`: made by hand; `calendar`: from a calendar's entries. */
+    origin: v.picklist(["auto", "owner", "calendar"]),
+    status: v.nullable(text),
+    all_day: v.boolean(),
+    /** When its calendar deleted it: shown as "deleted in Google", kept as history. */
+    source_deleted_at: v.nullable(isoTime),
     deleted_at: v.nullable(isoTime),
     created_at: isoTime,
     updated_at: isoTime,
@@ -207,6 +211,9 @@ export const eventItem = (one) => ({
     ends_at: iso(one.endsAt),
     timezone: one.timezone,
     origin: one.origin,
+    status: one.status ?? null,
+    all_day: one.allDay === true,
+    source_deleted_at: iso(one.sourceDeletedAt ?? null),
     deleted_at: iso(one.deletedAt),
     created_at: new Date(one.createdAt).toISOString(),
     updated_at: new Date(one.updatedAt).toISOString(),

package/dist/meetings/store.d.ts

@@ -120,6 +120,8 @@ export interface MeetingStore {
     setEventSeries(meetingSeriesId: number, eventSeriesId: number, now: number): Promise<void>;
     /** Automatic linking must not replace an existing link. */
     linkMeeting(id: number, eventId: number, now: number, mode?: "auto" | "owner"): Promise<void>;
+    /** Two or more events fit a meeting equally: no link, and the pair goes to the owner's review list. */
+    reviewMeetingLink?(meetingId: number, eventIds: number[], now: number): Promise<void>;
     cursor(accountId: number): Promise<string | null>;
     setCursor(accountId: number, value: string, now: number): Promise<void>;
 }

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

@@ -0,0 +1,10 @@
+import type { EventStore } from "../event-store.js";
+import type { ContractCase } from "../store.js";
+/** A fresh, empty store and one calendar account in it. */
+export interface EventStoreFixture {
+    store: EventStore;
+    accountId: number;
+}
+/** "Now" in every case: entries before it have happened. */
+export declare const CONTRACT_NOW: number;
+export declare const eventStoreContract: (make: () => EventStoreFixture | Promise<EventStoreFixture>) => ContractCase[];

package/dist/meetings/testing/event-store-contract.js

@@ -0,0 +1,161 @@
+import assert from "node:assert/strict";
+const HOUR = 3_600_000;
+/** "Now" in every case: entries before it have happened. */
+export const CONTRACT_NOW = 1_000 * HOUR;
+const single = (externalId, at, extra = {}) => ({
+    externalId,
+    kind: "single",
+    status: "confirmed",
+    title: "Example review",
+    startsAt: at,
+    endsAt: at + HOUR,
+    ...extra,
+});
+export const eventStoreContract = (make) => {
+    const test = (name, check) => ({
+        name,
+        async run() {
+            const fixture = await make();
+            const [calendar] = await fixture.store.saveCalendars(fixture.accountId, [{ externalId: "primary", title: "Work", timezone: "UTC", accessRole: "owner", primary: true }], 1);
+            await check({ ...fixture, calendar: calendar.id });
+        },
+    });
+    const second = async ({ store, accountId }, externalId = "personal") => (await store.saveCalendars(accountId, [{ externalId, title: externalId, timezone: "UTC", accessRole: "owner", primary: false }], 1))[0].id;
+    const later = CONTRACT_NOW + 24 * HOUR;
+    const earlier = CONTRACT_NOW - 24 * HOUR;
+    return [
+        test("a calendar the owner owns syncs; one shared with them is listed and does not", async ({ store, accountId, }) => {
+            await store.saveCalendars(accountId, [{ externalId: "team", title: "Team", timezone: null, accessRole: "reader", primary: false }], 2);
+            assert.deepEqual((await store.calendars(accountId)).map(({ externalId, synced }) => [externalId, synced]), [
+                ["primary", true],
+                ["team", false],
+            ]);
+        }),
+        test("rule 1: the same calendar and id is the same entry; a change keeps the old values", async ({ store, calendar, }) => {
+            const [first] = await store.saveEntries(calendar, [single("e1", later)], 2);
+            const [again] = await store.saveEntries(calendar, [single("e1", later + HOUR, { title: "Moved review" })], 3);
+            assert.equal(again?.id, first?.id);
+            assert.equal(again?.eventId, first?.eventId);
+            const details = await store.event(first?.eventId);
+            assert.equal(details?.event.title, "Moved review");
+            assert.equal(details?.event.startsAt, later + HOUR);
+            assert.equal(details?.event.origin, "calendar");
+            assert.deepEqual(details?.revisions.map(({ title, startsAt }) => [title, startsAt]), [["Example review", later]]);
+        }),
+        test("rule 2: a plain occurrence and the exception of its slot are one entry, the series in any order", async ({ store, calendar, }) => {
+            const slot = later;
+            const occurrence = (externalId, extra = {}) => single(externalId, slot, { kind: "occurrence", seriesExternalId: "s1", originalStartsAt: slot, ...extra });
+            const [plain] = await store.saveEntries(calendar, [occurrence("s1_slot")], 2);
+            await store.saveEntries(calendar, [{ ...single("s1", earlier), kind: "series", recurrence: ["RRULE:FREQ=WEEKLY"], recurrenceEndsAt: null }], 3);
+            const [exception] = await store.saveEntries(calendar, [occurrence("s1_moved", { exception: true, startsAt: slot + HOUR, endsAt: slot + 2 * HOUR })], 4);
+            assert.equal(exception?.id, plain?.id);
+            assert.notEqual(exception?.seriesEntryId, null);
+            const details = await store.event(exception?.eventId);
+            assert.equal(details?.event.startsAt, slot + HOUR);
+            assert.notEqual(details?.event.eventSeriesId, null);
+        }),
+        test("rule 3: another calendar's copy with the same iCalUID is the same event", async (fixture) => {
+            const { store, calendar } = fixture;
+            const other = await second(fixture);
+            const [work] = await store.saveEntries(calendar, [single("w1", later, { icalUid: "uid-1@example.com" })], 2);
+            const [home] = await store.saveEntries(other, [single("p1", later, { icalUid: "uid-1@example.com" })], 3);
+            assert.equal(home?.eventId, work?.eventId);
+            assert.equal((await store.event(work?.eventId))?.entries.length, 2);
+        }),
+        test("rule 5: otherwise a new event of origin calendar; a slot cancelled before it was stored is none", async ({ store, calendar, }) => {
+            const [one, two, gone] = await store.saveEntries(calendar, [single("a", later), single("b", later), single("c", later, { status: "cancelled" })], 2);
+            assert.notEqual(one?.eventId, two?.eventId);
+            assert.equal(gone?.eventId, null);
+            assert.equal((await store.events({ from: later, to: later + HOUR })).length, 2);
+        }),
+        test("two candidates: no link and one review entry, kept through a second sync and an owner's decision", async (fixture) => {
+            const { store, calendar } = fixture;
+            const other = await second(fixture);
+            const third = await second(fixture, "third");
+            const [a] = await store.saveEntries(calendar, [single("a", later, { icalUid: "first" })], 2);
+            const [b] = await store.saveEntries(other, [single("b", later, { icalUid: "second" })], 2);
+            await store.saveEntries(calendar, [single("a", later, { icalUid: "shared" })], 3);
+            await store.saveEntries(other, [single("b", later, { icalUid: "shared" })], 3);
+            const [c] = await store.saveEntries(third, [single("c", later, { icalUid: "shared" })], 4);
+            assert.equal(c?.eventId, null);
+            await store.saveEntries(third, [single("c", later, { icalUid: "shared" })], 5);
+            const open = await store.reviews({ status: "open" });
+            assert.equal(open.length, 1);
+            assert.deepEqual(open[0]?.candidates, [a?.eventId, b?.eventId].sort((x, y) => x - y));
+            await store.resolveReview(open[0]?.id, { choose: b?.eventId }, 6);
+            await store.saveEntries(third, [single("c", later, { icalUid: "shared" })], 7);
+            const [after] = await store.saveEntries(third, [single("c", later, { icalUid: "shared" })], 8);
+            assert.equal(after?.eventId, b?.eventId);
+            assert.deepEqual((await store.reviews()).map(({ status }) => status), ["linked"]);
+        }),
+        test("the owner's unlink holds: no rule links the entry again", async ({ store, calendar }) => {
+            const [entry] = await store.saveEntries(calendar, [single("a", later)], 2);
+            await store.unlinkEntry(entry?.id, 3);
+            const [again] = await store.saveEntries(calendar, [single("a", later, { title: "Renamed" })], 4);
+            assert.equal(again?.eventId, null);
+            await store.linkEntry(entry?.id, entry?.eventId, 5);
+            const [linked] = await store.saveEntries(calendar, [single("a", later)], 6);
+            assert.equal(linked?.eventId, entry?.eventId);
+        }),
+        test("a deleted single event: past stays as history, future is cancelled", async ({ store, calendar }) => {
+            const [past, future] = await store.saveEntries(calendar, [single("p", earlier), single("f", later)], 2);
+            await store.saveEntries(calendar, [single("p", earlier, { status: "cancelled" }), single("f", later, { status: "cancelled" })], CONTRACT_NOW);
+            const happened = (await store.event(past?.eventId))?.event;
+            assert.equal(happened?.sourceDeletedAt, CONTRACT_NOW);
+            assert.notEqual(happened?.status, "cancelled");
+            assert.equal(happened?.title, "Example review");
+            const cancelled = (await store.event(future?.eventId))?.event;
+            assert.equal(cancelled?.status, "cancelled");
+            assert.equal(cancelled?.sourceDeletedAt, null);
+        }),
+        test("a whole series deleted: its entries cancel, past occurrences stay, future ones cancel", async ({ store, calendar, }) => {
+            const series = {
+                ...single("s", earlier - HOUR),
+                kind: "series",
+                icalUid: "series@example.com",
+                recurrence: ["RRULE:FREQ=DAILY"],
+            };
+            const occurrence = (at) => single(`s_${at}`, at, { kind: "occurrence", seriesExternalId: "s", originalStartsAt: at });
+            const [, past, future] = await store.saveEntries(calendar, [series, occurrence(earlier), occurrence(later)], 2);
+            await store.saveEntries(calendar, [{ ...series, status: "cancelled" }], CONTRACT_NOW);
+            const before = await store.event(past?.eventId);
+            assert.equal(before?.event.sourceDeletedAt, CONTRACT_NOW);
+            assert.equal(before?.entries[0]?.status, "cancelled");
+            const after = await store.event(future?.eventId);
+            assert.equal(after?.event.status, "cancelled");
+        }),
+        test("a full list marks the entries it did not return, plain occurrences only inside the window", async ({ store, calendar, }) => {
+            const outside = later + 30 * 24 * HOUR;
+            const [kept, gone, far] = await store.saveEntries(calendar, [
+                single("kept", later),
+                single("gone", later),
+                single("far", outside, { kind: "occurrence", seriesExternalId: "x", originalStartsAt: outside }),
+            ], 2);
+            await store.saveEntries(calendar, [single("kept", later)], 10);
+            assert.equal(await store.markUnseen(calendar, 10, { from: earlier, to: later + 24 * HOUR }, 11), 1);
+            const entries = new Map((await store.event(gone?.eventId))?.entries.map((entry) => [entry.externalId, entry]));
+            assert.equal(entries.get("gone")?.deletedAt, 11);
+            assert.notEqual(await store.event(gone?.eventId), null);
+            assert.equal((await store.event(kept?.eventId))?.entries[0]?.deletedAt, null);
+            assert.equal((await store.event(far?.eventId))?.entries[0]?.deletedAt, null);
+        }),
+        test("participants are kept by address; a room is listed and is no contact", async ({ store, calendar }) => {
+            const [entry] = await store.saveEntries(calendar, [
+                single("a", later, {
+                    participants: [
+                        { email: "Alice@Example.com", name: "Alice Example", response: "accepted" },
+                        { email: "room-1@resource.example.com", name: "Room 1", resource: true },
+                    ],
+                }),
+            ], 2);
+            const participants = (await store.event(entry?.eventId))?.participants ?? [];
+            assert.deepEqual(participants.map(({ email, resource, identityId }) => [email, resource, identityId === null]), [
+                ["alice@example.com", false, false],
+                ["room-1@resource.example.com", true, true],
+            ]);
+        }),
+        test("an entry that ends before it starts is refused", async ({ store, calendar }) => {
+            await assert.rejects(store.saveEntries(calendar, [single("bad", later, { endsAt: later - 1 })], 2));
+        }),
+    ];
+};

package/dist/meetings/testing/index.d.ts

@@ -1,4 +1,5 @@
 export { meetingStoreContract } from "./contract.js";
+export { CONTRACT_NOW, type EventStoreFixture, eventStoreContract } from "./event-store-contract.js";
 export { type MeetingManagementContractFixture, meetingManagementContract } from "./management-contract.js";
 export { memoryMeetingStore } from "./memory.js";
 export { type RecordingSyncCheckpointFixture, recordingSyncCheckpointStoreContract, } from "./recording-sync-contract.js";

package/dist/meetings/testing/index.js

@@ -1,4 +1,5 @@
 export { meetingStoreContract } from "./contract.js";
+export { CONTRACT_NOW, eventStoreContract } from "./event-store-contract.js";
 export { meetingManagementContract } from "./management-contract.js";
 export { memoryMeetingStore } from "./memory.js";
 export { recordingSyncCheckpointStoreContract, } from "./recording-sync-contract.js";

package/dist/search/account-list.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { FOLDER_PROVIDER, INTERNAL_NOTES, isKind, kindIn, kindOf, providerNamed, providers as registered, UNKNOWN_PROVIDER, } from "../domain/providers.js";
+import { INTERNAL_NOTES, isDocumentAccountProvider, isFolderProvider, isKind, kindIn, kindOf, providerNamed, providers as registered, UNKNOWN_PROVIDER, } from "../domain/providers.js";
 import { isBotProvider } from "./query.js";
 /** Store-wide: every profile, tg, MAX and memo reads the same groups. */
 export const ACCOUNT_GROUPS = "accountGroups";
@@ -29,13 +29,29 @@ const describe = (accounts) => accounts.map(({ provider, account, name }) => `${
 const kindHere = (provider, running) => provider === running.provider ? kindOf(provider) : kindIn(provider);
 const heldOf = (stored, running) => [
     ...stored
-        .filter(({ provider }) => kindIn(provider) !== "notes")
+        .filter(({ provider }) => kindIn(provider) !== "notes" && !isDocumentAccountProvider(provider))
         .map(({ provider, account, name }) => ({ provider, account, name, kind: kindHere(provider, running) })),
     { provider: "notes", account: INTERNAL_NOTES, name: null, kind: "notes" },
     ...stored
-        .filter(({ provider }) => provider === FOLDER_PROVIDER)
-        .map(({ id, name }) => ({ provider: "notes", account: String(id), name, kind: "notes" })),
+        .filter(({ provider }) => isFolderProvider(provider))
+        .map(({ id, name, provider }) => ({
+        provider: "notes",
+        account: String(id),
+        name,
+        kind: "notes",
+        folder: provider,
+    })),
+    ...stored
+        .filter(({ provider }) => isDocumentAccountProvider(provider))
+        .map(({ id, provider, account, name }) => ({
+        provider: "notes",
+        account: String(id),
+        name,
+        kind: "notes",
+        stored: { provider, account },
+    })),
 ];
+const storedAs = (held, key) => held.filter(({ stored }) => stored?.provider === key.provider && (key.account === "" || stored.account === key.account));
 const registry = () => registered()
     .map(({ name, aliases }) => (aliases.length ? `${name} (${aliases.join(", ")})` : name))
     .join(", ");
@@ -44,7 +60,7 @@ const providerOf = (prefix, held, { running, profiles }) => {
     if (wanted === running.command?.toLowerCase())
         return running.provider;
     const providers = [...new Set(held.map(({ provider }) => provider))];
-    if (providers.includes(wanted))
+    if (providers.includes(wanted) || isDocumentAccountProvider(wanted))
         return wanted;
     const named = providerNamed(wanted);
     if (named)
@@ -57,6 +73,11 @@ const providerOf = (prefix, held, { running, profiles }) => {
 const profilesOf = (provider, profiles) => Object.values(profiles).flatMap((named) => Object.entries(named).filter(([, key]) => key.provider === provider));
 const accountOf = (prefix, ref, held, context) => {
     const provider = providerOf(prefix, held, context);
+    if (isDocumentAccountProvider(provider) && !context.profiles[prefix.toLowerCase()]?.[ref]) {
+        const stored = storedAs(held, { provider, account: ref })[0];
+        if (stored)
+            return stored;
+    }
     const ofProvider = held.filter((one) => one.provider === provider);
     const byId = ofProvider.find(({ account }) => account === ref || account === ref.toLowerCase());
     if (byId)
@@ -67,12 +88,18 @@ const accountOf = (prefix, ref, held, context) => {
         kind: kindHere(key.provider, context.running),
     };
     const recorded = context.profiles[prefix.toLowerCase()]?.[ref];
-    if (recorded?.provider === FOLDER_PROVIDER) {
+    if (recorded && isFolderProvider(recorded.provider)) {
         const folder = held.find((one) => one.provider === "notes" && one.name === recorded.account);
         if (folder)
             return folder;
         return fail(`no stored folder for ${prefix}:${ref}; sync that profile first`);
     }
+    if (recorded && isDocumentAccountProvider(recorded.provider)) {
+        const account = storedAs(held, recorded)[0];
+        if (account)
+            return account;
+        return fail(`no stored documents for ${prefix}:${ref}; sync that profile first`);
+    }
     if (recorded)
         return keyed(recorded);
     const byProfile = [
@@ -101,9 +128,14 @@ const accountsOfWord = (word, held, context) => {
     if (isKind(wanted))
         return held.filter(({ kind }) => kind === wanted);
     const recorded = context.profiles[wanted];
-    if (recorded && Object.values(recorded).every((key) => key.provider === FOLDER_PROVIDER))
+    if (recorded &&
+        Object.values(recorded).every((key) => isFolderProvider(key.provider) || isDocumentAccountProvider(key.provider)))
         return Object.keys(recorded).map((profile) => accountOf(word, profile, held, context));
     const provider = providerOf(word, held, context);
+    if (isDocumentAccountProvider(provider))
+        return storedAs(held, { provider, account: "" });
+    if (isFolderProvider(provider))
+        return held.filter(({ folder }) => folder === provider);
     return held.filter((one) => one.provider === provider);
 };
 const keyOf = ({ provider, account }) => `${provider}\u0000${account}`;

package/dist/services/agenda.js

@@ -5,6 +5,7 @@ import { agenda } from "../entities/agenda.js";
 import { AGENDA_COLUMNS, inboxKey, queryFilter, } from "../store/store.js";
 import { CHAT_KINDS } from "./chats.js";
 import { taskAccount } from "./task-rules.js";
+import { taskTagFilters } from "./task-tag-filters.js";
 const DAY = 86_400_000;
 const CLAIMS = ["none", "mine", "others", "any"];
 const TASK_FIELDS = new Set(["tag", "category", "claimed"]);
@@ -46,8 +47,9 @@ export const agendaService = (deps, now = Date.now) => ({
             throw error;
         });
         const open = await find();
+        const tags = await taskTagFilters(store, parts.tasks);
         const listed = parts.tasks
-            ? await find(queryFilter(parts.tasks, taskColumns(holder, at), { command: "tasks agenda" }))
+            ? await find(queryFilter(parts.tasks, taskColumns(holder, at, tags), { command: "tasks agenda" }))
             : open;
         const tasks = listed
             .map((task) => ({ task, reasons: reasonsOf(task, at, dueWithin) }))
@@ -148,11 +150,9 @@ const split = (query) => {
     };
     return { tasks: of("tasks"), chats: of("chats") };
 };
-const TAGGED = "EXISTS (SELECT 1 FROM taggings g JOIN tags n ON n.id = g.tag_id " +
-    "WHERE g.taggable_type = 'task' AND g.taggable_id = t.id AND n.name = ?)";
 /** A claim that lapsed holds nothing, as `tasks claim` reads it. */
-const taskColumns = (holder, at) => ({
-    tag: { where: (node) => ({ sql: TAGGED, params: [node.value.trim().toLowerCase()] }) },
+const taskColumns = (holder, at, tags) => ({
+    tag: { where: (node) => tags.get(node.value) ?? { sql: "0", params: [] } },
     category: { type: "kw", sql: "t.category" },
     claimed: {
         where: (node) => {

package/dist/services/document-source.d.ts

@@ -1,7 +1,11 @@
 import type { Profiles } from "../search/account-list.js";
-import type { Note, NoteFolder } from "../store/index.js";
-/** Imported sources keep their remote edit time; indexing time still belongs to the local row. */
-export declare const documentSource: (note: Note, folders: NoteFolder[], profiles: Profiles) => {
+import type { Note, StoredAccount, StoredFile } from "../store/index.js";
+/**
+ * Where a hit came from. The document's preferred file says it: its account's provider, its link and its edit time.
+ * A Drive document under a notes folder (before version 31 moves it) is still known by its front matter.
+ * Indexing time belongs to the local row.
+ */
+export declare const documentSource: (note: Note, accounts: readonly StoredAccount[], profiles: Profiles, file?: StoredFile) => {
     kind: "document" | "note";
     provider: string;
     account: string;

package/dist/services/document-source.js

@@ -1,18 +1,30 @@
-/** Imported sources keep their remote edit time; indexing time still belongs to the local row. */
-export const documentSource = (note, folders, profiles) => {
+import { isFolderProvider, kindIn } from "../domain/providers.js";
+/**
+ * Where a hit came from. The document's preferred file says it: its account's provider, its link and its edit time.
+ * A Drive document under a notes folder (before version 31 moves it) is still known by its front matter.
+ * Indexing time belongs to the local row.
+ */
+export const documentSource = (note, accounts, profiles, file) => {
     const metadata = note.frontMatter;
-    const folder = folders.find(({ id }) => id === note.folderId);
-    const remote = note.source === "file" && metadata?.source === "google-drive";
-    const profile = remote && folder
-        ? Object.entries(profiles.drive ?? {}).find(([, key]) => key.provider === "folder" && key.account === folder.name)?.[0]
+    const account = accounts.find(({ id }) => String(id) === note.folderId);
+    const remote = note.source === "file" &&
+        ((account !== undefined && kindIn(account.provider) === "documents") || metadata?.source === "google-drive");
+    const profile = remote && account
+        ? Object.entries(profiles)
+            .flatMap(([command, named]) => Object.entries(named).map(([name, key]) => ({ command, name, key })))
+            .find(({ key }) => (key.provider === account.provider && key.account === account.account) ||
+            (isFolderProvider(key.provider) && key.account === account.name))
         : undefined;
+    const url = file?.url ?? (remote && typeof metadata?.sourceUrl === "string" ? metadata.sourceUrl : undefined);
+    const modified = file?.externalUpdatedAt ??
+        (remote && typeof metadata?.modifiedAt === "string" && Number.isFinite(Date.parse(metadata.modifiedAt))
+            ? metadata.modifiedAt
+            : undefined);
     return {
         kind: remote ? "document" : "note",
-        provider: profile ? "drive" : "notes",
-        account: profile ?? note.folderId ?? "internal",
-        ...(remote && typeof metadata?.sourceUrl === "string" ? { url: metadata.sourceUrl } : {}),
-        updated_at: remote && typeof metadata?.modifiedAt === "string" && Number.isFinite(Date.parse(metadata.modifiedAt))
-            ? metadata.modifiedAt
-            : note.updatedAt,
+        provider: profile ? profile.command : "notes",
+        account: profile?.name ?? note.folderId ?? "internal",
+        ...(remote && url !== undefined ? { url } : {}),
+        updated_at: remote && modified !== undefined ? modified : note.updatedAt,
     };
 };

package/dist/services/documents/ingestion.d.ts

@@ -1,7 +1,12 @@
 import type { SourceContent, SourceFile } from "../../documents/model.js";
 import type { CatalogInput, CatalogQuery, MessageStore } from "../../store/index.js";
 export interface IngestionOptions<M extends SourceFile> {
-    collectionName(principal: string): string;
+    /**
+     * The documents account's provider (`google-drive`): each principal's documents live under
+     * `{ provider, account: principal }`. Without it they live in a notes folder named `collectionName(principal)`.
+     */
+    provider?: string;
+    collectionName?(principal: string): string;
     externalId(id: string): string;
     catalogInput(file: M): CatalogInput;
     frontMatter(content: SourceContent<M>): Record<string, unknown>;

package/dist/services/documents/ingestion.js

@@ -2,6 +2,10 @@ import { CliError } from "@wirecat/cli-base";
 import { walkQuery } from "@wirecat/cli-base/query";
 export const documentIngestion = (store, options) => {
     const folder = async (principal, create) => {
+        if (options.provider)
+            return store.notes.documentsAccount({ provider: options.provider, account: principal }, create);
+        if (!options.collectionName)
+            throw new CliError("configuration_error", "document ingestion needs a provider or a collection name");
         const name = options.collectionName(principal);
         const found = (await store.notes.folders()).find((item) => item.name === name);
         return found ?? (create ? await store.notes.addFolder({ name, format: "markdown" }) : undefined);

package/dist/services/notes-search.js

@@ -295,7 +295,7 @@ export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, f
     const hasMore = slice ? matched.hasMore : ordered.length > window || matched.hasMore || titled.hasMore;
     const hits = [];
     const counts = new Map();
-    const folders = await store.notes.folders();
+    const accounts = await store.accounts.storedAccounts();
     const profiles = await store.accounts.profiles();
     for (const [ref, { note, foundBy }] of page) {
         const links = (await store.notes.links({ from: ref })).map(({ to, targetText, kind, anchor }) => ({
@@ -310,7 +310,7 @@ export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, f
             folder_id: note.folderId,
             path: note.path,
             title: note.title,
-            ...documentSource(note, folders, profiles),
+            ...documentSource(note, accounts, profiles, note.source === "file" ? (await store.files.ofDocument(note.ref))[0] : undefined),
             excerpt: firstLine(note.text, words),
             links,
             found_by: foundBy,
@@ -374,6 +374,7 @@ export const searchNotesOf = async (store, account, text, { accounts: list, app,
     const held = [
         { provider: "notes", account: INTERNAL_NOTES },
         ...(await store.notes.folders()).map(({ id }) => ({ provider: "notes", account: id })),
+        ...(await store.notes.documentsAccounts()).map(({ id }) => ({ provider: "notes", account: id })),
     ];
     const named = list === undefined
         ? { accounts: held, skipped: [] }

package/dist/services/search-all.js

@@ -109,6 +109,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                 const read = chosen?.map(({ account }) => account) ?? [
                     INTERNAL_NOTES,
                     ...(await store.notes.folders()).map(({ id }) => id),
+                    ...(await store.notes.documentsAccounts()).map(({ id }) => id),
                 ];
                 accounts.push(...read.map((account) => ({ resource, provider: "notes", account })));
             }

package/dist/services/task-tag-filters.d.ts

@@ -0,0 +1,3 @@
+import { type QueryAst } from "@wirecat/cli-base/query";
+import type { MessageStore, Where } from "../store/store.js";
+export declare const taskTagFilters: (store: MessageStore, query: QueryAst | undefined) => Promise<Map<string, Where>>;

package/dist/services/task-tag-filters.js

@@ -0,0 +1,8 @@
+import { walkQuery } from "@wirecat/cli-base/query";
+export const taskTagFilters = async (store, query) => {
+    const tags = new Map();
+    for (const node of query ? walkQuery(query.root) : [])
+        if (node.field === "tag" && !tags.has(node.value))
+            tags.set(node.value, await store.tasks.tagWhere(node.value));
+    return tags;
+};

package/dist/services/tasks.js

@@ -9,6 +9,7 @@ import { createTaskService, TASK_KINDS, TASK_STATES, } from "../tasks/index.js";
 import { storedChatId } from "./message-resolution.js";
 import { categorize, taskCategoryOf } from "./task-categories.js";
 import { taskAccount } from "./task-rules.js";
+import { taskTagFilters } from "./task-tag-filters.js";
 export { TASK_KINDS, TASK_STATES };
 export const TASK_QUERY = {
     entity: "task",
@@ -68,17 +69,11 @@ export const TASK_PAIR_QUERY = {
 };
 const TIME = (sql) => ({ type: "time", sql });
 /** `chat:` names the chat as the messenger does; `groups` holds each name already resolved to its stored id. */
-const taskColumns = (groups) => ({
+const taskColumns = (groups, tags) => ({
     id: { type: "kw", sql: "t.package_id" },
     key: { type: "kw", sql: "t.key" },
     category: { type: "kw", sql: "t.category" },
-    tag: {
-        where: (node) => ({
-            sql: "EXISTS (SELECT 1 FROM taggings g JOIN tags n ON n.id = g.tag_id " +
-                "WHERE g.taggable_type = 'task' AND g.taggable_id = t.id AND n.name = ?)",
-            params: [node.value.trim().toLowerCase()],
-        }),
-    },
+    tag: { where: (node) => tags.get(node.value) ?? { sql: "0", params: [] } },
     title: { type: "kw", sql: "t.title_folded", folded: true },
     kind: { type: "enum", sql: "t.type" },
     state: { type: "enum", sql: "t.status" },
@@ -213,7 +208,8 @@ export const tasksService = (deps, categories) => {
             for (const node of query ? walkQuery(query.root) : [])
                 if (node.field === "chat" && node.operator !== "wildcard" && !groups.has(node.value))
                     groups.set(node.value, await storedChatId(deps.messenger, node.value, store, account, { includeLeft: true }));
-            const where = query ? queryFilter(query, taskColumns(groups), { command: "tasks list" }) : undefined;
+            const tags = await taskTagFilters(store, query);
+            const where = query ? queryFilter(query, taskColumns(groups, tags), { command: "tasks list" }) : undefined;
             const rows = await store.tasks.query(taskAccount(account), where, { limit: limit + 1, offset });
             const shown = rows.slice(0, limit);
             return {

package/dist/store/document-transfer/index.js

@@ -7,6 +7,7 @@ import { planTransfer } from "../sqlite/document-transfer/plan.js";
 import { transferSnapshot } from "../sqlite/document-transfer/snapshot.js";
 import { openSqlite } from "../sqlite/open.js";
 import { openStoreContext } from "../sqlite/open-store.js";
+import { assertReadCompatible } from "../sqlite/read-compatibility.js";
 import { digest } from "./digest.js";
 const locations = (options) => {
     for (const value of [options.source, options.destination, options.collection])
@@ -51,8 +52,17 @@ const openSource = async (path) => {
     }
 };
 const openPreviewTarget = async (path) => {
-    if (statSync(path, { throwIfNoEntry: false }))
-        return openSource(path);
+    if (statSync(path, { throwIfNoEntry: false })) {
+        const opened = await openSource(path);
+        try {
+            assertReadCompatible(opened.database);
+            return opened;
+        }
+        catch (error) {
+            opened.database.close();
+            throw error;
+        }
+    }
     const target = await openSqlite(":memory:");
     try {
         migrate(target.database);

package/dist/store/index.d.ts

@@ -1,6 +1,6 @@
 export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextEvidenceSender, ContextSource, } from "../context/evidence.js";
 export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES, TASK_TYPES, WORK_TASK_TYPES, } from "../domain/knowledge.js";
-export type { TagConsolidationOptions, TagConsolidationPreview, TagConsolidationStore, } from "../domain/tag-consolidation.js";
+export type { TagConsolidationApplyOptions, TagConsolidationOptions, TagConsolidationPreview, TagConsolidationReceipt, TagConsolidationStore, } from "../domain/tag-consolidation.js";
 export type { TagRedirectIndex, TagRedirectResolution, TagRedirectSnapshot } from "../domain/tag-redirects.js";
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
 export { note } from "../entities/note.js";
@@ -31,6 +31,7 @@ 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 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";
 export type { Involvement, InvolvementStore } from "./sqlite/involvements.js";
 export type { Annotation, KnowledgeRelation, KnowledgeStore, KnowledgeTarget, LabelledType, Organization, Project, Reminder, } from "./sqlite/knowledge.js";

package/dist/store/sqlite/accounts.js

@@ -111,6 +111,7 @@ export const purgeAccount = ({ orm, database }, accountKey) => {
     orm.delete(accountIdentities).where(eq(accountIdentities.accountId, accountKey)).run();
     // The inbox project and its tasks are the owner's; only the tie to the account goes.
     orm.update(projects).set({ accountId: null }).where(eq(projects.accountId, accountKey)).run();
+    orm.run(sql `DELETE FROM files WHERE account_id = ${accountKey}`);
     orm.delete(accounts).where(eq(accounts.id, accountKey)).run();
     dropOrphanPeople(database, unseenBefore);
     orm.run(sql `DELETE FROM embeddings WHERE content_hash IN (SELECT value FROM json_each(${JSON.stringify(hashes)}))

package/dist/store/sqlite/calendar.d.ts

@@ -0,0 +1,3 @@
+import { type EventStore } from "../../meetings/index.js";
+import type { StoreContext } from "./open.js";
+export declare const eventStoreOver: (context: StoreContext) => EventStore;