@simmalugnt-se/payload-editor-assistant 0.10.0 → 0.11.1

package/dist/components/batch-run.js

@@ -0,0 +1,67 @@
+/**
+ * The batch panel's cards and what each step does to them. Pure: the panel runs the requests one
+ * after the other and feeds the answers in here.
+ */
+import { batchTargetKey } from "../batch/targets.js";
+export function initialCards(targets, infos) {
+    return targets.map((target) => {
+        const key = batchTargetKey(target);
+        const info = infos?.find((entry) => entry.key === key);
+        return {
+            key,
+            target,
+            title: info?.title ?? target.id,
+            thumbnail: info?.thumbnail,
+            drafts: info?.drafts ?? false,
+            status: info && !info.allowed ? "unavailable" : "waiting",
+            checked: false,
+            edits: {},
+        };
+    });
+}
+/** Documents still to ask the assistant about, in order. */
+export function waitingKeys(cards) {
+    return cards.filter((card) => card.status === "waiting").map((card) => card.key);
+}
+export function cardAfterPropose(card, answer) {
+    const base = { ...card, edits: {}, proposal: undefined, error: undefined };
+    if (!answer.ok) {
+        return answer.error === "nothing_to_do"
+            ? { ...base, status: "nothing", checked: false }
+            : { ...base, status: "failed", error: answer.error, text: answer.message, checked: false };
+    }
+    if (!answer.proposal) {
+        return { ...base, status: "nothing", text: answer.text, checked: false };
+    }
+    return {
+        ...base,
+        status: "proposed",
+        text: answer.text,
+        proposal: answer.proposal,
+        checked: true,
+    };
+}
+/** What saving the batch does per card: apply the checked proposals, reject the others. */
+export function savePlan(cards) {
+    return cards
+        .filter((card) => card.status === "proposed" && card.proposal)
+        .map((card) => ({ key: card.key, action: card.checked ? "apply" : "reject" }));
+}
+/** The editor's wording where it differs from the proposal's. */
+export function changedEdits(card) {
+    const changed = {};
+    for (const line of card.proposal?.lines ?? []) {
+        const edited = card.edits[line.path];
+        if (line.edit && edited !== undefined && edited !== line.edit.value) {
+            changed[line.path] = edited;
+        }
+    }
+    return changed;
+}
+export function cardAfterApply(card, answer) {
+    if (answer.ok) {
+        return { ...card, status: answer.status };
+    }
+    const status = answer.error === "stale_context" ? "stale" : answer.error === "locked" ? "locked" : "failed";
+    return { ...card, status, error: answer.error, text: answer.message };
+}

package/dist/components/copy.d.ts

@@ -141,3 +141,85 @@ export declare function translateAction(language: UiLanguage, source: string): {
     label: string;
     prompt: string;
 };
+/** What the batch panel says: fixing many documents at once from the work list. */
+export declare const BATCH_COPY: {
+    readonly en: {
+        readonly title: (count: number) => string;
+        readonly task: "Task";
+        readonly intro: (count: number) => string;
+        readonly start: "Start";
+        readonly continue: "Continue";
+        readonly stop: "Stop";
+        readonly cancel: "Cancel";
+        readonly close: "Close";
+        readonly progress: (done: number, total: number) => string;
+        readonly save: (count: number) => string;
+        readonly saving: "Saving…";
+        readonly review: "Check the suggestions. Uncheck any you do not want, or change the wording before saving.";
+        readonly savesDraft: "Saved as a draft; nothing is published.";
+        readonly savesDirectly: "Saved directly: this collection has no drafts.";
+        readonly before: "Before";
+        readonly empty: "empty";
+        readonly retry: "Try again";
+        readonly retryWith: "What should be different? (optional)";
+        readonly retrySend: "Ask again";
+        readonly open: "Open";
+        readonly select: (title: string) => string;
+        readonly status: {
+            readonly waiting: "Waiting";
+            readonly working: "Working…";
+            readonly proposed: "Suggested";
+            readonly nothing: "No change";
+            readonly failed: "Failed";
+            readonly saving: "Saving…";
+            readonly saved: "Saved";
+            readonly draft: "Saved as draft";
+            readonly stale: "Changed since the suggestion";
+            readonly locked: "Someone else is editing it";
+            readonly rejected: "Not saved";
+            readonly unavailable: "Not available";
+        };
+        readonly staleHint: "Someone changed the document after the suggestion. Open it, or try again.";
+        readonly summary: (saved: number, skipped: number) => string;
+    };
+    readonly sv: {
+        readonly title: (count: number) => string;
+        readonly task: "Uppgift";
+        readonly intro: (count: number) => string;
+        readonly start: "Starta";
+        readonly continue: "Fortsätt";
+        readonly stop: "Stoppa";
+        readonly cancel: "Avbryt";
+        readonly close: "Stäng";
+        readonly progress: (done: number, total: number) => string;
+        readonly save: (count: number) => string;
+        readonly saving: "Sparar…";
+        readonly review: "Granska förslagen. Kryssa ur dem du inte vill ha, eller ändra formuleringen innan du sparar.";
+        readonly savesDraft: "Sparas som utkast; inget publiceras.";
+        readonly savesDirectly: "Sparas direkt: den här samlingen har inga utkast.";
+        readonly before: "Före";
+        readonly empty: "tomt";
+        readonly retry: "Försök igen";
+        readonly retryWith: "Vad ska bli annorlunda? (valfritt)";
+        readonly retrySend: "Fråga igen";
+        readonly open: "Öppna";
+        readonly select: (title: string) => string;
+        readonly status: {
+            readonly waiting: "Väntar";
+            readonly working: "Arbetar…";
+            readonly proposed: "Förslag";
+            readonly nothing: "Ingen ändring";
+            readonly failed: "Misslyckades";
+            readonly saving: "Sparar…";
+            readonly saved: "Sparat";
+            readonly draft: "Sparat som utkast";
+            readonly stale: "Ändrat sedan förslaget";
+            readonly locked: "Någon annan redigerar";
+            readonly rejected: "Inte sparat";
+            readonly unavailable: "Inte tillgängligt";
+        };
+        readonly staleHint: "Någon ändrade dokumentet efter förslaget. Öppna det, eller försök igen.";
+        readonly summary: (saved: number, skipped: number) => string;
+    };
+};
+export type BatchCopy = (typeof BATCH_COPY)[UiLanguage];

