@enjoys/context-engine 1.1.0 → 1.1.2

package/data/defination/scala.json

@@ -0,0 +1,285 @@
+{
+  "language": "scala",
+  "definitions": {
+    "println": {
+      "signature": "def println(x: Any): Unit",
+      "description": "Prints a value followed by a newline to standard output",
+      "type": "function",
+      "module": "scala.Predef",
+      "url": "https://www.scala-lang.org/api/current/scala/Predef$.html#println(x:Any):Unit"
+    },
+    "print": {
+      "signature": "def print(x: Any): Unit",
+      "description": "Prints a value to standard output without a trailing newline",
+      "type": "function",
+      "module": "scala.Predef",
+      "url": "https://www.scala-lang.org/api/current/scala/Predef$.html#print(x:Any):Unit"
+    },
+    "require": {
+      "signature": "def require(requirement: Boolean, message: => Any): Unit",
+      "description": "Tests an expression, throwing an IllegalArgumentException if false",
+      "type": "function",
+      "module": "scala.Predef",
+      "url": "https://www.scala-lang.org/api/current/scala/Predef$.html#require(requirement:Boolean,message:=%3EAny):Unit"
+    },
+    "assert": {
+      "signature": "def assert(assertion: Boolean, message: => Any): Unit",
+      "description": "Tests an expression, throwing an AssertionError if false",
+      "type": "function",
+      "module": "scala.Predef",
+      "url": "https://www.scala-lang.org/api/current/scala/Predef$.html#assert(assertion:Boolean,message:=%3EAny):Unit"
+    },
+    "sys.exit": {
+      "signature": "def exit(status: Int): Nothing",
+      "description": "Terminates the currently running JVM with the given status code",
+      "type": "function",
+      "module": "scala.sys",
+      "url": "https://www.scala-lang.org/api/current/scala/sys/index.html"
+    },
+    "sys.error": {
+      "signature": "def error(message: String): Nothing",
+      "description": "Throws a RuntimeException with the given message",
+      "type": "function",
+      "module": "scala.sys",
+      "url": "https://www.scala-lang.org/api/current/scala/sys/index.html"
+    },
+    "Some.apply": {
+      "signature": "def apply[A](x: A): Some[A]",
+      "description": "Creates an Option containing the given value",
+      "type": "function",
+      "module": "scala.Some",
+      "url": "https://www.scala-lang.org/api/current/scala/Some$.html"
+    },
+    "None": {
+      "signature": "object None extends Option[Nothing]",
+      "description": "Represents the absence of a value in an Option",
+      "type": "object",
+      "module": "scala",
+      "url": "https://www.scala-lang.org/api/current/scala/None$.html"
+    },
+    "Left.apply": {
+      "signature": "def apply[A, B](value: A): Left[A, B]",
+      "description": "Creates the left projection of an Either (typically an error)",
+      "type": "function",
+      "module": "scala.util.Left",
+      "url": "https://www.scala-lang.org/api/current/scala/util/Left.html"
+    },
+    "Right.apply": {
+      "signature": "def apply[A, B](value: B): Right[A, B]",
+      "description": "Creates the right projection of an Either (typically a success value)",
+      "type": "function",
+      "module": "scala.util.Right",
+      "url": "https://www.scala-lang.org/api/current/scala/util/Right.html"
+    },
+    "List.apply": {
+      "signature": "def apply[A](xs: A*): List[A]",
+      "description": "Creates a new immutable list with the given elements",
+      "type": "function",
+      "module": "scala.collection.immutable.List",
+      "url": "https://www.scala-lang.org/api/current/scala/collection/immutable/List$.html"
+    },
+    "Map.apply": {
+      "signature": "def apply[K, V](elems: (K, V)*): Map[K, V]",
+      "description": "Creates a new immutable map with the given key-value pairs",
+      "type": "function",
+      "module": "scala.collection.immutable.Map",
+      "url": "https://www.scala-lang.org/api/current/scala/collection/immutable/Map$.html"
+    },
+    "Set.apply": {
+      "signature": "def apply[A](elems: A*): Set[A]",
+      "description": "Creates a new immutable set with the given elements",
+      "type": "function",
+      "module": "scala.collection.immutable.Set",
+      "url": "https://www.scala-lang.org/api/current/scala/collection/immutable/Set$.html"
+    },
+    "Vector.apply": {
+      "signature": "def apply[A](elems: A*): Vector[A]",
+      "description": "Creates a new immutable vector with the given elements",
+      "type": "function",
+      "module": "scala.collection.immutable.Vector",
+      "url": "https://www.scala-lang.org/api/current/scala/collection/immutable/Vector$.html"
+    },
+    "Array.apply": {
+      "signature": "def apply[T: ClassTag](xs: T*): Array[T]",
+      "description": "Creates a new array with the given elements",
+      "type": "function",
+      "module": "scala.Array",
+      "url": "https://www.scala-lang.org/api/current/scala/Array$.html"
+    },
+    "Option.apply": {
+      "signature": "def apply[A](x: A): Option[A]",
+      "description": "Creates an Option from a nullable value; returns None if null",
+      "type": "function",
+      "module": "scala.Option",
+      "url": "https://www.scala-lang.org/api/current/scala/Option$.html"
+    },
+    "Try.apply": {
+      "signature": "def apply[T](r: => T): Try[T]",
+      "description": "Wraps a computation in a Try, catching non-fatal exceptions",
+      "type": "function",
+      "module": "scala.util.Try",
+      "url": "https://www.scala-lang.org/api/current/scala/util/Try$.html"
+    },
+    "Future.apply": {
+      "signature": "def apply[T](body: => T)(implicit executor: ExecutionContext): Future[T]",
+      "description": "Starts an asynchronous computation and returns a Future holding the result",
+      "type": "function",
+      "module": "scala.concurrent.Future",
+      "url": "https://www.scala-lang.org/api/current/scala/concurrent/Future$.html"
+    },
+    "Future.sequence": {
+      "signature": "def sequence[A](in: IterableOnce[Future[A]])(implicit executor: ExecutionContext): Future[List[A]]",
+      "description": "Transforms a collection of Futures into a Future of a collection",
+      "type": "function",
+      "module": "scala.concurrent.Future",
+      "url": "https://www.scala-lang.org/api/current/scala/concurrent/Future$.html"
+    },
+    "Future.successful": {
+      "signature": "def successful[T](result: T): Future[T]",
+      "description": "Creates an already completed Future with the given value",
+      "type": "function",
+      "module": "scala.concurrent.Future",
+      "url": "https://www.scala-lang.org/api/current/scala/concurrent/Future$.html"
+    },
+    "Future.failed": {
+      "signature": "def failed[T](exception: Throwable): Future[T]",
+      "description": "Creates an already failed Future with the given exception",
+      "type": "function",
+      "module": "scala.concurrent.Future",
+      "url": "https://www.scala-lang.org/api/current/scala/concurrent/Future$.html"
+    },
+    "Await.result": {
+      "signature": "def result[T](awaitable: Awaitable[T], atMost: Duration): T",
+      "description": "Blocks until the awaitable completes or the timeout expires",
+      "type": "function",
+      "module": "scala.concurrent.Await",
+      "url": "https://www.scala-lang.org/api/current/scala/concurrent/Await$.html"
+    },
+    "Promise.apply": {
+      "signature": "def apply[T](): Promise[T]",
+      "description": "Creates a new Promise that can be completed to produce a Future",
+      "type": "function",
+      "module": "scala.concurrent.Promise",
+      "url": "https://www.scala-lang.org/api/current/scala/concurrent/Promise$.html"
+    },
+    "Source.fromFile": {
+      "signature": "def fromFile(name: String)(implicit codec: Codec): BufferedSource",
+      "description": "Creates a source from the given filename for reading text",
+      "type": "function",
+      "module": "scala.io.Source",
+      "url": "https://www.scala-lang.org/api/current/scala/io/Source$.html"
+    },
+    "Using.apply": {
+      "signature": "def apply[R: Releasable, A](resource: => R)(f: R => A): Try[A]",
+      "description": "Performs an operation using a resource, ensuring the resource is released afterwards",
+      "type": "function",
+      "module": "scala.util.Using",
+      "url": "https://www.scala-lang.org/api/current/scala/util/Using$.html"
+    },
+    "LazyList.from": {
+      "signature": "def from(start: Int): LazyList[Int]",
+      "description": "Creates an infinite lazy list of integers starting from the given value",
+      "type": "function",
+      "module": "scala.collection.immutable.LazyList",
+      "url": "https://www.scala-lang.org/api/current/scala/collection/immutable/LazyList$.html"
+    },
+    "Iterator.apply": {
+      "signature": "def apply[A](elems: A*): Iterator[A]",
+      "description": "Creates an iterator over the given elements",
+      "type": "function",
+      "module": "scala.collection.Iterator",
+      "url": "https://www.scala-lang.org/api/current/scala/collection/Iterator$.html"
+    },
+    "Seq.apply": {
+      "signature": "def apply[A](elems: A*): Seq[A]",
+      "description": "Creates a new sequence with the given elements",
+      "type": "function",
+      "module": "scala.collection.immutable.Seq",
+      "url": "https://www.scala-lang.org/api/current/scala/collection/immutable/Seq$.html"
+    },
+    "Range.apply": {
+      "signature": "def apply(start: Int, end: Int): Range",
+      "description": "Creates a range of integers from start (inclusive) to end (exclusive)",
+      "type": "function",
+      "module": "scala.collection.immutable.Range",
+      "url": "https://www.scala-lang.org/api/current/scala/collection/immutable/Range$.html"
+    },
+    "Ordering.by": {
+      "signature": "def by[T, S](f: T => S)(implicit ord: Ordering[S]): Ordering[T]",
+      "description": "Creates an ordering based on a mapping function",
+      "type": "function",
+      "module": "scala.math.Ordering",
+      "url": "https://www.scala-lang.org/api/current/scala/math/Ordering$.html"
+    },
+    "implicitly": {
+      "signature": "def implicitly[T](implicit e: T): T",
+      "description": "Summons an implicit value of the given type",
+      "type": "function",
+      "module": "scala.Predef",
+      "url": "https://www.scala-lang.org/api/current/scala/Predef$.html#implicitly[T](implicite:T):T"
+    },
+    "summon": {
+      "signature": "def summon[T](using x: T): T",
+      "description": "Summons a given instance of the specified type (Scala 3)",
+      "type": "function",
+      "module": "scala.Predef",
+      "url": "https://www.scala-lang.org/api/current/scala/Predef$.html"
+    },
+    "identity": {
+      "signature": "def identity[A](x: A): A",
+      "description": "Returns its argument unchanged; the identity function",
+      "type": "function",
+      "module": "scala.Predef",
+      "url": "https://www.scala-lang.org/api/current/scala/Predef$.html#identity[A](x:A):A"
+    },
+    "locally": {
+      "signature": "def locally[T](x: T): T",
+      "description": "Used to create a local block for clarity without introducing a new scope",
+      "type": "function",
+      "module": "scala.Predef",
+      "url": "https://www.scala-lang.org/api/current/scala/Predef$.html"
+    },
+    "classOf": {
+      "signature": "def classOf[T]: Class[T]",
+      "description": "Returns the runtime Class object for the given type",
+      "type": "function",
+      "module": "scala.Predef",
+      "url": "https://www.scala-lang.org/api/current/scala/Predef$.html"
+    },
+    "isInstanceOf": {
+      "signature": "def isInstanceOf[T]: Boolean",
+      "description": "Tests whether the object is an instance of the given type",
+      "type": "function",
+      "module": "scala.Any",
+      "url": "https://www.scala-lang.org/api/current/scala/Any.html"
+    },
+    "asInstanceOf": {
+      "signature": "def asInstanceOf[T]: T",
+      "description": "Casts the object to the given type",
+      "type": "function",
+      "module": "scala.Any",
+      "url": "https://www.scala-lang.org/api/current/scala/Any.html"
+    },
+    "toString": {
+      "signature": "def toString: String",
+      "description": "Returns a string representation of the object",
+      "type": "function",
+      "module": "scala.Any",
+      "url": "https://www.scala-lang.org/api/current/scala/Any.html"
+    },
+    "hashCode": {
+      "signature": "def hashCode: Int",
+      "description": "Returns a hash code value for the object",
+      "type": "function",
+      "module": "scala.Any",
+      "url": "https://www.scala-lang.org/api/current/scala/Any.html"
+    },
+    "equals": {
+      "signature": "def equals(that: Any): Boolean",
+      "description": "Compares this object with another for equality",
+      "type": "function",
+      "module": "scala.Any",
+      "url": "https://www.scala-lang.org/api/current/scala/Any.html"
+    }
+  }
+}

