ara-cli 0.1.9.95__py3-none-any.whl → 0.1.9.96__py3-none-any.whl

ara_cli/__init__.py

@@ -1,10 +1,13 @@
 import warnings
-from .version import __version__
+from .error_handler import ErrorHandler
 
 
 whitelisted_commands = ["RERUN", "SEND", "EXTRACT", "LOAD_IMAGE", "CHOOSE_MODEL", "CHOOSE_EXTRACTION_MODEL", "CURRENT_MODEL", "CURRENT_EXTRACTION_MODEL", "LIST_MODELS"]
 
 
+error_handler = ErrorHandler()
+
+
 # ANSI escape codes for coloring
 YELLOW = '\033[93m'
 RESET = '\033[0m'

ara_cli/__main__.py

@@ -1,5 +1,6 @@
 # PYTHON_ARGCOMPLETE_OK
 from ara_cli.ara_command_parser import action_parser
+from ara_cli.error_handler import AraError
 from ara_cli.version import __version__
 from ara_cli.ara_command_action import (
     create_action,
@@ -22,8 +23,10 @@ from ara_cli.ara_command_action import (
     autofix_action,
     extract_action
 )
+from . import error_handler
 import argcomplete
 import sys
+from os import getenv
 
 
 def define_action_mapping():
@@ -51,31 +54,74 @@ def define_action_mapping():
 
 
 def handle_invalid_action(args):
-    sys.exit("Invalid action provided. Type ara -h for help")
+    raise AraError("Invalid action provided. Type ara -h for help", error_code=1)
 
 
-def cli():
-    parser = action_parser()
+def is_debug_mode_enabled():
+    """Check if debug mode is enabled via environment variable."""
+    return getenv('ARA_DEBUG', '').lower() in ('1', 'true', 'yes')
 
+
+def setup_parser():
+    """Create and configure the argument parser."""
+    parser = action_parser()
+    
     # Show examples when help is called
     if any(arg in sys.argv for arg in ["-h", "--help"]):
         parser.add_examples = True
-
+    
     parser.add_argument(
         "-v", "--version", action="version", version=f"%(prog)s {__version__}"
     )
+    
+    parser.add_argument(
+        "--debug", action="store_true", help="Enable debug mode for detailed error output"
+    )
+    
+    return parser
 
-    action_mapping = define_action_mapping()
 
-    argcomplete.autocomplete(parser)
+def configure_debug_mode(args, env_debug_mode):
+    """Configure debug mode based on arguments and environment."""
+    if (hasattr(args, 'debug') and args.debug) or env_debug_mode:
+        error_handler.debug_mode = True
 
-    args = parser.parse_args()
-    if not hasattr(args, "action") or not args.action:
-        parser.print_help()
-        return
+
+def should_show_help(args):
+    """Check if help should be displayed."""
+    return not hasattr(args, "action") or not args.action
+
+
+def execute_action(args, action_mapping):
+    """Execute the specified action."""
     action = action_mapping.get(args.action, handle_invalid_action)
     action(args)
 
 
+def cli():
+    debug_mode = is_debug_mode_enabled()
+    
+    try:
+        parser = setup_parser()
+        action_mapping = define_action_mapping()
+        
+        argcomplete.autocomplete(parser)
+        args = parser.parse_args()
+        
+        configure_debug_mode(args, debug_mode)
+        
+        if should_show_help(args):
+            parser.print_help()
+            return
+            
+        execute_action(args, action_mapping)
+        
+    except KeyboardInterrupt:
+        print("\n[INFO] Operation cancelled by user", file=sys.stderr)
+        sys.exit(130)  # Standard exit code for Ctrl+C
+    except Exception as e:
+        error_handler.handle_error(e, context="cli")
+
+
 if __name__ == "__main__":
-    cli()
+    cli()

ara_cli/ara_command_action.py

@@ -2,17 +2,19 @@ from os.path import join
 import os
 import sys
 import json
+from ara_cli.error_handler import AraError
+from ara_cli.error_handler import handle_errors, AraValidationError
 from ara_cli.output_suppressor import suppress_stdout
 from ara_cli.artefact_fuzzy_search import suggest_close_name_matches
-from . import whitelisted_commands
+from . import whitelisted_commands, error_handler
 
 
 def check_validity(condition, error_message):
     if not condition:
-        print(error_message)
-        sys.exit(1)
+        raise AraValidationError(error_message)
 
 
+@handle_errors(context="create action", error_handler=error_handler)
 def create_action(args):
     from ara_cli.artefact_creator import ArtefactCreator
     from ara_cli.classifier import Classifier
@@ -62,6 +64,7 @@ def create_action(args):
     artefact_creator.run(args.parameter, args.classifier, parent_classifier, parent_name, rule)
 
 
+@handle_errors(context="delete action", error_handler=error_handler)
 def delete_action(args):
     from ara_cli.artefact_deleter import ArtefactDeleter
 
@@ -69,6 +72,7 @@ def delete_action(args):
     artefact_deleter.delete(args.parameter, args.classifier, args.force)
 
 
+@handle_errors(context="rename action", error_handler=error_handler)
 def rename_action(args):
     from ara_cli.artefact_renamer import ArtefactRenamer
     from ara_cli.classifier import Classifier
@@ -82,6 +86,7 @@ def rename_action(args):
     artefact_renamer.rename(args.parameter, args.aspect, args.classifier)
 
 
+@handle_errors(context="rename action", error_handler=error_handler)
 def list_action(args):
     from ara_cli.artefact_lister import ArtefactLister
     from ara_cli.list_filter import ListFilter
@@ -131,6 +136,7 @@ def list_action(args):
     artefact_lister.list_files(list_filter=list_filter)
 
 
+@handle_errors(context="list-tags action", error_handler=error_handler)
 def list_tags_action(args):
     from ara_cli.tag_extractor import TagExtractor
     from ara_cli.list_filter import ListFilter
@@ -155,6 +161,7 @@ def list_tags_action(args):
     print(output)
 
 
+@handle_errors(context="prompt action", error_handler=error_handler)
 def prompt_action(args):
     from ara_cli.classifier import Classifier
     from ara_cli.filename_validator import is_valid_filename
@@ -227,6 +234,7 @@ def prompt_action(args):
         raise ValueError(f"Unknown command '{init}' provided.")
 
 
+@handle_errors(context="chat action", error_handler=error_handler)
 def chat_action(args):
     from ara_cli.chat import Chat
 
@@ -253,6 +261,7 @@ def chat_action(args):
     chat.start()
 
 
+@handle_errors(context="template action", error_handler=error_handler)
 def template_action(args):
     from ara_cli.classifier import Classifier
     from ara_cli.template_manager import TemplatePathManager
@@ -265,6 +274,7 @@ def template_action(args):
     print(content)
 
 
+@handle_errors(context="fetch-templates action", error_handler=error_handler)
 def fetch_templates_action(args):
     import shutil
     from ara_cli.ara_config import ConfigManager
@@ -294,6 +304,7 @@ def fetch_templates_action(args):
         os.makedirs(join(local_prompt_modules_dir, subdir), exist_ok=True)
 
 
+@handle_errors(context="read action", error_handler=error_handler)
 def read_action(args):
     from ara_cli.commands.read_command import ReadCommand
     from ara_cli.list_filter import ListFilter
@@ -321,6 +332,7 @@ def read_action(args):
     command.execute()
 
 
+@handle_errors(context="reconnect action", error_handler=error_handler)
 def reconnect_action(args):
     from ara_cli.artefact_models.artefact_load import artefact_from_content
     from ara_cli.artefact_models.artefact_model import Contribution
@@ -348,8 +360,7 @@ def reconnect_action(args):
     )
 
     if not artefact:
-        print(read_error_message)
-        return
+        raise AraError(read_error_message)
 
     parent = ArtefactReader.read_artefact(
         artefact_name=parent_name,
@@ -358,8 +369,7 @@ def reconnect_action(args):
     )
 
     if not parent:
-        print(read_error_message)
-        return
+        raise AraError(read_error_message)
 
     contribution = Contribution(
         artefact_name=parent.title,
@@ -367,13 +377,9 @@ def reconnect_action(args):
     )
 
     if rule:
-        try:
-            closest_rule = find_closest_rule(parent, rule)
-            contribution.rule = closest_rule
-            feedback_message += f" using rule '{closest_rule}'"
-        except TypeError as e:
-            print(f"{type(e).__name__}:", e)
-            exit(1)
+        closest_rule = find_closest_rule(parent, rule)
+        contribution.rule = closest_rule
+        feedback_message += f" using rule '{closest_rule}'"
 
     artefact.contribution = contribution
     with open(artefact.file_path, 'w', encoding='utf-8') as file:
@@ -383,6 +389,7 @@ def reconnect_action(args):
     print(feedback_message + ".")
 
 
+@handle_errors(context="read-status action", error_handler=error_handler)
 def read_status_action(args):
     from ara_cli.file_classifier import FileClassifier
     from ara_cli.artefact_models.artefact_load import artefact_from_content