package/dist/components/copy.js

@@ -151,3 +151,84 @@ function languageName(language, code) {
         return code;
     }
 }
+/** What the batch panel says: fixing many documents at once from the work list. */
+export const BATCH_COPY = {
+    en: {
+        title: (count) => `Fix ${count} ${count === 1 ? "document" : "documents"}`,
+        task: "Task",
+        intro: (count) => `The assistant goes through them one at a time and suggests a change for each: ${count} ${count === 1 ? "request" : "requests"} to the AI model. Nothing is saved until you save the ones you want.`,
+        start: "Start",
+        continue: "Continue",
+        stop: "Stop",
+        cancel: "Cancel",
+        close: "Close",
+        progress: (done, total) => `${done} of ${total}`,
+        save: (count) => `Save ${count} selected`,
+        saving: "Saving…",
+        review: "Check the suggestions. Uncheck any you do not want, or change the wording before saving.",
+        savesDraft: "Saved as a draft; nothing is published.",
+        savesDirectly: "Saved directly: this collection has no drafts.",
+        before: "Before",
+        empty: "empty",
+        retry: "Try again",
+        retryWith: "What should be different? (optional)",
+        retrySend: "Ask again",
+        open: "Open",
+        select: (title) => `Save the change to ${title}`,
+        status: {
+            waiting: "Waiting",
+            working: "Working…",
+            proposed: "Suggested",
+            nothing: "No change",
+            failed: "Failed",
+            saving: "Saving…",
+            saved: "Saved",
+            draft: "Saved as draft",
+            stale: "Changed since the suggestion",
+            locked: "Someone else is editing it",
+            rejected: "Not saved",
+            unavailable: "Not available",
+        },
+        staleHint: "Someone changed the document after the suggestion. Open it, or try again.",
+        summary: (saved, skipped) => skipped ? `${saved} saved, ${skipped} not saved.` : `${saved} saved.`,
+    },
+    sv: {
+        title: (count) => `Åtgärda ${count} dokument`,
+        task: "Uppgift",
+        intro: (count) => `Assistenten går igenom dem ett i taget och föreslår en ändring för varje: ${count} anrop till AI-modellen. Inget sparas förrän du sparar de förslag du vill ha.`,
+        start: "Starta",
+        continue: "Fortsätt",
+        stop: "Stoppa",
+        cancel: "Avbryt",
+        close: "Stäng",
+        progress: (done, total) => `${done} av ${total}`,
+        save: (count) => `Spara ${count} valda`,
+        saving: "Sparar…",
+        review: "Granska förslagen. Kryssa ur dem du inte vill ha, eller ändra formuleringen innan du sparar.",
+        savesDraft: "Sparas som utkast; inget publiceras.",
+        savesDirectly: "Sparas direkt: den här samlingen har inga utkast.",
+        before: "Före",
+        empty: "tomt",
+        retry: "Försök igen",
+        retryWith: "Vad ska bli annorlunda? (valfritt)",
+        retrySend: "Fråga igen",
+        open: "Öppna",
+        select: (title) => `Spara ändringen i ${title}`,
+        status: {
+            waiting: "Väntar",
+            working: "Arbetar…",
+            proposed: "Förslag",
+            nothing: "Ingen ändring",
+            failed: "Misslyckades",
+            saving: "Sparar…",
+            saved: "Sparat",
+            draft: "Sparat som utkast",
+            stale: "Ändrat sedan förslaget",
+            locked: "Någon annan redigerar",
+            rejected: "Inte sparat",
+            unavailable: "Inte tillgängligt",
+        },
+        staleHint: "Någon ändrade dokumentet efter förslaget. Öppna det, eller försök igen.",
+        summary: (saved, skipped) => skipped ? `${saved} sparade, ${skipped} inte sparade.` : `${saved} sparade.`,
+    },
+};

