ara-cli 0.1.9.69__py3-none-any.whl → 0.1.9.70__py3-none-any.whl

ara_cli/ara_command_action.py

@@ -575,6 +575,7 @@ def scan_action(args):
 
 def autofix_action(args):
     from ara_cli.artefact_autofix import parse_report, apply_autofix, read_report_file
+    from ara_cli.file_classifier import FileClassifier
 
     # If the user passes --non-deterministic, only_deterministic_fix becomes False.
     # If the user passes --deterministic, only_non_deterministic_fix becomes False.
@@ -591,6 +592,9 @@ def autofix_action(args):
         print("No issues found in the report. Nothing to fix.")
         return
 
+    file_classifier = FileClassifier(os)
+    classified_artefact_info = file_classifier.classify_files()
+
     # print("\nStarting autofix process...")
     for classifier, files in issues.items():
         print(f"\nClassifier: {classifier}")
@@ -600,8 +604,8 @@ def autofix_action(args):
                 classifier,
                 reason,
                 deterministic=run_deterministic,
-                non_deterministic=run_non_deterministic
+                non_deterministic=run_non_deterministic,
+                classified_artefact_info=classified_artefact_info
             )
 
     print("\nAutofix process completed. Please review the changes.")
-

ara_cli/ara_config.py

@@ -1,4 +1,4 @@
-from typing import List, Dict, Union, Optional
+from typing import List, Dict, Optional
 from pydantic import BaseModel
 import json
 import os
@@ -10,6 +10,13 @@ from functools import lru_cache
 DEFAULT_CONFIG_LOCATION = "./ara/.araconfig/ara_config.json"
 
 
+class LLMConfigItem(BaseModel):
+    provider: str
+    model: str
+    temperature: float
+    max_tokens: Optional[int] = None
+
+
 class ARAconfig(BaseModel):
     ext_code_dirs: List[Dict[str, str]] = [
         {"source_dir_1": "./src"},
@@ -36,42 +43,49 @@ class ARAconfig(BaseModel):
         "*.jpg",
         "*.jpeg",
     ]
-    llm_config: Dict[str, Dict[str, Union[str, float]]] = {
+    llm_config: Dict[str, LLMConfigItem] = {
         "gpt-4o": {
             "provider": "openai",
             "model": "openai/gpt-4o",
-            "temperature": 0.8
+            "temperature": 0.8,
+            "max_tokens": 16384
         },
         "gpt-4.1": {
             "provider": "openai",
             "model": "openai/gpt-4.1",
             "temperature": 0.8,
+            "max_tokens": 1024
         },
         "o3-mini": {
             "provider": "openai",
             "model": "openai/o3-mini",
             "temperature": 1.0,
+            "max_tokens": 1024
         },
         "opus-4": {
             "provider": "anthropic",
             "model": "anthropic/claude-opus-4-20250514",
             "temperature": 0.8,
+            "max_tokens": 32000
         },
         "sonnet-4": {
             "provider": "anthropic",
             "model": "anthropic/claude-sonnet-4-20250514",
             "temperature": 0.8,
+            "max_tokens": 1024
         },
         "together-ai-llama-2": {
             "provider": "together_ai",
             "model": "together_ai/togethercomputer/llama-2-70b",
             "temperature": 0.8,
+            "max_tokens": 1024
         },
         "groq-llama-3": {
             "provider": "groq",
             "model": "groq/llama3-70b-8192",
             "temperature": 0.8,
-        },
+            "max_tokens": 1024
+        }
     }
     default_llm: Optional[str] = "gpt-4o"
 
@@ -99,7 +113,7 @@ def read_data(filepath: str) -> ARAconfig:
         default_config = ARAconfig()
 
         with open(filepath, "w") as file:
-            json.dump(default_config.model_dump(), file, indent=4)
+            json.dump(default_config.model_dump(mode='json'), file, indent=4)
 
         print(
             f"ara-cli configuration file '{filepath}' created with default configuration. Please modify it as needed and re-run your command"
@@ -113,7 +127,7 @@ def read_data(filepath: str) -> ARAconfig:
 # Function to save the modified configuration back to the JSON file
 def save_data(filepath: str, config: ARAconfig):
     with open(filepath, "w") as file:
-        json.dump(config.dict(), file, indent=4)
+        json.dump(config.model_dump(mode='json'), file, indent=4)
 
 
 # Singleton for configuration management
@@ -129,4 +143,4 @@ class ConfigManager:
                 makedirs(config_dir)
 
             cls._config_instance = read_data(filepath)
-        return cls._config_instance
+        return cls._config_instance

ara_cli/artefact_autofix.py

@@ -1,5 +1,15 @@
+from ara_cli.artefact_fuzzy_search import (
+    find_closest_name_matches,
+    extract_artefact_names_of_classifier,
+)
+from ara_cli.file_classifier import FileClassifier
+from ara_cli.artefact_reader import ArtefactReader
+from ara_cli.artefact_models.artefact_load import artefact_from_content
+from ara_cli.artefact_models.artefact_model import Artefact
+from typing import Optional, Dict, List, Tuple
+import difflib
 import os
-from typing import Dict, List, Tuple
+
 
 def read_report_file():
     file_path = "incompatible_artefacts_report.md"
@@ -7,7 +17,9 @@ def read_report_file():
         with open(file_path, "r", encoding="utf-8") as f:
             content = f.read()
     except OSError:
-        print('Artefact scan results file not found. Did you run the "ara scan" command?')
+        print(
+            'Artefact scan results file not found. Did you run the "ara scan" command?'
+        )
         return None
     return content
 
@@ -23,9 +35,11 @@ def parse_report(content: str) -> Dict[str, List[Tuple[str, str]]]:
 
     if not lines or lines[0] != "# Artefact Check Report":
         return issues
+        return issues
 
     if len(lines) >= 3 and lines[2] == "No problems found.":
         return issues
+        return issues
 
     for line in lines[1:]:
         line = line.strip()
@@ -51,7 +65,7 @@ def parse_report(content: str) -> Dict[str, List[Tuple[str, str]]]:
 def read_artefact(file_path):
     """Reads the artefact text from the given file path."""
     try:
-        with open(file_path, 'r', encoding="utf-8") as file:
+        with open(file_path, "r", encoding="utf-8") as file:
             return file.read()
     except FileNotFoundError:
         print(f"File not found: {file_path}")
@@ -84,7 +98,7 @@ def construct_prompt(artefact_type, reason, file_path, artefact_text):
         "Provide the corrected artefact. Do not reformulate the artefact, "
         "just fix the pydantic model errors, use correct grammar. "
         "You should follow the name of the file "
-        f"from its path {file_path} for naming the arteafact's title. "
+        f"from its path {file_path} for naming the artefact's title. "
         "You are not allowed to use file extention in the artefact title. "
         "You are not allowed to modify, delete or add tags. "
         "User tag should be '@user_<username>'. The pydantic model already provides the '@user_' prefix. "
@@ -97,43 +111,234 @@ def construct_prompt(artefact_type, reason, file_path, artefact_text):
             "then just delete those action items."
         )
 
-    prompt += (
-        "\nThe current artefact is:\n"
-        "```\n"
-        f"{artefact_text}\n"
-        "```"
-    )
+    prompt += "\nThe current artefact is:\n" "```\n" f"{artefact_text}\n" "```"
 
     return prompt
 
 
 def run_agent(prompt, artefact_class):
     from pydantic_ai import Agent
+
     # gpt-4o
     # anthropic:claude-3-7-sonnet-20250219
     # anthropic:claude-4-sonnet-20250514
-    agent = Agent(model="anthropic:claude-4-sonnet-20250514",
-                  result_type=artefact_class, instrument=True)
+    agent = Agent(
+        model="anthropic:claude-4-sonnet-20250514",
+        result_type=artefact_class,
+        instrument=True,
+    )
     result = agent.run_sync(prompt)
     return result.data
 
 
 def write_corrected_artefact(file_path, corrected_text):
