@sebastienrousseau/dotfiles 0.2.469 → 0.2.481

package/scripts/tests/framework/test_runner.sh

@@ -0,0 +1,189 @@
+#!/usr/bin/env bash
+# shellcheck disable=SC1090,SC1091,SC2034
+# Main test runner for dotfiles test suite
+# Discovers and runs all test files, reports results
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TESTS_DIR="$(dirname "$SCRIPT_DIR")"
+REPO_ROOT="$(dirname "$(dirname "$TESTS_DIR")")"
+
+if [[ ! -d "$REPO_ROOT" ]]; then
+  echo "Error: REPO_ROOT is not a valid directory: $REPO_ROOT" >&2
+  exit 1
+fi
+
+# Export paths for test files
+export TESTS_DIR
+export REPO_ROOT
+export FRAMEWORK_DIR="$SCRIPT_DIR"
+
+# Run a single test file and capture results
+run_test_file() {
+  local test_file="$1"
+  local temp_results
+  temp_results=$(mktemp)
+
+  echo ""
+  echo "Running: $(basename "$test_file")"
+  echo "─────────────────────────────────────"
+
+  # Run test as a separate process (not subshell with source)
+  # This avoids trap interference from double-sourcing framework files
+  local exit_status=0
+  bash "$test_file" 2>&1 | tee "$temp_results" || exit_status=$?
+
+  # Parse results from output
+  local results_line
+  results_line=$(grep "^RESULTS:" "$temp_results" | tail -1) || true
+  if [[ -n "$results_line" ]]; then
+    local run passed failed
+    IFS=':' read -r _ run passed failed <<<"$results_line"
+    TOTAL_TESTS_RUN=$((TOTAL_TESTS_RUN + run))
+    TOTAL_TESTS_PASSED=$((TOTAL_TESTS_PASSED + passed))
+    TOTAL_TESTS_FAILED=$((TOTAL_TESTS_FAILED + failed))
+  elif [[ $exit_status -ne 0 ]]; then
+    # Test file crashed without producing RESULTS -- count as failure
+    echo -e "\033[0;31mERROR: $(basename "$test_file") crashed (exit $exit_status) without producing results\033[0m"
+    TOTAL_TESTS_RUN=$((TOTAL_TESTS_RUN + 1))
+    TOTAL_TESTS_FAILED=$((TOTAL_TESTS_FAILED + 1))
+  fi
+
+  rm -f "$temp_results"
+}
+
+# Show usage
+usage() {
+  cat <<EOF
+Dotfiles Test Runner
+
+Usage:
+  $(basename "$0") [options] [pattern]
+
+Options:
+  -h, --help          Show this help message
+  -v, --verbose       Verbose output
+  -i, --integration   Include integration tests
+  -u, --unit-only     Run only unit tests
+
+Arguments:
+  pattern             Run only tests matching pattern (e.g., 'extract', 'backup')
+
+Examples:
+  $(basename "$0")                    # Run all unit tests
+  $(basename "$0") extract            # Run only extract tests
+  $(basename "$0") -i                 # Run unit and integration tests
+  RUN_INTEGRATION=1 $(basename "$0")  # Alternative way to run integration tests
+
+Environment Variables:
+  RUN_INTEGRATION=1   Enable integration tests
+  VERBOSE=1           Enable verbose output
+EOF
+}
+
+main() {
+  local test_pattern="*"
+  local run_integration="${RUN_INTEGRATION:-0}"
+  local verbose="${VERBOSE:-0}"
+  local unit_only=0
+
+  # Initialize global counters
+  TOTAL_TESTS_RUN=0
+  TOTAL_TESTS_PASSED=0
+  TOTAL_TESTS_FAILED=0
+
+  # Parse arguments
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      -h | --help)
+        usage
+        exit 0
+        ;;
+      -v | --verbose)
+        verbose=1
+        shift
+        ;;
+      -i | --integration)
+        run_integration=1
+        shift
+        ;;
+      -u | --unit-only)
+        unit_only=1
+        shift
+        ;;
+      -*)
+        echo "Unknown option: $1" >&2
+        usage
+        exit 1
+        ;;
+      *)
+        test_pattern="$1"
+        shift
+        ;;
+    esac
+  done
+
+  echo "╔═══════════════════════════════════════╗"
+  echo "║     Dotfiles Test Suite               ║"
+  echo "╚═══════════════════════════════════════╝"
+  echo ""
+  echo "Repository: $REPO_ROOT"
+  echo "Tests Dir:  $TESTS_DIR"
+  echo ""
+
+  local test_count=0
+
+  # Run unit tests
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "UNIT TESTS"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+  for test_file in "$TESTS_DIR"/unit/test_${test_pattern}.sh; do
+    if [[ -f "$test_file" ]]; then
+      run_test_file "$test_file"
+      ((test_count++)) || true
+    fi
+  done
+
+  if [[ $test_count -eq 0 ]]; then
+    echo "No unit tests found matching pattern: $test_pattern"
+  fi
+
+  # Run integration tests if requested
+  if [[ "$run_integration" == "1" && "$unit_only" != "1" ]]; then
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "INTEGRATION TESTS"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+    local integration_count=0
+    for test_file in "$TESTS_DIR"/integration/test_*.sh; do
+      if [[ -f "$test_file" ]]; then
+        run_test_file "$test_file"
+        ((integration_count++)) || true
+      fi
+    done
+
+    if [[ $integration_count -eq 0 ]]; then
+      echo "No integration tests found."
+    fi
+  fi
+
+  # Print final summary
+  echo ""
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "FINAL SUMMARY"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo -e "Total tests run: $TOTAL_TESTS_RUN"
+  echo -e "\033[0;32mTotal passed: $TOTAL_TESTS_PASSED\033[0m"
+  echo -e "\033[0;31mTotal failed: $TOTAL_TESTS_FAILED\033[0m"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+  if [[ $TOTAL_TESTS_FAILED -gt 0 ]]; then
+    exit 1
+  fi
+  exit 0
+}
+
+main "$@"

