wowok_agent 1.6.6 → 2.1.8

package/dist/schema/utils/node-parser.js

@@ -0,0 +1,382 @@
+import { NodeSchema } from '../call/machine.js';
+import { MachineNodeSchema } from '../query/index.js';
+import { writeFileSync } from 'fs';
+function detectFormat(text) {
+    const trimmed = text.trim();
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        return 'json';
+    }
+    return 'markdown';
+}
+function extractJsonFromMarkdown(markdown) {
+    const codeBlockRegex = /```(?:json)?\s*\n([\s\S]*?)```/g;
+    let match;
+    let lastMatch = null;
+    while ((match = codeBlockRegex.exec(markdown)) !== null) {
+        const jsonContent = match[1].trim();
+        if (jsonContent.startsWith('[') || jsonContent.startsWith('{')) {
+            const beforeMatch = markdown.substring(0, match.index);
+            const lineOffset = (beforeMatch.match(/\n/g) || []).length + 1;
+            lastMatch = { json: jsonContent, lineOffset };
+        }
+    }
+    return lastMatch;
+}
+function parseMarkdownToNodeData(markdown) {
+    const errors = [];
+    // Try to extract JSON from markdown code block first
+    const jsonMatch = extractJsonFromMarkdown(markdown);
+    if (jsonMatch) {
+        try {
+            const data = JSON.parse(jsonMatch.json);
+            return { data, errors: [] };
+        }
+        catch (e) {
+            errors.push({
+                message: `Failed to parse JSON from markdown: ${e.message}`,
+                path: '/',
+            });
+            return { data: null, errors };
+        }
+    }
+    // Parse markdown structure
+    const result = { op: 'add' };
+    const nodes = [];
+    // Parse operation type
+    const opMatch = markdown.match(/(?:^|\n)#+\s*(?:Operation|操作类型)[^\n]*\n+[-*]\s*op\s*:\s*(\w+)/i);
+    if (opMatch) {
+        result.op = opMatch[1].toLowerCase();
+    }
+    // Parse bReplace option
+    const replaceMatch = markdown.match(/(?:^|\n)#+\s*(?:Options|选项)[^\n]*\n+[-*]\s*bReplace\s*:\s*(true|false)/i);
+    if (replaceMatch) {
+        result.bReplace = replaceMatch[1].toLowerCase() === 'true';
+    }
+    // Parse node sections - match "## Node: name" format
+    const nodeSections = markdown.split(/(?=^##\s*(?:Node|节点)[:\s])/m);
+    for (const section of nodeSections.slice(1)) {
+        const nodeNameMatch = section.match(/^##\s*(?:Node|节点)[:\s]+(.+?)(?:\n|$)/im);
+        if (!nodeNameMatch)
+            continue;
+        const nodeName = nodeNameMatch[1].trim();
+        const node = { name: nodeName, pairs: [] };
+        // Parse pair sections - match "### Pair: prev_node" format
+        const pairSections = section.split(/(?=^###\s*(?:Pair|节点对|Previous Node)[:\s])/m);
+        for (const pairSection of pairSections.slice(1)) {
+            // Support both "prev_node: value" and "Previous Node: value" formats
+            const prevNodeMatch = pairSection.match(/(?:^|\n)[-*]\s*prev_node\s*[:：]\s*(.+?)(?:\n|$)/im) ||
+                pairSection.match(/^###\s*(?:Pair|节点对|Previous Node)[:\s]+(.+?)(?:\n|$)/im);
+            const thresholdMatch = pairSection.match(/(?:^|\n)[-*]\s*threshold\s*[:：]\s*(\d+)/i);
+            if (!prevNodeMatch)
+                continue;
+            const pair = {
+                prev_node: prevNodeMatch[1].trim(),
+                threshold: thresholdMatch ? parseInt(thresholdMatch[1], 10) : 0,
+                forwards: []
+            };
+            // Parse forwards from table format
+            const tableRows = pairSection.match(/\|[^\n]+\|/g);
+            if (tableRows && tableRows.length > 2) {
+                // Skip header and separator rows
+                for (const row of tableRows.slice(2)) {
+                    const cells = row.split('|').filter(c => c.trim()).map(c => c.trim());
+                    if (cells.length >= 2) {
+                        const forward = {
+                            name: cells[0],
+                            weight: parseInt(cells[1], 10) || 0
+                        };
+                        if (cells.length >= 3 && cells[2] && cells[2] !== '-') {
+                            forward.namedOperator = cells[2];
+                        }
+                        if (cells.length >= 4 && cells[3] && cells[3] !== '-') {
+                            forward.permissionIndex = parseInt(cells[3], 10);
+                        }
+                        if (cells.length >= 5 && cells[4] && cells[4] !== '-') {
+                            forward.guard = cells[4];
+                        }
+                        pair.forwards.push(forward);
+                    }
+                }
+            }
+            // Also parse forwards from list format
+            const forwardMatches = pairSection.matchAll(/(?:^|\n)[-*]\s*(?:forward)?\s*[:：]?\s*\n?([\s\S]*?)(?=(?:\n[-*]\s*(?:forward|prev_node|threshold))|\n###|\n##|$)/gi);
+            for (const forwardMatch of forwardMatches) {
+                const forwardSection = forwardMatch[1];
+                const nameMatch = forwardSection.match(/\s*name\s*[:：]\s*(.+?)(?:\n|$)/im);
+                const weightMatch = forwardSection.match(/\s*weight\s*[:：]\s*(\d+)/i);
+                if (nameMatch && weightMatch) {
+                    const forward = {
+                        name: nameMatch[1].trim(),
+                        weight: parseInt(weightMatch[1], 10)
+                    };
+                    const namedOperatorMatch = forwardSection.match(/\s*namedOperator\s*[:：]\s*(.+?)(?:\n|$)/im);
+                    const permissionIndexMatch = forwardSection.match(/\s*permissionIndex\s*[:：]\s*(\d+)/i);
+                    const guardMatch = forwardSection.match(/\s*guard\s*[:：]\s*(.+?)(?:\n|$)/im);
+                    if (namedOperatorMatch) {
+                        forward.namedOperator = namedOperatorMatch[1].trim();
+                    }
+                    if (permissionIndexMatch) {
+                        forward.permissionIndex = parseInt(permissionIndexMatch[1], 10);
+                    }
+                    if (guardMatch) {
+                        forward.guard = guardMatch[1].trim();
+                    }
+                    pair.forwards.push(forward);
+                }
+            }
+            node.pairs.push(pair);
+        }
+        nodes.push(node);
+    }
+    if (nodes.length > 0) {
+        result.nodes = nodes;
+    }
+    return { data: result, errors };
+}
+function formatZodPath(path) {
+    return '/' + path.map(p => String(p).replace(/~/g, '~0').replace(/\//g, '~1')).join('/');
+}
+function parseJsonWithErrors(text) {
+    const errors = [];
+    try {
+        const data = JSON.parse(text);
+        return { data, errors: [] };
+    }
+    catch (e) {
+        const jsonError = e;
+        const lineMatch = jsonError.message.match(/position\s+(\d+)/);
+        let line = 1;
+        let column = 1;
+        if (lineMatch) {
+            const pos = parseInt(lineMatch[1], 10);
+            const lines = text.substring(0, pos).split('\n');
+            line = lines.length;
+            column = lines[lines.length - 1].length + 1;
+        }
+        errors.push({
+            message: `JSON parse error: ${jsonError.message}`,
+            path: '/',
+            line,
+            column,
+        });
+        return { data: null, errors };
+    }
+}
+function validateWithZod(schema, data, basePath = '') {
+    const errors = [];
+    const result = schema.safeParse(data);
+    if (result.success) {
+        return { success: true, data: result.data, errors: [] };
+    }
+    for (const issue of result.error.issues) {
+        const path = basePath + formatZodPath(issue.path);
+        errors.push({
+            message: issue.message,
+            path,
+        });
+    }
+    return { success: false, errors };
+}
+export function parseNodeFromText(text) {
+    const trimmed = text.trim();
+    const format = detectFormat(trimmed);
+    let parsedData;
+    let errors = [];
+    if (format === 'markdown') {
+        const mdResult = parseMarkdownToNodeData(trimmed);
+        if (mdResult.errors.length > 0) {
+            return { success: false, errors: mdResult.errors };
+        }
+        parsedData = mdResult.data;
+    }
+    else {
+        const jsonResult = parseJsonWithErrors(trimmed);
+        if (jsonResult.errors.length > 0) {
+            return { success: false, errors: jsonResult.errors };
+        }
+        parsedData = jsonResult.data;
+    }
+    const validation = validateWithZod(NodeSchema, parsedData);
+    return {
+        success: validation.success,
+        data: validation.data,
+        errors: validation.errors,
+    };
+}
+export function parseMachineNodesFromText(text) {
+    const trimmed = text.trim();
+    const format = detectFormat(trimmed);
+    let parsedData;
+    let errors = [];
+    if (format === 'markdown') {
+        const mdResult = parseMarkdownToNodeData(trimmed);
+        if (mdResult.errors.length > 0) {
+            return { success: false, errors: mdResult.errors };
+        }
+        // If markdown contains { nodes: [...] }, extract nodes array
+        if (typeof mdResult.data === 'object' && mdResult.data !== null && 'nodes' in mdResult.data) {
+            parsedData = mdResult.data.nodes;
+        }
+        else {
+            parsedData = mdResult.data;
+        }
+    }
+    else {
+        const jsonResult = parseJsonWithErrors(trimmed);
+        if (jsonResult.errors.length > 0) {
+            return { success: false, errors: jsonResult.errors };
+        }
+        parsedData = jsonResult.data;
+    }
+    // Validate that parsedData is an array
+    if (!Array.isArray(parsedData)) {
+        if (typeof parsedData === 'object' && parsedData !== null && 'op' in parsedData) {
+            return {
+                success: false,
+                errors: [{
+                        message: 'Expected JSON array of nodes for json_or_markdown mode. Use schema mode for operations with "op" field.',
+                        path: '/',
+                    }]
+            };
+        }
+        return {
+            success: false,
+            errors: [{
+                    message: 'Expected JSON array of nodes',
+                    path: '/',
+                }]
+        };
+    }
+    // Validate each node
+    const nodes = [];
+    for (let i = 0; i < parsedData.length; i++) {
+        const nodeData = parsedData[i];
+        const validation = validateWithZod(MachineNodeSchema, nodeData, `/${i}`);
+        if (validation.success && validation.data) {
+            nodes.push(validation.data);
+        }
+        else {
+            errors.push(...validation.errors);
+        }
+    }
+    if (errors.length > 0) {
+        return { success: false, errors };
+    }
+    return { success: true, data: nodes, errors: [] };
+}
+export function formatNodeErrors(errors) {
+    return errors.map(e => {
+        let msg = `Path: ${e.path}`;
+        if (e.line !== undefined && e.column !== undefined) {
+            msg += ` (line ${e.line}, column ${e.column})`;
+        }
+        msg += `\n  Error: ${e.message}`;
+        return msg;
+    }).join('\n\n');
+}
+export function validateMachineNode(node) {
+    return validateWithZod(MachineNodeSchema, node);
+}
+export function validateMachineNodePair(pair) {
+    const result = MachineNodeSchema.shape.pairs.element.safeParse(pair);
+    if (result.success) {
+        return { success: true, errors: [] };
+    }
+    const errors = result.error.issues.map(issue => ({
+        message: issue.message,
+        path: formatZodPath(issue.path),
+    }));
+    return { success: false, errors };
+}
+export function validateMachineForward(forward) {
+    const result = MachineNodeSchema.shape.pairs.element.shape.forwards.element.safeParse(forward);
+    if (result.success) {
+        return { success: true, errors: [] };
+    }
+    const errors = result.error.issues.map(issue => ({
+        message: issue.message,
+        path: formatZodPath(issue.path),
+    }));
+    return { success: false, errors };
+}
+/**
+ * 将 MachineNode 数组生成为 JSON 格式字符串
+ */
+export function machineNodesToJson(nodes, options = {}) {
+    const { machineId, includeComments = true } = options;
+    let result = '';
+    if (includeComments && machineId) {
+        result += `// Machine ID: ${machineId}\n`;
+    }
+    result += JSON.stringify(nodes, null, 2);
+    return result;
+}
+/**
+ * 将 MachineNode 数组生成为 Markdown 格式字符串
+ * 生成的格式与 parseMarkdownToNodeData 解析的格式匹配
+ */
+export function machineNodesToMarkdown(nodes, options = {}) {
+    const { machineName, machineAddress, machineId, includeComments = true } = options;
+    let md = `# Machine Node Definition\n\n`;
+    if (machineName) {
+        md += `**Machine:** ${machineName}\n\n`;
+    }
+    if (machineAddress) {
+        md += `**Address:** ${machineAddress}\n\n`;
+    }
+    if (machineId) {
+        md += `**ID:** ${machineId}\n\n`;
+    }
+    md += `**Total Nodes:** ${nodes.length}\n\n`;
+    md += `---\n\n`;
+    for (const node of nodes) {
+        md += `## Node: ${node.name}\n\n`;
+        if (includeComments) {
+            md += `<!-- Node definition with pairs and forwards -->\n\n`;
+        }
+        for (const pair of node.pairs) {
+            md += `### Pair: ${pair.prev_node}\n\n`;
+            md += `- **prev_node**: ${pair.prev_node}\n`;
+            md += `- **threshold**: ${pair.threshold}\n\n`;
+            if (pair.forwards && pair.forwards.length > 0) {
+                md += `#### Forwards\n\n`;
+                // 使用表格格式展示 forwards
+                md += `| name | weight | namedOperator | permissionIndex | guard |\n`;
+                md += `|------|--------|---------------|-----------------|-------|\n`;
+                for (const forward of pair.forwards) {
+                    const namedOp = forward.namedOperator || '';
+                    const permIdx = forward.permissionIndex?.toString() || '';
+                    const guard = forward.guard?.guard || '';
+                    md += `| ${forward.name} | ${forward.weight} | ${namedOp} | ${permIdx} | ${guard} |\n`;
+                }
+                md += `\n`;
+            }
+        }
+        md += `---\n\n`;
+    }
+    // 在末尾添加 JSON 代码块（便于复制和解析）
+    md += `## JSON Definition\n\n`;
+    if (includeComments) {
+        md += `<!-- You can also use the JSON format below -->\n\n`;
+    }
+    md += `\`\`\`json\n`;
+    if (includeComments && machineId) {
+        md += `// Machine ID: ${machineId}\n`;
+    }
+    md += JSON.stringify(nodes, null, 2);
+    md += `\n\`\`\`\n`;
+    return md;
+}
+/**
+ * 将 MachineNode 数组保存到文件
+ * @param nodes - MachineNode 数组
+ * @param filePath - 文件路径
+ * @param format - 文件格式：'json' 或 'markdown'
+ * @param options - 可选配置
+ */
+export function saveMachineNodesToFile(nodes, filePath, format = 'json', options = {}) {
+    const content = format === 'json'
+        ? machineNodesToJson(nodes, options)
+        : machineNodesToMarkdown(nodes, options);
+    writeFileSync(filePath, content, 'utf-8');
+}

package/dist/schema/utils/permission-index-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const getValidBuiltinPermissionIndexes: () => Set<number>;
+export declare const isValidPermissionIndex: (index: number) => boolean;

package/dist/schema/utils/permission-index-utils.js

@@ -0,0 +1,10 @@
+// 使用npm link的wowok包
+import { BuiltinPermissionIndex } from "wowok";
+// 提取所有有效的内置权限索引值并存储在 Set 中（查询更快）
+export const getValidBuiltinPermissionIndexes = () => {
+    return new Set(Object.values(BuiltinPermissionIndex).filter(value => typeof value === 'number'));
+};
+// 验证权限索引是否有效
+export const isValidPermissionIndex = (index) => {
+    return getValidBuiltinPermissionIndexes().has(index) || (index >= 1000 && index <= 65535);
+};

package/package.json

@@ -1,65 +1,47 @@
 {
   "name": "wowok_agent",
-  "version": "1.6.6",
-  "description": "Agent for WoWok: Unlock Co-Creation, Lighting Transaction, Empower Potential.",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "version": "2.1.8",
+  "description": "Making It Easy for Agents to Communicate, Collaborate, Trade, and Trust.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "module": "node",
   "type": "module",
   "scripts": {
+    "clean": "rm -rf dist",
     "build": "tsc",
-    "build2": "tsc && webpack --mode production"
+    "watch": "tsc --watch",
+    "start": "tsx src/index.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "wowok_agent": "dist/index.js"
   },
   "keywords": [
     "web3",
     "AI",
     "wowok",
-    "sui",
-    "collaboration",
-    "protocol",
-    "WOW",
-    "permission",
-    "guard",
-    "service",
-    "order",
-    "machine",
-    "progress",
-    "passport",
-    "demand",
-    "reward",
-    "discount",
-    "mark",
-    "message",
-    "vote",
-    "tags",
-    "entity",
-    "resource",
-    "grantor",
-    "grantee",
-    "move language",
-    "move",
-    "treasury",
-    "payment",
-    "arbitration",
-    "oracle",
-    "AI agent tool"
+    "wow",
+    "blockchain",
+    "mcp server",
+    "personal",
+    "merchant",
+    "finance",
+    "watch",
+    "messenger"
   ],
-  "author": "wowok",
+  "author": "wowok <build@wowok.net>",
   "license": "Apache-2.0",
-  "devDependencies": {
-    "@types/node": "^20.12.12",
-    "@types/node-rsa": "^1.1.4",
-    "ts-loader": "^9.5.2",
-    "typescript": "^5.8.2"
-  },
   "dependencies": {
-    "level": "^9.0.0",
-    "node-rsa": "^1.1.1",
-    "wowok": "^1.8.3",
-    "zod": "^3.25.57",
-    "zod-to-json-schema": "^3.24.6"
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "lodash": "^4.18.1",
+    "wowok": "file:d:/wowok/wchain/sdk/ts-sdks/packages/typescript",
+    "zod": "^3.25.76"
   },
-  "files": [
-    "dist"
-  ]
+  "devDependencies": {
+    "@types/node": "^22.7.5",
+    "tsx": "^4.21.0",
+    "typescript": "^5.8.2"
+  }
 }