@simmalugnt-se/payload-editor-assistant 0.2.0 → 0.3.0

package/dist/runtime/agent.js

@@ -28,7 +28,8 @@ export async function runAgentTurn(req, options, input) {
     const signal = req.signal ? AbortSignal.any([req.signal, timeout]) : timeout;
     const history = truncateMessages(input.messages ?? [{ role: "user", text: input.message }]);
     const captured = [];
-    const tools = buildSdkTools(ai, ctx, captured);
+    const previews = new Map();
+    const tools = buildSdkTools(ai, ctx, captured, previews);
     const turnContext = await loadTurnContext(req, options, input.bridge, input.formData);
     const system = buildSystemPrompt(options.instructions, input.bridge, turnContext);
     const sdkMessages = toSdkMessages(history);
@@ -45,7 +46,7 @@ export async function runAgentTurn(req, options, input) {
             logProviderError(req, "the model returned no result");
             return { ok: false, error: "provider_error" };
         }
-        const collected = collectResult(String(first.text ?? ""), first, captured, input.bridge.language ?? input.bridge.locale);
+        const collected = collectResult(String(first.text ?? ""), first, captured, input.bridge.language ?? input.bridge.locale, false, previews);
         if (!collected.ok) {
             return collected;
         }
@@ -54,11 +55,12 @@ export async function runAgentTurn(req, options, input) {
             pendingApproval: collected.pendingApproval,
             navigate: collected.navigate,
             text: String(first.text ?? ""),
+            request: input.message,
         })) {
             return collected;
         }
         const retryCaptured = [];
-        const retryTools = buildSdkTools(ai, ctx, retryCaptured);
+        const retryTools = buildSdkTools(ai, ctx, retryCaptured, previews);
         const retry = await generate(ai, {
             model,
             system,
@@ -75,9 +77,9 @@ export async function runAgentTurn(req, options, input) {
             signal,
         });
         if (!retry) {
-            return collectResult(String(first.text ?? ""), first, captured, input.bridge.language ?? input.bridge.locale, true);
+            return collectResult(String(first.text ?? ""), first, captured, input.bridge.language ?? input.bridge.locale, true, previews);
         }
-        return collectResult(String(retry.text ?? ""), retry, retryCaptured, input.bridge.language ?? input.bridge.locale, true);
+        return collectResult(String(retry.text ?? ""), retry, retryCaptured, input.bridge.language ?? input.bridge.locale, true, previews);
     }
     catch (error) {
         if (signal.aborted) {
@@ -91,7 +93,7 @@ export async function runAgentTurn(req, options, input) {
         };
     }
 }
