@wirecat/cli-core 0.393.0 → 0.395.0

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

@@ -0,0 +1,66 @@
+import type { Id, Provider } from "../domain/models.js";
+import type { AccountKey, MessageStore, PreparationFact, PreparationNote, PreparationTask } from "../store/store.js";
+import { type ContextMessage, type ContextOptions, type PersonContext } from "./person-context.js";
+import { type PersonMeetingContextItem } from "./person-meeting-context.js";
+export declare const PREPARE_BYTES: number;
+export interface WaitingDialog {
+    provider: Provider;
+    account: Id;
+    chatId: Id;
+    title: string | null;
+    /** Their message, the newest the store holds in this one-to-one chat. */
+    message: ContextMessage;
+    /** The store does not hold the whole chat, so a later answer may be missing from it. */
+    partial: boolean;
+}
+type Cut = "limit" | "bytes" | null;
+interface SectionCoverage {
+    included: number;
+    hasMore: boolean;
+    cutBy: Cut;
+}
+export interface PersonPreparation extends PersonContext {
+    prepare: {
+        waiting: WaitingDialog[];
+        tasks: PreparationTask[];
+        facts: PreparationFact[];
+        notes: PreparationNote[];
+        meetings: PersonMeetingContextItem[];
+        limits: {
+            items: number;
+            bytes: number;
+        };
+        coverage: {
+            waiting: SectionCoverage & {
+                rule: "their message is the newest the store holds in a one-to-one chat";
+            };
+            tasks: SectionCoverage & {
+                selection: "open, assigned to them in any role";
+                accounts: string[];
+            };
+            facts: SectionCoverage & {
+                selection: "accepted, about them or a project they are a member of";
+            };
+            /** `withheld` when the profile denies `contacts.notes.list`. */
+            notes: SectionCoverage & {
+                selection: "written by you, about them";
+                withheld?: "contacts.notes.list";
+            };
+            /** `accounts`: the ones their meetings came from. */
+            meetings: SectionCoverage & {
+                read: "every account of the store that saw them";
+                accounts: string[];
+                pending: number;
+            };
+        };
+    };
+}
+/**
+ * `contacts context` and what to know before talking to them: the one-to-one chats where they wrote last, open tasks,
+ * accepted facts, your notes and their recent meetings, each item with its reference. The messages keep their own
+ * budget; the sections share what is left of `PREPARE_BYTES`, in that order, so evidence comes first.
+ */
+export declare const personPreparation: (store: MessageStore, asked: AccountKey, reference: string, options?: ContextOptions & {
+    notes?: boolean;
+}) => Promise<PersonPreparation>;
+export {};

package/dist/services/person-preparation.js

