@enjoys/context-engine 1.1.1 → 1.1.2

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

package/data/defination/twig.json

@@ -0,0 +1,113 @@
+{
+  "language": "twig",
+  "definitions": {
+    "if": {
+      "signature": "if",
+      "description": "if keyword in Twig.",
+      "type": "keyword",
+      "module": "Twig"
+    },
+    "elseif": {
+      "signature": "elseif",
+      "description": "elseif keyword in Twig.",
+      "type": "keyword",
+      "module": "Twig"
+    },
+    "else": {
+      "signature": "else",
+      "description": "else keyword in Twig.",
+      "type": "keyword",
+      "module": "Twig"
+    },
+    "endif": {
+      "signature": "endif",
+      "description": "endif keyword in Twig.",
+      "type": "keyword",
+      "module": "Twig"
+    },
+    "for": {
+      "signature": "for",
+      "description": "for keyword in Twig.",
+      "type": "keyword",
+      "module": "Twig"
+    },
+    "endfor": {
+      "signature": "endfor",
+      "description": "endfor keyword in Twig.",
+      "type": "keyword",
+      "module": "Twig"
+    },
+    "block": {
+      "signature": "block",
+      "description": "block keyword in Twig.",
+      "type": "keyword",
+      "module": "Twig"
+    },
+    "endblock": {
+      "signature": "endblock",
+      "description": "endblock keyword in Twig.",
+      "type": "keyword",
+      "module": "Twig"
+    },
+    "extends": {
+      "signature": "extends",
+      "description": "extends keyword in Twig.",
+      "type": "keyword",
+      "module": "Twig"
+    },
+    "include": {
+      "signature": "include",
+      "description": "include keyword in Twig.",
+      "type": "keyword",
+      "module": "Twig"
+    },
+    "abs": {
+      "signature": "abs",
+      "description": "Built-in abs.",
+      "type": "function",
+      "module": "Twig"
+    },
+    "batch": {
+      "signature": "batch",
+      "description": "Built-in batch.",
+      "type": "function",
+      "module": "Twig"
+    },
+    "capitalize": {
+      "signature": "capitalize",
+      "description": "Built-in capitalize.",
+      "type": "function",
+      "module": "Twig"
+    },
+    "column": {
+      "signature": "column",
+      "description": "Built-in column.",
+      "type": "function",
+      "module": "Twig"
+    },
+    "convert_encoding": {
+      "signature": "convert_encoding",
+      "description": "Built-in convert_encoding.",
+      "type": "function",
+      "module": "Twig"
+    },
+    "country_name": {
+      "signature": "country_name",
+      "description": "Built-in country_name.",
+      "type": "function",
+      "module": "Twig"
+    },
+    "currency_name": {
+      "signature": "currency_name",
+      "description": "Built-in currency_name.",
+      "type": "function",
+      "module": "Twig"
+    },
+    "currency_symbol": {
+      "signature": "currency_symbol",
+      "description": "Built-in currency_symbol.",
+      "type": "function",
+      "module": "Twig"
+    }
+  }
+}

package/data/defination/vb.json

