@simmalugnt-se/payload-editor-assistant 0.1.0

package/dist/runtime/tools.js

@@ -0,0 +1,189 @@
+import { writeAudit } from "../domain/audit.js";
+import { findContent, findContentById } from "../domain/content.js";
+import { canNavigate, navigateAdmin } from "../domain/navigate.js";
+import { proposeChange } from "../domain/propose.js";
+import { discoverSchema, entityFields } from "../schema/discover.js";
+import { projectRecord } from "../schema/project.js";
+export const TOOL_JSON_SCHEMAS = {
+    "schema.discover": {
+        type: "object",
+        properties: {},
+    },
+    "content.find": {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            collection: { type: "string" },
+            query: { type: "string" },
+        },
+    },
+    "content.findById": {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            collection: { type: "string" },
+            global: { type: "string" },
+            documentId: { type: ["string", "number"] },
+            locale: { type: "string" },
+        },
+    },
+    "form.read": {
+        type: "object",
+        properties: {},
+    },
+    "admin.navigate": {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            collection: { type: "string" },
+            global: { type: "string" },
+            documentId: { type: ["string", "number"] },
+            query: { type: "string" },
+        },
+    },
+    "form.propose": {
+        type: "object",
+        properties: {
+            operations: {
+                description: 'Array of patches. Use dotted paths such as layout.0.headline. Example item: {"op":"set","path":"layout.0.headline","value":"Välkommen"}.',
+            },
+            patches: {},
+            changes: {},
+        },
+    },
+    "draft.create": {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            collection: { type: "string" },
+            operations: { type: "array" },
+        },
+        required: ["collection", "operations"],
+    },
+};
+export const TOOL_DESCRIPTIONS = {
+    "schema.discover": "List allowlisted collections, globals, fields, and constraints. Never invent fields.",
+    "content.find": "Search or list allowlisted documents by title, slug, or id. Omit query to list recent documents. Returns identity only, not a summary.",
+    "content.findById": "Read one allowlisted document or global. Pass locale to read another language of the same document. For the currently open form, prefer form.read.",
+    "form.read": "Read the currently open unsaved form in the current language. No document ID needed.",
+    "form.propose": 'Stage a structured patch against the open unsaved form in the current language. Call this as soon as you have the new field values. Do not ask the editor to confirm in chat; they approve in the panel. Example: {"op":"set","path":"layout.0.headline","value":"Välkommen"}. Requires editor approval.',
+    "admin.navigate": "Navigate Admin to an allowlisted collection, global, or unique document match.",
+    "draft.create": 'Stage creation of one draft document. Requires editor approval. Never publishes. The document starts empty: set top-level fields with {"op":"set","path":"title","value":"Start"}, and add each layout block with {"op":"blocks.insert","path":"layout","index":0,"blockType":"hero","data":{"headline":"Välkommen"}} using only block types and fields from the quoted context. Rich text fields take plain text.',
+};
+/** Provider APIs reject dots in tool names (`^[a-zA-Z0-9_-]+$`). Capability IDs stay dotted. */
+export function toProviderToolName(capability) {
+    return capability.replaceAll(".", "_");
+}
+export function fromProviderToolName(name) {
+    const match = Object.keys(TOOL_JSON_SCHEMAS).find((capability) => toProviderToolName(capability) === name);
+    return match ?? name;
+}
+export async function executeTool(name, input, ctx) {
+    switch (name) {
+        case "schema.discover":
+            return {
+                ok: true,
+                capability: name,
+                data: discoverSchema(ctx.req, ctx.options),
+            };
+        case "content.find":
+            return wrap(name, await findContent(ctx.req, ctx.options, {
+                collection: asString(input.collection),
+                query: asString(input.query) ?? "",
+                locale: ctx.bridge.locale,
+            }));
+        case "content.findById":
+            return wrap(name, await findContentById(ctx.req, ctx.options, {
+                collection: asString(input.collection) ?? ctx.bridge.collection,
+                global: asString(input.global) ?? ctx.bridge.global,
+                documentId: input.documentId ?? ctx.bridge.documentId,
+                locale: asString(input.locale) ?? ctx.bridge.locale,
+            }));
+        case "form.read": {
+            if (!ctx.bridge.collection && !ctx.bridge.global) {
+                return {
+                    ok: false,
+                    capability: name,
+                    error: "tool_denied",
+                    message: "No document is open. Open an allowlisted document to read the form.",
+                };
+            }
+            const fields = entityFields(ctx.req, ctx.options, {
+                collection: ctx.bridge.collection,
+                global: ctx.bridge.global,
+            });
+            const projected = projectRecord(ctx.formData ?? {}, fields, ctx.options.redact, ctx.bridge.collection ?? ctx.bridge.global);
+            return { ok: true, capability: name, data: projected };
+        }
+        case "admin.navigate": {
+            if (!canNavigate(ctx.options)) {
+                return {
+                    ok: false,
+                    capability: name,
+                    error: "tool_denied",
+                    message: "Nothing is allowlisted.",
+                };
+            }
+            const result = await navigateAdmin(ctx.req, ctx.options, {
+                collection: asString(input.collection),
+                global: asString(input.global),
+                documentId: input.documentId,
+                query: asString(input.query),
+                locale: ctx.bridge.locale,
+            });
+            if (!result.ok) {
+                return { ok: false, capability: name, error: result.error, message: result.message };
+            }
+            await writeAudit(ctx.req, ctx.options, {
+                capability: name,
+                risk: "auto",
+                outcome: "executed",
+                targetCollection: asString(input.collection),
+                targetGlobal: asString(input.global),
+                locale: ctx.bridge.locale,
+            });
+            if ("href" in result) {
+                return { ok: true, capability: name, navigate: { href: result.href, label: result.label } };
+            }
+            return { ok: true, capability: name, navigate: { candidates: result.candidates } };
+        }
+        case "form.propose":
+        case "draft.create": {
+            const proposed = await proposeChange(ctx.req, ctx.options, {
+                capability: name,
+                collection: name === "draft.create" ? asString(input.collection) : ctx.bridge.collection,
+                global: name === "form.propose" ? ctx.bridge.global : undefined,
+                documentId: name === "form.propose" ? ctx.bridge.documentId : undefined,
+                locale: ctx.bridge.locale,
+                language: ctx.bridge.language,
+                operations: input.operations ?? input.patches ?? input.changes ?? input.ops,
+                formData: name === "form.propose" ? ctx.formData : undefined,
+            });
+            if (!proposed.ok) {
+                return { ok: false, capability: name, error: proposed.error, message: proposed.message };
+            }
+            return {
+                ok: true,
+                capability: name,
+                pendingApproval: {
+                    title: proposed.title,
+                    summary: proposed.summary,
+                    approvalId: proposed.approvalId,
+                    nonce: proposed.nonce,
+                    capability: name,
+                },
+            };
+        }
+        default:
+            return { ok: false, capability: name, error: "tool_denied", message: "Unknown tool." };
+    }
+}
+function wrap(capability, result) {
+    if (!result.ok) {
+        return { ok: false, capability, error: result.error, message: result.message };
+    }
+    return { ok: true, capability, data: "results" in result ? result.results : result.data };
+}
+function asString(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}

