@revenexx/editor 0.1.0

package/dist/modules/agent/runtime/app/providers/planProvider.js

@@ -0,0 +1,34 @@
+import { ref } from "#imports";
+export default function planProvider({
+  socket,
+  conversation
+}) {
+  const plan = ref(null);
+  function approve() {
+    socket.send({ type: "plan_approve" });
+  }
+  function reject() {
+    socket.send({ type: "plan_reject" });
+  }
+  function applyUpdate(state) {
+    if (state && state.steps.length > 0 && state.steps.every((s) => s.status === "completed")) {
+      conversation.pushServerTool({
+        tool: "plan_completed",
+        label: state.title
+      });
+      plan.value = null;
+      return;
+    }
+    plan.value = state;
+  }
+  function clear() {
+    plan.value = null;
+  }
+  return {
+    plan,
+    approve,
+    reject,
+    applyUpdate,
+    clear
+  };
+}

package/dist/modules/agent/runtime/app/providers/socketProvider.d.ts

@@ -0,0 +1,17 @@
+import { type Ref } from '#imports';
+import type { ClientMessage, ServerMessage } from '#blokkli/agent/shared/types';
+export type SocketLifecycleHandlers = {
+    onOpen?: () => void;
+    onClose?: () => void;
+    onError?: (e: Event) => void;
+    onMaxReconnects?: () => void;
+};
+export type SocketProvider = {
+    isConnected: Readonly<Ref<boolean>>;
+    send: (msg: ClientMessage) => void;
+    connect: () => void;
+    disconnect: () => void;
+    setMessageHandler: (handler: (data: ServerMessage) => void) => void;
+    setLifecycleHandlers: (handlers: SocketLifecycleHandlers) => void;
+};
+export default function socketProvider(): SocketProvider;

package/dist/modules/agent/runtime/app/providers/socketProvider.js

@@ -0,0 +1,110 @@
+import { ref, readonly } from "#imports";
+import { routeAgent } from "#blokkli-build/agent-client";
+const PING_INTERVAL_MS = 3e4;
+const RECONNECT_DELAY_MS = 3e3;
+const MAX_RECONNECT_ATTEMPTS = 10;
+export default function socketProvider() {
+  let ws = null;
+  let pingInterval = null;
+  let reconnectTimeout = null;
+  let reconnectAttempts = 0;
+  const isConnected = ref(false);
+  let messageHandler = null;
+  let lifecycle = {};
+  function setMessageHandler(handler) {
+    messageHandler = handler;
+  }
+  function setLifecycleHandlers(handlers) {
+    lifecycle = handlers;
+  }
+  function send(message) {
+    if (ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(message));
+    }
+  }
+  function detachListeners(socket) {
+    socket.removeEventListener("open", onWebSocketOpen);
+    socket.removeEventListener("close", onWebSocketClose);
+    socket.removeEventListener("error", onWebSocketError);
+    socket.removeEventListener("message", onWebSocketMessage);
+  }
+  function clearTimers() {
+    if (pingInterval) {
+      window.clearInterval(pingInterval);
+      pingInterval = null;
+    }
+    if (reconnectTimeout) {
+      window.clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+  }
+  function onWebSocketOpen() {
+    isConnected.value = true;
+    reconnectAttempts = 0;
+    pingInterval = window.setInterval(() => {
+      send({ type: "ping" });
+    }, PING_INTERVAL_MS);
+    lifecycle.onOpen?.();
+  }
+  function onWebSocketClose() {
+    if (pingInterval) {
+      window.clearInterval(pingInterval);
+      pingInterval = null;
+    }
+    isConnected.value = false;
+    lifecycle.onClose?.();
+    reconnectAttempts++;
+    if (reconnectAttempts > MAX_RECONNECT_ATTEMPTS) {
+      lifecycle.onMaxReconnects?.();
+      return;
+    }
+    reconnectTimeout = window.setTimeout(() => {
+      if (!isConnected.value) connect();
+    }, RECONNECT_DELAY_MS);
+  }
+  function onWebSocketError(error) {
+    console.error("WebSocket error:", error);
+    lifecycle.onError?.(error);
+  }
+  function onWebSocketMessage(event) {
+    try {
+      const data = JSON.parse(event.data);
+      messageHandler?.(data);
+    } catch (error) {
+      console.error("Failed to parse WebSocket message:", error);
+    }
+  }
+  function connect() {
+    if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) {
+      return;
+    }
+    if (ws) {
+      detachListeners(ws);
+      ws = null;
+    }
+    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    const url = `${protocol}//${window.location.host}${routeAgent}`;
+    ws = new WebSocket(url);
+    ws.addEventListener("open", onWebSocketOpen);
+    ws.addEventListener("close", onWebSocketClose);
+    ws.addEventListener("error", onWebSocketError);
+    ws.addEventListener("message", onWebSocketMessage);
+  }
+  function disconnect() {
+    clearTimers();
+    if (ws) {
+      detachListeners(ws);
+      ws.close();
+      ws = null;
+    }
+    isConnected.value = false;
+  }
+  return {
+    isConnected: readonly(isConnected),
+    send,
+    connect,
+    disconnect,
+    setMessageHandler,
+    setLifecycleHandlers
+  };
+}

