import os

def list_shell_commands():
    # Get the system's PATH environment variable
    path_env = os.environ.get('PATH', '')

    # Split the PATH into individual directories
    path_dirs = path_env.split(os.pathsep)

    # Initialize a set to store unique command names
    commands = set()

    # Iterate over each directory in PATH
    for directory in path_dirs:
        try:
            # List all entries in the directory
            for entry in os.listdir(directory):
                # Construct full path
                full_path = os.path.join(directory, entry)

                # Check if entry is a file and is executable
                if os.path.isfile(full_path) and os.access(full_path, os.X_OK):
                    commands.add(entry)
        except FileNotFoundError:
            # If the directory does not exist, skip it
            pass

    # Sort and print the list of commands
    for command in sorted(commands):
        print(command)

if __name__ == "__main__":
    list_shell_commands()

#!/bin/bash

# List all available commands
compgen -c | sort -u

#!/bin/bash

echo "Built-in commands:"
compgen -b | sort -u

echo -e "\nAliases:"
compgen -a | sort -u

echo -e "\nFunctions:"
compgen -A function | sort -u

echo -e "\nExternal Commands:"
compgen -c | while read -r cmd; do
    type -t "$cmd" | grep -q 'file' && echo "$cmd"
done | sort -u

#!/bin/bash

# Declare an array to store available commands
available_commands=()

# IFS is set so that we can handle directories with spaces in their names
IFS=':'

# Iterate over each path in the PATH variable
for dir in $PATH; do
    # Check if directory exists and is readable
    if [[ -d "$dir" && -r "$dir" ]]; then
        # Append each executable file in the directory to the available commands list
        for file in "$dir"/*; do
            # Check if file is executable
            if [[ -x "$file" && ! -d "$file" ]]; then
                available_commands+=("$(basename "$file")")
            fi
        done
    fi 
done

# Reset IFS to default value
unset IFS

# Sort and print unique commands
printf "%s\n" "${available_commands[@]}" | sort -u

#!/bin/bash

# List of built-in commands
echo "Built-in commands:"
compgen -b

echo ""
# List of all executables found in directories listed in $PATH
echo "Commands in PATH:"
compgen -c | sort -u

# Explanation:
# - `compgen` is a bash built-in command used to list possible completions.
#   - `-b`: Lists all built-in commands available in the current shell.
#   - `-c`: Lists all command names found in the system's `PATH`.
# - `sort -u` is used to sort the output and ensure uniqueness.

chmod +x list_commands.sh
./list_commands.sh

import os

def is_executable(file_path):
    """Check if a file is executable."""
    return os.path.isfile(file_path) and os.access(file_path, os.X_OK)

def get_available_commands():
    """Return a list of available shell commands on a Linux system."""
    available_commands = set()

    # Get directories in the PATH environment variable
    path_dirs = os.environ.get('PATH', '').split(os.pathsep)

    for dir_path in path_dirs:
        try:
            # List all files in the directory
            for filename in os.listdir(dir_path):
                file_path = os.path.join(dir_path, filename)

                # Check if the file is executable
                if is_executable(file_path):
                    available_commands.add(filename)
        except FileNotFoundError:
            # Skip directories that don't exist
            continue
        except PermissionError:
            # Skip directories we don't have permissions to access
            continue

    return sorted(available_commands)

if __name__ == "__main__":
    commands = get_available_commands()
    print("Available commands:")
    for cmd in commands:
        print(cmd)