@wowok/agent-mcp 2.4.3 → 2.5.1

package/dist/project/business-puzzle.d.ts

@@ -0,0 +1,47 @@
+import type { ProjectObjectType, IndustryMode } from "./namespace.js";
+export interface BusinessPuzzleInput {
+    user_intent: string;
+    project_name?: string;
+    target_objects?: string[];
+    industry?: IndustryMode | string;
+}
+export interface DetectedScene {
+    object: ProjectObjectType;
+    scene_id: string;
+}
+export interface IntentParsed {
+    primary_object: ProjectObjectType;
+    secondary_objects: ProjectObjectType[];
+    detected_scenes: DetectedScene[];
+    industry: IndustryMode;
+    keyword_matches: KeywordMatch[];
+}
+export interface ObjectPuzzleEntry {
+    puzzle: unknown;
+    completeness: unknown;
+    missing_dimensions: string[];
+}
+export interface BusinessPuzzleResult {
+    intent_parsed: IntentParsed;
+    puzzles: Record<string, ObjectPuzzleEntry>;
+    overall_completeness: "complete" | "partial" | "empty";
+    next_step: string;
+    warnings: string[];
+}
+export interface KeywordMatch {
+    keyword: string;
+    category: string;
+    matched_objects: ProjectObjectType[];
+    required_level: "R" | "C" | "OPTIONAL";
+    match_count: number;
+}
+export declare function extractKeywords(business_intent: string): KeywordMatch[];
+export declare function resolveIndustry(intent: string, hint?: string): IndustryMode;
+export declare function identifyObjects(intent: string, matches: KeywordMatch[]): {
+    primary: ProjectObjectType;
+    secondary: ProjectObjectType[];
+    scenes: DetectedScene[];
+};
+export declare function analyzeBusinessIntent(input: BusinessPuzzleInput): BusinessPuzzleResult;
+export declare function aggregatePuzzleCompleteness(puzzles: Record<string, ObjectPuzzleEntry>): "complete" | "partial" | "empty";
+export declare function suggestNextPuzzleStep(currentResult: BusinessPuzzleResult): string;

package/dist/project/business-puzzle.js

