@wowok/agent-mcp 2.3.18 → 2.4.3

package/dist/knowledge/guard-migration.d.ts

@@ -0,0 +1,48 @@
+export type GuardNodeType = 'logic_or' | 'logic_and' | 'logic_not' | 'logic_equal' | 'logic_string_nocase_equal' | 'logic_as_u256_equal' | 'logic_string_contains' | 'logic_string_nocase_contains' | 'logic_as_u256_greater' | 'logic_as_u256_lesser' | 'logic_as_u256_greater_or_equal' | 'logic_as_u256_lesser_or_equal' | 'vec_contains_string' | 'vec_contains_string_nocase' | 'vec_contains_address' | 'vec_contains_number' | 'vec_contains_bool' | 'identifier' | 'query' | 'context' | 'calc_number_add' | 'calc_number_subtract' | 'calc_number_multiply' | 'calc_number_divide' | 'calc_number_mod' | string;
+export interface GuardNode {
+    type: GuardNodeType;
+    nodes?: GuardNode[];
+    node?: GuardNode;
+    identifier?: number;
+    query?: string | number;
+    context?: string;
+    object?: {
+        identifier?: number;
+        convert_witness?: string | number;
+    };
+    parameters?: unknown[];
+}
+export interface GuardTableEntry {
+    identifier: number;
+    b_submission?: boolean;
+    value_type?: string | number;
+    value?: unknown;
+    name?: string;
+}
+export type VecContainsTarget = 'vec_contains_string' | 'vec_contains_string_nocase' | 'vec_contains_address' | 'vec_contains_number' | 'vec_contains_bool';
+export type VecValueType = 'VecString' | 'VecAddress' | 'VecU64' | 'VecU128' | 'VecU256' | 'VecU8' | 'VecU16' | 'VecU32' | 'VecBool';
+export interface ConversionResult {
+    convertible: boolean;
+    targetOperator?: VecContainsTarget;
+    vectorValueType?: VecValueType;
+    sharedNode?: GuardNode;
+    constants?: Array<{
+        identifier: number;
+        value: unknown;
+        value_type: string;
+    }>;
+    reasons?: string[];
+}
+export declare function analyzeLogicOrConversion(orNode: GuardNode, table: GuardTableEntry[]): ConversionResult;
+export interface ShorthandResult {
+    newRoot: GuardNode;
+    removeIdentifiers: number[];
+    addEntry: {
+        identifier: number;
+        b_submission: false;
+        value_type: VecValueType;
+        value: unknown[];
+        name: string;
+    };
+}
+export declare function buildShorthand(orNode: GuardNode, result: ConversionResult, newIdentifier: number): ShorthandResult | null;

package/dist/knowledge/guard-migration.js

