@sebastienrousseau/dotfiles 0.2.481 → 0.2.500

package/dot_config/zsh/rc.d/20-zinit.zsh

@@ -0,0 +1,65 @@
+# Zinit plugin manager
+[[ "${DOTFILES_FAST:-0}" == "1" ]] && return 0
+[[ "${DOTFILES_ULTRA_FAST:-0}" == "1" ]] && return 0
+
+ZINIT_HOME="${XDG_DATA_HOME:-${HOME}/.local/share}/zinit/zinit.git"
+
+_dotfiles_zinit_git_policy() {
+  [[ -d "$ZINIT_HOME/.git" ]] || return 0
+  command git -C "$ZINIT_HOME" config --local merge.verifySignatures false >/dev/null 2>&1 || true
+}
+
+_dotfiles_zinit_init() {
+  if [[ ! -f "$ZINIT_HOME/zinit.zsh" ]]; then
+     print -P "%F{33}▓▒░ %F{220}Installing %F{33}ZDHARMA-CONTINUUM%F{220} Initiative Plugin Manager (%F{33}zdharma-continuum/zinit%F{220})…%f"
+     command mkdir -p "$(dirname "$ZINIT_HOME")" && command chmod g-rwX "$(dirname "$ZINIT_HOME")"
+     command git clone https://github.com/zdharma-continuum/zinit "$ZINIT_HOME" && \
+        print -P "%F{33}▓▒░ %F{34}Installation successful.%f%b" || \
+        print -P "%F{160}▓▒░ The clone has failed.%f%b"
+  fi
+
+  _dotfiles_zinit_git_policy
+
+  source "$ZINIT_HOME/zinit.zsh"
+  autoload -Uz _zinit
+  (( ${+_comps} )) && _comps[zinit]=_zinit
+
+  # Load Zsh Plugins (Turbo mode - deferred loading, pinned to stable releases)
+  zinit ice wait lucid ver"0.8.0"
+  zinit light zsh-users/zsh-syntax-highlighting
+  zinit ice wait lucid ver"v0.7.1" atload"_zsh_autosuggest_start"
+  zinit light zsh-users/zsh-autosuggestions
+  zinit ice wait lucid ver"0.35.0" blockf atpull"zinit creinstall -q ."
+  zinit light zsh-users/zsh-completions
+}
+
+# Defer Zinit init for faster first prompt (opt-out by setting DOTFILES_DEFER_ZINIT=0)
+: ${DOTFILES_DEFER_ZINIT:=1}
+: ${DOTFILES_DEFER_ZINIT_MODE:=preexec}
+
+if [[ "${DOTFILES_DEFER_ZINIT}" == "1" ]]; then
+  # Stub to auto-load zinit on first call (e.g. by topgrade)
+  zinit() {
+    unfunction zinit
+    _dotfiles_zinit_init
+    zinit "$@"
+  }
+
+  _dotfiles_zinit_deferred() {
+    if [[ "${DOTFILES_DEFER_ZINIT_MODE}" == "preexec" ]]; then
+      _dotfiles_del_preexec _dotfiles_zinit_deferred
+    else
+      _dotfiles_del_precmd _dotfiles_zinit_deferred
+    fi
+    # If zinit was already loaded via the stub, this is a no-op
+    (( ${+functions[zinit]} )) && [[ "$(whence -w zinit)" == "zinit: function" ]] || _dotfiles_zinit_init
+  }
+
+  if [[ "${DOTFILES_DEFER_ZINIT_MODE}" == "preexec" ]]; then
+    _dotfiles_add_preexec _dotfiles_zinit_deferred
+  else
+    _dotfiles_add_precmd _dotfiles_zinit_deferred
+  fi
+else
+  _dotfiles_zinit_init
+fi

package/dot_config/zsh/rc.d/30-options.zsh.tmpl

@@ -1,7 +1,4 @@
 # Zsh history and options
-# Set secure default umask (077 = owner only, 022 = standard)
-umask 022
-
 HISTFILE="${HOME}/.zsh_history"
 HISTSIZE=10000
 SAVEHIST=10000
@@ -14,6 +11,8 @@ setopt HIST_REDUCE_BLANKS
 setopt EXTENDED_HISTORY
 setopt SHARE_HISTORY
 setopt APPEND_HISTORY
