@enjoys/context-engine 1.0.0 → 1.0.1

package/data/hover/python.json

@@ -0,0 +1,380 @@
+{
+  "language": "python",
+  "hovers": {
+    "print": {
+      "contents": [
+        { "value": "```python\nprint(*objects, sep=' ', end='\\n', file=sys.stdout, flush=False) -> None\n```\nPrint objects to the text stream *file*, separated by *sep* and followed by *end*. Both *sep* and *end* must be strings." }
+      ]
+    },
+    "len": {
+      "contents": [
+        { "value": "```python\nlen(s: Sized) -> int\n```\nReturn the number of items in a container. The argument may be a sequence (string, bytes, tuple, list, range) or a collection (dict, set, frozenset)." }
+      ]
+    },
+    "range": {
+      "contents": [
+        { "value": "```python\nclass range(stop)\nclass range(start, stop, step=1)\n```\nAn immutable sequence of numbers. Commonly used for looping a specific number of times in `for` loops. Supports membership testing, indexing, slicing, and negative indices." }
+      ]
+    },
+    "enumerate": {
+      "contents": [
+        { "value": "```python\nenumerate(iterable, start=0) -> Iterator[tuple[int, T]]\n```\nReturn an enumerate object. Yields pairs containing a count (from *start*, default 0) and the values from the iterable." }
+      ]
+    },
+    "zip": {
+      "contents": [
+        { "value": "```python\nzip(*iterables, strict=False) -> Iterator[tuple[...]]\n```\nIterate over several iterables in parallel, producing tuples with an item from each one. With `strict=True` (3.10+), raises `ValueError` if iterables have different lengths." }
+      ]
+    },
+    "map": {
+      "contents": [
+        { "value": "```python\nmap(function, iterable, *iterables) -> Iterator\n```\nReturn an iterator that applies *function* to every item of *iterable*, yielding the results. With multiple iterables, the function must accept that many arguments." }
+      ]
+    },
+    "filter": {
+      "contents": [
+        { "value": "```python\nfilter(function: Callable[[T], bool] | None, iterable: Iterable[T]) -> Iterator[T]\n```\nReturn an iterator yielding those items of *iterable* for which `function(item)` is true. If function is `None`, return items that are true." }
+      ]
+    },
+    "sorted": {
+      "contents": [
+        { "value": "```python\nsorted(iterable, /, *, key=None, reverse=False) -> list\n```\nReturn a new sorted list from the items in *iterable*. *key* specifies a function of one argument used to extract a comparison key. The sort is stable." }
+      ]
+    },
+    "reversed": {
+      "contents": [
+        { "value": "```python\nreversed(sequence) -> Iterator\n```\nReturn a reverse iterator over the values of the given sequence. The sequence must have a `__reversed__()` method or support `__len__()` and `__getitem__()`." }
+      ]
+    },
+    "any": {
+      "contents": [
+        { "value": "```python\nany(iterable) -> bool\n```\nReturn `True` if any element of the *iterable* is true. If the iterable is empty, return `False`. Short-circuits on the first true value." }
+      ]
+    },
+    "all": {
+      "contents": [
+        { "value": "```python\nall(iterable) -> bool\n```\nReturn `True` if all elements of the *iterable* are true (or if the iterable is empty). Short-circuits on the first false value." }
+      ]
+    },
+    "isinstance": {
+      "contents": [
+        { "value": "```python\nisinstance(object, classinfo) -> bool\n```\nReturn `True` if *object* is an instance of *classinfo*. *classinfo* may be a type, a tuple of types, or (3.10+) a `Union` type." }
+      ]
+    },
+    "issubclass": {
+      "contents": [
+        { "value": "```python\nissubclass(class, classinfo) -> bool\n```\nReturn `True` if *class* is a subclass (direct, indirect, or virtual) of *classinfo*. A class is considered a subclass of itself." }
+      ]
+    },
+    "type": {
+      "contents": [
+        { "value": "```python\ntype(object) -> type\ntype(name: str, bases: tuple, dict: dict) -> type\n```\nWith one argument, return the type of *object*. With three arguments, create a new type object — this is essentially a dynamic form of the `class` statement." }
+      ]
+    },
+    "id": {
+      "contents": [
+        { "value": "```python\nid(object) -> int\n```\nReturn the identity of an object. This is an integer guaranteed to be unique and constant for this object during its lifetime (CPython: memory address)." }
+      ]
+    },
+    "hash": {
+      "contents": [
+        { "value": "```python\nhash(object) -> int\n```\nReturn the hash value of the object (if it has one). Hash values are integers used to quickly compare dictionary keys during lookup." }
+      ]
+    },
+    "dir": {
+      "contents": [
+        { "value": "```python\ndir(object=...) -> list[str]\n```\nWithout arguments, return the list of names in the current local scope. With an argument, return a list of valid attributes for that object." }
+      ]
+    },
+    "vars": {
+      "contents": [
+        { "value": "```python\nvars(object=...) -> dict[str, Any]\n```\nReturn the `__dict__` attribute of the given object. Without arguments, acts like `locals()`." }
+      ]
+    },
+    "getattr": {
+      "contents": [
+        { "value": "```python\ngetattr(object, name: str, default=...) -> Any\n```\nReturn the value of the named attribute of *object*. If *default* is provided, it is returned when the attribute doesn't exist; otherwise `AttributeError` is raised." }
+      ]
+    },
+    "setattr": {
+      "contents": [
+        { "value": "```python\nsetattr(object, name: str, value) -> None\n```\nSet the named attribute on the given object to the specified value. Equivalent to `object.name = value`." }
+      ]
+    },
+    "hasattr": {
+      "contents": [
+        { "value": "```python\nhasattr(object, name: str) -> bool\n```\nReturn `True` if the string *name* is the name of one of the object's attributes. Implemented by calling `getattr(object, name)` and checking for `AttributeError`." }
+      ]
+    },
+    "delattr": {
+      "contents": [
+        { "value": "```python\ndelattr(object, name: str) -> None\n```\nDelete the named attribute from the given object. Equivalent to `del object.name`." }
+      ]
+    },
+    "super": {
+      "contents": [
+        { "value": "```python\nsuper() -> super\nsuper(type, object_or_type=...) -> super\n```\nReturn a proxy object that delegates method calls to a parent or sibling class of *type*. Zero-argument form works inside a class body." }
+      ]
+    },
+    "abs": {
+      "contents": [
+        { "value": "```python\nabs(x) -> int | float | complex\n```\nReturn the absolute value of a number. The argument may be an integer, a floating-point number, or an object implementing `__abs__()`." }
+      ]
+    },
+    "min": {
+      "contents": [
+        { "value": "```python\nmin(iterable, *, key=None, default=...)\nmin(arg1, arg2, *args, key=None)\n```\nReturn the smallest item in an iterable or the smallest of two or more arguments. If *key* is provided, it specifies a one-argument ordering function." }
+      ]
+    },
+    "max": {
+      "contents": [
+        { "value": "```python\nmax(iterable, *, key=None, default=...)\nmax(arg1, arg2, *args, key=None)\n```\nReturn the largest item in an iterable or the largest of two or more arguments. If *key* is provided, it specifies a one-argument ordering function." }
+      ]
+    },
+    "sum": {
+      "contents": [
+        { "value": "```python\nsum(iterable, /, start=0) -> number\n```\nSums *start* and the items of an *iterable* from left to right and returns the total. The iterable's items are normally numbers; the start value is not allowed to be a string." }
+      ]
+    },
+    "round": {
+      "contents": [
+        { "value": "```python\nround(number, ndigits=None) -> int | float\n```\nRound a number to a given precision in decimal digits. If *ndigits* is omitted or `None`, returns the nearest integer. Uses banker's rounding (round-half-to-even)." }
+      ]
+    },
+    "pow": {
+      "contents": [
+        { "value": "```python\npow(base, exp, mod=None)\n```\nReturn `base ** exp`; if *mod* is present, return `base ** exp % mod` (computed more efficiently than `pow(base, exp) % mod`)." }
+      ]
+    },
+    "divmod": {
+      "contents": [
+        { "value": "```python\ndivmod(a, b) -> tuple[int, int]\n```\nReturn the pair `(a // b, a % b)`. For floating-point numbers, the result is `(q, a % b)` where `q` is usually `math.floor(a / b)`." }
+      ]
+    },
+    "open": {
+      "contents": [
+        { "value": "```python\nopen(\n    file,\n    mode='r',\n    buffering=-1,\n    encoding=None,\n    errors=None,\n    newline=None,\n    closefd=True,\n    opener=None\n) -> IO\n```\nOpen *file* and return a corresponding file object. *mode* is an optional string specifying the mode: `'r'` (read), `'w'` (write), `'a'` (append), `'x'` (exclusive create), `'b'` (binary), `'t'` (text), `'+'` (update)." }
+      ]
+    },
+    "input": {
+      "contents": [
+        { "value": "```python\ninput(prompt='') -> str\n```\nRead a line from input (via `sys.stdin`), convert it to a string (stripping a trailing newline), and return that. The *prompt* string is written to standard output without a trailing newline." }
+      ]
+    },
+    "iter": {
+      "contents": [
+        { "value": "```python\niter(object) -> Iterator\niter(callable, sentinel) -> Iterator\n```\nReturn an iterator object. The first form expects an iterable. The second form calls *callable* with no arguments until it returns *sentinel*." }
+      ]
+    },
+    "next": {
+      "contents": [
+        { "value": "```python\nnext(iterator, default=...) -> T\n```\nRetrieve the next item from the *iterator* by calling its `__next__()` method. If *default* is given, it is returned if the iterator is exhausted; otherwise, `StopIteration` is raised." }
+      ]
+    },
+    "callable": {
+      "contents": [
+        { "value": "```python\ncallable(object) -> bool\n```\nReturn `True` if the object argument appears callable, `False` if not. Classes are callable (calling a class returns a new instance); instances are callable if their class has a `__call__()` method." }
+      ]
+    },
+    "eval": {
+      "contents": [
+        { "value": "```python\neval(expression: str, globals=None, locals=None) -> Any\n```\nEvaluate a Python expression string (a single expression, not statements) and return the result.\n\n⚠️ **Security warning:** Never use `eval` with untrusted input." }
+      ]
+    },
+    "exec": {
+      "contents": [
+        { "value": "```python\nexec(code: str | code, globals=None, locals=None) -> None\n```\nDynamically execute Python code. *code* can be a string or a code object. Unlike `eval`, `exec` supports statements.\n\n⚠️ **Security warning:** Never use `exec` with untrusted input." }
+      ]
+    },
+    "compile": {
+      "contents": [
+        { "value": "```python\ncompile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1) -> code\n```\nCompile the *source* into a code or AST object. *mode* is `'exec'` (module), `'eval'` (single expression), or `'single'` (interactive statement)." }
+      ]
+    },
+    "breakpoint": {
+      "contents": [
+        { "value": "```python\nbreakpoint(*args, **kws) -> None\n```\nCall `sys.breakpointhook()`, passing *args* and *kws* through. By default this drops you into `pdb`. Set `PYTHONBREAKPOINT=0` to disable, or set it to another debugger's entry point." }
+      ]
+    },
+    "repr": {
+      "contents": [
+        { "value": "```python\nrepr(object) -> str\n```\nReturn a string containing a printable representation of an object. For many types this attempts to return a string that would yield an object with the same value when passed to `eval()`." }
+      ]
+    },
+    "format": {
+      "contents": [
+        { "value": "```python\nformat(value, format_spec='') -> str\n```\nConvert a *value* to a formatted representation, as controlled by *format_spec*. Delegates to `value.__format__(format_spec)`." }
+      ]
+    },
+    "hex": {
+      "contents": [
+        { "value": "```python\nhex(x: int) -> str\n```\nConvert an integer number to a lowercase hexadecimal string prefixed with `'0x'`." }
+      ]
+    },
+    "oct": {
+      "contents": [
+        { "value": "```python\noct(x: int) -> str\n```\nConvert an integer number to an octal string prefixed with `'0o'`." }
+      ]
+    },
+    "bin": {
+      "contents": [
+        { "value": "```python\nbin(x: int) -> str\n```\nConvert an integer number to a binary string prefixed with `'0b'`." }
+      ]
+    },
+    "ord": {
+      "contents": [
+        { "value": "```python\nord(c: str) -> int\n```\nReturn the Unicode code point for a one-character string." }
+      ]
+    },
+    "chr": {
+      "contents": [
+        { "value": "```python\nchr(i: int) -> str\n```\nReturn the string representing a character whose Unicode code point is the integer *i*. `chr(97)` returns `'a'`." }
+      ]
+    },
+    "str": {
+      "contents": [
+        { "value": "```python\nclass str(object='')\nclass str(object=b'', encoding='utf-8', errors='strict')\n```\nThe `str` type is the standard text sequence type in Python. Strings are immutable sequences of Unicode code points. Support indexing, slicing, `+` concatenation, `*` repetition, `in` membership, and numerous methods like `.split()`, `.join()`, `.replace()`, `.strip()`, `.format()`, `.encode()`." }
+      ]
+    },
+    "list": {
+      "contents": [
+        { "value": "```python\nclass list(iterable=())\n```\nMutable sequence type. Lists may be constructed with `[]`, `list()`, or list comprehensions `[x for x in it]`. Support indexing, slicing, `+`, `*`, `in`, and methods like `.append()`, `.extend()`, `.pop()`, `.insert()`, `.remove()`, `.sort()`, `.reverse()`, `.copy()`." }
+      ]
+    },
+    "dict": {
+      "contents": [
+        { "value": "```python\nclass dict(**kwargs)\nclass dict(mapping, **kwargs)\nclass dict(iterable, **kwargs)\n```\nMutable mapping type. Dicts may be constructed with `{}`, `dict()`, or dict comprehensions `{k: v for k, v in it}`. Key methods: `.get()`, `.items()`, `.keys()`, `.values()`, `.update()`, `.pop()`, `.setdefault()`, `|` merge (3.9+)." }
+      ]
+    },
+    "set": {
+      "contents": [
+        { "value": "```python\nclass set(iterable=())\n```\nMutable unordered collection of unique hashable elements. Support set operations: `|` (union), `&` (intersection), `-` (difference), `^` (symmetric difference). Methods include `.add()`, `.discard()`, `.remove()`, `.update()`, `.intersection()`, `.union()`, `.difference()`." }
+      ]
+    },
+    "tuple": {
+      "contents": [
+        { "value": "```python\nclass tuple(iterable=())\n```\nImmutable sequence type. Tuples may be constructed with `()`, `tuple()`, or a trailing comma `a,`. Support indexing, slicing, `+`, `*`, `in`, packing/unpacking, and named tuples via `collections.namedtuple`." }
+      ]
+    },
+    "int": {
+      "contents": [
+        { "value": "```python\nclass int(x=0)\nclass int(x: str, base=10)\n```\nImmutable arbitrary-precision integer type. Supports standard arithmetic operations and bit operations (`&`, `|`, `^`, `~`, `<<`, `>>`). Methods: `.bit_length()`, `.bit_count()`, `.to_bytes()`, `.from_bytes()`." }
+      ]
+    },
+    "float": {
+      "contents": [
+        { "value": "```python\nclass float(x=0.0)\n```\nImmutable floating-point number (IEEE 754 double precision). Special values: `float('inf')`, `float('-inf')`, `float('nan')`. Methods: `.is_integer()`, `.hex()`, `.fromhex()`, `.as_integer_ratio()`." }
+      ]
+    },
+    "bool": {
+      "contents": [
+        { "value": "```python\nclass bool(x=False)\n```\nSubclass of `int`. Has exactly two instances: `True` (== 1) and `False` (== 0). Falsy values include `None`, `0`, `''`, `[]`, `{}`, `set()`, `b''`." }
+      ]
+    },
+    "bytes": {
+      "contents": [
+        { "value": "```python\nclass bytes(source=b'')\nclass bytes(source: str, encoding: str)\nclass bytes(length: int)\n```\nImmutable sequence of bytes (integers 0–255). Supports many `str`-like methods: `.split()`, `.join()`, `.replace()`, `.startswith()`, `.decode()`, `.hex()`, `.fromhex()`." }
+      ]
+    },
+    "frozenset": {
+      "contents": [
+        { "value": "```python\nclass frozenset(iterable=())\n```\nImmutable version of `set`. Being immutable and hashable, frozensets can be used as dictionary keys or elements of other sets." }
+      ]
+    },
+    "os": {
+      "contents": [
+        { "value": "```python\nimport os\n```\nMiscellaneous operating system interfaces. Provides functions for interacting with the file system, process management, and environment variables. Key members: `os.path`, `os.environ`, `os.listdir()`, `os.makedirs()`, `os.getcwd()`, `os.getenv()`, `os.walk()`." }
+      ]
+    },
+    "sys": {
+      "contents": [
+        { "value": "```python\nimport sys\n```\nSystem-specific parameters and functions. Provides access to interpreter variables: `sys.argv`, `sys.path`, `sys.stdin`, `sys.stdout`, `sys.stderr`, `sys.version_info`, `sys.exit()`, `sys.modules`, `sys.platform`." }
+      ]
+    },
+    "json": {
+      "contents": [
+        { "value": "```python\nimport json\n```\nJSON encoder and decoder. Key functions: `json.dumps(obj)` — serialize to string, `json.loads(s)` — deserialize from string, `json.dump(obj, fp)` — serialize to file, `json.load(fp)` — deserialize from file." }
+      ]
+    },
+    "pathlib": {
+      "contents": [
+        { "value": "```python\nfrom pathlib import Path\n```\nObject-oriented filesystem paths. `Path` represents filesystem paths with methods for common operations: `.read_text()`, `.write_text()`, `.exists()`, `.mkdir()`, `.glob()`, `.iterdir()`, `.resolve()`, `.parent`, `.name`, `.suffix`, `.stem`. Use `/` operator for joining paths." }
+      ]
+    },
+    "asyncio": {
+      "contents": [
+        { "value": "```python\nimport asyncio\n```\nAsynchronous I/O framework. Core concepts: coroutines (`async def`), tasks, event loops. Key functions: `asyncio.run()`, `asyncio.create_task()`, `asyncio.gather()`, `asyncio.sleep()`, `asyncio.wait()`, `asyncio.TaskGroup` (3.11+). Use `await` to suspend until a coroutine completes." }
+      ]
+    },
+    "re": {
+      "contents": [
+        { "value": "```python\nimport re\n```\nRegular expression operations. Key functions: `re.search()` — scan for a match, `re.match()` — match at the beginning, `re.findall()` — find all matches, `re.sub()` — replace matches, `re.compile()` — compile a pattern for reuse, `re.split()` — split by pattern." }
+      ]
+    },
+    "typing": {
+      "contents": [
+        { "value": "```python\nimport typing\n```\nSupport for type hints. Provides special forms: `Optional`, `Union`, `Any`, `TypeVar`, `Generic`, `Protocol`, `Literal`, `Final`, `TypeGuard`, `Self`, `Never`, `TypeAlias`. In Python 3.9+ most generic types can use built-in syntax (`list[int]` instead of `List[int]`). In 3.10+ use `X | Y` instead of `Union[X, Y]`." }
+      ]
+    },
+    "async": {
+      "contents": [
+        { "value": "```python\nasync def coroutine():\n    result = await some_awaitable()\n```\nThe `async` keyword declares an asynchronous coroutine function. Use `await` inside to pause execution until the awaitable completes. Combine with `async for` (async iteration) and `async with` (async context managers)." }
+      ]
+    },
+    "await": {
+      "contents": [
+        { "value": "```python\nresult = await coroutine()\n```\nSuspend execution of the coroutine until the awaitable object completes and return its result. Can only be used inside `async def` functions." }
+      ]
+    },
+    "yield": {
+      "contents": [
+        { "value": "```python\nyield value\nyield from iterable\n```\n`yield` pauses a generator function and sends a value to the caller. `yield from` delegates to a sub-generator, forwarding sent values and exceptions. A function containing `yield` becomes a generator function." }
+      ]
+    },
+    "with": {
+      "contents": [
+        { "value": "```python\nwith expression as variable:\n    ...\n```\nThe `with` statement simplifies resource management using context managers. `__enter__()` is called on entry (its return value is bound to `as variable`) and `__exit__()` is called on exit, even if an exception occurs." }
+      ]
+    },
+    "match": {
+      "contents": [
+        { "value": "```python\nmatch subject:\n    case pattern:\n        ...\n```\nStructural pattern matching (Python 3.10+). Matches *subject* against one or more `case` patterns in order. Supports literal patterns, capture patterns, sequence patterns, mapping patterns, class patterns, OR patterns (`|`), and wildcard `_`." }
+      ]
+    },
+    "case": {
+      "contents": [
+        { "value": "```python\ncase pattern [if guard]:\n    ...\n```\nA `case` clause in a `match` statement. The pattern can be a literal, name, sequence, mapping, class pattern, or `_` wildcard. An optional `if guard` adds an extra condition." }
+      ]
+    },
+    "property": {
+      "contents": [
+        { "value": "```python\n@property\ndef name(self) -> type:\n    return self._name\n```\nThe `@property` decorator turns a method into a read-only attribute. Use `@name.setter` and `@name.deleter` to define the setter and deleter." }
+      ]
+    },
+    "staticmethod": {
+      "contents": [
+        { "value": "```python\n@staticmethod\ndef method(args) -> type:\n    ...\n```\nTransform a method into a static method — it does not receive an implicit first argument (`self` or `cls`). Can be called on the class or on an instance." }
+      ]
+    },
+    "classmethod": {
+      "contents": [
+        { "value": "```python\n@classmethod\ndef method(cls, args) -> type:\n    ...\n```\nTransform a method into a class method — it receives the class as the implicit first argument instead of an instance. Commonly used for alternative constructors." }
+      ]
+    },
+    "dataclass": {
+      "contents": [
+        { "value": "```python\nfrom dataclasses import dataclass\n\n@dataclass\nclass ClassName:\n    field: type\n```\nThe `@dataclass` decorator auto-generates `__init__()`, `__repr__()`, `__eq__()`, and optionally `__hash__()`, `__lt__()` etc. Parameters: `frozen=True` (immutable), `slots=True` (3.10+), `kw_only=True` (3.10+), `order=True`." }
+      ]
+    },
+    "globals": {
+      "contents": [
+        { "value": "```python\nglobals() -> dict[str, Any]\n```\nReturn the dictionary implementing the current module namespace. This is always the namespace of the current module — inside a function, this is the module's namespace, not the function's local namespace." }
+      ]
+    },
+    "locals": {
+      "contents": [
+        { "value": "```python\nlocals() -> dict[str, Any]\n```\nReturn a mapping of the current local symbol table. Free variables are returned by `locals()` when called in function blocks. The contents should not be modified (changes may not affect the actual locals in CPython 3.13+)." }
+      ]
+    }
+  }
+}