package/dist/modules/agent/runtime/app/providers/toolsProvider.d.ts

@@ -0,0 +1,44 @@
+import { type Ref } from '#imports';
+import type { MutationAction } from '#blokkli/agent/app/types';
+import type { PageContext } from '#blokkli/agent/shared/types';
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { FullBlokkliAdapter } from '#blokkli/editor/adapter';
+import type { AgentToolName, AgentToolMap } from '#blokkli-build/agent-client';
+import type { SocketProvider } from './socketProvider.js';
+import type { ConversationProvider } from './conversationProvider.js';
+export type PendingMutationState = {
+    action: MutationAction;
+    resolve: (approved: boolean) => void;
+};
+export type PendingToolCall = {
+    toolName: string;
+    params: Record<string, unknown>;
+};
+export type ToolsProvider = {
+    pendingMutation: Ref<PendingMutationState | null>;
+    pendingToolCall: Ref<PendingToolCall | null>;
+    autoApprove: Ref<boolean>;
+    pageContext: Readonly<Ref<PageContext | null>>;
+    init: () => Promise<{
+        toolNames: string[];
+    }>;
+    setPageContext: (ctx: PageContext) => void;
+    dispatch: (callId: string, tool: string, params: Record<string, unknown>) => Promise<void>;
+    runForPrompt: <T extends AgentToolName>(toolName: T, params: AgentToolMap[T]['params']) => Promise<{
+        toolName: T;
+        params: AgentToolMap[T]['params'];
+        result: AgentToolMap[T]['result'];
+        label: string;
+    }>;
+    approve: () => void;
+    reject: () => void;
+    setAutoApprove: (value: boolean) => void;
+    onComponentDone: (result: unknown) => void;
+    cancelPending: () => void;
+};
+export default function toolsProvider({ app, adapter, socket, conversation, }: {
+    app: BlokkliApp;
+    adapter: FullBlokkliAdapter<any>;
+    socket: SocketProvider;
+    conversation: ConversationProvider;
+}): ToolsProvider;

package/dist/modules/agent/runtime/app/providers/toolsProvider.js