+setopt HIST_SAVE_BY_COPY
+setopt INTERACTIVE_COMMENTS
 
 setopt AUTO_CD
 setopt AUTO_PUSHD
@@ -42,12 +41,12 @@ fi
 if [[ -z ${fpath[(r)${ZSH_COMPLETIONS_DIR}]} ]]; then
   fpath=("${ZSH_COMPLETIONS_DIR}" "${fpath[@]}")
 fi
-if [[ -f "${HOME}/.local/bin/executable_dot_completion" ]]; then
-  fpath=("${HOME}/.local/bin" "${fpath[@]}")
-fi
+{{- /* Node.js version manager: configured via .chezmoidata.toml tools.node_manager */ -}}
+{{- $node_mgr := default "mise" .tools.node_manager -}}
+{{- if eq $node_mgr "fnm" }}
 # fnm (Fast Node Manager)
 # Initialize early so Node + corepack use the expected version.
-if command -v fnm >/dev/null; then
+if [[ "${DOTFILES_FAST:-0}" != "1" ]] && [[ "${DOTFILES_ULTRA_FAST:-0}" != "1" ]] && command -v fnm >/dev/null; then
   if [[ ! -f "${ZSH_COMPLETIONS_DIR}/_fnm" ]]; then
     command fnm completions --shell zsh >| "${ZSH_COMPLETIONS_DIR}/_fnm"
   fi
@@ -62,11 +61,29 @@ if command -v fnm >/dev/null; then
   pnpm() { _lazy_load_fnm; command pnpm "$@"; }
   pnpx() { _lazy_load_fnm; command pnpx "$@"; }
 fi
+{{- end }}
+{{- /* When node_manager = "mise", Node.js is handled by mise activate in dot_zshrc.tmpl */}}
 
+# Completions: pre-warmed by `dot prewarm`, generated on-demand as fallback
+if [[ "${DOTFILES_FAST:-0}" != "1" ]] && [[ "${DOTFILES_ULTRA_FAST:-0}" != "1" ]]; then
+  [[ ! -f "${ZSH_COMPLETIONS_DIR}/_gh" ]] && command -v gh >/dev/null &&
+    command gh completion -s zsh >| "${ZSH_COMPLETIONS_DIR}/_gh"
+  [[ ! -f "${ZSH_COMPLETIONS_DIR}/_just" ]] && command -v just >/dev/null &&
+    command just --completions zsh >| "${ZSH_COMPLETIONS_DIR}/_just"
+  [[ ! -f "${ZSH_COMPLETIONS_DIR}/_chezmoi" ]] && command -v chezmoi >/dev/null &&
+    command chezmoi completion zsh >| "${ZSH_COMPLETIONS_DIR}/_chezmoi"
+  [[ ! -f "${ZSH_COMPLETIONS_DIR}/_kubectl" ]] && command -v kubectl >/dev/null &&
+    command kubectl completion zsh >| "${ZSH_COMPLETIONS_DIR}/_kubectl"
+  [[ ! -f "${ZSH_COMPLETIONS_DIR}/_atuin" ]] && command -v atuin >/dev/null &&
+    command atuin gen-completions --shell zsh --out-dir "${ZSH_COMPLETIONS_DIR}" 2>/dev/null
+  [[ ! -f "${ZSH_COMPLETIONS_DIR}/_mise" ]] && command -v mise >/dev/null &&
+    command mise completions zsh >| "${ZSH_COMPLETIONS_DIR}/_mise" 2>/dev/null
+fi
 
