@wowok/agent-mcp 2.7.1 → 2.7.2

package/dist/knowledge/machine-topology.js

@@ -1,234 +1 @@
-import { MAX_NODE_COUNT, MAX_NODE_PAIR_COUNT, MAX_FORWARD_COUNT, MAX_FORWARD_ORDER_COUNT, } from "./onchain-constants.js";
-export { MAX_NODE_COUNT, MAX_NODE_PAIR_COUNT, MAX_FORWARD_COUNT, MAX_FORWARD_ORDER_COUNT, };
-export function analyzeTopology(nodes, pairs) {
-    const nodeNames = nodes.map((n) => n.name);
-    const nodeSet = new Set(nodeNames);
-    const outgoing = new Map();
-    const incoming = new Map();
-    for (const name of nodeNames) {
-        outgoing.set(name, []);
-        incoming.set(name, []);
-    }
-    for (const pair of pairs) {
-        if (!outgoing.has(pair.prev_node) && pair.prev_node !== "") {
-            outgoing.set(pair.prev_node, []);
-        }
-        if (!incoming.has(pair.next_node)) {
-            incoming.set(pair.next_node, []);
-        }
-        if (pair.prev_node !== "") {
-            outgoing.get(pair.prev_node).push(pair.next_node);
-        }
-        incoming.get(pair.next_node).push(pair.prev_node);
-    }
-    const entry_nodes = pairs
-        .filter((p) => p.prev_node === "")
-        .map((p) => p.next_node)
-        .filter((n) => nodeSet.has(n));
-    const terminal_nodes = nodeNames.filter((n) => (outgoing.get(n) || []).length === 0);
-    const orphaned_nodes = nodeNames.filter((n) => !entry_nodes.includes(n) && (incoming.get(n) || []).length === 0);
-    const dead_end_nodes = nodeNames.filter((n) => (outgoing.get(n) || []).length === 0 && !terminal_nodes.includes(n));
-    const { has_cycles, cycle_nodes } = detectCycles(nodeNames, pairs);
-    const dead_branches = analyzeDeadBranches(pairs);
-    const reachability = computeReachability(nodeNames, pairs);
-    const totalForwards = pairs.reduce((sum, p) => sum + p.forwards.length, 0);
-    const maxForwardsInPair = Math.max(0, ...pairs.map((p) => p.forwards.length));
-    const maxRetainedSubmissionsPerForward = Math.max(0, ...pairs.flatMap((p) => p.forwards.map((f) => countRetainedSubmissions(f.retained_submission))));
-    const within_limits = {
-        max_node_count: nodes.length <= MAX_NODE_COUNT,
-        max_node_pair_count: pairs.length <= MAX_NODE_PAIR_COUNT,
-        max_forward_count: maxForwardsInPair <= MAX_FORWARD_COUNT,
-        max_forward_order_count: maxRetainedSubmissionsPerForward <= MAX_FORWARD_ORDER_COUNT,
-    };
-    return {
-        entry_nodes,
-        terminal_nodes,
-        orphaned_nodes,
-        dead_end_nodes,
-        dead_branches,
-        has_cycles,
-        cycle_nodes,
-        reachability,
-        node_count: nodes.length,
-        pair_count: pairs.length,
-        forward_count: totalForwards,
-        within_limits,
-    };
-}
-function countRetainedSubmissions(retained_submission) {
-    if (retained_submission === undefined || retained_submission === null)
-        return 0;
-    if (Array.isArray(retained_submission))
-        return retained_submission.length;
-    if (typeof retained_submission === 'string') {
-        return retained_submission.length > 0 ? 1 : 0;
-    }
-    return 0;
-}
-export function detectCycle(nodes, pairs) {
-    const nodeNames = nodes.map((n) => n.name);
-    return detectCycles(nodeNames, pairs);
-}
-function detectCycles(nodeNames, pairs) {
-    const adj = new Map();
-    for (const name of nodeNames)
-        adj.set(name, []);
-    for (const pair of pairs) {
-        if (pair.prev_node !== "" && adj.has(pair.prev_node)) {
-            adj.get(pair.prev_node).push(pair.next_node);
-        }
-    }
-    const WHITE = 0, GRAY = 1, BLACK = 2;
-    const color = new Map();
-    for (const name of nodeNames)
-        color.set(name, WHITE);
-    const cycles = [];
-    const path = [];
-    function dfs(u) {
-        color.set(u, GRAY);
-        path.push(u);
-        for (const v of adj.get(u) || []) {
-            if (color.get(v) === GRAY) {
-                const cycleStart = path.indexOf(v);
-                cycles.push(path.slice(cycleStart));
-                return true;
-            }
-            if (color.get(v) === WHITE) {
-                if (dfs(v))
-                    return true;
-            }
-        }
-        path.pop();
-        color.set(u, BLACK);
-        return false;
-    }
-    for (const name of nodeNames) {
-        if (color.get(name) === WHITE) {
-            dfs(name);
-        }
-    }
-    return {
-        has_cycles: cycles.length > 0,
-        cycle_nodes: cycles,
-    };
-}
-function analyzeDeadBranches(pairs) {
-    const dead = [];
-    const byPrevNode = new Map();
-    for (const pair of pairs) {
-        if (!byPrevNode.has(pair.prev_node))
-            byPrevNode.set(pair.prev_node, []);
-        byPrevNode.get(pair.prev_node).push(pair);
-    }
-    for (const [prev, groupPairs] of byPrevNode) {
-        if (groupPairs.length <= 1)
-            continue;
-        const minThreshold = Math.min(...groupPairs.map((p) => p.threshold));
-        for (const pair of groupPairs) {
-            if (pair.threshold > minThreshold * 2) {
-                dead.push({
-                    pair: { prev_node: pair.prev_node, next_node: pair.next_node },
-                    reason: `Threshold ${pair.threshold} is much higher than competing minimum ${minThreshold}. Likely always loses.`,
-                    competing_with: groupPairs
-                        .filter((p) => p !== pair)
-                        .map((p) => p.next_node),
-                });
-            }
-        }
-    }
-    return dead;
-}
-function computeReachability(nodeNames, pairs) {
-    const adj = new Map();
-    for (const name of nodeNames)
-        adj.set(name, []);
-    for (const pair of pairs) {
-        if (pair.prev_node !== "") {
-            if (!adj.has(pair.prev_node))
-                adj.set(pair.prev_node, []);
-            adj.get(pair.prev_node).push(pair.next_node);
-        }
-    }
-    const reachability = new Map();
-    for (const start of nodeNames) {
-        const visited = new Set();
-        const queue = [start];
-        while (queue.length > 0) {
-            const u = queue.shift();
-            for (const v of adj.get(u) || []) {
-                if (!visited.has(v)) {
-                    visited.add(v);
-                    queue.push(v);
-                }
-            }
-        }
-        reachability.set(start, visited);
-    }
-    return reachability;
-}
-export function isReachableFromEntry(node, topology) {
-    for (const entry of topology.entry_nodes) {
-        if (entry === node)
-            return true;
-        if (topology.reachability.get(entry)?.has(node))
-            return true;
-    }
-    return false;
-}
-export function getNodesReachingTerminals(topology) {
-    const result = new Set();
-    for (const [node, reachable] of topology.reachability) {
-        for (const terminal of topology.terminal_nodes) {
-            if (reachable.has(terminal)) {
-                result.add(node);
-                break;
-            }
-        }
-    }
-    return result;
-}
-export function formatTopologySummary(topology) {
-    const lines = [
-        `Nodes: ${topology.node_count} (max 100)`,
-        `Pairs: ${topology.pair_count} (max 40)`,
-        `Forwards: ${topology.forward_count} (max 20 per Pair)`,
-        "",
-        `Entry nodes: ${topology.entry_nodes.join(", ") || "(none)"}`,
-        `Terminal nodes: ${topology.terminal_nodes.join(", ") || "(none)"}`,
-        `Orphaned nodes: ${topology.orphaned_nodes.join(", ") || "(none)"}`,
-        `Dead branches: ${topology.dead_branches.length}`,
-        `Cycles: ${topology.has_cycles ? "YES (❌ invalid DAG)" : "NO (✓ valid DAG)"}`,
-        "",
-        `Within on-chain limits: ${topology.within_limits.max_node_count &&
-            topology.within_limits.max_node_pair_count &&
-            topology.within_limits.max_forward_count &&
-            topology.within_limits.max_forward_order_count
-            ? "YES ✓"
-            : "NO ❌"}`,
-    ];
-    return lines.join("\n");
-}
-export function identifyTopologyPattern(pairs) {
-    const fromNode = new Map();
-    const toNode = new Map();
-    for (const p of pairs) {
-        if (!fromNode.has(p.prev_node))
-            fromNode.set(p.prev_node, []);
-        fromNode.get(p.prev_node).push(p.next_node);
-        if (!toNode.has(p.next_node))
-            toNode.set(p.next_node, []);
-        toNode.get(p.next_node).push(p.prev_node);
-    }
-    for (const [prev, nexts] of fromNode) {
-        if (nexts.length > 1 && prev !== "") {
-            return "P-M-COMPETING";
-        }
-    }
-    for (const [next, prevs] of toNode) {
-        if (prevs.length > 1) {
-            return "P-M-FORKMERGE";
-        }
-    }
-    return "P-M-LINEAR";
-}
-export const MACHINE_TOPOLOGY_VERSION = "1.0.0";
+import{MAX_NODE_COUNT,MAX_NODE_PAIR_COUNT,MAX_FORWARD_COUNT,MAX_FORWARD_ORDER_COUNT}from'./onchain-constants.js';export{MAX_NODE_COUNT,MAX_NODE_PAIR_COUNT,MAX_FORWARD_COUNT,MAX_FORWARD_ORDER_COUNT};export function analyzeTopology(a,b){const c=a['map'](s=>s['name']),d=new Set(c),e=new Map(),f=new Map();for(const s of c){e['set'](s,[]),f['set'](s,[]);}for(const t of b){!e['has'](t['prev_node'])&&t['prev_node']!==''&&e['set'](t['prev_node'],[]),!f['has'](t['next_node'])&&f['set'](t['next_node'],[]),t['prev_node']!==''&&e['get'](t['prev_node'])['push'](t['next_node']),f['get'](t['next_node'])['push'](t['prev_node']);}const g=b['filter'](u=>u['prev_node']==='')['map'](u=>u['next_node'])['filter'](u=>d['has'](u)),h=c['filter'](u=>(e['get'](u)||[])['length']===0x0),i=c['filter'](u=>!g['includes'](u)&&(f['get'](u)||[])['length']===0x0),j=c['filter'](u=>(e['get'](u)||[])['length']===0x0&&!h['includes'](u)),{has_cycles:k,cycle_nodes:l}=detectCycles(c,b),m=analyzeDeadBranches(b),n=computeReachability(c,b),o=b['reduce']((u,v)=>u+v['forwards']['length'],0x0),p=Math['max'](0x0,...b['map'](u=>u['forwards']['length'])),q=Math['max'](0x0,...b['flatMap'](u=>u['forwards']['map'](v=>countRetainedSubmissions(v['retained_submission'])))),r={'max_node_count':a['length']<=MAX_NODE_COUNT,'max_node_pair_count':b['length']<=MAX_NODE_PAIR_COUNT,'max_forward_count':p<=MAX_FORWARD_COUNT,'max_forward_order_count':q<=MAX_FORWARD_ORDER_COUNT};return{'entry_nodes':g,'terminal_nodes':h,'orphaned_nodes':i,'dead_end_nodes':j,'dead_branches':m,'has_cycles':k,'cycle_nodes':l,'reachability':n,'node_count':a['length'],'pair_count':b['length'],'forward_count':o,'within_limits':r};}function countRetainedSubmissions(a){if(a===undefined||a===null)return 0x0;if(Array['isArray'](a))return a['length'];if(typeof a==='string')return a['length']>0x0?0x1:0x0;return 0x0;}export function detectCycle(a,b){const c=a['map'](d=>d['name']);return detectCycles(c,b);}function detectCycles(a,b){const c=new Map();for(const k of a)c['set'](k,[]);for(const l of b){l['prev_node']!==''&&c['has'](l['prev_node'])&&c['get'](l['prev_node'])['push'](l['next_node']);}const d=0x0,e=0x1,f=0x2,g=new Map();for(const m of a)g['set'](m,d);const h=[],i=[];function j(n){g['set'](n,e),i['push'](n);for(const o of c['get'](n)||[]){if(g['get'](o)===e){const p=i['indexOf'](o);return h['push'](i['slice'](p)),!![];}if(g['get'](o)===d){if(j(o))return!![];}}return i['pop'](),g['set'](n,f),![];}for(const n of a){g['get'](n)===d&&j(n);}return{'has_cycles':h['length']>0x0,'cycle_nodes':h};}function analyzeDeadBranches(a){const b=[],c=new Map();for(const d of a){if(!c['has'](d['prev_node']))c['set'](d['prev_node'],[]);c['get'](d['prev_node'])['push'](d);}for(const [e,f]of c){if(f['length']<=0x1)continue;const g=Math['min'](...f['map'](h=>h['threshold']));for(const h of f){h['threshold']>g*0x2&&b['push']({'pair':{'prev_node':h['prev_node'],'next_node':h['next_node']},'reason':'Threshold\x20'+h['threshold']+'\x20is\x20much\x20higher\x20than\x20competing\x20minimum\x20'+g+'.\x20Likely\x20always\x20loses.','competing_with':f['filter'](i=>i!==h)['map'](i=>i['next_node'])});}}return b;}function computeReachability(a,b){const c=new Map();for(const e of a)c['set'](e,[]);for(const f of b){if(f['prev_node']!==''){if(!c['has'](f['prev_node']))c['set'](f['prev_node'],[]);c['get'](f['prev_node'])['push'](f['next_node']);}}const d=new Map();for(const g of a){const h=new Set(),i=[g];while(i['length']>0x0){const j=i['shift']();for(const k of c['get'](j)||[]){!h['has'](k)&&(h['add'](k),i['push'](k));}}d['set'](g,h);}return d;}export function isReachableFromEntry(a,b){for(const c of b['entry_nodes']){if(c===a)return!![];if(b['reachability']['get'](c)?.['has'](a))return!![];}return![];}export function getNodesReachingTerminals(a){const b=new Set();for(const [c,d]of a['reachability']){for(const e of a['terminal_nodes']){if(d['has'](e)){b['add'](c);break;}}}return b;}export function formatTopologySummary(a){const b=['Nodes:\x20'+a['node_count']+'\x20(max\x20100)','Pairs:\x20'+a['pair_count']+'\x20(max\x2040)','Forwards:\x20'+a['forward_count']+'\x20(max\x2020\x20per\x20Pair)','','Entry\x20nodes:\x20'+(a['entry_nodes']['join'](',\x20')||'(none)'),'Terminal\x20nodes:\x20'+(a['terminal_nodes']['join'](',\x20')||'(none)'),'Orphaned\x20nodes:\x20'+(a['orphaned_nodes']['join'](',\x20')||'(none)'),'Dead\x20branches:\x20'+a['dead_branches']['length'],'Cycles:\x20'+(a['has_cycles']?'YES\x20(❌\x20invalid\x20DAG)':'NO\x20(✓\x20valid\x20DAG)'),'','Within\x20on-chain\x20limits:\x20'+(a['within_limits']['max_node_count']&&a['within_limits']['max_node_pair_count']&&a['within_limits']['max_forward_count']&&a['within_limits']['max_forward_order_count']?'YES\x20✓':'NO\x20❌')];return b['join']('\x0a');}export function identifyTopologyPattern(a){const b=new Map(),c=new Map();for(const d of a){if(!b['has'](d['prev_node']))b['set'](d['prev_node'],[]);b['get'](d['prev_node'])['push'](d['next_node']);if(!c['has'](d['next_node']))c['set'](d['next_node'],[]);c['get'](d['next_node'])['push'](d['prev_node']);}for(const [e,f]of b){if(f['length']>0x1&&e!=='')return'P-M-COMPETING';}for(const [g,h]of c){if(h['length']>0x1)return'P-M-FORKMERGE';}return'P-M-LINEAR';}export const MACHINE_TOPOLOGY_VERSION='1.0.0';