@wowok/agent-mcp 2.6.0 → 2.6.3

package/dist/schema/utils/object-type-utils.d.ts

@@ -0,0 +1,12 @@
+export declare function shortTypeName(objectType: string | null | undefined): string;
+export declare function normalizeObjectType(objectType: string | null | undefined): string;
+export declare function isObjectOfType(objectType: string | null | undefined, expectedShortName: string): boolean;
+export declare function groupObjectsByType<T extends {
+    objectType: string | null;
+}>(objects: T[]): Map<string, T[]>;
+export declare function findObjectByType<T extends {
+    objectType: string | null;
+}>(objects: T[], expectedShortName: string): T | undefined;
+export declare function countObjectsByType<T extends {
+    objectType: string | null;
+}>(objects: T[], expectedShortName: string): number;

package/dist/schema/utils/object-type-utils.js

@@ -0,0 +1,35 @@
+export function shortTypeName(objectType) {
+    if (!objectType)
+        return "unknown";
+    const base = objectType.replace(/<.*>/, "").trim();
+    const segments = base.split("::");
+    const shortName = segments[segments.length - 1] || "unknown";
+    if (shortName.length > 0 && shortName === shortName.toLowerCase()) {
+        return shortName.charAt(0).toUpperCase() + shortName.slice(1);
+    }
+    return shortName;
+}
+export function normalizeObjectType(objectType) {
+    return shortTypeName(objectType).toLowerCase();
+}
+export function isObjectOfType(objectType, expectedShortName) {
+    const normalized = normalizeObjectType(objectType);
+    const expected = expectedShortName.toLowerCase();
+    return normalized === expected;
+}
+export function groupObjectsByType(objects) {
+    const byType = new Map();
+    for (const obj of objects) {
+        const t = shortTypeName(obj.objectType);
+        if (!byType.has(t))
+            byType.set(t, []);
+        byType.get(t).push(obj);
+    }
+    return byType;
+}
+export function findObjectByType(objects, expectedShortName) {
+    return objects.find(o => isObjectOfType(o.objectType, expectedShortName));
+}
+export function countObjectsByType(objects, expectedShortName) {
+    return objects.filter(o => isObjectOfType(o.objectType, expectedShortName)).length;
+}

package/dist/schema/utils/permission-machine-check.d.ts

@@ -0,0 +1,49 @@
+export interface ForwardPermissionRef {
+    nodeName: string;
+    prevNode: string;
+    forwardName: string;
+    permissionIndex: number | null;
+    namedOperator: string | null;
+}
+export interface PermissionRefCollection {
+    indexRefs: ForwardPermissionRef[];
+    namedRefs: ForwardPermissionRef[];
+    missingRefs: ForwardPermissionRef[];
+    requiredIndexes: number[];
+}
+export interface IndexAuthorizationStatus {
+    index: number;
+    authorized: boolean;
+    entityCount: number;
+}
+export interface PermissionAuthorizationReport {
+    statuses: IndexAuthorizationStatus[];
+    missingIndexes: number[];
+    authorizedIndexes: number[];
+    allAuthorized: boolean;
+    summary: string;
+}
+export declare function collectPermissionIndexes(nodes: Array<{
+    name: string;
+    pairs?: Array<{
+        prev_node: string;
+        forwards?: Array<{
+            name: string;
+            permissionIndex?: number | null;
+            namedOperator?: string | null;
+        }>;
+    }>;
+}>): PermissionRefCollection;
+export interface PermissionObjectData {
+    address?: string;
+    entity_count?: number;
+    perm_remark?: Array<{
+        index: number;
+        remark: string;
+    }>;
+    entityPermissions?: Map<string, number[]>;
+    owner?: string;
+    admin?: string[];
+}
+export declare function checkPermissionAuthorization(requiredIndexes: number[], permission: PermissionObjectData | null | undefined): PermissionAuthorizationReport;
+export declare function formatPermissionWarning(report: PermissionAuthorizationReport): string;

package/dist/schema/utils/permission-machine-check.js

