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

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}")
@@ -106,7 +101,7 @@ class ArtefactCreator:
         if not self.handle_existing_files(file_exists):
             return
 
-        artefact = template_artefact_of_type(classifier, filename, False)
+        artefact = template_artefact_of_type(classifier, filename, True)
 
         if parent_classifier and parent_name:
             artefact.set_contribution(
@@ -114,6 +109,8 @@ class ArtefactCreator:
                 classifier=parent_classifier,
                 rule=rule
             )
+        else:
+            artefact.set_contribution(None, None, None)
 
         artefact_content = artefact.serialize()
         rmtree(dir_path, ignore_errors=True)

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:"

ara_cli/artefact_reader.py

@@ -1,3 +1,4 @@
+from . import error_handler
 from ara_cli.classifier import Classifier
 from ara_cli.file_classifier import FileClassifier
 from ara_cli.artefact_models.artefact_model import Artefact
@@ -12,8 +13,7 @@ class ArtefactReader:
     @staticmethod
     def read_artefact_data(artefact_name, classifier, classified_file_info = None) -> tuple[str, dict[str, str]]:
         if not Classifier.is_valid_classifier(classifier):
-            print("Invalid classifier provided. Please provide a valid classifier.")
-            return None, None
+            raise ValueError("Invalid classifier provided. Please provide a valid classifier.")
 
         if not classified_file_info:
             file_classifier = FileClassifier(os)
@@ -74,7 +74,6 @@ class ArtefactReader:
 
     @staticmethod
     def read_artefacts(classified_artefacts=None, file_system=os, tags=None) -> Dict[str, List[Artefact]]:
-        from ara_cli.artefact_models.artefact_load import artefact_from_content
 
         if classified_artefacts is None:
             file_classifier = FileClassifier(file_system)
@@ -89,7 +88,7 @@ class ArtefactReader:
                     artefact = ArtefactReader.read_artefact(title, artefact_type, classified_artefacts)
                     artefacts[artefact_type].append(artefact)
                 except Exception as e:
-                    print(f"Failed to read {artefact_type} '{title}' with an error: ", e)
+                    error_handler.report_error(e, f"reading {artefact_type} '{title}'")
                     continue
         return artefacts
 
@@ -143,7 +142,7 @@ class ArtefactReader:
         ArtefactReader._ensure_classifier_key(classifier, artefacts_by_classifier)
 
         artefact = ArtefactReader._find_artefact_by_name(
-            artefact_name, 
+            artefact_name,
             classified_artefacts.get(classifier, [])
         )
 

ara_cli/chat.py

@@ -1,6 +1,7 @@
 import os
 import argparse
 import cmd2
+from . import error_handler
 from ara_cli.prompt_handler import send_prompt
 
 from ara_cli.file_loaders.document_file_loader import DocumentFileLoader
@@ -16,6 +17,13 @@ load_parser = argparse.ArgumentParser()
 load_parser.add_argument('file_name', nargs='?', default='', help='File to load')
 load_parser.add_argument('--load-images', action='store_true', help='Extract and describe images from documents')
 
+extract_parser = argparse.ArgumentParser()
+extract_parser.add_argument('-f', '--force', action='store_true', help='Force extraction')
+extract_parser.add_argument('-w','--write', action='store_true', help='Overwrite existing files without using LLM for merging.')
+
+load_parser = argparse.ArgumentParser()
+load_parser.add_argument('file_name', nargs='?', default='', help='File to load')
+load_parser.add_argument('--load-images', action='store_true', help='Extract and describe images from documents')
 
 
 class Chat(cmd2.Cmd):
@@ -49,7 +57,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
             ".jpg": "image/jpeg",
             ".jpeg": "image/jpeg",
         }
-    
+
     DOCUMENT_TYPE_EXTENSIONS = [".docx", ".doc", ".odt", ".pdf"]
 
     def __init__(
@@ -492,6 +500,13 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         self.last_result = True
         return True
 
+    def onecmd(self, *args, **kwargs):
+        try:
+            return super().onecmd(*args, **kwargs)
+        except Exception as e:
+            error_handler.report_error(e)
+        return False
+
     def onecmd_plus_hooks(self, line, orig_rl_history_length):
         # store the full line for use with default()
         self.full_input = line
@@ -817,50 +832,77 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
             file_name=self.chat_name,
             force=args.force,
             write=args.write,
-            output=self.poutput,
-            error_output=self.perror
+            output=self.poutput
         )
         command.execute()
 
