@sebastienrousseau/dotfiles 0.2.481 → 0.2.499

package/scripts/tests/framework/test_runner.sh

@@ -1,189 +0,0 @@
-#!/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

@@ -1,237 +0,0 @@
-#!/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

@@ -1,156 +0,0 @@
-#!/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

@@ -1,73 +0,0 @@
-#!/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 "$@"