@wirecat/cli-core 0.399.0 → 0.401.0

package/dist/cli/messenger/message-writes.d.ts

@@ -4,14 +4,16 @@ interface Written {
     operationId: string;
     sendId?: string;
     message: Message;
+    messages?: Message[];
     scheduledFor?: string;
 }
 /**
  * A send, forward or edit: the message as it now stands, with its `operation_id` — for a send, the id a repeat
- * passes as `--operation-id` so it cannot make a second copy. A scheduled message gets a new id when it goes out,
+ * passes as `--operation-id` so it cannot make a second copy. An album adds `messages`, every one it made, in order;
+ * `message` stays its first, so a reader of one message reads an album as before. A scheduled message gets a new id when it goes out,
  * so its next step is the list that shows it, never a retry.
  */
-export declare const writtenAnswer: ({ operationId, sendId, message, scheduledFor }: Written, reader: AccountKey) => import("../envelope.js").ItemBody<{
+export declare const writtenAnswer: ({ operationId, sendId, message, messages, scheduledFor }: Written, reader: AccountKey) => import("../envelope.js").ItemBody<{
     operation_id: string;
     message: {
         ref: string;
@@ -201,6 +203,194 @@ export declare const writtenAnswer: ({ operationId, sendId, message, scheduledFo
             [x: string]: unknown;
         } | undefined;
     };
+    messages?: {
+        ref: string;
+        id: string;
+        provider?: string | undefined;
+        account?: string | undefined;
+        chat_id: string;
+        chat_title?: string | null | undefined;
+        sender_id: string | null;
+        sender_name: string | null;
+        sender_username?: string | undefined;
+        sender_is_chat?: boolean | undefined;
+        mentions?: string[] | undefined;
+        timestamp: string;
+        edited_at: string | null;
+        text: string;
+        transcript?: string | undefined;
+        anchor?: boolean | undefined;
+        excerpt?: string | undefined;
+        matched_in?: "context" | "file" | "filename" | "picture" | "text" | "transcript" | undefined;
+        score?: number | undefined;
+        match?: "beginnings" | "corrected" | "words" | undefined;
+        corrections?: {
+            from: string;
+            to: string[];
+        }[] | undefined;
+        found_in?: "archive" | "both" | "server" | undefined;
+        discovery?: {
+            coverage: number;
+            matched_terms: string[];
+            missing_terms: string[];
+            parent?: string | undefined;
+        } | undefined;
+        context?: {
+            ref: string;
+            timestamp: string;
+            sender_name: string | null;
+            text: string;
+        }[] | undefined;
+        outgoing: boolean | null;
+        attachments: {
+            message?: string | undefined;
+            kind: string;
+            position?: number | undefined;
+            url?: string | undefined;
+            name?: string | undefined;
+            title?: string | undefined;
+            mime?: string | undefined;
+            size?: number | undefined;
+            width?: number | undefined;
+            height?: number | undefined;
+            duration?: number | undefined;
+            text?: string | undefined;
+            extraction?: {
+                origin: string;
+                extractor: string;
+                chars: number;
+                error?: string | undefined;
+            } | undefined;
+            local_path?: string | undefined;
+            buttons?: {
+                kind: "app" | "callback" | "chat" | "clipboard" | "contact" | "link" | "location" | "message" | "other";
+                text: string;
+                url?: string | undefined;
+            }[][] | undefined;
+        }[];
+        reply_to: {
+            id: string;
+            sender_id: string | null;
+            sender_name: string | null;
+            timestamp: string | null;
+            text: string;
+            attachments: {
+                message?: string | undefined;
+                kind: string;
+                position?: number | undefined;
+                url?: string | undefined;
+                name?: string | undefined;
+                title?: string | undefined;
+                mime?: string | undefined;
+                size?: number | undefined;
+                width?: number | undefined;
+                height?: number | undefined;
+                duration?: number | undefined;
+                text?: string | undefined;
+                extraction?: {
+                    origin: string;
+                    extractor: string;
+                    chars: number;
+                    error?: string | undefined;
+                } | undefined;
+                local_path?: string | undefined;
+                buttons?: {
+                    kind: "app" | "callback" | "chat" | "clipboard" | "contact" | "link" | "location" | "message" | "other";
+                    text: string;
+                    url?: string | undefined;
+                }[][] | undefined;
+            }[];
+            outgoing: boolean | null;
+        } | null;
+        reply_to_id?: string | undefined;
+        forwarded_from: {
+            id: string;
+            sender_id: string | null;
+            sender_name: string | null;
+            timestamp: string | null;
+            text: string;
+            attachments: {
+                message?: string | undefined;
+                kind: string;
+                position?: number | undefined;
+                url?: string | undefined;
+                name?: string | undefined;
+                title?: string | undefined;
+                mime?: string | undefined;
+                size?: number | undefined;
+                width?: number | undefined;
+                height?: number | undefined;
+                duration?: number | undefined;
+                text?: string | undefined;
+                extraction?: {
+                    origin: string;
+                    extractor: string;
+                    chars: number;
+                    error?: string | undefined;
+                } | undefined;
+                local_path?: string | undefined;
+                buttons?: {
+                    kind: "app" | "callback" | "chat" | "clipboard" | "contact" | "link" | "location" | "message" | "other";
+                    text: string;
+                    url?: string | undefined;
+                }[][] | undefined;
+            }[];
+            outgoing: boolean | null;
+        } | null;
+        thread_id?: string | undefined;
+        thread_root_id?: string | undefined;
+        reactions?: {
+            counts: {
+                reaction: string;
+                count: number;
+            }[];
+            mine: string | null;
+            total: number;
+        } | null | undefined;
+        scheduled_for?: string | undefined;
+        starred?: true | undefined;
+        delivery?: "delivered" | "read" | undefined;
+        email?: {
+            subject: string | null;
+            from: {
+                name: string | null;
+                address: string;
+                ref: string | null;
+            } | null;
+            to: {
+                name: string | null;
+                address: string;
+                ref: string | null;
+            }[];
+            cc: {
+                name: string | null;
+                address: string;
+                ref: string | null;
+            }[];
+            bcc: {
+                name: string | null;
+                address: string;
+                ref: string | null;
+            }[];
+            reply_addresses: {
+                name: string | null;
+                address: string;
+                ref: string | null;
+            }[];
+            labels: string[];
+            thread: string;
+            read: boolean | null;
+            flagged: boolean | null;
+            sender_score?: {
+                score: number;
+                signals: string[];
+                demoted?: true | undefined;
+            } | undefined;
+        } | undefined;
+        provider_metadata?: {
+            [x: string]: unknown;
+        } | undefined;
+    }[] | undefined;
     scheduled_for?: string | undefined;
 }>;
 /**

package/dist/cli/messenger/message-writes.js

@@ -4,12 +4,16 @@ import { nextStep } from "../steps.js";
 import { messageItem } from "./message-items.js";
 /**
  * A send, forward or edit: the message as it now stands, with its `operation_id` — for a send, the id a repeat
- * passes as `--operation-id` so it cannot make a second copy. A scheduled message gets a new id when it goes out,
+ * passes as `--operation-id` so it cannot make a second copy. An album adds `messages`, every one it made, in order;
+ * `message` stays its first, so a reader of one message reads an album as before. A scheduled message gets a new id when it goes out,
  * so its next step is the list that shows it, never a retry.
  */
-export const writtenAnswer = ({ operationId, sendId, message, scheduledFor }, reader) => itemOf({
+export const writtenAnswer = ({ operationId, sendId, message, messages, scheduledFor }, reader) => itemOf({
     operation_id: sendId ?? operationId,
     message: messageItem(message, reader),
+    ...(messages === undefined || messages.length < 2
+        ? {}
+        : { messages: messages.map((one) => messageItem(one, reader)) }),
     ...(scheduledFor === undefined ? {} : { scheduled_for: scheduledFor }),
 }, scheduledFor === undefined ? {} : { next: [nextStep("messages.scheduled", { args: { chat: message.chatId } })] });
 /**

package/dist/cli/messenger/messages-command.js

@@ -110,6 +110,7 @@ export const messagesCommand = (messenger) => {
     };
     messages.addCommand(sendCommand(messenger));
     annotate(messages.command("show"), {
+        output: { entity: "message" },
         examples: [`${messenger.app.command} personal messages show "Book club" 101`],
         effects: REMOTE_READ,
     })
@@ -122,6 +123,7 @@ export const messagesCommand = (messenger) => {
         await readWindow(this, chat, message, { before: 0, after: 0 });
     });
     threadOptions(annotate(messages.command("context"), {
+        output: { entity: "message_context" },
         examples: [`${messenger.app.command} personal messages context "Book club" 101 --before-n 3 --after-n 3`],
         effects: REMOTE_READ,
     }))

package/dist/cli/messenger/messages-delete-command.js

@@ -14,6 +14,7 @@ import { messengerContext } from "./context.js";
 export const deleteCommand = (messenger) => annotate(new Command("delete"), {
     examples: [`${messenger.app.command} personal messages delete "Book club" 101`],
     effects: REMOTE_WRITE,
+    output: { entity: "message_deletion" },
 })
     .description("delete messages for you only; with --for-everyone, for everyone in the chat")
     .argument("<chat>", messenger.chatArgument)

package/dist/cli/messenger/messages-edit-command.js

@@ -11,6 +11,7 @@ export const editCommand = (messenger) => {
     const edit = annotate(new Command("edit"), {
         examples: [`${messenger.app.command} personal messages edit "Book club" 101 "The meeting starts at 11."`],
         effects: REMOTE_WRITE,
+        output: { entity: "message_write" },
     })
         .description("change the text of your own message; the other side may have read it already")
         .argument("<chat>", messenger.chatArgument)

package/dist/cli/messenger/messages-evidence-command.js

@@ -7,10 +7,12 @@ import { positiveCount } from "../paging.js";
 import { messengerContext } from "./context.js";
 import { evidenceAnswer } from "./message-answers.js";
 export const evidenceCommand = (messenger) => annotate(new Command("evidence"), {
+    output: { entity: "evidence_packet" },
     examples: [`${messenger.app.command} personal messages evidence "Book club" --limit 10`],
     effects: LOCAL_READ,
 })
-    .description("a bounded evidence packet from stored messages, newest first")
+    .summary("a recent-chat evidence packet from stored messages")
+    .description("general chat context, newest first, with references, coverage and fingerprints for verification")
     .argument("<chat>", messenger.chatArgument)
     .option("--limit <n>", "how many, 1–100", positiveCount("--limit"))
     .option("--cursor <cursor>", "go on from where page.next says the last packet stopped")

package/dist/cli/messenger/messages-forward-command.js

@@ -9,6 +9,7 @@ export const forwardCommand = (messenger) => {
     const forward = annotate(new Command("forward"), {
         examples: [`${messenger.app.command} personal messages forward "Book club" 101 --to "Project room"`],
         effects: REMOTE_WRITE,
+        output: { entity: "message_write" },
     })
         .description("forward one message to another chat")
         .argument("<chat>", `the chat the message is in: ${messenger.chatArgument}`)

package/dist/cli/messenger/messages-pin-command.js

@@ -10,6 +10,7 @@ export const pinCommand = (messenger) => {
     const durations = messenger.pinDurations?.length ? messenger.pinDurations : undefined;
     const command = annotate(new Command("pin"), {
         effects: REMOTE_WRITE,
+        output: { entity: "message_pin" },
         examples: [
             `${tool} messages pin <chat> <message>`,
             ...(quiet ? [`${tool} messages pin <chat> <message> --notify`] : []),
@@ -38,6 +39,7 @@ export const pinCommand = (messenger) => {
 };
 export const unpinCommand = (messenger) => annotate(new Command("unpin"), {
     effects: REMOTE_WRITE,
+    output: { entity: "message_pin" },
     examples: [`${messenger.app.command} messages unpin <chat> <message>`],
 })
     .description("unpin a message in a chat")
@@ -53,6 +55,7 @@ export const starCommands = (messenger) => [true, false].map((starred) => {
     const name = starred ? "star" : "unstar";
     return annotate(new Command(name), {
         effects: REMOTE_WRITE,
+        output: { entity: "message_star" },
         examples: [`${messenger.app.command} messages ${name} <chat> <message>`],
     })
         .description(starred ? "star a message, so it is easy to find again; only you see the star" : "take the star off a message")

package/dist/cli/messenger/messages-send-command.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { sendTime } from "../../domain/send-time.js";
 import { threadIdOf } from "../../domain/thread.js";
 import { typedSendAs } from "../../sends/send-as.js";
@@ -15,10 +15,14 @@ import { readAll } from "./stdin.js";
  * of what this profile tried to send, and it never holds the text.
  */
 export const HTML_HELP = "the text is HTML: <b>, <i>, <a href>, <code>";
+const collect = (value, previous) => [...previous, value];
+/** The empty list as its default is what tells the MCP tool to take a list for it. */
+const repeatable = (flags, description) => new Option(flags, description).argParser(collect).default([], "none");
 export const sendCommand = (messenger) => {
     const send = annotate(new Command("send"), {
         examples: [`${messenger.app.command} personal messages send "Book club" "The meeting starts at 10."`],
         effects: REMOTE_WRITE,
+        output: { entity: "message_write" },
     })
         .description("send a text message; without [text], the text is read from stdin")
         .argument("<chat>", messenger.chatArgument)
@@ -37,9 +41,9 @@ export const sendCommand = (messenger) => {
     send
         .option("--no-preview", "no preview card for a link in the text")
         .option("--md", "read this messenger's Markdown; see its formatting guide for supported syntax")
-        .option("--file <file>", "attach a file; the text becomes its caption")
-        .option("--photo <file>", "attach a .jpg, .png or .webp as a photo; the text becomes its caption")
-        .option("--as-file", "send the --file as a file to download, a video included")
+        .addOption(repeatable("--file <file>", "attach a file; the text becomes its caption; repeat it for an album"))
+        .addOption(repeatable("--photo <file>", "attach a .jpg, .png or .webp as a photo; the text becomes its caption; repeat it for an album"))
+        .option("--as-file", "send each --file as a file to download, a video included")
         .option("--voice <file>", "send an Ogg Opus file as a voice message, alone, with no text")
         .addOption(ownerOnlyOption("--allow-any-file", "send a file even from credential folders or this CLI's own folders"));
     if (messenger.scheduledSends !== false)
@@ -75,8 +79,8 @@ const sendText = async (command, messenger, chat, text) => {
         throw new CliError("validation_error", "--comment-to needs the post's message id");
     const read = { app: messenger.app, env: context.env, anyFile: allowAnyFile === true };
     const attachments = await readAttachments({
-        ...(photo === undefined ? {} : { photo }),
-        ...(file === undefined ? {} : { file }),
+        photo,
+        file,
         ...(voice === undefined ? {} : { voice }),
         ...(text === undefined ? {} : { text }),
         asFile: asFile === true,

package/dist/cli/messenger/metadata-command.js

@@ -8,7 +8,11 @@ import { messengerContext, refuseLocalWrite } from "./context.js";
 export const metadataCommand = (messenger) => {
     const tool = messenger.app.command;
     const command = new Command("metadata").description("cached group/channel descriptions for local automatic tags");
-    annotate(command.command("get"), { effects: LOCAL_READ, examples: [`${tool} metadata get --chat 7`] })
+    annotate(command.command("get"), {
+        output: { entity: "chat_metadata" },
+        effects: LOCAL_READ,
+        examples: [`${tool} metadata get --chat 7`],
+    })
         .description("a stored chat's cached description, as automatic tags read it")
         .requiredOption("--chat <chat>", "a stored chat")
         .action(async function () {
@@ -17,6 +21,7 @@ export const metadataCommand = (messenger) => {
         renderAnswer(this, context, itemOf(snakeKeys(await context.withServices((services) => services.metadata.get(chat)))));
     });
     annotate(command.command("refresh"), {
+        output: { entity: "chat_metadata_refresh" },
         effects: FETCH,
         examples: [`${tool} metadata refresh --chat 7 --chat 8`, `${tool} metadata refresh --only-missing --limit 20`],
     })

package/dist/cli/messenger/models-command.js

@@ -76,7 +76,6 @@ export const modelsCommand = (messenger) => {
         });
     });
     reachesOtherService(annotate(audio.command("download"), {
-        mcp: false,
         effects: FETCH,
         output: { entity: "model" },
         examples: [`${tool} models audio download parakeet-v3`],
@@ -124,7 +123,6 @@ export const modelsCommand = (messenger) => {
         });
     });
     reachesOtherService(annotate(text.command("download"), {
-        mcp: false,
         effects: FETCH,
         output: { entity: "model" },
         examples: [`${tool} models text download ${DEFAULT_TEXT_MODEL}`],
@@ -145,7 +143,11 @@ export const modelsCommand = (messenger) => {
         }, { unbounded: true });
     });
     const key = text.command("key").description("API keys for embedding and analysis providers");
-    grantsAuthority(annotate(key.command("set"), { effects: LOCAL_WRITE, examples: [`${tool} models text key set openai`] }))
+    grantsAuthority(annotate(key.command("set"), {
+        effects: LOCAL_WRITE,
+        output: { entity: "model_key", view: "stored" },
+        examples: [`${tool} models text key set openai`],
+    }))
         .argument("<provider>", "openai, anthropic, or the host of a --base-url server that wants a key")
         .description("store a key, typed at a hidden prompt or piped on stdin — never as an argument")
         .action(async function (provider) {
@@ -159,7 +161,11 @@ export const modelsCommand = (messenger) => {
             renderAnswer(this, context, itemOf({ provider, stored: source }));
         });
     });
-    grantsAuthority(annotate(key.command("remove"), { effects: LOCAL_WRITE, examples: [`${tool} models text key remove openai`] }))
+    grantsAuthority(annotate(key.command("remove"), {
+        effects: LOCAL_WRITE,
+        output: { entity: "model_key", view: "removed" },
+        examples: [`${tool} models text key remove openai`],
+    }))
         .argument("<provider>", "openai, anthropic, or a server's host")
         .description("forget a stored key")
         .action(async function (provider) {
@@ -189,7 +195,6 @@ export const imageModelsCommand = (messenger) => {
         });
     });
     reachesOtherService(annotate(image.command("download"), {
-        mcp: false,
         effects: FETCH,
         output: { entity: "model" },
         examples: [`${tool} images models download ${DEFAULT_IMAGE_MODEL}`],

package/dist/cli/messenger/polls-command.js

@@ -23,6 +23,7 @@ export const pollsCommand = (messenger) => {
         ? "read a poll, vote in it, create one"
         : "read a poll, vote in it, close your own, create one");
     annotate(polls.command("show"), {
+        output: { entity: "poll" },
         effects: REMOTE_READ,
         examples: [`${messenger.app.command} personal polls show "Book club" 101`],
     })
@@ -67,6 +68,7 @@ export const pollsCommand = (messenger) => {
             }), lines(({ voted_at, person_id, name, answers }) => [voted_at, name ?? person_id, answers.join(",")].join("  ")));
         }));
     annotate(polls.command("vote"), {
+        output: { entity: "poll_change" },
         effects: REMOTE_WRITE,
         examples: [`${messenger.app.command} personal polls vote "Book club" 101 0`],
     })
@@ -95,6 +97,7 @@ export const pollsCommand = (messenger) => {
     });
     if (messenger.pollClose !== false)
         annotate(polls.command("close"), {
+            output: { entity: "poll_change" },
             effects: REMOTE_WRITE,
             examples: [`${messenger.app.command} personal polls close "Book club" 101`],
         })
@@ -107,6 +110,7 @@ export const pollsCommand = (messenger) => {
             renderAnswer(this, context, itemOf(snakeKeys(closed)));
         });
     const create = annotate(polls.command("create"), {
+        output: { entity: "message_write" },
         effects: REMOTE_WRITE,
         examples: [`${messenger.app.command} personal polls create "Book club" "Which day?" Monday Tuesday`],
     })

package/dist/cli/messenger/private-people-command.js

@@ -14,7 +14,7 @@ const NOTES_QUERY = unfilteredQuery("contact_note", contactNote);
 const everyNote = (command, items) => listOf(command, { items, limit: Math.max(1, items.length), has_more: false });
 export const privatePeopleCommands = (messenger) => {
     const alias = new Command("alias").description("a private local display name in the selected account");
-    annotate(alias.command("set"), { effects: LOCAL_WRITE })
+    annotate(alias.command("set"), { effects: LOCAL_WRITE, output: { entity: "contact_alias" } })
         .description("your own name for a person in this account; kept on this machine, never sent")
         .argument("<person>", "the person's id, reference or known name")
         .argument("<alias>", "the private name to use for this person")
@@ -23,7 +23,7 @@ export const privatePeopleCommands = (messenger) => {
         refuseLocalWrite(context, messenger.app.command, "contacts.alias.set");
         renderAnswer(this, context, itemOf(snakeKeys(await context.withServices((services) => services.privatePeople.alias(person, value)))));
     });
-    annotate(alias.command("rm"), { effects: LOCAL_WRITE })
+    annotate(alias.command("rm"), { effects: LOCAL_WRITE, output: { entity: "contact_alias" } })
         .description("drop your local name for a person; their own name shows again")
         .argument("<person>", "the person's id, reference or known name")
         .action(async function (person) {
@@ -78,7 +78,7 @@ export const privatePeopleCommands = (messenger) => {
             renderAnswer(this, context, itemOf(saved));
         });
     }
-    annotate(notes.command("remove"), { effects: LOCAL_WRITE })
+    annotate(notes.command("remove"), { effects: LOCAL_WRITE, output: { entity: "contact_note_removal" } })
         .description("delete one private note on a person")
         .argument("<person>", "the person's id, reference or known name")
         .argument("<id>", "the note id from contacts notes list")

package/dist/cli/messenger/rankings-command.js

@@ -12,6 +12,7 @@ import { renderAnswer } from "../envelope.js";
 import { positiveCount } from "../paging.js";
 import { messengerContext } from "./context.js";
 import { syncOptions, syncRequest } from "./search-sync-options.js";
+import { statisticsQuery, withStatisticsQuery } from "./statistics-query.js";
 import { evidenceAnswer, rankingAnswer, refuseJsonl } from "./stats-answers.js";
 const selectionOf = (value) => {
     if (Buffer.byteLength(value) > RANKING_SELECTION_BYTES)
@@ -35,28 +36,22 @@ export const rankingsTopCommand = (messenger, target) => {
         "engaging",
     ]))
         .option("--weights <json>", "the complete component weights; replaces preset weights")
-        .addOption(new Option("--message-kind <kind>", "select proven all, posts or comments before ranking").choices([
-        "all",
-        "posts",
-        "comments",
-    ]))
-        .option("--chat <chat>", `only this chat; ${messenger.chatArgument}`)
         .option("--source <accounts>", "every held account of this messenger; personal, bots or all")
         .option("--timezone <zone>", "the IANA timezone for dates and active days")
-        .option("--exact", "bare words match exact forms rather than stems")
         .option("--limit <n>", "ranked rows, 1–100", positiveCount("--limit"))
         .option("--saved <name|id>", "run a saved query or ranking run; typed options replace stored options");
-    if (target === "contacts")
-        command.option("--min-messages <n>", "minimum selected messages per author; 1, or 5 for engaging", positiveCount("--min-messages"));
+    const report = target === "contacts" ? "contacts-top" : "messages-top";
+    withStatisticsQuery(command, report);
     command.action(async function (words) {
+        const filters = statisticsQuery(words, report);
         const context = messengerContext(this, messenger);
         refuseJsonl(context.format);
         const options = this.opts();
         const { saved, ...typed } = options;
-        let params = { ...typed, ...(words.length ? { text: words.join(" ") } : {}) };
+        let params = { ...typed, ...filters };
         const found = await context.withServices(async (services) => {
             if (saved !== undefined)
-                params = (await services.searches.resolve(saved, { ...params, text: words.join(" ") })).params;
+                params = (await services.searches.resolve(saved, { ...params, text: filters.text ?? "" })).params;
             if (params.target !== undefined && params.target !== target)
                 throw new CliError("validation_error", "saved ranking belongs to a different target");
             if (params.newest || params.context)

package/dist/cli/messenger/reactions-command.js

@@ -8,6 +8,7 @@ export const reactionsCommand = (messenger) => {
     const reactions = new Command("reactions").description("react to messages");
     annotate(reactions.command("add"), {
         effects: REMOTE_WRITE,
+        output: { entity: "reaction_change" },
         examples: [`${messenger.app.command} personal reactions add "Book club" 101 👍`],
     })
         .description("put your reaction on a message; it replaces the one you had")
@@ -21,6 +22,7 @@ export const reactionsCommand = (messenger) => {
     });
     annotate(reactions.command("remove"), {
         effects: REMOTE_WRITE,
+        output: { entity: "reaction_change" },
         examples: [`${messenger.app.command} personal reactions remove "Book club" 101`],
     })
         .description("take your reaction off a message")

package/dist/cli/messenger/recipients-query.d.ts

@@ -0,0 +1,5 @@
+import { type QueryRegistry } from "@wirecat/cli-base/query";
+import type { RecipientFilter } from "../../sends/recipients.js";
+import { type QueryWords } from "../list-query.js";
+export declare const RECIPIENTS_QUERY: QueryRegistry;
+export declare const recipientFilter: (words: QueryWords) => RecipientFilter;

package/dist/cli/messenger/recipients-query.js

@@ -0,0 +1,18 @@
+import { queryFieldsOf } from "@wirecat/cli-base/query";
+import { recipient } from "../../entities/index.js";
+import { queryTerms } from "../list-query.js";
+export const RECIPIENTS_QUERY = {
+    entity: "recipient",
+    backend: "native",
+    fields: queryFieldsOf(recipient, {
+        native: ["id", "title"],
+        examples: { id: "id:7", title: 'title:"Book club"' },
+    }).map((field) => field.native
+        ? { ...field, operators: field.operators.filter((operator) => operator === "term" || operator === "phrase") }
+        : field),
+};
+export const recipientFilter = (words) => {
+    const terms = queryTerms(words, RECIPIENTS_QUERY, "recipients list");
+    const id = terms.get("id"), title = terms.get("title");
+    return { ...(id === undefined ? {} : { id }), ...(title === undefined ? {} : { title }) };
+};