@revenexx/editor 0.1.0

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

@@ -0,0 +1,264 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { parentSchema, blockOptionsMapSchema } from "../schemas.js";
+import { booleanParamWithDefault } from "../../../shared/toolParams.js";
+import {
+  buildBlockOptionsMap,
+  getResolvedOptions,
+  readBlockContentFields
+} from "../helpers.js";
+import { fragmentBlockBundle } from "#blokkli-build/config";
+export const paramsSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  includeParentChain: booleanParamWithDefault(
+    "Include ancestor parent paragraphs up to the page",
+    true
+  ),
+  includeSiblings: booleanParamWithDefault(
+    "Include sibling paragraphs in the same field",
+    false
+  ),
+  includeChildren: booleanParamWithDefault(
+    "Include child fields summary",
+    true
+  ),
+  includeContentFields: booleanParamWithDefault(
+    "Include content fields (text, media, links) with values",
+    true
+  ),
+  includeOptions: booleanParamWithDefault("Include paragraph options", true)
+});
+const parentChainItemSchema = z.object({
+  uuid: z.string().describe("The parent paragraph UUID"),
+  bundle: z.string().describe("The paragraph type"),
+  label: z.string().describe("Human-readable paragraph label"),
+  field: z.string().describe("The field name this paragraph is in")
+});
+const siblingInfoSchema = z.object({
+  total: z.number().describe("Total number of siblings including this paragraph"),
+  position: z.number().describe("1-based position of this paragraph"),
+  prev: z.object({
+    uuid: z.string(),
+    bundle: z.string()
+  }).nullable().describe("Previous sibling paragraph"),
+  next: z.object({
+    uuid: z.string(),
+    bundle: z.string()
+  }).nullable().describe("Next sibling paragraph")
+});
+const childFieldSchema = z.object({
+  name: z.string().describe("Field name"),
+  label: z.string().describe("Human-readable field label"),
+  count: z.number().describe("Number of paragraphs in this field"),
+  cardinality: z.number().describe("Max paragraphs allowed (-1 = unlimited)"),
+  bundles: z.array(z.string()).describe("Unique bundle types in this field")
+});
+const contentFieldSchema = z.discriminatedUnion("type", [
+  z.object({
+    field: z.string().describe("The field name"),
+    type: z.literal("plain").describe("Plain text field"),
+    currentValue: z.string().describe("Current field value")
+  }),
+  z.object({
+    field: z.string().describe("The field name"),
+    type: z.literal("markup").describe("Rich text / HTML field"),
+    currentValue: z.string().describe("Current field value")
+  }),
+  z.object({
+    field: z.string().describe("The field name"),
+    label: z.string().describe("Human-readable field label"),
+    type: z.literal("reference").describe("Entity reference field"),
+    allowed: z.array(
+      z.object({
+        type: z.string().describe('The entity type (e.g., "media", "node")'),
+        bundles: z.array(z.string()).describe("The bundles accepted for this entity type")
+      })
+    ).describe("Entity types and bundles this field accepts")
+  }),
+  z.object({
+    field: z.string().describe("The field name"),
+    label: z.string().describe("Human-readable field label"),
+    type: z.literal("link").describe("Link field"),
+    allowed: z.array(
+      z.object({
+        type: z.string().describe('The entity type (e.g., "media", "node")'),
+        bundles: z.array(z.string()).describe("The bundles accepted for this entity type")
+      })
+    ).describe("Entity types and bundles this field accepts")
+  })
+]);
+export const resultSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  bundle: z.string().describe("The paragraph type"),
+  label: z.string().describe("Human-readable paragraph label"),
+  fragmentName: z.string().optional().describe("The fragment name, if this paragraph is a fragment block"),
+  nestingLevel: z.number().describe("Nesting depth (0 = root level)"),
+  parent: parentSchema.nullable().describe("The parent entity containing this paragraph"),
+  parentChain: z.array(parentChainItemSchema).optional().describe("Ancestor parent paragraphs from immediate parent to page"),
+  siblings: siblingInfoSchema.optional().describe("Information about sibling paragraphs in the same field"),
+  childFields: z.array(childFieldSchema).optional().describe("Child fields with paragraph counts"),
+  contentFields: z.array(contentFieldSchema).optional().describe("Content fields (text, media, links) with current values"),
+  options: blockOptionsMapSchema.optional().describe("Paragraph options with current values")
+});
+export default defineBlokkliAgentTool({
+  name: "get_paragraph_context",
+  description: "Get comprehensive context for a single paragraph including parent chain, siblings, children, content fields, and options. Preferred over multiple individual tool calls.",
+  category: "query",
+  lazy: true,
+  volatile: true,
+  prunedSummary: (r) => `context for ${r.bundle || "paragraph"} (${r.uuid?.slice(0, 8) || "?"})`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetBlockContextRunning", "Getting block context", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { blocks, state, context, types, selection, $t } = ctx.app;
+    const block = blocks.getBlock(params.uuid);
+    if (!block) {
+      return {
+        error: `Paragraph not found: ${params.uuid}`
+      };
+    }
+    const bundleLabel = types.getBlockLabel(block.bundle);
+    const fieldList = state.getFieldListForBlock(params.uuid);
+    let parent = null;
+    if (fieldList) {
+      const parentType = fieldList.entityUuid === context.value.entityUuid ? context.value.entityType : ctx.itemEntityType;
+      parent = {
+        type: parentType,
+        uuid: fieldList.entityUuid,
+        field: fieldList.name
+      };
+    }
+    const result = {
+      uuid: params.uuid,
+      bundle: block.bundle,
+      label: bundleLabel,
+      nestingLevel: state.getNestingLevel(params.uuid),
+      parent
+    };
+    if (block.bundle === fragmentBlockBundle && block.fragment?.name) {
+      result.fragmentName = block.fragment.name;
+    }
+    if (params.includeParentChain) {
+      const parentChain = [];
+      let currentUuid = state.getParentEntityUuid(params.uuid);
+      while (currentUuid && currentUuid !== context.value.entityUuid) {
+        const parentBlock = blocks.getBlock(currentUuid);
+        const parentField = state.getFieldListForBlock(currentUuid);
+        if (parentBlock && parentField) {
+          parentChain.push({
+            uuid: currentUuid,
+            bundle: parentBlock.bundle,
+            label: types.getBlockLabel(parentBlock.bundle),
+            field: parentField.name
+          });
+        }
+        currentUuid = state.getParentEntityUuid(currentUuid);
+      }
+      result.parentChain = parentChain;
+    }
+    if (params.includeSiblings && fieldList) {
+      const siblings = fieldList.list;
+      const currentIndex = siblings.findIndex(
+        (item) => item.uuid === params.uuid
+      );
+      if (currentIndex !== -1) {
+        const prevSibling = currentIndex > 0 ? siblings[currentIndex - 1] : null;
+        const nextSibling = currentIndex < siblings.length - 1 ? siblings[currentIndex + 1] : null;
+        result.siblings = {
+          total: siblings.length,
+          position: currentIndex + 1,
+          prev: prevSibling ? { uuid: prevSibling.uuid, bundle: prevSibling.bundle } : null,
+          next: nextSibling ? { uuid: nextSibling.uuid, bundle: nextSibling.bundle } : null
+        };
+      }
+    }
+    if (params.includeChildren) {
+      const mutatedFields = state.mutatedFields.value;
+      const childFields = [];
+      for (const field of mutatedFields) {
+        if (field.entityUuid === params.uuid && field.list.length > 0) {
+          const uniqueBundles = [
+            ...new Set(field.list.map((item) => item.bundle))
+          ];
+          const fieldConfig = types.fieldConfig.forName(
+            field.entityType,
+            block.bundle,
+            field.name
+          );
+          childFields.push({
+            name: field.name,
+            label: fieldConfig?.label || field.name,
+            count: field.list.length,
+            cardinality: fieldConfig?.cardinality ?? -1,
+            bundles: uniqueBundles
+          });
+        }
+      }
+      if (childFields.length > 0) {
+        result.childFields = childFields;
+      }
+    }
+    if (params.includeContentFields) {
+      const fields = [];
+      for (const f of readBlockContentFields(
+        ctx.app,
+        params.uuid,
+        ctx.itemEntityType,
+        block.bundle
+      )) {
+        fields.push({
+          field: f.fieldName,
+          type: f.fieldType,
+          currentValue: f.value
+        });
+      }
+      const droppableConfigs = types.droppableFieldConfig.forEntityTypeAndBundle(
+        ctx.itemEntityType,
+        block.bundle
+      );
+      for (const config of droppableConfigs) {
+        fields.push({
+          field: config.name,
+          label: config.label,
+          type: config.type,
+          allowed: config.allowed
+        });
+      }
+      if (fields.length > 0) {
+        result.contentFields = fields;
+      }
+    }
+    if (params.includeOptions) {
+      const selectionItem = selection.items.value.find(
+        (v) => v.uuid === params.uuid
+      );
+      const availableOptions = getResolvedOptions(
+        ctx.app,
+        block.bundle,
+        selectionItem?.fieldListType ?? "default",
+        selectionItem?.parentBlockBundle ?? null
+      );
+      if (availableOptions && availableOptions.length > 0) {
+        result.options = buildBlockOptionsMap(
+          availableOptions,
+          state.mutatedOptions,
+          params.uuid
+        );
+      }
+    }
+    return {
+      label: $t(
+        "aiAgentGetBlockContextDone",
+        "Got context for @bundle"
+      ).replace("@bundle", bundleLabel),
+      result,
+      affectedUuids: [params.uuid]
+    };
+  }
+});

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    min: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    max: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    step: z.ZodOptional<z.ZodNumber>;
+    currentValue: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>;
+}, z.core.$strip>>>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { blockOptionsMapSchema } from "../schemas.js";
+import { buildBlockOptionsMap, getResolvedOptions } from "../helpers.js";
+export const paramsSchema = z.object({
+  uuids: z.array(z.string()).describe("The paragraph UUIDs to get options for")
+});
+export const resultSchema = z.record(
+  z.string().describe("Paragraph UUID"),
+  blockOptionsMapSchema.describe("Options for this paragraph")
+);
+export default defineBlokkliAgentTool({
+  name: "get_paragraph_options",
+  description: "Get available options and their current values for one or more paragraphs",
+  category: "query",
+  lazy: true,
+  volatile: true,
+  prunedSummary: (r) => `options for ${Object.keys(r || {}).length} paragraphs`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetBlockOptionsRunning", "Getting block options", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { blocks, state, selection, types, $t } = ctx.app;
+    const result = {};
+    const affectedUuids = [];
+    for (const uuid of params.uuids) {
+      const block = blocks.getBlock(uuid);
+      if (!block) continue;
+      const bundle = block.library?.reusableBundle || block.bundle;
+      const selectionItem = selection.items.value.find((v) => v.uuid === uuid);
+      const availableOptions = getResolvedOptions(
+        ctx.app,
+        bundle,
+        selectionItem?.fieldListType ?? "default",
+        selectionItem?.parentBlockBundle ?? null
+      );
+      if (!availableOptions) continue;
+      result[uuid] = buildBlockOptionsMap(
+        availableOptions,
+        state.mutatedOptions,
+        uuid
+      );
+      affectedUuids.push(uuid);
+    }
+    const count = affectedUuids.length;
+    const firstUuid = affectedUuids[0];
+    const firstBlock = firstUuid ? blocks.getBlock(firstUuid) : null;
+    const label = count === 1 && firstBlock ? $t("aiAgentGetBlockOptionsDone", "Got options of @bundle").replace(
+      "@bundle",
+      types.getBlockLabel(firstBlock.bundle)
+    ) : $t(
+      "aiAgentGetBlockOptionsMultipleDone",
+      "Got options of @count blocks"
+    ).replace("@count", String(count));
+    return { label, result, affectedUuids };
+  }
+});

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    maxNestingLevel: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    includeDimensions: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+}, z.core.$strip>;
+type BlockDimensions = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type NestedBlock = {
+    uuid: string;
+    bundle: string;
+    label: string;
+    dimensions?: BlockDimensions;
+    children?: Record<string, NestedBlock[]>;
+};
+export declare const resultSchema: z.ZodObject<{
+    paragraphs: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        bundle: z.ZodString;
+        label: z.ZodString;
+        dimensions: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>>;
+        visibilityPercent: z.ZodNumber;
+        parent: z.ZodObject<{
+            type: z.ZodString;
+            uuid: z.ZodString;
+            field: z.ZodString;
+        }, z.core.$strip>;
+        children: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<NestedBlock, unknown, z.core.$ZodTypeInternals<NestedBlock, unknown>>>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,186 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { booleanParamWithDefault } from "../../../shared/toolParams.js";
+export const paramsSchema = z.object({
+  maxNestingLevel: z.coerce.number().optional().describe(
+    "Maximum nesting depth to include (0 = only root paragraphs, 1 = root + direct children, etc.). Omit for unlimited depth."
+  ),
+  includeDimensions: booleanParamWithDefault(
+    "Include x, y, width, height for each paragraph (default: false)",
+    false
+  )
+});
+const dimensionsSchema = z.object({
+  x: z.number().describe("X position in artboard coordinates"),
+  y: z.number().describe("Y position in artboard coordinates"),
+  width: z.number().describe("Width in pixels"),
+  height: z.number().describe("Height in pixels")
+});
+const nestedBlockSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  bundle: z.string().describe("The paragraph type"),
+  label: z.string().describe("Human-readable paragraph label"),
+  dimensions: dimensionsSchema.optional().describe("Paragraph position and size (if requested)"),
+  children: z.record(z.string(), z.array(z.lazy(() => nestedBlockSchema))).optional().describe("Child paragraphs organized by field name")
+});
+const rootBlockSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  bundle: z.string().describe("The paragraph type"),
+  label: z.string().describe("Human-readable paragraph label"),
+  dimensions: dimensionsSchema.optional().describe("Paragraph position and size (if requested)"),
+  visibilityPercent: z.number().describe("Percentage of paragraph area visible in viewport (0-100)"),
+  parent: z.object({
+    type: z.string().describe("Parent entity type"),
+    uuid: z.string().describe("Parent entity UUID"),
+    field: z.string().describe("Field name containing this paragraph")
+  }).describe("Parent field information"),
+  children: z.record(z.string(), z.array(nestedBlockSchema)).optional().describe("Child paragraphs organized by field name")
+});
+export const resultSchema = z.object({
+  paragraphs: z.array(rootBlockSchema).describe("Root-level paragraphs currently visible in the viewport")
+});
+function getDimensions(app, uuid) {
+  const rect = app.dom.getBlockRect(uuid);
+  if (!rect) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  return {
+    x: Math.round(rect.x),
+    y: Math.round(rect.y),
+    width: Math.round(rect.width),
+    height: Math.round(rect.height)
+  };
+}
+function calculateVisibility(app, uuid) {
+  const artboardRect = app.dom.getBlockRect(uuid);
+  if (!artboardRect) return 0;
+  const viewport = app.ui.visibleViewport.value;
+  const rect = app.ui.getViewportRelativeRect(artboardRect);
+  const intersectX = Math.max(
+    0,
+    Math.min(rect.x + rect.width, viewport.x + viewport.width) - Math.max(rect.x, viewport.x)
+  );
+  const intersectY = Math.max(
+    0,
+    Math.min(rect.y + rect.height, viewport.y + viewport.height) - Math.max(rect.y, viewport.y)
+  );
+  const intersectArea = intersectX * intersectY;
+  const blockArea = rect.width * rect.height;
+  if (blockArea === 0) return 0;
+  return Math.round(intersectArea / blockArea * 100);
+}
+function buildNestedBlockTree(app, uuid, options) {
+  const block = app.blocks.getBlock(uuid);
+  const bundle = block?.bundle ?? "unknown";
+  const result = {
+    uuid,
+    bundle,
+    label: app.types.getBlockLabel(bundle)
+  };
+  if (options.includeDimensions) {
+    result.dimensions = getDimensions(app, uuid);
+  }
+  const shouldIncludeChildren = options.maxNestingLevel === void 0 || options.currentLevel < options.maxNestingLevel;
+  if (shouldIncludeChildren) {
+    const mutatedFields = app.state.mutatedFields.value;
+    const childFields = {};
+    for (const field of mutatedFields) {
+      if (field.entityUuid === uuid && field.list.length > 0) {
+        childFields[field.name] = field.list.map(
+          (item) => buildNestedBlockTree(app, item.uuid, {
+            ...options,
+            currentLevel: options.currentLevel + 1
+          })
+        );
+      }
+    }
+    if (Object.keys(childFields).length > 0) {
+      result.children = childFields;
+    }
+  }
+  return result;
+}
+function buildRootBlockTree(app, uuid, options) {
+  const block = app.blocks.getBlock(uuid);
+  const bundle = block?.bundle ?? "unknown";
+  const parentField = app.state.getFieldListForBlock(uuid);
+  const parent = parentField ? {
+    type: parentField.entityType,
+    uuid: parentField.entityUuid,
+    field: parentField.name
+  } : { type: "unknown", uuid: "unknown", field: "unknown" };
+  const result = {
+    uuid,
+    bundle,
+    label: app.types.getBlockLabel(bundle),
+    visibilityPercent: calculateVisibility(app, uuid),
+    parent
+  };
+  if (options.includeDimensions) {
+    result.dimensions = getDimensions(app, uuid);
+  }
+  const shouldIncludeChildren = options.maxNestingLevel === void 0 || options.currentLevel < options.maxNestingLevel;
+  if (shouldIncludeChildren) {
+    const mutatedFields = app.state.mutatedFields.value;
+    const childFields = {};
+    for (const field of mutatedFields) {
+      if (field.entityUuid === uuid && field.list.length > 0) {
+        childFields[field.name] = field.list.map(
+          (item) => buildNestedBlockTree(app, item.uuid, {
+            ...options,
+            currentLevel: options.currentLevel + 1
+          })
+        );
+      }
+    }
+    if (Object.keys(childFields).length > 0) {
+      result.children = childFields;
+    }
+  }
+  return result;
+}
+export default defineBlokkliAgentTool({
+  name: "get_paragraphs_in_viewport",
+  description: `Get paragraphs currently visible in the viewport with their visibility percentage. Use this for viewport-relative queries like "the paragraph at the top", "what's in the center", or "paragraphs near the bottom". NOT for getting all page content - use get_all_page_content for that.`,
+  category: "query",
+  lazy: true,
+  volatile: true,
+  prunedSummary: (r) => `${r.paragraphs?.length || 0} paragraphs in viewport`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t(
+      "aiAgentGetBlocksInViewportRunning",
+      "Getting blocks in viewport",
+      {
+        more: true
+      }
+    );
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { dom, state, $t } = ctx.app;
+    const visibleUuids = dom.getVisibleBlocks();
+    const buildOptions = {
+      includeDimensions: params.includeDimensions ?? false,
+      maxNestingLevel: params.maxNestingLevel,
+      currentLevel: 0
+    };
+    const rootUuids = visibleUuids.filter(
+      (uuid) => state.getNestingLevel(uuid) === 0
+    );
+    const blockTrees = rootUuids.map(
+      (uuid) => buildRootBlockTree(ctx.app, uuid, buildOptions)
+    );
+    blockTrees.sort((a, b) => b.visibilityPercent - a.visibilityPercent);
+    return {
+      label: $t(
+        "aiAgentGetBlocksInViewportDone",
+        "Got @count blocks in viewport"
+      ).replace("@count", String(blockTrees.length)),
+      result: {
+        paragraphs: blockTrees
+      }
+    };
+  }
+});

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+    fieldValue: z.ZodOptional<z.ZodString>;
+    issues: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        impact: z.ZodOptional<z.ZodString>;
+        score: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { runReadabilityAnalysis } from "../readability.js";
+const issueSchema = z.object({
+  text: z.string(),
+  impact: z.string().optional(),
+  score: z.number().optional()
+});
+const fieldResultSchema = z.object({
+  fieldValue: z.string().optional(),
+  issues: z.array(issueSchema)
+});
+export const paramsSchema = z.object({
+  uuids: z.array(z.string()).optional().describe(
+    "Optional list of paragraph UUIDs to return results for. If omitted, returns results for all paragraphs."
+  )
+});
+export const resultSchema = z.record(
+  z.string(),
+  z.record(z.string(), fieldResultSchema)
+);
+export default defineBlokkliAgentTool({
+  name: "get_readability_issues",
+  description: "Run all readability analyzers against the full page. Returns an object keyed by paragraph UUID and field name, with the current field value and a list of issues. Each issue contains the flagged text segment, impact, and scores. Use the result to call update_text_fields directly.",
+  category: "query",
+  volatile: true,
+  lazy: true,
+  modes: ["readonly", "editing", "translating", "review"],
+  requiredAdapterMethods: ["getAnalyzers"],
+  isAvailable: (app) => app.readability.isAvailable.value,
+  label($t) {
+    return $t("aiAgentAnalyzeContentRunning", "Analyzing content", {
+      more: true
+    });
+  },
+  prunedSummary: (r) => {
+    let count = 0;
+    for (const fields of Object.values(r)) {
+      for (const field of Object.values(fields)) {
+        count += field.issues.length;
+      }
+    }
+    return `found ${count} issues`;
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx, params) {
+    const { $t } = ctx.app;
+    const allResults = await runReadabilityAnalysis(ctx.app);
+    const result = params.uuids ? Object.fromEntries(
+      Object.entries(allResults).filter(
+        ([uuid]) => params.uuids.some(
+          (selected) => selected === uuid || ctx.app.state.isChildOf(uuid, selected)
+        )
+      )
+    ) : allResults;
+    let issueCount = 0;
+    for (const fields of Object.values(result)) {
+      for (const field of Object.values(fields)) {
+        issueCount += field.issues.length;
+      }
+    }
+    return {
+      label: $t("aiAgentAnalyzeContentDone", "Analyzed @count results").replace(
+        "@count",
+        String(issueCount)
+      ),
+      result
+    };
+  }
+});

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuids: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    entities: z.ZodArray<z.ZodObject<{
+        entityUuid: z.ZodString;
+        entityType: z.ZodString;
+        entityBundle: z.ZodString;
+        label: z.ZodString;
+        editUrl: z.ZodString;
+        referencedBy: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const _default: any;
+export default _default;