@@ -0,0 +1,372 @@
+import { initServicePuzzleFromIntent, initMachinePuzzleFromIntent, initAllocationPuzzleFromIntent, initTreasuryPuzzleFromIntent, initArbitrationPuzzleFromIntent, initRewardPuzzleFromIntent, initProgressPuzzleFromIntent, initOrderPuzzleFromIntent, initPuzzleFromIntent as initGuardPuzzleFromIntent, checkServicePuzzleCompleteness, checkMachinePuzzleCompleteness, checkAllocationPuzzleCompleteness, checkTreasuryPuzzleCompleteness, checkArbitrationPuzzleCompleteness, checkRewardPuzzleCompleteness, checkProgressPuzzleCompleteness, checkOrderPuzzleCompleteness, checkPuzzleCompleteness as checkGuardPuzzleCompleteness, } from "../knowledge/index.js";
+import { initPuzzleFromIntent as initPermissionPuzzleFromIntent, checkPuzzleCompleteness as checkPermissionPuzzleCompleteness, } from "../knowledge/permission-puzzle.js";
+const KEYWORD_TABLE = [
+    {
+        category: "Product/Service",
+        keywords_zh: ["product", "selling", "sell", "sales", "store", "open shop"],
+        keywords_en: ["sell", "product", "sale", "shop", "store"],
+        objects: ["service", "order", "progress"],
+        required_level: "R",
+        scene_id: "retail",
+    },
+    {
+        category: "Subscription",
+        keywords_zh: ["subscription", "cycle", "renewal"],
+        keywords_en: ["subscribe", "recurring", "subscription"],
+        objects: ["service", "machine", "reward"],
+        required_level: "C",
+        scene_id: "subscription",
+    },
+    {
+        category: "Rental",
+        keywords_zh: ["rent", "lease", "return"],
+        keywords_en: ["rent", "lease", "return"],
+        objects: ["service", "machine", "arb"],
+        required_level: "C",
+        scene_id: "rental_return",
+    },
+    {
+        category: "Trust",
+        keywords_zh: ["deposit", "pledge", "verify", "trust"],
+        keywords_en: ["deposit", "trust", "verify"],
+        objects: ["guard", "permission", "treasury"],
+        required_level: "R",
+        scene_id: "trust_deposit",
+    },
+    {
+        category: "Funds",
+        keywords_zh: ["split", "collect", "share profit", "income", "incentive"],
+        keywords_en: ["split", "revenue", "reward"],
+        objects: ["allocation", "treasury", "reward"],
+        required_level: "R",
+        scene_id: "revenue_split",
+    },
+    {
+        category: "Workflow",
+        keywords_zh: ["node", "stage", "process", "workflow"],
+        keywords_en: ["workflow", "stage", "node"],
+        objects: ["machine", "progress"],
+        required_level: "R",
+        scene_id: "workflow",
+    },
+    {
+        category: "Dispute",
+        keywords_zh: ["arbitration", "refund", "conflict", "rights protection"],
+        keywords_en: ["arbitration", "refund", "dispute"],
+        objects: ["arb", "proof"],
+        required_level: "C",
+        scene_id: "arbitration_dispute",
+    },
+    {
+        category: "Contact",
+        keywords_zh: ["customer service", "contact", "communication"],
+        keywords_en: ["contact", "support", "im"],
+        objects: ["contact"],
+        required_level: "C",
+        scene_id: "contact_im",
+    },
+    {
+        category: "Data",
+        keywords_zh: ["evidence", "record", "data"],
+        keywords_en: ["evidence", "record", "data"],
+        objects: ["repository", "proof"],
+        required_level: "C",
+        scene_id: "evidence_record",
+    },
+    {
+        category: "User Profile",
+        keywords_zh: ["personal info", "preference", "privacy"],
+        keywords_en: ["personal", "profile", "privacy"],
+        objects: ["personal", "contact"],
+        required_level: "OPTIONAL",
+        scene_id: "user_profile",
+    },
+    {
+        category: "Demand Submission",
+        keywords_zh: ["demand", "publish", "inquiry"],
+        keywords_en: ["demand", "request", "inquiry"],
+        objects: ["demand"],
+        required_level: "OPTIONAL",
+        scene_id: "demand_inquiry",
+    },
+];
+const INDUSTRY_KEYWORDS = [
+    { industry: "freelance", words: ["freelance", "outsourcing", "freelance", "gig"] },
+    { industry: "rental", words: ["rental", "lease", "rental", "rent"] },
+    { industry: "education", words: ["education", "course", "training", "education", "course"] },
+    { industry: "travel", words: ["travel", "tour", "itinerary", "travel", "trip"] },
+    { industry: "subscription", words: ["subscription", "cycle", "subscription", "recurring"] },
+];
+function buildPuzzleDispatch() {
+    const safeInit = (fn, input) => {
+        try {
+            return fn(input);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const safeCheck = (puzzle, fn) => {
+        if (!puzzle)
+            return { missing: [], complete: false, next_step: "init failed" };
+        try {
+            return fn(puzzle);
+        }
+        catch {
+            return { missing: [], complete: false, next_step: "check failed" };
+        }
+    };
+    return {
+        service: {
+            init: (intent) => safeInit(initServicePuzzleFromIntent, { primary_goal: intent }),
+            check: (p) => safeCheck(p, checkServicePuzzleCompleteness),
+        },
+        machine: {
+            init: (intent) => safeInit(initMachinePuzzleFromIntent, intent),
+            check: (p) => safeCheck(p, checkMachinePuzzleCompleteness),
+        },
+        allocation: {
+            init: (intent) => safeInit(initAllocationPuzzleFromIntent, { primary_goal: intent }),
+            check: (p) => safeCheck(p, checkAllocationPuzzleCompleteness),
+        },
+        treasury: {
+            init: (intent) => safeInit(initTreasuryPuzzleFromIntent, { primary_goal: intent }),
+            check: (p) => safeCheck(p, checkTreasuryPuzzleCompleteness),
+        },
+        arb: {
+            init: (intent) => safeInit(initArbitrationPuzzleFromIntent, { primary_goal: intent }),
+            check: (p) => safeCheck(p, checkArbitrationPuzzleCompleteness),
+        },
+        reward: {
+            init: (intent) => safeInit(initRewardPuzzleFromIntent, { primary_goal: intent }),
+            check: (p) => safeCheck(p, checkRewardPuzzleCompleteness),
+        },
+        progress: {
+            init: (intent) => safeInit(initProgressPuzzleFromIntent, { primary_goal: intent }),
+            check: (p) => safeCheck(p, checkProgressPuzzleCompleteness),
+        },
+        order: {
+            init: (intent) => safeInit(initOrderPuzzleFromIntent, { primary_goal: intent }),
+            check: (p) => safeCheck(p, checkOrderPuzzleCompleteness),
+        },
+        permission: {
+            init: (intent) => safeInit(initPermissionPuzzleFromIntent, { primary_goal: intent }),
+            check: (p) => safeCheck(p, checkPermissionPuzzleCompleteness),
+        },
+        guard: {
+            init: (intent) => safeInit(initGuardPuzzleFromIntent, { primary_goal: intent }),
+            check: (p) => safeCheck(p, checkGuardPuzzleCompleteness),
+        },
+    };
+}
+export function extractKeywords(business_intent) {
+    if (!business_intent || typeof business_intent !== "string")
+        return [];
+    const matches = [];
+    for (const entry of KEYWORD_TABLE) {
+        const allKeywords = [...entry.keywords_zh, ...entry.keywords_en];
+        for (const keyword of allKeywords) {
+            try {
+                const regex = new RegExp(escapeRegex(keyword), "gi");
+                const count = (business_intent.match(regex) || []).length;
+                if (count > 0) {
+                    matches.push({
+                        keyword,
+                        category: entry.category,
+                        matched_objects: [...entry.objects],
+                        required_level: entry.required_level,
+                        match_count: count,
+                    });
+                }
+            }
+            catch {
+            }
+        }
+    }
+    matches.sort((a, b) => b.match_count - a.match_count);
+    return matches;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function resolveIndustry(intent, hint) {
+    const text = `${intent ?? ""} ${hint ?? ""}`.toLowerCase();
+    for (const entry of INDUSTRY_KEYWORDS) {
+        for (const w of entry.words) {
+            if (text.includes(w.toLowerCase()))
+                return entry.industry;
+        }
+    }
+    return "general";
+}
+export function identifyObjects(intent, matches) {
+    if (matches.length === 0) {
+        return {
+            primary: "service",
+            secondary: ["permission", "machine", "progress"],
+            scenes: [{ object: "service", scene_id: "general" }],
+        };
+    }
+    const firstR = matches.find((m) => m.required_level === "R");
+    const primary = (firstR ?? matches[0]).matched_objects[0];
+    const seen = new Set([primary]);
+    const secondary = [];
+    for (const m of matches) {
+        for (const obj of m.matched_objects) {
+            if (!seen.has(obj)) {
+                seen.add(obj);
+                secondary.push(obj);
+            }
+        }
+    }
+    const scenes = [];
+    const sceneSeen = new Set();
+    for (const entry of KEYWORD_TABLE) {
+        const matched = matches.find((m) => m.category === entry.category);
+        if (!matched)
+            continue;
+        if (sceneSeen.has(entry.scene_id))
+            continue;
+        sceneSeen.add(entry.scene_id);
+        scenes.push({ object: entry.objects[0], scene_id: entry.scene_id });
+    }
+    return { primary, secondary, scenes };
+}
+export function analyzeBusinessIntent(input) {
+    const warnings = [];
+    if (!input || !input.user_intent || typeof input.user_intent !== "string") {
+        return {
+            intent_parsed: {
+                primary_object: "service",
+                secondary_objects: [],
+                detected_scenes: [],
+                industry: "general",
+                keyword_matches: [],
+            },
+            puzzles: {},
+            overall_completeness: "empty",
+            next_step: "Please provide a non-empty business intent.",
+            warnings: ["input.user_intent is empty"],
+        };
+    }
+    const intent = input.user_intent;
+    const matches = extractKeywords(intent);
+    const industry = resolveIndustry(intent, input.industry);
+    const { primary, secondary, scenes } = identifyObjects(intent, matches);
+    let targetObjects = [primary, ...secondary];
+    if (input.target_objects && input.target_objects.length > 0) {
+        const explicit = input.target_objects.filter((t) => [
+            "service", "machine", "guard", "permission", "reward", "arb",
+            "progress", "treasury", "demand", "repository", "contact", "order",
+            "allocation", "personal", "payment", "proof",
+        ].includes(t));
+        if (explicit.length > 0)
+            targetObjects = explicit;
+    }
+    const dispatch = buildPuzzleDispatch();
+    const puzzles = {};
+    for (const objType of targetObjects) {
+        const d = dispatch[objType];
+        if (!d) {
+            warnings.push(`No puzzle module for '${objType}' — skipped (L3 object)`);
+            continue;
+        }
+        const puzzle = d.init(intent);
+        const completeness = puzzle ? d.check(puzzle) : undefined;
+        const missingDimensions = extractMissingDimensions(completeness);
+        puzzles[objType] = {
+            puzzle,
+            completeness,
+            missing_dimensions: missingDimensions,
+        };
+        if (!puzzle) {
+            warnings.push(`Puzzle init failed for '${objType}'`);
+        }
+    }
+    const overall = aggregatePuzzleCompleteness(puzzles);
+    const nextStep = suggestNextPuzzleStep({
+        intent_parsed: {
+            primary_object: primary,
+            secondary_objects: secondary,
+            detected_scenes: scenes,
+            industry,
+            keyword_matches: matches,
+        },
+        puzzles,
+        overall_completeness: overall,
+        next_step: "",
+        warnings,
+    });
+    return {
+        intent_parsed: {
+            primary_object: primary,
+            secondary_objects: secondary,
+            detected_scenes: scenes,
+            industry,
+            keyword_matches: matches,
+        },
+        puzzles,
+        overall_completeness: overall,
+        next_step: nextStep,
+        warnings,
+    };
+}
+function extractMissingDimensions(completeness) {
+    if (!completeness || typeof completeness !== "object")
+        return [];
+    const c = completeness;
+    const missing = c.missing;
+    if (Array.isArray(missing)) {
+        return missing.map((m) => String(m));
+    }
+    const missingDetails = c.missing_details;
+    if (Array.isArray(missingDetails)) {
+        return missingDetails.map((m) => String(m?.dimension ?? m));
+    }
+    return [];
+}
+export function aggregatePuzzleCompleteness(puzzles) {
+    const entries = Object.values(puzzles ?? {});
+    if (entries.length === 0)
+        return "empty";
+    const emptyCount = entries.filter((e) => !e.puzzle).length;
+    if (emptyCount === entries.length)
+        return "empty";
+    const missingCount = entries.reduce((sum, e) => sum + (e.missing_dimensions?.length ?? 0), 0);
+    if (missingCount === 0)
+        return "complete";
+    return "partial";
+}
+export function suggestNextPuzzleStep(currentResult) {
+    if (!currentResult)
+        return "No result to suggest from.";
+    if (currentResult.overall_completeness === "complete") {
+        return "All puzzle dimensions are complete — ready for risk calibration (stage 3).";
+    }
+    if (currentResult.overall_completeness === "empty") {
+        return "No puzzle has been initialized. Provide more concrete business intent so the primary object can be identified.";
+    }
+    const order = [
+        "permission", "treasury", "allocation", "guard", "machine",
+        "service", "order", "progress", "arb", "reward",
+        "proof", "repository", "demand", "contact",
+        "personal", "payment",
+    ];
+    const puzzles = currentResult.puzzles ?? {};
+    const ordered = order.filter((o) => puzzles[o]);
+    for (const objType of ordered) {
+        const entry = puzzles[objType];
+        if (!entry)
+            continue;
+        const missing = entry.missing_dimensions ?? [];
+        if (missing.length === 0)
+            continue;
+        const c = entry.completeness;
+        const innerNext = c && typeof c === "object" ? c.next_step : undefined;
+        if (typeof innerNext === "string" && innerNext.trim()) {
+            return `[${objType}] ${innerNext}`;
+        }
+        return `[${objType}] Complete dimension${missing.length > 1 ? "s" : ""} ${missing.join(", ")} to advance the puzzle.`;
+    }
+    return "Continue dialog to fill remaining pending fields.";
+}

package/dist/project/deployment-doc.d.ts

@@ -0,0 +1,61 @@
+import type { ProjectObjectType, IndustryMode } from "./namespace.js";
+import type { EdgeKind } from "./graph.js";
+export interface DeploymentObject {
+    entry_id: string;
+    object_type: ProjectObjectType;
+    name: string;
+    reused_from?: string;
+    publish_required: boolean;
+    description?: string;
+}
+export interface DeploymentDagEdge {
+    from: string;
+    to: string;
+    edge_kind: EdgeKind | string;
+    field_path: string;
+    required_at_publish: boolean;
+}
+export interface DeploymentScenario {
+    scenario_id: string;
+    description: string;
+    primary_object: string;
+    supporting_objects: string[];
+    test_step_refs?: string[];
+}
+export interface DeploymentStep {
+    step: number;
+    object_type: ProjectObjectType;
+    operation: string;
+    substep_count: number;
+    depends_on: number[];
+    entry_id: string;
+    network_phase: "testnet" | "mainnet" | "both";
+}
+export interface DeploymentDocInput {
+    project_prefix: string;
+    business_intent: string;
+    industry: IndustryMode | string;
+    version: string;
+    author?: string;
+    scenario_mode?: string;
+    objects: DeploymentObject[];
+    edges: DeploymentDagEdge[];
+    steps: DeploymentStep[];
+    scenarios?: DeploymentScenario[];
+    risk_status?: "RISK_PASSED" | "RISK_BLOCKED" | "RISK_PENDING_CONFIRM" | "RISK_CANCELLED";
+    risk_critical_count?: number;
+    risk_high_count?: number;
+}
+export interface DeploymentDocValidationResult {
+    valid: boolean;
+    checks: Array<{
+        check_id: string;
+        description: string;
+        status: "PASS" | "FAIL" | "WARN";
+        notes?: string;
+    }>;
+    errors: string[];
+}
+export declare function generateDeploymentDoc(input: DeploymentDocInput): string;
+export declare function validateDeploymentDoc(input: DeploymentDocInput): DeploymentDocValidationResult;
+export declare function getStandardTopoOrder(): ProjectObjectType[];