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

package/dist/modules/agent/runtime/app/helpers/index.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+export function createToolMap(tools) {
+  return Object.fromEntries(tools.map((t) => [t.name, t]));
+}
+function stripSchemaOverhead(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(stripSchemaOverhead);
+  }
+  if (typeof obj === "object" && obj !== null) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === "$schema") continue;
+      if (key === "additionalProperties" && value === false) continue;
+      if (key === "propertyNames") continue;
+      result[key] = stripSchemaOverhead(value);
+    }
+    return result;
+  }
+  return obj;
+}
+export function getToolsForServer(tools, editMode, adapter) {
+  return tools.filter((tool) => {
+    if (!tool.modes.includes(editMode)) return false;
+    if (!tool.requiredAdapterMethods) return true;
+    if (!adapter) return true;
+    return tool.requiredAdapterMethods.every(
+      (method) => typeof adapter[method] === "function"
+    );
+  }).map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: stripSchemaOverhead(
+      z.toJSONSchema(tool.paramsSchema)
+    ),
+    ...tool.lazy ? { lazy: true } : {},
+    category: tool.category,
+    ...tool.volatile ? { volatile: true } : {}
+  }));
+}
+export async function executeTool(toolMap, name, context, params) {
+  const tool = toolMap[name];
+  if (!tool) {
+    throw new Error(`Unknown tool: ${name}`);
+  }
+  const validatedParams = tool.paramsSchema.parse(params);
+  return tool.execute(context, validatedParams);
+}
+export function getToolCategory(toolMap, name) {
+  const tool = toolMap[name];
+  if (!tool) {
+    throw new Error(`Unknown tool: ${name}`);
+  }
+  return tool.category;
+}
+export function getToolDefinition(toolMap, name) {
+  const tool = toolMap[name];
+  if (!tool) {
+    throw new Error(`Unknown tool: ${name}`);
+  }
+  return tool;
+}
+export function isMutationAction(result) {
+  return typeof result === "object" && result !== null && "type" in result && "label" in result && "apply" in result && typeof result.apply === "function";
+}
+export function isQueryResult(result) {
+  return typeof result === "object" && result !== null && "label" in result && "result" in result && !("apply" in result);
+}
+export function isToolError(result) {
+  return typeof result === "object" && result !== null && "error" in result && typeof result.error === "string";
+}
+export function isToolFactory(item) {
+  return "__factory" in item && item.__factory === true;
+}
+export function isToolDefinition(item) {
+  return !isToolFactory(item);
+}
+export async function resolveTools(tools, context) {
+  const resolved = [];
+  for (const tool of tools) {
+    if (isToolFactory(tool)) {
+      const factoryTools = await tool.resolve(context);
+      resolved.push(...factoryTools);
+    } else {
+      resolved.push(tool);
+    }
+  }
+  return resolved;
+}

package/dist/modules/agent/runtime/app/helpers/pageStructure.d.ts

@@ -0,0 +1,5 @@
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { PageStructure, PageStructureBlock } from '#blokkli/agent/shared/types';
+export declare function buildBlock(app: BlokkliApp, uuid: string, bundle: string): PageStructureBlock;
+export declare function buildPageStructure(app: BlokkliApp): PageStructure;
+export declare function countBlocks(block: PageStructureBlock): number;

package/dist/modules/agent/runtime/app/helpers/pageStructure.js

@@ -0,0 +1,106 @@
+import {
+  getFieldType,
+  getEditableValue,
+  getParagraphChildren
+} from "#blokkli/agent/app/tools/schemas";
+import { itemEntityType } from "#blokkli-build/config";
+const MAX_CONTENT_LENGTH = 150;
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "").trim();
+}
+function truncate(text) {
+  const cleaned = text.trim();
+  if (cleaned.length <= MAX_CONTENT_LENGTH) return cleaned;
+  return cleaned.slice(0, MAX_CONTENT_LENGTH) + "\u2026";
+}
+export function buildBlock(app, uuid, bundle) {
+  const block = { uuid, bundle };
+  const editables = app.directive.getEditablesForBlock(uuid);
+  const content = {};
+  for (const editable of editables) {
+    const fieldType = getFieldType(
+      app,
+      itemEntityType,
+      bundle,
+      editable.fieldName
+    );
+    if (!fieldType) continue;
+    const raw = getEditableValue(
+      app,
+      itemEntityType,
+      uuid,
+      bundle,
+      editable.fieldName,
+      fieldType
+    );
+    const text = fieldType === "markup" ? stripHtml(raw) : raw;
+    const truncated = truncate(text);
+    if (truncated) {
+      content[editable.fieldName] = truncated;
+    }
+  }
+  if (Object.keys(content).length > 0) {
+    block.contentFields = content;
+  }
+  const children = getParagraphChildren(app, uuid);
+  if (children.length > 0) {
+    const fields = {};
+    for (const child of children) {
+      fields[child.fieldName] = child.paragraphs.map(
+        (b) => buildBlock(app, b.uuid, b.bundle)
+      );
+    }
+    block.fields = fields;
+  }
+  return block;
+}
+export function buildPageStructure(app) {
+  const pageUuid = app.context.value.entityUuid;
+  const entityType = app.context.value.entityType;
+  const entityBundle = app.context.value.entityBundle;
+  const topLevelChildren = getParagraphChildren(app, pageUuid);
+  const fields = {};
+  let totalParagraphs = 0;
+  for (const child of topLevelChildren) {
+    fields[child.fieldName] = child.paragraphs.map((b) => {
+      const block = buildBlock(app, b.uuid, b.bundle);
+      totalParagraphs += countBlocks(block);
+      return block;
+    });
+  }
+  const entityEditableConfigs = app.types.editableFieldConfig.forEntityTypeAndBundle(entityType, entityBundle).filter((f) => f.type !== "table");
+  let entityContentFields;
+  for (const config of entityEditableConfigs) {
+    const fieldType = config.type === "frame" || config.type === "markup" ? "markup" : "plain";
+    const raw = getEditableValue(
+      app,
+      entityType,
+      pageUuid,
+      entityBundle,
+      config.name,
+      fieldType
+    );
+    const text = fieldType === "markup" ? stripHtml(raw) : raw;
+    const truncated = truncate(text);
+    if (truncated) {
+      if (!entityContentFields) entityContentFields = {};
+      entityContentFields[config.name] = truncated;
+    }
+  }
+  return {
+    totalParagraphs,
+    fields,
+    entityContentFields
+  };
+}
+export function countBlocks(block) {
+  let count = 1;
+  if (block.fields) {
+    for (const blocks of Object.values(block.fields)) {
+      for (const child of blocks) {
+        count += countBlocks(child);
+      }
+    }
+  }
+  return count;
+}

