@wirecat/cli-core 0.399.0 → 0.401.0

package/dist/entities/contact-context.js

@@ -0,0 +1,191 @@
+import * as v from "valibot";
+import { chat } from "./chat.js";
+import { linkedPerson } from "./contact-activity.js";
+import { count, id, reference, text, time } from "./fields.js";
+import { message } from "./message.js";
+const contextPerson = v.strictObject({ ...linkedPerson.entries, provider: text, id });
+const contextMessage = v.strictObject({
+    locator: reference,
+    provider: text,
+    account: id,
+    chat_id: id,
+    chat_title: v.nullable(text),
+    id,
+    timestamp: time,
+    sender_id: v.nullable(id),
+    sender_name: v.nullable(text),
+    outgoing: v.nullable(v.boolean()),
+    text,
+});
+const sharedChat = v.strictObject({
+    provider: text,
+    account: id,
+    chat_id: id,
+    title: v.nullable(text),
+    kind: chat.entries.kind,
+    last_message_at: v.nullable(time),
+});
+const context = v.strictObject({
+    person: contextPerson,
+    shared: v.array(sharedChat),
+    last: v.strictObject({
+        from_them: v.nullable(contextMessage),
+        from_me: v.nullable(contextMessage),
+        from_them_anywhere: v.nullable(contextMessage),
+    }),
+    recent: v.strictObject({ direct: v.array(contextMessage), groups: v.array(contextMessage) }),
+    mentions: v.array(contextMessage),
+    limits: v.strictObject({ messages: count, bytes: count }),
+    complete: v.boolean(),
+    not_read: v.array(v.strictObject({
+        provider: text,
+        account: id,
+        chat_id: id,
+        title: v.nullable(text),
+        reason: v.picklist(["not_fetched", "partial"]),
+    })),
+});
+const shortMessage = v.strictObject({ at: time, text, transcript: v.optional(text) });
+const identifiedMessage = v.strictObject({
+    ...shortMessage.entries,
+    id,
+    locator: reference,
+    sender_id: v.nullable(id),
+    reply_to: v.nullable(id),
+});
+const counterObservation = v.strictObject({
+    value: v.number(),
+    observed_at: time,
+    source: v.picklist(["remote_fetch", "remote_update"]),
+    reactions: v.optional(message.entries.reactions.wrapped.wrapped),
+});
+const { reply_addresses: mailReplyTo, ...mailFields } = message.entries.email.wrapped.entries;
+const fullMessage = v.strictObject({
+    ...v.pick(message, [
+        "id",
+        "chat_id",
+        "chat_title",
+        "excerpt",
+        "sender_id",
+        "sender_name",
+        "sender_username",
+        "mentions",
+        "sender_is_chat",
+        "timestamp",
+        "edited_at",
+        "text",
+        "outgoing",
+        "attachments",
+        "reply_to",
+        "reply_to_id",
+        "forwarded_from",
+        "thread_id",
+        "thread_root_id",
+        "scheduled_for",
+        "provider_metadata",
+        "delivery",
+    ]).entries,
+    reactions: v.nullable(message.entries.reactions.wrapped.wrapped),
+    starred: v.optional(v.boolean()),
+    email: v.optional(v.strictObject({ ...mailFields, reply_to: mailReplyTo })),
+    counter_observations: v.optional(v.partial(v.strictObject({
+        views: counterObservation,
+        reactions: counterObservation,
+        comments: counterObservation,
+    }))),
+    ...shortMessage.entries,
+    locator: reference,
+});
+export const contactMessages = v.strictObject({
+    person: v.strictObject({ uid: id, provider: text, id, name: v.nullable(text) }),
+    chats: v.array(v.strictObject({
+        chat: v.pick(chat, ["id", "title", "kind"]),
+        messages: v.array(v.union([shortMessage, identifiedMessage, fullMessage])),
+        complete: v.boolean(),
+        more: v.boolean(),
+    })),
+    limits: v.strictObject({ messages: count }),
+});
+/** --chat returns selected message windows; without it the result is the cross-account context. */
+export const contactContext = v.union([context, contactMessages]);
+const coverage = v.strictObject({
+    included: count,
+    has_more: v.boolean(),
+    cut_by: v.nullable(v.picklist(["limit", "bytes"])),
+});
+const meetingCue = v.strictObject({
+    reference,
+    fingerprint: text,
+    transcript_id: count,
+    content_hash: v.nullable(text),
+    position: count,
+    start_ms: count,
+    end_ms: count,
+    speaker_participant_id: v.nullable(count),
+    speaker_name: v.nullable(text),
+    text,
+    revision: v.picklist(["current", "superseded"]),
+});
+export const contactPreparation = v.strictObject({
+    ...context.entries,
+    prepare: v.strictObject({
+        waiting: v.array(v.strictObject({
+            provider: text,
+            account: id,
+            chat_id: id,
+            title: v.nullable(text),
+            message: contextMessage,
+            partial: v.boolean(),
+        })),
+        tasks: v.array(v.strictObject({
+            ref: reference,
+            title: text,
+            role: text,
+            due_at: v.nullable(time),
+            project: reference,
+            source: v.nullable(reference),
+            created_at: time,
+        })),
+        facts: v.array(v.strictObject({
+            ref: reference,
+            type: text,
+            statement: text,
+            subject: v.nullable(reference),
+            project: v.nullable(reference),
+            updated_at: time,
+        })),
+        notes: v.array(v.strictObject({ ref: reference, title: v.nullable(text), text, revision: count, updated_at: time })),
+        meetings: v.array(v.strictObject({
+            reference,
+            cues: v.array(meetingCue),
+            cue_coverage: v.strictObject({ included: count, omitted: v.nullable(count), has_more: v.boolean() }),
+        })),
+        limits: v.strictObject({ items: count, bytes: count }),
+        coverage: v.strictObject({
+            waiting: v.strictObject({
+                ...coverage.entries,
+                rule: v.literal("their message is the newest the store holds in a one-to-one chat"),
+            }),
+            tasks: v.strictObject({
+                ...coverage.entries,
+                selection: v.literal("open, assigned to them in any role"),
+                accounts: v.array(text),
+            }),
+            facts: v.strictObject({
+                ...coverage.entries,
+                selection: v.literal("accepted, about them or a project they are a member of"),
+            }),
+            notes: v.strictObject({
+                ...coverage.entries,
+                selection: v.literal("written by you, about them"),
+                withheld: v.optional(v.literal("contacts.notes.list")),
+            }),
+            meetings: v.strictObject({
+                ...coverage.entries,
+                read: v.literal("every account of the store that saw them"),
+                accounts: v.array(text),
+                pending: count,
+            }),
+        }),
+    }),
+});