@@ -0,0 +1,291 @@
+import { ref, shallowRef, readonly } from "#imports";
+import {
+  createToolMap,
+  executeTool,
+  getToolCategory,
+  getToolDefinition,
+  getToolInfoForServer,
+  isMutationAction,
+  isQueryResult,
+  isToolError,
+  asRecord,
+  splitMeta
+} from "#blokkli/agent/app/helpers";
+import { buildNewParagraphsTree } from "#blokkli/agent/app/helpers/mutationResult";
+import { mcpTools } from "#blokkli-build/agent-client";
+import { itemEntityType } from "#blokkli-build/config";
+import { generateId } from "#blokkli/agent/app/helpers/id";
+export default function toolsProvider({
+  app,
+  adapter,
+  socket,
+  conversation
+}) {
+  const { $t, state } = app;
+  const pendingMutation = ref(null);
+  const pendingToolCall = ref(null);
+  const autoApprove = ref(false);
+  const pageContext = shallowRef(null);
+  let toolMap = {};
+  let pendingToolCallResolve = null;
+  function createToolContext() {
+    return {
+      app,
+      itemEntityType,
+      adapter,
+      pageContext: pageContext.value
+    };
+  }
+  async function init() {
+    toolMap = createToolMap(mcpTools);
+    const toolNames = await getToolInfoForServer(
+      mcpTools,
+      state.editMode.value,
+      app,
+      adapter
+    );
+    return { toolNames };
+  }
+  function setPageContext(ctx) {
+    pageContext.value = ctx;
+  }
+  function waitForToolComponent(toolName, params) {
+    return new Promise((resolve) => {
+      pendingToolCall.value = { toolName, params };
+      pendingToolCallResolve = resolve;
+    });
+  }
+  function waitForApproval(action) {
+    return new Promise((resolve) => {
+      pendingMutation.value = { action, resolve };
+    });
+  }
+  async function executeComponentTool(toolDef, ctx, params, setLabel) {
+    const preparedParams = await executeTool(toolMap, toolDef.name, ctx, params);
+    if (isToolError(preparedParams)) {
+      return { ok: false, error: preparedParams.error };
+    }
+    const raw = await waitForToolComponent(
+      toolDef.name,
+      preparedParams
+    );
+    const { payload, meta } = splitMeta(raw);
+    const payloadObj = asRecord(payload);
+    if (setLabel && payloadObj && typeof payloadObj.label === "string") {
+      setLabel(payloadObj.label);
+    }
+    return { ok: true, result: payload, meta };
+  }
+  function executeQueryTool(result, setLabel) {
+    if (isQueryResult(result)) {
+      if (setLabel) setLabel(result.label);
+      if (result.affectedUuids?.length) {
+        app.eventBus.emit("select", result.affectedUuids);
+        app.eventBus.emit("scrollSelectionIntoView", {});
+      }
+      return { ok: true, result: result.result, meta: {} };
+    }
+    return { ok: true, result, meta: {} };
+  }
+  async function executeMutationTool(result, toolDef, setLabel) {
+    if (!isMutationAction(result)) {
+      return { ok: false, error: "Invalid mutation tool result" };
+    }
+    const action = result;
+    if (setLabel) setLabel(action.label);
+    async function applyMutation() {
+      const uuidsBefore = state.getAllUuids();
+      await state.mutateWithLoadingState(() => action.apply(adapter));
+      const newUuids = state.getAllUuids().filter((uuid) => !uuidsBefore.includes(uuid));
+      const selectUuids = newUuids.length ? newUuids : action.affectedUuids || [];
+      if (selectUuids.length) {
+        app.eventBus.emit("select", selectUuids);
+        app.eventBus.emit("scrollSelectionIntoView", {});
+      }
+      return newUuids;
+    }
+    function buildMutationResult(newUuids) {
+      const newParagraphs = action.type === "add" ? buildNewParagraphsTree(newUuids, app, itemEntityType) : [];
+      return {
+        success: true,
+        historyIndex: state.currentMutationIndex.value,
+        newParagraphs: newParagraphs.length ? newParagraphs : void 0,
+        ...action.result
+      };
+    }
+    if (autoApprove.value || !toolDef.requiresApproval) {
+      const newUuids = await applyMutation();
+      return { ok: true, result: buildMutationResult(newUuids), meta: {} };
+    }
+    const approved = await waitForApproval(action);
+    if (approved) {
+      const newUuids = await applyMutation();
+      return { ok: true, result: buildMutationResult(newUuids), meta: {} };
+    }
+    if (action.revert) action.revert();
+    return { ok: true, result: { success: false, rejected: true }, meta: {} };
+  }
+  async function executeLocally(toolName, params, setLabel) {
+    const ctx = createToolContext();
+    const toolDef = getToolDefinition(toolMap, toolName);
+    if (toolDef.component) {
+      return executeComponentTool(toolDef, ctx, params, setLabel);
+    }
+    const category = getToolCategory(toolMap, toolName);
+    const result = await executeTool(toolMap, toolName, ctx, params);
+    if (isToolError(result)) return { ok: false, error: result.error };
+    if (category === "query") {
+      return executeQueryTool(result, setLabel);
+    }
+    return executeMutationTool(result, toolDef, setLabel);
+  }
+  async function dispatch(callId, tool, params) {
+    const toolDef = getToolDefinition(toolMap, tool);
+    const initialLabel = toolDef.label($t);
+    const toolId = generateId();
+    const timestamp = Date.now();
+    let currentLabel = initialLabel;
+    conversation.setActive({
+      type: "tool",
+      id: toolId,
+      callId,
+      tool,
+      label: initialLabel,
+      status: "active",
+      timestamp
+    });
+    function finishItem(status) {
+      conversation.pushTool({
+        type: "tool",
+        id: toolId,
+        callId,
+        tool,
+        label: currentLabel,
+        status,
+        timestamp
+      });
+      conversation.setActive(null);
+    }
+    try {
+      const outcome = await executeLocally(tool, params, (label) => {
+        currentLabel = label;
+        const active = conversation.activeItem.value;
+        if (active?.type === "tool" && active.callId === callId) {
+          conversation.setActive({ ...active, label });
+        }
+      });
+      if (!outcome.ok) {
+        finishItem("error");
+        socket.send({
+          type: "tool_result",
+          callId,
+          result: null,
+          error: outcome.error
+        });
+        return;
+      }
+      finishItem("success");
+      if (toolDef.buildDetails) {
+        try {
+          const detailsSource = outcome.meta.details ?? outcome.result;
+          const details = toolDef.buildDetails(detailsSource);
+          if (details != null) {
+            conversation.setToolDetail(callId, details);
+          }
+        } catch {
+        }
+      }
+      if (outcome.meta.usage) {
+        conversation.pushUsage(outcome.meta.usage);
+      }
+      let resultForServer = outcome.result;
+      const resultObj = asRecord(resultForServer);
+      if (toolDef.prunedSummary && resultObj) {
+        try {
+          const summary = toolDef.prunedSummary(resultObj);
+          if (summary) {
+            resultForServer = { ...resultObj, _summary: summary };
+          }
+        } catch {
+        }
+      }
+      socket.send({
+        type: "tool_result",
+        callId,
+        result: resultForServer,
+        skipLlmResponse: outcome.meta.skipLlmResponse
+      });
+    } catch (error) {
+      finishItem("error");
+      socket.send({
+        type: "tool_result",
+        callId,
+        result: null,
+        error: error.message
+      });
+    }
+  }
+  async function runForPrompt(toolName, params) {
+    const ctx = createToolContext();
+    if (!Object.keys(toolMap).length) {
+      toolMap = createToolMap(mcpTools);
+    }
+    const toolDef = getToolDefinition(toolMap, toolName);
+    const rawResult = await executeTool(toolMap, toolName, ctx, params);
+    const label = isQueryResult(rawResult) ? rawResult.label : toolDef.label($t);
+    const result = isQueryResult(rawResult) ? rawResult.result : rawResult;
+    return { toolName, params, result, label };
+  }
+  function approve() {
+    if (pendingMutation.value) {
+      pendingMutation.value.resolve(true);
+      pendingMutation.value = null;
+    }
+  }
+  function reject() {
+    if (pendingMutation.value) {
+      pendingMutation.value.resolve(false);
+      pendingMutation.value = null;
+    }
+  }
+  function setAutoApprove(value) {
+    autoApprove.value = value;
+    if (value) approve();
+  }
+  function onComponentDone(result) {
+    if (pendingToolCallResolve) {
+      pendingToolCallResolve(result);
+      pendingToolCallResolve = null;
+    }
+    pendingToolCall.value = null;
+  }
+  function cancelPending() {
+    if (pendingMutation.value) {
+      if (pendingMutation.value.action.revert) {
+        pendingMutation.value.action.revert();
+      }
+      pendingMutation.value.resolve(false);
+      pendingMutation.value = null;
+    }
+    if (pendingToolCallResolve) {
+      pendingToolCallResolve({ cancelled: true });
+      pendingToolCallResolve = null;
+    }
+    pendingToolCall.value = null;
+  }
+  return {
+    pendingMutation,
+    pendingToolCall,
+    autoApprove,
+    pageContext: readonly(pageContext),
+    init,
+    setPageContext,
+    dispatch,
+    runForPrompt,
+    approve,
+    reject,
+    setAutoApprove,
+    onComponentDone,
+    cancelPending
+  };
+}

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

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    itemId: z.ZodString;
+    itemEntityType: z.ZodString;
+    itemEntityBundle: z.ZodString;
+    targetBundle: z.ZodString;
+    parent: z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strip>;
+    position: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        rewrite: "rewrite";
+        delete: "delete";
+        add: "add";
+        move: "move";
+        options: "options";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,79 @@
+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";
+export 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 const resultSchema = mutationResultSchema;
+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.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "added content paragraph" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t(
+      "aiAgentAddContentSearchBlockRunning",
+      "Adding content paragraph",
+      { more: true }
+    );
+  },
+  paramsSchema,
+  resultSchema,
+  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,24 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    name: z.ZodString;
+    parent: z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strip>;
+    position: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        rewrite: "rewrite";
+        delete: "delete";
+        add: "add";
+        move: "move";
+        options: "options";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+declare const _default: any;
+export default _default;