Prototype for trying out blesh

Recommendations came from this blog post:
    https://blog.gitbutler.com/how-git-core-devs-configure-git/

Let's see how this works out lol

Test

.gitmodules

@@ -61,3 +61,6 @@
 [submodule "vim/.vim/nvim-bundle/zk-nvim"]
 	path = vim/.vim/nvim-bundle/zk-nvim
 	url = https://github.com/zk-org/zk-nvim.git
+[submodule "vim/.vim/bundle/vim-helm"]
+	path = vim/.vim/bundle/vim-helm
+	url = https://github.com/towolf/vim-helm.git

apply-dotfiles

@@ -17,6 +17,9 @@ apply_dotfile sh
 apply_dotfile readline
 apply_dotfile screen
 
+apply_dotfile git
+apply_dotfile xdg
+
 apply_dotfile vim
 
 apply_dotfile ruby

bash/.bashrc

@@ -1,5 +1,46 @@
 #{- ~/.bashrc -}#
 
+#{- SOURCING -}#
+
+# Source profile, if it hasn't already been loaded
+if [ -z "$__PROFILE_DONE" ]; then
+  . $HOME/.profile
+fi
+
+# Source .env to extend with secret/sensitive environment variables if it exists
+if [ -r "$HOME/.env" ]; then
+  . "$HOME/.env"
+fi
+
+if [ -r "$HOME/.config/xdg/env" ]; then
+  . "$HOME/.config/xdg/env"
+fi
+
+# Source aliases, if they exist
+if [ -f "$HOME/.aliases" ] && [ -r "$HOME/.aliases" ]; then
+  . "$HOME/.aliases"
+fi
+
+# Source private aliases, if they exist
+if [ -f "$HOME/.private_aliases" ] && [ -r "$HOME/.private_aliases" ]; then
+  . "$HOME/.private_aliases"
+fi
+
+# Source functions, if they exist
+if [ -f "$HOME/.functions" ] && [ -r "$HOME/.functions" ]; then
+  . "$HOME/.functions"
+fi
+
+# Source private functions, if they exist
+if [ -f "$HOME/.private_functions" ] && [ -r "$HOME/.private_functions" ]; then
+  . "$HOME/.private_functions"
+fi
+
+if blesh-available; then
+  # blesh-activate
+  :
+fi
+
 #{- PROMPT -}#
 
 if which tput &> /dev/null && tput bold &> /dev/null; then
@@ -20,7 +61,6 @@ else
   no_color="\[\033[0m\]"
 fi
 
-
 export PS1="${green}"'\$'"${no_color} "
 export DIRENV_PS1="${red}"'\$'"${no_color} "
 export NIX_SHELL_PS1="${blue}"'λ'"${no_color} "
@@ -55,7 +95,7 @@ if which direnv &> /dev/null; then
       PS1=${ORIG_PS1}
     fi
   }
-  PROMPT_COMMAND="update_prompt; $PROMPT_COMMAND"
+  prompt_command_prepend "update_prompt"
 fi
 
 # Continuation Prompt: "> " in cyan
@@ -65,8 +105,14 @@ export PS4="${blue}#${no_color} "
 
 #{- HISTORY -}#
 
-PROMPT_COMMAND="history -n; history -w; history -c; history -r; $PROMPT_COMMAND"
-# PROMPT_COMMAND="echo hist1; history; history -n; echo hist2; history; history -w; echo hist3; history; history -c; echo hist4; history; history -r; echo hist5; history; $PROMPT_COMMAND"
+if blesh-attached; then
+  bleopt history_share=1
+else
+  prompt_command_prepend "history -r"
+  prompt_command_prepend "history -c"
+  prompt_command_prepend "history -w"
+  prompt_command_prepend "history -n"
+fi
 export HISTFILE="$HOME/.history/bash"
 export HISTTIMEFORMAT="%F %T  "
 export HISTCONTROL="erasedups:ignoreboth"
@@ -93,42 +139,17 @@ log_bash_persistent_history()
   fi
 }
 
-PROMPT_COMMAND="log_bash_persistent_history; $PROMPT_COMMAND"
+prompt_command_prepend "log_bash_persistent_history"
 
