@enjoys/context-engine 1.1.1 → 1.1.2

package/data/defination/sol.json

@@ -0,0 +1,186 @@
+{
+  "language": "sol",
+  "definitions": {
+    "msg": {
+      "signature": "msg",
+      "description": "Global variable providing information about the current message call including sender address, value sent, calldata, and gas remaining for the transaction execution context.",
+      "type": "class",
+      "module": "Global Variables",
+      "members": {
+        "sender": {
+          "signature": "msg.sender -> address",
+          "description": "Returns the address of the account that directly called the current function.",
+          "type": "method"
+        },
+        "value": {
+          "signature": "msg.value -> uint256",
+          "description": "Returns the amount of wei sent with the current message call.",
+          "type": "method"
+        },
+        "data": {
+          "signature": "msg.data -> bytes",
+          "description": "Returns the complete calldata payload of the current message call.",
+          "type": "method"
+        },
+        "sig": {
+          "signature": "msg.sig -> bytes4",
+          "description": "Returns the first four bytes of the calldata, representing the function selector.",
+          "type": "method"
+        }
+      }
+    },
+    "block": {
+      "signature": "block",
+      "description": "Global variable providing access to current block properties including timestamp, number, difficulty, gas limit, and coinbase address for on-chain time and block-dependent logic.",
+      "type": "class",
+      "module": "Global Variables",
+      "members": {
+        "timestamp": {
+          "signature": "block.timestamp -> uint256",
+          "description": "Returns the current block's Unix timestamp in seconds since epoch.",
+          "type": "method"
+        },
+        "number": {
+          "signature": "block.number -> uint256",
+          "description": "Returns the current block number in the blockchain.",
+          "type": "method"
+        },
+        "chainid": {
+          "signature": "block.chainid -> uint256",
+          "description": "Returns the chain ID of the current blockchain network.",
+          "type": "method"
+        },
+        "coinbase": {
+          "signature": "block.coinbase -> address payable",
+          "description": "Returns the address of the miner or validator that produced the current block.",
+          "type": "method"
+        },
+        "basefee": {
+          "signature": "block.basefee -> uint256",
+          "description": "Returns the base fee of the current block according to EIP-1559.",
+          "type": "method"
+        }
+      }
+    },
+    "tx": {
+      "signature": "tx",
+      "description": "Global variable providing transaction-level properties including the original sender (origin) and gas price, representing the outermost transaction context in the call chain.",
+      "type": "class",
+      "module": "Global Variables",
+      "members": {
+        "origin": {
+          "signature": "tx.origin -> address",
+          "description": "Returns the address of the externally-owned account that initiated the entire transaction chain.",
+          "type": "method"
+        },
+        "gasprice": {
+          "signature": "tx.gasprice -> uint256",
+          "description": "Returns the gas price of the current transaction in wei.",
+          "type": "method"
+        }
+      }
+    },
+    "address": {
+      "signature": "address(value) | address payable",
+      "description": "The address type holds a 20-byte Ethereum address with members for checking balance, sending ether, and performing low-level calls to other contracts on the blockchain.",
+      "type": "class",
+      "module": "Value Types",
+      "members": {
+        "balance": {
+          "signature": "address.balance -> uint256",
+          "description": "Returns the balance of the address in wei.",
+          "type": "method"
+        },
+        "transfer": {
+          "signature": "address.transfer(amount)",
+          "description": "Sends the specified amount of wei, reverting on failure with a fixed 2300 gas stipend.",
+          "type": "method"
+        },
+        "send": {
+          "signature": "address.send(amount) -> bool",
+          "description": "Sends wei and returns false on failure instead of reverting, with a 2300 gas stipend.",
+          "type": "method"
+        },
+        "call": {
+          "signature": "address.call(bytes memory) -> (bool, bytes memory)",
+          "description": "Performs a low-level call to the address, forwarding all available gas and returning success status and return data.",
+          "type": "method"
+        },
+        "delegatecall": {
+          "signature": "address.delegatecall(bytes memory) -> (bool, bytes memory)",
+          "description": "Performs a delegate call that executes the target's code in the caller's storage context.",
+          "type": "method"
+        },
+        "code": {
+          "signature": "address.code -> bytes memory",
+          "description": "Returns the bytecode deployed at the address, empty for externally-owned accounts.",
+          "type": "method"
+        }
+      }
+    },
+    "mapping": {
+      "signature": "mapping(KeyType => ValueType) [visibility] name",
+      "description": "Hash table data structure that maps keys to values with O(1) lookup, where all possible keys exist and map to a default zero value, not iterable or enumerable by design.",
+      "type": "function",
+      "module": "Reference Types"
+    },
+    "require": {
+      "signature": "require(condition) | require(condition, errorMessage)",
+      "description": "Validates a condition and reverts the transaction with remaining gas refunded if the condition evaluates to false, optionally providing a descriptive error message string.",
+      "type": "function",
+      "module": "Error Handling"
+    },
+    "revert": {
+      "signature": "revert() | revert(string memory reason) | revert CustomError(args)",
+      "description": "Aborts execution and reverts all state changes in the current call context, optionally providing a reason string or custom error with typed parameters for gas-efficient errors.",
+      "type": "function",
+      "module": "Error Handling"
+    },
+    "emit": {
+      "signature": "emit EventName(arg1, arg2, ...)",
+      "description": "Triggers a named event that stores arguments in the transaction log, enabling off-chain applications to listen for and react to on-chain state changes through indexed topics.",
+      "type": "function",
+      "module": "Events"
+    },
+    "payable": {
+      "signature": "payable(address) -> address payable | function ... payable",
+      "description": "Modifier that enables a function to receive Ether or converts a regular address to a payable address, required for any contract function that accepts native currency transfers.",
+      "type": "function",
+      "module": "Modifiers"
+    },
+    "keccak256": {
+      "signature": "keccak256(bytes memory) -> bytes32",
+      "description": "Computes the Keccak-256 cryptographic hash of the input bytes, widely used for generating unique identifiers, verifying data integrity, and implementing Merkle tree structures.",
+      "type": "function",
+      "module": "Cryptographic Functions"
+    },
+    "abi": {
+      "signature": "abi.encode(...) | abi.encodePacked(...) | abi.encodeWithSelector(bytes4, ...) | abi.decode(bytes, (types))",
+      "description": "Provides ABI encoding and decoding functions for serializing function call parameters, computing function selectors, and packing data for cryptographic hashing and cross-contract calls.",
+      "type": "class",
+      "module": "ABI Encoding",
+      "members": {
+        "encode": {
+          "signature": "abi.encode(args...) -> bytes memory",
+          "description": "ABI-encodes the given arguments with padding to 32-byte boundaries.",
+          "type": "method"
+        },
+        "encodePacked": {
+          "signature": "abi.encodePacked(args...) -> bytes memory",
+          "description": "Non-standard packed encoding without padding, commonly used before hashing.",
+          "type": "method"
+        },
+        "decode": {
+          "signature": "abi.decode(data, (types)) -> values",
+          "description": "Decodes ABI-encoded data according to the given type tuple.",
+          "type": "method"
+        },
+        "encodeWithSelector": {
+          "signature": "abi.encodeWithSelector(selector, args...) -> bytes memory",
+          "description": "ABI-encodes arguments prepended with the 4-byte function selector.",
+          "type": "method"
+        }
+      }
+    }
+  }
+}