@@ -0,0 +1,126 @@
+import { CliError } from "@wirecat/cli-base";
+import { parseMeetingReference } from "../meetings/index.js";
+import { CONTEXT_BYTES, CONTEXT_MESSAGES, personContext, readsOf, toContext, } from "./person-context.js";
+import { personMeetingContext } from "./person-meeting-context.js";
+export const PREPARE_BYTES = 96 * 1024;
+const MEETINGS = 5;
+const CUES = 3;
+const size = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+const accountName = ({ provider, account }) => `${provider}:${account}`;
+/**
+ * `contacts context` and what to know before talking to them: the one-to-one chats where they wrote last, open tasks,
+ * accepted facts, your notes and their recent meetings, each item with its reference. The messages keep their own
+ * budget; the sections share what is left of `PREPARE_BYTES`, in that order, so evidence comes first.
+ */
+export const personPreparation = async (store, asked, reference, options = {}) => {
+    const context = await personContext(store, asked, reference, { ...options, bytes: CONTEXT_BYTES });
+    const limit = options.messages ?? CONTEXT_MESSAGES;
+    let left = PREPARE_BYTES - size({ recent: context.recent, mentions: context.mentions });
+    const budgeted = (page) => {
+        const items = [];
+        let cut = false;
+        for (const item of page.items.slice(0, limit)) {
+            const bytes = size(item);
+            if (cut || bytes > left) {
+                cut = true;
+                continue;
+            }
+            left -= bytes;
+            items.push(item);
+        }
+        const over = page.hasMore || page.items.length > limit;
+        return {
+            items,
+            coverage: { included: items.length, hasMore: over || cut, cutBy: cut ? "bytes" : over ? "limit" : null },
+        };
+    };
+    const reads = readsOf(context.person, asked);
+    const partial = new Set(context.notRead.map((chat) => `${chat.provider}/${chat.account}/${chat.chatId}`));
+    const waiting = [];
+    for (const chat of context.shared.filter((one) => one.kind === "dialog")) {
+        const key = { provider: chat.provider, account: chat.account };
+        const [newest] = (await store.messages.messages(key, chat.chatId, { limit: 1 })).items;
+        if (newest?.outgoing !== false)
+            continue;
+        waiting.push({
+            ...key,
+            chatId: chat.chatId,
+            title: chat.title,
+            message: toContext(key, newest, chat.title),
+            partial: partial.has(`${chat.provider}/${chat.account}/${chat.chatId}`),
+        });
+    }
+    waiting.sort((a, b) => Date.parse(b.message.timestamp) - Date.parse(a.message.timestamp));
+    const accounts = [...new Map(reads.map(({ key }) => [accountName(key), key])).values()];
+    const held = await store.people.preparation(context.person.uid, { accounts, limit });
+    const stored = await store.accounts.storedAccounts();
+    const meetings = await meetingsOf(store, context.person.uid, stored, options.since, () => left);
+    const sections = {
+        waiting: budgeted({ items: waiting, hasMore: false }),
+        tasks: budgeted(held.tasks),
+        facts: budgeted(held.facts),
+        notes: budgeted(options.notes === false ? { items: [], hasMore: false } : held.notes),
+        meetings: budgeted({ items: meetings.items, hasMore: meetings.hasMore }),
+    };
+    return {
+        ...context,
+        prepare: {
+            waiting: sections.waiting.items,
+            tasks: sections.tasks.items,
+            facts: sections.facts.items,
+            notes: sections.notes.items,
+            meetings: sections.meetings.items,
+            limits: { items: limit, bytes: PREPARE_BYTES },
+            coverage: {
+                waiting: {
+                    ...sections.waiting.coverage,
+                    rule: "their message is the newest the store holds in a one-to-one chat",
+                },
+                tasks: {
+                    ...sections.tasks.coverage,
+                    selection: "open, assigned to them in any role",
+                    accounts: accounts.map(accountName),
+                },
+                facts: { ...sections.facts.coverage, selection: "accepted, about them or a project they are a member of" },
+                notes: {
+                    ...sections.notes.coverage,
+                    selection: "written by you, about them",
+                    ...(options.notes === false ? { withheld: "contacts.notes.list" } : {}),
+                },
+                meetings: {
+                    ...sections.meetings.coverage,
+                    read: "every account of the store that saw them",
+                    accounts: meetings.accounts,
+                    pending: meetings.pending,
+                },
+            },
+        },
+    };
+};
+/** Their recent meetings in every account of the store that saw them; none is not an error. */
+const meetingsOf = async (store, uid, stored, since, left) => {
+    const none = { items: [], hasMore: false, accounts: [], pending: 0 };
+    if (!stored.length || left() < 2)
+        return none;
+    try {
+        const found = await personMeetingContext(store, `person:${uid}`, {
+            accountIds: stored.slice(0, 1000).map(({ id }) => id),
+            meetings: MEETINGS,
+            cues: CUES,
+            bytes: Math.min(left(), 4 * 1024 * 1024),
+            ...(since === undefined ? {} : { since }),
+        });
+        const read = new Set(found.items.map((item) => parseMeetingReference(item.reference).accountId));
+        return {
+            items: found.items,
+            hasMore: found.coverage.truncatedBy !== null || found.coverage.scanLimitReached,
+            accounts: stored.filter(({ id }) => read.has(id)).map(accountName),
+            pending: found.coverage.pending,
+        };
+    }
+    catch (error) {
+        if (error instanceof CliError && error.code === "not_found")
+            return none;
+        throw error;
+    }
+};

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

@@ -21,4 +21,4 @@ export interface SearchParams extends RankingInput {
     by?: StatsGrouping;
 }
 /** One run or one saved search as the store keeps it; the same parameters always give the same text. */
