@wowok/agent-mcp 2.3.14 → 2.3.16

package/dist/knowledge/demand-matching.js

@@ -0,0 +1,132 @@
+export const DEMAND_MATCHING_VERSION = 1;
+const WEIGHTS = {
+    tags: 30,
+    price: 20,
+    scenario: 15,
+    trust: 20,
+    location: 10,
+    keyword: 5,
+};
+export function matchDemand(demand, services, limit = 5) {
+    const matches = services
+        .filter((s) => s.published !== false)
+        .map((s) => computeMatchScore(demand, s))
+        .filter((m) => m.score >= 60)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    return matches;
+}
+function computeMatchScore(demand, service) {
+    const reasons = [];
+    const warnings = [];
+    let score = 0;
+    const tagScore = computeTagScore(demand.tags, service.tags);
+    score += tagScore;
+    if (tagScore >= WEIGHTS.tags * 0.8) {
+        reasons.push(`tags 匹配度高 (${tagScore}/${WEIGHTS.tags})`);
+    }
+    const priceScore = computePriceScore(demand.maxPrice, service.price);
+    score += priceScore;
+    if (priceScore === WEIGHTS.price) {
+        reasons.push(`价格在预算范围内`);
+    }
+    else if (priceScore === 0 && demand.maxPrice && service.price) {
+        warnings.push(`价格超出预算 (${service.price} > ${demand.maxPrice})`);
+    }
+    const scenarioScore = computeScenarioScore(demand.scenario, service.scenario);
+    score += scenarioScore;
+    if (scenarioScore === WEIGHTS.scenario) {
+        reasons.push(`行业场景匹配 (${service.scenario})`);
+    }
+    const trustScore = computeTrustScore(service.trustScore, demand.minTrustScore);
+    score += trustScore;
+    if (service.trustScore !== undefined) {
+        if (service.trustScore >= 75) {
+            reasons.push(`信任分高 (${service.trustScore}/100)`);
+        }
+        else if (service.trustScore < 50) {
+            warnings.push(`信任分较低 (${service.trustScore}/100)`);
+        }
+    }
+    const locationScore = computeLocationScore(demand.location, service.location);
+    score += locationScore;
+    if (locationScore === WEIGHTS.location && demand.location) {
+        reasons.push(`地理位置匹配 (${service.location})`);
+    }
+    const keywordScore = computeKeywordScore(demand.keywords, service.description);
+    score += keywordScore;
+    if (demand.minTrustScore !== undefined && service.trustScore !== undefined) {
+        if (service.trustScore < demand.minTrustScore) {
+            warnings.push(`信任分低于要求 (${service.trustScore} < ${demand.minTrustScore})`);
+            score -= 10;
+        }
+    }
+    return {
+        service,
+        score: Math.max(0, Math.min(100, score)),
+        reasons,
+        warnings,
+    };
+}
+function computeTagScore(demandTags, serviceTags) {
+    if (!demandTags || !serviceTags || demandTags.length === 0 || serviceTags.length === 0)
+        return 0;
+    const demandSet = new Set(demandTags.map((t) => t.toLowerCase()));
+    const serviceSet = new Set(serviceTags.map((t) => t.toLowerCase()));
+    const overlap = [...demandSet].filter((t) => serviceSet.has(t)).length;
+    return Math.round((overlap / demandSet.size) * WEIGHTS.tags);
+}
+function computePriceScore(maxPrice, servicePrice) {
+    if (!maxPrice || !servicePrice)
+        return WEIGHTS.price / 2;
+    try {
+        const max = BigInt(maxPrice);
+        const price = BigInt(servicePrice);
+        if (price <= max)
+            return WEIGHTS.price;
+        if (price <= max * 110n / 100n)
+            return WEIGHTS.price * 0.5;
+        return 0;
+    }
+    catch {
+        return WEIGHTS.price / 2;
+    }
+}
+function computeScenarioScore(demandScenario, serviceScenario) {
+    if (!demandScenario || !serviceScenario)
+        return 0;
+    return demandScenario.toLowerCase() === serviceScenario.toLowerCase() ? WEIGHTS.scenario : 0;
+}
+function computeTrustScore(serviceTrust, minTrust) {
+    if (serviceTrust === undefined)
+        return WEIGHTS.trust / 2;
+    if (serviceTrust >= 75)
+        return WEIGHTS.trust;
+    if (serviceTrust >= 50)
+        return WEIGHTS.trust * 0.6;
+    if (serviceTrust >= 25)
+        return WEIGHTS.trust * 0.3;
+    return 0;
+}
+function computeLocationScore(demandLocation, serviceLocation) {
+    if (!demandLocation || !serviceLocation)
+        return 0;
+    return demandLocation.toLowerCase() === serviceLocation.toLowerCase() ? WEIGHTS.location : 0;
+}
+function computeKeywordScore(keywords, description) {
+    if (!keywords || !description || keywords.length === 0)
+        return 0;
+    const desc = description.toLowerCase();
+    const matches = keywords.filter((k) => desc.includes(k.toLowerCase()));
+    return Math.min(WEIGHTS.keyword, matches.length);
+}
+export function extractDemandInfo(demandData) {
+    return {
+        tags: demandData?.tags,
+        maxPrice: demandData?.max_price ?? demandData?.maxPrice,
+        scenario: demandData?.scenario,
+        location: demandData?.location,
+        minTrustScore: demandData?.min_trust_score ?? demandData?.minTrustScore,
+        keywords: demandData?.keywords,
+    };
+}

package/dist/knowledge/dynamic-pricing.d.ts

@@ -0,0 +1,31 @@
+export interface MarketSignals {
+    supplyCount: number;
+    demandCount: number;
+    avgPrice?: string;
+    myPrice?: string;
+    competitorPrices?: string[];
+    recentOrderCount?: number;
+    repeatCustomerRate?: number;
+}
+export interface PricingSuggestion {
+    action: "increase" | "decrease" | "maintain";
+    suggestedRange?: {
+        min: string;
+        max: string;
+    };
+    reason: string;
+    confidence: number;
+    adjustmentPercent?: number;
+}
+export interface MutableFieldInfo {
+    field: string;
+    purpose: string;
+    mutableAfterPublish: boolean;
+    adjustmentMechanism: string;
+    metricToWatch: string;
+}
+export declare const DYNAMIC_PRICING_VERSION = 1;
+export declare const MUTABLE_FIELDS: MutableFieldInfo[];
+export declare function suggestPricing(signals: MarketSignals): PricingSuggestion;
+export declare function getMutableFields(published?: boolean): MutableFieldInfo[];
+export declare function getMutableField(field: string): MutableFieldInfo | undefined;

package/dist/knowledge/dynamic-pricing.js

@@ -0,0 +1,87 @@
+export const DYNAMIC_PRICING_VERSION = 1;
+export const MUTABLE_FIELDS = [
+    { field: "sales", purpose: "调整产品/价格", mutableAfterPublish: true, adjustmentMechanism: "Service.sales 可变", metricToWatch: "下单率" },
+    { field: "discount", purpose: "营销促销", mutableAfterPublish: true, adjustmentMechanism: "add/set/destroy", metricToWatch: "转化率" },
+    { field: "description", purpose: "信任说明", mutableAfterPublish: true, adjustmentMechanism: "可变", metricToWatch: "浏览时长" },
+    { field: "rewards", purpose: "Reward 营销活动", mutableAfterPublish: true, adjustmentMechanism: "add/remove", metricToWatch: "复购率" },
+    { field: "arbitrations", purpose: "仲裁升级", mutableAfterPublish: true, adjustmentMechanism: "可变", metricToWatch: "仲裁率" },
+    { field: "compensation_fund", purpose: "增信", mutableAfterPublish: true, adjustmentMechanism: "add", metricToWatch: "信任分" },
+    { field: "buy_guard", purpose: "购买门槛", mutableAfterPublish: true, adjustmentMechanism: "可变", metricToWatch: "下单率" },
+    { field: "pause", purpose: "暂停/恢复", mutableAfterPublish: true, adjustmentMechanism: "可变", metricToWatch: "库存状态" },
+    { field: "machine", purpose: "流程模板", mutableAfterPublish: false, adjustmentMechanism: "publish 后锁定，需新建 Service", metricToWatch: "流程速度" },
+    { field: "order_allocators", purpose: "资金分配", mutableAfterPublish: false, adjustmentMechanism: "publish 后锁定，需新建 Service", metricToWatch: "分配公平性" },
+    { field: "type_parameter", purpose: "支付代币", mutableAfterPublish: false, adjustmentMechanism: "不可变，可新建 Service + Reward 引导迁移", metricToWatch: "代币偏好" },
+];
+export function suggestPricing(signals) {
+    const { supplyCount, demandCount, avgPrice, myPrice, competitorPrices, recentOrderCount, repeatCustomerRate } = signals;
+    const supplyDemandRatio = demandCount / Math.max(1, supplyCount);
+    if (supplyDemandRatio > 2) {
+        const increasePercent = Math.min(30, Math.round((supplyDemandRatio - 1) * 10));
+        return {
+            action: "increase",
+            adjustmentPercent: increasePercent,
+            reason: `需求/供给比 ${supplyDemandRatio.toFixed(1)}，市场供不应求，建议涨价 ${increasePercent}%`,
+            confidence: Math.min(0.9, 0.5 + supplyDemandRatio * 0.1),
+        };
+    }
+    if (supplyDemandRatio < 0.5) {
+        const decreasePercent = Math.min(20, Math.round((1 - supplyDemandRatio) * 15));
+        return {
+            action: "decrease",
+            adjustmentPercent: decreasePercent,
+            reason: `需求/供给比 ${supplyDemandRatio.toFixed(1)}，市场供过于求，建议降价 ${decreasePercent}% 以提升竞争力`,
+            confidence: Math.min(0.85, 0.5 + (1 - supplyDemandRatio) * 0.15),
+        };
+    }
+    if (myPrice && competitorPrices && competitorPrices.length > 0) {
+        try {
+            const my = BigInt(myPrice);
+            const comps = competitorPrices.map((p) => BigInt(p));
+            const avgComp = comps.reduce((a, b) => a + b, 0n) / BigInt(comps.length);
+            if (my > avgComp * 120n / 100n) {
+                return {
+                    action: "decrease",
+                    adjustmentPercent: 10,
+                    reason: `当前价格高于市场均价 20%+，建议降价以提升竞争力`,
+                    confidence: 0.7,
+                };
+            }
+            if (my < avgComp * 80n / 100n) {
+                return {
+                    action: "increase",
+                    adjustmentPercent: 10,
+                    reason: `当前价格低于市场均价 20%+，有涨价空间`,
+                    confidence: 0.65,
+                };
+            }
+        }
+        catch {
+        }
+    }
+    if (repeatCustomerRate !== undefined && repeatCustomerRate > 0.4) {
+        return {
+            action: "maintain",
+            reason: `复购率 ${Math.round(repeatCustomerRate * 100)}%，定价策略有效，建议维持`,
+            confidence: 0.8,
+        };
+    }
+    if (repeatCustomerRate !== undefined && repeatCustomerRate < 0.1 && (recentOrderCount ?? 0) > 10) {
+        return {
+            action: "decrease",
+            adjustmentPercent: 5,
+            reason: `复购率仅 ${Math.round(repeatCustomerRate * 100)}%，建议小幅降价或增加 Reward 吸引复购`,
+            confidence: 0.6,
+        };
+    }
+    return {
+        action: "maintain",
+        reason: "市场供需平衡，建议维持当前定价",
+        confidence: 0.5,
+    };
+}
+export function getMutableFields(published = true) {
+    return MUTABLE_FIELDS.filter((f) => published ? f.mutableAfterPublish : true);
+}
+export function getMutableField(field) {
+    return MUTABLE_FIELDS.find((f) => f.field === field);
+}

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

