@wirecat/cli-core 0.556.0 → 0.558.0

package/dist/store/sqlite/entity-types.d.ts

@@ -20,6 +20,7 @@ export declare const ENTITY_TABLES: {
     readonly file: "files";
     readonly identity: "identities";
     readonly image: "attachments";
+    readonly invoice: "invoices";
     readonly meeting: "meetings";
     readonly meeting_transcript: "meeting_transcripts";
     readonly meeting_transcript_row: "meeting_transcript_rows";
@@ -27,6 +28,7 @@ export declare const ENTITY_TABLES: {
     readonly message: "messages";
     readonly note: "notes";
     readonly organization: "organizations";
+    readonly payment: "payments";
     readonly person: "persons";
     readonly place: "places";
     readonly project: "projects";

package/dist/store/sqlite/entity-types.js

@@ -19,6 +19,7 @@ export const ENTITY_TABLES = {
     file: "files",
     identity: "identities",
     image: "attachments",
+    invoice: "invoices",
     meeting: "meetings",
     meeting_transcript: "meeting_transcripts",
     meeting_transcript_row: "meeting_transcript_rows",
@@ -26,6 +27,7 @@ export const ENTITY_TABLES = {
     message: "messages",
     note: "notes",
     organization: "organizations",
+    payment: "payments",
     person: "persons",
     place: "places",
     project: "projects",

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

@@ -1,5 +1,4 @@
 import { type FACT_STATUSES, FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
-import { type PAYMENT_DIRECTIONS, type PAYMENT_STATES, type Payment } from "../../meetings/index.js";
 import { type Decider } from "../decisions.js";
 import { type Actor, type ProposedByFilter } from "./actors.js";
 import { type EvidenceSource } from "./evidence-sources.js";
@@ -35,8 +34,6 @@ export interface Fact {
     scope: (typeof MEMORY_SCOPES)[number] | null;
     source: string;
     evidence: string[];
-    /** Set on a `payment` fact only. */
-    payment: Payment | null;
     createdAt: string;
     updatedAt: string;
 }
@@ -55,14 +52,6 @@ export interface FactInput {
     supersedes?: string;
     /** The memory an agent drew it from: a `created-from` link. */
     createdFrom?: string;
-    /** Required on a `payment` fact, refused on any other; checked as `validatePayment` does. */
-    payment?: Payment;
-}
-/** `open` is an expected payment that still holds: not superseded, rejected or cancelled. */
-export interface PaymentFilter {
-    direction?: (typeof PAYMENT_DIRECTIONS)[number];
-    state?: (typeof PAYMENT_STATES)[number];
-    open?: boolean;
 }
 export interface FactsStore {
     add(input: FactInput): Promise<Fact>;
@@ -73,8 +62,6 @@ export interface FactsStore {
         subject?: string;
         status?: Fact["status"];
         proposedBy?: ProposedByFilter;
-        /** Narrows to payment facts by their fields. */
-        payment?: PaymentFilter;
         /** `created` lists the newest written first; by default the newest by when it happened. */
         order?: "occurred" | "created";
         limit?: number;

package/dist/store/sqlite/facts.js

@@ -1,7 +1,6 @@
 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";
@@ -36,7 +35,6 @@ 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),
     });
@@ -54,7 +52,6 @@ export const factOperationsOver = (context) => {
     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) => {
@@ -83,6 +80,8 @@ export const factOperationsOver = (context) => {
     };
     return {
         add: (input) => {
+            if (input.type === "payment")
+                throw new CliError("validation_error", "a payment is not a fact: record it with store.finance.addPayment, a payment: row, or an invoice: for one expected", { reason: "fact.payment-retired" });
             const type = oneOf(input.type, FACT_TYPES, "a fact's type");
             const statement = input.statement?.trim() ?? "";
             if (!statement || statement.length > 2000)
@@ -91,7 +90,6 @@ 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")
@@ -100,10 +98,6 @@ 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();
@@ -111,7 +105,7 @@ export const factOperationsOver = (context) => {
                     .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, 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);
+                    .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", 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");
@@ -132,12 +126,11 @@ 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}${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))
+                `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))
                 .map(factOf);
         },
         accept: (reference, by, reason) => {
@@ -195,52 +188,6 @@ 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/finance.d.ts

@@ -0,0 +1,203 @@
+import { type FinanceReview, type InvoiceDirection, type InvoiceStatus, type MoneyDirection } from "../../domain/finance.js";
+import { type Money } from "../../domain/money.js";
+import { type Decider } from "../decisions.js";
+import { type Actor, type ProposedByFilter } from "./actors.js";
+import { type Author } from "./memories.js";
+import type { StoreContext } from "./open.js";
+/** A `person:` or `organization:` on an invoice or a payment, with its name so a list needs no lookup. */
+export interface Party {
+    ref: string;
+    name: string | null;
+    /** The owner's own person row. */
+    owner: boolean;
+}
+interface Reviewed {
+    review: FinanceReview;
+    /** `name` is a bot's handle and `kind` whether it is an agent or a rule; both `null` for a person. */
+    author: {
+        type: Actor["type"];
+        id: string;
+        name: string | null;
+        kind: "agent" | "rule" | null;
+    };
+    model: string | null;
+    confirmedBy: {
+        type: Actor["type"];
+        id: string;
+    } | null;
+    source: string;
+    /** Why an agent or an import proposed it. */
+    reason: string | null;
+    /** What it was read from: the messages, documents or notes an agent or the owner cited. */
+    evidence: string[];
+    project: string | null;
+    projectName: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Invoice extends Reviewed {
+    id: string;
+    ref: string;
+    /** One line, as a list or the review inbox prints it. */
+    title: string;
+    direction: InvoiceDirection;
+    number: string | null;
+    issuer: Party | null;
+    counterparty: Party;
+    currency: string;
+    total: string;
+    /** Settled by confirmed payments. */
+    paid: string;
+    /** Still owed: `total − paid`. */
+    open: string;
+    issueDate: string | null;
+    dueDate: string | null;
+    status: InvoiceStatus;
+}
+export interface InvoiceLine {
+    position: number;
+    description: string;
+    quantity: string;
+    unitPrice: string | null;
+    amount: string;
+}
+export interface Allocation {
+    payment: string;
+    invoice: string;
+    amount: string;
+    currency: string;
+    createdAt: string;
+}
+export interface InvoiceDetail extends Invoice {
+    lines: InvoiceLine[];
+    allocations: Allocation[];
+}
+export interface Payment extends Reviewed {
+    id: string;
+    ref: string;
+    title: string;
+    direction: MoneyDirection;
+    payer: Party | null;
+    payee: Party | null;
+    amount: string;
+    currency: string;
+    /** `YYYY-MM-DD`. */
+    date: string;
+    reference: string | null;
+    /** Allocated to invoices, confirmed or not. */
+    allocated: string;
+    unallocated: string;
+}
+export interface PaymentDetail extends Payment {
+    allocations: Allocation[];
+}
+interface Written {
+    /** The owner's entry is confirmed at once; a bot's waits as proposed for the owner. */
+    by: Author;
+    project?: string;
+    /** Where a bot's row came from, such as `agent` or an importer's name; the owner's is always `owner`. */
+    source?: string;
+    /** Why a bot proposes it, kept for the reviewer. */
+    reason?: string;
+    /** References it was read from, linked as `evidence`. */
+    evidence?: string[];
+}
+export interface InvoiceLineInput {
+    description: string;
+    /** A decimal string; `1` when not given. */
+    quantity?: string;
+    /** Decimal strings in the invoice's currency. Give either or both: both must agree, quantity × unit price. */
+    unitPrice?: string;
+    amount?: string;
+}
+export interface InvoiceInput extends Written {
+    direction: InvoiceDirection;
+    number?: string;
+    /** `person:` or `organization:`. */
+    issuer?: string;
+    counterparty: string;
+    currency: string;
+    /** `YYYY-MM-DD`. */
+    issueDate?: string;
+    dueDate?: string;
+    /** Kept as a draft until `issueInvoice`; otherwise issued at once. */
+    draft?: boolean;
+    lines: InvoiceLineInput[];
+    /** The total printed on the invoice: refused when it is not the sum of the lines. */
+    total?: string;
+}
+export interface PaymentInput extends Written {
+    direction: MoneyDirection;
+    payer?: string;
+    payee?: string;
+    amount: string;
+    currency: string;
+    date: string;
+    reference?: string;
+    /** Invoices it settles, in the payment's currency; a bot's count only once the owner confirms the payment. */
+    allocations?: {
+        invoice: string;
+        amount: string;
+    }[];
+}
+interface ListFilter {
+    project?: string;
+    review?: FinanceReview;
+    proposedBy?: ProposedByFilter;
+    /** 1–500, 100 by default; newest written first. */
+    limit?: number;
+}
+export interface OpenTotal extends Money {
+    invoices: number;
+}
+export interface FinanceStore {
+    addInvoice(input: InvoiceInput): Promise<InvoiceDetail>;
+    invoice(reference: string): Promise<InvoiceDetail>;
+    invoices(filter?: ListFilter & {
+        direction?: InvoiceDirection;
+        status?: InvoiceStatus;
+        /** Issued or partly paid. */
+        open?: boolean;
+        counterparty?: string;
+    }): Promise<Invoice[]>;
+    /** The owner sends a draft: its status then follows its allocations. */
+    issueInvoice(reference: string, by: Author): Promise<InvoiceDetail>;
+    /** The owner cancels an invoice no confirmed payment is allocated to; proposed allocations to it go. */
+    voidInvoice(reference: string, by: Author): Promise<InvoiceDetail>;
+    addPayment(input: PaymentInput): Promise<PaymentDetail>;
+    payment(reference: string): Promise<PaymentDetail>;
+    payments(filter?: ListFilter & {
+        direction?: MoneyDirection;
+        party?: string;
+    }): Promise<Payment[]>;
+    /**
+     * Settles part of an invoice with part of a payment, in one currency, never beyond either. The owner allocates any
+     * payment; a bot only one it proposed that is still proposed.
+     */
+    allocate(input: {
+        payment: string;
+        invoice: string;
+        amount: string;
+        by: Author;
+    }): Promise<Allocation>;
+    /**
+     * The owner confirms a proposed `invoice:` or `payment:`; only the owner decides money. A payment whose allocations
+     * would settle more than an invoice's total, given the confirmed payments by then, is refused and stays proposed.
+     */
+    confirm(reference: string, by: Decider, reason?: string): Promise<InvoiceDetail | PaymentDetail>;
+    /** The owner turns a proposal down; it stays, `rejected`, and its allocations go. */
+    reject(reference: string, by: Decider, reason?: string): Promise<InvoiceDetail | PaymentDetail>;
+    /** What is still owed on confirmed open invoices, per direction and per currency: nothing is converted. */
+    openTotals(filter?: {
+        project?: string;
+    }): Promise<{
+        receivable: OpenTotal[];
+        payable: OpenTotal[];
+    }>;
+}
+type FinanceOperations = {
+    [K in keyof FinanceStore]: FinanceStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;
+};
+export declare const financeOperationsOver: (context: StoreContext) => FinanceOperations;
+export declare const financeStoreOver: (context: StoreContext) => FinanceStore;
+export {};