@enjoys/context-engine 1.1.1 → 1.2.0

package/data/definition/elixir.json

@@ -0,0 +1,244 @@
+{
+  "language": "elixir",
+  "definitions": {
+    "Enum": {
+      "signature": "defmodule Enum",
+      "description": "The Enum module provides a comprehensive set of algorithms for enumerating over collections that implement the Enumerable protocol (lists, maps, ranges, streams). It includes functions for mapping, filtering, reducing, sorting, grouping, and chunking — forming the backbone of data transformation in Elixir.",
+      "type": "module",
+      "module": "Elixir.Enum",
+      "members": {
+        "map": {
+          "signature": "Enum.map(enumerable, fun) :: list",
+          "description": "Returns a list where each element is the result of invoking fun on the corresponding element of the enumerable.",
+          "type": "function"
+        },
+        "filter": {
+          "signature": "Enum.filter(enumerable, fun) :: list",
+          "description": "Returns a list of elements for which the function returns a truthy value.",
+          "type": "function"
+        },
+        "reduce": {
+          "signature": "Enum.reduce(enumerable, acc, fun) :: term",
+          "description": "Invokes fun for each element with the accumulator, reducing the enumerable to a single value.",
+          "type": "function"
+        },
+        "each": {
+          "signature": "Enum.each(enumerable, fun) :: :ok",
+          "description": "Invokes the given function for each element in the enumerable for side effects only, returns :ok.",
+          "type": "function"
+        },
+        "sort": {
+          "signature": "Enum.sort(enumerable, sorter \\\\ :asc) :: list",
+          "description": "Sorts the enumerable according to Erlang's term ordering or a custom comparison function.",
+          "type": "function"
+        },
+        "find": {
+          "signature": "Enum.find(enumerable, default \\\\ nil, fun) :: term",
+          "description": "Returns the first element for which fun returns a truthy value, or default if no such element exists.",
+          "type": "function"
+        },
+        "group_by": {
+          "signature": "Enum.group_by(enumerable, key_fun, value_fun \\\\ fn x -> x end) :: map",
+          "description": "Groups elements by the result of the key function into a map of lists.",
+          "type": "function"
+        },
+        "count": {
+          "signature": "Enum.count(enumerable) :: non_neg_integer",
+          "description": "Returns the number of elements in the enumerable.",
+          "type": "function"
+        }
+      }
+    },
+    "Map": {
+      "signature": "defmodule Map",
+      "description": "The Map module provides functions for creating and manipulating maps, which are key-value stores in Elixir. Maps allow any value as a key, provide O(log n) access, and are the primary data structure for representing structured data. Map literals use the %{key => value} syntax.",
+      "type": "module",
+      "module": "Elixir.Map",
+      "members": {
+        "new": {
+          "signature": "Map.new(enumerable \\\\ []) :: map",
+          "description": "Creates a new map from an enumerable of key-value pairs (2-element tuples).",
+          "type": "function"
+        },
+        "get": {
+          "signature": "Map.get(map, key, default \\\\ nil) :: value",
+          "description": "Returns the value associated with the key, or the default if the key is not present.",
+          "type": "function"
+        },
+        "put": {
+          "signature": "Map.put(map, key, value) :: map",
+          "description": "Returns a new map with the key-value pair added or updated, preserving all other entries.",
+          "type": "function"
+        },
+        "delete": {
+          "signature": "Map.delete(map, key) :: map",
+          "description": "Returns a new map with the given key removed; returns the map unchanged if key is absent.",
+          "type": "function"
+        },
+        "merge": {
+          "signature": "Map.merge(map1, map2, fun \\\\ fn _k, _v1, v2 -> v2 end) :: map",
+          "description": "Merges two maps into one, using the function to resolve conflicts when both maps contain the same key.",
+          "type": "function"
+        },
+        "keys": {
+          "signature": "Map.keys(map) :: list",
+          "description": "Returns a list of all keys in the map.",
+          "type": "function"
+        }
+      }
+    },
+    "List": {
+      "signature": "defmodule List",
+      "description": "The List module provides functions specific to linked lists, which are the fundamental ordered collection in Elixir. Lists support pattern matching with [head | tail] destructuring, are immutable, and prepending is O(1). For general collection operations, use Enum instead.",
+      "type": "module",
+      "module": "Elixir.List",
+      "members": {
+        "first": {
+          "signature": "List.first(list, default \\\\ nil) :: term",
+          "description": "Returns the first element of the list, or default if the list is empty.",
+          "type": "function"
+        },
+        "last": {
+          "signature": "List.last(list, default \\\\ nil) :: term",
+          "description": "Returns the last element of the list, or default if the list is empty.",
+          "type": "function"
+        },
+        "flatten": {
+          "signature": "List.flatten(list) :: list",
+          "description": "Recursively flattens nested lists into a single flat list.",
+          "type": "function"
+        },
+        "zip": {
+          "signature": "List.zip(list_of_lists) :: list",
+          "description": "Zips corresponding elements from multiple lists into a list of tuples.",
+          "type": "function"
+        }
+      }
+    },
+    "String": {
+      "signature": "defmodule String",
+      "description": "The String module provides functions for manipulating UTF-8 encoded binary strings. Elixir strings are binaries and fully support Unicode. The module handles grapheme clusters correctly, distinguishing between bytes, codepoints, and graphemes for accurate text processing.",
+      "type": "module",
+      "module": "Elixir.String",
+      "members": {
+        "split": {
+          "signature": "String.split(string, pattern, opts \\\\ []) :: list(String.t())",
+          "description": "Divides the string into substrings based on the given pattern (string, regex, or list of strings).",
+          "type": "function"
+        },
+        "replace": {
+          "signature": "String.replace(subject, pattern, replacement, opts \\\\ []) :: String.t()",
+          "description": "Returns a new string with occurrences of pattern replaced by replacement.",
+          "type": "function"
+        },
+        "trim": {
+          "signature": "String.trim(string) :: String.t()",
+          "description": "Returns a string with leading and trailing Unicode whitespace removed.",
+          "type": "function"
+        },
+        "contains?": {
+          "signature": "String.contains?(string, contents) :: boolean",
+          "description": "Returns true if the string contains any of the given contents (string or list of strings).",
+          "type": "function"
+        },
+        "length": {
+          "signature": "String.length(string) :: non_neg_integer",
+          "description": "Returns the number of Unicode graphemes in the string (the perceived character count).",
+          "type": "function"
+        }
+      }
+    },
+    "IO": {
+      "signature": "defmodule IO",
+      "description": "The IO module provides functions for handling input and output operations in Elixir. It supports reading from and writing to standard I/O, files, and other I/O devices. IO functions accept iolists (nested lists of integers and binaries) for efficient output without prior concatenation.",
+      "type": "module",
+      "module": "Elixir.IO",
+      "members": {
+        "puts": {
+          "signature": "IO.puts(device \\\\ :stdio, item) :: :ok",
+          "description": "Writes the item to the device followed by a newline character.",
+          "type": "function"
+        },
+        "inspect": {
+          "signature": "IO.inspect(item, opts \\\\ []) :: item",
+          "description": "Inspects and prints the item, then returns it unchanged — perfect for debugging in pipelines.",
+          "type": "function"
+        },
+        "write": {
+          "signature": "IO.write(device \\\\ :stdio, chardata) :: :ok",
+          "description": "Writes the chardata to the device without appending a newline.",
+          "type": "function"
+        }
+      }
+    },
+    "GenServer": {
+      "signature": "defmodule GenServer (behaviour)",
+      "description": "A behaviour module for implementing client-server relationships in OTP. GenServer abstracts the common patterns of a server process that maintains state, handles synchronous (call) and asynchronous (cast) requests, and manages lifecycle callbacks (init, terminate, handle_info).",
+      "type": "module",
+      "module": "Elixir.GenServer",
+      "members": {
+        "start_link": {
+          "signature": "GenServer.start_link(module, init_arg, opts \\\\ []) :: {:ok, pid} | {:error, term}",
+          "description": "Starts a GenServer process linked to the current process, which will be restarted by its supervisor if it crashes.",
+          "type": "function"
+        },
+        "call": {
+          "signature": "GenServer.call(server, request, timeout \\\\ 5000) :: term",
+          "description": "Makes a synchronous request to the server and waits for its reply, with a configurable timeout.",
+          "type": "function"
+        },
+        "cast": {
+          "signature": "GenServer.cast(server, request) :: :ok",
+          "description": "Sends an asynchronous request to the server without waiting for a reply.",
+          "type": "function"
+        }
+      }
+    },
+    "Task": {
+      "signature": "defmodule Task",
+      "description": "The Task module provides conveniences for spawning and awaiting concurrent work in Elixir. Tasks are used for running computations in parallel, especially for fan-out operations where multiple independent pieces of work can execute simultaneously and their results collected later.",
+      "type": "module",
+      "module": "Elixir.Task",
+      "members": {
+        "async": {
+          "signature": "Task.async(fun) :: Task.t()",
+          "description": "Starts a task that can be awaited on, linked to the caller process for error propagation.",
+          "type": "function"
+        },
+        "await": {
+          "signature": "Task.await(task, timeout \\\\ 5000) :: term",
+          "description": "Awaits a task reply and returns the result, raising if the task fails or times out.",
+          "type": "function"
+        },
+        "async_stream": {
+          "signature": "Task.async_stream(enumerable, fun, opts \\\\ []) :: Enumerable.t()",
+          "description": "Returns a stream that runs the given function concurrently on each element of the enumerable with configurable concurrency.",
+          "type": "function"
+        }
+      }
+    },
+    "Stream": {
+      "signature": "defmodule Stream",
+      "description": "The Stream module provides lazy, composable operations on enumerables. Unlike Enum, Stream operations return lazy enumerables that are only computed when consumed. This enables processing large datasets or infinite sequences without loading everything into memory at once.",
+      "type": "module",
+      "module": "Elixir.Stream",
+      "members": {
+        "map": {
+          "signature": "Stream.map(enum, fun) :: Enumerable.t()",
+          "description": "Creates a lazy stream that applies fun to each element when consumed.",
+          "type": "function"
+        },
+        "filter": {
+          "signature": "Stream.filter(enum, fun) :: Enumerable.t()",
+          "description": "Creates a lazy stream that only emits elements for which fun returns a truthy value.",
+          "type": "function"
+        },
+        "chunk_every": {
+          "signature": "Stream.chunk_every(enum, count, step \\\\ count, leftover \\\\ []) :: Enumerable.t()",
+          "description": "Creates a lazy stream that chunks elements into lists of the given count.",
+          "type": "function"
+        }
+      }
+    }
+  }
+}

