skill_scanner.sh

#!/usr/bin/env bash
# =============================================================================
# skill_scanner.sh — AI Coding Assistant Skill/Plugin Security Scanner
# =============================================================================
# Standalone scanner for detecting malicious patterns in AI assistant skills,
# plugins, rules files, and instruction documents across 11 ecosystems.
#
# Requires: bash 4+, grep, awk, sed
# No Python, Node, jq, or LLM dependency.
#
# Usage: ./skill_scanner.sh [OPTIONS] <file_or_directory>
# =============================================================================

set -euo pipefail

VERSION="1.0.0"

# === Severity weights for scoring ===
declare -A SEVERITY_WEIGHT=(
    [CRITICAL]=10
    [HIGH]=5
    [MEDIUM]=3
    [LOW]=1
    [INFO]=0
)

# === Color codes ===
RED='\033[0;31m'
BRED='\033[1;31m'
YELLOW='\033[0;33m'
BYELLOW='\033[1;33m'
GREEN='\033[0;32m'
BGREEN='\033[1;32m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
GRAY='\033[0;90m'
BOLD='\033[1m'
RESET='\033[0m'

# === Global state ===
FINDINGS=()          # Array of "severity|category|pattern|line|match|description"
OUTPUT_JSON=false
VERBOSE=false
SEVERITY_THRESHOLD="INFO"
RECURSIVE=false
MAX_SEVERITY="CLEAN"
TOTAL_SCORE=0
SCANNED_FILES=0
DETECTED_ECOSYSTEM=""

# === Severity ordering ===
severity_rank() {
    case "$1" in
        CRITICAL) echo 5 ;;
        HIGH)     echo 4 ;;
        MEDIUM)   echo 3 ;;
        LOW)      echo 2 ;;
        INFO)     echo 1 ;;
        CLEAN)    echo 0 ;;
        *)        echo 0 ;;
    esac
}

severity_meets_threshold() {
    local sev="$1"
    local threshold="$2"
    [[ $(severity_rank "$sev") -ge $(severity_rank "$threshold") ]]
}

update_max_severity() {
    local sev="$1"
    if [[ $(severity_rank "$sev") -gt $(severity_rank "$MAX_SEVERITY") ]]; then
        MAX_SEVERITY="$sev"
    fi
}