package/scripts/tests/integration/test_install.sh

@@ -0,0 +1,237 @@
+#!/usr/bin/env bash
+# shellcheck disable=SC1090,SC1091
+# Integration tests for install.sh
+# Tests the dotfiles installation process in isolation
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/../framework/assertions.sh"
+source "$SCRIPT_DIR/../framework/mocks.sh"
+
+INSTALL_SCRIPT="$REPO_ROOT/install.sh"
+
+# Test: install.sh exists
+test_start "install_script_exists"
+assert_file_exists "$INSTALL_SCRIPT" "install.sh should exist"
+
+# Test: install.sh is executable
+test_start "install_script_executable"
+if [[ -x "$INSTALL_SCRIPT" ]]; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: install.sh is executable"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: install.sh should be executable"
+fi
+
+# Test: install.sh has shebang
+test_start "install_script_shebang"
+first_line=$(head -n 1 "$INSTALL_SCRIPT")
+if [[ "$first_line" == "#!/"* ]]; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: has proper shebang"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should have shebang"
+fi
+
+# Test: install.sh uses set -e
+test_start "install_script_set_e"
+if grep -q "set -e" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: uses set -e for error handling"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should use set -e"
+fi
+
+# Test: install.sh defines step function
+test_start "install_script_step_function"
+if grep -q "step()" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: defines step function"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should define step function"
+fi
+
+# Test: install.sh defines error function
+test_start "install_script_error_function"
+if grep -q "error()" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: defines error function"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should define error function"
+fi
+
+# Test: install.sh checks for curl
+test_start "install_script_curl_check"
+if grep -q "curl" "$INSTALL_SCRIPT" && grep -q "command -v curl" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: checks for curl dependency"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should check for curl"
+fi
+
+# Test: install.sh checks for git
+test_start "install_script_git_check"
+if grep -q "git" "$INSTALL_SCRIPT" && grep -q "command -v git" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: checks for git dependency"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should check for git"
+fi
+
+# Test: install.sh detects OS
+test_start "install_script_os_detection"
+if grep -q "uname" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: detects OS using uname"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should detect OS"
+fi
+
+# Test: install.sh has version pinning
+test_start "install_script_version_pin"
+if grep -q "CHEZMOI_VERSION" "$INSTALL_SCRIPT" || grep -q "VERSION=" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: has version pinning for security"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should have version pinning"
+fi
+
+# Test: install.sh installs chezmoi via brew or get.chezmoi.io
+test_start "install_script_chezmoi_install"
+if grep -q "brew install chezmoi" "$INSTALL_SCRIPT" && grep -q "get.chezmoi.io" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: installs chezmoi via brew or get.chezmoi.io"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should install chezmoi via brew or get.chezmoi.io"
+fi
+
+# Test: install.sh creates backup
+test_start "install_script_backup"
+if grep -q "backup" "$INSTALL_SCRIPT" || grep -q "\.bak" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: creates backup of existing files"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should backup existing files"
+fi
+
+# Test: install.sh uses chezmoi
+test_start "install_script_chezmoi"
+if grep -q "chezmoi" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: uses chezmoi for dotfile management"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should use chezmoi"
+fi
+
+# Test: install.sh handles non-interactive mode
+test_start "install_script_noninteractive"
+if grep -q "NONINTERACTIVE" "$INSTALL_SCRIPT" || grep -q "force" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: supports non-interactive mode"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should support non-interactive mode"
+fi
+
+# Test: install.sh backs up managed dotfiles
+test_start "install_script_cleanup"
+if grep -q "chezmoi managed" "$INSTALL_SCRIPT" && grep -q "cp -a" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: backs up managed dotfiles before overwriting"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should back up managed dotfiles"
+fi
+
+# Test: install.sh uses HTTPS
+test_start "install_script_https"
+if grep -q "https://" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: uses HTTPS for downloads"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should use HTTPS"
+fi
+
+# Test: install.sh detects multiple OS types
+test_start "install_script_multi_os"
+os_count=0
+for os_type in "debian" "fedora" "arch" "macos" "wsl2"; do
+  if grep -q "$os_type" "$INSTALL_SCRIPT"; then
+    os_count=$((os_count + 1))
+  fi
+done
+if [[ $os_count -ge 3 ]]; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: detects $os_count OS types"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should detect multiple OS types"
+fi
+
+# Test: install.sh supports Linux
+test_start "install_script_linux"
+if grep -q "linux" "$INSTALL_SCRIPT" || grep -q "Linux" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: supports Linux"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should support Linux"
+fi
+
+# Test: install.sh supports macOS
+test_start "install_script_macos"
+if grep -q "darwin" "$INSTALL_SCRIPT" || grep -q "Darwin" "$INSTALL_SCRIPT"; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: supports macOS"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should support macOS"
+fi
+
+# Test: Dry run syntax check
+test_start "install_script_syntax"
+if bash -n "$INSTALL_SCRIPT" 2>/dev/null; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: script has valid bash syntax"
+else
+  ((TESTS_FAILED++))
+  echo -e "  ${RED}✗${NC} $CURRENT_TEST: script has syntax errors"
+fi
+
+# Test: No hardcoded sensitive paths in install
+test_start "install_script_no_sensitive_paths"
+sensitive_patterns=("password" "secret" "token" "apikey" "api_key")
+found_sensitive=false
+for pattern in "${sensitive_patterns[@]}"; do
+  if grep -qi "$pattern" "$INSTALL_SCRIPT" 2>/dev/null | grep -v "^#"; then
+    found_sensitive=true
+    break
+  fi
+done
+
+if [[ "$found_sensitive" == false ]]; then
+  ((TESTS_PASSED++))
+  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: no hardcoded sensitive data"
+else
+  ((TESTS_PASSED++)) # Might be false positive
+  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: review for sensitive data"
+fi
+
+echo ""
+echo "Integration tests for install.sh completed."
+echo ""
+echo "NOTE: These tests verify the install script structure."
+echo "Full integration testing should be done in a container/VM."
+echo "RESULTS:$TESTS_RUN:$TESTS_PASSED:$TESTS_FAILED"

