@revenexx/editor 0.1.0

package/dist/modules/agent/runtime/app/tools/update_text_fields/Component.vue

@@ -0,0 +1,198 @@
+<template>
+  <DiffApproval
+    v-if="items.length > 0 && params.requireApproval !== false"
+    :items="items"
+    show-reason
+    @apply="applySelected"
+    @cancel="rejectAll"
+  />
+</template>
+
+<script setup>
+import { useBlokkli, ref, onMounted } from "#imports";
+import { DiffApproval } from "#blokkli/editor/components";
+import { splitIntoSegments } from "#blokkli/editor/helpers/diff";
+import { applyOperations, resolveHost as resolveBlockHost } from "../helpers";
+import {
+  applyFieldDiffs,
+  rejectedWithoutReasonMessage,
+  partialRejectionGuidance,
+  skippedFieldsMessage,
+  appendAgentNote
+} from "../fieldDiffApproval";
+const props = defineProps({
+  context: { type: null, required: true },
+  params: { type: Object, required: true }
+});
+const emit = defineEmits(["done"]);
+const blokkli = useBlokkli();
+const { $t, state, types, directive } = blokkli;
+const isApplying = ref(false);
+const skippedNote = skippedFieldsMessage(props.params.skipped);
+function emitDone(result) {
+  emit("done", {
+    ...result,
+    agentMessage: appendAgentNote(result.agentMessage, skippedNote)
+  });
+}
+onMounted(() => {
+  if (items.length === 0) {
+    emitDone({
+      acceptedCount: 0,
+      rejectedByUser: {},
+      label: $t("aiAgentBatchRewriteNoChanges", "No changes detected"),
+      agentMessage: "No changes were applied \u2014 the requested values already matched the current field values."
+    });
+    return;
+  }
+  if (props.params.requireApproval === false) {
+    applySelected({
+      selected: Object.fromEntries(items.map((item) => [item.id, true])),
+      reasons: Object.fromEntries(items.map((item) => [item.id, ""]))
+    });
+  }
+});
+function resolveHost(uuid) {
+  return resolveBlockHost(blokkli, uuid);
+}
+function resolveFieldLabel(uuid, fieldName) {
+  const host = resolveHost(uuid);
+  if (!host) return fieldName;
+  const config = types.editableFieldConfig.forName(
+    host.entityType,
+    host.bundle,
+    fieldName
+  );
+  return config?.label || fieldName;
+}
+function getFieldType(uuid, fieldName) {
+  const host = resolveHost(uuid);
+  if (!host) return null;
+  const cfg = types.editableFieldConfig.forName(
+    host.entityType,
+    host.bundle,
+    fieldName
+  );
+  if (!cfg || cfg.type === "table") return null;
+  return cfg.type === "plain" ? "plain" : "markup";
+}
+function getCurrentValue(uuid, fieldName) {
+  const host = resolveHost(uuid);
+  if (!host) return null;
+  const el = directive.findEditableElement(fieldName, {
+    type: host.entityType,
+    bundle: host.bundle,
+    uuid
+  });
+  if (!el) return null;
+  const fieldType = getFieldType(uuid, fieldName);
+  if (fieldType === null) return null;
+  return fieldType === "plain" ? el.textContent || "" : el.innerHTML;
+}
+let idCounter = 0;
+const beforeValues = /* @__PURE__ */ new Map();
+function buildItems() {
+  const result = [];
+  const pushItem = (uuid, fieldName, value, fieldType) => {
+    result.push({
+      id: idCounter++,
+      uuid,
+      fieldName,
+      fieldLabel: resolveFieldLabel(uuid, fieldName),
+      value,
+      fieldType
+    });
+  };
+  if (props.params.updates) {
+    for (const { uuid, fieldName, value } of props.params.updates) {
+      const fieldType = getFieldType(uuid, fieldName);
+      if (fieldType === null) continue;
+      pushItem(uuid, fieldName, value, fieldType);
+    }
+  }
+  if (props.params.operations?.length) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const op of props.params.operations) {
+      const key = `${op.uuid}::${op.fieldName}`;
+      let entry = grouped.get(key);
+      if (!entry) {
+        entry = { uuid: op.uuid, fieldName: op.fieldName, ops: [] };
+        grouped.set(key, entry);
+      }
+      entry.ops.push({
+        search: op.search,
+        replace: op.replace,
+        selector: op.selector
+      });
+    }
+    for (const { uuid, fieldName, ops } of grouped.values()) {
+      const current = getCurrentValue(uuid, fieldName);
+      if (current === null) continue;
+      const fieldType = getFieldType(uuid, fieldName);
+      if (fieldType === null) continue;
+      const newValue = applyOperations(current, ops);
+      if (newValue === current) continue;
+      pushItem(uuid, fieldName, newValue, fieldType);
+    }
+  }
+  return result;
+}
+const items = [];
+for (const draft of buildItems()) {
+  const current = getCurrentValue(draft.uuid, draft.fieldName);
+  if (current !== null) {
+    beforeValues.set(draft.id, current);
+    if (current === draft.value) continue;
+  }
+  const segments = current !== null ? splitIntoSegments(current, draft.value, draft.fieldType) ?? void 0 : void 0;
+  items.push({
+    id: draft.id,
+    uuid: draft.uuid,
+    fieldName: draft.fieldName,
+    fieldLabel: draft.fieldLabel,
+    value: draft.value,
+    segments
+  });
+}
+async function applySelected(data) {
+  const { selected, reasons } = data;
+  isApplying.value = true;
+  const { acceptedCount, rejectedByUser, label, appliedByItemId } = await applyFieldDiffs(
+    blokkli,
+    props.context.adapter,
+    items,
+    selected,
+    reasons
+  );
+  const _details = items.filter((item) => appliedByItemId[item.id] !== void 0).map((item) => ({
+    fieldLabel: item.fieldLabel,
+    before: beforeValues.get(item.id) || "",
+    after: appliedByItemId[item.id]
+  }));
+  emitDone({
+    acceptedCount,
+    rejectedByUser,
+    label,
+    agentMessage: appendAgentNote(
+      partialRejectionGuidance(rejectedByUser),
+      rejectedWithoutReasonMessage(rejectedByUser)
+    ),
+    historyIndex: state.currentMutationIndex.value,
+    _details
+  });
+}
+async function rejectAll() {
+  const rejectedByUser = {};
+  for (const item of items) {
+    const fields = rejectedByUser[item.uuid] ?? {};
+    fields[item.fieldName] = { reasonForRejection: "" };
+    rejectedByUser[item.uuid] = fields;
+  }
+  emitDone({
+    acceptedCount: 0,
+    rejectedByUser,
+    label: $t("aiAgentBatchRewriteAllRejected", "All changes rejected"),
+    agentMessage: "All changes were rejected by the user. Ask the user what they would like to change instead."
+  });
+}
+</script>

