@blokkli/editor 2.0.0-alpha.32 → 2.0.0-alpha.34

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

@@ -0,0 +1,180 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { parentSchema } from "../schemas.js";
+import {
+  getAvailableOptions,
+  getMutatedOptionValue,
+  optionValueToStorable
+} from "#blokkli/editor/helpers/options";
+const paramsSchema = z.object({
+  // Bundle filters
+  bundle: z.string().optional().describe("Filter by exact bundle name"),
+  bundles: z.array(z.string()).optional().describe("Filter by any of these bundles"),
+  // Structure filters
+  hasChildren: z.boolean().optional().describe("Filter by whether paragraph has child paragraphs"),
+  isRootLevel: z.boolean().optional().describe("Filter to root level paragraphs (nesting 0)"),
+  nestingLevel: z.number().optional().describe("Filter to exact nesting level"),
+  parentBundle: z.string().optional().describe("Filter to paragraphs whose parent is this bundle"),
+  inField: z.string().optional().describe("Filter to paragraphs in a field with this name"),
+  // Content filters
+  containsText: z.string().optional().describe("Filter to paragraphs containing this text (case-insensitive)"),
+  // Option filters
+  optionEquals: z.object({
+    key: z.string().describe("Option key to check"),
+    value: z.union([z.string(), z.boolean(), z.number()]).describe("Expected option value")
+  }).optional().describe("Filter to paragraphs where an option equals a value"),
+  // Pagination
+  limit: z.number().optional().default(50).describe("Maximum number of results to return (default: 50)")
+});
+const paragraphResultSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  bundle: z.string().describe("The paragraph type"),
+  label: z.string().describe("Human-readable paragraph label"),
+  nestingLevel: z.number().describe("Nesting depth (0 = root level)"),
+  parent: parentSchema.describe("The parent entity containing this paragraph")
+});
+const resultSchema = z.object({
+  paragraphs: z.array(paragraphResultSchema).describe("paragraphs matching the filters"),
+  total: z.number().describe("Total number of matches before pagination"),
+  hasMore: z.boolean().describe("Whether there are more results beyond the limit")
+});
+export default defineBlokkliAgentTool({
+  name: "find_paragraphs",
+  description: "Find paragraphs matching multiple filter criteria. Supports filtering by bundle, structure (nesting, parent, field), content, and options. Returns paginated results. containsText does simple case-insensitive substring matching. For regex or match snippets, use search_text instead.",
+  category: "query",
+  volatile: true,
+  lazy: true,
+  prunedSummary: (r) => `found ${r.total || 0} paragraphs${r.hasMore ? " (more available)" : ""}`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentFindBlocksRunning", "Finding blocks...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { blocks, state, context, types, dom, definitions, $t } = ctx.app;
+    const limit = params.limit ?? 50;
+    let candidates = blocks.getAllBlocks();
+    if (params.bundle) {
+      candidates = candidates.filter((block) => block.bundle === params.bundle);
+    }
+    if (params.bundles && params.bundles.length > 0) {
+      const bundleSet = new Set(params.bundles);
+      candidates = candidates.filter((block) => bundleSet.has(block.bundle));
+    }
+    if (params.isRootLevel === true) {
+      candidates = candidates.filter(
+        (block) => state.getNestingLevel(block.uuid) === 0
+      );
+    } else if (params.isRootLevel === false) {
+      candidates = candidates.filter(
+        (block) => state.getNestingLevel(block.uuid) > 0
+      );
+    }
+    if (params.nestingLevel !== void 0) {
+      candidates = candidates.filter(
+        (block) => state.getNestingLevel(block.uuid) === params.nestingLevel
+      );
+    }
+    if (params.inField) {
+      candidates = candidates.filter((block) => {
+        const fieldList = state.getFieldListForBlock(block.uuid);
+        return fieldList?.name === params.inField;
+      });
+    }
+    if (params.parentBundle) {
+      candidates = candidates.filter((block) => {
+        const parentUuid = state.getParentEntityUuid(block.uuid);
+        if (!parentUuid || parentUuid === context.value.entityUuid) {
+          return false;
+        }
+        const parentBlock = blocks.getBlock(parentUuid);
+        return parentBlock?.bundle === params.parentBundle;
+      });
+    }
+    if (params.hasChildren !== void 0) {
+      const mutatedFields = state.mutatedFields.value;
+      candidates = candidates.filter((block) => {
+        const hasChildFields = mutatedFields.some(
+          (field) => field.entityUuid === block.uuid && field.list.length > 0
+        );
+        return params.hasChildren ? hasChildFields : !hasChildFields;
+      });
+    }
+    if (params.optionEquals) {
+      const { key, value } = params.optionEquals;
+      candidates = candidates.filter((block) => {
+        const definition = definitions.getBlockDefinition(
+          block.bundle,
+          block.fieldListType,
+          block.parentBlockBundle
+        );
+        if (!definition) return false;
+        const availableOptions = getAvailableOptions(
+          definition.options,
+          definition.globalOptions,
+          definitions.globalOptions.value
+        );
+        const optionDef = availableOptions.find((o) => o.property === key);
+        if (!optionDef) return false;
+        const currentValue = getMutatedOptionValue(
+          state.mutatedOptions,
+          block.uuid,
+          key,
+          optionDef.option.default
+        );
+        const storableQueryValue = optionValueToStorable(
+          optionDef.option,
+          value
+        );
+        const storableCurrentValue = optionValueToStorable(
+          optionDef.option,
+          currentValue
+        );
+        return storableCurrentValue === storableQueryValue;
+      });
+    }
+    if (params.containsText) {
+      const searchText = params.containsText.toLowerCase();
+      candidates = candidates.filter((block) => {
+        const el = dom.getDragElement(block);
+        if (!el) return false;
+        const text = el.textContent?.toLowerCase() || "";
+        return text.includes(searchText);
+      });
+    }
+    const total = candidates.length;
+    const hasMore = total > limit;
+    const limitedCandidates = candidates.slice(0, limit);
+    const resultBlocks = [];
+    for (const block of limitedCandidates) {
+      const fieldList = state.getFieldListForBlock(block.uuid);
+      if (!fieldList) continue;
+      const parentType = fieldList.entityUuid === context.value.entityUuid ? context.value.entityType : ctx.itemEntityType;
+      resultBlocks.push({
+        uuid: block.uuid,
+        bundle: block.bundle,
+        label: types.getBlockLabel(block.bundle),
+        nestingLevel: state.getNestingLevel(block.uuid),
+        parent: {
+          type: parentType,
+          uuid: fieldList.entityUuid,
+          field: fieldList.name
+        }
+      });
+    }
+    return {
+      label: $t("aiAgentFindBlocksDone", "Found @count blocks").replace(
+        "@count",
+        String(total)
+      ),
+      result: {
+        paragraphs: resultBlocks,
+        total,
+        hasMore
+      },
+      // Select blocks if there's only one match
+      affectedUuids: resultBlocks.length === 1 ? [resultBlocks[0].uuid] : void 0
+    };
+  }
+});

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

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

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

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const fragmentSchema = z.object({
+  name: z.string().describe("The unique fragment identifier"),
+  label: z.string().describe("The display label"),
+  description: z.string().optional().describe("A short description of the fragment")
+});
+const paramsSchema = z.object({});
+const resultSchema = z.array(fragmentSchema).describe("All available fragments");
+export default defineBlokkliAgentTool({
+  name: "get_all_fragments",
+  description: "Get all available fragments that can be added to the page",
+  category: "query",
+  modes: ["readonly", "editing", "translating", "review"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentGetAllFragments", "Get all fragments");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx) {
+    const { definitions, $t } = ctx.app;
+    const result = definitions.fragmentDefinitions.value.map((fragment) => ({
+      name: fragment.name,
+      label: fragment.label,
+      description: fragment.description
+    }));
+    return {
+      label: $t("aiAgentGetAllFragmentsDone", "Got all fragments"),
+      result
+    };
+  }
+});

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

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

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

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { getFieldType, getEditableValue } from "../schemas.js";
+const paramsSchema = z.object({});
+const blockContentSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  bundle: z.string().describe("The paragraph type"),
+  text: z.string().describe("All text content from this paragraph concatenated"),
+  referenceFields: z.array(z.string()).optional().describe(
+    "Names of reference/link content fields on this paragraph (e.g., media fields)"
+  )
+});
+const resultSchema = z.object({
+  content: z.array(blockContentSchema).describe("All paragraphs with their text content, flattened")
+});
+export default defineBlokkliAgentTool({
+  name: "get_all_page_content",
+  description: "Get all text content from the entire page in a single call. Returns a flat list of all paragraphs with their concatenated text. Use this as the first tool when reviewing or analyzing page content.",
+  category: "query",
+  volatile: true,
+  prunedSummary: (r) => `${r.content?.length || 0} paragraphs`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetAllPageContentRunning", "Getting all page content...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx) {
+    const { blocks, state, $t } = ctx.app;
+    const content = [];
+    function processBlock(blockUuid) {
+      const block = blocks.getBlock(blockUuid);
+      if (!block) return;
+      const editables = ctx.app.directive.getEditablesForBlock(blockUuid);
+      const textParts = [];
+      for (const editable of editables) {
+        const fieldType = getFieldType(
+          ctx.app,
+          ctx.itemEntityType,
+          block.bundle,
+          editable.fieldName
+        );
+        if (!fieldType) continue;
+        const value = getEditableValue(
+          ctx.app,
+          ctx.itemEntityType,
+          blockUuid,
+          block.bundle,
+          editable.fieldName,
+          fieldType
+        );
+        if (value.trim()) {
+          textParts.push(value.trim());
+        }
+      }
+      const droppableFields = ctx.app.types.droppableFieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, block.bundle).map((f) => f.name);
+      if (textParts.length > 0 || droppableFields.length > 0) {
+        content.push({
+          uuid: blockUuid,
+          bundle: block.bundle,
+          text: textParts.join("\n\n"),
+          referenceFields: droppableFields.length ? droppableFields : void 0
+        });
+      }
+      const mutatedFields2 = state.mutatedFields.value;
+      for (const field of mutatedFields2) {
+        if (field.entityUuid === blockUuid) {
+          for (const child of field.list) {
+            processBlock(child.uuid);
+          }
+        }
+      }
+    }
+    const pageUuid = ctx.app.context.value.entityUuid;
+    const mutatedFields = state.mutatedFields.value;
+    for (const field of mutatedFields) {
+      if (field.entityUuid === pageUuid) {
+        for (const item of field.list) {
+          processBlock(item.uuid);
+        }
+      }
+    }
+    return {
+      label: $t(
+        "aiAgentGetAllPageContentDone",
+        "Got content from @count blocks"
+      ).replace("@count", String(content.length)),
+      result: {
+        content
+      }
+    };
+  }
+});

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

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

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

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const paramsSchema = z.object({
+  parentUuid: z.string().describe("The parent entity UUID"),
+  field: z.string().describe("The field name")
+});
+const bundleSchema = z.object({
+  bundle: z.string().describe("The paragraph type identifier"),
+  label: z.string().describe("Human-readable label"),
+  description: z.string().optional().describe("Bundle description if available"),
+  contentFields: z.array(
+    z.object({
+      name: z.string().describe("The field name"),
+      type: z.string().describe("Field type: plain, markup, reference, or link")
+    })
+  ).describe("Content fields (text, media, links) on this bundle"),
+  paragraphFields: z.array(
+    z.object({
+      name: z.string().describe("The field name"),
+      label: z.string().describe("Human-readable label"),
+      allowedBundles: z.array(z.string()).describe("Paragraph types allowed in this field"),
+      cardinality: z.number().describe("Max paragraphs allowed (-1 = unlimited)")
+    })
+  ).describe("Paragraph fields (for nested paragraphs) on this bundle")
+});
+const resultSchema = z.object({
+  fieldLabel: z.string().describe("Human-readable field label"),
+  cardinality: z.number().describe("Max paragraphs allowed (-1 = unlimited)"),
+  currentCount: z.number().describe("Current number of paragraphs in the field"),
+  bundles: z.array(bundleSchema).describe("Available paragraph types"),
+  nestingInfo: z.string().optional().describe(
+    "Summary of which bundles have paragraph fields for nested paragraphs. Use get_child_paragraphs after adding these bundles to populate their nested fields."
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "get_bundle_info",
+  description: "Get detailed information about which paragraph types can be added to a specific field, including their content fields and paragraph fields (for nested paragraphs).",
+  category: "query",
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetBundleInfoRunning", "Getting bundle info...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { fields, types, state, $t } = ctx.app;
+    const label = $t(
+      "aiAgentGetBundleInfoDone",
+      "Got bundle info for @field"
+    ).replace("@field", params.field);
+    const field = fields.find(params.parentUuid, params.field);
+    if (!field) {
+      return {
+        label,
+        result: {
+          fieldLabel: params.field,
+          cardinality: -1,
+          currentCount: 0,
+          bundles: []
+        }
+      };
+    }
+    const fieldKey = `${params.parentUuid}:${params.field}`;
+    const currentCount = state.getFieldBlockCount(fieldKey);
+    const bundles = field.allowedBundles.map((bundle) => {
+      const bundleDefinition = types.getBlockBundleDefinition(bundle);
+      const editableConfigs = types.editableFieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, bundle).filter((c) => c.type !== "table").map((c) => ({
+        name: c.name,
+        type: c.type === "frame" || c.type === "markup" ? "markup" : "plain"
+      }));
+      const droppableConfigs = types.droppableFieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, bundle).map((c) => ({
+        name: c.name,
+        type: c.type
+      }));
+      const blockFieldConfigs = types.fieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, bundle).map((c) => ({
+        name: c.name,
+        label: c.label,
+        allowedBundles: c.allowedBundles,
+        cardinality: c.cardinality
+      }));
+      return {
+        bundle,
+        label: bundleDefinition?.label ?? bundle,
+        description: bundleDefinition?.description,
+        contentFields: [...editableConfigs, ...droppableConfigs],
+        paragraphFields: blockFieldConfigs
+      };
+    });
+    const nestingBundles = bundles.filter((b) => b.paragraphFields.length > 0);
+    const nestingInfo = nestingBundles.length ? nestingBundles.map(
+      (b) => `${b.bundle} has paragraph fields: ${b.paragraphFields.map((f) => `${f.name} (${f.allowedBundles.join(", ")})`).join(", ")}`
+    ).join("; ") : void 0;
+    return {
+      label,
+      result: {
+        fieldLabel: field.label,
+        cardinality: field.cardinality,
+        currentCount,
+        bundles,
+        nestingInfo
+      }
+    };
+  }
+});

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

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

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

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { parentSchema } from "../schemas.js";
+const paramsSchema = z.object({
+  uuid: z.string().optional().describe(
+    "Paragraph UUID to get children for. If not provided, returns page-level paragraphs."
+  )
+});
+const paragraphSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  bundle: z.string().describe("The paragraph type")
+});
+const fieldWithParagraphsSchema = z.object({
+  label: z.string().describe("Human-readable field label"),
+  cardinality: z.number().describe("Max paragraphs allowed (-1 = unlimited)"),
+  parent: parentSchema.describe(
+    "Parent object to use when adding paragraphs to this field"
+  ),
+  paragraphs: z.array(paragraphSchema).describe("Paragraphs in this field")
+});
+const resultSchema = z.object({
+  parentBundle: z.string().describe("The bundle type of the parent (page or paragraph)"),
+  fields: z.record(z.string().describe("Field name"), fieldWithParagraphsSchema).describe("Fields keyed by name, each with parent object and paragraphs")
+});
+export default defineBlokkliAgentTool({
+  name: "get_child_paragraphs",
+  description: "Get all child fields and paragraphs for the page or a paragraph. Returns parent objects ready for use with add_paragraphs. Use this to understand structure before adding paragraphs.",
+  category: "query",
+  volatile: true,
+  prunedSummary: (r) => {
+    const fieldCount = Object.keys(r.fields).length;
+    const paragraphCount = Object.values(r.fields).reduce(
+      (s, f) => s + f.paragraphs.length,
+      0
+    );
+    return `${paragraphCount} paragraphs across ${fieldCount} fields`;
+  },
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetChildBlocks", "Get child blocks");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { context, state, $t, blocks, types } = ctx.app;
+    const parentUuid = params.uuid || context.value.entityUuid;
+    const isPage = !params.uuid;
+    let parentBundle;
+    let parentEntityType;
+    if (isPage) {
+      parentBundle = context.value.entityBundle;
+      parentEntityType = context.value.entityType;
+    } else {
+      const block = blocks.getBlock(parentUuid);
+      if (!block) {
+        return {
+          label: $t("aiAgentBlockNotFound", "Block not found"),
+          result: { parentBundle: "unknown", fields: {} }
+        };
+      }
+      parentBundle = block.bundle;
+      parentEntityType = ctx.itemEntityType;
+    }
+    const fieldConfigs = types.fieldConfig.forEntityTypeAndBundle(
+      parentEntityType,
+      parentBundle
+    );
+    if (fieldConfigs.length === 0 && !isPage && params.uuid) {
+      return {
+        label: $t(
+          "aiAgentGetChildBlocksNone",
+          "@bundle has no child fields"
+        ).replace("@bundle", types.getBlockLabel(parentBundle)),
+        result: { parentBundle, fields: {} },
+        affectedUuids: [params.uuid]
+      };
+    }
+    const mutatedFieldsMap = new Map(
+      state.mutatedFields.value.filter((field) => field.entityUuid === parentUuid).map((field) => [field.name, field.list])
+    );
+    const fields = {};
+    for (const fieldConfig of fieldConfigs) {
+      const blockList = mutatedFieldsMap.get(fieldConfig.name) || [];
+      fields[fieldConfig.name] = {
+        label: fieldConfig.label,
+        cardinality: fieldConfig.cardinality,
+        parent: {
+          type: parentEntityType,
+          uuid: parentUuid,
+          field: fieldConfig.name
+        },
+        paragraphs: blockList.map((item) => ({
+          uuid: item.uuid,
+          bundle: item.bundle
+        }))
+      };
+    }
+    const bundleLabel = isPage ? context.value.entityBundle : types.getBlockLabel(parentBundle);
+    return {
+      label: $t("aiAgentGetChildBlocksDone", "Got children of @bundle").replace(
+        "@bundle",
+        bundleLabel
+      ),
+      result: { parentBundle, fields },
+      affectedUuids: params.uuid ? [params.uuid] : void 0
+    };
+  }
+});

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

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