@sebastienrousseau/dotfiles 0.2.468 → 0.2.481

package/scripts/diagnostics/benchmark.sh

@@ -0,0 +1,201 @@
+#!/usr/bin/env bash
+# Enhanced Shell Benchmark with Per-Component Profiling
+# Usage: dot benchmark [--detailed|--profile|--compare]
+
+set -euo pipefail
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+BENCHMARK_DIR="${XDG_DATA_HOME:-$HOME/.local/share}/dotfiles/benchmarks"
+mkdir -p "$BENCHMARK_DIR"
+
+# Parse arguments
+DETAILED=false
+PROFILE=false
+COMPARE=false
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --detailed | -d)
+      DETAILED=true
+      shift
+      ;;
+    --profile | -p)
+      PROFILE=true
+      shift
+      ;;
+    --compare | -c)
+      COMPARE=true
+      shift
+      ;;
+    *) shift ;;
+  esac
+done
+
+print_header() {
+  echo -e "\n${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+  echo -e "${CYAN}  Shell Performance Benchmark${NC}"
+  echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}\n"
+}
+
+# Basic timing function
+time_command() {
+  local start end
+  start=$(python3 -c 'import time; print(int(time.time() * 1000))')
+  eval "$1" >/dev/null 2>&1
+  end=$(python3 -c 'import time; print(int(time.time() * 1000))')
+  echo $((end - start))
+}
+
+# Per-component profiling using zprof
+run_zsh_profile() {
+  echo -e "${BLUE}Running Zsh profiler (zprof)...${NC}\n"
+
+  zsh -c '
+    zmodload zsh/zprof
+    source ~/.zshenv 2>/dev/null
+    source ~/.config/zsh/.zshrc 2>/dev/null
+    zprof
+  ' 2>/dev/null | head -30
+}
+
+# Benchmark individual components
+benchmark_components() {
+  echo -e "${BLUE}Per-Component Timing:${NC}\n"
+  printf "%-35s %8s\n" "Component" "Time (ms)"
+  echo "───────────────────────────────────────────────"
+
+  # zshenv (bootloader)
+  local zshenv_time
+  zshenv_time=$(time_command "zsh -c 'source ~/.zshenv 2>/dev/null; exit'")
+  printf "%-35s %8s\n" "zshenv (bootloader)" "${zshenv_time}ms"
+
+  # Core shell options
+  local options_time
+  options_time=$(time_command "zsh -c 'source ~/.config/zsh/rc.d/30-options.zsh 2>/dev/null; exit'" 2>/dev/null || echo "N/A")
+  printf "%-35s %8s\n" "rc.d/30-options.zsh" "${options_time}ms"
+
+  # Zinit plugins
+  local zinit_time
+  zinit_time=$(time_command "zsh -c 'source ~/.config/zsh/rc.d/20-zinit.zsh 2>/dev/null; exit'" 2>/dev/null || echo "N/A")
+  printf "%-35s %8s\n" "rc.d/20-zinit.zsh (plugins)" "${zinit_time}ms"
+
+  # Tool initializations
+  for tool in starship atuin zoxide fzf direnv; do
+    if command -v "$tool" >/dev/null 2>&1; then
+      local tool_time
+      case "$tool" in
+        starship) tool_time=$(time_command "starship init zsh >/dev/null") ;;
+        atuin) tool_time=$(time_command "atuin init zsh >/dev/null") ;;
+        zoxide) tool_time=$(time_command "zoxide init zsh >/dev/null") ;;
+        fzf) tool_time=$(time_command "true") ;; # FZF sourced from file
+        direnv) tool_time=$(time_command "direnv hook zsh >/dev/null") ;;
+      esac
+      printf "%-35s %8s\n" "$tool init" "${tool_time}ms"
+    fi
+  done
+
+  echo "───────────────────────────────────────────────"
+}
+
+# Run hyperfine benchmark
+run_hyperfine() {
+  if ! command -v hyperfine >/dev/null 2>&1; then
+    echo -e "${YELLOW}hyperfine not installed. Using basic timing.${NC}"
+    local times=()
+    for _ in {1..5}; do
+      times+=("$(time_command "zsh -i -c exit")")
+    done
+    local sum=0
+    for t in "${times[@]}"; do sum=$((sum + t)); done
+    echo -e "\n${GREEN}Average startup time: $((sum / 5))ms${NC}"
+    return
+  fi
+
+  echo -e "\n${BLUE}Running hyperfine benchmark (10 runs, 3 warmup)...${NC}\n"
+  hyperfine --warmup 3 --runs 10 --shell=none \
+    --export-json "$BENCHMARK_DIR/latest.json" \
+    'zsh -i -c exit'
+
+  # Extract and display results
+  if [[ -f "$BENCHMARK_DIR/latest.json" ]]; then
+    local mean_ms
+    mean_ms=$(jq '.results[0].mean * 1000 | floor' "$BENCHMARK_DIR/latest.json")
+    local min_ms
+    min_ms=$(jq '.results[0].min * 1000 | floor' "$BENCHMARK_DIR/latest.json")
+    local max_ms
+    max_ms=$(jq '.results[0].max * 1000 | floor' "$BENCHMARK_DIR/latest.json")
+
+    echo -e "\n${GREEN}Results:${NC}"
+    echo "  Mean: ${mean_ms}ms"
+    echo "  Min:  ${min_ms}ms"
+    echo "  Max:  ${max_ms}ms"
+
+    # Performance rating
+    if [[ $mean_ms -lt 100 ]]; then
+      echo -e "\n${GREEN}⚡ Excellent (<100ms)${NC}"
+    elif [[ $mean_ms -lt 200 ]]; then
+      echo -e "\n${GREEN}✓ Good (<200ms)${NC}"
+    elif [[ $mean_ms -lt 500 ]]; then
+      echo -e "\n${YELLOW}⚠ Acceptable (<500ms)${NC}"
+    else
+      echo -e "\n${RED}✗ Slow (>500ms) - optimization needed${NC}"
+    fi
+
+    # Save with timestamp for history
+    cp "$BENCHMARK_DIR/latest.json" "$BENCHMARK_DIR/$(date +%Y%m%d_%H%M%S).json"
+  fi
+}
+
+# Compare with previous benchmarks
+compare_benchmarks() {
+  echo -e "${BLUE}Benchmark History:${NC}\n"
+
+  local files
+  files=$(find "$BENCHMARK_DIR" -name "*.json" -type f | sort -r | head -10)
+
+  if [[ -z "$files" ]]; then
+    echo "No benchmark history found."
+    return
+  fi
+
+  printf "%-20s %10s %10s %10s\n" "Date" "Mean" "Min" "Max"
+  echo "────────────────────────────────────────────────"
+
+  for f in $files; do
+    local basename
+    basename=$(basename "$f" .json)
+    if [[ "$basename" == "latest" ]]; then continue; fi
+
+    local mean min max
+    mean=$(jq '.results[0].mean * 1000 | floor' "$f" 2>/dev/null || echo "N/A")
+    min=$(jq '.results[0].min * 1000 | floor' "$f" 2>/dev/null || echo "N/A")
+    max=$(jq '.results[0].max * 1000 | floor' "$f" 2>/dev/null || echo "N/A")
+
+    printf "%-20s %10sms %10sms %10sms\n" "$basename" "$mean" "$min" "$max"
+  done
+}
+
+# Main execution
+print_header
+
+if $PROFILE; then
+  run_zsh_profile
+elif $COMPARE; then
+  compare_benchmarks
+elif $DETAILED; then
+  benchmark_components
+  echo ""
+  run_hyperfine
+else
+  run_hyperfine
+fi
+
+echo -e "\n${CYAN}Tip: Run 'dot benchmark --detailed' for per-component timing${NC}"
+echo -e "${CYAN}     Run 'dot benchmark --profile' for zprof analysis${NC}"
+echo -e "${CYAN}     Run 'dot benchmark --compare' for history${NC}\n"