package/dist/entities/contact-write.d.ts

@@ -0,0 +1,22 @@
+import * as v from "valibot";
+export declare const contactUpdate: v.StrictObjectSchema<{
+    readonly operation_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly person: v.StrictObjectSchema<{
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly username: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const contactStateChange: v.StrictObjectSchema<{
+    readonly operation_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly person_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>;
+export declare const contactImport: v.StrictObjectSchema<{
+    readonly operation_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly sent: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly recognised: v.ArraySchema<v.StrictObjectSchema<{
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly username: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;

package/dist/entities/contact-write.js

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+import { count, id, text } from "./fields.js";
+const addressBookPerson = v.strictObject({ id, name: v.nullable(text), username: v.nullable(text) });
+export const contactUpdate = v.strictObject({ operation_id: id, person: addressBookPerson });
+export const contactStateChange = v.strictObject({ operation_id: id, person_id: id });
+export const contactImport = v.strictObject({ operation_id: id, sent: count, recognised: v.array(addressBookPerson) });

package/dist/entities/conversation-preparation.d.ts

@@ -0,0 +1,63 @@
+import * as v from "valibot";
+export declare const conversationBuild: v.StrictObjectSchema<{
+    readonly chat: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly messages: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly links: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly conversations: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly built_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 rules_version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export declare const chatEmbedding: v.StrictObjectSchema<{
+    readonly chat: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly model: v.StringSchema<undefined>;
+    readonly embedded: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly skipped: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export declare const conversationPreparation: v.StrictObjectSchema<{
+    readonly model: v.StringSchema<undefined>;
+    readonly model_available: v.BooleanSchema<undefined>;
+    readonly built: v.ArraySchema<v.StrictObjectSchema<{
+        readonly chat: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly messages: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly links: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly conversations: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly built_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 rules_version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    readonly embedded: v.ArraySchema<v.StrictObjectSchema<{
+        readonly chat: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly model: v.StringSchema<undefined>;
+        readonly embedded: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly skipped: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    readonly left: v.ArraySchema<v.StrictObjectSchema<{
+        readonly chat: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly needs: v.PicklistSchema<["build", "embed"], undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const catchUpPreparation: v.StrictObjectSchema<{
+    readonly complete: v.BooleanSchema<undefined>;
+    readonly reason: v.OptionalSchema<v.PicklistSchema<["message_bound", "time_or_abort_bound", "preparation_failed", "pending"], undefined>, undefined>;
+    readonly prepared: v.OptionalSchema<v.StrictObjectSchema<{
+        readonly model: v.StringSchema<undefined>;
+        readonly model_available: v.BooleanSchema<undefined>;
+        readonly built: v.ArraySchema<v.StrictObjectSchema<{
+            readonly chat: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly messages: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly links: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly conversations: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly built_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 rules_version: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>, undefined>;
+        readonly embedded: v.ArraySchema<v.StrictObjectSchema<{
+            readonly chat: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly model: v.StringSchema<undefined>;
+            readonly embedded: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly skipped: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>, undefined>;
+        readonly left: v.ArraySchema<v.StrictObjectSchema<{
+            readonly chat: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly needs: v.PicklistSchema<["build", "embed"], undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;

package/dist/entities/conversation-preparation.js

@@ -0,0 +1,23 @@
+import * as v from "valibot";
+import { count, id, text, time } from "./fields.js";
+export const conversationBuild = v.strictObject({
+    chat: id,
+    messages: count,
+    links: count,
+    conversations: count,
+    built_at: time,
+    rules_version: count,
+});
+export const chatEmbedding = v.strictObject({ chat: id, model: text, embedded: count, skipped: count });
+export const conversationPreparation = v.strictObject({
+    model: text,
+    model_available: v.boolean(),
+    built: v.array(conversationBuild),
+    embedded: v.array(chatEmbedding),
+    left: v.array(v.strictObject({ chat: id, needs: v.picklist(["build", "embed"]) })),
+});
+export const catchUpPreparation = v.strictObject({
+    complete: v.boolean(),
+    reason: v.optional(v.picklist(["message_bound", "time_or_abort_bound", "preparation_failed", "pending"])),
+    prepared: v.optional(conversationPreparation),
+});