@wowok/agent-mcp 2.5.5 → 2.6.1

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

@@ -1,5 +1,12 @@
 import { query_objects, queryTableItem_EntityLinker, LocalProject, } from "@wowok/wowok";
 const MAX_OBJECTS_PER_QUERY = 50;
+function shortTypeName(objectType) {
+    if (!objectType)
+        return "unknown";
+    const base = objectType.replace(/<.*>/, "").trim();
+    const segments = base.split("::");
+    return segments[segments.length - 1] || "unknown";
+}
 function extractAddressFields(obj) {
     const refs = [];
     const objType = obj.type;
@@ -35,47 +42,89 @@ function extractAddressFields(obj) {
                 for (const alloc of data.order_allocators.allocators) {
                     addRef(alloc.guard, "allocator_guard", "validate");
                 }
+                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": {
@@ -86,9 +135,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": {
@@ -156,53 +212,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;
@@ -449,7 +523,7 @@ export class GraphBuilder {
         }
         const byType = new Map();
         for (const obj of projectObjects) {
-            const type = obj.objectType ?? "unknown";
+            const type = shortTypeName(obj.objectType);
             if (!byType.has(type))
                 byType.set(type, []);
             byType.get(type).push({
@@ -469,33 +543,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,
+                        },
+                    });
                 }
             }
         }