package/data/hover/ruby.json

@@ -0,0 +1,265 @@
+{
+  "language": "ruby",
+  "hovers": {
+    "puts": {
+      "contents": [
+        { "value": "```ruby\nputs(*objects) -> nil\n```\nWrites the given objects to STDOUT, followed by a newline for each. Calls `.to_s` on each object. Returns `nil`." }
+      ]
+    },
+    "print": {
+      "contents": [
+        { "value": "```ruby\nprint(*objects) -> nil\n```\nPrints the given objects to STDOUT without a trailing newline. Calls `.to_s` on each object." }
+      ]
+    },
+    "p": {
+      "contents": [
+        { "value": "```ruby\np(*objects) -> object\n```\nFor each object, calls `object.inspect` and writes the result to STDOUT followed by a newline. Returns the object (or array of objects if multiple)." }
+      ]
+    },
+    "pp": {
+      "contents": [
+        { "value": "```ruby\npp(*objects) -> object\n```\nPretty-prints the given objects with nice formatting and indentation. Returns the object." }
+      ]
+    },
+    "printf": {
+      "contents": [
+        { "value": "```ruby\nprintf(format_string, *args) -> nil\n```\nPrints a formatted string to STDOUT using format specifiers like `%s`, `%d`, `%f`, `%x`." }
+      ]
+    },
+    "warn": {
+      "contents": [
+        { "value": "```ruby\nwarn(*messages, uplevel: nil, category: nil) -> nil\n```\nWrites the given messages to STDERR. If `uplevel` is given, prepends the file and line info." }
+      ]
+    },
+    "def": {
+      "contents": [
+        { "value": "```ruby\ndef method_name(args)\n  body\nend\n```\nDefines a new method. The return value is the result of the last evaluated expression, or an explicit `return`. Methods are instances of `UnboundMethod`." }
+      ]
+    },
+    "class": {
+      "contents": [
+        { "value": "```ruby\nclass ClassName < SuperClass\n  body\nend\n```\nDefines a new class. Classes are open and can be reopened to add or modify methods. Inherits from `Object` by default." }
+      ]
+    },
+    "module": {
+      "contents": [
+        { "value": "```ruby\nmodule ModuleName\n  body\nend\n```\nDefines a module. Modules serve as namespaces and as mixins. They cannot be instantiated. Use `include` to mix into a class." }
+      ]
+    },
+    "include": {
+      "contents": [
+        { "value": "```ruby\ninclude(module, ...) -> self\n```\nIncludes the given module(s) into the current class or module. The module's methods become available as instance methods." }
+      ]
+    },
+    "extend": {
+      "contents": [
+        { "value": "```ruby\nextend(module, ...) -> self\n```\nAdds the methods from the given module(s) as singleton (class-level) methods to the receiver." }
+      ]
+    },
+    "prepend": {
+      "contents": [
+        { "value": "```ruby\nprepend(module, ...) -> self\n```\nPrepends the module(s) to the current class, inserting them before the class in the method lookup chain. Useful for method wrapping." }
+      ]
+    },
+    "require": {
+      "contents": [
+        { "value": "```ruby\nrequire(name) -> true or false\n```\nLoads the given library (a `.rb` or native extension). Returns `true` if loaded successfully, `false` if already loaded. Searches `$LOAD_PATH`." }
+      ]
+    },
+    "require_relative": {
+      "contents": [
+        { "value": "```ruby\nrequire_relative(path) -> true or false\n```\nLoads a file relative to the directory of the file containing the `require_relative` call." }
+      ]
+    },
+    "attr_accessor": {
+      "contents": [
+        { "value": "```ruby\nattr_accessor(*symbols) -> array\n```\nDefines getter and setter instance methods for the named attributes. Equivalent to calling both `attr_reader` and `attr_writer`." }
+      ]
+    },
+    "attr_reader": {
+      "contents": [
+        { "value": "```ruby\nattr_reader(*symbols) -> array\n```\nDefines getter instance methods for the named attributes. Each generated method returns the value of the corresponding instance variable." }
+      ]
+    },
+    "attr_writer": {
+      "contents": [
+        { "value": "```ruby\nattr_writer(*symbols) -> array\n```\nDefines setter instance methods for the named attributes. Each generated method sets the corresponding instance variable." }
+      ]
+    },
+    "raise": {
+      "contents": [
+        { "value": "```ruby\nraise(exception_class, message, backtrace)\nraise(message)\nraise\n```\nRaises an exception. With no arguments, re-raises the current exception. With a string, raises a `RuntimeError`. With a class, creates and raises an instance of that class." }
+      ]
+    },
+    "yield": {
+      "contents": [
+        { "value": "```ruby\nyield(*args) -> object\n```\nTransfers control to the block passed to the current method. Passes the given arguments to the block and returns the block's return value." }
+      ]
+    },
+    "block_given?": {
+      "contents": [
+        { "value": "```ruby\nblock_given? -> true or false\n```\nReturns `true` if a block was passed to the current method via `yield`. Useful for methods that optionally accept blocks." }
+      ]
+    },
+    "lambda": {
+      "contents": [
+        { "value": "```ruby\nlambda { |args| body } -> Proc\n```\nCreates a lambda (a Proc with strict argument checking). `return` inside a lambda exits the lambda only. Also available as `->` (stabby lambda)." }
+      ]
+    },
+    "proc": {
+      "contents": [
+        { "value": "```ruby\nproc { |args| body } -> Proc\n```\nCreates a Proc object. Unlike lambdas, procs have relaxed argument checking and `return` exits the enclosing method." }
+      ]
+    },
+    "if": {
+      "contents": [
+        { "value": "```ruby\nif condition\n  body\nelsif condition\n  body\nelse\n  body\nend\n```\nConditional execution. In Ruby, only `false` and `nil` are falsy; everything else (including `0` and `\"\"`) is truthy. `if` is also an expression that returns a value." }
+      ]
+    },
+    "unless": {
+      "contents": [
+        { "value": "```ruby\nunless condition\n  body\nelse\n  body\nend\n```\nNegated conditional. Executes the body if the condition is `false` or `nil`. Equivalent to `if !condition`. Avoid using `unless` with `else`." }
+      ]
+    },
+    "case": {
+      "contents": [
+        { "value": "```ruby\ncase expression\nwhen value1\n  body1\nwhen value2\n  body2\nelse\n  default_body\nend\n```\nCase expression using `===` for comparison. Supports ranges, classes, regexps, and procs as `when` values. Ruby 2.7+ also supports pattern matching with `case/in`." }
+      ]
+    },
+    "while": {
+      "contents": [
+        { "value": "```ruby\nwhile condition\n  body\nend\n```\nExecutes the body repeatedly while the condition is truthy. Can also be used as a modifier: `do_something while condition`." }
+      ]
+    },
+    "until": {
+      "contents": [
+        { "value": "```ruby\nuntil condition\n  body\nend\n```\nExecutes the body repeatedly until the condition becomes truthy. Equivalent to `while !condition`." }
+      ]
+    },
+    "begin": {
+      "contents": [
+        { "value": "```ruby\nbegin\n  body\nrescue ExceptionClass => e\n  handle error\nelse\n  no error occurred\nensure\n  always runs\nend\n```\nException handling block. `rescue` catches exceptions, `else` runs when no exception occurs, `ensure` always runs (like `finally` in other languages)." }
+      ]
+    },
+    "rescue": {
+      "contents": [
+        { "value": "```ruby\nrescue ExceptionClass => variable\n```\nCatches exceptions in a `begin/end` block or method body. Without a class, catches `StandardError`. Multiple `rescue` clauses are checked in order." }
+      ]
+    },
+    "ensure": {
+      "contents": [
+        { "value": "```ruby\nensure\n  cleanup_code\nend\n```\nCode in the `ensure` clause always runs, whether or not an exception was raised. Similar to `finally` in Java/JavaScript." }
+      ]
+    },
+    "self": {
+      "contents": [
+        { "value": "```ruby\nself -> object\n```\nRefers to the current object (the receiver of the current method call). At the top level, `self` is `main`. Inside a class body, `self` is the class." }
+      ]
+    },
+    "super": {
+      "contents": [
+        { "value": "```ruby\nsuper\nsuper(args)\n```\nCalls the same-named method in the superclass. Without parentheses or arguments, passes along the current method's arguments. With explicit arguments, passes those instead. With empty parens `super()`, passes no arguments." }
+      ]
+    },
+    "freeze": {
+      "contents": [
+        { "value": "```ruby\nobj.freeze -> obj\n```\nPrevents further modifications to the object. Attempting to modify a frozen object raises `FrozenError`. Freezing is permanent and cannot be undone." }
+      ]
+    },
+    "frozen?": {
+      "contents": [
+        { "value": "```ruby\nobj.frozen? -> true or false\n```\nReturns `true` if the object is frozen (cannot be modified). All `Integer`, `Float`, `Symbol`, and frozen string literals are frozen." }
+      ]
+    },
+    "each": {
+      "contents": [
+        { "value": "```ruby\ncollection.each { |element| block } -> collection\ncollection.each -> Enumerator\n```\nCalls the given block once for each element in the collection, passing that element as a parameter. Returns the collection itself." }
+      ]
+    },
+    "map": {
+      "contents": [
+        { "value": "```ruby\ncollection.map { |element| block } -> Array\ncollection.map -> Enumerator\n```\nReturns a new array with the results of running the block once for every element in the collection. Alias: `collect`." }
+      ]
+    },
+    "select": {
+      "contents": [
+        { "value": "```ruby\ncollection.select { |element| block } -> Array\ncollection.select -> Enumerator\n```\nReturns a new array containing all elements for which the block returns a truthy value. Alias: `filter`." }
+      ]
+    },
+    "reject": {
+      "contents": [
+        { "value": "```ruby\ncollection.reject { |element| block } -> Array\ncollection.reject -> Enumerator\n```\nReturns a new array excluding all elements for which the block returns a truthy value. Opposite of `select`." }
+      ]
+    },
+    "reduce": {
+      "contents": [
+        { "value": "```ruby\ncollection.reduce(initial) { |accumulator, element| block } -> object\ncollection.reduce(symbol) -> object\n```\nCombines all elements by applying a binary operation. Also known as `inject` or `fold`. Without an initial value, uses the first element." }
+      ]
+    },
+    "flat_map": {
+      "contents": [
+        { "value": "```ruby\ncollection.flat_map { |element| block } -> Array\n```\nReturns a new array with the concatenated results of running the block for every element. Equivalent to `map` followed by `flatten(1)`." }
+      ]
+    },
+    "group_by": {
+      "contents": [
+        { "value": "```ruby\ncollection.group_by { |element| block } -> Hash\n```\nGroups the collection's elements into a hash. Keys are the block's return values; values are arrays of elements that produced that key." }
+      ]
+    },
+    "sort_by": {
+      "contents": [
+        { "value": "```ruby\ncollection.sort_by { |element| block } -> Array\n```\nSorts the elements using the values returned by the block as sort keys. Uses a Schwartzian transform for efficiency." }
+      ]
+    },
+    "tally": {
+      "contents": [
+        { "value": "```ruby\ncollection.tally -> Hash\ncollection.tally_by { |element| block } -> Hash\n```\nCounts the occurrences of each element and returns a hash where keys are elements and values are their counts. Added in Ruby 2.7." }
+      ]
+    },
+    "File.read": {
+      "contents": [
+        { "value": "```ruby\nFile.read(filename, length = nil, offset = 0, **opts) -> String\n```\nOpens the file, optionally seeks to the given offset, reads `length` bytes (or all if nil), and returns the data as a string." }
+      ]
+    },
+    "File.write": {
+      "contents": [
+        { "value": "```ruby\nFile.write(filename, string, offset = nil, **opts) -> Integer\n```\nOpens the file, optionally seeks to the given offset, writes the string, and returns the number of bytes written." }
+      ]
+    },
+    "File.open": {
+      "contents": [
+        { "value": "```ruby\nFile.open(filename, mode = 'r', **opts) -> File\nFile.open(filename, mode = 'r', **opts) { |f| block } -> object\n```\nOpens the file with the given mode. When a block is given, the file is passed to the block and automatically closed afterward." }
+      ]
+    },
+    "File.exist?": {
+      "contents": [
+        { "value": "```ruby\nFile.exist?(path) -> true or false\n```\nReturns `true` if the named file exists. Follows symlinks." }
+      ]
+    },
+    "File.delete": {
+      "contents": [
+        { "value": "```ruby\nFile.delete(*filenames) -> Integer\n```\nDeletes the named file(s). Returns the number of files deleted. Raises `Errno::ENOENT` if a file does not exist." }
+      ]
+    },
+    "File.join": {
+      "contents": [
+        { "value": "```ruby\nFile.join(*parts) -> String\n```\nJoins the given path components using `File::SEPARATOR` (typically `/`). Handles redundant separators." }
+      ]
+    },
+    "File.dirname": {
+      "contents": [
+        { "value": "```ruby\nFile.dirname(path, level = 1) -> String\n```\nReturns all components of the filename except the last one. With `level`, strips that many trailing components." }
+      ]
+    },
+    "File.basename": {
+      "contents": [
+        { "value": "```ruby\nFile.basename(path, suffix = '') -> String\n```\nReturns the last component of the filename. If `suffix` is given and present, it is removed from the result." }
+      ]
+    },
+    "Dir.glob": {
+      "contents": [
+        { "value": "```ruby\nDir.glob(pattern, flags = 0, base: nil) -> Array\n```\nReturns filenames matching the given glob pattern. Supports `*`, `**`, `?`, `[set]`, and `{alt1,alt2}` syntax." }
+      ]
+    }
+  }
+}