local str="$1"

local visible_str

# Handle both actual escape sequences and literal \033 strings

local temp_str="$str"

# Replace literal \033 with actual escape character

temp_str="${temp_str//\\033/$'\033'}"

# Remove actual escape sequences

visible_str=""

local in_escape=false

local i=0

while [[ $i -lt ${#temp_str} ]]; do

local char="${temp_str:$i:1}"

if [[ "$char" == $'\033' ]]; then

in_escape=true

elif [[ $in_escape == true && "$char" =~ [mKJH] ]]; then

in_escape=false

elif [[ $in_escape == false ]]; then

visible_str+="$char"

fi

((i++))

done

echo ${#visible_str}

local line="$1"

local -n char_stream_ref=$2

char_stream_ref=()

local i=0

local current_color=""

while [[ $i -lt ${#line} ]]; do

if [[ "${line:$i:4}" == "\033" ]]; then

# Extract the complete color code

local color_start=$i

i=$((i + 4)) # Skip \033[

# Find the end of the color sequence

while [[ $i -lt ${#line} && ! "${line:$i:1}" =~ [mKJH] ]]; do

((i++))

done

if [[ $i -lt ${#line} ]]; then

((i++)) # Include the terminating character

local color_code="${line:$color_start:$((i-color_start))}"

current_color="$color_code"

fi

else

# Add character with current color state

char_stream_ref+=("${line:$i:1}|$current_color")

((i++))

fi

done

local line="$1"

local -n tokens_ref=$2

tokens_ref=()

local i=0

local current_text=""

while [[ $i -lt ${#line} ]]; do

if [[ "${line:$i:4}" == "\033" ]]; then

# Save any accumulated text

if [[ -n "$current_text" ]]; then

tokens_ref+=("text:$current_text")

current_text=""

fi

# Extract the complete color code

local color_start=$i

i=$((i + 4)) # Skip \033[

# Find the end of the color sequence

while [[ $i -lt ${#line} && ! "${line:$i:1}" =~ [mKJH] ]]; do

((i++))

done

if [[ $i -lt ${#line} ]]; then

((i++)) # Include the terminating character

local color_code="${line:$color_start:$((i-color_start))}"

tokens_ref+=("color:$color_code")

fi

else

current_text+="${line:$i:1}"

((i++))

fi

done

# Save any remaining text

if [[ -n "$current_text" ]]; then

tokens_ref+=("text:$current_text")

fi

local -n char_stream_ref=$1

local plain_text=""

for char_color in "${char_stream_ref[@]}"; do

local char="${char_color%%|*}"

plain_text+="$char"

done

echo "$plain_text"

local -n tokens_ref=$1

local plain_text=""

for token in "${tokens_ref[@]}"; do

if [[ "$token" =~ ^text: ]]; then

plain_text+="${token#text:}"

fi

done

echo "$plain_text"

local -n char_stream_ref=$1

local max_width="$2"

local -n result_streams_ref=$3

result_streams_ref=()

# Convert character stream to words with color info

local -a words_with_colors=()

local current_word_chars=()

for char_color in "${char_stream_ref[@]}"; do

local char="${char_color%%|*}"

if [[ "$char" == " " ]]; then

# End of word

if [[ ${#current_word_chars[@]} -gt 0 ]]; then

# Store word as array of char|color elements

words_with_colors+=("$(printf '%s\n' "${current_word_chars[@]}" | tr '\n' '\001')")

current_word_chars=()

fi

else

current_word_chars+=("$char_color")

fi

done

# Add final word

if [[ ${#current_word_chars[@]} -gt 0 ]]; then

words_with_colors+=("$(printf '%s\n' "${current_word_chars[@]}" | tr '\n' '\001')")

fi

# Wrap words into lines

local current_line_chars=()

local current_line_length=0

for word_data in "${words_with_colors[@]}"; do

# Convert back to array

local -a word_chars=()

IFS=$'\001' read -ra word_chars <<< "$word_data"

local word_length=${#word_chars[@]}

local new_length

if [[ ${#current_line_chars[@]} -gt 0 ]]; then

new_length=$((current_line_length + 1 + word_length)) # +1 for space

else

new_length=$word_length

fi

if [[ $new_length -le $max_width ]]; then

# Add to current line

if [[ ${#current_line_chars[@]} -gt 0 ]]; then

current_line_chars+=("||") # Space placeholder

current_line_length=$((current_line_length + 1))

fi

current_line_chars+=("${word_chars[@]}")

current_line_length=$((current_line_length + word_length))

else

# Complete current line

if [[ ${#current_line_chars[@]} -gt 0 ]]; then

result_streams_ref+=("$(printf '%s\n' "${current_line_chars[@]}" | tr '\n' '\001')")

fi

# Start new line

current_line_chars=("${word_chars[@]}")

current_line_length=$word_length

fi

done

# Add final line

if [[ ${#current_line_chars[@]} -gt 0 ]]; then

result_streams_ref+=("$(printf '%s\n' "${current_line_chars[@]}" | tr '\n' '\001')")

fi

local -n char_stream_ref=$1

local result=""

local current_color=""

# Convert stream data back to array if needed

local -a chars=()

if [[ ${#char_stream_ref[@]} -eq 1 ]]; then

# Single string with \001 separators

IFS=$'\001' read -ra chars <<< "${char_stream_ref[0]}"

else

chars=("${char_stream_ref[@]}")

fi

for char_color in "${chars[@]}"; do

if [[ "$char_color" == "||" ]]; then

# Space placeholder

result+=" "

continue

fi

local char="${char_color%%|*}"

local color="${char_color#*|}"

# Insert color code if state changed

if [[ "$color" != "$current_color" ]]; then

if [[ -n "$color" ]]; then

result+="$color"

fi

current_color="$color"

fi

result+="$char"

done

echo "$result"

local -n tokens_ref=$1

local -n wrapped_lines_ref=$2

local -n result_ref=$3

result_ref=()

# Build a position map of where colors should go

local -A color_map=()

local text_pos=0

for token in "${tokens_ref[@]}"; do

if [[ "$token" =~ ^text: ]]; then

local text_content="${token#text:}"

text_pos=$((text_pos + ${#text_content}))

elif [[ "$token" =~ ^color: ]]; then

local color_content="${token#color:}"

color_map[$text_pos]="$color_content"

fi

done

# Function to determine what color is active at a given position

get_active_color_at_position() {

local pos=$1

local active_color=""

# Go through all color positions up to this point to find the last active color

for color_pos in $(printf '%s\n' "${!color_map[@]}" | sort -n); do

if [[ $color_pos -le $pos ]]; then

local color_code="${color_map[$color_pos]}"

if [[ "$color_code" == "\033[0m" ]]; then

active_color="" # Reset clears color

else

active_color="$color_code" # New color becomes active

fi

else

break # Don't process colors beyond our position

fi

done

echo "$active_color"

}

# Process each wrapped line

local line_start=0

for plain_line in "${wrapped_lines_ref[@]}"; do

local line_end=$((line_start + ${#plain_line}))

local colored_line="$plain_line"

# Get the active color at the start of this line

local line_start_color

line_start_color=$(get_active_color_at_position $line_start)

# If there's an active color, prepend it to the line

if [[ -n "$line_start_color" ]]; then

colored_line="${line_start_color}${colored_line}"

fi

# Find colors that should be inserted within this line

local -a insertions=()

for pos in $(printf '%s\n' "${!color_map[@]}" | sort -n); do

if [[ $pos -gt $line_start && $pos -lt $line_end ]]; then

local relative_pos=$((pos - line_start))

# Account for any color code we added at the beginning

if [[ -n "$line_start_color" ]]; then

relative_pos=$((relative_pos + ${#line_start_color}))

fi

insertions+=("$relative_pos:${color_map[$pos]}")

fi

done

# Apply insertions in reverse order to maintain positions

local -a sorted_insertions=($(printf '%s\n' "${insertions[@]}" | sort -rn))

for insertion in "${sorted_insertions[@]}"; do

local insert_pos="${insertion%%:*}"

local color_code="${insertion#*:}"

colored_line="${colored_line:0:$insert_pos}${color_code}${colored_line:$insert_pos}"

done

result_ref+=("$colored_line")

line_start=$((line_end + 1)) # +1 for the space that was removed during wrapping

done

local line="$1"

local max_width="$2"

local -n result_lines=$3

# Parse into character stream

local -a char_stream=()

parse_to_character_stream "$line" char_stream

# Get plain text for length calculation

local plain_text

plain_text=$(get_plain_text_from_char_stream char_stream)

local plain_length=${#plain_text}

if [[ $plain_length -le $max_width ]]; then

result_lines+=("$line") # Use original line with colors preserved

return

fi

# Wrap character stream at word boundaries

local -a wrapped_streams=()

wrap_character_stream char_stream "$max_width" wrapped_streams

# Render each wrapped stream to final colored strings

result_lines=()

for stream_data in "${wrapped_streams[@]}"; do

local -a stream_array=("$stream_data")

local colored_line

colored_line=$(render_character_stream stream_array)

result_lines+=("$colored_line")

done

local -n input_content=$1

local -n output_content=$2

local terminal_width="$3"

local max_content_width=$((terminal_width - 4))

[[ $max_content_width -lt 20 ]] && max_content_width=20

output_content=()

for line in "${input_content[@]}"; do

if [[ "$line" == "---EMPTY---" || "$line" == "---SEPARATOR---" ]]; then

output_content+=("$line")

else

local wrapped_lines=()

word_wrap_line "$line" "$max_content_width" wrapped_lines

output_content+=("${wrapped_lines[@]}")

fi

done

local content="$1"

local box_width="$2"

local padding_char="${3:- }"

local content_length

content_length=$(calculate_visible_length "$content")

local available_width=$((box_width - 4))

local padding_needed=$((available_width - content_length))

if [[ $padding_needed -lt 0 ]]; then

echo "[ERROR] Content too long for box width: $content_length > $available_width" >&2

return 1

fi

local padding=""

for ((i=0; i<padding_needed; i++)); do

padding+="$padding_char"

done

# Check if content has color codes - if so, don't add our own reset codes that interfere

if [[ "$content" =~ \\033\[ ]]; then

# Content has colors - ensure reset happens before closing border

echo -e "${CYAN}${BOX_CHARS[VERTICAL]}${NC} ${content}${padding}${NC} ${CYAN}${BOX_CHARS[VERTICAL]}${NC}"

else

# Content has no colors - safe to use our normal coloring

echo -e "${CYAN}${BOX_CHARS[VERTICAL]}${NC} ${content}${padding} ${CYAN}${BOX_CHARS[VERTICAL]}${NC}"

fi

local line_type="$1"

local box_width="$2"

local left_char right_char

case "$line_type" in

"top")

left_char="${BOX_CHARS[TOP_LEFT]}"

right_char="${BOX_CHARS[TOP_RIGHT]}"

;;

"bottom")

left_char="${BOX_CHARS[BOTTOM_LEFT]}"

right_char="${BOX_CHARS[BOTTOM_RIGHT]}"

;;

"separator")

left_char="${BOX_CHARS[TEE_LEFT]}"

right_char="${BOX_CHARS[TEE_RIGHT]}"

;;

*)

echo "[ERROR] Unknown line type: $line_type" >&2

return 1

;;

esac

local horizontal_chars=""

for ((i=0; i<box_width-2; i++)); do

horizontal_chars+="${BOX_CHARS[HORIZONTAL]}"

done

echo -e "${CYAN}${left_char}${horizontal_chars}${right_char}${NC}"

local box_width="$1"

local spaces=""

for ((i=0; i<box_width-2; i++)); do

spaces+=" "

done

echo -e "${CYAN}${BOX_CHARS[VERTICAL]}${spaces}${BOX_CHARS[VERTICAL]}${NC}"

local -n content_array=$1

local min_width="${2:-60}"

local max_width="${3:-}"

local max_content_length=0

for line in "${content_array[@]}"; do

local line_length

line_length=$(calculate_visible_length "$line")

if [[ $line_length -gt $max_content_length ]]; then

max_content_length=$line_length

fi

done

local required_width=$((max_content_length + 4))

local final_width=$((required_width > min_width ? required_width : min_width))

if [[ -n "$max_width" && $final_width -gt $max_width ]]; then

final_width=$max_width

fi

echo $final_width

local title="$1"

local -n lines=$2

local min_width="${3:-60}"

local show_separator="${4:-true}"

local terminal_width="${5:-}"

# Get terminal width if not provided

if [[ -z "$terminal_width" ]]; then

terminal_width=${COLUMNS:-$(tput cols 2>/dev/null || echo 80)}

fi

# Process content for responsive width

local processed_content=()

process_content_for_width lines processed_content "$terminal_width"

# Prepare all content for width calculation

local all_content=()

[[ -n "$title" ]] && all_content+=("$title")

all_content+=("${processed_content[@]}")

# Calculate box width with terminal width as maximum

local box_width

box_width=$(calculate_box_width all_content "$min_width" "$terminal_width")

# Render the box

build_horizontal_line "top" "$box_width"

if [[ -n "$title" ]]; then

build_content_line "$title" "$box_width"

[[ "$show_separator" == "true" ]] && build_horizontal_line "separator" "$box_width"

fi

for line in "${processed_content[@]}"; do

case "$line" in

"---EMPTY---")

build_empty_line "$box_width"

;;

"---SEPARATOR---")

build_horizontal_line "separator" "$box_width"

;;

*)

build_content_line "$line" "$box_width"

;;

esac

done

build_horizontal_line "bottom" "$box_width"

: i stands for "investigate"

local file="" debug=0 found=0 use_color=1

local preview_lines=15 indent="" depth=0 no_truncate=0

local investigation_chain=()

local shown_alias_target_inode="" # Track inode of target shown during alias investigation

local shown_alias_target_path="" # Track path of target shown during alias investigation

local shown_file_path="" # Track path of file shown in main section

[[ -t 1 ]] || use_color=0

[[ $use_color -eq 1 ]] && {

BLACK='\033[0;30m'; RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[0;33m'

BLUE='\033[0;34m'; MAGENTA='\033[0;35m'; CYAN='\033[0;36m';

WHITE='\033[1;37m';

BRIGHT_BLACK='\033[0;90m'; BRIGHT_RED='\033[0;91m'; BRIGHT_GREEN='\033[0;92m'; BRIGHT_YELLOW='\033[0;93m'

BRIGHT_BLUE='\033[0;94m'; BRIGHT_MAGENTA='\033[0;95m'; BRIGHT_CYAN='\033[0;96m';

BRIGHT_WHITE='\033[1;97m';

ORANGE='\033[38;5;208m'; NC='\033[0m'

} || {

RED=''; GREEN=''; YELLOW=''; BLUE=''; MAGENTA=''; CYAN='';

WHITE=''; NC=''

}

# Debug output removed for performance

# Helper function to track alias target for deduplication

track_alias_target() {

local target_path="$1"

local resolved

resolved=$(readlink -f "$target_path" 2>/dev/null || echo "$target_path")

local inode

inode=$(stat -Lc '%d:%i' "$resolved" 2>/dev/null)

shown_alias_target_inode="$inode"

shown_alias_target_path="$resolved"

}

# Helper function for recursive investigation with indentation

investigate_target() {

local target="$1"

local current_depth="$2"

local debug_flag=""

[[ $debug -eq 1 ]] && debug_flag="--debug"

# Strip ANSI color codes from target to prevent contamination

local clean_target

clean_target=$(echo "$target" | sed -e 's/\x1b\[[0-9;]*m//g' | sed -e 's/\\033\[[0-9;]*m//g')

# Check for circular reference before investigation

if [[ "${investigation_chain[*]}" =~ " $clean_target " || "${investigation_chain[0]}" == "$clean_target" ]]; then

# Create tree prefix based on depth

local tree_prefix=""

for ((i=0; i<current_depth; i++)); do

tree_prefix+="│ "

done

echo -e "${RED}${tree_prefix}↳ Circular reference detected: '${WHITE}$clean_target${RED}' is already being investigated in this chain${NC}"

echo -e "${YELLOW}${tree_prefix} Chain: ${investigation_chain[*]} → $clean_target${NC}"

return

fi

# Create tree prefix based on depth

local tree_prefix=""

for ((i=0; i<current_depth; i++)); do

tree_prefix+="│ "

done

# Print target with tree structure

if [[ $current_depth -eq 0 ]]; then

echo "↳ Investigating: $clean_target"

else

echo "${tree_prefix}└─ Investigating: $clean_target"

fi

local chain_str=""

for item in "${investigation_chain[@]}"; do

chain_str+="$item "

done

i "$clean_target" $debug_flag --depth=$((current_depth + 1)) --chain="$chain_str$file"

}

# Function to display variable information

show_variable_info() {

local var_name="$1"

# Get variable declaration info

local var_declaration

var_declaration=$(declare -p "$var_name" 2>/dev/null)

if [[ -z "$var_declaration" ]]; then

echo -e "${RED}Variable '${WHITE}$var_name${RED}' is not set or declared.${NC}"

return

fi

# Parse the declaration to get type and value

local var_type="variable"

if [[ "$var_declaration" =~ ^declare\ -([aAilnrtux]+) ]]; then

local flags="${BASH_REMATCH[1]}"

case "$flags" in

*A*) var_type="associative array" ;;

*a*) var_type="indexed array" ;;

*i*) var_type="integer variable" ;;

*l*) var_type="lowercase variable" ;;

*n*) var_type="nameref variable" ;;

*r*) var_type="readonly variable" ;;

*t*) var_type="traced variable" ;;

*u*) var_type="uppercase variable" ;;

*x*) var_type="exported variable" ;;

*) var_type="string variable" ;;

esac

fi

# Use correct article (a/an) based on first letter

local article="a"

if [[ "$var_type" =~ ^[aeiouAEIOU] ]]; then

article="an"

fi

echo -e "${CYAN}'${WHITE}$var_name${CYAN}' is $article $var_type${NC}"

echo

# Show the declaration (includes the value)

echo -e "${MAGENTA}Declaration: ${NC}$var_declaration"

# For arrays, show elements

if [[ "$var_declaration" =~ ^declare\ -[aA] ]]; then

# For arrays, show element count and first few elements

if [[ "$var_declaration" =~ ^declare\ -a ]]; then

# Indexed array

local -n array_ref="$var_name"

local array_size=${#array_ref[@]}

echo -e "${YELLOW}Array size: ${NC}$array_size elements"

if [[ $array_size -gt 0 ]]; then

echo -e "${YELLOW}First few elements:${NC}"

local count=0

for index in "${!array_ref[@]}"; do

if [[ $count -ge 5 ]]; then

echo "${indent}... (showing first 5 of $array_size elements)"

break

fi

echo "${indent}[$index] = '${array_ref[$index]}'"

((count++))

done

fi

elif [[ "$var_declaration" =~ ^declare\ -A ]]; then

# Associative array

local -n assoc_ref="$var_name"

local assoc_size=${#assoc_ref[@]}

echo -e "${YELLOW}Associative array size: ${NC}$assoc_size elements"

if [[ $assoc_size -gt 0 ]]; then

echo -e "${YELLOW}First few key-value pairs:${NC}"

local count=0

for key in "${!assoc_ref[@]}"; do

if [[ $count -ge 5 ]]; then

echo "${indent}... (showing first 5 of $assoc_size pairs)"

break

fi

echo "${indent}['$key'] = '${assoc_ref[$key]}'"

((count++))

done

fi

fi

fi

echo

}

# Optimized show_usage function with static output for common widths

show_usage() {

local terminal_width=${COLUMNS:-$(tput cols 2>/dev/null || echo 80)}

local max_usage_width=100

if [[ $terminal_width -gt $max_usage_width ]]; then

terminal_width=$max_usage_width

fi

# Use static pre-formatted output for terminals ≥80 columns (most common case)

if [[ $terminal_width -ge 80 ]]; then

# Static output optimized for 80-column terminals

echo -e "${CYAN}╭──────────────────────────────────────────────────────────────────────────────╮${NC}"

echo -e "${CYAN}│${NC} ${WHITE}i${NC} ${BRIGHT_CYAN}(investigate): Inspect bash shell commands, functions, files, and more${NC} ${CYAN}│${NC}"

echo -e "${CYAN}├──────────────────────────────────────────────────────────────────────────────┤${NC}"

echo -e "${CYAN}│${NC} ${YELLOW}Usage:${NC} ${WHITE}i${NC} ${GREEN}<name>${NC} ${BLUE}[options]${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${YELLOW}Description:${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} Thoroughly investigates any given name, showing detailed information about ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} files, commands, aliases, functions, builtins, and keywords. ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${YELLOW}Arguments:${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${GREEN}<name>${NC} Required. The target to investigate ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${YELLOW}Options:${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${BLUE}--debug${NC} Shows verbose output when tracing function sources ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${BLUE}--functions, -f${NC} Show only if target is a function ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${BLUE}--aliases, -a${NC} Show only if target is an alias ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${BLUE}--variables, -v${NC} Show only if target is a variable ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${BLUE}--builtins, -b${NC} Show only if target is a builtin or keyword ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${BLUE}--files${NC} Show only if target is a file ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${BLUE}--commands, -c${NC} Show only if target is an executable command ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${BLUE}--no-truncate, -n${NC} Show full content without truncating file previews ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${YELLOW}Examples:${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${WHITE}i${NC} ${GREEN}grep${NC} ${MAGENTA}# Inspect the grep command${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${WHITE}i${NC} ${GREEN}my_function${NC} ${MAGENTA}# Analyze a custom shell function${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${WHITE}i${NC} ${GREEN}script.sh${NC} ${BLUE}--debug${NC} ${MAGENTA}# Debug function source tracing${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${WHITE}i${NC} ${GREEN}ls${NC} ${BLUE}--functions${NC} ${MAGENTA}# Only show if 'ls' is a function${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${WHITE}i${NC} ${GREEN}ll${NC} ${BLUE}-a${NC} ${MAGENTA}# Only show if 'll' is an alias${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${WHITE}i${NC} ${GREEN}PATH${NC} ${BLUE}--variables${NC} ${MAGENTA}# Only show if 'PATH' is a variable${NC} ${CYAN}│${NC}"

echo -e "${CYAN}│${NC} ${WHITE}i${NC} ${GREEN}cd${NC} ${BLUE}-b${NC} ${MAGENTA}# Only show if 'cd' is a builtin${NC} ${CYAN}│${NC}"

echo -e "${CYAN}╰──────────────────────────────────────────────────────────────────────────────╯${NC}"

else

# Fall back to dynamic calculation for narrow terminals

local usage_content=(

"${WHITE}i${NC} ${BRIGHT_CYAN}(investigate): Inspect bash shell commands, functions, files, and more${NC}"

"---SEPARATOR---"

"${YELLOW}Usage:${NC} ${WHITE}i${NC} ${GREEN}<name>${NC} ${BLUE}[options]${NC}"

"---EMPTY---"

"${YELLOW}Description:${NC}"

"Thoroughly investigates any given name, showing detailed information about"

"files, commands, aliases, functions, builtins, and keywords."

"---EMPTY---"

"${YELLOW}Arguments:${NC}"

" ${GREEN}<name>${NC} Required. The target to investigate"

"---EMPTY---"

"${YELLOW}Options:${NC}"

" ${BLUE}--debug${NC} Shows verbose output when tracing function sources"

" ${BLUE}--functions, -f${NC} Show only if target is a function"

" ${BLUE}--aliases, -a${NC} Show only if target is an alias"

" ${BLUE}--variables, -v${NC} Show only if target is a variable"

" ${BLUE}--builtins, -b${NC} Show only if target is a builtin or keyword"

" ${BLUE}--files${NC} Show only if target is a file"

" ${BLUE}--commands, -c${NC} Show only if target is an executable command"

" ${BLUE}--no-truncate, -n${NC} Show full content without truncating file previews"

"---EMPTY---"

"${YELLOW}Examples:${NC}"

" ${WHITE}i${NC} ${GREEN}grep${NC} ${MAGENTA}# Inspect the grep command${NC}"

" ${WHITE}i${NC} ${GREEN}my_function${NC} ${MAGENTA}# Analyze a custom shell function${NC}"

" ${WHITE}i${NC} ${GREEN}script.sh${NC} ${BLUE}--debug${NC} ${MAGENTA}# Debug function source tracing${NC}"

" ${WHITE}i${NC} ${GREEN}ls${NC} ${BLUE}--functions${NC} ${MAGENTA}# Only show if 'ls' is a function${NC}"

" ${WHITE}i${NC} ${GREEN}ll${NC} ${BLUE}-a${NC} ${MAGENTA}# Only show if 'll' is an alias${NC}"

" ${WHITE}i${NC} ${GREEN}PATH${NC} ${BLUE}--variables${NC} ${MAGENTA}# Only show if 'PATH' is a variable${NC}"

" ${WHITE}i${NC} ${GREEN}cd${NC} ${BLUE}-b${NC} ${MAGENTA}# Only show if 'cd' is a builtin${NC}"

)

render_box "" usage_content 80 false "$terminal_width"

fi

}

declare -A bash_keywords=(

[if]="Starts a conditional statement."

[then]="Begins the command block for a true condition."

[else]="Begins the command block if the condition is false."

[elif]="Introduces a new condition if the previous one is false."

[fi]="Ends an if statement."

[case]="Starts a multi-branch conditional statement."

[esac]="Ends a case statement."

[for]="Begins a for loop."

[select]="Creates a user selection menu loop."

[while]="Begins a loop that runs while a condition is true."

[until]="Begins a loop that runs until a condition becomes true."

[do]="Begins the body of a loop or conditional block."

[done]="Ends the body of a loop or conditional block."

[in]="Specifies the list to iterate over in a loop."

[function]="Defines a named function."

[time]="Measures execution time of a command or pipeline."

["{"]="Begins a group of commands in a block."

["}"]="Ends a group of commands in a block."

["!"]="Negates the exit status of a command or pipeline."

["[["]="Begins a conditional test expression."

["]"]="Ends a conditional test expression."

[coproc]="Starts a coprocess for asynchronous communication."

)

# Parse arguments - handle flags and options

local args=()

local filter_type=""

local filter_types=() # Support multiple filters

# Expand combined short flags (e.g., -bvf -> -b -v -f)

local expanded_args=()

for arg in "$@"; do

if [[ "$arg" =~ ^-[a-z]{2,}$ ]]; then

# Combined short flags like -bvf

local flag_chars="${arg#-}"

for ((i=0; i<${#flag_chars}; i++)); do

expanded_args+=("-${flag_chars:$i:1}")

done

else

expanded_args+=("$arg")

fi

done

# Process the expanded arguments

for arg in "${expanded_args[@]}"; do

if [[ "$arg" == "--debug" ]]; then

debug=1

elif [[ "$arg" =~ ^--depth=([0-9]+)$ ]]; then

depth="${BASH_REMATCH[1]}"

# Indentation disabled - keep flat output

indent=""

elif [[ "$arg" =~ ^--chain=(.*)$ ]]; then

# Parse the investigation chain from parent call

IFS=' ' read -ra investigation_chain <<< "${BASH_REMATCH[1]}"

elif [[ "$arg" == "--functions" || "$arg" == "-f" ]]; then

filter_types+=("function")

filter_type="function" # Keep for backward compatibility

elif [[ "$arg" == "--aliases" || "$arg" == "-a" ]]; then

filter_types+=("alias")

filter_type="alias" # Keep for backward compatibility

elif [[ "$arg" == "--variables" || "$arg" == "-v" ]]; then

filter_types+=("variable")

filter_type="variable" # Keep for backward compatibility

elif [[ "$arg" == "--builtins" || "$arg" == "-b" ]]; then

filter_types+=("builtin")

filter_type="builtin" # Keep for backward compatibility

elif [[ "$arg" == "--files" ]]; then

filter_type="file"

elif [[ "$arg" == "--commands" || "$arg" == "-c" ]]; then

filter_type="file" # commands are executable files

elif [[ "$arg" == "--no-truncate" || "$arg" == "-n" ]]; then

no_truncate=1

else

args+=("$arg")

fi

done

if [ ${#args[@]} -eq 0 ]; then

show_usage

return 1

fi

if [ ${#args[@]} -gt 1 ]; then

echo -e "${RED}Error: Too many arguments (expected 1 name, got ${#args[@]}).${NC}"

echo -e "${YELLOW}Tip: Use '${WHITE}i --help${YELLOW}' or just '${WHITE}i${YELLOW}' to see usage information.${NC}"

return 1

fi

file="${args[0]}"

# Handle help requests

if [[ "$file" == "--help" || "$file" == "-h" ]]; then

show_usage

return 0

fi

declare -A inspected_inodes_map=()

local inspected_paths=()

show_file_preview() {

local target="$1"

[[ ! -r "$target" ]] && return

# Don't preview directories

[[ -d "$target" ]] && return

if head -c 4 "$target" | grep -q $'^\x7fELF'; then

echo "${indent}(Skipping preview: Binary ELF file)"

return

fi

if LC_ALL=C grep -qP '[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]' "$target"; then

echo "${indent}(Skipping preview: File contains binary control characters)"

return

fi

if grep -q $'\e\[' "$target"; then

echo "${indent}(Skipping preview: Contains ANSI escape sequences)"

return

fi

local line_count

line_count=$(wc -l < "$target" 2>/dev/null)

echo "${indent}The file has $line_count lines."

# Determine how many lines to actually show

local lines_to_show=$preview_lines

if [[ $no_truncate -eq 1 ]]; then

lines_to_show=$line_count

else

local truncated_lines=$((line_count - preview_lines))

if [[ $line_count -gt $preview_lines && $truncated_lines -le 10 ]]; then

# If we would only truncate 10 or fewer lines, show them all instead

lines_to_show=$line_count

fi

fi

if [ "$line_count" -le "$lines_to_show" ]; then

echo "${indent}Displaying all content:"

else

echo "${indent}Displaying the first $lines_to_show lines:"

fi

# Get terminal width for line wrapping

local terminal_width=${COLUMNS:-$(tput cols 2>/dev/null || echo 80)}

local max_line_width=$((terminal_width - ${#indent} - 4)) # Account for indent and some margin

[[ $max_line_width -lt 40 ]] && max_line_width=40 # Minimum readable width

if command -v bat &>/dev/null; then

if [[ $use_color -eq 1 ]]; then

bat --style=plain --color=always --paging=never --line-range=1:$lines_to_show --wrap=character --terminal-width="$max_line_width" "$target" | sed "s/^/${indent}/"

else

bat --style=plain --color=never --paging=never --line-range=1:$lines_to_show --wrap=character --terminal-width="$max_line_width" "$target" | sed "s/^/${indent}/"

fi

else

# Wrap long lines manually for non-bat output

head -n "$lines_to_show" "$target" | while IFS= read -r line; do

if [[ ${#line} -le $max_line_width ]]; then

echo "${indent}${line}"

else

# Wrap the line

local pos=0

while [[ $pos -lt ${#line} ]]; do

local chunk="${line:$pos:$max_line_width}"