@wowok/agent-mcp 2.3.13 → 2.3.16

package/dist/knowledge/acquisition-flywheel.d.ts

@@ -0,0 +1,50 @@
+export interface FlywheelAction {
+    action: string;
+    purpose: string;
+    mutableField: string;
+    metricToWatch: string;
+}
+export interface AcquisitionFlywheel {
+    industry: string;
+    trustSellingPoints: string[];
+    keyActions: FlywheelAction[];
+    rewardStrategy: string;
+    discountStrategy: string;
+    trustDescription: string;
+}
+export interface TrustDescriptionParams {
+    industry?: string;
+    orderCount?: number;
+    completedRate?: number;
+    avgCompletionTime?: number;
+    hasCompensationFund?: boolean;
+    hasArbitration?: boolean;
+    reviewLikeRate?: number;
+    reviewCount?: number;
+}
+export declare const ACQUISITION_FLYWHEEL_VERSION = 1;
+export declare const INDUSTRY_FLYWHEELS: AcquisitionFlywheel[];
+export declare function getFlywheelForIndustry(industry: string): AcquisitionFlywheel | undefined;
+export declare function listIndustries(): string[];
+export declare function suggestAcquisitionActions(industry: string): FlywheelAction[];
+export declare function generateTrustDescription(params: TrustDescriptionParams): string;
+export interface AcquisitionDashboard {
+    metrics: {
+        orderCount: number;
+        completedRate: number;
+        avgCompletionTime?: number;
+        repeatCustomerRate?: number;
+        reviewLikeRate?: number;
+        reviewCount?: number;
+    };
+    suggestions: string[];
+    flywheelStage: "cold_start" | "growing" | "mature" | "optimization";
+}
+export declare function buildAcquisitionDashboard(params: {
+    orderCount: number;
+    completedRate?: number;
+    avgCompletionTime?: number;
+    repeatCustomerRate?: number;
+    reviewLikeRate?: number;
+    reviewCount?: number;
+}): AcquisitionDashboard;

package/dist/knowledge/acquisition-flywheel.js

@@ -0,0 +1,183 @@
+export const ACQUISITION_FLYWHEEL_VERSION = 1;
+export const INDUSTRY_FLYWHEELS = [
+    {
+        industry: "freelance",
+        trustSellingPoints: [
+            "交付验收 + 资金托管 + 仲裁保障",
+            "流程透明：Machine 定义清晰的交付节点",
+            "compensation_fund 资金安全保障客户权益",
+        ],
+        keyActions: [
+            { action: "设置 Reward 首单奖励", purpose: "吸引新客户下单", mutableField: "rewards", metricToWatch: "新客下单率" },
+            { action: "累计金额阶梯 Reward", purpose: "激励复购", mutableField: "rewards", metricToWatch: "复购率" },
+            { action: "调整 Machine 节点", purpose: "优化交付流程速度", mutableField: "description", metricToWatch: "平均完成时间" },
+            { action: "增加 compensation_fund", purpose: "提升信任分", mutableField: "compensation_fund", metricToWatch: "信任分" },
+        ],
+        rewardStrategy: "首单奖励 + 累计金额阶梯（如满 5 单送折扣）",
+        discountStrategy: "包月折扣 + 长期合作优惠",
+        trustDescription: "资金托管 + 交付验收 + 仲裁保障",
+    },
+    {
+        industry: "rental",
+        trustSellingPoints: [
+            "押金托管 + 损伤 Guard + 退还流程",
+            "Guard 验证物品状况，防纠纷",
+            "compensation_fund 覆盖损坏风险",
+        ],
+        keyActions: [
+            { action: "设置 Discount 长租优惠", purpose: "激励长期租赁", mutableField: "discount", metricToWatch: "长租比例" },
+            { action: "信用累计 Reward", purpose: "多次租赁信用积累", mutableField: "rewards", metricToWatch: "复租率" },
+            { action: "配置损伤 Guard", purpose: "降低纠纷率", mutableField: "buy_guard", metricToWatch: "纠纷率" },
+            { action: "增加 compensation_fund", purpose: "覆盖损坏风险", mutableField: "compensation_fund", metricToWatch: "信任分" },
+        ],
+        rewardStrategy: "信用累计 + 长租折扣 + 推荐返现",
+        discountStrategy: "月租 9 折 + 季租 8 折 + 年租 7 折",
+        trustDescription: "押金托管 + Guard 验证 + 退还保障",
+    },
+    {
+        industry: "education",
+        trustSellingPoints: [
+            "课程进度透明 + 退款 Guard",
+            "Machine 定义学习阶段和验收节点",
+        ],
+        keyActions: [
+            { action: "设置里程碑 Reward", purpose: "激励完成课程", mutableField: "rewards", metricToWatch: "完课率" },
+            { action: "推荐返现 Reward", purpose: "裂变获客", mutableField: "rewards", metricToWatch: "推荐率" },
+        ],
+        rewardStrategy: "里程碑奖励 + 推荐返现 + 试听折扣",
+        discountStrategy: "早鸟价 + 团购价 + 助学折扣",
+        trustDescription: "进度透明 + 退款保障 + 验收节点",
+    },
+    {
+        industry: "travel",
+        trustSellingPoints: [
+            "行程托管 + 取消 Guard + 仲裁保障",
+            "Guard 验证行程变更条件",
+        ],
+        keyActions: [
+            { action: "限时闪购 Reward", purpose: "清仓促销", mutableField: "rewards", metricToWatch: "转化率" },
+            { action: "消费返现 Reward", purpose: "提升复购", mutableField: "rewards", metricToWatch: "复购率" },
+        ],
+        rewardStrategy: "限时闪购 + 消费返现 + 推荐返佣",
+        discountStrategy: "早鸟价 + 拼团价 + 会员价",
+        trustDescription: "行程托管 + 取消保障 + 仲裁",
+    },
+    {
+        industry: "subscription",
+        trustSellingPoints: [
+            "订阅透明 + 自动续费 Guard + 随时取消",
+            "Machine 定义计费周期和自动扣款",
+        ],
+        keyActions: [
+            { action: "忠诚度 Reward", purpose: "长期留存", mutableField: "rewards", metricToWatch: "续费率" },
+            { action: "推荐返现 Reward", purpose: "裂变获客", mutableField: "rewards", metricToWatch: "推荐率" },
+        ],
+        rewardStrategy: "忠诚度奖励 + 推荐返现 + 首月折扣",
+        discountStrategy: "年付折扣 + 团队折扣 + 升级折扣",
+        trustDescription: "订阅透明 + 续费保障 + 随时取消",
+    },
+    {
+        industry: "retail",
+        trustSellingPoints: [
+            "交易托管 + 物流 Guard + 退款保障",
+            "Guard 验证发货和收货",
+        ],
+        keyActions: [
+            { action: "首单折扣", purpose: "吸引新客", mutableField: "discount", metricToWatch: "新客下单率" },
+            { action: "消费返现 Reward", purpose: "提升复购", mutableField: "rewards", metricToWatch: "复购率" },
+        ],
+        rewardStrategy: "首单折扣 + 消费返现 + 满减",
+        discountStrategy: "满减 + 限时折扣 + 会员价",
+        trustDescription: "交易托管 + 物流 Guard + 退款保障",
+    },
+];
+export function getFlywheelForIndustry(industry) {
+    return INDUSTRY_FLYWHEELS.find((f) => f.industry === industry.toLowerCase());
+}
+export function listIndustries() {
+    return INDUSTRY_FLYWHEELS.map((f) => f.industry);
+}
+export function suggestAcquisitionActions(industry) {
+    const flywheel = getFlywheelForIndustry(industry);
+    return flywheel?.keyActions ?? [];
+}
+export function generateTrustDescription(params) {
+    const parts = [];
+    if (params.industry) {
+        const flywheel = getFlywheelForIndustry(params.industry);
+        if (flywheel) {
+            parts.push(flywheel.trustDescription);
+        }
+    }
+    if (params.orderCount !== undefined && params.orderCount > 0) {
+        parts.push(`已完成 ${params.orderCount} 单`);
+    }
+    if (params.completedRate !== undefined) {
+        parts.push(`完成率 ${Math.round(params.completedRate * 100)}%`);
+    }
+    if (params.avgCompletionTime !== undefined) {
+        if (params.avgCompletionTime < 1) {
+            parts.push(`平均完成时间 ${Math.round(params.avgCompletionTime * 60)} 分钟`);
+        }
+        else {
+            parts.push(`平均完成时间 ${Math.round(params.avgCompletionTime)} 小时`);
+        }
+    }
+    if (params.hasCompensationFund) {
+        parts.push("赔偿金充足");
+    }
+    if (params.hasArbitration) {
+        parts.push("第三方仲裁保障");
+    }
+    if (params.reviewCount !== undefined && params.reviewCount > 0 && params.reviewLikeRate !== undefined) {
+        parts.push(`好评率 ${Math.round(params.reviewLikeRate * 100)}% (${params.reviewCount} 条评价)`);
+    }
+    return parts.join("；") || "暂无信任数据";
+}
+export function buildAcquisitionDashboard(params) {
+    const { orderCount, completedRate, avgCompletionTime, repeatCustomerRate, reviewLikeRate, reviewCount } = params;
+    let stage = "cold_start";
+    if (orderCount >= 50)
+        stage = "optimization";
+    else if (orderCount >= 20)
+        stage = "mature";
+    else if (orderCount >= 5)
+        stage = "growing";
+    const suggestions = [];
+    if (stage === "cold_start") {
+        suggestions.push("冷启动阶段：设置首单 Reward 吸引新客户");
+        suggestions.push("增加 compensation_fund 提升初始信任");
+    }
+    else if (stage === "growing") {
+        suggestions.push("成长阶段：设置推荐返现 Reward 裂变获客");
+        if (repeatCustomerRate !== undefined && repeatCustomerRate < 0.2) {
+            suggestions.push("复购率偏低，考虑设置累计金额阶梯 Reward");
+        }
+    }
+    else if (stage === "mature") {
+        if (reviewLikeRate !== undefined && reviewLikeRate > 0.8) {
+            suggestions.push("好评率高，可在 description 中突出信任指标");
+        }
+        if (repeatCustomerRate !== undefined && repeatCustomerRate > 0.3) {
+            suggestions.push("复购率高，考虑设置忠诚度 Reward 激励长期客户");
+        }
+    }
+    else {
+        suggestions.push("优化阶段：精细化调整定价和 Reward 策略");
+        if (avgCompletionTime !== undefined && avgCompletionTime > 48) {
+            suggestions.push("完成时间偏长，考虑优化 Machine 流程");
+        }
+    }
+    return {
+        metrics: {
+            orderCount,
+            completedRate: completedRate ?? 0,
+            avgCompletionTime,
+            repeatCustomerRate,
+            reviewLikeRate,
+            reviewCount,
+        },
+        suggestions,
+        flywheelStage: stage,
+    };
+}

package/dist/knowledge/arbitration-trust.d.ts

@@ -0,0 +1,24 @@
+export interface ArbMetrics {
+    totalCases: number;
+    timelyResolutions: number;
+    acceptedVerdicts: number;
+    disputedVerdicts: number;
+    avgResponseHours: number;
+    compensationLocked?: bigint;
+    hasVerifiedIdentity: boolean;
+}
+export interface TrustScore {
+    score: number;
+    components: TrustComponent[];
+    level: "high_risk" | "caution" | "moderate" | "trusted";
+    warnings: string[];
+}
+export interface TrustComponent {
+    name: string;
+    maxPoints: number;
+    earnedPoints: number;
+    reason: string;
+}
+export declare function computeTrustScore(metrics: ArbMetrics): TrustScore;
+export declare function quickRiskAssessment(score: number): string;
+export declare const ARBITRATION_TRUST_VERSION = 1;

package/dist/knowledge/arbitration-trust.js

@@ -0,0 +1,117 @@
+const WEIGHTS = {
+    acceptanceRate: 35,
+    timeliness: 20,
+    volume: 15,
+    responseSpeed: 10,
+    compensation: 10,
+    identity: 10,
+};
+export function computeTrustScore(metrics) {
+    const components = [];
+    const acceptanceRate = metrics.totalCases > 0
+        ? metrics.acceptedVerdicts / metrics.totalCases
+        : 0;
+    const acceptancePoints = Math.round(acceptanceRate * WEIGHTS.acceptanceRate);
+    components.push({
+        name: "verdict_acceptance",
+        maxPoints: WEIGHTS.acceptanceRate,
+        earnedPoints: acceptancePoints,
+        reason: `${metrics.acceptedVerdicts}/${metrics.totalCases} verdicts accepted without dispute`,
+    });
+    const timelyRate = metrics.totalCases > 0
+        ? metrics.timelyResolutions / metrics.totalCases
+        : 0;
+    const timelyPoints = Math.round(timelyRate * WEIGHTS.timeliness);
+    components.push({
+        name: "timeliness",
+        maxPoints: WEIGHTS.timeliness,
+        earnedPoints: timelyPoints,
+        reason: `${metrics.timelyResolutions}/${metrics.totalCases} cases resolved in time`,
+    });
+    const volumePoints = Math.min(WEIGHTS.volume, Math.round((metrics.totalCases / 20) * WEIGHTS.volume));
+    components.push({
+        name: "case_volume",
+        maxPoints: WEIGHTS.volume,
+        earnedPoints: volumePoints,
+        reason: `${metrics.totalCases} total cases handled`,
+    });
+    let responsePoints = 0;
+    if (metrics.avgResponseHours <= 1)
+        responsePoints = 10;
+    else if (metrics.avgResponseHours <= 6)
+        responsePoints = 7;
+    else if (metrics.avgResponseHours <= 24)
+        responsePoints = 5;
+    else if (metrics.avgResponseHours <= 72)
+        responsePoints = 3;
+    components.push({
+        name: "response_speed",
+        maxPoints: WEIGHTS.responseSpeed,
+        earnedPoints: responsePoints,
+        reason: `Average response: ${metrics.avgResponseHours}h`,
+    });
+    const compPoints = (metrics.compensationLocked !== undefined && metrics.compensationLocked > 0n)
+        ? WEIGHTS.compensation
+        : 0;
+    components.push({
+        name: "compensation_fund",
+        maxPoints: WEIGHTS.compensation,
+        earnedPoints: compPoints,
+        reason: metrics.compensationLocked
+            ? `Compensation fund: ${metrics.compensationLocked} smallest unit`
+            : "No compensation fund locked",
+    });
+    const identityPoints = metrics.hasVerifiedIdentity ? WEIGHTS.identity : 0;
+    components.push({
+        name: "verified_identity",
+        maxPoints: WEIGHTS.identity,
+        earnedPoints: identityPoints,
+        reason: metrics.hasVerifiedIdentity
+            ? "Has verified on-chain Personal identity"
+            : "No verified on-chain identity",
+    });
+    const score = components.reduce((sum, c) => sum + c.earnedPoints, 0);
+    const level = scoreLevel(score);
+    const warnings = buildWarnings(score, metrics, components);
+    return { score, components, level, warnings };
+}
+function scoreLevel(score) {
+    if (score < 25)
+        return "high_risk";
+    if (score < 50)
+        return "caution";
+    if (score < 75)
+        return "moderate";
+    return "trusted";
+}
+function buildWarnings(score, metrics, components) {
+    const warnings = [];
+    if (score < 50) {
+        warnings.push(`仲裁员信任分较低 (${score}/100, ${scoreLevel(score)})。` +
+            `建议客户谨慎选择此仲裁员。数据使用权在用户，系统不阻止使用。`);
+    }
+    if (metrics.disputedVerdicts > 0 && metrics.totalCases > 0) {
+        const disputeRate = metrics.disputedVerdicts / metrics.totalCases;
+        if (disputeRate > 0.3) {
+            warnings.push(`争议率较高 (${(disputeRate * 100).toFixed(1)}%)：` +
+                `${metrics.disputedVerdicts}/${metrics.totalCases} 案件出现争议。`);
+        }
+    }
+    if (!metrics.hasVerifiedIdentity) {
+        warnings.push("仲裁员未验证链上身份（无 Personal 对象），建议核实其真实性。");
+    }
+    if (metrics.avgResponseHours > 72) {
+        warnings.push(`仲裁员平均响应时间较长 (${metrics.avgResponseHours}h)，可能影响纠纷解决效率。`);
+    }
+    return warnings;
+}
+export function quickRiskAssessment(score) {
+    const level = scoreLevel(score);
+    switch (level) {
+        case "high_risk": return "高风险：建议更换仲裁员或增加补偿金保障";
+        case "caution": return "注意：信任分偏低，建议谨慎评估";
+        case "moderate": return "中等信任：可接受，建议持续观察";
+        case "trusted": return "高信任：仲裁员表现良好";
+    }
+}
+export const ARBITRATION_TRUST_VERSION = 1;

