@wirecat/cli-core 0.410.0 → 0.412.0

package/dist/entities/index.js

@@ -41,6 +41,7 @@ import { imageEmbedding } from "./image-embedding.js";
 import { inviteLink } from "./invite-link.js";
 import { job } from "./job.js";
 import { joinRequest } from "./join-request.js";
+import { organization, project, reminder } from "./knowledge-lists.js";
 import { botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, callRecord, scheduledJob, stickerInventory, } from "./list-results.js";
 import { messageEvent, serveSummary, watchedMessage, watchItem } from "./listener.js";
 import { mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer } from "./media-archive.js";
@@ -91,7 +92,7 @@ import { topic } from "./topic.js";
  * subset of its fields, never a renamed one. Commands move onto these one by one; until then, a schema
  * is the target, not a description of today's output.
  */
-export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactProfile, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, person, place, poll, pollChange, pollVote, ranking, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
+export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactProfile, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
 export const ENTITIES = {
     sync_progress: syncProgress,
     ...MEETING_RESULT_ENTITIES,
@@ -167,6 +168,9 @@ export const ENTITIES = {
     account_privacy: accountPrivacy,
     account_privacy_change: accountPrivacyChange,
     account_profile: accountProfile,
+    organization,
+    project,
+    reminder,
     bot_profile: botProfile,
     bot_template: botTemplate,
     bot_seen_chat: botSeenChat,

package/dist/entities/knowledge-lists.d.ts

@@ -0,0 +1,28 @@
+import * as v from "valibot";
+export declare const organization: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly kind: v.PicklistSchema<["company", "team", "family", "community"], undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly scope: v.PicklistSchema<["personal", "work"], undefined>;
+    readonly created_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+}, undefined>;
+export declare const project: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly key: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly type: v.PicklistSchema<["work", "client", "personal", "oss", "other"], undefined>;
+    readonly organization_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    readonly scope: v.PicklistSchema<["personal", "work"], undefined>;
+    readonly created_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+}, undefined>;
+export declare const reminder: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly task: v.StringSchema<undefined>;
+    readonly due_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+    readonly timezone: v.StringSchema<undefined>;
+    readonly state: v.PicklistSchema<["pending", "leased", "delivered", "cancelled"], undefined>;
+    readonly revision: v.NumberSchema<undefined>;
+    readonly receipt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;

package/dist/entities/knowledge-lists.js

@@ -0,0 +1,29 @@
+import * as v from "valibot";
+import { id, reference, text, time } from "./fields.js";
+export const organization = v.strictObject({
+    id,
+    ref: reference,
+    kind: v.picklist(["company", "team", "family", "community"]),
+    name: text,
+    scope: v.picklist(["personal", "work"]),
+    created_at: time,
+});
+export const project = v.strictObject({
+    id,
+    ref: reference,
+    key: text,
+    name: text,
+    type: v.picklist(["work", "client", "personal", "oss", "other"]),
+    organization_id: v.nullable(id),
+    scope: v.picklist(["personal", "work"]),
+    created_at: time,
+});
+export const reminder = v.strictObject({
+    id,
+    task: text,
+    due_at: time,
+    timezone: text,
+    state: v.picklist(["pending", "leased", "delivered", "cancelled"]),
+    revision: v.number(),
+    receipt: v.nullable(text),
+});

package/dist/entities/list-results.d.ts