-    with open(file_path, 'w', encoding="utf-8") as file:
+    with open(file_path, "w", encoding="utf-8") as file:
         file.write(corrected_text)
     print(f"Fixed artefact at {file_path}")
 
 
-def fix_title_mismatch(file_path: str, artefact_text: str, artefact_class) -> str:
+def ask_for_correct_contribution(
+    artefact_info: Optional[tuple[str, str]] = None
+) -> tuple[str, str]:
+    """
+    Ask the user to provide a valid contribution when no match can be found.
+
+    Args:
+        artefact_info: Optional tuple containing (artefact_name, artefact_classifier)
+
+    Returns:
+        A tuple of (name, classifier) for the contribution
+    """
+
+    artefact_name, artefact_classifier = (
+        artefact_info if artefact_info else (None, None)
+    )
+    contribution_message = (
+        f"of {artefact_classifier} artefact '{artefact_name}'" if artefact_name else ""
+    )
+
+    print(
+        f"Can not determine a match for contribution {contribution_message}. "
+        f"Please provide a valid contribution or contribution will be empty (<classifier> <file_name>)."
+    )
+
+    user_input = input().strip()
+
+    if not user_input:
+        return None, None
+
+    parts = user_input.split(maxsplit=1)
+    if len(parts) != 2:
+        print("Invalid input format. Expected: <classifier> <file_name>")
+        return None, None
+
+    classifier, name = parts
+    return name, classifier
+
+
+def ask_for_contribution_choice(
+    choices, artefact_info: Optional[tuple[str, str]] = None
+) -> Optional[str]:
+    artefact_name, artefact_classifier = artefact_info
+    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): "
+    )
+    try:
+        choice_index = int(choice_number) - 1
+        if choice_index < 0 or choice_index >= len(choices):
+            print("Invalid choice. Aborting contribution choice.")
+            return None
+        choice = choices[choice_index]
+    except ValueError:
+        print("Invalid input. Aborting contribution choice.")
+        return None
+    return choice
+
+
+def _has_valid_contribution(artefact: Artefact) -> bool:
+    contribution = artefact.contribution
+    return contribution and contribution.artefact_name and contribution.classifier
+
+
+def _update_rule(
+    artefact: Artefact, name: str, classifier: str, classified_file_info: dict
+) -> None:
+    """Updates the rule in the contribution if a close match is found."""
+    rule = artefact.contribution.rule
+
+    content, artefact_data = ArtefactReader.read_artefact(
+        artefact_name=name,
+        classifier=classifier,
+        classified_file_info=classified_file_info,
+    )
+
+    parent = artefact_from_content(content=content)
+    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]
+
+
+def _set_contribution_multiple_matches(
+    artefact: Artefact,
+    closest_matches: list,
+    artefact_tuple: tuple,
+    classified_file_info: dict,
+) -> tuple[Artefact, bool]:
+    contribution = artefact.contribution
+    classifier = contribution.classifier
+    original_name = contribution.artefact_name
+
+    closest_match = closest_matches[0]
+    if len(closest_matches) > 1:
+        closest_match = ask_for_contribution_choice(closest_matches, artefact_tuple)
+
+    if not closest_match:
+        print(
+            f"Contribution of {artefact_tuple[1]} '{artefact_tuple[0]}' will be empty."
+        )
+        artefact.contribution = None
+        return artefact, True
+
+    print(
+        f"Updating contribution of {artefact_tuple[1]} '{artefact_tuple[0]}' to {classifier} '{closest_match}'"
+    )
+    contribution.artefact_name = closest_match
+    artefact.contribution = contribution
+
+    if contribution.rule:
+        _update_rule(artefact, original_name, classifier, classified_file_info)
+
+    return artefact, True
+
+
+def set_closest_contribution(
+    artefact: Artefact, classified_file_info=None
+) -> tuple[Artefact, bool]:
+    if not _has_valid_contribution(artefact):
+        return artefact, False
+    contribution = artefact.contribution
+    name = contribution.artefact_name
+    classifier = contribution.classifier
+    rule = contribution.rule
+
+    if not classified_file_info:
+        file_classifier = FileClassifier(os)
+        classified_file_info = file_classifier.classify_files()
+
+    all_artefact_names = extract_artefact_names_of_classifier(
+        classified_files=classified_file_info, classifier=classifier
+    )
+    closest_matches = find_closest_name_matches(
+        artefact_name=name, all_artefact_names=all_artefact_names
+    )
+
+    artefact_tuple = (artefact.title, artefact._artefact_type().value)
+
+    if not closest_matches:
+        name, classifier = ask_for_correct_contribution(artefact_tuple)
+        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}'")
+        contribution.artefact_name = name
+        contribution.classifier = classifier
+        artefact.contribution = contribution
+        return artefact, True
+
+    if closest_matches[0] == name:
+        return artefact, False
+
+    return _set_contribution_multiple_matches(
+        artefact=artefact,
+        closest_matches=closest_matches,
+        artefact_tuple=artefact_tuple,
+        classified_file_info=classified_file_info,
+    )
+
+    print(
+        f"Updating contribution of {artefact._artefact_type().value} '{artefact.title}' to {classifier} '{closest_match}'"
+    )
+    contribution.artefact_name = closest_match
+    artefact.contribution = contribution
+
+    if not rule:
+        return artefact, True
+
+    content, artefact = ArtefactReader.read_artefact(
+        artefact_name=name,
+        classifier=classifier,
+        classified_file_info=classified_file_info,
+    )
+    parent = artefact_from_content(content=content)
+    rules = parent.rules
+
+    closest_rule_match = difflib.get_close_matches(rule, rules, cutoff=0.5)
+    if closest_rule_match:
+        contribution.rule = closest_rule_match
+        artefact.contribution = contribution
+    return artefact, True
+
+
+def fix_title_mismatch(
+    file_path: str, artefact_text: str, artefact_class, **kwargs
+) -> str:
     """
     Deterministically fixes the title in the artefact text to match the filename.
     """
     base_name = os.path.basename(file_path)
     correct_title_underscores, _ = os.path.splitext(base_name)