-export function collectResult(text, result, captured, locale, expectedProposal = false) {
+export function collectResult(text, result, captured, locale, expectedProposal = false, previews) {
     const outcomes = [...captured];
     harvestOutcomes(outcomes, result.toolResults);
     if (Array.isArray(result.steps)) {
@@ -116,6 +118,10 @@ export function collectResult(text, result, captured, locale, expectedProposal =
             proposeFailed = true;
         }
     }
+    const preview = pendingApproval && previews?.get(pendingApproval.approvalId);
+    if (pendingApproval && preview) {
+        pendingApproval = { ...pendingApproval, preview };
+    }
     return {
         ok: true,
         text: editorFacingText({
@@ -162,7 +168,7 @@ function isToolOutcome(value) {
     const record = value;
     return typeof record.ok === "boolean" && typeof record.capability === "string";
 }
-function buildSdkTools(ai, ctx, captured) {
+function buildSdkTools(ai, ctx, captured, previews) {
     const tools = {};
     for (const capability of Object.keys(TOOL_JSON_SCHEMAS)) {
         const schema = TOOL_JSON_SCHEMAS[capability];
@@ -174,7 +180,14 @@ function buildSdkTools(ai, ctx, captured) {
             execute: async (raw) => {
                 try {
                     const input = raw && typeof raw === "object" ? raw : {};
-                    const outcome = await executeTool(fromProviderToolName(name), input, ctx);
+                    const executed = await executeTool(fromProviderToolName(name), input, ctx);
+                    // The whole form with the change applied is for Admin, not another round through the model.
+                    const { preview, ...outcome } = executed.ok
+                        ? executed
+                        : { ...executed, preview: undefined };
+                    if (preview && executed.ok && executed.pendingApproval) {
+                        previews.set(executed.pendingApproval.approvalId, preview);
+                    }
                     captured.push(outcome);
                     return outcome;
                 }

package/dist/runtime/context.d.ts

@@ -1,6 +1,7 @@
 import type { PayloadRequest } from "payload";
 import type { ValidatedEditorAssistantOptions } from "../config/validate.ts";
 import type { AdminView } from "../view.ts";
+import { type Selection } from "./selection.ts";
 import { type ToolBridge } from "./tools.ts";
 export type TurnContext = {
     allowlist: Array<{
@@ -31,6 +32,8 @@ export type TurnContext = {
     } | null;
     view?: AdminView;
     form?: Record<string, unknown>;
+    /** What the editor clicked or focused; "this" in their message refers to it. */
+    selection?: Selection;
     otherLanguages?: Record<string, Record<string, unknown>>;
     documents: Record<string, unknown>[];
 };

package/dist/runtime/context.js

@@ -1,5 +1,6 @@
 import { findContent, findContentById } from "../domain/content.js";
-import { configuredLocales, discoverSchema } from "../schema/discover.js";
+import { configuredLocales, discoverSchema, entityFields, } from "../schema/discover.js";
+import { resolveSelection } from "./selection.js";
 import { executeTool } from "./tools.js";
 export async function loadTurnContext(req, options, bridge, formData) {
     const ctx = { req, options, bridge, formData };
@@ -13,7 +14,12 @@ export async function loadTurnContext(req, options, bridge, formData) {
             locale: bridge.locale,
         }
         : null;
-    const form = open ? await readOpenForm(ctx) : undefined;
+    const form = open
+        ? ((await readOpenForm(ctx)) ?? (await readSavedDocument(req, options, bridge)))
+        : undefined;
+    const selection = open
+        ? resolveSelection(bridge.selection, form, entityFields(req, options, { collection: bridge.collection, global: bridge.global }))
+        : undefined;
     const listed = await findContent(req, options, {
         collection: bridge.collection ?? (bridge.view?.kind === "list" ? bridge.view.collection : undefined),
         query: "",
@@ -24,7 +30,8 @@ export async function loadTurnContext(req, options, bridge, formData) {
         allowlist: schema.map(compactEntity),
         open,
         view: bridge.view,
-        form: form ?? (open ? await readSavedDocument(req, options, bridge) : undefined),
+        form,
+        selection,
         otherLanguages,
         documents: listed.ok ? listed.results : [],
     };

package/dist/runtime/propose-loop.d.ts

@@ -1,7 +1,16 @@
 export declare function claimedUnstagedChange(text: string): boolean;
+/**
+ * The editor asked for a change and the reply writes a value out in chat ("a tighter version could
+ * be "Visual editing, live"") instead of staging it. Phrasings vary too much to list, so this only
+ * needs the request and a quoted value. A question ("what is this for?") is not a request, so a
+ * value the model volunteers while answering it stays advice.
+ */
+export declare function offeredValue(text: string, request: string): boolean;
 export declare function needsProposeRetry(input: {
     hasOpenDocument: boolean;
     pendingApproval?: unknown;
     navigate?: unknown;
     text: string;
+    /** The editor's latest message. */
+    request?: string;
 }): boolean;

package/dist/runtime/propose-loop.js

@@ -1,11 +1,23 @@
 export function claimedUnstagedChange(text) {
     return CLAIMED_CHANGE.test(text) || ASKED_TO_MUTATE.test(text);
 }
+/**
+ * The editor asked for a change and the reply writes a value out in chat ("a tighter version could
+ * be "Visual editing, live"") instead of staging it. Phrasings vary too much to list, so this only
+ * needs the request and a quoted value. A question ("what is this for?") is not a request, so a
+ * value the model volunteers while answering it stays advice.
+ */
+export function offeredValue(text, request) {
+    return QUOTED.test(text) && ASKS_FOR_CHANGE.test(request);
+}
+// Letter lookarounds rather than \b, which treats å, ä and ö as word boundaries.
+const ASKS_FOR_CHANGE = /(?<!\p{L})(make|change|rewrite|write|add|replace|shorten|tighten|fill|translate|update|improve|set|rename|remove|delete|gör|göra|ändra|skriv|skriva|lägg|lägga|byt|byta|korta|fyll|fylla|översätt|uppdatera|förbättra|sätt|ta bort)(?!\p{L})/iu;
+const QUOTED = /["“”«»][^"“”«»]{2,}["“”«»]|'[^']{2,}'/;
 const CLAIMED_CHANGE = /godkänn|godkann|approve|rubriken är nu|the headline is now|sparas den på sidan|fälten i på sidan|pending form change|i've applied|i have applied/i;
 const ASKED_TO_MUTATE = /ska jag (lägga|fylla|ändra|sätta|uppdatera)|should i (put|fill|change|set|update|apply)|shall i (put|fill|change|set|update|apply)|want me to (put|fill|change|set|update|apply)/i;
 export function needsProposeRetry(input) {
     if (!input.hasOpenDocument || input.pendingApproval || input.navigate) {
         return false;
     }
-    return claimedUnstagedChange(input.text);
+    return claimedUnstagedChange(input.text) || offeredValue(input.text, input.request ?? "");
 }

package/dist/runtime/selection.d.ts

@@ -0,0 +1,28 @@
+import type { FieldNode } from "../schema/fields.ts";
+/** What the editor last clicked or focused in the open form, resolved against the visible fields. */
+export type Selection = {
+    /** Form path, e.g. `layout.2.headline` or `layout.2` for a whole block. */
+    path: string;
+    /** Visible labels from the top down, e.g. `["Hero 3", "Headline"]`. */
+    trail: string[];
+    /** Innermost block or array row the selection sits in. */
+    scope?: {
+        path: string;
+        kind: "block" | "row";
+        label: string;
+        blockType?: string;
+    };
+    /** The selected field when the selection is a single value rather than a whole row. */
+    field?: {
+        path: string;
+        label: string;
+        type: string;
+        value?: unknown;
+    };
+};
+/**
+ * Resolves a path the browser sent against the projected form and the allowlisted fields. Anything
+ * the assistant may not see (denied, excluded, missing) resolves to nothing, so a crafted path
+ * cannot pull hidden values into the prompt.
+ */
+export declare function resolveSelection(raw: unknown, form: Record<string, unknown> | undefined, fields: FieldNode[]): Selection | undefined;

package/dist/runtime/selection.js

@@ -0,0 +1,87 @@
+import { isLexical, lexicalPlaintext } from "../form/lexical.js";
+import { getAtPath, parseFieldPath } from "../form/path.js";
+const PATH = /^[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$/;
+const MAX_VALUE_CHARS = 600;
+const CONTAINER_TYPES = new Set(["group", "array", "blocks"]);
+/**
+ * Resolves a path the browser sent against the projected form and the allowlisted fields. Anything
+ * the assistant may not see (denied, excluded, missing) resolves to nothing, so a crafted path
+ * cannot pull hidden values into the prompt.
+ */
+export function resolveSelection(raw, form, fields) {
+    if (typeof raw !== "string" || !PATH.test(raw) || !form) {
+        return undefined;
+    }
+    const segments = parseFieldPath(raw);
+    const trail = [];
+    let nodes = fields;
+    let node;
+    let scope;
+    let data = form;
+    const walked = [];
+    for (const segment of segments) {
+        walked.push(segment);
+        if (typeof segment === "number") {
+            if (!node || (node.type !== "array" && node.type !== "blocks")) {
+                return undefined;
+            }
+            const item = getAtPath(data, [segment]);
+            if (!item || typeof item !== "object") {
+                return undefined;
+            }
+            const path = walked.join(".");
+            if (node.type === "blocks") {
+                const blockType = item.blockType;
+                const block = node.blocks?.find((entry) => entry.slug === blockType);
+                if (!block) {
+                    return undefined;
+                }
+                const label = `${block.label ?? block.slug} ${segment + 1}`;
+                scope = { path, kind: "block", label, blockType: block.slug };
+                nodes = block.fields;
+                trail.push(label);
+            }
+            else {
+                const label = `${node.label ?? node.name} ${segment + 1}`;
+                scope = { path, kind: "row", label };
+                nodes = node.fields ?? [];
+                trail.push(label);
+            }
+            data = item;
+            node = undefined;
+            continue;
+        }
+        node = nodes.find((entry) => entry.name === segment);
+        if (!node) {
+            return undefined;
+        }
+        // A list's own label repeats in its rows' labels ("Cards 2"), so only rows name it.
+        if (node.type !== "array" && node.type !== "blocks") {
+            trail.push(node.label ?? node.name);
+        }
+        data = getAtPath(data, [segment]);
+        if (node.type === "group") {
+            nodes = node.fields ?? [];
+        }
+    }
+    const field = node && !CONTAINER_TYPES.has(node.type)
+        ? { path: raw, label: node.label ?? node.name, type: node.type, value: preview(data) }
+        : undefined;
+    return { path: raw, trail, scope, field };
+}
+function preview(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (isLexical(value)) {
+        return preview(lexicalPlaintext(value));
+    }
+    if (typeof value === "string") {
+        return value.length <= MAX_VALUE_CHARS ? value : `${value.slice(0, MAX_VALUE_CHARS)}…`;
+    }
+    const json = JSON.stringify(value);
+    if (json === undefined || json.length <= MAX_VALUE_CHARS) {
+        return value;
+    }
+    return `${json.slice(0, MAX_VALUE_CHARS)}…`;
+}

package/dist/runtime/system-prompt.js

@@ -30,10 +30,20 @@ function openDocumentLine(bridge, turnContext) {
         const sources = turnContext?.otherLanguages
             ? " Other language versions of this same page are in the quoted context. If the editor asks to fill or translate empty fields, call form.propose with text written in the open language. Translate from the source language; do not copy the source wording unless they asked to copy it unchanged. Do not ask them to paste. Do not say the source is missing if it is in the context. If a layout block already exists, set its empty text fields; do not insert a new block."
             : "";
-        return `The editor is looking at ${title} in ${language}. Do not ask them which document it is.${sources}`;
+        return `The editor is looking at ${title} in ${language}. Do not ask them which document it is.${sources}${selectionLine(turnContext)}`;
     }
     return `${viewLine(turnContext)}No document is open. You can search, navigate, or create a draft. Form edits need an open document.`;
 }
+function selectionLine(turnContext) {
+    const selection = turnContext?.selection;
+    if (!selection) {
+        return "";
+    }
+    const scope = selection.field
+        ? "change only that field unless they ask for more"
+        : "change only fields inside it unless they ask for more";
+    return ` The editor has selected ${selection.trail.join(" › ")} in the form or preview. When they say "this", "here", "den här", "det här" or name no place, they mean that selection: ${scope}. Refer to it by its labels.`;
+}
 function viewLine(turnContext) {
     const view = turnContext?.view;
     if (view?.kind === "dashboard") {
@@ -65,6 +75,12 @@ function thisTurnBlock(bridge, turnContext) {
             lines.push(`The editor chats in ${languageName(chat)}, so say in one short sentence that the content is written in ${content}.`);
         }
     }
+    const selection = turnContext?.selection;
+    if (selection) {
+        lines.push(selection.field
+            ? `Selected field: ${selection.field.path}.`
+            : `Selected: ${selection.path}; its fields are under that path in the form.`);
+    }
     const form = turnContext?.form;
     if (form) {
         const empty = listEmptyTextPaths(form);

package/dist/runtime/tools.d.ts

@@ -1,5 +1,6 @@
 import type { PayloadRequest } from "payload";
 import type { ValidatedEditorAssistantOptions } from "../config/validate.ts";
+import { type ProposalPreview } from "../domain/propose.ts";
 import type { AdminView } from "../view.ts";
 import type { ChatLanguage } from "./language.ts";
 export type ToolBridge = {
@@ -11,8 +12,12 @@ export type ToolBridge = {
     locale: string;
     /** Language the editor chats in; may differ from `locale`. */
     language?: ChatLanguage;
+    /** Admin's language, for what the panel shows around a proposal (its title and change list). */
+    uiLanguage?: ChatLanguage;
     /** Where the editor is in Admin. Context only; tools act on the open document fields above. */
     view?: AdminView;
+    /** Form path of what the editor last clicked or focused in the open form, unverified. */
+    selection?: string;
 };
 export type ToolContext = {
     req: PayloadRequest;
@@ -40,6 +45,8 @@ export type ToolSuccess = {
             label: string;
         }>;
     };
+    /** For Admin only; the agent keeps it out of what the model sees. */
+    preview?: ProposalPreview;
 };
 export type ToolFailure = {
     ok: false;

package/dist/runtime/tools.js

@@ -155,7 +155,7 @@ export async function executeTool(name, input, ctx) {
                 global: name === "form.propose" ? ctx.bridge.global : undefined,
                 documentId: name === "form.propose" ? ctx.bridge.documentId : undefined,
                 locale: ctx.bridge.locale,
-                language: ctx.bridge.language,
+                language: ctx.bridge.uiLanguage ?? ctx.bridge.language,
                 operations: input.operations ?? input.patches ?? input.changes ?? input.ops,
                 formData: name === "form.propose" ? ctx.formData : undefined,
             });
@@ -172,6 +172,7 @@ export async function executeTool(name, input, ctx) {
                     nonce: proposed.nonce,
                     capability: name,
                 },
+                preview: proposed.preview,
             };
         }
         default:

package/dist/runtime/voice.js

@@ -30,11 +30,11 @@ export function approvalCopy(locale, capability) {
     if (isSwedish(locale)) {
         return capability === "draft.create"
             ? "Utkastet ligger i panelen. Godkänn det så skapas det."
-            : "Förslaget ligger i panelen. Godkänn det så fylls fälten i. Spara sedan som vanligt.";
+            : "Jag har lagt in förslaget i formuläret. Behåll det eller ångra.";
     }
     return capability === "draft.create"
         ? "The draft is ready in the panel. Approve it to create it."
-        : "The change is ready in the panel. Approve it to fill the fields, then save as usual.";
+        : "I've put the change in the form. Keep it or undo it.";
 }
 export function couldNotStageCopy(locale) {
     return isSwedish(locale)

package/dist/schema/fields.d.ts

@@ -13,6 +13,7 @@ export type FieldNode = {
     fields?: FieldNode[];
     blocks?: Array<{
         slug: string;
+        label?: string;
         fields: FieldNode[];
     }>;
 };

package/dist/schema/fields.js

@@ -68,6 +68,7 @@ function walkField(field, parentPath, allowlist, denyFields) {
             .filter((block) => Boolean(block.slug))
             .map((block) => ({
             slug: block.slug,
+            label: asLabel(block.labels?.singular),
             fields: walkFields(block.fields, path, allowlist, denyFields),
         }));
     }