package/data/definition/flow9.json

@@ -0,0 +1,156 @@
+{
+  "language": "flow9",
+  "definitions": {
+    "array": {
+      "signature": "[T]",
+      "description": "The array type in Flow9 represents an immutable, ordered sequence of elements of the same type. Arrays are the primary collection type and are created using bracket syntax [1, 2, 3]. Since Flow9 arrays are persistent, operations that modify content return new arrays while leaving the original unchanged.",
+      "type": "class",
+      "module": "Flow9 Runtime",
+      "members": {
+        "length": {
+          "signature": "length(a : [?]) -> int",
+          "description": "Returns the number of elements in the array.",
+          "type": "function"
+        },
+        "concat": {
+          "signature": "concat(a : [?], b : [?]) -> [?]",
+          "description": "Returns a new array that is the concatenation of the two input arrays.",
+          "type": "function"
+        },
+        "map": {
+          "signature": "map(a : [?], fn : (?) -> ??) -> [??]",
+          "description": "Returns a new array with the function applied to each element of the input array.",
+          "type": "function"
+        },
+        "filter": {
+          "signature": "filter(a : [?], fn : (?) -> bool) -> [?]",
+          "description": "Returns a new array containing only the elements for which the predicate function returns true.",
+          "type": "function"
+        },
+        "fold": {
+          "signature": "fold(a : [?], init : ??, fn : (??, ?) -> ??) -> ??",
+          "description": "Reduces the array to a single value by applying the function to the accumulator and each element from left to right.",
+          "type": "function"
+        },
+        "arrayPush": {
+          "signature": "arrayPush(a : [?], v : ?) -> [?]",
+          "description": "Returns a new array with the given value appended as the last element.",
+          "type": "function"
+        }
+      }
+    },
+    "tree": {
+      "signature": "Tree<K, V>",
+      "description": "The Tree type in Flow9 is an immutable balanced binary search tree (similar to a sorted map/dictionary) that maps keys to values. Trees provide O(log n) lookup, insertion, and deletion. They are the standard key-value data structure when ordered access or efficient lookup by key is needed.",
+      "type": "class",
+      "module": "Flow9 Runtime",
+      "members": {
+        "makeTree": {
+          "signature": "makeTree() -> Tree<?, ??>",
+          "description": "Creates a new empty tree with no key-value bindings.",
+          "type": "function"
+        },
+        "setTree": {
+          "signature": "setTree(tree : Tree<?, ??>, key : ?, value : ??) -> Tree<?, ??>",
+          "description": "Returns a new tree with the given key-value pair added or updated.",
+          "type": "function"
+        },
+        "lookupTree": {
+          "signature": "lookupTree(tree : Tree<?, ??>, key : ?) -> Maybe<??>",
+          "description": "Looks up a key in the tree, returning Some(value) if found or None() if absent.",
+          "type": "function"
+        },
+        "removeFromTree": {
+          "signature": "removeFromTree(tree : Tree<?, ??>, key : ?) -> Tree<?, ??>",
+          "description": "Returns a new tree with the specified key and its value removed.",
+          "type": "function"
+        },
+        "foldTree": {
+          "signature": "foldTree(tree : Tree<?, ??>, init : ???, fn : (?, ??, ???) -> ???) -> ???",
+          "description": "Folds over all key-value pairs in the tree in order, accumulating a result.",
+          "type": "function"
+        }
+      }
+    },
+    "string": {
+      "signature": "string",
+      "description": "The string type in Flow9 represents an immutable sequence of Unicode characters. Strings support concatenation with the + operator and various built-in functions for searching, splitting, trimming, and converting. String literals are enclosed in double quotes with standard escape sequences.",
+      "type": "class",
+      "module": "Flow9 Runtime",
+      "members": {
+        "strlen": {
+          "signature": "strlen(s : string) -> int",
+          "description": "Returns the length of the string in characters.",
+          "type": "function"
+        },
+        "strContainsAt": {
+          "signature": "strContainsAt(str : string, pos : int, substr : string) -> bool",
+          "description": "Returns true if the substring is found at the specified position in the string.",
+          "type": "function"
+        },
+        "substring": {
+          "signature": "substring(s : string, start : int, length : int) -> string",
+          "description": "Returns a substring starting at the given index with the specified length.",
+          "type": "function"
+        },
+        "strIndexOf": {
+          "signature": "strIndexOf(str : string, substr : string) -> int",
+          "description": "Returns the index of the first occurrence of the substring, or -1 if not found.",
+          "type": "function"
+        },
+        "toLowerCase": {
+          "signature": "toLowerCase(s : string) -> string",
+          "description": "Returns a new string with all characters converted to lowercase.",
+          "type": "function"
+        }
+      }
+    },
+    "ref": {
+      "signature": "ref T",
+      "description": "A mutable reference cell in Flow9 that holds a value of type T and can be updated in place. Refs are the primary mechanism for mutable state in the otherwise functional Flow9 language. Created with ref(value), read with ^refVar (dereference), and updated with refVar := newValue.",
+      "type": "class",
+      "module": "Flow9 Runtime"
+    },
+    "maybe": {
+      "signature": "Maybe<?> ::= None | Some(value : ?)",
+      "description": "A union type representing an optional value that may or may not be present. Maybe is used throughout Flow9 for safe handling of possibly-absent values, particularly as return types from lookups in trees and arrays. Pattern matching with switch is used to extract the contained value.",
+      "type": "class",
+      "module": "Flow9 Runtime",
+      "members": {
+        "Some": {
+          "signature": "Some(value : ?) -> Maybe<?>",
+          "description": "Wraps a present value in the Maybe type, indicating the value exists.",
+          "type": "function"
+        },
+        "None": {
+          "signature": "None() -> Maybe<?>",
+          "description": "Represents the absence of a value in the Maybe type.",
+          "type": "function"
+        },
+        "either": {
+          "signature": "either(m : Maybe<?>, default : ?) -> ?",
+          "description": "Extracts the value from a Maybe, returning the default if it is None.",
+          "type": "function"
+        }
+      }
+    },
+    "int": {
+      "signature": "int",
+      "description": "A 32-bit signed integer type in Flow9 for representing whole numbers. Supports standard arithmetic operations (+, -, *, /, %), comparison operators, and bitwise operations. Integer division truncates toward zero.",
+      "type": "class",
+      "module": "Flow9 Runtime"
+    },
+    "double": {
+      "signature": "double",
+      "description": "A 64-bit double-precision floating-point number type in Flow9 for representing decimal numbers. Follows IEEE 754 standard. Supports standard arithmetic operations and mathematical functions from the math module.",
+      "type": "class",
+      "module": "Flow9 Runtime"
+    },
+    "bool": {
+      "signature": "bool",
+      "description": "A Boolean type in Flow9 with two possible values: true and false. Supports logical operators && (and), || (or), and ! (not). Used in conditional expressions, filter predicates, and control flow statements.",
+      "type": "class",
+      "module": "Flow9 Runtime"
+    }
+  }
+}