-export declare const searchRecordOf: (command: SearchCommand, params: SearchParams) => SearchRecord;
+export declare const searchRecordOf: (command: SearchCommand, params: SearchParams | Readonly<Record<string, unknown>>) => SearchRecord;

package/dist/services/searches.d.ts

@@ -33,4 +33,5 @@ export interface SearchesService {
      */
     resolve(reference: string, typed: SearchParams): Promise<ResolvedSearch>;
 }
+export declare const nameOf: (value: string) => string;
 export declare const searchesService: (deps: ServiceDeps) => SearchesService;

package/dist/services/searches.js

@@ -17,8 +17,16 @@ export const savedSearchItem = (one) => ({
     last_run_at: one.lastRunAt,
     runs: one.runs,
 });
+/** What the messenger commands run; the table is shared, and another CLI's rows are not theirs to list or run. */
+const MESSAGE_SEARCH_COMMANDS = [
+    "search",
+    "stats",
+    "message-top",
+    "author-top",
+    "admin-statistics",
+];
 const NAME = /^[a-z0-9][a-z0-9-]{0,63}$/;
-const nameOf = (value) => {
+export const nameOf = (value) => {
     const name = value.trim().toLowerCase();
     if (!NAME.test(name) || /^\d+$/.test(name))
         throw new CliError("validation_error", `"${singleLine(value)}" cannot name a saved search — use up to 64 letters a–z, digits and hyphens, not only digits`, { reason: "name.invalid" });
@@ -63,6 +71,11 @@ export const searchesService = (deps) => {
         const search = await store.searches.storedSearch(reference.trim().toLowerCase());
         if (!search)
             throw new CliError("not_found", `no saved search or run "${singleLine(reference)}"`);
+        if (!MESSAGE_SEARCH_COMMANDS.includes(search.command))
+            throw new CliError("validation_error", `"${singleLine(reference)}" is a saved meeting search, not one of messages`, {
+                reason: "search.kind",
+                command: search.command,
+            });
         return search;
     };
     return {
@@ -87,13 +100,13 @@ export const searchesService = (deps) => {
             });
         }),
         show: (reference) => inStore((store) => found(store, reference)),
-        list: () => inStore((store) => store.searches.savedSearches()),
+        list: () => inStore((store) => store.searches.savedSearches(MESSAGE_SEARCH_COMMANDS)),
         history: (limit, offset = 0) => inStore(async (store) => {
-            const rows = await store.searches.searchHistory(limit, offset);
+            const rows = await store.searches.searchHistory(limit, offset, MESSAGE_SEARCH_COMMANDS);
             return { items: rows.slice(0, limit), has_more: rows.length > limit };
         }),
         delete: (reference) => inStore(async (store) => store.searches.deleteSearch((await found(store, reference)).id)),