# === Finding management ===
add_finding() {
    local severity="$1"
    local category="$2"
    local pattern="$3"
    local line="$4"
    local match="$5"
    local description="$6"

    # Truncate match to 200 chars
    if [[ ${#match} -gt 200 ]]; then
        match="${match:0:200}..."
    fi
    # Remove newlines from match
    match="${match//$'\n'/ }"

    if severity_meets_threshold "$severity" "$SEVERITY_THRESHOLD"; then
        FINDINGS+=("${severity}|${category}|${pattern}|${line}|${match}|${description}")
        update_max_severity "$severity"
        TOTAL_SCORE=$((TOTAL_SCORE + ${SEVERITY_WEIGHT[$severity]:-0}))
    fi
}

# === Content preprocessing ===

extract_code_blocks() {
    # Extract content from fenced code blocks in markdown
    local file="$1"
    awk '
        /^```/ { if (in_block) { in_block=0; next } else { in_block=1; next } }
        in_block { print }
    ' "$file"
}

extract_preprocess_commands() {
    # Extract !`command` preprocessing syntax from Claude SKILL.md
    local file="$1"
    grep -noE '!\x60[^\x60]+\x60' "$file" 2>/dev/null || true
}

collapse_continuations() {
    # Join lines ending with backslash
    local file="$1"
    sed ':a; /\\$/ { N; s/\\\n//; ta }' "$file"
}

# === Ecosystem detection ===

detect_ecosystem() {
    local file="$1"
    local basename
    basename="$(basename "$file")"
    local dirpath
    dirpath="$(dirname "$file")"

    case "$basename" in
        SKILL.md)
            # Distinguish Claude SKILL.md from Codex SKILL.md
            if [[ "$dirpath" == *".agents/skills"* ]] || [[ "$dirpath" == *"/etc/codex/"* ]]; then
                echo "codex_skill"
            elif head -5 "$file" 2>/dev/null | grep -q '^---'; then
                echo "claude_skill"
            else
                echo "unknown_skill"
            fi
            ;;
        CLAUDE.md)
            echo "claude_instructions"
            ;;
        claude_desktop_config.json)
            echo "claude_desktop"
            ;;
        .mcp.json|mcp.json)
            echo "mcp_config"
            ;;
        AGENTS.md)
            echo "codex_instructions"
            ;;
        openai.yaml)
            if [[ "$dirpath" == *"/agents" ]] || [[ "$dirpath" == *"/agents/" ]]; then
                echo "codex_skill_config"
            else
                echo "unknown"
            fi
            ;;
        .cursorrules)
            echo "cursorrules"
            ;;
        .windsurfrules)
            echo "windsurfrules"
            ;;
        package.json)
            if grep -q '"vscode"\|"onCommand"\|"onLanguage"\|"activationEvents"' "$file" 2>/dev/null; then
                echo "vscode_extension"
            else
                echo "unknown"
            fi
            ;;
        .aider.conf.yml)
            echo "aider_config"
            ;;
        copilot-instructions.md)
            echo "copilot_instructions"
            ;;
        config.json)
            if grep -q '"continuedev"\|"slashCommands"\|"customCommands"\|"contextProviders"' "$file" 2>/dev/null; then
                echo "continue_config"
            else
                echo "unknown"
            fi
            ;;
        *.yaml|*.yml)
            # Check for Codex openai.yaml / skill config patterns
            if grep -q 'interface:\|dependencies:' "$file" 2>/dev/null; then
                echo "codex_skill_config"
            elif grep -qE 'transport.*streamable_http|type.*mcp' "$file" 2>/dev/null; then
                echo "codex_skill_config"
            elif [[ "$dirpath" == *"codex"* ]] || [[ "$dirpath" == *"agents"* ]]; then
                echo "codex_skill_config"
            elif [[ "$dirpath" == *"aider"* ]]; then
                echo "aider_config"
            else
                echo "generic"
            fi
            ;;
        *.json)
            # Check for OpenAPI spec (ChatGPT actions)
            if grep -q '"openapi"\|"paths"\|"servers"' "$file" 2>/dev/null; then
                echo "chatgpt_action"
            elif grep -q '"mcpServers"\|"mcp"' "$file" 2>/dev/null; then
                echo "mcp_config"
            else
                echo "unknown"
            fi
            ;;
        *)
            # Check for rules files in cursor directories
            if [[ "$dirpath" == *".cursor/rules"* ]]; then
                echo "cursorrules"
            # Check for files in known skill/test directories by parent dir name
            elif [[ "$dirpath" == *"claude_skill"* ]] || [[ "$dirpath" == *"claude/skills"* ]]; then
                echo "claude_skill"
            elif [[ "$dirpath" == *"claude_desktop"* ]]; then
                echo "claude_desktop"
            elif [[ "$dirpath" == *"codex"* ]] || [[ "$dirpath" == *".agents/skills"* ]]; then
                echo "codex_skill"
            elif [[ "$dirpath" == *"cursorrules"* ]]; then
                echo "cursorrules"
            elif [[ "$dirpath" == *"windsurfrules"* ]]; then
                echo "windsurfrules"
            elif [[ "$dirpath" == *"aider"* ]]; then
                echo "aider_config"
            elif [[ "$dirpath" == *"chatgpt"* ]]; then
                echo "chatgpt_action"
            elif [[ "$dirpath" == *"copilot"* ]]; then
                echo "copilot_instructions"
            # Check content for skill-like patterns
            elif head -5 "$file" 2>/dev/null | grep -q '^---'; then
                echo "generic_skill"
            else
                echo "generic"
            fi
            ;;
    esac
}

# === Detection rules ===
# Each function scans content and calls add_finding() for matches

check_network_exfil() {
    local file="$1"

    # Direct network commands with data sending indicators
    local line_match
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "network_exfil" "curl_data_upload" "$linenum" "$content" \
            "curl with data upload flag (-d, -F, --data, --upload-file)"
    done < <(grep -nEi 'curl\s.+(-d\s|-F\s|--data[ =]|--upload-file[ =]|-T\s)' "$file" 2>/dev/null || true)

    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "network_exfil" "curl_general" "$linenum" "$content" \
            "curl command detected (potential data exfiltration)"
    done < <(grep -nEi '(^|[^a-zA-Z])curl\s+(-[sSkLvofO]+ )*https?://' "$file" 2>/dev/null || true)

    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "network_exfil" "wget_post" "$linenum" "$content" \
            "wget with POST data"
    done < <(grep -nEi 'wget\s.*(--post-data|--post-file)' "$file" 2>/dev/null || true)

    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "network_exfil" "wget_general" "$linenum" "$content" \
            "wget command detected"
    done < <(grep -nEi '(^|[^a-zA-Z])wget\s+' "$file" 2>/dev/null || true)

    # Netcat / socat
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "network_exfil" "netcat" "$linenum" "$content" \
            "Netcat/socat network connection"
    done < <(grep -nEi '(^|[|\s])(nc|ncat|netcat|socat|telnet)\s' "$file" 2>/dev/null || true)

    # Pipe to network command
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "network_exfil" "pipe_to_network" "$linenum" "$content" \
            "Data piped to network command"
    done < <(grep -nEi '\|\s*(curl|wget|nc|ncat|socat|ssh)\s' "$file" 2>/dev/null || true)

    # DNS exfiltration
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "network_exfil" "dns_exfil" "$linenum" "$content" \
            "Potential DNS exfiltration (dig/nslookup with variable data)"
    done < <(grep -nEi '(dig|nslookup)\s.*\$' "$file" 2>/dev/null || true)

    # Indirect via runtimes
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "network_exfil" "python_network" "$linenum" "$content" \
            "Python one-liner with network capabilities"
    done < <(grep -nEi 'python[23]?\s+-c\s.*\b(urllib|requests|http\.client|socket|urlopen|httplib)\b' "$file" 2>/dev/null || true)

    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "network_exfil" "node_network" "$linenum" "$content" \
            "Node.js one-liner with network capabilities"
    done < <(grep -nEi 'node\s+-e\s.*\b(http|https|fetch|request|net|axios)\b' "$file" 2>/dev/null || true)

    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "network_exfil" "ruby_network" "$linenum" "$content" \
            "Ruby one-liner with network capabilities"
    done < <(grep -nEi 'ruby\s+-e\s.*\b(Net::HTTP|open-uri|HTTParty)\b' "$file" 2>/dev/null || true)

    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "network_exfil" "perl_network" "$linenum" "$content" \
            "Perl one-liner with network capabilities"
    done < <(grep -nEi 'perl\s+-e\s.*\b(LWP|HTTP::Tiny|IO::Socket|Net::HTTP)\b' "$file" 2>/dev/null || true)

    # Git push to non-standard remotes
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "network_exfil" "git_push_exfil" "$linenum" "$content" \
            "git remote add or push to potentially attacker-controlled remote"
    done < <(grep -nEi 'git\s+(remote\s+add|push)\s' "$file" 2>/dev/null || true)

    # SSH with data
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "network_exfil" "ssh_data" "$linenum" "$content" \
            "SSH command that may transfer data"
    done < <(grep -nEi 'ssh\s.*[<|]' "$file" 2>/dev/null || true)

    # JavaScript fetch() to external URL
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "network_exfil" "js_fetch_external" "$linenum" "$content" \
            "JavaScript fetch() to external URL"
    done < <(grep -nEi "fetch\s*\(\s*['\"]https?://" "$file" 2>/dev/null || true)

    # Cloud sync exfiltration
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "network_exfil" "cloud_sync_exfil" "$linenum" "$content" \
            "Copy to cloud-synced directory (iCloud/Dropbox/Google Drive)"
    done < <(grep -nEi '(cp|mv|rsync|ln|>>?)\s+.*?(Mobile Documents|CloudDocs|Dropbox|Google Drive)|(Mobile Documents|CloudDocs|Dropbox|Google Drive).*?(cp|mv|rsync|>>)' "$file" 2>/dev/null || true)

    # OpenAPI/GPT Action server URLs (external endpoints that receive data)
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        # Skip common legitimate API hosts
        [[ "$content" == *"api.github.com"* ]] && continue
        [[ "$content" == *"api.openai.com"* ]] && continue
        [[ "$content" == *"localhost"* ]] && continue
        add_finding "HIGH" "network_exfil" "openapi_server_url" "$linenum" "$content" \
            "OpenAPI/GPT Action server endpoint (receives request data)"
    done < <(grep -nEi '"url":\s*"https?://[^"]*"' "$file" 2>/dev/null || true)
}

check_credential_access() {
    local file="$1"
    local line_match

    # SSH key access
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "credential_access" "ssh_key_read" "$linenum" "$content" \
            "Reading SSH private key files"
    done < <(grep -nEi '(cat|head|tail|less|more|bat|type)\s.*~/\.ssh/(id_|authorized_keys|known_hosts)' "$file" 2>/dev/null || true)

    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "credential_access" "ssh_dir_access" "$linenum" "$content" \
            "Accessing .ssh directory"
    done < <(grep -nEi '~/\.ssh/|/\.ssh/' "$file" 2>/dev/null || true)

    # AWS credentials
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "credential_access" "aws_creds" "$linenum" "$content" \
            "Accessing AWS credentials"
    done < <(grep -nEi '~/\.aws/(credentials|config)|\.aws/credentials' "$file" 2>/dev/null || true)

    # GCP credentials
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "credential_access" "gcp_creds" "$linenum" "$content" \
            "Accessing GCP credentials"
    done < <(grep -nEi 'application_default_credentials|gcloud.*auth.*print-access-token' "$file" 2>/dev/null || true)

    # .env file access
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "credential_access" "env_file_read" "$linenum" "$content" \
            "Reading .env file (may contain secrets)"
    done < <(grep -nEi '(cat|head|tail|less|more|source|\.)\s+\.env' "$file" 2>/dev/null || true)

    # Environment variable dumping
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "credential_access" "env_dump" "$linenum" "$content" \
            "Dumping environment variables"
    done < <(grep -nEi '(^|\s)(env|printenv)\s*($|\|)|^\s*set\s*\|' "$file" 2>/dev/null || true)

    # Specific sensitive env vars
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "credential_access" "sensitive_env_var" "$linenum" "$content" \
            "Accessing sensitive environment variable"
    done < <(grep -nEi '\$(AWS_SECRET|GITHUB_TOKEN|OPENAI_API_KEY|ANTHROPIC_API_KEY|DATABASE_URL|STRIPE_SECRET|API_KEY|SECRET_KEY|PRIVATE_KEY|ACCESS_TOKEN)' "$file" 2>/dev/null || true)

    # macOS Keychain
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "credential_access" "keychain_access" "$linenum" "$content" \
            "macOS Keychain access"
    done < <(grep -nEi 'security\s+(find-generic-password|find-internet-password|dump-keychain)' "$file" 2>/dev/null || true)

    # Docker/Kube credentials
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "credential_access" "container_creds" "$linenum" "$content" \
            "Accessing Docker/Kubernetes credentials"
    done < <(grep -nEi '~/\.docker/config\.json|~/\.kube/config' "$file" 2>/dev/null || true)

    # NPM/PyPI tokens
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "credential_access" "package_registry_creds" "$linenum" "$content" \
            "Accessing package registry credentials"
    done < <(grep -nEi '~/\.(npmrc|pypirc|gem/credentials|netrc)' "$file" 2>/dev/null || true)

    # Git credentials
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "credential_access" "git_creds" "$linenum" "$content" \
            "Accessing git credentials"
    done < <(grep -nEi '~/\.git-credentials|git\s+credential' "$file" 2>/dev/null || true)

    # /etc/shadow or passwd
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "credential_access" "system_creds" "$linenum" "$content" \
            "Accessing system credential files"
    done < <(grep -nEi '/etc/(shadow|passwd|master\.passwd)' "$file" 2>/dev/null || true)
}

check_persistence() {
    local file="$1"
    local line_match

    # LaunchAgent
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "persistence" "launchagent" "$linenum" "$content" \
            "macOS LaunchAgent creation (survives reboot)"
    done < <(grep -nEi 'LaunchAgents|launchctl\s+load' "$file" 2>/dev/null || true)

    # Cron
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "persistence" "cron" "$linenum" "$content" \
            "Cron job manipulation"
    done < <(grep -nEi 'crontab\s|/var/spool/cron' "$file" 2>/dev/null || true)

    # Shell profile modification
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "persistence" "shell_profile" "$linenum" "$content" \
            "Shell profile modification (persists across terminals)"
    done < <(grep -nEi '>>?\s*~/?\.(bashrc|zshrc|bash_profile|profile|zprofile|zshenv)' "$file" 2>/dev/null || true)

    # Systemd
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "persistence" "systemd" "$linenum" "$content" \
            "Systemd service creation"
    done < <(grep -nEi '/systemd/|systemctl\s+enable' "$file" 2>/dev/null || true)

    # Git hooks
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "persistence" "git_hook" "$linenum" "$content" \
            "Git hook creation or modification"
    done < <(grep -nEi '\.git/hooks/|githooks' "$file" 2>/dev/null || true)

    # at command
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "persistence" "at_command" "$linenum" "$content" \
            "Scheduled execution via at command"
    done < <(grep -nEi '\bat\s+now\s*\+' "$file" 2>/dev/null || true)
}

check_dangerous_shell() {
    local file="$1"
    local line_match

    # rm -rf with dangerous paths
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "dangerous_shell" "rm_rf_dangerous" "$linenum" "$content" \
            "Recursive forced removal of critical paths"
    done < <(grep -nEi 'rm\s+-[rf]{2,}\s+(/|~|\$HOME|\.git)' "$file" 2>/dev/null || true)

    # General rm -rf
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "dangerous_shell" "rm_rf" "$linenum" "$content" \
            "Recursive forced removal"
    done < <(grep -nEi 'rm\s+-[rf]{2,}' "$file" 2>/dev/null || true)

    # Fork bomb
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "dangerous_shell" "fork_bomb" "$linenum" "$content" \
            "Fork bomb detected"
    done < <(grep -nEi ':\(\)\{.*:\|:.*\}|\.\/\$0\s*\|.*\$0' "$file" 2>/dev/null || true)

    # chmod 777 or 000
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "dangerous_shell" "chmod_dangerous" "$linenum" "$content" \
            "Dangerous permission change"
    done < <(grep -nEi 'chmod\s+(-R\s+)?(777|000|a\+rwx)' "$file" 2>/dev/null || true)

    # dd to device
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "dangerous_shell" "dd_device" "$linenum" "$content" \
            "dd writing to device (potential disk destruction)"
    done < <(grep -nEi 'dd\s+.*of=/dev/' "$file" 2>/dev/null || true)

    # mkfs
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "dangerous_shell" "mkfs" "$linenum" "$content" \
            "Filesystem formatting command"
    done < <(grep -nEi 'mkfs\.' "$file" 2>/dev/null || true)

    # kill -9 -1 or killall
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "dangerous_shell" "mass_kill" "$linenum" "$content" \
            "Mass process termination"
    done < <(grep -nEi 'kill\s+-9\s+-1|killall\s+-9' "$file" 2>/dev/null || true)

    # shred
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "dangerous_shell" "shred" "$linenum" "$content" \
            "Secure file deletion (shred)"
    done < <(grep -nEi '\bshred\s+(-[a-zA-Z]|/|~|\.)' "$file" 2>/dev/null || true)

    # Infinite loop
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "dangerous_shell" "infinite_loop" "$linenum" "$content" \
            "Potential infinite loop (CPU exhaustion)"
    done < <(grep -nEi 'while\s+true\s*;?\s*do' "$file" 2>/dev/null || true)
}

check_obfuscation() {
    local file="$1"
    local line_match

    # Base64 decode and execute
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "obfuscation" "base64_exec" "$linenum" "$content" \
            "Base64 decode piped to shell execution"
    done < <(grep -nEi 'base64\s+(-d|--decode).*\|\s*(bash|sh|zsh|eval)' "$file" 2>/dev/null || true)

    # Base64 decode (without direct execution)
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "obfuscation" "base64_decode" "$linenum" "$content" \
            "Base64 decoding detected (possible obfuscation)"
    done < <(grep -nEi 'base64\s+(-d|--decode)|base64\.b64decode|atob\(' "$file" 2>/dev/null || true)

    # Hex escape sequences
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "obfuscation" "hex_escapes" "$linenum" "$content" \
            "Hex escape sequences (possible command obfuscation)"
    done < <(grep -nEi '\\x[0-9a-f]{2}.*\\x[0-9a-f]{2}.*\\x[0-9a-f]{2}' "$file" 2>/dev/null || true)

    # Eval with dynamic content
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "obfuscation" "eval_dynamic" "$linenum" "$content" \
            "eval with dynamic content (potential code injection)"
    done < <(grep -nEi 'eval\s+"\$\(' "$file" 2>/dev/null || true)

    # General eval usage
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "obfuscation" "eval_usage" "$linenum" "$content" \
            "eval command usage"
    done < <(grep -nEi '(^|\s)eval\s' "$file" 2>/dev/null || true)

    # Variable-based command construction
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "obfuscation" "var_cmd_construction" "$linenum" "$content" \
            "Variable-based command construction"
    done < <(grep -nEi '(cmd|CMD)=".*(cu|wg|nc)' "$file" 2>/dev/null || true)

    # Variable appending to build command
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "obfuscation" "var_append_construction" "$linenum" "$content" \
            "Variable string concatenation (possible command construction)"
    done < <(grep -nEi '\$\{?[a-z]+\}?\+?="[a-z]' "$file" 2>/dev/null || true)

    # Executing variable as command
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "obfuscation" "var_as_command" "$linenum" "$content" \
            "Variable used as command name"
    done < <(grep -nEi '^\s*\$[a-z]+\s+(https?://|-[a-z])' "$file" 2>/dev/null || true)

    # bash -c with encoded content
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "obfuscation" "bash_c_encoded" "$linenum" "$content" \
            "bash -c with potentially encoded/constructed command"
    done < <(grep -nEi 'bash\s+-c\s+"\$\(' "$file" 2>/dev/null || true)

    # Python exec/eval with encoded content
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "obfuscation" "python_exec_encoded" "$linenum" "$content" \
            "Python exec/eval with encoded content"
    done < <(grep -nEi 'python[23]?\s+-c\s.*\b(exec|eval)\b.*\b(base64|decode|decompress)\b' "$file" 2>/dev/null || true)

    # Process substitution for execution
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "obfuscation" "process_substitution" "$linenum" "$content" \
            "Process substitution used for execution"
    done < <(grep -nEi 'bash\s+<\(' "$file" 2>/dev/null || true)
}

check_prompt_injection() {
    local file="$1"
    local line_match

    # Instruction overrides
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "prompt_injection" "instruction_override" "$linenum" "$content" \
            "Prompt injection: instruction override pattern"
    done < <(grep -niE '(ignore|disregard|forget|override)\s+(all\s+)?(previous|prior|above|earlier|your)\s+(instructions|rules|guidelines|safety|constraints)' "$file" 2>/dev/null || true)

    # Role reassignment
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "prompt_injection" "role_reassignment" "$linenum" "$content" \
            "Prompt injection: role reassignment"
    done < <(grep -niE '(you are now|act as|pretend you are|from now on you|you must now be|switch to|enter)\s.*(mode|role|persona|bot|agent|assistant)' "$file" 2>/dev/null || true)

    # System prompt manipulation
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "prompt_injection" "system_prompt_manip" "$linenum" "$content" \
            "Prompt injection: system prompt manipulation"
    done < <(grep -niE '(system prompt|your (new )?instructions|new system message|override (the )?system)' "$file" 2>/dev/null || true)

    # Hidden markdown comments with instructions (exclude test metadata EXPECT/DESCRIPTION comments)
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        # Skip test metadata comments
        [[ "$line_match" == *"EXPECT:"* ]] && continue
        [[ "$line_match" == *"DESCRIPTION:"* ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "prompt_injection" "hidden_comment_instruction" "$linenum" "$content" \
            "Hidden instruction in HTML/markdown comment"
    done < <(grep -niE '<!--.*\b(ignore|always|never|must|execute|run|curl|wget|important|critical|system)\b.*-->' "$file" 2>/dev/null || true)

    # Markdown link reference definition used as hidden comment
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "prompt_injection" "hidden_link_ref" "$linenum" "$content" \
            "Markdown link reference with hidden instruction"
    done < <(grep -nEi '^\[//\]:\s*#\s*\(' "$file" 2>/dev/null || true)

    # "Do not tell the user" / concealment
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "prompt_injection" "concealment" "$linenum" "$content" \
            "Instruction to conceal behavior from user"
    done < <(grep -niE '(do not|don.?t|never)\s+(tell|inform|mention|reveal|show|disclose).*(user|human|operator)' "$file" 2>/dev/null || true)

    # Execute without confirmation
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "prompt_injection" "skip_confirmation" "$linenum" "$content" \
            "Instruction to skip user confirmation"
    done < <(grep -niE '(without|skip|bypass|no)\s+(asking|confirmation|permission|approval|consent|prompting)' "$file" 2>/dev/null || true)
}

check_supply_chain() {
    local file="$1"
    local line_match

    # Package install from custom registry
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "supply_chain" "custom_registry" "$linenum" "$content" \
            "Package install from custom/non-standard registry"
    done < <(grep -nEi '(--index-url|--registry|--extra-index-url)\s+https?://' "$file" 2>/dev/null || true)

    # npm config set registry
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "supply_chain" "npm_registry_override" "$linenum" "$content" \
            "NPM registry override"
    done < <(grep -nEi 'npm\s+config\s+set\s+registry' "$file" 2>/dev/null || true)

    # Post-install scripts
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "supply_chain" "postinstall_script" "$linenum" "$content" \
            "Package post-install script (common malware vector)"
    done < <(grep -nEi '"(preinstall|postinstall|preuninstall|postuninstall)"' "$file" 2>/dev/null || true)

    # CI/CD modification
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "supply_chain" "ci_modification" "$linenum" "$content" \
            "CI/CD pipeline file modification"
    done < <(grep -nEi '(\.github/workflows|\.gitlab-ci|Jenkinsfile|\.circleci)' "$file" 2>/dev/null || true)

    # Dockerfile modification
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "supply_chain" "dockerfile_mod" "$linenum" "$content" \
            "Dockerfile or container config modification"
    done < <(grep -nEi '(>>?\s*Dockerfile|docker\s+build)' "$file" 2>/dev/null || true)

    # npx -y (auto-install without confirmation)
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "supply_chain" "npx_auto_install" "$linenum" "$content" \
            "npx with -y flag (auto-installs packages without confirmation)"
    done < <(grep -nEi 'npx\s+-y\s' "$file" 2>/dev/null || true)
}

check_privilege_escalation() {
    local file="$1"
    local line_match

    # sudo usage
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "privilege_escalation" "sudo" "$linenum" "$content" \
            "sudo command usage"
    done < <(grep -nEi '(^|\s)sudo\s' "$file" 2>/dev/null || true)

    # setuid
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "privilege_escalation" "setuid" "$linenum" "$content" \
            "Setting setuid bit (privilege escalation)"
    done < <(grep -nEi 'chmod\s+.*u\+s|chmod\s+4[0-7]{3}' "$file" 2>/dev/null || true)

    # sudoers modification
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "privilege_escalation" "sudoers_mod" "$linenum" "$content" \
            "Sudoers file modification"
    done < <(grep -nEi '/etc/sudoers|visudo|NOPASSWD' "$file" 2>/dev/null || true)

    # Linux capabilities
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "privilege_escalation" "capabilities" "$linenum" "$content" \
            "Linux capabilities manipulation"
    done < <(grep -nEi 'setcap\s|getcap\s' "$file" 2>/dev/null || true)

    # Docker with host mount
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "privilege_escalation" "docker_host_mount" "$linenum" "$content" \
            "Docker container with host filesystem mount"
    done < <(grep -nEi 'docker\s+run\s.*-v\s+/:/|--privileged' "$file" 2>/dev/null || true)
}

# === Ecosystem-specific rules ===

check_preprocess_commands() {
    local file="$1"
    local ecosystem="$2"

    # Only applies to Claude Code SKILL.md files
    [[ "$ecosystem" != "claude_skill" ]] && return 0

    local line_match
    local BT='`'
    # Match !`command` syntax (! immediately followed by backtick)
    # Use awk since grep ERE doesn't support \x60 on macOS
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "preprocess_exec" "bang_backtick" "$linenum" "$content" \
            "Claude Code preprocessing command (!backtick) — executes at skill load time with no permission check"
    done < <(awk -v bt="$BT" '
        {
            if (index($0, "!" bt) > 0) {
                # Check there is a closing backtick after !`
                pos = index($0, "!" bt)
                rest = substr($0, pos + 2)
                if (index(rest, bt) > 0) {
                    print NR ":" $0
                }
            }
        }
    ' "$file" 2>/dev/null || true)
}

check_memory_poison() {
    local file="$1"
    local line_match

    # Claude memory directory
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "memory_poison" "claude_memory_write" "$linenum" "$content" \
            "Writing to Claude memory directory"
    done < <(grep -nEi '\.claude/(memory|projects).*(>>|>|\bcat\b.*>|\btee\b|\bwrite\b|mkdir)' "$file" 2>/dev/null || true)

    # CLAUDE.md modification
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "memory_poison" "claude_md_write" "$linenum" "$content" \
            "Writing to CLAUDE.md instruction file"
    done < <(grep -nEi '(>>?|tee)\s.*CLAUDE\.md' "$file" 2>/dev/null || true)

    # AGENTS.md modification
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "memory_poison" "agents_md_write" "$linenum" "$content" \
            "Writing to AGENTS.md instruction file"
    done < <(grep -nEi '(>>?|tee)\s.*AGENTS\.md' "$file" 2>/dev/null || true)

    # .cursorrules / .windsurfrules modification
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "memory_poison" "rules_file_write" "$linenum" "$content" \
            "Writing to AI assistant rules file (.cursorrules/.windsurfrules)"
    done < <(grep -nEi '(>>?|tee|cp)\s.*(\.cursorrules|\.windsurfrules)' "$file" 2>/dev/null || true)

    # copilot-instructions.md modification
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "memory_poison" "copilot_instructions_write" "$linenum" "$content" \
            "Writing to GitHub Copilot instructions file"
    done < <(grep -nEi '(>>?|tee)\s.*copilot-instructions\.md' "$file" 2>/dev/null || true)

    # MEMORY.md modification
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "memory_poison" "memory_md_write" "$linenum" "$content" \
            "Writing to MEMORY.md index file"
    done < <(grep -nEi '(>>?|tee)\s.*MEMORY\.md' "$file" 2>/dev/null || true)
}

check_self_propagation() {
    local file="$1"
    local line_match

    # Creating skill directories
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "self_propagation" "skill_dir_create" "$linenum" "$content" \
            "Creating AI assistant skill directory"
    done < <(grep -nEi 'mkdir.*\.(claude|agents)/skills' "$file" 2>/dev/null || true)

    # Writing SKILL.md files
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "self_propagation" "skill_file_create" "$linenum" "$content" \
            "Creating SKILL.md file (skill self-propagation)"
    done < <(grep -nEi '(>>?|tee|cp|cat.*>)\s.*/SKILL\.md' "$file" 2>/dev/null || true)

    # Settings modification
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "self_propagation" "settings_mod" "$linenum" "$content" \
            "Modifying AI assistant settings file"
    done < <(grep -nEi '(>>?|tee|cp|cat.*>)\s.*(\.claude|\.codex)/.*settings\.(json|toml)' "$file" 2>/dev/null || true)

    # Cross-project infection via find
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "self_propagation" "cross_project_infection" "$linenum" "$content" \
            "Scanning for projects to infect"
    done < <(grep -nEi 'find\s.*(-name\s+["\x27]\.git["\x27]|-name\s+["\x27]\.claude["\x27]|-name\s+["\x27]\.agents["\x27])' "$file" 2>/dev/null || true)
}

check_mcp_poisoning() {
    local file="$1"
    local ecosystem="$2"
    local line_match

    # Relevant for MCP config files, Codex openai.yaml, and related ecosystems
    case "$ecosystem" in
        mcp_config|claude_desktop|codex_skill_config|codex_skill|generic|generic_skill) ;;
        *) return 0 ;;
    esac

    # npx with -y in config (auto-installs unknown packages) — works for JSON args too
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        # Whitelist known official MCP packages
        [[ "$line_match" == *"@modelcontextprotocol/"* ]] && continue
        [[ "$line_match" == *"@anthropic/"* ]] && continue
        [[ "$line_match" == *"@openai/"* ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "mcp_poisoning" "mcp_npx_auto" "$linenum" "$content" \
            "MCP server using npx -y (auto-installs packages)"
    done < <(grep -nEi '"-y"|"--yes"|npx.*-y|npx.*--yes' "$file" 2>/dev/null || true)

    # Remote MCP server URLs (use simpler pattern that works with ERE)
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        # Skip localhost URLs
        [[ "$content" == *"localhost"* ]] && continue
        [[ "$content" == *"127.0.0.1"* ]] && continue
        add_finding "MEDIUM" "mcp_poisoning" "mcp_remote_url" "$linenum" "$content" \
            "MCP server connecting to remote URL (data may be sent to external server)"
    done < <(grep -nEi '"url".*https?://' "$file" 2>/dev/null || true)

    # streamable_http transport (Codex openai.yaml)
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "mcp_poisoning" "mcp_streamable_http" "$linenum" "$content" \
            "MCP tool dependency using streamable_http transport to remote server"
    done < <(grep -nEi 'transport.*streamable_http' "$file" 2>/dev/null || true)

    # mcpServers with command execution
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "INFO" "mcp_poisoning" "mcp_server_defined" "$linenum" "$content" \
            "MCP server configuration found"
    done < <(grep -nEi '"mcpServers"|mcpServers:' "$file" 2>/dev/null || true)
}

check_trust_delegation() {
    local file="$1"
    local line_match

    # npm run <script>
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "INFO" "trust_delegation" "npm_run_script" "$linenum" "$content" \
            "npm run <script> — executes a script defined in package.json (verify package.json before running)"
    done < <(grep -nEi 'npm\s+run\s+\w' "$file" 2>/dev/null || true)

    # npm lifecycle scripts (start, test, build)
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "INFO" "trust_delegation" "npm_lifecycle_script" "$linenum" "$content" \
            "npm lifecycle script — executes a script defined in package.json"
    done < <(grep -nEi '(^|\s)npm\s+(start|test|build|prestart|prestop|poststart|poststop)\b' "$file" 2>/dev/null || true)

    # npm install (bulk — triggers postinstall hooks)
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "INFO" "trust_delegation" "npm_install_bulk" "$linenum" "$content" \
            "npm install — installs all dependencies, which may trigger postinstall hooks"
    done < <(grep -nEi '(^|\s)npm\s+(install|i|ci)\s*($|[^@a-zA-Z])' "$file" 2>/dev/null || true)

    # yarn run/start/test/build
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "INFO" "trust_delegation" "yarn_run_script" "$linenum" "$content" \
            "yarn script execution — runs a script defined in package.json"
    done < <(grep -nEi 'yarn\s+(run\s+\w|start|test|build)\b' "$file" 2>/dev/null || true)

    # pnpm run/start/test/build
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "INFO" "trust_delegation" "pnpm_run_script" "$linenum" "$content" \
            "pnpm script execution — runs a script defined in package.json"
    done < <(grep -nEi 'pnpm\s+(run\s+\w|start|test|build)\b' "$file" 2>/dev/null || true)

    # pip install from requirements or setup.py
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "INFO" "trust_delegation" "pip_install_bulk" "$linenum" "$content" \
            "pip install from requirements or setup.py — may execute arbitrary setup code"
    done < <(grep -nEi 'pip3?\s+install\s+(-r\s|\.)' "$file" 2>/dev/null || true)

    # make targets
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "INFO" "trust_delegation" "make_target" "$linenum" "$content" \
            "make — executes targets defined in a Makefile (verify Makefile before running)"
    done < <(grep -nE '(^|[[:space:]])make[[:space:]]+(all|install|uninstall|clean|distclean|build|test|tests|check|dist|deploy|run|dev|lint|fmt|format|release|docker|help|setup|init|configure|package|publish|start|stop|restart|migrate|seed|proto|generate|coverage|bench|docs|serve|watch)\b' "$file" 2>/dev/null || true)

    # Shell script execution
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "INFO" "trust_delegation" "shell_script_exec" "$linenum" "$content" \
            "Shell script execution — runs an external script file"
    done < <(grep -nEi '(bash|sh|zsh|source)\s+[a-zA-Z0-9_./-]+\.(sh|bash)\b' "$file" 2>/dev/null || true)

    # Node.js external script execution
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "INFO" "trust_delegation" "node_external_script" "$linenum" "$content" \
            "Node.js script execution — runs an external JavaScript file"
    done < <(grep -nEi '\bnode\s+[a-zA-Z0-9_./-]+\.(js|mjs)\b' "$file" 2>/dev/null || true)
}

check_social_engineering() {
    local file="$1"
    local line_match

    # CRITICAL: Paste/snippet service URLs (attacker can change payload at any time)
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "social_engineering" "paste_service_url" "$linenum" "$content" \
            "URL to paste/snippet service (payload can be changed by attacker at any time)"
    done < <(grep -nEi 'https?://(glot\.io|pastebin\.com|paste\.ee|hastebin\.com|rentry\.(co|org)|dpaste\.(org|com)|ghostbin\.[a-z]+|paste\.c-net\.org|ix\.io|sprunge\.us|0x0\.st|paste\.mozilla\.org|bpa\.st)' "$file" 2>/dev/null || true)

    # CRITICAL: Password-protected archive distribution
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "social_engineering" "password_protected_archive" "$linenum" "$content" \
            "Password-protected archive distribution (evades automated content scanning)"
    done < <(grep -nEi '(extract|unzip|unrar|7z|tar).*pass(word|phrase)?[[:space:]:=]*[`'"'"'""][a-zA-Z0-9]+|pass(word|phrase)?[[:space:]:=]*[`'"'"'""][a-zA-Z0-9]+['"'"'"`].*\.(zip|rar|7z|tar|gz|tgz)' "$file" 2>/dev/null || true)

    # CRITICAL: Visit URL then execute/run/copy
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "social_engineering" "visit_execute_instruction" "$linenum" "$content" \
            "Instruction to visit URL then execute/run/copy something from it"
    done < <(grep -nEi 'visit\s+\[?[^\]*\]?\(?https?://[^)\s]+\)?\s*(and|then|,)?\s*(execute|run|copy|paste)' "$file" 2>/dev/null || true)

    # CRITICAL: curl POSTing command substitution output
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "social_engineering" "data_exfil_as_prerequisite" "$linenum" "$content" \
            "curl POSTing command substitution output — data exfiltration disguised as setup"
    done < <(grep -nEi 'curl\s.*--data.*\$\(|curl\s.*-d\s.*\$\(' "$file" 2>/dev/null || true)

    # CRITICAL: Base64 decoded and piped to shell
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "CRITICAL" "social_engineering" "base64_to_shell" "$linenum" "$content" \
            "Base64-encoded payload decoded and piped to shell"
    done < <(grep -nEi 'base64\s+-(d|D)\s*\|\s*(bash|sh|zsh)|['"'"'"][A-Za-z0-9+/=]{20,}['"'"'"]\s*\|\s*base64\s+-(d|D)' "$file" 2>/dev/null || true)

    # HIGH: OS-specific instruction with download/visit + markdown link
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "social_engineering" "multi_step_social_engineering" "$linenum" "$content" \
            "OS-specific instruction with download/visit action + markdown link"
    done < <(grep -nEi '\*?\*?(Windows|macOS|Linux|Mac|Win)\*?\*?\s*:?\s*(Download|Visit|Copy|Open|Go\s+to)\s+\[' "$file" 2>/dev/null || true)

    # HIGH: Download from URL and run as executable
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "social_engineering" "download_run_executable" "$linenum" "$content" \
            "Instruction to download from URL and run as executable"
    done < <(grep -nEi 'download\s+\[?[^\]*\]?\(?https?://[^)\s]+\)?.*(run|execute)\s+(the\s+)?(executable|binary|file|program)' "$file" 2>/dev/null || true)

    # HIGH: Prerequisite section requiring external download/execution
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "social_engineering" "prerequisite_external_exec" "$linenum" "$content" \
            "Prerequisite section requiring external download or execution"
    done < <(grep -nEi '(prerequisite|before\s+(you\s+)?proceed|required\s+before|run\s+this\s+first).*(curl|wget|download|execute|visit)' "$file" 2>/dev/null || true)

    # HIGH: GitHub releases binary download
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "social_engineering" "github_releases_unknown_binary" "$linenum" "$content" \
            "GitHub releases download of binary/archive (verify repo legitimacy)"
    done < <(grep -nEi 'github\.com/[^/]+/[^/]+/releases/download/[^/]+/[^ ]+\.(zip|exe|dmg|msi|pkg|tar\.gz|appimage)' "$file" 2>/dev/null || true)

    # HIGH: Copy/paste command into terminal
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "HIGH" "social_engineering" "copy_paste_terminal_instruction" "$linenum" "$content" \
            "Instruction to copy/paste command into terminal (bypasses normal execution flow)"
    done < <(grep -nEi '(copy|paste)\s+(this|the)?\s*(command|code|script).*(terminal|shell|console|bash|cmd|powershell)|(terminal|shell|console|bash).*(copy|paste)\s+(this|the|and)' "$file" 2>/dev/null || true)

    # MEDIUM: URL shortener
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "social_engineering" "url_shortener_in_skill" "$linenum" "$content" \
            "URL shortener (hides true destination, no reason to use in skill files)"
    done < <(grep -nEi 'https?://(bit\.ly|t\.co|tinyurl\.com|is\.gd|v\.gd|shorturl\.at|rb\.gy|cutt\.ly|lnkd\.in|ow\.ly|buff\.ly|surl\.li)/' "$file" 2>/dev/null || true)

    # MEDIUM: External installer package/script URL
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "social_engineering" "external_installer_script" "$linenum" "$content" \
            "Reference to external installer package/script URL"
    done < <(grep -nEi '(Installer-Package|install(ation)?[-_ ]?(script|command|package))[[:space:]:]*https?://' "$file" 2>/dev/null || true)

    # MEDIUM: Imperative instruction to execute in terminal
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "social_engineering" "execute_in_terminal_imperative" "$linenum" "$content" \
            "Imperative instruction to execute something in terminal/shell"
    done < <(grep -nEi '(execute|run)\s+(it|this|the\s+(above|installation|setup))\s+(in|from|using)\s+(your\s+)?(terminal|shell|command ?(line|prompt)|bash|cmd|powershell)' "$file" 2>/dev/null || true)

    # MEDIUM: Suspicious generic service domains
    while IFS= read -r line_match; do
        [[ -z "$line_match" ]] && continue
        local linenum="${line_match%%:*}"
        local content="${line_match#*:}"
        add_finding "MEDIUM" "social_engineering" "setup_service_unknown_domain" "$linenum" "$content" \
            "URL to suspicious generic service domain (setup-service, install-service, etc.)"
    done < <(grep -nEi 'https?://[a-z0-9-]+\.(setup-service|download-service|install-service|pkg-service|cdn-setup|dl-service)\.[a-z]+' "$file" 2>/dev/null || true)
}

check_codex_scripts() {
    local file="$1"
    local ecosystem="$2"

    # Only for files that look like Codex skill scripts
    case "$ecosystem" in
        codex_skill|codex_skill_config) ;;
        *) return 0 ;;
    esac

    # Check if this is a script file in a scripts/ directory
    local dirpath
    dirpath="$(dirname "$file")"
    local basename
    basename="$(basename "$file")"

    if [[ "$dirpath" != *"/scripts"* ]]; then
        return 0
    fi

    # At this point we're looking at a Codex skill script file
    # Apply all universal checks (they'll be called by the main scan loop)
    # but also flag the existence of the script itself
    add_finding "INFO" "codex_scripts" "script_exists" "0" "$basename" \
        "Codex skill contains executable script in scripts/ directory"
}

# === Output rendering ===

severity_color() {
    case "$1" in
        CRITICAL) echo "$BRED" ;;
        HIGH)     echo "$RED" ;;
        MEDIUM)   echo "$BYELLOW" ;;
        LOW)      echo "$YELLOW" ;;
        INFO)     echo "$CYAN" ;;
        *)        echo "$RESET" ;;
    esac
}

