@wirecat/cli-core 0.411.0 → 0.412.0

package/dist/search/account-list.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { FOLDER_PROVIDER, INTERNAL_NOTES, isKind, kindOf, PROVIDERS, providerNamed, } from "../domain/providers.js";
+import { FOLDER_PROVIDER, INTERNAL_NOTES, 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";
@@ -25,16 +25,20 @@ export const groupMembers = (value) => itemsOf(value).map((item) => item.toLower
         ? fail(`"${item}" names no account after the colon`)
         : item);
 const describe = (accounts) => accounts.map(({ provider, account, name }) => `${provider}:${account}${name ? ` (${name})` : ""}`).join(", ");
-const heldOf = (stored) => [
+/** The app running knows its own provider is a messenger, entry or not. */
+const kindHere = (provider, running) => provider === running.provider ? kindOf(provider) : kindIn(provider);
+const heldOf = (stored, running) => [
     ...stored
-        .filter(({ provider }) => kindOf(provider) !== "notes")
-        .map(({ provider, account, name }) => ({ provider, account, name, kind: kindOf(provider) })),
+        .filter(({ provider }) => kindIn(provider) !== "notes")
+        .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" })),
 ];
-const registry = () => PROVIDERS.map(({ name, aliases }) => (aliases.length ? `${name} (${aliases.join(", ")})` : name)).join(", ");
+const registry = () => registered()
+    .map(({ name, aliases }) => (aliases.length ? `${name} (${aliases.join(", ")})` : name))
+    .join(", ");
 const providerOf = (prefix, held, { running, profiles }) => {
     const wanted = prefix.toLowerCase();
     if (wanted === running.command?.toLowerCase())
@@ -57,7 +61,11 @@ const accountOf = (prefix, ref, held, context) => {
     const byId = ofProvider.find(({ account }) => account === ref || account === ref.toLowerCase());
     if (byId)
         return byId;
-    const keyed = (key) => ofProvider.find(({ account }) => account === key.account) ?? { ...key, name: null, kind: kindOf(key.provider) };
+    const keyed = (key) => ofProvider.find(({ account }) => account === key.account) ?? {
+        ...key,
+        name: null,
+        kind: kindHere(key.provider, context.running),
+    };
     const recorded = context.profiles[prefix.toLowerCase()]?.[ref];
     if (recorded?.provider === FOLDER_PROVIDER) {
         const folder = held.find((one) => one.provider === "notes" && one.name === recorded.account);
@@ -105,7 +113,7 @@ const keyOf = ({ provider, account }) => `${provider}\u0000${account}`;
  * the account's name — a bare provider for all its accounts, or a bare kind for every provider of it.
  */
 export const entriesOfList = (value, context) => {
-    const held = heldOf(context.held);
+    const held = heldOf(context.held, context.running);
     const entries = [];
     const entry = (item, group) => {
         const colon = item.indexOf(":");
@@ -161,6 +169,7 @@ const READS = {
     notes: "notes — search notes reads them",
     documents: "documents — search notes reads them",
     meetings: "meetings — search all reads them",
+    events: "calendar events — no search reads them yet",
 };
 /**
  * The accounts of `kinds` the entries name, and each entry that names none of them with the reason. A search
@@ -170,16 +179,23 @@ export const fitting = (entries, kinds, what, reasonOf = (kind) => READS[kind])
     const chosen = new Map();
     const skipped = [];
     for (const { entry, accounts } of entries) {
-        const fits = accounts.filter(({ kind }) => kinds.includes(kind));
+        const fits = accounts.filter(({ kind }) => kind !== undefined && kinds.includes(kind));
         for (const { provider, account } of fits)
             if (!chosen.has(keyOf({ provider, account })))
                 chosen.set(keyOf({ provider, account }), { provider, account });
+        const known = accounts.filter(({ kind }) => kind !== undefined);
+        const unknown = accounts.filter(({ kind }) => kind === undefined);
+        if (known.length)
+            for (const { provider, account } of unknown)
+                skipped.push({ source: `${provider}:${account}`, code: "not_found", reason: UNKNOWN_PROVIDER });
         if (fits.length)
             continue;
-        const other = accounts[0];
-        skipped.push(other
+        const other = known[0];
+        skipped.push(other?.kind
             ? { source: entry, code: "validation_error", reason: reasonOf(other.kind) }
-            : { source: entry, code: "not_found", reason: "no account in the store" });
+            : unknown.length
+                ? { source: entry, code: "not_found", reason: UNKNOWN_PROVIDER }
+                : { source: entry, code: "not_found", reason: "no account in the store" });
     }
     if (chosen.size === 0)
         fail(`--source names nothing ${what} reads: ${skipped.map(({ source, reason }) => `${source} (${reason})`).join(", ")}`);

package/dist/search/query.js

@@ -27,7 +27,9 @@ export const sourceOf = (name, value, providers) => {
         return source;
     if (isKind(source))
         fail(`${name}${source} names ${source}, which a message search does not read — ` +
-            `search ${source === "meetings" ? "all --source meetings" : "notes"} does`);
+            (source === "events"
+                ? "no search reads them yet"
+                : `search ${source === "meetings" ? "all --source meetings" : "notes"} does`));
     const named = providerNamed(source);
     if (named && providers.includes(named.name))
         return named.name;

package/dist/sends/permission-aliases.js

@@ -28,6 +28,7 @@ const RENAMED = [
     ["conversations.batches.next", "conversations.batches.show"],
     ["conversations.consents.revoke", "conversations.consents.remove"],
     ["stats.messages.counters.refresh", "stats.messages.counters.sync"],
+    ["store.fetch", "messages.sync"],
     ["store.gaps.plan", "store.gaps.show"],
     ["store.reindex", "store.rebuild"],
 ];

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

@@ -1,5 +1,5 @@
 import type { QueryAst } from "@wirecat/cli-base/query";
-import type { Author, Fact, Link, LinkInput, Memory, MemoryInput, MessageStore, Note } from "../../store/index.js";
+import type { Author, Fact, Link, LinkInput, LinkListFilter, Memory, MemoryInput, MessageStore, Note } from "../../store/index.js";
 export interface DocumentKnowledge {
     documents(principal: string, query: QueryAst | undefined, page: {
         limit: number;
@@ -9,8 +9,10 @@ export interface DocumentKnowledge {
         hasMore: boolean;
     }>;
     document(principal: string, ref: string): Promise<Note>;
-    tags(principal: string, ref: string, action: "list" | "add" | "remove", tags?: string[]): Promise<string[]>;
-    links(principal: string, ref: string): Promise<Link[]>;
+    tags(principal: string, ref: string, action: "list" | "add" | "remove", tags?: string[], filter?: {
+        tag?: string;
+    }): Promise<string[]>;
+    links(principal: string, ref: string, filter?: Omit<LinkListFilter, "from" | "to">): Promise<Link[]>;
     addLink(principal: string, ref: string, input: Omit<LinkInput, "from" | "origin">): Promise<Link>;
     removeLink(principal: string, ref: string, id: string): Promise<unknown>;
     notes(principal: string, ref: string, options?: {

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/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/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/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;