@ixo/oracle-runtime 0.0.1

package/dist/plugins/editor/blocknote-helper.js

@@ -0,0 +1,542 @@
+/**
+ * Helper functions for Y.js BlockNote operations
+ *
+ * These functions handle the low-level Y.Doc operations
+ * that the LangChain tools use.
+ *
+ * Matches the pattern from the CLI commands (runAddBlock, runEditBlock, etc.)
+ */
+import * as Y from 'yjs';
+import { MatrixProviderManager } from './provider.js';
+import { parseSurveyAnswers, parseSurveySchema } from './survey-helpers.js';
+// Re-export helpers from blockActions for consistency
+export { appendBlock, editBlock, deleteBlock, } from './block-actions.js';
+/**
+ * Initialize provider, do work, and dispose
+ * This matches the pattern from runAddBlock.ts exactly
+ */
+export async function withProvider(matrixClient, config, work) {
+    const providerManager = new MatrixProviderManager(matrixClient, config);
+    try {
+        const { doc } = await providerManager.init();
+        const result = await work(doc);
+        return result;
+    }
+    finally {
+        await providerManager.dispose();
+    }
+}
+/**
+ * Find a block container by ID
+ */
+export function findBlockById(container, blockId) {
+    const nodes = container.toArray();
+    for (const node of nodes) {
+        if (!(node instanceof Y.XmlElement)) {
+            continue;
+        }
+        const candidateId = node.getAttribute('id');
+        if (candidateId === blockId) {
+            return node;
+        }
+        // Recursively search nested structures
+        const nested = findBlockById(node, blockId);
+        if (nested) {
+            return nested;
+        }
+    }
+    return null;
+}
+// Helper to get any attribute (same as blockActions.ts)
+export const getAnyAttribute = (element, key) => {
+    return element.getAttribute(key);
+};
+/**
+ * Extract text content from an element (EXACT copy from runListBlocks.ts)
+ */
+export function extractText(element) {
+    const parts = [];
+    const visit = (node) => {
+        if (node instanceof Y.XmlText) {
+            parts.push(node.toString());
+            return;
+        }
+        node.toArray().forEach((child) => {
+            if (child instanceof Y.XmlElement || child instanceof Y.XmlText) {
+                visit(child);
+            }
+        });
+    };
+    visit(element);
+    return parts.join('');
+}
+/**
+ * Extract complete block details (EXACT copy from runListBlocks.ts - THE WORKING VERSION!)
+ */
+function extractBlockDetail(element) {
+    if (element instanceof Y.XmlText) {
+        return {
+            id: '',
+            nodeName: '#text',
+            blockType: '',
+            attributes: {},
+            children: [],
+            text: element.toString(),
+        };
+    }
+    const detail = {
+        id: element.getAttribute('id') || '',
+        nodeName: element.nodeName,
+        blockType: '',
+        attributes: {},
+    };
+    const xmlAttrs = element.getAttributes();
+    for (const [key, value] of Object.entries(xmlAttrs)) {
+        detail.attributes[key] = value;
+    }
+    const attrsValue = getAnyAttribute(element, 'attrs');
+    if (attrsValue) {
+        detail.attributes.attrs = attrsValue;
+        // Extract blockType from attrs if available
+        const attrsType = attrsValue.type;
+        if (typeof attrsType === 'string') {
+            detail.blockType = attrsType;
+        }
+    }
+    const children = element.toArray();
+    detail.children = [];
+    for (const child of children) {
+        if (child instanceof Y.XmlElement || child instanceof Y.XmlText) {
+            const childDetail = extractBlockDetail(child);
+            if (childDetail) {
+                detail.children.push(childDetail);
+            }
+        }
+    }
+    const textContent = extractText(element);
+    if (textContent.length > 0) {
+        detail.text = textContent;
+    }
+    return detail;
+}
+/**
+ * Extract user-facing properties from a block.
+ * Flattens the internal CRDT structure so ALL block properties are visible:
+ *   1. Extracts every entry from attrs.props (the canonical source)
+ *   2. Fills gaps from child element direct attributes (BlockNote mirrors props there)
+ *   3. Parses surveySchema and answers from JSON strings when present
+ *
+ * Generic — works for any block type without hardcoding field names.
+ */
+export function extractBlockProperties(detail) {
+    const merged = {};
+    // --- Source 1: attrs.props on the blockContainer (canonical) ---
+    const directAttrs = detail.attributes || {};
+    const attrsObj = directAttrs.attrs || {};
+    const attrsProps = attrsObj.props || {};
+    for (const [key, value] of Object.entries(attrsProps)) {
+        merged[key] = value;
+    }
+    // --- Source 2: child element direct attributes ---
+    // BlockNote mirrors props as direct attributes on the typed child element
+    const contentChild = detail.children?.find((c) => c.nodeName &&
+        c.nodeName !== '#text' &&
+        c.nodeName !== 'blockGroup' &&
+        c.nodeName !== 'blockContainer');
+    if (contentChild) {
+        for (const [key, value] of Object.entries(contentChild.attributes || {})) {
+            // Skip structural keys that are not user-facing props
+            if (key === 'id' || key === 'attrs')
+                continue;
+            if (!(key in merged)) {
+                merged[key] = value;
+            }
+        }
+    }
+    // --- Parse JSON strings for known structured fields ---
+    if (typeof merged.surveySchema === 'string') {
+        const parsedSchema = parseSurveySchema(merged.surveySchema);
+        if (parsedSchema) {
+            merged.surveySchema = parsedSchema;
+        }
+    }
+    if (typeof merged.answers === 'string') {
+        const parsedAnswers = parseSurveyAnswers(merged.answers);
+        if (parsedAnswers && Object.keys(parsedAnswers).length > 0) {
+            merged.answers = parsedAnswers;
+        }
+    }
+    // Parse `inputs` JSON string so agents see structured data
+    if (typeof merged.inputs === 'string') {
+        try {
+            const parsed = JSON.parse(merged.inputs);
+            if (parsed && typeof parsed === 'object') {
+                merged.inputs = parsed;
+            }
+        }
+        catch {
+            // keep raw string if not valid JSON
+        }
+    }
+    // Parse `links` JSON string so agents see structured data
+    if (typeof merged.links === 'string') {
+        try {
+            const parsed = JSON.parse(merged.links);
+            if (Array.isArray(parsed)) {
+                merged.links = parsed;
+            }
+        }
+        catch {
+            // keep raw string if not valid JSON
+        }
+    }
+    return merged;
+}
+/**
+ * Transform block detail into agent-friendly format
+ */
+export function simplifyBlockForAgent(detail) {
+    // Use detail.blockType (already extracted in extractBlockDetail)
+    // If not available, check first child element's nodeName
+    // Fallback to nodeName
+    let blockType = detail.blockType;
+    if (!blockType && detail.children && detail.children.length > 0) {
+        const firstChild = detail.children.find((c) => c.nodeName && c.nodeName !== '#text' && c.nodeName !== 'blockGroup');
+        if (firstChild) {
+            blockType = firstChild.nodeName;
+        }
+    }
+    if (!blockType) {
+        blockType = detail.nodeName;
+    }
+    const properties = extractBlockProperties(detail);
+    return {
+        id: detail.id,
+        type: blockType,
+        properties,
+        ...(detail.text && { text: detail.text }),
+    };
+}
+/**
+ * Collect all block containers from the document (EXACT copy from runListBlocks.ts)
+ */
+export function collectAllBlocks(fragment, _includeText = true) {
+    const results = [];
+    function collectBlockContainers(container, results) {
+        const nodes = container.toArray();
+        for (const node of nodes) {
+            if (!(node instanceof Y.XmlElement)) {
+                continue;
+            }
+            if (node.nodeName === 'blockContainer') {
+                const detail = extractBlockDetail(node);
+                if (detail) {
+                    results.push(detail);
+                }
+            }
+            collectBlockContainers(node, results);
+        }
+    }
+    collectBlockContainers(fragment, results);
+    return results;
+}
+/**
+ * Get block by ID and return its details
+ */
+export function getBlockDetail(doc, blockId, _includeText = true) {
+    const fragment = doc.getXmlFragment('document');
+    const blockContainer = findBlockById(fragment, blockId);
+    if (!blockContainer) {
+        return null;
+    }
+    return extractBlockDetail(blockContainer);
+}
+// ─── Y.Doc Namespace Helpers ─────────────────────────────────────────
+// Pure functions that read from Y.Doc namespaces beyond 'document'.
+// Each operates on an already-synced Y.Doc — no Matrix I/O.
+/**
+ * Read flow metadata from Y.Map('root') + Y.Text('title').
+ * Returns ALL entries from the root map — no field filtering.
+ */
+export function readFlowMetadata(doc) {
+    const root = doc.getMap('root');
+    const titleText = doc.getText('title');
+    const result = {};
+    root.forEach((value, key) => {
+        result[key] = value;
+    });
+    // Title from Y.Text takes precedence over root map entry
+    const titleStr = titleText.toString();
+    if (titleStr) {
+        result.title = titleStr;
+    }
+    return result;
+}
+/**
+ * Read all flow nodes from Y.Array('flow').
+ * Returns raw entries without type casting.
+ */
+export function readFlowNodes(doc) {
+    const flowArray = doc.getArray('flow');
+    return flowArray.toArray();
+}
+/**
+ * Read runtime state from Y.Map('runtime').
+ * If nodeId provided, returns only that node's state.
+ * Returns raw objects — no type filtering.
+ */
+export function readRuntimeState(doc, nodeId) {
+    const runtimeMap = doc.getMap('runtime');
+    if (nodeId) {
+        const state = runtimeMap.get(nodeId);
+        return state ? { [nodeId]: state } : {};
+    }
+    const result = {};
+    runtimeMap.forEach((value, key) => {
+        if (value && typeof value === 'object') {
+            result[key] = value;
+        }
+    });
+    return result;
+}
+/**
+ * Merge updates into a block's runtime state in Y.Map('runtime').
+ * Reads existing state first, spreads, then writes the merged result.
+ * Must be called inside a doc.transact() by the caller.
+ */
+export function updateRuntimeState(doc, blockId, updates) {
+    const runtimeMap = doc.getMap('runtime');
+    const existing = runtimeMap.get(blockId) || {};
+    const merged = { ...existing, ...updates };
+    runtimeMap.set(blockId, merged);
+    return merged;
+}
+/**
+ * Read audit trail events for a specific block from Y.Map('auditTrail').
+ * Returns raw entries without type casting.
+ */
+export function readAuditTrailForBlock(doc, blockId) {
+    const auditTrailMap = doc.getMap('auditTrail');
+    const eventsArray = auditTrailMap.get(blockId);
+    if (!eventsArray || !(eventsArray instanceof Y.Array)) {
+        return [];
+    }
+    return eventsArray
+        .toArray()
+        .filter((e) => e != null && typeof e === 'object');
+}
+/**
+ * Read invocations from Y.Map('invocations'), optionally filtered by blockId.
+ * Sorted by executedAt descending (most recent first) if the field exists.
+ * Returns raw entries without type casting.
+ */
+export function readInvocations(doc, blockId) {
+    const invocationsMap = doc.getMap('invocations');
+    const all = [];
+    invocationsMap.forEach((value) => {
+        if (value && typeof value === 'object') {
+            all.push(value);
+        }
+    });
+    // Sort by executedAt if present (entries without it sort last)
+    const sorted = all.sort((a, b) => {
+        const aTime = typeof a.executedAt === 'number' ? a.executedAt : 0;
+        const bTime = typeof b.executedAt === 'number' ? b.executedAt : 0;
+        return bTime - aTime;
+    });
+    return blockId ? sorted.filter((i) => i.blockId === blockId) : sorted;
+}
+/**
+ * Read delegations from Y.Map('delegations').
+ * Handles both v2 StoredEntry { v: 2, data: ... } and legacy JSON strings.
+ * Returns raw entries without type casting.
+ */
+export function readDelegations(doc) {
+    const ROOT_KEY = '__root__';
+    const VERSION_KEY = '__version__';
+    const delegationsMap = doc.getMap('delegations');
+    const rootCid = delegationsMap.get(ROOT_KEY) || null;
+    const delegations = [];
+    delegationsMap.forEach((value, key) => {
+        if (key === ROOT_KEY || key === VERSION_KEY)
+            return;
+        // New v2 format: { v: 2, data: {...} }
+        if (value &&
+            typeof value === 'object' &&
+            value.v === 2 &&
+            value.data) {
+            delegations.push(value.data);
+            return;
+        }
+        // Legacy format: JSON string — normalize + spread all original fields
+        if (typeof value === 'string') {
+            try {
+                const parsed = JSON.parse(value);
+                delegations.push({
+                    ...parsed,
+                    cid: parsed.id || key,
+                    issuerDid: parsed.issuer || '',
+                    audienceDid: parsed.audience || '',
+                    capabilities: parsed.capabilities || [],
+                    expiration: parsed.expiration,
+                    createdAt: parsed.issuedAt
+                        ? new Date(parsed.issuedAt).getTime()
+                        : 0,
+                    format: 'legacy',
+                    proofCids: parsed.proofs || [],
+                });
+            }
+            catch {
+                /* skip malformed entries */
+            }
+        }
+    });
+    return { rootCid, delegations };
+}
+/**
+ * Evaluate a block's condition config against all blocks in the document.
+ * Returns computed visibility and enabled state.
+ */
+export function evaluateBlockConditions(conditionConfig, allBlocks) {
+    if (!conditionConfig.enabled || conditionConfig.conditions.length === 0) {
+        return { isVisible: true, isEnabled: true, actions: [] };
+    }
+    // Build a props map keyed by block ID for fast lookup
+    const blockPropsMap = new Map();
+    allBlocks.forEach((b) => {
+        // Merge direct attributes and nested attrs.props
+        const attrs = b.attributes || {};
+        const attrsObj = attrs.attrs || {};
+        const props = attrsObj.props || {};
+        blockPropsMap.set(b.id, { ...attrs, ...attrsObj, ...props });
+    });
+    const results = conditionConfig.conditions.map((condition) => {
+        const sourceProps = blockPropsMap.get(condition.sourceBlockId);
+        if (!sourceProps)
+            return { condition, passes: false };
+        const sourceValue = sourceProps[condition.rule.property];
+        const ruleValue = condition.rule.value;
+        let passes = false;
+        switch (condition.rule.operator) {
+            case 'equals':
+                passes = String(sourceValue) === String(ruleValue);
+                break;
+            case 'not_equals':
+                passes = String(sourceValue) !== String(ruleValue);
+                break;
+            case 'greater_than':
+                passes = Number(sourceValue) > Number(ruleValue);
+                break;
+            case 'less_than':
+                passes = Number(sourceValue) < Number(ruleValue);
+                break;
+            case 'contains':
+                passes = String(sourceValue ?? '')
+                    .toLowerCase()
+                    .includes(String(ruleValue).toLowerCase());
+                break;
+            case 'not_contains':
+                passes = !String(sourceValue ?? '')
+                    .toLowerCase()
+                    .includes(String(ruleValue).toLowerCase());
+                break;
+            case 'is_empty':
+                passes =
+                    sourceValue === undefined ||
+                        sourceValue === null ||
+                        String(sourceValue).trim() === '';
+                break;
+            case 'is_not_empty':
+                passes =
+                    sourceValue !== undefined &&
+                        sourceValue !== null &&
+                        String(sourceValue).trim() !== '';
+                break;
+        }
+        return { condition, passes };
+    });
+    // Aggregate based on mode
+    const allPass = conditionConfig.mode === 'all_must_pass'
+        ? results.every((r) => r.passes)
+        : results.some((r) => r.passes);
+    const passingResults = conditionConfig.mode === 'all_must_pass'
+        ? allPass
+            ? results
+            : []
+        : results.filter((r) => r.passes);
+    const actions = passingResults.map((r) => ({
+        action: r.condition.effect.action,
+        message: r.condition.effect.message,
+        conditionName: r.condition.name,
+    }));
+    // Derive visibility and enabled state from actions
+    const hasVisibilityConditions = conditionConfig.conditions.some((c) => c.effect.action === 'show' || c.effect.action === 'hide');
+    const hasEnableConditions = conditionConfig.conditions.some((c) => c.effect.action === 'enable' || c.effect.action === 'disable');
+    const hideActions = actions.filter((a) => a.action === 'hide');
+    const showActions = actions.filter((a) => a.action === 'show');
+    const disableActions = actions.filter((a) => a.action === 'disable');
+    const isVisible = hasVisibilityConditions
+        ? hideActions.length === 0 && (showActions.length > 0 || !allPass)
+        : true;
+    const isEnabled = hasEnableConditions ? disableActions.length === 0 : true;
+    return { isVisible, isEnabled, actions };
+}
+/**
+ * Resolve {{blockId.propPath}} template references in a string.
+ * Returns the string with all references replaced by their resolved values.
+ */
+export function resolveBlockReferences(template, allBlocks) {
+    const REFERENCE_REGEX = /\{\{([a-zA-Z0-9_-]+)\.([a-zA-Z0-9_.]+)\}\}/g;
+    // Build a props map for all blocks
+    const blockPropsMap = new Map();
+    allBlocks.forEach((b) => {
+        const attrs = b.attributes || {};
+        const attrsObj = attrs.attrs || {};
+        const props = attrsObj.props || {};
+        blockPropsMap.set(b.id, { ...attrs, ...attrsObj, ...props });
+    });
+    return template.replace(REFERENCE_REGEX, (fullMatch, blockId, propPath) => {
+        const props = blockPropsMap.get(blockId);
+        if (!props)
+            return fullMatch;
+        // Navigate nested path (e.g. "response.data.items")
+        const pathParts = propPath.split('.');
+        let value = props;
+        for (const part of pathParts) {
+            if (value && typeof value === 'object') {
+                value = value[part];
+            }
+            else {
+                return '';
+            }
+        }
+        // For response props stored as JSON strings, parse and navigate
+        if (pathParts[0] === 'response' && typeof props['response'] === 'string') {
+            try {
+                const parsed = JSON.parse(props['response']);
+                let innerValue = parsed;
+                for (const part of pathParts.slice(1)) {
+                    if (innerValue && typeof innerValue === 'object') {
+                        innerValue = innerValue[part];
+                    }
+                    else {
+                        return '';
+                    }
+                }
+                if (innerValue === undefined || innerValue === null)
+                    return '';
+                if (typeof innerValue === 'object')
+                    return JSON.stringify(innerValue);
+                return String(innerValue);
+            }
+            catch {
+                /* fall through to default */
+            }
+        }
+        if (value === undefined || value === null)
+            return '';
+        if (typeof value === 'object')
+            return JSON.stringify(value);
+        return String(value);
+    });
+}