+    def _find_givens_files(self, file_name: str) -> list[str]:
+        """
+        Finds the givens files to be processed.
+        - If file_name is provided, it resolves that path.
+        - Otherwise, it looks for default givens files.
+        - If no defaults are found, it prompts the user.
+        Returns a list of absolute file paths or an empty list if none are found.
+        """
+        base_directory = os.path.dirname(self.chat_name)
+
+        def resolve_path(name):
+            """Inner helper to resolve a path relative to chat, then absolute."""
+            relative_path = os.path.join(base_directory, name)
+            if os.path.exists(relative_path):
+                return relative_path
+            if os.path.exists(name):
+                return name
+            return None
+
+        if file_name:
+            path = resolve_path(file_name)
+            if path:
+                return [path]
+            relative_path_for_error = os.path.join(base_directory, file_name)
+            self.perror(f"No givens file found at {relative_path_for_error} or {file_name}")
+            return []
+
+        # If no file_name, check for defaults
+        default_files_to_check = [
+            os.path.join(base_directory, "prompt.data", "config.prompt_givens.md"),
+            os.path.join(base_directory, "prompt.data", "config.prompt_global_givens.md")
+        ]
+        existing_defaults = [f for f in default_files_to_check if os.path.exists(f)]
+        if existing_defaults:
+            return existing_defaults
+
+        # No defaults found, prompt user
+        user_input = input("Please specify a givens file: ")
+        if not user_input:
+            self.poutput("Aborting.")
+            return []
+        
+        path = resolve_path(user_input)
+        if path:
+            return [path]
+        self.perror(f"No givens file found at {user_input}. Aborting.")
+        return []
+
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_LOAD_GIVENS(self, file_name):
-        """Load all files listed in a ./prompt.data/config.prompt_givens.md"""
-        from ara_cli.directory_navigator import DirectoryNavigator
+        """Load all files listed in a ./prompt.data/config.prompt_givens.md and ./prompt.data/config.prompt_global_givens.md"""
         from ara_cli.prompt_handler import load_givens
 
-        base_directory = os.path.dirname(self.chat_name)
-
-        if file_name == "":
-            file_name = f"{base_directory}/prompt.data/config.prompt_givens.md"
-
-        # Check the relative path first
-        relative_givens_path = os.path.join(base_directory, file_name)
-        if os.path.exists(relative_givens_path):
-            givens_path = relative_givens_path
-        elif os.path.exists(file_name):  # Check the absolute path
-            givens_path = file_name
-        else:
-            print(f"No givens file found at {relative_givens_path} or {file_name}")
-            user_input = input("Please specify a givens file: ")
-            if os.path.exists(os.path.join(base_directory, user_input)):
-                givens_path = os.path.join(base_directory, user_input)
-            elif os.path.exists(user_input):
-                givens_path = user_input
-            else:
-                print(f"No givens file found at {user_input}. Aborting.")
-                return
+        givens_files_to_process = self._find_givens_files(file_name)
+        if not givens_files_to_process:
+            self.poutput("No givens files to load.")
+            return
 
-        cwd = os.getcwd()
-        navigator = DirectoryNavigator()
-        navigator.navigate_to_target()
-        os.chdir('..')
-        content, image_data = load_givens(givens_path)
-        os.chdir(cwd)
+        for givens_path in givens_files_to_process:
+            # The givens_path is absolute, and load_givens reconstructs absolute paths
+            # from the markdown file. No directory change is needed.
+            content, _ = load_givens(givens_path)
 
-        with open(self.chat_name, 'a', encoding='utf-8') as chat_file:
-            chat_file.write(content)
+            with open(self.chat_name, 'a', encoding='utf-8') as chat_file:
+                chat_file.write(content)
 
-        print(f"Loaded files listed and marked in {givens_path}")
+            self.poutput(f"Loaded files listed and marked in {givens_path}")
 
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_SEND(self, _):
@@ -876,7 +918,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
 
         artefact = template_artefact_of_type(''.join(template_name))
         if not artefact:
-            return
+            raise ValueError(f"No template for '{template_name}' found.")
         write_content = artefact.serialize()
         self.add_prompt_tag_if_needed(self.chat_name)
         with open(self.chat_name, 'a', encoding='utf-8') as chat_file:
@@ -884,7 +926,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         print(f"Loaded {template_name} artefact template")
 
     def complete_LOAD_TEMPLATE(self, text, line, begidx, endidx):
-        return self._complete_classifiers(self, text, line, begidx, endidx)
+        return self._complete_classifiers(text, line, begidx, endidx)
 
     def _complete_classifiers(self, text, line, begidx, endidx):
         from ara_cli.classifier import Classifier

ara_cli/commands/extract_command.py

@@ -3,20 +3,13 @@ from ara_cli.prompt_extractor import extract_responses
 import os
 
 class ExtractCommand(Command):
-    def __init__(self, file_name, force=False, write=False, output=None, error_output=None):
+    def __init__(self, file_name, force=False, write=False, output=None):
         self.file_name = file_name
         self.force = force
         self.write = write
         self.output = output    # Callable for standard output (optional)
-        self.error_output = error_output  # Callable for errors (optional)
 
     def execute(self, *args, **kwargs):