-    correct_title_spaces = correct_title_underscores.replace('_', ' ')
+    correct_title_spaces = correct_title_underscores.replace("_", " ")
 
     title_prefix = artefact_class._title_prefix()
-    
+
     lines = artefact_text.splitlines()
     new_lines = []
     title_found_and_replaced = False
@@ -144,15 +349,40 @@ def fix_title_mismatch(file_path: str, artefact_text: str, artefact_class) -> st
             title_found_and_replaced = True
         else:
             new_lines.append(line)
-    
+
     if not title_found_and_replaced:
-        print(f"Warning: Title prefix '{title_prefix}' not found in {file_path}. Title could not be fixed.")
+        print(
+            f"Warning: Title prefix '{title_prefix}' not found in {file_path}. Title could not be fixed."
+        )
         return artefact_text
 
     return "\n".join(new_lines)
 
 
-def apply_autofix(file_path: str, classifier: str, reason: str, deterministic: bool, non_deterministic: bool) -> bool:
+def fix_contribution(
+    file_path: str,
+    artefact_text: str,
+    artefact_class: str,
+    classified_artefact_info: dict,
+    **kwargs,
+):
+    if not classified_artefact_info:
+        file_classifier = FileClassifier(os)
+        classified_artefact_info = file_classifier.classify_files()
+    artefact = artefact_class.deserialize(artefact_text)
+    artefact, _ = set_closest_contribution(artefact)
+    artefact_text = artefact.serialize()
+    return artefact_text
+
+
+def apply_autofix(
+    file_path: str,
+    classifier: str,
+    reason: str,
+    deterministic: bool = True,
+    non_deterministic: bool = True,
+    classified_artefact_info: Optional[Dict[str, List[Dict[str, str]]]] = None,
+) -> bool:
     artefact_text = read_artefact(file_path)
     if artefact_text is None:
         return False