package/dist/runtime/voice.d.ts

@@ -0,0 +1,11 @@
+export declare function editorFacingText(input: {
+    text: string;
+    locale: string;
+    pendingApproval?: {
+        capability: "form.propose" | "draft.create";
+    };
+    expectedProposal?: boolean;
+}): string;
+export declare function stripInternalSpeech(text: string, locale: string): string;
+export declare function approvalCopy(locale: string, capability: "form.propose" | "draft.create"): string;
+export declare function couldNotStageCopy(locale: string): string;

package/dist/runtime/voice.js

@@ -0,0 +1,55 @@
+import { claimedUnstagedChange } from "./propose-loop.js";
+const INTERNAL = /\b(form\.propose|form_propose|draft\.create|draft_create|schema\.discover|content\.find|tool call|tool_denied|allowlist|blockType|capability|JSON|quoted CMS|I've applied|I have applied|I should apply|operations)\b/i;
+const ENGLISH_META = /\b(despite|therefore|however|the tool|I should|I've|has been issued|appropriate turn|proposed values)\b/i;
+export function editorFacingText(input) {
+    if (input.pendingApproval) {
+        return approvalCopy(input.locale, input.pendingApproval.capability);
+    }
+    const cleaned = stripInternalSpeech(input.text, input.locale);
+    if (input.expectedProposal ||
+        claimedUnstagedChange(cleaned) ||
+        claimedUnstagedChange(input.text)) {
+        return couldNotStageCopy(input.locale);
+    }
+    return cleaned || doneCopy(input.locale);
+}
+export function stripInternalSpeech(text, locale) {
+    const swedish = isSwedish(locale);
+    const kept = splitSentences(text).filter((sentence) => {
+        if (INTERNAL.test(sentence)) {
+            return false;
+        }
+        if (swedish && ENGLISH_META.test(sentence) && !/[åäöÅÄÖ]/.test(sentence)) {
+            return false;
+        }
+        return true;
+    });
+    return kept.join(" ").replace(/\s+/g, " ").trim();
+}
+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.";
+    }
+    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.";
+}
+export function couldNotStageCopy(locale) {
+    return isSwedish(locale)
+        ? "Jag kunde inte lägga förslaget i panelen. Försök igen."
+        : "I could not stage the change in the panel. Try again.";
+}
+function doneCopy(locale) {
+    return isSwedish(locale) ? "Klart." : "Done.";
+}
+function isSwedish(locale) {
+    return locale === "sv" || locale.startsWith("sv-");
+}
+function splitSentences(text) {
+    return text
+        .split(/(?<=[.!?])\s+|\n+/)
+        .map((part) => part.trim())
+        .filter(Boolean);
+}

