@blokkli/editor 2.0.0-alpha.5 → 2.0.0-alpha.50

package/dist/modules/agent/runtime/app/prompts/fixReadability.js

@@ -0,0 +1,49 @@
+import { defineBlokkliAgentPrompt } from "#blokkli/agent/app/composables";
+export default defineBlokkliAgentPrompt({
+  id: "fix_readability",
+  skills: ["rewrite-and-translate", "asses-and-fix-readability"],
+  tools: [
+    "get_readability_issues",
+    "check_readability_for_texts",
+    "delegate_text_rewrite"
+  ],
+  getLabel: ({ $t }) => {
+    return $t("agentPromptReadabilityLabel", "Fix readability...");
+  },
+  getPrompt: ({ $t }) => {
+    return $t(
+      "agentPromptReadabilityPrompt",
+      "The readability issues have already been analyzed and the fix has been applied. Do not call any more tools. Just very briefly confirm that you are done."
+    );
+  },
+  getUserPrompt: ({ $t }) => {
+    return $t(
+      "agentPromptReadabilityUserPrompt",
+      "Fix the readability of the selected paragraphs."
+    );
+  },
+  async preExecute({ selectedUuids, runTool }) {
+    const readability = await runTool(
+      "get_readability_issues",
+      selectedUuids.length ? {
+        uuids: selectedUuids
+      } : {}
+    );
+    const fields = Object.entries(readability.result).flatMap(
+      ([uuid, fieldMap]) => Object.keys(fieldMap).map((fieldName) => ({ uuid, fieldName }))
+    );
+    return {
+      preSeededResults: [readability],
+      autoExecuteTools: fields.length > 0 ? [
+        {
+          toolName: "delegate_text_rewrite",
+          params: {
+            template: "fix_readability",
+            templateParams: {},
+            fields
+          }
+        }
+      ] : void 0
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/add_content_search_paragraph/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/app/tools/add_content_search_paragraph/index.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
+import { requireBundlePermission } from "../../helpers/validation.js";
+const paramsSchema = z.object({
+  itemId: z.string().describe("Content item ID from search_content results"),
+  itemEntityType: z.string().describe("Entity type of the content item"),
+  itemEntityBundle: z.string().describe("Entity bundle of the content item"),
+  targetBundle: z.string().describe(
+    "Paragraph bundle to create (from targetBundles in search_content results)"
+  ),
+  parent: parentSchema.describe("The parent entity to add the paragraph to"),
+  position: positionSchema
+});
+export default defineBlokkliAgentTool({
+  name: "add_content_search_paragraphs",
+  description: "Add a paragraph using a content item from search results. Use search_content first to find content items, then use this tool to add one to the page. Requires user approval.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "added content paragraph" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t(
+      "aiAgentAddContentSearchBlockRunning",
+      "Adding content paragraph..."
+    );
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["addContentSearchItem"],
+  execute(ctx, params) {
+    const denied = requireBundlePermission(
+      ctx.app,
+      [params.targetBundle],
+      "add"
+    );
+    if (denied) return denied;
+    if (ctx.app.permissions.blockHasRestrictedAncestor(params.parent.uuid)) {
+      return {
+        error: "Permission denied: target parent is inside a block with restricted editing permissions"
+      };
+    }
+    const { $t, types } = ctx.app;
+    const item = {
+      id: params.itemId,
+      entityType: params.itemEntityType,
+      entityBundle: params.itemEntityBundle,
+      title: params.itemId,
+      targetBundles: [params.targetBundle]
+    };
+    const resolved = resolvePosition(
+      ctx.app,
+      params.parent.uuid,
+      params.parent.field,
+      params.position
+    );
+    if ("error" in resolved) return resolved;
+    return {
+      type: "add",
+      label: $t(
+        "aiAgentAddContentSearchBlockDone",
+        "Added @bundle with content ID @id"
+      ).replace("@bundle", types.getBlockLabel(params.targetBundle)).replace("@id", params.itemId),
+      apply: (adapter) => adapter.addContentSearchItem({
+        host: {
+          type: params.parent.type,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field
+        },
+        afterUuid: resolved.afterUuid,
+        item,
+        bundle: params.targetBundle
+      })
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/add_fragment/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/app/tools/add_fragment/index.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
+import { fragmentBlockBundle } from "#blokkli-build/config";
+const paramsSchema = z.object({
+  name: z.string().describe("The fragment name to add"),
+  parent: parentSchema.describe("The parent entity to add the fragment to"),
+  position: positionSchema
+});
+export default defineBlokkliAgentTool({
+  name: "add_fragment",
+  description: "Add a fragment paragraph to the page. Requires user approval before the fragment is actually added.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "added fragment" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentAddFragmentRunning", "Adding fragment...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["fragmentsAddBlock"],
+  execute(ctx, params) {
+    const { fields, definitions, permissions } = ctx.app;
+    if (!permissions.checkBlockBundlePermission(fragmentBlockBundle, "add")) {
+      return {
+        error: "Permission denied: cannot add fragment blocks."
+      };
+    }
+    if (permissions.blockHasRestrictedAncestor(params.parent.uuid)) {
+      return {
+        error: "Permission denied: target parent is inside a block with restricted editing permissions"
+      };
+    }
+    const fragment = definitions.fragmentDefinitions.value.find(
+      (f) => f.name === params.name
+    );
+    if (!fragment) {
+      return { error: `Fragment not found: ${params.name}` };
+    }
+    const field = fields.find(params.parent.uuid, params.parent.field);
+    if (!field) {
+      return {
+        error: `Field not found: ${params.parent.field} on entity ${params.parent.uuid}`
+      };
+    }
+    if (!field.allowedFragments.length) {
+      return {
+        error: `Field "${params.parent.field}" does not allow fragments`
+      };
+    }
+    if (!field.allowedFragments.includes(params.name)) {
+      const allowedIn = ctx.app.dom.getFieldsAllowingFragment(params.name);
+      if (allowedIn.length === 0) {
+        return {
+          error: `Fragment "${params.name}" is not allowed in any currently registered field.`
+        };
+      }
+      const locationsList = allowedIn.map((f) => `${f.fieldName} on ${f.entity.type} ${f.entity.uuid}`).join(", ");
+      return {
+        error: `Fragment "${params.name}" is not allowed in field "${params.parent.field}". This fragment can be added to: ${locationsList}`
+      };
+    }
+    const { $t } = ctx.app;
+    const resolved = resolvePosition(
+      ctx.app,
+      params.parent.uuid,
+      params.parent.field,
+      params.position
+    );
+    if ("error" in resolved) return resolved;
+    return {
+      type: "add",
+      label: $t("aiAgentAddFragmentDone", 'Added fragment "@label"').replace(
+        "@label",
+        fragment.label
+      ),
+      apply: (adapter) => adapter.fragmentsAddBlock({
+        name: params.name,
+        host: {
+          type: params.parent.type,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field
+        },
+        preceedingUuid: resolved.afterUuid
+      })
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/add_media_paragraph/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/app/tools/add_media_paragraph/index.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
+import { requireBundlePermission } from "../../helpers/validation.js";
+const paramsSchema = z.object({
+  mediaId: z.string().describe("Media item ID from search_media results"),
+  mediaBundle: z.string().describe('Media bundle type (e.g., "image")'),
+  targetBundle: z.string().describe(
+    "Paragraph bundle to create (from targetBundles in search_media)"
+  ),
+  parent: parentSchema.describe("The parent entity to add the paragraph to"),
+  position: positionSchema
+});
+export default defineBlokkliAgentTool({
+  name: "add_media_paragraph",
+  description: "Add a paragraph using a media item from the library. Use search_media first to find media items, then use this tool to add one to the page. Requires user approval.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "added media paragraph" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentAddMediaBlockRunning", "Adding media block...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["mediaLibraryAddBlock"],
+  execute(ctx, params) {
+    const denied = requireBundlePermission(
+      ctx.app,
+      [params.targetBundle],
+      "add"
+    );
+    if (denied) return denied;
+    if (ctx.app.permissions.blockHasRestrictedAncestor(params.parent.uuid)) {
+      return {
+        error: "Permission denied: target parent is inside a block with restricted editing permissions"
+      };
+    }
+    const { $t, types } = ctx.app;
+    const item = {
+      itemType: "media_library",
+      mediaId: params.mediaId,
+      mediaBundle: params.mediaBundle,
+      itemBundles: [params.targetBundle],
+      element: () => document.createElement("div")
+    };
+    const resolved = resolvePosition(
+      ctx.app,
+      params.parent.uuid,
+      params.parent.field,
+      params.position
+    );
+    if ("error" in resolved) return resolved;
+    return {
+      type: "add",
+      label: $t("aiAgentAddMediaBlockDone", "Added @bundle with media ID @id").replace("@bundle", types.getBlockLabel(params.targetBundle)).replace("@id", params.mediaId),
+      apply: (adapter) => adapter.mediaLibraryAddBlock({
+        host: {
+          type: params.parent.type,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field
+        },
+        preceedingUuid: resolved.afterUuid,
+        item,
+        targetBundle: params.targetBundle
+      })
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/add_paragraphs/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/app/tools/add_paragraphs/index.js

@@ -0,0 +1,318 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { generateUUID } from "#blokkli/editor/helpers/uuid";
+import {
+  mutationResultSchema,
+  parentSchema,
+  positionSchema,
+  optionValueSchema
+} from "../schemas.js";
+import { resolvePosition, validateOptionValue } from "../helpers.js";
+import { itemEntityType } from "#blokkli-build/config";
+import {
+  getAvailableOptions,
+  optionValueToStorable
+} from "#blokkli/editor/helpers/options";
+const contentFieldValueSchema = z.union([
+  z.string().describe(
+    "Text value for plain/markup content fields, or a URL string (starting with http) for link content fields"
+  ),
+  z.object({
+    entityType: z.string().describe('Entity type (e.g., "media", "node")'),
+    entityId: z.string().describe("Entity ID")
+  }).describe(
+    "Entity reference for reference content fields (media, content references)"
+  )
+]);
+const contentFieldsSchema = z.record(
+  z.string().describe("The content field name"),
+  contentFieldValueSchema
+).optional().describe(
+  "Content field values to set on the new paragraph, keyed by field name. Use this to set text content and media/entity references in one step."
+);
+const blockSchema = z.object({
+  bundle: z.string().describe("The paragraph bundle to add"),
+  contentFields: contentFieldsSchema,
+  options: z.record(z.string(), optionValueSchema).optional().describe(
+    "Paragraph options to set as key-value pairs (e.g. alignment, style). Use get_bundle_info to see available options."
+  ),
+  children: z.record(
+    z.string().describe("Paragraph field name"),
+    z.lazy(() => z.array(blockSchema)).describe("Child paragraphs for this field")
+  ).optional().describe(
+    "Nested child paragraphs keyed by paragraph field name. Recursive \u2014 children can also have children."
+  )
+});
+const paramsSchema = z.object({
+  paragraphs: z.array(blockSchema).min(1).describe("Array of paragraphs to add, in order"),
+  parent: parentSchema.describe("The parent entity to add the paragraphs to"),
+  position: positionSchema
+});
+function validateContentFields(ctx, block, path) {
+  if (!block.contentFields) return void 0;
+  for (const [fieldName, fieldValue] of Object.entries(block.contentFields)) {
+    const editableConfig = ctx.app.types.editableFieldConfig.forName(
+      ctx.itemEntityType,
+      block.bundle,
+      fieldName
+    );
+    const droppableConfig = ctx.app.types.droppableFieldConfig.forName(
+      ctx.itemEntityType,
+      block.bundle,
+      fieldName
+    );
+    if (!editableConfig && !droppableConfig) {
+      const editableFieldNames = ctx.app.types.editableFieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, block.bundle).map((f) => f.name);
+      const droppableFieldNames = ctx.app.types.droppableFieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, block.bundle).map((f) => f.name);
+      const availableFields = [...editableFieldNames, ...droppableFieldNames];
+      return `${path}: Field "${fieldName}" does not exist on bundle "${block.bundle}". ` + (availableFields.length ? `Available content fields: ${availableFields.join(", ")}` : "This bundle has no content fields.");
+    }
+    if (editableConfig && typeof fieldValue !== "string") {
+      return `${path}: Field "${fieldName}" is a text field and expects a string value, got ${typeof fieldValue}.`;
+    }
+    if (droppableConfig) {
+      if (typeof fieldValue === "string" && droppableConfig.type !== "link") {
+        return `${path}: Field "${fieldName}" is a reference field and expects { entityType, entityId }, got a string.`;
+      }
+    }
+  }
+  return void 0;
+}
+function validateBlockOptions(ctx, block, path, parentBundle) {
+  if (!block.options) return void 0;
+  const { definitions } = ctx.app;
+  const definition = definitions.getBlockDefinition(
+    block.bundle,
+    "default",
+    parentBundle
+  );
+  if (!definition) {
+    return `${path}: Paragraph definition not found for bundle "${block.bundle}".`;
+  }
+  const availableOptions = getAvailableOptions(
+    definition.options,
+    definition.globalOptions,
+    definitions.globalOptions.value
+  );
+  for (const [key, value] of Object.entries(block.options)) {
+    const optionDef = availableOptions.find((o) => o.property === key);
+    if (!optionDef) {
+      const availableKeys = availableOptions.map((o) => o.property);
+      return `${path}: Option "${key}" is not available for bundle "${block.bundle}". ` + (availableKeys.length ? `Available options: ${availableKeys.join(", ")}` : "This bundle has no options.");
+    }
+    const valueError = validateOptionValue(key, value, optionDef);
+    if (valueError) {
+      return `${path}: ${valueError}`;
+    }
+  }
+  return void 0;
+}
+function validateBlockTree(ctx, blocks, allowedBundles, fieldLabel, pathPrefix, parentBundle) {
+  const { types } = ctx.app;
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const path = `${pathPrefix}Paragraph ${i + 1}`;
+    const bundleDefinition = types.getBlockBundleDefinition(block.bundle);
+    if (!bundleDefinition) {
+      return `${path}: Bundle "${block.bundle}" does not exist.`;
+    }
+    if (allowedBundles.length && !allowedBundles.includes(block.bundle)) {
+      return `${path}: Bundle "${block.bundle}" is not allowed in field "${fieldLabel}". Allowed bundles: ${allowedBundles.join(", ")}`;
+    }
+    if (!ctx.app.permissions.checkBlockBundlePermission(block.bundle, "add")) {
+      return `${path}: Permission denied: cannot add "${bundleDefinition.label}" blocks.`;
+    }
+    const contentError = validateContentFields(ctx, block, path);
+    if (contentError) return contentError;
+    const optionsError = validateBlockOptions(ctx, block, path, parentBundle);
+    if (optionsError) return optionsError;
+    if (block.children) {
+      for (const [childFieldName, childBlocks] of Object.entries(
+        block.children
+      )) {
+        const childFieldConfig = types.fieldConfig.forName(
+          ctx.itemEntityType,
+          block.bundle,
+          childFieldName
+        );
+        if (!childFieldConfig) {
+          const availableBlockFields = types.fieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, block.bundle).map((f) => f.name);
+          return `${path}: Paragraph field "${childFieldName}" does not exist on bundle "${block.bundle}". ` + (availableBlockFields.length ? `Available paragraph fields: ${availableBlockFields.join(", ")}` : "This bundle has no paragraph fields.");
+        }
+        if (!childBlocks.length) continue;
+        const childError = validateBlockTree(
+          ctx,
+          childBlocks,
+          childFieldConfig.allowedBundles,
+          childFieldName,
+          `${path} > ${childFieldName} > `,
+          block.bundle
+        );
+        if (childError) return childError;
+      }
+    }
+  }
+  return void 0;
+}
+function buildEventBlocks(ctx, blocks, parentBundle) {
+  const { definitions } = ctx.app;
+  return blocks.map((block) => {
+    const blockUuid = generateUUID();
+    const values = block.contentFields ? Object.entries(block.contentFields).map(([fieldName, fieldValue]) => ({
+      fieldName,
+      fieldValue
+    })) : void 0;
+    let options;
+    if (block.options) {
+      const definition = definitions.getBlockDefinition(
+        block.bundle,
+        "default",
+        parentBundle
+      );
+      if (definition) {
+        const availableOptions = getAvailableOptions(
+          definition.options,
+          definition.globalOptions,
+          definitions.globalOptions.value
+        );
+        options = {};
+        for (const [key, value] of Object.entries(block.options)) {
+          const optionDef = availableOptions.find((o) => o.property === key);
+          if (optionDef) {
+            options[key] = optionValueToStorable(optionDef.option, value);
+          }
+        }
+      }
+    }
+    let children;
+    if (block.children) {
+      children = {};
+      for (const [fieldName, childBlocks] of Object.entries(block.children)) {
+        if (childBlocks.length) {
+          children[fieldName] = buildEventBlocks(
+            ctx,
+            childBlocks,
+            block.bundle
+          );
+        }
+      }
+    }
+    return {
+      bundle: block.bundle,
+      blockUuid,
+      values,
+      options,
+      children
+    };
+  });
+}
+function countBlocks(blocks) {
+  let count = blocks.length;
+  for (const block of blocks) {
+    if (block.children) {
+      for (const childBlocks of Object.values(block.children)) {
+        count += countBlocks(childBlocks);
+      }
+    }
+  }
+  return count;
+}
+function collectAllUuids(blocks) {
+  const uuids = [];
+  for (const block of blocks) {
+    uuids.push(block.blockUuid);
+    if (block.children) {
+      for (const childBlocks of Object.values(block.children)) {
+        uuids.push(...collectAllUuids(childBlocks));
+      }
+    }
+  }
+  return uuids;
+}
+export default defineBlokkliAgentTool({
+  name: "add_paragraphs",
+  description: "Add one or more new paragraphs to the page. Supports nested structures via the `children` property \u2014 define entire paragraph trees in a single call. IMPORTANT: Always provide content field values (text, media/entity references) directly via contentFields, instead of adding empty paragraphs! For reference content fields (media), set the value to { entityType, entityId } from search_media results. NOTE: You can ONLY provide content fields, NOT paragraph fields! For nested paragraphs, use the `children` property keyed by paragraph field name. You can also set paragraph options inline via the `options` property (key-value pairs).",
+  category: "mutation",
+  lazy: false,
+  prunedSummary: (r) => r.success ? `added ${r.newParagraphs?.length || 0} paragraphs` : "rejected",
+  modes: ["editing"],
+  label($t) {
+    return $t("aiAgentAddBlocksRunning", "Adding blocks...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["addNewBlocks"],
+  execute(ctx, params) {
+    const { types, context, blocks } = ctx.app;
+    const isRootEntity = params.parent.uuid === context.value.entityUuid;
+    const entityType = isRootEntity ? context.value.entityType : itemEntityType;
+    const bundle = isRootEntity ? context.value.entityBundle : blocks.getBlock(params.parent.uuid)?.bundle;
+    if (!bundle) {
+      return {
+        error: "Parent not found."
+      };
+    }
+    const field = types.getFieldConfig(entityType, bundle, params.parent.field);
+    if (!field) {
+      const availableFields = types.fieldConfig.forEntityTypeAndBundle(entityType, bundle).map((f) => f.name);
+      return {
+        error: `Field "${params.parent.field}" not found on bundle "${bundle}". Available fields: ${availableFields.length ? availableFields.join(", ") : "none"}. Use get_child_paragraphs to get the correct parent object.`
+      };
+    }
+    if (!isRootEntity) {
+      if (ctx.app.permissions.blockHasRestrictedAncestor(params.parent.uuid)) {
+        return {
+          error: "Permission denied: target parent is inside a block with restricted editing permissions"
+        };
+      }
+    }
+    const topLevelParentBundle = isRootEntity ? null : bundle;
+    const validationError = validateBlockTree(
+      ctx,
+      params.paragraphs,
+      field.allowedBundles,
+      params.parent.field,
+      "",
+      topLevelParentBundle
+    );
+    if (validationError) {
+      return { error: validationError };
+    }
+    const eventBlocks = buildEventBlocks(
+      ctx,
+      params.paragraphs,
+      topLevelParentBundle
+    );
+    const totalCount = countBlocks(eventBlocks);
+    const blockUuids = collectAllUuids(eventBlocks);
+    const { $t } = ctx.app;
+    const label = totalCount === 1 ? $t("aiAgentAddBlockDone", "Added @bundle").replace(
+      "@bundle",
+      types.getBlockLabel(eventBlocks[0].bundle)
+    ) : $t("aiAgentAddBlocksDone", "Added @count blocks").replace(
+      "@count",
+      String(totalCount)
+    );
+    const resolved = resolvePosition(
+      ctx.app,
+      params.parent.uuid,
+      params.parent.field,
+      params.position
+    );
+    if ("error" in resolved) return resolved;
+    return {
+      type: "add",
+      label,
+      apply: (adapter) => adapter.addNewBlocks({
+        blocks: eventBlocks,
+        host: {
+          type: params.parent.type,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field
+        },
+        afterUuid: resolved.afterUuid
+      }),
+      affectedUuids: blockUuids
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/add_reusable_paragraph/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;