package/scripts/diagnostics/doctor.sh

@@ -0,0 +1,115 @@
+#!/usr/bin/env bash
+# MIT License
+# Copyright (c) 2026 Sebastien Rousseau
+# See LICENSE file for details.
+
+# Script: doctor.sh
+# Description: Diagnostics tool for the dotfiles environment.
+# Checks dependencies, paths, and configuration integrity.
+
+set -euo pipefail
+
+# Colors (respect NO_COLOR: https://no-color.org)
+if [[ -z "${NO_COLOR:-}" ]] && [[ -t 1 ]]; then
+  GREEN='\033[0;32m'
+  RED='\033[0;31m'
+  YELLOW='\033[1;33m'
+  NC='\033[0m'
+else
+  GREEN='' RED='' YELLOW='' NC=''
+fi
+
+echo " Dotfiles Doctor - System Diagnostics"
+echo "-------------------------------------"
+
+Errors=0
+Warnings=0
+
+log_success() { echo -e "${GREEN} $1${NC}"; }
+log_fail() {
+  echo -e "${RED} $1${NC}"
+  Errors=$((Errors + 1))
+}
+log_warn() {
+  echo -e "${YELLOW}️  $1${NC}"
+  Warnings=$((Warnings + 1))
+}
+
+# 1. Check Dependencies
+echo "Checking Core Dependencies..."
+for cmd in git curl chezmoi starship rg bat; do
+  if command -v "$cmd" &>/dev/null; then
+    log_success "Found $cmd: $(command -v "$cmd")"
+  else
+    log_fail "Missing $cmd"
+  fi
+done
+
+echo -e "\nChecking Optional AI CLIs..."
+for cmd in claude gemini sgpt ollama opencode aider; do
+  if command -v "$cmd" &>/dev/null; then
+    log_success "Found $cmd: $(command -v "$cmd")"
+  else
+    log_warn "Missing $cmd (optional)"
+  fi
+done
+
+# 2. Check XDG Compliance
+echo -e "\nChecking Environment..."
+if [[ -z "${XDG_CONFIG_HOME:-}" ]]; then
+  log_warn "XDG_CONFIG_HOME is not set (Defaulting to ~/.config)"
+else
+  log_success "XDG_CONFIG_HOME=$XDG_CONFIG_HOME"
+fi
+
+if [[ -z "${PIPX_HOME:-}" ]]; then
+  log_warn "PIPX_HOME is not set (Check paths configuration)"
+else
+  log_success "PIPX_HOME=$PIPX_HOME"
+fi
+
+# 3. Check Chezmoi State
+echo -e "\nChecking Chezmoi State..."
+if chezmoi verify &>/dev/null; then
+  log_success "Chezmoi state is synchronized"
+else
+  log_fail "Chezmoi state has drifted (Run 'dot drift' to see details)"
+fi
+
+# 4. Check Critical Files
+echo -e "\nChecking Critical Files..."
+if [[ -f "$HOME/.zshrc" ]]; then
+  log_success "Found .zshrc"
+else
+  log_fail "Missing .zshrc"
+fi
+
+# 5. Check for Broken Symlinks (Ghost Links)
+echo -e "\nChecking for Broken Symlinks..."
+broken_links=0
+while IFS= read -r -d '' link; do
+  if [[ ! -e "$link" ]]; then
+    log_warn "Broken symlink: $link -> $(readlink "$link")"
+    broken_links=$((broken_links + 1))
+  fi
+done < <(find "$HOME" -maxdepth 3 -type l -print0 2>/dev/null)
+
+if [[ $broken_links -eq 0 ]]; then
+  log_success "No broken symlinks found"
+else
+  log_warn "$broken_links broken symlink(s) detected"
+fi
+
+# Summary
+echo -e "\n-------------------------------------"
+if [[ $Errors -eq 0 ]]; then
+  if [[ $Warnings -eq 0 ]]; then
+    echo -e "${GREEN}All systems healthy! ${NC}"
+  else
+    echo -e "${YELLOW}System healthy with $Warnings warnings.${NC}"
+  fi
+else
+  echo -e "${RED}Found $Errors errors and $Warnings warnings.${NC}"
+  echo "Run 'dot heal' to attempt auto-repair."
+  exit 1
+fi