-        try:
-            extract_responses(self.file_name, True, force=self.force, write=self.write)
-            if self.output:
-                self.output("End of extraction")
-        except Exception as e:
-            if self.error_output:
-                self.error_output(f"Extraction failed: {e}")
-            else:
-                raise
+        extract_responses(self.file_name, True, force=self.force, write=self.write)
+        if self.output:
+            self.output("End of extraction")

ara_cli/error_handler.py

@@ -0,0 +1,134 @@
+import sys
+import traceback
+from typing import Optional
+from enum import Enum
+from functools import wraps
+
+
+RED = '\033[91m'
+RESET = '\033[0m'
+
+
+class ErrorLevel(Enum):
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class AraError(Exception):
+    """Base exception class for ARA CLI errors"""
+
+    def __init__(
+        self, message: str, error_code: int = 1, level: ErrorLevel = ErrorLevel.ERROR
+    ):
+        self.message = message
+        self.error_code = error_code
+        self.level = level
+        super().__init__(self.message)
+
+
+class AraValidationError(AraError):
+    """Raised when validation fails"""
+
+    def __init__(self, message: str):
+        super().__init__(message, error_code=2, level=ErrorLevel.ERROR)
+
+
+class AraConfigurationError(AraError):
+    """Raised when configuration is invalid"""
+
+    def __init__(self, message: str):
+        super().__init__(message, error_code=4, level=ErrorLevel.ERROR)
+
+
+class ErrorHandler:
+    """Centralized error handler for ARA CLI"""
+
+    def __init__(self, debug_mode: bool = False):
+        self.debug_mode = debug_mode
+
+    def handle_error(self, error: Exception, context: Optional[str] = None) -> None:
+        """Handle any error with standardized output"""
+        if isinstance(error, AraError):
+            self._handle_ara_error(error, context)
+        else:
+            self._handle_generic_error(error, context)
+
+    def _handle_ara_error(self, error: AraError, context: Optional[str] = None) -> None:
+        """Handle ARA-specific errors"""
+        self._report_ara_error(error, context)
+
+        sys.exit(error.error_code)
+
+    def _handle_generic_error(
+        self, error: Exception, context: Optional[str] = None
+    ) -> None:
+        """Handle generic Python errors"""
+        self._report_generic_error(error, context)
+
+        sys.exit(1)
+
+
+    def report_error(self, error: Exception, context: Optional[str] = None) -> None:
+        """Report error with standardized formatting but don't exit"""
+        if isinstance(error, AraError):
+            self._report_ara_error(error, context)
+        else:
+            self._report_generic_error(error, context)
+
+
+    def _report_ara_error(self, error: AraError, context: Optional[str] = None) -> None:
+        """Report ARA-specific errors without exiting"""
+        error_prefix = f"[{error.level.value}]"
+
+        if context:
+            print(f"{RED}{error_prefix} {context}: {error.message}{RESET}", file=sys.stderr)
+        else:
+            print(f"{RED}{error_prefix} {error.message}{RESET}", file=sys.stderr)
+
+        if self.debug_mode:
+            traceback.print_exc()
+
+
+    def _report_generic_error(self, error: Exception, context: Optional[str] = None) -> None:
+        """Report generic Python errors without exiting"""
+        error_type = type(error).__name__
+
+        if context:
+            print(f"{RED}[ERROR] {context}: {error_type}: {str(error)}{RESET}", file=sys.stderr)
+        else:
+            print(f"{RED}[ERROR] {error_type}: {str(error)}{RESET}", file=sys.stderr)
+
+        if self.debug_mode:
+            traceback.print_exc()
+
+
+    def validate_and_exit(
+        self, condition: bool, message: str, error_code: int = 1
+    ) -> None:
+        """Validate condition and exit with error if false"""
+        if not condition:
+            raise AraValidationError(message)
+
+
+def handle_errors(_func=None, context: Optional[str] = None, error_handler: Optional[ErrorHandler] = None):
+    """Decorator to handle errors in action functions"""
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            nonlocal error_handler
+            if error_handler is None:
+                error_handler = ErrorHandler()
+
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                error_handler.handle_error(e, context or func.__name__)
+
+        return wrapper
+
+    if callable(_func):
+        return decorator(_func)
+    return decorator

ara_cli/file_classifier.py

@@ -1,3 +1,4 @@
+from . import error_handler
 from ara_cli.classifier import Classifier
 from ara_cli.artefact_models.artefact_model import Artefact
 from ara_cli.artefact_fuzzy_search import find_closest_name_matches
@@ -33,8 +34,8 @@ class FileClassifier:
                     if byte > 127:
                         return True
         except Exception as e:
-            # Handle unexpected errors while reading the file in binary mode
-            print(f"Error while checking if file is binary: {e}")
+            error_handler.report_error(e, "checking if file is binary")
+            # print(f"Error while checking if file is binary: {e}")
         return False
 
     def read_file_with_fallback(self, file_path):