@@ -0,0 +1,121 @@
+export function collectPermissionIndexes(nodes) {
+    const indexRefs = [];
+    const namedRefs = [];
+    const missingRefs = [];
+    const requiredIndexSet = new Set();
+    for (const node of nodes) {
+        if (!node.pairs)
+            continue;
+        for (const pair of node.pairs) {
+            if (!pair.forwards)
+                continue;
+            for (const forward of pair.forwards) {
+                const ref = {
+                    nodeName: node.name,
+                    prevNode: pair.prev_node,
+                    forwardName: forward.name,
+                    permissionIndex: forward.permissionIndex ?? null,
+                    namedOperator: forward.namedOperator ?? null,
+                };
+                if (ref.permissionIndex != null) {
+                    indexRefs.push(ref);
+                    requiredIndexSet.add(ref.permissionIndex);
+                }
+                else if (ref.namedOperator != null && ref.namedOperator !== "") {
+                    namedRefs.push(ref);
+                }
+                else {
+                    missingRefs.push(ref);
+                }
+            }
+        }
+    }
+    return {
+        indexRefs,
+        namedRefs,
+        missingRefs,
+        requiredIndexes: Array.from(requiredIndexSet).sort((a, b) => a - b),
+    };
+}
+export function checkPermissionAuthorization(requiredIndexes, permission) {
+    const BUILTIN_THRESHOLD = 1000;
+    const statuses = [];
+    const missingIndexes = [];
+    const authorizedIndexes = [];
+    for (const index of requiredIndexes) {
+        if (index < BUILTIN_THRESHOLD) {
+            statuses.push({ index, authorized: true, entityCount: -1 });
+            authorizedIndexes.push(index);
+            continue;
+        }
+        let authorized = false;
+        let entityCount = 0;
+        if (permission?.entityPermissions) {
+            for (const perms of permission.entityPermissions.values()) {
+                if (perms.includes(index)) {
+                    entityCount++;
+                }
+            }
+            authorized = entityCount > 0;
+        }
+        else if (permission?.perm_remark && permission.perm_remark.length > 0) {
+            authorized = permission.perm_remark.some(r => r.index === index);
+            entityCount = authorized ? -1 : 0;
+        }
+        else {
+            authorized = true;
+            entityCount = -1;
+        }
+        statuses.push({ index, authorized, entityCount });
+        if (authorized) {
+            authorizedIndexes.push(index);
+        }
+        else {
+            missingIndexes.push(index);
+        }
+    }
+    const allAuthorized = missingIndexes.length === 0;
+    const summary = allAuthorized
+        ? `All ${requiredIndexes.length} required permission index(es) are authorized.`
+        : `${missingIndexes.length}/${requiredIndexes.length} required permission index(es) are NOT authorized: [${missingIndexes.join(", ")}]. ` +
+            `Forwards using these indexes will be un-executable — Progress will be stuck. ` +
+            `Grant entities for these indexes via permission.op="add perm by index" before publishing the Machine.`;
+    return {
+        statuses,
+        missingIndexes,
+        authorizedIndexes,
+        allAuthorized,
+        summary,
+    };
+}
+export function formatPermissionWarning(report) {
+    if (report.allAuthorized) {
+        return "";
+    }
+    const lines = [
+        "CRITICAL PRE-PUBLISH: Machine forwards reference permission indexes that are NOT authorized in the Permission object.",
+        "",
+        `Missing indexes (no entities granted): ${report.missingIndexes.join(", ")}`,
+        "",
+        "Impact: Forwards using these indexes can NEVER be executed — Progress will be permanently stuck at the source node.",
+        "Buyer funds may be trapped if the workflow cannot advance past the stuck node.",
+        "",
+        "To fix BEFORE publishing:",
+        '  1. Call onchain_operations with op="permission"',
+        '  2. Set object=<your_permission_name_or_address>',
+        '  3. Set permission.op="add perm by index"',
+        "  4. Set index=<missing_index> for each missing index",
+        '  5. Set entity=["<entity_address>"] — the address that should be authorized',
+        "  6. After granting all missing indexes, re-attempt the Machine publish.",
+        "",
+        "Required permission indexes for this Machine:",
+    ];
+    for (const status of report.statuses) {
+        const state = status.authorized ? "AUTHORIZED" : "MISSING";
+        const count = status.entityCount === -1
+            ? "(built-in or heuristic)"
+            : `(${status.entityCount} entity/entities)`;
+        lines.push(`  - Index ${status.index}: ${state} ${count}`);
+    }
+    return lines.join("\n");
+}

package/dist/schema/utils/skills-recommendation.d.ts

@@ -0,0 +1,2 @@
+export declare function getSkillsHintForOnchain(operationType: string, data?: unknown): string | undefined;
+export declare function getSkillsHintForProject(action: string): string | undefined;

package/dist/schema/utils/skills-recommendation.js