-
-#{- SOURCING -}#
-
-
-# Source profile, if it hasn't already been loaded
-if [ -z "$__PROFILE_DONE" ]; then
-  . $HOME/.profile
-fi
-
-# Source .env to extend with secret/sensitive environment variables if it exists
-if [ -r "$HOME/.env" ]; then
-  . "$HOME/.env"
-fi
-
-
-# Source aliases, if they exist
-if [ -f "$HOME/.aliases" ] && [ -r "$HOME/.aliases" ]; then
-  . "$HOME/.aliases"
-fi
-
-# Source private aliases, if they exist
-if [ -f "$HOME/.private_aliases" ] && [ -r "$HOME/.private_aliases" ]; then
-  . "$HOME/.private_aliases"
-fi
-
-# Source functions, if they exist
-if [ -f "$HOME/.functions" ] && [ -r "$HOME/.functions" ]; then
-  . "$HOME/.functions"
-fi
-
-# Source private functions, if they exist
-if [ -f "$HOME/.private_functions" ] && [ -r "$HOME/.private_functions" ]; then
-  . "$HOME/.private_functions"
-fi
+# Source bash completion, this file will then lazy load all other completions
+source_completions() {
+  if [ -r "/usr/share/bash-completion/bash_completion" ]; then
+    . "/usr/share/bash-completion/bash_completion"
+  elif [ -r "/etc/bash_completion" ]; then
+    . "/etc/bash_completion"
+  fi
+}
+source_completions
 
 # Preserve the usefulness of set -x by attempting to hide everything that
 # happens in prompt_command
@@ -145,8 +166,12 @@ preserve_xtrace_reset() {
   fi
 } 2>/dev/null
 
-PROMPT_COMMAND="preserve_xtrace; $PROMPT_COMMAND preserve_xtrace_reset"
+prompt_command_prepend "preserve_xtrace"
+prompt_command_append  "preserve_xtrace_reset"
 
 if $(which direnv &> /dev/null); then
-  eval "$(direnv hook bash)"
+  # Only if direnv isn't already defined in our prompt_command
+  if ! grep -q _direnv_hook <<< $PROMPT_COMMAND; then
+    eval "$(direnv hook bash)"
+  fi
 fi

bash/.functions

@@ -18,6 +18,85 @@ maths()
 
 cat_with_newline()
 {
-  cat "$@" && echo
+  \cat "$@" && echo
 }
 alias cat="cat_with_newline"
+
+k_prompt()
+{
+  set -x
+  if [ -z ${KUBE_PROMPT+x} ]; then
+    export KUBE_PROMPT=1
+  else
+    unset KUBE_PROMPT
+  fi
+  set +x
+}
+
+kube_prompt()
+{
+  set -x
+  if ! [ -z ${KUBE_PROMPT+x} ]; then
+    context=$(\cat ${KUBECONFIG} \
+              | grep "current-context: " \
+              | sed "s/current-context: //")
+    echo {$context}
+  fi
+  set +x
+}
+
+g_prompt()
+{
+  if ! [ -z ${GIT_PROMPT+x} ]; then
+    export GIT_PROMPT=1
+  else
+    unset GIT_PROMPT
+  fi
+}
+
+git_prompt()
+{
+  if ! [ -z ${GIT_PROMPT+x} ]; then
+    # Determine if we are in a git repository
+    if git rev-parse --is-inside-work-tree &> /dev/null; then
+      branch=$(git rev-parse --abbrev-ref HEAD)
+      echo [$branch]
+    fi
+  fi
+}
+
+prompt_command_append() {
+  arg=${1}
+  PROMPT_COMMAND=${PROMPT_COMMAND:+"$PROMPT_COMMAND; "}"${arg}"
+}
+
+prompt_command_prepend() {
+  arg=${1}
+  PROMPT_COMMAND="${arg}"${PROMPT_COMMAND:+"; $PROMPT_COMMAND"}
+}
+
+blesh-activate()
+{
+  BLESH_PATH=$HOME/.nix-profile/share/blesh/ble.sh
+  if [ -r $BLESH_PATH ]; then
+    [[ $- == *i* ]] && . $HOME/.nix-profile/share/blesh/ble.sh
+    [[ ! ${BLE_VERSION-} ]] || ble-attach
+  fi
+}
+
+blesh-available() {
+  BLESH_PATH=$HOME/.nix-profile/share/blesh/ble.sh
+  if [ -r $BLESH_PATH ]; then
+    return 0
+  else
+    return 1
+  fi
+}
+
+blesh-attached () {
+  if [ -z ${BLE_VERSION:+x} ]; then
+    return 1
+  else
+    return 0
+  fi
+}

git/.config/git/config

