@enjoys/context-engine 1.1.1 → 1.2.0

package/data/definition/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"
+        }
+      }
+    }
+  }
+}

package/data/definition/systemverilog.json

@@ -0,0 +1,101 @@
+{
+  "language": "systemverilog",
+  "definitions": {
+    "module": {
+      "signature": "module name #(parameter_list) (port_list); ... endmodule",
+      "description": "Defines a hardware design unit encapsulating combinational and sequential logic with input/output ports, parameters, and internal signal declarations for synthesizable RTL design.",
+      "type": "function",
+      "module": "Design Units"
+    },
+    "interface": {
+      "signature": "interface name #(parameters) (port_list); ... endinterface",
+      "description": "Defines a bundle of signals and optional protocol logic that can be shared between modules, reducing port-level connections and enabling modular communication protocol definitions.",
+      "type": "function",
+      "module": "Design Units"
+    },
+    "class": {
+      "signature": "class name [extends base_class] [implements interface_class]; ... endclass",
+      "description": "Defines an object-oriented class for verification with properties, methods, constructor, constraints, and inheritance support, primarily used in testbench and UVM environments.",
+      "type": "class",
+      "module": "Verification",
+      "members": {
+        "new": {
+          "signature": "function new(args...)",
+          "description": "Constructor method called when creating a new instance of the class.",
+          "type": "method"
+        },
+        "randomize": {
+          "signature": "object.randomize() -> int",
+          "description": "Generates random values for rand/randc variables subject to defined constraints.",
+          "type": "method"
+        }
+      }
+    },
+    "logic": {
+      "signature": "logic [signed] [width-1:0] name",
+      "description": "Four-state data type (0, 1, x, z) that can be used in both procedural assignments and continuous assignments, replacing the need to choose between reg and wire in Verilog.",
+      "type": "function",
+      "module": "Data Types"
+    },
+    "wire": {
+      "signature": "wire [signed] [width-1:0] name",
+      "description": "Net type representing a physical connection driven by continuous assignments or module port connections, resolving multiple drivers according to resolution functions in hardware modeling.",
+      "type": "function",
+      "module": "Data Types"
+    },
+    "reg": {
+      "signature": "reg [signed] [width-1:0] name",
+      "description": "Variable type that holds its value between procedural assignments in always blocks, representing storage elements in sequential logic though not necessarily synthesized as registers.",
+      "type": "function",
+      "module": "Data Types"
+    },
+    "always_ff": {
+      "signature": "always_ff @(posedge clk or negedge rst_n) begin ... end",
+      "description": "Procedural block specifically for modeling flip-flop based sequential logic, enforced by synthesis tools to contain only synchronous assignments with clock and optional reset sensitivity.",
+      "type": "function",
+      "module": "Procedural Blocks"
+    },
+    "always_comb": {
+      "signature": "always_comb begin ... end",
+      "description": "Procedural block for modeling combinational logic that automatically infers a complete sensitivity list from all signals read within the block, preventing unintended latch inference.",
+      "type": "function",
+      "module": "Procedural Blocks"
+    },
+    "always_latch": {
+      "signature": "always_latch begin ... end",
+      "description": "Procedural block explicitly intended for latch-based logic, with automatic sensitivity list inference and tool checks ensuring the block correctly implements level-sensitive storage elements.",
+      "type": "function",
+      "module": "Procedural Blocks"
+    },
+    "constraint": {
+      "signature": "constraint name { expression1; expression2; ... }",
+      "description": "Defines declarative constraints on random variables within a class, specifying valid value ranges, relationships, distributions, and conditional rules for constrained random verification.",
+      "type": "function",
+      "module": "Verification"
+    },
+    "covergroup": {
+      "signature": "covergroup name @(event); coverpoint var { bins name = {values}; } endgroup",
+      "description": "Defines a functional coverage model with coverpoints and cross coverage for tracking which design scenarios have been exercised during simulation verification campaigns.",
+      "type": "function",
+      "module": "Verification"
+    },
+    "assertion": {
+      "signature": "assert property (@(posedge clk) antecedent |-> consequent) else $error(\"msg\")",
+      "description": "SystemVerilog assertion that formally specifies and checks temporal properties of the design during simulation, using sequences and properties for protocol and timing verification.",
+      "type": "function",
+      "module": "Assertions"
+    },
+    "typedef": {
+      "signature": "typedef data_type new_type_name | typedef enum {labels} enum_type",
+      "description": "Creates a user-defined type alias or enumerated type for improved code readability, type safety, and abstraction of complex data type declarations in hardware designs.",
+      "type": "function",
+      "module": "Data Types"
+    },
+    "struct": {
+      "signature": "typedef struct [packed] { type1 field1; type2 field2; ... } struct_name",
+      "description": "Groups related signals into a composite data type with named fields, with the packed qualifier ensuring contiguous bit-level representation for synthesis and bus-width calculations.",
+      "type": "function",
+      "module": "Data Types"
+    }
+  }
+}

