@wowok/agent-mcp 2.6.0 → 2.6.3

package/dist/project/graph-builder.d.ts

@@ -1,4 +1,7 @@
-import { type GraphData } from "@wowok/wowok";
+import { type GraphData, type GraphNode } from "@wowok/wowok";
+export type GraphNodeWithTemplate = GraphNode & {
+    isTemplate?: boolean;
+};
 export interface GraphBuildOptions {
     maxDepth?: number;
     maxConcurrency?: number;

package/dist/project/graph-builder.js

@@ -9,7 +9,12 @@ function shortTypeName(objectType) {
 }
 function extractAddressFields(obj) {
     const refs = [];
-    const objType = obj.type;
+    const rawType = obj.type;
+    let objType = rawType;
+    if (rawType && rawType.includes("::")) {
+        const parts = rawType.split("::");
+        objType = parts[parts.length - 1];
+    }
     const isAddress = (v) => typeof v === "string" && v.startsWith("0x") && v.length >= 10;
     const addRef = (addr, field, refType) => {
         if (isAddress(addr) && addr !== "0x0" && addr !== obj.object) {
@@ -45,46 +50,86 @@ function extractAddressFields(obj) {
                 const firstGuard = data.order_allocators.allocators[0]?.guard;
                 addRef(firstGuard, "order_allocators", "create");
             }
-            addRefOption(data.compensation_fund, "compensation_fund", "bind");
             break;
         }
         case "Machine": {
             addRef(data.permission, "permission", "validate");
-            addRefArray(data.repositories, "repositories", "consume");
-            if (data.nodes) {
-                for (const node of data.nodes) {
-                    if (node.forward?.guard) {
-                        addRef(node.forward.guard, "node_guard", "validate");
-                    }
-                }
-            }
+            addRefArray(data.consensus_repositories, "consensus_repositories", "consume");
             break;
         }
         case "Order": {
             addRef(data.service, "service", "consume");
             addRefOption(data.machine, "machine", "consume");
             addRefOption(data.progress, "progress", "trigger");
-            addRefOption(data.arbitration, "arbitration", "trigger");
+            addRefArray(data.dispute, "dispute", "trigger");
+            addRefOption(data.allocation, "allocation", "bind");
             break;
         }
         case "Progress": {
             addRef(data.machine, "machine", "bind");
-            addRefOption(data.parent, "parent", "bind");
-            addRefOption(data.order, "order", "bind");
+            addRefArray(data.context_repositories, "context_repositories", "consume");
             break;
         }
         case "Treasury": {
             addRef(data.permission, "permission", "validate");
-            addRefOption(data.guard, "guard", "validate");
+            if (Array.isArray(data.external_deposit_guard)) {
+                for (const g of data.external_deposit_guard)
+                    addRef(g?.guard, "external_deposit_guard", "validate");
+            }
+            if (Array.isArray(data.external_withdraw_guard)) {
+                for (const g of data.external_withdraw_guard)
+                    addRef(g?.guard, "external_withdraw_guard", "validate");
+            }
+            break;
+        }
+        case "Allocation": {
+            if (Array.isArray(data.allocators)) {
+                for (const alloc of data.allocators)
+                    addRef(alloc?.guard, "allocator_guard", "validate");
+            }
+            addRefOption(data.payment_info?.for_object, "for_object", "bind");
+            addRefOption(data.payment_info?.for_guard, "for_guard", "validate");
+            addRefArray(data.payment, "payment", "trigger");
+            break;
+        }
+        case "Arbitration": {
+            addRef(data.permission, "permission", "validate");
+            if (Array.isArray(data.voting_guard)) {
+                for (const vg of data.voting_guard)
+                    addRef(vg?.guard, "voting_guard", "validate");
+            }
+            addRefOption(data.usage_guard, "usage_guard", "validate");
+            break;
+        }
+        case "Reward": {
+            addRef(data.permission, "permission", "validate");
+            if (Array.isArray(data.guards)) {
+                for (const rg of data.guards)
+                    addRef(rg?.guard, "guard", "validate");
+            }
+            break;
+        }
+        case "Repository": {
+            addRef(data.permission, "permission", "validate");
+            addRefArray(data.rewards, "rewards", "trigger");
+            if (Array.isArray(data.policies)) {
+                for (const policy of data.policies) {
+                    if (Array.isArray(policy?.write_guard)) {
+                        for (const wg of policy.write_guard)
+                            addRef(wg?.guard, "write_guard", "validate");
+                    }
+                    addRefOption(policy?.quote_guard, "quote_guard", "validate");
+                }
+            }
             break;
         }
-        case "Allocation":
-        case "Arbitration":
-        case "Reward":
-        case "Repository":
         case "Demand": {
             addRef(data.permission, "permission", "validate");
-            addRefOption(data.guard, "guard", "validate");
+            if (Array.isArray(data.guards)) {
+                for (const dg of data.guards)
+                    addRef(dg?.guard, "guard", "validate");
+            }
+            addRefArray(data.rewards, "rewards", "trigger");
             break;
         }
         case "Contact": {
@@ -95,9 +140,16 @@ function extractAddressFields(obj) {
             break;
         }
         case "Payment": {
-            addRefOption(data.for_object, "for_object", "bind");
-            addRefOption(data.for_guard, "for_guard", "validate");
-            addRefArray(data.recipients, "recipients", "consume");
+            addRefOption(data.info?.for_object, "for_object", "bind");
+            addRefOption(data.info?.for_guard, "for_guard", "validate");
+            if (Array.isArray(data.record)) {
+                for (const r of data.record) {
+                    const rec = r?.recipient;
+                    if (rec && typeof rec === "object" && typeof rec.Entity === "string") {
+                        addRef(rec.Entity, "recipient_entity", "consume");
+                    }
+                }
+            }
             break;
         }
         case "Guard": {
@@ -165,53 +217,71 @@ const EXPECTED_RELATIONSHIPS = new Map([
             { targetType: "Machine", fieldName: "machine", relationshipType: "bind", single: true },
             { targetType: "Guard", fieldName: "buy_guard", relationshipType: "validate", single: true },
             { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
-            { targetType: "Allocation", fieldName: "order_allocators", relationshipType: "create" },
-            { targetType: "Treasury", fieldName: "compensation_fund", relationshipType: "bind", single: true },
+            { targetType: "Guard", fieldName: "allocator_guard", relationshipType: "validate" },
+            { targetType: "Contact", fieldName: "um", relationshipType: "bind", single: true },
             { targetType: "Arbitration", fieldName: "arbitrations", relationshipType: "trigger" },
             { targetType: "Reward", fieldName: "rewards", relationshipType: "trigger" },
             { targetType: "Repository", fieldName: "repositories", relationshipType: "consume" },
         ]],
     ["Machine", [
-            { targetType: "Guard", fieldName: "nodes.guard", relationshipType: "validate" },
             { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
-            { targetType: "Repository", fieldName: "repositories", relationshipType: "consume" },
+            { targetType: "Repository", fieldName: "consensus_repositories", relationshipType: "consume" },
+            { targetType: "Contact", fieldName: "um", relationshipType: "bind", single: true },
         ]],
     ["Order", [
             { targetType: "Service", fieldName: "service", relationshipType: "consume", single: true },
+            { targetType: "Machine", fieldName: "machine", relationshipType: "consume", single: true },
             { targetType: "Progress", fieldName: "progress", relationshipType: "trigger", single: true },
+            { targetType: "Arb", fieldName: "dispute", relationshipType: "trigger" },
+            { targetType: "Allocation", fieldName: "allocation", relationshipType: "bind", single: true },
         ]],
     ["Progress", [
-            { targetType: "Machine", fieldName: "parent", relationshipType: "bind", single: true },
             { targetType: "Machine", fieldName: "machine", relationshipType: "bind", single: true },
+            { targetType: "Repository", fieldName: "context_repositories", relationshipType: "consume" },
         ]],
     ["Allocation", [
-            { targetType: "Treasury", fieldName: "treasury", relationshipType: "consume", single: true },
-            { targetType: "Guard", fieldName: "guard", relationshipType: "validate", single: true },
+            { targetType: "Guard", fieldName: "allocator_guard", relationshipType: "validate" },
+            { targetType: "Guard", fieldName: "for_guard", relationshipType: "validate", single: true },
+            { targetType: "Payment", fieldName: "payment", relationshipType: "trigger" },
         ]],
     ["Reward", [
-            { targetType: "Guard", fieldName: "guard", relationshipType: "validate", single: true },
+            { targetType: "Guard", fieldName: "guard", relationshipType: "validate" },
             { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
+            { targetType: "Contact", fieldName: "um", relationshipType: "bind", single: true },
         ]],
     ["Repository", [
-            { targetType: "Guard", fieldName: "guard", relationshipType: "validate", single: true },
+            { targetType: "Guard", fieldName: "write_guard", relationshipType: "validate" },
+            { targetType: "Guard", fieldName: "quote_guard", relationshipType: "validate", single: true },
             { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
+            { targetType: "Reward", fieldName: "rewards", relationshipType: "trigger" },
+            { targetType: "Contact", fieldName: "um", relationshipType: "bind", single: true },
         ]],
     ["Demand", [
-            { targetType: "Service", fieldName: "service", relationshipType: "consume", single: true },
-            { targetType: "Guard", fieldName: "guards", relationshipType: "validate" },
+            { targetType: "Guard", fieldName: "guard", relationshipType: "validate" },
             { targetType: "Reward", fieldName: "rewards", relationshipType: "trigger" },
+            { targetType: "Contact", fieldName: "um", relationshipType: "bind", single: true },
         ]],
     ["Treasury", [
             { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
-            { targetType: "Guard", fieldName: "guard", relationshipType: "validate", single: true },
+            { targetType: "Guard", fieldName: "external_deposit_guard", relationshipType: "validate" },
+            { targetType: "Guard", fieldName: "external_withdraw_guard", relationshipType: "validate" },
+            { targetType: "Contact", fieldName: "um", relationshipType: "bind", single: true },
         ]],
     ["Arbitration", [
             { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
-            { targetType: "Guard", fieldName: "guard", relationshipType: "validate", single: true },
+            { targetType: "Guard", fieldName: "voting_guard", relationshipType: "validate" },
+            { targetType: "Guard", fieldName: "usage_guard", relationshipType: "validate", single: true },
+            { targetType: "Contact", fieldName: "um", relationshipType: "bind", single: true },
         ]],
     ["Payment", [
             { targetType: "Guard", fieldName: "for_guard", relationshipType: "validate", single: true },
         ]],
+    ["Contact", [
+            { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
+        ]],
+    ["Permission", [
+            { targetType: "Contact", fieldName: "um", relationshipType: "bind", single: true },
+        ]],
 ]);
 export class GraphBuilder {
     localProject;
@@ -478,33 +548,31 @@ export class GraphBuilder {
                     const fieldKey = `${source.address}#${expected.fieldName}`;
                     const existingBindings = sourceFieldBindings.get(fieldKey);
                     const hasOtherBinding = existingBindings !== undefined && existingBindings.size > 0;
-                    for (const target of targets) {
-                        if (source.address === target.address)
-                            continue;
-                        const pairKey = `${source.address}→${target.address}`;
-                        if (existingPairs.has(pairKey))
-                            continue;
-                        if (existingBindings?.has(target.address))
-                            continue;
-                        potentialEdges.push({
-                            sourceObject: source.address,
-                            targetObject: target.address,
-                            edgeSource: "potential",
-                            relationshipType: expected.relationshipType,
-                            fieldName: expected.fieldName,
-                            depth: 0,
-                            verified: false,
-                            weight: hasOtherBinding ? 0.3 : 0.6,
-                            direction: "outbound",
-                            metadata: {
-                                reason: hasOtherBinding
-                                    ? "field_already_bound_to_other"
-                                    : "expected_relationship_missing",
-                                expected_target_type: expected.targetType,
-                                source_object_name: source.name,
-                            },
-                        });
-                    }
+                    if (hasOtherBinding)
+                        continue;
+                    const representativeTarget = targets.find((t) => t.address !== source.address &&
+                        !existingPairs.has(`${source.address}→${t.address}`) &&
+                        !existingBindings?.has(t.address));
+                    if (!representativeTarget)
+                        continue;
+                    potentialEdges.push({
+                        sourceObject: source.address,
+                        targetObject: representativeTarget.address,
+                        edgeSource: "potential",
+                        relationshipType: expected.relationshipType,
+                        fieldName: expected.fieldName,
+                        depth: 0,
+                        verified: false,
+                        weight: 0.6,
+                        direction: "outbound",
+                        metadata: {
+                            reason: "expected_relationship_missing",
+                            expected_target_type: expected.targetType,
+                            source_object_name: source.name,
+                            representative: true,
+                            alternative_target_count: targets.length - 1,
+                        },
+                    });
                 }
             }
         }
@@ -554,12 +622,14 @@ export class GraphBuilder {
                 const obj = objectCache.get(addr);
                 const queryName = obj?.query_name;
                 const objectName = queryName && queryName !== addr ? queryName : null;
+                const isTemplate = addr.startsWith("draft:");
                 nodeMap.set(addr, {
                     address: addr,
                     objectType: obj?.type ?? null,
                     objectName,
                     role: null,
                     isCore: addr === rootAddress,
+                    isTemplate,
                 });
             }
             return nodeMap.get(addr);

package/dist/project/graph.d.ts

@@ -6,6 +6,7 @@ export interface GraphNode {
     projects?: string[];
     type?: ProjectObjectType;
     address?: string;
+    isTemplate?: boolean;
     decision_contexts?: GraphDecisionContext[];
 }
 export interface GraphDecisionContext {