@wirecat/cli-core 0.545.0 → 0.547.0

package/dist/store/sqlite/relation-proposals.js

@@ -0,0 +1,114 @@
+import { CliError } from "@wirecat/cli-base";
+import { assertMayDecide, deciderAuthor } from "../decisions.js";
+import { actorOfOrigin, botNamed, ownerPerson } from "./actors.js";
+import { insertLink, linkOf } from "./notes.js";
+import { proposalOperationsOver, proposerOfAction } from "./proposed-actions.js";
+import { thingOf } from "./things.js";
+import { write } from "./transaction.js";
+/** `relationship` proposals in `proposed_actions`: an agent's or a rule's, and the rejected ones a scan skips. */
+export const relationProposalsOver = (context) => {
+    const { database, now } = context;
+    const operations = proposalOperationsOver(context);
+    /** The rejected `relationship` proposal a removed link leaves behind, so a scan never proposes it again. */
+    const rejected = (link, by, reason) => {
+        const at = now();
+        const proposed = link.confirmed ? ownerPerson(database) : actorOfOrigin(database, "agent");
+        const decided = by === "owner" ? ownerPerson(database) : botNamed(database, by.bot, at);
+        const why = [
+            `${link.confirmed ? "removed" : "rejected"} by ${by === "owner" ? "the owner" : `agent:${by.bot}`}`,
+            by === "owner" ? undefined : by.reason.trim(),
+            reason?.trim() || undefined,
+        ].filter(Boolean);
+        const from = thingOf(database, link.from);
+        database
+            .prepare("INSERT INTO proposed_actions (kind, target_type, target_id, payload, reason, status, proposed_by_type, " +
+            "proposed_by_id, decided_by_type, decided_by_id, decided_at, result, created_at, updated_at) " +
+            "VALUES ('relationship', ?, ?, ?, ?, 'rejected', ?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(from?.type ?? null, from?.id ?? null, JSON.stringify({ from: link.from, to: link.to, kind: link.kind, ...(link.role ? { role: link.role } : {}) }), link.evidence, proposed.type, proposed.id, decided.type, decided.id, at, JSON.stringify({ reason: why.join(": "), link: link.id }), at, at);
+    };
+    return {
+        /** The same pending pair returns the proposal already held. */
+        propose: (from, input, by) => {
+            const evidence = input.evidence ?? [];
+            if (!Array.isArray(evidence) || evidence.length > 5 || evidence.some((ref) => typeof ref !== "string"))
+                throw new CliError("validation_error", "a relationship proposal cites up to 5 references");
+            return write(database, () => {
+                const held = database
+                    .prepare("SELECT id FROM proposed_actions WHERE kind='relationship' AND status='proposed' AND target_type=? AND target_id=? " +
+                    "AND json_extract(payload,'$.to')=? AND json_extract(payload,'$.kind')=? ORDER BY id LIMIT 1")
+                    .get(from.type, from.id, input.to, input.kind);
+                if (held)
+                    return operations.get(String(held.id));
+                return operations.propose({
+                    kind: "relationship",
+                    by,
+                    target: input.from,
+                    payload: {
+                        from: input.from,
+                        to: input.to,
+                        kind: input.kind,
+                        ...(input.role === undefined ? {} : { role: input.role }),
+                        evidence,
+                    },
+                    ...(input.reason === undefined ? {} : { reason: input.reason }),
+                });
+            });
+        },
+        rejected: (link, by, reason) => rejected(link, by, reason),
+        /**
+         * Decides a stored `relationship` or `key_document` proposal in one transaction: the confirmed link and the
+         * decision land together or not at all.
+         */
+        decideProposal: (id, decision) => write(database, () => {
+            const proposal = operations.get(id);
+            if (proposal.kind !== "relationship" && proposal.kind !== "key_document")
+                throw new CliError("validation_error", `${id} is a ${proposal.kind} proposal, not a link`);
+            assertMayDecide({ id, proposedBy: proposerOfAction(proposal) }, decision.by, context.decisions);
+            const author = deciderAuthor(decision.by);
+            const reason = decision.reason?.trim() || undefined;
+            if (!decision.confirm)
+                return { proposal: operations.reject(id, author, reason === undefined ? undefined : { reason }), link: null };
+            const payload = proposal.payload;
+            const key = proposal.kind === "key_document";
+            const link = insertLink(context, {
+                from: String(key ? payload.ref : payload.from),
+                to: String(key ? payload.project : payload.to),
+                kind: key ? "related-to" : (payload.kind ?? "member-of"),
+                ...(key ? { role: "key" } : payload.role === undefined ? {} : { role: payload.role }),
+                ...(proposal.reason === null ? {} : { evidence: proposal.reason }),
+                ...decidedOrigin(decision.by),
+            });
+            return {
+                proposal: operations.approve(id, { link: link.id, ...(reason === undefined ? {} : { reason }) }, author),
+                link,
+            };
+        }),
+        /** Decides an unconfirmed link written before proposals were stored; only the owner may, as its author is unknown. */
+        decideLink: (id, decision) => write(database, () => {
+            const row = /^\d+$/.test(id)
+                ? database.prepare("SELECT * FROM links WHERE id = ? AND confirmed = 0").get(Number(id))
+                : undefined;
+            if (!row)
+                throw new CliError("not_found", `no suggested link ${id}`);
+            assertMayDecide({ id: `link:${id}`, proposedBy: { type: "unknown" } }, decision.by, context.decisions);
+            const link = linkOf(database, row);
+            if (!decision.confirm) {
+                rejected(link, decision.by, decision.reason);
+                database.prepare("DELETE FROM links WHERE id = ?").run(Number(id));
+                return null;
+            }
+            database
+                .prepare("UPDATE links SET confirmed=1, source='owner', author='owner', updated_at=? WHERE id=?")
+                .run(now(), Number(id));
+            return linkOf(database, database.prepare("SELECT * FROM links WHERE id = ?").get(Number(id)));
+        }),
+    };
+};
+/** A link an agent confirmed for the owner says so in its provenance. */
+const decidedOrigin = (by) => by === "owner"
+    ? { origin: "owner" }
+    : {
+        origin: "suggested",
+        confirmed: true,
+        provenance: `agent:${by.bot} for the owner: ${by.reason.trim()}`,
+    };

package/dist/store/sqlite/things.d.ts

@@ -24,4 +24,3 @@ export declare const stateOfThing: (database: CacheDatabase, thing: Thing | unde
 export declare const taskRowOf: (database: CacheDatabase, id: string) => number | undefined;
 /** The package's id for a task row: the reverse of `taskRowOf`. */
 export declare const taskIdOf: (database: CacheDatabase, rowId: number) => string | undefined;
-export declare const canonicalThingReference: (reference: string) => string;

package/dist/store/sqlite/things.js

@@ -1,7 +1,7 @@
 import { formatLocator } from "../../domain/locator.js";
 import { filesAccountSql } from "../../domain/providers.js";
-import { canonicalReference, formatReference, parseReference } from "../../domain/references.js";
-import { canonicalMeetingReference, formatMeetingReference, parseMeetingReference } from "../../meetings/index.js";
+import { formatReference, parseReference } from "../../domain/references.js";
+import { formatMeetingReference } from "../../meetings/index.js";
 import { ENTITY_TABLES, isEntityType } from "./entity-types.js";
 /** A pointer as a row holds it. An unknown type is not refused on read: `store check` reports it. */
 export const storedThing = (type, id) => ({ type: String(type), id: Number(id) });
@@ -16,6 +16,7 @@ const REFERABLE = {
     memory: { tombstone: true },
     fact: { tombstone: true },
     bot: { tombstone: false },
+    event: { tombstone: true },
     message: { tombstone: true },
     email: { tombstone: true },
     email_thread: { tombstone: true },
@@ -30,30 +31,11 @@ const storeId = (text) => (/^[1-9]\d{0,15}$/.test(text) ? Number(text) : undefin
  * `messages.db` (a ULID, an `entity:`) is simply not found: it is never guessed at.
  */
 export const thingOf = (database, reference) => {
-    if (typeof reference === "string" && reference.trim().startsWith("meeting:")) {
-        const parsed = parseMeetingReference(reference);
-        const meeting = database
-            .prepare("SELECT id FROM meetings WHERE id=? AND account_id=? AND deleted_at IS NULL")
-            .get(parsed.meetingId, parsed.accountId);
-        if (!meeting)
-            return undefined;
-        if (parsed.transcriptId === undefined)
-            return { type: "meeting", id: parsed.meetingId };
-        const transcript = database
-            .prepare("SELECT id FROM meeting_transcripts WHERE id=? AND meeting_id=? AND deleted_at IS NULL")
-            .get(parsed.transcriptId, parsed.meetingId);
-        if (!transcript)
-            return undefined;
-        if (parsed.cuePosition === undefined)
-            return { type: "meeting_transcript", id: parsed.transcriptId };
-        const row = database
-            .prepare("SELECT id FROM meeting_transcript_rows WHERE meeting_transcript_id=? AND position=?")
-            .get(parsed.transcriptId, parsed.cuePosition);
-        return row ? { type: "meeting_transcript_row", id: Number(row.id) } : undefined;
-    }
     const parsed = typeof reference === "string" ? parseReference(reference) : reference;
     const found = (type, row) => row ? { type, id: Number(row.id) } : undefined;
     switch (parsed.type) {
+        case "meeting":
+            return meetingThingOf(database, parsed);
         case "message":
             return ((parsed.provider === "email" ? emailOf(database, parsed.account, parsed.chat, parsed.message) : undefined) ??
                 found("message", database
@@ -90,6 +72,26 @@ export const thingOf = (database, reference) => {
         }
     }
 };
+const meetingThingOf = (database, parsed) => {
+    const meeting = database
+        .prepare("SELECT id FROM meetings WHERE id=? AND account_id=? AND deleted_at IS NULL")
+        .get(parsed.meetingId, parsed.accountId);
+    if (!meeting)
+        return undefined;
+    if (parsed.transcriptId === undefined)
+        return { type: "meeting", id: parsed.meetingId };
+    const transcript = database
+        .prepare("SELECT id FROM meeting_transcripts WHERE id=? AND meeting_id=? AND deleted_at IS NULL")
+        .get(parsed.transcriptId, parsed.meetingId);
+    if (!transcript)
+        return undefined;
+    if (parsed.cuePosition === undefined)
+        return { type: "meeting_transcript", id: parsed.transcriptId };
+    const row = database
+        .prepare("SELECT id FROM meeting_transcript_rows WHERE meeting_transcript_id=? AND position=?")
+        .get(parsed.transcriptId, parsed.cuePosition);
+    return row ? { type: "meeting_transcript_row", id: Number(row.id) } : undefined;
+};
 /** Mail that memo saved before it wrote the mail tables is still messages, so the caller falls back to them. */
 export const emailOf = (database, account, thread, email) => {
     const row = database
@@ -237,4 +239,3 @@ export const taskIdOf = (database, rowId) => {
     const row = database.prepare("SELECT key, package_id AS id FROM tasks WHERE id = ?").get(rowId);
     return row ? String(row.id ?? row.key) : undefined;
 };
-export const canonicalThingReference = (reference) => reference.trim().startsWith("meeting:") ? canonicalMeetingReference(reference) : canonicalReference(reference);

package/dist/store/store.d.ts

@@ -6,6 +6,7 @@ import { type AttachmentsStore } from "./attachments.js";
 import { type ChatsStore } from "./chats.js";
 import { type ConversationsStore } from "./conversations.js";
 import { type CountersStore } from "./counters.js";
+import { type DecisionPolicy } from "./decisions.js";
 import type { EvidenceFindingsStore } from "./evidence-findings.js";
 import type { MeetingFindingsStore } from "./meeting-findings.js";
 import { type MentionsStore } from "./mentions.js";
@@ -95,6 +96,8 @@ export interface MessageStore {
     readonly memories: MemoriesStore;
     /** What an agent wants done outside the store, waiting for the owner's approval. */
     readonly proposedActions: ProposedActionsStore;
+    /** Who may decide proposals, fixed when the store was opened; the store's decide methods and the registry read it. */
+    readonly decisionPolicy: DecisionPolicy;
     /** One row per tool an agent called, never its arguments. */
     readonly agentActions: AgentActionsStore;
     /** Meetings and calendar events: the port `src/meetings/` defines. */

package/dist/store/store.js

@@ -4,6 +4,7 @@ import { accountAttachmentsOver, attachmentsStoreOver, } from "./attachments.js"
 import { chatsStoreOver } from "./chats.js";
 import { conversationsStoreOver } from "./conversations.js";
 import { accountCountersOver, countersStoreOver } from "./counters.js";
+import { DEFAULT_DECISION_POLICY } from "./decisions.js";
 import { accountMentionsOver, mentionsStoreOver } from "./mentions.js";
 import { accountMessagesOver, messagesStoreOver } from "./messages.js";
 import { accountPeopleOver, peopleStoreOver } from "./people.js";
@@ -207,6 +208,7 @@ const storeOver = (context) => {
         get memories() {
             return memories();
         },
+        decisionPolicy: context.decisions ?? DEFAULT_DECISION_POLICY,
         get proposedActions() {
             return proposedActions();
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.545.0",
+  "version": "0.547.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",