@wirecat/cli-core 0.549.0 → 0.551.0

package/dist/store/sqlite/facts.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import { calendarMoment } from "../../domain/moment.js";
+import { validatePayment } from "../../meetings/index.js";
 import { assertMayDecide, assertMayWithdraw, deciderAuthor } from "../decisions.js";
 import { proposedBySql, proposerOf } from "./actors.js";
 import { evidenceSourcesOf } from "./evidence-sources.js";
@@ -35,6 +36,7 @@ export const factOperationsOver = (context) => {
         scope: row.scope == null ? null : row.scope,
         source: String(row.source),
         evidence: evidenceOf(context, { type: "fact", id: Number(row.id) }),
+        payment: row.type === "payment" ? paymentOf(row.metadata) : null,
         createdAt: iso(row.created_at),
         updatedAt: iso(row.updated_at),
     });
@@ -49,7 +51,11 @@ export const factOperationsOver = (context) => {
         proposedBy: proposerOf(database, row.author_type, row.author_id),
         proposed: row.status === "proposed",
     }, by);
-    const decided = (row, by) => assertMayDecide({ id: `fact:${row.id}`, proposedBy: proposerOf(database, row.author_type, row.author_id) }, by, context.decisions);
+    const decided = (row, by) => assertMayDecide({
+        id: `fact:${row.id}`,
+        proposedBy: proposerOf(database, row.author_type, row.author_id),
+        ownerOnly: row.type === "payment",
+    }, by, context.decisions);
     /** Keeps who decided for the owner and why in `metadata.decision`; the decider's actor is in `confirmed_by`. */
     const keepDecision = (id, by, reason) => {
         const why = [by === "owner" ? undefined : by.reason.trim(), reason?.trim() || undefined].filter(Boolean).join(": ");
@@ -85,6 +91,7 @@ export const factOperationsOver = (context) => {
             const occurredAt = input.occurredAt === undefined ? null : calendarMoment(input.occurredAt, "occurredAt");
             if (occurredAt !== null && !Number.isFinite(occurredAt))
                 throw new CliError("validation_error", "occurredAt takes an ISO timestamp");
+            const payment = paymentInput(type, input);
             const id = write(database, () => {
                 const project = input.project === undefined ? undefined : requiredThing(database, input.project, "the project");
                 if (project && project.type !== "project")
@@ -93,14 +100,18 @@ export const factOperationsOver = (context) => {
                 const replaced = input.supersedes === undefined ? undefined : rowOf(input.supersedes);
                 if (replaced && replaced.status !== "proposed" && replaced.status !== "accepted")
                     throw new CliError("validation_error", `${input.supersedes} is ${String(replaced.status)}; only a proposed or accepted fact can be corrected`);
+                if (replaced && (replaced.type === "payment") !== (type === "payment"))
+                    throw new CliError("validation_error", "a payment fact corrects a payment fact, and only one");
+                if (payment?.counterparty)
+                    requiredThing(database, payment.counterparty, "the counterparty");
                 const owner = input.by === "owner";
                 const { actor, model } = authorActor(context, input.by);
                 const at = now();
                 const made = Number(database
                     .prepare("INSERT INTO facts (id, type, statement, status, project_id, subject_type, subject_id, occurred_at, supersedes_id, " +
-                    "author_type, author_id, model, scope, source, created_at, updated_at) " +
-                    "VALUES (?, ?, ?, 'proposed', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
-                    .get(nextId(database, "facts"), type, statement, project?.id ?? null, subject?.type ?? null, subject?.id ?? null, occurredAt, replaced === undefined ? null : Number(replaced.id), actor.type, actor.id, model, scope, owner ? "owner" : "agent", at, at)?.id);
+                    "author_type, author_id, model, scope, source, metadata, created_at, updated_at) " +
+                    "VALUES (?, ?, ?, 'proposed', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
+                    .get(nextId(database, "facts"), type, statement, project?.id ?? null, subject?.type ?? null, subject?.id ?? null, occurredAt, replaced === undefined ? null : Number(replaced.id), actor.type, actor.id, model, scope, owner ? "owner" : "agent", payment ? JSON.stringify({ payment }) : null, at, at)?.id);
                 linkEvidence(context, { type: "fact", id: made }, input.evidence ?? [], owner ? "owner" : "agent");
                 if (input.createdFrom !== undefined) {
                     const from = requiredThing(database, input.createdFrom, "the source");
@@ -121,11 +132,12 @@ export const factOperationsOver = (context) => {
             const subject = options.subject === undefined ? undefined : requiredThing(database, options.subject);
             const by = proposedBySql("f.author_type", "f.author_id", options.proposedBy);
             const order = options.order === "created" ? "f.created_at" : "coalesce(f.occurred_at, f.created_at)";
+            const paid = paymentSql(options.payment);
             return database
                 .prepare(`${NAMED} WHERE f.deleted_at IS NULL AND (? IS NULL OR f.type = ?) AND (? IS NULL OR f.project_id = ?) ` +
                 "AND (? IS NULL OR (f.subject_type = ? AND f.subject_id = ?)) AND (? IS NULL OR f.status = ?) " +
-                `AND ${by.sql} ORDER BY ${order} DESC, f.id DESC LIMIT ?`)
-                .all(options.type ?? null, options.type ?? null, project?.id ?? null, project?.id ?? null, subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, options.status ?? null, options.status ?? null, ...by.params, Math.min(Math.max(options.limit ?? 100, 1), 500))
+                `AND ${by.sql}${paid.sql} ORDER BY ${order} DESC, f.id DESC LIMIT ?`)
+                .all(options.type ?? null, options.type ?? null, project?.id ?? null, project?.id ?? null, subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, options.status ?? null, options.status ?? null, ...by.params, ...paid.params, Math.min(Math.max(options.limit ?? 100, 1), 500))
                 .map(factOf);
         },
         accept: (reference, by, reason) => {
@@ -183,6 +195,52 @@ export const factOperationsOver = (context) => {
         sources: (reference) => evidenceSourcesOf(database, { type: "fact", id: Number(rowOf(reference).id) }),
     };
 };
+const paymentInput = (type, input) => {
+    if (type !== "payment") {
+        if (input.payment !== undefined)
+            throw new CliError("validation_error", "only a payment fact takes a payment");
+        return undefined;
+    }
+    if (input.payment === undefined)
+        throw new CliError("validation_error", "a payment fact needs its payment: amount, currency, direction and state");
+    const evidence = input.evidence?.length ?? 0;
+    if (evidence < 1 || evidence > 8)
+        throw new CliError("validation_error", "a payment fact cites 1–8 references: the ask, the transfer or a sheet row");
+    return validatePayment(input.payment);
+};
+const paymentOf = (metadata) => {
+    if (metadata == null)
+        return null;
+    try {
+        const { payment } = JSON.parse(String(metadata));
+        return payment ?? null;
+    }
+    catch {
+        return null;
+    }
+};
+const paymentSql = (filter) => {
+    if (filter === undefined)
+        return { sql: "", params: [] };
+    const parts = ["f.type = 'payment'"];
+    const params = [];
+    const state = filter.open ? "expected" : filter.state;
+    if (filter.open && filter.state !== undefined && filter.state !== "expected")
+        parts.push("0");
+    if (filter.direction !== undefined) {
+        parts.push("json_extract(f.metadata, '$.payment.direction') = ?");
+        params.push(filter.direction);
+    }
+    if (state !== undefined) {
+        parts.push("json_extract(f.metadata, '$.payment.state') = ?");
+        params.push(state);
+    }
+    if (filter.open)
+        parts.push("f.status IN ('proposed', 'accepted')");
+    if (filter.open === false)
+        parts.push("NOT (json_extract(f.metadata, '$.payment.state') = 'expected' AND f.status IN ('proposed', 'accepted'))");
+    return { sql: ` AND ${parts.join(" AND ")}`, params };
+};
 const migratedFrom = (metadata) => {
     try {
         const { memory } = JSON.parse(metadata);

package/dist/store/sqlite/findings-core.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { findingFingerprint, findingHash, } from "../../meetings/index.js";
+import { findingFingerprint, findingHash, paymentTitle, } from "../../meetings/index.js";
 import { factOperationsOver } from "./facts.js";
 import { linkEvidence } from "./memories.js";
 import { requiredThing } from "./notes.js";
@@ -81,6 +81,19 @@ export const findingsCoreOver = (context, kind) => {
             });
             return facts.acceptChecked(fact.ref, decidedBy).ref;
         }
+        if (finding.kind === "payment") {
+            const fact = facts.add({
+                type: "payment",
+                statement: finding.statement ?? paymentTitle(finding),
+                payment: finding.payment,
+                ...(finding.project === undefined ? {} : { project: finding.project }),
+                ...(finding.subject === undefined ? {} : { subject: finding.subject }),
+                ...(finding.supersedes === undefined ? {} : { supersedes: finding.supersedes }),
+                evidence,
+                by: agent,
+            });
+            return facts.acceptChecked(fact.ref, decidedBy).ref;
+        }
         if (finding.project === undefined)
             return invalid("a task finding names the project the task goes in");
         const task = tasks.create({

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

@@ -6,7 +6,7 @@ import type { Author } from "./memories.js";
 import { type Link } from "./notes.js";
 import type { StoreContext } from "./open.js";
 import type { ProposedAction } from "./proposed-actions.js";
-import { type KnowledgeRelation, type LinkDecision, type RelateInput, type RelationUpdate } from "./relation-proposals.js";
+import { type KnowledgeRelation, type LinkDecision, type RelateInput, type RelationUpdate, type Scored } from "./relation-proposals.js";
 import type { TagCreationOptions } from "./tag-creation.js";
 import { type Label, type TagKind, type TagRow } from "./tags.js";
 import { type ThingState } from "./things.js";
@@ -190,7 +190,21 @@ export interface KnowledgeStore extends VocabularyStore, MeetingProjectsStore {
         purpose?: string;
         evidence?: string[];
         reason?: string;
-    }, by: Exclude<Author, "owner">): Promise<ProposedAction>;
+    } & Scored, by: Exclude<Author, "owner">): Promise<ProposedAction>;
+    /**
+     * Where a pair stands for a scan: `linked` when a link already joins it, `rejected` when any `relationship`
+     * proposal for it was rejected, and the pending proposal if one waits. `undefined` when either end is not stored.
+     */
+    relationState(key: KnowledgeScope, input: {
+        from: string;
+        to: string;
+        kind: KnowledgeRelation["kind"];
+    }): Promise<{
+        linked: boolean;
+        confirmed: boolean;
+        rejected: boolean;
+        pending: ProposedAction | null;
+    } | undefined>;
     /** The owner sets a relationship's role and purpose; `null` clears one. */
     updateRelation(key: KnowledgeScope, id: string, input: RelationUpdate & {
         by: "owner";

package/dist/store/sqlite/knowledge.js

@@ -562,6 +562,7 @@ export const knowledgeStoreOver = (context) => {
                 });
             return proposals.propose(from, input, by);
         },
+        relationState: async (key, input) => proposals.state(() => pair(key, input), input),
         updateRelation: (async (key, id, input) => {
             checked(key);
             const link = linkOf(database, relation(id));

package/dist/store/sqlite/project-transfer/snapshot.d.ts

@@ -5,7 +5,7 @@ export declare const projectAnnotationSnapshot: (database: CacheDatabase, projec
         format: "wirecat.project-annotations";
         facts: {
             ref: string;
-            type: "decision" | "fact" | "promise" | "question" | "statement";
+            type: "decision" | "fact" | "payment" | "promise" | "question" | "statement";
             statement: string;
             status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
             subject: string | null;

package/dist/store/sqlite/relation-proposals.d.ts

@@ -5,6 +5,7 @@ import { type Link } from "./notes.js";
 import type { StoreContext } from "./open.js";
 import { type ProposedAction } from "./proposed-actions.js";
 import { type Thing } from "./things.js";
+type Row = Record<string, unknown>;
 export interface KnowledgeRelation {
     id: string;
     from: string;
@@ -32,7 +33,23 @@ export interface RelateInput {
 export declare const relationOf: (link: Link) => KnowledgeRelation;
 /** `relationship` proposals in `proposed_actions`: an agent's or a rule's, and the rejected ones a scan skips. */
 export declare const relationProposalsOver: (context: StoreContext) => {
-    /** The same pending pair returns the proposal already held. */
+    /**
+     * Where a pair stands before a scan proposes it: a link joins it, a `relationship` proposal for it was rejected,
+     * or one is pending. A rejection is matched by the pair alone, whoever proposed it and with whatever scorer.
+     */
+    state: (paired: () => {
+        from: Thing;
+        existing: Row | undefined;
+    }, { to, kind }: {
+        to: string;
+        kind: string;
+    }) => {
+        linked: boolean;
+        confirmed: boolean;
+        rejected: boolean;
+        pending: ProposedAction | null;
+    } | undefined;
+    /** The same pending pair returns the proposal already held; a scored one updates its score in place. */
     propose: (from: Thing, input: {
         from: string;
         to: string;
@@ -41,7 +58,7 @@ export declare const relationProposalsOver: (context: StoreContext) => {
         purpose?: string;
         evidence?: string[];
         reason?: string;
-    }, by: Exclude<Author, "owner">) => ProposedAction;
+    } & Scored, by: Exclude<Author, "owner">) => ProposedAction;
     rejected: (link: Link, by: Decider, reason?: string) => void;
     update: (link: Link, input: RelationUpdate) => Link;
     proposeUpdate: (link: Link, input: RelationUpdate & {
@@ -62,6 +79,15 @@ export declare const relationProposalsOver: (context: StoreContext) => {
     /** Decides an unconfirmed link written before proposals were stored; only the owner may, as its author is unknown. */
     decideLink: (id: string, decision: LinkDecision) => Link | null;
 };
+/** What a scan adds to a relationship proposal: the combined score and each scorer's part in it. */
+export interface Scored {
+    score?: number;
+    signals?: {
+        scorer: string;
+        weight: number;
+        why: string;
+    }[];
+}
 /** A relationship's role and purpose to set; `null` clears one. */
 export interface RelationUpdate {
     role?: string | null;
@@ -72,3 +98,4 @@ export interface LinkDecision {
     by: Decider;
     reason?: string;
 }
+export {};

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

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { assertMayDecide, deciderAuthor } from "../decisions.js";
+import { assertMayDecide, botKey, deciderAuthor } from "../decisions.js";
 import { actorOfOrigin, botNamed, ownerPerson } from "./actors.js";
 import { insertLink, linkOf, purposeOf } from "./notes.js";
 import { proposalOperationsOver, proposerOfAction } from "./proposed-actions.js";
@@ -47,19 +47,74 @@ export const relationProposalsOver = (context) => {
             .run(Number("role" in changes), changes.role ?? null, Number("purpose" in changes), changes.purpose ?? null, now(), Number(link.id));
         return linkOf(database, database.prepare("SELECT * FROM links WHERE id = ?").get(Number(link.id)));
     };
+    /**
+     * A scan's newer score on a pending proposal, in place under the same id. A rule's own row takes the new score,
+     * signals, evidence and purpose; another proposer's row keeps its author, evidence and purpose and gains the signals.
+     */
+    const rescored = (action, input, scored, by) => {
+        const proposer = proposerOfAction(action);
+        const own = proposer.type === "bot" && proposer.kind === "rule" && botKey(proposer.name) === botKey(by.bot);
+        const before = action.payload;
+        const payload = own
+            ? {
+                ...before,
+                ...scored,
+                evidence: input.evidence ?? [],
+                ...(input.purpose === undefined ? {} : { purpose: purposeOf(input.purpose) }),
+            }
+            : { ...before, ...scored };
+        const reason = own && input.reason !== undefined ? input.reason : action.reason;
+        if (JSON.stringify(payload) === JSON.stringify(before) && reason === action.reason)
+            return action;
+        database
+            .prepare("UPDATE proposed_actions SET payload = ?, reason = ?, updated_at = ? WHERE id = ? AND status = 'proposed'")
+            .run(JSON.stringify(payload), reason, now(), Number(action.id));
+        return operations.get(action.id);
+    };
     return {
-        /** The same pending pair returns the proposal already held. */
+        /**
+         * Where a pair stands before a scan proposes it: a link joins it, a `relationship` proposal for it was rejected,
+         * or one is pending. A rejection is matched by the pair alone, whoever proposed it and with whatever scorer.
+         */
+        state: (paired, { to, kind }) => {
+            let found;
+            try {
+                found = paired();
+            }
+            catch (error) {
+                if (error instanceof CliError && (error.code === "not_found" || error.code === "validation_error"))
+                    return;
+                throw error;
+            }
+            const { from, existing } = found;
+            const rows = database
+                .prepare("SELECT id, status FROM proposed_actions WHERE kind='relationship' AND status IN ('proposed','rejected') " +
+                "AND target_type=? AND target_id=? AND json_extract(payload,'$.to')=? AND json_extract(payload,'$.kind')=? " +
+                "ORDER BY id")
+                .all(from.type, from.id, to, kind);
+            const pending = rows.find((row) => row.status === "proposed");
+            return {
+                linked: existing !== undefined,
+                confirmed: existing !== undefined && Number(existing.confirmed) === 1,
+                rejected: rows.some((row) => row.status === "rejected"),
+                pending: pending ? operations.get(String(pending.id)) : null,
+            };
+        },
+        /** The same pending pair returns the proposal already held; a scored one updates its score in place. */
         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");
+            const scored = scoredOf(input);
             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));
+                if (held) {
+                    const action = operations.get(String(held.id));
+                    return scored ? rescored(action, input, scored, by) : action;
+                }
                 return operations.propose({
                     kind: "relationship",
                     by,
@@ -71,6 +126,7 @@ export const relationProposalsOver = (context) => {
                         ...(input.role === undefined ? {} : { role: input.role }),
                         ...(input.purpose === undefined ? {} : { purpose: purposeOf(input.purpose) }),
                         evidence,
+                        ...scored,
                     },
                     ...(input.reason === undefined ? {} : { reason: input.reason }),
                 });
@@ -174,6 +230,21 @@ export const relationProposalsOver = (context) => {
         }),
     };
 };
+const scoredOf = (input) => {
+    if (input.score === undefined && input.signals === undefined)
+        return undefined;
+    const { score, signals } = input;
+    if (typeof score !== "number" || !(score >= 0 && score <= 1) || !Array.isArray(signals) || signals.length > 20)
+        throw new CliError("validation_error", "a scored proposal takes a score of 0–1 and up to 20 signals");
+    for (const signal of signals)
+        if (typeof signal?.scorer !== "string" ||
+            typeof signal.why !== "string" ||
+            signal.why.length > 500 ||
+            typeof signal.weight !== "number" ||
+            !(signal.weight >= 0 && signal.weight <= 1))
+            throw new CliError("validation_error", "a signal names its scorer, a weight of 0–1 and why, up to 500 characters");
+    return { score, signals: signals.map(({ scorer, weight, why }) => ({ scorer, weight, why })) };
+};
 /** What a relationship update sets, checked; `null` clears a field and an absent one is left alone. */
 const changesOf = (input) => {
     const changes = {};

package/dist/store/store.d.ts

@@ -112,6 +112,7 @@ export interface MessageStore {
     forAccount(key: AccountKey): AccountStore;
     close(): Promise<void>;
 }
+export type { PaymentFilter } from "./sqlite/facts.js";
 export type { ChatHistoryShape, StoredHistorySkip } from "./sqlite/history-skips.js";
 export { BACKFILL_ON_OPEN, type StoreOptions } from "./sqlite/open-store.js";
 export { fileFacts, readStoreTables, type TableKind } from "./sqlite/store-tables.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.549.0",
+  "version": "0.551.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",
@@ -251,7 +251,7 @@
     "@types/node": "^22.20.5",
     "@types/pngjs": "6.0.5",
     "@vitest/coverage-v8": "^5.0.5",
-    "@wirecat/cli-base": "0.74.0",
+    "@wirecat/cli-base": "0.75.0",
     "@wirecat/cli-core-legacy-tags": "npm:@wirecat/cli-core@0.414.0",
     "commander": "15.0.0",
     "cspell": "10.4.0",
@@ -271,7 +271,7 @@
   },
   "peerDependencies": {
     "@napi-rs/canvas": ">=0.1.69 <2",
-    "@wirecat/cli-base": ">=0.74.0 <0.75.0",
+    "@wirecat/cli-base": ">=0.75.0 <0.76.0",
     "commander": ">=15"
   },
   "bin": {

package/parity.json

@@ -3715,6 +3715,17 @@
         "--sync-time": "all"
       }
     },
+    "projects status": {
+      "in": ["max", "tg"],
+      "planned": {
+        "wa": "wa backlog: mount projectsCommand once wa is on cli-core 0.504.0"
+      },
+      "options": {
+        "--before-time": "all",
+        "--context-query": "all",
+        "--since-time": "all"
+      }
+    },
     "reactions": {
       "in": "all"
     },