fix ignore noglob setting

.gitignore

@@ -3,3 +3,5 @@ aliases/private_functions
 modules/vcs/filter
 *.zwc
 .zcompdump
+env/*_local_*
+local.zsh

.zimrc

@@ -1,3 +1,5 @@
+zmodule zsh-users/zsh-completions
+
 zmodule jreese/zsh-titles -n titles
 
 zmodule SmartFinn/fzf-widgets
@@ -8,11 +10,18 @@ zmodule $ZDOTDIR/plugins/tmpsrc
 zmodule $ZDOTDIR/plugins/pyenv
 zmodule $ZDOTDIR/plugins/cs-java-home
 zmodule $ZDOTDIR/plugins/atuin
+zmodule $ZDOTDIR/plugins/nvm
+zmodule $ZDOTDIR/plugins/cdup
 
 zmodule $ZDOTDIR/plugins/highlight-config
 zmodule zsh-users/zsh-syntax-highlighting
 
 zmodule ohmyzsh/ohmyzsh --root plugins/ng --fpath ./
+zmodule ohmyzsh/ohmyzsh --root plugins/direnv
 
 zmodule carlosedp/mill-zsh-completions
 zmodule zsh-users/zsh-autosuggestions
+
+zmodule $ZDOTDIR/plugins/fzf
+zmodule chitoku-k/fzf-zsh-completions
+zmodule urbainvaes/fzf-marks

.zshenv

@@ -0,0 +1 @@
+zshenv

aliases/apt

@@ -9,7 +9,18 @@ grep -iq 'ID_LIKE=debian' /etc/os-release || \
 	return
 
 alias xq="apt-cache search"
-alias xi="apt-get install"
+alias xi="sudo apt-get install"
 alias xowner="dpkg -S"
 alias xfiles="dpkg -L"
 alias sv="systemctl"
+
+xupdate() {
+	sudo -v
+	echo "\e[1;32mUpdating package cache...\e[0m"
+	if sudo apt update 2>&1 | grep -q 'apt list --upgradable'; then
+		echo "\e[1;92mUpgrades available:\e[0m"
+		apt list --upgradable
+		echo "\e[1;92mRun upgrades?\e[0m"
+		read -q && sudo apt upgrade -y
+	fi
+}

aliases/devel

@@ -0,0 +1,6 @@
+
+ignore() {
+	printf "%s\n" $@ >> .gitignore
+	git add .gitignore
+}
+alias ignore="noglob ignore"

aliases/functions

@@ -20,6 +20,8 @@ alias d="dragon-drop -a -x -T"
 if ! command -v fd >/dev/null; then
     if command -v fdfind >/dev/null; then
 	alias fd="fdfind"
+	autoload -Uz _fd
+	compdef _fd fdfind
     else
 	fd() {
 	    if [[ "$1" =~ "^-" ]]; then
@@ -145,7 +147,6 @@ send-subvolume() { btrfs property set $1 ro true; btrfs send -v $1 | pv | nc -c
 #################################################################################
 # filename manipulation
 ##############################################################################{{{
-alias cleanspaces="renamexm -s/\ /_/g -R"
 
 # prefix all given files with first argument to this function
 prefix() {
@@ -280,17 +281,8 @@ alias -s log=vimpager
 # various small scripts
 ##############################################################################{{{
 
-urlencode() {
+alias urldecode="python3 -c 'import sys; from urllib import parse; print(parse.unquote_plus(sys.stdin.read().strip()))'"
-	local input
+alias urlencode="python3 -c 'import sys; from urllib import parse; print(parse.quote_plus(sys.stdin.read().strip()))'"
-        setopt extendedglob
-	if [ -n "$1" ]; then
-		input="$*"
-	else
-		input=$(</dev/stdin)
-	fi
-	# by jkramer, source: http://stackoverflow.com/a/187853/928769
-        echo "${${(j: :)input}//(#b)(?)/%$[[##16]##${match[1]}]}"
-}
 
 #}}}
 
@@ -392,3 +384,11 @@ fi
 duplicates() {
     sort | uniq -c | grep -v '^\s*1'
 }
+
+alias rg="RIPGREP_CONFIG_PATH=$XDG_CONFIG_HOME/ripgreprc rg"
+
+if exists gron; then
+    jgrep() {
+	gron | grep "$@" | gron -u
+    }
+fi

aliases/git

@@ -88,3 +88,16 @@ gclone() {
 
     git clone $url "$@"
 }
+
+gwt() {
+	local current_tree line prefix
+	typeset -A trees
+	prefix=$(git rev-parse --show-prefix)
+	git worktree list --porcelain | while read line; do
+			if [[ $line = worktree* ]]; then current_tree=${line##worktree }
+			elif [[ $line = branch* ]]; then trees[${line##branch refs/heads/}]=$current_tree
+			fi
+	done
+	local target=$(for k v in ${(kv)trees}; do echo "$k $v"; done | column -t | fzf ${1:+-q} ${1} -1| awk '{print $2}')
+	[[ -n $target ]] && cd $target/$prefix
+}

bashcomp/az.completion

@@ -0,0 +1,21 @@
+_az_python_argcomplete() {
+    local IFS=$'\013'
+    local SUPPRESS_SPACE=0
+    if compopt +o nospace 2> /dev/null; then
+        SUPPRESS_SPACE=1
+    fi
+    COMPREPLY=( $(IFS="$IFS" \
+                  COMP_LINE="$COMP_LINE" \
+                  COMP_POINT="$COMP_POINT" \
+                  COMP_TYPE="$COMP_TYPE" \
+                  _ARGCOMPLETE_COMP_WORDBREAKS="$COMP_WORDBREAKS" \
+                  _ARGCOMPLETE=1 \
+                  _ARGCOMPLETE_SUPPRESS_SPACE=$SUPPRESS_SPACE \
+                  "$1" 8>&1 9>&2 1>/dev/null 2>/dev/null) )
+    if [[ $? != 0 ]]; then
+        unset COMPREPLY
+    elif [[ $SUPPRESS_SPACE == 1 ]] && [[ "$COMPREPLY" =~ [=/:]$ ]]; then
+        compopt -o nospace
+    fi
+}
+complete -o nospace -o default -o bashdefault -F _az_python_argcomplete "az"

completion.zsh

@@ -1,6 +1,7 @@
 # autoload completions
-fpath=( "${XDG_DATA_HOME:-$HOME/.local/share}/zsh/site-functions" "${ZDOTDIR:+$ZDOTDIR/compdef}" "/etc/zsh/compdef" $fpath )
+fpath=( "${XDG_DATA_HOME:-$HOME/.local/share}/zsh/site-functions" "/usr/share/zsh/site-functions" "${ZDOTDIR:+$ZDOTDIR/compdef}" "/etc/zsh/compdef" $fpath )
 fpath=("$XDG_DATA_HOME/scalacli/completions/zsh" $fpath)
+fpath=(/opt/vagrant/embedded/gems/gems/vagrant-2.4.3/contrib/zsh $fpath)
 
 [[ -n $(echo /etc/zsh/compdef/*(N:t)) ]] && autoload -U /etc/zsh/compdef/*(N:t)
 [[ -n $(echo $ZDOTDIR/compdef/*(N:t)) ]] && autoload -U $ZDOTDIR/compdef/*(N:t)
@@ -11,12 +12,14 @@ mkdir -p ${ZSH_COMPDUMP_LOCATION:h}
 autoload -Uz compinit
 if [[ ${UID} -eq 0 ]] && [[ -n ${SUDO_USER} ]]; then
 	compinit -u -d $ZSH_COMPDUMP_LOCATION
-else
+elif [[ -n ${ZSH_COMPDUMP_LOCATION}(#qN.mh+24) ]]; then
 	compinit -d $ZSH_COMPDUMP_LOCATION
+else
+	compinit -C -d $ZSH_COMPDUMP_LOCATION
 fi
-unset ZSH_COMPDUMP_LOCATION
 
 autoload -U +X bashcompinit && bashcompinit
+try-source $ZDOTDIR/bashcomp/*(N)
 
 zstyle ':completion:*:descriptions' format ‘%B%d%b’
 zstyle ':completion:*:messages' format ‘%d’

env/20_dockerhost.zsh

@@ -1,3 +0,0 @@
-if [[ -e $XDG_RUNTIME_DIR/podman/podman.sock ]]; then
-	export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/podman/podman.sock
-fi

env/50_bun.zsh

@@ -0,0 +1,4 @@
+export BUN_INSTALL="$HOME/.local/share/bun" 
+if [[ -d $BUN_INSTALL ]]; then
+	path+="$BUN_INSTALL/bin"
+fi

env/50_rust.zsh

@@ -1,6 +1,6 @@
 export RUSTUP_HOME="${XDG_DATA_HOME}/rustup"
 export CARGO_HOME="${XDG_DATA_HOME}/cargo"
 export PATH="${CARGO_HOME}/bin:${PATH}"
-if which rustup &>/dev/null && [[ -n $(rustup show active-toolchain) ]]; then
+if [[ $- == *i* ]] && which rustup &>/dev/null && [[ -n $(rustup show active-toolchain) ]]; then
 	export RUST_SRC_PATH=$(rustup run stable rustc --print sysroot)/lib/rustlib/src/rust/src
 fi

env/90_podman-socket.zsh

@@ -1,4 +1,15 @@
+[[ $- == *i* ]] || return 0
+
+local SOCKET_CACHE=$XDG_CACHE_HOME/zsh-podman-socket
 if command -v podman &>/dev/null; then
-	export DOCKER_SOCKET=$(podman system info -f '{{.Host.RemoteSocket.Path}}')
+	local podman_socket
+	if [[ ! -e $SOCKET_CACHE ]]; then
+		podman system info -f '{{.Host.RemoteSocket.Path}}' > $SOCKET_CACHE
+	else
+		podman_socket=$(<$SOCKET_CACHE)
+	fi
+	if [[ -e $podman_socket ]]; then
+		export DOCKER_SOCKET=$podman_socket
 		export DOCKER_HOST=unix://$DOCKER_SOCKET
 	fi
+fi

plugins/cdup/cdup.plugin.zsh

@@ -0,0 +1,20 @@
+
+_cdup() {
+	local dir=$1; shift
+	local targets=("$@")
+	for target in $targets; do
+		if [[ -e $dir/$target ]]; then
+			cd $dir
+			return 0
+		fi
+	done
+	if [[ $dir == "/" ]]; then return 1
+	else _cdup ${dir:h} ${targets[@]}
+	fi
+}
+
+cdup() {
+	if [[ ${#@} -gt 0 ]]; then _cdup ${PWD:h} "$@"
+	else _cdup ${PWD:h} .git .hg package.json build.sbt
+	fi
+}

plugins/cs-java-home/_set-jvm

@@ -0,0 +1,5 @@
+#compdef set-jvm
+
+_set-jvm() {
+	compadd $(cs java --available)
+}

plugins/cs-java-home/cs-java-home.plugin.zsh

@@ -1,5 +1,7 @@
 typeset -a chpwd_functions __chromaz_extra_left
 
+fpath+=("${0:A:h}")
+
 SYSTEM_JAVA_HOME=${CS_FORMER_JAVA_HOME:-$JAVA_HOME}
 
 local cs_jvm_id
@@ -36,6 +38,15 @@ cs-current-java() {
 	echo ${cs_jvm_id:+JVM: }${cs_jvm_id}
 }
 
+set-jvm() {
+	if [[ -z $1 ]]; then
+		echo 'Usage: set-jvm VERSION'
+		return 1
+	fi
+	cs java --jvm $1 --env  && echo $1 > .jvm
+	cs-set-java-home
+}
+
 chpwd_functions+=cs-set-java-home
 __chromaz_extra_left+=cs-current-java
 cs-set-java-home

plugins/fzf/fzf.plugin.zsh

@@ -0,0 +1,524 @@
+### key-bindings.zsh ###
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ key-bindings.zsh
+#
+# - $FZF_TMUX_OPTS
+# - $FZF_CTRL_T_COMMAND
+# - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_OPTS
+# - $FZF_ALT_C_COMMAND
+# - $FZF_ALT_C_OPTS
+
+
+# Key bindings
+# ------------
+
+# The code at the top and the bottom of this file is the same as in completion.zsh.
+# Refer to that file for explanation.
+if 'zmodload' 'zsh/parameter' 2>'/dev/null' && (( ${+options} )); then
+  __fzf_key_bindings_options="options=(${(j: :)${(kv)options[@]}})"
+else
+  () {
+    __fzf_key_bindings_options="setopt"
+    'local' '__fzf_opt'
+    for __fzf_opt in "${(@)${(@f)$(set -o)}%% *}"; do
+      if [[ -o "$__fzf_opt" ]]; then
+        __fzf_key_bindings_options+=" -o $__fzf_opt"
+      else
+        __fzf_key_bindings_options+=" +o $__fzf_opt"
+      fi
+    done
+  }
+fi
+
+'builtin' 'emulate' 'zsh' && 'builtin' 'setopt' 'no_aliases'
+
+{
+if [[ -o interactive ]]; then
+
+__fzf_defaults() {
+  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
+  echo "${FZF_DEFAULT_OPTS-} $2"
+}
+
+# CTRL-T - Paste the selected file path(s) into the command line
+__fzf_select() {
+  setopt localoptions pipefail no_aliases 2> /dev/null
+  local item
+  FZF_DEFAULT_COMMAND=${FZF_CTRL_T_COMMAND:-} \
+  FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=file,dir,follow,hidden --scheme=path" "${FZF_CTRL_T_OPTS-} -m") \
+  FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) "$@" < /dev/tty | while read -r item; do
+    echo -n -E "${(q)item} "
+  done
+  local ret=$?
+  echo
+  return $ret
+}
+
+__fzfcmd() {
+  [ -n "${TMUX_PANE-}" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "${FZF_TMUX_OPTS-}" ]; } &&
+    echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
+}
+
+fzf-file-widget() {
+  LBUFFER="${LBUFFER}$(__fzf_select)"
+  local ret=$?
+  zle reset-prompt
+  return $ret
+}
+if [[ "${FZF_CTRL_T_COMMAND-x}" != "" ]]; then
+  zle     -N            fzf-file-widget
+  bindkey -M emacs '^T' fzf-file-widget
+  bindkey -M vicmd '^T' fzf-file-widget
+  bindkey -M viins '^T' fzf-file-widget
+fi
+
+# ALT-C - cd into the selected directory
+fzf-cd-widget() {
+  setopt localoptions pipefail no_aliases 2> /dev/null
+  local dir="$(
+    FZF_DEFAULT_COMMAND=${FZF_ALT_C_COMMAND:-} \
+    FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=dir,follow,hidden --scheme=path" "${FZF_ALT_C_OPTS-} +m") \
+    FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) < /dev/tty)"
+  if [[ -z "$dir" ]]; then
+    zle redisplay
+    return 0
+  fi
+  zle push-line # Clear buffer. Auto-restored on next prompt.
+  BUFFER="builtin cd -- ${(q)dir:a}"
+  zle accept-line
+  local ret=$?
+  unset dir # ensure this doesn't end up appearing in prompt expansion
+  zle reset-prompt
+  return $ret
+}
+if [[ "${FZF_ALT_C_COMMAND-x}" != "" ]]; then
+  zle     -N             fzf-cd-widget
+  bindkey -M emacs '\ec' fzf-cd-widget
+  bindkey -M vicmd '\ec' fzf-cd-widget
+  bindkey -M viins '\ec' fzf-cd-widget
+fi
+
+# CTRL-R - Paste the selected command from history into the command line
+fzf-history-widget() {
+  local selected
+  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases noglob nobash_rematch 2> /dev/null
+  # Ensure the associative history array, which maps event numbers to the full
+  # history lines, is loaded, and that Perl is installed for multi-line output.
+  if zmodload -F zsh/parameter p:history 2>/dev/null && (( ${#commands[perl]} )); then
+    selected="$(printf '%s\t%s\000' "${(kv)history[@]}" |
+      perl -0 -ne 'if (!$seen{(/^\s*[0-9]+\**\t(.*)/s, $1)}++) { s/\n/\n\t/g; print; }' |
+      FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '\t↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m --read0") \
+      FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
+  else
+    selected="$(fc -rl 1 | awk '{ cmd=$0; sub(/^[ \t]*[0-9]+\**[ \t]+/, "", cmd); if (!seen[cmd]++) print $0 }' |
+      FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '\t↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m") \
+      FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
+  fi
+  local ret=$?
+  if [ -n "$selected" ]; then
+    if [[ $(awk '{print $1; exit}' <<< "$selected") =~ ^[1-9][0-9]* ]]; then
+      zle vi-fetch-history -n $MATCH
+    else # selected is a custom query, not from history
+      LBUFFER="$selected"
+    fi
+  fi
+  zle reset-prompt
+  return $ret
+}
+zle     -N            fzf-history-widget
+bindkey -M emacs '^R' fzf-history-widget
+bindkey -M vicmd '^R' fzf-history-widget
+bindkey -M viins '^R' fzf-history-widget
+fi
+
+} always {
+  eval $__fzf_key_bindings_options
+  'unset' '__fzf_key_bindings_options'
+}
+### end: key-bindings.zsh ###
+### completion.zsh ###
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ completion.zsh
+#
+# - $FZF_TMUX                 (default: 0)
+# - $FZF_TMUX_OPTS            (default: empty)
+# - $FZF_COMPLETION_TRIGGER   (default: '**')
+# - $FZF_COMPLETION_OPTS      (default: empty)
+# - $FZF_COMPLETION_PATH_OPTS (default: empty)
+# - $FZF_COMPLETION_DIR_OPTS  (default: empty)
+
+
+# Both branches of the following `if` do the same thing -- define
+# __fzf_completion_options such that `eval $__fzf_completion_options` sets
+# all options to the same values they currently have. We'll do just that at
+# the bottom of the file after changing options to what we prefer.
+#
+# IMPORTANT: Until we get to the `emulate` line, all words that *can* be quoted
+# *must* be quoted in order to prevent alias expansion. In addition, code must
+# be written in a way works with any set of zsh options. This is very tricky, so
+# careful when you change it.
+#
+# Start by loading the builtin zsh/parameter module. It provides `options`
+# associative array that stores current shell options.
+if 'zmodload' 'zsh/parameter' 2>'/dev/null' && (( ${+options} )); then
+  # This is the fast branch and it gets taken on virtually all Zsh installations.
+  #
+  # ${(kv)options[@]} expands to array of keys (option names) and values ("on"
+  # or "off"). The subsequent expansion# with (j: :) flag joins all elements
+  # together separated by spaces. __fzf_completion_options ends up with a value
+  # like this: "options=(shwordsplit off aliases on ...)".
+  __fzf_completion_options="options=(${(j: :)${(kv)options[@]}})"
+else
+  # This branch is much slower because it forks to get the names of all
+  # zsh options. It's possible to eliminate this fork but it's not worth the
+  # trouble because this branch gets taken only on very ancient or broken
+  # zsh installations.
+  () {
+    # That `()` above defines an anonymous function. This is essentially a scope
+    # for local parameters. We use it to avoid polluting global scope.
+    'local' '__fzf_opt'
+    __fzf_completion_options="setopt"
+    # `set -o` prints one line for every zsh option. Each line contains option
+    # name, some spaces, and then either "on" or "off". We just want option names.
+    # Expansion with (@f) flag splits a string into lines. The outer expansion
+    # removes spaces and everything that follow them on every line. __fzf_opt
+    # ends up iterating over option names: shwordsplit, aliases, etc.
+    for __fzf_opt in "${(@)${(@f)$(set -o)}%% *}"; do
+      if [[ -o "$__fzf_opt" ]]; then
+        # Option $__fzf_opt is currently on, so remember to set it back on.
+        __fzf_completion_options+=" -o $__fzf_opt"
+      else
+        # Option $__fzf_opt is currently off, so remember to set it back off.
+        __fzf_completion_options+=" +o $__fzf_opt"
+      fi
+    done
+    # The value of __fzf_completion_options here looks like this:
+    # "setopt +o shwordsplit -o aliases ..."
+  }
+fi
+
+# Enable the default zsh options (those marked with <Z> in `man zshoptions`)
+# but without `aliases`. Aliases in functions are expanded when functions are
+# defined, so if we disable aliases here, we'll be sure to have no pesky
+# aliases in any of our functions. This way we won't need prefix every
+# command with `command` or to quote every word to defend against global
+# aliases. Note that `aliases` is not the only option that's important to
+# control. There are several others that could wreck havoc if they are set
+# to values we don't expect. With the following `emulate` command we
+# sidestep this issue entirely.
+'builtin' 'emulate' 'zsh' && 'builtin' 'setopt' 'no_aliases'
+
+# This brace is the start of try-always block. The `always` part is like
+# `finally` in lesser languages. We use it to *always* restore user options.
+{
+# The 'emulate' command should not be placed inside the interactive if check;
+# placing it there fails to disable alias expansion. See #3731.
+if [[ -o interactive ]]; then
+
+# To use custom commands instead of find, override _fzf_compgen_{path,dir}
+#
+#   _fzf_compgen_path() {
+#     echo "$1"
+#     command find -L "$1" \
+#       -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+#       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+#   }
+#
+#   _fzf_compgen_dir() {
+#     command find -L "$1" \
+#       -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
+#       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+#   }
+
+###########################################################
+
+__fzf_defaults() {
+  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
+  echo "${FZF_DEFAULT_OPTS-} $2"
+}
+
+__fzf_comprun() {
+  if [[ "$(type _fzf_comprun 2>&1)" =~ function ]]; then
+    _fzf_comprun "$@"
+  elif [ -n "${TMUX_PANE-}" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "${FZF_TMUX_OPTS-}" ]; }; then
+    shift
+    if [ -n "${FZF_TMUX_OPTS-}" ]; then
+      fzf-tmux ${(Q)${(Z+n+)FZF_TMUX_OPTS}} -- "$@"
+    else
+      fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%} -- "$@"
+    fi
+  else
+    shift
+    fzf "$@"
+  fi
+}
+
+# Extract the name of the command. e.g. foo=1 bar baz**<tab>
+__fzf_extract_command() {
+  local token tokens
+  tokens=(${(z)1})
+  for token in $tokens; do
+    token=${(Q)token}
+    if [[ "$token" =~ [[:alnum:]] && ! "$token" =~ "=" ]]; then
+      echo "$token"
+      return
+    fi
+  done
+  echo "${tokens[1]}"
+}
+
+__fzf_generic_path_completion() {
+  local base lbuf cmd compgen fzf_opts suffix tail dir leftover matches
+  base=$1
+  lbuf=$2
+  cmd=$(__fzf_extract_command "$lbuf")
+  compgen=$3
+  fzf_opts=$4
+  suffix=$5
+  tail=$6
+
+  setopt localoptions nonomatch
+  if [[ $base = *'$('* ]] || [[ $base = *'<('* ]] || [[ $base = *'>('* ]] || [[ $base = *':='* ]] || [[ $base = *'`'* ]]; then
+    return
+  fi
+  eval "base=$base" 2> /dev/null || return
+  [[ $base = *"/"* ]] && dir="$base"
+  while [ 1 ]; do
+    if [[ -z "$dir" || -d ${dir} ]]; then
+      leftover=${base/#"$dir"}
+      leftover=${leftover/#\/}
+      [ -z "$dir" ] && dir='.'
+      [ "$dir" != "/" ] && dir="${dir/%\//}"
+      matches=$(
+        export FZF_DEFAULT_OPTS
+        FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --scheme=path" "${FZF_COMPLETION_OPTS-}")
+        unset FZF_DEFAULT_COMMAND FZF_DEFAULT_OPTS_FILE
+        if declare -f "$compgen" > /dev/null; then
+          eval "$compgen $(printf %q "$dir")" | __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover"
+        else
+          if [[ $compgen =~ dir ]]; then
+            walker=dir,follow
+            rest=${FZF_COMPLETION_DIR_OPTS-}
+          else
+            walker=file,dir,follow,hidden
+            rest=${FZF_COMPLETION_PATH_OPTS-}
+          fi
+          __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" --walker "$walker" --walker-root="$dir" ${(Q)${(Z+n+)rest}} < /dev/tty
+        fi | while read -r item; do
+          item="${item%$suffix}$suffix"
+          echo -n -E "${(q)item} "
+        done
+      )
+      matches=${matches% }
+      if [ -n "$matches" ]; then
+        LBUFFER="$lbuf$matches$tail"
+      fi
+      zle reset-prompt
+      break
+    fi
+    dir=$(dirname "$dir")
+    dir=${dir%/}/
+  done
+}
+
+_fzf_path_completion() {
+  __fzf_generic_path_completion "$1" "$2" _fzf_compgen_path \
+    "-m" "" " "
+}
+
+_fzf_dir_completion() {
+  __fzf_generic_path_completion "$1" "$2" _fzf_compgen_dir \
+    "" "/" ""
+}
+
+_fzf_feed_fifo() {
+  command rm -f "$1"
+  mkfifo "$1"
+  cat <&0 > "$1" &|
+}
+
+_fzf_complete() {
+  setopt localoptions ksh_arrays
+  # Split arguments around --
+  local args rest str_arg i sep
+  args=("$@")
+  sep=
+  for i in {0..${#args[@]}}; do
+    if [[ "${args[$i]-}" = -- ]]; then
+      sep=$i
+      break
+    fi
+  done
+  if [[ -n "$sep" ]]; then
+    str_arg=
+    rest=("${args[@]:$((sep + 1)):${#args[@]}}")
+    args=("${args[@]:0:$sep}")
+  else
+    str_arg=$1
+    args=()
+    shift
+    rest=("$@")
+  fi
+
+  local fifo lbuf cmd matches post
+  fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$"
+  lbuf=${rest[0]}
+  cmd=$(__fzf_extract_command "$lbuf")
+  post="${funcstack[1]}_post"
+  type $post > /dev/null 2>&1 || post=cat
+
+  _fzf_feed_fifo "$fifo"
+  matches=$(
+    FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse" "${FZF_COMPLETION_OPTS-} $str_arg") \
+    FZF_DEFAULT_OPTS_FILE='' \
+      __fzf_comprun "$cmd" "${args[@]}" -q "${(Q)prefix}" < "$fifo" | $post | tr '\n' ' ')
+  if [ -n "$matches" ]; then
+    LBUFFER="$lbuf$matches"
+  fi
+  command rm -f "$fifo"
+}
+
+# To use custom hostname lists, override __fzf_list_hosts.
+# The function is expected to print hostnames, one per line as well as in the
+# desired sorting and with any duplicates removed, to standard output.
+if ! declare -f __fzf_list_hosts > /dev/null; then
+  __fzf_list_hosts() {
+    setopt localoptions nonomatch
+    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?%]') \
+      <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts 2> /dev/null | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
+      <(command grep -v '^\s*\(#\|$\)' /etc/hosts 2> /dev/null | command grep -Fv '0.0.0.0' | command sed 's/#.*//') |
+      awk '{for (i = 2; i <= NF; i++) print $i}' | sort -u
+  }
+fi
+
+_fzf_complete_telnet() {
+  _fzf_complete +m -- "$@" < <(__fzf_list_hosts)
+}
+
+# The first and the only argument is the LBUFFER without the current word that contains the trigger.
+# The current word without the trigger is in the $prefix variable passed from the caller.
+_fzf_complete_ssh() {
+  local -a tokens
+  tokens=(${(z)1})
+  case ${tokens[-1]} in
+    -i|-F|-E)
+      _fzf_path_completion "$prefix" "$1"
+      ;;
+    *)
+      local user
+      [[ $prefix =~ @ ]] && user="${prefix%%@*}@"
+      _fzf_complete +m -- "$@" < <(__fzf_list_hosts | awk -v user="$user" '{print user $0}')
+      ;;
+  esac
+}
+
+_fzf_complete_export() {
+  _fzf_complete -m -- "$@" < <(
+    declare -xp | sed 's/=.*//' | sed 's/.* //'
+  )
+}
+
+_fzf_complete_unset() {
+  _fzf_complete -m -- "$@" < <(
+    declare -xp | sed 's/=.*//' | sed 's/.* //'
+  )
+}
+
+_fzf_complete_unalias() {
+  _fzf_complete +m -- "$@" < <(
+    alias | sed 's/=.*//'
+  )
+}
+
+_fzf_complete_kill() {
+  _fzf_complete -m --header-lines=1 --no-preview --wrap -- "$@" < <(
+    command ps -eo user,pid,ppid,start,time,command 2> /dev/null ||
+      command ps -eo user,pid,ppid,time,args 2> /dev/null || # For BusyBox
+      command ps --everyone --full --windows # For cygwin
+  )
+}
+
+_fzf_complete_kill_post() {
+  awk '{print $2}'
+}
+
+fzf-completion() {
+  local tokens cmd prefix trigger tail matches lbuf d_cmds
+  setopt localoptions noshwordsplit noksh_arrays noposixbuiltins
+
+  # http://zsh.sourceforge.net/FAQ/zshfaq03.html
+  # http://zsh.sourceforge.net/Doc/Release/Expansion.html#Parameter-Expansion-Flags
+  tokens=(${(z)LBUFFER})
+  if [ ${#tokens} -lt 1 ]; then
+    zle ${fzf_default_completion:-expand-or-complete}
+    return
+  fi
+
+  cmd=$(__fzf_extract_command "$LBUFFER")
+
+  # Explicitly allow for empty trigger.
+  trigger=${FZF_COMPLETION_TRIGGER-'**'}
+  [ -z "$trigger" -a ${LBUFFER[-1]} = ' ' ] && tokens+=("")
+
+  # When the trigger starts with ';', it becomes a separate token
+  if [[ ${LBUFFER} = *"${tokens[-2]-}${tokens[-1]}" ]]; then
+    tokens[-2]="${tokens[-2]-}${tokens[-1]}"
+    tokens=(${tokens[0,-2]})
+  fi
+
+  lbuf=$LBUFFER
+  tail=${LBUFFER:$(( ${#LBUFFER} - ${#trigger} ))}
+
+  # Trigger sequence given
+  if [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
+    d_cmds=(${=FZF_COMPLETION_DIR_COMMANDS-cd pushd rmdir})
+
+    [ -z "$trigger"      ] && prefix=${tokens[-1]} || prefix=${tokens[-1]:0:-${#trigger}}
+    if [[ $prefix = *'$('* ]] || [[ $prefix = *'<('* ]] || [[ $prefix = *'>('* ]] || [[ $prefix = *':='* ]] || [[ $prefix = *'`'* ]]; then
+      return
+    fi
+    [ -n "${tokens[-1]}" ] && lbuf=${lbuf:0:-${#tokens[-1]}}
+
+    if eval "type _fzf_complete_${cmd} > /dev/null"; then
+      prefix="$prefix" eval _fzf_complete_${cmd} ${(q)lbuf}
+      zle reset-prompt
+    elif [ ${d_cmds[(i)$cmd]} -le ${#d_cmds} ]; then
+      _fzf_dir_completion "$prefix" "$lbuf"
+    else
+      _fzf_path_completion "$prefix" "$lbuf"
+    fi
+  # Fall back to default completion
+  else
+    zle ${fzf_default_completion:-expand-or-complete}
+  fi
+}
+
+[ -z "$fzf_default_completion" ] && {
+  binding=$(bindkey '^I')
+  [[ $binding =~ 'undefined-key' ]] || fzf_default_completion=$binding[(s: :w)2]
+  unset binding
+}
+
+zle     -N   fzf-completion
+bindkey '^I' fzf-completion
+fi
+
+} always {
+  # Restore the original options.
+  eval $__fzf_completion_options
+  'unset' '__fzf_completion_options'
+}
+### end: completion.zsh ###

plugins/nvm/nvm.plugin.zsh

@@ -0,0 +1,51 @@
+typeset -a chpwd_functions __chromaz_extra_left
+# fnm
+FNM_PATH="${XDG_DATA_HOME:-$HOME/.local/share}/fnm"
+if [ -d "$FNM_PATH" ]; then
+	export PATH="$FNM_PATH:$PATH"
+	eval "$(fnm env --use-on-cd --version-file-strategy recursive)"
+	FNM_DEFAULT=${$(readlink $FNM_PATH/aliases/default):h:t}
+
+	_prompt_fnm_version() {
+		local node_version=$(fnm current)
+		[[ $node_version == $FNM_DEFAULT ]] && return
+		echo "nodejs: ${node_version}"
+	}
+	__chromaz_extra_left+=_prompt_fnm_version
+elif [ -d "$HOME/.nvm" ]; then
+	export NVM_DIR="$HOME/.nvm"
+	nvm() {
+		[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
+		nvm "$@"
+	}
+
+	find-nvmrc-version() {
+		local dir=${1:-${PWD:a}}
+		if [[ $dir == / ]]; then return 1; fi
+		if [[ -e $dir/.nvmrc ]]; then
+			< $dir/.nvmrc
+		else
+			find-nvmrc-version ${dir:h}
+		fi
+	}
+
+	chpwd-set-nvm() {
+		if vers=$(find-nvmrc-version); then
+			if [[ $vers != ${NVM_BIN:h:t} ]]; then
+				nvm use
+			fi
+		fi
+	}
+	chpwd-set-nvm &>/dev/null
+
+	chpwd_functions+=chpwd-set-nvm
+
+	_prompt_nvm_version() {
+		[[ -z $NVM_BIN ]] && return
+		echo "nodejs: ${NVM_BIN:h:t}"
+	}
+	__chromaz_extra_left+=_prompt_nvm_version
+else
+	return
+fi
+

zshenv

@@ -8,3 +8,4 @@ function(){
 		. $i
 	done
 }
+skip_global_compinit=1

zshrc

@@ -1,3 +1,4 @@
+#zmodload zsh/zprof
 typeset -U path
 
 HISTFILE=${XDG_STATE_HOME:-$HOME/.local/state}/zsh/histfile
@@ -67,6 +68,12 @@ function(){
     try-source $(zdotfile dirs)
 }
 
+try-source $(zdotfile local.zsh)
+
+if [[ ! -z $ZDOTDIR/plugins/fzf/fzf.plugin.zsh ]] && exists fzf; then
+	mkdir -p $ZDOTDIR/plugins/fzf
+	fzf --zsh 2>/dev/null > $ZDOTDIR/plugins/fzf/fzf.plugin.zsh || true
+fi
 
 ZIM_HOME=${XDG_CACHE_HOME:-$HOME/.cache}/zim
 if [[ ! -e ${ZIM_HOME}/zimfw.zsh ]]; then
@@ -120,4 +127,9 @@ if exists mail; then
     }
     __chromaz_extra_left+=_prompt_cron_mails
 fi
+
 tabs -4
+#zprof
+
+# bun completions
+[ -s "/home/crater2150/.bun/_bun" ] && source "/home/crater2150/.bun/_bun"