@@ -0,0 +1,25 @@
+[branch]
+	sort = -committerdate
+[column]
+	ui = auto
+[tag]
+	sort = version:refname
+[init]
+	defaultBranch = main
+[diff]
+	algorithm = histogram
+	colorMoved = plain
+	mnemonicPrefix = true
+	renames = true
+[push]
+	default = simple
+	autoSetupRemote = true
+	followTags = true
+[fetch]
+	prune = true
+	pruneTags = true
+	all = true
+[commit]
+	verbose = true
+[core]
+	excludefiles = ~/.config/git/ignore

install.sh

@@ -6,17 +6,36 @@ set -ex
 echo "PWD: $PWD"
 # Coder dotfiles (and most other ways of doing this) will not do a recursive clone, so do that in install script.
 git submodule init && git submodule update
+
 # Match case insensitively to make things easier for this part
 shopt -s nocasematch
 
 echo "Installing dotfiles..."
-if [ -f /etc/os-release ]; then
+
+if [ "${CODER_TEMPLATE_TYPE}" == "Devcontainer" ]; then
+  installers/install-nix.sh
+  installers/install-nix-packages-flake.sh
+  if [ -r "$HOME/.nix-profile/etc/profile.d/nix.sh" ]; then
+    . "$HOME/.nix-profile/etc/profile.d/nix.sh"
+  elif [ -r "${XDG_STATE_HOME:-$HOME/.local/state}/nix/profile/etc/profile.d/nix.sh" ]; then
+    . "${XDG_STATE_HOME:-$HOME/.local/state}/nix/profile/etc/profile.d/nix.sh"
+  fi
+elif [ "${CODER_OS_FAMILY:-}" == "Ubuntu" ]; then
+  echo "Detected OS as Ubuntu, using apt";
+  sudo apt-get update;
+  sudo apt-get install -y stow;
+  installers/install-nix.sh
+  if [ -r "$HOME/.nix-profile/etc/profile.d/nix.sh" ]; then
+    . "$HOME/.nix-profile/etc/profile.d/nix.sh"
+  elif [ -r "${XDG_STATE_HOME:-$HOME/.local/state}/nix/profile/etc/profile.d/nix.sh" ]; then
+    . "${XDG_STATE_HOME:-$HOME/.local/state}/nix/profile/etc/profile.d/nix.sh"
+  fi
+elif [ -f /etc/os-release ]; then
   echo "Idenitfying OS to install GNU stow..."
-  if [ "${CODER_OS_FAMILY:-}" == "Ubuntu" ] || grep -q -i debian /etc/os-release; then
+  if grep -q -i debian /etc/os-release; then
     echo "Detected OS as Ubuntu, using apt";
     sudo apt-get update;
     sudo apt-get install -y stow;
-    installers/install-nix.sh
   elif grep -q -i rhel /etc/os-release || grep -q -i fedora /etc/os-release; then
     echo "You've got RedHat (or maybe Fedora)! Which is unsupported right now sorry!";
     # sudo yum install -y stow;
@@ -31,15 +50,20 @@ if [ -f /etc/os-release ]; then
     exit 1;
   fi;
 else
-  if [ "${CODER_TEMPLATE_TYPE}" == "Devcontainer" ]; then
-    installers/install-nix.sh
-  fi
   echo "ERROR: Unable to find '/etc/os-release' information!" 1>&2;
   exit 1;
 fi
+
 shopt -u nocasematch
 
 # Apply the dotfiles with stow
 echo "Running apply dotfiles"
-./apply-dotfiles
+if which stow &> /dev/null; then
+  ./apply-dotfiles
+elif which nix &> /dev/null; then
+  ./apply-dotfiles-nix
+else
+  echo "Tools for installing dotfiles are unavailable, failing..."
+  exit 1
+fi
 echo "Dotfiles applied successfully"

installers/install-nix-packages-flake.sh

@@ -2,14 +2,30 @@
 # Installs packages to the nix profile using nix profile
 # Reference: https://nixos.org/manual/nixpkgs/stable/#sec-declarative-package-management
 