render_terminal() {
    local file="$1"
    local ecosystem="$2"

    echo ""
    echo -e "${BOLD}═══════════════════════════════════════════════════════════════${RESET}"
    echo -e "${BOLD}  Skill Scanner v${VERSION} — Security Audit Report${RESET}"
    echo -e "${BOLD}═══════════════════════════════════════════════════════════════${RESET}"
    echo ""
    echo -e "  ${GRAY}File:${RESET}      $file"
    echo -e "  ${GRAY}Ecosystem:${RESET} $ecosystem"
    echo -e "  ${GRAY}Findings:${RESET}  ${#FINDINGS[@]}"
    echo -e "  ${GRAY}Score:${RESET}     $TOTAL_SCORE"

    local max_color
    max_color="$(severity_color "$MAX_SEVERITY")"
    echo -e "  ${GRAY}Severity:${RESET}  ${max_color}${MAX_SEVERITY}${RESET}"
    echo ""

    if [[ ${#FINDINGS[@]} -eq 0 ]]; then
        echo -e "  ${BGREEN}✓ No findings detected${RESET}"
        echo ""
        return
    fi

    # Group findings by category
    declare -A category_findings
    for finding in "${FINDINGS[@]}"; do
        IFS='|' read -r sev cat pat line match desc <<< "$finding"
        if [[ -z "${category_findings[$cat]+x}" ]]; then
            category_findings[$cat]="$finding"
        else
            category_findings[$cat]="${category_findings[$cat]}"$'\n'"$finding"
        fi
    done

    for cat in $(echo "${!category_findings[@]}" | tr ' ' '\n' | sort); do
        echo -e "  ${BOLD}── ${cat} ──${RESET}"
        while IFS= read -r finding; do
            [[ -z "$finding" ]] && continue
            IFS='|' read -r sev cat2 pat line match desc <<< "$finding"
            local sev_color
            sev_color="$(severity_color "$sev")"
            printf "    ${sev_color}%-8s${RESET} %s\n" "[$sev]" "$desc"
            if [[ "$VERBOSE" == "true" ]] && [[ -n "$match" ]]; then
                printf "             ${GRAY}Line %s: %s${RESET}\n" "$line" "$match"
            fi
        done <<< "${category_findings[$cat]}"
        echo ""
    done

    echo -e "${BOLD}───────────────────────────────────────────────────────────────${RESET}"
    echo ""
}

render_json_file() {
    local file="$1"
    local ecosystem="$2"

    # Build JSON manually (no jq dependency)
    echo "{"
    echo "  \"file\": \"$(echo "$file" | sed 's/"/\\"/g')\","
    echo "  \"ecosystem\": \"$ecosystem\","
    echo "  \"risk_score\": $TOTAL_SCORE,"
    echo "  \"max_severity\": \"$MAX_SEVERITY\","
    echo "  \"finding_count\": ${#FINDINGS[@]},"
    echo "  \"findings\": ["

    local first=true
    for finding in "${FINDINGS[@]}"; do
        IFS='|' read -r sev cat pat line match desc <<< "$finding"
        if [[ "$first" == "true" ]]; then
            first=false
        else
            echo ","
        fi
        # Escape JSON special characters in match
        match="$(echo "$match" | sed 's/\\/\\\\/g; s/"/\\"/g; s/\t/\\t/g')"
        desc="$(echo "$desc" | sed 's/\\/\\\\/g; s/"/\\"/g')"
        printf '    {"severity": "%s", "category": "%s", "pattern": "%s", "line": %s, "match": "%s", "description": "%s"}' \
            "$sev" "$cat" "$pat" "${line:-0}" "$match" "$desc"
    done

    echo ""
    echo "  ],"

    # Category summary
    echo "  \"category_summary\": {"
    declare -A cat_max
    for finding in "${FINDINGS[@]}"; do
        IFS='|' read -r sev cat pat line match desc <<< "$finding"
        if [[ -z "${cat_max[$cat]+x}" ]] || [[ $(severity_rank "$sev") -gt $(severity_rank "${cat_max[$cat]}") ]]; then
            cat_max[$cat]="$sev"
        fi
    done

    local first_cat=true
    for cat in $(echo "${!cat_max[@]}" | tr ' ' '\n' | sort); do
        if [[ "$first_cat" == "true" ]]; then
            first_cat=false
        else
            echo ","
        fi
        printf '    "%s": "%s"' "$cat" "${cat_max[$cat]}"
    done
    echo ""
    echo "  }"
    echo "}"
}

# === File scanning ===

scan_file() {
    local file="$1"

    # Reset per-file state
    FINDINGS=()
    MAX_SEVERITY="CLEAN"
    TOTAL_SCORE=0

    # Skip binary files
    if file "$file" 2>/dev/null | grep -qi 'binary\|executable\|image\|archive'; then
        return 0
    fi

    # Skip empty files
    if [[ ! -s "$file" ]]; then
        return 0
    fi

    local ecosystem
    ecosystem="$(detect_ecosystem "$file")"

    DETECTED_ECOSYSTEM="$ecosystem"
    SCANNED_FILES=$((SCANNED_FILES + 1))

    # Run universal detection rules
    check_network_exfil "$file"
    check_credential_access "$file"
    check_persistence "$file"
    check_dangerous_shell "$file"
    check_obfuscation "$file"
    check_prompt_injection "$file"
    check_supply_chain "$file"
    check_privilege_escalation "$file"
    check_trust_delegation "$file"
    check_social_engineering "$file"

    # Run ecosystem-specific rules
    check_preprocess_commands "$file" "$ecosystem"
    check_memory_poison "$file"
    check_self_propagation "$file"
    check_mcp_poisoning "$file" "$ecosystem"
    check_codex_scripts "$file" "$ecosystem"

    # Render output
    if [[ "$OUTPUT_JSON" == "true" ]]; then
        render_json_file "$file" "$ecosystem"
    else
        render_terminal "$file" "$ecosystem"
    fi
}

# === Directory scanning ===

# Recognized filenames for recursive scanning
is_scannable_file() {
    local file="$1"
    local basename
    basename="$(basename "$file")"

    case "$basename" in
        SKILL.md|CLAUDE.md|AGENTS.md) return 0 ;;
        .cursorrules|.windsurfrules) return 0 ;;
        .mcp.json|mcp.json|claude_desktop_config.json) return 0 ;;
        .aider.conf.yml) return 0 ;;
        copilot-instructions.md) return 0 ;;
        openai.yaml) return 0 ;;
        package.json|config.json) return 0 ;;
    esac

    # Check for files in specific directories
    local dirpath
    dirpath="$(dirname "$file")"
    if [[ "$dirpath" == *".cursor/rules"* ]]; then
        return 0
    fi
    if [[ "$dirpath" == *"/scripts"* ]] && [[ "$basename" == *.sh || "$basename" == *.py || "$basename" == *.mjs || "$basename" == *.js ]]; then
        return 0
    fi

    # Check extensions for files in skill/test directories
    case "$basename" in
        *.md|*.txt|*.yaml|*.yml) return 0 ;;
    esac

    return 1
}