package/data/definition/freemarker2.json

@@ -0,0 +1,176 @@
+{
+  "language": "freemarker2",
+  "definitions": {
+    "string_builtins": {
+      "signature": "expr?builtin_name",
+      "description": "FreeMarker string built-ins provide powerful string manipulation capabilities applied using the ?suffix syntax on string expressions. They cover case conversion, trimming, searching, replacing, splitting, and formatting — enabling rich text processing directly within templates without Java code.",
+      "type": "class",
+      "module": "FreeMarker Built-ins",
+      "members": {
+        "length": {
+          "signature": "string?length -> number",
+          "description": "Returns the number of characters in the string as an integer value.",
+          "type": "method"
+        },
+        "upper_case": {
+          "signature": "string?upper_case -> string",
+          "description": "Converts all characters in the string to uppercase according to the current locale settings.",
+          "type": "method"
+        },
+        "lower_case": {
+          "signature": "string?lower_case -> string",
+          "description": "Converts all characters in the string to lowercase according to the current locale settings.",
+          "type": "method"
+        },
+        "cap_first": {
+          "signature": "string?cap_first -> string",
+          "description": "Capitalizes the first letter of the string while leaving the rest unchanged.",
+          "type": "method"
+        },
+        "trim": {
+          "signature": "string?trim -> string",
+          "description": "Removes leading and trailing whitespace characters from the string.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "string?contains(substring) -> boolean",
+          "description": "Returns true if the string contains the specified substring anywhere within it.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "string?replace(target, replacement) -> string",
+          "description": "Replaces all occurrences of the target substring with the replacement string.",
+          "type": "method"
+        },
+        "split": {
+          "signature": "string?split(separator) -> sequence",
+          "description": "Splits the string at each occurrence of the separator and returns a sequence of substrings.",
+          "type": "method"
+        }
+      }
+    },
+    "sequence_builtins": {
+      "signature": "sequence?builtin_name",
+      "description": "FreeMarker sequence built-ins operate on ordered collections (arrays/lists) and provide operations for querying size, sorting, reversing, joining, chunking, and filtering sequences. Sequences are zero-indexed and support random access by index.",
+      "type": "class",
+      "module": "FreeMarker Built-ins",
+      "members": {
+        "size": {
+          "signature": "sequence?size -> number",
+          "description": "Returns the number of elements in the sequence.",
+          "type": "method"
+        },
+        "sort": {
+          "signature": "sequence?sort -> sequence",
+          "description": "Returns a new sequence with elements sorted in ascending order using natural ordering.",
+          "type": "method"
+        },
+        "sort_by": {
+          "signature": "sequence?sort_by(key) -> sequence",
+          "description": "Sorts a sequence of hashes by the specified key name, returning a new sorted sequence.",
+          "type": "method"
+        },
+        "reverse": {
+          "signature": "sequence?reverse -> sequence",
+          "description": "Returns a new sequence with elements in reverse order.",
+          "type": "method"
+        },
+        "first": {
+          "signature": "sequence?first -> element",
+          "description": "Returns the first element of the sequence, or is missing if the sequence is empty.",
+          "type": "method"
+        },
+        "last": {
+          "signature": "sequence?last -> element",
+          "description": "Returns the last element of the sequence.",
+          "type": "method"
+        },
+        "join": {
+          "signature": "sequence?join(separator) -> string",
+          "description": "Concatenates all sequence elements into a single string separated by the given separator.",
+          "type": "method"
+        },
+        "chunk": {
+          "signature": "sequence?chunk(size) -> sequence",
+          "description": "Splits the sequence into sub-sequences of the given maximum size, useful for creating rows/columns in tables.",
+          "type": "method"
+        }
+      }
+    },
+    "hash_builtins": {
+      "signature": "hash?builtin_name",
+      "description": "FreeMarker hash built-ins operate on hash (map/dictionary) values and provide access to the keys and values collections. Hashes in FreeMarker map string keys to arbitrary values and are the primary structure for data model objects passed from the Java backend.",
+      "type": "class",
+      "module": "FreeMarker Built-ins",
+      "members": {
+        "keys": {
+          "signature": "hash?keys -> sequence",
+          "description": "Returns a sequence of all key names in the hash.",
+          "type": "method"
+        },
+        "values": {
+          "signature": "hash?values -> sequence",
+          "description": "Returns a sequence of all values in the hash, in the same order as their corresponding keys.",
+          "type": "method"
+        }
+      }
+    },
+    "number_builtins": {
+      "signature": "number?builtin_name",
+      "description": "FreeMarker number built-ins provide formatting and conversion operations for numeric values including rounding, absolute value, and string conversion with locale-aware formatting. Numbers in FreeMarker automatically handle both integers and floating-point values.",
+      "type": "class",
+      "module": "FreeMarker Built-ins",
+      "members": {
+        "string": {
+          "signature": "number?string(format) -> string",
+          "description": "Converts the number to a formatted string; format can be 'computer' for locale-independent, 'currency', 'percent', or a Java DecimalFormat pattern.",
+          "type": "method"
+        },
+        "abs": {
+          "signature": "number?abs -> number",
+          "description": "Returns the absolute (non-negative) value of the number.",
+          "type": "method"
+        },
+        "round": {
+          "signature": "number?round -> number",
+          "description": "Rounds the number to the nearest integer using half-up rounding.",
+          "type": "method"
+        },
+        "floor": {
+          "signature": "number?floor -> number",
+          "description": "Rounds the number down to the nearest integer (toward negative infinity).",
+          "type": "method"
+        },
+        "ceiling": {
+          "signature": "number?ceiling -> number",
+          "description": "Rounds the number up to the nearest integer (toward positive infinity).",
+          "type": "method"
+        }
+      }
+    },
+    "if_directive": {
+      "signature": "<#if condition>...<#elseif condition>...<#else>...</#if>",
+      "description": "The conditional directive that renders its enclosed content only when the condition evaluates to true. Supports optional elseif and else branches for multi-way branching. Conditions can use comparison operators (==, !=, <, >, <=, >=), logical operators (&&, ||, !), and built-in tests.",
+      "type": "keyword",
+      "module": "FreeMarker Directives"
+    },
+    "list_directive": {
+      "signature": "<#list sequence as item>...<#sep>separator</#sep></#list>",
+      "description": "Iterates over a sequence or collection, rendering the body once for each element. The item variable holds the current element. Supports <#sep> for inter-element separators, <#items> for explicit item blocks, and <#else> for empty collection handling. Tracks iteration via item?index, item?counter, and item?is_last.",
+      "type": "keyword",
+      "module": "FreeMarker Directives"
+    },
+    "assign_directive": {
+      "signature": "<#assign name = value> | <#assign name>capture</#assign>",
+      "description": "Creates or replaces a variable in the current template namespace. The simple form assigns an expression value directly. The capture form captures all output between the tags as a string value, useful for building complex strings from template output.",
+      "type": "keyword",
+      "module": "FreeMarker Directives"
+    },
+    "macro_directive": {
+      "signature": "<#macro name param1 param2=default>body</#macro>",
+      "description": "Defines a reusable template fragment (macro) with optional parameters and default values. Macros are called with the <@name> syntax and support nested content via <#nested>. They enable DRY template design by encapsulating repeated layout patterns.",
+      "type": "keyword",
+      "module": "FreeMarker Directives"
+    }
+  }
+}