@wirecat/cli-core 0.398.0 → 0.400.0

package/dist/entities/listener.js

@@ -0,0 +1,46 @@
+import * as v from "valibot";
+import { chatEvent } from "./chat-event.js";
+import { count, id, text, time } from "./fields.js";
+import { member } from "./member.js";
+import { message } from "./message.js";
+import { pollVote } from "./poll-vote.js";
+const reactions = v.unwrap(v.unwrap(message.entries.reactions));
+const observation = v.strictObject({
+    value: v.pipe(v.number(), v.minValue(0)),
+    observed_at: time,
+    source: v.picklist(["remote_fetch", "remote_update"]),
+    reactions: v.optional(reactions),
+});
+/** Live messages retain counter observations and an explicit false star when the source supplies them. */
+export const watchedMessage = v.strictObject({
+    ...message.entries,
+    starred: v.optional(v.boolean()),
+    counter_observations: v.optional(v.partial(v.strictObject({ views: observation, reactions: observation, comments: observation }))),
+});
+const target = { chat_id: id, chat_title: v.nullable(text), message_id: id };
+export const messageEvent = v.variant("event", [
+    v.strictObject({ event: v.picklist(["message", "edit"]), message: watchedMessage }),
+    v.strictObject({ event: v.literal("delete"), ...target, chat_id: v.nullable(id) }),
+    v.strictObject({ event: v.literal("reaction"), ...target, reactions, counter_observation: v.optional(observation) }),
+    v.strictObject({ event: v.literal("vote"), ...target, vote: pollVote }),
+    v.strictObject({
+        event: v.literal("person_reaction"),
+        ...target,
+        reaction: v.strictObject({ person: member, own: v.boolean(), reaction: v.nullable(text), reacted_at: time }),
+    }),
+    v.strictObject({ event: v.literal("star"), ...target, starred: v.boolean() }),
+    v.strictObject({ event: v.literal("delivery"), ...target, delivery: v.unwrap(message.entries.delivery), at: time }),
+    v.strictObject({ event: v.literal("chat_event"), chat_id: id, chat_title: v.nullable(text), change: chatEvent }),
+]);
+export const watchItem = v.union([watchedMessage, messageEvent]);
+const totals = v.record(text, count);
+export const serveSummary = v.strictObject({
+    profile: text,
+    started_at: time,
+    stopped_at: time,
+    kept: totals,
+    replies: v.optional(v.strictObject({ sent: totals, skipped: totals, tasks: v.optional(totals) })),
+    members: v.optional(v.strictObject({ fetched: count, failed: count })),
+    stems: v.optional(v.strictObject({ stemmed: count })),
+    tasks: v.optional(v.strictObject({ added: count, closed: count, review: count })),
+});

package/dist/entities/media-archive.d.ts