package/dist/schema/discover.d.ts

@@ -0,0 +1,35 @@
+import type { PayloadRequest } from "payload";
+import type { ValidatedEditorAssistantOptions } from "../config/validate.ts";
+import { type FieldNode } from "./fields.ts";
+export type DiscoveredEntity = {
+    kind: "collection" | "global";
+    slug: string;
+    label?: string;
+    drafts?: boolean;
+    upload?: boolean;
+    capabilities: string[];
+    fields: FieldNode[];
+};
+export type EntityConfig = {
+    slug: string;
+    labels?: {
+        singular?: unknown;
+        plural?: unknown;
+    };
+    label?: unknown;
+    fields?: unknown[];
+    versions?: unknown;
+    upload?: unknown;
+    admin?: {
+        useAsTitle?: string;
+    };
+};
+export declare function discoverSchema(req: PayloadRequest, options: ValidatedEditorAssistantOptions): DiscoveredEntity[];
+export declare function findCollectionConfig(req: PayloadRequest, slug: string): EntityConfig | undefined;
+export declare function findGlobalConfig(req: PayloadRequest, slug: string): EntityConfig | undefined;
+export declare function entityFields(req: PayloadRequest, options: ValidatedEditorAssistantOptions, target: {
+    collection?: string;
+    global?: string;
+}): FieldNode[];
+export declare function hasDrafts(versions: unknown): boolean;
+export declare function configuredLocales(req: PayloadRequest): string[];

package/dist/schema/discover.js

