@wirecat/cli-core 0.550.0 → 0.551.0

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.550.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"
     },