@wowok/agent-mcp 2.4.3 → 2.5.1

package/dist/knowledge/machine-puzzle.js

@@ -0,0 +1,494 @@
+import { inferSceneFromFlow, findScene, } from "./machine-ledger.js";
+import { MACHINE_TEMPLATES, getTemplateById, } from "./machine-templates.js";
+import { matchSemanticPattern, identifyExecutionMode, } from "./machine-translation.js";
+import { analyzeTopology, identifyTopologyPattern, } from "./machine-topology.js";
+export function initPuzzleFromIntent(intent) {
+    const scene = inferSceneFromFlow(intent);
+    const template = scene
+        ? MACHINE_TEMPLATES.find((t) => t.scene_id === scene.id)
+        : undefined;
+    const pattern = matchSemanticPattern(intent);
+    return {
+        version: "1.0.0",
+        business_flow: {
+            scenario_description: intent,
+            scene_id: scene?.id,
+            template_id: template?.id,
+            industry: scene?.industry[0],
+            participation_mode: "P-M4",
+        },
+        node_design: {
+            nodes: [],
+            topological_order: [],
+            business_stage_mapping: {},
+        },
+        guard_acceptance: {
+            guard_bindings: [],
+            name_length_verified: false,
+            all_guards_created: false,
+            cross_machine_guards: [],
+        },
+        permission_model: {
+            forward_permissions: [],
+            named_operator_roles: [],
+            completeness_verified: false,
+        },
+        threshold_weight: {
+            pair_thresholds: [],
+            forward_weights: [],
+            execution_mode: pattern?.id || "P-M-SEQ",
+            allocator_integration: [],
+        },
+        branch_topology: {
+            topology_pattern: "P-M-LINEAR",
+            branching_points: [],
+            merge_points: [],
+            is_dag: true,
+        },
+        overall_objective: {
+            primary_branch: { start_node: "", end_node: "", description: "" },
+            secondary_branches: [],
+            success_criteria: "",
+            failure_criteria: "",
+        },
+        risk_assessment: {
+            overall_risk_level: "low",
+            identified_risks: [],
+            mitigation_strategy: "",
+            environment_readiness: {
+                permission_published: false,
+                guards_published: false,
+                arbitration_published: false,
+                reward_published: false,
+                testnet_tested: false,
+            },
+        },
+    };
+}
+export function initPuzzleFromTemplate(templateId) {
+    const template = getTemplateById(templateId);
+    if (!template)
+        return undefined;
+    const scene = findScene(template.scene_id);
+    if (!scene)
+        return undefined;
+    const puzzle = initPuzzleFromIntent(template.description);
+    puzzle.business_flow.template_id = template.id;
+    puzzle.business_flow.scene_id = scene.id;
+    puzzle.business_flow.industry = scene.industry[0];
+    puzzle.business_flow.participation_mode = "P-M1";
+    puzzle.node_design.nodes = template.example_nodes.map((n) => ({
+        name: n.name,
+        description: n.description || "",
+        is_entry: false,
+        is_terminal: false,
+    }));
+    puzzle.permission_model.permission_object = {
+        use_custom: true,
+        custom_indices: template.required_permissions.map((p) => ({
+            index: p.index,
+            name: p.name,
+            description: p.description,
+        })),
+    };
+    puzzle.guard_acceptance.guard_bindings = template.required_guards.map((g) => ({
+        forward_id: {
+            pair_id: { prev_node: "", next_node: "" },
+            forward_name: g.bound_to_forward,
+        },
+        guard_template_id: g.guard_template_id,
+        purpose: g.purpose,
+        tested_on_testnet: false,
+    }));
+    puzzle.threshold_weight.allocator_integration = template.required_allocators.map((a) => ({
+        name: a.name,
+        trigger_node: a.trigger_node,
+        sharing_who: "Entity",
+        recipient_description: a.description,
+    }));
+    return puzzle;
+}
+function resolveFragmentNameConflicts(fragments) {
+    const allNodes = [];
+    const allPairs = [];
+    const renameMap = new Map();
+    for (let i = 0; i < fragments.length; i++) {
+        const frag = fragments[i];
+        const localRename = new Map();
+        for (const node of frag.nodes) {
+            const isEntryTarget = frag.pairs.some((p) => p.prev_node === "" && p.next_node === node.name);
+            const newName = isEntryTarget ? node.name : `f${i}__${node.name}`;
+            localRename.set(node.name, newName);
+            allNodes.push({ name: newName, description: node.description });
+        }
+        renameMap.set(i, localRename);
+        for (const pair of frag.pairs) {
+            const localRenames = renameMap.get(i);
+            const newPrev = pair.prev_node === "" ? "" : (localRenames.get(pair.prev_node) ?? pair.prev_node);
+            const newNext = localRenames.get(pair.next_node) ?? pair.next_node;
+            allPairs.push({
+                prev_node: newPrev,
+                next_node: newNext,
+                threshold: pair.threshold,
+                forwards: pair.forwards.map((f) => ({ ...f })),
+            });
+        }
+    }
+    return { nodes: allNodes, pairs: allPairs };
+}
+export function initPuzzleFromMachineId(machineId, machineJson) {
+    const puzzle = derivePuzzleFromMachineJson(machineJson);
+    puzzle.business_flow.participation_mode = "P-M1";
+    puzzle.business_flow.referenced_machine_ids = [machineId];
+    puzzle.business_flow.scenario_description =
+        `Reference to published Machine ${machineId}` +
+            (machineJson.name ? ` (${machineJson.name})` : "");
+    return puzzle;
+}
+export function initPuzzleFromFragments(fragments) {
+    if (fragments.length === 0) {
+        const puzzle = initPuzzleFromIntent("(composition of zero fragments)");
+        puzzle.business_flow.participation_mode = "P-M2";
+        return puzzle;
+    }
+    const { nodes, pairs } = resolveFragmentNameConflicts(fragments);
+    const mergedSceneId = fragments.find((f) => f.scene_id)?.scene_id;
+    const mergedTemplateId = fragments.find((f) => f.template_id)?.template_id;
+    const mergedName = fragments.map((f) => f.name ?? "(unnamed)").join(" + ");
+    const puzzle = derivePuzzleFromMachineJson({
+        name: mergedName,
+        nodes,
+        pairs,
+        scene_id: mergedSceneId,
+        template_id: mergedTemplateId,
+    });
+    puzzle.business_flow.participation_mode = "P-M2";
+    puzzle.business_flow.scenario_description =
+        `Composition of ${fragments.length} Machine fragments: ${mergedName}`;
+    return puzzle;
+}
+export function initPuzzleForCrossChain(machineBId, machineBJson) {
+    const puzzle = initPuzzleFromIntent(`Cross-chain dependency on upstream Machine ${machineBId}`);
+    puzzle.business_flow.participation_mode = "P-M3";
+    puzzle.business_flow.referenced_machine_ids = [machineBId];
+    if (machineBJson) {
+        const upstreamTopology = analyzeTopology(machineBJson.nodes, machineBJson.pairs);
+        for (const terminalNode of upstreamTopology.terminal_nodes) {
+            puzzle.guard_acceptance.cross_machine_guards.push({
+                forward_id: {
+                    pair_id: { prev_node: "", next_node: "" },
+                    forward_name: "",
+                },
+                upstream_machine_id: machineBId,
+                upstream_node_name: terminalNode,
+            });
+        }
+    }
+    return puzzle;
+}
+export function initPuzzleForForkModify(machineId, machineJson) {
+    const puzzle = derivePuzzleFromMachineJson(machineJson);
+    puzzle.business_flow.participation_mode = "P-M5";
+    puzzle.business_flow.referenced_machine_ids = [machineId];
+    puzzle.business_flow.fork_source_template_id =
+        machineJson.template_id ?? machineId;
+    puzzle.business_flow.scenario_description =
+        `Fork-modify from Machine ${machineId}` +
+            (machineJson.name ? ` (${machineJson.name})` : "");
+    return puzzle;
+}
+export function checkPuzzleCompleteness(puzzle) {
+    const dimensions = [];
+    const aMissing = [];
+    if (!puzzle.business_flow.scenario_description)
+        aMissing.push("scenario_description");
+    if (!puzzle.business_flow.scene_id)
+        aMissing.push("scene_id");
+    if (!puzzle.business_flow.participation_mode)
+        aMissing.push("participation_mode");
+    dimensions.push({
+        dimension: "A_business_flow",
+        complete: aMissing.length === 0,
+        missing_fields: aMissing,
+    });
+    const bMissing = [];
+    if (puzzle.node_design.nodes.length === 0)
+        bMissing.push("nodes (empty)");
+    dimensions.push({
+        dimension: "B_node_design",
+        complete: bMissing.length === 0,
+        missing_fields: bMissing,
+    });
+    const cMissing = [];
+    if (!puzzle.guard_acceptance.all_guards_created)
+        cMissing.push("all_guards_created");
+    dimensions.push({
+        dimension: "C_guard_acceptance",
+        complete: cMissing.length === 0,
+        missing_fields: cMissing,
+    });
+    const dMissing = [];
+    if (!puzzle.permission_model.completeness_verified)
+        dMissing.push("completeness_verified");
+    dimensions.push({
+        dimension: "D_permission_model",
+        complete: dMissing.length === 0,
+        missing_fields: dMissing,
+    });
+    const eMissing = [];
+    if (puzzle.threshold_weight.pair_thresholds.length === 0)
+        eMissing.push("pair_thresholds (empty)");
+    dimensions.push({
+        dimension: "E_threshold_weight",
+        complete: eMissing.length === 0,
+        missing_fields: eMissing,
+    });
+    const fMissing = [];
+    if (!puzzle.branch_topology.is_dag)
+        fMissing.push("is_dag (cycle detected)");
+    dimensions.push({
+        dimension: "F_branch_topology",
+        complete: fMissing.length === 0,
+        missing_fields: fMissing,
+    });
+    const gMissing = [];
+    if (!puzzle.overall_objective.primary_branch.end_node)
+        gMissing.push("primary_branch.end_node");
+    if (!puzzle.overall_objective.success_criteria)
+        gMissing.push("success_criteria");
+    dimensions.push({
+        dimension: "G_overall_objective",
+        complete: gMissing.length === 0,
+        missing_fields: gMissing,
+    });
+    const hMissing = [];
+    if (puzzle.risk_assessment.overall_risk_level === "critical")
+        hMissing.push("overall_risk_level=critical (must fix)");
+    dimensions.push({
+        dimension: "H_risk_assessment",
+        complete: hMissing.length === 0,
+        missing_fields: hMissing,
+    });
+    const complete = dimensions.every((d) => d.complete);
+    const firstIncomplete = dimensions.find((d) => !d.complete);
+    let next_step = "All dimensions complete. Ready for confirmation.";
+    if (firstIncomplete) {
+        next_step = `Complete dimension ${firstIncomplete.dimension}: ${firstIncomplete.missing_fields.join(", ")}`;
+    }
+    return { complete, dimensions, next_step };
+}
+export function recommendNextStep(puzzle) {
+    const completeness = checkPuzzleCompleteness(puzzle);
+    return completeness.next_step;
+}
+export function derivePuzzleFromMachineJson(machine) {
+    const topology = analyzeTopology(machine.nodes, machine.pairs);
+    const topologyPattern = identifyTopologyPattern(machine.pairs);
+    const node_design = {
+        nodes: machine.nodes.map((n) => ({
+            name: n.name,
+            description: n.description || "",
+            is_entry: topology.entry_nodes.includes(n.name),
+            is_terminal: topology.terminal_nodes.includes(n.name),
+        })),
+        topological_order: [],
+        business_stage_mapping: {},
+    };
+    const forward_permissions = [];
+    const named_operator_roles = [];
+    const roleSet = new Set();
+    for (const pair of machine.pairs) {
+        for (const fwd of pair.forwards) {
+            const hasNamed = fwd.named_operator !== undefined;
+            const hasPerm = fwd.permission_index !== undefined;
+            forward_permissions.push({
+                forward: {
+                    pair_id: { prev_node: pair.prev_node, next_node: pair.next_node },
+                    forward_name: fwd.name,
+                },
+                namedOperator: hasNamed
+                    ? { type: fwd.named_operator === "" ? "order_holder" : "role", role: fwd.named_operator || undefined }
+                    : { type: "none" },
+                permissionIndex: hasPerm
+                    ? { type: "custom", index: fwd.permission_index }
+                    : { type: "none" },
+                semantic: "",
+            });
+            if (fwd.named_operator && fwd.named_operator !== "" && !roleSet.has(fwd.named_operator)) {
+                roleSet.add(fwd.named_operator);
+                named_operator_roles.push({
+                    role: fwd.named_operator,
+                    semantic: "",
+                    assignment_timing: "at_progress_new_via_sdk",
+                });
+            }
+        }
+    }
+    const pair_thresholds = machine.pairs.map((p) => ({
+        pair_id: { prev_node: p.prev_node, next_node: p.next_node },
+        threshold: p.threshold,
+        semantic: "",
+    }));
+    const forward_weights = machine.pairs.flatMap((p) => p.forwards.map((f) => ({
+        forward_id: {
+            pair_id: { prev_node: p.prev_node, next_node: p.next_node },
+            forward_name: f.name,
+        },
+        weight: f.weight,
+        semantic: "",
+    })));
+    const executionMode = machine.pairs.length > 0
+        ? identifyExecutionMode({
+            threshold: machine.pairs[0].threshold,
+            forwards: machine.pairs[0].forwards.map((f) => ({
+                weight: f.weight,
+                named_operator: f.named_operator,
+                permission_index: f.permission_index,
+            })),
+        })
+        : "P-M-SEQ";
+    const branching_points = [];
+    const merge_points = [];
+    const outgoing = new Map();
+    const incoming = new Map();
+    for (const pair of machine.pairs) {
+        if (!outgoing.has(pair.prev_node))
+            outgoing.set(pair.prev_node, []);
+        outgoing.get(pair.prev_node).push(pair.next_node);
+        if (!incoming.has(pair.next_node))
+            incoming.set(pair.next_node, []);
+        incoming.get(pair.next_node).push(pair.prev_node);
+    }
+    for (const [node, nexts] of outgoing) {
+        if (nexts.length > 1 && node !== "") {
+            branching_points.push({
+                node,
+                branches: nexts,
+                branch_type: "competing",
+            });
+        }
+    }
+    for (const [node, prevs] of incoming) {
+        if (prevs.length > 1) {
+            merge_points.push({ node, incoming_from: prevs });
+        }
+    }
+    return {
+        version: "1.0.0",
+        business_flow: {
+            scenario_description: "",
+            scene_id: machine.scene_id,
+            template_id: machine.template_id,
+            participation_mode: "P-M1",
+        },
+        node_design,
+        guard_acceptance: {
+            guard_bindings: machine.pairs.flatMap((p) => p.forwards
+                .filter((f) => f.guard)
+                .map((f) => ({
+                forward_id: {
+                    pair_id: { prev_node: p.prev_node, next_node: p.next_node },
+                    forward_name: f.name,
+                },
+                guard_address: f.guard,
+                purpose: "",
+                tested_on_testnet: false,
+            }))),
+            name_length_verified: true,
+            all_guards_created: true,
+            cross_machine_guards: [],
+        },
+        permission_model: {
+            forward_permissions,
+            named_operator_roles,
+            completeness_verified: true,
+        },
+        threshold_weight: {
+            pair_thresholds,
+            forward_weights,
+            execution_mode: executionMode,
+            allocator_integration: [],
+        },
+        branch_topology: {
+            topology_pattern: topologyPattern,
+            branching_points,
+            merge_points,
+            is_dag: !topology.has_cycles,
+        },
+        overall_objective: {
+            primary_branch: {
+                start_node: topology.entry_nodes[0] || "",
+                end_node: topology.terminal_nodes[0] || "",
+                description: "",
+            },
+            secondary_branches: [],
+            success_criteria: "",
+            failure_criteria: "",
+        },
+        risk_assessment: {
+            overall_risk_level: "low",
+            identified_risks: [],
+            mitigation_strategy: "",
+            environment_readiness: {
+                permission_published: false,
+                guards_published: false,
+                arbitration_published: false,
+                reward_published: false,
+                testnet_tested: false,
+            },
+        },
+    };
+}
+export function generateConfirmationText(puzzle) {
+    const lines = [
+        "=== Machine Puzzle Summary ===",
+        "",
+        "A. Business Flow:",
+        `   Scenario: ${puzzle.business_flow.scenario_description || "(not set)"}`,
+        `   Scene: ${puzzle.business_flow.scene_id || "(not set)"}`,
+        `   Template: ${puzzle.business_flow.template_id || "(not set)"}`,
+        `   Participation: ${puzzle.business_flow.participation_mode || "(not set)"}`,
+        "",
+        "B. Node Design:",
+        `   Nodes: ${puzzle.node_design.nodes.length}`,
+        ...puzzle.node_design.nodes.slice(0, 10).map((n) => `   - ${n.name}${n.is_entry ? " [ENTRY]" : ""}${n.is_terminal ? " [TERMINAL]" : ""}`),
+        puzzle.node_design.nodes.length > 10 ? `   ... and ${puzzle.node_design.nodes.length - 10} more` : "",
+        "",
+        "C. Guard Acceptance:",
+        `   Guards bound: ${puzzle.guard_acceptance.guard_bindings.length}`,
+        `   All created: ${puzzle.guard_acceptance.all_guards_created ? "YES" : "NO"}`,
+        `   Name length verified: ${puzzle.guard_acceptance.name_length_verified ? "YES" : "NO"}`,
+        `   Cross-machine: ${puzzle.guard_acceptance.cross_machine_guards.length}`,
+        "",
+        "D. Permission Model:",
+        `   Forward permissions: ${puzzle.permission_model.forward_permissions.length}`,
+        `   NamedOperator roles: ${puzzle.permission_model.named_operator_roles.length}`,
+        `   Completeness verified: ${puzzle.permission_model.completeness_verified ? "YES" : "NO"}`,
+        "",
+        "E. Threshold & Weight:",
+        `   Pair thresholds: ${puzzle.threshold_weight.pair_thresholds.length}`,
+        `   Forward weights: ${puzzle.threshold_weight.forward_weights.length}`,
+        `   Execution mode: ${puzzle.threshold_weight.execution_mode}`,
+        `   Allocators: ${puzzle.threshold_weight.allocator_integration.length}`,
+        "",
+        "F. Branch Topology:",
+        `   Pattern: ${puzzle.branch_topology.topology_pattern}`,
+        `   Branching points: ${puzzle.branch_topology.branching_points.length}`,
+        `   Merge points: ${puzzle.branch_topology.merge_points.length}`,
+        `   Is DAG: ${puzzle.branch_topology.is_dag ? "YES" : "NO"}`,
+        "",
+        "G. Overall Objective:",
+        `   Primary: ${puzzle.overall_objective.primary_branch.start_node} -> ${puzzle.overall_objective.primary_branch.end_node}`,
+        `   Secondary branches: ${puzzle.overall_objective.secondary_branches.length}`,
+        "",
+        "H. Risk Assessment:",
+        `   Overall level: ${puzzle.risk_assessment.overall_risk_level}`,
+        `   Identified risks: ${puzzle.risk_assessment.identified_risks.length}`,
+        "",
+    ];
+    if (puzzle.environment) {
+        lines.push("Environment:", `   Network: ${puzzle.environment.network}`, `   Testnet passed: ${puzzle.environment.testnet_test_passed ? "YES" : "NO"}`, `   Backup created: ${puzzle.environment.backup_created ? "YES" : "NO"}`, "");
+    }
+    return lines.filter((l) => l !== "").join("\n");
+}
+export const MACHINE_PUZZLE_VERSION = "1.0.0";