@@ -0,0 +1,93 @@
+import { isDeniedCollectionSlug } from "../config/denied-fields.js";
+import { walkFields } from "./fields.js";
+export function discoverSchema(req, options) {
+    const entities = [];
+    for (const [slug, allowlist] of Object.entries(options.collections)) {
+        if (isDeniedCollectionSlug(slug)) {
+            continue;
+        }
+        const config = findCollectionConfig(req, slug);
+        if (!config) {
+            continue;
+        }
+        entities.push({
+            kind: "collection",
+            slug,
+            label: asString(config.labels?.plural) ?? asString(config.labels?.singular) ?? slug,
+            drafts: hasDrafts(config.versions),
+            upload: Boolean(config.upload),
+            capabilities: allowlist.capabilities,
+            fields: walkFields(config.fields, "", allowlist.fields, options.denyFields),
+        });
+    }
+    for (const [slug, allowlist] of Object.entries(options.globals)) {
+        const config = findGlobalConfig(req, slug);
+        if (!config) {
+            continue;
+        }
+        entities.push({
+            kind: "global",
+            slug,
+            label: asString(config.label) ?? slug,
+            capabilities: allowlist.capabilities,
+            fields: walkFields(config.fields, "", allowlist.fields, options.denyFields),
+        });
+    }
+    return entities;
+}
+export function findCollectionConfig(req, slug) {
+    const collections = req.payload.config.collections;
+    return collections?.find((collection) => collection.slug === slug);
+}
+export function findGlobalConfig(req, slug) {
+    const globals = req.payload.config.globals;
+    return globals?.find((global) => global.slug === slug);
+}
+export function entityFields(req, options, target) {
+    if (target.collection) {
+        const allowlist = options.collections[target.collection];
+        const config = findCollectionConfig(req, target.collection);
+        if (!allowlist || !config) {
+            return [];
+        }
+        return walkFields(config.fields, "", allowlist.fields, options.denyFields);
+    }
+    if (target.global) {
+        const allowlist = options.globals[target.global];
+        const config = findGlobalConfig(req, target.global);
+        if (!allowlist || !config) {
+            return [];
+        }
+        return walkFields(config.fields, "", allowlist.fields, options.denyFields);
+    }
+    return [];
+}
+export function hasDrafts(versions) {
+    if (!versions || typeof versions !== "object") {
+        return false;
+    }
+    return Boolean(versions.drafts);
+}
+function asString(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+export function configuredLocales(req) {
+    const localization = req.payload.config.localization;
+    if (!localization || typeof localization !== "object") {
+        return [];
+    }
+    const locales = localization.locales;
+    if (!Array.isArray(locales)) {
+        return [];
+    }
+    return locales.flatMap((entry) => {
+        if (typeof entry === "string" && entry.trim()) {
+            return [entry];
+        }
+        if (entry && typeof entry === "object" && "code" in entry) {
+            const code = entry.code;
+            return typeof code === "string" && code.trim() ? [code] : [];
+        }
+        return [];
+    });
+}

package/dist/schema/fields.d.ts

@@ -0,0 +1,21 @@
+import type { FieldAllowlist } from "../types.ts";
+export type FieldNode = {
+    name: string;
+    type: string;
+    path: string;
+    required?: boolean;
+    localized?: boolean;
+    relationTo?: string[];
+    hasMany?: boolean;
+    options?: string[];
+    label?: string;
+    description?: string;
+    fields?: FieldNode[];
+    blocks?: Array<{
+        slug: string;
+        fields: FieldNode[];
+    }>;
+};
+export declare function isFieldAllowed(name: string, path: string, allowlist: FieldAllowlist | undefined, denyFields: string[]): boolean;
+export declare function walkFields(fields: unknown[] | undefined, parentPath: string, allowlist: FieldAllowlist | undefined, denyFields: string[]): FieldNode[];
+export declare function findFieldNode(nodes: FieldNode[], path: string): FieldNode | undefined;

package/dist/schema/fields.js

@@ -0,0 +1,139 @@
+import { isDeniedFieldName } from "../config/denied-fields.js";
+const SKIP_TYPES = new Set(["ui", "join", "row", "collapsible", "tabs"]);
+export function isFieldAllowed(name, path, allowlist, denyFields) {
+    if (isDeniedFieldName(name) || denyFields.includes(name)) {
+        return false;
+    }
+    if (!allowlist || allowlist === true) {
+        return true;
+    }
+    if ("include" in allowlist) {
+        return allowlist.include.some((entry) => entry === name || entry === path || path === entry || path.startsWith(`${entry}.`));
+    }
+    if ("exclude" in allowlist) {
+        return !allowlist.exclude.includes(name);
+    }
+    return true;
+}
+export function walkFields(fields, parentPath, allowlist, denyFields) {
+    const nodes = [];
+    for (const raw of fields ?? []) {
+        nodes.push(...walkField(raw, parentPath, allowlist, denyFields));
+    }
+    return nodes;
+}
+function walkField(field, parentPath, allowlist, denyFields) {
+    if (!field || typeof field !== "object") {
+        return [];
+    }
+    const type = field.type ?? "unknown";
+    if (type === "tabs") {
+        const nested = [];
+        for (const tab of field.tabs ?? []) {
+            const tabPath = tab.name ? joinPath(parentPath, tab.name) : parentPath;
+            nested.push(...walkFields(tab.fields, tabPath, allowlist, denyFields));
+        }
+        return nested;
+    }
+    if (type === "ui" || type === "join") {
+        return [];
+    }
+    if (type === "row" || type === "collapsible") {
+        return walkFields(field.fields, parentPath, allowlist, denyFields);
+    }
+    if (!field.name) {
+        return walkFields(field.fields, parentPath, allowlist, denyFields);
+    }
+    const path = joinPath(parentPath, field.name);
+    if (!isFieldAllowed(field.name, path, allowlist, denyFields)) {
+        return [];
+    }
+    const node = {
+        name: field.name,
+        type,
+        path,
+        required: field.required,
+        localized: field.localized,
+        hasMany: field.hasMany,
+        relationTo: normalizeRelationTo(field.relationTo),
+        options: optionValues(field.options),
+        label: asLabel(field.label) ?? field.name,
+        description: asLabel(field.admin?.description),
+    };
+    if (type === "group" || type === "array") {
+        node.fields = walkFields(field.fields, path, allowlist, denyFields);
+    }
+    if (type === "blocks") {
+        node.blocks = (field.blocks ?? [])
+            .filter((block) => Boolean(block.slug))
+            .map((block) => ({
+            slug: block.slug,
+            fields: walkFields(block.fields, path, allowlist, denyFields),
+        }));
+    }
+    if (SKIP_TYPES.has(type) && node.fields) {
+        return node.fields;
+    }
+    return [node];
+}
+export function findFieldNode(nodes, path) {
+    for (const node of nodes) {
+        if (node.path === path) {
+            return node;
+        }
+        if (node.fields) {
+            const nested = findFieldNode(node.fields, path);
+            if (nested) {
+                return nested;
+            }
+        }
+        if (node.blocks) {
+            for (const block of node.blocks) {
+                const nested = findFieldNode(block.fields, path);
+                if (nested) {
+                    return nested;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function joinPath(parent, name) {
+    return parent ? `${parent}.${name}` : name;
+}
+function normalizeRelationTo(value) {
+    if (!value) {
+        return undefined;
+    }
+    return Array.isArray(value) ? value : [value];
+}
+function optionValues(options) {
+    if (!Array.isArray(options)) {
+        return undefined;
+    }
+    const values = options
+        .map((option) => {
+        if (typeof option === "string") {
+            return option;
+        }
+        if (option && typeof option === "object" && "value" in option) {
+            return String(option.value);
+        }
+        return undefined;
+    })
+        .filter((value) => Boolean(value));
+    return values.length > 0 ? values : undefined;
+}
+function asLabel(value) {
+    if (typeof value === "string" && value.trim()) {
+        return value;
+    }
+    if (value && typeof value === "object") {
+        for (const entry of Object.values(value)) {
+            if (typeof entry === "string" && entry.trim()) {
+                return entry;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/schema/project.d.ts

@@ -0,0 +1,15 @@
+import type { FieldAllowlist } from "../types.ts";
+import { type FieldNode } from "./fields.ts";
+export declare function projectRecord(data: Record<string, unknown> | null | undefined, fields: FieldNode[], redact?: (input: {
+    slug: string;
+    data: Record<string, unknown>;
+}) => Record<string, unknown>, slug?: string): {
+    data: Record<string, unknown>;
+    truncated: boolean;
+};
+export declare function projectIdentity(doc: Record<string, unknown>, locale?: string): Record<string, unknown>;
+export declare function capRecord(data: Record<string, unknown>): {
+    data: Record<string, unknown>;
+    truncated: boolean;
+};
+export declare function filterRootKeys(data: Record<string, unknown>, allowlist: FieldAllowlist | undefined, denyFields: string[]): Record<string, unknown>;

package/dist/schema/project.js

@@ -0,0 +1,111 @@
+import { isDeniedFieldName } from "../config/denied-fields.js";
+import { isFieldAllowed } from "./fields.js";
+const MAX_CHARS = 16_000;
+export function projectRecord(data, fields, redact, slug = "") {
+    const projected = {};
+    if (!data) {
+        return { data: projected, truncated: false };
+    }
+    for (const field of fields) {
+        if (!(field.name in data)) {
+            continue;
+        }
+        projected[field.name] = projectValue(data[field.name], field);
+    }
+    const redacted = redact ? redact({ slug, data: projected }) : projected;
+    return capRecord(redacted);
+}
+export function projectIdentity(doc, locale) {
+    const identity = {
+        id: doc.id,
+    };
+    for (const key of ["title", "slug", "name", "label", "_status"]) {
+        if (key in doc && !isDeniedFieldName(key)) {
+            identity[key] = doc[key];
+        }
+    }
+    if (locale) {
+        identity.locale = locale;
+    }
+    return identity;
+}
+export function capRecord(data) {
+    const encoded = JSON.stringify(data);
+    if (encoded.length <= MAX_CHARS) {
+        return { data, truncated: false };
+    }
+    return {
+        data: {
+            incomplete: true,
+            notice: "Result truncated because it exceeded the size cap.",
+            preview: encoded.slice(0, MAX_CHARS),
+        },
+        truncated: true,
+    };
+}
+export function filterRootKeys(data, allowlist, denyFields) {
+    const next = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (isFieldAllowed(key, key, allowlist, denyFields)) {
+            next[key] = value;
+        }
+    }
+    return next;
+}
+function projectValue(value, field) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (field.type === "array" && Array.isArray(value)) {
+        return value.map((item) => item && typeof item === "object" && !Array.isArray(item)
+            ? projectRecord(item, field.fields ?? []).data
+            : item);
+    }
+    if (field.type === "blocks" && Array.isArray(value)) {
+        return value.map((item) => {
+            if (!item || typeof item !== "object" || Array.isArray(item)) {
+                return item;
+            }
+            const record = item;
+            const blockType = typeof record.blockType === "string" ? record.blockType : "";
+            const block = field.blocks?.find((entry) => entry.slug === blockType);
+            const projected = projectRecord(record, block?.fields ?? []).data;
+            return {
+                id: record.id,
+                blockType,
+                ...projected,
+            };
+        });
+    }
+    if (field.type === "group" && value && typeof value === "object" && !Array.isArray(value)) {
+        return projectRecord(value, field.fields ?? []).data;
+    }
+    if (field.type === "relationship" || field.type === "upload") {
+        return projectRelation(value);
+    }
+    return value;
+}
+function projectRelation(value) {
+    if (Array.isArray(value)) {
+        return value.map(projectRelation);
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        return value;
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        if ("relationTo" in record && "value" in record) {
+            return { relationTo: record.relationTo, value: idOf(record.value) };
+        }
+        if ("id" in record) {
+            return record.id;
+        }
+    }
+    return value;
+}
+function idOf(value) {
+    if (value && typeof value === "object" && "id" in value) {
+        return value.id;
+    }
+    return value;
+}