package/data/defination/scheme.json

@@ -0,0 +1,107 @@
+{
+  "language": "scheme",
+  "definitions": {
+    "define": {
+      "signature": "(define name value) | (define (name params ...) body ...)",
+      "description": "Binds a name to a value or defines a procedure with parameters and body expressions in the current environment, serving as the primary definition form in Scheme programs.",
+      "type": "function",
+      "module": "Core Forms"
+    },
+    "lambda": {
+      "signature": "(lambda (params ...) body ...) -> procedure",
+      "description": "Creates an anonymous procedure (closure) that captures its lexical environment, accepting the specified formal parameters and evaluating the body expressions when called.",
+      "type": "function",
+      "module": "Core Forms"
+    },
+    "let": {
+      "signature": "(let ((var1 expr1) (var2 expr2) ...) body ...) -> value",
+      "description": "Introduces local bindings where all initial value expressions are evaluated in the outer scope before any bindings take effect, then evaluates the body in the extended environment.",
+      "type": "function",
+      "module": "Binding Forms"
+    },
+    "let*": {
+      "signature": "(let* ((var1 expr1) (var2 expr2) ...) body ...) -> value",
+      "description": "Sequential binding form where each variable binding is visible to subsequent binding expressions, allowing later bindings to reference earlier ones in the same let block.",
+      "type": "function",
+      "module": "Binding Forms"
+    },
+    "letrec": {
+      "signature": "(letrec ((var1 expr1) (var2 expr2) ...) body ...) -> value",
+      "description": "Recursive binding form where all variables are in scope for all expressions, enabling mutually recursive procedure definitions within a local binding block.",
+      "type": "function",
+      "module": "Binding Forms"
+    },
+    "cond": {
+      "signature": "(cond (test1 expr1 ...) (test2 expr2 ...) ... (else expr ...)) -> value",
+      "description": "Multi-way conditional expression that evaluates test clauses in order and returns the value of the expression sequence for the first true test, with an optional else clause.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "car": {
+      "signature": "(car pair) -> value",
+      "description": "Returns the first element (head) of a pair or the first element of a non-empty list, raising an error if applied to an empty list or non-pair value.",
+      "type": "function",
+      "module": "Pairs and Lists"
+    },
+    "cdr": {
+      "signature": "(cdr pair) -> value",
+      "description": "Returns the second element (tail) of a pair, or the rest of a list after removing the first element, serving as the fundamental list decomposition operation.",
+      "type": "function",
+      "module": "Pairs and Lists"
+    },
+    "cons": {
+      "signature": "(cons a b) -> pair",
+      "description": "Constructs a new pair from two values; when the second argument is a list, produces a new list with the first argument prepended as the head element.",
+      "type": "function",
+      "module": "Pairs and Lists"
+    },
+    "map": {
+      "signature": "(map procedure list1 list2 ...) -> list",
+      "description": "Applies a procedure element-wise to corresponding elements of one or more lists and returns a new list of the results, preserving the order of elements.",
+      "type": "function",
+      "module": "List Operations"
+    },
+    "fold-left": {
+      "signature": "(fold-left procedure init list) -> value",
+      "description": "Reduces a list from left to right by applying a binary procedure to an accumulator (starting with init) and each element, returning the final accumulated value.",
+      "type": "function",
+      "module": "List Operations"
+    },
+    "call/cc": {
+      "signature": "(call-with-current-continuation procedure) -> value",
+      "description": "Captures the current continuation as a first-class escape procedure and passes it to the given procedure, enabling non-local exits, coroutines, and advanced control flow patterns.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "syntax-rules": {
+      "signature": "(define-syntax name (syntax-rules (literals ...) (pattern template) ...)) -> macro",
+      "description": "Defines a hygienic macro transformer using pattern matching rules, where each pattern is matched against use-site forms and the corresponding template generates the expansion.",
+      "type": "function",
+      "module": "Macros"
+    },
+    "values": {
+      "signature": "(values val1 val2 ...) -> multiple values",
+      "description": "Returns multiple values from a procedure, which can be received by call-with-values or let-values, enabling functions to produce more than one result efficiently.",
+      "type": "function",
+      "module": "Multiple Values"
+    },
+    "apply": {
+      "signature": "(apply procedure arg1 ... args-list) -> value",
+      "description": "Calls a procedure with arguments taken from a list, optionally preceded by individual arguments, effectively spreading the list elements as positional parameters.",
+      "type": "function",
+      "module": "Procedures"
+    },
+    "for-each": {
+      "signature": "(for-each procedure list1 list2 ...) -> void",
+      "description": "Applies a procedure to corresponding elements of one or more lists in order purely for side effects, guaranteed to process elements sequentially unlike map.",
+      "type": "function",
+      "module": "List Operations"
+    },
+    "dynamic-wind": {
+      "signature": "(dynamic-wind before thunk after) -> value",
+      "description": "Executes thunk between before and after procedures, guaranteeing that before runs on entry and after on exit even when continuations transfer control in or out.",
+      "type": "function",
+      "module": "Control Flow"
+    }
+  }
+}