@@ -0,0 +1,76 @@
+const SKILLS_BY_OPERATION_TYPE = {
+    service: ["wowok-provider", "wowok-safety"],
+    machine: ["wowok-machine"],
+    guard: ["wowok-guard"],
+    arbitration: ["wowok-arbitrator"],
+    allocation: ["wowok-provider"],
+    permission: ["wowok-safety"],
+    treasury: ["wowok-provider", "wowok-safety"],
+    reward: ["wowok-provider"],
+    repository: ["wowok-provider"],
+    demand: ["wowok-provider"],
+    contact: ["wowok-messenger"],
+    order: ["wowok-order"],
+    progress: [],
+    personal: [],
+    payment: [],
+    proof: [],
+};
+const SKILLS_BY_PROJECT_ACTION = {
+    create_project: ["wowok-onboard", "wowok-planner"],
+    create_project_from_onchain: ["wowok-onboard"],
+    evaluate_project: ["wowok-auditor"],
+    pre_evaluate_check: ["wowok-auditor"],
+    verify_deployment: ["wowok-auditor"],
+    generate_deployment_doc: ["wowok-planner"],
+    migrate_to_mainnet: ["wowok-onboard", "wowok-safety"],
+    migrate_network: ["wowok-onboard"],
+    clone_project_to_network: ["wowok-onboard"],
+    build_graph: ["wowok-planner"],
+    list_projects: [],
+    get_project_detail: [],
+    update_project: [],
+    add_object: [],
+    remove_object: [],
+    update_object: [],
+    create_version: [],
+    get_graph: [],
+    save_evaluation: [],
+    compare_projects: [],
+    refresh_objects: [],
+    get_object_diff: [],
+    delete_project: [],
+    assemble_context: [],
+    get_machine_graph: ["wowok-machine"],
+    get_guard_graph: ["wowok-guard"],
+    plan_object_edit: ["wowok-machine", "wowok-guard", "wowok-auditor"],
+    apply_object_edit: ["wowok-safety"],
+    patch_machine_nodes: ["wowok-machine"],
+    patch_guard_tree: ["wowok-guard"],
+};
+export function getSkillsHintForOnchain(operationType, data) {
+    const skills = SKILLS_BY_OPERATION_TYPE[operationType];
+    if (!skills || skills.length === 0)
+        return undefined;
+    const isPublish = data?.publish === true;
+    const hasOrderAllocators = !!data?.order_allocators;
+    const isComplex = isPublish || hasOrderAllocators;
+    const prefix = isComplex
+        ? "SKILLS RECOMMENDED (complex operation — skills provide business-semantic guidance):"
+        : "SKILLS RECOMMENDED (optional — skills provide deeper guidance):";
+    return `${prefix} ${skills.join(", ")}. ` +
+        `skills focus on business intent → object parameter translation; ` +
+        `MCP handles object structure and on-chain execution. ` +
+        `If skills are installed, consult them BEFORE this call for design rationale. ` +
+        `If not installed, MCP executes independently — this hint is informational only.`;
+}
+export function getSkillsHintForProject(action) {
+    const skills = SKILLS_BY_PROJECT_ACTION[action];
+    if (!skills || skills.length === 0)
+        return undefined;
+    return `SKILLS RECOMMENDED (optional — skills provide deeper guidance): ${skills.join(", ")}. ` +
+        `skills focus on business intent → object parameter translation; ` +
+        `MCP handles project structure and evaluation. ` +
+        `If skills are installed, consult them for design/planning rationale. ` +
+        `If not installed, MCP executes independently — this hint is informational only.`;
+}

package/dist/schema-query/index.d.ts

@@ -1,3 +1,4 @@
+export declare const EXAMPLES_DIR: string;
 export interface SchemaInfo {
     name: string;
     title: string;
@@ -6,9 +7,23 @@ export interface SchemaInfo {
     outputPath?: string;
 }
 export interface SchemaQueryRequest {
-    action: "list" | "get" | "search" | "list_operations" | "get_output";
+    action: "list" | "get" | "search" | "list_operations" | "get_output" | "get_guard_templates" | "get_field" | "search_examples";
     name?: string;
     query?: string;
+    field_path?: string;
+    template?: string;
+    output_file?: string;
+}
+export interface ExampleSearchResult {
+    file: string;
+    title: string;
+    description: string;
+    tags: string[];
+    industry: string;
+    operation_type: string;
+    verified: boolean;
+    score: number;
+    matched_fields: string[];
 }
 export interface SchemaQueryResponse {
     [key: string]: unknown;
@@ -17,6 +32,7 @@ export interface SchemaQueryResponse {
     data: any;
     message: string;
     suggestions?: string[];
+    output_file_path?: string;
 }
 export declare function areSchemasAvailable(): boolean;
 export declare function getSchemaIndex(): {
@@ -26,6 +42,9 @@ export declare function getSchemaIndex(): {
 export declare function listSchemas(): SchemaInfo[];
 export declare function getSchema(name: string): any | null;
 export declare function getOutputSchema(name: string): any | null;
+export declare function getGuardTemplates(templateName?: string): any | null;
+export declare function searchExamples(query: string): ExampleSearchResult[];
+export declare function getSchemaField(name: string, fieldPath: string): any | null;
 export declare function searchSchemas(query: string): SchemaInfo[];
 export declare function listOperations(): SchemaInfo[];
 export declare function processSchemaQuery(request: SchemaQueryRequest): SchemaQueryResponse;