@wirecat/cli-core 0.410.0 → 0.412.0

package/dist/services/documents/knowledge.js

@@ -47,18 +47,18 @@ export const documentKnowledge = (store, folder) => {
             return folderId ? store.notes.importedDocuments(folderId, query, page) : { items: [], hasMore: false };
         },
         document,
-        tags: async (principal, ref, action, tags = []) => {
+        tags: async (principal, ref, action, tags = [], filter) => {
             const note = await document(principal, ref);
             const target = { type: "document", id: note.id };
             if (action === "add")
                 return store.knowledge.addTags(null, target, tags);
             if (action === "remove")
                 return store.knowledge.removeTags(null, target, tags);
-            return store.knowledge.tags(null, target);
+            return store.knowledge.tags(null, target, filter?.tag);
         },
-        links: async (principal, ref) => {
+        links: async (principal, ref, filter) => {
             await document(principal, ref);
-            return store.notes.links({ from: ref });
+            return store.notes.links({ ...filter, from: ref });
         },
         addLink: async (principal, ref, input) => {
             await document(principal, ref);

package/dist/services/meeting-links.d.ts

@@ -1,7 +1,9 @@
 import type { MeetingChatLinesInput, MeetingHitSearchRequest, MeetingLink } from "../meetings/index.js";
 import type { MessageStore } from "../store/store.js";
 export type { MeetingLink };
-export type MeetingLinksRequest = Omit<MeetingHitSearchRequest, "limit" | "after" | "maxReadBytes"> & Pick<MeetingChatLinesInput, "maxMessages">;
+export type MeetingLinksRequest = Omit<MeetingHitSearchRequest, "limit" | "after" | "maxReadBytes"> & Pick<MeetingChatLinesInput, "maxMessages"> & {
+    url?: string;
+};
 /** Links shared in the chat of the selected meetings, most shared first; found when read, not stored. */
 export declare const readMeetingLinks: (store: Pick<MessageStore, "meetings"> & {
     knowledge?: MessageStore["knowledge"];

package/dist/services/meeting-links.js

@@ -3,7 +3,7 @@ import { findMentions } from "../domain/mentions.js";
 import { resolveMeetingSelection } from "./meeting-hit-search.js";
 /** Links shared in the chat of the selected meetings, most shared first; found when read, not stored. */
 export const readMeetingLinks = async (store, request) => {
-    const { maxMessages, ...selecting } = request;
+    const { maxMessages, url, ...selecting } = request;
     const { input, selection } = await resolveMeetingSelection(store, selecting);
     const lines = await store.meetings.meetingChatLines({
         ...input,
@@ -12,7 +12,7 @@ export const readMeetingLinks = async (store, request) => {
     const links = new Map();
     for (const line of lines)
         for (const found of findMentions(line.text)) {
-            if (found.kind !== "url")
+            if (found.kind !== "url" || (url !== undefined && found.value !== url))
                 continue;
             const link = links.get(found.value) ?? {
                 url: found.value,

package/dist/services/messages-search.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { calendarKey } from "../domain/calendar.js";
 import { parseLocator } from "../domain/locator.js";
+import { kindIn, UNKNOWN_PROVIDER } from "../domain/providers.js";
 import { syncsOneChat } from "../ports/traits.js";
 import { PRESET_VERSION } from "../search/lucene/presets.js";
 import { FIELD_VERSION, validateAst, validateFields } from "../search/lucene/registry.js";
@@ -69,13 +70,24 @@ export const prepareLucene = async (store, account, request, messenger) => {
         throw new CliError("validation_error", "a search names at least one account");
     if (request.senders !== undefined && leaves.some(({ field }) => field === "from"))
         throw new CliError("validation_error", "--from and from: together — name the people once");
-    const accounts = accountsOfKind(request.kind, request.accounts ??
+    const chosen = request.accounts ??
         listed?.accounts ??
         (source !== undefined
             ? held.filter(({ provider }) => inSource(source, provider))
             : sources.length
                 ? held.filter(({ provider }) => sources.some((source) => inSource(source, provider)))
-                : [account]), held, source ?? (sources.includes("email") ? "email" : sources[0]), messenger.app?.command, request.mailAccount, listed !== undefined || request.accounts !== undefined);
+                : [account]);
+    // The account running is the app's own: its provider is a messenger whether or not an entry names it.
+    const unknown = chosen.filter(({ provider }) => provider !== account.provider && kindIn(provider) === undefined);
+    const unknownSkipped = unknown.map(({ provider, account }) => ({
+        source: `${provider}:${account}`,
+        code: "not_found",
+        reason: UNKNOWN_PROVIDER,
+    }));
+    if (unknown.length > 0 && unknown.length === chosen.length)
+        throw new CliError("not_found", `this search reads nothing: ${unknownSkipped.map(({ source }) => source).join(", ")} (${UNKNOWN_PROVIDER})`);
+    const skipped = [...(listed?.skipped ?? []), ...unknownSkipped];
+    const accounts = accountsOfKind(request.kind, chosen.filter((one) => !unknown.includes(one)), held, source ?? (sources.includes("email") ? "email" : sources[0]), messenger.app?.command, request.mailAccount, listed !== undefined || request.accounts !== undefined);
     const scopeAccounts = accounts.map(({ provider, account }) => ({ provider, account }));
     const chatLookup = scopeAccounts.some(({ provider }) => provider === MAIL) ? withMailThreads(store) : store;
     const mailField = leaves.find(({ field, value }) => MAIL_FIELDS.has(field) &&
@@ -141,7 +153,7 @@ export const prepareLucene = async (store, account, request, messenger) => {
         stemsReady,
         ...(stemmer ? { stemming: stemmingOf(ast.root, stemmer) } : unstemmed ? { stemming: unstemmed } : {}),
         scopeAccounts,
-        ...(listed?.skipped.length ? { skipped: listed.skipped } : {}),
+        ...(skipped.length ? { skipped } : {}),
         ...(selectedChat ? { selectedChat } : {}),
     };
 };

package/dist/services/search-all.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { parseLocator } from "../domain/locator.js";
-import { INTERNAL_NOTES, kindOf } from "../domain/providers.js";
+import { INTERNAL_NOTES, kindIn } from "../domain/providers.js";
 import { excerpt } from "./excerpt.js";
 import { MAX_SEARCH_OFFSET, searchStore } from "./messages-archive-search.js";
 import { notesScopeOf, RRF_K, searchNotes } from "./notes-search.js";
@@ -55,7 +55,10 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
         hasMore ||= found.hasMore;
         const read = found.coverage?.accounts ??
             given ??
-            (await store.accounts.accounts()).filter(({ provider }) => kindOf(provider) === kind);
+            (await store.accounts.accounts()).filter(({ provider }) => kindIn(provider) === kind);
+        for (const one of found.skipped ?? [])
+            if (!skipped.some(({ source }) => source === one.source))
+                skipped.push(one);
         accounts.push(...read.map(({ provider, account }) => ({ resource: kind, provider, account })));
         return found.items.map((hit) => {
             const at = parseLocator(hit.locator);

package/dist/services/tasks.d.ts

@@ -60,6 +60,8 @@ export interface TaskList {
  * from a message: the message stays a link, so deleting it leaves no copy here.
  */
 export interface TaskPlan {
+    priority?: number | null;
+    parent?: string | null;
     title?: string;
     description?: string | null;
     dueAt?: Date | null;

package/dist/services/tasks.js

@@ -170,7 +170,7 @@ export const tasksService = (deps, categories) => {
     const planOf = async (store, id, plan, by) => {
         if (plan.category !== undefined)
             plan = { ...plan, category: await categoryOf(store, plan.category) };
-        const open = (await store.tasks.get(id))?.state === "open";
+        const open = (await store.tasks.details(id)).status === "open";
         if (!open && (plan.dueAt != null || plan.nextCheckAt != null))
             throw new CliError("validation_error", "a closed task takes no due date or next check; it stays closed");
         const { assignees, ...fields } = plan;
@@ -405,10 +405,12 @@ export const tasksService = (deps, categories) => {
             await store.tasks.suggestClose(id, null, "owner");
             return cardOf(store, id);
         }),
-        plan: (id, plan, by) => inStore(async (store, account) => {
-            await owned(store, account, id);
+        plan: async (id, plan, by) => {
+            const store = await deps.store();
+            if (!(await store.tasks.projectTask(id)))
+                await owned(store, await deps.account(), id);
             return planOf(store, id, plan, by);
-        }),
+        },
         link: async (id, { references = [], chats = [] }, { kind, by }) => {
             const written = references.map((one) => one.trim()).filter(Boolean);
             const relationKind = TASK_RELATION_KINDS.includes(kind);

package/dist/store/accounts.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderEntry } from "../domain/providers.js";
 import { type AccountGroups, type Profiles } from "../search/account-list.js";
 import type { StoreContext } from "./sqlite/open.js";
 import type { AccountKey, StoredAccount } from "./types.js";
@@ -29,6 +30,8 @@ export interface AccountsStore extends AccountAccounts {
     profiles(): Promise<Profiles>;
     /** Records which account a profile of `app` is; a no-op when the store already says so. */
     saveProfile(app: string, profile: string, key: AccountKey): Promise<void>;
+    /** Writes a CLI's provider entry for every tool on this store to read; see `registerProvider`. */
+    registerProvider(entry: ProviderEntry): Promise<void>;
 }
 export declare const accountAccountsOver: (context: StoreContext) => AccountAccounts;
 export declare const accountsStoreOver: (context: StoreContext, keyed: AccountAccounts) => AccountsStore;

package/dist/store/accounts.js

@@ -3,6 +3,7 @@ import { keysOver } from "./keys.js";
 import { accountGroupsOf, profilesOf, saveProfile } from "./sqlite/account-groups.js";
 import * as accounts from "./sqlite/accounts.js";
 import { linkOwnIdentities } from "./sqlite/own-identities.js";
+import { registerProvider } from "./sqlite/providers.js";
 import { linkInbox } from "./sqlite/tasks.js";
 import { write } from "./sqlite/transaction.js";
 export const accountAccountsOver = (context) => {
@@ -34,6 +35,7 @@ export const accountsStoreOver = (context, keyed) => {
         accountGroups: async () => accountGroupsOf(database),
         profiles: async () => profilesOf(database),
         saveProfile: async (app, profile, key) => write(database, () => saveProfile(database, app, profile, key, context.now())),
+        registerProvider: async (entry) => registerProvider(database, entry, context.now()),
         saveAccountGroup: async (name, members) => write(database, () => {
             const groups = accountGroupsOf(database);
             if (members === undefined)

package/dist/store/exports.d.ts

@@ -8,6 +8,7 @@ export type { AccountCounters, CountersStore } from "./counters.js";
 export type { AccountMentions, MentionsStore } from "./mentions.js";
 export type { AccountMessages, MessagesStore } from "./messages.js";
 export type { AccountPeople, PeopleStore } from "./people.js";
+export { registerProvider } from "./providers.js";
 export type { QueriesStore } from "./queries.js";
 export type { RosterStore } from "./roster.js";
 export type { SearchIndexStore } from "./search-index.js";

package/dist/store/exports.js

@@ -1,3 +1,4 @@
+export { registerProvider } from "./providers.js";
 export { accountGroupsOf } from "./sqlite/account-groups.js";
 export { attachmentColumns, resetAttachmentWords, } from "./sqlite/attachment-texts.js";
 export { pendingNormalization } from "./sqlite/backfill.js";

package/dist/store/index.d.ts

@@ -3,6 +3,7 @@ export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES
 export type { TagConsolidationOptions, TagConsolidationPreview, 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";
 export type { FindingEvidence, FindingOutcome, MeetingFactFinding, MeetingFinding, MeetingFindingsInput, MeetingFindingsReceipt, MeetingTaskFinding, } from "../meetings/index.js";
 export type { AccountMail, AccountMeetings, AccountStore } from "./account-store.js";
 export type { DocumentTransferOptions, DocumentTransferPreview, DocumentTransferReceipt, } from "./document-transfer/index.js";
@@ -10,6 +11,7 @@ export { applyDocumentTransfer, previewDocumentTransfer } from "./document-trans
 export type { CacheDatabase, CacheStatement, OpenDatabase, SqlValue } from "./driver.js";
 export { PRAGMAS } from "./driver.js";
 export { EVIDENCE_FINDINGS_KIND, type EvidenceFindingsBatch, type EvidenceFindingsDecider, type EvidenceFindingsReceipt, type EvidenceFindingsStore, validateEvidenceFindings, } from "./evidence-findings.js";
+export { ORGANIZATIONS_QUERY, organization, PROJECTS_QUERY, project, REMINDERS_QUERY, reminder, } from "./knowledge-query.js";
 export type { MeetingFindingsBatch, MeetingFindingsStore } from "./meeting-findings.js";
 export { MIGRATIONS, type Migration, migrate } from "./migrations.js";
 export { openCache } from "./open.js";
@@ -41,7 +43,7 @@ export type { AttachmentInput } from "./sqlite/meetings.js";
 export type { Author, MemoriesStore, Memory, MemoryInput } from "./sqlite/memories.js";
 export type { NoteIndexState } from "./sqlite/note-index.js";
 export { type NearestNote, NOTE_FIELDS, type NoteChunkToEmbed, type NoteHit, type NoteQuery, type NoteSearch, } from "./sqlite/note-search.js";
-export type { FileNoteInput, Link, LinkInput, Note, NoteFolder, NotesStore, NoteTag, } from "./sqlite/notes.js";
+export type { FileNoteInput, Link, LinkInput, LinkListFilter, Note, NoteFolder, NotesStore, NoteTag, } from "./sqlite/notes.js";
 export type { PrivateContact, PrivateContactNote } from "./sqlite/private-people.js";
 export type { ProposalInput, ProposedAction, ProposedActionsStore } from "./sqlite/proposed-actions.js";
 export { PROPOSAL_STATUSES } from "./sqlite/proposed-actions.js";

package/dist/store/index.js

@@ -1,8 +1,10 @@
 export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES, TASK_TYPES, WORK_TASK_TYPES, } from "../domain/knowledge.js";
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
+export { note } from "../entities/note.js";
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";
 export { PRAGMAS } from "./driver.js";
 export { EVIDENCE_FINDINGS_KIND, validateEvidenceFindings, } from "./evidence-findings.js";
+export { ORGANIZATIONS_QUERY, organization, PROJECTS_QUERY, project, REMINDERS_QUERY, reminder, } from "./knowledge-query.js";
 export { MIGRATIONS, migrate } from "./migrations.js";
 export { openCache } from "./open.js";
 export { storePath } from "./path.js";

package/dist/store/knowledge-query.d.ts

@@ -0,0 +1,6 @@
+import { type QueryRegistry } from "@wirecat/cli-base/query";
+import { organization, project, reminder } from "../entities/knowledge-lists.js";
+export { organization, project, reminder };
+export declare const ORGANIZATIONS_QUERY: QueryRegistry;
+export declare const PROJECTS_QUERY: QueryRegistry;
+export declare const REMINDERS_QUERY: QueryRegistry;

package/dist/store/knowledge-query.js

@@ -0,0 +1,34 @@
+import { queryFieldsOf } from "@wirecat/cli-base/query";
+import { organization, project, reminder } from "../entities/knowledge-lists.js";
+export { organization, project, reminder };
+export const ORGANIZATIONS_QUERY = {
+    entity: "organization",
+    backend: "sql",
+    fields: queryFieldsOf(organization, {
+        native: ["id", "kind", "scope", "created_at"],
+        examples: { id: "id:1", kind: "kind:company", scope: "scope:work", created_at: "created_at>=2026-01-01" },
+    }),
+};
+export const PROJECTS_QUERY = {
+    entity: "project",
+    backend: "sql",
+    fields: queryFieldsOf(project, {
+        native: ["id", "key", "type", "organization_id", "scope", "created_at"],
+        examples: {
+            id: "id:1",
+            key: "key:SMP",
+            type: "type:work",
+            organization_id: "organization_id:1",
+            scope: "scope:work",
+            created_at: "created_at>=2026-01-01",
+        },
+    }),
+};
+export const REMINDERS_QUERY = {
+    entity: "reminder",
+    backend: "sql",
+    fields: queryFieldsOf(reminder, {
+        native: ["id", "state", "due_at", "revision"],
+        examples: { id: "id:1", state: "state:pending", due_at: "due_at>=2026-01-01", revision: "revision>1" },
+    }),
+};

package/dist/store/providers.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderEntry } from "../domain/providers.js";
+import type { MessageStore } from "./store.js";
+/**
+ * A CLI's entry, written into the store on every run so cli-core in every other CLI knows its provider's kind and
+ * aliases. Two entries that disagree on a kind, or an alias another provider already has, are an error.
+ */
+export declare const registerProvider: (store: Pick<MessageStore, "accounts">, entry: ProviderEntry) => Promise<void>;

package/dist/store/providers.js

@@ -0,0 +1,5 @@
+/**
+ * A CLI's entry, written into the store on every run so cli-core in every other CLI knows its provider's kind and
+ * aliases. Two entries that disagree on a kind, or an alias another provider already has, are an error.
+ */
+export const registerProvider = (store, entry) => store.accounts.registerProvider(entry);

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

@@ -1,3 +1,4 @@
+import type { QueryAst } from "@wirecat/cli-base/query";
 import type { Event, EventCandidateFilter, EventSeries, NewRecord } from "../../meetings/index.js";
 import type { CacheDatabase } from "../driver.js";
 /** JSON columns keep a missing value as SQL NULL, never the text `null`, so a read gives back what was saved. */
@@ -12,7 +13,7 @@ export declare const page: (filter: {
     limit?: number;
     offset?: number;
 }) => [number, number];
-export declare const events: (database: CacheDatabase) => Event[];
+export declare const events: (database: CacheDatabase, query?: QueryAst) => Event[];
 /** An event without an end occupies its start instant. */
 export declare const eventCandidates: (database: CacheDatabase, filter: EventCandidateFilter) => Event[];
 export declare const createEvent: (database: CacheDatabase, input: NewRecord<Event>, now: number) => Event;

package/dist/store/sqlite/events.js

@@ -1,3 +1,4 @@
+import { queryFilter } from "./query-filter.js";
 /** JSON columns keep a missing value as SQL NULL, never the text `null`, so a read gives back what was saved. */
 export const toJson = (value) => value === null || value === undefined ? null : JSON.stringify(value);
 export const fromJson = (value) => (value === null || value === undefined ? null : JSON.parse(String(value)));
@@ -36,7 +37,21 @@ const seriesOf = (row) => ({
     updatedAt: Number(row.updated_at),
 });
 const exists = (database, table, id) => database.prepare(`SELECT 1 FROM ${table} WHERE id = ?`).get(id) !== undefined;
-export const events = (database) => database.prepare("SELECT * FROM events WHERE deleted_at IS NULL ORDER BY id").all().map(eventOf);
+export const events = (database, query) => {
+    const where = query &&
+        queryFilter(query, {
+            id: { type: "num", sql: "id" },
+            origin: { type: "enum", sql: "origin" },
+            starts_at: { type: "time", sql: "starts_at" },
+            ends_at: { type: "time", sql: "ends_at" },
+            created_at: { type: "time", sql: "created_at" },
+            updated_at: { type: "time", sql: "updated_at" },
+        });
+    return database
+        .prepare(`SELECT * FROM events WHERE deleted_at IS NULL${where ? ` AND (${where.sql})` : ""} ORDER BY id`)
+        .all(...(where?.params ?? []))
+        .map(eventOf);
+};
 /** An event without an end occupies its start instant. */
 export const eventCandidates = (database, filter) => database
     .prepare(`SELECT e.* FROM events e

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

@@ -1,3 +1,4 @@
+import type { QueryAst } from "@wirecat/cli-base/query";
 import type { AccountKey } from "../types.js";
 import { RELATION_KINDS } from "./link-kinds.js";
 import { type MeetingProjectsStore } from "./meeting-projects.js";
@@ -130,7 +131,7 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
         id: string;
         removed: true;
     }>;
-    tags(key: KnowledgeScope, target: KnowledgeTarget): Promise<string[]>;
+    tags(key: KnowledgeScope, target: KnowledgeTarget, tag?: string): Promise<string[]>;
     addTags(key: KnowledgeScope, target: KnowledgeTarget, tags: string[]): Promise<string[]>;
     removeTags(key: KnowledgeScope, target: KnowledgeTarget, tags: string[]): Promise<string[]>;
     /**
@@ -163,7 +164,7 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
         name: string;
         scope?: Organization["scope"];
     }): Promise<Organization>;
-    organizations(): Promise<Organization[]>;
+    organizations(query?: QueryAst): Promise<Organization[]>;
     /** A project; its key is made from the name when none is given. */
     addProject(input: {
         name: string;
@@ -173,7 +174,7 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
         scope?: Project["scope"];
         description?: string;
     }): Promise<Project>;
-    projects(): Promise<Project[]>;
+    projects(query?: QueryAst): Promise<Project[]>;
     relate(key: KnowledgeScope, input: {
         from: string;
         to: string;
@@ -190,7 +191,7 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
     }>;
     confirmRelation(key: KnowledgeScope, id: string): Promise<KnowledgeRelation>;
     schedule(key: AccountKey, task: string, dueAt: string, timezone: string): Promise<Reminder>;
-    reminders(key: AccountKey): Promise<Reminder[]>;
+    reminders(key: AccountKey, query?: QueryAst): Promise<Reminder[]>;
     cancelReminder(key: AccountKey, id: string): Promise<Reminder>;
     snoozeReminder(key: AccountKey, id: string, dueAt: string, revision: number): Promise<Reminder>;
     claimReminders(key: AccountKey, options?: {

package/dist/store/sqlite/knowledge.js

@@ -9,6 +9,7 @@ import { ownerPerson } from "./actors.js";
 import { linkKind, RELATION_KINDS } from "./link-kinds.js";
 import { meetingProjectsStoreOver } from "./meeting-projects.js";
 import { insertLink, linkOf } from "./notes.js";
+import { queryFilter } from "./query-filter.js";
 import { addTags as addThingTags, canonicalTagNamed, createTag, labelsOf, removeTags as removeThingTags, setMainTopic, } from "./tags.js";
 import { TASK_KEY_PREFIXES } from "./task-keys.js";
 import { inboxKey, taskAccountOf, taskIdOf, taskRowOf } from "./tasks.js";
@@ -153,10 +154,10 @@ export const knowledgeStoreOver = (context) => {
         ? parseReference(formatReference({ type: "folder", id: target.id, path: target.path ?? null })).path
         : null;
     /** A subfolder's labels: `labelled` links from the folder, anchored at the path, to each tag. */
-    const subfolderLabels = (folder, path) => database
+    const subfolderLabels = (folder, path, tag) => database
         .prepare("SELECT t.name FROM links l JOIN tags t ON t.id = l.to_id WHERE l.from_type = 'account' AND l.from_id = ? " +
-        `AND l.kind = ${linkKind("labelled")} AND l.to_type = 'tag' AND l.anchor = ? ORDER BY t.name`)
-        .all(folder, path)
+        `AND l.kind = ${linkKind("labelled")} AND l.to_type = 'tag' AND l.anchor = ?${tag === undefined ? "" : " AND t.name = ?"} ORDER BY t.name`)
+        .all(folder, path, ...(tag === undefined ? [] : [tag]))
         .map((row) => String(row.name));
     const annotationOf = (row) => {
         const thing = storedThing(row.notable_type, row.notable_id);
@@ -335,12 +336,15 @@ export const knowledgeStoreOver = (context) => {
             database.prepare("DELETE FROM notes WHERE id=?").run(Number(id));
             return { id, removed: true };
         },
-        tags: async (key, target) => {
+        tags: async (key, target, tag) => {
             const { thing, state } = resolve(key, target);
             if (!thing || state !== "available")
                 return [];
             const path = subfolder(target);
-            return path === null ? labelsOf(database, thing).map(({ tag }) => tag) : subfolderLabels(thing.id, path);
+            const name = tag === undefined ? undefined : canonicalTagName(tag);
+            return path === null
+                ? labelsOf(database, thing, name).map(({ tag }) => tag)
+                : subfolderLabels(thing.id, path, name);
         },
         addTags: async (key, target, tags) => {
             const thing = available(key, target);
@@ -418,10 +422,19 @@ export const knowledgeStoreOver = (context) => {
                 .get(oneOf(kind, ORGANIZATION_KINDS, "an organization's kind"), textOf(name, 200), oneOf(scope, SCOPES, "a scope"), at, at);
             return organizationOf(row);
         },
-        organizations: async () => database
-            .prepare("SELECT * FROM organizations WHERE deleted_at IS NULL ORDER BY name, id LIMIT 500")
-            .all()
-            .map(organizationOf),
+        organizations: async (query) => {
+            const where = query &&
+                queryFilter(query, {
+                    id: { type: "kw", sql: "CAST(id AS TEXT)" },
+                    kind: { type: "enum", sql: "kind" },
+                    scope: { type: "enum", sql: "scope" },
+                    created_at: { type: "time", sql: "created_at" },
+                });
+            return database
+                .prepare(`SELECT * FROM organizations WHERE deleted_at IS NULL${where ? ` AND (${where.sql})` : ""} ORDER BY name, id LIMIT 500`)
+                .all(...(where?.params ?? []))
+                .map(organizationOf);
+        },
         addProject: async ({ name, key, type = "other", organization, scope = "personal", description }) => write(database, () => {
             const title = textOf(name, 200);
             const organizationId = organization === undefined
@@ -475,10 +488,21 @@ export const knowledgeStoreOver = (context) => {
                 .get(chosen, title, description === undefined ? null : textOf(description, 2000), oneOf(type, PROJECT_TYPES, "a project's type"), organizationId, oneOf(scope, SCOPES, "a scope"), at, at);
             return projectOf(row);
         }),
-        projects: async () => database
-            .prepare("SELECT * FROM projects WHERE deleted_at IS NULL ORDER BY name, id LIMIT 500")
-            .all()
-            .map(projectOf),
+        projects: async (query) => {
+            const where = query &&
+                queryFilter(query, {
+                    id: { type: "kw", sql: "CAST(id AS TEXT)" },
+                    key: { type: "kw", sql: "key" },
+                    type: { type: "enum", sql: "type" },
+                    organization_id: { type: "kw", sql: "CAST(organization_id AS TEXT)" },
+                    scope: { type: "enum", sql: "scope" },
+                    created_at: { type: "time", sql: "created_at" },
+                });
+            return database
+                .prepare(`SELECT * FROM projects WHERE deleted_at IS NULL${where ? ` AND (${where.sql})` : ""} ORDER BY name, id LIMIT 500`)
+                .all(...(where?.params ?? []))
+                .map(projectOf);
+        },
         relate: async (key, input) => {
             const from = related(key, input.from, true);
             const to = related(key, input.to);
@@ -553,10 +577,19 @@ export const knowledgeStoreOver = (context) => {
                 .get(row, accountId, timestamp, timezone, at, at);
             return reminder(key, String(made?.id));
         },
-        reminders: async (key) => database
-            .prepare("SELECT * FROM reminders WHERE account_id=? ORDER BY due_at, id LIMIT 500")
-            .all(account(key))
-            .map(reminderOf),
+        reminders: async (key, query) => {
+            const where = query &&
+                queryFilter(query, {
+                    id: { type: "kw", sql: "CAST(id AS TEXT)" },
+                    state: { type: "enum", sql: "state" },
+                    due_at: { type: "time", sql: "due_at" },
+                    revision: { type: "num", sql: "revision" },
+                });
+            return database
+                .prepare(`SELECT * FROM reminders WHERE account_id=?${where ? ` AND (${where.sql})` : ""} ORDER BY due_at, id LIMIT 500`)
+                .all(account(key), ...(where?.params ?? []))
+                .map(reminderOf);
+        },
         cancelReminder: async (key, id) => {
             reminder(key, id);
             database

package/dist/store/sqlite/mail-rules.d.ts

@@ -1,3 +1,4 @@
+import type { QueryAst } from "@wirecat/cli-base/query";
 import type { JsonValue } from "../../meetings/index.js";
 import type { CacheDatabase } from "../driver.js";
 type JsonObject = {
@@ -36,7 +37,7 @@ export interface MailRuleCount {
 }
 export interface MailRulesStore {
     /** Oldest first. */
-    list(accountId: number): Promise<MailRule[]>;
+    list(accountId: number, query?: QueryAst): Promise<MailRule[]>;
     /** A rule with the same conditions is replaced, and keeps its id and the emails it decided. */
     upsert(accountId: number, rule: MailRuleInput, now: number): Promise<MailRule>;
     /** Clears the rule from the emails it decided. Answers false when no rule has these conditions. */

package/dist/store/sqlite/mail-rules.js

@@ -1,3 +1,4 @@
+import { queryFilter } from "./query-filter.js";
 import { write } from "./transaction.js";
 const sorted = (value) => Array.isArray(value)
     ? value.map(sorted)
@@ -23,8 +24,17 @@ const ruleOf = (row) => ({
 // SQLite allows 32766 parameters; two are taken by the account and the rule.
 const CHUNK = 30_000;
 export const mailRulesOver = (database) => ({
-    async list(accountId) {
-        return database.prepare("SELECT * FROM mail_rules WHERE account_id = ? ORDER BY id").all(accountId).map(ruleOf);
+    async list(accountId, query) {
+        const where = query &&
+            queryFilter(query, {
+                id: { type: "num", sql: "id" },
+                protected: { type: "bool", sql: "protected" },
+                source: { type: "kw", sql: "source" },
+            });
+        return database
+            .prepare(`SELECT * FROM mail_rules WHERE account_id = ?${where ? ` AND (${where.sql})` : ""} ORDER BY id`)
+            .all(accountId, ...(where?.params ?? []))
+            .map(ruleOf);
     },
     async upsert(accountId, rule, now) {
         const row = database

package/dist/store/sqlite/meetings.js

@@ -620,6 +620,9 @@ export const meetingStoreOver = (context) => {
         async events() {
             return eventQueries.events(database);
         },
+        async queryEvents(query) {
+            return eventQueries.events(database, query);
+        },
         async eventCandidates(filter) {
             return eventQueries.eventCandidates(database, filter);
         },

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

@@ -51,6 +51,16 @@ export interface Link {
     confirmed: boolean;
     createdAt: string;
 }
+export interface LinkListFilter {
+    from?: string;
+    to?: string;
+    unresolved?: boolean;
+    id?: string;
+    kind?: Link["kind"];
+    role?: string;
+    origin?: Link["origin"];
+    confirmed?: boolean;
+}
 export interface LinkInput {
     from: string;
     to?: string;
@@ -123,11 +133,7 @@ export interface NotesStore extends NoteSearch, ImportedDocuments {
         removed: true;
     }>;
     addLink(input: LinkInput): Promise<Link>;
-    links(options?: {
-        from?: string;
-        to?: string;
-        unresolved?: boolean;
-    }): Promise<Link[]>;
+    links(options?: LinkListFilter): Promise<Link[]>;
     removeLink(id: string): Promise<{
         id: string;
         removed: true;

package/dist/store/sqlite/notes.js

@@ -404,10 +404,17 @@ export const notesStoreOver = (context) => {
             const to = pair(options.to);
             if (!from.known || !to.known)
                 return [];
+            const filters = [
+                ...(options.id === undefined ? [] : [{ sql: "CAST(id AS TEXT) = ?", value: options.id }]),
+                ...(options.kind === undefined ? [] : [{ sql: "kind = ?", value: options.kind }]),
+                ...(options.role === undefined ? [] : [{ sql: "role = ?", value: options.role }]),
+                ...(options.origin === undefined ? [] : [{ sql: "source = ?", value: options.origin }]),
+                ...(options.confirmed === undefined ? [] : [{ sql: "confirmed = ?", value: options.confirmed ? 1 : 0 }]),
+            ];
             return database
                 .prepare("SELECT * FROM links WHERE (? IS NULL OR (from_type = ? AND from_id = ?)) AND (? IS NULL OR (to_type = ? AND to_id = ?)) " +
-                "AND (? = 0 OR to_id IS NULL) ORDER BY created_at, id LIMIT 5000")
-                .all(from.type, from.type, from.id, to.type, to.type, to.id, options.unresolved ? 1 : 0)
+                `AND (? = 0 OR to_id IS NULL)${filters.map(({ sql }) => ` AND (${sql})`).join("")} ORDER BY created_at, id LIMIT 5000`)
+                .all(from.type, from.type, from.id, to.type, to.type, to.id, options.unresolved ? 1 : 0, ...filters.map(({ value }) => value))
                 .map((row) => linkOf(database, row));
         },
         removeLink: async (id) => write(database, () => {

package/dist/store/sqlite/open-store.js

@@ -9,6 +9,7 @@ import { backfillNormalized, pendingNormalization } from "./backfill.js";
 import { fillFolded } from "./folded.js";
 import { logPruner } from "./log-pruning.js";
 import { openSqlite } from "./open.js";
+import { loadProviders } from "./providers.js";
 import { assertReadCompatible } from "./read-compatibility.js";
 import { stemsState } from "./stems.js";
 import { fillStems, followDefaultStemmers } from "./stems-fill.js";
@@ -56,6 +57,7 @@ export const openStoreContext = async ({ path, env, now = Date.now, command, rea
                 fillStems(database, { now });
             logPruner(database, now)();
         }
+        loadProviders(database);
         return { ...opened, now, sharedConfig: sharedConfigPath(file, env ?? process.env) };
     }
     catch (error) {