@@ -504,6 +576,8 @@ export class GraphBuilder {
     resolveConflicts(edges) {
         const edgeMap = new Map();
         for (const edge of edges) {
+            if (!edge.sourceObject || !edge.targetObject)
+                continue;
             const key = `${edge.sourceObject}→${edge.targetObject}:${edge.relationshipType}`;
             const list = edgeMap.get(key) ?? [];
             list.push(edge);
@@ -541,12 +615,16 @@ export class GraphBuilder {
         const ensureNode = (addr) => {
             if (!nodeMap.has(addr)) {
                 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: 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 {

package/dist/project/handlers.d.ts

@@ -1,11 +1,12 @@
 import type { z } from "zod";
-import { type Project, type ProjectObject, type EvaluationType } from "@wowok/wowok";
+import { type ProjectObject, type EvaluationType } from "@wowok/wowok";
 import type { ProjectOperationInputSchema } from "../schema/project/index.js";
 type ProjectInput = z.infer<typeof ProjectOperationInputSchema>;
 export declare function handleListProjects(v: ProjectInput): Promise<{
     action: "list_projects";
     items: {
         objectCount: number;
+        evaluationCount: number;
         objectTypes: string[];
         id: string;
         prefix: string;
@@ -27,28 +28,104 @@ export declare function handleListProjects(v: ProjectInput): Promise<{
 }>;
 export declare function handleCreateProject(v: ProjectInput): Promise<{
     action: "create_project";
-    project: Project;
+    project: import("@wowok/wowok").Project;
+    blueprint: {
+        objects_count: number;
+        edges_count: number;
+        industry_source: string;
+        applied_template: string;
+        steps_count: number;
+        scenarios_count: number;
+        key_risk: string | undefined;
+    };
+    recommended_creation_order: {
+        step: number;
+        object: string;
+        reason: string;
+        required: boolean;
+    }[];
+    blueprint_warning?: undefined;
+    blueprint_skipped?: undefined;
+    hint?: undefined;
+} | {
+    action: "create_project";
+    project: import("@wowok/wowok").Project;
+    blueprint_warning: string;
+    recommended_creation_order: {
+        step: number;
+        object: string;
+        reason: string;
+        required: boolean;
+    }[];
+    blueprint?: undefined;
+    blueprint_skipped?: undefined;
+    hint?: undefined;
+} | {
+    action: "create_project";
+    project: import("@wowok/wowok").Project;
+    blueprint_skipped: boolean;
+    hint: string;
+    recommended_creation_order: {
+        step: number;
+        object: string;
+        reason: string;
+        required: boolean;
+    }[];
+    blueprint?: undefined;
+    blueprint_warning?: undefined;
+} | {
+    action: "create_project";
+    project: import("@wowok/wowok").Project;
+    recommended_creation_order: {
+        step: number;
+        object: string;
+        reason: string;
+        required: boolean;
+    }[];
+    blueprint?: undefined;
+    blueprint_warning?: undefined;
+    blueprint_skipped?: undefined;
+    hint?: undefined;
 }>;
 export declare function handleCreateProjectFromOnchain(v: ProjectInput): Promise<{
     action: "create_project_from_onchain";
-    project: Project;
+    project: import("@wowok/wowok").Project;
     objects: ProjectObject[];
     graphEdgeCount: number;
 }>;
 export declare function handleUpdateProject(v: ProjectInput): Promise<{
     action: "update_project";
-    project: Project;
+    project: import("@wowok/wowok").Project;
 }>;
 export declare function handleGetProjectDetail(v: ProjectInput): Promise<{
     action: "get_project_detail";
-    project: Project;
+    project: import("@wowok/wowok").Project;
     objects: ProjectObject[];
+    objectGroups: {
+        core: ProjectObject[];
+        dependency: ProjectObject[];
+        reference: ProjectObject[];
+        other: ProjectObject[];
+        stats: {
+            total: number;
+            core_count: number;
+            dependency_count: number;
+            reference_count: number;
+            other_count: number;
+            by_type: Record<string, number>;
+        };
+    };
     graphEdgeCount: number;
+    serviceStatus: {
+        published: boolean | null;
+        paused: boolean | null;
+    } | null;
     evaluations: {
         id: string;
         evalType: EvaluationType;
         score: number | null;
         summary: string | null;
+        details: Record<string, unknown> | null;
         evaluatedAt: number;
     }[];
     versions: {
@@ -84,6 +161,31 @@ export declare function handleBuildGraph(v: ProjectInput): Promise<{
     edgesBySource: Record<string, number>;
     reputationCount: number;
     builtAt: number;
+    topEdges: {
+        source: string;
+        target: string;
+        fieldName: string | null;
+        relationshipType: import("@wowok/wowok").RelationshipType;
+        weight: number;
+        verified: boolean;
+    }[];
+    visualization: string;
+    hint: string;
+    binding_verification: {
+        service: string;
+        bindings: Record<string, {
+            expected: string;
+            actual: string | null;
+            count?: number;
+            verified: boolean;
+        }>;
+        all_verified: boolean;
+    } | null;
+} | {
+    action: "build_graph";
+    async_mode: true;
+    task_id: string;
+    hint: string;
 }>;
 export declare function handleGetGraph(v: ProjectInput): Promise<{
     action: "get_graph";
@@ -137,6 +239,15 @@ export declare function handleDeleteProject(v: ProjectInput): Promise<{
     action: "delete_project";
     deleted: true;
 }>;
+export declare function handleCloneProjectToNetwork(v: ProjectInput): Promise<{
+    action: "clone_project_to_network" | "migrate_network";
+    new_project_id: string;
+    new_prefix: string;
+    target_network: "testnet" | "mainnet";
+    cloned_objects_count: number;
+    message: string;
+    next_steps: string;
+}>;
 export declare function handleGetObjectDiff(v: ProjectInput): Promise<{
     action: "get_object_diff";
     address: string;
@@ -149,4 +260,109 @@ export declare function handleGetObjectDiff(v: ProjectInput): Promise<{
         changeType: "modified" | "removed" | "added";
     }[];
 }>;
+declare function normalizeForwards(raw: unknown): {
+    name: string;
+    weight: number;
+    guard: string | null;
+    retained_submission: number[] | null;
+    named_operator: string | null;
+    permission_index: number | null;
+}[];
+export declare function handleGetMachineGraph(v: ProjectInput): Promise<{
+    action: "get_machine_graph";
+    machineAddress: string;
+    machineName: string | null;
+    nodes: {
+        name: string;
+        description: string | null;
+    }[];
+    edges: {
+        from: string;
+        to: string;
+        threshold: number;
+        forwards: ReturnType<typeof normalizeForwards>;
+    }[];
+    published: boolean | null;
+    paused: boolean | null;
+}>;
+export declare function handlePreEvaluateCheck(v: ProjectInput): Promise<{
+    action: "pre_evaluate_check";
+    ready: boolean;
+    missing: {
+        id: string;
+        description: string;
+        impact: string;
+    }[];
+    warnings: {
+        id: string;
+        description: string;
+        impact: string;
+    }[];
+    summary: string;
+    counts?: undefined;
+} | {
+    action: "pre_evaluate_check";
+    ready: boolean;
+    missing: {
+        id: string;
+        description: string;
+        impact: string;
+    }[];
+    warnings: {
+        id: string;
+        description: string;
+        impact: string;
+    }[];
+    summary: string;
+    counts: {
+        objects: number;
+        edges: number;
+        uncached: number;
+        stale: number;
+        dangling_edges: number;
+        drafts: number;
+    };
+}>;
+export declare function handleVerifyDeployment(v: ProjectInput): Promise<{
+    action: "verify_deployment";
+    verifiedCount: number;
+    matched: number;
+    mismatched: number;
+    missing: number;
+    unreachable: number;
+    results: {
+        objectAddress: string;
+        objectName: string | null;
+        objectType: string | null;
+        status: "unreachable";
+        error: string;
+    }[];
+    summary: string;
+} | {
+    action: "verify_deployment";
+    verifiedCount: number;
+    matched: number;
+    mismatched: number;
+    missing: number;
+    unreachable: number;
+    results: {
+        objectAddress: string;
+        objectName: string | null;
+        objectType: string | null;
+        status: "matched" | "mismatched" | "missing" | "unreachable";
+        error?: string;
+        differences?: Array<{
+            field: string;
+            sqlite: unknown;
+            onchain: unknown;
+        }>;
+        bindings?: {
+            machine: boolean;
+            permission: boolean;
+            buy_guard: boolean;
+            order_allocators: boolean;
+        };
+    }[];
+    summary: string;
+}>;
 export {};