@@ -161,11 +391,36 @@ def apply_autofix(file_path: str, classifier: str, reason: str, deterministic: b
     if artefact_type is None or artefact_class is None:
         return False
 
-    is_deterministic_issue = "Filename-Title Mismatch" in reason
+    if classified_artefact_info is None:
+        file_classifier = FileClassifier(os)
+        classified_file_info = file_classifier.classified_files()
+
+    deterministic_markers_to_functions = {
+        "Filename-Title Mismatch": fix_title_mismatch,
+        "Invalid Contribution Reference": fix_contribution,
+    }
+
+    try:
+        deterministic_issue = next(
+            (
+                marker
+                for marker in deterministic_markers_to_functions.keys()
+                if marker in reason
+            ),
+            None,
+        )
+    except StopIteration:
+        pass
+    is_deterministic_issue = deterministic_issue is not None
 
     if deterministic and is_deterministic_issue:
         print(f"Attempting deterministic fix for {file_path}...")
-        corrected_text = fix_title_mismatch(file_path, artefact_text, artefact_class)
+        corrected_text = deterministic_markers_to_functions[deterministic_issue](
+            file_path=file_path,
+            artefact_text=artefact_text,
+            artefact_class=artefact_class,
+            classified_artefact_info=classified_artefact_info,
+        )
         write_corrected_artefact(file_path, corrected_text)
         return True
 
@@ -181,11 +436,11 @@ def apply_autofix(file_path: str, classifier: str, reason: str, deterministic: b
         except Exception as e:
             print(f"LLM agent failed to fix artefact at {file_path}: {e}")
             return False
-    
+
     # Log if a fix was skipped due to flags
     if is_deterministic_issue and not deterministic:
         print(f"Skipping deterministic fix for {file_path} as per request.")
     elif not is_deterministic_issue and not non_deterministic:
         print(f"Skipping non-deterministic fix for {file_path} as per request.")
 
-    return False
+    return False

ara_cli/artefact_fuzzy_search.py

@@ -33,12 +33,17 @@ def suggest_close_name_matches_for_parent(artefact_name: str, all_artefact_names
     )
 
 
-def find_closest_name_match(artefact_name: str, all_artefact_names: list[str]) -> Optional[str]:
-    closest_matches = difflib.get_close_matches(artefact_name, all_artefact_names, cutoff=0.5, n=1)
+def find_closest_name_matches(artefact_name: str, all_artefact_names: list[str]) -> Optional[str]:
+    closest_matches = difflib.get_close_matches(artefact_name, all_artefact_names, cutoff=0.5)
     if not closest_matches:
         return None
-    closest_match = closest_matches[0]
-    return closest_match
+    return closest_matches
+
+
+def extract_artefact_names_of_classifier(classified_files: dict[str, list[dict]], classifier: str):
+    artefact_info_of_classifier = classified_files.get(classifier, [])
+    titles = list(map(lambda artefact: artefact['title'], artefact_info_of_classifier))
+    return titles
 
 
 def find_closest_rule(parent_artefact: 'Artefact', rule: str):

ara_cli/artefact_models/feature_artefact_model.py

@@ -363,27 +363,43 @@ class FeatureArtefact(Artefact):
 
     @classmethod
     def deserialize(cls, text: str) -> 'FeatureArtefact':
-        fields = super()._parse_common_fields(text)
+        """
+        Deserializes the feature file using a robust extract-and-reinject strategy.
+        1. Hides all docstrings by replacing them with placeholders.
+        2. Parses the sanitized text using the original, simple parsing logic.
+        3. Re-injects the original docstring content back into the parsed objects.
+        This prevents the parser from ever being confused by content within docstrings.
+        """
+        # 1. Hide all docstrings from the entire file text first.
+        sanitized_text, docstrings = cls._hide_docstrings(text)
+
+        # 2. Perform the original parsing logic on the SANITIZED text.
+        # This part of the code is now "safe" because it will never see a docstring.
+        fields = super()._parse_common_fields(sanitized_text)
+        intent = FeatureIntent.deserialize(sanitized_text)
+        background = cls.deserialize_background(sanitized_text)
+        scenarios = cls.deserialize_scenarios(sanitized_text)
 
-        intent = FeatureIntent.deserialize(text)
-        background = cls.deserialize_background(text)
-        scenarios = cls.deserialize_scenarios(text)
-
-        fields['scenarios'] = scenarios
-        fields['background'] = background
         fields['intent'] = intent
+        fields['background'] = background
+        fields['scenarios'] = scenarios
+
+        # 3. Re-inject the docstrings back into the parsed scenarios.
+        if fields['scenarios'] and docstrings:
+            for scenario in fields['scenarios']:
+                if isinstance(scenario, (Scenario, ScenarioOutline)):
+                    scenario.steps = cls._reinject_docstrings_into_steps(scenario.steps, docstrings)
 
         return cls(**fields)
 
     @classmethod
     def deserialize_scenarios(cls, text):
-        lines = [line.strip()
-                 for line in text.strip().splitlines() if line.strip()]
-
+        if not text: return []
+        lines = [line.strip() for line in text.strip().splitlines() if line.strip()]
         scenarios = []
         idx = 0
         while idx < len(lines):
-            line = lines[idx].strip()
+            line = lines[idx]
             if line.startswith('Scenario:'):
                 scenario, next_idx = Scenario.from_lines(lines, idx)
                 scenarios.append(scenario)
@@ -398,16 +414,54 @@ class FeatureArtefact(Artefact):
 
     @classmethod
     def deserialize_background(cls, text):
-        lines = [line.strip()
-                 for line in text.strip().splitlines() if line.strip()]
-
+        if not text: return None
+        lines = [line.strip() for line in text.strip().splitlines() if line.strip()]
         background = None
         idx = 0
         while idx < len(lines):
-            line = lines[idx].strip()
+            line = lines[idx]
             if line.startswith('Background:'):
-                background, next_idx = Background.from_lines(lines, idx)
+                background, _ = Background.from_lines(lines, idx)
                 break
-            else:
-                idx += 1
+            idx += 1
         return background
+
+
+    @staticmethod
+    def _hide_docstrings(text: str) -> Tuple[str, Dict[str, str]]:
+        """
+        Finds all docstring blocks ('''...''') in the text,
+        replaces them with a unique placeholder, and returns the sanitized
+        text and a dictionary mapping placeholders to the original docstrings.
+        """
+        docstrings = {}
+        placeholder_template = "__DOCSTRING_PLACEHOLDER_{}__"
+
+        def replacer(match):
+            # This function is called for each found docstring.
+            key = placeholder_template.format(len(docstrings))
+            docstrings[key] = match.group(0)  # Store the full matched docstring
+            return key
+
+        # The regex finds ''' followed by any character (including newlines)
+        # in a non-greedy way (.*?) until the next '''.
+        sanitized_text = re.sub(r'"""[\s\S]*?"""', replacer, text)
+
+        return sanitized_text, docstrings
+
+    @staticmethod
+    def _reinject_docstrings_into_steps(steps: List[str], docstrings: Dict[str, str]) -> List[str]:
+        """
+        Iterates through a list of steps, finds any placeholders,
+        and replaces them with their original docstring content.
+        """
+        rehydrated_steps = []
+        for step in steps:
+            for key, value in docstrings.items():
+                if key in step:
+                    # Replace the placeholder with the original, full docstring block.
+                    # This handles cases where the step is just the placeholder,
+                    # or the placeholder is at the end of a line (e.g., "Then I see... __PLACEHOLDER__").
+                    step = step.replace(key, value)
+            rehydrated_steps.append(step)
+        return rehydrated_steps

ara_cli/artefact_reader.py

@@ -10,13 +10,14 @@ import re
 
 class ArtefactReader:
     @staticmethod
-    def read_artefact(artefact_name, classifier) -> tuple[str, dict[str, str]]:
+    def read_artefact(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
 
-        file_classifier = FileClassifier(os)
-        classified_file_info = file_classifier.classify_files()
+        if not classified_file_info:
+            file_classifier = FileClassifier(os)
+            classified_file_info = file_classifier.classify_files()
         artefact_info_of_classifier = classified_file_info.get(classifier, [])
 
         for artefact_info in artefact_info_of_classifier: