@wowok/agent-mcp 2.3.13 → 2.3.16

package/dist/experience/realtime-feedback.js

@@ -0,0 +1,77 @@
+import { distillIntent, extractSignals } from "./intent-distill.js";
+import { getProfile, updateFromOperation } from "./user-profile.js";
+import { findMatches, recordSignature } from "./experience-reuse.js";
+import { EXPERIENCE_LAYER_VERSION } from "./types.js";
+export { EXPERIENCE_LAYER_VERSION };
+export function getExperienceFeedback(operation_type, data, baseIntent) {
+    try {
+        const distilled = distillIntent(operation_type, data, baseIntent);
+        const matches = findMatches(distilled.primary_intent, operation_type, data, 3);
+        if (matches.length === 0)
+            return undefined;
+        const topMatch = matches[0];
+        const profile = getProfile();
+        return formatFeedback(topMatch, matches, distilled.scenario, profile);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function recordOperationOutcome(operation_type, data, baseIntent, outcome, errorCode, referencedObjects = []) {
+    try {
+        const distilled = distillIntent(operation_type, data, baseIntent);
+        const signals = extractSignals(operation_type, data);
+        recordSignature({
+            intent: distilled.primary_intent,
+            scenario: distilled.scenario,
+            signals,
+            timestamp: Date.now(),
+            outcome,
+            error_code: errorCode,
+        });
+        updateFromOperation(distilled.primary_intent, distilled.scenario, outcome, errorCode, referencedObjects);
+    }
+    catch {
+    }
+}
+function formatFeedback(topMatch, allMatches, scenario, profile) {
+    const advice = buildAdviceText(topMatch, allMatches, profile);
+    const avoid = collectAvoidList(allMatches, profile);
+    const relevance = topMatch.relevance;
+    const matchedScenario = scenario ?? topMatch.signature.scenario;
+    const feedback = {};
+    if (advice)
+        feedback.advice = advice;
+    if (avoid.length > 0)
+        feedback.avoid = avoid;
+    if (relevance > 0)
+        feedback.relevance = Math.round(relevance * 100) / 100;
+    if (matchedScenario)
+        feedback.matched_scenario = matchedScenario;
+    return feedback;
+}
+function buildAdviceText(topMatch, allMatches, profile) {
+    const parts = [];
+    if (topMatch.signature.outcome === "success") {
+        parts.push(`Historically, ${topMatch.signature.intent} operation succeeded`);
+    }
+    else if (topMatch.signature.outcome === "failed") {
+        parts.push(`Historically, ${topMatch.signature.intent} operation failed (${topMatch.signature.error_code ?? "unknown error"}), pay special attention to parameters`);
+    }
+    if (profile.expertise_tier === "novice" && allMatches.length > 0) {
+        parts.push("It is recommended to carefully check parameters before executing");
+    }
+    return parts.join("; ") || topMatch.advice;
+}
+function collectAvoidList(matches, profile) {
+    const avoid = new Set();
+    for (const m of matches) {
+        for (const a of m.avoid) {
+            avoid.add(a);
+        }
+    }
+    for (const p of profile.frequent_pitfalls) {
+        avoid.add(`You often make mistakes at the ${p} step, please be especially careful`);
+    }
+    return Array.from(avoid).slice(0, 5);
+}

package/dist/experience/types.d.ts

@@ -0,0 +1,50 @@
+export interface UserIntentSignature {
+    intent: string;
+    scenario?: string;
+    signals: Record<string, any>;
+    timestamp: number;
+    outcome: "success" | "failed" | "partial";
+    error_code?: string;
+    recovery_path?: string[];
+}
+export interface UserProfile {
+    expertise_tier: "novice" | "advanced" | "expert";
+    preferred_industries: string[];
+    risk_appetite: "conservative" | "balanced" | "aggressive";
+    frequent_pitfalls: string[];
+    reused_objects: string[];
+    preferred_confirmation: "minimal" | "standard" | "verbose";
+    total_operations: number;
+    success_rate: number;
+    last_updated: number;
+    buyer_signals?: BuyerSignals;
+}
+export interface BuyerSignals {
+    purchase_count: number;
+    avg_purchase_price_ratio: number;
+    discount_usage_count: number;
+    referral_usage_count: number;
+    dispute_count: number;
+    inferred_price_sensitivity?: "low" | "medium" | "high";
+    inferred_bargain_hunting?: number;
+}
+export interface DistilledIntent {
+    primary_intent: string;
+    secondary_intents: string[];
+    confidence: number;
+    urgency: "low" | "normal" | "high" | "critical";
+    scenario?: string;
+}
+export interface ExperienceMatch {
+    signature: UserIntentSignature;
+    relevance: number;
+    advice: string;
+    avoid: string[];
+}
+export interface ExperienceFeedback {
+    advice?: string;
+    avoid?: string[];
+    relevance?: number;
+    matched_scenario?: string;
+}
+export declare const EXPERIENCE_LAYER_VERSION = 1;

package/dist/experience/types.js

@@ -0,0 +1 @@
+export const EXPERIENCE_LAYER_VERSION = 1;

package/dist/experience/user-profile.d.ts

@@ -0,0 +1,25 @@
+import type { UserProfile, BuyerSignals } from "./types.js";
+export declare function getProfile(): UserProfile;
+export interface PurchaseOutcomeInput {
+    price: bigint;
+    avg_market_price?: bigint;
+    used_discount?: boolean;
+    used_referral?: boolean;
+    has_dispute?: boolean;
+}
+export declare function recordPurchaseOutcome(input: PurchaseOutcomeInput): void;
+export declare function getBuyerSignals(): BuyerSignals;
+export declare function updateFromOperation(intent: string, scenario: string | undefined, outcome: "success" | "failed" | "partial", errorCode: string | undefined, referencedObjects: string[]): void;
+export declare function resetProfile(): void;
+export declare function getProfileStats(): {
+    total_operations: number;
+    success_rate: number;
+    top_scenarios: Array<{
+        scenario: string;
+        count: number;
+    }>;
+    top_pitfalls: Array<{
+        error_code: string;
+        count: number;
+    }>;
+};

package/dist/experience/user-profile.js

@@ -0,0 +1,171 @@
+let currentProfile = {
+    expertise_tier: "novice",
+    preferred_industries: [],
+    risk_appetite: "balanced",
+    frequent_pitfalls: [],
+    reused_objects: [],
+    preferred_confirmation: "standard",
+    total_operations: 0,
+    success_rate: 1.0,
+    last_updated: 0,
+};
+let buyerSignals = {
+    purchase_count: 0,
+    avg_purchase_price_ratio: 1.0,
+    discount_usage_count: 0,
+    referral_usage_count: 0,
+    dispute_count: 0,
+};
+let scenarioCounts = new Map();
+let pitfallCounts = new Map();
+let objectRefs = new Map();
+let successCount = 0;
+let totalCount = 0;
+export function getProfile() {
+    return { ...currentProfile, buyer_signals: { ...buyerSignals } };
+}
+export function recordPurchaseOutcome(input) {
+    try {
+        buyerSignals.purchase_count++;
+        if (input.used_discount)
+            buyerSignals.discount_usage_count++;
+        if (input.used_referral)
+            buyerSignals.referral_usage_count++;
+        if (input.has_dispute)
+            buyerSignals.dispute_count++;
+        if (input.avg_market_price && input.avg_market_price > 0n) {
+            const ratio = Number((input.price * 100n) / input.avg_market_price) / 100;
+            const prevAvg = buyerSignals.avg_purchase_price_ratio;
+            const n = buyerSignals.purchase_count;
+            buyerSignals.avg_purchase_price_ratio = (prevAvg * (n - 1) + ratio) / n;
+        }
+        recomputeBuyerInferences();
+    }
+    catch {
+    }
+}
+function recomputeBuyerInferences() {
+    const n = buyerSignals.purchase_count;
+    if (n >= 3) {
+        const avgRatio = buyerSignals.avg_purchase_price_ratio;
+        if (avgRatio < 0.9) {
+            buyerSignals.inferred_price_sensitivity = "high";
+        }
+        else if (avgRatio > 1.1) {
+            buyerSignals.inferred_price_sensitivity = "low";
+        }
+        else {
+            buyerSignals.inferred_price_sensitivity = "medium";
+        }
+    }
+    if (n >= 2) {
+        const signalCount = buyerSignals.discount_usage_count + buyerSignals.referral_usage_count;
+        const ratio = signalCount / n;
+        buyerSignals.inferred_bargain_hunting = Math.min(1, ratio);
+    }
+}
+export function getBuyerSignals() {
+    return { ...buyerSignals };
+}
+export function updateFromOperation(intent, scenario, outcome, errorCode, referencedObjects) {
+    try {
+        totalCount++;
+        if (outcome === "success")
+            successCount++;
+        if (scenario) {
+            scenarioCounts.set(scenario, (scenarioCounts.get(scenario) ?? 0) + 1);
+        }
+        if (outcome !== "success" && errorCode) {
+            pitfallCounts.set(errorCode, (pitfallCounts.get(errorCode) ?? 0) + 1);
+        }
+        for (const obj of referencedObjects) {
+            objectRefs.set(obj, (objectRefs.get(obj) ?? 0) + 1);
+        }
+        currentProfile = recomputeProfile();
+    }
+    catch {
+    }
+}
+function recomputeProfile() {
+    const total = totalCount;
+    const successRate = total > 0 ? successCount / total : 1.0;
+    let tier = "novice";
+    if (total >= 50 && successRate >= 0.9)
+        tier = "expert";
+    else if (total >= 10 && successRate >= 0.7)
+        tier = "advanced";
+    const topScenarios = Array.from(scenarioCounts.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([s]) => s);
+    let riskAppetite = "balanced";
+    if (total > 20 && successRate < 0.6)
+        riskAppetite = "aggressive";
+    else if (total > 20 && successRate > 0.95)
+        riskAppetite = "conservative";
+    const topPitfalls = Array.from(pitfallCounts.entries())
+        .filter(([, count]) => count >= 2)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([code]) => code);
+    const topObjects = Array.from(objectRefs.entries())
+        .filter(([, count]) => count >= 2)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([obj]) => obj);
+    let preferredConfirmation = "standard";
+    if (tier === "expert")
+        preferredConfirmation = "minimal";
+    else if (tier === "novice")
+        preferredConfirmation = "verbose";
+    return {
+        expertise_tier: tier,
+        preferred_industries: topScenarios,
+        risk_appetite: riskAppetite,
+        frequent_pitfalls: topPitfalls,
+        reused_objects: topObjects,
+        preferred_confirmation: preferredConfirmation,
+        total_operations: total,
+        success_rate: successRate,
+        last_updated: Date.now(),
+    };
+}
+export function resetProfile() {
+    currentProfile = {
+        expertise_tier: "novice",
+        preferred_industries: [],
+        risk_appetite: "balanced",
+        frequent_pitfalls: [],
+        reused_objects: [],
+        preferred_confirmation: "verbose",
+        total_operations: 0,
+        success_rate: 1.0,
+        last_updated: 0,
+    };
+    scenarioCounts = new Map();
+    pitfallCounts = new Map();
+    objectRefs = new Map();
+    successCount = 0;
+    totalCount = 0;
+    buyerSignals = {
+        purchase_count: 0,
+        avg_purchase_price_ratio: 1.0,
+        discount_usage_count: 0,
+        referral_usage_count: 0,
+        dispute_count: 0,
+    };
+}
+export function getProfileStats() {
+    return {
+        total_operations: totalCount,
+        success_rate: totalCount > 0 ? successCount / totalCount : 1.0,
+        top_scenarios: Array.from(scenarioCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([scenario, count]) => ({ scenario, count })),
+        top_pitfalls: Array.from(pitfallCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([error_code, count]) => ({ error_code, count })),
+    };
+}

package/dist/harness/checkpoint.d.ts

@@ -0,0 +1,8 @@
+import type { Checkpoint } from "./types.js";
+export declare function saveCheckpoint(cp: Checkpoint): void;
+export declare function loadCheckpoint(taskId: string, checkpointId: string): Checkpoint | null;
+export declare function loadLatestCheckpoint(taskId: string): Checkpoint | null;
+export declare function listCheckpoints(taskId: string): Checkpoint[];
+export declare function listTasks(): string[];
+export declare function deleteCheckpoint(taskId: string, checkpointId: string): void;
+export declare function createCheckpoint(taskId: string, phase: string, phaseStatus: Checkpoint["phase_status"], odgSnapshot: Checkpoint["odg_snapshot"], userDecisions: Record<string, unknown>, operationLog: Checkpoint["operation_log"], nextPhase: string, semanticSummary: Checkpoint["semantic_summary"]): Checkpoint;

package/dist/harness/checkpoint.js

@@ -0,0 +1,129 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync, openSync, closeSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const CHECKPOINT_ROOT = join(homedir(), ".wowok", "checkpoints");
+function getTaskDir(taskId) {
+    return join(CHECKPOINT_ROOT, taskId);
+}
+function getCheckpointPath(taskId, checkpointId) {
+    return join(getTaskDir(taskId), `${checkpointId}.json`);
+}
+function getLatestPath(taskId) {
+    return join(getTaskDir(taskId), "latest.json");
+}
+function acquireLock(filePath) {
+    const lockPath = filePath + ".lock";
+    try {
+        const fd = openSync(lockPath, "wx");
+        closeSync(fd);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function releaseLock(filePath) {
+    const lockPath = filePath + ".lock";
+    try {
+        unlinkSync(lockPath);
+    }
+    catch {
+    }
+}
+export function saveCheckpoint(cp) {
+    const taskDir = getTaskDir(cp.task_id);
+    if (!existsSync(taskDir)) {
+        mkdirSync(taskDir, { recursive: true });
+    }
+    const cpPath = getCheckpointPath(cp.task_id, cp.checkpoint_id);
+    const latestPath = getLatestPath(cp.task_id);
+    if (!acquireLock(cpPath)) {
+        throw new Error(`Cannot acquire lock for checkpoint ${cp.checkpoint_id} — another process may be writing`);
+    }
+    try {
+        writeFileSync(cpPath, JSON.stringify(cp, null, 2), "utf8");
+        writeFileSync(latestPath, JSON.stringify(cp, null, 2), "utf8");
+    }
+    finally {
+        releaseLock(cpPath);
+    }
+}
+export function loadCheckpoint(taskId, checkpointId) {
+    const cpPath = getCheckpointPath(taskId, checkpointId);
+    if (!existsSync(cpPath))
+        return null;
+    try {
+        const raw = readFileSync(cpPath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function loadLatestCheckpoint(taskId) {
+    const latestPath = getLatestPath(taskId);
+    if (!existsSync(latestPath))
+        return null;
+    try {
+        const raw = readFileSync(latestPath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function listCheckpoints(taskId) {
+    const taskDir = getTaskDir(taskId);
+    if (!existsSync(taskDir))
+        return [];
+    const files = readdirSync(taskDir)
+        .filter((f) => f.endsWith(".json") && f !== "latest.json")
+        .sort();
+    return files
+        .map((f) => {
+        try {
+            const raw = readFileSync(join(taskDir, f), "utf8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((cp) => cp !== null);
+}
+export function listTasks() {
+    if (!existsSync(CHECKPOINT_ROOT))
+        return [];
+    return readdirSync(CHECKPOINT_ROOT, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name);
+}
+export function deleteCheckpoint(taskId, checkpointId) {
+    const cpPath = getCheckpointPath(taskId, checkpointId);
+    if (existsSync(cpPath)) {
+        if (!acquireLock(cpPath)) {
+            throw new Error(`Cannot acquire lock for deletion of ${checkpointId}`);
+        }
+        try {
+            unlinkSync(cpPath);
+        }
+        finally {
+            releaseLock(cpPath);
+        }
+    }
+}
+export function createCheckpoint(taskId, phase, phaseStatus, odgSnapshot, userDecisions, operationLog, nextPhase, semanticSummary) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return {
+        checkpoint_id: `CP-${phase.replace(/\s+/g, "")}-${phaseStatus}-${timestamp}`,
+        task_id: taskId,
+        timestamp: new Date().toISOString(),
+        phase,
+        phase_status: phaseStatus,
+        odg_snapshot: odgSnapshot,
+        user_decisions: userDecisions,
+        operation_log: operationLog,
+        next_phase: nextPhase,
+        semantic_summary: semanticSummary,
+    };
+}

package/dist/harness/index.d.ts

@@ -0,0 +1,33 @@
+export * from "./types.js";
+export * from "./plan.js";
+export * from "./verify.js";
+export * from "./recover.js";
+export * from "./checkpoint.js";
+import type { DecisionPoint } from "./plan.js";
+import type { VerifyInput } from "./verify.js";
+import type { ODG, ExpectedResult, VerifyReport, RecoveryAction, Checkpoint } from "./types.js";
+export declare class Harness {
+    private context;
+    plan(userInput: string, taskId?: string): ODG;
+    classifyIntent(userInput: string): import("./plan.js").IntentClassification;
+    getDecisions(odg: ODG): DecisionPoint[];
+    detectCycles(odg: ODG): string[] | null;
+    getScenarioRegistry(): import("./types.js").ScenarioTemplate[];
+    expect(operation: string, intent: string, operationType: string, data?: Record<string, unknown>): ExpectedResult;
+    verify(input: VerifyInput): VerifyReport;
+    recover(errorCode: string, operationId: string, context?: {
+        operation_type?: string;
+        data?: Record<string, unknown>;
+    }): RecoveryAction;
+    resetRecovery(operationId: string): void;
+    getBackoffDelay(attempt: number): number;
+    getRecoveryRules(): Record<string, import("./recover.js").RecoveryRule>;
+    checkpoint(taskId: string, phase: string, phaseStatus: Checkpoint["phase_status"], odgSnapshot: Checkpoint["odg_snapshot"], userDecisions: Record<string, unknown>, operationLog: Checkpoint["operation_log"], nextPhase: string, semanticSummary: Checkpoint["semantic_summary"]): Checkpoint;
+    loadCheckpoint(taskId: string): Checkpoint | null;
+    listCheckpoints(taskId: string): Checkpoint[];
+    listTasks(): string[];
+    setContext(key: string, value: unknown): void;
+    getContext<T>(key: string): T | undefined;
+}
+export declare function getHarness(): Harness;
+export declare function setHarness(h: Harness): void;

package/dist/harness/index.js

@@ -0,0 +1,75 @@
+export * from "./types.js";
+export * from "./plan.js";
+export * from "./verify.js";
+export * from "./recover.js";
+export * from "./checkpoint.js";
+import { classifyIntent, generateODG, identifyDecisionPoints, detectCycles, SCENARIO_REGISTRY } from "./plan.js";
+import { verify, generateExpected } from "./verify.js";
+import { recover, resetAttempts, getBackoffDelay, RECOVERY_RULES } from "./recover.js";
+import { saveCheckpoint, loadLatestCheckpoint, listCheckpoints, listTasks, createCheckpoint } from "./checkpoint.js";
+export class Harness {
+    context = new Map();
+    plan(userInput, taskId) {
+        return generateODG(userInput, taskId);
+    }
+    classifyIntent(userInput) {
+        return classifyIntent(userInput);
+    }
+    getDecisions(odg) {
+        return identifyDecisionPoints(odg);
+    }
+    detectCycles(odg) {
+        return detectCycles(odg);
+    }
+    getScenarioRegistry() {
+        return SCENARIO_REGISTRY;
+    }
+    expect(operation, intent, operationType, data) {
+        return generateExpected(operation, intent, operationType, data);
+    }
+    verify(input) {
+        return verify(input);
+    }
+    recover(errorCode, operationId, context) {
+        return recover(errorCode, operationId, context);
+    }
+    resetRecovery(operationId) {
+        resetAttempts(operationId);
+    }
+    getBackoffDelay(attempt) {
+        return getBackoffDelay(attempt);
+    }
+    getRecoveryRules() {
+        return RECOVERY_RULES;
+    }
+    checkpoint(taskId, phase, phaseStatus, odgSnapshot, userDecisions, operationLog, nextPhase, semanticSummary) {
+        const cp = createCheckpoint(taskId, phase, phaseStatus, odgSnapshot, userDecisions, operationLog, nextPhase, semanticSummary);
+        saveCheckpoint(cp);
+        return cp;
+    }
+    loadCheckpoint(taskId) {
+        return loadLatestCheckpoint(taskId);
+    }
+    listCheckpoints(taskId) {
+        return listCheckpoints(taskId);
+    }
+    listTasks() {
+        return listTasks();
+    }
+    setContext(key, value) {
+        this.context.set(key, value);
+    }
+    getContext(key) {
+        return this.context.get(key);
+    }
+}
+let singleton = null;
+export function getHarness() {
+    if (!singleton) {
+        singleton = new Harness();
+    }
+    return singleton;
+}
+export function setHarness(h) {
+    singleton = h;
+}

package/dist/harness/plan.d.ts

@@ -0,0 +1,18 @@
+import type { ODG, ScenarioTemplate } from "./types.js";
+export declare const SCENARIO_REGISTRY: ScenarioTemplate[];
+export interface IntentClassification {
+    scenario: string;
+    matched_keywords: string[];
+    confidence: number;
+    fallback: boolean;
+}
+export declare function classifyIntent(userInput: string): IntentClassification;
+export declare function generateODG(userInput: string, taskId?: string): ODG;
+export interface DecisionPoint {
+    round: string;
+    question: string;
+    options: string[];
+    default?: string;
+}
+export declare function identifyDecisionPoints(odg: ODG): DecisionPoint[];
+export declare function detectCycles(odg: ODG): string[] | null;