Bash — per-model detail

largest_file() {
    find "$1" -type f -printf '%s\t%p\n' | sort -nr | head -n 1 | cut -f2-
}

largest_file() {
    find "$1" -type f -printf '%s\t%p\n' | sort -nr | head -n 1 | cut -f2-
}

largest_file() {
    find "$1" -type f -printf '%s\t%p\n' | sort -nr | head -n 1 | cut -f2-
}

extract_urls() {
  grep -oE 'https?://[^[:space:]]+'
}

extract_urls() {
  grep -oE 'https?://[^[:space:]]+'
}

extract_urls() {
  grep -oE 'https?://[^[:space:]]+'
}

rotate() {
    local file="$1"
    local i=1
    while [ -f "${file}.${i}" ]; do
        mv "${file}.${i}" "${file}.$((i + 1))"
        i=$((i + 1))
    done
    mv "$file" "${file}.1"
}

rotate() {
    local file="$1"
    local i=1
    while [ -f "${file}.${i}" ]; do
        mv "${file}.${i}" "${file}.$((i + 1))"
        i=$((i + 1))
    done
    mv "$file" "${file}.1"
}

rotate() {
    local file="$1"
    local i=1
    while [ -f "${file}.${i}" ]; do
        mv "${file}.${i}" "${file}.$((i + 1))"
        i=$((i + 1))
    done
    mv "$file" "${file}.1"
}

find_dupes() {
    local dir="$1"
    local tmpfile=$(mktemp)
    
    # Find all regular files, compute MD5, store hash and path
    find "$dir" -type f -exec md5 -r {} \; 2>/dev/null | while IFS= read -r line; do
        # md5 -r outputs: <hash> <path>
        local hash="${line%% *}"
        local path="${line#* }"
        printf '%s\t%s\n' "$hash" "$path"
    done > "$tmpfile"
    
    # Sort by hash, then by path
    sort -t$'\t' -k1,1 -k2,2 "$tmpfile" | while IFS=$'\t' read -r hash path; do
        if [[ "$hash" == "$prev_hash" ]]; then
            # Append to current group
            if [[ -z "$group" ]]; then
                group="$prev_path"
            fi
            group="$group $path"
        else
            # Output previous group if it has 2+ files
            if [[ -n "$group" ]]; then
                # Check if group has at least 2 files (count spaces)
                local count=$(echo "$group" | wc -w)
                if [[ $count -ge 2 ]]; then
                    echo "$group"
                fi
            fi
            # Start new group
            group="$path"
        fi
        prev_hash="$hash"
        prev_path="$path"
    done
    
    # Output last group
    if [[ -n "$group" ]]; then
        local count=$(echo "$group" | wc -w)
        if [[ $count -ge 2 ]]; then
            echo "$group"
        fi
    fi
    
    rm -f "$tmpfile"
}

find_dupes() {
    local dir="$1"
    local tmpfile=$(mktemp)
    
    # Find all regular files, compute MD5, store hash and path
    find "$dir" -type f -exec md5 -r {} \; 2>/dev/null | while IFS= read -r line; do
        # md5 -r outputs: <hash> <path>
        local hash="${line%% *}"
        local path="${line#* }"
        printf '%s\t%s\n' "$hash" "$path"
    done > "$tmpfile"
    
    # Sort by hash, then by path
    sort -t$'\t' -k1,1 -k2,2 "$tmpfile" | while IFS=$'\t' read -r hash path; do
        if [[ "$hash" == "$prev_hash" ]]; then
            # Append to current group
            if [[ -z "$group" ]]; then
                group="$prev_path"
            fi
            group="$group $path"
        else
            # Output previous group if it has 2+ files
            if [[ -n "$group" ]]; then
                # Check if group has at least 2 files (count spaces)
                local count=$(echo "$group" | wc -w)
                if [[ $count -ge 2 ]]; then
                    echo "$group"
                fi
            fi
            # Start new group
            group="$path"
        fi
        prev_hash="$hash"
        prev_path="$path"
    done
    
    # Output last group
    if [[ -n "$group" ]]; then
        local count=$(echo "$group" | wc -w)
        if [[ $count -ge 2 ]]; then
            echo "$group"
        fi
    fi
    
    rm -f "$tmpfile"
}

find_dupes() {
    local dir="$1"
    local tmpfile=$(mktemp)
    
    # Find all regular files, compute MD5, store hash and path
    find "$dir" -type f -exec md5 -r {} \; 2>/dev/null | while IFS= read -r line; do
        # md5 -r outputs: <hash> <path>
        local hash="${line%% *}"
        local path="${line#* }"
        printf '%s\t%s\n' "$hash" "$path"
    done > "$tmpfile"
    
    # Sort by hash, then by path
    sort -t$'\t' -k1,1 -k2,2 "$tmpfile" | while IFS=$'\t' read -r hash path; do
        if [[ "$hash" == "$prev_hash" ]]; then
            # Append to current group
            if [[ -z "$group" ]]; then
                group="$prev_path"
            fi
            group="$group $path"
        else
            # Output previous group if it has 2+ files
            if [[ -n "$group" ]]; then
                # Check if group has at least 2 files (count spaces)
                local count=$(echo "$group" | wc -w)
                if [[ $count -ge 2 ]]; then
                    echo "$group"
                fi
            fi
            # Start new group
            group="$path"
        fi
        prev_hash="$hash"
        prev_path="$path"
    done
    
    # Output last group
    if [[ -n "$group" ]]; then
        local count=$(echo "$group" | wc -w)
        if [[ $count -ge 2 ]]; then
            echo "$group"
        fi
    fi
    
    rm -f "$tmpfile"
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ ! -f "$logfile" ]]; then
        return
    fi

    grep 'ERROR: ' "$logfile" | \
    sed 's/.*ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2 | \
    head -n "$n" | \
    awk '{count=$1; $1=""; sub(/^ /, ""); print count " " $0}'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ ! -f "$logfile" ]]; then
        return
    fi

    grep 'ERROR: ' "$logfile" | \
    sed 's/.*ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2 | \
    head -n "$n" | \
    awk '{count=$1; $1=""; sub(/^ /, ""); print count " " $0}'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ ! -f "$logfile" ]]; then
        return
    fi

    grep 'ERROR: ' "$logfile" | \
    sed 's/.*ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2 | \
    head -n "$n" | \
    awk '{count=$1; $1=""; sub(/^ /, ""); print count " " $0}'
}

largest_file() {
    local dir=${1:-.}
    if [[ ! -d $dir ]]; then
        return 1
    fi
    find "$dir" -type f -printf '%s %p\n' |
        sort -nr |
        awk 'NR==1{ $1=""; sub(/^ /,""); print }'
}

largest_file() {
    local dir=${1:-.}
    local maxsize=-1 maxpath=
    while IFS= read -r -d '' size && IFS= read -r -d '' path; do
        if (( size > maxsize )); then
            maxsize=$size
            maxpath=$path
        fi
    done < <(find "$dir" -type f -printf '%s\0%p\0')
    printf '%s\n' "$maxpath"
}

largest_file() {
    local dir=${1:-.}
    local maxsize=-1 maxpath=
    while IFS= read -r -d '' size && IFS= read -r -d '' path; do
        if (( size > maxsize )); then
            maxsize=$size
            maxpath=$path
        fi
    done < <(find "$dir" -type f -printf '%s\0%p\0')
    printf '%s\n' "$maxpath"
}

extract_urls() {
    grep -oE 'https?://[^[:space:]<>"]+' || :
}

extract_urls() {
    grep -oE 'https?://[^[:space:]<>"]+' || :
}

extract_urls() {
    grep -oE 'https?://[^[:space:]<>"]+' || :
}