-# Lazy-load NVM (if fnm is not installed)
-if ! command -v fnm >/dev/null; then
-  export NVM_DIR="${NVM_DIR:-$HOME/.nvm}"
+{{- if eq $node_mgr "nvm" }}
+# Lazy-load NVM
+export NVM_DIR="${NVM_DIR:-$HOME/.nvm}"
+if [[ "${DOTFILES_FAST:-0}" != "1" ]] && [[ "${DOTFILES_ULTRA_FAST:-0}" != "1" ]]; then
   if [[ -s "${NVM_DIR}/nvm.sh" ]]; then
     _lazy_load_nvm() {
       unfunction node npm npx nvm _lazy_load_nvm 2>/dev/null
@@ -83,10 +100,11 @@ if ! command -v fnm >/dev/null; then
     npx() { _lazy_load_nvm; command npx "$@"; }
   fi
 fi
+{{- end }}
 
 # Lazy-load SDKMAN
 export SDKMAN_DIR="${SDKMAN_DIR:-$HOME/.sdkman}"
-if [[ -s "${SDKMAN_DIR}/bin/sdkman-init.sh" && -z "${functions[sdk]:-}" ]]; then
+if [[ "${DOTFILES_FAST:-0}" != "1" ]] && [[ "${DOTFILES_ULTRA_FAST:-0}" != "1" ]] && [[ -s "${SDKMAN_DIR}/bin/sdkman-init.sh" && -z "${functions[sdk]:-}" ]]; then
   _lazy_load_sdkman() {
     unfunction sdk _lazy_load_sdkman 2>/dev/null
     # shellcheck disable=SC1090
@@ -94,30 +112,83 @@ if [[ -s "${SDKMAN_DIR}/bin/sdkman-init.sh" && -z "${functions[sdk]:-}" ]]; then
   }
   sdk() { _lazy_load_sdkman; sdk "$@"; }
 fi
-# Defer compinit to first prompt — saves ~37ms off startup
-autoload -Uz compinit add-zsh-hook
-_deferred_compinit() {
-  add-zsh-hook -d precmd _deferred_compinit
-  if [[ -n ${ZDOTDIR}/.zcompdump(#qN.mh+24) ]]; then
-    compinit
+# Defer compinit to first prompt — opt-in for max performance
+: ${DOTFILES_ENABLE_COMPINIT:=0}
+: ${DOTFILES_DEFER_COMPINIT:=1}
+if [[ "${DOTFILES_ENABLE_COMPINIT}" == "1" ]] && [[ "${DOTFILES_FAST:-0}" != "1" ]] && [[ "${DOTFILES_ULTRA_FAST:-0}" != "1" ]]; then
+  autoload -Uz compinit
+  _deferred_compinit() {
+    if [[ "${DOTFILES_DEFER_COMPINIT}" == "1" ]]; then
+      _dotfiles_del_preexec _deferred_compinit
+    else
+      _dotfiles_del_precmd _deferred_compinit
+    fi
+    if [[ -n ${ZDOTDIR}/.zcompdump(#qN.mh+24) ]]; then
+      compinit
+    else
+      compinit -C
+    fi
+    # Compile zcompdump to bytecode in background for faster subsequent loads
+    { [[ ! -f "${ZDOTDIR}/.zcompdump.zwc" || "${ZDOTDIR}/.zcompdump" -nt "${ZDOTDIR}/.zcompdump.zwc" ]] && zcompile "${ZDOTDIR}/.zcompdump" } &!
+  }
+  if [[ "${DOTFILES_DEFER_COMPINIT}" == "1" ]]; then
+    _dotfiles_add_preexec _deferred_compinit
   else
-    compinit -C
+    _dotfiles_add_precmd _deferred_compinit
   fi
-  # Compile zcompdump to bytecode in background for faster subsequent loads
-  { [[ ! -f "${ZDOTDIR}/.zcompdump.zwc" || "${ZDOTDIR}/.zcompdump" -nt "${ZDOTDIR}/.zcompdump.zwc" ]] && zcompile "${ZDOTDIR}/.zcompdump" } &!
-}
-add-zsh-hook precmd _deferred_compinit
 
-zstyle ':completion:*' menu select
-zstyle ':completion:*' matcher-list 'm:{a-zA-Z}={A-Za-z}'
-zstyle ':completion:*' list-colors "${(s.:.)LS_COLORS}"
-zstyle ':completion:*' special-dirs true
-zstyle ':completion:*' verbose yes
+  zstyle ':completion:*' menu select
+  zstyle ':completion:*' matcher-list 'm:{a-zA-Z}={A-Za-z}'
+  zstyle ':completion:*' list-colors "${(s.:.)LS_COLORS}"
+  zstyle ':completion:*' special-dirs true
+  zstyle ':completion:*' verbose yes
+fi
 
-autoload -Uz colors && colors
+# Colors (opt-in; enables $fg/$bg variables)
+: ${DOTFILES_ENABLE_COLORS:=0}
+if [[ "${DOTFILES_ENABLE_COLORS}" == "1" ]]; then
+  : ${DOTFILES_DEFER_COLORS:=1}
+  if [[ "${DOTFILES_DEFER_COLORS}" == "1" ]]; then
+    _dotfiles_colors_zle_init() {
+      zle -D zle-line-init
+      # Skip when running -c (no prompt)
+      [[ -n "${ZSH_EXECUTION_STRING:-}" ]] && return 0
+      autoload -Uz colors && colors
+    }
+    zle -N zle-line-init _dotfiles_colors_zle_init
+  else
+    autoload -Uz colors && colors
+  fi
+fi
 unsetopt correct_all
 
+# fzf integration
+if [[ "${DOTFILES_FAST:-0}" != "1" ]] && [[ "${DOTFILES_ULTRA_FAST:-0}" != "1" ]]; then
+  if [[ -f "${HOME}/.config/fzf/fzf.zsh" ]]; then
+    source "${HOME}/.config/fzf/fzf.zsh"
+  elif [[ -f "${HOME}/.fzf.zsh" ]]; then
+    source "${HOME}/.fzf.zsh"
+  fi
+fi
+
+# Explicit fzf bindings (fallback if not already set by fzf)
+if [[ "${DOTFILES_FAST:-0}" != "1" ]] && [[ "${DOTFILES_ULTRA_FAST:-0}" != "1" ]] && command -v fzf >/dev/null; then
+  bindkey -M viins -s '^T' 'fzf^M'
+  bindkey -M viins -s '^R' 'fzf^M'
+fi
+
 # direnv (directory environments)
-if command -v direnv >/dev/null; then
-  _cached_eval direnv-hook direnv hook zsh
+if [[ "${DOTFILES_FAST:-0}" != "1" ]] && [[ "${DOTFILES_ULTRA_FAST:-0}" != "1" ]] && command -v direnv >/dev/null; then
+  # Custom quiet hook: suppress direnv status chatter on every prompt/chdir.
+  _dotfiles_direnv_hook() {
+    # Fast path: skip direnv in dotfiles unless flake mode is explicitly enabled.
+    if [[ "${PWD:A}" == "${HOME}/.dotfiles"* ]] && [[ "${DOTFILES_USE_FLAKE:-0}" != "1" ]] && [[ "${CI:-0}" != "1" ]]; then
+      return 0
+    fi
+    trap -- '' SIGINT
+    eval "$(direnv export zsh 2>/dev/null)"
+    trap - SIGINT
+  }
+  autoload -Uz add-zsh-hook
+  add-zsh-hook chpwd _dotfiles_direnv_hook
 fi

package/dot_config/zsh/rc.d/99-alias-wrapper.zsh

@@ -0,0 +1,32 @@
+# Smart Alias Function (High-Fidelity TUI)
+alias_wrapper() {
+  if [[ $# -eq 0 ]]; then
+    # Find gum cmd dynamically if needed
+    local gum_cmd
+    gum_cmd=$(command -v gum 2>/dev/null || (command -v mise >/dev/null && mise which "aqua:charmbracelet/gum" 2>/dev/null))
+
+    if [[ -n "$gum_cmd" ]]; then
+      # Use printf to get a literal tab
+      local tab=$'\t'
+
+      # Extract aliases, format as Tab separated, ensure only 2 columns, and pipe to gum table
+      builtin alias | sed -E "s/^([^=]+)='?([^']*)'?$/\1${tab}\2/" |
+        while IFS=$tab read -r alias_name cmd_body; do
+          if [[ -n "$alias_name" && -n "$cmd_body" ]]; then
+            # Ensure no extra tabs in body and exactly one tab total
+            local clean_cmd="${cmd_body//$tab/ }"
+            printf "%s\t%s\n" "$alias_name" "$clean_cmd"
+          fi
+        done |
+        "$gum_cmd" table --separator "${tab}" --print --columns "Alias,Command" --widths 15,60 \
+          --border rounded --border.foreground 212 --header.foreground 212
+    elif command -v bat >/dev/null 2>&1; then
+      builtin alias | bat -l sh --style=plain
+    else
+      builtin alias
+    fi
+  else
+    builtin alias "$@"
+  fi
+}
+alias alias=alias_wrapper

package/dot_local/bin/executable_ai-update

@@ -0,0 +1,195 @@
+#!/usr/bin/env bash
+## AI Update — Dotfiles AI workflow updater for cross-platform environments.
+##
+## Updates all AI-related tools and runtimes including mise, npm globals,
+## pipx tools, Ollama, and LM Studio. Auto-detects installation methods.
+##
+## # Requirements
+## - curl: For downloading updates
+## - sudo: For system-level updates (Linux)
+## - zstd: For Ollama archive extraction (Linux)
+##
+## # Usage
+## ai-update                   # Update all AI tools
+##
+## # Platform Notes
+## - macOS: Updates via Homebrew where applicable
+## - Linux: Updates via APT, manual binaries, or pipx
+## - WSL: Full Linux support
+
+set -euo pipefail
+
+# --- Configuration & Theme ---
+CYAN=''
+PURPLE=''
+GREEN=''
+YELLOW=''
+RED=''
+GRAY=''
+NC=''
+BOLD=''
+
+# --- UI Components ---
+log_header() {
+  printf '%b\n' "
+${BOLD}${PURPLE}Updating AI Environment${NC}"
+  printf '%b\n' "${GRAY}-----------------------------------------------------------${NC}"
+}
+
+step() { echo -ne "${CYAN}->${NC} ${BOLD}$1...${NC} "; }
+ok() { printf '%b\n' "${GREEN}done${NC}"; }
+skip() { printf '%b\n' "${YELLOW}skipped${NC} ${GRAY}($1)${NC}"; }
+err() { printf '%b\n' "${RED}error${NC}
+   ${RED}$1${NC}"; }
+
+# --- Initialization ---
+log_header
+
+# Pre-auth sudo to avoid mid-script interruptions
+if [[ "$(uname -s)" == "Linux" ]]; then
+  step "Authenticating sudo"
+  if sudo -v; then ok; else
+    err "Sudo required for system updates"
+    exit 1
+  fi
+fi
+
+# --- 1. mise Core (Multi-Method Detection) ---
+if command -v mise >/dev/null 2>&1; then
+  step "Checking mise core"
+  if [[ "$(uname -s)" == "Linux" ]] && command -v pacman >/dev/null 2>&1 && pacman -Qs mise >/dev/null 2>&1; then
+    # Handle Arch/CachyOS AUR/Official package
+    sudo pacman -S --noconfirm mise >/dev/null 2>&1 || true
+    ok
+  elif [[ "$(uname -s)" == "Linux" ]] && command -v dpkg >/dev/null 2>&1 && dpkg -s mise >/dev/null 2>&1; then
+    # Handle your ZorinOS APT installation
+    sudo apt update -y -o Dir::Etc::sourcelist="sources.list.d/jdx.list" >/dev/null 2>&1 || true
+    sudo apt install --only-upgrade -y mise >/dev/null 2>&1
+    ok
+  elif command -v brew >/dev/null 2>&1 && brew list mise >/dev/null 2>&1; then
+    # Handle macOS/Linux Brew installation
+    brew upgrade mise >/dev/null 2>&1
+    ok
+  else
+    # Fallback for standalone binary installation
+    if mise self-update -y >/dev/null 2>&1; then ok; else skip "manual update needed"; fi
+  fi
+else
+  skip "mise not found"
+fi
+
+# --- 2. System & Language Packages ---
+
+# Homebrew
+if command -v brew >/dev/null 2>&1; then
+  step "Homebrew packages"
+  brew update >/dev/null && brew upgrade --quiet >/dev/null
+  ok
+fi
+
+# NPM Globals (via mise)
+if command -v mise >/dev/null 2>&1; then
+  step "NPM (claude, gemini, etc)"
+  mise exec node -- npm update -g --audit=false >/dev/null 2>&1
+  ok
+
+  step "Kiro CLI"
+  if [[ "$(uname -s)" == "Darwin" ]]; then
+    skip "managed by Kiro app bundle via mise plugin"
+  elif mise upgrade kiro-cli >/dev/null 2>&1; then
+    ok
+  else
+    skip "mise plugin update unavailable"
+  fi
+fi
+
+# Pipx (aider, sgpt)
+if command -v pipx >/dev/null 2>&1; then
+  step "Pipx tools"
+  pipx upgrade-all >/dev/null 2>&1
+  ok
+fi
+
+# --- 3. Specialized AI Binaries ---
+
+# Ollama (Verified Manual Override)
+if command -v ollama >/dev/null 2>&1; then
+  if [[ "$(uname -s)" == "Linux" ]]; then
+    step "Ollama (Manual Deployment)"
+    arch="$(uname -m)"
+    case "$arch" in
+      x86_64 | amd64) ollama_arch="amd64" ;;
+      aarch64 | arm64) ollama_arch="arm64" ;;
+      *) ollama_arch="" ;;
+    esac
+
+    if [[ -n "$ollama_arch" ]]; then
+      # Check for updates by comparing local vs remote version
+      current_ver="$(ollama --version | awk '{print $NF}' | tr -d '[:space:]')"
+      # This is a bit slow but safer than downloading every time
+      latest_ver="$(curl -fsSL -I https://github.com/ollama/ollama/releases/latest | grep -i location | sed 's/.*\/v//;s/
+
+      if [[ "$current_ver" == "$latest_ver" ]]; then
+        skip "already up to date"
+      else
+        tmp_tar="$(umask 077 && mktemp)"
+        trap 'rm -f "$tmp_tar"' EXIT
+        tar_url="https://ollama.com/download/ollama-linux-${ollama_arch}.tar.zst"
+
+        if curl -fsSL --retry 2 "$tar_url" -o "$tmp_tar" && zstd -t "$tmp_tar" >/dev/null 2>&1; then
+          # Stop service safely
+          if command -v systemctl >/dev/null 2>&1; then
+            sudo systemctl stop ollama 2>/dev/null || true
+          fi
+
+          # Extract
+          zstd -dc "$tmp_tar" | sudo tar -x -C /usr/local >/dev/null
+
+          # Ensure permissions
+          sudo chmod +x /usr/local/bin/ollama
+
+          # Restart if systemd exists
+          if command -v systemctl >/dev/null 2>&1; then
+            sudo systemctl daemon-reload
+            sudo systemctl start ollama 2>/dev/null || true
+          fi
+          ok
+        else
+          err "Integrity check failed"
+        fi
+      fi
+    else
+      skip "unsupported arch"
+    fi
+  else
+    # macOS users typically use the .app or Brew
+    step "Ollama (macOS)"
+    if command -v brew >/dev/null 2>&1 && brew upgrade ollama --cask >/dev/null 2>&1; then
+      ok
+    else
+      skip "Update via App"
+    fi
+  fi
+fi
+
+# LM Studio Runtime
+if command -v lms >/dev/null 2>&1; then
+  step "LM Studio Runtime"
+  lms runtime update >/dev/null 2>&1
+  ok
+fi
+
+# --- 4. Final Summary ---
+printf '%b\n' "${GRAY}-----------------------------------------------------------${NC}"
+printf '%b\n' "${GREEN}${BOLD}Dotfiles Environment Ready${NC}"
+
+# Version Report
+printf '%b\n' "
+${BOLD}System Version Status:${NC}"
+printf "%b%-12s%b %s\n" "${GRAY}" "Node:" "${NC}" "$(node -v 2>/dev/null || echo 'N/A')"
+printf "%b%-12s%b %s\n" "${GRAY}" "Kiro:" "${NC}" "$(kiro-cli --version 2>/dev/null | awk '{print $NF}' || echo 'N/A')"
+printf "%b%-12s%b %s\n" "${GRAY}" "Ollama:" "${NC}" "$(ollama --version 2>/dev/null | awk '{print $NF}' || echo 'N/A')"
+printf "%b%-12s%b %s\n" "${GRAY}" "Pipx:" "${NC}" "$(pipx --version 2>/dev/null || echo 'N/A')"
+printf "%b%-12s%b %s\n" "${GRAY}" "Mise:" "${NC}" "$(mise --version 2>/dev/null | awk '{print $1}' || echo 'N/A')"
+
+trap - EXIT