package/data/defination/scss.json

@@ -0,0 +1,95 @@
+{
+  "language": "scss",
+  "definitions": {
+    "@mixin": {
+      "signature": "@mixin name($param1, $param2: default) { ... }",
+      "description": "Defines a reusable block of CSS declarations and logic that can accept parameters with optional defaults, enabling DRY styling patterns across stylesheets with @include invocations.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@include": {
+      "signature": "@include mixin-name($arg1, $arg2) | @include mixin-name { @content }",
+      "description": "Invokes a previously defined mixin by name with arguments, optionally passing a content block that the mixin can inject using @content for flexible wrapper-style mixins.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@extend": {
+      "signature": "@extend selector | @extend selector !optional",
+      "description": "Shares CSS rules between selectors by making the current selector inherit all styles of the extended selector, generating combined selector groups in the compiled CSS output.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@use": {
+      "signature": "@use 'path/module' | @use 'path/module' as namespace | @use 'path/module' with ($var: value)",
+      "description": "Imports and namespaces a Sass module, making its variables, mixins, and functions available under a namespace, replacing @import with better encapsulation and deduplication.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@forward": {
+      "signature": "@forward 'path/module' | @forward 'path/module' as prefix-* | @forward 'path/module' hide $var, mixin-name",
+      "description": "Re-exports members from another module, optionally adding a prefix or hiding specific members, enabling library authors to compose public APIs from multiple source files.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@function": {
+      "signature": "@function name($param1, $param2) { @return value; }",
+      "description": "Defines a custom function that computes and returns a value using @return, callable anywhere a CSS value is expected for dynamic calculations within stylesheets.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@each": {
+      "signature": "@each $var in list | @each $key, $value in map { ... }",
+      "description": "Iterates over items in a list or key-value pairs in a map, generating CSS rules for each iteration, commonly used for producing utility classes or theme variations.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "darken": {
+      "signature": "darken($color, $amount) -> Color",
+      "description": "Returns a darker version of the given color by decreasing its lightness by the specified percentage amount, useful for generating hover states and shadow color variations.",
+      "type": "function",
+      "module": "sass:color"
+    },
+    "lighten": {
+      "signature": "lighten($color, $amount) -> Color",
+      "description": "Returns a lighter version of the given color by increasing its lightness by the specified percentage amount, commonly used for creating highlight effects and tint variations.",
+      "type": "function",
+      "module": "sass:color"
+    },
+    "map-get": {
+      "signature": "map-get($map, $key) -> value | null",
+      "description": "Retrieves the value associated with a key in a Sass map data structure, returning null if the key is not found, essential for theme configuration and design token lookups.",
+      "type": "function",
+      "module": "sass:map"
+    },
+    "color.adjust": {
+      "signature": "color.adjust($color, $red: null, $green: null, $blue: null, $hue: null, $saturation: null, $lightness: null, $alpha: null) -> Color",
+      "description": "Creates a new color by adjusting one or more properties of an existing color by fixed amounts, providing precise control over color channel manipulation in the modern module system.",
+      "type": "function",
+      "module": "sass:color"
+    },
+    "map.merge": {
+      "signature": "map.merge($map1, $map2) -> Map",
+      "description": "Combines two maps into a new map where keys from the second map override matching keys in the first, enabling configuration override patterns and theme extension.",
+      "type": "function",
+      "module": "sass:map"
+    },
+    "list.append": {
+      "signature": "list.append($list, $val, $separator: auto) -> List",
+      "description": "Returns a new list with the given value appended to the end, using the specified separator or inheriting the existing list separator for consistent formatting.",
+      "type": "function",
+      "module": "sass:list"
+    },
+    "math.div": {
+      "signature": "math.div($number1, $number2) -> Number",
+      "description": "Performs division of two numbers, replacing the deprecated slash-as-division syntax with an explicit function call to avoid ambiguity with CSS separator slashes.",
+      "type": "function",
+      "module": "sass:math"
+    },
+    "string.unquote": {
+      "signature": "string.unquote($string) -> String",
+      "description": "Removes quotes from a Sass string, returning it as an unquoted string suitable for use as CSS identifiers, property names, and other contexts requiring unquoted values.",
+      "type": "function",
+      "module": "sass:string"
+    }
+  }
+}

package/data/defination/shell.json

@@ -0,0 +1,95 @@
+{
+  "language": "shell",
+  "definitions": {
+    "echo": {
+      "signature": "echo [-neE] [string ...]",
+      "description": "Writes its arguments to standard output separated by spaces followed by a newline. The -n flag suppresses the trailing newline, -e enables backslash escape interpretation.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "test": {
+      "signature": "test expression | [ expression ]",
+      "description": "Evaluates conditional expressions for file attributes, string comparisons, and arithmetic tests, returning exit status 0 for true and 1 for false, used in if statements and loops.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "read": {
+      "signature": "read [-r] [-p prompt] [-t timeout] [-n nchars] [-d delim] [-a array] [name ...]",
+      "description": "Reads a line of input from standard input and splits it into fields assigned to named variables, with -r preventing backslash escape processing and -p displaying a prompt.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "trap": {
+      "signature": "trap [-lp] [action] [signal ...]",
+      "description": "Registers a command to execute when the shell receives specified signals such as EXIT, INT, TERM, or HUP, enabling cleanup handlers and graceful shutdown procedures.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "set": {
+      "signature": "set [-abefhkmnptuvxBCHP] [-o option-name] [-- arg ...]",
+      "description": "Sets or unsets shell options and positional parameters. Common flags include -e (exit on error), -u (treat unset variables as error), -x (print commands before execution).",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "export": {
+      "signature": "export [-fn] [-p] [name[=value] ...]",
+      "description": "Marks variables for automatic export to the environment of subsequently executed child processes, making them available as environment variables in subshells and commands.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "getopts": {
+      "signature": "getopts optstring name [args]",
+      "description": "Parses positional parameters as command-line options according to the optstring specification, setting the named variable to each option found and OPTARG to its argument.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "shift": {
+      "signature": "shift [n]",
+      "description": "Shifts positional parameters to the left by n positions (default 1), discarding the first n parameters and renumbering the remaining ones starting from $1 for argument processing.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "eval": {
+      "signature": "eval [arg ...]",
+      "description": "Concatenates its arguments into a single command string and then executes the result as a shell command, enabling dynamic command construction and variable indirection patterns.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "exec": {
+      "signature": "exec [-cl] [-a name] [command [arguments ...]] [redirection ...]",
+      "description": "Replaces the current shell process with the specified command without creating a new process, or with no command applies redirections to the current shell for file descriptor manipulation.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "source": {
+      "signature": "source filename [arguments] | . filename [arguments]",
+      "description": "Reads and executes commands from the specified file in the current shell environment, making all variable assignments and function definitions persist in the calling shell.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "printf": {
+      "signature": "printf format [arguments ...]",
+      "description": "Formats and outputs text according to a format string with conversion specifiers like %s, %d, %f, providing more precise control over output formatting than echo.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "local": {
+      "signature": "local [option] name[=value] ...",
+      "description": "Declares variables with local scope within a function, preventing modifications from affecting the calling scope, essential for writing reusable shell functions without side effects.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "wait": {
+      "signature": "wait [-fn] [-p varname] [id ...]",
+      "description": "Suspends execution until specified background processes or jobs complete and returns their exit status, or waits for all background children when called without arguments.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "declare": {
+      "signature": "declare [-aAfFgiIlnrtux] [-p] [name[=value] ...]",
+      "description": "Declares variables with specific attributes such as -i for integer, -a for indexed array, -A for associative array, -r for readonly, and -x for export in bash scripts.",
+      "type": "function",
+      "module": "Builtins"
+    }
+  }
+}