package/data/defination/sparql.json

@@ -0,0 +1,83 @@
+{
+  "language": "sparql",
+  "definitions": {
+    "SELECT": {
+      "signature": "SELECT [DISTINCT|REDUCED] ?var1 ?var2 ... | SELECT * WHERE { pattern }",
+      "description": "Retrieves variable bindings from matched graph patterns, returning a result set of solutions as a table with columns for each projected variable from the WHERE clause patterns.",
+      "type": "function",
+      "module": "Query Forms"
+    },
+    "CONSTRUCT": {
+      "signature": "CONSTRUCT { triple_template } WHERE { graph_pattern }",
+      "description": "Builds a new RDF graph by substituting matched variable bindings into a triple template, enabling transformation and reshaping of RDF data into different graph structures.",
+      "type": "function",
+      "module": "Query Forms"
+    },
+    "ASK": {
+      "signature": "ASK WHERE { graph_pattern }",
+      "description": "Tests whether a graph pattern has any solution in the dataset, returning a boolean true or false result without retrieving any variable bindings or result rows.",
+      "type": "function",
+      "module": "Query Forms"
+    },
+    "DESCRIBE": {
+      "signature": "DESCRIBE ?var | DESCRIBE <uri> WHERE { graph_pattern }",
+      "description": "Returns an RDF graph containing information about specified resources, with the exact triples returned determined by the SPARQL endpoint implementation rather than explicitly specified.",
+      "type": "function",
+      "module": "Query Forms"
+    },
+    "FILTER": {
+      "signature": "FILTER (expression) | FILTER regex(?var, 'pattern', 'flags') | FILTER (?var > value)",
+      "description": "Restricts query solutions to those where the given boolean expression evaluates to true, supporting comparison operators, regular expressions, string functions, and logical connectives.",
+      "type": "function",
+      "module": "Graph Patterns"
+    },
+    "OPTIONAL": {
+      "signature": "OPTIONAL { graph_pattern }",
+      "description": "Performs a left outer join by attempting to match an additional graph pattern, retaining solutions even when the optional pattern fails to match for some bindings.",
+      "type": "function",
+      "module": "Graph Patterns"
+    },
+    "UNION": {
+      "signature": "{ pattern1 } UNION { pattern2 }",
+      "description": "Combines solutions from two or more alternative graph patterns into a single result set, functioning as a logical OR that matches if any of the alternative patterns match.",
+      "type": "function",
+      "module": "Graph Patterns"
+    },
+    "BIND": {
+      "signature": "BIND (expression AS ?variable)",
+      "description": "Assigns the result of an expression to a new variable within a graph pattern, enabling computed values, string concatenation, and arithmetic results to be used in subsequent patterns.",
+      "type": "function",
+      "module": "Graph Patterns"
+    },
+    "VALUES": {
+      "signature": "VALUES (?var1 ?var2) { (val1 val2) (val3 val4) } | VALUES ?var { val1 val2 }",
+      "description": "Provides inline data bindings that constrain variable values to a specified set, functioning as parameterized queries or lookup tables directly within the SPARQL query body.",
+      "type": "function",
+      "module": "Graph Patterns"
+    },
+    "GROUP BY": {
+      "signature": "GROUP BY ?var1 ?var2 | GROUP BY (expression AS ?alias)",
+      "description": "Partitions query solutions into groups based on one or more variables or expressions, enabling aggregate functions like COUNT, SUM, AVG, MIN, and MAX over each group.",
+      "type": "function",
+      "module": "Solution Modifiers"
+    },
+    "SERVICE": {
+      "signature": "SERVICE <endpoint_uri> { graph_pattern } | SERVICE SILENT <endpoint_uri> { pattern }",
+      "description": "Executes a portion of a query against a remote SPARQL endpoint for federated querying across distributed datasets, with SILENT suppressing errors from unavailable endpoints.",
+      "type": "function",
+      "module": "Federated Query"
+    },
+    "INSERT DATA": {
+      "signature": "INSERT DATA { GRAPH <uri> { triple1 . triple2 . } }",
+      "description": "Adds specified RDF triples to a named graph in the dataset as a SPARQL Update operation, using concrete triple data without variable bindings or pattern matching.",
+      "type": "function",
+      "module": "SPARQL Update"
+    },
+    "DELETE WHERE": {
+      "signature": "DELETE WHERE { graph_pattern }",
+      "description": "Removes all triples matching the specified graph pattern from the dataset in a single SPARQL Update operation, combining the match pattern and deletion template for conciseness.",
+      "type": "function",
+      "module": "SPARQL Update"
+    }
+  }
+}

