@revenexx/editor 0.1.0

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

@@ -0,0 +1,47 @@
+const UUID_PATTERN = /(?<![\w#-])[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(?![\w-])/gi;
+const CODE_REGION_PATTERN = /```[\s\S]*?```|`[^`\n]*`/g;
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (c) => {
+    switch (c) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      default:
+        return "&#39;";
+    }
+  });
+}
+export function linkifyBlockUuids(content, resolve, deletedLabel) {
+  if (!content) return content;
+  const parts = [];
+  let cursor = 0;
+  CODE_REGION_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = CODE_REGION_PATTERN.exec(content)) !== null) {
+    parts.push(
+      replaceOutsideCode(
+        content.slice(cursor, match.index),
+        resolve,
+        deletedLabel
+      )
+    );
+    parts.push(match[0]);
+    cursor = match.index + match[0].length;
+  }
+  parts.push(replaceOutsideCode(content.slice(cursor), resolve, deletedLabel));
+  return parts.join("");
+}
+function replaceOutsideCode(segment, resolve, deletedLabel) {
+  return segment.replace(UUID_PATTERN, (uuid) => {
+    const label = resolve(uuid);
+    if (label === null) {
+      return `<span class="bk-agent-block-ref-deleted">[${escapeHtml(deletedLabel)}]</span>`;
+    }
+    return `<a class="bk-agent-block-ref" href="#${uuid}">${escapeHtml(label)}</a>`;
+  });
+}

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

@@ -0,0 +1,7 @@
+/** Shared marked options for all agent markdown rendering. */
+export declare const markedOptions: {
+    readonly gfm: true;
+    readonly breaks: true;
+};
+/** Render markdown to an HTML string using the shared options. */
+export declare function renderMarkdown(content: string): string;

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

@@ -0,0 +1,5 @@
+import { marked } from "marked";
+export const markedOptions = { gfm: true, breaks: true };
+export function renderMarkdown(content) {
+  return marked.parse(content, markedOptions);
+}

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

@@ -0,0 +1,38 @@
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+/**
+ * Tree-shaped entry in the `newParagraphs` payload returned by mutation tools.
+ *
+ * Mirrors the input shape of `add_paragraphs` — nested children are grouped by
+ * paragraph field name so the LLM can verify the structure round-tripped. A
+ * flat list was previously emitted; the model could not tell whether a child
+ * UUID was actually a sibling that got placed at the top level by mistake.
+ */
+export type NewParagraphNode = {
+    uuid: string;
+    bundle: string;
+    paragraphFields?: string[];
+    children?: Record<string, NewParagraphNode[]>;
+};
+/**
+ * Build the tree-shaped `newParagraphs` payload from a flat list of newly
+ * created block UUIDs (computed as the set diff of `getAllUuids()` before vs
+ * after a mutation).
+ *
+ * A block whose host is ALSO in `newUuids` is nested under that parent's
+ * `children[fieldName]`. Top-level entries are blocks whose parent already
+ * existed before the mutation — these were inserted into the target field.
+ *
+ * Per-block lookup uses `app.blocks.getBlock` (host metadata) and
+ * `app.types.fieldConfig` (paragraph-field discovery), so no extra adapter
+ * round-trips are needed.
+ */
+export declare function buildNewParagraphsTree(newUuids: string[], app: BlokkliApp, itemEntityType: string): NewParagraphNode[];
+/**
+ * Count every node in a `newParagraphs` tree, including nested children.
+ *
+ * The tree-shaped envelope means a top-level array of length 1 can still
+ * represent dozens of added blocks (one parent with many children). Callers
+ * that report "added N paragraphs" should count recursively so the figure
+ * stays honest.
+ */
+export declare function countNewParagraphs(nodes: NewParagraphNode[]): number;

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

@@ -0,0 +1,49 @@
+export function buildNewParagraphsTree(newUuids, app, itemEntityType) {
+  if (!newUuids.length) return [];
+  const newSet = new Set(newUuids);
+  const nodes = /* @__PURE__ */ new Map();
+  const roots = [];
+  const pendingChildren = /* @__PURE__ */ new Map();
+  for (const uuid of newUuids) {
+    const block = app.blocks.getBlock(uuid);
+    if (!block) continue;
+    const paragraphFields = app.types.fieldConfig.forEntityTypeAndBundle(itemEntityType, block.bundle).map((f) => f.name);
+    const node = {
+      uuid,
+      bundle: block.bundle,
+      ...paragraphFields.length ? { paragraphFields } : {}
+    };
+    nodes.set(uuid, node);
+    const host = block.host;
+    if (host.type === itemEntityType && newSet.has(host.uuid)) {
+      let perField = pendingChildren.get(host.uuid);
+      if (!perField) {
+        perField = /* @__PURE__ */ new Map();
+        pendingChildren.set(host.uuid, perField);
+      }
+      const bucket = perField.get(host.fieldName) ?? [];
+      bucket.push(node);
+      perField.set(host.fieldName, bucket);
+    } else {
+      roots.push(node);
+    }
+  }
+  for (const [parentUuid, perField] of pendingChildren) {
+    const parent = nodes.get(parentUuid);
+    if (!parent) continue;
+    parent.children = Object.fromEntries(perField);
+  }
+  return roots;
+}
+export function countNewParagraphs(nodes) {
+  let total = 0;
+  for (const node of nodes) {
+    total += 1;
+    if (node.children) {
+      for (const childList of Object.values(node.children)) {
+        total += countNewParagraphs(childList);
+      }
+    }
+  }
+  return total;
+}

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,84 @@
+import {
+  getParagraphChildren,
+  readBlockContentFields
+} from "#blokkli/agent/app/tools/helpers";
+import { itemEntityType } from "#blokkli-build/config";
+const MAX_CONTENT_LENGTH = 150;
+function truncate(text) {
+  const cleaned = text.trim();
+  if (cleaned.length <= MAX_CONTENT_LENGTH) return cleaned;
+  return cleaned.slice(0, MAX_CONTENT_LENGTH) + " [TRUNCATED]";
+}
+export function buildBlock(app, uuid, bundle) {
+  const block = { uuid, bundle };
+  const content = {};
+  for (const f of readBlockContentFields(app, uuid, itemEntityType, bundle)) {
+    const truncated = truncate(f.value);
+    if (truncated) {
+      content[f.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 = app.fieldValue.readValue(
+      entityType,
+      pageUuid,
+      entityBundle,
+      config.name,
+      fieldType
+    );
+    const text = 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/parseConversationData.d.ts

@@ -0,0 +1,27 @@
+import { type ConversationItem } from '#blokkli/agent/app/types';
+import type { ConversationStateSnapshot, UsageTurn } from '#blokkli/agent/shared/types';
+import type { AgentConversationData, AgentConversationFeedbackItem, AgentConversationHostInfo } from '#blokkli/agent/app/features/agent/types';
+import type { BlokkliUser } from '#blokkli/editor/types/user';
+export type ParsedConversation = {
+    uuid: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    host: AgentConversationHostInfo | null;
+    author: BlokkliUser | null;
+    conversation: ConversationItem[];
+    usageTurns: UsageTurn[];
+    serverState: ConversationStateSnapshot;
+    feedbackItemIds: string[];
+    feedback: AgentConversationFeedbackItem[];
+};
+/**
+ * Parse a stored conversation into the runtime shape used by the conversation
+ * rendering. Pure — does not touch any reactive state — so it can be reused by
+ * both the live editor session (which then applies it via the provider) and
+ * the admin moderation modal (which renders it read-only).
+ *
+ * Returns null if the stored data is missing required pieces or fails to
+ * parse; callers should treat that as "unrenderable".
+ */
+export declare function parseConversationData(data: AgentConversationData): ParsedConversation | null;

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

@@ -0,0 +1,42 @@
+import {
+  conversationItemSchema
+} from "#blokkli/agent/app/types";
+import { generateId } from "#blokkli/agent/app/helpers/id";
+export function parseConversationData(data) {
+  try {
+    const parsed = JSON.parse(data.clientState);
+    if (!parsed.conversation?.length) return null;
+    const clientConversation = parsed.conversation.map(
+      (item) => {
+        const result = conversationItemSchema.safeParse(item);
+        if (result.success) return result.data;
+        return {
+          type: "unknown",
+          id: generateId(),
+          timestamp: Date.now()
+        };
+      }
+    );
+    const serverParsed = JSON.parse(data.serverState);
+    if (!serverParsed?.messages?.length) return null;
+    return {
+      uuid: data.uuid,
+      title: data.title,
+      createdAt: data.createdAt,
+      updatedAt: data.updatedAt,
+      host: data.host,
+      author: data.author,
+      conversation: clientConversation,
+      usageTurns: parsed.usageTurns ?? [],
+      feedbackItemIds: data.feedbackItemIds ?? [],
+      feedback: data.feedback ?? [],
+      serverState: {
+        messages: serverParsed.messages,
+        activatedLazyTools: serverParsed.activatedLazyTools,
+        hash: data.hash
+      }
+    };
+  } catch {
+    return null;
+  }
+}

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

@@ -0,0 +1,48 @@
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { RenderedFieldListItem } from '#blokkli/editor/types/field';
+import type { BlockPermission } from '#blokkli/editor/types/definitions';
+import type { ToolError } from '../types/index.js';
+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;
+/**
+ * Check that none of the given blocks are inside a restricted ancestor.
+ * Returns a ToolError if any block has a restricted ancestor, or undefined if
+ * all are unrestricted.
+ */
+export declare function requireNoRestrictedAncestor(app: BlokkliApp, uuids: string[]): ToolError | undefined;
+/**
+ * Check that the user has a specific permission for all given bundles.
+ * Returns a ToolError if any bundle is denied, or undefined if all are allowed.
+ */
+export declare function requireBundlePermission(app: BlokkliApp, bundles: string[], operation: BlockPermission): ToolError | undefined;
+export {};

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

@@ -0,0 +1,99 @@
+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 };
+}
+export function requireNoRestrictedAncestor(app, uuids) {
+  for (const uuid of uuids) {
+    if (app.permissions.blockHasRestrictedAncestor(uuid)) {
+      return {
+        error: "Permission denied: block is inside a parent with restricted editing permissions"
+      };
+    }
+  }
+  return void 0;
+}
+export function requireBundlePermission(app, bundles, operation) {
+  const denied = app.permissions.filterDeniedBundles(bundles, operation);
+  if (denied.length > 0) {
+    const labels = denied.map(
+      (b) => app.types.getBlockBundleDefinition(b)?.label || b
+    );
+    return {
+      error: `Permission denied: cannot ${operation} ${labels.map((l) => `"${l}"`).join(", ")}`
+    };
+  }
+  return void 0;
+}

package/dist/modules/agent/runtime/app/prompts/fixReadability.d.ts

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

package/dist/modules/agent/runtime/app/prompts/fixReadability.js

@@ -0,0 +1,57 @@
+import { defineBlokkliAgentPrompt } from "#blokkli/agent/app/composables";
+export default defineBlokkliAgentPrompt({
+  resolve: (app) => {
+    if (!app.readability.isAvailable.value) return [];
+    return [
+      {
+        id: "fix_readability",
+        skills: ["rewrite-and-translate", "assess-and-fix-readability"],
+        tools: [
+          "get_readability_issues",
+          "check_readability_for_texts",
+          "delegate_text_rewrite"
+        ],
+        getLabel: ({ $t }) => {
+          return $t("fixReadability", "Fix readability", {
+            more: true
+          });
+        },
+        getPrompt: ({ $t }) => {
+          return $t(
+            "agentPromptReadabilityPrompt",
+            "The readability issues have already been analyzed and the fix has been applied. Do not call any more tools. Just very briefly confirm that you are done."
+          );
+        },
+        getUserPrompt: ({ $t }) => {
+          return $t(
+            "agentPromptReadabilityUserPrompt",
+            "Fix the readability of the selected paragraphs."
+          );
+        },
+        async preExecute({ selectedBlocks, runTool }) {
+          const readability = await runTool(
+            "get_readability_issues",
+            selectedBlocks.length ? {
+              uuids: selectedBlocks.map((b) => b.uuid)
+            } : {}
+          );
+          const fields = Object.entries(readability.result).flatMap(
+            ([uuid, fieldMap]) => Object.keys(fieldMap).map((fieldName) => ({ uuid, fieldName }))
+          );
+          return {
+            preSeededResults: [readability],
+            autoExecuteTools: fields.length > 0 ? [
+              {
+                toolName: "delegate_text_rewrite",
+                params: {
+                  request: { template: "fix_readability" },
+                  fields
+                }
+              }
+            ] : void 0
+          };
+        }
+      }
+    ];
+  }
+});

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

@@ -0,0 +1,56 @@
+import { type Ref } from '#imports';
+import type { Attachment, PreSeededToolResult, AutoExecuteTool } from '#blokkli/agent/app/types';
+import type { SelectedBlock } from '#blokkli/agent/shared/types';
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { FullBlokkliAdapter } from '#blokkli/editor/adapter';
+import type { SocketProvider } from './socketProvider.js';
+import type { ConversationProvider } from './conversationProvider.js';
+import type { PlanProvider } from './planProvider.js';
+import type { ToolsProvider } from './toolsProvider.js';
+export type SendPromptOptions = {
+    prompt: string;
+    displayPrompt?: string;
+    selectedBlocks?: SelectedBlock[];
+    attachments?: Attachment[];
+    autoLoadTools?: string[];
+    autoLoadSkills?: string[];
+    preSeededResults?: PreSeededToolResult[];
+    autoExecuteTools?: AutoExecuteTool[];
+    /**
+     * When set, the server truncates Session.messages at the Nth real user
+     * turn (0-based) before processing this prompt. Used by retry/edit.
+     */
+    rollbackToUserMessageIndex?: number;
+    /**
+     * Id of the prompt definition that triggered this send, if any. Stored on
+     * the user message so retry can re-run `preExecute` against current
+     * (post-rollback) page state.
+     */
+    promptId?: string;
+};
+export type AgentOrchestrator = {
+    isReady: Ref<boolean>;
+    hasBeenReady: Ref<boolean>;
+    isProcessing: Ref<boolean>;
+    isThinking: Ref<boolean>;
+    connect: () => void;
+    disconnect: () => void;
+    sendPrompt: (options: SendPromptOptions) => void;
+    retry: (targetItemId?: string) => void;
+    rollbackAndSend: (targetItemId: string, newPrompt?: string) => void;
+    cancel: () => void;
+    newConversation: () => void;
+    getTranscript: () => void;
+    switchConversation: (id: string) => Promise<void>;
+    deleteConversation: (id: string) => Promise<void>;
+    refreshConversationList: () => Promise<void>;
+};
+export default function agentProvider({ app, adapter, agentName, socket, conversation, plan, tools, }: {
+    app: BlokkliApp;
+    adapter: FullBlokkliAdapter<any>;
+    agentName: string;
+    socket: SocketProvider;
+    conversation: ConversationProvider;
+    plan: PlanProvider;
+    tools: ToolsProvider;
+}): AgentOrchestrator;