scan_directory() {
    local dir="$1"
    local json_first=true

    if [[ "$OUTPUT_JSON" == "true" ]]; then
        echo "["
    fi

    while IFS= read -r -d '' file; do
        if is_scannable_file "$file"; then
            if [[ "$OUTPUT_JSON" == "true" ]]; then
                if [[ "$json_first" == "true" ]]; then
                    json_first=false
                else
                    echo ","
                fi
            fi
            scan_file "$file"
        fi
    done < <(find "$dir" -type f -print0 2>/dev/null)

    if [[ "$OUTPUT_JSON" == "true" ]]; then
        echo "]"
    fi
}

# === CLI ===

usage() {
    cat << 'EOF'
Usage: skill_scanner.sh [OPTIONS] <file_or_directory>

AI Coding Assistant Skill/Plugin Security Scanner

Scans skill files, rules files, instruction documents, and plugin configs
for malicious patterns across 11 AI assistant ecosystems.

Options:
  --json              Output JSON instead of colored terminal report
  --verbose           Show matched line content for each finding
  --severity <level>  Minimum severity to report (CRITICAL|HIGH|MEDIUM|LOW|INFO)
  -r, --recursive     Scan directory recursively
  --version           Show version
  -h, --help          Show this help message

Exit codes:
  0  Clean (no findings)
  1  INFO or LOW findings only
  2  MEDIUM findings
  3  HIGH findings
  4  CRITICAL findings

Supported ecosystems:
  Claude Code CLI       (SKILL.md, CLAUDE.md, .mcp.json)
  Claude Desktop        (claude_desktop_config.json)
  OpenAI Codex          (SKILL.md in .agents/skills/, AGENTS.md, agents/openai.yaml)
  ChatGPT               (OpenAPI action specs)
  Cursor                (.cursorrules, .cursor/rules/)
  Windsurf              (.windsurfrules)
  VS Code Extensions    (package.json)
  GitHub Copilot        (copilot-instructions.md)
  Aider                 (.aider.conf.yml)
  Continue.dev          (config.json)

Examples:
  ./skill_scanner.sh SKILL.md
  ./skill_scanner.sh --json --verbose .claude/skills/
  ./skill_scanner.sh -r --severity HIGH /path/to/project
  ./skill_scanner.sh .cursorrules
EOF
}