@@ -39,7 +39,7 @@ export declare const botMenuEntry: v.StrictObjectSchema<{
 }, undefined>;
 export declare const botWebhook: v.StrictObjectSchema<{
     readonly url: v.StringSchema<undefined>;
-    readonly types: v.NullableSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly types: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
 }, undefined>;
 export declare const scheduledJob: v.StrictObjectSchema<{
     readonly name: v.StringSchema<undefined>;

package/dist/entities/list-results.js

@@ -26,7 +26,7 @@ export const botAdmin = v.strictObject({
     title: v.nullable(text),
 });
 export const botMenuEntry = v.strictObject({ name: text, description: v.nullable(text) });
-export const botWebhook = v.strictObject({ url: text, types: v.nullable(v.array(text)) });
+export const botWebhook = v.strictObject({ url: text, types: v.optional(v.array(text)) });
 export const scheduledJob = v.strictObject({
     name: text,
     kind: v.picklist(["command", "agent"]),

package/dist/entities/send-attempt.d.ts

@@ -11,7 +11,6 @@ export declare const sendAttempt: v.StrictObjectSchema<{
     readonly key: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly count: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     readonly for_everyone: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-    readonly send_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
     readonly operation_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
     readonly parent_operation_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
     readonly reply_to: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;

package/dist/entities/send-attempt.js

@@ -12,7 +12,6 @@ export const sendAttempt = v.strictObject({
     key: v.optional(text),
     count: v.optional(count),
     for_everyone: v.optional(v.boolean()),
-    send_id: v.optional(id),
     operation_id: v.optional(id),
     parent_operation_id: v.optional(id),
     reply_to: v.optional(id),

package/dist/errors/reasons.d.ts

@@ -7,7 +7,7 @@ export declare const REASONS: ErrorReason[];
  * Detail keys an error from this package may carry, until each is registered on its own reason. Not `cause`:
  * that can hold a provider's or SQLite's raw text.
  */
-export declare const DETAILS: readonly ["allowed", "alternative", "arguments", "at", "available", "batch", "budget", "built", "candidates", "chat", "chat_id", "cli", "complete", "emitted_bytes", "exact", "forum", "guide", "hint", "id", "index", "kind", "limit", "limit_source", "max_bytes", "model", "name", "operation_id", "operation_ids", "text_limit", "store_refused_in", "partial_output", "path", "permission", "person_ids", "previous_chat_id", "profiles", "provider_error", "provider", "recovery", "reference", "remembered", "retry_at", "runtime", "saved", "scheduled_for", "script", "sent", "sent_count", "settlement_failed", "span", "sqlite", "stage", "standing", "state", "stderr", "term", "total", "upgraded", "wanted"];
+export declare const DETAILS: readonly ["contracts", "allowed", "alternative", "arguments", "at", "available", "batch", "budget", "built", "candidates", "chat", "chat_id", "cli", "complete", "emitted_bytes", "exact", "forum", "guide", "hint", "id", "index", "kind", "limit", "limit_source", "max_bytes", "model", "name", "operation_id", "operation_ids", "text_limit", "store_refused_in", "partial_output", "path", "permission", "person_ids", "previous_chat_id", "profiles", "provider_error", "provider", "recovery", "reference", "remembered", "retry_at", "runtime", "saved", "scheduled_for", "script", "sent", "sent_count", "settlement_failed", "span", "sqlite", "stage", "standing", "state", "stderr", "term", "total", "upgraded", "wanted"];
 /** What a CLI adds to the shared registry: its own reasons, and the detail keys its adapters raise. */
 export interface AppErrors {
     reasons?: readonly ErrorReason[];

package/dist/errors/reasons.js

@@ -16,6 +16,12 @@ const QUERY = [
     ["query.topic-scope", "a topic needs its chat in the query"],
 ].map(([reason, message]) => validation(reason, message));
 const OTHERS = [
+    ["model.offline", "permission_error", "downloading a model needs the network; --offline was requested"],
+    [
+        "contract.unacknowledged-override",
+        "configuration_error",
+        "a shared command contract changed without an explicit override",
+    ],
     validation("context.read-budget", "the selected context reads exceed their text or request allowance"),
     validation("meeting-findings.stale", "meeting findings changed since they were read; stage a new batch"),
     validation("meeting-findings.dedicated-review", "review meeting findings through the dedicated findings command"),
@@ -111,6 +117,7 @@ export const REASONS = defineReasons([
  * that can hold a provider's or SQLite's raw text.
  */
 export const DETAILS = [
+    "contracts",
     "allowed",
     "alternative",
     "arguments",

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export { parseMarkdownSpans } from "./domain/markdown-spans.js";
 export type { MessageLink, MessagePermalink } from "./domain/message-link.js";
 export type * from "./domain/models.js";
 export { countedPoll } from "./domain/polls.js";
+export { isKind, KINDS, type Kind, kindIn, kindOf, PROVIDERS, type ProviderEntry, providerNamed, providers, UNKNOWN_PROVIDER, useProviders, } from "./domain/providers.js";
 export type { RankingGraphEvidence, RankingGraphLink } from "./domain/rankings-graph.js";
 export type { RankingComponent, RankingInput, RankingMeasure, RankingOptions, RankingTarget, RankingWeights, ScorePreset, } from "./domain/rankings-options.js";
 export { rankingOptions } from "./domain/rankings-options.js";

package/dist/index.js

@@ -5,6 +5,7 @@ export { formatLocator, isLocator, parseLocator } from "./domain/locator.js";
 export { parseMarkdown } from "./domain/markdown.js";
 export { parseMarkdownSpans } from "./domain/markdown-spans.js";
 export { countedPoll } from "./domain/polls.js";
+export { isKind, KINDS, kindIn, kindOf, PROVIDERS, providerNamed, providers, UNKNOWN_PROVIDER, useProviders, } from "./domain/providers.js";
 export { rankingOptions } from "./domain/rankings-options.js";
 export { canonicalReference, formatReference, parseReference } from "./domain/references.js";
 export { normalizeTag, TAG_TYPES } from "./domain/tags.js";

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

@@ -13,8 +13,8 @@ export interface MeetingCommandDeps {
     write: (value: unknown, format: "json" | "jsonl" | "text") => void;
     now?: () => number;
 }
-export declare const addMeetingCommands: (program: Command, deps: MeetingCommandDeps) => void;
 export { addMeetingPassageCommand, createMeetingPassageCommand, type MeetingPassageFlags, meetingPassageRequest, } from "./passage.js";
 export { addMeetingProjectEvidenceCommand } from "./project-evidence.js";
 export { queryWordsAfterOptions } from "./query-options.js";
 export { addMeetingSearchCommand, createMeetingSearchCommand, type MeetingHitSearch, type MeetingHitSearchOptions, type MeetingSearchFlags, meetingHitSearchRequest, meetingSearchArguments, meetingSearchMeta, validateMeetingHitSearch, } from "./search.js";
+export declare const addMeetingCommands: (program: Command, deps: MeetingCommandDeps) => void;

package/dist/meetings/cli/index.js

@@ -1,6 +1,7 @@
-import { annotate } from "@wirecat/cli-base/commands";
-import { defineQuery, fieldsHelp, timezoneOf, zonedMoment } from "@wirecat/cli-base/query";
+import { annotate, sharedCommand } from "@wirecat/cli-base/commands";
+import { defineQuery, fieldsHelp, parseLucene, timezoneOf, validateQuery, zonedMoment } from "@wirecat/cli-base/query";
 import { InvalidArgumentError, Option } from "commander";
+import { EVENT_QUERY } from "../event-query.js";
 import { exportMeeting } from "../export.js";
 import { importFiles } from "../import.js";
 import { MEETING_QUERY } from "../item.js";
@@ -30,8 +31,10 @@ const date = (text) => {
 const LOCAL_READ = { remote: "none", local: "read" };
 const LOCAL_WRITE = { remote: "none", local: "write" };
 const FETCH = { remote: "read", local: "write" };
-export const addMeetingCommands = (program, deps) => {
-    const group = program.command("meetings").description("stored meetings and their records");
+const addMeetingCommandsDefinition = (program, deps) => {
+    const group = annotate(program.command("meetings").description("stored meetings and their records"), {
+        effects: { remote: "none", local: "none" },
+    });
     const output = (command) => command
         .option("--json", "one JSON value")
         .option("--jsonl", "one JSON object per item")
@@ -143,14 +146,27 @@ export const addMeetingCommands = (program, deps) => {
             throw new MeetingError("validation_error", "file account differs from selected account");
         print(await importFiles(files, deps.store, deps.now?.()), command);
     });
-    output(annotate(program.command("events").description("the owner's stored events").command("list"), {
-        effects: LOCAL_READ,
-        output: { entity: "event" },
-    }).description("list stored events")).action(async (_opts, command) => {
-        print(listed((await deps.store.events()).map(eventItem)), command);
+    const eventList = queryWordsAfterOptions(annotate(program.command("events").description("the owner's stored events"), {
+        effects: { remote: "none", local: "none" },
+    }).command("list"))
+        .description("list stored events")
+        .argument("[query...]", "event id, origin or time fields that narrow the list")
+        .addHelpText("after", `\n${fieldsHelp(EVENT_QUERY, MEETING_QUERY_GUIDE)}`);
+    annotate(eventList, { effects: LOCAL_READ, output: { entity: "event" }, query: EVENT_QUERY });
+    output(eventList).action(async (words, _opts, command) => {
+        const query = words.length
+            ? parseLucene(words.join(" "), { defaultField: "none", command: "events list" })
+            : undefined;
+        if (query)
+            validateQuery(query, EVENT_QUERY, { command: "events list" });
+        if (query && !deps.store.queryEvents)
+            throw new MeetingError("validation_error", "this store cannot filter events");
+        const events = query ? await deps.store.queryEvents?.(query) : await deps.store.events();
+        print(listed((events ?? []).map(eventItem)), command);
     });
 };
 export { addMeetingPassageCommand, createMeetingPassageCommand, meetingPassageRequest, } from "./passage.js";
 export { addMeetingProjectEvidenceCommand } from "./project-evidence.js";
 export { queryWordsAfterOptions } from "./query-options.js";
 export { addMeetingSearchCommand, createMeetingSearchCommand, meetingHitSearchRequest, meetingSearchArguments, meetingSearchMeta, validateMeetingHitSearch, } from "./search.js";
+export const addMeetingCommands = sharedCommand(addMeetingCommandsDefinition);

package/dist/meetings/cli/passage.d.ts

@@ -10,7 +10,6 @@ export interface MeetingPassageFlags {
 }
 export declare const meetingPassageRequest: (reference: string, options: MeetingPassageFlags, signal?: AbortSignal) => MeetingPassageRequest;
 export declare const createMeetingPassageCommand: (program: Command) => Command;
-/** The host fixes account scope, connection lifetime and final rendering/output limits. */
 export declare const addMeetingPassageCommand: (program: Command, deps: {
     read: MeetingPassageReader;
     signal: () => AbortSignal | undefined;

package/dist/meetings/cli/passage.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { annotate } from "@wirecat/cli-base/commands";
+import { annotate, sharedCommand } from "@wirecat/cli-base/commands";
 import { Option } from "commander";
 import { validateMeetingPassage, } from "../passage.js";
 const count = (value) => {
@@ -21,7 +21,7 @@ export const meetingPassageRequest = (reference, options, signal) => {
     signal?.throwIfAborted();
     return input;
 };
-export const createMeetingPassageCommand = (program) => {
+const createMeetingPassageCommandDefinition = (program) => {
     const meetings = program.commands.find((command) => command.name() === "meetings");
     if (!meetings)
         throw new CliError("configuration_error", "meeting command group is unavailable");
@@ -44,7 +44,7 @@ export const createMeetingPassageCommand = (program) => {
     });
 };
 /** The host fixes account scope, connection lifetime and final rendering/output limits. */
-export const addMeetingPassageCommand = (program, deps) => createMeetingPassageCommand(program).action(async (reference, options, command) => {
+const addMeetingPassageCommandDefinition = (program, deps) => createMeetingPassageCommand(program).action(async (reference, options, command) => {
     const globals = command.optsWithGlobals();
     const format = globals.json || globals.jsonl ? "json" : (options.format ?? "text");
     const input = meetingPassageRequest(reference, { ...options, format }, deps.signal());
@@ -52,3 +52,5 @@ export const addMeetingPassageCommand = (program, deps) => createMeetingPassageC
     input.signal?.throwIfAborted();
     deps.output(result, format);
 });
+export const createMeetingPassageCommand = sharedCommand(createMeetingPassageCommandDefinition);
+export const addMeetingPassageCommand = sharedCommand(addMeetingPassageCommandDefinition);

package/dist/meetings/cli/project-evidence.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { annotate } from "@wirecat/cli-base/commands";
+import { annotate, sharedCommand } from "@wirecat/cli-base/commands";
 import { fieldsHelp } from "@wirecat/cli-base/query";
 import { readMeetingProjectEvidence } from "../project-evidence.js";
 import { MEETING_PROJECT_EVIDENCE_QUERY } from "../project-evidence-query.js";
@@ -9,7 +9,7 @@ const integer = (value) => {
         throw new CliError("validation_error", "expected a positive safe integer");
     return Number(value);
 };
-export const addMeetingProjectEvidenceCommand = (program, deps) => {
+const addMeetingProjectEvidenceCommandDefinition = (program, deps) => {
     const group = program.commands.find((command) => command.name() === "meetings");
     if (!group)
         throw new CliError("configuration_error", "meeting command group is unavailable");
@@ -33,3 +33,4 @@ export const addMeetingProjectEvidenceCommand = (program, deps) => {
         output: { entity: "meeting_project_evidence" },
     });
 };
+export const addMeetingProjectEvidenceCommand = sharedCommand(addMeetingProjectEvidenceCommandDefinition);

package/dist/meetings/cli/search.d.ts

@@ -12,6 +12,7 @@ export interface MeetingSearchFlags {
     project?: string;
     tag?: string;
     topic?: string;
+    topicName?: string;
     sinceTime?: number;
     untilTime?: number;
     /** The zone a date or time without one was read in; the parser sets it, since the typed text is gone after. */
@@ -20,14 +21,13 @@ export interface MeetingSearchFlags {
     cursor?: string;
     maxReadBytes?: number;
 }
-/** Shared grammar without an action: a host with other source reports supplies their transport routing. */
-export declare const createMeetingSearchCommand: (program: Command) => Command;
 /** Transport fields become one validated word request before a host opens its selected source. */
 export declare const meetingHitSearchRequest: (query: string, options: MeetingSearchFlags, signal?: AbortSignal) => MeetingHitSearchOptions;
 /** Parsed dates must become ISO values again so the CLI can replay its own continuation. */
 export declare const meetingSearchArguments: (query: string, options: MeetingSearchFlags) => Record<string, unknown>;
 /** What `meta` says about the dates: the zone one without its own was read in, and the window in UTC. */
 export declare const meetingSearchMeta: (options: MeetingSearchFlags) => Pick<Meta, "timezone" | "window">;
+export declare const createMeetingSearchCommand: (program: Command) => Command;
 export declare const addMeetingSearchCommand: (program: Command, deps: {
     search: (query: string, request: MeetingHitSearchOptions, options: MeetingSearchFlags & Record<string, unknown>) => Promise<MeetingSearchPage>;
     signal: () => AbortSignal | undefined;

package/dist/meetings/cli/search.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { annotate } from "@wirecat/cli-base/commands";
+import { annotate, sharedCommand } from "@wirecat/cli-base/commands";
 import { timezoneOf, zonedMoment } from "@wirecat/cli-base/query";
 import { Command } from "commander";
 import { meetingHitsList } from "../answers.js";
@@ -25,7 +25,7 @@ const integer = (value) => {
     return Number(value);
 };
 /** Shared grammar without an action: a host with other source reports supplies their transport routing. */
-export const createMeetingSearchCommand = (program) => {
+const createMeetingSearchCommandDefinition = (program) => {
     let search = program.commands.find((command) => command.name() === "search");
     if (!search) {
         search = new Command("search").description("search the stored resources");
@@ -41,9 +41,9 @@ export const createMeetingSearchCommand = (program) => {
         .option("--person-id <id>", "meetings with a participant linked to this person", integer)
         .option("--event-id <id>", "only meetings linked to this stored event", integer)
         .option("--series-id <id>", "only meetings in this stored series", integer)
-        .option("--project <name>", "meetings confirmed in this project, by name, key or alias")
+        .option("--project <project>", "meetings confirmed in this project, by name, key or alias")
         .option("--tag <name>", "meetings with this tag, by name or alias")
-        .option("--topic <name>", "meetings with this topic, by name or alias")
+        .option("--topic-name <name>", "meetings with this topic, by name or alias")
         .option("--since-time <time>", "meetings starting at or after this ISO 8601 date or time", moment("--since-time", false, readIn))
         .option("--until-time <time>", "meetings starting at or before this ISO 8601 date or time; a date alone covers that whole local day", moment("--until-time", true, readIn))
         .option("--limit <n>", "how many hits, 1 through 1000 (default 100)", integer)
@@ -66,7 +66,7 @@ export const meetingHitSearchRequest = (query, options, signal) => {
         meetingSeriesId: options.seriesId,
         project: options.project,
         tag: options.tag,
-        topic: options.topic,
+        topic: options.topicName ?? options.topic,
         since: options.sinceTime,
         until: options.untilTime,
         limit: options.limit,
@@ -88,7 +88,7 @@ export const meetingSearchArguments = (query, options) => Object.fromEntries(Obj
     series_id: options.seriesId?.toString(),
     project: options.project,
     tag: options.tag,
-    topic: options.topic,
+    topic_name: options.topicName ?? options.topic,
     since_time: options.sinceTime === undefined ? undefined : new Date(options.sinceTime).toISOString(),
     until_time: options.untilTime === undefined ? undefined : new Date(options.untilTime).toISOString(),
     max_read_bytes: options.maxReadBytes ?? 4194304,
@@ -104,7 +104,9 @@ export const meetingSearchMeta = (options) => {
         ...(Object.keys(window).length === 0 ? {} : { window }),
     };
 };
-export const addMeetingSearchCommand = (program, deps) => createMeetingSearchCommand(program).action(async (query, options) => {
+const addMeetingSearchCommandDefinition = (program, deps) => createMeetingSearchCommand(program).action(async (query, options) => {
     const request = meetingHitSearchRequest(query, options, deps.signal());
     deps.output(meetingHitsList(await deps.search(query, request, options), request.limit ?? 100, "search meetings", meetingSearchArguments(query, options), meetingSearchMeta(options)));
 });
+export const createMeetingSearchCommand = sharedCommand(createMeetingSearchCommandDefinition);
+export const addMeetingSearchCommand = sharedCommand(addMeetingSearchCommandDefinition);

package/dist/meetings/event-query.d.ts

@@ -0,0 +1 @@
+export declare const EVENT_QUERY: import("@wirecat/cli-base/query").QueryRegistry;

package/dist/meetings/event-query.js

@@ -0,0 +1,15 @@
+import { defineQuery } from "@wirecat/cli-base/query";
+export const EVENT_QUERY = defineQuery({
+    entity: "event",
+    backend: "sql",
+    fields: [
+        { name: "id", type: "num", operators: ["term", "range"], example: "id:1" },
+        { name: "origin", type: "enum", operators: ["term"], values: ["auto", "owner"], example: "origin:owner" },
+        ...["starts_at", "ends_at", "created_at", "updated_at"].map((name) => ({
+            name,
+            type: "time",
+            operators: ["term", "range"],
+            example: `${name}>=2026-01-01`,
+        })),
+    ],
+});

package/dist/meetings/index.d.ts

@@ -2,6 +2,7 @@ export { MEETING_STEPS, type MeetingDetailsItem, type MeetingHitItem, type Meeti
 export type { MeetingBatchReader } from "./batch.js";
 export type { MeetingContextStore, MeetingEventLinkInput, MeetingEventLinkReceipt, ParticipantPerson, ParticipantPersonInput, ParticipantPersonLinkInput, ParticipantPersonLinkReceipt, } from "./context-store.js";
 export { type MeetingCueIdentity, meetingCueFingerprint } from "./cue-fingerprint.js";
+export { EVENT_QUERY } from "./event-query.js";
 export { linkEvent } from "./events.js";
 export { exportMeeting, type MeetingExport, type MeetingExportFormat, type MeetingExportOptions, serializeVtt, } from "./export.js";
 export { type FindingEvidence, type FindingOutcome, findingHash, MEETING_FINDINGS_KIND, type MeetingFactFinding, type MeetingFinding, type MeetingFindingsInput, type MeetingFindingsReceipt, type MeetingTaskFinding, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";

package/dist/meetings/index.js

@@ -1,5 +1,6 @@
 export { MEETING_STEPS, meetingDetails, meetingHit, meetingHitsList, meetingSummary, meetingTranscript, } from "./answers.js";
 export { meetingCueFingerprint } from "./cue-fingerprint.js";
+export { EVENT_QUERY } from "./event-query.js";
 export { linkEvent } from "./events.js";
 export { exportMeeting, serializeVtt, } from "./export.js";
 export { findingHash, MEETING_FINDINGS_KIND, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";

package/dist/meetings/store.d.ts

@@ -111,6 +111,8 @@ export interface MeetingStore {
     participants(query: string, accountId?: number): Promise<Participant[]>;
     search(query: string, filter?: MeetingFilter): Promise<SearchHit[]>;
     events(): Promise<Event[]>;
+    /** Filters at the store; adapters without this method refuse nonempty event queries. */
+    queryEvents?(query: QueryAst): Promise<Event[]>;
     /** Inclusive overlap; an event with a start but no end occupies its start instant. */
     eventCandidates(filter: EventCandidateFilter): Promise<Event[]>;
     createEvent(input: NewRecord<Event>, now: number): Promise<Event>;

package/dist/meetings/testing/memory.js

@@ -1,5 +1,7 @@
 import { evaluate } from "@wirecat/cli-base/query";
+import { EVENT_QUERY } from "../event-query.js";
 import { MEETING_QUERY, meetingItem } from "../item.js";
+import { eventItem } from "../read-answers.js";
 import { MeetingError, positiveInteger } from "../reads.js";
 const overlap = (start, end, from, to) => start !== null && start <= to && (end ?? start) >= from;
 /** A test store keeps no accounts: every id is an account of the `memory` provider. */
@@ -136,6 +138,9 @@ export const memoryMeetingStore = () => {
         async events() {
             return structuredClone(state.events.filter((e) => e.deletedAt === null));
         },
+        async queryEvents(query) {
+            return structuredClone(state.events.filter((event) => event.deletedAt === null && evaluate(query, EVENT_QUERY.fields, { ...eventItem(event), id: event.id })));
+        },
         async eventCandidates(filter) {
             const series = state.series.find((s) => s.id === filter.meetingSeriesId);
             return structuredClone(state.events.filter((e) => e.deletedAt === null &&

package/dist/search/account-list.d.ts

@@ -24,9 +24,12 @@ export interface ListContext {
         command?: string;
     };
 }
-/** An account as `--source` and a hit name it: a notes folder is `notes:<its id>`, never the store's ulid. */
+/**
+ * An account as `--source` and a hit name it: a notes folder is `notes:<its id>`, never the store's ulid. The kind is
+ * `undefined` for a provider no registry entry names: no search reads it, and `fitting` reports it.
+ */
 export interface ListedAccount extends AccountKey {
-    kind: Kind;
+    kind: Kind | undefined;
 }
 /** One entry of the list as written, a group's member included, and the accounts it named. */
 export interface ListedEntry {

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?: {