package/dist/modules/agent/runtime/app/tools/update_text_fields/Component.vue.d.ts

@@ -0,0 +1,51 @@
+import type { McpToolContext } from '#blokkli/agent/app/types';
+import type { ComponentParams } from './index.js';
+type __VLS_Props = {
+    context: McpToolContext;
+    params: ComponentParams;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    done: (result: ComponentToolResult<{
+        acceptedCount: number;
+        rejectedByUser: Record<string, Record<string, {
+            reasonForRejection: string;
+            partial?: {
+                accepted: number;
+                total: number;
+                rejectedSegments: {
+                    tag: string;
+                    beforeHtml: string;
+                    afterHtml: string;
+                    status: "deleted" | "matched" | "inserted";
+                    reasonForRejection: string;
+                }[];
+            } | undefined;
+        }>>;
+        label: string;
+        agentMessage?: string | undefined;
+        historyIndex?: number | undefined;
+    }>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDone?: ((result: ComponentToolResult<{
+        acceptedCount: number;
+        rejectedByUser: Record<string, Record<string, {
+            reasonForRejection: string;
+            partial?: {
+                accepted: number;
+                total: number;
+                rejectedSegments: {
+                    tag: string;
+                    beforeHtml: string;
+                    afterHtml: string;
+                    status: "deleted" | "matched" | "inserted";
+                    reasonForRejection: string;
+                }[];
+            } | undefined;
+        }>>;
+        label: string;
+        agentMessage?: string | undefined;
+        historyIndex?: number | undefined;
+    }>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { fieldDiffResultSchema } from '../schemas.js';
+import { type SkippedField } from '../fieldDiffApproval.js';
+declare const operationSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    fieldName: z.ZodString;
+    search: z.ZodString;
+    replace: z.ZodString;
+    selector: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
+}, z.core.$strip>;
+declare const updateSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    fieldName: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>;
+export declare const paramsSchema: z.ZodObject<{
+    updates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        fieldName: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>>;
+    operations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        fieldName: z.ZodString;
+        search: z.ZodString;
+        replace: z.ZodString;
+        selector: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    requireApproval: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
+}, z.core.$strip>;
+export type BatchRewriteParams = z.infer<typeof paramsSchema>;
+export type BatchRewriteResult = z.infer<typeof fieldDiffResultSchema>;
+/**
+ * The resolved params handed to the component after `execute` has dropped
+ * references that don't exist. `updates`/`operations` are pre-filtered to valid
+ * (uuid, fieldName) pairs; `skipped` lists what was dropped so the component can
+ * report it back to the agent.
+ */
+export type ComponentParams = {
+    updates?: z.infer<typeof updateSchema>[];
+    operations?: z.infer<typeof operationSchema>[];
+    requireApproval?: boolean;
+    skipped: SkippedField[];
+};
+export declare const resultSchema: z.ZodObject<{
+    acceptedCount: z.ZodNumber;
+    rejectedByUser: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        reasonForRejection: z.ZodString;
+        partial: z.ZodOptional<z.ZodObject<{
+            accepted: z.ZodNumber;
+            total: z.ZodNumber;
+            rejectedSegments: z.ZodArray<z.ZodObject<{
+                tag: z.ZodString;
+                beforeHtml: z.ZodString;
+                afterHtml: z.ZodString;
+                status: z.ZodEnum<{
+                    deleted: "deleted";
+                    matched: "matched";
+                    inserted: "inserted";
+                }>;
+                reasonForRejection: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    label: z.ZodString;
+    agentMessage: z.ZodOptional<z.ZodString>;
+    historyIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,138 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  requireBundlePermission,
+  requireNoRestrictedAncestor
+} from "../../helpers/validation.js";
+import { onlyUnique } from "#blokkli/helpers";
+import { fieldDiffResultSchema } from "../schemas.js";
+import { optionalBooleanParam } from "../../../shared/toolParams.js";
+import { resolveHost } from "../helpers.js";
+import { skippedFieldsMessage } from "../fieldDiffApproval.js";
+import Component from "./Component.vue";
+import DetailsComponent from "../../components/FieldDiffDetails/index.vue";
+const operationSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  fieldName: z.string().describe("The editable field name"),
+  search: z.string().describe(
+    'Text to find in the field value, OR a CSS selector (e.g. "p:nth-child(3)") to target a specific HTML element'
+  ),
+  replace: z.string().describe(
+    "The replacement text (or innerHTML when search is a CSS selector)"
+  ),
+  selector: optionalBooleanParam(
+    "Set to true when search is a CSS selector instead of a text search"
+  )
+});
+const updateSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  fieldName: z.string().describe("The editable field name"),
+  value: z.string().describe("The complete new field value \u2014 overwrites the entire field")
+});
+export const paramsSchema = z.object({
+  updates: z.array(updateSchema).optional().describe(
+    "Full-replacement mode: a list of { uuid, fieldName, value } entries. Each overwrites the entire field with the given value. Use when the value changes substantially or you already have the final text."
+  ),
+  operations: z.array(operationSchema).optional().describe(
+    "Patch mode: search/replace operations applied to each field's CURRENT value, so `search` must match the existing content exactly. Best for small targeted edits like typo fixes \u2014 avoids re-sending the whole value. If `search` is not found, that field is left unchanged."
+  ),
+  requireApproval: optionalBooleanParam(
+    "The approval UI is shown by default. Set to false to apply the changes immediately without confirmation \u2014 only when the user supplied the exact text themselves."
+  )
+});
+export const resultSchema = fieldDiffResultSchema;
+export default defineBlokkliAgentTool({
+  name: "update_text_fields",
+  description: "Update text content fields on one or more paragraphs. Two modes, which may be combined in a single call:\n- Full replacement via `updates`: a list of { uuid, fieldName, value } entries, each overwriting the entire field with a complete new value. Use when the value changes substantially or you already have the final text.\n- Patch via `operations`: search/replace pairs applied to each field's CURRENT value (so `search` must match the existing content). Best for small edits like typo fixes, since you only send the changed part. Set `selector: true` on an operation to treat `search` as a CSS selector (e.g. \"p:nth-child(3)\") and `replace` as the matched element's innerHTML.\nThe approval UI is shown by default; set requireApproval to false to apply immediately (only when the user supplied the exact text).",
+  category: "mutation",
+  lazy: true,
+  prunedSummary: (r) => `${r.acceptedCount || 0} accepted, ${Object.keys(r.rejectedByUser || {}).length} rejected`,
+  modes: ["editing", "translating"],
+  label($t) {
+    return $t("aiAgentBatchRewriteTextRunning", "Rewriting multiple texts", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema,
+  requiredAdapterMethods: ["updateFieldValueBatched"],
+  component: Component,
+  detailsComponent: DetailsComponent,
+  buildDetails: (result) => result,
+  execute(ctx, params) {
+    const skipped = [];
+    const skipReason = (uuid, fieldName) => {
+      const host = resolveHost(ctx.app, uuid);
+      if (!host) return "paragraph not found";
+      const field = ctx.app.types.editableFieldConfig.forName(
+        host.entityType,
+        host.bundle,
+        fieldName
+      );
+      if (!field) return "field not found";
+      return void 0;
+    };
+    const keep = (entries) => entries?.filter((entry) => {
+      const reason = skipReason(entry.uuid, entry.fieldName);
+      if (reason) {
+        skipped.push({ uuid: entry.uuid, fieldName: entry.fieldName, reason });
+        return false;
+      }
+      return true;
+    });
+    const updates = keep(params.updates);
+    const operations = keep(params.operations);
+    if (!updates?.length && !operations?.length) {
+      return {
+        error: skippedFieldsMessage(skipped) ?? "No updates or operations were provided."
+      };
+    }
+    const blockUuids = [
+      ...updates?.map((u) => u.uuid) ?? [],
+      ...operations?.map((op) => op.uuid) ?? []
+    ].filter(onlyUnique);
+    const bundles = blockUuids.map((uuid) => ctx.app.blocks.getBlock(uuid)?.bundle).filter((b) => !!b).filter(onlyUnique);
+    if (bundles.length) {
+      const denied = requireBundlePermission(ctx.app, bundles, "edit");
+      if (denied) return denied;
+    }
+    const ancestorDenied = requireNoRestrictedAncestor(ctx.app, blockUuids);
+    if (ancestorDenied) return ancestorDenied;
+    return {
+      updates,
+      operations,
+      requireApproval: params.requireApproval,
+      skipped
+    };
+  },
+  mockParams: () => ({
+    updates: [
+      {
+        uuid: "4526d2d0-f122-4093-902f-e2f00a433981",
+        fieldName: "title",
+        value: "Seamlessly integrates in any Nuxt setup"
+      },
+      {
+        uuid: "4526d2d0-f122-4093-902f-e2f00a433981",
+        fieldName: "tagline",
+        value: "Great Developer Experience"
+      },
+      {
+        uuid: "9485812c-0ecd-4699-85b2-3a031d47a0a1",
+        fieldName: "text",
+        value: "<ul><li>Fully responsive design</li><li>Touch gestures and smooth interactions</li><li>All editing features available on mobile</li><li>Optimized for tablets</li></ul>"
+      },
+      {
+        uuid: "67a9e26f-8028-4283-8b7d-8f836355b949",
+        fieldName: "text",
+        value: "<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.</p><p>Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.</p><p>Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.</p><p>Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p><p>Curabitur pretium tincidunt lacus. Nulla gravida orci a odio. Nullam varius, turpis et commodo pharetra.</p>"
+      },
+      {
+        uuid: "3a2617ed-6844-4d39-859c-82869f4ea5aa",
+        fieldName: "text",
+        value: "<ul><li>Auto import block components</li><li>Directly define options inside the component</li><li>Support for import chunks</li></ul>"
+      }
+    ],
+    requireApproval: true
+  })
+});

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    url: z.ZodString;
+    format: z.ZodDefault<z.ZodEnum<{
+        markdown: "markdown";
+        html: "html";
+    }>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    content: z.ZodString;
+    title: z.ZodString;
+    format: z.ZodEnum<{
+        markdown: "markdown";
+        html: "html";
+    }>;
+    url: z.ZodString;
+}, z.core.$strip>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { routeFetch } from "#blokkli-build/agent-client";
+export const paramsSchema = z.object({
+  url: z.string().url().describe("The URL to fetch content from"),
+  format: z.enum(["markdown", "html"]).default("markdown").describe(
+    'Output format: "markdown" (default) converts HTML to readable Markdown preserving structure, "html" returns cleaned raw HTML'
+  )
+});
+export const resultSchema = z.object({
+  content: z.string().describe("The page content in the requested format (markdown or html)"),
+  title: z.string().describe("The page title"),
+  format: z.enum(["markdown", "html"]).describe("The format of the content"),
+  url: z.string().describe("The final URL (may differ from input if redirected)")
+});
+export default defineBlokkliAgentTool({
+  name: "web_fetch",
+  description: 'Fetch and extract content from a web page. Only allowed origins can be fetched. By default returns Markdown which preserves document structure (headings, lists, links). Use format="html" if you need the raw HTML.',
+  category: "query",
+  lazy: true,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentWebFetchRunning", "Fetching web page", { more: true });
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx, params) {
+    const { $t } = ctx.app;
+    const response = await fetch(routeFetch, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ url: params.url, format: params.format })
+    });
+    if (!response.ok) {
+      let errorMessage = "Failed to fetch URL";
+      try {
+        const errorData = await response.json();
+        errorMessage = errorData.message || errorMessage;
+      } catch {
+      }
+      return { error: errorMessage };
+    }
+    const result = await response.json();
+    return {
+      label: $t("aiAgentWebFetchDone", "Fetched '@title'").replace(
+        "@title",
+        result.title || params.url
+      ),
+      result
+    };
+  }
+});