@@ -0,0 +1,43 @@
+import * as v from "valibot";
+export declare const mediaArchive: v.StrictObjectSchema<{
+    readonly directory: v.StringSchema<undefined>;
+    readonly chats: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly saved: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly existing: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly complete: v.BooleanSchema<undefined>;
+}, undefined>;
+export declare const mediaArchiveCheck: v.StrictObjectSchema<{
+    readonly valid: v.BooleanSchema<undefined>;
+    readonly checked: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly files: v.ArraySchema<v.StrictObjectSchema<{
+        readonly path: v.StringSchema<undefined>;
+        readonly valid: v.BooleanSchema<undefined>;
+        readonly archive_directory: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const mediaArchiveMove: v.StrictObjectSchema<{
+    readonly directory: v.StringSchema<undefined>;
+    readonly archive_directory: v.StringSchema<undefined>;
+    readonly before_time: 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 selected: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly selected_bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly moved: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly moved_bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly already_archived: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly undated: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly complete: v.BooleanSchema<undefined>;
+    readonly dry_run: v.BooleanSchema<undefined>;
+}, undefined>;
+export declare const mediaArchiveTimer: v.UnionSchema<[v.StrictObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly installed: v.BooleanSchema<undefined>;
+    readonly service_path: v.StringSchema<undefined>;
+    readonly timer_path: v.StringSchema<undefined>;
+    readonly active: v.BooleanSchema<undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly installed: v.BooleanSchema<undefined>;
+    readonly service_path: v.StringSchema<undefined>;
+    readonly timer_path: v.StringSchema<undefined>;
+    readonly action: v.PicklistSchema<["install", "start", "stop", "uninstall"], undefined>;
+}, undefined>], undefined>;

package/dist/entities/media-archive.js

@@ -0,0 +1,32 @@
+import * as v from "valibot";
+import { count, text, time } from "./fields.js";
+export const mediaArchive = v.strictObject({
+    directory: text,
+    chats: count,
+    saved: count,
+    existing: count,
+    complete: v.boolean(),
+});
+export const mediaArchiveCheck = v.strictObject({
+    valid: v.boolean(),
+    checked: count,
+    files: v.array(v.strictObject({ path: text, valid: v.boolean(), archive_directory: v.optional(text) })),
+});
+export const mediaArchiveMove = v.strictObject({
+    directory: text,
+    archive_directory: text,
+    before_time: time,
+    selected: count,
+    selected_bytes: count,
+    moved: count,
+    moved_bytes: count,
+    already_archived: count,
+    undated: count,
+    complete: v.boolean(),
+    dry_run: v.boolean(),
+});
+const timer = { name: text, installed: v.boolean(), service_path: text, timer_path: text };
+export const mediaArchiveTimer = v.union([
+    v.strictObject({ ...timer, active: v.boolean() }),
+    v.strictObject({ ...timer, action: v.picklist(["install", "start", "stop", "uninstall"]) }),
+]);

package/dist/entities/meeting-task-proposal.d.ts

@@ -0,0 +1,14 @@
+import * as v from "valibot";
+/** `meetings task-proposal`: the task a meeting line would become; nothing is created. */
+export declare const meetingTaskProposal: v.StrictObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly source: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly source_kind: v.LiteralSchema<"meeting", undefined>;
+    readonly group: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly account_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    readonly kind: v.PicklistSchema<readonly ["question", "request", "mention", "promise"], undefined>;
+    readonly preview: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly revision: v.NullableSchema<v.PicklistSchema<["current", "superseded"], undefined>, undefined>;
+    readonly applied: v.LiteralSchema<false, undefined>;
+    readonly persistence: v.LiteralSchema<"proposal-only", undefined>;
+}, undefined>;

package/dist/entities/meeting-task-proposal.js

@@ -0,0 +1,19 @@
+import { reference } from "@wirecat/cli-base/standards";
+import * as v from "valibot";
+import { TASK_KINDS } from "../tasks/index.js";
+const text = v.string();
+const id = v.pipe(v.number(), v.integer(), v.minValue(1));
+const revision = v.picklist(["current", "superseded"]);
+/** `meetings task-proposal`: the task a meeting line would become; nothing is created. */
+export const meetingTaskProposal = v.strictObject({
+    id: text,
+    source: reference,
+    source_kind: v.literal("meeting"),
+    group: reference,
+    account_id: id,
+    kind: v.picklist(TASK_KINDS),
+    preview: v.nullable(text),
+    revision: v.nullable(revision),
+    applied: v.literal(false),
+    persistence: v.literal("proposal-only"),
+});

package/dist/entities/meeting.d.ts

@@ -1 +1 @@
-export { meeting, meetingDetails, meetingHit, meetingProjectEvidence, meetingSummary, meetingTranscript, } from "../meetings/index.js";
+export { meeting, meetingDetails, meetingHit, meetingLink, meetingParticipants, meetingPassage, meetingProjectEvidence, meetingReview, meetingSpeaker, meetingStats, meetingSummary, meetingTranscript, } from "../meetings/index.js";

package/dist/entities/meeting.js

@@ -1 +1 @@
-export { meeting, meetingDetails, meetingHit, meetingProjectEvidence, meetingSummary, meetingTranscript, } from "../meetings/index.js";
+export { meeting, meetingDetails, meetingHit, meetingLink, meetingParticipants, meetingPassage, meetingProjectEvidence, meetingReview, meetingSpeaker, meetingStats, meetingSummary, meetingTranscript, } from "../meetings/index.js";

package/dist/entities/mention.d.ts

@@ -0,0 +1,63 @@
+import * as v from "valibot";
+/** Mention and place IDs retain the numeric identifiers returned by the local store. */
+export declare const mention: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly kind: v.PicklistSchema<["phone", "email", "url", "document", "person-name", "place"], undefined>;
+    readonly value: v.StringSchema<undefined>;
+    readonly domain: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly confidence: v.NumberSchema<undefined>;
+    readonly status: v.PicklistSchema<["found", "linked", "dismissed"], undefined>;
+    readonly field: v.StringSchema<undefined>;
+    readonly author: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly target: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    readonly sent_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 found_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 written: v.StringSchema<undefined>;
+    readonly locator: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+}, undefined>;
+export declare const mentionDetails: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly kind: v.PicklistSchema<["phone", "email", "url", "document", "person-name", "place"], undefined>;
+    readonly value: v.StringSchema<undefined>;
+    readonly domain: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly confidence: v.NumberSchema<undefined>;
+    readonly status: v.PicklistSchema<["found", "linked", "dismissed"], undefined>;
+    readonly field: v.StringSchema<undefined>;
+    readonly author: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly target: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    readonly sent_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 found_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 written: v.StringSchema<undefined>;
+    readonly locator: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly before: v.StringSchema<undefined>;
+    readonly after: v.StringSchema<undefined>;
+    readonly same_value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly candidates: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+}, undefined>;
+export declare const mentionDomain: v.StrictObjectSchema<{
+    readonly domain: v.StringSchema<undefined>;
+    readonly links: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly chats: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly first_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 last_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 place: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly address: v.StringSchema<undefined>;
+    readonly mentions: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export declare const mentionDecision: v.StrictObjectSchema<{
+    readonly kind: v.PicklistSchema<["phone", "email", "url", "document", "person-name", "place"], undefined>;
+    readonly value: v.StringSchema<undefined>;
+    readonly status: v.PicklistSchema<["found", "linked", "dismissed"], undefined>;
+    readonly target: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    readonly mentions: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export declare const mentionRebuild: v.StrictObjectSchema<{
+    readonly messages: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly attachments: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly documents: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly notes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly emails: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly mentions: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;

package/dist/entities/mention.js

@@ -0,0 +1,44 @@
+import * as v from "valibot";
+import { count, reference, text, time } from "./fields.js";
+const kind = v.picklist(["phone", "email", "url", "document", "person-name", "place"]);
+const status = v.picklist(["found", "linked", "dismissed"]);
+/** Mention and place IDs retain the numeric identifiers returned by the local store. */
+export const mention = v.strictObject({
+    id: count,
+    kind,
+    value: text,
+    domain: v.nullable(text),
+    confidence: v.number(),
+    status,
+    field: text,
+    author: v.nullable(text),
+    target: v.nullable(reference),
+    sent_at: time,
+    found_at: time,
+    written: text,
+    locator: reference,
+});
+export const mentionDetails = v.strictObject({
+    ...mention.entries,
+    before: text,
+    after: text,
+    same_value: count,
+    candidates: v.array(reference),
+});
+export const mentionDomain = v.strictObject({ domain: text, links: count, chats: count, first_at: time, last_at: time });
+export const place = v.strictObject({ id: count, address: text, mentions: count });
+export const mentionDecision = v.strictObject({
+    kind,
+    value: text,
+    status,
+    target: v.nullable(reference),
+    mentions: count,
+});
+export const mentionRebuild = v.strictObject({
+    messages: count,
+    attachments: count,
+    documents: count,
+    notes: count,
+    emails: count,
+    mentions: count,
+});

package/dist/entities/message-change.d.ts

@@ -0,0 +1,19 @@
+import * as v from "valibot";
+export declare const messagePin: v.StrictObjectSchema<{
+    readonly operation_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly chat_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly message_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly pinned: v.BooleanSchema<undefined>;
+}, undefined>;
+export declare const messageStar: v.StrictObjectSchema<{
+    readonly operation_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly chat_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly message_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly starred: v.BooleanSchema<undefined>;
+}, undefined>;
+export declare const messageDeletion: v.StrictObjectSchema<{
+    readonly operation_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly chat_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly deleted: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    readonly for_everyone: v.BooleanSchema<undefined>;
+}, undefined>;

package/dist/entities/message-change.js

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+import { id } from "./fields.js";
+const operated = { operation_id: id, chat_id: id };
+export const messagePin = v.strictObject({ ...operated, message_id: id, pinned: v.boolean() });
+export const messageStar = v.strictObject({ ...operated, message_id: id, starred: v.boolean() });
+export const messageDeletion = v.strictObject({ ...operated, deleted: v.array(id), for_everyone: v.boolean() });