pygeai 0.1.6__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/cli/commands/validators.py

@@ -0,0 +1,209 @@
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+import json
+
+from pygeai.core.common.exceptions import WrongArgumentError, ValidationError
+
+
+def validate_dataset_file(dataset_file: str):
+    path = Path(dataset_file)
+    if not path.exists():
+        raise FileNotFoundError(f"Dataset file not found: {dataset_file}")
+    if not path.is_file():
+        raise ValueError(f"Dataset path is not a file: {dataset_file}")
+
+
+def validate_row_structure(row: dict):
+    required_fields = ["dataSetRowExpectedAnswer", "dataSetRowContextDocument", "dataSetRowInput"]
+    for field in required_fields:
+        if not isinstance(row.get(field), str):
+            raise WrongArgumentError(f'Missing or invalid value for required field "{field}". It must be a non-empty string.')
+
+    expected_sources = row.get("expectedSources", [])
+    if not isinstance(expected_sources, list):
+        raise WrongArgumentError('"expectedSources" must be a list of objects, even if empty.')
+    for source in expected_sources:
+        if not isinstance(source, dict) or not all(
+                key in source and isinstance(source[key], str) for key in [
+                    "dataSetExpectedSourceId", "dataSetExpectedSourceName",
+                    "dataSetExpectedSourceValue", "dataSetExpectedSourceExtension"
+                ]
+        ):
+            raise WrongArgumentError(
+                'Each item in "expectedSources" must be a dictionary containing the following string fields: '
+                '"dataSetExpectedSourceId", "dataSetExpectedSourceName", "dataSetExpectedSourceValue", and "dataSetExpectedSourceExtension".'
+            )
+
+    filter_variables = row.get("filterVariables", [])
+    if not isinstance(filter_variables, list):
+        raise WrongArgumentError('"filterVariables" must be a list of objects, even if empty.')
+    for variable in filter_variables:
+        if not isinstance(variable, dict) or not all(
+                key in variable and isinstance(variable[key], str) for key in [
+                    "dataSetMetadataType", "dataSetRowFilterKey",
+                    "dataSetRowFilterOperator", "dataSetRowFilterValue", "dataSetRowFilterVarId"
+                ]
+        ):
+            raise WrongArgumentError(
+                'Each item in "filterVariables" must be a dictionary containing the following string fields: '
+                '"dataSetMetadataType", "dataSetRowFilterKey", "dataSetRowFilterOperator", '
+                '"dataSetRowFilterValue", and "dataSetRowFilterVarId".'
+            )
+
+
+def validate_system_metric(metric: dict):
+    required_fields = ["systemMetricId", "systemMetricWeight"]
+
+    if not isinstance(metric, dict):
+        raise WrongArgumentError("Each system metric must be a dictionary.")
+
+    for field in required_fields:
+        if field not in metric:
+            raise WrongArgumentError(f'Missing required field "{field}" in system metric.')
+
+    if not isinstance(metric["systemMetricId"], str) or not metric["systemMetricId"].strip():
+        raise WrongArgumentError('"systemMetricId" must be a non-empty string.')
+
+    if not isinstance(metric["systemMetricWeight"], (int, float)) or not (0 <= metric["systemMetricWeight"] <= 1):
+        raise WrongArgumentError('"systemMetricWeight" must be a number between 0 and 1 (inclusive).')
+
+
+def validate_json_input(
+    value: str, 
+    expected_type: type,
+    field_name: str,
+    example: Optional[str] = None
+) -> Union[Dict, List]:
+    """
+    Validates and parses JSON input with detailed error messages.
+
+    :param value: str - The JSON string to parse.
+    :param expected_type: type - Expected type (dict or list).
+    :param field_name: str - Name of the field being validated.
+    :param example: Optional[str] - Example of valid input.
+    :return: Union[Dict, List] - Parsed JSON object.
+    :raises ValidationError: If JSON is invalid or doesn't match expected type.
+    """
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError as e:
+        raise ValidationError(
+            f"Invalid JSON for '{field_name}'",
+            field=field_name,
+            expected="Valid JSON string",
+            received=value[:100] + "..." if len(value) > 100 else value,
+            example=example or '{"key": "value"}'
+        ) from e
+    
+    if not isinstance(parsed, expected_type):
+        raise ValidationError(
+            f"Wrong type for '{field_name}'",
+            field=field_name,
+            expected=expected_type.__name__,
+            received=type(parsed).__name__,
+            example=example
+        )
+    
+    return parsed
+
+
+def validate_numeric_range(
+    value: str,
+    field_name: str,
+    min_value: Optional[float] = None,
+    max_value: Optional[float] = None,
+    value_type: type = float
+) -> Union[int, float]:
+    """
+    Validates numeric input within a specified range.
+
+    :param value: str - The numeric string to validate.
+    :param field_name: str - Name of the field being validated.
+    :param min_value: Optional[float] - Minimum allowed value.
+    :param max_value: Optional[float] - Maximum allowed value.
+    :param value_type: type - Expected numeric type (int or float).
+    :return: Union[int, float] - Validated numeric value.
+    :raises ValidationError: If value is not numeric or out of range.
+    """
+    try:
+        numeric_value = value_type(value)
+    except ValueError as e:
+        raise ValidationError(
+            f"Invalid {value_type.__name__} for '{field_name}'",
+            field=field_name,
+            expected=f"{value_type.__name__}",
+            received=value
+        ) from e
+    
+    if min_value is not None and numeric_value < min_value:
+        raise ValidationError(
+            f"Value too low for '{field_name}'",
+            field=field_name,
+            expected=f">= {min_value}",
+            received=str(numeric_value)
+        )
+    
+    if max_value is not None and numeric_value > max_value:
+        raise ValidationError(
+            f"Value too high for '{field_name}'",
+            field=field_name,
+            expected=f"<= {max_value}",
+            received=str(numeric_value)
+        )
+    
+    return numeric_value
+
+
+def validate_choice(
+    value: str,
+    field_name: str,
+    choices: List[str],
+    case_sensitive: bool = True
+) -> str:
+    """
+    Validates that input is one of the allowed choices.
+
+    :param value: str - The value to validate.
+    :param field_name: str - Name of the field being validated.
+    :param choices: List[str] - List of allowed values.
+    :param case_sensitive: bool - Whether comparison is case-sensitive.
+    :return: str - Validated value.
+    :raises ValidationError: If value is not in choices.
+    """
+    compare_value = value if case_sensitive else value.lower()
+    compare_choices = choices if case_sensitive else [c.lower() for c in choices]
+    
+    if compare_value not in compare_choices:
+        raise ValidationError(
+            f"Invalid value for '{field_name}'",
+            field=field_name,
+            expected=f"One of: {', '.join(choices)}",
+            received=value
+        )
+    
+    return value
+
+
+def validate_boolean_value(value: str, field_name: str = "boolean option") -> bool:
+    """
+    Converts a string argument into a boolean value with flexible input formats.
+
+    :param value: str - A string representation of a boolean.
+    :param field_name: str - Name of the field being validated.
+    :return: bool - The boolean value corresponding to the input.
+    :raises ValidationError: If the input is not a valid boolean representation.
+    """
+    normalized = value.lower().strip()
+    
+    if normalized in ("0", "false", "no", "off"):
+        return False
+    elif normalized in ("1", "true", "yes", "on"):
+        return True
+    else:
+        raise ValidationError(
+            f"Invalid boolean value for '{field_name}'",
+            field=field_name,
+            expected="0/1, true/false, yes/no, on/off",
+            received=value,
+            example="1 or true"
+        )

