ara-cli 0.1.9.76__py3-none-any.whl → 0.1.9.78__py3-none-any.whl

ara_cli/artefact_autofix.py

@@ -12,6 +12,15 @@ import difflib
 import os
 
 
+def populate_classified_artefact_info(
+    classified_artefact_info: Optional[dict], force: bool = False
+):
+    if not classified_artefact_info or force:
+        file_classifier = FileClassifier(os)
+        classified_artefact_info = file_classifier.classify_files()
+    return classified_artefact_info
+
+
 def read_report_file():
     file_path = "incompatible_artefacts_report.md"
     try:
@@ -30,6 +39,7 @@ def parse_report(content: str) -> Dict[str, List[Tuple[str, str]]]:
     Parses the incompatible artefacts report and returns structured data.
     Returns a dictionary where keys are artefact classifiers, and values are lists of (file_path, reason) tuples.
     """
+
     def is_valid_report(lines: List[str]) -> bool:
         return bool(lines) and lines[0] == "# Artefact Check Report"
 
@@ -219,7 +229,7 @@ def _has_valid_contribution(artefact: Artefact) -> bool:
 
 
 def _update_rule(
-    artefact: Artefact, name: str, classifier: str, classified_file_info: dict
+    artefact: Artefact, name: str, classifier: str, classified_file_info: dict, delete_if_not_found: bool = False
 ) -> None:
     """Updates the rule in the contribution if a close match is found."""
     rule = artefact.contribution.rule
@@ -234,8 +244,12 @@ def _update_rule(
     rules = parent.rules
 
     closest_rule_match = difflib.get_close_matches(rule, rules, cutoff=0.5)
-    if closest_rule_match:
-        artefact.contribution.rule = closest_rule_match[0]
+    if not closest_rule_match and delete_if_not_found:
+        artefact.contribution.rule = None
+        return
+    if not closest_rule_match:
+        return
+    artefact.contribution.rule = closest_rule_match[0]
 
 
 def _set_contribution_multiple_matches(
@@ -281,9 +295,7 @@ def set_closest_contribution(
     classifier = contribution.classifier
     rule = contribution.rule
 
-    if not classified_file_info:
-        file_classifier = FileClassifier(os)
-        classified_file_info = file_classifier.classify_files()
+    classified_file_info = populate_classified_artefact_info(classified_artefact_info=classified_file_info)
 
     all_artefact_names = extract_artefact_names_of_classifier(
         classified_files=classified_file_info, classifier=classifier
@@ -299,7 +311,9 @@ def set_closest_contribution(
         if not name or not classifier:
             artefact.contribution = None
             return artefact, True
-        print(f"Updating contribution of {artefact._artefact_type().value} '{artefact.title}' to {classifier} '{name}'")
+        print(
+            f"Updating contribution of {artefact._artefact_type().value} '{artefact.title}' to {classifier} '{name}'"
+        )
         contribution.artefact_name = name
         contribution.classifier = classifier
         artefact.contribution = contribution
@@ -378,100 +392,118 @@ def fix_contribution(
     classified_artefact_info: dict,
     **kwargs,
 ):
-    if not classified_artefact_info:
-        file_classifier = FileClassifier(os)
-        classified_artefact_info = file_classifier.classify_files()
+    classified_artefact_info = populate_classified_artefact_info(classified_artefact_info=classified_artefact_info)
     artefact = artefact_class.deserialize(artefact_text)
     artefact, _ = set_closest_contribution(artefact)
     artefact_text = artefact.serialize()
     return artefact_text
 
 
-def apply_autofix(
+def fix_rule(
     file_path: str,
-    classifier: str,
-    reason: str,
-    single_pass: bool = False,
-    deterministic: bool = True,
-    non_deterministic: bool = True,
-    classified_artefact_info: Optional[Dict[str, List[Dict[str, str]]]] = None,
-) -> bool:
-    """
-    Applies fixes to a single artefact file iteratively until it is valid
-    or a fix cannot be applied. If single_pass is True, it runs for only one attempt.
-    """
-    deterministic_markers_to_functions = {
-        "Filename-Title Mismatch": fix_title_mismatch,
-        "Invalid Contribution Reference": fix_contribution,
-    }
+    artefact_text: str,
+    artefact_class: str,
+    classified_artefact_info: dict,
+    **kwargs,
+):
+    classified_artefact_info = populate_classified_artefact_info(classified_artefact_info=classified_artefact_info)
+    artefact = artefact_class.deserialize(artefact_text)
+    contribution = artefact.contribution
+    assert contribution is not None
+    _update_rule(
+        artefact=artefact,
+        name=contribution.artefact_name,
+        classifier=contribution.classifier,
+        classified_file_info=classified_artefact_info,
+        delete_if_not_found=True
+    )
+    feedback_message = (f"Updating contribution of {artefact._artefact_type().value} "
+                        f"'{artefact.title}' to {contribution.classifier} "
+                        f"'{contribution.artefact_name}' ")
+    rule = contribution.rule
+    if rule:
+        feedback_message += f"with rule '{rule}'"
+    else:
+        feedback_message += "without a rule"
+    print(feedback_message)
+    return artefact.serialize()
+
+
+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.")
+        return True
+    if not deterministic and deterministic_issue:
+        print(f"Skipping fix for {file_path} as per request flags.")
+        return True
+    return False
 
-    def populate_classified_artefact_info(force: bool = False):
-        nonlocal classified_artefact_info
-        if force or classified_artefact_info is None:
-            file_classifier = FileClassifier(os)
-            classified_artefact_info = file_classifier.classify_files()
-
-    def determine_attempt_count() -> int:
-        nonlocal single_pass, file_path
-        if single_pass:
-            print(f"Single-pass mode enabled for {file_path}. Running for 1 attempt.")
-            return 1
-        return 3
-
-    def apply_deterministic_fix() -> str:
-        nonlocal deterministic, deterministic_issue, corrected_text, file_path, artefact_text, artefact_class, classified_artefact_info
-        if deterministic and deterministic_issue:
-            print(f"Applying deterministic fix for '{deterministic_issue}'...")
-            fix_function = deterministic_markers_to_functions[deterministic_issue]
-            return fix_function(
-                file_path=file_path,
-                artefact_text=artefact_text,
-                artefact_class=artefact_class,
-                classified_artefact_info=classified_artefact_info,
-            )
-        return corrected_text
-
-    def apply_non_deterministic_fix() -> Optional[str]:
-        """
-        Applies LLM fix. Return None in case of an exception
-        """
-        nonlocal non_deterministic, deterministic_issue, corrected_text, artefact_type, current_reason, file_path, artefact_text
-        if non_deterministic and not deterministic_issue:
-            print("Applying non-deterministic (LLM) fix...")
-            prompt = construct_prompt(artefact_type, current_reason, file_path, artefact_text)
-            try:
-                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}")
-                return None
-        return corrected_text
-
-    def should_skip() -> bool:
-        nonlocal deterministic_issue, deterministic, non_deterministic
-        if not non_deterministic and not deterministic_issue:
-            print(f"Skipping non-deterministic fix for {file_path} as per request.")
-            return True
-        if not deterministic and deterministic_issue:
-            print(f"Skipping fix for {file_path} as per request flags.")
-            return True
-        return False
+def determine_attempt_count(single_pass, file_path) -> int:
+    if single_pass:
+        print(f"Single-pass mode enabled for {file_path}. Running for 1 attempt.")
+        return 1
+    return 3
 
-    artefact_type, artefact_class = determine_artefact_type_and_class(classifier)
-    if artefact_type is None or artefact_class is None:
-        return False
+def apply_deterministic_fix(
+    deterministic, deterministic_issue, file_path, artefact_text, artefact_class, classified_artefact_info,
+    deterministic_markers_to_functions, corrected_text
+) -> str:
+    if deterministic and deterministic_issue:
+        print(f"Applying deterministic fix for '{deterministic_issue}'...")
+        fix_function = deterministic_markers_to_functions[deterministic_issue]
+        return fix_function(
+            file_path=file_path,
+            artefact_text=artefact_text,
+            artefact_class=artefact_class,
+            classified_artefact_info=classified_artefact_info,
+        )
+    return corrected_text
 
-    populate_classified_artefact_info()
-    max_attempts = determine_attempt_count()
+def apply_non_deterministic_fix(
+    non_deterministic, deterministic_issue, corrected_text,
+    artefact_type, current_reason, file_path, artefact_text, artefact_class
+) -> Optional[str]:
+    """
+    Applies LLM fix. Return None in case of an exception
+    """
+    if non_deterministic and not deterministic_issue:
+        print("Applying non-deterministic (LLM) fix...")
+        prompt = construct_prompt(
+            artefact_type, current_reason, file_path, artefact_text
+        )
+        try:
+            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}")
+            return None
+    return corrected_text
 
+def attempt_autofix_loop(
+    file_path: str,
+    artefact_type,
+    artefact_class,
+    deterministic_markers_to_functions,
+    max_attempts,
+    deterministic: bool,
+    non_deterministic: bool,
+    classified_artefact_info: Optional[Dict[str, List[Dict[str, str]]]],
+) -> bool:
+    """
+    Attempts to fix the artefact in a loop, up to max_attempts.
+    """
     for attempt in range(max_attempts):
-        is_valid, current_reason = check_file(file_path, artefact_class, classified_artefact_info)
+        is_valid, current_reason = check_file(
+            file_path, artefact_class, classified_artefact_info
+        )
 
         if is_valid:
             print(f"✅ Artefact at {file_path} is now valid.")
             return True
 
-        print(f"Attempting to fix {file_path} (Attempt {attempt + 1}/{max_attempts})...")
+        print(
+            f"Attempting to fix {file_path} (Attempt {attempt + 1}/{max_attempts})..."
+        )
         print(f"   Reason: {current_reason}")
 
         artefact_text = read_artefact(file_path)
@@ -487,22 +519,68 @@ def apply_autofix(
             None,
         )
 
-        if should_skip():
+        if should_skip_issue(deterministic_issue, deterministic, non_deterministic, file_path):
             return False
 
         corrected_text = None
 
-        corrected_text = apply_deterministic_fix()
-        corrected_text = apply_non_deterministic_fix()
+        corrected_text = apply_deterministic_fix(
+            deterministic, deterministic_issue, file_path, artefact_text,
+            artefact_class, classified_artefact_info,
+            deterministic_markers_to_functions, corrected_text
+        )
+        corrected_text = apply_non_deterministic_fix(
+            non_deterministic, deterministic_issue, corrected_text,
+            artefact_type, current_reason, file_path, artefact_text, artefact_class
+        )
 
         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.")
+            print(
+                "   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...")
-        populate_classified_artefact_info(force=True)
+        classified_artefact_info = populate_classified_artefact_info(classified_artefact_info, force=True)
 
     print(f"❌ Failed to fix {file_path} after {max_attempts} attempts.")
     return False
+
+def apply_autofix(
+    file_path: str,
+    classifier: str,
+    reason: str,
+    single_pass: bool = False,
+    deterministic: bool = True,
+    non_deterministic: bool = True,
+    classified_artefact_info: Optional[Dict[str, List[Dict[str, str]]]] = None,
+) -> bool:
+    """
+    Applies fixes to a single artefact file iteratively until it is valid
+    or a fix cannot be applied. If single_pass is True, it runs for only one attempt.
+    """
+    deterministic_markers_to_functions = {
+        "Filename-Title Mismatch": fix_title_mismatch,
+        "Invalid Contribution Reference": fix_contribution,
+        "Rule Mismatch": fix_rule,
+    }
+
+    artefact_type, artefact_class = determine_artefact_type_and_class(classifier)
+    if artefact_type is None or artefact_class is None:
+        return False
+
+    classified_artefact_info = populate_classified_artefact_info(classified_artefact_info)
+    max_attempts = determine_attempt_count(single_pass, file_path)
+
+    return attempt_autofix_loop(
+        file_path=file_path,
+        artefact_type=artefact_type,
+        artefact_class=artefact_class,
+        deterministic_markers_to_functions=deterministic_markers_to_functions,
+        max_attempts=max_attempts,
+        deterministic=deterministic,
+        non_deterministic=non_deterministic,
+        classified_artefact_info=classified_artefact_info,
+    )

ara_cli/artefact_models/artefact_load.py

@@ -2,9 +2,17 @@ from ara_cli.artefact_models.artefact_mapping import title_prefix_to_artefact_cl
 
 
 def artefact_from_content(content):
-    relevant_lines = content.splitlines()[:2]
-    for line in relevant_lines:
+    lines = content.splitlines()
+    
+    # Look through more lines to find the title, skipping empty lines
+    for line in lines:
+        line = line.strip()
+        if not line:  # Skip empty lines
+            continue
+        if line.startswith('@'):  # Skip tag lines
+            continue
+            
         for prefix, artefact_class in title_prefix_to_artefact_class.items():
-            if line.strip().startswith(prefix):
+            if line.startswith(prefix):
                 return artefact_class.deserialize(content)
     return None

ara_cli/artefact_models/task_artefact_model.py

@@ -74,47 +74,55 @@ class TaskArtefact(Artefact):
     artefact_type: ArtefactType = ArtefactType.task
     action_items: List[ActionItem] = Field(default_factory=list)
 
+    @classmethod
+    def _is_action_item_start(cls, line: str) -> bool:
+        return line.startswith('[@')
+
+    @classmethod
+    def _is_section_start(cls, line: str, description_marker: str, contribution_marker: str) -> bool:
+        return (
+            line.startswith(description_marker) or
+            line.startswith(contribution_marker)
+        )
+
+    @classmethod
+    def _collect_action_item_lines(cls, lines, start_idx, description_marker, contribution_marker):
+        action_item_lines = [lines[start_idx]]
+        j = start_idx + 1
+        while j < len(lines):
+            next_line = lines[j]
+            if (
+                cls._is_action_item_start(next_line) or 
+                cls._is_section_start(next_line, description_marker, contribution_marker)
+            ):
+                break
+            action_item_lines.append(next_line)
+            j += 1
+        return action_item_lines, j
+
     @classmethod
     def _deserialize_action_items(cls, text) -> Tuple[List[ActionItem], List[str]]:
         lines = [line.strip() for line in text.strip().splitlines() if line.strip()]
-
         action_items = []
         remaining_lines = []
         i = 0
-
         contribution_marker = cls._contribution_starts_with()
         description_marker = cls._description_starts_with()
 
         while i < len(lines):
             line = lines[i]
-
-            if line.startswith('[@'):
-                # Collect all lines for this action item
-                action_item_lines = [line]
-                j = i + 1
-                # Collect lines until we hit another action item or a known section
-                while j < len(lines):
-                    next_line = lines[j]
-                    # Check if next line is a new action item or a known section
-                    if (next_line.startswith('[@') or 
-                        next_line.startswith(description_marker) or
-                        next_line.startswith(contribution_marker)):
-                        break
-                    action_item_lines.append(next_line)
-                    j += 1
-
-                # Join all lines and pass as a single string to deserialize
+            if cls._is_action_item_start(line):
+                action_item_lines, next_idx = cls._collect_action_item_lines(
+                    lines, i, description_marker, contribution_marker
+                )
                 action_item_text = '\n'.join(action_item_lines)
                 try:
                     action_item = ActionItem.deserialize(action_item_text)
                     if action_item:
                         action_items.append(action_item)
                 except ValueError as e:
-                    # Re-raise with more context about where the error occurred
                     raise ValueError(f"Error parsing action item: {e}")
-
-                # Move index to the next unprocessed line
-                i = j
+                i = next_idx
             else:
                 remaining_lines.append(line)
                 i += 1

ara_cli/artefact_reader.py

@@ -94,7 +94,7 @@ class ArtefactReader:
         return artefacts
 
     @staticmethod
-    def find_children(artefact_name, classifier, artefacts_by_classifier={}, classified_artefacts=None):
+    def find_children(artefact_name, classifier, artefacts_by_classifier=None, classified_artefacts=None):
         artefacts_by_classifier = artefacts_by_classifier or {}
         filtered_artefacts = {k: [] for k in artefacts_by_classifier.keys()}
 
@@ -103,73 +103,97 @@ class ArtefactReader:
 
         for artefact_classifier, artefacts in classified_artefacts.items():
             for artefact in artefacts:
-                if not isinstance(artefact, Artefact):
-                    continue
-
-                try:
-                    contribution = artefact.contribution
-                    if (contribution and
-                        contribution.artefact_name == artefact_name and
-                            contribution.classifier == classifier):
+                ArtefactReader._process_artefact(
+                    artefact, artefact_name, classifier, filtered_artefacts
+                )
 
-                        file_classifier = artefact._file_path.split('.')[-1]
-
-                        if file_classifier not in filtered_artefacts:
-                            filtered_artefacts[file_classifier] = []
-                        filtered_artefacts[file_classifier].append(artefact)
+        return ArtefactReader.merge_dicts(artefacts_by_classifier, filtered_artefacts)
 
-                except AttributeError as e:
-                    continue
+    @staticmethod
+    def _process_artefact(artefact, artefact_name, classifier, filtered_artefacts):
+        if not isinstance(artefact, Artefact):
+            return
+        contribution = getattr(artefact, 'contribution', None)
+        if not contribution:
+            return
+        if getattr(contribution, 'artefact_name', None) != artefact_name:
+            return
+        if getattr(contribution, 'classifier', None) != classifier:
+            return
 
-        return ArtefactReader.merge_dicts(artefacts_by_classifier, filtered_artefacts)
+        file_classifier = getattr(artefact, '_file_path', '').split('.')[-1]
+        if file_classifier not in filtered_artefacts:
+            filtered_artefacts[file_classifier] = []
+        filtered_artefacts[file_classifier].append(artefact)
 
     @staticmethod
     def step_through_value_chain(
             artefact_name,
             classifier,
-            artefacts_by_classifier={},
-            classified_artefacts: dict[str, list[Artefact]] | None = None
+            artefacts_by_classifier=None,
+            classified_artefacts: dict[str, list['Artefact']] | None = None
     ):
         from ara_cli.artefact_models.artefact_load import artefact_from_content
 
+        artefacts_by_classifier = artefacts_by_classifier or {}
+
         if classified_artefacts is None:
             classified_artefacts = ArtefactReader.read_artefacts()
 
-        if classifier not in artefacts_by_classifier:
-            artefacts_by_classifier[classifier] = []
+        ArtefactReader._ensure_classifier_key(classifier, artefacts_by_classifier)
 
-        artefact = next(filter(
-            lambda x: x.title == artefact_name, classified_artefacts[classifier]
-        ))
+        artefact = ArtefactReader._find_artefact_by_name(
+            artefact_name, 
+            classified_artefacts.get(classifier, [])
+        )
 
-        if not artefact:
-            return
-        if artefact in artefacts_by_classifier[classifier]:
+        if not artefact or artefact in artefacts_by_classifier[classifier]:
             return
 
         artefacts_by_classifier[classifier].append(artefact)
 
-        parent = artefact.contribution
-        if parent and parent.artefact_name and parent.classifier:
-            parent_name = parent.artefact_name
-            parent_classifier = parent.classifier
-
-            parent_classifier_artefacts = classified_artefacts[parent_classifier]
-            all_artefact_names = [x.title for x in parent_classifier_artefacts]
-
-            if parent_name not in all_artefact_names:
-                if parent_name is not None:
-                    suggest_close_name_matches_for_parent(
-                        artefact_name,
-                        all_artefact_names,
-                        parent_name
-                    )
-                print()
-                return
-
-            ArtefactReader.step_through_value_chain(
-                artefact_name=parent_name,
-                classifier=parent_classifier,
-                artefacts_by_classifier=artefacts_by_classifier,
-                classified_artefacts=classified_artefacts
+        parent = getattr(artefact, 'contribution', None)
+        if not ArtefactReader._has_valid_parent(parent):
+            return
+
+        parent_name = parent.artefact_name
+        parent_classifier = parent.classifier
+
+        parent_classifier_artefacts = classified_artefacts.get(parent_classifier, [])
+        all_artefact_names = [x.title for x in parent_classifier_artefacts]
+
+        if parent_name not in all_artefact_names:
+            ArtefactReader._suggest_parent_name_match(
+                artefact_name, all_artefact_names, parent_name
+            )
+            print()
+            return
+
+        ArtefactReader.step_through_value_chain(
+            artefact_name=parent_name,
+            classifier=parent_classifier,
+            artefacts_by_classifier=artefacts_by_classifier,
+            classified_artefacts=classified_artefacts
+        )
+
+    @staticmethod
+    def _ensure_classifier_key(classifier, artefacts_by_classifier):
+        if classifier not in artefacts_by_classifier:
+            artefacts_by_classifier[classifier] = []
+
+    @staticmethod
+    def _find_artefact_by_name(artefact_name, artefacts):
+        return next((x for x in artefacts if x.title == artefact_name), None)
+
+    @staticmethod
+    def _has_valid_parent(parent):
+        return parent and getattr(parent, 'artefact_name', None) and getattr(parent, 'classifier', None)
+
+    @staticmethod
+    def _suggest_parent_name_match(artefact_name, all_artefact_names, parent_name):
+        if parent_name is not None:
+            suggest_close_name_matches_for_parent(
+                artefact_name,
+                all_artefact_names,
+                parent_name
             )