@wowok/agent-mcp 2.5.3 → 2.5.5

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

@@ -0,0 +1,43 @@
+import { type GraphData } from "@wowok/wowok";
+export interface GraphBuildOptions {
+    maxDepth?: number;
+    maxConcurrency?: number;
+    rateLimitQPS?: number;
+    cacheTTL?: number;
+    enableRegistrar?: boolean;
+    enablePotential?: boolean;
+    projectId?: string | null;
+    network?: string;
+    batchSize?: number;
+}
+export interface ReputationData {
+    likes: number;
+    dislikes: number;
+    affiliations: number;
+    voters: Array<{
+        who: string;
+        like: boolean;
+        dislike: boolean;
+        affiliation: boolean;
+        time: number;
+    }>;
+}
+export interface GraphBuildResult {
+    graph: GraphData;
+    reputation: Map<string, ReputationData>;
+}
+export declare class GraphBuilder {
+    private localProject;
+    private rateLimiter;
+    private options;
+    constructor(options?: GraphBuildOptions);
+    buildRelationshipGraph(rootAddress: string): Promise<GraphBuildResult>;
+    private buildInternalRefsBatched;
+    private fetchObjectsBatch;
+    private mapRefTypeToRelationship;
+    private buildRegistrarRefs;
+    private buildPotentialRefs;
+    private resolveConflicts;
+    private buildNodes;
+}
+export declare function buildGraph(rootAddress: string, options?: GraphBuildOptions): Promise<GraphBuildResult>;

package/dist/project/graph-builder.js