pygeai/cli/commands/version.py

@@ -0,0 +1,44 @@
+import requests
+import json
+from packaging.version import Version as LooseVersion
+
+from pygeai.core.utils.console import Console
+
+
+def get_latest_version(package_name):
+    url = f"https://pypi.org/pypi/{package_name}/json"
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        data = json.loads(response.text)
+        return data['info']['version']
+    except requests.RequestException as e:
+        Console.write_stderr(f"An error occurred while fetching the latest version: {e}")
+
+
+def get_installed_version(package_name):
+    try:
+        import importlib.metadata
+        installed_version = importlib.metadata.version(package_name)
+        return installed_version
+    except importlib.metadata.PackageNotFoundError:
+        return "Not installed"
+    except ModuleNotFoundError:
+        Console.write_stderr("This Python installation does not support importlib.metadata. Use Python 3.8+ or install importlib_metadata manually.")
+        return "Unknown"
+
+
+def check_new_version(package_name):
+    latest_version = get_latest_version(package_name)
+    installed_version = get_installed_version(package_name)
+
+    if latest_version is None or installed_version == "Unknown":
+        return "Could not determine version information."
+
+    if installed_version == "Not installed":
+        return f"{package_name} is not installed, but the latest version available is {latest_version}."
+
+    if LooseVersion(latest_version) > LooseVersion(installed_version):
+        return f"There's a new version available: {latest_version}. You have {installed_version} installed."
+    else:
+        return f"You have the latest version {installed_version} of {package_name}."