-        clear: () => inStore(async (store) => ({ cleared: await store.searches.clearSearchHistory() })),
+        clear: () => inStore(async (store) => ({ cleared: await store.searches.clearSearchHistory(MESSAGE_SEARCH_COMMANDS) })),
         resolve: (reference, { text: words, ...typed }) => inStore(async (store) => {
             const search = await found(store, reference);
             const stored = search.params;

package/dist/store/exports.d.ts

@@ -31,6 +31,7 @@ export { OTHER_SOURCES, type OtherSource, type SourceMention } from "./sqlite/me
 export { MENTION_QUERY, MENTION_STATUSES, type MentionDecision, type MentionStatus, type MentionsRebuild, type MentionsState, type StoredMention, type StoredPlace, } from "./sqlite/mentions.js";
 export { drainNoteIndex, noteIndexState, resetNoteIndex } from "./sqlite/note-index.js";
 export type { Link as ThingLink } from "./sqlite/notes.js";
+export type { PersonPreparationRead, PreparationFact, PreparationNote, PreparationTask, } from "./sqlite/person-preparation.js";
 export { savedPhoneCountries, saveStorePhoneCountries } from "./sqlite/phone-countries.js";
 export type { PrivateContact, PrivateContactNote } from "./sqlite/private-people.js";
 export type { ProposedAction } from "./sqlite/proposed-actions.js";

package/dist/store/people.d.ts

@@ -2,6 +2,7 @@ import type { Contact, Id, Page, PersonAlias, Provider } from "../domain/models.
 import type { PeopleLookup } from "../resolve.js";
 import type { ContactFilter } from "./sqlite/identities.js";
 import type { StoreContext } from "./sqlite/open.js";
+import { type PersonPreparationRead } from "./sqlite/person-preparation.js";
 import type { PrivateContact, PrivateContactNote } from "./sqlite/private-people.js";
 import type { AccountKey, IdentityRef, LinkOptions, PersonFacts, PersonRecord } from "./types.js";
 export interface AccountPeople {
@@ -44,6 +45,11 @@ export interface PeopleStore extends AccountPeople {
     /** The person a `person:<uid>` reference names. */
     personSeenInAccounts(uid: string, accountIds: readonly number[]): Promise<boolean>;
     personByUid(uid: string): Promise<PersonRecord | undefined>;
+    /** Accepted facts, the owner's notes and open tasks about them; tasks of an account only if `accounts` holds it. */
+    preparation(uid: string, options: {
+        accounts: readonly AccountKey[];
+        limit: number;
+    }): Promise<PersonPreparationRead>;
     /** Records the decision in `identity_link_events`; `unlinkIdentity` undoes it. */
     linkIdentities(person: IdentityRef, other: IdentityRef, options: LinkOptions): Promise<PersonRecord>;
     unlinkIdentity(identity: IdentityRef, options: LinkOptions): Promise<PersonRecord>;

package/dist/store/people.js

@@ -2,6 +2,7 @@ import { keysOver } from "./keys.js";
 import * as identities from "./sqlite/identities.js";
 import { linkToOwner } from "./sqlite/own-identities.js";
 import * as personLinks from "./sqlite/person-links.js";
+import { personPreparation } from "./sqlite/person-preparation.js";
 import { personSeenInAccounts } from "./sqlite/person-scope.js";
 import * as privatePeople from "./sqlite/private-people.js";
 import { write } from "./sqlite/transaction.js";
@@ -55,6 +56,7 @@ export const peopleStoreOver = (context, keyed) => {
         personOf: async (identity) => personLinks.personOf(context, identity),
         personSeenInAccounts: async (uid, accountIds) => personSeenInAccounts(context, uid, accountIds),
         personByUid: async (uid) => personLinks.personByUid(context, uid),
+        preparation: async (uid, options) => personPreparation(context, uid, options),
         linkIdentities: async (person, other, options) => {
             return write(database, () => personLinks.linkIdentities(context, person, other, options));
         },

package/dist/store/searches.d.ts

@@ -1,5 +1,5 @@
 import type { StoreContext } from "./sqlite/open.js";
-import type { SearchRecord, StoredSearch } from "./sqlite/searches.js";
+import type { SearchCommand, SearchRecord, StoredSearch } from "./sqlite/searches.js";
 export interface SearchesStore {
     /** One run of a search or stats; the same unnamed run again counts on its row. `saved` is the saved search it ran. */
     recordSearch(run: SearchRecord, options?: {
@@ -11,11 +11,12 @@ export interface SearchesStore {
     }): Promise<StoredSearch>;
     /** A saved search by name, or any row by id. */
     storedSearch(reference: string): Promise<StoredSearch | undefined>;
-    savedSearches(): Promise<StoredSearch[]>;
+    /** `commands`: only rows of these kinds; the table is shared by every CLI on the store. */
+    savedSearches(commands?: readonly SearchCommand[]): Promise<StoredSearch[]>;
     /** Runs, newest first, one more than `limit` when there are more. */
-    searchHistory(limit: number, offset?: number): Promise<StoredSearch[]>;
+    searchHistory(limit: number, offset?: number, commands?: readonly SearchCommand[]): Promise<StoredSearch[]>;
     deleteSearch(reference: string): Promise<StoredSearch>;
     /** Drops the unnamed runs; answers how many. */
-    clearSearchHistory(): Promise<number>;
+    clearSearchHistory(commands?: readonly SearchCommand[]): Promise<number>;
 }
 export declare const searchesStoreOver: (context: StoreContext) => SearchesStore;

package/dist/store/searches.js

@@ -8,15 +8,15 @@ export const searchesStoreOver = (context) => {
             return write(database, () => searchRecords.saveSearch(context, name, search, replace));
         },
         storedSearch: async (reference) => searchRecords.findSearch(context, reference),
-        savedSearches: async () => searchRecords.savedSearches(context),
-        searchHistory: async (limit, offset) => searchRecords.searchHistory(context, limit, offset),
+        savedSearches: async (commands) => searchRecords.savedSearches(context, commands),
+        searchHistory: async (limit, offset, commands) => searchRecords.searchHistory(context, limit, offset, commands),
         deleteSearch: async (reference) => {
             return write(database, () => searchRecords.deleteSearch(context, reference));
         },
-        clearSearchHistory: async () => {
+        clearSearchHistory: async (commands) => {
             let cleared = 0;
             write(database, () => {
-                cleared = searchRecords.clearHistory(context);
+                cleared = searchRecords.clearHistory(context, commands);
             });
             return cleared;
         },

package/dist/store/sqlite/person-preparation.d.ts

@@ -0,0 +1,48 @@
+import type { AccountKey } from "../types.js";
+import type { StoreContext } from "./open.js";
+export interface PreparationFact {
+    ref: string;
+    type: string;
+    statement: string;
+    subject: string | null;
+    project: string | null;
+    updatedAt: string;
+}
+export interface PreparationNote {
+    ref: string;
+    title: string | null;
+    text: string;
+    revision: number;
+    updatedAt: string;
+}
+export interface PreparationTask {
+    ref: string;
+    title: string;
+    role: string;
+    dueAt: string | null;
+    project: string;
+    source: string | null;
+    createdAt: string;
+}
+export interface PersonPreparationRead {
+    facts: {
+        items: PreparationFact[];
+        hasMore: boolean;
+    };
+    notes: {
+        items: PreparationNote[];
+        hasMore: boolean;
+    };
+    tasks: {
+        items: PreparationTask[];
+        hasMore: boolean;
+    };
+}
+/**
+ * The accepted facts, the owner's notes and the open tasks about one person. A project bound to an account is that
+ * account's: its facts never come along, and its tasks only when `accounts` holds it.
+ */
+export declare const personPreparation: ({ database }: Pick<StoreContext, "database">, uid: string, { accounts, limit }: {
+    accounts: readonly AccountKey[];
+    limit: number;
+}) => PersonPreparationRead;

package/dist/store/sqlite/person-preparation.js

@@ -0,0 +1,72 @@
+import { CliError } from "@wirecat/cli-base";
+import { linkKind } from "./link-kinds.js";
+import { taskIdOf } from "./things.js";
+import { read } from "./transaction.js";
+const GLOBAL_PROJECT = "SELECT id FROM main.projects WHERE account_id IS NULL AND deleted_at IS NULL";
+const iso = (value) => (value == null ? null : new Date(Number(value)).toISOString());
+/**
+ * The accepted facts, the owner's notes and the open tasks about one person. A project bound to an account is that
+ * account's: its facts never come along, and its tasks only when `accounts` holds it.
+ */
+export const personPreparation = ({ database }, uid, { accounts, limit }) => {
+    const person = Number(uid);
+    if (!/^[1-9]\d*$/.test(uid) || !Number.isSafeInteger(person) || !Number.isSafeInteger(limit) || limit < 1)
+        throw new CliError("validation_error", "person preparation takes a person id and a positive limit");
+    const page = (rows) => ({ items: rows.slice(0, limit), hasMore: rows.length > limit });
+    return read(database, () => {
+        const projects = `SELECT l.to_id FROM links l WHERE l.from_type='person' AND l.from_id=? AND l.to_type='project'
+      AND l.kind=${linkKind("member-of")} AND l.confirmed=1 AND l.to_id IN (${GLOBAL_PROJECT})`;
+        const facts = database
+            .prepare(`SELECT f.id,f.type,f.statement,f.subject_type,f.subject_id,f.project_id,f.updated_at FROM facts f
+        WHERE f.status='accepted' AND f.deleted_at IS NULL
+        AND ((f.subject_type='person' AND f.subject_id=?) OR (f.subject_type='project' AND f.subject_id IN (${projects}))
+          OR f.project_id IN (${projects}))
+        AND (f.subject_type IS NOT 'project' OR f.subject_id IN (${GLOBAL_PROJECT}))
+        AND (f.project_id IS NULL OR f.project_id IN (${GLOBAL_PROJECT}))
+        ORDER BY f.updated_at DESC, f.id DESC LIMIT ?`)
+            .all(person, person, person, limit + 1)
+            .map((row) => ({
+            ref: `fact:${row.id}`,
+            type: String(row.type),
+            statement: String(row.statement),
+            subject: row.subject_type == null ? null : `${row.subject_type}:${row.subject_id}`,
+            project: row.project_id == null ? null : `project:${row.project_id}`,
+            updatedAt: iso(row.updated_at),
+        }));
+        const notes = database
+            .prepare(`SELECT n.id,n.title,n.body,n.revision,n.updated_at FROM notes n
+        JOIN persons owner ON n.author_type='person' AND n.author_id=owner.id AND owner.owner=1
+        WHERE n.deleted_at IS NULL
+        AND ((n.notable_type='person' AND n.notable_id=?) OR EXISTS(SELECT 1 FROM links l WHERE l.from_type='note'
+          AND l.from_id=n.id AND l.to_type='person' AND l.to_id=? AND l.kind=${linkKind("about")} AND l.confirmed=1))
+        AND (n.notable_type='person' OR (n.notable_type='project' AND n.notable_id IN (${GLOBAL_PROJECT})))
+        ORDER BY n.updated_at DESC, n.id DESC LIMIT ?`)
+            .all(person, person, limit + 1)
+            .map((row) => ({
+            ref: `note:${row.id}`,
+            title: row.title == null ? null : String(row.title),
+            text: String(row.body),
+            revision: Number(row.revision),
+            updatedAt: iso(row.updated_at),
+        }));
+        const tasks = database
+            .prepare(`SELECT t.id,t.title,t.due_at,t.project_id,t.source_locator,t.created_at,group_concat(DISTINCT ta.role) AS role
+        FROM task_assignments ta JOIN tasks t ON t.id=ta.task_id JOIN main.projects p ON p.id=t.project_id
+        WHERE ta.assignee_type='person' AND ta.assignee_id=? AND t.deleted_at IS NULL AND t.status='open'
+        AND p.deleted_at IS NULL AND (p.account_id IS NULL OR p.account_id IN (SELECT a.id FROM accounts a
+          JOIN json_each(?) k ON a.provider=json_extract(k.value,'$.provider')
+          AND a.external_id=json_extract(k.value,'$.account')))
+        GROUP BY t.id ORDER BY t.due_at IS NULL, t.due_at, t.created_at, t.id LIMIT ?`)
+            .all(person, JSON.stringify(accounts.map(({ provider, account }) => ({ provider, account }))), limit + 1)
+            .map((row) => ({
+            ref: `task:${taskIdOf(database, Number(row.id))}`,
+            title: String(row.title),
+            role: String(row.role),
+            dueAt: iso(row.due_at),
+            project: `project:${row.project_id}`,
+            source: row.source_locator == null ? null : String(row.source_locator),
+            createdAt: iso(row.created_at),
+        }));
+        return { facts: page(facts), notes: page(notes), tasks: page(tasks) };
+    });
+};

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

@@ -1,7 +1,7 @@
 import type { StoreContext } from "./open.js";
 /** Unnamed runs kept, newest first; a saved search is never pruned. */
 export declare const HISTORY_KEPT = 1000;
-export type SearchCommand = "search" | "stats" | "message-top" | "author-top" | "admin-statistics";
+export type SearchCommand = "search" | "stats" | "message-top" | "author-top" | "admin-statistics" | "meetings-search";
 /** What one run or one saved search is: `params` as canonical JSON, so the same run is the same text. */
 export interface SearchRecord {
     command: SearchCommand;
@@ -26,9 +26,9 @@ export declare const recordRun: ({ database, now }: StoreContext, run: SearchRec
 export declare const findSearch: ({ database }: StoreContext, reference: string) => StoredSearch | undefined;
 /** A name already taken is refused unless `replace`, which starts it afresh: new parameters, no runs. */
 export declare const saveSearch: (context: StoreContext, name: string, search: SearchRecord, replace: boolean) => StoredSearch;
-export declare const savedSearches: ({ database }: StoreContext) => StoredSearch[];
+export declare const savedSearches: ({ database }: StoreContext, commands?: readonly SearchCommand[]) => StoredSearch[];
 /** Runs, newest first: unnamed ones and saved searches that have run. One more than `limit` says there are more. */
-export declare const searchHistory: ({ database }: StoreContext, limit: number, offset?: number) => StoredSearch[];
+export declare const searchHistory: ({ database }: StoreContext, limit: number, offset?: number, commands?: readonly SearchCommand[]) => StoredSearch[];
 export declare const deleteSearch: (context: StoreContext, reference: string) => StoredSearch;
 /** Unnamed runs only; saved searches stay. */
-export declare const clearHistory: ({ database }: StoreContext) => number;
+export declare const clearHistory: ({ database }: StoreContext, commands?: readonly SearchCommand[]) => number;

package/dist/store/sqlite/searches.js

@@ -2,6 +2,9 @@ import { CliError, singleLine } from "@wirecat/cli-base";
 import { toIso } from "./values.js";
 /** Unnamed runs kept, newest first; a saved search is never pruned. */
 export const HISTORY_KEPT = 1000;
+const commandFilter = (commands) => commands
+    ? { sql: ` AND command IN (${commands.map(() => "?").join(", ")})`, values: [...commands] }
+    : { sql: "", values: [] };
 const COLUMNS = "id, name, command, params, language, version, fields_version, created_at, updated_at, last_run_at, runs";
 const searchOf = (row) => ({
     id: String(row.id),
@@ -61,16 +64,28 @@ export const saveSearch = (context, name, search, replace) => {
             .run(...values, now(), name);
     return mustFind(context, name);
 };
-export const savedSearches = ({ database }) => database.prepare(`SELECT ${COLUMNS} FROM searches WHERE name IS NOT NULL ORDER BY name`).all().map(searchOf);
+export const savedSearches = ({ database }, commands) => {
+    const only = commandFilter(commands);
+    return database
+        .prepare(`SELECT ${COLUMNS} FROM searches WHERE name IS NOT NULL${only.sql} ORDER BY name`)
+        .all(...only.values)
+        .map(searchOf);
+};
 /** Runs, newest first: unnamed ones and saved searches that have run. One more than `limit` says there are more. */
-export const searchHistory = ({ database }, limit, offset = 0) => database
-    .prepare(`SELECT ${COLUMNS} FROM searches WHERE last_run_at IS NOT NULL ORDER BY last_run_at DESC, id DESC LIMIT ? OFFSET ?`)
-    .all(limit + 1, offset)
-    .map(searchOf);
+export const searchHistory = ({ database }, limit, offset = 0, commands) => {
+    const only = commandFilter(commands);
+    return database
+        .prepare(`SELECT ${COLUMNS} FROM searches WHERE last_run_at IS NOT NULL${only.sql} ORDER BY last_run_at DESC, id DESC LIMIT ? OFFSET ?`)
+        .all(...only.values, limit + 1, offset)
+        .map(searchOf);
+};
 export const deleteSearch = (context, reference) => {
     const found = mustFind(context, reference);
     context.database.prepare("DELETE FROM searches WHERE id = ?").run(Number(found.id));
     return found;
 };
 /** Unnamed runs only; saved searches stay. */
-export const clearHistory = ({ database }) => database.prepare("DELETE FROM searches WHERE name IS NULL").run().changes;
+export const clearHistory = ({ database }, commands) => {
+    const only = commandFilter(commands);
+    return database.prepare(`DELETE FROM searches WHERE name IS NULL${only.sql}`).run(...only.values).changes;
+};

package/package.json

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

package/parity.json

@@ -2816,6 +2816,13 @@
     "contacts notes show": {
       "in": "all"
     },
+    "contacts prepare": {
+      "in": "all",
+      "options": {
+        "--limit": "all",
+        "--since-time": "all"
+      }
+    },
     "contacts profile": {
       "in": "all",
       "options": {