@@ -0,0 +1,228 @@
+const EQUAL_OPERATORS = new Set([
+    'logic_equal',
+    'logic_string_nocase_equal',
+    'logic_as_u256_equal',
+]);
+function mapOperatorToTarget(operator, valueType) {
+    if (valueType === 'String' || valueType === 2) {
+        if (operator === 'logic_string_nocase_equal') {
+            return { target: 'vec_contains_string_nocase', vecType: 'VecString' };
+        }
+        if (operator === 'logic_equal') {
+            return { target: 'vec_contains_string', vecType: 'VecString' };
+        }
+        return null;
+    }
+    if (valueType === 'Address' || valueType === 1) {
+        if (operator === 'logic_equal') {
+            return { target: 'vec_contains_address', vecType: 'VecAddress' };
+        }
+        return null;
+    }
+    if (valueType === 'Bool' || valueType === 0) {
+        if (operator === 'logic_equal') {
+            return { target: 'vec_contains_bool', vecType: 'VecBool' };
+        }
+        return null;
+    }
+    const numericTypes = new Set([
+        'U8', 'U16', 'U32', 'U64', 'U128', 'U256',
+        3, 4, 5, 6, 7, 8,
+    ]);
+    if (numericTypes.has(valueType)) {
+        if (operator === 'logic_equal' || operator === 'logic_as_u256_equal') {
+            return { target: 'vec_contains_number', vecType: 'VecU256' };
+        }
+        return null;
+    }
+    return null;
+}
+export function analyzeLogicOrConversion(orNode, table) {
+    const reasons = [];
+    if (orNode.type !== 'logic_or') {
+        return {
+            convertible: false,
+            reasons: [`Node type is '${orNode.type}', not 'logic_or'. Only logic_or nodes are candidates.`],
+        };
+    }
+    const children = orNode.nodes ?? [];
+    if (children.length < 2) {
+        return {
+            convertible: false,
+            reasons: [`logic_or has ${children.length} children; need at least 2 to convert.`],
+        };
+    }
+    if (children.length > 7) {
+        return {
+            convertible: false,
+            reasons: [
+                `logic_or has ${children.length} children; vec_contains_* supports at most 7 needles (1 haystack + 7 needles = 8 node limit). Keep the logic_or.`,
+            ],
+        };
+    }
+    const childOperators = new Set();
+    for (const child of children) {
+        if (!EQUAL_OPERATORS.has(child.type)) {
+            if (child.type === 'logic_string_contains' || child.type === 'logic_string_nocase_contains') {
+                reasons.push(`Child uses '${child.type}' (substring match). vec_contains_* is whole-element membership, NOT substring. Cannot convert.`);
+            }
+            else if (child.type?.startsWith('logic_as_u256_greater') || child.type?.startsWith('logic_as_u256_lesser')) {
+                reasons.push(`Child uses '${child.type}' (ordering comparison). vec_contains_* is membership, not ordering. Cannot convert.`);
+            }
+            else if (child.type === 'logic_and' || child.type === 'logic_or' || child.type === 'logic_not') {
+                reasons.push(`Child is a nested logic node ('${child.type}'). Only leaf equal-style comparisons are convertible.`);
+            }
+            else {
+                reasons.push(`Child uses '${child.type}' which is not an equal-style operator (logic_equal / logic_string_nocase_equal / logic_as_u256_equal).`);
+            }
+            return { convertible: false, reasons };
+        }
+        childOperators.add(child.type);
+    }
+    if (childOperators.size > 1) {
+        const opList = Array.from(childOperators).join(', ');
+        return {
+            convertible: false,
+            reasons: [
+                `Children use mixed operators: [${opList}]. Mixing case-sensitive (logic_equal) and case-insensitive (logic_string_nocase_equal) comparisons would change semantics. Keep the logic_or.`,
+            ],
+        };
+    }
+    const sharedOperator = children[0].type;
+    for (let i = 0; i < children.length; i++) {
+        const childNodes = children[i].nodes ?? [];
+        if (childNodes.length !== 2) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} ('${sharedOperator}') has ${childNodes.length} sub-nodes; expected exactly 2 (one constant side + one shared query side).`,
+                ],
+            };
+        }
+    }
+    const constants = [];
+    let sharedNode = null;
+    let sharedNodeSerial = null;
+    for (let i = 0; i < children.length; i++) {
+        const childNodes = children[i].nodes;
+        const left = childNodes[0];
+        const right = childNodes[1];
+        const leftIsConstId = left.type === 'identifier' && typeof left.identifier === 'number';
+        const rightIsConstId = right.type === 'identifier' && typeof right.identifier === 'number';
+        if (!leftIsConstId && !rightIsConstId) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} has no constant identifier side (both sub-nodes are non-identifier). Conversion requires one side to be a constant table entry.`,
+                ],
+            };
+        }
+        if (leftIsConstId && rightIsConstId) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} has two identifier sides. Conversion requires one side to be a non-constant (query/context/calc) node shared across all children.`,
+                ],
+            };
+        }
+        const constIdNode = leftIsConstId ? left : right;
+        const nonConstNode = leftIsConstId ? right : left;
+        const tableEntry = table.find((e) => e.identifier === constIdNode.identifier);
+        if (!tableEntry) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} references identifier[${constIdNode.identifier}] which is not in the table.`,
+                ],
+            };
+        }
+        if (tableEntry.b_submission !== false) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} references identifier[${constIdNode.identifier}] with b_submission=${tableEntry.b_submission}. Conversion requires compile-time constants (b_submission=false).`,
+                ],
+            };
+        }
+        if (tableEntry.value === undefined || tableEntry.value === null) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} references identifier[${constIdNode.identifier}] which has no 'value' field. Conversion requires explicit constant values.`,
+                ],
+            };
+        }
+        const nonConstSerial = JSON.stringify(nonConstNode);
+        if (sharedNodeSerial === null) {
+            sharedNodeSerial = nonConstSerial;
+            sharedNode = nonConstNode;
+        }
+        else if (sharedNodeSerial !== nonConstSerial) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i}'s non-constant side differs from child 0's. All children must share the SAME non-constant node (same query, same convert_witness, same parameters). Keep the logic_or.`,
+                ],
+            };
+        }
+        constants.push({
+            identifier: constIdNode.identifier,
+            value: tableEntry.value,
+            value_type: String(tableEntry.value_type ?? ''),
+        });
+    }
+    const valueTypes = new Set(constants.map((c) => c.value_type));
+    if (valueTypes.size > 1) {
+        return {
+            convertible: false,
+            reasons: [
+                `Constants have mixed value_types: [${Array.from(valueTypes).join(', ')}]. All constants must share the same type to form a single VecXxx.`,
+            ],
+        };
+    }
+    const sharedValueType = constants[0].value_type;
+    const mapping = mapOperatorToTarget(sharedOperator, sharedValueType);
+    if (!mapping) {
+        return {
+            convertible: false,
+            reasons: [
+                `No vec_contains_* variant maps to operator='${sharedOperator}' with value_type='${sharedValueType}'. ` +
+                    `Mappable combinations: (logic_string_nocase_equal, String)→vec_contains_string_nocase; ` +
+                    `(logic_equal, String)→vec_contains_string; (logic_equal, Address)→vec_contains_address; ` +
+                    `(logic_equal, Bool)→vec_contains_bool; (logic_equal|logic_as_u256_equal, numeric)→vec_contains_number.`,
+            ],
+        };
+    }
+    return {
+        convertible: true,
+        targetOperator: mapping.target,
+        vectorValueType: mapping.vecType,
+        sharedNode: sharedNode ?? undefined,
+        constants,
+    };
+}
+export function buildShorthand(orNode, result, newIdentifier) {
+    if (!result.convertible || !result.targetOperator || !result.vectorValueType || !result.sharedNode || !result.constants) {
+        return null;
+    }
+    const values = result.constants.map((c) => c.value);
+    const removeIdentifiers = result.constants.map((c) => c.identifier);
+    const newRoot = {
+        type: result.targetOperator,
+        nodes: [
+            { type: 'identifier', identifier: newIdentifier },
+            result.sharedNode,
+        ],
+    };
+    return {
+        newRoot,
+        removeIdentifiers,
+        addEntry: {
+            identifier: newIdentifier,
+            b_submission: false,
+            value_type: result.vectorValueType,
+            value: values,
+            name: 'converted_constants',
+        },
+    };
+}

package/dist/knowledge/guard-puzzle.d.ts

@@ -10,21 +10,45 @@ export interface BindingPuzzle {
     circular_reference: boolean;
     host_object_state: "not_created" | "created_unpublished" | "published_immutable" | "unknown";
 }
-export interface DataEntryPuzzle {
+export interface OnChainConstantEntry {
     identifier: number;
-    b_submission: boolean;
-    value_type: string;
-    value?: string | number | boolean | string[];
+    object_address: string;
+    object_type: string;
     name: string;
-    object_type?: string;
     is_system_address?: boolean;
 }
-export interface WitnessUsagePuzzle {
+export interface WitnessDerivedEntry {
+    identifier: number;
+    source_type: string;
     witness_type: number;
     witness_name: string;
-    source_type: string;
     target_type: string;
-    scenario: string;
+    source_b_submission: boolean;
+    name: string;
+}
+export interface SubmittedObjectEntry {
+    identifier: number;
+    expected_object_type: string;
+    value_type: string;
+    name: string;
+    binding_constraint?: string;
+}
+export interface SubmittedValueEntry {
+    identifier: number;
+    value_type: string;
+    name: string;
+    binding_constraint?: string;
+}
+export interface SystemContextEntry {
+    context_type: "Signer" | "Clock" | "Guard";
+    usage: string;
+}
+export interface DataSourcePuzzle {
+    on_chain_constants: OnChainConstantEntry[];
+    witness_derived: WitnessDerivedEntry[];
+    submitted_objects: SubmittedObjectEntry[];
+    submitted_values: SubmittedValueEntry[];
+    system_contexts: SystemContextEntry[];
 }
 export interface QueryPuzzle {
     query_id: number;
@@ -32,7 +56,13 @@ export interface QueryPuzzle {
     object_type: string;
     parameters: string[];
     return_type: string;
-    witness?: WitnessUsagePuzzle;
+    witness?: {
+        witness_type: number;
+        witness_name: string;
+        source_type: string;
+        target_type: string;
+        scenario: string;
+    };
     purpose: string;
 }
 export interface LogicNodePuzzle {
@@ -59,15 +89,18 @@ export interface ConstraintChecklist {
     pitfall_08_rely_rep_true: boolean;
     pitfall_09_voting_weight_numeric: boolean;
     pitfall_10_arbitration_not_paused: boolean;
+    runtime_01_guard_immutable: boolean;
+    runtime_02_submission_type_match: boolean;
+    runtime_03_submission_complete: boolean;
+    runtime_04_submission_size: boolean;
+    runtime_05_witness_source_valid: boolean;
+    runtime_06_query_object_valid: boolean;
 }
 export interface GuardPuzzle {
     current_round: "R1" | "R2" | "R3" | "R4" | "R5" | "R6" | "R7" | "R8" | "R9" | "R10";
     intent?: IntentPuzzle;
     binding?: BindingPuzzle;
-    data?: {
-        entries: DataEntryPuzzle[];
-        witnesses: WitnessUsagePuzzle[];
-    };
+    data_sources?: DataSourcePuzzle;
     queries?: QueryPuzzle[];
     logic?: {
         root: LogicNodePuzzle;
@@ -75,7 +108,7 @@ export interface GuardPuzzle {
     };
     constraints?: ConstraintChecklist;
 }
-export type PuzzleDimension = "intent" | "binding" | "data" | "query" | "logic" | "constraints";
+export type PuzzleDimension = "intent" | "binding" | "data_sources" | "query" | "logic" | "constraints";
 export interface PuzzleCompleteness {
     dimensions: Record<PuzzleDimension, boolean>;
     missing: PuzzleDimension[];
@@ -91,3 +124,65 @@ export declare function checkPuzzleCompleteness(puzzle: GuardPuzzle): PuzzleComp
 export declare function generateConfirmationText(puzzle: GuardPuzzle): string;
 export declare function initPuzzleFromIntent(intent: Partial<IntentPuzzle>): GuardPuzzle;
 export declare function inferBindingFromAction(action: IntentPuzzle["action"]): Partial<BindingPuzzle>;
+export declare function emptyDataSources(): DataSourcePuzzle;
+export declare const WITNESS_NAME_MAP: Record<number, {
+    name: string;
+    source: string;
+    target: string;
+}>;
+export declare function getWitnessInfo(witness_type: number): {
+    name: string;
+    source: string;
+    target: string;
+} | undefined;
+export interface RootNodeSnapshot {
+    type: string;
+    identifier?: number;
+    query?: string | number;
+    object?: {
+        identifier: number;
+        convert_witness?: number;
+    };
+    parameters?: RootNodeSnapshot[];
+    context?: "Clock" | "Guard" | "Signer";
+    nodes?: RootNodeSnapshot[];
+    node?: RootNodeSnapshot;
+    nodeLeft?: RootNodeSnapshot;
+    nodeRight?: RootNodeSnapshot;
+}
+export type ValueSnapshot = string | number | boolean | string[] | number[] | boolean[];
+export interface TableItemSnapshot {
+    identifier: number;
+    b_submission: boolean;
+    value_type: string | number;
+    value?: ValueSnapshot;
+    name: string;
+    object_type?: string;
+}
+export interface BindingHintSnapshot {
+    action: string;
+    host_object: string;
+    binding_field: string;
+    rule_sentence?: string;
+    failure_conditions?: string[];
+    circular_reference?: boolean;
+}
+export interface DerivePuzzleInput {
+    table?: TableItemSnapshot[];
+    root?: RootNodeSnapshot;
+    rely?: {
+        guards: string[];
+        logic_or?: boolean;
+    };
+    binding_hint?: BindingHintSnapshot;
+}
+export declare function derivePuzzleFromCallData(input: DerivePuzzleInput): GuardPuzzle;
+export declare function getPuzzleStatusBooleans(puzzle: GuardPuzzle): {
+    intent: boolean;
+    binding: boolean;
+    data: boolean;
+    query: boolean;
+    logic: boolean;
+    constraints: boolean;
+};
+export declare function getPendingQuestions(puzzle: GuardPuzzle): string[];