ara-cli 0.1.9.77__py3-none-any.whl → 0.1.10.8__py3-none-any.whl

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
 
@@ -144,11 +147,11 @@ def run_agent(prompt, artefact_class):
     # anthropic:claude-4-sonnet-20250514
     agent = Agent(
         model="anthropic:claude-4-sonnet-20250514",
-        result_type=artefact_class,
+        output_type=artefact_class,
         instrument=True,
     )
     result = agent.run_sync(prompt)
-    return result.data
+    return result.output
 
 
 def write_corrected_artefact(file_path, corrected_text):
@@ -196,36 +199,52 @@ def ask_for_correct_contribution(
     return name, classifier
 
 
-def ask_for_contribution_choice(
-    choices, artefact_info: Optional[tuple[str, str]] = None
-) -> Optional[str]:
-    artefact_name, artefact_classifier = (
-        artefact_info if artefact_info else (None, None)
-    )
+def ask_for_contribution_choice(choices: List[str], artefact_info: Optional[tuple[str, str]] = None) -> Optional[str]:
+    artefact_name, artefact_classifier = artefact_info if artefact_info else (None, None)
     message = "Found multiple close matches for the contribution"
     if artefact_name and artefact_classifier:
         message += f" of the {artefact_classifier} '{artefact_name}'"
-    print(f"{message}.")
-    for i, contribution in enumerate(choices):
-        print(f"{i + 1}: {contribution}")
-    choice_number = input(
-        "Please choose the artefact to use for contribution (enter number): "
-    )
+    message += "."
+    return get_user_choice(choices, message)
+
+
+def _has_valid_contribution(artefact: Artefact) -> bool:
+    contribution = artefact.contribution
+    return contribution and contribution.artefact_name and contribution.classifier
+
+
+def get_user_choice(choices: List[str], message: str) -> Optional[str]:
+    """
+    Generic function to present user with a list of choices and return their selection.
+
+    Args:
+        choices: A list of strings representing the choices to display.
+        message: A message to display before listing the choices.
+
+    Returns:
+        The chosen item from the list or None if the input was invalid.
+    """
+    print(message)
+    for i, choice in enumerate(choices):
+        print(f"{i + 1}: {choice}")
+
+    choice_number = input("Please enter your choice (number): ")
+
     try:
         choice_index = int(choice_number) - 1
         if choice_index < 0 or choice_index >= len(choices):
-            print("Invalid choice. Aborting contribution choice.")
+            print("Invalid choice. Aborting operation.")
             return None
-        choice = choices[choice_index]
+        return choices[choice_index]
     except ValueError:
-        print("Invalid input. Aborting contribution choice.")
+        print("Invalid input. Aborting operation.")
         return None
-    return choice
 
 
-def _has_valid_contribution(artefact: Artefact) -> bool:
-    contribution = artefact.contribution
-    return contribution and contribution.artefact_name and contribution.classifier
+def ask_for_rule_choice(matches: List[str]) -> Optional[str]:
+    """Asks the user for a choice between multiple rule matches"""
+    message = "Multiple rule matches found:"
+    return get_user_choice(matches, message)
 
 
 def _update_rule(
@@ -249,6 +268,9 @@ def _update_rule(
         return
     if not closest_rule_match:
         return
+    if len(closest_rule_match) > 1:
+        artefact.contribution.rule = ask_for_rule_choice(closest_rule_match)
+        return
     artefact.contribution.rule = closest_rule_match[0]
 
 
@@ -353,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:
@@ -429,6 +576,42 @@ def fix_rule(
     return artefact.serialize()
 
 
+def fix_misplaced_content(file_path: str, artefact_text: str, **kwargs) -> str:
+    """
+    Deterministically fixes content like 'Rule:' or 'Estimate:' misplaced in the description.
+    """
+    lines = artefact_text.splitlines()
+
+    desc_start_idx = -1
+    for i, line in enumerate(lines):
+        if line.strip().startswith("Description:"):
+            desc_start_idx = i
+            break
+
+    if desc_start_idx == -1:
+        return artefact_text  # No description, nothing to fix.
+
+    pre_desc_lines = lines[:desc_start_idx]
+    desc_line = lines[desc_start_idx]
+    post_desc_lines = lines[desc_start_idx+1:]
+
+    misplaced_content = []
+    new_post_desc_lines = []
+
+    for line in post_desc_lines:
+        if line.strip().startswith("Rule:") or line.strip().startswith("Estimate:"):
+            misplaced_content.append(line)
+        else:
+            new_post_desc_lines.append(line)
+
+    if not misplaced_content:
+        return artefact_text
+
+    # Rebuild the file content
+    final_lines = pre_desc_lines + misplaced_content + [""] + [desc_line] + new_post_desc_lines
+    return "\n".join(final_lines)
+
+
 def should_skip_issue(deterministic_issue, deterministic, non_deterministic, file_path) -> bool:
     if not non_deterministic and not deterministic_issue:
         print(f"Skipping non-deterministic fix for {file_path} as per request.")
@@ -475,7 +658,7 @@ def apply_non_deterministic_fix(
             corrected_artefact = run_agent(prompt, artefact_class)
             corrected_text = corrected_artefact.serialize()
         except Exception as e:
-            print(f"   ❌ LLM agent failed to fix artefact at {file_path}: {e}")
+            print(f"    ❌ LLM agent failed to fix artefact at {file_path}: {e}")
             return None
     return corrected_text
 
@@ -504,7 +687,7 @@ def attempt_autofix_loop(
         print(
             f"Attempting to fix {file_path} (Attempt {attempt + 1}/{max_attempts})..."
         )
-        print(f"   Reason: {current_reason}")
+        print(f"    Reason: {current_reason}")
 
         artefact_text = read_artefact(file_path)
         if artefact_text is None:
@@ -536,13 +719,13 @@ def attempt_autofix_loop(
 
         if corrected_text is None or corrected_text.strip() == artefact_text.strip():
             print(
-                "   Fixing attempt did not alter the file. Stopping to prevent infinite loop."
+                "    Fixing attempt did not alter the file. Stopping to prevent infinite loop."
             )
             return False
 
         write_corrected_artefact(file_path, corrected_text)
 
-        print("   File modified. Re-classifying artefact information for next check...")
+        print("    File modified. Re-classifying artefact information for next check...")
         classified_artefact_info = populate_classified_artefact_info(classified_artefact_info, force=True)
 
     print(f"❌ Failed to fix {file_path} after {max_attempts} attempts.")
@@ -565,6 +748,9 @@ 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,
+        "Found 'Rule:' inside description": fix_misplaced_content,
+        "Found 'Estimate:' inside description": fix_misplaced_content,
     }
 
     artefact_type, artefact_class = determine_artefact_type_and_class(classifier)
@@ -583,4 +769,4 @@ def apply_autofix(
         deterministic=deterministic,
         non_deterministic=non_deterministic,
         classified_artefact_info=classified_artefact_info,
-    )
+    )

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_lister.py

@@ -1,9 +1,13 @@
 from ara_cli.file_classifier import FileClassifier
 from ara_cli.artefact_reader import ArtefactReader
 from ara_cli.file_lister import list_files_in_directory
-from ara_cli.artefact_models.artefact_model import Artefact
 from ara_cli.list_filter import ListFilter, filter_list
 from ara_cli.artefact_fuzzy_search import suggest_close_name_matches
+from ara_cli.artefact_models.artefact_data_retrieval import (
+    artefact_content_retrieval,
+    artefact_path_retrieval,
+    artefact_tags_retrieval,
+)
 import os
 
 
@@ -11,43 +15,18 @@ class ArtefactLister:
     def __init__(self, file_system=None):
         self.file_system = file_system or os
 
-    @staticmethod
-    def artefact_content_retrieval(artefact: Artefact):
-        content = artefact.serialize()
-        return content
-
-    @staticmethod
-    def artefact_path_retrieval(artefact: Artefact):
-        return artefact.file_path
-
-    @staticmethod
-    def artefact_tags_retrieval(artefact: Artefact):
-        final_tags = []
-
-        if not artefact:
-            return []
-
-        final_tags.extend([f"user_{user}" for user in artefact.users])
-        final_tags.append(artefact.status)
-        final_tags.extend(artefact.tags)
-
-        return final_tags
-
     def filter_artefacts(self, classified_files: list, list_filter: ListFilter):
         filtered_list = filter_list(
             list_to_filter=classified_files,
             list_filter=list_filter,
-            content_retrieval_strategy=ArtefactLister.artefact_content_retrieval,
-            file_path_retrieval=ArtefactLister.artefact_path_retrieval,
-            tag_retrieval=ArtefactLister.artefact_tags_retrieval
+            content_retrieval_strategy=artefact_content_retrieval,
+            file_path_retrieval=artefact_path_retrieval,
+            tag_retrieval=artefact_tags_retrieval,
         )
         return filtered_list
 
     def list_files(
-        self,
-        tags=None,
-        navigate_to_target=False,
-        list_filter: ListFilter | None = None
+        self, tags=None, navigate_to_target=False, list_filter: ListFilter | None = None
     ):
         artefact_list = ArtefactReader.read_artefacts(tags=tags)
         artefact_list = self.filter_artefacts(artefact_list, list_filter)
@@ -60,20 +39,18 @@ class ArtefactLister:
         file_classifier.print_classified_files(filtered_artefact_list)
 
     def list_branch(
-        self,
-        classifier,
-        artefact_name,
-        list_filter: ListFilter | None = None
+        self, classifier, artefact_name, list_filter: ListFilter | None = None
     ):
         file_classifier = FileClassifier(os)
         classified_artefacts = file_classifier.classify_files()
         artefact_info = classified_artefacts.get(classifier, [])
-        matching_artefact_info = [p for p in artefact_info if p["title"] == artefact_name]
+        matching_artefact_info = [
+            p for p in artefact_info if p["title"] == artefact_name
+        ]
 
         if not matching_artefact_info:
             suggest_close_name_matches(
-                artefact_name,
-                [info["title"] for info in artefact_info]
+                artefact_name, [info["title"] for info in artefact_info]
             )
 
         artefacts_by_classifier = {classifier: []}
@@ -82,29 +59,28 @@ class ArtefactLister:
             classifier=classifier,
             artefacts_by_classifier=artefacts_by_classifier,
         )
-        artefacts_by_classifier = self.filter_artefacts(artefacts_by_classifier, list_filter)
+        artefacts_by_classifier = self.filter_artefacts(
+            artefacts_by_classifier, list_filter
+        )
         file_classifier.print_classified_files(artefacts_by_classifier)
 
     def list_children(
-        self,
-        classifier,
-        artefact_name,
-        list_filter: ListFilter | None = None
+        self, classifier, artefact_name, list_filter: ListFilter | None = None
     ):
         file_classifier = FileClassifier(os)
         classified_artefacts = file_classifier.classify_files()
         artefact_info = classified_artefacts.get(classifier, [])
-        matching_artefact_info = [p for p in artefact_info if p["title"] == artefact_name]
+        matching_artefact_info = [
+            p for p in artefact_info if p["title"] == artefact_name
+        ]
 
         if not matching_artefact_info:
             suggest_close_name_matches(
-                artefact_name,
-                [info["title"] for info in artefact_info]
+                artefact_name, [info["title"] for info in artefact_info]
             )
 
         child_artefacts = ArtefactReader.find_children(
-            artefact_name=artefact_name,
-            classifier=classifier
+            artefact_name=artefact_name, classifier=classifier
         )
 
         child_artefacts = self.filter_artefacts(child_artefacts, list_filter)
@@ -112,25 +88,23 @@ class ArtefactLister:
         file_classifier.print_classified_files(child_artefacts)
 
     def list_data(
-        self,
-        classifier,
-        artefact_name,
-        list_filter: ListFilter | None = None
+        self, classifier, artefact_name, list_filter: ListFilter | None = None
     ):
         file_classifier = FileClassifier(os)
         classified_artefact_info = file_classifier.classify_files()
         artefact_info_dict = classified_artefact_info.get(classifier, [])
 
-        matching_info = [info for info in artefact_info_dict if info["title"] == artefact_name]
+        matching_info = [
+            info for info in artefact_info_dict if info["title"] == artefact_name
+        ]
 
         if not matching_info:
             suggest_close_name_matches(
-                artefact_name,
-                [info["title"] for info in artefact_info_dict]
+                artefact_name, [info["title"] for info in artefact_info_dict]
             )
             return
 
         artefact_info = matching_info[0]
-        data_dir = os.path.splitext(artefact_info["file_path"])[0] + '.data'
+        data_dir = os.path.splitext(artefact_info["file_path"])[0] + ".data"
         if os.path.exists(data_dir):
             list_files_in_directory(data_dir, list_filter)

ara_cli/artefact_models/artefact_data_retrieval.py

@@ -0,0 +1,23 @@
+from ara_cli.artefact_models.artefact_model import Artefact
+
+
+def artefact_content_retrieval(artefact: Artefact):
+    content = artefact.serialize()
+    return content
+
+
+def artefact_path_retrieval(artefact: Artefact):
+    return artefact.file_path
+
+
+def artefact_tags_retrieval(artefact: Artefact):
+    final_tags = []
+
+    if not artefact:
+        return []
+
+    final_tags.extend([f"user_{user}" for user in artefact.users])
+    final_tags.append(artefact.status)
+    final_tags.extend(artefact.tags)
+
+    return final_tags