package/dist/config/validate.js

@@ -39,6 +39,9 @@ function validateEntityMap(kind, map, rules) {
             if (capability === "draft.create" && !rules.allowDraftCreate) {
                 throw new Error(`payload-editor-assistant: globals cannot enable draft.create ("${slug}").`);
             }
+            if (capability === "content.update" && kind === "globals") {
+                throw new Error(`payload-editor-assistant: content.update is for collections, not globals ("${slug}").`);
+            }
             if (capability === "media.view" && kind === "globals") {
                 throw new Error(`payload-editor-assistant: media.view is for upload collections, not globals ("${slug}").`);
             }

package/dist/domain/audit.d.ts

@@ -14,4 +14,6 @@ export declare function writeAudit(req: PayloadRequest, options: ValidatedEditor
     canonicalHash?: string;
     baseRevision?: string;
     errorClass?: string;
+    /** `batch:<id>` for the documents of one batch. */
+    requestId?: string;
 }): Promise<void>;

package/dist/domain/audit.js

@@ -17,6 +17,7 @@ export async function writeAudit(req, options, event) {
             canonicalHash: event.canonicalHash,
             baseRevision: event.baseRevision,
             errorClass: event.errorClass,
+            requestId: event.requestId,
         },
         req,
         overrideAccess: false,

package/dist/domain/batch.d.ts

@@ -0,0 +1,74 @@
+import type { PayloadRequest } from "payload";
+import type { BatchScope, BatchTarget } from "../batch/targets.ts";
+import type { ValidatedEditorAssistantOptions } from "../config/validate.ts";
+import { runAgentTurn } from "../runtime/agent.ts";
+import type { ProposalLine } from "./propose.ts";
+export type BatchProposeInput = {
+    target: BatchTarget;
+    scope: BatchScope;
+    /** The task, as content health words it for the check. */
+    prompt: string;
+    /** What the editor added when asking again, e.g. "shorter". */
+    instruction?: string;
+    /** Admin's language: the reply and the change list are shown in it. */
+    language: "sv" | "en";
+    batchId: string;
+};
+export type BatchProposeResult = {
+    ok: true;
+    /** The model's one-sentence reply, shown with the change or instead of one. */
+    text: string;
+    proposal?: {
+        approvalId: string;
+        nonce: string;
+        lines: ProposalLine[];
+    };
+} | {
+    ok: false;
+    error: string;
+    message?: string;
+};
+type Run = typeof runAgentTurn;
+/**
+ * One document of a batch: a turn on the saved document, as if it were open with the finding's field
+ * selected. The model may only propose a `content.update` within the target's fields.
+ */
+export declare function proposeBatchTarget(req: PayloadRequest, options: ValidatedEditorAssistantOptions, input: BatchProposeInput, run?: Run): Promise<BatchProposeResult>;
+export type BatchApplyInput = {
+    action: "apply" | "reject";
+    approvalId: string;
+    nonce: string;
+    batchId: string;
+    /** The editor's own wording for plain text values the proposal set, by path. */
+    edits?: Record<string, string>;
+};
+export type BatchApplyResult = {
+    ok: true;
+    status: "draft" | "saved" | "rejected";
+} | {
+    ok: false;
+    error: "tool_denied" | "stale_context" | "locked";
+    message: string;
+};
+/**
+ * Saves one batch proposal to the document, or rejects it. Checked again as it is saved: the editor,
+ * the one-time approval, `content.update`, and that the saved document is still the one the proposal
+ * was made for. A collection with drafts gets a draft; one without is saved.
+ */
+export declare function applyBatchTarget(req: PayloadRequest, options: ValidatedEditorAssistantOptions, input: BatchApplyInput): Promise<BatchApplyResult>;
+export type BatchTargetInfo = {
+    key: string;
+    /** The document's title, file name or id. */
+    title: string;
+    /** A small image for upload collections, as Payload serves it. */
+    thumbnail?: string;
+    /** Saved as a draft rather than directly. */
+    drafts: boolean;
+    /** The editor may read it and the assistant may change it in a batch. */
+    allowed: boolean;
+};
+/** What the panel shows before the batch runs: titles and whether each document can be changed. */
+export declare function describeBatchTargets(req: PayloadRequest, options: ValidatedEditorAssistantOptions, targets: Array<BatchTarget & {
+    key: string;
+}>): Promise<BatchTargetInfo[]>;
+export {};