package/dist/knowledge/audit-rules.d.ts

@@ -0,0 +1,28 @@
+export type AuditSeverity = "error" | "warning" | "info";
+export interface AuditFinding {
+    rule_id: string;
+    severity: AuditSeverity;
+    field?: string;
+    message: string;
+    recommendation?: string;
+}
+export interface AuditRule {
+    id: string;
+    description: string;
+    severity: AuditSeverity;
+    check: (data: any, context?: AuditContext) => boolean;
+    message: (data: any) => string;
+    recommendation?: string;
+}
+export interface AuditContext {
+    graph?: any;
+    hasName?: boolean;
+    userConfirmed?: boolean;
+}
+export declare const AUDIT_RULES: AuditRule[];
+export declare function auditService(data: any, context?: AuditContext): AuditFinding[];
+export declare function hasBlockingErrors(findings: AuditFinding[]): boolean;
+export declare function getErrors(findings: AuditFinding[]): AuditFinding[];
+export declare function getWarnings(findings: AuditFinding[]): AuditFinding[];
+export declare function summarizeFindings(findings: AuditFinding[]): string;
+export declare const AUDIT_RULES_VERSION = 1;

package/dist/knowledge/audit-rules.js

@@ -0,0 +1,141 @@
+export const AUDIT_RULES = [
+    {
+        id: "audit_machine_bound",
+        description: "Service should have a Machine workflow bound before publish",
+        severity: "warning",
+        check: (d, ctx) => {
+            if (!d?.publish)
+                return true;
+            return !!d?.machine;
+        },
+        message: () => "Publishing a service without a Machine workflow. Customers won't have a structured order process.",
+        recommendation: "Create a Machine (workflow template) and bind it to the service before publishing. The machine field becomes IMMUTABLE after publish.",
+    },
+    {
+        id: "audit_order_allocators",
+        description: "Service should have order_allocators for fund distribution",
+        severity: "warning",
+        check: (d) => {
+            if (!d?.publish)
+                return true;
+            return Array.isArray(d?.order_allocators) && d.order_allocators.length > 0;
+        },
+        message: () => "Publishing a service without order_allocators. Order funds cannot be auto-distributed to suppliers.",
+        recommendation: "Configure order_allocators before publishing — this field becomes IMMUTABLE after publish.",
+    },
+    {
+        id: "audit_buy_guard",
+        description: "Service should have a buy_guard for customer screening",
+        severity: "info",
+        check: (d) => !!d?.buy_guard,
+        message: () => "No buy_guard configured — anyone can purchase this service without verification.",
+        recommendation: "Consider adding a Guard to verify customer eligibility (e.g., identity, wallet balance, location).",
+    },
+    {
+        id: "audit_compensation_fund",
+        description: "Service should have a compensation_fund for trust",
+        severity: "warning",
+        check: (d) => !!d?.compensation_fund,
+        message: () => "No compensation_fund configured. Customers have no financial protection if you fail to deliver.",
+        recommendation: "Lock a compensation_fund (Treasury) to build trust. The fund deters fraud and enables arbitration claims.",
+    },
+    {
+        id: "audit_arbitrations",
+        description: "Service should have arbitration options for dispute resolution",
+        severity: "info",
+        check: (d) => Array.isArray(d?.arbitrations) && d.arbitrations.length > 0,
+        message: () => "No arbitration configured. Disputes cannot be resolved through a third party.",
+        recommendation: "Add at least one Arb object to enable on-chain dispute resolution.",
+    },
+    {
+        id: "audit_price",
+        description: "Service should have a price set",
+        severity: "error",
+        check: (d) => d?.price !== undefined && d?.price !== null,
+        message: () => "Service has no price. Customers cannot place orders without knowing the cost.",
+        recommendation: "Set the price field before publishing.",
+    },
+    {
+        id: "audit_description",
+        description: "Service should have a description",
+        severity: "warning",
+        check: (d) => typeof d?.description === "string" && d.description.length > 0,
+        message: () => "Service has no description. Customers won't understand what you're offering.",
+        recommendation: "Write a clear description of the service, including deliverables, timelines, and terms.",
+    },
+    {
+        id: "audit_named_new_name",
+        description: "Service being created should have a name",
+        severity: "warning",
+        check: (d) => !!d?.namedNew?.name || typeof d?.object === "string",
+        message: () => "Creating a service without a name makes it hard to reference and organize.",
+        recommendation: "Set namedNew.name following the convention: <projectPrefix>_<service>_<purpose>.",
+    },
+    {
+        id: "audit_dangling_deps",
+        description: "Service dependencies should be fully created",
+        severity: "error",
+        check: (d, ctx) => {
+            if (!d?.publish)
+                return true;
+            if (!ctx?.graph)
+                return true;
+            const dangling = ctx.graph?.findDanglingDependencies?.() ?? [];
+            return dangling.length === 0;
+        },
+        message: (d) => "Service references objects that are not yet created. Publishing will lock these references.",
+        recommendation: "Ensure all referenced objects (machine, allocators, guards) are created and finalized before publishing.",
+    },
+    {
+        id: "audit_type_parameter",
+        description: "Service should have a token type specified",
+        severity: "info",
+        check: (d) => !!d?.type_parameter || !!d?.namedNew?.type_parameter,
+        message: () => "No payment token type specified. Defaulting to WOW (0x2::wow::WOW).",
+        recommendation: "Explicitly set type_parameter if you want to accept non-WOW tokens (e.g., USDT, ETH).",
+    },
+];
+const RULE_INDEX = new Map(AUDIT_RULES.map((r) => [r.id, r]));
+export function auditService(data, context) {
+    const findings = [];
+    for (const rule of AUDIT_RULES) {
+        try {
+            if (!rule.check(data, context)) {
+                findings.push({
+                    rule_id: rule.id,
+                    severity: rule.severity,
+                    message: rule.message(data),
+                    recommendation: rule.recommendation,
+                });
+            }
+        }
+        catch {
+        }
+    }
+    return findings;
+}
+export function hasBlockingErrors(findings) {
+    return findings.some((f) => f.severity === "error");
+}
+export function getErrors(findings) {
+    return findings.filter((f) => f.severity === "error");
+}
+export function getWarnings(findings) {
+    return findings.filter((f) => f.severity === "warning");
+}
+export function summarizeFindings(findings) {
+    if (findings.length === 0)
+        return "All audit checks passed.";
+    const errors = getErrors(findings);
+    const warnings = getWarnings(findings);
+    const infos = findings.filter((f) => f.severity === "info");
+    const parts = [];
+    if (errors.length > 0)
+        parts.push(`${errors.length} error(s)`);
+    if (warnings.length > 0)
+        parts.push(`${warnings.length} warning(s)`);
+    if (infos.length > 0)
+        parts.push(`${infos.length} info`);
+    return `Audit: ${parts.join(", ")}. Review before publishing.`;
+}
+export const AUDIT_RULES_VERSION = 1;

package/dist/knowledge/demand-matching.d.ts

@@ -0,0 +1,29 @@
+export interface ServiceInfo {
+    id: string;
+    name?: string;
+    tags?: string[];
+    price?: string;
+    priceToken?: string;
+    description?: string;
+    scenario?: string;
+    trustScore?: number;
+    location?: string;
+    published?: boolean;
+}
+export interface DemandInfo {
+    tags?: string[];
+    maxPrice?: string;
+    scenario?: string;
+    location?: string;
+    minTrustScore?: number;
+    keywords?: string[];
+}
+export interface DemandMatch {
+    service: ServiceInfo;
+    score: number;
+    reasons: string[];
+    warnings: string[];
+}
+export declare const DEMAND_MATCHING_VERSION = 1;
+export declare function matchDemand(demand: DemandInfo, services: ServiceInfo[], limit?: number): DemandMatch[];
+export declare function extractDemandInfo(demandData: any): DemandInfo;