DefinetlyNotAI
diff --git a/‎CODE/Logicytics.py‎
Lines changed: 86 additions & 28 deletions b/‎CODE/Logicytics.py‎
Lines changed: 86 additions & 28 deletions
diff --git a/‎CODE/_debug.py‎
Lines changed: 40 additions & 6 deletions b/‎CODE/_debug.py‎
Lines changed: 40 additions & 6 deletions
diff --git a/‎CODE/_dev.py‎
Lines changed: 44 additions & 10 deletions b/‎CODE/_dev.py‎
Lines changed: 44 additions & 10 deletions
@@ -75,10 +75,16 @@ def update() -> tuple[str, str]:
 
 def get_flags():
     """
-    Retrieves the action and sub-action flags_list from the Flag module and logs them.
-
-    This function sets the global variables ACTION and SUB_ACTION based on the data
-    retrieved from the Flag module. It also logs the retrieved values for debugging purposes.
+    Retrieves action and sub-action flags from the Flag module and sets global variables.
+    
+    This function extracts the current action and sub-action from the Flag module, setting global
+    ACTION and SUB_ACTION variables. It logs the retrieved values for debugging and tracing purposes.
+    
+    No parameters.
+    
+    Side effects:
+        - Sets global variables ACTION and SUB_ACTION
+        - Logs debug information about current action and sub-action
     """
     global ACTION, SUB_ACTION
     # Get flags_list
@@ -89,10 +95,22 @@ def get_flags():
 
 def special_execute(file_path: str):
     """
-    Executes a Python script in a new command prompt window.
-
-    Args:
-        file_path (str): The relative path to the Python script to be executed.
+    Execute a Python script in a new command prompt window.
+    
+    This function launches the specified Python script in a separate command prompt window, waits for its completion, and then exits the current process.
+    
+    Parameters:
+        file_path (str): The relative path to the Python script to be executed, 
+                         which will be resolved relative to the current script's directory.
+    
+    Side Effects:
+        - Opens a new command prompt window
+        - Runs the specified Python script
+        - Terminates the current process after script execution
+    
+    Raises:
+        FileNotFoundError: If the specified script path does not exist
+        subprocess.SubprocessError: If there are issues launching the subprocess
     """
     sr_current_dir = os.path.dirname(os.path.abspath(__file__))
     sr_script_path = os.path.join(sr_current_dir, file_path)
@@ -103,12 +121,23 @@ def special_execute(file_path: str):
 
 def handle_special_actions():
     """
-    Handles special actions based on the provided action flag.
-
-    This function checks the value of the `action` variable and performs
-    corresponding special actions such as opening debug, developer, or extra
-    tools menus, updating the repository, restoring backups, creating backups,
-    or unzipping extra files.
+    Handles special actions based on the current action flag.
+    
+    This function performs specific actions depending on the global `ACTION` variable:
+    - For "debug": Opens the debug menu by executing '_debug.py'
+    - For "dev": Opens the developer menu by executing '_dev.py'
+    - For "update": Updates the repository using Health.update() method
+    - For "restore": Displays a warning and opens the backup location
+    - For "backup": Creates backups of the CODE and MODS directories
+    
+    Side Effects:
+        - Logs informational, debug, warning, or error messages
+        - May execute external Python scripts
+        - May open file locations
+        - May terminate the program after completing special actions
+    
+    Raises:
+        SystemExit: Exits the program after completing certain special actions
     """
     # Special actions -> Quit
     if ACTION == "debug":
@@ -158,10 +187,18 @@ def handle_special_actions():
 def check_privileges():
     """
     Checks if the script is running with administrative privileges and handles UAC (User Account Control) settings.
-
+    
     This function verifies if the script has admin privileges. If not, it either logs a warning (in debug mode) or
     prompts the user to run the script with admin privileges and exits. It also checks if UAC is enabled and logs
     warnings accordingly.
+    
+    Raises:
+        SystemExit: If the script is not running with admin privileges and not in debug mode.
+    
+    Notes:
+        - Requires the `Check` module with `admin()` and `uac()` methods
+        - Depends on global `DEBUG` configuration variable
+        - Logs warnings or critical messages based on privilege and UAC status
     """
     if not Check.admin():
         if DEBUG == "DEBUG":