@@ -396,7 +403,7 @@ def read_status_action(args):
 
     all_artefact_names = [artefact_info["title"] for artefact_info in artefact_info_dicts]
     if artefact_name not in all_artefact_names:
-        suggest_close_name_matches(artefact_name, all_artefact_names)
+        suggest_close_name_matches(artefact_name, all_artefact_names, report_as_error=True)
         return
 
     artefact_info = next(filter(
@@ -415,6 +422,7 @@ def read_status_action(args):
     print(status)
 
 
+@handle_errors(context="read-user action", error_handler=error_handler)
 def read_user_action(args):
     from ara_cli.artefact_models.artefact_load import artefact_from_content
     from ara_cli.file_classifier import FileClassifier
@@ -428,7 +436,7 @@ def read_user_action(args):
 
     all_artefact_names = [artefact_info["title"] for artefact_info in artefact_info_dicts]
     if artefact_name not in all_artefact_names:
-        suggest_close_name_matches(artefact_name, all_artefact_names)
+        suggest_close_name_matches(artefact_name, all_artefact_names, report_as_error=True)
         return
 
     artefact_info = next(filter(
@@ -448,6 +456,7 @@ def read_user_action(args):
         print(f" - {tag}")
 
 
+@handle_errors(context="set-status action", error_handler=error_handler)
 def set_status_action(args):
     from ara_cli.artefact_models.artefact_model import ALLOWED_STATUS_VALUES
     from ara_cli.artefact_models.artefact_load import artefact_from_content
@@ -490,6 +499,7 @@ def set_status_action(args):
     print(f"Status of task '{artefact_name}' has been updated to '{new_status}'.")
 
 
+@handle_errors(context="set-user action", error_handler=error_handler)
 def set_user_action(args):
     from ara_cli.file_classifier import FileClassifier
     from ara_cli.artefact_models.artefact_load import artefact_from_content
@@ -528,6 +538,7 @@ def set_user_action(args):
     print(f"User of task '{artefact_name}' has been updated to '{new_user}'.")
 
 
+@handle_errors(context="classifier-directory action", error_handler=error_handler)
 def classifier_directory_action(args):
     from ara_cli.classifier import Classifier
 
@@ -536,6 +547,7 @@ def classifier_directory_action(args):
     print(subdirectory)
 
 
+@handle_errors(context="scan action", error_handler=error_handler)
 def scan_action(args):
     from ara_cli.file_classifier import FileClassifier
     from ara_cli.artefact_scan import find_invalid_files, show_results
@@ -550,6 +562,7 @@ def scan_action(args):
     show_results(invalid_artefacts)
 
 
+@handle_errors(context="autofix_action", error_handler=error_handler)
 def autofix_action(args):
     from ara_cli.artefact_autofix import parse_report, apply_autofix, read_report_file
     from ara_cli.file_classifier import FileClassifier
@@ -589,18 +602,17 @@ def autofix_action(args):
     print("\nAutofix process completed. Please review the changes.")
 
 
+@handle_errors(context="extract action", error_handler=error_handler)
 def extract_action(args):
     from ara_cli.commands.extract_command import ExtractCommand
 
     filename = args.filename
     force = args.force
     write = getattr(args, 'write', False)
-    print(filename)
     command = ExtractCommand(
         file_name=filename,
         force=force,
         write=write,
-        output=lambda msg: print(msg, file=sys.stdout),
-        error_output=lambda msg: print(msg, file=sys.stderr)
+        output=lambda msg: print(msg, file=sys.stdout)
     )
     command.execute()

ara_cli/artefact_autofix.py

@@ -1,3 +1,4 @@
+from ara_cli.error_handler import AraError
 from ara_cli.artefact_scan import check_file
 from ara_cli.artefact_fuzzy_search import (
     find_closest_name_matches,
@@ -10,6 +11,7 @@ from ara_cli.artefact_models.artefact_model import Artefact
 from typing import Optional, Dict, List, Tuple
 import difflib
 import os
+import re
 
 
 def populate_classified_artefact_info(
@@ -104,8 +106,9 @@ def determine_artefact_type_and_class(classifier):
 
     artefact_class = artefact_type_mapping.get(artefact_type)
     if not artefact_class:
-        print(f"No artefact class found for {artefact_type}")
-        return None, None
+        raise AraError(f"No artefact class found for {artefact_type}")
+        # print(f"No artefact class found for {artefact_type}")
+        # return None, None
 
     return artefact_type, artefact_class
 
@@ -372,6 +375,131 @@ def set_closest_contribution(
     return artefact, True
 
 
+def fix_scenario_placeholder_mismatch(
+    file_path: str, artefact_text: str, artefact_class, **kwargs
+) -> str:
+    """
+    Converts a regular Scenario with placeholders to a Scenario Outline.
+    This is a deterministic fix that detects placeholders and converts the format.
+    """
+    lines = artefact_text.splitlines()
+    new_lines = []
+    i = 0
+    
+    while i < len(lines):
+        line = lines[i]
+        stripped_line = line.strip()
+        
+        if stripped_line.startswith('Scenario:'):
+            scenario_lines, next_index = _extract_scenario_block(lines, i)
+            processed_lines = _process_scenario_block(scenario_lines)
+            new_lines.extend(processed_lines)
+            i = next_index
+        else:
+            new_lines.append(line)
+            i += 1
+    
+    return "\n".join(new_lines)
+
+
+def _extract_scenario_block(lines: list, start_index: int) -> tuple[list, int]:
+    """Extract all lines belonging to a scenario block."""
+    scenario_lines = [lines[start_index]]
+    j = start_index + 1
+    
+    while j < len(lines):
+        next_line = lines[j].strip()
+        if _is_scenario_boundary(next_line):
+            break
+        scenario_lines.append(lines[j])
+        j += 1
+    
+    return scenario_lines, j
+
+
+def _is_scenario_boundary(line: str) -> bool:
+    """Check if a line marks the boundary of a scenario block."""
+    boundaries = ['Scenario:', 'Scenario Outline:', 'Background:', 'Feature:']
+    return any(line.startswith(boundary) for boundary in boundaries)
+
+
+def _process_scenario_block(scenario_lines: list) -> list:
+    """Process a scenario block and convert to outline if placeholders are found."""
+    if not scenario_lines:
+        return scenario_lines
+    
+    first_line = scenario_lines[0]
+    indentation = _get_line_indentation(first_line)
+    placeholders = _extract_placeholders_from_scenario(scenario_lines[1:])
+    
+    if not placeholders:
+        return scenario_lines
+    
+    return _convert_to_scenario_outline(scenario_lines, placeholders, indentation)
+
+
+def _get_line_indentation(line: str) -> str:
+    """Get the indentation of a line."""
+    return line[:len(line) - len(line.lstrip())]
+
+
+def _extract_placeholders_from_scenario(step_lines: list) -> set:
+    """Extract placeholders from scenario step lines, ignoring docstrings."""
+    placeholders = set()
+    in_docstring = False
+    
+    for line in step_lines:
+        step_line = line.strip()
+        if not step_line:
+            continue
+            
+        in_docstring = _update_docstring_state(step_line, in_docstring)
+        
+        if not in_docstring and '"""' not in step_line:
+            found = re.findall(r'<([^>]+)>', step_line)
+            placeholders.update(found)
+    
+    return placeholders
+
+
+def _update_docstring_state(line: str, current_state: bool) -> bool:
+    """Update the docstring state based on the current line."""
+    if '"""' in line:
+        return not current_state
+    return current_state
+
+
+def _convert_to_scenario_outline(scenario_lines: list, placeholders: set, indentation: str) -> list:
+    """Convert scenario lines to scenario outline format with examples table."""
+    first_line = scenario_lines[0]
+    title = first_line.strip()[len('Scenario:'):].strip()
+    
+    new_lines = [f"{indentation}Scenario Outline: {title}"]
+    new_lines.extend(scenario_lines[1:])
+    new_lines.append("")
+    
+    examples_lines = _create_examples_table(placeholders, indentation)
+    new_lines.extend(examples_lines)
+    
+    return new_lines
+
+
+def _create_examples_table(placeholders: set, base_indentation: str) -> list:
+    """Create the Examples table for the scenario outline."""
+    examples_indentation = base_indentation + "    "
+    table_indentation = examples_indentation + "  "
+    
+    sorted_placeholders = sorted(placeholders)
+    header = "| " + " | ".join(sorted_placeholders) + " |"
+    sample_row = "| " + " | ".join(f"<{p}_value>" for p in sorted_placeholders) + " |"
+    
+    return [
+        f"{examples_indentation}Examples:",
+        f"{table_indentation}{header}",
+        f"{table_indentation}{sample_row}"
+    ]
+
+
 def fix_title_mismatch(
     file_path: str, artefact_text: str, artefact_class, **kwargs
 ) -> str:
@@ -584,6 +712,7 @@ def apply_autofix(
         "Filename-Title Mismatch": fix_title_mismatch,
         "Invalid Contribution Reference": fix_contribution,
         "Rule Mismatch": fix_rule,
+        "Scenario Contains Placeholders": fix_scenario_placeholder_mismatch,
     }
 
     artefact_type, artefact_class = determine_artefact_type_and_class(classifier)

ara_cli/artefact_creator.py

@@ -38,11 +38,9 @@ class ArtefactCreator:
         destination = Path(dir_path) / dest_name
 
         if not source.exists():
-            print("[ERROR] Source file does not exist!")
             raise FileNotFoundError(f"Source file {source} not found!")
 
         if not destination.parent.exists():
-            print("[ERROR] Destination directory does not exist!")
             raise NotADirectoryError(f"Destination directory {destination.parent} does not exist!")
 
         copyfile(source, destination)
@@ -70,9 +68,7 @@ class ArtefactCreator:
     def validate_template(self, template_path, classifier):
         template_name = f"template.{classifier}"
         if not self.template_exists(template_path, template_name):
-            print(f"Template file '{template_name}' not found in the specified template path.")
-            return False
-        return True
+            raise FileNotFoundError(f"Template file '{template_name}' not found in the specified template path.")
 
     def set_artefact_parent(self, artefact, parent_classifier, parent_file_name) -> Artefact:
         classified_artefacts = ArtefactReader.read_artefacts()
@@ -94,8 +90,7 @@ class ArtefactCreator:
         navigator.navigate_to_target()
 
         if not Classifier.is_valid_classifier(classifier):
-            print("Invalid classifier provided. Please provide a valid classifier.")
-            return
+            raise ValueError("Invalid classifier provided. Please provide a valid classifier.")
 
         sub_directory = Classifier.get_sub_directory(classifier)
         file_path = self.file_system.path.join(sub_directory, f"{filename}.{classifier}")

ara_cli/artefact_deleter.py

@@ -20,16 +20,14 @@ class ArtefactDeleter:
         self.navigate_to_target()
 
         if not Classifier.is_valid_classifier(classifier):
-            print("Invalid classifier provided. Please provide a valid classifier.")
-            return
+            raise ValueError("Invalid classifier provided. Please provide a valid classifier.")
 
         sub_directory = Classifier.get_sub_directory(classifier)
         file_path = self.file_system.path.join(sub_directory, f"{filename}.{classifier}")
         dir_path = self.file_system.path.join(sub_directory, f"{filename}.data")
 
         if not self.file_system.path.exists(file_path):
-            print(f"Artefact {file_path} not found.")
-            return
+            raise FileNotFoundError(f"Artefact {file_path} not found.")
         if not force:
             user_choice = input(f"Are you sure you want to delete the file {filename} and data directory if existing? (y/N): ")
 

ara_cli/artefact_fuzzy_search.py

@@ -1,11 +1,16 @@
 import difflib
 from textwrap import indent
 from typing import Optional
+from . import error_handler
+from ara_cli.error_handler import AraError
 
 
-def suggest_close_names(artefact_name: str, all_artefact_names: list[str], message: str, cutoff=0.5):
+def suggest_close_names(artefact_name: str, all_artefact_names: list[str], message: str, cutoff=0.5, report_as_error: bool = False):
     closest_matches = difflib.get_close_matches(artefact_name, all_artefact_names, cutoff=cutoff)
-    print(message)
+    if report_as_error:
+        error_handler.report_error(AraError(message))
+    else:
+        print(message)
     if not closest_matches:
         return
     print("Closest matches:")
@@ -13,23 +18,25 @@ def suggest_close_names(artefact_name: str, all_artefact_names: list[str], messa
         print(f"  - {match}")
 
 
-def suggest_close_name_matches(artefact_name: str, all_artefact_names: list[str]):
+def suggest_close_name_matches(artefact_name: str, all_artefact_names: list[str], report_as_error: bool = False):
     message = f"No match found for artefact with name '{artefact_name}'"
 
     suggest_close_names(
         artefact_name=artefact_name,
         all_artefact_names=all_artefact_names,
-        message=message
+        message=message,
+        report_as_error=report_as_error
     )
 
 
-def suggest_close_name_matches_for_parent(artefact_name: str, all_artefact_names: list[str], parent_name: str):
+def suggest_close_name_matches_for_parent(artefact_name: str, all_artefact_names: list[str], parent_name: str, report_as_error: bool = False):
     message = f"No match found for parent of '{artefact_name}' with name '{parent_name}'"
 
     suggest_close_names(
         artefact_name=parent_name,
         all_artefact_names=all_artefact_names,
-        message=message
+        message=message,
+        report_as_error=report_as_error
     )
 
 

ara_cli/artefact_models/artefact_templates.py

@@ -148,9 +148,9 @@ def _default_feature(title: str, use_default_contribution: bool) -> FeatureArtef
         Scenario(
             title="<descriptive_scenario_title>",
             steps=[
-                "Given <precondition>",
-                "When <action>",
-                "Then <expected result>"
+                "Given [precondition]",
+                "When [action]",
+                "Then [expected result]"
             ],
         ),
         ScenarioOutline(

ara_cli/artefact_models/feature_artefact_model.py

@@ -148,6 +148,30 @@ class Scenario(BaseModel):
             raise ValueError("steps list must not be empty")
         return steps
 
+    @model_validator(mode='after')
+    def check_no_placeholders(cls, values: 'Scenario') -> 'Scenario':
+        """Ensure regular scenarios don't contain placeholders that should be in scenario outlines."""
+        placeholders = set()
+        for step in values.steps:
+            # Skip validation if step contains docstring placeholders (during parsing)
+            if '__DOCSTRING_PLACEHOLDER_' in step:
+                continue
+            
+            # Skip validation if step contains docstring markers (after reinjection)
+            if '"""' in step:
+                continue
+                
+            found = re.findall(r'<([^>]+)>', step)
+            placeholders.update(found)
+        
+        if placeholders:
+            placeholder_list = ', '.join(f"<{p}>" for p in sorted(placeholders))
+            raise ValueError(
+                f"Scenario Contains Placeholders ({placeholder_list}) but is not a Scenario Outline. "
+                f"Use 'Scenario Outline:' instead of 'Scenario:' and provide an Examples table."
+            )
+        return values
+
     @classmethod
     def from_lines(cls, lines: List[str], start_idx: int) -> Tuple['Scenario', int]:
         """Parse a Scenario from a list of lines starting at start_idx."""
@@ -277,6 +301,7 @@ class FeatureArtefact(Artefact):
                 f"FeatureArtefact must have artefact_type of '{ArtefactType.feature}', not '{v}'")
         return v
 
+
     @classmethod
     def _title_prefix(cls) -> str:
         return "Feature:"