@@ -0,0 +1,572 @@
+import { query_objects, queryTableItem_EntityLinker, LocalProject, } from "@wowok/wowok";
+const MAX_OBJECTS_PER_QUERY = 50;
+function extractAddressFields(obj) {
+    const refs = [];
+    const objType = obj.type;
+    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) {
+            refs.push({ address: addr, field, type: refType });
+        }
+    };
+    const addRefArray = (arr, field, refType) => {
+        if (Array.isArray(arr)) {
+            for (const item of arr) {
+                addRef(item, field, refType);
+            }
+        }
+    };
+    const addRefOption = (val, field, refType) => {
+        if (val !== null && val !== undefined) {
+            addRef(val, field, refType);
+        }
+    };
+    const data = obj;
+    switch (objType) {
+        case "Service": {
+            addRefOption(data.machine, "machine", "bind");
+            addRefOption(data.buy_guard, "buy_guard", "validate");
+            addRefOption(data.um, "um", "bind");
+            addRef(data.permission, "permission", "validate");
+            addRefArray(data.repositories, "repositories", "consume");
+            addRefArray(data.arbitrations, "arbitrations", "trigger");
+            addRefArray(data.rewards, "rewards", "trigger");
+            if (data.order_allocators?.allocators) {
+                for (const alloc of data.order_allocators.allocators) {
+                    addRef(alloc.guard, "allocator_guard", "validate");
+                }
+            }
+            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");
+                    }
+                }
+            }
+            break;
+        }
+        case "Order": {
+            addRef(data.service, "service", "consume");
+            addRefOption(data.machine, "machine", "consume");
+            addRefOption(data.progress, "progress", "trigger");
+            addRefOption(data.arbitration, "arbitration", "trigger");
+            break;
+        }
+        case "Progress": {
+            addRef(data.machine, "machine", "bind");
+            addRefOption(data.parent, "parent", "bind");
+            addRefOption(data.order, "order", "bind");
+            break;
+        }
+        case "Treasury": {
+            addRef(data.permission, "permission", "validate");
+            addRefOption(data.guard, "guard", "validate");
+            break;
+        }
+        case "Allocation":
+        case "Arbitration":
+        case "Reward":
+        case "Repository":
+        case "Demand": {
+            addRef(data.permission, "permission", "validate");
+            addRefOption(data.guard, "guard", "validate");
+            break;
+        }
+        case "Contact": {
+            addRef(data.permission, "permission", "validate");
+            break;
+        }
+        case "Permission": {
+            break;
+        }
+        case "Payment": {
+            addRefOption(data.for_object, "for_object", "bind");
+            addRefOption(data.for_guard, "for_guard", "validate");
+            addRefArray(data.recipients, "recipients", "consume");
+            break;
+        }
+        case "Guard": {
+            break;
+        }
+        default:
+            break;
+    }
+    return refs;
+}
+class RateLimiter {
+    maxConcurrency;
+    qps;
+    queue = [];
+    activeCount = 0;
+    lastRequestTime = 0;
+    constructor(maxConcurrency, qps) {
+        this.maxConcurrency = maxConcurrency;
+        this.qps = qps;
+    }
+    async acquire() {
+        if (this.activeCount < this.maxConcurrency) {
+            this.activeCount++;
+            await this.enforceRate();
+            return;
+        }
+        return new Promise((resolve) => {
+            this.queue.push(() => {
+                this.activeCount++;
+                this.enforceRate().then(resolve);
+            });
+        });
+    }
+    release() {
+        this.activeCount--;
+        if (this.queue.length > 0) {
+            const next = this.queue.shift();
+            next();
+        }
+    }
+    async enforceRate() {
+        const now = Date.now();
+        const minInterval = 1000 / this.qps;
+        const elapsed = now - this.lastRequestTime;
+        if (elapsed < minInterval) {
+            await sleep(minInterval - elapsed);
+        }
+        this.lastRequestTime = Date.now();
+    }
+    async run(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const EXPECTED_RELATIONSHIPS = new Map([
+    ["Service", [
+            { 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: "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" },
+        ]],
+    ["Order", [
+            { targetType: "Service", fieldName: "service", relationshipType: "consume", single: true },
+            { targetType: "Progress", fieldName: "progress", relationshipType: "trigger", single: true },
+        ]],
+    ["Progress", [
+            { targetType: "Machine", fieldName: "parent", relationshipType: "bind", single: true },
+            { targetType: "Machine", fieldName: "machine", relationshipType: "bind", single: true },
+        ]],
+    ["Allocation", [
+            { targetType: "Treasury", fieldName: "treasury", relationshipType: "consume", single: true },
+            { targetType: "Guard", fieldName: "guard", relationshipType: "validate", single: true },
+        ]],
+    ["Reward", [
+            { targetType: "Guard", fieldName: "guard", relationshipType: "validate", single: true },
+            { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
+        ]],
+    ["Repository", [
+            { targetType: "Guard", fieldName: "guard", relationshipType: "validate", single: true },
+            { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
+        ]],
+    ["Demand", [
+            { targetType: "Service", fieldName: "service", relationshipType: "consume", single: true },
+            { targetType: "Guard", fieldName: "guards", relationshipType: "validate" },
+            { targetType: "Reward", fieldName: "rewards", relationshipType: "trigger" },
+        ]],
+    ["Treasury", [
+            { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
+            { targetType: "Guard", fieldName: "guard", relationshipType: "validate", single: true },
+        ]],
+    ["Arbitration", [
+            { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
+            { targetType: "Guard", fieldName: "guard", relationshipType: "validate", single: true },
+        ]],
+    ["Payment", [
+            { targetType: "Guard", fieldName: "for_guard", relationshipType: "validate", single: true },
+        ]],
+]);
+export class GraphBuilder {
+    localProject;
+    rateLimiter;
+    options;
+    constructor(options) {
+        const batchSize = Math.min(Math.max(options?.batchSize ?? MAX_OBJECTS_PER_QUERY, 1), MAX_OBJECTS_PER_QUERY);
+        this.options = {
+            maxDepth: options?.maxDepth ?? 3,
+            maxConcurrency: options?.maxConcurrency ?? 5,
+            rateLimitQPS: options?.rateLimitQPS ?? 10,
+            cacheTTL: options?.cacheTTL ?? 3600000,
+            enableRegistrar: options?.enableRegistrar ?? true,
+            enablePotential: options?.enablePotential ?? false,
+            projectId: options?.projectId ?? null,
+            network: options?.network ?? "testnet",
+            batchSize,
+        };
+        this.rateLimiter = new RateLimiter(this.options.maxConcurrency, this.options.rateLimitQPS);
+        this.localProject = LocalProject.Instance();
+    }
+    async buildRelationshipGraph(rootAddress) {
+        const allEdges = [];
+        const reputationMap = new Map();
+        const visited = new Set();
+        const objectCache = new Map();
+        const pendingAddresses = new Set([rootAddress]);
+        await this.buildInternalRefsBatched(pendingAddresses, visited, allEdges, objectCache);
+        if (this.options.enableRegistrar) {
+            const allAddresses = new Set([rootAddress]);
+            for (const edge of allEdges) {
+                allAddresses.add(edge.sourceObject);
+                allAddresses.add(edge.targetObject);
+            }
+            const registrarPromises = Array.from(allAddresses).map((addr) => this.buildRegistrarRefs(addr).then((result) => {
+                allEdges.push(...result.edges);
+                if (result.reputation) {
+                    reputationMap.set(addr, result.reputation);
+                }
+            }));
+            await Promise.all(registrarPromises);
+        }
+        if (this.options.enablePotential && this.options.projectId) {
+            const potentialEdges = await this.buildPotentialRefs(this.options.projectId, allEdges);
+            allEdges.push(...potentialEdges);
+        }
+        const resolvedEdges = this.resolveConflicts(allEdges);
+        const nodes = this.buildNodes(resolvedEdges, objectCache, rootAddress);
+        const savedEdges = await this.localProject.saveGraphEdges(this.options.projectId, resolvedEdges);
+        return {
+            graph: {
+                nodes,
+                edges: savedEdges,
+                builtAt: Date.now(),
+            },
+            reputation: reputationMap,
+        };
+    }
+    async buildInternalRefsBatched(pendingAddresses, visited, edges, objectCache) {
+        const batchSize = this.options.batchSize;
+        for (let depth = 0; depth < this.options.maxDepth; depth++) {
+            const currentLevel = [];
+            for (const addr of pendingAddresses) {
+                if (!visited.has(addr)) {
+                    visited.add(addr);
+                    currentLevel.push(addr);
+                }
+            }
+            pendingAddresses.clear();
+            if (currentLevel.length === 0)
+                break;
+            const nextLevelPending = new Set();
+            for (let i = 0; i < currentLevel.length; i += batchSize) {
+                const batch = currentLevel.slice(i, i + batchSize);
+                const objects = await this.fetchObjectsBatch(batch, objectCache);
+                for (const addr of batch) {
+                    const obj = objects.get(addr);
+                    if (!obj)
+                        continue;
+                    const refs = extractAddressFields(obj);
+                    for (const ref of refs) {
+                        edges.push({
+                            sourceObject: addr,
+                            targetObject: ref.address,
+                            edgeSource: "internal",
+                            relationshipType: this.mapRefTypeToRelationship(ref.type),
+                            fieldName: ref.field,
+                            depth,
+                            verified: true,
+                            weight: 1.0,
+                            direction: "outbound",
+                            metadata: { ref_type: ref.type },
+                        });
+                        if (!visited.has(ref.address)) {
+                            nextLevelPending.add(ref.address);
+                        }
+                    }
+                }
+            }
+            for (const addr of nextLevelPending) {
+                pendingAddresses.add(addr);
+            }
+        }
+    }
+    async fetchObjectsBatch(addresses, objectCache) {
+        const result = new Map();
+        const toFetch = [];
+        for (const addr of addresses) {
+            const cached = objectCache.get(addr);
+            if (cached) {
+                result.set(addr, cached);
+            }
+            else {
+                toFetch.push(addr);
+            }
+        }
+        if (toFetch.length === 0)
+            return result;
+        const response = await this.rateLimiter.run(async () => {
+            return await query_objects({
+                objects: toFetch,
+                network: this.options.network,
+            });
+        });
+        for (const obj of response.objects ?? []) {
+            if (!obj || !obj.object)
+                continue;
+            objectCache.set(obj.object, obj);
+            result.set(obj.object, obj);
+            void this.localProject.cacheObject(obj.object, obj.type ?? null, JSON.stringify(obj), this.options.network).catch(() => {
+            });
+        }
+        return result;
+    }
+    mapRefTypeToRelationship(refType) {
+        switch (refType) {
+            case "bind":
+                return "bind";
+            case "validate":
+                return "validate";
+            case "consume":
+                return "consume";
+            case "trigger":
+                return "trigger";
+            case "reference":
+                return "affiliation";
+            default:
+                return "bind";
+        }
+    }
+    async buildRegistrarRefs(address) {
+        try {
+            const result = await this.rateLimiter.run(async () => {
+                return await queryTableItem_EntityLinker({
+                    address,
+                    network: this.options.network,
+                });
+            });
+            if (!result || !result.votes || result.votes.length === 0) {
+                return { edges: [] };
+            }
+            const edges = [];
+            const reputation = {
+                likes: 0,
+                dislikes: 0,
+                affiliations: 0,
+                voters: [],
+            };
+            for (const vote of result.votes) {
+                if (vote.like)
+                    reputation.likes++;
+                if (vote.dislike)
+                    reputation.dislikes++;
+                if (vote.affiliation)
+                    reputation.affiliations++;
+                reputation.voters.push({
+                    who: vote.address,
+                    like: vote.like ?? false,
+                    dislike: vote.dislike ?? false,
+                    affiliation: vote.affiliation ?? false,
+                    time: vote.time,
+                });
+                if (vote.affiliation) {
+                    edges.push({
+                        sourceObject: vote.address,
+                        targetObject: address,
+                        edgeSource: "registrar",
+                        relationshipType: "affiliation",
+                        fieldName: null,
+                        depth: 0,
+                        verified: true,
+                        weight: 0.9,
+                        direction: "inbound",
+                        metadata: {
+                            like: vote.like ?? false,
+                            dislike: vote.dislike ?? false,
+                            affiliation: true,
+                            time: vote.time,
+                        },
+                    });
+                }
+                else if (vote.like || vote.dislike) {
+                    edges.push({
+                        sourceObject: vote.address,
+                        targetObject: address,
+                        edgeSource: "registrar",
+                        relationshipType: "affiliation",
+                        fieldName: null,
+                        depth: 0,
+                        verified: true,
+                        weight: 0.3,
+                        direction: "inbound",
+                        metadata: {
+                            like: vote.like ?? false,
+                            dislike: vote.dislike ?? false,
+                            affiliation: false,
+                            disaffiliated: true,
+                            time: vote.time,
+                        },
+                    });
+                }
+            }
+            return { edges, reputation };
+        }
+        catch {
+            return { edges: [] };
+        }
+    }
+    async buildPotentialRefs(projectId, existingEdges) {
+        const potentialEdges = [];
+        const projectObjects = await this.localProject.listObjects(projectId);
+        if (projectObjects.length === 0)
+            return potentialEdges;
+        const existingPairs = new Set(existingEdges.map((e) => `${e.sourceObject}→${e.targetObject}`));
+        const sourceFieldBindings = new Map();
+        for (const e of existingEdges) {
+            if (e.fieldName) {
+                const key = `${e.sourceObject}#${e.fieldName}`;
+                if (!sourceFieldBindings.has(key)) {
+                    sourceFieldBindings.set(key, new Set());
+                }
+                sourceFieldBindings.get(key).add(e.targetObject);
+            }
+        }
+        const byType = new Map();
+        for (const obj of projectObjects) {
+            const type = obj.objectType ?? "unknown";
+            if (!byType.has(type))
+                byType.set(type, []);
+            byType.get(type).push({
+                address: obj.objectAddress,
+                name: obj.objectName,
+            });
+        }
+        for (const [sourceType, expectedRels] of EXPECTED_RELATIONSHIPS) {
+            const sources = byType.get(sourceType);
+            if (!sources || sources.length === 0)
+                continue;
+            for (const source of sources) {
+                for (const expected of expectedRels) {
+                    const targets = byType.get(expected.targetType);
+                    if (!targets || targets.length === 0)
+                        continue;
+                    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,
+                            },
+                        });
+                    }
+                }
+            }
+        }
+        return potentialEdges;
+    }
+    resolveConflicts(edges) {
+        const edgeMap = new Map();
+        for (const edge of edges) {
+            const key = `${edge.sourceObject}→${edge.targetObject}:${edge.relationshipType}`;
+            const list = edgeMap.get(key) ?? [];
+            list.push(edge);
+            edgeMap.set(key, list);
+        }
+        const result = [];
+        for (const list of edgeMap.values()) {
+            if (list.length === 1) {
+                result.push(list[0]);
+                continue;
+            }
+            const priority = (e) => {
+                let p = 0;
+                if (e.edgeSource === "internal")
+                    p += 100;
+                if (e.edgeSource === "registrar")
+                    p += 50;
+                if (e.verified)
+                    p += 10;
+                p += (e.weight ?? 0.5) * 10;
+                return p;
+            };
+            list.sort((a, b) => priority(b) - priority(a));
+            const winner = list[0];
+            const mergedMetadata = { ...(winner.metadata ?? {}) };
+            for (let i = 1; i < list.length; i++) {
+                mergedMetadata[`alt_${list[i].edgeSource}`] = list[i].metadata ?? {};
+            }
+            result.push({ ...winner, metadata: mergedMetadata });
+        }
+        return result;
+    }
+    buildNodes(edges, objectCache, rootAddress) {
+        const nodeMap = new Map();
+        const ensureNode = (addr) => {
+            if (!nodeMap.has(addr)) {
+                const obj = objectCache.get(addr);
+                nodeMap.set(addr, {
+                    address: addr,
+                    objectType: obj?.type ?? null,
+                    objectName: null,
+                    role: null,
+                    isCore: addr === rootAddress,
+                });
+            }
+            return nodeMap.get(addr);
+        };
+        for (const edge of edges) {
+            const source = ensureNode(edge.sourceObject);
+            const target = ensureNode(edge.targetObject);
+            if (edge.edgeSource === "internal" && edge.relationshipType === "bind") {
+                if (source.isCore) {
+                    target.role = "dependency";
+                }
+            }
+            if (edge.edgeSource === "potential") {
+                target.role = "reference";
+            }
+        }
+        return Array.from(nodeMap.values());
+    }
+}
+export async function buildGraph(rootAddress, options) {
+    const builder = new GraphBuilder(options);
+    return builder.buildRelationshipGraph(rootAddress);
+}