-set -ex
+set -e
+
+FLAKE_PATH="${HOME}/.config/nix/flakes/my-package-collection"
+FLAKE_NAME="flake.nix"
+ARCHIVE_PATH="${FLAKE_PATH}/archive.nar"
+
+if ! which nix &>/dev/null; then
+  if [ -r "$HOME/.nix-profile/etc/profile.d/nix.sh" ]; then
+    . "$HOME/.nix-profile/etc/profile.d/nix.sh"
+  elif [ -r "${XDG_STATE_HOME:-$HOME/.local/state}/nix/profile/etc/profile.d/nix.sh" ]; then
+    . "${XDG_STATE_HOME:-$HOME/.local/state}/nix/profile/etc/profile.d/nix.sh"
+  else
+    echo "Nix isn't available. Exiting now!"
+    exit 1
+  fi
+fi
 
 nix_packages=(
   # Personal tools
-  "vimHugeX"
   "ranger"
   "jq"
   "yq"
+  "screen"
+  "xdg-utils" # For xdg-open
   "zk"
 
   # Neovim + Plugin dependencies
@@ -65,13 +81,13 @@ unstable_packages=(
 )
 
 
-mkdir -p ~/.config/nixpkgs/
-templated_insert="$(for nix_package in ${nix_packages[@]}; do echo "                $nix_package"; echo; done)"
-templated_insert=${templated_insert}$(for unstable_package in ${unstable_packages[@]}; do echo; echo "                unstablePkgs.$unstable_package"; done)
+generate_flake() {
+  mkdir -p "${FLAKE_PATH}"
+  templated_insert="$(for nix_package in ${nix_packages[@]}; do echo "                $nix_package"; echo; done)"
+  templated_insert=${templated_insert}$(for unstable_package in ${unstable_packages[@]}; do echo; echo "                unstablePkgs.$unstable_package"; done)
 
-
-# Reference: https://discourse.nixos.org/t/nix-profile-in-combination-with-declarative-package-management/21228/9
-cat << EOF > ~/.config/nixpkgs/flake.nix
+  # Reference: https://discourse.nixos.org/t/nix-profile-in-combination-with-declarative-package-management/21228/9
+cat <<EOF > "${FLAKE_PATH}/${FLAKE_NAME}"
 {
   description = "A declarative system installation";
 
@@ -103,7 +119,7 @@ cat << EOF > ~/.config/nixpkgs/flake.nix
               pkgs = nixpkgs.legacyPackages.\${system}; # here we need just legacy packages
               unstablePkgs = import unstable { inherit system; config.allowUnfree = true; };
             in pkgs.buildEnv {
-              name = "myPackages";
+              name = "myPackageCollection";
               paths = with pkgs; [
 ${templated_insert}
               ];
@@ -114,6 +130,19 @@ ${templated_insert}
     }; # outputs
 }
 EOF
+}
+
+lock_flake() {
+  nix flake lock "${FLAKE_PATH}"
+}
+
+flake_lock_exists() {
+  if [ -r "${FLAKE_PATH}/flake.lock" ]; then
+    return 0
+  else
+    return 1
+  fi
+}
 
 install_nix_packages()
 {
@@ -122,13 +151,48 @@ install_nix_packages()
   if [ "${nix_packages[*]}" ]; then
     # Updated to process new nix profile format, proper processing probably needs JQ
     # But JQ would be another dependency and this is good enough for now
-    if nix profile list --json | grep -i "\"attrPath\":\"${package_name}\""; then
+    # Okay we are installing jq to do stuff now but I don't feel like reworking this
+    if nix profile list --json | grep -qi "\"attrPath\":\"${package_name}\""; then
       echo "Removing previous version of profile"
-      nix profile remove "${package_name}"
+      store_path=$(nix profile list --json | nix-shell --quiet -p jq --run 'jq -r .elements.myPackageCollection.storePaths[0]')
+      nix profile remove "${store_path}"
     fi
     echo "Installing profile"
-    nix profile install "${HOME}/.config/nixpkgs/flake.nix#myPackageCollection"
+    nix profile install "${FLAKE_PATH}/#myPackageCollection"
   fi
 }
 
+get_store_path() {
+  # This is only called post successful installation so jq is available
+  nix profile list --json | jq -r .elements.myPackageCollection.storePaths[0]
+}
+
+export_archive() {
+  store_path="${1}"
+  mkdir -p "$(dirname ${ARCHIVE_PATH})"
+  nix-store --export $(nix-store --query --requisites ${store_path}) > "${ARCHIVE_PATH}"
+}
+
+import_archive() {
+  nix-store --import < "${ARCHIVE_PATH}" > /dev/null
+}
+
+archive_exists() {
+  if [ -r "${ARCHIVE_PATH}" ]; then
+    return 0
+  else
+    return 1
+  fi
+}
+
+if archive_exists; then
+  import_archive
+fi
+generate_flake
+if ! flake_lock_exists; then
+  lock_flake
+fi
 install_nix_packages
+if ! archive_exists; then
+  export_archive "$(get_store_path)"
+fi

installers/install-nix.sh

@@ -7,8 +7,12 @@ set -e
 set -x
 
 # Abort installation if Nix is already installed
-if [ -d /nix ]; then
+if [ -d /nix/store ]; then
   exit 0
+elif [ -d /nix ] && ! [ -O /nix ]; then
+  # If we don't own /nix use sudo to chown it.
+  # If we can't sudo then nothing we do here will work so we just let this fail
+  sudo chown $UID /nix
 fi
 
 # Workaround to make a single user install work as root
@@ -18,7 +22,7 @@ if [ "${USER:-}" == "root" ] || [ "${UID:-}" == "0" ]; then
 fi
 
 # Download the Nix installer and it's signature from NixOS.org
-curl -so install-nix https://releases.nixos.org/nix/nix-2.18.7/install
+curl -so install-nix https://releases.nixos.org/nix/nix-2.24.12/install
 
 # Run the installer
 sh ./install-nix
@@ -28,6 +32,8 @@ cat << EOF > ~/.bashrc
 # Source nix if it's installed
 if [ -r ~/.nix-profile/etc/profile.d/nix.sh ]; then
   . ~/.nix-profile/etc/profile.d/nix.sh
+elif [ -r "${XDG_STATE_HOME:-$HOME/.local/state}/nix/profile/etc/profile.d/nix.sh" ]; then
+	. "${XDG_STATE_HOME:-$HOME/.local/state}/nix/profile/etc/profile.d/nix.sh"
 fi
 EOF
 
@@ -40,6 +46,7 @@ NIX_CONF_FILE=${NIX_CONF_DIR}/nix.conf
 mkdir -p ${NIX_CONF_DIR}
 cat <<EOF > ${NIX_CONF_FILE}
 experimental-features = flakes nix-command
+use-xdg-base-directories = true
 EOF
 # Conditionally add a link to system certificates for nix
 if [ -f /etc/ssl/certs/ca-certificates.crt ]; then

screen/.config/screen/screenrc

@@ -1,3 +1,5 @@
+# Defaults to using bash as the shell
+defshell $SHELL
 # Extend scrollback buffer
 defscrollback 100000
 # Disable startup message

sh/.profile

@@ -50,4 +50,6 @@ export HISTFILESIZE=10000
 
 if [ -r "$HOME/.nix-profile/etc/profile.d/nix.sh" ]; then
 	. "$HOME/.nix-profile/etc/profile.d/nix.sh"
+elif [ -r "${XDG_STATE_HOME:-$HOME/.local/state}/nix/profile/etc/profile.d/nix.sh" ]; then
+	. "${XDG_STATE_HOME:-$HOME/.local/state}/nix/profile/etc/profile.d/nix.sh"
 fi

xdg/.config/xdg/env

@@ -0,0 +1,14 @@
+export XDG_DATA_HOME="${HOME}/.local/share"
+export XDG_CONFIG_HOME="${HOME}/.config"
+export XDG_STATE_HOME="${HOME}/.local/state"
+export XDG_CACHE_HOME="${HOME}/.cache"
+
+# Set environment variables to force programs to respect XDG that do not by default
+export SCREENRC="${XDG_CONFIG_HOME}/screen/screenrc"
+export GNUPGHOME="$XDG_DATA_HOME"/gnupg
+export MYSQL_HISTFILE="$XDG_DATA_HOME"/mysql_history
+export INPUTRC="$XDG_CONFIG_HOME"/readline/inputrc
+export IRBRC="$XDG_CONFIG_HOME/irb/irbrc"
+
+export KUBECONFIG="${XDG_CONFIG_HOME}/kube/config"
+mkdir -p "$(dirname ${KUBECONFIG})"

xdg/.local/bin/enable-xdg-legacy-support

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# For older systems that don't support newer versions of programs that may
+# support XDG config paths natively we have to symlink to the new paths from 
+# the expected locations of the older paths.
+
+# This can also be used to support migrations from systems before we started XDGifying
+
+ln -s "${XDG_CONFIG_HOME}/screen/screenrc" "${HOME}/.screenrc"
+ln -s "${XDG_DATA_HOME}/.gnupg" "${HOME}/.gnupg"
+ln -s "${XDG_DATA_HOME}/mysql_history" "${HOME}/.mysql_history"
+ln -s "${XDG_CONFIG_HOME}/readline/inputrc" "${HOME}/.inputrc"
+ln -s "${XDG_CONFIG_HOME}/irb/irbc" "${HOME}/.irbrc"
+ln -s "${XDG_CONFIG_HOME}/kube/config" "${HOME}/.kubeconfig"