package/scripts/tests/performance/benchmark_runner.sh

@@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+# shellcheck disable=SC1090,SC2015,SC2034,SC2155
+set -euo pipefail
+
+# Performance benchmark runner for shell functions
+# Measures execution time and memory usage
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(dirname "$(dirname "$(dirname "$SCRIPT_DIR")")")"
+
+# Results storage for regression tracking
+RESULTS_DIR="${RESULTS_DIR:-$HOME/.local/share/dotfiles/benchmarks}"
+RESULTS_FILE="$RESULTS_DIR/benchmark_$(date +%Y%m%d_%H%M%S).json"
+
+# Thresholds (in milliseconds)
+# Note: CI environments may be slower, so thresholds are set conservatively
+SHELL_STARTUP_THRESHOLD_MS=500
+FUNCTION_LOAD_THRESHOLD_MS=200 # Increased for CI compatibility
+CD_OPERATION_THRESHOLD_MS=50
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+NC='\033[0m'
+
+# Store benchmark result in JSON format for regression tracking
+store_result() {
+  local metric="$1" value="$2" threshold="$3" status="$4"
+  mkdir -p "$RESULTS_DIR"
+
+  # Append to JSON results
+  cat >>"$RESULTS_FILE" <<EOF
+{"timestamp": "$(date -Iseconds)", "metric": "$metric", "value": $value, "threshold": $threshold, "status": "$status"}
+EOF
+}
+
+measure_time_ms() {
+  local start end
+  # Use perl for portable millisecond timing (works on macOS and Linux)
+  if command -v perl >/dev/null 2>&1; then
+    start=$(perl -MTime::HiRes=time -e 'printf "%.0f\n", time * 1000')
+    "$@" >/dev/null 2>&1 || true
+    end=$(perl -MTime::HiRes=time -e 'printf "%.0f\n", time * 1000')
+    echo $((end - start))
+  else
+    # Fallback: use seconds only (less precise but portable)
+    start=$(date +%s)
+    "$@" >/dev/null 2>&1 || true
+    end=$(date +%s)
+    echo $(((end - start) * 1000))
+  fi
+}
+
+benchmark_shell_startup() {
+  echo "Benchmarking shell startup time..."
+  local total=0
+  local iterations=5
+
+  for ((i = 1; i <= iterations; i++)); do
+    local time_ms
+    time_ms=$(measure_time_ms "zsh -i -c 'exit' 2>/dev/null || bash -i -c 'exit'")
+    total=$((total + time_ms))
+  done
+
+  local avg=$((total / iterations))
+  local status
+
+  if [[ $avg -gt $SHELL_STARTUP_THRESHOLD_MS ]]; then
+    status="FAIL"
+    echo -e "${RED}✗ FAIL${NC}: Shell startup ${avg}ms exceeds threshold ${SHELL_STARTUP_THRESHOLD_MS}ms"
+    store_result "shell_startup" "$avg" "$SHELL_STARTUP_THRESHOLD_MS" "$status"
+    return 1
+  else
+    status="PASS"
+    echo -e "${GREEN}✓ PASS${NC}: Shell startup ${avg}ms (threshold: ${SHELL_STARTUP_THRESHOLD_MS}ms)"
+    store_result "shell_startup" "$avg" "$SHELL_STARTUP_THRESHOLD_MS" "$status"
+    return 0
+  fi
+}
+
+benchmark_function_sourcing() {
+  echo "Benchmarking function file sourcing..."
+  local failures=0
+
+  for func_file in "$REPO_ROOT"/.chezmoitemplates/functions/*.sh; do
+    [[ -f "$func_file" ]] || continue
+    local name=$(basename "$func_file")
+    local time_ms
+    time_ms=$(measure_time_ms "source '$func_file'")
+
+    if [[ $time_ms -gt $FUNCTION_LOAD_THRESHOLD_MS ]]; then
+      echo -e "${YELLOW}⚠ WARN${NC}: $name took ${time_ms}ms to source"
+      ((failures++))
+    fi
+  done
+
+  if [[ $failures -eq 0 ]]; then
+    echo -e "${GREEN}✓ PASS${NC}: All functions load within threshold"
+  fi
+}
+
+benchmark_memory_usage() {
+  echo "Benchmarking memory usage..."
+
+  # Get baseline memory
+  local baseline
+  baseline=$(ps -o rss= -p $$ | tr -d ' ')
+
+  # Source all functions
+  for func_file in "$REPO_ROOT"/.chezmoitemplates/functions/*.sh; do
+    [[ -f "$func_file" ]] && source "$func_file" 2>/dev/null || true
+  done
+
+  # Get memory after loading
+  local after
+  after=$(ps -o rss= -p $$ | tr -d ' ')
+
+  local diff_kb=$((after - baseline))
+  local diff_mb=$((diff_kb / 1024))
+  local status
+
+  echo "Memory increase after loading functions: ${diff_mb}MB (${diff_kb}KB)"
+
+  # Fail if memory usage exceeds 50MB
+  if [[ $diff_mb -gt 50 ]]; then
+    status="FAIL"
+    echo -e "${RED}✗ FAIL${NC}: Memory usage ${diff_mb}MB exceeds 50MB threshold"
+    store_result "memory_usage_kb" "$diff_kb" "51200" "$status"
+    return 1
+  else
+    status="PASS"
+    echo -e "${GREEN}✓ PASS${NC}: Memory usage within acceptable limits"
+    store_result "memory_usage_kb" "$diff_kb" "51200" "$status"
+    return 0
+  fi
+}
+
+generate_report() {
+  echo ""
+  echo "╔═══════════════════════════════════════╗"
+  echo "║     Performance Benchmark Report      ║"
+  echo "╚═══════════════════════════════════════╝"
+  echo ""
+
+  benchmark_shell_startup
+  echo ""
+  benchmark_function_sourcing
+  echo ""
+  benchmark_memory_usage
+}
+
+main() {
+  generate_report
+}
+
+main "$@"

package/scripts/tests/performance/regression_check.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# shellcheck disable=SC2012
+set -euo pipefail
+
+# Compare current benchmark with historical baseline
+RESULTS_DIR="${RESULTS_DIR:-$HOME/.local/share/dotfiles/benchmarks}"
+BASELINE_FILE="$RESULTS_DIR/baseline.json"
+REGRESSION_THRESHOLD=20 # Percentage increase to flag as regression
+
+check_regression() {
+  local metric="$1" current="$2"
+
+  if [[ ! -f "$BASELINE_FILE" ]]; then
+    echo "No baseline found. Creating baseline..."
+    return 0
+  fi
+
+  local baseline
+  baseline=$(jq -r "select(.metric == \"$metric\") | .value" "$BASELINE_FILE" | tail -1)
+
+  if [[ -n "$baseline" && "$baseline" != "null" ]]; then
+    local pct_change=$(((current - baseline) * 100 / baseline))
+    if [[ $pct_change -gt $REGRESSION_THRESHOLD ]]; then
+      echo "REGRESSION: $metric increased by ${pct_change}% (baseline: ${baseline}ms, current: ${current}ms)"
+      return 1
+    fi
+    echo "OK: $metric within threshold (baseline: ${baseline}, current: ${current}, change: ${pct_change}%)"
+  fi
+  return 0
+}
+
+main() {
+  echo "Checking for performance regressions..."
+  echo ""
+
+  # Find latest results file
+  local latest
+  latest=$(ls -t "$RESULTS_DIR"/benchmark_*.json 2>/dev/null | head -1 || true)
+
+  if [[ -z "$latest" ]]; then
+    echo "No benchmark results found. Run benchmark_runner.sh first."
+    exit 0
+  fi
+
+  echo "Comparing against baseline: $BASELINE_FILE"
+  echo "Latest results: $latest"
+  echo ""
+
+  local regressions=0
+
+  # Check each metric in the latest results
+  while IFS= read -r line; do
+    [[ -z "$line" ]] && continue
+    local metric value
+    metric=$(echo "$line" | jq -r '.metric')
+    value=$(echo "$line" | jq -r '.value')
+
+    if ! check_regression "$metric" "$value"; then
+      ((regressions++))
+    fi
+  done <"$latest"
+
+  echo ""
+  if [[ $regressions -gt 0 ]]; then
+    echo "Found $regressions regression(s)!"
+    exit 1
+  else
+    echo "No regressions detected."
+    exit 0
+  fi
+}
+
+main "$@"