ara-cli 0.1.9.73__tar.gz → 0.1.9.75__tar.gz

{ara_cli-0.1.9.73 → ara_cli-0.1.9.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.9.73
+Version: 0.1.9.75
 Requires-Dist: litellm
 Requires-Dist: llama-index
 Requires-Dist: llama-index-llms-openai

{ara_cli-0.1.9.73 → ara_cli-0.1.9.75}/ara_cli/ara_command_action.py

@@ -347,6 +347,7 @@ def reconnect_action(args):
     from ara_cli.artefact_models.artefact_load import artefact_from_content
     from ara_cli.artefact_models.artefact_model import Contribution
     from ara_cli.artefact_reader import ArtefactReader
+    from ara_cli.file_classifier import FileClassifier
     from ara_cli.artefact_fuzzy_search import find_closest_rule
 
     classifier = args.classifier
@@ -359,31 +360,29 @@ def reconnect_action(args):
 
     feedback_message = f"Updated contribution of {classifier} '{artefact_name}' to {parent_classifier} '{parent_name}'"
 
-    content, artefact_info = ArtefactReader.read_artefact_data(
+    file_classifier = FileClassifier(os)
+    classified_file_info = file_classifier.classify_files()
+
+    artefact = ArtefactReader.read_artefact(
         artefact_name=artefact_name,
-        classifier=classifier
+        classifier=classifier,
+        classified_file_info=classified_file_info
     )
-    if not content:
+
+    if not artefact:
         print(read_error_message)
         return
 
-    parent_content, parent_info = ArtefactReader.read_artefact_data(
+    parent = ArtefactReader.read_artefact(
         artefact_name=parent_name,
-        classifier=parent_classifier
+        classifier=parent_classifier,
+        classified_file_info=classified_file_info
     )
-    if not parent_content:
+
+    if not parent:
         print(read_error_message)
         return
 
-    artefact = artefact_from_content(
-        content=content,
-    )
-    artefact._file_path = artefact_info["file_path"]
-
-    parent = artefact_from_content(
-        content=parent_content
-    )
-
     contribution = Contribution(
         artefact_name=parent.title,
         classifier=parent.artefact_type
@@ -603,6 +602,7 @@ def autofix_action(args):
                 file_path,
                 classifier,
                 reason,
+                single_pass=args.single_pass,
                 deterministic=run_deterministic,
                 non_deterministic=run_non_deterministic,
                 classified_artefact_info=classified_artefact_info

{ara_cli-0.1.9.73 → ara_cli-0.1.9.75}/ara_cli/ara_command_parser.py

@@ -229,7 +229,8 @@ def scan_parser(subparsers):
 
 
 def autofix_parser(subparsers):
-    autofix_parser = subparsers.add_parser("autofix", help="Fix ARA tree with llm models for scanned artefacts with ara scan command.")
+    autofix_parser = subparsers.add_parser("autofix", help="Fix ARA tree with llm models for scanned artefacts with ara scan command. By default three attemps for every file.")
+    autofix_parser.add_argument("--single-pass", action="store_true", help="Run the autofix once for every scaned file.")
     determinism_group = autofix_parser.add_mutually_exclusive_group()
     determinism_group.add_argument("--deterministic", "-d", action="store_true", help="Run only deterministic fixes e.g Title-FileName Mismatch fix")
     determinism_group.add_argument("--non-deterministic", "-nd", action="store_true", help="Run only non-deterministic fixes")

ara_cli-0.1.9.75/ara_cli/ara_config.py

@@ -0,0 +1,254 @@
+from typing import List, Dict, Optional, Any
+from pydantic import BaseModel, ValidationError, Field, field_validator, model_validator
+import json
+import os
+from os.path import exists, dirname
+from os import makedirs
+from functools import lru_cache
+import sys
+
+DEFAULT_CONFIG_LOCATION = "./ara/.araconfig/ara_config.json"
+
+class LLMConfigItem(BaseModel):
+    provider: str
+    model: str
+    temperature: float = Field(ge=0.0, le=1.0)
+    max_tokens: Optional[int] = None
+    
+    @field_validator('temperature')
+    @classmethod
+    def validate_temperature(cls, v: float, info) -> float:
+        if not 0.0 <= v <= 1.0:
+            print(f"Warning: Temperature is outside the 0.0 to 1.0 range")
+            # Return a valid default
+            return 0.8
+        return v
+
+class ExtCodeDirItem(BaseModel):
+    source_dir: str
+
+class ARAconfig(BaseModel):
+    ext_code_dirs: List[ExtCodeDirItem] = Field(default_factory=lambda: [
+        ExtCodeDirItem(source_dir="./src"),
+        ExtCodeDirItem(source_dir="./tests")
+    ])
+    glossary_dir: str = "./glossary"
+    doc_dir: str = "./docs"
+    local_prompt_templates_dir: str = "./ara/.araconfig"
+    custom_prompt_templates_subdir: Optional[str] = "custom-prompt-modules"
+    local_ara_templates_dir: str = "./ara/.araconfig/templates/"
+    ara_prompt_given_list_includes: List[str] = Field(default_factory=lambda: [
+        "*.businessgoal",
+        "*.vision",
+        "*.capability",
+        "*.keyfeature",
+        "*.epic",
+        "*.userstory",
+        "*.example",
+        "*.feature",
+        "*.task",
+        "*.py",
+        "*.md",
+        "*.png",
+        "*.jpg",
+        "*.jpeg",
+    ])
+    llm_config: Dict[str, LLMConfigItem] = Field(default_factory=lambda: {
+        "gpt-4o": LLMConfigItem(
+            provider="openai",
+            model="openai/gpt-4o",
+            temperature=0.8,
+            max_tokens=16384
+        ),
+        "gpt-4.1": LLMConfigItem(
+            provider="openai",
+            model="openai/gpt-4.1",
+            temperature=0.8,
+            max_tokens=1024
+        ),
+        "o3-mini": LLMConfigItem(
+            provider="openai",
+            model="openai/o3-mini",
+            temperature=1.0,
+            max_tokens=1024
+        ),
+        "opus-4": LLMConfigItem(
+            provider="anthropic",
+            model="anthropic/claude-opus-4-20250514",
+            temperature=0.8,
+            max_tokens=32000
+        ),
+        "sonnet-4": LLMConfigItem(
+            provider="anthropic",
+            model="anthropic/claude-sonnet-4-20250514",
+            temperature=0.8,
+            max_tokens=1024
+        ),
+        "together-ai-llama-2": LLMConfigItem(
+            provider="together_ai",
+            model="together_ai/togethercomputer/llama-2-70b",
+            temperature=0.8,
+            max_tokens=1024
+        ),
+        "groq-llama-3": LLMConfigItem(
+            provider="groq",
+            model="groq/llama3-70b-8192",
+            temperature=0.8,
+            max_tokens=1024
+        )
+    })
+    default_llm: Optional[str] = "gpt-4o"
+    
+    model_config = {
+        "extra": "forbid"  # This will help identify unrecognized keys
+    }
+
+    @model_validator(mode='after')
+    def check_critical_fields(self) -> 'ARAconfig':
+        """Check for empty critical fields and use defaults if needed"""
+        critical_fields = {
+            'ext_code_dirs': [ExtCodeDirItem(source_dir="./src"), ExtCodeDirItem(source_dir="./tests")],
+            'local_ara_templates_dir': "./ara/.araconfig/templates/",
+            'local_prompt_templates_dir': "./ara/.araconfig",
+            'glossary_dir': "./glossary"
+        }
+        
+        for field, default_value in critical_fields.items():
+            current_value = getattr(self, field)
+            if (not current_value or 
+                (isinstance(current_value, list) and len(current_value) == 0) or
+                (isinstance(current_value, str) and current_value.strip() == "")):
+                print(f"Warning: Value for '{field}' is missing or empty.")
+                setattr(self, field, default_value)
+        
+        return self
+
+# Function to ensure the necessary directories exist
+@lru_cache(maxsize=None)
+def ensure_directory_exists(directory: str):
+    if not exists(directory):
+        os.makedirs(directory)
+        print(f"New directory created at {directory}")
+    return directory
+
+def handle_unrecognized_keys(data: dict, known_fields: set) -> dict:
+    """Remove unrecognized keys and warn the user"""
+    cleaned_data = {}
+    for key, value in data.items():
+        if key not in known_fields:
+            print(f"Warning: {key} is not recognized as a valid configuration option.")
+        else:
+            cleaned_data[key] = value
+    return cleaned_data
+
+def fix_llm_temperatures(data: dict) -> dict:
+    """Fix invalid temperatures in LLM configurations"""
+    if 'llm_config' in data:
+        for model_key, model_config in data['llm_config'].items():
+            if isinstance(model_config, dict) and 'temperature' in model_config:
+                temp = model_config['temperature']
+                if not 0.0 <= temp <= 1.0:
+                    print(f"Warning: Temperature for model '{model_key}' is outside the 0.0 to 1.0 range")
+                    model_config['temperature'] = 0.8
+    return data
+
+def validate_and_fix_config_data(filepath: str) -> dict:
+    """Load, validate, and fix configuration data"""
+    try:
+        with open(filepath, "r", encoding="utf-8") as file:
+            data = json.load(file)
+        
+        # Get known fields from the ARAconfig model
+        known_fields = set(ARAconfig.model_fields.keys())
+        
+        # Handle unrecognized keys
+        data = handle_unrecognized_keys(data, known_fields)
+        
+        # Fix LLM temperatures before validation
+        data = fix_llm_temperatures(data)
+        
+        return data
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in configuration file: {e}")
+        print("Creating new configuration with defaults...")
+        return {}
+    except Exception as e:
+        print(f"Error reading configuration file: {e}")
+        return {}
+
+# Function to read the JSON file and return an ARAconfig model
+@lru_cache(maxsize=1)
+def read_data(filepath: str) -> ARAconfig:
+    # Ensure the directory for the config file exists
+    config_dir = dirname(filepath)
+    ensure_directory_exists(config_dir)
+
+    if not exists(filepath):
+        # If the file does not exist, create it with default values
+        default_config = ARAconfig()
+        save_data(filepath, default_config)
+        print(
+            f"ara-cli configuration file '{filepath}' created with default configuration."
+            f" Please modify it as needed and re-run your command"
+        )
+        sys.exit(0)  # Exit the application
+
+    # Validate and load the existing configuration
+    data = validate_and_fix_config_data(filepath)
+    
+    try:
+        # Try to create the config with the loaded data
+        config = ARAconfig(**data)
+        
+        # Save the potentially fixed configuration back
+        save_data(filepath, config)
+        
+        return config
+    except ValidationError as e:
+        print(f"ValidationError: {e}")
+        print("Correcting configuration with default values...")
+        
+        # Create a default config
+        default_config = ARAconfig()
+        
+        # Try to preserve valid fields from the original data
+        for field_name, field_value in data.items():
+            if field_name in ARAconfig.model_fields:
+                try:
+                    # Attempt to set the field value
+                    setattr(default_config, field_name, field_value)
+                except:
+                    # If it fails, keep the default
+                    pass
+        
+        # Save the corrected configuration
+        save_data(filepath, default_config)
+        print("Fixed configuration saved to file.")
+        
+        return default_config
+
+# Function to save the modified configuration back to the JSON file
+def save_data(filepath: str, config: ARAconfig):
+    with open(filepath, "w", encoding="utf-8") as file:
+        json.dump(config.model_dump(), file, indent=4)
+
+# Singleton for configuration management
+class ConfigManager:
+    _config_instance = None
+
+    @classmethod
+    def get_config(cls, filepath=DEFAULT_CONFIG_LOCATION):
+        if cls._config_instance is None:
+            config_dir = dirname(filepath)
+
+            if not exists(config_dir):
+                makedirs(config_dir)
+
+            cls._config_instance = read_data(filepath)
+        return cls._config_instance
+    
+    @classmethod
+    def reset(cls):
+        """Reset the configuration instance (useful for testing)"""
+        cls._config_instance = None
+        read_data.cache_clear()

{ara_cli-0.1.9.73 → ara_cli-0.1.9.75}/ara_cli/artefact_autofix.py

@@ -1,3 +1,4 @@
+from ara_cli.artefact_scan import check_file
 from ara_cli.artefact_fuzzy_search import (
     find_closest_name_matches,
     extract_artefact_names_of_classifier,
@@ -29,36 +30,45 @@ 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"
+
+    def has_no_problems(lines: List[str]) -> bool:
+        return len(lines) >= 3 and lines[2] == "No problems found."
+
+    def parse_classifier(line: str) -> Optional[str]:
+        if line.startswith("## "):
+            return line[3:].strip()
+        return None
+
+    def parse_issue(line: str) -> Optional[Tuple[str, str]]:
+        if not line.startswith("- "):
+            return None
+        parts = line.split("`", 2)
+        if len(parts) < 3:
+            return None
+        file_path = parts[1]
+        reason = parts[2].split(":", 1)[1].strip() if ":" in parts[2] else ""
+        return file_path, reason
+
     lines = content.splitlines()
+    if not is_valid_report(lines) or has_no_problems(lines):
+        return {}
+
     issues = {}
     current_classifier = None
 
-    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()
+    for line in map(str.strip, lines[1:]):
         if not line:
             continue
-
-        if line.startswith("## "):
-            current_classifier = line[3:].strip()
+        classifier = parse_classifier(line)
+        if classifier is not None:
+            current_classifier = classifier
             issues[current_classifier] = []
-
-        elif line.startswith("- ") and current_classifier is not None:
-            parts = line.split("`", 2)
-            if len(parts) < 3:
-                continue
-
-            file_path = parts[1]
-            reason = parts[2].split(":", 1)[1].strip() if ":" in parts[2] else ""
-            issues[current_classifier].append((file_path, reason))
-
+            continue
+        issue = parse_issue(line)
+        if issue and current_classifier is not None:
+            issues[current_classifier].append(issue)
     return issues
 
 
@@ -159,7 +169,7 @@ def ask_for_correct_contribution(
 
     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>)."
+        f"Please provide a valid contribution or contribution will be empty ([classifier] [file_name])."
     )
 
     user_input = input().strip()
@@ -179,7 +189,9 @@ def ask_for_correct_contribution(
 def ask_for_contribution_choice(
     choices, artefact_info: Optional[tuple[str, str]] = None
 ) -> Optional[str]:
-    artefact_name, artefact_classifier = artefact_info
+    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}'"
@@ -379,68 +391,118 @@ 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:
-    artefact_text = read_artefact(file_path)
-    if artefact_text is None:
+    """
+    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,
+    }
+
+    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
 
     artefact_type, artefact_class = determine_artefact_type_and_class(classifier)
     if artefact_type is None or artefact_class is None:
         return False
 
-    if classified_artefact_info is None:
-        file_classifier = FileClassifier(os)
-        classified_file_info = file_classifier.classified_files()
+    populate_classified_artefact_info()
+    max_attempts = determine_attempt_count()
 
-    deterministic_markers_to_functions = {
-        "Filename-Title Mismatch": fix_title_mismatch,
-        "Invalid Contribution Reference": fix_contribution,
-    }
+    for attempt in range(max_attempts):
+        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"   Reason: {current_reason}")
+
+        artefact_text = read_artefact(file_path)
+        if artefact_text is None:
+            return False
 
-    try:
         deterministic_issue = next(
             (
                 marker
-                for marker in deterministic_markers_to_functions.keys()
-                if marker in reason
+                for marker in deterministic_markers_to_functions
+                if marker in current_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 = 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
-
-    # Attempt non-deterministic fix if requested and the issue is NOT deterministic
-    if non_deterministic and not is_deterministic_issue:
-        print(f"Attempting non-deterministic (LLM) fix for {file_path}...")
-        prompt = construct_prompt(artefact_type, reason, file_path, artefact_text)
-        try:
-            corrected_artefact = run_agent(prompt, artefact_class)
-            corrected_text = corrected_artefact.serialize()
-            write_corrected_artefact(file_path, corrected_text)
-            return True
-        except Exception as e:
-            print(f"LLM agent failed to fix artefact at {file_path}: {e}")
+
+        if should_skip():
             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.")
+        corrected_text = None
+
+        corrected_text = apply_deterministic_fix()
+        corrected_text = apply_non_deterministic_fix()
+
+        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.")
+            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)
 
+    print(f"❌ Failed to fix {file_path} after {max_attempts} attempts.")
     return False

{ara_cli-0.1.9.73 → ara_cli-0.1.9.75}/ara_cli/artefact_creator.py

@@ -106,7 +106,7 @@ class ArtefactCreator:
         if not self.handle_existing_files(file_exists):
             return
 
-        artefact = template_artefact_of_type(classifier, filename)
+        artefact = template_artefact_of_type(classifier, filename, False)
 
         if parent_classifier and parent_name:
             artefact.set_contribution(

{ara_cli-0.1.9.73 → ara_cli-0.1.9.75}/ara_cli/artefact_models/artefact_model.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, Field, field_validator, model_validator
-from typing import Optional, List, Literal, Union, Dict
+from typing import Optional, List, Literal, Union, Dict, ClassVar
 from typing_extensions import Self
 from enum import Enum
 from abc import ABC, abstractmethod
@@ -47,13 +47,23 @@ class Contribution(BaseModel):
         description="Rule the contribution is using. The classifier of the parent must be userstory or epic if this is used"
     )
 
+    PLACEHOLDER_NAME: ClassVar[str] = "<filename or title of the artefact>"
+    PLACEHOLDER_CLASSIFIER: ClassVar[str] = "<agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules)"
+    PLACEHOLDER_RULE: ClassVar[str] = "<rule as it is formulated>"
+
     @model_validator(mode="after")
     def validate_parent(self) -> Self:
-
         artefact_name = self.artefact_name
         classifier = self.classifier
         rule = self.rule
 
+        if (
+            artefact_name == Contribution.PLACEHOLDER_NAME
+            or classifier == Contribution.PLACEHOLDER_CLASSIFIER
+            or rule == Contribution.PLACEHOLDER_RULE
+        ):
+            return self
+
         if artefact_name:
             artefact_name = replace_space_with_underscore(artefact_name)
         if not artefact_name or not classifier:
@@ -68,7 +78,7 @@ class Contribution(BaseModel):
 
     @field_validator('artefact_name')
     def validate_artefact_name(cls, value):
-        if not value:
+        if not value or value == Contribution.PLACEHOLDER_NAME:
             return value
         if ' ' in value:
             warnings.warn(message="artefact_name can not contain spaces. Replacing spaces with '_'")
@@ -77,7 +87,7 @@ class Contribution(BaseModel):
 
     @field_validator('classifier', mode='after')
     def validate_classifier(cls, v):
-        if not v:
+        if not v or v == Contribution.PLACEHOLDER_CLASSIFIER:
             return v
         try:
             return ArtefactType(v)
@@ -91,12 +101,21 @@ class Contribution(BaseModel):
         if not line.startswith(contribution_line_start):
             raise ValueError(f"Contribution line '{line}' does not start with '{contribution_line_start}'")
 
+        parent_text = line[len(contribution_line_start):].strip()
+        rule_specifier = " using rule "
+
+        placeholder_line = f"{cls.PLACEHOLDER_NAME} {cls.PLACEHOLDER_CLASSIFIER}{rule_specifier}{cls.PLACEHOLDER_RULE}"
+        if parent_text == placeholder_line:
+            return cls(
+                artefact_name=cls.PLACEHOLDER_NAME,
+                classifier=cls.PLACEHOLDER_CLASSIFIER,
+                rule=cls.PLACEHOLDER_RULE
+            )
+
         artefact_name = None
         classifier = None
         rule = None
 
-        parent_text = line[len(contribution_line_start):].strip()
-        rule_specifier = " using rule "
         if rule_specifier in parent_text:
             parent_text, rule_text = parent_text.split(rule_specifier, 1)
             rule = rule_text
@@ -113,7 +132,7 @@ class Contribution(BaseModel):
     def serialize(self) -> str:
         if not self.classifier or not self.artefact_name:
             return ""
-        artefact_type = Classifier.get_artefact_title(self.classifier)
+        artefact_type = Classifier.get_artefact_title(self.classifier) or self.classifier
         artefact_name = replace_underscore_with_space(self.artefact_name)
         contribution = f"{artefact_name} {artefact_type}"
         if self.rule: