@wirecat/cli-core 0.399.0 → 0.401.0

package/dist/entities/store-records.js

@@ -0,0 +1,99 @@
+import * as v from "valibot";
+import { batchResult } from "./batch-result.js";
+import { chat } from "./chat.js";
+import { catchUpPreparation } from "./conversation-preparation.js";
+import { count, id, text, time } from "./fields.js";
+import { job } from "./job.js";
+import { message } from "./message.js";
+import { messageSyncStarted } from "./message-transfer.js";
+const range = v.strictObject({ from: v.number(), to: v.number() });
+export const storeChatStatus = v.strictObject({
+    chat_id: id,
+    title: v.nullable(text),
+    kind: chat.entries.kind,
+    messages: count,
+    oldest_at: v.nullable(time),
+    newest_at: v.nullable(time),
+    last_stored_at: v.nullable(time),
+    held: v.array(range),
+});
+export const storeClear = v.strictObject({
+    cleared: v.boolean(),
+    dry_run: v.optional(v.literal(true)),
+    chats: count,
+    messages: count,
+    left: v.array(v.strictObject({ id, title: v.nullable(text), messages: count })),
+});
+/** Exports answer with message rows, one written file, or an incremental directory receipt. */
+export const storeExport = v.union([
+    message,
+    v.strictObject({
+        path: text,
+        format: v.picklist(["jsonl", "markdown"]),
+        count,
+        encrypted: v.optional(v.literal(true)),
+    }),
+    v.strictObject({
+        path: text,
+        encrypted: v.optional(v.literal(true)),
+        chats: v.array(v.strictObject({ id, title: v.nullable(text), file: v.nullable(text), messages: count, deleted: count })),
+    }),
+]);
+export const storeGapPlan = v.strictObject({
+    version: v.literal(1),
+    scope: v.literal("interior"),
+    account: v.strictObject({ provider: text, account: id }),
+    chat: id,
+    ordering: v.picklist(["id", "time"]),
+    held: v.array(range),
+    gaps: v.array(range),
+    unknown: v.strictObject({ older: v.boolean(), newer: v.literal(true) }),
+    fingerprint: text,
+    limits: v.strictObject({ max_gaps: count, limit: count, time_ms: count, page_size: count }),
+});
+export const storeGapRepair = v.union([
+    messageSyncStarted,
+    v.strictObject({
+        version: v.literal(1),
+        scope: v.literal("interior"),
+        chat: id,
+        before: storeGapPlan,
+        after: storeGapPlan,
+        repaired: v.array(range),
+        fetched: count,
+        requests: count,
+        complete: v.boolean(),
+        prepared: v.optional(catchUpPreparation),
+        stopped: v.optional(v.picklist(["bound", "partial_or_inaccessible", "fetch_failed"])),
+    }),
+]);
+/** Persisted older jobs can lack recovery flags; newer diagnostics remain available. */
+const problem = v.objectWithRest({ code: text, message: text, retryable: v.optional(v.boolean()), retry_after_ms: v.optional(v.number()) }, v.unknown());
+const progress = v.strictObject({
+    job: id,
+    profile: text,
+    done: count,
+    total: v.nullable(count),
+    remaining: v.nullable(count),
+    state: v.picklist(["partial", "complete"]),
+    updated_at: v.nullable(time),
+    cursor_age_ms: v.nullable(count),
+});
+export const storeJobDetails = v.strictObject({
+    ...v.omit(job, ["id", "issue", "error"]).entries,
+    job: id,
+    profile: text,
+    issue: v.optional(problem),
+    error: v.optional(problem),
+    batch: v.optional(batchResult),
+    resume: v.optional(v.strictObject({ before: v.optional(text) })),
+    progress,
+    held: v.optional(v.array(range)),
+    log: text,
+});
+export const storeJobCancel = v.strictObject({ job: id, cancelled: v.literal(true) });
+export const storeJobRetry = v.union([
+    v.strictObject({ ...messageSyncStarted.entries, retried: id }),
+    v.strictObject({ retried: id, chat: text, error: v.strictObject({ code: text, message: text }) }),
+]);
+export const storeJobClear = v.strictObject({ cleared: v.array(id) });

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

@@ -0,0 +1,74 @@
+import * as v from "valibot";
+export declare const tagTarget: v.VariantSchema<"type", [v.StrictObjectSchema<{
+    readonly type: v.LiteralSchema<"chat", undefined>;
+    readonly chat_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly type: v.LiteralSchema<"contact", undefined>;
+    readonly person_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly type: v.LiteralSchema<"message", 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 locator: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly type: v.LiteralSchema<"task", undefined>;
+    readonly task_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>], undefined>;
+export declare const tagChange: v.UnionSchema<[v.StrictObjectSchema<{
+    readonly target: v.VariantSchema<"type", [v.StrictObjectSchema<{
+        readonly type: v.LiteralSchema<"chat", undefined>;
+        readonly chat_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly type: v.LiteralSchema<"contact", undefined>;
+        readonly person_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly type: v.LiteralSchema<"message", 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 locator: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly type: v.LiteralSchema<"task", undefined>;
+        readonly task_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>], undefined>;
+    readonly unchanged: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly added: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly target: v.VariantSchema<"type", [v.StrictObjectSchema<{
+        readonly type: v.LiteralSchema<"chat", undefined>;
+        readonly chat_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly type: v.LiteralSchema<"contact", undefined>;
+        readonly person_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly type: v.LiteralSchema<"message", 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 locator: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly type: v.LiteralSchema<"task", undefined>;
+        readonly task_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>], undefined>;
+    readonly unchanged: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly removed: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+}, undefined>], undefined>;
+export declare const automaticTags: v.StrictObjectSchema<{
+    readonly items: v.ArraySchema<v.UnionSchema<[v.StrictObjectSchema<{
+        readonly chat_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly tags: v.ArraySchema<v.StrictObjectSchema<{
+            readonly tag: v.StringSchema<undefined>;
+            readonly score: v.NumberSchema<undefined>;
+            readonly fields: v.ArraySchema<v.PicklistSchema<["title", "username", "description"], undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly algorithm: v.StringSchema<undefined>;
+        readonly fetched_at: v.NullableSchema<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>;
+        readonly source: v.PicklistSchema<["metadata", "stored-chat"], undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly chat_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly error: v.StrictObjectSchema<{
+            readonly code: v.StringSchema<undefined>;
+            readonly message: v.StringSchema<undefined>;
+        }, undefined>;
+    }, undefined>], undefined>, undefined>;
+    readonly has_more: v.BooleanSchema<undefined>;
+    readonly dry_run: v.BooleanSchema<undefined>;
+}, undefined>;

package/dist/entities/tag-change.js

@@ -0,0 +1,31 @@
+import * as v from "valibot";
+import { id, reference, text, time } from "./fields.js";
+export const tagTarget = v.variant("type", [
+    v.strictObject({ type: v.literal("chat"), chat_id: id }),
+    v.strictObject({ type: v.literal("contact"), person_id: id }),
+    v.strictObject({ type: v.literal("message"), chat_id: id, message_id: id, locator: reference }),
+    v.strictObject({ type: v.literal("task"), task_id: id }),
+]);
+const receipt = { target: tagTarget, unchanged: v.array(text) };
+export const tagChange = v.union([
+    v.strictObject({ ...receipt, added: v.array(text) }),
+    v.strictObject({ ...receipt, removed: v.array(text) }),
+]);
+export const automaticTags = v.strictObject({
+    items: v.array(v.union([
+        v.strictObject({
+            chat_id: id,
+            tags: v.array(v.strictObject({
+                tag: text,
+                score: v.number(),
+                fields: v.array(v.picklist(["title", "username", "description"])),
+            })),
+            algorithm: text,
+            fetched_at: v.nullable(time),
+            source: v.picklist(["metadata", "stored-chat"]),
+        }),
+        v.strictObject({ chat_id: id, error: v.strictObject({ code: text, message: text }) }),
+    ])),
+    has_more: v.boolean(),
+    dry_run: v.boolean(),
+});

package/dist/entities/task-pair.d.ts

@@ -0,0 +1,31 @@
+import * as v from "valibot";
+export declare const taskPair: v.StrictObjectSchema<{
+    readonly task: v.NullableSchema<v.StrictObjectSchema<{
+        readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly key: v.StringSchema<undefined>;
+        readonly title: v.StringSchema<undefined>;
+        readonly status: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly source: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    readonly other: v.StrictObjectSchema<{
+        readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly key: v.StringSchema<undefined>;
+        readonly title: v.StringSchema<undefined>;
+        readonly status: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly score: v.NumberSchema<undefined>;
+    readonly band: v.PicklistSchema<["likely", "maybe", "different"], undefined>;
+    readonly levels: v.StrictObjectSchema<{
+        readonly text: v.PicklistSchema<["high", "middle", "low"], undefined>;
+        readonly person: v.PicklistSchema<["same", "different", "unknown"], undefined>;
+        readonly amount: v.PicklistSchema<["equal", "different", "missing"], undefined>;
+        readonly category: v.PicklistSchema<["same", "different", "unknown"], undefined>;
+        readonly due: v.PicklistSchema<["near", "far", "missing"], undefined>;
+        readonly reply: v.PicklistSchema<["yes", "no"], undefined>;
+        readonly time: v.PicklistSchema<["near", "weeks", "far"], undefined>;
+    }, undefined>;
+    readonly reasons: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly decision: v.PicklistSchema<["review", "unsure", "merged", "rejected", "unmerged", "attached", "new"], undefined>;
+    readonly decided_at: v.NullableSchema<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>;
+    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>;

package/dist/entities/task-pair.js

@@ -0,0 +1,23 @@
+import * as v from "valibot";
+import { reference, text, time } from "./fields.js";
+const side = v.strictObject({ ref: reference, key: text, title: text, status: text });
+export const taskPair = v.strictObject({
+    task: v.nullable(side),
+    source: v.nullable(reference),
+    other: side,
+    score: v.number(),
+    band: v.picklist(["likely", "maybe", "different"]),
+    levels: v.strictObject({
+        text: v.picklist(["high", "middle", "low"]),
+        person: v.picklist(["same", "different", "unknown"]),
+        amount: v.picklist(["equal", "different", "missing"]),
+        category: v.picklist(["same", "different", "unknown"]),
+        due: v.picklist(["near", "far", "missing"]),
+        reply: v.picklist(["yes", "no"]),
+        time: v.picklist(["near", "weeks", "far"]),
+    }),
+    reasons: v.array(text),
+    decision: v.picklist(["review", "unsure", "merged", "rejected", "unmerged", "attached", "new"]),
+    decided_at: v.nullable(time),
+    created_at: time,
+});