package/dist/modules/agent/runtime/app/helpers/validation.d.ts

@@ -0,0 +1,35 @@
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { RenderedFieldListItem } from '#blokkli/editor/types/field';
+type ValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    error: string;
+};
+/**
+ * Validate that all blocks exist and return them.
+ */
+export declare function validateBlocksExist(app: BlokkliApp, uuids: string[]): {
+    blocks: RenderedFieldListItem[];
+} | {
+    error: string;
+};
+/**
+ * Validate that all blocks are in the same field.
+ * Returns the field key if valid.
+ */
+export declare function validateSameField(blocks: RenderedFieldListItem[]): {
+    fieldKey: string;
+    host: RenderedFieldListItem['host'];
+} | {
+    error: string;
+};
+/**
+ * Validate that field cardinality allows adding N blocks.
+ */
+export declare function validateFieldCardinality(app: BlokkliApp, host: RenderedFieldListItem['host'], fieldKey: string, additionalCount: number): ValidationResult;
+/**
+ * Validate that all bundles are allowed in the field.
+ */
+export declare function validateBundlesAllowed(app: BlokkliApp, host: RenderedFieldListItem['host'], bundles: string[]): ValidationResult;
+export {};

package/dist/modules/agent/runtime/app/helpers/validation.js

@@ -0,0 +1,77 @@
+import { getFieldKey } from "#blokkli/helpers";
+export function validateBlocksExist(app, uuids) {
+  const blocks = [];
+  for (const uuid of uuids) {
+    const block = app.blocks.getBlock(uuid);
+    if (!block) {
+      return { error: `Paragraph not found: ${uuid}` };
+    }
+    blocks.push(block);
+  }
+  return { blocks };
+}
+export function validateSameField(blocks) {
+  if (blocks.length === 0) {
+    return { error: "No paragraphs provided" };
+  }
+  const firstBlock = blocks[0];
+  const fieldKey = getFieldKey(firstBlock.host.uuid, firstBlock.host.fieldName);
+  for (let i = 1; i < blocks.length; i++) {
+    const block = blocks[i];
+    const blockFieldKey = getFieldKey(block.host.uuid, block.host.fieldName);
+    if (blockFieldKey !== fieldKey) {
+      return { error: "All paragraphs must be in the same field" };
+    }
+  }
+  return { fieldKey, host: firstBlock.host };
+}
+export function validateFieldCardinality(app, host, fieldKey, additionalCount) {
+  const fieldConfig = app.types.getFieldConfig(
+    host.type,
+    host.bundle,
+    host.fieldName
+  );
+  if (!fieldConfig) {
+    return {
+      valid: false,
+      error: `Field configuration not found for ${host.fieldName}`
+    };
+  }
+  if (fieldConfig.cardinality === -1) {
+    return { valid: true };
+  }
+  const currentCount = app.state.getFieldBlockCount(fieldKey);
+  if (currentCount + additionalCount > fieldConfig.cardinality) {
+    return {
+      valid: false,
+      error: `Field "${host.fieldName}" can only hold ${fieldConfig.cardinality} paragraphs (currently has ${currentCount}, trying to add ${additionalCount})`
+    };
+  }
+  return { valid: true };
+}
+export function validateBundlesAllowed(app, host, bundles) {
+  const fieldConfig = app.types.getFieldConfig(
+    host.type,
+    host.bundle,
+    host.fieldName
+  );
+  if (!fieldConfig) {
+    return {
+      valid: false,
+      error: `Field configuration not found for ${host.fieldName}`
+    };
+  }
+  if (!fieldConfig.allowedBundles.length) {
+    return { valid: true };
+  }
+  const disallowed = bundles.filter(
+    (b) => !fieldConfig.allowedBundles.includes(b)
+  );
+  if (disallowed.length > 0) {
+    return {
+      valid: false,
+      error: `Bundle(s) "${disallowed.join(", ")}" not allowed in field "${host.fieldName}"`
+    };
+  }
+  return { valid: true };
+}

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,69 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  mutationResultSchema,
+  parentSchema,
+  positionSchema,
+  resolvePosition
+} from "../schemas.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 { $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,83 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  mutationResultSchema,
+  parentSchema,
+  positionSchema,
+  resolvePosition
+} from "../schemas.js";
+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 } = ctx.app;
+    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,62 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  mutationResultSchema,
+  parentSchema,
+  positionSchema,
+  resolvePosition
+} from "../schemas.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 { $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;