@@ -178,10 +215,29 @@ def check_privileges():
 
 def generate_execution_list() -> list | list[str] | list[str | Any]:
     """
-    Creates an execution list based on the provided action.
-
+    Generate an execution list of scripts based on the specified action.
+    
+    This function dynamically creates a list of scripts to be executed by filtering and selecting
+    scripts based on the global ACTION variable. It supports different execution modes:
+    - 'minimal': A predefined set of lightweight scripts
+    - 'nopy': PowerShell and script-based scripts without Python
+    - 'modded': Includes scripts from the MODS directory
+    - 'depth': Comprehensive script execution with data mining and logging scripts
+    - 'vulnscan_ai': Vulnerability scanning script only
+    
+    Parameters:
+        None
+    
     Returns:
-        list: The execution list of scripts to be executed.
+        list[str]: A list of script file paths to be executed, filtered and modified based on the current action.
+    
+    Raises:
+        ValueError: Implicitly if a script file cannot be removed from the initial list.
+    
+    Notes:
+        - Removes sensitive or unnecessary scripts from the initial file list
+        - Logs the final execution list for debugging purposes
+        - Warns users about potential long execution times for certain actions
     """
     execution_list = Get.list_of_files(".", extensions=(".py", ".exe", ".ps1", ".bat"))
     execution_list.remove("sensitive_data_miner.py")
@@ -345,16 +401,18 @@ def handle_sub_action():
 @log.function
 def Logicytics():
     """
-    Main function to run the Logicytics process.
-
-    This function performs the following steps:
-    1. Retrieves command-line flags_list and configurations.
-    2. Handles any special actions based on the provided action flag.
-    3. Checks for administrative privileges and potential errors.
-    4. Executes the scripts based on the action flag.
-    5. Zips the generated files.
-    6. Handles any sub-actions based on the provided sub-action flag.
-    7. Waits for user input to exit the program.
+    Orchestrates the complete Logicytics workflow, managing script execution, system actions, and user interactions.
+    
+    This function serves as the primary entry point for the Logicytics utility, coordinating a series of system-level operations:
+    - Retrieves command-line configuration flags
+    - Processes special actions
+    - Verifies system privileges
+    - Executes targeted scripts
+    - Compresses generated output files
+    - Handles final system sub-actions
+    - Provides a graceful exit mechanism
+    
+    Performs actions sequentially without returning a value, designed to be the main execution flow of the Logicytics utility.
     """
     # Get flags_list and configs
     get_flags()
 
@@ -179,12 +179,28 @@ def cpu_info() -> tuple[str, str, str]:
 
 def python_version():
     """
-    Checks the current Python version and logs the result.
-
+    Checks the current Python version against recommended version ranges and logs the result.
+    
+    This function determines the compatibility of the current Python runtime by comparing its version
+    against predefined minimum and maximum version thresholds. It provides informative logging about
+    the Python version status.
+    
+    Parameters:
+        None
+    
     Logs:
-        - Info if the Python version is within the acceptable range.
-        - Warning if the Python version is below the minimum recommended version.
-        - Error if the Python version is above the maximum supported version or if there is a parsing error.
+        - Info: When Python version is within the recommended range (3.11.x to 3.12.x)
+        - Warning: When Python version is below the minimum recommended version (< 3.11)
+        - Error: When Python version is above the maximum supported version (>= 3.13) or parsing fails
+    
+    Raises:
+        No explicit exceptions are raised; errors are logged internally
+    
+    Example:
+        Typical log outputs might include:
+        - "Python Version: 3.11.5 - Perfect"
+        - "Python Version: 3.10.2 - Recommended: 3.11.x"
+        - "Python Version: 3.13.0 - Incompatible"
     """
     version = sys.version.split()[0]
     MIN_VERSION = (3, 11)