@@ -0,0 +1,87 @@
+import { type IndustryHealthReport, type IndustryUpdateSuggestion, type OrderRawDataPoint } from "./industry-evolution.js";
+import { type BusinessIntent, type AdviceRole } from "./intent-metrics.js";
+export declare const FLYWHEEL_LOOP_VERSION = 2;
+declare const MIN_SIGNALS_FOR_EVOLUTION = 10;
+export type EvolutionScheduleMode = "realtime" | "semi_realtime" | "manual";
+export interface EvolutionScheduleConfig {
+    mode: EvolutionScheduleMode;
+    signal_threshold?: number;
+    time_interval_ms?: number;
+    auto_apply?: boolean;
+}
+export interface IndustrySignal {
+    industry: string;
+    operation_type: string;
+    success: boolean;
+    error_code?: string;
+    timestamp: number;
+    decision_context_id?: string;
+}
+export declare function recordIndustrySignal(industry: string, operation: {
+    type: string;
+    data?: unknown;
+}, outcome: {
+    success: boolean;
+    error_code?: string;
+}): void;
+export declare function setEvolutionSchedule(industry: string, config: EvolutionScheduleConfig): void;
+export declare function getEvolutionSchedule(industry: string): EvolutionScheduleConfig;
+export declare function setIndustryIntent(industry: string, intent: BusinessIntent): void;
+export declare function getIndustryIntent(industry: string): BusinessIntent;
+export declare function getIndustrySignalCount(industry: string): number;
+export declare function getIndustrySignals(industry: string): IndustrySignal[];
+export declare function listIndustriesWithSignals(): string[];
+export declare function getPendingSuggestions(industry: string): IndustryUpdateSuggestion[];
+export interface DecisionContext {
+    id: string;
+    node_id: string;
+    decided_at: number;
+    decider: "user" | "ai" | "system";
+    industry?: string;
+    intent?: string;
+    alternatives?: string[];
+    rationale?: string;
+    outcome?: "success" | "failed" | "pending";
+}
+export declare function recordDecisionContext(ctx: DecisionContext, graph?: {
+    attachDecisionContext: (nodeId: string, c: any) => unknown;
+}): void;
+export declare function queryDecisionsByIndustry(industry: string): DecisionContext[];
+export declare function queryDecisionsByNode(nodeId: string): DecisionContext[];
+export declare function backfillDecisionOutcome(decisionId: string, outcome: "success" | "failed" | "pending"): boolean;
+export interface CognitionUpdateResult {
+    industry: string;
+    metrics_updated: boolean;
+    health_recomputed: boolean;
+    suggestions_generated: number;
+    evolution_ready: boolean;
+}
+export declare function updateIndustryCognition(industry: string, rawData?: OrderRawDataPoint[]): CognitionUpdateResult;
+export interface EvolutionContext {
+    industry_signal?: string;
+    evolution_advice?: string;
+    confidence: number;
+    health_score?: number;
+    pending_suggestions?: number;
+    intent?: BusinessIntent;
+    role_advice?: string[];
+    role?: AdviceRole;
+}
+export declare function injectEvolutionContext(_semantic: unknown, industry?: string, role?: AdviceRole): EvolutionContext;
+export interface IndustryEvolutionStatus {
+    industry: string;
+    version: string;
+    last_updated: number;
+    signal_count: number;
+    health?: IndustryHealthReport;
+    pending_suggestions: number;
+    evolution_ready: boolean;
+}
+export declare function getIndustryEvolutionStatus(industry: string): IndustryEvolutionStatus;
+export declare const EVOLUTION_STATE_VERSION = 1;
+export declare function saveEvolutionState(): string;
+export declare function loadEvolutionState(): boolean;
+export declare function hasPersistedEvolutionState(): boolean;
+export declare function _resetFlywheelLoopForTest(): void;
+export declare function _snapshotSignalBuffer(): Record<string, IndustrySignal[]>;
+export { MIN_SIGNALS_FOR_EVOLUTION as FLYWHEEL_LOOP_MIN_SIGNALS };