@@ -0,0 +1,113 @@
+{
+  "language": "vb",
+  "definitions": {
+    "Module": {
+      "signature": "Module",
+      "description": "Module keyword in Visual Basic.",
+      "type": "keyword",
+      "module": "Visual Basic"
+    },
+    "End Module": {
+      "signature": "End Module",
+      "description": "End Module keyword in Visual Basic.",
+      "type": "keyword",
+      "module": "Visual Basic"
+    },
+    "Sub": {
+      "signature": "Sub",
+      "description": "Sub keyword in Visual Basic.",
+      "type": "keyword",
+      "module": "Visual Basic"
+    },
+    "End Sub": {
+      "signature": "End Sub",
+      "description": "End Sub keyword in Visual Basic.",
+      "type": "keyword",
+      "module": "Visual Basic"
+    },
+    "Function": {
+      "signature": "Function",
+      "description": "Function keyword in Visual Basic.",
+      "type": "keyword",
+      "module": "Visual Basic"
+    },
+    "End Function": {
+      "signature": "End Function",
+      "description": "End Function keyword in Visual Basic.",
+      "type": "keyword",
+      "module": "Visual Basic"
+    },
+    "Class": {
+      "signature": "Class",
+      "description": "Class keyword in Visual Basic.",
+      "type": "keyword",
+      "module": "Visual Basic"
+    },
+    "End Class": {
+      "signature": "End Class",
+      "description": "End Class keyword in Visual Basic.",
+      "type": "keyword",
+      "module": "Visual Basic"
+    },
+    "Interface": {
+      "signature": "Interface",
+      "description": "Interface keyword in Visual Basic.",
+      "type": "keyword",
+      "module": "Visual Basic"
+    },
+    "End Interface": {
+      "signature": "End Interface",
+      "description": "End Interface keyword in Visual Basic.",
+      "type": "keyword",
+      "module": "Visual Basic"
+    },
+    "Console.WriteLine": {
+      "signature": "Console.WriteLine",
+      "description": "Built-in Console.WriteLine.",
+      "type": "function",
+      "module": "Visual Basic"
+    },
+    "Console.ReadLine": {
+      "signature": "Console.ReadLine",
+      "description": "Built-in Console.ReadLine.",
+      "type": "function",
+      "module": "Visual Basic"
+    },
+    "Console.Write": {
+      "signature": "Console.Write",
+      "description": "Built-in Console.Write.",
+      "type": "function",
+      "module": "Visual Basic"
+    },
+    "MessageBox.Show": {
+      "signature": "MessageBox.Show",
+      "description": "Built-in MessageBox.Show.",
+      "type": "function",
+      "module": "Visual Basic"
+    },
+    "MsgBox": {
+      "signature": "MsgBox",
+      "description": "Built-in MsgBox.",
+      "type": "function",
+      "module": "Visual Basic"
+    },
+    "InputBox": {
+      "signature": "InputBox",
+      "description": "Built-in InputBox.",
+      "type": "function",
+      "module": "Visual Basic"
+    },
+    "CStr": {
+      "signature": "CStr",
+      "description": "Built-in CStr.",
+      "type": "function",
+      "module": "Visual Basic"
+    },
+    "CInt": {
+      "signature": "CInt",
+      "description": "Built-in CInt.",
+      "type": "function",
+      "module": "Visual Basic"
+    }
+  }
+}

package/data/defination/wgsl.json

@@ -0,0 +1,113 @@
+{
+  "language": "wgsl",
+  "definitions": {
+    "fn": {
+      "signature": "fn",
+      "description": "fn keyword in WGSL.",
+      "type": "keyword",
+      "module": "WGSL"
+    },
+    "var": {
+      "signature": "var",
+      "description": "var keyword in WGSL.",
+      "type": "keyword",
+      "module": "WGSL"
+    },
+    "let": {
+      "signature": "let",
+      "description": "let keyword in WGSL.",
+      "type": "keyword",
+      "module": "WGSL"
+    },
+    "const": {
+      "signature": "const",
+      "description": "const keyword in WGSL.",
+      "type": "keyword",
+      "module": "WGSL"
+    },
+    "override": {
+      "signature": "override",
+      "description": "override keyword in WGSL.",
+      "type": "keyword",
+      "module": "WGSL"
+    },
+    "struct": {
+      "signature": "struct",
+      "description": "struct keyword in WGSL.",
+      "type": "keyword",
+      "module": "WGSL"
+    },
+    "alias": {
+      "signature": "alias",
+      "description": "alias keyword in WGSL.",
+      "type": "keyword",
+      "module": "WGSL"
+    },
+    "if": {
+      "signature": "if",
+      "description": "if keyword in WGSL.",
+      "type": "keyword",
+      "module": "WGSL"
+    },
+    "else": {
+      "signature": "else",
+      "description": "else keyword in WGSL.",
+      "type": "keyword",
+      "module": "WGSL"
+    },
+    "for": {
+      "signature": "for",
+      "description": "for keyword in WGSL.",
+      "type": "keyword",
+      "module": "WGSL"
+    },
+    "abs": {
+      "signature": "abs",
+      "description": "Built-in abs.",
+      "type": "function",
+      "module": "WGSL"
+    },
+    "acos": {
+      "signature": "acos",
+      "description": "Built-in acos.",
+      "type": "function",
+      "module": "WGSL"
+    },
+    "asin": {
+      "signature": "asin",
+      "description": "Built-in asin.",
+      "type": "function",
+      "module": "WGSL"
+    },
+    "atan": {
+      "signature": "atan",
+      "description": "Built-in atan.",
+      "type": "function",
+      "module": "WGSL"
+    },
+    "atan2": {
+      "signature": "atan2",
+      "description": "Built-in atan2.",
+      "type": "function",
+      "module": "WGSL"
+    },
+    "ceil": {
+      "signature": "ceil",
+      "description": "Built-in ceil.",
+      "type": "function",
+      "module": "WGSL"
+    },
+    "clamp": {
+      "signature": "clamp",
+      "description": "Built-in clamp.",
+      "type": "function",
+      "module": "WGSL"
+    },
+    "cos": {
+      "signature": "cos",
+      "description": "Built-in cos.",
+      "type": "function",
+      "module": "WGSL"
+    }
+  }
+}