csv_col() {
    local col="$1"
    gawk -v col="$col" '
        BEGIN {
            # FPAT matches a CSV field: either quoted (allowing doubled quotes) or unquoted
            FPAT = "([^,]*|\"([^\"]|\"\")*\")*"
        }
        NR == 1 {
            # Find the column index from the header line
            for (i = 1; i <= NF; i++) {
                hdr = $i
                if (hdr ~ /^".*"$/) {
                    gsub(/^"/, "", hdr)
                    gsub(/"$/, "", hdr)
                    gsub(/""/, "\"", hdr)
                }
                if (hdr == col) {
                    idx = i
                    break
                }
            }
            if (!idx) exit 1   # column not found
            next
        }
        {
            if (idx > NF) next
            val = $idx
            # Strip surrounding quotes and un‑escape doubled quotes
            if (val ~ /^".*"$/) {
                gsub(/^"/, "", val)
                gsub(/"$/, "", val)
                gsub(/""/, "\"", val)
            }
            print val
        }
    '
}

csv_col() {
    local colname="$1"
    awk -v colname="$colname" '
        BEGIN {
            # CSV field pattern: unquoted fields or quoted fields (allowing commas inside)
            FPAT = "([^,]*|\"([^\"]|\"\")*\")"
        }
        NR == 1 {
            for (i = 1; i <= NF; i++) {
                # Strip surrounding quotes for header comparison
                hdr = $i
                gsub(/^\"|\"$/,"",hdr)
                if (hdr == colname) {
                    col = i
                    break
                }
            }
            if (!col) exit 1   # column not found
            next
        }
        {
            field = $col
            gsub(/^\"|\"$/,"",field)   # remove surrounding quotes from data
            print field
        }
    '
}

csv_col() {
    local colname="$1"
    awk -v colname="$colname" '
        BEGIN {
            # CSV field pattern: unquoted fields or quoted fields (allowing commas inside)
            FPAT = "([^,]*|\"([^\"]|\"\")*\")"
        }
        NR == 1 {
            for (i = 1; i <= NF; i++) {
                # Strip surrounding quotes for header comparison
                hdr = $i
                gsub(/^\"|\"$/,"",hdr)
                if (hdr == colname) {
                    col = i
                    break
                }
            }
            if (!col) exit 1   # column not found
            next
        }
        {
            field = $col
            gsub(/^\"|\"$/,"",field)   # remove surrounding quotes from data
            print field
        }
    '
}

json_get() {
    local key=$1
    python3 - "$key" <<'PY'
import sys, json
key = sys.argv[1]
obj = json.load(sys.stdin)
val = obj.get(key)
if isinstance(val, str):
    print(val)
else:
    print(json.dumps(val))
PY
}

json_get() {
    local key=$1
    python3 - "$key" <<'PY'
import sys, json
key = sys.argv[1]
obj = json.load(sys.stdin)
val = obj.get(key)
if isinstance(val, str):
    print(val)
else:
    print(json.dumps(val))
PY
}

json_get() {
    local key=$1
    python3 - "$key" <<'PY'
import sys, json
key = sys.argv[1]
obj = json.load(sys.stdin)
val = obj.get(key)
if isinstance(val, str):
    print(val)
else:
    print(json.dumps(val))
PY
}

find_dupes() {
    local dir="${1:?missing directory}"
    declare -A hash_map
    # Gather files and their MD5 hashes
    while IFS= read -r -d '' file; do
        # md5 -r prints: "<hash> <filename>"
        local hash
        hash=$(md5 -r "$file" | awk '{print $1}')
        hash_map["$hash"]+=$file$'\0'
    done < <(find "$dir" -type f -print0)

    # Build groups of duplicates
    local -a groups
    for hash in "${!hash_map[@]}"; do
        IFS=$'\0' read -ra files <<< "${hash_map[$hash]}"
        (( ${#files[@]} > 1 )) || continue
        # Sort paths within the group
        local sorted
        sorted=$(printf '%s\n' "${files[@]}" | sort | tr '\n' ' ')
        sorted=${sorted% }   # strip trailing space
        groups+=("$sorted")
    done

    # Output groups sorted by their first path
    printf '%s\n' "${groups[@]}" | sort -k1,1
}

largest_file() {
  find "$1" -type f -printf "%s\t%p\n" | sort -nr | head -n 1 | cut -f2-
}

largest_file() {
  find "$1" -type f -printf "%s\t%p\n" | sort -nr | head -n 1 | cut -f2-
}

largest_file() {
  find "$1" -type f -printf "%s\t%p\n" | sort -nr | head -n 1 | cut -f2-
}

retry3() {
  local attempts=3
  local exit_code=1
  for ((i=1; i<=attempts; i++)); do
    "$@"
    exit_code=$?
    if [[ $exit_code -eq 0 ]]; then
      exit 0
    fi
  done
  exit $exit_code
}

retry3() {
  local attempts=3
  local exit_code=1
  for ((i=1; i<=attempts; i++)); do
    "$@"
    exit_code=$?
    if [[ $exit_code -eq 0 ]]; then
      exit 0
    fi
  done
  exit $exit_code
}

retry3() {
  local attempts=3
  local exit_code=1
  for ((i=1; i<=attempts; i++)); do
    "$@"
    exit_code=$?
    if [[ $exit_code -eq 0 ]]; then
      exit 0
    fi
  done
  exit $exit_code
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

rotate() {
  local file="$1"
  return 1  # no argument provided
  [[ -z "$file" ]] && return 1

  if [[ -e "${file}.1" ]]; then
    mv -f "${file}.1" "${file}.2"
  fi

  if [[ -e "$file" ]]; then
    mv -f "$file" "${file}.1"
  fi
}

json_get() {
  local key="$1"
  python3 - <<'PY' "$key"
import sys, json
key = sys.argv[1]
try:
    data = json.load(sys.stdin)
except Exception:
    sys.exit(1)
value = data.get(key)
if value is not None:
    if isinstance(value, str):
        print(value)
    else:
        print(value)
PY
}

json_get() {
  local key="$1"
  python3 - <<'PY' "$key"
import sys, json
key = sys.argv[1]
try:
    data = json.load(sys.stdin)
except Exception:
    sys.exit(1)
value = data.get(key)
if value is not None:
    if isinstance(value, str):
        print(value)
    else:
        print(value)
PY
}

json_get() {
  local key="$1"
  python3 - <<'PY' "$key"
import sys, json
key = sys.argv[1]
try:
    data = json.load(sys.stdin)
except Exception:
    sys.exit(1)
value = data.get(key)
if value is not None:
    if isinstance(value, str):
        print(value)
    else:
        print(value)
PY
}

(no code extracted)

(no code extracted)

top_errors() {
    local logfile=$1
    local n=$2
    awk '
    BEGIN { OFS="\t" }
    {
        if (index($0, "ERROR: ") > 0) {
            sig = substr($0, index($0, "ERROR: ") + 7)
            gsub(/[0-9]+/, "#", sig)
            counts[sig]++
        }
    }
    END {
        for (s in counts) {
            print counts[s], s
        }
    }' "$logfile" | sort -t$'\t' -k1,1nr -k2,2 | head -n "$n"
}

count_matches() {
    grep -F -c "$1" "$2" 2>/dev/null || echo 0
}

count_matches() {
    grep -F -c "$1" "$2" 2>/dev/null || echo 0
}

count_matches() {
    grep -F -c "$1" "$2" 2>/dev/null || echo 0
}

largest_file() {
    find "$1" -type f -printf "%s %p\n" | sort -rn | head -n 1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -printf "%s %p\n" | sort -rn | head -n 1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -printf "%s %p\n" | sort -rn | head -n 1 | cut -d' ' -f2-
}

retry3() {
    local n=0
    local exit_code=0
    while [ $n -lt 3 ]; do
        "$@" && return 0
        exit_code=$?
        n=$((n + 1))
    done
    return $exit_code
}

retry3() {
    local n=0
    local exit_code=0
    while [ $n -lt 3 ]; do
        "$@" && return 0
        exit_code=$?
        n=$((n + 1))
    done
    return $exit_code
}

retry3() {
    local n=0
    local exit_code=0
    while [ $n -lt 3 ]; do
        "$@" && return 0
        exit_code=$?
        n=$((n + 1))
    done
    return $exit_code
}

extract_urls() {
  grep -oE 'https?://[^[:space:]"<>]+'
}

extract_urls() {
  grep -oE 'https?://[^[:space:]"<>]+'
}

extract_urls() {
  grep -oE 'https?://[^[:space:]"<>]+'
}

find_dupes() {
    local search_dir="$1"
    find "$search_dir" -type f -exec md5 -r {} + | \
    awk '{
        hash = $1;
        $1 = "";
        sub(/^ /, "", $0);
        paths[hash] = paths[hash] ? paths[hash] " " $0 : $0;
        count[hash]++;
    }
    END {
        for (h in count) {
            if (count[h] > 1) {
                split(paths[h], p, " ");
                # Sort paths within the group
                asort(p);
                line = "";
                for (i=1; i<=length(p); i++) {
                    line = (line == "" ? p[i] : line " " p[i]);
                }
                print line;
            }
        }
    }' | sort
}

find_dupes() {
    local search_dir="$1"
    find "$search_dir" -type f -exec md5 -r {} + | \
    awk '{
        hash = $1;
        $1 = "";
        sub(/^ /, "", $0);
        paths[hash] = paths[hash] ? paths[hash] " " $0 : $0;
        count[hash]++;
    }
    END {
        for (h in count) {
            if (count[h] > 1) {
                split(paths[h], p, " ");
                # Sort paths within the group
                asort(p);
                line = "";
                for (i=1; i<=length(p); i++) {
                    line = (line == "" ? p[i] : line " " p[i]);
                }
                print line;
            }
        }
    }' | sort
}

find_dupes() {
    local search_dir="$1"
    find "$search_dir" -type f -exec md5 -r {} + | \
    awk '{
        hash = $1;
        $1 = "";
        sub(/^ /, "", $0);
        paths[hash] = paths[hash] ? paths[hash] " " $0 : $0;
        count[hash]++;
    }
    END {
        for (h in count) {
            if (count[h] > 1) {
                split(paths[h], p, " ");
                # Sort paths within the group
                asort(p);
                line = "";
                for (i=1; i<=length(p); i++) {
                    line = (line == "" ? p[i] : line " " p[i]);
                }
                print line;
            }
        }
    }' | sort
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -cF -- "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -cF -- "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -cF -- "$pattern" "$file" 2>/dev/null || echo 0
}

largest_file() {
    local dir="$1"
    find "$dir" -type f -exec stat -c '%s %n' {} + 2>/dev/null | sort -rn | head -n 1 | cut -d' ' -f2-
}

largest_file() {
    local dir="$1"
    find "$dir" -type f -exec stat -c '%s %n' {} + 2>/dev/null | sort -rn | head -n 1 | cut -d' ' -f2-
}

largest_file() {
    local dir="$1"
    find "$dir" -type f -exec stat -c '%s %n' {} + 2>/dev/null | sort -rn | head -n 1 | cut -d' ' -f2-
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

csv_col() {
    local name="$1"
    local header
    header=$(head -n 1)
    local idx
    idx=$(echo "$header" | awk -F',' -v col="$name" '{for(i=1;i<=NF;i++) if($i==col){print i; exit}}')
    if [[ -z "$idx" ]]; then
        return 1
    fi
    tail -n +2 | awk -F',' -v idx="$idx" '{print $idx}'
}

csv_col() {
    local name="$1"
    local header
    header=$(head -n 1)
    local idx
    idx=$(echo "$header" | awk -F',' -v col="$name" '{for(i=1;i<=NF;i++) if($i==col){print i; exit}}')
    if [[ -z "$idx" ]]; then
        return 1
    fi
    tail -n +2 | awk -F',' -v idx="$idx" '{print $idx}'
}

csv_col() {
    local name="$1"
    local header
    header=$(head -n 1)
    local idx
    idx=$(echo "$header" | awk -F',' -v col="$name" '{for(i=1;i<=NF;i++) if($i==col){print i; exit}}')
    if [[ -z "$idx" ]]; then
        return 1
    fi
    tail -n +2 | awk -F',' -v idx="$idx" '{print $idx}'
}

find_dupes() {
    local dir="$1"
    local -a files=()
    local -A md5_map=()
    local -a md5s=()

    # Collect all regular files
    while IFS= read -r -d '' f; do
        files+=("$f")
    done < <(find "$dir" -type f -print0)

    # Compute MD5 for each file and group by hash
    local f hash
    for f in "${files[@]}"; do
        hash=$(md5 -r "$f" | awk '{print $1}')
        if [[ -n "${md5_map[$hash]+x}" ]]; then
            md5_map[$hash]+=" $f"
        else
            md5_map[$hash]="$f"
            md5s+=("$hash")
        fi
    done

    # Collect groups with 2+ files
    local -a groups=()
    local h
    for h in "${md5s[@]}"; do
        local -a group_files=()
        read -ra group_files <<< "${md5_map[$h]}"
        if (( ${#group_files[@]} >= 2 )); then
            # Sort the files in this group
            local sorted
            sorted=$(printf '%s\n' "${group_files[@]}" | sort)
            groups+=("$sorted")
        fi
    done

    # Sort groups by first path
    if (( ${#groups[@]} > 0 )); then
        printf '%s\n' "${groups[@]}" | sort | while IFS= read -r line; do
            printf '%s\n' "$line"
        done
    fi
}

find_dupes() {
    local dir="$1"
    local -a files=()
    local -A md5_map=()
    local -a md5s=()

    # Collect all regular files
    while IFS= read -r -d '' f; do
        files+=("$f")
    done < <(find "$dir" -type f -print0)

    # Compute MD5 for each file and group by hash
    local f hash
    for f in "${files[@]}"; do
        hash=$(md5 -r "$f" | awk '{print $1}')
        if [[ -n "${md5_map[$hash]+x}" ]]; then
            md5_map[$hash]+=" $f"
        else
            md5_map[$hash]="$f"
            md5s+=("$hash")
        fi
    done

    # Collect groups with 2+ files
    local -a groups=()
    local h
    for h in "${md5s[@]}"; do
        local -a group_files=()
        read -ra group_files <<< "${md5_map[$h]}"
        if (( ${#group_files[@]} >= 2 )); then
            # Sort the files in this group
            local sorted
            sorted=$(printf '%s\n' "${group_files[@]}" | sort)
            groups+=("$sorted")
        fi
    done

    # Sort groups by first path
    if (( ${#groups[@]} > 0 )); then
        printf '%s\n' "${groups[@]}" | sort | while IFS= read -r line; do
            printf '%s\n' "$line"
        done
    fi
}

find_dupes() {
    local dir="$1"
    local -a files=()
    local -A md5_map=()
    local -a md5s=()

    # Collect all regular files
    while IFS= read -r -d '' f; do
        files+=("$f")
    done < <(find "$dir" -type f -print0)

    # Compute MD5 for each file and group by hash
    local f hash
    for f in "${files[@]}"; do
        hash=$(md5 -r "$f" | awk '{print $1}')
        if [[ -n "${md5_map[$hash]+x}" ]]; then
            md5_map[$hash]+=" $f"
        else
            md5_map[$hash]="$f"
            md5s+=("$hash")
        fi
    done

    # Collect groups with 2+ files
    local -a groups=()
    local h
    for h in "${md5s[@]}"; do
        local -a group_files=()
        read -ra group_files <<< "${md5_map[$h]}"
        if (( ${#group_files[@]} >= 2 )); then
            # Sort the files in this group
            local sorted
            sorted=$(printf '%s\n' "${group_files[@]}" | sort)
            groups+=("$sorted")
        fi
    done

    # Sort groups by first path
    if (( ${#groups[@]} > 0 )); then
        printf '%s\n' "${groups[@]}" | sort | while IFS= read -r line; do
            printf '%s\n' "$line"
        done
    fi
}

top_errors() {
    local logfile="$1"
    local n="$2"

    # Extract ERROR lines, get text after 'ERROR: ', replace digit runs with #
    # Then count, sort by count desc then signature asc, take top n
    grep -E 'ERROR: ' "$logfile" 2>/dev/null | \
    sed -E 's/.*ERROR: //' | \
    sed -E 's/[0-9]+/#/g' | \
    sort | \
    uniq -c | \
    awk '{print $1, $2}' | \
    sort -k1,1nr -k2,2 | \
    head -n "$n"
}

top_errors() {
    local logfile="$1"
    local n="$2"

    # Extract ERROR lines, get text after 'ERROR: ', replace digit runs with #
    # Then count, sort by count desc then signature asc, take top n
    grep -E 'ERROR: ' "$logfile" 2>/dev/null | \
    sed -E 's/.*ERROR: //' | \
    sed -E 's/[0-9]+/#/g' | \
    sort | \
    uniq -c | \
    awk '{print $1, $2}' | \
    sort -k1,1nr -k2,2 | \
    head -n "$n"
}

top_errors() {
    local logfile="$1"
    local n="$2"

    # Extract ERROR lines, get text after 'ERROR: ', replace digit runs with #
    # Then count, sort by count desc then signature asc, take top n
    grep -E 'ERROR: ' "$logfile" 2>/dev/null | \
    sed -E 's/.*ERROR: //' | \
    sed -E 's/[0-9]+/#/g' | \
    sort | \
    uniq -c | \
    awk '{print $1, $2}' | \
    sort -k1,1nr -k2,2 | \
    head -n "$n"
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' 2>/dev/null | sort -nr | head -n1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' 2>/dev/null | sort -nr | head -n1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' 2>/dev/null | sort -nr | head -n1 | cut -d' ' -f2-
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' | tr '\n' '\n'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' | tr '\n' '\n'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' | tr '\n' '\n'
}

find_dupes() {
    local dir="$1"
    find "$dir" -type f -exec md5 -r {} + | sort | awk '
        {
            md5 = $1
            file = $2
            if (md5 in groups) {
                groups[md5] = groups[md5] " " file
            } else {
                groups[md5] = file
            }
        }
        END {
            for (md5 in groups) {
                split(groups[md5], files, " ")
                if (length(files) >= 2) {
                    n = asort(files)
                    line = ""
                    for (i = 1; i <= n; i++) {
                        line = line (i > 1 ? " " : "") files[i]
                    }
                    print line
                }
            }
        }' | sort
}

find_dupes() {
    local dir="$1"
    find "$dir" -type f -exec md5 -r {} + | sort | awk '
        {
            md5 = $1
            file = $2
            if (md5 in groups) {
                groups[md5] = groups[md5] " " file
            } else {
                groups[md5] = file
            }
        }
        END {
            for (md5 in groups) {
                split(groups[md5], files, " ")
                if (length(files) >= 2) {
                    n = asort(files)
                    line = ""
                    for (i = 1; i <= n; i++) {
                        line = line (i > 1 ? " " : "") files[i]
                    }
                    print line
                }
            }
        }' | sort
}

find_dupes() {
    local dir="$1"
    find "$dir" -type f -exec md5 -r {} + | sort | awk '
        {
            md5 = $1
            file = $2
            if (md5 in groups) {
                groups[md5] = groups[md5] " " file
            } else {
                groups[md5] = file
            }
        }
        END {
            for (md5 in groups) {
                split(groups[md5], files, " ")
                if (length(files) >= 2) {
                    n = asort(files)
                    line = ""
                    for (i = 1; i <= n; i++) {
                        line = line (i > 1 ? " " : "") files[i]
                    }
                    print line
                }
            }
        }' | sort
}

top_errors() {
    local logfile="$1"
    local n="$2"
    grep -o 'ERROR: .*' "$logfile" | sed 's/^ERROR: //; s/[0-9]\+/#/g' | sort | uniq -c | sort -k1,1nr -k2,2 | head -n "$n" | awk '{print $1, $2}'
}

top_errors() {
    local logfile="$1"
    local n="$2"
    grep -o 'ERROR: .*' "$logfile" | sed 's/^ERROR: //; s/[0-9]\+/#/g' | sort | uniq -c | sort -k1,1nr -k2,2 | head -n "$n" | awk '{print $1, $2}'
}

top_errors() {
    local logfile="$1"
    local n="$2"
    grep -o 'ERROR: .*' "$logfile" | sed 's/^ERROR: //; s/[0-9]\+/#/g' | sort | uniq -c | sort -k1,1nr -k2,2 | head -n "$n" | awk '{print $1, $2}'
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c -- "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c -- "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c -- "$pattern" "$file" 2>/dev/null || echo 0
}

largest_file() {
    local dir="$1"
    local largest_path=""
    local largest_size=0
    while IFS= read -r -d '' file; do
        local size
        size=$(stat -c %s "$file" 2>/dev/null)
        if [[ -n "$size" && "$size" -gt "$largest_size" ]]; then
            largest_size="$size"
            largest_path="$file"
        fi
    done < <(find "$dir" -type f -print0)
    printf '%s\n' "$largest_path"
}

largest_file() {
    local dir="$1"
    local largest_path=""
    local largest_size=0
    while IFS= read -r -d '' file; do
        local size
        size=$(stat -c %s "$file" 2>/dev/null)
        if [[ -n "$size" && "$size" -gt "$largest_size" ]]; then
            largest_size="$size"
            largest_path="$file"
        fi
    done < <(find "$dir" -type f -print0)
    printf '%s\n' "$largest_path"
}

largest_file() {
    local dir="$1"
    local largest_path=""
    local largest_size=0
    while IFS= read -r -d '' file; do
        local size
        size=$(stat -c %s "$file" 2>/dev/null)
        if [[ -n "$size" && "$size" -gt "$largest_size" ]]; then
            largest_size="$size"
            largest_path="$file"
        fi
    done < <(find "$dir" -type f -print0)
    printf '%s\n' "$largest_path"
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

find_dupes() {
    local dir="$1"
    find "$dir" -type f -exec md5 -r {} + 2>/dev/null |
    awk '{
        hash = $1
        $1 = ""
        sub(/^ /, "")
        paths[hash] = paths[hash] " " $0
        count[hash]++
    }
    END {
        for (h in count) {
            if (count[h] > 1) {
                cmd = "echo \"" paths[h] "\" | tr ' ' '\n' | grep -v '^$' | sort | tr '\n' ' '"
                cmd | getline sorted
                close(cmd)
                sub(/ $/, "", sorted)
                print sorted
            }
        }
    }' | sort
}

find_dupes() {
    local dir="$1"
    find "$dir" -type f -exec md5 -r {} + 2>/dev/null |
    awk '{
        hash = $1
        $1 = ""
        sub(/^ /, "")
        paths[hash] = paths[hash] " " $0
        count[hash]++
    }
    END {
        for (h in count) {
            if (count[h] > 1) {
                cmd = "echo \"" paths[h] "\" | tr ' ' '\n' | grep -v '^$' | sort | tr '\n' ' '"
                cmd | getline sorted
                close(cmd)
                sub(/ $/, "", sorted)
                print sorted
            }
        }
    }' | sort
}

find_dupes() {
    local dir="$1"
    find "$dir" -type f -exec md5 -r {} + 2>/dev/null |
    awk '{
        hash = $1
        $1 = ""
        sub(/^ /, "")
        paths[hash] = paths[hash] " " $0
        count[hash]++
    }
    END {
        for (h in count) {
            if (count[h] > 1) {
                cmd = "echo \"" paths[h] "\" | tr ' ' '\n' | grep -v '^$' | sort | tr '\n' ' '"
                cmd | getline sorted
                close(cmd)
                sub(/ $/, "", sorted)
                print sorted
            }
        }
    }' | sort
}

top_errors() {
    local logfile="$1"
    local n="$2"
    grep -o 'ERROR: .*' "$logfile" 2>/dev/null | \
        sed 's/ERROR: //; s/[0-9]\+/#/g' | \
        sort | uniq -c | sort -k1,1nr -k2,2 | \
        head -n "$n" | \
        awk '{count=$1; $1=""; sub(/^ /, ""); print count " " $0}'
}

top_errors() {
    local logfile="$1"
    local n="$2"
    grep -o 'ERROR: .*' "$logfile" 2>/dev/null | \
        sed 's/ERROR: //' | \
        sed 's/[0-9]\+/#/g' | \
        sort | \
        uniq -c | \
        sort -k1,1nr -k2,2 | \
        head -n "$n" | \
        awk '{print $1 " " $2}'
}

top_errors() {
    local logfile="$1"
    local n="$2"
    grep -o 'ERROR: .*' "$logfile" 2>/dev/null | \
        sed 's/ERROR: //' | \
        sed 's/[0-9]\+/#/g' | \
        sort | \
        uniq -c | \
        sort -k1,1nr -k2,2 | \
        head -n "$n" | \
        awk '{print $1 " " $2}'
}

backup_rotate() {
    local dir="$1"
    local keep="$2"
    local files=()
    while IFS= read -r -d '' f; do
        files+=("$f")
    done < <(find "$dir" -maxdepth 1 -type f -name 'backup-*.tar.gz' -print0 | sort -rz)
    local count=${#files[@]}
    if (( count <= keep )); then
        return 0
    fi
    local to_delete=$((count - keep))
    local i
    for ((i = 0; i < to_delete; i++)); do
        local file="${files[i]}"
        rm -f "$file"
        basename "$file"
    done
}

backup_rotate() {
    local dir="$1"
    local keep="$2"
    local files=()
    while IFS= read -r -d '' f; do
        files+=("$f")
    done < <(find "$dir" -maxdepth 1 -type f -name 'backup-*.tar.gz' -print0 | sort -rz)
    local count=${#files[@]}
    if (( count <= keep )); then
        return 0
    fi
    local to_delete=$((count - keep))
    local i
    for ((i = 0; i < to_delete; i++)); do
        local file="${files[i]}"
        rm -f "$file"
        basename "$file"
    done
}

backup_rotate() {
    local dir="$1"
    local keep="$2"
    local files=()
    while IFS= read -r -d '' f; do
        files+=("$f")
    done < <(find "$dir" -maxdepth 1 -type f -name 'backup-*.tar.gz' -print0 | sort -rz)
    local count=${#files[@]}
    if (( count <= keep )); then
        return 0
    fi
    local to_delete=$((count - keep))
    local i
    for ((i = 0; i < to_delete; i++)); do
        local file="${files[i]}"
        rm -f "$file"
        basename "$file"
    done
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' | sort -rn | head -1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' 2>/dev/null | sort -rn | head -n1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' 2>/dev/null | sort -rn | head -n1 | cut -d' ' -f2-
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' |
    while IFS= read -r url; do
        echo "$url"
    done
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' |
    while IFS= read -r url; do
        echo "$url"
    done
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' |
    while IFS= read -r url; do
        echo "$url"
    done
}

csv_col() {
    local col_name="$1"
    local header_line=$(head -n 1)
    local col_num=0
    local found=0
    local IFS=','
    read -ra headers <<< "$header_line"
    for i in "${!headers[@]}"; do
        if [[ "${headers[$i]}" == "$col_name" ]]; then
            col_num=$((i + 1))
            found=1
            break
        fi
    done
    if [[ $found -eq 0 ]]; then
        return 1
    fi
    tail -n +2 | while IFS= read -r line; do
        if [[ -n "$line" ]]; then
            cut -d',' -f"$col_num" <<< "$line"
        fi
    done
}

csv_col() {
    local col_name="$1"
    local header_line=$(head -n 1)
    local col_num=0
    local found=0
    local IFS=','
    read -ra headers <<< "$header_line"
    for i in "${!headers[@]}"; do
        if [[ "${headers[$i]}" == "$col_name" ]]; then
            col_num=$((i + 1))
            found=1
            break
        fi
    done
    if [[ $found -eq 0 ]]; then
        return 1
    fi
    tail -n +2 | while IFS= read -r line; do
        if [[ -n "$line" ]]; then
            cut -d',' -f"$col_num" <<< "$line"
        fi
    done
}

find_dupes() {
    local dir="$1"
    local tmpfile
    tmpfile=$(mktemp)
    
    # Find all regular files and compute their MD5 hashes
    while IFS= read -r -d '' file; do
        if [[ -f "$file" ]]; then
            hash=$(md5 -r "$file" | awk '{print $1}')
            printf '%s\t%s\n' "$hash" "$file"
        fi
    done < <(find "$dir" -type f -print0) > "$tmpfile"
    
    # Group files by hash, filter groups with 2+ files, sort and output
    awk -F'\t' '
        {
            hash = $1
            file = $2
            files[hash] = files[hash] (files[hash] ? " " : "") file
            count[hash]++
        }
        END {
            for (h in count) {
                if (count[h] >= 2) {
                    n = split(files[h], arr, " ")
                    for (i = 0; i < n; i++) {
                        print arr[i]
                    }
                    print ""
                }
            }
        }
    ' "$tmpfile" | awk '
        BEGIN { RS = "" }
        {
            n = split($0, lines, "\n")
            for (i = 1; i <= n; i++) {
                if (lines[i] != "") files[i] = lines[i]
            }
            n = asort(files)
            for (i = 1; i <= n; i++) {
                printf "%s", files[i] (i < n ? " " : "")
            }
            print ""
        }
    '
    
    rm -f "$tmpfile"
}

find_dupes() {
    local dir="$1"
    local tmpfile
    tmpfile=$(mktemp)
    
    # Find all regular files and compute their MD5 hashes
    while IFS= read -r -d '' file; do
        if [[ -f "$file" ]]; then
            hash=$(md5 -r "$file" | awk '{print $1}')
            printf '%s\t%s\n' "$hash" "$file"
        fi
    done < <(find "$dir" -type f -print0) > "$tmpfile"
    
    # Group files by hash, filter groups with 2+ files, sort and output
    awk -F'\t' '
        {
            hash = $1
            file = $2
            files[hash] = files[hash] (files[hash] ? " " : "") file
            count[hash]++
        }
        END {
            for (h in count) {
                if (count[h] >= 2) {
                    n = split(files[h], arr, " ")
                    for (i = 0; i < n; i++) {
                        print arr[i]
                    }
                    print ""
                }
            }
        }
    ' "$tmpfile" | awk '
        BEGIN { RS = "" }
        {
            n = split($0, lines, "\n")
            for (i = 1; i <= n; i++) {
                sorted[i] = lines[i]
            }
            # Sort lines within the group
            for (i = 1; i <= n; i++) {
                for (j = i + 1; j <= n; j++) {
                    if (sorted[i] > sorted[j]) {
                        tmp = sorted[i]
                        sorted[i] = sorted[j]
                        sorted[j] = tmp
                    }
                }
            }
            # Output sorted group
            for (i = 1; i <= n; i++) {
                printf "%s", sorted[i]
                if (i < n) printf " "
            }
            printf "\n"
        }
    ' | sort -t' ' -k1,1
    
    rm -f "$tmpfile"
}

find_dupes() {
    local dir="$1"
    local tmpfile
    tmpfile=$(mktemp)
    
    # Find all regular files and compute their MD5 hashes
    while IFS= read -r -d '' file; do
        if [[ -f "$file" ]]; then
            hash=$(md5 -r "$file" | awk '{print $1}')
            printf '%s\t%s\n' "$hash" "$file"
        fi
    done < <(find "$dir" -type f -print0) > "$tmpfile"
    
    # Group files by hash, filter groups with 2+ files, sort and output
    awk -F'\t' '
        {
            hash = $1
            file = $2
            files[hash] = files[hash] (files[hash] ? " " : "") file
            count[hash]++
        }
        END {
            for (h in count) {
                if (count[h] >= 2) {
                    n = split(files[h], arr, " ")
                    for (i = 0; i < n; i++) {
                        print arr[i]
                    }
                    print ""
                }
            }
        }
    ' "$tmpfile" | awk '
        BEGIN { RS = "" }
        {
            n = split($0, lines, "\n")
            for (i = 1; i <= n; i++) {
                sorted[i] = lines[i]
            }
            # Sort lines within the group
            for (i = 1; i <= n; i++) {
                for (j = i + 1; j <= n; j++) {
                    if (sorted[i] > sorted[j]) {
                        tmp = sorted[i]
                        sorted[i] = sorted[j]
                        sorted[j] = tmp
                    }
                }
            }
            # Output sorted group
            for (i = 1; i <= n; i++) {
                printf "%s", sorted[i]
                if (i < n) printf " "
            }
            printf "\n"
        }
    ' | sort -t' ' -k1,1
    
    rm -f "$tmpfile"
}

backup_rotate() {
    local dir="$1"
    local keep="$2"
    local count
    count=$(find "$dir" -maxdepth 1 -type f -name 'backup-*.tar.gz' | wc -l)
    if (( count <= keep )); then
        return
    fi
    find "$dir" -maxdepth 1 -type f -name 'backup-*.tar.gz' | sort | head -n -keep | while IFS= read -r file; do
        basename "$file"
        rm "$file"
    done
}

backup_rotate() {
    local dir="$1"
    local keep="$2"
    local count
    count=$(find "$dir" -maxdepth 1 -type f -name 'backup-*.tar.gz' | wc -l)
    if (( count <= keep )); then
        return
    fi
    find "$dir" -maxdepth 1 -type f -name 'backup-*.tar.gz' | sort | head -n -keep | while IFS= read -r file; do
        basename "$file"
        rm "$file"
    done
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F "$pattern" "$file" 2>/dev/null | wc -l
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F "$pattern" "$file" 2>/dev/null | wc -l
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F "$pattern" "$file" 2>/dev/null | wc -l
}

largest_file() {
    find "$1" -type f -exec stat -c '%s %n' {} \; 2>/dev/null | sort -nr | head -n1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -exec stat -c '%s %n' {} \; 2>/dev/null | sort -nr | head -n1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -exec stat -c '%s %n' {} \; 2>/dev/null | sort -nr | head -n1 | cut -d' ' -f2-
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"<>]*'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"<>]*'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"<>]*'
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    grep -oP 'ERROR: \K.*' "$logfile" 2>/dev/null | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2 | \
    head -n "$n" | \
    awk '{count=$1; $1=""; sub(/^ /, ""); print count " " $0}'
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    grep -oP 'ERROR: \K.*' "$logfile" 2>/dev/null | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2 | \
    head -n "$n" | \
    awk '{count=$1; $1=""; sub(/^ /, ""); print count " " $0}'
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    grep -oP 'ERROR: \K.*' "$logfile" 2>/dev/null | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2 | \
    head -n "$n" | \
    awk '{count=$1; $1=""; sub(/^ /, ""); print count " " $0}'
}

largest_file() {
    local dir="$1"
    find "$dir" -type f -exec stat --format='%s %n' {} + 2>/dev/null | sort -rn | head -n 1 | cut -d' ' -f2-
}

largest_file() {
    local dir="$1"
    find "$dir" -type f -exec stat --format='%s %n' {} + 2>/dev/null | sort -rn | head -n 1 | cut -d' ' -f2-
}

largest_file() {
    local dir="$1"
    find "$dir" -type f -exec stat --format='%s %n' {} + 2>/dev/null | sort -rn | head -n 1 | cut -d' ' -f2-
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"<>()\[\]{}\'\',;!?]*'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"<>()\[\]{}\'\',;!?]*'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"<>()\[\]{}\'\',;!?]*'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ -z "$logfile" || -z "$n" ]]; then
        return
    fi

    if [[ ! -f "$logfile" ]]; then
        return
    fi

    grep 'ERROR: ' "$logfile" | \
        sed 's/ERROR: //' | \
        sed 's/[0-9]\+/#/g' | \
        sort | \
        uniq -c | \
        sort -k1,1nr -k2 | \
        head -n "$n" | \
        sed 's/^ *//'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ -z "$logfile" || -z "$n" ]]; then
        return
    fi

    if [[ ! -f "$logfile" ]]; then
        return
    fi

    grep 'ERROR: ' "$logfile" | \
        sed 's/ERROR: //' | \
        sed 's/[0-9]\+/#/g' | \
        sort | \
        uniq -c | \
        sort -k1,1nr -k2 | \
        head -n "$n" | \
        sed 's/^ *//'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ -z "$logfile" || -z "$n" ]]; then
        return
    fi

    if [[ ! -f "$logfile" ]]; then
        return
    fi

    grep 'ERROR: ' "$logfile" | \
        sed 's/ERROR: //' | \
        sed 's/[0-9]\+/#/g' | \
        sort | \
        uniq -c | \
        sort -k1,1nr -k2 | \
        head -n "$n" | \
        sed 's/^ *//'
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -c -F -x "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -c -F -x "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -c -F -x "$pattern" "$file" 2>/dev/null || echo 0
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' | sort -n | tail -n 1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' | sort -n | tail -n 1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' | sort -n | tail -n 1 | cut -d' ' -f2-
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+'
}

find_dupes() {
    local dir="${1:-.}"
    
    # Use find to get all regular files, then compute md5 for each.
    # We use a while loop to read the output of find to handle filenames with spaces/newlines safely.
    # However, to sort and group efficiently, we'll pipe through awk or sort.
    # Strategy:
    # 1. Find all regular files.
    # 2. For each file, compute md5 and print "md5 path".
    # 3. Sort by md5, then by path.
    # 4. Group by md5, collect paths, print groups with 2+ files.
    
    # Note: macOS md5 outputs "MD5 (filename) = hash" or "hash  filename" depending on version.
    # md5 -r outputs "hash  filename" (two spaces).
    
    # We need to handle filenames with newlines? The prompt says "space-separated paths", implying standard filenames.
    # But to be safe with spaces, we'll use null-delimited find if possible, but md5 -r doesn't support null.
    # We'll assume filenames don't contain newlines for simplicity, as is common in such tasks unless specified otherwise.
    # If newlines are possible, this approach breaks. Let's assume standard filenames.
    
    find "$dir" -type f -exec md5 -r {} + 2>/dev/null | \
    awk '{
        # md5 -r output: hash  filename
        # The hash is the first field. The filename starts after the first two spaces.
        # But awk splits by whitespace. So $1 is hash, $2 is filename?
        # No, if filename has spaces, $2..$NF is filename.
        # Let's reconstruct the filename.
        hash = $1
        # Remove the first two fields (hash and the two spaces are not fields, just delimiters)
        # Actually, md5 -r output is: "hash  filename"
        # So $1 is hash, and the rest is filename.
        # We need to get the filename part.
        # Substring from length of hash + 2
        fname = substr($0, length(hash) + 3)
        
        # Store paths by hash
        if (hash in files) {
            files[hash] = files[hash] "\n" fname
            count[hash]++
        } else {
            files[hash] = fname
            count[hash] = 1
            hashes[++num_hashes] = hash
        }
    }
    END {
        # We need to sort groups by first path.
        # So we need to collect all groups, then sort them.
        # Let's store groups in an array indexed by a counter.
        n = 0
        for (i = 1; i <= num_hashes; i++) {
            h = hashes[i]
            if (count[h] >= 2) {
                n++
                # Split the file list by newline
                split(files[h], farr, "\n")
                # Sort the paths within the group
                # Simple insertion sort for small groups
                for (j = 2; j <= count[h]; j++) {
                    key = farr[j]
                    k = j - 1
                    while (k > 0 && farr[k] > key) {
                        farr[k+1] = farr[k]
                        k--
                    }
                    farr[k+1] = key
                }
                # Build the line
                line = farr[1]
                for (j = 2; j <= count[h]; j++) {
                    line = line " " farr[j]
                }
                group_lines[n] = line
            }
        }
        
        # Sort group_lines by the first path (which is the first element of the space-separated list)
        # Since the line starts with the first path, we can sort the lines directly.
        # Insertion sort for group_lines
        for (i = 2; i <= n; i++) {
            key = group_lines[i]
            k = i - 1
            while (k > 0 && group_lines[k] > key) {
                group_lines[k+1] = group_lines[k]
                k--
            }
            group_lines[k+1] = key
        }
        
        for (i = 1; i <= n; i++) {
            print group_lines[i]
        }
    }'
}

find_dupes() {
    local dir="${1:-.}"
    
    # Use find to get all regular files, then compute md5 for each.
    # We use a while loop to read the output of find to handle filenames with spaces/newlines safely.
    # However, to sort and group efficiently, we'll pipe through awk or sort.
    # Strategy:
    # 1. Find all regular files.
    # 2. For each file, compute md5 and print "md5 path".
    # 3. Sort by md5, then by path.
    # 4. Group by md5, collect paths, print groups with 2+ files.
    
    # Note: macOS md5 outputs "MD5 (filename) = hash" or "hash  filename" depending on version.
    # md5 -r outputs "hash  filename" (two spaces).
    
    # We need to handle filenames with newlines? The prompt says "space-separated paths", implying standard filenames.
    # But to be safe with spaces, we'll use null-delimited find if possible, but md5 -r doesn't support null.
    # We'll assume filenames don't contain newlines for simplicity, as is common in such tasks unless specified otherwise.
    # If newlines are possible, this approach breaks. Let's assume standard filenames.
    
    find "$dir" -type f -exec md5 -r {} + 2>/dev/null | \
    awk '{
        # md5 -r output: hash  filename
        # The hash is the first field. The filename starts after the first two spaces.
        # But awk splits by whitespace. So $1 is hash, $2 is filename?
        # No, if filename has spaces, $2..$NF is filename.
        # Let's reconstruct the filename.
        hash = $1
        # Remove the first two fields (hash and the two spaces are not fields, just delimiters)
        # Actually, md5 -r output is: "hash  filename"
        # So $1 is hash, and the rest is filename.
        # We need to get the filename part.
        # Substring from length of hash + 2
        fname = substr($0, length(hash) + 3)
        
        # Store paths by hash
        if (hash in files) {
            files[hash] = files[hash] "\n" fname
            count[hash]++
        } else {
            files[hash] = fname
            count[hash] = 1
            hashes[++num_hashes] = hash
        }
    }
    END {
        # We need to sort groups by first path.
        # So we need to collect all groups, then sort them.
        # Let's store groups in an array indexed by a counter.
        n = 0
        for (i = 1; i <= num_hashes; i++) {
            h = hashes[i]
            if (count[h] >= 2) {
                n++
                # Split the file list by newline
                split(files[h], farr, "\n")
                # Sort the paths within the group
                # Simple insertion sort for small groups
                for (j = 2; j <= count[h]; j++) {
                    key = farr[j]
                    k = j - 1
                    while (k > 0 && farr[k] > key) {
                        farr[k+1] = farr[k]
                        k--
                    }
                    farr[k+1] = key
                }
                # Build the line
                line = farr[1]
                for (j = 2; j <= count[h]; j++) {
                    line = line " " farr[j]
                }
                group_lines[n] = line
            }
        }
        
        # Sort group_lines by the first path (which is the first element of the space-separated list)
        # Since the line starts with the first path, we can sort the lines directly.
        # Insertion sort for group_lines
        for (i = 2; i <= n; i++) {
            key = group_lines[i]
            k = i - 1
            while (k > 0 && group_lines[k] > key) {
                group_lines[k+1] = group_lines[k]
                k--
            }
            group_lines[k+1] = key
        }
        
        for (i = 1; i <= n; i++) {
            print group_lines[i]
        }
    }'
}

find_dupes() {
    local dir="${1:-.}"
    
    # Use find to get all regular files, then compute md5 for each.
    # We use a while loop to read the output of find to handle filenames with spaces/newlines safely.
    # However, to sort and group efficiently, we'll pipe through awk or sort.
    # Strategy:
    # 1. Find all regular files.
    # 2. For each file, compute md5 and print "md5 path".
    # 3. Sort by md5, then by path.
    # 4. Group by md5, collect paths, print groups with 2+ files.
    
    # Note: macOS md5 outputs "MD5 (filename) = hash" or "hash  filename" depending on version.
    # md5 -r outputs "hash  filename" (two spaces).
    
    # We need to handle filenames with newlines? The prompt says "space-separated paths", implying standard filenames.
    # But to be safe with spaces, we'll use null-delimited find if possible, but md5 -r doesn't support null.
    # We'll assume filenames don't contain newlines for simplicity, as is common in such tasks unless specified otherwise.
    # If newlines are possible, this approach breaks. Let's assume standard filenames.
    
    find "$dir" -type f -exec md5 -r {} + 2>/dev/null | \
    awk '{
        # md5 -r output: hash  filename
        # The hash is the first field. The filename starts after the first two spaces.
        # But awk splits by whitespace. So $1 is hash, $2 is filename?
        # No, if filename has spaces, $2..$NF is filename.
        # Let's reconstruct the filename.
        hash = $1
        # Remove the first two fields (hash and the two spaces are not fields, just delimiters)
        # Actually, md5 -r output is: "hash  filename"
        # So $1 is hash, and the rest is filename.
        # We need to get the filename part.
        # Substring from length of hash + 2
        fname = substr($0, length(hash) + 3)
        
        # Store paths by hash
        if (hash in files) {
            files[hash] = files[hash] "\n" fname
            count[hash]++
        } else {
            files[hash] = fname
            count[hash] = 1
            hashes[++num_hashes] = hash
        }
    }
    END {
        # We need to sort groups by first path.
        # So we need to collect all groups, then sort them.
        # Let's store groups in an array indexed by a counter.
        n = 0
        for (i = 1; i <= num_hashes; i++) {
            h = hashes[i]
            if (count[h] >= 2) {
                n++
                # Split the file list by newline
                split(files[h], farr, "\n")
                # Sort the paths within the group
                # Simple insertion sort for small groups
                for (j = 2; j <= count[h]; j++) {
                    key = farr[j]
                    k = j - 1
                    while (k > 0 && farr[k] > key) {
                        farr[k+1] = farr[k]
                        k--
                    }
                    farr[k+1] = key
                }
                # Build the line
                line = farr[1]
                for (j = 2; j <= count[h]; j++) {
                    line = line " " farr[j]
                }
                group_lines[n] = line
            }
        }
        
        # Sort group_lines by the first path (which is the first element of the space-separated list)
        # Since the line starts with the first path, we can sort the lines directly.
        # Insertion sort for group_lines
        for (i = 2; i <= n; i++) {
            key = group_lines[i]
            k = i - 1
            while (k > 0 && group_lines[k] > key) {
                group_lines[k+1] = group_lines[k]
                k--
            }
            group_lines[k+1] = key
        }
        
        for (i = 1; i <= n; i++) {
            print group_lines[i]
        }
    }'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ -z "$logfile" || -z "$n" ]]; then
        return 1
    fi

    if [[ ! -f "$logfile" ]]; then
        return 1
    fi

    # Extract ERROR lines, replace digits with #, count frequencies, sort, and print top n
    grep 'ERROR: ' "$logfile" 2>/dev/null | \
        sed 's/ERROR: //' | \
        sed 's/[0-9]*/#/g' | \
        sort | \
        uniq -c | \
        sort -k1,1nr -k2,2 | \
        head -n "$n" | \
        awk '{print $1, $2}'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ -z "$logfile" || -z "$n" ]]; then
        return 1
    fi

    if [[ ! -f "$logfile" ]]; then
        return 1
    fi

    # Extract ERROR lines, replace digits with #, count frequencies, sort, and print top n
    grep 'ERROR: ' "$logfile" 2>/dev/null | \
        sed 's/ERROR: //' | \
        sed 's/[0-9]*/#/g' | \
        sort | \
        uniq -c | \
        sort -k1,1nr -k2,2 | \
        head -n "$n" | \
        awk '{print $1, $2}'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ -z "$logfile" || -z "$n" ]]; then
        return 1
    fi

    if [[ ! -f "$logfile" ]]; then
        return 1
    fi

    # Extract ERROR lines, replace digits with #, count frequencies, sort, and print top n
    grep 'ERROR: ' "$logfile" 2>/dev/null | \
        sed 's/ERROR: //' | \
        sed 's/[0-9]*/#/g' | \
        sort | \
        uniq -c | \
        sort -k1,1nr -k2,2 | \
        head -n "$n" | \
        awk '{print $1, $2}'
}

count_matches() {
  local pattern="$1"
  local file="$2"
  if [[ -z "$pattern" || -z "$file" ]]; then
    echo 0
    return
  fi
  grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
  local pattern="$1"
  local file="$2"
  if [[ -z "$pattern" || -z "$file" ]]; then
    echo 0
    return
  fi
  grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
  local pattern="$1"
  local file="$2"
  if [[ -z "$pattern" || -z "$file" ]]; then
    echo 0
    return
  fi
  grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

largest_file() {
  find "$1" -type f -printf '%s %p\n' | sort -n | tail -n 1 | cut -d' ' -f2-
}

largest_file() {
  find "$1" -type f -printf '%s %p\n' | sort -n | tail -n 1 | cut -d' ' -f2-
}

largest_file() {
  find "$1" -type f -printf '%s %p\n' | sort -n | tail -n 1 | cut -d' ' -f2-
}

extract_urls() {
  grep -oE 'https?://[^[:space:]"<>'\''\)]+'
}

extract_urls() {
  grep -oE 'https?://[^[:space:]"<>'\''\)]+'
}

extract_urls() {
  grep -oE 'https?://[^[:space:]"<>'\''\)]+'
}

find_dupes() {
  local dir="$1"
  if [[ -z "$dir" ]]; then
    echo "Usage: find_dupes <dir>" >&2
    return 1
  fi

  # Find all regular files, compute MD5, format as "md5 path"
  # Using find -exec with md5 -r (BSD)
  find "$dir" -type f -exec md5 -r {} \; 2>/dev/null | \
  awk '{
    # md5 -r output format: "MD5 (file) = hash" or "hash  file" depending on version
    # On macOS, md5 -r outputs: "MD5 (file) = hash"
    # We need to extract the hash and the file path.
    # Actually, standard md5 -r on macOS outputs: "MD5 (filename) = hash"
    # Let's parse carefully.
    # Example: MD5 (path/to/file) = a1b2c3d4...
    if (match($0, /MD5 \((.+)\) = ([a-f0-9]+)/, arr)) {
      hash = arr[2]
      path = arr[1]
    } else {
      # Fallback for older or different format if needed, but assume standard BSD
      next
    }
    print hash, path
  }' | \
  sort -k1,1 -k2,2 | \
  awk '{
    if ($1 == prev_hash) {
      paths[NR] = paths[NR-1] " " $2
      count++
    } else {
      if (count > 1) {
        # Sort the paths for this group
        n = split(paths[NR], arr, " ")
        asort(arr)
        line = arr[1]
        for (i = 2; i <= n; i++) {
          line = line " " arr[i]
        }
        print line
      }
      prev_hash = $1
      paths[NR] = $2
      count = 1
    }
  }
  END {
    if (count > 1) {
      n = split(paths[NR], arr, " ")
      asort(arr)
      line = arr[1]
      for (i = 2; i <= n; i++) {
        line = line " " arr[i]
      }
      print line
    }
  }' | \
  sort
}

find_dupes() {
  local dir="$1"
  if [[ -z "$dir" ]]; then
    echo "Usage: find_dupes <dir>" >&2
    return 1
  fi

  # Find all regular files, compute MD5, format as "md5 path"
  # Using find -exec with md5 -r (BSD)
  find "$dir" -type f -exec md5 -r {} \; 2>/dev/null | \
  awk '{
    # md5 -r output format: "MD5 (file) = hash" or "hash  file" depending on version
    # On macOS, md5 -r outputs: "MD5 (file) = hash"
    # We need to extract the hash and the file path.
    # Actually, standard md5 -r on macOS outputs: "MD5 (filename) = hash"
    # Let's parse carefully.
    # Example: MD5 (path/to/file) = a1b2c3d4...
    if (match($0, /MD5 \((.+)\) = ([a-f0-9]+)/, arr)) {
      hash = arr[2]
      path = arr[1]
    } else {
      # Fallback for older or different format if needed, but assume standard BSD
      next
    }
    print hash, path
  }' | \
  sort -k1,1 -k2,2 | \
  awk '{
    if ($1 == prev_hash) {
      paths[NR] = paths[NR-1] " " $2
      count++
    } else {
      if (count > 1) {
        # Sort the paths for this group
        n = split(paths[NR], arr, " ")
        asort(arr)
        line = arr[1]
        for (i = 2; i <= n; i++) {
          line = line " " arr[i]
        }
        print line
      }
      prev_hash = $1
      paths[NR] = $2
      count = 1
    }
  }
  END {
    if (count > 1) {
      n = split(paths[NR], arr, " ")
      asort(arr)
      line = arr[1]
      for (i = 2; i <= n; i++) {
        line = line " " arr[i]
      }
      print line
    }
  }' | \
  sort
}

find_dupes() {
  local dir="$1"
  if [[ -z "$dir" ]]; then
    echo "Usage: find_dupes <dir>" >&2
    return 1
  fi

  # Find all regular files, compute MD5, format as "md5 path"
  # Using find -exec with md5 -r (BSD)
  find "$dir" -type f -exec md5 -r {} \; 2>/dev/null | \
  awk '{
    # md5 -r output format: "MD5 (file) = hash" or "hash  file" depending on version
    # On macOS, md5 -r outputs: "MD5 (file) = hash"
    # We need to extract the hash and the file path.
    # Actually, standard md5 -r on macOS outputs: "MD5 (filename) = hash"
    # Let's parse carefully.
    # Example: MD5 (path/to/file) = a1b2c3d4...
    if (match($0, /MD5 \((.+)\) = ([a-f0-9]+)/, arr)) {
      hash = arr[2]
      path = arr[1]
    } else {
      # Fallback for older or different format if needed, but assume standard BSD
      next
    }
    print hash, path
  }' | \
  sort -k1,1 -k2,2 | \
  awk '{
    if ($1 == prev_hash) {
      paths[NR] = paths[NR-1] " " $2
      count++
    } else {
      if (count > 1) {
        # Sort the paths for this group
        n = split(paths[NR], arr, " ")
        asort(arr)
        line = arr[1]
        for (i = 2; i <= n; i++) {
          line = line " " arr[i]
        }
        print line
      }
      prev_hash = $1
      paths[NR] = $2
      count = 1
    }
  }
  END {
    if (count > 1) {
      n = split(paths[NR], arr, " ")
      asort(arr)
      line = arr[1]
      for (i = 2; i <= n; i++) {
        line = line " " arr[i]
      }
      print line
    }
  }' | \
  sort
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    if [[ -z "$logfile" || -z "$n" ]]; then
        return 1
    fi

    grep -o 'ERROR: [^[:space:]]*' "$logfile" 2>/dev/null | \
    sed 's/ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2,2 | \
    head -n "$n" | \
    awk '{print $1, $2}'
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    if [[ -z "$logfile" || -z "$n" ]]; then
        return 1
    fi

    grep -o 'ERROR: [^[:space:]]*' "$logfile" 2>/dev/null | \
    sed 's/ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2,2 | \
    head -n "$n" | \
    awk '{print $1, $2}'
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    if [[ -z "$logfile" || -z "$n" ]]; then
        return 1
    fi

    grep -o 'ERROR: [^[:space:]]*' "$logfile" 2>/dev/null | \
    sed 's/ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2,2 | \
    head -n "$n" | \
    awk '{print $1, $2}'
}

largest_file() {
    find "$1" -type f -exec du -b {} + | sort -nr | head -n1 | cut -f2
}

largest_file() {
    find "$1" -type f -exec du -b {} + | sort -nr | head -n1 | cut -f2
}

largest_file() {
    find "$1" -type f -exec du -b {} + | sort -nr | head -n1 | cut -f2
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"]+' | sort -u
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"]+' | sort -u
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"]+' | sort -u
}

csv_col() {
    local -r name="$1"
    local -r header=$(head -n 1)
    local -r col_index=$(echo "$header" | tr ',' '\n' | grep -n "^${name}$" | cut -d: -f1)
    tail -n +2 | while IFS=, read -r -a row; do
        if [ "$col_index" -le "${#row[@]}" ]; then
            echo "${row[$((col_index - 1))]}"
        fi
    done
}

csv_col() {
    local -r name="$1"
    local -r header=$(head -n 1)
    local -r col_index=$(echo "$header" | tr ',' '\n' | grep -n "^${name}$" | cut -d: -f1)
    tail -n +2 | while IFS=, read -r -a row; do
        if [ "$col_index" -le "${#row[@]}" ]; then
            echo "${row[$((col_index - 1))]}"
        fi
    done
}

csv_col() {
    local -r name="$1"
    local -r header=$(head -n 1)
    local -r col_index=$(echo "$header" | tr ',' '\n' | grep -n "^${name}$" | cut -d: -f1)
    tail -n +2 | while IFS=, read -r -a row; do
        if [ "$col_index" -le "${#row[@]}" ]; then
            echo "${row[$((col_index - 1))]}"
        fi
    done
}

find_dupes() {
    dir="$1"
    find "$dir" -type f -exec md5 -r {} + | sort -k1,1 -k2,2 | uniq -w32 -d --all-repeated=prepend | awk '{print $2}' | sort -k1,1 | while read -r line; do
        paths=$(echo "$line" | sed 's/ .*//')
        count=$(echo "$line" | wc -w)
        if [ "$count" -ge 2 ]; then
            echo "$line"
        fi
    done
}

find_dupes() {
    dir="$1"
    find "$dir" -type f -exec md5 -r {} + | sort -k1,1 -k2,2 | uniq -w32 -d --all-repeated=prepend | awk '{print $2}' | sort -k1,1 | while read -r line; do
        paths=$(echo "$line" | sed 's/ .*//')
        count=$(echo "$line" | wc -w)
        if [ "$count" -ge 2 ]; then
            echo "$line"
        fi
    done
}

find_dupes() {
    dir="$1"
    find "$dir" -type f -exec md5 -r {} + | sort -k1,1 -k2,2 | uniq -w32 -d --all-repeated=prepend | awk '{print $2}' | sort -k1,1 | while read -r line; do
        paths=$(echo "$line" | sed 's/ .*//')
        count=$(echo "$line" | wc -w)
        if [ "$count" -ge 2 ]; then
            echo "$line"
        fi
    done
}

backup_rotate() {
    local dir="$1"
    local keep="$2"
    local files=()
    local deleted=()

    # Get all backup files, sort lexicographically (newest first)
    while IFS= read -r -d '' file; do
        files+=("$file")
    done < <(find "$dir" -maxdepth 1 -name 'backup-*.tar.gz' -print0 | sort -z -r)

    # Check if we have more files than we want to keep
    if (( ${#files[@]} > keep )); then
        # Delete oldest files (from position $keep onwards)
        for ((i=keep; i<${#files[@]}; i++)); do
            local filename=$(basename "${files[i]}")
            rm -f "${files[i]}"
            deleted+=("$filename")
        done
    fi

    # Print deleted files, oldest first
    for filename in "${deleted[@]}"; do
        echo "$filename"
    done
}

backup_rotate() {
    local dir="$1"
    local keep="$2"
    local files=()
    local deleted=()

    # Get all backup files, sort lexicographically (newest first)
    while IFS= read -r -d '' file; do
        files+=("$file")
    done < <(find "$dir" -maxdepth 1 -name 'backup-*.tar.gz' -print0 | sort -z -r)

    # Check if we have more files than we want to keep
    if (( ${#files[@]} > keep )); then
        # Delete oldest files (from position $keep onwards)
        for ((i=keep; i<${#files[@]}; i++)); do
            local filename=$(basename "${files[i]}")
            rm -f "${files[i]}"
            deleted+=("$filename")
        done
    fi

    # Print deleted files, oldest first
    for filename in "${deleted[@]}"; do
        echo "$filename"
    done
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

largest_file() {
    local dir="$1"
    local largest_path=""
    local largest_size=0

    while IFS= read -r -d '' file; do
        local size=$(stat -c %s "$file" 2>/dev/null)
        if [ "$size" -gt "$largest_size" ]; then
            largest_size="$size"
            largest_path="$file"
        fi
    done < <(find "$dir" -type f -printf '%p\0' 2>/dev/null)

    echo "$largest_path"
}

largest_file() {
    local dir="$1"
    local largest_path=""
    local largest_size=0

    while IFS= read -r -d '' file; do
        local size=$(stat -c %s "$file" 2>/dev/null)
        if [ "$size" -gt "$largest_size" ]; then
            largest_size=$size
            largest_path="$file"
        fi
    done < <(find "$dir" -type f -printf '%p\0' 2>/dev/null)

    echo "$largest_path"
}

largest_file() {
    local dir="$1"
    local largest_path=""
    local largest_size=0

    while IFS= read -r -d '' file; do
        local size=$(stat -c %s "$file" 2>/dev/null)
        if [ "$size" -gt "$largest_size" ]; then
            largest_size=$size
            largest_path="$file"
        fi
    done < <(find "$dir" -type f -printf '%p\0' 2>/dev/null)

    echo "$largest_path"
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' | sort -u
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' | sort -u
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' | sort -u
}

find_dupes() {
    local dir="$1"
    local temp_file=$(mktemp)
    local temp_list=$(mktemp)

    # Generate MD5 hashes for all regular files recursively
    find "$dir" -type f -exec md5 -r {} + | awk '{print $1, $2}' > "$temp_file"

    # Sort by hash, then by filename to group identical files together
    sort "$temp_file" > "$temp_list"

    # Iterate through sorted list, grouping files with identical hashes
    local current_hash=""
    local current_group=""
    local first_file=""

    while IFS=' ' read -r hash file; do
        if [ "$hash" != "$current_hash" ]; then
            # If we have a previous group with 2+ files, print it
            if [ -n "$current_group" ] && [ $(echo "$current_group" | wc -w) -ge 2 ]; then
                echo "$current_group"
            fi
            # Start a new group
            current_hash="$hash"
            current_group="$file"
            first_file="$file"
        else
            # Add file to current group
            current_group="$current_group $file"
        fi
    done < "$temp_list"

    # Print the last group if it has 2+ files
    if [ -n "$current_group" ] && [ $(echo "$current_group" | wc -w) -ge 2 ]; then
        echo "$current_group"
    fi

    # Cleanup
    rm "$temp_file" "$temp_list"
}

find_dupes() {
    local dir="$1"
    local temp_file=$(mktemp)
    local temp_list=$(mktemp)

    # Generate MD5 hashes for all regular files recursively
    find "$dir" -type f -exec md5 -r {} + | awk '{print $1, $2}' > "$temp_file"

    # Sort by hash, then by filename to group identical files together
    sort "$temp_file" > "$temp_list"

    # Iterate through sorted list, grouping files with identical hashes
    local current_hash=""
    local current_group=""
    local first_file=""

    while IFS=' ' read -r hash file; do
        if [ "$hash" != "$current_hash" ]; then
            # If we have a previous group with 2+ files, print it
            if [ -n "$current_group" ] && [ $(echo "$current_group" | wc -w) -ge 2 ]; then
                echo "$current_group"
            fi
            # Start a new group
            current_hash="$hash"
            current_group="$file"
            first_file="$file"
        else
            # Add file to current group
            current_group="$current_group $file"
        fi
    done < "$temp_list"

    # Print the last group if it has 2+ files
    if [ -n "$current_group" ] && [ $(echo "$current_group" | wc -w) -ge 2 ]; then
        echo "$current_group"
    fi

    # Cleanup
    rm "$temp_file" "$temp_list"
}

find_dupes() {
    local dir="$1"
    local temp_file=$(mktemp)
    local temp_list=$(mktemp)

    # Generate MD5 hashes for all regular files recursively
    find "$dir" -type f -exec md5 -r {} + | awk '{print $1, $2}' > "$temp_file"

    # Sort by hash, then by filename to group identical files together
    sort "$temp_file" > "$temp_list"

    # Iterate through sorted list, grouping files with identical hashes
    local current_hash=""
    local current_group=""
    local first_file=""

    while IFS=' ' read -r hash file; do
        if [ "$hash" != "$current_hash" ]; then
            # If we have a previous group with 2+ files, print it
            if [ -n "$current_group" ] && [ $(echo "$current_group" | wc -w) -ge 2 ]; then
                echo "$current_group"
            fi
            # Start a new group
            current_hash="$hash"
            current_group="$file"
            first_file="$file"
        else
            # Add file to current group
            current_group="$current_group $file"
        fi
    done < "$temp_list"

    # Print the last group if it has 2+ files
    if [ -n "$current_group" ] && [ $(echo "$current_group" | wc -w) -ge 2 ]; then
        echo "$current_group"
    fi

    # Cleanup
    rm "$temp_file" "$temp_list"
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    awk -v n="$n" '
    BEGIN { count = 0; }
    /ERROR: / {
        # Extract text after "ERROR: " and replace digits with #
        match($0, /ERROR: (.*)/, arr)
        sig = arr[1]
        gsub(/[0-9]+/, "#", sig)
        
        # Store signature and count
        sigs[count] = sig
        counts[count] = 1
        
        # Check if we have more than n entries
        if (count >= n) {
            # Find the minimum count among the first n entries
            min_count = counts[0]
            min_idx = 0
            for (i = 1; i < n; i++) {
                if (counts[i] < min_count) {
                    min_count = counts[i]
                    min_idx = i
                }
            }
            
            # If current count is greater than min_count, replace the min entry
            if (1 > min_count) {
                sigs[min_idx] = sig
                counts[min_idx] = 1
            }
        } else {
            count++
        }
    }
    END {
        # Prepare output array
        for (i = 0; i < count; i++) {
            output[i] = counts[i] " " sigs[i]
        }
        
        # Sort output: count desc, signature asc
        for (i = 0; i < count; i++) {
            for (j = i + 1; j < count; j++) {
                if (output[i] < output[j]) {
                    temp = output[i]
                    output[i] = output[j]
                    output[j] = temp
                }
            }
        }
        
        # Print results
        for (i = 0; i < count; i++) {
            print output[i]
        }
    }
    ' "$logfile"
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    awk -v n="$n" '
    BEGIN { count = 0; }
    /ERROR: / {
        # Extract text after "ERROR: " and replace digits with #
        match($0, /ERROR: (.*)/, arr)
        sig = arr[1]
        gsub(/[0-9]+/, "#", sig)
        
        # Store signature and count
        sigs[count] = sig
        counts[count] = 1
        
        # Check if we have more than n entries
        if (count >= n) {
            # Find the minimum count among the first n entries
            min_count = counts[0]
            min_idx = 0
            for (i = 1; i < n; i++) {
                if (counts[i] < min_count) {
                    min_count = counts[i]
                    min_idx = i
                }
            }
            
            # If current count is greater than min_count, replace the min entry
            if (1 > min_count) {
                sigs[min_idx] = sig
                counts[min_idx] = 1
            }
        } else {
            count++
        }
    }
    END {
        # Prepare array for sorting
        for (i = 0; i < count; i++) {
            if (counts[i] > 0) {
                sorted[counts[i]] = sorted[counts[i]] " " sigs[i]
            }
        }
        
        # Sort by count descending
        for (c = count; c >= 0; c--) {
            if (sorted[c] != "") {
                # Sort signatures for this count ascending
                n = split(sorted[c], arr, " ")
                for (i = 1; i <= n; i++) {
                    for (j = i + 1; j <= n; j++) {
                        if (arr[i] > arr[j]) {
                            temp = arr[i]
                            arr[i] = arr[j]
                            arr[j] = temp
                        }
                    }
                }
                for (i = 1; i <= n; i++) {
                    printf "%d %s\n", c, arr[i]
                }
            }
        }
    }
    ' "$logfile"
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    awk -v n="$n" '
    BEGIN { count = 0; }
    /ERROR: / {
        # Extract text after "ERROR: " and replace digits with #
        match($0, /ERROR: (.*)/, arr)
        sig = arr[1]
        gsub(/[0-9]+/, "#", sig)
        
        # Store signature and count
        sigs[count] = sig
        counts[count] = 1
        
        # Check if we have more than n entries
        if (count >= n) {
            # Find the minimum count among the first n entries
            min_count = counts[0]
            min_idx = 0
            for (i = 1; i < n; i++) {
                if (counts[i] < min_count) {
                    min_count = counts[i]
                    min_idx = i
                }
            }
            
            # If current count is greater than min_count, replace the min entry
            if (1 > min_count) {
                sigs[min_idx] = sig
                counts[min_idx] = 1
            }
        } else {
            count++
        }
    }
    END {
        # Prepare array for sorting
        for (i = 0; i < count; i++) {
            if (counts[i] > 0) {
                sorted[counts[i]] = sorted[counts[i]] " " sigs[i]
            }
        }
        
        # Sort by count descending
        for (c = count; c >= 0; c--) {
            if (sorted[c] != "") {
                # Sort signatures for this count ascending
                n = split(sorted[c], arr, " ")
                for (i = 1; i <= n; i++) {
                    for (j = i + 1; j <= n; j++) {
                        if (arr[i] > arr[j]) {
                            temp = arr[i]
                            arr[i] = arr[j]
                            arr[j] = temp
                        }
                    }
                }
                for (i = 1; i <= n; i++) {
                    printf "%d %s\n", c, arr[i]
                }
            }
        }
    }
    ' "$logfile"
}

backup_rotate() {
    local dir="$1"
    local keep="$2"
    local pattern="backup-*.tar.gz"
    local files=()

    # Find files matching the pattern and sort them lexicographically (newest first)
    while IFS= read -r -d '' file; do
        files+=("$file")
    done < <(find "$dir" -maxdepth 1 -type f -name "$pattern" -print0 | sort -z)

    # If we have fewer or equal files than keep, do nothing
    if (( ${#files[@]} <= keep )); then
        return
    fi

    # Calculate how many files to delete
    local to_delete=$(( ${#files[@]} - keep ))

    # Print the oldest files (last in the array) one per line
    for (( i=0; i<to_delete; i++ )); do
        local file="${files[$(( ${#files[@]} - 1 - i ))]}"
        # Extract just the filename from the full path
        local filename=$(basename "$file")
        echo "$filename"
    done
}

backup_rotate() {
    local dir="$1"
    local keep="$2"
    local pattern="backup-*.tar.gz"
    local files=()

    # Find files matching the pattern and sort them lexicographically (newest first)
    while IFS= read -r -d '' file; do
        files+=("$file")
    done < <(find "$dir" -maxdepth 1 -type f -name "$pattern" -print0 | sort -z)

    # If we have fewer or equal files than keep, do nothing
    if (( ${#files[@]} <= keep )); then
        return
    fi

    # Calculate how many files to delete
    local delete_count=$(( ${#files[@]} - keep ))

    # Print the oldest files (last in the array) one per line
    for (( i=0; i<delete_count; i++ )); do
        local file="${files[$(( ${#files[@]} - 1 - i ))]}"
        # Extract just the filename from the full path
        local filename=$(basename "$file")
        echo "$filename"
    done
}

backup_rotate() {
    local dir="$1"
    local keep="$2"
    local pattern="backup-*.tar.gz"
    local files=()

    # Find files matching the pattern and sort them lexicographically (newest first)
    while IFS= read -r -d '' file; do
        files+=("$file")
    done < <(find "$dir" -maxdepth 1 -type f -name "$pattern" -print0 | sort -z)

    # If we have fewer or equal files than keep, do nothing
    if (( ${#files[@]} <= keep )); then
        return
    fi

    # Calculate how many files to delete
    local delete_count=$(( ${#files[@]} - keep ))

    # Print the oldest files (last in the array) one per line
    for (( i=0; i<delete_count; i++ )); do
        local file="${files[$(( ${#files[@]} - 1 - i ))]}"
        # Extract just the filename from the full path
        local filename=$(basename "$file")
        echo "$filename"
    done
}

extract_urls() {
  grep -oE 'https?://[^[:space:]"]+'
}

extract_urls() {
  grep -oE 'https?://[^[:space:]"]+'
}

extract_urls() {
  grep -oE 'https?://[^[:space:]"]+'
}

csv_col() {
  local name="$1"
  local header
  local col_index
  local line

  header=$(head -n 1)
  col_index=$(echo "$header" | awk -F, -v name="$name" '{
    for (i=1; i<=NF; i++) {
      if ($i == name) {
        print i;
        exit;
      }
    }
    exit 1;
  }')

  if [ -z "$col_index" ]; then
    echo "Column '$name' not found in CSV header" >&2
    exit 1
  fi

  while IFS= read -r line; do
    echo "$line" | awk -F, -v index="$col_index" '{
      if (index <= NF) {
        print $index;
      }
    }'
  done
}

csv_col() {
  local name="$1"
  local header
  local col_index
  local line

  header=$(head -n 1)
  col_index=$(echo "$header" | awk -F, -v name="$name" '{
    for (i=1; i<=NF; i++) {
      if ($i == name) {
        print i;
        exit;
      }
    }
    exit 1;
  }')

  if [ -z "$col_index" ]; then
    echo "Column '$name' not found in CSV header" >&2
    exit 1
  fi

  while IFS= read -r line; do
    echo "$line" | awk -F, -v index="$col_index" '{
      if (index <= NF) {
        print $index;
      }
    }'
  done
}

csv_col() {
  local name="$1"
  local header
  local col_index
  local line

  header=$(head -n 1)
  col_index=$(echo "$header" | awk -F, -v name="$name" '{
    for (i=1; i<=NF; i++) {
      if ($i == name) {
        print i;
        exit;
      }
    }
    exit 1;
  }')

  if [ -z "$col_index" ]; then
    echo "Column '$name' not found in CSV header" >&2
    exit 1
  fi

  while IFS= read -r line; do
    echo "$line" | awk -F, -v index="$col_index" '{
      if (index <= NF) {
        print $index;
      }
    }'
  done
}

json_get() {
  local key="$1"
  local line
  while IFS= read -r line; do
    if [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*\"([^\"]*)\" ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    elif [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*\'([^\']*)\' ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    elif [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*([0-9]+) ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    elif [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*([a-z]+) ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    fi
  done
}

json_get() {
  local key="$1"
  local line
  while IFS= read -r line; do
    if [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*\"([^\"]*)\" ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    elif [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*\'([^\']*)\' ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    elif [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*([0-9]+) ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    elif [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*([a-z]+) ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    fi
  done
}

json_get() {
  local key="$1"
  local line
  while IFS= read -r line; do
    if [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*\"([^\"]*)\" ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    elif [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*\'([^\']*)\' ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    elif [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*([0-9]+) ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    elif [[ "$line" =~ ^[[:space:]]*\"$key\"[[:space:]]*:[[:space:]]*([a-z]+) ]]; then
      echo "${BASH_REMATCH[1]}"
      return
    fi
  done
}

find_dupes() {
  local dir="$1"
  find "$dir" -type f -exec md5 -r {} + | sort | awk '{
    md5=$1
    path=$2
    if (md5 != prev) {
      if (NR > 1) {
        if (count > 1) {
          for (i=1; i<=count; i++) print paths[i]
        }
        delete paths
      }
      count=1
      paths[count]=path
      prev=md5
    } else {
      count++
      paths[count]=path
    }
  } END {
    if (count > 1) {
      for (i=1; i<=count; i++) print paths[i]
    }
  }' | sort
}

find_dupes() {
  local dir="$1"
  find "$dir" -type f -exec md5 -r {} + | sort | awk '{
    md5=$1
    path=$2
    if (md5 != prev) {
      if (NR > 1) {
        if (count > 1) {
          for (i=1; i<=count; i++) print paths[i]
        }
        delete paths
      }
      count=1
      paths[count]=path
      prev=md5
    } else {
      count++
      paths[count]=path
    }
  } END {
    if (count > 1) {
      for (i=1; i<=count; i++) print paths[i]
    }
  }' | sort
}

find_dupes() {
  local dir="$1"
  find "$dir" -type f -exec md5 -r {} + | sort | awk '{
    md5=$1
    path=$2
    if (md5 != prev) {
      if (NR > 1) {
        if (count > 1) {
          for (i=1; i<=count; i++) print paths[i]
        }
        delete paths
      }
      count=1
      paths[count]=path
      prev=md5
    } else {
      count++
      paths[count]=path
    }
  } END {
    if (count > 1) {
      for (i=1; i<=count; i++) print paths[i]
    }
  }' | sort
}

top_errors() {
  local logfile="$1"
  local n="$2"
  awk -F'ERROR: ' '/ERROR:/ {print $2}' "$logfile" | sed 's/[0-9][0-9]*/#/g' | sort | uniq -c | sort -nr | head -n "$n" | awk '{count=$1; $1=""; print count, substr($0, 2)}' | sort -k1,1nr -k2,2 | awk '{print $2}'
}

top_errors() {
  local logfile="$1"
  local n="$2"
  awk -F'ERROR: ' '/ERROR:/ {print $2}' "$logfile" | sed 's/[0-9][0-9]*/#/g' | sort | uniq -c | sort -nr | head -n "$n" | awk '{count=$1; $1=""; print count, substr($0, 2)}' | sort -k1,1nr -k2,2 | awk '{print $2}'
}

top_errors() {
  local logfile="$1"
  local n="$2"
  awk -F'ERROR: ' '/ERROR:/ {print $2}' "$logfile" | sed 's/[0-9][0-9]*/#/g' | sort | uniq -c | sort -nr | head -n "$n" | awk '{count=$1; $1=""; print count, substr($0, 2)}' | sort -k1,1nr -k2,2 | awk '{print $2}'
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c "$pattern" "$file" 2>/dev/null || echo 0
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' | sort -rn | head -n 1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' | sort -rn | head -n 1 | cut -d' ' -f2-
}

largest_file() {
    find "$1" -type f -printf '%s %p\n' | sort -rn | head -n 1 | cut -d' ' -f2-
}

retry3() {
    local cmd=("$@")
    local max_attempts=3
    local attempt=1

    while [ $attempt -le $max_attempts ]; do
        if "${cmd[@]}"; then
            return 0
        fi
        ((attempt++))
    done

    return $?
}

retry3() {
    local cmd=("$@")
    local max_attempts=3
    local attempt=1

    while [ $attempt -le $max_attempts ]; do
        if "${cmd[@]}"; then
            return 0
        fi
        ((attempt++))
    done

    return $?
}

retry3() {
    local cmd=("$@")
    local max_attempts=3
    local attempt=1

    while [ $attempt -le $max_attempts ]; do
        if "${cmd[@]}"; then
            return 0
        fi
        ((attempt++))
    done

    return $?
}

extract_urls() {
    grep -oE 'https?://[^[:space:]<>"]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]<>"]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]<>"]+'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ ! -f "$logfile" ]]; then
        return 0
    fi

    grep 'ERROR: ' "$logfile" 2>/dev/null | \
    sed 's/.*ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2,2 | \
    head -n "$n" | \
    awk '{print $1, $2}'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ ! -f "$logfile" ]]; then
        return 0
    fi

    grep 'ERROR: ' "$logfile" 2>/dev/null | \
    sed 's/.*ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2,2 | \
    head -n "$n" | \
    awk '{print $1, $2}'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    if [[ ! -f "$logfile" ]]; then
        return 0
    fi

    grep 'ERROR: ' "$logfile" 2>/dev/null | \
    sed 's/.*ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2,2 | \
    head -n "$n" | \
    awk '{print $1, $2}'
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c -- "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c -- "$pattern" "$file" 2>/dev/null || echo 0
}

count_matches() {
    local pattern="$1"
    local file="$2"
    grep -F -c -- "$pattern" "$file" 2>/dev/null || echo 0
}

largest_file() {
  find "$1" -type f -printf '%s\t%p\n' | sort -rn | head -n 1 | cut -f2
}

largest_file() {
  find "$1" -type f -printf '%s\t%p\n' | sort -rn | head -n 1 | cut -f2
}

largest_file() {
  find "$1" -type f -printf '%s\t%p\n' | sort -rn | head -n 1 | cut -f2
}

retry3() {
    local attempts=3
    local exit_code=1
    while (( attempts > 0 )); do
        if "$@"; then
            exit_code=0
            break
        fi
        exit_code=$?
        (( attempts-- ))
    done
    return $exit_code
}

retry3() {
    local attempts=3
    local exit_code=1
    while (( attempts > 0 )); do
        if "$@"; then
            exit_code=0
            break
        fi
        exit_code=$?
        (( attempts-- ))
    done
    return $exit_code
}

retry3() {
    local attempts=3
    local exit_code=1
    while (( attempts > 0 )); do
        if "$@"; then
            exit_code=0
            break
        fi
        exit_code=$?
        (( attempts-- ))
    done
    return $exit_code
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"<>()]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"<>()]+'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]"<>()]+'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    grep 'ERROR:' "$logfile" 2>/dev/null | \
    sed 's/.*ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2,2 | \
    head -n "$n" | \
    awk '{print $1, substr($0, index($0, $2))}'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    grep 'ERROR:' "$logfile" 2>/dev/null | \
    sed 's/.*ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2,2 | \
    head -n "$n" | \
    awk '{print $1, substr($0, index($0, $2))}'
}

top_errors() {
    local logfile="$1"
    local n="$2"

    grep 'ERROR:' "$logfile" 2>/dev/null | \
    sed 's/.*ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -k1,1nr -k2,2 | \
    head -n "$n" | \
    awk '{print $1, substr($0, index($0, $2))}'
}

count_matches() {
    local pattern="$1"
    local file="$2"
    
    if [[ -f "$file" ]]; then
        grep -c "^$pattern$" "$file" 2>/dev/null | head -1
    else
        echo "0"
    fi
}

count_matches() {
    local pattern="$1"
    local file="$2"
    
    if [[ -f "$file" ]]; then
        grep -c "^$pattern$" "$file" 2>/dev/null | head -1
    else
        echo "0"
    fi
}

count_matches() {
    local pattern="$1"
    local file="$2"
    
    if [[ -f "$file" ]]; then
        grep -c "^$pattern$" "$file" 2>/dev/null | head -1
    else
        echo "0"
    fi
}

largest_file() {
    find "$1" -type f -exec du -b {} + 2>/dev/null | sort -nr | head -1 | cut -f2
}

largest_file() {
    find "$1" -type f -exec du -b {} + 2>/dev/null | sort -nr | head -1 | cut -f2
}

largest_file() {
    find "$1" -type f -exec du -b {} + 2>/dev/null | sort -nr | head -1 | cut -f2
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' | grep -vE '^[^/]*$'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' | grep -vE '^[^/]*$'
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' | grep -vE '^[^/]*$'
}

rotate() {
    local file="$1"
    local backup="${file}.1"
    
    if [[ -f "$backup" ]]; then
        local i=9
        while [[ $i -gt 1 ]]; do
            local prev_backup="${file}.${i}"
            local next_backup="${file}.$((i+1))"
            if [[ -f "$prev_backup" ]]; then
                mv "$prev_backup" "$next_backup"
            fi
            ((i--))
        done
        mv "$file" "${file}.1"
    else
        mv "$file" "${file}.1"
    fi
}

rotate() {
    local file="$1"
    local backup="${file}.1"
    
    if [[ -f "$backup" ]]; then
        local i=9
        while [[ $i -gt 1 ]]; do
            local prev="{$file}.${i}"
            local next="{$file}.${((i+1))"
            if [[ -f "$prev" ]]; then
                mv "$prev" "$next"
            fi
            ((i--))
        done
        mv "$file" "$backup"
    else
        mv "$file" "$backup"
    fi
}

rotate() {
    local file="$1"
    local backup="${file}.1"
    
    if [[ -f "$backup" ]]; then
        local i=9
        while [[ $i -gt 1 ]]; do
            local prev="{$file}.${i}"
            local next="{$file}.${((i+1))"
            if [[ -f "$prev" ]]; then
                mv "$prev" "$next"
            fi
            ((i--))
        done
        mv "$file" "$backup"
    else
        mv "$file" "$backup"
    fi
}

csv_col() {
    local col_name="$1"
    local col_num=$(head -n1 | tr ',' '\n' | grep -n "^$col_name$" | cut -d: -f1)
    if [ -z "$col_num" ]; then
        return 1
    fi
    cut -d',' -f"$col_num" | tail -n +2
}

csv_col() {
    local col_name="$1"
    local col_num=$(head -n1 | tr ',' '\n' | grep -n "^$col_name$" | cut -d: -f1)
    if [ -z "$col_num" ]; then
        return 1
    fi
    cut -d',' -f"$col_num" | tail -n +2
}

csv_col() {
    local col_name="$1"
    local col_num=$(head -n1 | tr ',' '\n' | grep -n "^$col_name$" | cut -d: -f1)
    if [ -z "$col_num" ]; then
        return 1
    fi
    cut -d',' -f"$col_num" | tail -n +2
}

find_dupes() {
    local dir="$1"
    local temp_file
    temp_file=$(mktemp)
    
    find "$dir" -type f -exec md5 -r {} \; 2>/dev/null | sort > "$temp_file"
    
    awk '{
        if ($0 == prev) {
            if (first == "") first = prev_file
            dupes = dupes " " $2
        } else {
            if (first != "") {
                if (dupes != "") {
                    echo "$first$dupes" | tr ' ' '\n' | sort | tr '\n' ' ' | sed 's/ $//'
                }
                first = ""
                dupes = ""
            }
            prev = $0
            prev_file = $2
        }
    }
    END {
        if (first != "") {
            if (dupes != "") {
                echo "$first$dupes" | tr ' ' '\n' | sort | tr '\n' ' ' | sed 's/ $//'
            }
        }
    }' "$temp_file"
    
    rm -f "$temp_file"
}

find_dupes() {
    local dir="$1"
    local temp_file
    temp_file=$(mktemp)
    
    find "$dir" -type f -exec md5 -r {} \; 2>/dev/null | sort > "$temp_file"
    
    awk '{
        if ($0 == prev) {
            if (first == "") first = prev_file
            dupes = dupes " " $2
        } else {
            if (first != "") {
                if (dupes != "") {
                    echo "$first$dupes" | tr ' ' '\n' | sort | tr '\n' ' ' | sed 's/ $//'
                }
                first = ""
                dupes = ""
            }
            prev = $0
            prev_file = $2
        }
    }
    END {
        if (first != "") {
            if (dupes != "") {
                echo "$first$dupes" | tr ' ' '\n' | sort | tr '\n' ' ' | sed 's/ $//'
            }
        }
    }' "$temp_file"
    
    rm -f "$temp_file"
}

find_dupes() {
    local dir="$1"
    local temp_file
    temp_file=$(mktemp)
    
    find "$dir" -type f -exec md5 -r {} \; 2>/dev/null | sort > "$temp_file"
    
    awk '{
        if ($0 == prev) {
            if (first == "") first = prev_file
            dupes = dupes " " $2
        } else {
            if (first != "") {
                if (dupes != "") {
                    echo "$first$dupes" | tr ' ' '\n' | sort | tr '\n' ' ' | sed 's/ $//'
                }
                first = ""
                dupes = ""
            }
            prev = $0
            prev_file = $2
        }
    }
    END {
        if (first != "") {
            if (dupes != "") {
                echo "$first$dupes" | tr ' ' '\n' | sort | tr '\n' ' ' | sed 's/ $//'
            }
        }
    }' "$temp_file"
    
    rm -f "$temp_file"
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    if [[ ! -f "$logfile" ]]; then
        return
    fi
    
    grep '^ERROR: ' "$logfile" | \
    sed 's/^ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -nr | \
    head -n "$n" | \
    while read count signature; do
        echo "$count $signature"
    done
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    if [[ ! -f "$logfile" ]]; then
        return
    fi
    
    grep '^ERROR: ' "$logfile" | \
    sed 's/^ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -nr | \
    head -n "$n" | \
    while read count signature; do
        echo "$count $signature"
    done
}

top_errors() {
    local logfile="$1"
    local n="$2"
    
    if [[ ! -f "$logfile" ]]; then
        return
    fi
    
    grep '^ERROR: ' "$logfile" | \
    sed 's/^ERROR: //' | \
    sed 's/[0-9]\+/#/g' | \
    sort | \
    uniq -c | \
    sort -nr | \
    head -n "$n" | \
    while read count signature; do
        echo "$count $signature"
    done
}

backup_rotate() {
    local dir="$1"
    local keep="$2"
    local -a backups
    local i=0
    
    # Find all backup-*.tar.gz files
    while IFS= read -r -d '' file; do
        backups[i]="${file##*/}"
        ((i++))
    done < <(find "$dir" -maxdepth 1 -name 'backup-*.tar.gz' -print0 2>/dev/null)
    
    local count=${#backups[@]}
    
    # If we have <= keep backups, do nothing
    if (( count <= keep )); then
        return
    fi
    
    # Sort backups lexicographically (newest first)
    IFS=$'\n' sorted=($(sort -r <<<"${backups[*]}"))
    unset IFS
    
    # Delete the oldest backups (keep the newest keep ones)
    local delete_count=$((count - keep))
    for ((i=0; i<delete_count; i++)); do
        echo "${sorted[i]}"
        rm -f "$dir/${sorted[i]}"
    done
}

largest_file() {
    local dir="$1"
    find "$dir" -type f -printf '%s\t%p\n' 2>/dev/null | sort -nr | head -n 1 | cut -f2-
}

largest_file() {
    local dir="$1"
    find "$dir" -type f -printf '%s\t%p\n' 2>/dev/null | sort -nr | head -n 1 | cut -f2-
}

largest_file() {
    local dir="$1"
    find "$dir" -type f -printf '%s\t%p\n' 2>/dev/null | sort -nr | head -n 1 | cut -f2-
}

retry3() {
    local attempt
    for attempt in 1 2 3; do
        if "$@"; then
            return 0
        fi
    done
    return $?
}

retry3() {
    local attempt
    for attempt in 1 2 3; do
        if "$@"; then
            return 0
        fi
    done
    return $?
}

retry3() {
    local attempt
    for attempt in 1 2 3; do
        if "$@"; then
            return 0
        fi
    done
    return $?
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' || true
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' || true
}

extract_urls() {
    grep -oE 'https?://[^[:space:]]+' || true
}

rotate() {
    local file="$1"
    local i=1
    while [ -e "$file.$i" ]; do
        i=$((i + 1))
    done
    if [ "$i" -gt 2 ]; then
        mv "$file.$((i - 1))" "$file.$i"
    fi
    mv "$file" "$file.1"
}

rotate() {
    local file="$1"
    local i=1
    while [ -e "$file.$i" ]; do
        i=$((i + 1))
    done
    if [ "$i" -gt 2 ]; then
        mv "$file.$((i - 1))" "$file.$i"
    fi
    mv "$file" "$file.1"
}

json_get() {
    python3 -c 'import json,sys; print(json.load(sys.stdin)["$1"])'
}

json_get() {
    python3 -c 'import json,sys; print(json.load(sys.stdin)["$1"])'
}

json_get() {
    python3 -c 'import json,sys; print(json.load(sys.stdin)["$1"])'
}

find_dupes() {
    local dir="$1"
    [ -d "$dir" ] || return 1
    local tmp
    tmp=$(mktemp -t find_dupes.XXXXXX) || return 1
    trap 'rm -f "$tmp"' RETURN

    find "$dir" -type f -print0 2>/dev/null | while IFS= read -r -d '' f; do
        md5=$(md5 -q "$f" 2>/dev/null) || continue
        printf '%s\t%s\n' "$md5" "$f"
    done | sort -k1,1 -k2,2 > "$tmp"

    awk -F '\t' '
        NR == 1 || $1 != prev {
            if (count > 1) {
                for (i = 1; i <= count; i++) {
                    if (i > 1) printf " "
                    printf "%s", paths[i]
                }
                printf "\n"
            }
            count = 0
        }
        prev = $1
        paths[++count] = $2
        last = $2
    END {
        if (count > 1) {
            for (i = 1; i <= count; i++) {
                if (i > 1) printf " "
                printf "%s", paths[i]
            }
            printf "\n"
        }
    }' "$tmp"
}

find_dupes() {
    local dir="$1"
    [ -d "$dir" ] || return 1
    local tmp
    tmp=$(mktemp -t find_dupes.XXXXXX) || return 1
    trap 'rm -f "$tmp"' RETURN

    find "$dir" -type f -print0 2>/dev/null | while IFS= read -r -d '' f; do
        md5=$(md5 -q "$f" 2>/dev/null) || continue
        printf '%s\t%s\n' "$md5" "$f"
    done | sort -k1,1 -k2,2 > "$tmp"

    awk -F '\t' '
        NR == 1 || $1 != prev {
            if (count > 1) {
                for (i = 1; i <= count; i++) {
                    if (i > 1) printf " "
                    printf "%s", paths[i]
                }
                printf "\n"
            }
            count = 0
        }
        prev = $1
        paths[++count] = $2
        last = $2
    END {
        if (count > 1) {
            for (i = 1; i <= count; i++) {
                if (i > 1) printf " "
                printf "%s", paths[i]
            }
            printf "\n"
        }
    }' "$tmp"
}

find_dupes() {
    local dir="$1"
    [ -d "$dir" ] || return 1
    local tmp
    tmp=$(mktemp -t find_dupes.XXXXXX) || return 1
    trap 'rm -f "$tmp"' RETURN

    find "$dir" -type f -print0 2>/dev/null | while IFS= read -r -d '' f; do
        md5=$(md5 -q "$f" 2>/dev/null) || continue
        printf '%s\t%s\n' "$md5" "$f"
    done | sort -k1,1 -k2,2 > "$tmp"

    awk -F '\t' '
        NR == 1 || $1 != prev {
            if (count > 1) {
                for (i = 1; i <= count; i++) {
                    if (i > 1) printf " "
                    printf "%s", paths[i]
                }
                printf "\n"
            }
            count = 0
        }
        prev = $1
        paths[++count] = $2
        last = $2
    END {
        if (count > 1) {
            for (i = 1; i <= count; i++) {
                if (i > 1) printf " "
                printf "%s", paths[i]
            }
            printf "\n"
        }
    }' "$tmp"
}

backup_rotate() {
    local dir="$1" keep="$2"
    local files
    files=$(find "$dir" -maxdepth 1 -type f -name 'backup-*.tar.gz' -printf '%f\n' | sort -r)
    local count
    count=$(printf '%s\n' "$files" | grep -c .)
    if [ "$count" -le "$keep" ]; then
        return 0
    fi
    local to_delete=$((count - keep))
    printf '%s\n' "$files" | tail -n "$to_delete" | while IFS= read -r f; do
        rm -f "$dir/$f"
        printf '%s\n' "$f"
    done
}

backup_rotate() {
    local dir="$1" keep="$2"
    local files
    files=$(find "$dir" -maxdepth 1 -type f -name 'backup-*.tar.gz' -printf '%f\n' | sort -r)
    local count
    count=$(printf '%s\n' "$files" | grep -c .)
    if [ "$count" -le "$keep" ]; then
        return 0
    fi
    local to_delete=$((count - keep))
    printf '%s\n' "$files" | tail -n "$to_delete" | sort
    printf '%s\n' "$files" | tail -n "$to_delete" | while IFS= read -r f; do
        rm -- "$dir/$f"
    done
}

backup_rotate() {
    local dir="$1" keep="$2"
    local files
    files=$(find "$dir" -maxdepth 1 -type f -name 'backup-*.tar.gz' -printf '%f\n' | sort -r)
    local count
    count=$(printf '%s\n' "$files" | grep -c .)
    if [ "$count" -le "$keep" ]; then
        return 0
    fi
    local to_delete=$((count - keep))
    printf '%s\n' "$files" | tail -n "$to_delete" | sort
    printf '%s\n' "$files" | tail -n "$to_delete" | while IFS= read -r f; do
        rm -- "$dir/$f"
    done
}

count_matches() { grep -F "$1" "$2" | wc -l; }

count_matches() { grep -F "$1" "$2" | wc -l; }

count_matches() { grep -F "$1" "$2" | wc -l; }

largest_file() {
  find "$1" -type f -printf "%s\t%p\n" | sort -k1,1nr | head -n1 | cut -f2-
}

largest_file() {
  find "$1" -type f -printf "%s\t%p\n" | sort -k1,1nr | head -n1 | cut -f2-
}

largest_file() {
  find "$1" -type f -printf "%s\t%p\n" | sort -k1,1nr | head -n1 | cut -f2-
}

extract_urls() {
  grep -o 'https?://[^\s]*'
}

extract_urls() {
  grep -o 'https?://[^\s]*'
}

extract_urls() {
  grep -o 'https?://[^\s]*'
}

csv_col() {
  local col="$1"
  awk -v target="$col" '
    NR == 1 {
      for (i = 1; i <= NF; i++) {
        if ($i == target) { idx = i; break }
      }
    }
    NR > 1 { print $idx }
  '
}

json_get() {
  python3 -c '
import json
import sys
data = json.load(sys.stdin)
print(json.dumps(data[sys.argv[1]]))
' "$1"
}

json_get() {
  python3 -c '
import json
import sys
data = json.load(sys.stdin)
print(json.dumps(data[sys.argv[1]]))
' "$1"
}

json_get() {
  python3 -c '
import json
import sys
data = json.load(sys.stdin)
print(json.dumps(data[sys.argv[1]]))
' "$1"
}

find_dupes() {
	local dir="$1"
	find "$dir" -type f -print0 | while IFS= read -r -d '' file; do
		md5 -r "$file" | awk '{print $1}'
		echo -n $'\0'
		echo "$file"
		echo -n $'\0'
	done | sort -z | uniq -zD | while IFS= read -r -d '' line; do
		echo "$line" | tr '\0' '\n' | sort | tr '\n' ' ' | sed 's/ $//'
	done
}

find_dupes() {
	local dir="${1:-.}" shopt -s nullglob globstar
	mapfile -t files < <(find "$dir" -type f)
	declare -A md5_map
	for file in "${files[@]}"; do
		md5=$(md5 -rq "$file")
		md5_map["$md5"]+="$file "
	done
	for md5 in "${!md5_map[@]}"; do
		paths=(${md5_map["$md5"]})
		(( ${#paths[@]} >= 2 )) || continue
		IFS=$' ' sorted=($(printf '%s\n' "${paths[@]}" | sort))
		echo "${sorted[*]}"
	done | sort -f
}

find_dupes() {
	local dir="$1"
	find "$dir" -type f -print0 | while IFS= read -r -d '' file; do
		md5 -r "$file" | awk '{print $1}'
		echo -n "$file"$'\0'
	done | sort -z | while IFS= read -r -d '' line; do
		[[ $line =~ ^[0-9a-f]{32}$ ]] && hash="$line" && files=() || files+=("$line")
	done | {
		local hash files
		while IFS= read -r -d '' line; do
			if [[ $line =~ ^[0-9a-f]{32}$ ]]; then
				[[ ${#files[@]} -ge 2 ]] && IFS=$' ' echo "${files[*]}"
				hash="$line"
				files=()
			else
				files+=("$line")
			fi
		done
		[[ ${#files[@]} -ge 2 ]] && IFS=$' ' echo "${files[*]}"
	} | sort
}

top_errors() {
  awk '/ERROR: / { sig = substr($0, index($0, "ERROR: ") + 7); gsub(/[0-9]+/, "#", sig); print sig }' "$1" | sort | uniq -c | sort -k1nr -k2 | head -n "$2"
}

top_errors() {
  awk '/ERROR: / { sig = substr($0, index($0, "ERROR: ") + 7); gsub(/[0-9]+/, "#", sig); print sig }' "$1" | sort | uniq -c | sort -k1nr -k2 | head -n "$2"
}

top_errors() {
  awk '/ERROR: / { sig = substr($0, index($0, "ERROR: ") + 7); gsub(/[0-9]+/, "#", sig); print sig }' "$1" | sort | uniq -c | sort -k1nr -k2 | head -n "$2"
}

function largest_file() {
    local dir="$1"
    local max_size=0
    local max_file=""
    find "$dir" -type f -exec du -ch {} + | sort -rh | awk '{ if ($1 > '$(printf "%d\n" "$max_size")') { max_file = $2; max_size = $1 } }'
    echo "$max_file"
}

function largest_file() {
    local dir="$1"
    local max_size=0
    local max_file=""
    find "$dir" -type f -exec du -ch {} + | sort -rh | awk '{ if ($1 > '$(printf "%d\n" "$max_size")') { max_file = $2; max_size = $1 } }'
    echo "$max_file"
}

function largest_file() {
    local dir="$1"
    local max_size=0
    local max_file=""
    find "$dir" -type f -exec du -ch {} + | sort -rh | awk '{ if ($1 > '$(printf "%d\n" "$max_size")') { max_file = $2; max_size = $1 } }'
    echo "$max_file"
}

function extract_urls() {
    while IFS= read -r line; do
        urls=$(echo "$line" | perl -ne 'print "$1\n" if /(https?|ftp):\/\/[^\s/]+/i')
        echo "$urls"
    done
}

function extract_urls() {
    while IFS= read -r line; do
        urls=$(echo "$line" | perl -ne 'print "$1\n" if /(https?|ftp):\/\/[^\s/]+/i')
        echo "$urls"
    done
}

function extract_urls() {
    while IFS= read -r line; do
        urls=$(echo "$line" | perl -ne 'print "$1\n" if /(https?|ftp):\/\/[^\s/]+/i')
        echo "$urls"
    done
}

function csv_col() {
    local col=$1
    local header=$(head -n 1 < /dev/stdin)
    local cols=$(echo "$header" | tr ',' '\n' | wc -l)
    local i=0
    while IFS= read -r line; do
        local val=$(echo "$line" | awk -v col=$col -v header=$header '
            $1 == col { print $NF }
            $1 == header { for (i=2; i<=NF; i++) printf "%s,", $i; print "" }
        ')
        if [[ $val ]]; then
            echo "$val"
        fi
    done
}

function csv_col() {
    local col=$1
    local header=$(head -n 1 < /dev/stdin)
    local cols=$(echo "$header" | tr ',' '\n' | wc -l)
    local i=0
    while IFS= read -r line; do
        local val=$(echo "$line" | awk -v col=$col -v header=$header '
            $1 == col { print $NF }
            $1 == header { for (i=2; i<=NF; i++) printf "%s,", $i; print "" }
        ')
        if [[ $val ]]; then
            echo "$val"
        fi
    done
}

function csv_col() {
    local col=$1
    local header=$(head -n 1 < /dev/stdin)
    local cols=$(echo "$header" | tr ',' '\n' | wc -l)
    local i=0
    while IFS= read -r line; do
        local val=$(echo "$line" | awk -v col=$col -v header=$header '
            $1 == col { print $NF }
            $1 == header { for (i=2; i<=NF; i++) printf "%s,", $i; print "" }
        ')
        if [[ $val ]]; then
            echo "$val"
        fi
    done
}

function find_dupes() {
    local dir="$1"
    local md5s=$(md5 -r "$dir" | awk '{print $1, $2}')
    local groups=$(echo "$md5s" | sort -k2 | uniq -w32 -c -i | awk '!seen[$2]++ {print $2, $1}')
    local paths=$(echo "$groups" | awk '{print $2}' | xargs -I{} find "{}" -type f -print0 | sort -z | tr '\0' '\n')
    local result=$(echo "$paths" | xargs -I{} sh -c 'echo "$(md5 -r "{}") {}"')
    echo "$result" | awk -F'[ \t]+' 'NR==FNR{a[$1]=$2;next}{if(a[$1]!="")print a[$1],$2}' FS='\n' RS=
}

function find_dupes() {
    local dir="$1"
    local md5s=$(md5 -r "$dir" | awk '{print $1, $2}')
    local groups=$(echo "$md5s" | sort -k2 | uniq -w32 -c -i | awk '!seen[$2]++ {print $2, $1}')
    local paths=$(echo "$groups" | awk '{print $2}' | xargs -I{} find "{}" -type f -print0 | sort -z | tr '\0' '\n')
    local result=$(echo "$paths" | xargs -I{} sh -c 'echo "$(md5 -r "{}") {}"')
    echo "$result" | awk -F'[ \t]+' 'NR==FNR{a[$1]=$2;next}{if(a[$1]!="")print a[$1],$2}' FS='\n' RS=
}

function find_dupes() {
    local dir="$1"
    local md5s=$(md5 -r "$dir" | awk '{print $1, $2}')
    local groups=$(echo "$md5s" | sort -k2 | uniq -w32 -c -i | awk '!seen[$2]++ {print $2, $1}')
    local paths=$(echo "$groups" | awk '{print $2}' | xargs -I{} find "{}" -type f -print0 | sort -z | tr '\0' '\n')
    local result=$(echo "$paths" | xargs -I{} sh -c 'echo "$(md5 -r "{}") {}"')
    echo "$result" | awk -F'[ \t]+' 'NR==FNR{a[$1]=$2;next}{if(a[$1]!="")print a[$1],$2}' FS='\n' RS=
}

function top_errors() {
    local file="$1"
    local n="$2"
    local err_counts=()
    local err_sigs=()

    if [[ ! -f "$file" ]]; then
        echo "File not found: $file"
        return 1
    fi

    while IFS= read -r line; do
        if [[ $line == ERROR:* ]]; then
            local sig="${line##*ERROR:}"
            sig="${sig//[0-9]/#}"
            err_counts+=("$sig")
        fi
    done < "$file"

    for sig in "${err_counts[@]}"; do
        err_sigs+=("$sig")
    done

    local sorted_indices=($(for i in "${!err_counts[@]}"; do echo -en "${err_counts[$i]}\t$i\n"; done) | sort -nr | cut -f2 -d\ )

    for i in "${sorted_indices[@]}"; do
        echo "${err_counts[$i]} ${err_sigs[$i]}"
    done | head -n "$n"
}

function top_errors() {
    local file="$1"
    local n="$2"
    local err_counts=()
    local err_sigs=()

    if [[ ! -f "$file" ]]; then
        echo "File not found: $file"
        return 1
    fi

    while IFS= read -r line; do
        if [[ $line == ERROR:* ]]; then
            local sig="${line##*ERROR:}"
            sig="${sig//[0-9]/#}"
            err_counts+=("$sig")
        fi
    done < "$file"

    for sig in "${err_counts[@]}"; do
        err_sigs+=("$sig")
    done

    local sorted_indices=($(for i in "${!err_counts[@]}"; do echo -en "${err_counts[$i]}\t$i\n"; done) | sort -nr | cut -f2 -d\ )

    for i in "${sorted_indices[@]}"; do
        echo "${err_counts[$i]} ${err_sigs[$i]}"
    done | head -n "$n"
}

function top_errors() {
    local file="$1"
    local n="$2"
    local err_counts=()
    local err_sigs=()

    if [[ ! -f "$file" ]]; then
        echo "File not found: $file"
        return 1
    fi

    while IFS= read -r line; do
        if [[ $line == ERROR:* ]]; then
            local sig="${line##*ERROR:}"
            sig="${sig//[0-9]/#}"
            err_counts+=("$sig")
        fi
    done < "$file"

    for sig in "${err_counts[@]}"; do
        err_sigs+=("$sig")
    done

    local sorted_indices=($(for i in "${!err_counts[@]}"; do echo -en "${err_counts[$i]}\t$i\n"; done) | sort -nr | cut -f2 -d\ )

    for i in "${sorted_indices[@]}"; do
        echo "${err_counts[$i]} ${err_sigs[$i]}"
    done | head -n "$n"
}

function backup_rotate() {
    local dir="$1"
    local keep="$2"
    local files=("$dir"/backup-*.tar.gz)
    local -a to_delete=()
    local -a to_keep=()

    # sort files oldest to newest
    IFS=$'\n' sorted_files=($(sort -r <<<"${files[*]}"))
    unset IFS

    # delete all but the newest <keep> files
    for file in "${sorted_files[@]:keep:1}"; do
        to_delete+=("$file")
    done

    # print deleted files oldest first
    for file in "${to_delete[@]}"; do
        echo "$file"
    done

    # delete files
    for file in "${to_delete[@]}"; do
        rm "$file"
    done
}

function backup_rotate() {
    local dir="$1"
    local keep="$2"
    local files=("$dir"/backup-*.tar.gz)
    local -a to_delete=()
    local -a to_keep=()

    # sort files oldest to newest
    IFS=$'\n' sorted_files=($(sort -r <<<"${files[*]}"))
    unset IFS

    # delete all but the newest <keep> files
    for file in "${sorted_files[@]:keep:1}"; do
        to_delete+=("$file")
    done

    # print deleted files oldest first
    for file in "${to_delete[@]}"; do
        echo "$file"
    done

    # delete files
    for file in "${to_delete[@]}"; do
        rm "$file"
    done
}

function backup_rotate() {
    local dir="$1"
    local keep="$2"
    local files=("$dir"/backup-*.tar.gz)
    local -a to_delete=()
    local -a to_keep=()

    # sort files oldest to newest
    IFS=$'\n' sorted_files=($(sort -r <<<"${files[*]}"))
    unset IFS

    # delete all but the newest <keep> files
    for file in "${sorted_files[@]:keep:1}"; do
        to_delete+=("$file")
    done

    # print deleted files oldest first
    for file in "${to_delete[@]}"; do
        echo "$file"
    done

    # delete files
    for file in "${to_delete[@]}"; do
        rm "$file"
    done
}