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

ara_cli/ara_command_action.py

@@ -33,7 +33,7 @@ def create_action(args):
         if parent_classifier and parent_name and rule:
             check_validity(Classifier.is_valid_classifier(parent_classifier), invalid_classifier_message)
             check_validity(is_valid_filename(parent_name), invalid_name_message)
-            parent_artefact = ArtefactReader.read_single_artefact(artefact_name=parent_name, classifier=parent_classifier)
+            parent_artefact = ArtefactReader.read_artefact(artefact_name=parent_name, classifier=parent_classifier)
             rule = find_closest_rule(parent_artefact, rule)
             return parent_classifier, parent_name, rule
         if parent_classifier and parent_name:
@@ -359,7 +359,7 @@ def reconnect_action(args):
 
     feedback_message = f"Updated contribution of {classifier} '{artefact_name}' to {parent_classifier} '{parent_name}'"
 
-    content, artefact_info = ArtefactReader.read_artefact(
+    content, artefact_info = ArtefactReader.read_artefact_data(
         artefact_name=artefact_name,
         classifier=classifier
     )
@@ -367,7 +367,7 @@ def reconnect_action(args):
         print(read_error_message)
         return
 
-    parent_content, parent_info = ArtefactReader.read_artefact(
+    parent_content, parent_info = ArtefactReader.read_artefact_data(
         artefact_name=parent_name,
         classifier=parent_classifier
     )
@@ -399,7 +399,7 @@ def reconnect_action(args):
             exit(1)
 
     artefact.contribution = contribution
-    with open(artefact.file_path, 'w') as file:
+    with open(artefact.file_path, 'w', encoding='utf-8') as file:
         artefact_content = artefact.serialize()
         file.write(artefact_content)
 
@@ -426,7 +426,7 @@ def read_status_action(args):
         lambda x: x["title"] == artefact_name, artefact_info_dicts
     ))
 
-    with open(artefact_info["file_path"], 'r') as file:
+    with open(artefact_info["file_path"], 'r', encoding='utf-8') as file:
         content = file.read()
     artefact = artefact_from_content(content)
 
@@ -458,7 +458,7 @@ def read_user_action(args):
         lambda x: x["title"] == artefact_name, artefact_info_dicts
     ))
 
-    with open(artefact_info["file_path"], 'r') as file:
+    with open(artefact_info["file_path"], 'r', encoding='utf-8') as file:
         content = file.read()
     artefact = artefact_from_content(content)
 
@@ -500,14 +500,14 @@ def set_status_action(args):
         lambda x: x["title"] == artefact_name, classified_artefact_dict
     ))
 
-    with open(artefact_info["file_path"], 'r') as file:
+    with open(artefact_info["file_path"], 'r', encoding='utf-8') as file:
         content = file.read()
     artefact = artefact_from_content(content)
 
     artefact.status = new_status
 
     serialized_content = artefact.serialize()
-    with open(f"{artefact_info['file_path']}", 'w') as file:
+    with open(f"{artefact_info['file_path']}", 'w', encoding='utf-8') as file:
         file.write(serialized_content)
 
     print(f"Status of task '{artefact_name}' has been updated to '{new_status}'.")
@@ -537,7 +537,7 @@ def set_user_action(args):
         lambda x: x["title"] == artefact_name, classified_artefact_dict
     ))
 
-    with open(artefact_info["file_path"], 'r') as file:
+    with open(artefact_info["file_path"], 'r', encoding='utf-8') as file:
         content = file.read()
     artefact = artefact_from_content(content)
 
@@ -545,7 +545,7 @@ def set_user_action(args):
 
     serialized_content = artefact.serialize()
 
-    with open(artefact_info["file_path"], 'w') as file:
+    with open(artefact_info["file_path"], 'w', encoding='utf-8') as file:
         file.write(serialized_content)
 
     print(f"User of task '{artefact_name}' has been updated to '{new_user}'.")
@@ -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"
 
@@ -86,7 +100,7 @@ def ensure_directory_exists(directory: str):
 
 
 def validate_config_data(filepath: str):
-    with open(filepath, "r") as file:
+    with open(filepath, "r", encoding="utf-8") as file:
         data = json.load(file)
     return data
 
@@ -98,8 +112,8 @@ def read_data(filepath: str) -> ARAconfig:
         # If file does not exist, create it with default values
         default_config = ARAconfig()
 
-        with open(filepath, "w") as file:
-            json.dump(default_config.model_dump(), file, indent=4)
+        with open(filepath, "w", encoding="utf-8") as file:
+            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"
@@ -112,8 +126,8 @@ 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)
+    with open(filepath, "w", encoding="utf-8") as file:
+        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_data(
+        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_data(
+        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_creator.py

@@ -16,7 +16,7 @@ class ArtefactCreator:
 
     @lru_cache(maxsize=None)
     def read_template_content(self, template_file_path):
-        with open(template_file_path, "r") as template_file:
+        with open(template_file_path, "r", encoding="utf-8") as template_file:
             return template_file.read()
 
     def create_artefact_prompt_files(self, dir_path, template_path, classifier):
@@ -118,7 +118,7 @@ class ArtefactCreator:
         artefact_content = artefact.serialize()
         rmtree(dir_path, ignore_errors=True)
         os.makedirs(dir_path, exist_ok=True)
-        with open(file_path, 'w') as artefact_file:
+        with open(file_path, 'w', encoding='utf-8') as artefact_file:
             artefact_file.write(artefact_content)
 
         relative_file_path = os.path.relpath(file_path, original_directory)
@@ -138,7 +138,7 @@ class ArtefactCreator:
 
         title = Classifier.get_artefact_title(classifier)
 
-        with open(file_path, "r") as file:
+        with open(file_path, "r", encoding="utf-8") as file:
             for line in file:
                 if line.strip().startswith(title):
                     return line.split(':')[1].strip()

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