oh-my-devpod 0.14.2

package/runtime/vendor/zsh/ohmyzsh/plugins/dircycle/README.md

@@ -0,0 +1,82 @@
+# dircycle
+
+Plugin for cycling through the directory stack
+
+This plugin enables directory navigation similar to using back and forward on browsers or common file explorers like Finder or Nautilus. It uses a small zle trick that lets you cycle through your directory stack left or right using <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Left</kbd> / <kbd>Right</kbd> . This is useful when moving back and forth between directories in development environments, and can be thought of as kind of a nondestructive pushd/popd.
+
+## Enabling the plugin
+
+1. Open your `.zshrc` file and add `dircycle` in the plugins section:
+
+   ```zsh
+   plugins=(
+       # all your enabled plugins
+       dircycle
+   )
+   ```
+
+2. Restart the shell or restart your Terminal session:
+
+   ```console
+   $ exec zsh
+   $
+   ```
+
+## Usage Examples
+
+Say you opened these directories on the terminal:
+
+```console
+~$ cd Projects
+~/Projects$ cd Hacktoberfest
+~/Projects/Hacktoberfest$ cd oh-my-zsh
+~/Projects/Hacktoberfest/oh-my-zsh$ dirs -v
+0       ~/Projects/Hacktoberfest/oh-my-zsh
+1       ~/Projects/Hacktoberfest
+2       ~/Projects
+3       ~
+```
+
+By pressing <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Left</kbd>, the current working directory or `$PWD` will be from `oh-my-zsh` to `Hacktoberfest`. Press it again and it will be at `Projects`.
+
+And by pressing <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Right</kbd>, the `$PWD` will be from `Projects` to `Hacktoberfest`. Press it again and it will be at `oh-my-zsh`.
+
+Here's a example history table with the same accessed directories like above:
+
+| Current `$PWD`  | Key press                                             | New `$PWD`      |
+| --------------- | ----------------------------------------------------- | --------------- |
+| `oh-my-zsh`     | <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Left</kbd>  | `Hacktoberfest` |
+| `Hacktoberfest` | <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Left</kbd>  | `Projects`      |
+| `Projects`      | <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Left</kbd>  | `~`             |
+| `~`             | <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Right</kbd> | `Projects`      |
+| `Projects`      | <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Right</kbd> | `Hacktoberfest` |
+| `Hacktoberfest` | <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Right</kbd> | `oh-my-zsh`     |
+| `oh-my-zsh`     | <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Right</kbd> | `~`             |
+
+Note the last traversal, when pressing <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Right</kbd> on a last known `$PWD`, it will change back to the first known `$PWD`, which in the example is `~`.
+
+Here's an asciinema cast demonstrating the example above:
+
+[![asciicast](https://asciinema.org/a/204406.png)](https://asciinema.org/a/204406)
+
+## Functions
+
+| Function             | Description                                                                                                         |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| `insert-cycledleft`  | Change `$PWD` to the previous known stack, bound to <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Left</kbd>            |
+| `insert-cycledright` | Change `$PWD` to the next known stack, bound to <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Right</kbd>               |
+| `insert-cycledup`    | Change `$PWD` to the parent folder, bound to <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Up</kbd>                     |
+| `insert-cycleddown`  | Change `$PWD` to the first alphabetical child folder, bound to <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Down</kbd> |
+
+## Rebinding keys
+
+You can bind these functions to other key sequences, as long as you know the bindkey sequence. For example, these commands bind to <kbd>Alt</kbd> + <kbd>Shift</kbd> + <kbd>key</kbd> in `xterm-256color`:
+
+```zsh
+bindkey '^[[1;4D' insert-cycledleft
+bindkey '^[[1;4C' insert-cycledright
+bindkey "\e[1;4A" insert-cycledup
+bindkey "\e[1;4B" insert-cycleddown
+```
+
+You can get the bindkey sequence by pressing <kbd>Ctrl</kbd> + <kbd>V</kbd>, then pressing the keyboard shortcut you want to use.

package/runtime/vendor/zsh/ohmyzsh/plugins/dircycle/dircycle.plugin.zsh

@@ -0,0 +1,87 @@
+# enables cycling through the directory stack using
+# Ctrl+Shift+Left/Right
+#
+# left/right direction follows the order in which directories
+# were visited, like left/right arrows do in a browser
+
+# NO_PUSHD_MINUS syntax:
+#  pushd +N: start counting from left of `dirs' output
+#  pushd -N: start counting from right of `dirs' output
+
+# Either switch to a directory from dirstack, using +N or -N syntax
+# or switch to a directory by path, using `switch-to-dir -- <path>`
+switch-to-dir () {
+	# If $1 is --, then treat $2 as a directory path
+	if [[ $1 == -- ]]; then
+		# We use `-q` because we don't want chpwd to run, we'll do it manually
+		[[ -d "$2" ]] && builtin pushd -q "$2" &>/dev/null
+		return $?
+	fi
+
+	setopt localoptions nopushdminus
+	[[ ${#dirstack} -eq 0 ]] && return 1
+
+	while ! builtin pushd -q $1 &>/dev/null; do
+		# We found a missing directory: pop it out of the dir stack
+		builtin popd -q $1
+
+		# Stop trying if there are no more directories in the dir stack
+		[[ ${#dirstack} -eq 0 ]] && return 1
+	done
+}
+
+insert-cycledleft () {
+	switch-to-dir +1 || return $?
+
+	local fn
+	for fn in chpwd $chpwd_functions precmd $precmd_functions; do
+		(( $+functions[$fn] )) && $fn
+	done
+	zle reset-prompt
+}
+zle -N insert-cycledleft
+
+insert-cycledright () {
+	switch-to-dir -0 || return $?
+
+	local fn
+	for fn in chpwd $chpwd_functions precmd $precmd_functions; do
+		(( $+functions[$fn] )) && $fn
+	done
+	zle reset-prompt
+}
+zle -N insert-cycledright
+
+insert-cycledup () {
+	switch-to-dir -- .. || return $?
+
+	local fn
+	for fn in chpwd $chpwd_functions precmd $precmd_functions; do
+		(( $+functions[$fn] )) && $fn
+	done
+	zle reset-prompt
+}
+zle -N insert-cycledup
+
+insert-cycleddown () {
+	switch-to-dir -- "$(find . -mindepth 1 -maxdepth 1 -type d | sort -n | head -n 1)" || return $?
+
+	local fn
+	for fn in chpwd $chpwd_functions precmd $precmd_functions; do
+		(( $+functions[$fn] )) && $fn
+	done
+	zle reset-prompt
+}
+zle -N insert-cycleddown
+
+# These sequences work for xterm, Apple Terminal.app, and probably others.
+# Not for rxvt-unicode, but it doesn't seem differentiate Ctrl-Shift-Arrow
+# from plain Shift-Arrow, at least by default.
+#
+# iTerm2 does not have these key combinations defined by default; you will need
+# to add them under "Keys" in your profile if you want to use this. You can do
+# this conveniently by loading the "xterm with Numeric Keypad" preset.
+bindkey "\e[1;6D" insert-cycledleft     # Ctrl+Shift+Left
+bindkey "\e[1;6C" insert-cycledright    # Ctrl+Shift+Right
+bindkey "\e[1;6A" insert-cycledup       # Ctrl+Shift+Up
+bindkey "\e[1;6B" insert-cycleddown     # Ctrl+Shift+Down

package/runtime/vendor/zsh/ohmyzsh/plugins/direnv/README.md

@@ -0,0 +1,15 @@
+# direnv plugin
+
+This plugin creates the [Direnv](https://direnv.net/) hook.
+
+To use it, add `direnv` to the plugins array in your zshrc file:
+
+```zsh
+plugins=(... direnv)
+```
+
+## Requirements
+
+In order to make this work, you will need to have the direnv installed.
+
+More info on the usage and install: https://github.com/direnv/direnv

package/runtime/vendor/zsh/ohmyzsh/plugins/direnv/direnv.plugin.zsh

@@ -0,0 +1,19 @@
+# If direnv is not found, don't continue and print a warning
+if (( ! $+commands[direnv] )); then
+  echo "Warning: direnv not found. Please install direnv and ensure it's in your PATH before using this plugin."
+  return
+fi
+
+_direnv_hook() {
+  trap -- '' SIGINT;
+  eval "$(direnv export zsh)";
+  trap - SIGINT;
+}
+typeset -ag precmd_functions;
+if [[ -z "${precmd_functions[(r)_direnv_hook]+1}" ]]; then
+  precmd_functions=( _direnv_hook ${precmd_functions[@]} )
+fi
+typeset -ag chpwd_functions;
+if [[ -z "${chpwd_functions[(r)_direnv_hook]+1}" ]]; then
+  chpwd_functions=( _direnv_hook ${chpwd_functions[@]} )
+fi

package/runtime/vendor/zsh/ohmyzsh/plugins/dirhistory/README.md

@@ -0,0 +1,105 @@
+# Dirhistory plugin
+
+This plugin adds keyboard shortcuts for navigating directory history and hierarchy.
+
+To use it, add `dirhistory` to the plugins array in your zshrc file:
+
+```zsh
+plugins=(... dirhistory)
+```
+
+## Keyboard Shortcuts
+
+| Shortcut                          | Description                                               |
+|-----------------------------------|-----------------------------------------------------------|
+| <kbd>Alt</kbd> + <kbd>Left</kbd>  | Go to previous directory                                  |
+| <kbd>Alt</kbd> + <kbd>Right</kbd> | Go to next directory                                      |
+| <kbd>Alt</kbd> + <kbd>Up</kbd>    | Move into the parent directory                            |
+| <kbd>Alt</kbd> + <kbd>Down</kbd>  | Move into the first child directory by alphabetical order |
+
+**For macOS: use the Option key (<kbd>⌥</kbd>) instead of <kbd>Alt</kbd>**.
+
+> NOTE: some terminals might override the <kbd>Alt</kbd> + Arrows key bindings (e.g. Windows Terminal).
+> If these don't work check your terminal settings and change them to a different keyboard shortcut.
+
+## Usage
+
+This plugin allows you to navigate the history of previous working directories using <kbd>Alt</kbd> + <kbd>Left</kbd>
+and <kbd>Alt</kbd> + <kbd>Right</kbd>. <kbd>Alt</kbd> + <kbd>Left</kbd> moves to past directories, and
+<kbd>Alt</kbd> + <kbd>Right</kbd> goes back to recent directories.
+
+**NOTE: the maximum directory history size is 30.**
+
+You can also navigate **directory hierarchies** using <kbd>Alt</kbd> + <kbd>Up</kbd> and <kbd>Alt</kbd> + <kbd>Down</kbd>.
+<kbd>Alt</kbd> + <kbd>Up</kbd> moves to the parent directory, while <kbd>Alt</kbd> + <kbd>Down</kbd> moves into the first
+child directory found in alphabetical order (useful to navigate long empty directories, e.g. Java packages).
+
+For example, if the shell was started, and the following commands were entered:
+
+```shell
+cd ~
+cd /usr
+cd share
+cd doc
+```
+
+the directory stack (`dirs -v`) would look like this:
+
+```console
+$ dirs -v
+0       /usr/share/doc
+1       /usr/share
+2       /usr
+3       ~
+```
+
+then entering <kbd>Alt</kbd> + <kbd>Left</kbd> at the prompt would change directory from `/usr/share/doc` to `/usr/share`,
+then if pressed again to `/usr`, then `~`. If <kbd>Alt</kbd> + <kbd>Right</kbd> were pressed the directory would be changed
+to `/usr` again.
+
+After that, <kbd>Alt</kbd> + <kbd>Down</kbd> will probably go to `/usr/bin` if `bin` is the first directory in alphabetical
+order (depends on your `/usr` folder structure). <kbd>Alt</kbd> + <kbd>Up</kbd> will return to `/usr`, and once more will get
+you to the root folder (`/`).
+
+### cde
+
+This plugin also provides a `cde` alias that allows you to change to a directory without clearing the next directory stack.
+This changes the default behavior of `dirhistory`, which is to clear the next directory stack when changing directories.
+
+For example, if the shell was started, and the following commands were entered:
+
+```shell
+cd ~
+cd /usr
+cd share
+cd doc
+
+# <Alt + Left>
+# <Alt + Left>
+```
+
+The directory stack would look like this:
+
+```sh
+➜  /usr typeset -pm dirhistory_\*
+typeset -ax dirhistory_past=( /home/user /usr )
+typeset -ax dirhistory_future=( /usr/share/doc /usr/share )
+```
+
+This means that pressing <kbd>Alt</kbd> + <kbd>Right</kbd>, you'd go to `/usr/share` and `/usr/share/doc` (the "future" directories).
+
+If you run `cd /usr/bin`, the "future" directories will be removed, and you won't be able to access them with <kbd>Alt</kbd> + <kbd>Right</kbd>:
+
+```sh
+➜  /u/bin typeset -pm dirhistory_\*
+typeset -ax dirhistory_past=( /home/user /usr )
+typeset -ax dirhistory_future=( /usr/bin )
+```
+
+If you instead run `cde /usr/bin`, the "future" directories will be preserved:
+
+```sh
+➜  /u/bin typeset -pm dirhistory_\*
+typeset -ax dirhistory_past=( /home/user /usr /usr/bin )
+typeset -ax dirhistory_future=( /usr/share/doc /usr/share )
+```

package/runtime/vendor/zsh/ohmyzsh/plugins/dirhistory/dirhistory.plugin.zsh

@@ -0,0 +1,236 @@
+##
+#   Navigate directory history using ALT-LEFT and ALT-RIGHT. ALT-LEFT moves back to directories
+#   that the user has changed to in the past, and ALT-RIGHT undoes ALT-LEFT.
+#
+#   Navigate directory hierarchy using ALT-UP and ALT-DOWN.
+#   ALT-UP moves to higher hierarchy (cd ..)
+#   ALT-DOWN moves into the first directory found in alphabetical order
+#
+
+dirhistory_past=($PWD)
+dirhistory_future=()
+export dirhistory_past
+export dirhistory_future
+export DIRHISTORY_SIZE=30
+
+alias cde='dirhistory_cd'
+
+# Pop the last element of dirhistory_past.
+# Pass the name of the variable to return the result in.
+# Returns the element if the array was not empty,
+# otherwise returns empty string.
+function pop_past() {
+  setopt localoptions no_ksh_arrays
+  if [[ $#dirhistory_past -gt 0 ]]; then
+    typeset -g $1="${dirhistory_past[$#dirhistory_past]}"
+    dirhistory_past[$#dirhistory_past]=()
+  fi
+}
+
+function pop_future() {
+  setopt localoptions no_ksh_arrays
+  if [[ $#dirhistory_future -gt 0 ]]; then
+    typeset -g $1="${dirhistory_future[$#dirhistory_future]}"
+    dirhistory_future[$#dirhistory_future]=()
+  fi
+}
+
+# Push a new element onto the end of dirhistory_past. If the size of the array
+# is >= DIRHISTORY_SIZE, the array is shifted
+function push_past() {
+  setopt localoptions no_ksh_arrays
+  if [[ $#dirhistory_past -ge $DIRHISTORY_SIZE ]]; then
+    shift dirhistory_past
+  fi
+  if [[ $#dirhistory_past -eq 0 || $dirhistory_past[$#dirhistory_past] != "$1" ]]; then
+    dirhistory_past+=($1)
+  fi
+}
+
+function push_future() {
+  setopt localoptions no_ksh_arrays
+  if [[ $#dirhistory_future -ge $DIRHISTORY_SIZE ]]; then
+    shift dirhistory_future
+  fi
+  if [[ $#dirhistory_future -eq 0 || $dirhistory_futuret[$#dirhistory_future] != "$1" ]]; then
+    dirhistory_future+=($1)
+  fi
+}
+
+# Called by zsh when directory changes
+autoload -U add-zsh-hook
+add-zsh-hook chpwd chpwd_dirhistory
+function chpwd_dirhistory() {
+  push_past $PWD
+  # If DIRHISTORY_CD is not set...
+  if [[ -z "${DIRHISTORY_CD+x}" ]]; then
+    # ... clear future.
+    dirhistory_future=()
+  fi
+}
+
+function dirhistory_cd(){
+  DIRHISTORY_CD="1"
+  cd $1
+  unset DIRHISTORY_CD
+}
+
+# Move backward in directory history
+function dirhistory_back() {
+  local cw=""
+  local d=""
+  # Last element in dirhistory_past is the cwd.
+
+  pop_past cw
+  if [[ "" == "$cw" ]]; then
+    # Someone overwrote our variable. Recover it.
+    dirhistory_past=($PWD)
+    return
+  fi
+
+  pop_past d
+  if [[ "" != "$d" ]]; then
+    dirhistory_cd $d
+    push_future $cw
+  else
+    push_past $cw
+  fi
+}
+
+
+# Move forward in directory history
+function dirhistory_forward() {
+  local d=""
+
+  pop_future d
+  if [[ "" != "$d" ]]; then
+    dirhistory_cd $d
+    push_past $d
+  fi
+}
+
+
+# Bind keys to history navigation
+function dirhistory_zle_dirhistory_back() {
+  # Erase current line in buffer
+  zle .kill-buffer
+  dirhistory_back
+  zle .accept-line
+}
+
+function dirhistory_zle_dirhistory_future() {
+  # Erase current line in buffer
+  zle .kill-buffer
+  dirhistory_forward
+  zle .accept-line
+}
+
+zle -N dirhistory_zle_dirhistory_back
+zle -N dirhistory_zle_dirhistory_future
+
+for keymap in emacs vicmd viins; do
+  # dirhistory_back
+  bindkey -M $keymap "\e[3D" dirhistory_zle_dirhistory_back    # xterm in normal mode
+  bindkey -M $keymap "\e[1;3D" dirhistory_zle_dirhistory_back  # xterm in normal mode
+  bindkey -M $keymap "\e\e[D" dirhistory_zle_dirhistory_back   # Putty
+  bindkey -M $keymap "\eO3D" dirhistory_zle_dirhistory_back    # GNU screen
+
+  case "$TERM_PROGRAM" in
+  Apple_Terminal) bindkey -M $keymap "^[b" dirhistory_zle_dirhistory_back ;; # Terminal.app
+  ghostty) bindkey -M $keymap "^[b" dirhistory_zle_dirhistory_back ;;        # ghostty
+  iTerm.app)
+    bindkey -M $keymap "^[^[[D" dirhistory_zle_dirhistory_back
+    bindkey -M $keymap "^[b" dirhistory_zle_dirhistory_back
+    ;;
+  esac
+
+  if (( ${+terminfo[kcub1]} )); then
+    bindkey -M $keymap "^[${terminfo[kcub1]}" dirhistory_zle_dirhistory_back  # urxvt
+  fi
+
+  # dirhistory_future
+  bindkey -M $keymap "\e[3C" dirhistory_zle_dirhistory_future    # xterm in normal mode
+  bindkey -M $keymap "\e[1;3C" dirhistory_zle_dirhistory_future  # xterm in normal mode
+  bindkey -M $keymap "\e\e[C" dirhistory_zle_dirhistory_future   # Putty
+  bindkey -M $keymap "\eO3C" dirhistory_zle_dirhistory_future    # GNU screen
+
+  case "$TERM_PROGRAM" in
+  Apple_Terminal) bindkey -M $keymap "^[f" dirhistory_zle_dirhistory_future ;; # Terminal.app
+  ghostty) bindkey -M $keymap "^[f" dirhistory_zle_dirhistory_future ;;        # ghostty
+  iTerm.app)
+    bindkey -M $keymap "^[^[[C" dirhistory_zle_dirhistory_future
+    bindkey -M $keymap "^[f" dirhistory_zle_dirhistory_future
+    ;;
+  esac
+
+  if (( ${+terminfo[kcuf1]} )); then
+    bindkey -M $keymap "^[${terminfo[kcuf1]}" dirhistory_zle_dirhistory_future # urxvt
+  fi
+done
+
+#
+# HIERARCHY Implemented in this section, in case someone wants to split it to another plugin if it clashes bindings
+#
+
+# Move up in hierarchy
+function dirhistory_up() {
+  cd .. || return 1
+}
+
+# Move down in hierarchy
+function dirhistory_down() {
+  cd "$(find . -mindepth 1 -maxdepth 1 -type d | sort -n | head -n 1)" || return 1
+}
+
+
+# Bind keys to hierarchy navigation
+function dirhistory_zle_dirhistory_up() {
+  zle .kill-buffer   # Erase current line in buffer
+  dirhistory_up
+  zle .accept-line
+}
+
+function dirhistory_zle_dirhistory_down() {
+  zle .kill-buffer   # Erase current line in buffer
+  dirhistory_down
+  zle .accept-line
+}
+
+zle -N dirhistory_zle_dirhistory_up
+zle -N dirhistory_zle_dirhistory_down
+
+for keymap in emacs vicmd viins; do
+  # dirhistory_up
+  bindkey -M $keymap "\e[3A" dirhistory_zle_dirhistory_up    # xterm in normal mode
+  bindkey -M $keymap "\e[1;3A" dirhistory_zle_dirhistory_up  # xterm in normal mode
+  bindkey -M $keymap "\e\e[A" dirhistory_zle_dirhistory_up   # Putty
+  bindkey -M $keymap "\eO3A" dirhistory_zle_dirhistory_up    # GNU screen
+
+  case "$TERM_PROGRAM" in
+  Apple_Terminal) bindkey -M $keymap "^[[A" dirhistory_zle_dirhistory_up ;;  # Terminal.app
+  iTerm.app) bindkey -M $keymap "^[^[[A" dirhistory_zle_dirhistory_up ;;     # iTerm2
+  ghostty) bindkey -M $keymap "^[[1;3A" dirhistory_zle_dirhistory_up ;;      # ghostty
+  esac
+
+  if (( ${+terminfo[kcuu1]} )); then
+    bindkey -M $keymap "^[${terminfo[kcuu1]}" dirhistory_zle_dirhistory_up # urxvt
+  fi
+
+  # dirhistory_down
+  bindkey -M $keymap "\e[3B" dirhistory_zle_dirhistory_down    # xterm in normal mode
+  bindkey -M $keymap "\e[1;3B" dirhistory_zle_dirhistory_down  # xterm in normal mode
+  bindkey -M $keymap "\e\e[B" dirhistory_zle_dirhistory_down   # Putty
+  bindkey -M $keymap "\eO3B" dirhistory_zle_dirhistory_down    # GNU screen
+
+  case "$TERM_PROGRAM" in
+  Apple_Terminal) bindkey -M $keymap "^[[B" dirhistory_zle_dirhistory_down ;;  # Terminal.app
+  iTerm.app) bindkey -M $keymap "^[^[[B" dirhistory_zle_dirhistory_down ;;     # iTerm2
+  ghostty) bindkey -M $keymap "^[[1;3B" dirhistory_zle_dirhistory_down ;;      # ghostty
+  esac
+
+  if (( ${+terminfo[kcud1]} )); then
+    bindkey -M $keymap "^[${terminfo[kcud1]}" dirhistory_zle_dirhistory_down # urxvt
+  fi
+done
+
+unset keymap

package/runtime/vendor/zsh/ohmyzsh/plugins/dirpersist/README.md

@@ -0,0 +1,10 @@
+# Dirpersist plugin
+
+This plugin keeps a running tally of the previous 20 unique directories in the `$HOME/.zdirs` file.
+When you cd to a new directory, it is prepended to the beginning of the file.
+
+To use it, add `dirpersist` to the plugins array in your zshrc file:
+
+```zsh
+plugins=(... dirpersist)
+```

package/runtime/vendor/zsh/ohmyzsh/plugins/dirpersist/dirpersist.plugin.zsh

@@ -0,0 +1,21 @@
+# Save dirstack history to .zdirs
+# adapted from:
+# github.com/grml/grml-etc-core/blob/master/etc/zsh/zshrc#L1547
+
+DIRSTACKSIZE=${DIRSTACKSIZE:-20}
+dirstack_file=${dirstack_file:-${HOME}/.zdirs}
+
+if [[ -f ${dirstack_file} ]] && [[ ${#dirstack[*]} -eq 0 ]] ; then
+  dirstack=( ${(f)"$(< $dirstack_file)"} )
+  # "cd -" won't work after login by just setting $OLDPWD, so
+  [[ -d $dirstack[1] ]] && cd $dirstack[1] && cd $OLDPWD
+fi
+
+autoload -U add-zsh-hook
+add-zsh-hook chpwd chpwd_dirpersist
+chpwd_dirpersist() {
+  if (( $DIRSTACKSIZE <= 0 )) || [[ -z $dirstack_file ]]; then return; fi
+  local -ax my_stack
+  my_stack=( ${PWD} ${dirstack} )
+  builtin print -l ${(u)my_stack} >! ${dirstack_file}
+}

package/runtime/vendor/zsh/ohmyzsh/plugins/dnf/README.md

@@ -0,0 +1,32 @@
+# dnf plugin
+
+This plugin makes `dnf` usage easier by adding aliases for the most common commands.
+
+`dnf` is the new package manager for RPM-based distributions, which replaces `yum`.
+
+To use it, add `dnf` to the plugins array in your zshrc file:
+
+```zsh
+plugins=(... dnf)
+```
+
+Classic `dnf` is getting superseded by `dnf5`; this plugin detects the presence
+of `dnf5` and uses it as drop-in alternative to the slower `dnf`.
+
+## Aliases
+
+| Alias | Command                 | Description              |
+|-------|-------------------------|--------------------------|
+| dnfl  | `dnf list`              | List packages            |
+| dnfli | `dnf list installed`    | List installed packages  |
+| dnfgl | `dnf grouplist`         | List package groups      |
+| dnfmc | `dnf makecache`         | Generate metadata cache  |
+| dnfp  | `dnf info`              | Show package information |
+| dnfs  | `dnf search`            | Search package           |
+| **Use `sudo`**                                             |
+| dnfu  | `sudo dnf upgrade`      | Upgrade package          |
+| dnfi  | `sudo dnf install`      | Install package          |
+| dnfgi | `sudo dnf groupinstall` | Install package group    |
+| dnfr  | `sudo dnf remove`       | Remove package           |
+| dnfgr | `sudo dnf groupremove`  | Remove package group     |
+| dnfc  | `sudo dnf clean all`    | Clean cache              |