package/data/definition/tcl.json

@@ -0,0 +1,226 @@
+{
+  "language": "tcl",
+  "definitions": {
+    "proc": {
+      "signature": "proc name argList body",
+      "description": "Defines a new Tcl procedure (function) with a name, formal argument list supporting defaults and variable-length args, and a body script that executes when the procedure is called.",
+      "type": "function",
+      "module": "Core Commands"
+    },
+    "set": {
+      "signature": "set varName [value]",
+      "description": "Sets a variable to the specified value and returns it, or returns the current value when called without a value argument, serving as the fundamental variable assignment command.",
+      "type": "function",
+      "module": "Core Commands"
+    },
+    "puts": {
+      "signature": "puts [-nonewline] [channelId] string",
+      "description": "Writes a string to the specified output channel (defaulting to stdout) followed by a newline unless -nonewline is specified, used for all text output in Tcl programs.",
+      "type": "function",
+      "module": "I/O Commands"
+    },
+    "gets": {
+      "signature": "gets channelId [varName] -> count|string",
+      "description": "Reads a line of input from a channel, storing it in varName if provided and returning the character count, or returning the line directly if no variable name is given.",
+      "type": "function",
+      "module": "I/O Commands"
+    },
+    "string": {
+      "signature": "string subcommand [args ...]",
+      "description": "Ensemble command providing comprehensive string manipulation operations including comparison, searching, matching, transformation, formatting, and character classification subcommands.",
+      "type": "class",
+      "module": "String Commands",
+      "members": {
+        "length": {
+          "signature": "string length string -> integer",
+          "description": "Returns the number of characters in the string.",
+          "type": "method"
+        },
+        "range": {
+          "signature": "string range string first last -> string",
+          "description": "Returns a substring from the first to last character index inclusive.",
+          "type": "method"
+        },
+        "match": {
+          "signature": "string match [-nocase] pattern string -> boolean",
+          "description": "Tests if the string matches a glob-style pattern with * and ? wildcards.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "string map [-nocase] mapping string -> string",
+          "description": "Replaces substrings according to the key-value mapping list.",
+          "type": "method"
+        },
+        "trim": {
+          "signature": "string trim string [chars] -> string",
+          "description": "Removes leading and trailing characters (default whitespace) from the string.",
+          "type": "method"
+        },
+        "tolower": {
+          "signature": "string tolower string -> string",
+          "description": "Returns the string converted to lowercase.",
+          "type": "method"
+        },
+        "toupper": {
+          "signature": "string toupper string -> string",
+          "description": "Returns the string converted to uppercase.",
+          "type": "method"
+        },
+        "index": {
+          "signature": "string index string charIndex -> char",
+          "description": "Returns the character at the specified index position in the string.",
+          "type": "method"
+        },
+        "first": {
+          "signature": "string first needleString haystackString [startIndex] -> integer",
+          "description": "Returns the index of the first occurrence of the needle in the haystack, or -1.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "string replace string first last [newString] -> string",
+          "description": "Replaces characters from first to last index with the new string.",
+          "type": "method"
+        }
+      }
+    },
+    "list": {
+      "signature": "list [arg1 arg2 ...]",
+      "description": "Creates a properly-formed Tcl list from the given arguments with correct quoting and escaping, serving as the primary list constructor for building data structures.",
+      "type": "function",
+      "module": "List Commands"
+    },
+    "array": {
+      "signature": "array subcommand arrayName [args ...]",
+      "description": "Ensemble command for manipulating associative arrays with subcommands for getting, setting, querying existence, iterating names, and converting between arrays and key-value lists.",
+      "type": "class",
+      "module": "Array Commands",
+      "members": {
+        "set": {
+          "signature": "array set arrayName {key1 val1 key2 val2 ...}",
+          "description": "Sets multiple elements of an associative array from a key-value list.",
+          "type": "method"
+        },
+        "get": {
+          "signature": "array get arrayName [pattern] -> list",
+          "description": "Returns the array contents as a flat key-value list, optionally filtered by pattern.",
+          "type": "method"
+        },
+        "names": {
+          "signature": "array names arrayName [pattern] -> list",
+          "description": "Returns a list of all key names in the array, optionally filtered by glob pattern.",
+          "type": "method"
+        },
+        "exists": {
+          "signature": "array exists arrayName -> boolean",
+          "description": "Returns 1 if the named variable is an array, 0 otherwise.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "array size arrayName -> integer",
+          "description": "Returns the number of elements in the associative array.",
+          "type": "method"
+        },
+        "unset": {
+          "signature": "array unset arrayName [pattern]",
+          "description": "Removes elements matching the pattern from the array, or all if no pattern given.",
+          "type": "method"
+        }
+      }
+    },
+    "file": {
+      "signature": "file subcommand [args ...]",
+      "description": "Ensemble command for filesystem operations including path manipulation, file attribute queries, existence testing, copying, renaming, and deleting files and directories.",
+      "type": "class",
+      "module": "File Commands",
+      "members": {
+        "exists": {
+          "signature": "file exists name -> boolean",
+          "description": "Returns 1 if the specified file or directory exists, 0 otherwise.",
+          "type": "method"
+        },
+        "join": {
+          "signature": "file join name1 name2 ... -> path",
+          "description": "Joins path components using the platform-appropriate separator.",
+          "type": "method"
+        },
+        "dirname": {
+          "signature": "file dirname name -> path",
+          "description": "Returns the directory portion of the file path.",
+          "type": "method"
+        },
+        "tail": {
+          "signature": "file tail name -> string",
+          "description": "Returns the filename portion after the last directory separator.",
+          "type": "method"
+        },
+        "extension": {
+          "signature": "file extension name -> string",
+          "description": "Returns the file extension including the leading dot.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "file size name -> integer",
+          "description": "Returns the size of the file in bytes.",
+          "type": "method"
+        },
+        "delete": {
+          "signature": "file delete [-force] name ...",
+          "description": "Deletes the specified files or directories, with -force for non-empty directories.",
+          "type": "method"
+        }
+      }
+    },
+    "regexp": {
+      "signature": "regexp [-nocase] [-expanded] [-line] [--] exp string [matchVar subMatch1 ...]",
+      "description": "Tests if a string matches a regular expression pattern and optionally captures matched subexpressions into variables, returning 1 on match and 0 on no match.",
+      "type": "function",
+      "module": "String Commands"
+    },
+    "namespace": {
+      "signature": "namespace subcommand [args ...]",
+      "description": "Manages Tcl namespaces for organizing commands and variables into hierarchical scopes, preventing name collisions and enabling modular package design with import and export control.",
+      "type": "class",
+      "module": "Namespace Commands",
+      "members": {
+        "eval": {
+          "signature": "namespace eval name script",
+          "description": "Evaluates a script in the context of the specified namespace, creating it if needed.",
+          "type": "method"
+        },
+        "export": {
+          "signature": "namespace export [-clear] pattern ...",
+          "description": "Specifies which commands in the namespace are available for import by other namespaces.",
+          "type": "method"
+        },
+        "import": {
+          "signature": "namespace import [-force] pattern ...",
+          "description": "Imports commands from other namespaces into the current namespace.",
+          "type": "method"
+        },
+        "current": {
+          "signature": "namespace current -> string",
+          "description": "Returns the fully-qualified name of the current namespace.",
+          "type": "method"
+        }
+      }
+    },
+    "package": {
+      "signature": "package subcommand [args ...]",
+      "description": "Manages Tcl packages for code distribution and version control, supporting require for loading dependencies and provide for declaring package availability with semantic versioning.",
+      "type": "class",
+      "module": "Package Commands",
+      "members": {
+        "require": {
+          "signature": "package require [-exact] packageName [version]",
+          "description": "Loads a package by name, optionally requiring an exact or minimum version.",
+          "type": "method"
+        },
+        "provide": {
+          "signature": "package provide packageName version",
+          "description": "Declares that the current script provides the named package at the given version.",
+          "type": "method"
+        }
+      }
+    }
+  }
+}