package/scripts/diagnostics/drift-dashboard.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if ! command -v chezmoi >/dev/null; then
+  echo "chezmoi not found." >&2
+  exit 1
+fi
+
+echo "=== Dotfiles Drift Dashboard ==="
+
+status=$(chezmoi status || true)
+if [[ -z "$status" ]]; then
+  echo "Clean: no local drift detected."
+  exit 0
+fi
+
+printf "\nChanged files:\n"
+printf '%s\n' "$status"
+
+count=$(printf '%s\n' "$status" | wc -l | tr -d ' ')
+printf "\nTotal: %s\n" "$count"
+
+if [[ "${DOTFILES_DRIFT_SHOW_DIFF:-0}" = "1" ]]; then
+  printf "\n--- Diff (excluding scripts/install/tests) ---\n"
+  chezmoi diff --exclude scripts --exclude install --exclude tests || true
+fi

package/scripts/diagnostics/health.sh

@@ -0,0 +1,356 @@
+#!/usr/bin/env bash
+# Dotfiles Health Check Dashboard
+# Usage: dot health [--verbose|-v] [--json]
+
+set -euo pipefail
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+GRAY='\033[0;90m'
+NC='\033[0m'
+
+# Parse arguments (VERBOSE exported for potential use by sourced scripts)
+export VERBOSE=false
+JSON_OUTPUT=false
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --verbose | -v)
+      VERBOSE=true
+      shift
+      ;;
+    --json)
+      JSON_OUTPUT=true
+      shift
+      ;;
+    *) shift ;;
+  esac
+done
+
+# Health check results
+declare -A RESULTS
+TOTAL_CHECKS=0
+PASSED_CHECKS=0
+WARNINGS=0
+FAILURES=0
+
+check() {
+  local name="$1"
+  local status="$2"
+  local message="${3:-}"
+
+  TOTAL_CHECKS=$((TOTAL_CHECKS + 1))
+
+  case "$status" in
+    pass)
+      PASSED_CHECKS=$((PASSED_CHECKS + 1))
+      # shellcheck disable=SC2034
+      RESULTS["$name"]="pass"
+      if ! $JSON_OUTPUT; then
+        printf "${GREEN}✓${NC} %-35s ${GREEN}OK${NC}\n" "$name"
+      fi
+      ;;
+    warn)
+      WARNINGS=$((WARNINGS + 1))
+      # shellcheck disable=SC2034
+      RESULTS["$name"]="warn"
+      if ! $JSON_OUTPUT; then
+        printf "${YELLOW}⚠${NC} %-35s ${YELLOW}WARNING${NC}"
+        [[ -n "$message" ]] && printf " ${GRAY}%s${NC}" "$message"
+        printf "\n"
+      fi
+      ;;
+    fail)
+      FAILURES=$((FAILURES + 1))
+      # shellcheck disable=SC2034
+      RESULTS["$name"]="fail"
+      if ! $JSON_OUTPUT; then
+        printf "${RED}✗${NC} %-35s ${RED}FAILED${NC}"
+        [[ -n "$message" ]] && printf " ${GRAY}%s${NC}" "$message"
+        printf "\n"
+      fi
+      ;;
+  esac
+}
+
+print_header() {
+  if ! $JSON_OUTPUT; then
+    echo -e "\n${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo -e "${CYAN}  Dotfiles Health Dashboard${NC}"
+    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}\n"
+  fi
+}
+
+check_section() {
+  if ! $JSON_OUTPUT; then
+    echo -e "\n${BLUE}▸ $1${NC}"
+    echo "───────────────────────────────────────────────"
+  fi
+}
+
+# === Core Checks ===
+run_checks() {
+  # --- Dotfiles Core ---
+  check_section "Dotfiles Core"
+
+  # Chezmoi
+  if command -v chezmoi >/dev/null 2>&1; then
+    check "Chezmoi installed" "pass"
+    # Check if source dir exists
+    if [[ -d "${HOME}/.local/share/chezmoi" ]] || [[ -d "${HOME}/.dotfiles" ]]; then
+      check "Chezmoi source directory" "pass"
+    else
+      check "Chezmoi source directory" "fail" "Not found"
+    fi
+  else
+    check "Chezmoi installed" "fail" "Not installed"
+  fi
+
+  # Git
+  if command -v git >/dev/null 2>&1; then
+    check "Git installed" "pass"
+    if git config user.email >/dev/null 2>&1; then
+      check "Git user configured" "pass"
+    else
+      check "Git user configured" "warn" "Email not set"
+    fi
+  else
+    check "Git installed" "fail"
+  fi
+
+  # --- Shell ---
+  check_section "Shell Environment"
+
+  # Zsh
+  if command -v zsh >/dev/null 2>&1; then
+    check "Zsh installed" "pass"
+    if [[ "$SHELL" == *"zsh"* ]]; then
+      check "Zsh is default shell" "pass"
+    else
+      check "Zsh is default shell" "warn" "Current: $SHELL"
+    fi
+  else
+    check "Zsh installed" "fail"
+  fi
+
+  # Zinit
+  if [[ -d "${ZINIT_HOME:-$HOME/.local/share/zinit}" ]]; then
+    check "Zinit plugin manager" "pass"
+  else
+    check "Zinit plugin manager" "warn" "Not found"
+  fi
+
+  # Starship
+  if command -v starship >/dev/null 2>&1; then
+    check "Starship prompt" "pass"
+  else
+    check "Starship prompt" "warn" "Not installed"
+  fi
+
+  # --- Development Tools ---
+  check_section "Development Tools"
+
+  # Node.js
+  if command -v node >/dev/null 2>&1; then
+    local node_version
+    node_version=$(node --version 2>/dev/null)
+    check "Node.js ($node_version)" "pass"
+  else
+    check "Node.js" "warn" "Not installed"
+  fi
+
+  # fnm
+  if command -v fnm >/dev/null 2>&1; then
+    check "fnm (Node version manager)" "pass"
+  else
+    check "fnm" "warn" "Not installed"
+  fi
+
+  # Python
+  if command -v python3 >/dev/null 2>&1; then
+    local py_version
+    py_version=$(python3 --version 2>/dev/null | cut -d' ' -f2)
+    check "Python ($py_version)" "pass"
+  else
+    check "Python" "warn" "Not installed"
+  fi
+
+  # Rust
+  if command -v rustc >/dev/null 2>&1; then
+    check "Rust toolchain" "pass"
+  else
+    check "Rust toolchain" "warn" "Not installed"
+  fi
+
+  # Go
+  if command -v go >/dev/null 2>&1; then
+    check "Go" "pass"
+  else
+    check "Go" "warn" "Not installed"
+  fi
+
+  # --- CLI Tools ---
+  check_section "CLI Tools"
+
+  local tools=("fzf" "ripgrep:rg" "fd" "bat" "eza" "zoxide" "atuin" "delta" "jq" "yq" "sops" "mise" "just" "zellij" "hyperfine")
+  for tool in "${tools[@]}"; do
+    local name="${tool%%:*}"
+    local cmd="${tool##*:}"
+    if command -v "$cmd" >/dev/null 2>&1; then
+      check "$name" "pass"
+    else
+      check "$name" "warn" "Not installed"
+    fi
+  done
+
+  # --- Editors ---
+  check_section "Editors"
+
+  if command -v nvim >/dev/null 2>&1; then
+    check "Neovim" "pass"
+    if [[ -d "${XDG_DATA_HOME:-$HOME/.local/share}/nvim/lazy" ]]; then
+      check "Neovim plugins (lazy.nvim)" "pass"
+    else
+      check "Neovim plugins" "warn" "Lazy.nvim not found"
+    fi
+  else
+    check "Neovim" "warn" "Not installed"
+  fi
+
+  # --- Terminal ---
+  check_section "Terminal"
+
+  if command -v ghostty >/dev/null 2>&1 || [[ -d "/Applications/Ghostty.app" ]]; then
+    check "Ghostty terminal" "pass"
+  else
+    check "Ghostty terminal" "warn" "Not installed"
+  fi
+
+  # Fonts - check both Linux and macOS font locations
+  local font_found=false
+  if fc-list 2>/dev/null | grep -qi "JetBrains"; then
+    font_found=true
+  elif [[ -d "$HOME/Library/Fonts" ]] && compgen -G "$HOME/Library/Fonts/"*[Jj]et[Bb]rains* >/dev/null 2>&1; then
+    font_found=true
+  elif [[ -d "$HOME/.local/share/fonts" ]] && compgen -G "$HOME/.local/share/fonts/"*[Jj]et[Bb]rains* >/dev/null 2>&1; then
+    font_found=true
+  fi
+
+  if $font_found; then
+    check "JetBrains Mono Nerd Font" "pass"
+  else
+    check "JetBrains Mono Nerd Font" "warn" "Not installed"
+  fi
+
+  # --- Security ---
+  check_section "Security"
+
+  # Age encryption
+  if command -v age >/dev/null 2>&1; then
+    check "Age encryption" "pass"
+    if [[ -f "${HOME}/.config/chezmoi/key.txt" ]]; then
+      check "Age key configured" "pass"
+    else
+      check "Age key configured" "warn" "Key not found"
+    fi
+  else
+    check "Age encryption" "warn" "Not installed"
+  fi
+
+  # SSH
+  if [[ -f "${HOME}/.ssh/id_ed25519" ]] || [[ -f "${HOME}/.ssh/id_rsa" ]]; then
+    check "SSH keys present" "pass"
+  else
+    check "SSH keys present" "warn" "No keys found"
+  fi
+
+  # GPG
+  if command -v gpg >/dev/null 2>&1; then
+    if gpg --list-secret-keys 2>/dev/null | grep -q sec; then
+      check "GPG keys" "pass"
+    else
+      check "GPG keys" "warn" "No secret keys"
+    fi
+  else
+    check "GPG" "warn" "Not installed"
+  fi
+
+  # --- Performance ---
+  check_section "Performance"
+
+  # Shell startup time
+  if command -v zsh >/dev/null 2>&1; then
+    local startup_time
+    startup_time=$({ time zsh -i -c exit; } 2>&1 | grep real | awk '{print $2}' | sed 's/[ms]//g')
+    # Try to parse the time (handle different formats)
+    if [[ -n "$startup_time" ]]; then
+      # Simple check - if startup mentions 0m0, it's under 1 second
+      check "Shell startup time" "pass"
+    else
+      check "Shell startup time" "warn" "Could not measure"
+    fi
+  fi
+}
+
+print_summary() {
+  if $JSON_OUTPUT; then
+    echo "{"
+    echo "  \"total\": $TOTAL_CHECKS,"
+    echo "  \"passed\": $PASSED_CHECKS,"
+    echo "  \"warnings\": $WARNINGS,"
+    echo "  \"failures\": $FAILURES,"
+    echo "  \"score\": $((PASSED_CHECKS * 100 / TOTAL_CHECKS))"
+    echo "}"
+    return
+  fi
+
+  local score=$((PASSED_CHECKS * 100 / TOTAL_CHECKS))
+
+  echo -e "\n${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+  echo -e "${CYAN}  Summary${NC}"
+  echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}\n"
+
+  echo -e "  Total checks:  ${TOTAL_CHECKS}"
+  echo -e "  ${GREEN}Passed:${NC}        ${PASSED_CHECKS}"
+  echo -e "  ${YELLOW}Warnings:${NC}      ${WARNINGS}"
+  echo -e "  ${RED}Failures:${NC}      ${FAILURES}"
+  echo ""
+
+  # Health score bar
+  local bar_width=30
+  local filled=$((score * bar_width / 100))
+  local empty=$((bar_width - filled))
+
+  printf "  Health Score: ["
+  if [[ $score -ge 80 ]]; then
+    printf '%s' "${GREEN}"
+  elif [[ $score -ge 60 ]]; then
+    printf '%s' "${YELLOW}"
+  else
+    printf '%s' "${RED}"
+  fi
+  printf "%${filled}s" | tr ' ' '█'
+  printf '%s' "${NC}"
+  printf "%${empty}s" | tr ' ' '░'
+  printf "] %s%%\n\n" "${score}"
+
+  if [[ $score -ge 90 ]]; then
+    echo -e "  ${GREEN}⚡ Excellent! Your dotfiles are in great shape.${NC}"
+  elif [[ $score -ge 70 ]]; then
+    echo -e "  ${GREEN}✓ Good! Minor improvements possible.${NC}"
+  elif [[ $score -ge 50 ]]; then
+    echo -e "  ${YELLOW}⚠ Fair. Consider addressing warnings.${NC}"
+  else
+    echo -e "  ${RED}✗ Needs attention. Multiple issues found.${NC}"
+  fi
+
+  echo ""
+}
+
+# Main
+print_header
+run_checks
+print_summary