@@ -222,7 +238,25 @@ def get_online_config() -> dict | None:
 @log_debug.function
 def debug():
     """
-    Executes system checks and logs results.
+    Executes a comprehensive system debug routine, performing various checks and logging system information.
+    
+    This function performs the following tasks:
+    - Clears the existing debug log file
+    - Retrieves and validates online configuration
+    - Checks system version compatibility
+    - Verifies required file integrity
+    - Checks SysInternal binaries
+    - Logs system privileges and environment details
+    - Checks Python version compatibility
+    - Retrieves and logs CPU information
+    
+    Logs are written to the debug log file, capturing system state, configuration, and potential issues.
+    
+    Notes:
+    - Requires admin privileges for full system checks
+    - Logs information about execution environment
+    - Checks system and Python version compatibility
+    - Provides insights into system configuration and potential security settings
     """
     # Clear Debug Log
     log_path = "../ACCESS/LOGS/DEBUG/DEBUG.log"
 
@@ -40,13 +40,24 @@ def _update_ini_file(filename: str, new_data: list | str, key: str) -> None:
 
 def _prompt_user(question: str, file_to_open: str = None, special: bool = False) -> bool:
     """
-        Prompts the user with a question and optionally opens a file if the answer is not 'yes'.
-        Args:
-            question (str): The question to ask the user.
-            file_to_open (str, optional): The file to open if the user doesn't answer 'yes'.
-        Returns:
-            bool: True if the user's answer is 'yes', otherwise False.
-        """
+    Prompts the user with a yes/no question and optionally opens a file.
+    
+    Parameters:
+        question (str): The question to be presented to the user.
+        file_to_open (str, optional): Path to a file that will be opened if the user does not respond affirmatively.
+        special (bool, optional): Flag to suppress the default reminder message when the user responds negatively.
+    
+    Returns:
+        bool: True if the user responds with 'yes' or 'Y', False otherwise.
+    
+    Raises:
+        Exception: Logs any unexpected errors during user interaction.
+    
+    Notes:
+        - Uses subprocess to open files on Windows systems
+        - Case-insensitive input handling for 'yes' responses
+        - Provides optional file opening and reminder messaging
+    """
     try:
         answer = input(question + " (Y)es or (N)o:- ")
         if not (answer.lower() == "yes" or answer.lower() == "y"):
@@ -65,9 +76,32 @@ def _prompt_user(question: str, file_to_open: str = None, special: bool = False)
 @log_dev.function
 def dev_checks() -> None:
     """
-        Performs a series of checks to ensure that the developer has followed the required guidelines and best practices.
-        Returns:
-            bool: True if all checks pass, otherwise False.
+    Performs comprehensive developer checks to ensure code quality and project guidelines compliance.
+    
+    This function guides developers through a series of predefined checks, validates file additions, 
+    and updates project configuration. It performs the following key steps:
+    - Verify adherence to contributing guidelines
+    - Check file naming conventions
+    - Validate file placement
+    - Confirm docstring and comment coverage
+    - Assess feature modularity
+    - Categorize and display file changes
+    - Update project configuration file
+    
+    Raises:
+        None: Returns None if any check fails or an error occurs during the process.
+    
+    Side Effects:
+        - Creates necessary directories
+        - Prompts user for multiple confirmations
+        - Prints file change lists with color coding
+        - Updates configuration file with current files and version
+        - Logs warnings or errors during the process
+    
+    Example:
+        Typical usage is during project development to ensure consistent practices:
+        >>> dev_checks()
+        # Interactively guides developer through project checks
     """
     # Create the necessary directories if they do not exist
     FileManagement.mkdir()