pygeai/cli/error_handler.py

@@ -0,0 +1,151 @@
+import traceback
+from difflib import SequenceMatcher
+from typing import List, Optional, Tuple
+
+from pygeai import logger
+from pygeai.cli.commands import Command, Option
+from pygeai.core.utils.console import Console
+
+
+FUZZY_MATCH_THRESHOLD = 0.6
+MAX_FUZZY_SUGGESTIONS = 3
+
+
+class ExitCode:
+    SUCCESS = 0
+    USER_INPUT_ERROR = 1
+    MISSING_REQUIREMENT = 2
+    SERVICE_ERROR = 3
+    KEYBOARD_INTERRUPT = 130
+    UNEXPECTED_ERROR = 255
+
+
+class ErrorHandler:
+
+    @staticmethod
+    def format_error(
+        error_type: str, 
+        message: str, 
+        suggestion: Optional[str] = None, 
+        show_help: bool = True,
+        example: Optional[str] = None
+    ) -> str:
+        """
+        Formats an error message with optional suggestion and example.
+
+        :param error_type: str - Type of error (e.g., "Unknown Command").
+        :param message: str - The error message.
+        :param suggestion: Optional[str] - Suggested fix or next steps.
+        :param show_help: bool - Whether to show help command hint.
+        :param example: Optional[str] - Example of correct usage.
+        :return: str - Formatted error message.
+        """
+        output = f"ERROR [{error_type}]: {message}"
+        
+        if suggestion:
+            output += f"\n  → {suggestion}"
+        
+        if example:
+            output += f"\n\n  Example:\n    {example}"
+        
+        if show_help:
+            output += "\n\nRun 'geai help' for usage information."
+        
+        return output
+
+    @staticmethod
+    def find_similar_items(
+        item: str, 
+        available_items: List[str], 
+        threshold: float = FUZZY_MATCH_THRESHOLD
+    ) -> List[str]:
+        """
+        Finds similar items using fuzzy string matching.
+
+        :param item: str - The item to match against.
+        :param available_items: List[str] - List of available items.
+        :param threshold: float - Minimum similarity ratio (0.0 to 1.0).
+        :return: List[str] - List of similar items, up to MAX_FUZZY_SUGGESTIONS.
+        """
+        similarities: List[Tuple[str, float]] = []
+        for available in available_items:
+            ratio = SequenceMatcher(None, item.lower(), available.lower()).ratio()
+            if ratio >= threshold:
+                similarities.append((available, ratio))
+        
+        similarities.sort(key=lambda x: x[1], reverse=True)
+        return [item[0] for item in similarities[:MAX_FUZZY_SUGGESTIONS]]
+
+    @staticmethod
+    def get_available_commands(commands: List[Command]) -> List[str]:
+        all_identifiers = []
+        for cmd in commands:
+            all_identifiers.extend(cmd.identifiers)
+        return all_identifiers
+
+    @staticmethod
+    def get_available_options(options: List[Option]) -> List[str]:
+        all_identifiers = []
+        for opt in options:
+            all_identifiers.extend(opt.identifiers)
+        return all_identifiers
+
+    @staticmethod
+    def handle_unknown_command(command: str, available_commands: List[Command]) -> str:
+        cmd_identifiers = ErrorHandler.get_available_commands(available_commands)
+        similar = ErrorHandler.find_similar_items(command, cmd_identifiers)
+        
+        message = f"'{command}' is not a valid command."
+        
+        if similar:
+            suggestion = f"Did you mean: {', '.join(similar)}?"
+        else:
+            suggestion = f"Available commands: {', '.join(sorted(set([cmd.identifiers[0] for cmd in available_commands])))}"
+        
+        return ErrorHandler.format_error("Unknown Command", message, suggestion)
+
+    @staticmethod
+    def handle_unknown_option(option: str, available_options: List[Option]) -> str:
+        opt_identifiers = ErrorHandler.get_available_options(available_options)
+        similar = ErrorHandler.find_similar_items(option, opt_identifiers)
+        
+        message = f"'{option}' is not a valid option."
+        
+        if similar:
+            suggestion = f"Did you mean: {', '.join(similar)}?"
+        else:
+            suggestion = f"Available options: {', '.join(sorted(set([opt.identifiers[0] for opt in available_options])))}"
+        
+        return ErrorHandler.format_error("Unknown Option", message, suggestion)
+
+    @staticmethod
+    def handle_missing_requirement(requirement_message: str) -> str:
+        message = requirement_message
+        suggestion = "Please provide all required parameters."
+        return ErrorHandler.format_error("Missing Requirement", message, suggestion)
+
+    @staticmethod
+    def handle_invalid_agent(error_message: str) -> str:
+        message = f"Failed to retrieve or validate the agent.\n  Details: {error_message}"
+        suggestion = "Check your agent configuration and ensure the agent exists."
+        return ErrorHandler.format_error("Invalid Agent", message, suggestion)
+
+    @staticmethod
+    def handle_wrong_argument(error_message: str, usage: str) -> str:
+        Console.write_stderr(f"usage: {usage}")
+        message = error_message
+        suggestion = "Check the command syntax and try again."
+        return ErrorHandler.format_error("Invalid Argument", message, suggestion)
+
+    @staticmethod
+    def handle_keyboard_interrupt() -> str:
+        return "\n\nOperation cancelled by user."
+
+    @staticmethod
+    def handle_unexpected_error(exception: Exception) -> str:
+        logger.error(f"Unexpected error occurred: {exception}")
+        logger.error(traceback.format_exc())
+        
+        message = "An unexpected error occurred. This may be a bug."
+        suggestion = f"Please report this issue to geai-sdk@globant.com with the following details:\n  Error: {str(exception)}\n  Run with geai-dbg for more details."
+        return ErrorHandler.format_error("Critical Error", message, suggestion, show_help=False)

pygeai/cli/geai.py

@@ -1,36 +1,104 @@
 import sys
+import logging
+from typing import List, Optional
 
+from pygeai import logger
 from pygeai.cli.commands.base import base_commands, base_options
 from pygeai.cli.commands import ArgumentsEnum, Command
 from pygeai.cli.parsers import CommandParser
 from pygeai.cli.texts.help import CLI_USAGE
+from pygeai.cli.error_handler import ErrorHandler, ExitCode
 from pygeai.core.base.session import get_session
-from pygeai.core.common.exceptions import UnknownArgumentError, MissingRequirementException, WrongArgumentError
-
-
-def main():
-    driver = CLIDriver()
-    return driver.main()
+from pygeai.core.common.exceptions import UnknownArgumentError, MissingRequirementException, WrongArgumentError, \
+    InvalidAgentException
+from pygeai.core.utils.console import Console
+
+
+def setup_verbose_logging() -> None:
+    """
+    Configure verbose logging for the CLI.
+    
+    Sets up a console handler with DEBUG level logging and a formatted output
+    that includes timestamp, logger name, level, and message.
+    """
+    if logger.handlers:
+        for handler in logger.handlers:
+            if not isinstance(handler, logging.NullHandler):
+                return
+    
+    logger.setLevel(logging.DEBUG)
+    console_handler = logging.StreamHandler(sys.stderr)
+    console_handler.setLevel(logging.DEBUG)
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    logger.propagate = False
+    logger.debug("Verbose mode enabled")
+
+
+def main() -> int:
+    """
+    Main entry point for the GEAI CLI application.
+
+    :return: int - Exit code indicating success or error.
+    """
+    try:
+        driver = CLIDriver()
+        return driver.main()
+    except MissingRequirementException as e:
+        error_msg = ErrorHandler.handle_missing_requirement(str(e))
+        Console.write_stderr(error_msg)
+        return ExitCode.MISSING_REQUIREMENT
 
 
 class CLIDriver:
-
-    def __init__(self, session=None):
+    """
+    Main CLI driver for the GEAI command-line interface.
+    
+    The CLIDriver orchestrates command parsing, execution, and error handling
+    for all GEAI CLI operations. It supports multi-profile session management
+    via the --alias flag and provides comprehensive error handling with
+    user-friendly messages.
+    """
+
+    def __init__(self, session=None, credentials_file=None) -> None:
         """
-        Sets session to be used while running the command, either with a specified alias,
-        environment variables or function parameters.
-        Once the session is defined, it won't change during the curse of the execution.
+        Initialize the CLI driver with optional session and credentials file.
+        
+        Sets up the session to be used while running commands, either with a 
+        specified alias, environment variables, or function parameters.
+        Once the session is defined, it won't change during the execution.
+        
+        :param session: Optional session object. If None, uses 'default' or
+                       alias-specified session from command-line arguments.
+        :param credentials_file: Optional path to custom credentials file.
         """
+        from pygeai.core.common.config import get_settings
+        
         arguments = sys.argv
+        
+        if credentials_file or "--credentials" in arguments or "--creds" in arguments:
+            if not credentials_file:
+                credentials_file = self._get_credentials_file(arguments)
+            get_settings(credentials_file=credentials_file)
+            logger.debug(f"Using custom credentials file: {credentials_file}")
+        
         if "-a" in arguments or "--alias" in arguments:
             alias = self._get_alias(arguments)
             session = get_session(alias)
 
-        self.session = get_session() if session is None else session
+        self.session = get_session("default") if session is None else session
 
-    def _get_alias(self, arguments: list):
+    def _get_alias(self, arguments: List[str]) -> str:
         """
-        Retrieves and removes alias and alias flag from argument list
+        Retrieves and removes alias and alias flag from argument list.
+
+        :param arguments: List[str] - Command line arguments.
+        :return: str - The alias value.
+        :raises ValueError: If alias flag is present but no value provided.
         """
         alias_index = None
 
@@ -42,63 +110,136 @@ class CLIDriver:
         _ = arguments.pop(alias_index)
         alias = arguments.pop(alias_index)
         return alias
+    
+    def _get_credentials_file(self, arguments: List[str]) -> str:
+        """
+        Retrieves and removes credentials file path and flag from argument list.
+
+        :param arguments: List[str] - Command line arguments.
+        :return: str - The credentials file path.
+        :raises ValueError: If credentials flag is present but no value provided.
+        """
+        creds_index = None
 
-    def main(self, args=None):
+        if "--credentials" in arguments:
+            creds_index = arguments.index("--credentials")
+        elif "--creds" in arguments:
+            creds_index = arguments.index("--creds")
+
+        _ = arguments.pop(creds_index)
+        credentials_file = arguments.pop(creds_index)
+        return credentials_file
+
+    def main(self, args: Optional[List[str]] = None) -> int:
         """
-        If not argument is received, it defaults to help (first command in base_command list).
+        Execute the CLI command based on provided arguments.
+        
+        If no argument is received, it defaults to help (first command in base_command list).
         Otherwise, it parses the arguments received to identify the appropriate command and either
         execute it or parse it again to detect subcommands.
+
+        :param args: Optional[List[str]] - Command line arguments. If None, uses sys.argv.
+        :return: int - Exit code (0 for success, non-zero for errors).
         """
         try:
-            if len(sys.argv) > 1:
-                arg = sys.argv[1] if args is None else args[1]
-                arguments = sys.argv[2:] if args is None else args[2:]
-
+            argv = sys.argv if args is None else args
+            
+            if "--verbose" in argv or "-v" in argv:
+                setup_verbose_logging()
+                argv_copy = [a for a in argv if a not in ("--verbose", "-v")]
+                if args is None:
+                    sys.argv = argv_copy
+                else:
+                    args = argv_copy
+                argv = argv_copy
+            
+            logger.debug(f"Running geai with: {' '.join(a for a in argv)}")
+            logger.debug(f"Session: {self.session.alias if hasattr(self.session, 'alias') else 'default'}")
+            
+            if len(argv) > 1:
+                arg = argv[1] if args is None else args[1]
+                arguments = argv[2:] if args is None else args[2:]
+                
+                logger.debug(f"Identifying command for argument: {arg}")
                 command = CommandParser(base_commands, base_options).identify_command(arg)
+                logger.debug(f"Command identified: {command.name}")
             else:
+                logger.debug("No arguments provided, defaulting to help command")
                 command = base_commands[0]
                 arguments = []
 
             self.process_command(command, arguments)
-        except (UnknownArgumentError, WrongArgumentError) as e:
-            sys.stderr.write(f"usage: {CLI_USAGE}")
-            sys.stderr.write(str(e))
-            sys.stderr.write("\n")
+            logger.debug(f"Command completed successfully")
+            return ExitCode.SUCCESS
+        except UnknownArgumentError as e:
+            if hasattr(e, 'available_commands') and e.available_commands:
+                error_msg = ErrorHandler.handle_unknown_command(e.arg, e.available_commands)
+            elif hasattr(e, 'available_options') and e.available_options:
+                error_msg = ErrorHandler.handle_unknown_option(e.arg, e.available_options)
+            else:
+                error_msg = ErrorHandler.format_error("Unknown Argument", str(e))
+            
+            Console.write_stderr(error_msg)
+            return ExitCode.USER_INPUT_ERROR
+        except WrongArgumentError as e:
+            error_msg = ErrorHandler.handle_wrong_argument(str(e), CLI_USAGE)
+            Console.write_stderr(error_msg)
+            return ExitCode.USER_INPUT_ERROR
         except MissingRequirementException as e:
-            sys.stderr.write(f"ERROR: Something is missing! {e}")
+            error_msg = ErrorHandler.handle_missing_requirement(str(e))
+            Console.write_stderr(error_msg)
+            return ExitCode.MISSING_REQUIREMENT
+        except InvalidAgentException as e:
+            error_msg = ErrorHandler.handle_invalid_agent(str(e))
+            Console.write_stderr(error_msg)
+            return ExitCode.SERVICE_ERROR
         except KeyboardInterrupt:
-            sys.stdout.write("\n")
+            message = ErrorHandler.handle_keyboard_interrupt()
+            Console.write_stdout(message)
+            return ExitCode.KEYBOARD_INTERRUPT
         except Exception as e:
-            sys.stderr.write(f"Unexpected error. Please report this bug to the developers. Error: {e}")
-            return 255
+            error_msg = ErrorHandler.handle_unexpected_error(e)
+            Console.write_stderr(error_msg)
+            return ExitCode.UNEXPECTED_ERROR
 
     def process_command(self, command: Command, arguments: list[str]):
         """
         If the command has no action associated with it, it means it has subcommands, so it must be parsed again
         to identify it.
         """
+        logger.debug(f"Processing command: {command.name}, arguments: {arguments}")
+        
         if command.action:
             if command.additional_args == ArgumentsEnum.NOT_AVAILABLE:
+                logger.debug(f"Executing command {command.name} without arguments")
                 command.action()
             else:
+                logger.debug(f"Extracting options for command {command.name}")
                 option_list = CommandParser(base_commands, command.options).extract_option_list(arguments)
+                logger.debug(f"Options extracted: {len(option_list)} items")
                 command.action(option_list)
         elif command.subcommands:
             subcommand_arg = arguments[0] if len(arguments) > 0 else None
             subcommand_arguments = arguments[1:] if len(arguments) > 1 else []
-
+            
+            logger.debug(f"Command has subcommands, identifying: {subcommand_arg}")
+            
             available_commands = command.subcommands
             available_options = command.options
             parser = CommandParser(available_commands, available_options)
 
             if not subcommand_arg:
+                logger.debug(f"No subcommand specified, using default: {command.subcommands[0].name}")
                 subcommand = command.subcommands[0]
             else:
                 subcommand = parser.identify_command(subcommand_arg)
+                logger.debug(f"Subcommand identified: {subcommand.name}")
 
             if subcommand.additional_args == ArgumentsEnum.NOT_AVAILABLE:
+                logger.debug(f"Executing subcommand {subcommand.name} without arguments")
                 subcommand.action()
             else:
+                logger.debug(f"Extracting options for subcommand {subcommand.name}")
                 option_list = CommandParser(None, subcommand.options).extract_option_list(subcommand_arguments)
+                logger.debug(f"Options extracted: {len(option_list)} items")
                 subcommand.action(option_list)
-