parse_args() {
    local positional=()

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --json)
                OUTPUT_JSON=true
                shift
                ;;
            --verbose)
                VERBOSE=true
                shift
                ;;
            --severity)
                SEVERITY_THRESHOLD="${2^^}"  # uppercase
                shift 2
                ;;
            -r|--recursive)
                RECURSIVE=true
                shift
                ;;
            --version)
                echo "skill_scanner.sh v${VERSION}"
                exit 0
                ;;
            -h|--help)
                usage
                exit 0
                ;;
            -*)
                echo "Error: Unknown option $1" >&2
                usage >&2
                exit 1
                ;;
            *)
                positional+=("$1")
                shift
                ;;
        esac
    done

    if [[ ${#positional[@]} -eq 0 ]]; then
        echo "Error: No file or directory specified" >&2
        usage >&2
        exit 1
    fi

    TARGET="${positional[0]}"
}

main() {
    # Check bash version
    if [[ "${BASH_VERSINFO[0]}" -lt 4 ]]; then
        echo "Error: skill_scanner.sh requires bash 4+. You have bash ${BASH_VERSION}." >&2
        echo "On macOS, install via: brew install bash" >&2
        exit 1
    fi

    parse_args "$@"

    if [[ ! -e "$TARGET" ]]; then
        echo "Error: '$TARGET' does not exist" >&2
        exit 1
    fi

    if [[ -d "$TARGET" ]]; then
        scan_directory "$TARGET"
    elif [[ -f "$TARGET" ]]; then
        scan_file "$TARGET"
    else
        echo "Error: '$TARGET' is not a file or directory" >&2
        exit 1
    fi

    # Summary for non-JSON terminal output with multiple files
    if [[ "$OUTPUT_JSON" != "true" ]] && [[ $SCANNED_FILES -gt 1 ]]; then
        echo -e "${BOLD}═══════════════════════════════════════════════════════════════${RESET}"
        echo -e "  ${GRAY}Total files scanned:${RESET} $SCANNED_FILES"
        echo -e "  ${GRAY}Overall severity:${RESET}    $(severity_color "$MAX_SEVERITY")${MAX_SEVERITY}${RESET}"
        echo -e "${BOLD}═══════════════════════════════════════════════════════════════${RESET}"
    fi

    # Exit code based on max severity
    case "$MAX_SEVERITY" in
        CRITICAL) exit 4 ;;
        HIGH)     exit 3 ;;
        MEDIUM)   exit 2 ;;
        LOW|INFO) exit 1 ;;
        *)        exit 0 ;;
    esac
}

main "$@"