@enjoys/context-engine 1.3.1 → 1.4.2

package/data/hover/bash.json

@@ -1,579 +0,0 @@
-{
-  "language": "bash",
-  "hovers": {
-    "echo": {
-      "contents": [
-        {
-          "value": "```bash\necho [-neE] [string ...]\n```\nDisplay a line of text to stdout. `-n` suppresses the trailing newline. `-e` enables interpretation of backslash escapes (`\\t`, `\\n`, `\\\\`, `\\a`, `\\b`, `\\c`, `\\0nnn`, `\\xHH`). `-E` disables escape interpretation (default)."
-        }
-      ]
-    },
-    "printf": {
-      "contents": [
-        {
-          "value": "```bash\nprintf [-v var] format [arguments ...]\n```\nWrite formatted output to stdout. Format specifiers: `%s` (string), `%d` (decimal), `%f` (float), `%x` (hex), `%o` (octal), `%b` (backslash escapes), `%%` (literal %). `-v var` stores the result in a variable instead of printing."
-        }
-      ]
-    },
-    "read": {
-      "contents": [
-        {
-          "value": "```bash\nread [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]\n```\nRead a line from stdin and split it into fields. `-r` disables backslash escaping. `-p` displays a prompt. `-t` sets a timeout in seconds. `-a` reads into an array. `-s` hides input (for passwords). `-d` sets an alternate delimiter."
-        }
-      ]
-    },
-    "cd": {
-      "contents": [
-        {
-          "value": "```bash\ncd [-L|-P] [directory]\n```\nChange the shell working directory. Without arguments, changes to `$HOME`. `cd -` changes to `$OLDPWD` (previous directory). `-L` follows symbolic links (default). `-P` uses the physical directory structure (resolves symlinks)."
-        }
-      ]
-    },
-    "pwd": {
-      "contents": [
-        {
-          "value": "```bash\npwd [-LP]\n```\nPrint the absolute pathname of the current working directory. `-L` displays the logical path preserving symlinks (default). `-P` displays the physical path with all symlinks resolved."
-        }
-      ]
-    },
-    "export": {
-      "contents": [
-        {
-          "value": "```bash\nexport [-fn] [-p] [name[=value] ...]\n```\nSet environment variables for child processes. Variables marked for export are inherited by any subsequently executed commands. `-n` removes the export property. `-f` exports shell functions. `-p` lists all exported variables."
-        }
-      ]
-    },
-    "source": {
-      "contents": [
-        {
-          "value": "```bash\nsource filename [arguments]\n# or: . filename [arguments]\n```\nRead and execute commands from a file in the **current** shell environment. Unlike executing a script (which runs in a subshell), sourced files can modify variables, functions, and aliases in the calling shell."
-        }
-      ]
-    },
-    "alias": {
-      "contents": [
-        {
-          "value": "```bash\nalias [-p] [name[=value] ...]\n```\nDefine or display command aliases. An alias substitutes a string for the first word of a simple command. Aliases are expanded when a command is read, not when it is executed. Use `\\command` to bypass an alias."
-        }
-      ]
-    },
-    "trap": {
-      "contents": [
-        {
-          "value": "```bash\ntrap [-lp] [action] [signal ...]\n```\nExecute a command when the shell receives a signal or on certain events. Common signals: `EXIT` (on shell exit), `ERR` (on command failure with `set -e`), `INT` (Ctrl+C), `TERM` (termination), `DEBUG` (before every command), `RETURN` (after function/source return). Use `trap - signal` to reset to default."
-        }
-      ]
-    },
-    "set": {
-      "contents": [
-        {
-          "value": "```bash\nset [-abefhkmnptuvxBCEHPT] [-o option-name] [--] [arg ...]\n```\nSet or unset shell options and positional parameters. Common options:\n- `-e` — exit immediately if a command exits with non-zero status\n- `-u` — treat unset variables as an error\n- `-x` — print commands and arguments as they are executed\n- `-o pipefail` — return the exit status of the rightmost failed command in a pipeline\n- `--` — end of options; remaining args become positional parameters"
-        }
-      ]
-    },
-    "declare": {
-      "contents": [
-        {
-          "value": "```bash\ndeclare [-aAfFgiIlnrtux] [-p] [name[=value] ...]\n```\nDeclare variables and set their attributes. Flags: `-i` (integer), `-a` (indexed array), `-A` (associative array), `-r` (readonly), `-x` (export), `-l` (lowercase on assignment), `-u` (uppercase on assignment), `-n` (nameref), `-g` (global scope in functions). Inside functions, `declare` creates local variables unless `-g` is specified."
-        }
-      ]
-    },
-    "local": {
-      "contents": [
-        {
-          "value": "```bash\nlocal [-aAfFgiIlnrtux] [name[=value] ...]\n```\nDeclare a variable as local to a function. The variable is visible only within the function and its child functions. Accepts the same attribute flags as `declare`. Can only be used within a function body."
-        }
-      ]
-    },
-    "test": {
-      "contents": [
-        {
-          "value": "```bash\ntest expression\n[ expression ]\n[[ expression ]]\n```\nEvaluate conditional expressions. Returns 0 (true) or 1 (false).\n\n**File tests:** `-f` (regular file), `-d` (directory), `-e` (exists), `-r` (readable), `-w` (writable), `-x` (executable), `-s` (non-empty), `-L` (symlink)\n\n**String tests:** `-z` (empty), `-n` (non-empty), `=` / `==` (equal), `!=` (not equal)\n\n**Integer tests:** `-eq`, `-ne`, `-gt`, `-lt`, `-ge`, `-le`\n\n**Logical:** `!` (not), `-a` / `&&` (and), `-o` / `||` (or)\n\nPrefer `[[ ]]` for safer word-splitting behavior and regex support (`=~`)."
-        }
-      ]
-    },
-    "if": {
-      "contents": [
-        {
-          "value": "```bash\nif command-list; then\n    command-list\n[elif command-list; then\n    command-list] ...\n[else\n    command-list]\nfi\n```\nConditional execution. The `if` command-list is executed; if its exit status is 0, the `then` block runs. Otherwise, each `elif` is tested in turn. If none match, the `else` block runs (if present). Note: `if` tests the **exit status** of a command, not a boolean expression directly."
-        }
-      ]
-    },
-    "for": {
-      "contents": [
-        {
-          "value": "```bash\n# List form:\nfor name [in word ...]; do\n    command-list\ndone\n\n# C-style form:\nfor (( expr1; expr2; expr3 )); do\n    command-list\ndone\n```\nIterate over a list of words or use arithmetic expressions. In the list form, if `in word ...` is omitted, iterates over `\"$@\"`. The variable `name` is set to each word in turn."
-        }
-      ]
-    },
-    "while": {
-      "contents": [
-        {
-          "value": "```bash\nwhile command-list; do\n    command-list\ndone\n```\nExecute commands repeatedly as long as the test command-list returns exit status 0. Commonly used with `read` to process files line by line: `while IFS= read -r line; do ... done < file`."
-        }
-      ]
-    },
-    "until": {
-      "contents": [
-        {
-          "value": "```bash\nuntil command-list; do\n    command-list\ndone\n```\nExecute commands repeatedly until the test command-list returns exit status 0. Logically equivalent to `while ! command-list; do ... done`."
-        }
-      ]
-    },
-    "case": {
-      "contents": [
-        {
-          "value": "```bash\ncase word in\n    pattern1 | pattern2) commands ;;\n    pattern3) commands ;;&\n    pattern4) commands ;&\n    *) default-commands ;;\nesac\n```\nPattern matching construct. Each pattern is a glob pattern. `;;` terminates the clause. `;&` falls through to the next clause unconditionally. `;;&` tests the next pattern. `*` matches anything (default case). Patterns support `*`, `?`, `[...]`, and extended globs if `extglob` is set."
-        }
-      ]
-    },
-    "select": {
-      "contents": [
-        {
-          "value": "```bash\nselect name [in word ...]; do\n    command-list\ndone\n```\nCreate a numbered menu from `word` list. Displays items with numbers, prompts with `$PS3`, stores the chosen word in `name` and the user's raw input in `$REPLY`. Loops until `break` or EOF (Ctrl+D). If `in word ...` is omitted, uses positional parameters."
-        }
-      ]
-    },
-    "function": {
-      "contents": [
-        {
-          "value": "```bash\n# Two forms:\nname() { command-list; }\nfunction name [()] { command-list; }\n```\nDefine a function that can be called by name. Arguments are accessed as `$1`, `$2`, etc. `$@` for all arguments, `$#` for count. Use `local` for local variables. Use `return [n]` to exit with a status. Functions can be exported with `export -f name`."
-        }
-      ]
-    },
-    "shift": {
-      "contents": [
-        {
-          "value": "```bash\nshift [n]\n```\nShift positional parameters to the left by `n` positions (default 1). After `shift`, `$1` takes the value formerly in `$2`, `$2` takes `$3`, and so on. `$#` is decremented. Commonly used in argument-parsing loops."
-        }
-      ]
-    },
-    "eval": {
-      "contents": [
-        {
-          "value": "```bash\neval [arg ...]\n```\nConcatenate all arguments into a single command string and execute it in the current shell. Useful for executing dynamically constructed commands. **Use with caution** — eval can introduce code injection vulnerabilities if used with untrusted input."
-        }
-      ]
-    },
-    "exec": {
-      "contents": [
-        {
-          "value": "```bash\nexec [-cl] [-a name] [command [arguments ...]] [redirections ...]\n```\nReplace the current shell process with the specified command (no new process is created). If no command is given, redirections apply to the current shell. `-c` causes the command to execute with an empty environment. Commonly used for file descriptor manipulation: `exec 3>file`, `exec > >(tee log)`."
-        }
-      ]
-    },
-    "return": {
-      "contents": [
-        {
-          "value": "```bash\nreturn [n]\n```\nReturn from a shell function or sourced script with exit status `n`. If `n` is omitted, returns the exit status of the last command executed. Only valid inside a function or a sourced (`.`/`source`) script."
-        }
-      ]
-    },
-    "exit": {
-      "contents": [
-        {
-          "value": "```bash\nexit [n]\n```\nExit the shell with status `n`. If `n` is omitted, the status is that of the last command executed. Convention: 0 = success, 1 = general error, 2 = misuse of built-in, 126 = not executable, 127 = command not found, 128+N = killed by signal N."
-        }
-      ]
-    },
-    "readonly": {
-      "contents": [
-        {
-          "value": "```bash\nreadonly [-aAfp] [name[=value] ...]\n```\nMark variables or functions as read-only. Readonly variables cannot be reassigned or unset. `-a` for indexed arrays, `-A` for associative arrays, `-f` for functions. `-p` displays all readonly names."
-        }
-      ]
-    },
-    "getopts": {
-      "contents": [
-        {
-          "value": "```bash\ngetopts optstring name [args]\n```\nParse command-line options. Each call processes one option. `optstring` lists valid option letters; append `:` for options requiring arguments. On success, stores the option in `name`, the argument in `$OPTARG`, and advances `$OPTIND`. Returns non-zero when all options are processed."
-        }
-      ]
-    },
-    "wait": {
-      "contents": [
-        {
-          "value": "```bash\nwait [-fn] [-p varname] [id ...]\n```\nWait for background processes to finish. Without arguments, waits for all child processes. With a PID/job ID, waits for that specific process. `-n` waits for the next job to terminate and returns its exit status. `-p varname` stores the PID of the waited process (Bash 5.1+)."
-        }
-      ]
-    },
-    "shopt": {
-      "contents": [
-        {
-          "value": "```bash\nshopt [-pqsu] [-o] [optname ...]\n```\nSet or unset shell optional behavior. `-s` enables, `-u` disables. Common options:\n- `extglob` — extended pattern matching (`?(pat)`, `*(pat)`, `+(pat)`, `@(pat)`, `!(pat)`)\n- `globstar` — `**` matches directories recursively\n- `nullglob` — unmatched globs expand to nothing\n- `dotglob` — globs match dotfiles\n- `nocasematch` — case-insensitive matching in `case` and `[[`"
-        }
-      ]
-    },
-    "$?": {
-      "contents": [
-        {
-          "value": "```bash\n$?\n```\nThe exit status of the most recently executed foreground pipeline. `0` indicates success, non-zero indicates failure. After a pipeline, `$?` reflects the status of the last command (or rightmost failing command with `set -o pipefail`). Use `${PIPESTATUS[@]}` to access individual exit codes from each pipeline stage."
-        }
-      ]
-    },
-    "$#": {
-      "contents": [
-        {
-          "value": "```bash\n$#\n```\nThe number of positional parameters (command-line arguments). In a script, counts the arguments passed on invocation. Inside a function, counts the function's arguments. Does not include `$0`."
-        }
-      ]
-    },
-    "$@": {
-      "contents": [
-        {
-          "value": "```bash\n$@\n\"$@\"\n```\nAll positional parameters. When quoted (`\"$@\"`), each parameter is preserved as a separate word, correctly handling arguments with spaces. This is almost always the correct way to forward arguments. Equivalent to `\"$1\" \"$2\" ...`."
-        }
-      ]
-    },
-    "$*": {
-      "contents": [
-        {
-          "value": "```bash\n$*\n\"$*\"\n```\nAll positional parameters. When quoted (`\"$*\"`), expands to a single string with parameters joined by the first character of `$IFS` (default: space). Unquoted, behaves like `$@`. Rarely preferred over `\"$@\"`."
-        }
-      ]
-    },
-    "$$": {
-      "contents": [
-        {
-          "value": "```bash\n$$\n```\nThe process ID (PID) of the current shell. In a subshell `(...)`, `$$` still refers to the parent shell's PID. Use `$BASHPID` to get the actual PID of the current subshell (Bash 4.0+). Commonly used to create unique temporary filenames."
-        }
-      ]
-    },
-    "$!": {
-      "contents": [
-        {
-          "value": "```bash\n$!\n```\nThe PID of the most recently backgrounded process (started with `&`). Useful for tracking background jobs: `command & pid=$!; wait $pid`."
-        }
-      ]
-    },
-    "$0": {
-      "contents": [
-        {
-          "value": "```bash\n$0\n```\nThe name of the shell or the shell script being executed. In an interactive shell, typically `bash` or `-bash`. In a script, it is the path used to invoke the script. Use `${BASH_SOURCE[0]}` for the actual source file (works inside sourced scripts)."
-        }
-      ]
-    },
-    "IFS": {
-      "contents": [
-        {
-          "value": "```bash\nIFS=$' \\t\\n'  # default value\n```\nInternal Field Separator. Determines how the shell splits words after expansion and how `read` splits input. Default: space, tab, newline. Set `IFS=''` to disable splitting. Set `IFS=:` to split PATH-like variables. Often set locally in a subshell or function: `(IFS=,; echo \"${array[*]}\")`."
-        }
-      ]
-    },
-    "PATH": {
-      "contents": [
-        {
-          "value": "```bash\nPATH=/usr/local/bin:/usr/bin:/bin\n```\nColon-separated list of directories the shell searches (left to right) when locating commands. Prepend directories for priority: `PATH=\"/my/bin:$PATH\"`. Append for fallback: `PATH=\"$PATH:/my/bin\"`. Empty components (`::`or leading/trailing `:`) refer to the current directory."
-        }
-      ]
-    },
-    "HOME": {
-      "contents": [
-        {
-          "value": "```bash\nHOME=/home/username\n```\nThe home directory of the current user. Set at login from `/etc/passwd`. Used as the default directory for `cd` (no arguments), and for tilde expansion (`~` expands to `$HOME`, `~user` to that user's home)."
-        }
-      ]
-    },
-    "BASH_SOURCE": {
-      "contents": [
-        {
-          "value": "```bash\nBASH_SOURCE  # array variable\n```\nAn array whose members are the source filenames for each function in the call stack. `${BASH_SOURCE[0]}` is the file containing the currently executing code. Particularly useful for finding the script's own directory:\n```bash\nSCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n```"
-        }
-      ]
-    },
-    "PIPESTATUS": {
-      "contents": [
-        {
-          "value": "```bash\nPIPESTATUS  # array variable\n```\nAn array containing the exit statuses of the processes in the most recently executed foreground pipeline. `${PIPESTATUS[0]}` is the first command's status, `${PIPESTATUS[1]}` the second, etc. Useful for checking individual stages: `cmd1 | cmd2; echo \"${PIPESTATUS[@]}\"`."
-        }
-      ]
-    },
-    "RANDOM": {
-      "contents": [
-        {
-          "value": "```bash\nRANDOM\n```\nEach reference generates a random integer between 0 and 32767. Assigning a value seeds the generator for reproducible sequences. For a range 0 to N-1: `$((RANDOM % N))`. For better randomness in scripts, consider `/dev/urandom`."
-        }
-      ]
-    },
-    "SECONDS": {
-      "contents": [
-        {
-          "value": "```bash\nSECONDS\n```\nThe number of seconds since the shell was started. Assigning a value resets the counter:\n```bash\nSECONDS=0\n# ... operations ...\necho \"Elapsed: ${SECONDS}s\"\n```"
-        }
-      ]
-    },
-    "FUNCNAME": {
-      "contents": [
-        {
-          "value": "```bash\nFUNCNAME  # array variable\n```\nAn array of function names in the call stack. `${FUNCNAME[0]}` is the current function, `${FUNCNAME[1]}` is the caller, etc. The last element is `main` (for top-level code). Only meaningful inside functions."
-        }
-      ]
-    },
-    "BASH_REMATCH": {
-      "contents": [
-        {
-          "value": "```bash\nBASH_REMATCH  # array variable\n```\nPopulated by the `=~` operator in `[[ ]]`. Element 0 contains the entire match, elements 1+ contain capture group matches:\n```bash\nif [[ \"hello123\" =~ ^([a-z]+)([0-9]+)$ ]]; then\n    echo \"${BASH_REMATCH[0]}\"  # hello123\n    echo \"${BASH_REMATCH[1]}\"  # hello\n    echo \"${BASH_REMATCH[2]}\"  # 123\nfi\n```"
-        }
-      ]
-    },
-    "mapfile": {
-      "contents": [
-        {
-          "value": "```bash\nmapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]\n```\nRead lines from stdin into an indexed array. Default array is `MAPFILE`. `-t` strips trailing delimiters. `-n count` reads at most N lines. `-s count` skips the first N lines. Also available as `readarray`.\n```bash\nmapfile -t lines < file.txt\necho \"${lines[0]}\"\n```"
-        }
-      ]
-    },
-    "let": {
-      "contents": [
-        {
-          "value": "```bash\nlet expression [expression ...]\n```\nEvaluate arithmetic expressions. Each expression is an arithmetic expression using C-style operators: `+`, `-`, `*`, `/`, `%`, `**`, `++`, `--`, comparisons, bitwise and logical operators. Returns 0 if the last expression is non-zero, 1 otherwise. Equivalent to `(( expression ))`."
-        }
-      ]
-    },
-    "history": {
-      "contents": [
-        {
-          "value": "```bash\nhistory [-c] [-d offset] [n]\nhistory -anrw [filename]\n```\nDisplay or manipulate command history. `history n` shows the last N entries. `-c` clears the history list. `-d N` deletes entry N. `-a` appends new entries to the history file. `-r` reads the history file. `-w` writes the current history to the file. `HISTSIZE` controls the in-memory list size, `HISTFILESIZE` the file size."
-        }
-      ]
-    },
-    "unalias": {
-      "contents": [
-        {
-          "value": "```bash\nunalias [-a] name [name ...]\n```\nRemove alias definitions. Each `name` is removed from the list of aliases. The `-a` flag removes **all** aliases. Returns success unless a given name is not a defined alias."
-        }
-      ]
-    },
-    "type": {
-      "contents": [
-        {
-          "value": "```bash\ntype [-afptP] name [name ...]\n```\nIndicate how each `name` would be interpreted as a command. `-t` outputs a single word: `alias`, `keyword`, `function`, `builtin`, or `file`. `-a` displays all locations containing an executable named `name`. `-p` returns the disk file path (only for external commands). `-P` forces a PATH search even for builtins."
-        }
-      ]
-    },
-    "unset": {
-      "contents": [
-        {
-          "value": "```bash\nunset [-fv] [name ...]\n```\nRemove variable or function definitions. `-v` removes variables (default), `-f` removes functions. Readonly variables cannot be unset. Returns `0` unless a name is readonly. Unsetting `RANDOM`, `SECONDS`, etc. removes their special behavior."
-        }
-      ]
-    },
-    "[[": {
-      "contents": [
-        {
-          "value": "```bash\n[[ expression ]]\n```\nExtended conditional command. Unlike `[ ]`, supports `&&` and `||` operators, pattern matching with `==` (glob) and `=~` (regex), and no word splitting or pathname expansion inside. Returns `0` (true) or `1` (false). Use `BASH_REMATCH` array to access regex capture groups from `=~`."
-        }
-      ]
-    },
-    "jobs": {
-      "contents": [
-        {
-          "value": "```bash\njobs [-lnprs] [jobspec ...]\n```\nList active jobs. `-l` adds process IDs, `-p` lists PIDs only, `-r` restricts to running jobs, `-s` restricts to stopped jobs, `-n` lists only jobs whose status has changed since last notification. Job specs use `%n` (job number), `%string` (command prefix), `%%` or `%+` (current job), `%-` (previous job)."
-        }
-      ]
-    },
-    "kill": {
-      "contents": [
-        {
-          "value": "```bash\nkill [-s sigspec] [-n signum] [-sigspec] pid|jobspec ...\nkill -l|-L [sigspec]\n```\nSend signals to processes or jobs. Default signal is `TERM` (15). Common signals: `HUP` (1) — reload config, `INT` (2) — interrupt (Ctrl+C), `KILL` (9) — force kill (uncatchable), `STOP` (19) — pause, `CONT` (18) — resume. `-l` lists all signal names. Use `%jobspec` for background jobs."
-        }
-      ]
-    },
-    "bg": {
-      "contents": [
-        {
-          "value": "```bash\nbg [jobspec ...]\n```\nResume a suspended job in the background, as if it had been started with `&`. If no `jobspec` is given, the current job (`%%`) is used. The shell prints `[jobnumber] PID` when the job is resumed."
-        }
-      ]
-    },
-    "fg": {
-      "contents": [
-        {
-          "value": "```bash\nfg [jobspec]\n```\nMove a background or stopped job to the foreground, making it the current job. The shell waits for it to complete. If no `jobspec` is given, the current job (`%%`) is used. The resumed command's exit status becomes `$?`."
-        }
-      ]
-    },
-    "pushd": {
-      "contents": [
-        {
-          "value": "```bash\npushd [-n] [+n|-n|dir]\n```\nPush a directory onto the directory stack and `cd` to it. `-n` suppresses the directory change (only modifies the stack). `+n` rotates the stack so the nth directory (counting from the left) is at the top. `dirs` shows the stack. Used with `popd` for navigating multiple directories."
-        }
-      ]
-    },
-    "popd": {
-      "contents": [
-        {
-          "value": "```bash\npopd [-n] [+n|-n]\n```\nRemove the top entry from the directory stack and `cd` to the new top directory. `-n` suppresses the directory change (only modifies the stack). `+n`/`-n` removes the nth entry from the left/right of the stack. Use `dirs` to view the current stack."
-        }
-      ]
-    },
-    "complete": {
-      "contents": [
-        {
-          "value": "```bash\ncomplete [-abcdefgjksuv] [-o option] [-A action] [-G globpat] [-W wordlist] [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] name [name ...]\n```\nDefine programmable completion for command `name`. `-F function` calls a shell function to generate completions. `-W wordlist` provides a list of words. `-o filenames` enables filename-style processing. `-o nospace` suppresses trailing space. Use with `compgen` inside completion functions."
-        }
-      ]
-    },
-    "compgen": {
-      "contents": [
-        {
-          "value": "```bash\ncompgen [-abcdefgjksuv] [-o option] [-A action] [-G globpat] [-W wordlist] [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [word]\n```\nGenerate possible completions for `word`. Used within programmable completion functions (invoked by `complete -F`). `-W wordlist` generates from a word list. `-A action` generates from built-in categories (`file`, `directory`, `command`, `variable`, etc.). Output is one match per line."
-        }
-      ]
-    },
-    "enable": {
-      "contents": [
-        {
-          "value": "```bash\nenable [-a] [-dnps] [-f filename] [name ...]\n```\nEnable or disable shell builtin commands. `-n` disables the named builtins, causing the shell to use external commands instead. `-a` lists all builtins showing enabled/disabled state. `-f filename` loads a new builtin from a shared object file. Disabling builtins is useful for testing or replacing them with custom implementations."
-        }
-      ]
-    },
-    "ulimit": {
-      "contents": [
-        {
-          "value": "```bash\nulimit [-HSabcdefiklmnpqrstuvxPRT] [limit]\n```\nGet or set user-level resource limits. `-S` for soft limits, `-H` for hard limits. Common options: `-n` (max open files, default 1024), `-u` (max user processes), `-v` (virtual memory in KB), `-s` (stack size in KB), `-c` (core file size), `-f` (max file size). Use `unlimited` to remove a limit. Changes affect the current shell and its children."
-        }
-      ]
-    },
-    "umask": {
-      "contents": [
-        {
-          "value": "```bash\numask [-p] [-S] [mode]\n```\nSet the file creation permission mask. The mask is bits to **remove** from default permissions (777 for directories, 666 for files). Common values: `022` (owner full, group/others read+execute), `077` (owner only), `002` (group writable). `-S` displays in symbolic form (`u=rwx,g=rx,o=rx`). `-p` outputs in a form reusable as input."
-        }
-      ]
-    },
-    "$_": {
-      "contents": [
-        {
-          "value": "```bash\n$_\n```\nThe last argument of the previous command. At shell startup, set to the absolute pathname of the shell or script being executed. After a command runs, set to the last argument of that command. In interactive shells, pressing `Esc .` or `Alt+.` inserts the equivalent value."
-        }
-      ]
-    },
-    "$-": {
-      "contents": [
-        {
-          "value": "```bash\n$-\n```\nThe current set of active shell option flags. Each letter represents an enabled option (e.g., `h` for hashall, `i` for interactive, `m` for monitor, `B` for brace expansion, `H` for history expansion). Equivalent to the flags that `set` is currently using. Example: `himBH` for a typical interactive shell."
-        }
-      ]
-    },
-    "PWD": {
-      "contents": [
-        {
-          "value": "```bash\nPWD\n```\nThe absolute pathname of the current working directory. Automatically updated by `cd`. May contain symlinks unless `cd -P` was used. Equivalent to the output of `pwd -L` (logical path). Set by the shell at startup and after each directory change."
-        }
-      ]
-    },
-    "OLDPWD": {
-      "contents": [
-        {
-          "value": "```bash\nOLDPWD\n```\nThe previous working directory, set by `cd`. `cd -` changes to `$OLDPWD` and prints the new directory. Unset if `cd` has not been called since the shell started. Useful for toggling between two directories."
-        }
-      ]
-    },
-    "SHELL": {
-      "contents": [
-        {
-          "value": "```bash\nSHELL=/bin/bash\n```\nThe full pathname of the user's login shell, as defined in `/etc/passwd`. This variable is **not** changed when a different shell is invoked — it always reflects the login shell. Programs like terminal emulators use it to determine which shell to start."
-        }
-      ]
-    },
-    "USER": {
-      "contents": [
-        {
-          "value": "```bash\nUSER\n```\nThe name of the current user. Set at login. Unlike `$EUID` (numeric), `$USER` is the textual username. Equivalent to `$(whoami)` in most cases. Note: this can be overwritten since it's not readonly — use `id -un` for a reliable alternative."
-        }
-      ]
-    },
-    "HOSTNAME": {
-      "contents": [
-        {
-          "value": "```bash\nHOSTNAME\n```\nThe name of the current host, automatically set at shell startup. Equivalent to the output of the `hostname` command. Used in the default prompt (`$PS1`) with `\\h` (short hostname) or `\\H` (FQDN)."
-        }
-      ]
-    },
-    "LINENO": {
-      "contents": [
-        {
-          "value": "```bash\nLINENO\n```\nThe current line number in the script or function being executed (1-based). Dynamically updated as each line is processed. Useful for debugging and error messages:\n```bash\necho \"Error at line $LINENO\" >&2\n```\nInside a function, `LINENO` reflects the line within the function, not the script."
-        }
-      ]
-    },
-    "BASH_LINENO": {
-      "contents": [
-        {
-          "value": "```bash\nBASH_LINENO  # array variable\n```\nAn array of line numbers corresponding to the call stack. `${BASH_LINENO[0]}` is the line number in the calling script where the current function was invoked. Used with `FUNCNAME` and `BASH_SOURCE` to construct stack traces:\n```bash\necho \"Called from ${BASH_SOURCE[1]}:${BASH_LINENO[0]}\"\n```"
-        }
-      ]
-    },
-    "OPTARG": {
-      "contents": [
-        {
-          "value": "```bash\nOPTARG\n```\nSet by the `getopts` builtin. Contains the argument value when processing an option that requires one (indicated by `:` after the option letter in the optstring). When an invalid option is encountered, `OPTARG` holds the invalid option character if optstring starts with `:`."
-        }
-      ]
-    },
-    "OPTIND": {
-      "contents": [
-        {
-          "value": "```bash\nOPTIND\n```\nThe index of the next argument to be processed by `getopts`. Initialized to `1` each time the shell starts or a script is invoked. After `getopts` finishes, `shift $((OPTIND - 1))` removes all processed options, leaving only non-option arguments in `$@`."
-        }
-      ]
-    },
-    "REPLY": {
-      "contents": [
-        {
-          "value": "```bash\nREPLY\n```\nDefault variable for `read` when no variable name is supplied: `read` stores the entire input line in `$REPLY`. Also set by the `select` construct to the user's raw input string (the number they typed). Always a string value."
-        }
-      ]
-    },
-    "BASH_VERSION": {
-      "contents": [
-        {
-          "value": "```bash\nBASH_VERSION\n```\nA string describing the version of this Bash instance (e.g., `5.2.15(1)-release`). For structured version info, use `BASH_VERSINFO` array: `[0]`=major, `[1]`=minor, `[2]`=patch, `[3]`=build, `[4]`=status, `[5]`=machine type. Useful for feature detection:\n```bash\nif ((BASH_VERSINFO[0] >= 4)); then echo \"Bash 4+\"; fi\n```"
-        }
-      ]
-    },
-    "EUID": {
-      "contents": [
-        {
-          "value": "```bash\nEUID\n```\nThe effective user ID of the current user (read-only). `0` indicates root/superuser. May differ from `$UID` when running with `sudo` or setuid programs. Common use:\n```bash\nif [[ $EUID -ne 0 ]]; then echo \"Run as root\"; exit 1; fi\n```"
-        }
-      ]
-    },
-    "UID": {
-      "contents": [
-        {
-          "value": "```bash\nUID\n```\nThe real user ID of the current user (read-only). Unlike `$EUID`, `$UID` reflects the original user even under `sudo`. Both values are integers. Use `id -u` for a portable equivalent."
-        }
-      ]
-    },
-    "array": {
-      "contents": [
-        {
-          "value": "```bash\nname=(value1 value2 ...)\nname[index]=value\n```\nIndexed arrays hold ordered lists of values, accessed by integer index starting at `0`. Key operations: `${arr[@]}` (all elements), `${#arr[@]}` (length), `${!arr[@]}` (all indices), `arr+=(val)` (append), `${arr[@]:offset:length}` (slice), `unset 'arr[i]'` (remove element). Arrays can be sparse — indices don't need to be contiguous."
-        }
-      ]
-    },
-    "associative_array": {
-      "contents": [
-        {
-          "value": "```bash\ndeclare -A name=([key1]=value1 [key2]=value2)\n```\nAssociative arrays use arbitrary strings as keys. **Must** be declared with `declare -A` before use. Key operations: `${map[key]}` (get), `map[key]=value` (set), `${!map[@]}` (all keys), `${#map[@]}` (size), `unset 'map[key]'` (delete). Available since Bash 4.0. Cannot be exported to child processes."
-        }
-      ]
-    },
-    "string_operations": {
-      "contents": [
-        {
-          "value": "```bash\n${parameter...}\n```\nBash parameter expansion provides extensive string manipulation:\n- `${#var}` — length\n- `${var:offset:length}` — substring\n- `${var:-default}` — default value\n- `${var:=default}` — assign default\n- `${var:+alternate}` — alternate value\n- `${var:?error}` — error if unset\n- `${var#pattern}` / `${var##pattern}` — remove prefix (shortest/longest)\n- `${var%pattern}` / `${var%%pattern}` — remove suffix\n- `${var/pat/rep}` / `${var//pat/rep}` — replace first/all\n- `${var^}` / `${var^^}` — uppercase first/all\n- `${var,}` / `${var,,}` — lowercase first/all"
-        }
-      ]
-    },
-    "arithmetic": {
-      "contents": [
-        {
-          "value": "```bash\n$(( expression ))\n(( expression ))\nlet expression\n```\nBash integer arithmetic supports C-style operators: `+`, `-`, `*`, `/`, `%`, `**` (power), `++`, `--`, bitwise (`&`, `|`, `^`, `~`, `<<`, `>>`), logical (`&&`, `||`, `!`), ternary (`?:`), comma, and all compound assignments (`+=`, `-=`, etc.). Variables are referenced by name without `$`. Use `$(( ))` for substitution, `(( ))` for conditions/side-effects."
-        }
-      ]
-    }
-  }
-}