package/data/defination/st.json

@@ -0,0 +1,329 @@
+{
+  "language": "st",
+  "definitions": {
+    "Object": {
+      "signature": "Object",
+      "description": "The root class of the Smalltalk class hierarchy from which all other classes inherit, providing fundamental behavior for identity, equality, copying, printing, and message handling.",
+      "type": "class",
+      "module": "Kernel",
+      "members": {
+        "printString": {
+          "signature": "anObject printString -> String",
+          "description": "Returns a string representation of the receiver for display purposes.",
+          "type": "method"
+        },
+        "class": {
+          "signature": "anObject class -> Class",
+          "description": "Returns the class of the receiver object.",
+          "type": "method"
+        },
+        "copy": {
+          "signature": "anObject copy -> Object",
+          "description": "Returns a shallow copy of the receiver.",
+          "type": "method"
+        },
+        "respondsTo": {
+          "signature": "anObject respondsTo: aSymbol -> Boolean",
+          "description": "Returns true if the receiver can respond to the specified message selector.",
+          "type": "method"
+        },
+        "yourself": {
+          "signature": "anObject yourself -> Object",
+          "description": "Returns the receiver itself, useful for cascaded message sends.",
+          "type": "method"
+        },
+        "isNil": {
+          "signature": "anObject isNil -> Boolean",
+          "description": "Returns true if the receiver is nil (the undefined object).",
+          "type": "method"
+        }
+      }
+    },
+    "Collection": {
+      "signature": "Collection",
+      "description": "Abstract superclass for all collection types providing common enumeration, testing, conversion, and element access protocols shared by arrays, sets, dictionaries, and other containers.",
+      "type": "class",
+      "module": "Collections",
+      "members": {
+        "do:": {
+          "signature": "aCollection do: [:each | ...]",
+          "description": "Evaluates the block for each element in the collection for side effects.",
+          "type": "method"
+        },
+        "collect:": {
+          "signature": "aCollection collect: [:each | ...] -> Collection",
+          "description": "Returns a new collection of results from evaluating the block for each element.",
+          "type": "method"
+        },
+        "select:": {
+          "signature": "aCollection select: [:each | ...] -> Collection",
+          "description": "Returns a new collection containing only elements for which the block returns true.",
+          "type": "method"
+        },
+        "reject:": {
+          "signature": "aCollection reject: [:each | ...] -> Collection",
+          "description": "Returns a new collection excluding elements for which the block returns true.",
+          "type": "method"
+        },
+        "detect:": {
+          "signature": "aCollection detect: [:each | ...] -> Object",
+          "description": "Returns the first element for which the block returns true, raising an error if none found.",
+          "type": "method"
+        },
+        "inject:into:": {
+          "signature": "aCollection inject: initialValue into: [:acc :each | ...] -> Object",
+          "description": "Reduces the collection by accumulating through the block starting from the initial value.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "aCollection size -> Integer",
+          "description": "Returns the number of elements in the collection.",
+          "type": "method"
+        },
+        "includes:": {
+          "signature": "aCollection includes: anObject -> Boolean",
+          "description": "Returns true if the collection contains the specified element.",
+          "type": "method"
+        }
+      }
+    },
+    "OrderedCollection": {
+      "signature": "OrderedCollection new | OrderedCollection withAll: aCollection",
+      "description": "A dynamically-sized ordered collection that maintains insertion order and supports adding, removing, and accessing elements by integer index, similar to dynamic arrays in other languages.",
+      "type": "class",
+      "module": "Collections",
+      "members": {
+        "add:": {
+          "signature": "anOrderedCollection add: anObject -> Object",
+          "description": "Appends an object to the end of the collection and returns it.",
+          "type": "method"
+        },
+        "addFirst:": {
+          "signature": "anOrderedCollection addFirst: anObject -> Object",
+          "description": "Inserts an object at the beginning of the collection.",
+          "type": "method"
+        },
+        "remove:": {
+          "signature": "anOrderedCollection remove: anObject -> Object",
+          "description": "Removes the first occurrence of the specified object from the collection.",
+          "type": "method"
+        },
+        "at:": {
+          "signature": "anOrderedCollection at: index -> Object",
+          "description": "Returns the element at the specified one-based index position.",
+          "type": "method"
+        },
+        "at:put:": {
+          "signature": "anOrderedCollection at: index put: anObject -> Object",
+          "description": "Replaces the element at the specified index with the given object.",
+          "type": "method"
+        },
+        "removeAt:": {
+          "signature": "anOrderedCollection removeAt: index -> Object",
+          "description": "Removes and returns the element at the specified index.",
+          "type": "method"
+        }
+      }
+    },
+    "Dictionary": {
+      "signature": "Dictionary new | Dictionary newFrom: associations",
+      "description": "A hash-based collection that maps unique keys to values using associations, providing fast key-based lookup, insertion, and removal with enumeration over key-value pairs.",
+      "type": "class",
+      "module": "Collections",
+      "members": {
+        "at:put:": {
+          "signature": "aDictionary at: key put: value -> value",
+          "description": "Associates the given key with the value, replacing any existing association for that key.",
+          "type": "method"
+        },
+        "at:": {
+          "signature": "aDictionary at: key -> value",
+          "description": "Returns the value associated with the key, raising an error if the key is not found.",
+          "type": "method"
+        },
+        "at:ifAbsent:": {
+          "signature": "aDictionary at: key ifAbsent: aBlock -> value",
+          "description": "Returns the value for the key, or evaluates the block if the key is not present.",
+          "type": "method"
+        },
+        "keys": {
+          "signature": "aDictionary keys -> Set",
+          "description": "Returns a set of all keys in the dictionary.",
+          "type": "method"
+        },
+        "values": {
+          "signature": "aDictionary values -> Collection",
+          "description": "Returns a collection of all values in the dictionary.",
+          "type": "method"
+        },
+        "keysAndValuesDo:": {
+          "signature": "aDictionary keysAndValuesDo: [:key :value | ...]",
+          "description": "Evaluates the two-argument block for each key-value pair in the dictionary.",
+          "type": "method"
+        },
+        "includesKey:": {
+          "signature": "aDictionary includesKey: key -> Boolean",
+          "description": "Returns true if the dictionary contains the specified key.",
+          "type": "method"
+        }
+      }
+    },
+    "String": {
+      "signature": "String new: size | 'literal string'",
+      "description": "An immutable sequence of characters representing textual data, supporting pattern matching, substring operations, conversion, and comparison through the rich Smalltalk string protocol.",
+      "type": "class",
+      "module": "Collections",
+      "members": {
+        "size": {
+          "signature": "aString size -> Integer",
+          "description": "Returns the number of characters in the string.",
+          "type": "method"
+        },
+        "copyFrom:to:": {
+          "signature": "aString copyFrom: start to: end -> String",
+          "description": "Returns a substring from the start index to the end index inclusive.",
+          "type": "method"
+        },
+        "asUppercase": {
+          "signature": "aString asUppercase -> String",
+          "description": "Returns a new string with all characters converted to uppercase.",
+          "type": "method"
+        },
+        "asLowercase": {
+          "signature": "aString asLowercase -> String",
+          "description": "Returns a new string with all characters converted to lowercase.",
+          "type": "method"
+        },
+        "asInteger": {
+          "signature": "aString asInteger -> Integer",
+          "description": "Parses the string as an integer value.",
+          "type": "method"
+        },
+        "includesSubstring:": {
+          "signature": "aString includesSubstring: aSubstring -> Boolean",
+          "description": "Returns true if the string contains the specified substring.",
+          "type": "method"
+        }
+      }
+    },
+    "Number": {
+      "signature": "Number",
+      "description": "Abstract superclass for all numeric types including Integer, Float, and Fraction, providing arithmetic operations, comparisons, rounding, mathematical functions, and iteration support.",
+      "type": "class",
+      "module": "Magnitude",
+      "members": {
+        "abs": {
+          "signature": "aNumber abs -> Number",
+          "description": "Returns the absolute value of the receiver.",
+          "type": "method"
+        },
+        "max:": {
+          "signature": "aNumber max: anotherNumber -> Number",
+          "description": "Returns the larger of the receiver and the argument.",
+          "type": "method"
+        },
+        "min:": {
+          "signature": "aNumber min: anotherNumber -> Number",
+          "description": "Returns the smaller of the receiver and the argument.",
+          "type": "method"
+        },
+        "to:do:": {
+          "signature": "start to: end do: [:i | ...]",
+          "description": "Iterates from start to end, evaluating the block with each integer value.",
+          "type": "method"
+        },
+        "to:by:do:": {
+          "signature": "start to: end by: step do: [:i | ...]",
+          "description": "Iterates from start to end with the specified step increment.",
+          "type": "method"
+        },
+        "rounded": {
+          "signature": "aNumber rounded -> Integer",
+          "description": "Returns the integer nearest to the receiver.",
+          "type": "method"
+        }
+      }
+    },
+    "Block": {
+      "signature": "[ :arg1 :arg2 | expressions ]",
+      "description": "A first-class closure that captures its lexical environment and can be stored, passed as an argument, and evaluated on demand, forming the basis of all Smalltalk control structures.",
+      "type": "class",
+      "module": "Kernel",
+      "members": {
+        "value": {
+          "signature": "aBlock value -> Object",
+          "description": "Evaluates a zero-argument block and returns the result.",
+          "type": "method"
+        },
+        "value:": {
+          "signature": "aBlock value: arg -> Object",
+          "description": "Evaluates a one-argument block with the given argument.",
+          "type": "method"
+        },
+        "value:value:": {
+          "signature": "aBlock value: arg1 value: arg2 -> Object",
+          "description": "Evaluates a two-argument block with the given arguments.",
+          "type": "method"
+        },
+        "whileTrue:": {
+          "signature": "conditionBlock whileTrue: bodyBlock",
+          "description": "Repeatedly evaluates the body block while the condition block returns true.",
+          "type": "method"
+        },
+        "whileFalse:": {
+          "signature": "conditionBlock whileFalse: bodyBlock",
+          "description": "Repeatedly evaluates the body block while the condition block returns false.",
+          "type": "method"
+        },
+        "on:do:": {
+          "signature": "aBlock on: ExceptionClass do: [:ex | ...]",
+          "description": "Evaluates the block and handles the specified exception class with the handler block.",
+          "type": "method"
+        }
+      }
+    },
+    "Stream": {
+      "signature": "ReadStream on: collection | WriteStream on: collection",
+      "description": "Provides sequential read and write access to collections through a positioned cursor, supporting character-by-character or element-by-element traversal and accumulation of data.",
+      "type": "class",
+      "module": "Streams",
+      "members": {
+        "next": {
+          "signature": "aStream next -> Object",
+          "description": "Returns the next element from the stream and advances the position.",
+          "type": "method"
+        },
+        "next:": {
+          "signature": "aStream next: count -> Collection",
+          "description": "Returns the next count elements from the stream as a collection.",
+          "type": "method"
+        },
+        "nextPut:": {
+          "signature": "aStream nextPut: anObject -> Object",
+          "description": "Writes an object to the stream at the current position.",
+          "type": "method"
+        },
+        "nextPutAll:": {
+          "signature": "aStream nextPutAll: aCollection",
+          "description": "Writes all elements of the collection to the stream.",
+          "type": "method"
+        },
+        "atEnd": {
+          "signature": "aStream atEnd -> Boolean",
+          "description": "Returns true if the stream position is at or past the end.",
+          "type": "method"
+        },
+        "contents": {
+          "signature": "aStream contents -> Collection",
+          "description": "Returns all elements written to the stream so far as a collection.",
+          "type": "method"
+        },
+        "reset": {
+          "signature": "aStream reset",
+          "description": "Resets the stream position to the beginning.",
+          "type": "method"
+        }
+      }
+    }
+  }
+}