@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/tools/handlers/onchain.js

@@ -0,0 +1,248 @@
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import { CallService, CallMachine, CallProgress, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, CallProof, gen_proof, parseGuardFile, formatGuardParseErrors, transformRewardInput, transformPersonalInput, } from "@wowok/wowok";
+import { OnchainOperationsSchema, strictParse, getEnvConfig, handleCallResult, checkClientSchemaCompatibility, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, transformSubmission, } from "../../schema/index.js";
+import { handlePermissionOperations } from "../../schema/call/permission-handler.js";
+import { isProjectServiceEnabled, normalize as projectNormalize, } from "../../project/index.js";
+import { withHarness } from "../shared.js";
+export async function handleOnchainOperations(args) {
+    let validated;
+    let constraintWarnings = [];
+    let projectWarnings = [];
+    try {
+        if (typeof args === 'object' && args !== null
+            && 'description' in args && !('operation_type' in args)) {
+            const desc = args.description;
+            const hasWrappedParams = typeof desc === 'string' &&
+                (desc.includes('operation_type') || desc.includes('data'));
+            if (hasWrappedParams) {
+                throw new Error("Invalid parameter structure. Parameters should NOT be wrapped in 'description' field.\n" +
+                    "Correct format: { operation_type: '...', data: {...} }\n" +
+                    "Incorrect format: { description: '{ operation_type: ... }' }");
+            }
+        }
+        validated = strictParse(OnchainOperationsSchema, args, "onchain_operations input");
+        const env = getEnvConfig(validated.env);
+        const clientSchemaVersion = env.client_schema_version;
+        const schemaStrictMode = env.schema_strict_mode;
+        const schemaCheck = clientSchemaVersion
+            ? checkClientSchemaCompatibility(clientSchemaVersion, { mode: schemaStrictMode ? "strict" : "warn" })
+            : undefined;
+        const buildCtx = (data) => ({
+            operation_type: validated.operation_type,
+            data,
+            pre_warnings: [...constraintWarnings, ...projectWarnings].length
+                ? [...constraintWarnings, ...projectWarnings]
+                : undefined,
+            schema_check: schemaCheck,
+        });
+        const projectEnvPrefix = env.project;
+        if (isProjectServiceEnabled() && 'data' in validated && validated.data) {
+            const pn = projectNormalize({
+                operation_type: validated.operation_type,
+                data: validated.data,
+                projectPrefix: projectEnvPrefix,
+            });
+            validated.data = pn.data;
+            projectWarnings = pn.warnings ?? [];
+        }
+        delete env.confirmed;
+        delete env.user_intent_phrases;
+        delete env.project;
+        delete env.client_schema_version;
+        delete env.schema_strict_mode;
+        switch (validated.operation_type) {
+            case "service": {
+                const callService = new CallService(validated.data);
+                const result = validated.submission
+                    ? await callService.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callService.call(env);
+                const data = validated.data;
+                const intent = data?.publish ? "publish service" : data?.bPublished !== undefined ? "modify service" : "create service";
+                return handleCallResult(result, withHarness(buildCtx(data), "service", intent));
+            }
+            case "machine": {
+                if (validated.data.node && typeof validated.data.node === 'object' && 'json_or_markdown_file' in validated.data.node) {
+                    const filePathStr = validated.data.node.json_or_markdown_file;
+                    let fileContent;
+                    try {
+                        const filePath = resolve(filePathStr);
+                        fileContent = readFileSync(filePath, 'utf-8');
+                    }
+                    catch (e) {
+                        throw new Error(`Failed to read file '${filePathStr}': ${e.message}`);
+                    }
+                    const parseResult = parseMachineNodesFromText(fileContent);
+                    if (!parseResult.success) {
+                        const errorMessages = formatMachineNodeErrors(parseResult.errors);
+                        throw new Error(`Machine node validation failed for file '${filePathStr}':\n\n${errorMessages}`);
+                    }
+                    if (!parseResult.data) {
+                        throw new Error(`No nodes found in file '${filePathStr}'`);
+                    }
+                    validated.data.node = {
+                        op: "set",
+                        nodes: parseResult.data,
+                        bReplace: true
+                    };
+                }
+                const callMachine = new CallMachine(validated.data);
+                const result = validated.submission
+                    ? await callMachine.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callMachine.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "progress": {
+                const callProgress = new CallProgress(validated.data);
+                const result = validated.submission
+                    ? await callProgress.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callProgress.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "repository": {
+                const callRepository = new CallRepository(validated.data);
+                const result = validated.submission
+                    ? await callRepository.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callRepository.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "arbitration": {
+                const callArbitration = new CallArbitration(validated.data);
+                const result = validated.submission
+                    ? await callArbitration.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callArbitration.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "contact": {
+                const callContact = new CallContact(validated.data);
+                const result = validated.submission
+                    ? await callContact.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callContact.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "treasury": {
+                const callTreasury = new CallTreasury(validated.data);
+                const result = validated.submission
+                    ? await callTreasury.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callTreasury.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "reward": {
+                const transformedData = transformRewardInput(validated.data);
+                const callReward = new CallReward(transformedData);
+                const result = validated.submission
+                    ? await callReward.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callReward.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "allocation": {
+                const callAllocation = new CallAllocation(validated.data);
+                const result = validated.submission
+                    ? await callAllocation.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callAllocation.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "permission": {
+                return handlePermissionOperations(validated.data, env, buildCtx);
+            }
+            case "guard": {
+                const validatedData = validated.data;
+                if (validatedData.root?.type === "file") {
+                    const filePath = resolve(validatedData.root.file_path);
+                    let fileContent;
+                    try {
+                        fileContent = readFileSync(filePath, 'utf-8');
+                    }
+                    catch (e) {
+                        throw new Error(`Failed to read Guard definition file '${validatedData.root.file_path}': ${e.message}`);
+                    }
+                    const parseResult = parseGuardFile(fileContent, validatedData.root.format);
+                    if (!parseResult.success) {
+                        const errorMessages = formatGuardParseErrors(parseResult.errors);
+                        throw new Error(`Guard validation failed for file '${validatedData.root.file_path}':\n\n${errorMessages}`);
+                    }
+                    const fileData = parseResult.data;
+                    validatedData.root = { type: "node", node: fileData.root };
+                    if (fileData.table !== undefined && validatedData.table === undefined) {
+                        validatedData.table = fileData.table;
+                    }
+                    if (fileData.description !== undefined && validatedData.description === undefined) {
+                        validatedData.description = fileData.description;
+                    }
+                    if (fileData.rely !== undefined && validatedData.rely === undefined) {
+                        validatedData.rely = fileData.rely;
+                    }
+                    if (fileData.namedNew !== undefined && validatedData.namedNew === undefined) {
+                        validatedData.namedNew = fileData.namedNew;
+                    }
+                }
+                if (validatedData.root && typeof validatedData.root === 'object') {
+                    const rootObj = validatedData.root;
+                    if (rootObj.type === 'node' && rootObj.node) {
+                        validatedData.root = rootObj.node;
+                    }
+                }
+                if (!validatedData.table || validatedData.table.length === 0) {
+                    throw new Error("Guard 'table' field is required and cannot be empty");
+                }
+                if (!validatedData.root) {
+                    throw new Error("Guard 'root' field is required");
+                }
+                const callGuard = new CallGuard(validatedData);
+                const result = await callGuard.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "personal": {
+                const transformedData = transformPersonalInput(validated.data);
+                const callPersonal = new CallPersonal(transformedData);
+                const result = await callPersonal.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "payment": {
+                const callPayment = new CallPayment(validated.data);
+                const result = await callPayment.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "demand": {
+                const callDemand = new CallDemand(validated.data);
+                const result = validated.submission
+                    ? await callDemand.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callDemand.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "order": {
+                const callOrder = new CallOrder(validated.data);
+                const result = validated.submission
+                    ? await callOrder.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callOrder.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "gen_passport": {
+                const result = await gen_passport(env, validated.guard, validated.info);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "proof": {
+                const callProof = new CallProof(validated.data);
+                const result = validated.submission
+                    ? await callProof.call_with_submission(env, await transformSubmission(validated.submission))
+                    : await callProof.call(env);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+            case "gen_proof": {
+                const result = await gen_proof(env, validated.proof, validated.server_pubkey, validated.server_signature, validated.proof_type, validated.description, validated.item_count, validated.about_address);
+                return handleCallResult(result, buildCtx(validated.data));
+            }
+        }
+        const exhaustiveOp = validated;
+        throw new Error(`Unknown on-chain operation type: ${String(exhaustiveOp.operation_type)}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const opType = validated?.operation_type;
+        const ctxData = validated && 'data' in validated ? validated.data : undefined;
+        return handleCallResult({ error: errorMessage }, opType ? {
+            operation_type: opType,
+            data: ctxData,
+        } : undefined);
+    }
+}

package/dist/tools/handlers/project.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDispatchResult } from "../types.js";
+export declare function handleProjectOperation(args: unknown): Promise<ToolDispatchResult>;

package/dist/tools/handlers/project.js

@@ -0,0 +1,293 @@
+import { queryProjects, queryProjectObjects, queryShareableObjects, queryDependencies, queryReferencedBy, queryPrePublishCheck, queryCrossProjectReferences, queryGraphStats, saveGraph, loadGraph, } from "../../project/index.js";
+import { analyzeBusinessIntent } from "../../project/business-puzzle.js";
+import { aggregateProjectRisks } from "../../project/risk-aggregator.js";
+import { generateDeploymentDoc, validateDeploymentDoc, } from "../../project/deployment-doc.js";
+import { traceSubsteps } from "../../project/substep-trace.js";
+import { strictParse } from "../../schema/index.js";
+import { ProjectOperationInputSchema } from "../../schema/project/index.js";
+import { injectEvolutionContext } from "../../knowledge/flywheel-loop.js";
+import { getExperienceFeedback } from "../../experience/index.js";
+function requireProject(v) {
+    if (!v.project) {
+        throw new Error("'project' (prefix) is required for this action");
+    }
+    if (!v.version) {
+        throw new Error("'version' is required for this action (e.g. 'v1')");
+    }
+    return { prefix: v.project, version: v.version };
+}
+function requireUserIntent(v) {
+    if (!v.user_intent) {
+        throw new Error("'user_intent' is required for analyze_intent");
+    }
+    return v.user_intent;
+}
+function requirePuzzles(v) {
+    if (!v.puzzles || Object.keys(v.puzzles).length === 0) {
+        throw new Error("'puzzles' is required for this action (obtain from analyze_intent)");
+    }
+    return v.puzzles;
+}
+function requireDeploymentInputs(v) {
+    if (!v.business_intent) {
+        throw new Error("'business_intent' is required for generate_deployment_doc");
+    }
+    if (!v.objects || v.objects.length === 0) {
+        throw new Error("'objects' is required for generate_deployment_doc");
+    }
+    if (!v.edges) {
+        throw new Error("'edges' is required for generate_deployment_doc");
+    }
+    if (!v.steps) {
+        throw new Error("'steps' is required for generate_deployment_doc");
+    }
+    return {
+        business_intent: v.business_intent,
+        objects: v.objects,
+        edges: v.edges,
+        steps: v.steps,
+    };
+}
+function requireSubsteps(v) {
+    if (!v.network) {
+        throw new Error("'network' is required for trace_substeps");
+    }
+    if (v.network !== "testnet" && v.network !== "mainnet") {
+        throw new Error("'network' must be 'testnet' or 'mainnet'");
+    }
+    if (!v.substeps || v.substeps.length === 0) {
+        throw new Error("'substeps' is required for trace_substeps");
+    }
+    return {
+        network: v.network,
+        substeps: v.substeps,
+    };
+}
+async function handleAnalyzeIntent(validated) {
+    const { prefix, version } = requireProject(validated);
+    const userIntent = requireUserIntent(validated);
+    const result = analyzeBusinessIntent({
+        user_intent: userIntent,
+        project_name: `${prefix}_${version}`,
+        industry: validated.industry,
+        target_objects: validated.target_objects,
+    });
+    const industry = validated.industry ?? "general";
+    let evolutionContext;
+    let experienceFeedback;
+    try {
+        evolutionContext = injectEvolutionContext(undefined, industry);
+    }
+    catch {
+        evolutionContext = undefined;
+    }
+    try {
+        experienceFeedback = getExperienceFeedback("analyze_intent", { user_intent: userIntent, industry, target_objects: validated.target_objects }, `project:analyze_intent`);
+    }
+    catch {
+        experienceFeedback = undefined;
+    }
+    return {
+        action: "analyze_intent",
+        intent_parsed: result.intent_parsed,
+        puzzles: result.puzzles,
+        overall_completeness: result.overall_completeness,
+        next_step: result.next_step,
+        warnings: result.warnings,
+        evolution_context: evolutionContext,
+        experience_feedback: experienceFeedback,
+    };
+}
+async function handleAggregateRisks(validated) {
+    const { prefix, version } = requireProject(validated);
+    const puzzles = requirePuzzles(validated);
+    const result = aggregateProjectRisks({
+        project_prefix: prefix,
+        version: version,
+        industry: validated.industry,
+        puzzles,
+        severity_threshold: validated.severity_threshold,
+        user_confirmed_high_risks: validated.user_confirmed_high_risks,
+    });
+    const hasCritical = result.severity_summary.CRITICAL > 0;
+    const unconfirmedHigh = result.findings.filter((r) => r.severity === "HIGH").length;
+    return {
+        action: "aggregate_risks",
+        namespace: result.namespace,
+        findings: result.findings,
+        severity_summary: result.severity_summary,
+        status: result.status,
+        pending_confirmations: result.pending_confirmations,
+        calibrated_at: result.calibrated_at,
+        warnings: result.warnings,
+        can_proceed: !hasCritical,
+        user_action_required: hasCritical
+            ? `Fix ${result.severity_summary.CRITICAL} CRITICAL risk(s) before proceeding`
+            : unconfirmedHigh > 0
+                ? `Review ${unconfirmedHigh} HIGH risk(s). You may proceed at your own risk.`
+                : "All risks reviewed. You may proceed.",
+    };
+}
+async function handleGenerateDeploymentDoc(validated) {
+    const { prefix, version } = requireProject(validated);
+    const required = requireDeploymentInputs(validated);
+    const docInput = {
+        project_prefix: prefix,
+        version: version,
+        business_intent: required.business_intent,
+        industry: validated.industry ?? "general",
+        author: validated.author,
+        objects: required.objects,
+        edges: required.edges,
+        steps: required.steps,
+        scenarios: validated.scenarios,
+        risk_status: validated.risk_status,
+        risk_critical_count: validated.risk_critical_count,
+        risk_high_count: validated.risk_high_count,
+    };
+    const markdown = generateDeploymentDoc(docInput);
+    const generatedAt = new Date().toISOString();
+    const shouldRunScanner = validated.run_scanner !== false;
+    let validationResult;
+    if (shouldRunScanner) {
+        const validation = validateDeploymentDoc(docInput);
+        validationResult = {
+            valid: validation.valid,
+            checks: validation.checks,
+            errors: validation.errors,
+        };
+    }
+    const errorCount = validationResult
+        ? validationResult.checks.filter((c) => c.status === "FAIL").length
+        : 0;
+    const warningCount = validationResult
+        ? validationResult.checks.filter((c) => c.status === "WARN").length
+        : 0;
+    return {
+        action: "generate_deployment_doc",
+        markdown,
+        meta: {
+            project_prefix: prefix,
+            version: version,
+            generated_at: generatedAt,
+            object_count: required.objects.length,
+            step_count: required.steps.length,
+        },
+        validation: validationResult,
+        can_proceed: errorCount === 0,
+        user_action_required: errorCount > 0
+            ? `Fix ${errorCount} D-error(s) before deploying`
+            : warningCount > 0
+                ? `${warningCount} D-warning(s) found. You may proceed at your own risk.`
+                : "Deployment document ready. You may proceed to stage 5.",
+    };
+}
+async function handleTraceSubsteps(validated) {
+    const { prefix, version } = requireProject(validated);
+    const { network, substeps } = requireSubsteps(validated);
+    const result = traceSubsteps({
+        project_prefix: prefix,
+        version: version,
+        network: network,
+        substeps,
+    });
+    const hasFailedSubstep = substeps.some((s) => s.status === "FAILED");
+    const canProceed = result.coherent && !hasFailedSubstep;
+    const issueParts = [];
+    if (result.dangling_inputs.length > 0) {
+        issueParts.push(`${result.dangling_inputs.length} dangling inputs`);
+    }
+    if (result.circular_refs.length > 0) {
+        issueParts.push(`${result.circular_refs.length} circular refs`);
+    }
+    if (result.missing_outputs.length > 0) {
+        issueParts.push(`${result.missing_outputs.length} missing outputs`);
+    }
+    if (result.cross_step_breaks.length > 0) {
+        issueParts.push(`${result.cross_step_breaks.length} cross-step breaks`);
+    }
+    if (hasFailedSubstep) {
+        const failedCount = substeps.filter((s) => s.status === "FAILED").length;
+        issueParts.push(`${failedCount} failed substep(s)`);
+    }
+    return {
+        action: "trace_substeps",
+        namespace: result.namespace,
+        network: result.network,
+        coherent: result.coherent,
+        dangling_inputs: result.dangling_inputs,
+        circular_refs: result.circular_refs,
+        missing_outputs: result.missing_outputs,
+        cross_step_breaks: result.cross_step_breaks,
+        step_details: result.step_details,
+        topological_order: result.topological_order,
+        d10_check: result.d10_check,
+        can_proceed: canProceed,
+        user_action_required: issueParts.length > 0
+            ? `Fix: ${issueParts.join(", ")}`
+            : "All substeps passed. Deployment complete.",
+    };
+}
+export async function handleProjectOperation(args) {
+    const validated = strictParse(ProjectOperationInputSchema, args, "project_operation input");
+    const { action } = validated;
+    let result;
+    switch (action) {
+        case "list_projects":
+            result = { action: "list_projects", items: await queryProjects() };
+            break;
+        case "list_objects":
+            if (!validated.project)
+                throw new Error("'project' param is required for list_objects");
+            result = { action: "list_objects", items: await queryProjectObjects(validated.project) };
+            break;
+        case "shareable":
+            result = { action: "shareable", items: await queryShareableObjects() };
+            break;
+        case "dependencies":
+            if (!validated.object)
+                throw new Error("'object' param is required for dependencies");
+            result = { action: "dependencies", items: queryDependencies(validated.object) };
+            break;
+        case "referenced_by":
+            if (!validated.object)
+                throw new Error("'object' param is required for referenced_by");
+            result = { action: "referenced_by", items: queryReferencedBy(validated.object) };
+            break;
+        case "pre_publish_check":
+            if (!validated.object)
+                throw new Error("'object' param is required for pre_publish_check");
+            result = { action: "pre_publish_check", warnings: queryPrePublishCheck(validated.object) };
+            break;
+        case "cross_project_refs":
+            result = { action: "cross_project_refs", items: queryCrossProjectReferences() };
+            break;
+        case "graph_stats":
+            result = { action: "graph_stats", stats: queryGraphStats() };
+            break;
+        case "save_graph":
+            result = { action: "save_graph", saved: true, path: saveGraph() };
+            break;
+        case "load_graph":
+            result = { action: "load_graph", loaded: loadGraph() };
+            break;
+        case "analyze_intent":
+            result = await handleAnalyzeIntent(validated);
+            break;
+        case "aggregate_risks":
+            result = await handleAggregateRisks(validated);
+            break;
+        case "generate_deployment_doc":
+            result = await handleGenerateDeploymentDoc(validated);
+            break;
+        case "trace_substeps":
+            result = await handleTraceSubsteps(validated);
+            break;
+        default:
+            throw new Error(`Unknown project_operation action: ${String(action)}`);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: { result },
+    };
+}

package/dist/tools/handlers/query.d.ts

@@ -0,0 +1,5 @@
+import type { ToolDispatchResult } from "../types.js";
+export declare function handleWatchQueryOperations(args: unknown): Promise<ToolDispatchResult>;
+export declare function handleOnchainTableData(args: unknown): Promise<ToolDispatchResult>;
+export declare function handleOnchainEvents(args: unknown): Promise<ToolDispatchResult>;
+export declare function handleWowokInfo(args: unknown): Promise<ToolDispatchResult>;