package/dist/knowledge/machine-risk.d.ts

@@ -0,0 +1,75 @@
+export type MachineRiskLevel = "critical" | "high" | "medium" | "low";
+export type MachineRiskCategory = "structural" | "guard_integration" | "permission" | "immutability" | "environment";
+export interface MachineRiskRule {
+    id: string;
+    name: string;
+    category: MachineRiskCategory;
+    severity: MachineRiskLevel;
+    description: string;
+    detection: string;
+    recommendation: string;
+    auto_fixable: boolean;
+    related_constraint?: string;
+}
+export interface MachineRisk {
+    rule_id: string;
+    name: string;
+    severity: MachineRiskLevel;
+    detail: string;
+    recommendation: string;
+    auto_fixable: boolean;
+}
+export interface MachineRiskAssessment {
+    overall_level: MachineRiskLevel;
+    detected_risks: MachineRisk[];
+    summary: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    };
+    recommendation: "publish" | "fix_first" | "do_not_publish";
+}
+export interface MachineJsonForRisk {
+    nodes: Array<{
+        name: string;
+        description?: string;
+    }>;
+    pairs: Array<{
+        prev_node: string;
+        next_node: string;
+        threshold: number;
+        forwards: Array<{
+            name: string;
+            weight: number;
+            named_operator?: string;
+            permission_index?: number;
+            guard?: string;
+            retained_submission?: string | string[] | number[];
+        }>;
+    }>;
+    b_published?: boolean;
+    b_paused?: boolean;
+    scene_id?: string;
+}
+export interface ProjectContextForRisk {
+    network: "testnet" | "mainnet";
+    testnet_test_passed: boolean;
+    published_services: Set<string>;
+    published_guards: Set<string>;
+    published_permissions: Set<string>;
+    published_machines: Set<string>;
+    published_arbitrations: Set<string>;
+    published_rewards: Set<string>;
+    published_allocators: Set<string>;
+    published_repositories: Set<string>;
+}
+export declare const MACHINE_RISK_RULES: MachineRiskRule[];
+export declare function assessMachineRisks(machine: MachineJsonForRisk, context: ProjectContextForRisk): MachineRiskAssessment;
+export declare function getRiskRulesByCategory(category: MachineRiskCategory): MachineRiskRule[];
+export declare function getRiskRuleById(id: string): MachineRiskRule | undefined;
+export declare function getRiskRulesBySeverity(severity: MachineRiskLevel): MachineRiskRule[];
+export declare function getAutoFixableRules(): MachineRiskRule[];
+export declare function getRiskSummary(assessment: MachineRiskAssessment): string;
+export declare const MACHINE_RISK_VERSION = "1.0.0";
+export declare const MACHINE_RISK_RULES_COUNT: number;