@wowok/agent-mcp 2.6.0 → 2.6.3

package/dist/knowledge/guard-render.js

@@ -0,0 +1,700 @@
+function categorizeNodeType(type) {
+    if (type.startsWith("logic_"))
+        return "decision";
+    if (type === "context")
+        return "context";
+    if (type === "identifier")
+        return "leaf";
+    if (type === "query")
+        return "query";
+    if (type.startsWith("calc_") || type.startsWith("convert_"))
+        return "computation";
+    if (type.startsWith("vec_"))
+        return "computation";
+    if (type.startsWith("query_reward_") || type.startsWith("query_progress_"))
+        return "query";
+    return "computation";
+}
+function shortNodeLabel(node) {
+    const t = node.type;
+    switch (t) {
+        case "logic_and": return "AND";
+        case "logic_or": return "OR";
+        case "logic_not": return "NOT";
+        case "logic_equal": return "==";
+        case "logic_as_u256_equal": return "==#";
+        case "logic_as_u256_greater": return ">";
+        case "logic_as_u256_greater_or_equal": return ">=";
+        case "logic_as_u256_lesser": return "<";
+        case "logic_as_u256_lesser_or_equal": return "<=";
+        case "logic_string_contains": return "contains";
+        case "logic_string_nocase_contains": return "contains~";
+        case "logic_string_nocase_equal": return "==~";
+        case "calc_number_add": return "+";
+        case "calc_number_subtract": return "-";
+        case "calc_number_multiply": return "*";
+        case "calc_number_divide": return "/";
+        case "calc_number_mod": return "%";
+        case "calc_string_length": return "len";
+        case "calc_string_contains": return "contains";
+        case "calc_string_nocase_contains": return "contains~";
+        case "calc_string_nocase_equal": return "==~";
+        case "calc_string_indexof": return "indexOf";
+        case "calc_string_nocase_indexof": return "indexOf~";
+        case "convert_number_address": return "→Addr";
+        case "convert_address_number": return "→Num";
+        case "convert_number_string": return "→Str";
+        case "convert_string_number": return "→Num";
+        case "convert_safe_u8": return "→U8";
+        case "convert_safe_u16": return "→U16";
+        case "convert_safe_u32": return "→U32";
+        case "convert_safe_u64": return "→U64";
+        case "convert_safe_u128": return "→U128";
+        case "convert_safe_u256": return "→U256";
+        case "value_type": return "typeOf";
+        case "vec_length": return "len";
+        case "vec_contains_bool": return "∈?";
+        case "vec_contains_address": return "∈?";
+        case "vec_contains_string": return "∈?";
+        case "vec_contains_string_nocase": return "∈?~";
+        case "vec_contains_number": return "∈?";
+        case "vec_indexof_bool": return "idx";
+        case "vec_indexof_address": return "idx";
+        case "vec_indexof_string": return "idx";
+        case "vec_indexof_string_nocase": return "idx~";
+        case "vec_indexof_number": return "idx";
+        case "query":
+            return `Q:${typeof node.query === "number" ? `#${node.query}` : node.query}`;
+        case "query_reward_record_count": return "reward.count";
+        case "query_reward_record_exists": return "reward.exists";
+        case "query_reward_record_find": return "reward.find";
+        case "query_progress_history_find": return "history.find";
+        case "query_progress_history_session_find": return "session.find";
+        case "query_progress_history_session_forward_find": return "forward.find";
+        case "query_progress_history_session_count": return "session.count";
+        case "query_progress_history_session_forward_count": return "forward.count";
+        case "query_progress_history_session_forward_retained_submission_count":
+            return "retained.count";
+        case "identifier":
+            return `id[${node.identifier ?? "?"}]`;
+        case "context":
+            return node.context ?? "ctx";
+        default:
+            return t;
+    }
+}
+let nodeIdCounter = 0;
+function makeNodeId(prefix) {
+    nodeIdCounter++;
+    return `${prefix}_${nodeIdCounter}`;
+}
+function sanitizeMermaidLabel(text) {
+    if (/[<>"\[\]{}()|&]/.test(text)) {
+        return `"${text.replace(/"/g, "'")}"`;
+    }
+    return text;
+}
+const GUARD_NODE_COLORS = {
+    control: { fill: "#3b82f6", stroke: "#1e40af" },
+    decision: { fill: "#f59e0b", stroke: "#92400e" },
+    computation: { fill: "#8b5cf6", stroke: "#6d28d9" },
+    query: { fill: "#06b6d4", stroke: "#0e7490" },
+    leaf: { fill: "#6b7280", stroke: "#374151" },
+    context: { fill: "#10b981", stroke: "#065f46" },
+};
+function colorCategoryForNodeType(type) {
+    if (type === "logic_and" || type === "logic_or")
+        return "control";
+    if (type === "logic_not" || type.startsWith("logic_"))
+        return "decision";
+    if (type.startsWith("calc_") || type.startsWith("convert_") || type.startsWith("vec_"))
+        return "computation";
+    if (type === "query" || type.startsWith("query_"))
+        return "query";
+    if (type === "identifier")
+        return "leaf";
+    if (type === "context")
+        return "context";
+    return "computation";
+}
+export function renderGuardMermaid(root, options) {
+    const colored = options?.colored !== false;
+    nodeIdCounter = 0;
+    const lines = ["flowchart TD"];
+    if (colored) {
+        lines.push("  %% Color Legend (BehaviorTree.CPP-inspired semantic roles):");
+        lines.push("  %%   blue   #3b82f6 - control     (logic_and, logic_or)");
+        lines.push("  %%   amber  #f59e0b - decision    (logic_not, comparisons)");
+        lines.push("  %%   purple #8b5cf6 - computation (calc_*, convert_*, vec_*)");
+        lines.push("  %%   cyan   #06b6d4 - query       (query, query_*)");
+        lines.push("  %%   gray   #6b7280 - leaf        (identifier)");
+        lines.push("  %%   green  #10b981 - context     (Signer, Clock, Guard)");
+        lines.push("  %% Node shapes: {}=decision, []=computation/query, ([])=leaf, {{}}=context");
+    }
+    const nodeDecls = [];
+    const edgeLines = [];
+    const nodeColorMap = [];
+    function walk(node, parentId, edgeLabel) {
+        const id = makeNodeId("n");
+        const category = categorizeNodeType(node.type);
+        const label = shortNodeLabel(node);
+        let shapeOpen = "[", shapeClose = "]";
+        switch (category) {
+            case "decision":
+                shapeOpen = "{";
+                shapeClose = "}";
+                break;
+            case "context":
+                shapeOpen = "{{";
+                shapeClose = "}}";
+                break;
+            case "leaf":
+                shapeOpen = "([";
+                shapeClose = "])";
+                break;
+            case "query":
+            case "computation":
+            default:
+                shapeOpen = "[";
+                shapeClose = "]";
+                break;
+        }
+        nodeDecls.push(`${id}${shapeOpen}${sanitizeMermaidLabel(label)}${shapeClose}`);
+        nodeColorMap.push({ id, type: node.type });
+        if (parentId) {
+            if (edgeLabel) {
+                edgeLines.push(`  ${parentId} --> ${id}: ${sanitizeMermaidLabel(edgeLabel)}`);
+            }
+            else {
+                edgeLines.push(`  ${parentId} --> ${id}`);
+            }
+        }
+        if (node.nodes && Array.isArray(node.nodes)) {
+            node.nodes.forEach((child, i) => {
+                walk(child, id, `[${i}]`);
+            });
+        }
+        if (node.node) {
+            walk(node.node, id, "child");
+        }
+        if (node.nodeLeft) {
+            walk(node.nodeLeft, id, "left");
+        }
+        if (node.nodeRight) {
+            walk(node.nodeRight, id, "right");
+        }
+        if (node.parameters && Array.isArray(node.parameters)) {
+            node.parameters.forEach((child, i) => {
+                walk(child, id, `param[${i}]`);
+            });
+        }
+        if (node.historyIdx)
+            walk(node.historyIdx, id, "historyIdx");
+        if (node.sessionIdx)
+            walk(node.sessionIdx, id, "sessionIdx");
+        if (node.forwardIdx)
+            walk(node.forwardIdx, id, "forwardIdx");
+        if (node.where)
+            walk(node.where, id, "where");
+        if (node.find)
+            walk(node.find, id, "find");
+        if (node.objectLeft)
+            walk(node.objectLeft, id, "objLeft");
+        if (node.objectRight)
+            walk(node.objectRight, id, "objRight");
+        if (node.recipient)
+            walk(node.recipient, id, "recipient");
+        return id;
+    }
+    walk(root);
+    lines.push(...nodeDecls.map(d => `  ${d}`));
+    lines.push(...edgeLines);
+    if (colored) {
+        lines.push("");
+        lines.push("  %% Node colors (BehaviorTree.CPP-inspired semantic roles)");
+        for (const { id, type } of nodeColorMap) {
+            const category = colorCategoryForNodeType(type);
+            const color = GUARD_NODE_COLORS[category];
+            lines.push(`  style ${id} fill:${color.fill},stroke:${color.stroke},color:#fff`);
+        }
+    }
+    return lines.join("\n");
+}
+export function renderGuardTreeIndented(input) {
+    const { root, table, guardName, guardAddress, rely } = input;
+    const lines = [];
+    function describeLeaf(node) {
+        const t = node.type;
+        if (t === "identifier") {
+            const tableEntry = table?.find(e => e.identifier === node.identifier);
+            const nameHint = tableEntry?.name ? ` "${tableEntry.name}"` : "";
+            return `identifier[${node.identifier ?? "?"}]${nameHint}`;
+        }
+        if (t === "context") {
+            return `context(${node.context ?? "?"})`;
+        }
+        if (t === "query") {
+            const witness = node.object?.convert_witness;
+            const objId = node.object?.identifier;
+            const witnessStr = witness !== undefined ? `, witness=${witness}` : "";
+            const objStr = objId !== undefined ? `, id[${objId}]` : "";
+            const paramStr = node.parameters && node.parameters.length > 0
+                ? `, params=[${node.parameters.map(p => shortNodeLabel(p)).join(", ")}]`
+                : "";
+            return `query(${typeof node.query === "number" ? `#${node.query}` : node.query}${objStr}${witnessStr}${paramStr})`;
+        }
+        return shortNodeLabel(node);
+    }
+    function walk(node, depth, label) {
+        const indent = "  ".repeat(depth);
+        const prefix = depth === 0 ? "- " : "- ";
+        const labelStr = label ? `${label}: ` : "";
+        const isLeaf = !node.nodes && !node.node && !node.nodeLeft && !node.nodeRight
+            && !node.parameters?.length && !node.historyIdx && !node.sessionIdx
+            && !node.forwardIdx && !node.where && !node.find && !node.objectLeft
+            && !node.objectRight && !node.recipient;
+        if (isLeaf) {
+            lines.push(`${indent}${prefix}${labelStr}${describeLeaf(node)}`);
+        }
+        else {
+            lines.push(`${indent}${prefix}${labelStr}${node.type}`);
+        }
+        if (node.nodes && Array.isArray(node.nodes)) {
+            node.nodes.forEach((child, i) => walk(child, depth + 1, `child[${i}]`));
+        }
+        if (node.node) {
+            walk(node.node, depth + 1, "child");
+        }
+        if (node.nodeLeft) {
+            walk(node.nodeLeft, depth + 1, "left");
+        }
+        if (node.nodeRight) {
+            walk(node.nodeRight, depth + 1, "right");
+        }
+        if (node.parameters && Array.isArray(node.parameters)) {
+            node.parameters.forEach((child, i) => walk(child, depth + 1, `param[${i}]`));
+        }
+        if (node.historyIdx)
+            walk(node.historyIdx, depth + 1, "historyIdx");
+        if (node.sessionIdx)
+            walk(node.sessionIdx, depth + 1, "sessionIdx");
+        if (node.forwardIdx)
+            walk(node.forwardIdx, depth + 1, "forwardIdx");
+        if (node.where)
+            walk(node.where, depth + 1, "where");
+        if (node.find)
+            walk(node.find, depth + 1, "find");
+        if (node.objectLeft)
+            walk(node.objectLeft, depth + 1, "objLeft");
+        if (node.objectRight)
+            walk(node.objectRight, depth + 1, "objRight");
+        if (node.recipient)
+            walk(node.recipient, depth + 1, "recipient");
+    }
+    lines.push("# Guard Tree Definition");
+    lines.push("");
+    if (guardName) {
+        lines.push(`**Guard:** ${guardName}`);
+    }
+    if (guardAddress) {
+        lines.push(`**Address:** ${guardAddress}`);
+    }
+    if (table) {
+        lines.push(`**Table Entries:** ${table.length}`);
+    }
+    if (rely && rely.guards.length > 0) {
+        lines.push(`**Rely:** ${rely.guards.length} guard(s)${rely.logic_or ? " (logic_or)" : " (logic_and)"}`);
+    }
+    lines.push("");
+    lines.push("## Root");
+    walk(root, 0);
+    if (table && table.length > 0) {
+        lines.push("");
+        lines.push("## Table");
+        lines.push("");
+        lines.push("| identifier | b_submission | value_type | value | name |");
+        lines.push("|------------|-------------|------------|-------|------|");
+        for (const entry of table) {
+            const rawVal = entry.value === undefined ? "-" : String(entry.value);
+            const val = rawVal.replace(/\|/g, "\\|").replace(/\n/g, " ");
+            const name = entry.name ?? "-";
+            lines.push(`| ${entry.identifier} | ${entry.b_submission} | ${entry.value_type} | ${val} | ${name} |`);
+        }
+        lines.push("");
+        lines.push("## Table JSON");
+        lines.push("");
+        lines.push("```json");
+        lines.push(JSON.stringify(table, null, 2));
+        lines.push("```");
+    }
+    if (rely && rely.guards.length > 0) {
+        lines.push("");
+        lines.push("## Rely");
+        lines.push("");
+        lines.push(`Logic: ${rely.logic_or ? "OR" : "AND"}`);
+        for (const g of rely.guards) {
+            lines.push(`- ${g}`);
+        }
+    }
+    lines.push("");
+    lines.push("## JSON Definition");
+    lines.push("");
+    lines.push("```json");
+    lines.push(JSON.stringify({ root, table, guardName, guardAddress, rely }, null, 2));
+    lines.push("```");
+    return lines.join("\n");
+}
+export function parseGuardTreeIndented(text) {
+    const errors = [];
+    const jsonBlocks = text.matchAll(/```json\s*\n([\s\S]*?)```/g);
+    let lastJsonBlock = null;
+    for (const match of jsonBlocks) {
+        lastJsonBlock = match[1];
+    }
+    if (lastJsonBlock) {
+        try {
+            const data = JSON.parse(lastJsonBlock.trim());
+            if (data && typeof data === "object") {
+                if ("root" in data && data.root && typeof data.root === "object" && "type" in data.root) {
+                    return { success: true, data: data.root, errors: [] };
+                }
+                if ("type" in data) {
+                    return { success: true, data, errors: [] };
+                }
+            }
+        }
+        catch (e) {
+            errors.push(`JSON code block parse error: ${e.message}`);
+        }
+    }
+    const lines = text.split("\n").filter(l => l.trim().startsWith("- "));
+    if (lines.length === 0) {
+        return { success: false, errors: ["No outline entries found. Use '- ' prefixed lines or a JSON code block."] };
+    }
+    const stack = [];
+    let root = null;
+    function getDepth(line) {
+        const match = line.match(/^(\s*)- /);
+        return match ? match[1].length / 2 : 0;
+    }
+    function parseLine(line) {
+        const content = line.replace(/^\s*- /, "").trim();
+        const labelMatch = content.match(/^([^:]+):\s*(.*)$/);
+        const label = labelMatch ? labelMatch[1].trim() : undefined;
+        const rest = labelMatch ? labelMatch[2].trim() : content;
+        const idMatch = rest.match(/^identifier\[(\d+)\](?:\s+"(.+)")?$/);
+        if (idMatch) {
+            return {
+                label,
+                node: { type: "identifier", identifier: parseInt(idMatch[1], 10) },
+            };
+        }
+        const ctxMatch = rest.match(/^context\((\w+)\)$/);
+        if (ctxMatch) {
+            return { label, node: { type: "context", context: ctxMatch[1] } };
+        }
+        const queryMatch = rest.match(/^query\((.+?)\)$/);
+        if (queryMatch) {
+            const inner = queryMatch[1];
+            const parts = inner.split(",").map(s => s.trim());
+            const queryName = parts[0].replace(/^#/, "");
+            const isNumeric = /^\d+$/.test(queryName);
+            const node = {
+                type: "query",
+                query: isNumeric ? parseInt(queryName, 10) : queryName,
+            };
+            for (const part of parts.slice(1)) {
+                const idPart = part.match(/^id\[(\d+)\]$/);
+                if (idPart) {
+                    node.object = { identifier: parseInt(idPart[1], 10) };
+                }
+                const witnessPart = part.match(/^witness=(\d+)$/);
+                if (witnessPart) {
+                    node.object = { ...(node.object || {}), convert_witness: parseInt(witnessPart[1], 10) };
+                }
+            }
+            return { label, node };
+        }
+        return { label, node: { type: rest } };
+    }
+    for (const line of lines) {
+        const depth = getDepth(line);
+        const { label, node } = parseLine(line);
+        if (depth === 0) {
+            root = node;
+            stack.length = 0;
+            stack.push({ node, depth });
+        }
+        else {
+            while (stack.length > 0 && stack[stack.length - 1].depth >= depth) {
+                stack.pop();
+            }
+            const parent = stack[stack.length - 1];
+            if (!parent) {
+                errors.push(`Orphaned node at depth ${depth}: ${line}`);
+                continue;
+            }
+            if (label) {
+                const childIdxMatch = label.match(/^child\[(\d+)\]$/);
+                const paramIdxMatch = label.match(/^param\[(\d+)\]$/);
+                if (childIdxMatch) {
+                    if (!parent.node.nodes)
+                        parent.node.nodes = [];
+                    parent.node.nodes.push(node);
+                }
+                else if (paramIdxMatch) {
+                    if (!parent.node.parameters)
+                        parent.node.parameters = [];
+                    parent.node.parameters.push(node);
+                }
+                else if (label === "child") {
+                    parent.node.node = node;
+                }
+                else if (label === "left") {
+                    parent.node.nodeLeft = node;
+                }
+                else if (label === "right") {
+                    parent.node.nodeRight = node;
+                }
+                else if (label === "historyIdx") {
+                    parent.node.historyIdx = node;
+                }
+                else if (label === "sessionIdx") {
+                    parent.node.sessionIdx = node;
+                }
+                else if (label === "forwardIdx") {
+                    parent.node.forwardIdx = node;
+                }
+                else if (label === "where") {
+                    parent.node.where = node;
+                }
+                else if (label === "find") {
+                    parent.node.find = node;
+                }
+                else if (label === "objLeft") {
+                    parent.node.objectLeft = node;
+                }
+                else if (label === "objRight") {
+                    parent.node.objectRight = node;
+                }
+                else if (label === "recipient") {
+                    parent.node.recipient = node;
+                }
+            }
+            stack.push({ node, depth });
+        }
+    }
+    if (!root) {
+        return { success: false, errors: ["No root node found in outline."] };
+    }
+    return { success: true, data: root, errors };
+}
+export function renderGuardAscii(input) {
+    const { root, table, guardName, guardAddress, rely } = input;
+    const lines = [];
+    if (guardName)
+        lines.push(`Guard: ${guardName}`);
+    if (guardAddress)
+        lines.push(`Address: ${guardAddress}`);
+    if (guardName || guardAddress)
+        lines.push("");
+    function describeNode(node) {
+        const t = node.type;
+        const baseLabel = shortNodeLabel(node);
+        if (t === "identifier") {
+            const tableEntry = table?.find(e => e.identifier === node.identifier);
+            const typeStr = tableEntry ? ` [${typeof tableEntry.value_type === "string" ? tableEntry.value_type : `type=${tableEntry.value_type}`}]` : "";
+            const valueStr = (tableEntry && tableEntry.value !== undefined && !tableEntry.b_submission)
+                ? `, value=${String(tableEntry.value)}` : "";
+            const submissionStr = tableEntry?.b_submission ? " (submission)" : "";
+            return `${baseLabel}${typeStr}${valueStr}${submissionStr}`;
+        }
+        if (t === "context") {
+            return `${baseLabel} [${node.context ?? "?"}]`;
+        }
+        if (t === "query") {
+            const witness = node.object?.convert_witness;
+            const witnessStr = witness !== undefined ? `, witness=${witness}` : "";
+            return `${baseLabel}${witnessStr}`;
+        }
+        return baseLabel;
+    }
+    function collectChildren(node) {
+        const children = [];
+        if (node.nodes && Array.isArray(node.nodes)) {
+            node.nodes.forEach((child, i) => children.push({ node: child, label: `child[${i}]` }));
+        }
+        if (node.node)
+            children.push({ node: node.node, label: "child" });
+        if (node.nodeLeft)
+            children.push({ node: node.nodeLeft, label: "left" });
+        if (node.nodeRight)
+            children.push({ node: node.nodeRight, label: "right" });
+        if (node.parameters && Array.isArray(node.parameters)) {
+            node.parameters.forEach((child, i) => children.push({ node: child, label: `param[${i}]` }));
+        }
+        if (node.historyIdx)
+            children.push({ node: node.historyIdx, label: "historyIdx" });
+        if (node.sessionIdx)
+            children.push({ node: node.sessionIdx, label: "sessionIdx" });
+        if (node.forwardIdx)
+            children.push({ node: node.forwardIdx, label: "forwardIdx" });
+        if (node.where)
+            children.push({ node: node.where, label: "where" });
+        if (node.find)
+            children.push({ node: node.find, label: "find" });
+        if (node.objectLeft)
+            children.push({ node: node.objectLeft, label: "objLeft" });
+        if (node.objectRight)
+            children.push({ node: node.objectRight, label: "objRight" });
+        if (node.recipient)
+            children.push({ node: node.recipient, label: "recipient" });
+        return children;
+    }
+    function walk(node, prefix, isLast, edgeLabel) {
+        const connector = isLast ? "└─ " : "├─ ";
+        const labelStr = edgeLabel ? `${edgeLabel}: ` : "";
+        lines.push(`${prefix}${connector}${labelStr}${describeNode(node)}`);
+        const children = collectChildren(node);
+        const childPrefix = prefix + (isLast ? "   " : "│  ");
+        children.forEach((child, i) => {
+            walk(child.node, childPrefix, i === children.length - 1, child.label);
+        });
+    }
+    lines.push(describeNode(root));
+    const children = collectChildren(root);
+    children.forEach((child, i) => {
+        walk(child.node, "", i === children.length - 1, child.label);
+    });
+    if (table && table.length > 0) {
+        lines.push("");
+        lines.push("Table:");
+        for (const entry of table) {
+            const typeStr = typeof entry.value_type === "string" ? entry.value_type : `type=${entry.value_type}`;
+            const valueStr = (entry.value !== undefined && !entry.b_submission) ? `, value=${String(entry.value)}` : "";
+            const submissionStr = entry.b_submission ? " (submission)" : "";
+            const nameStr = entry.name ? ` "${entry.name}"` : "";
+            lines.push(`  id[${entry.identifier}]${nameStr}: ${typeStr}${valueStr}${submissionStr}`);
+        }
+    }
+    if (rely && rely.guards.length > 0) {
+        lines.push("");
+        lines.push(`Rely (${rely.logic_or ? "OR" : "AND"}):`);
+        for (const g of rely.guards) {
+            lines.push(`  - ${g}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function renderGuardMarkmap(input) {
+    const { root, table, guardName, guardAddress, rely } = input;
+    const lines = [];
+    const title = guardName ? `Guard: ${guardName}` : "Guard";
+    lines.push(`# ${title}`);
+    if (guardAddress)
+        lines.push("");
+    if (guardAddress)
+        lines.push(`**Address:** ${guardAddress}`);
+    lines.push("");
+    function heading(depth, text) {
+        return `${"#".repeat(Math.min(depth + 1, 6))} ${text}`;
+    }
+    function describeNode(node) {
+        const t = node.type;
+        const baseLabel = shortNodeLabel(node);
+        if (t === "identifier") {
+            const tableEntry = table?.find(e => e.identifier === node.identifier);
+            const typeStr = tableEntry ? ` [${typeof tableEntry.value_type === "string" ? tableEntry.value_type : `type=${tableEntry.value_type}`}]` : "";
+            const valueStr = (tableEntry && tableEntry.value !== undefined && !tableEntry.b_submission)
+                ? `, value=${String(tableEntry.value)}` : "";
+            const submissionStr = tableEntry?.b_submission ? " (submission)" : "";
+            return `${baseLabel}${typeStr}${valueStr}${submissionStr}`;
+        }
+        if (t === "context") {
+            return `${baseLabel} [${node.context ?? "?"}]`;
+        }
+        if (t === "query") {
+            const witness = node.object?.convert_witness;
+            const witnessStr = witness !== undefined ? `, witness=${witness}` : "";
+            return `${baseLabel}${witnessStr}`;
+        }
+        return baseLabel;
+    }
+    function walk(node, depth, edgeLabel) {
+        const labelStr = edgeLabel ? `${edgeLabel}: ` : "";
+        lines.push(heading(depth, `${labelStr}${describeNode(node)}`));
+        if (node.nodes && Array.isArray(node.nodes)) {
+            node.nodes.forEach((child, i) => walk(child, depth + 1, `child[${i}]`));
+        }
+        if (node.node)
+            walk(node.node, depth + 1, "child");
+        if (node.nodeLeft)
+            walk(node.nodeLeft, depth + 1, "left");
+        if (node.nodeRight)
+            walk(node.nodeRight, depth + 1, "right");
+        if (node.parameters && Array.isArray(node.parameters)) {
+            node.parameters.forEach((child, i) => walk(child, depth + 1, `param[${i}]`));
+        }
+        if (node.historyIdx)
+            walk(node.historyIdx, depth + 1, "historyIdx");
+        if (node.sessionIdx)
+            walk(node.sessionIdx, depth + 1, "sessionIdx");
+        if (node.forwardIdx)
+            walk(node.forwardIdx, depth + 1, "forwardIdx");
+        if (node.where)
+            walk(node.where, depth + 1, "where");
+        if (node.find)
+            walk(node.find, depth + 1, "find");
+        if (node.objectLeft)
+            walk(node.objectLeft, depth + 1, "objLeft");
+        if (node.objectRight)
+            walk(node.objectRight, depth + 1, "objRight");
+        if (node.recipient)
+            walk(node.recipient, depth + 1, "recipient");
+    }
+    lines.push(heading(1, "Root"));
+    walk(root, 2);
+    if (table && table.length > 0) {
+        lines.push("");
+        lines.push("## Table");
+        for (const entry of table) {
+            const typeStr = typeof entry.value_type === "string" ? entry.value_type : `type=${entry.value_type}`;
+            const valueStr = (entry.value !== undefined && !entry.b_submission) ? `, value=${String(entry.value)}` : "";
+            const submissionStr = entry.b_submission ? " (submission)" : "";
+            const nameStr = entry.name ? ` "${entry.name}"` : "";
+            lines.push(`- id[${entry.identifier}]${nameStr}: ${typeStr}${valueStr}${submissionStr}`);
+        }
+    }
+    if (rely && rely.guards.length > 0) {
+        lines.push("");
+        lines.push(`## Rely (${rely.logic_or ? "OR" : "AND"})`);
+        for (const g of rely.guards) {
+            lines.push(`- ${g}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function parseGuardTableJSON(text) {
+    const sectionMatch = text.match(/##\s*Table JSON[^\n]*\n\s*```json\s*\n([\s\S]*?)```/i);
+    if (!sectionMatch)
+        return null;
+    try {
+        const data = JSON.parse(sectionMatch[1].trim());
+        if (!Array.isArray(data))
+            return null;
+        return data.filter((entry) => {
+            return entry && typeof entry === "object" &&
+                typeof entry.identifier === "number" &&
+                typeof entry.b_submission === "boolean";
+        }).map((entry) => ({
+            identifier: entry.identifier,
+            name: entry.name,
+            value_type: entry.value_type,
+            b_submission: entry.b_submission,
+            value: entry.value,
+        }));
+    }
+    catch {
+        return null;
+    }
+}