ara-cli 0.1.9.95__py3-none-any.whl → 0.1.10.0__py3-none-any.whl

ara_cli/ara_config.py

@@ -10,6 +10,7 @@ import warnings
 
 DEFAULT_CONFIG_LOCATION = "./ara/.araconfig/ara_config.json"
 
+
 class LLMConfigItem(BaseModel):
     provider: str
     model: str
@@ -17,6 +18,7 @@ class LLMConfigItem(BaseModel):
     max_tokens: Optional[int] = None
     max_completion_tokens: Optional[int] = None
 
+
 class ARAconfig(BaseModel):
     ext_code_dirs: List[Dict[str, str]] = Field(default_factory=lambda: [
         {"source_dir": "./src"},
@@ -28,98 +30,104 @@ class ARAconfig(BaseModel):
     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-5": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-5",
-            temperature=1,
-            max_completion_tokens=16000
-        ),
-        "gpt-5-mini": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-5-mini-2025-08-07",
-            temperature=1
-        ),
-        "gpt-4o": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-4o",
-            temperature=0.8,
-            max_tokens=16000
-        ),
-        "gpt-4.1": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-4.1",
-            temperature=0.8,
-            max_tokens=16000
-        ),
-        "o3-mini": LLMConfigItem(
-            provider="openai",
-            model="openai/o3-mini",
-            temperature=1.0,
-            max_tokens=8000
-        ),
-        "opus-4": LLMConfigItem(
-            provider="anthropic",
-            model="anthropic/claude-opus-4-20250514",
-            temperature=0.5,
-            max_tokens=32000
-        ),
-        "sonnet-4": LLMConfigItem(
-            provider="anthropic",
-            model="anthropic/claude-sonnet-4-20250514",
-            temperature=0.5,
-            max_tokens=32000
-        ),
-        "together-ai-llama-2": LLMConfigItem(
-            provider="together_ai",
-            model="together_ai/togethercomputer/llama-2-70b",
-            temperature=0.8,
-            max_tokens=4000
-        ),
-        "groq-llama-3": LLMConfigItem(
-            provider="groq",
-            model="groq/llama3-70b-8192",
-            temperature=0.8,
-            max_tokens=4000
-        )
-    })
+    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-5": LLMConfigItem(
+                provider="openai",
+                model="openai/gpt-5",
+                temperature=1,
+                max_completion_tokens=16000,
+            ),
+            "gpt-5-mini": LLMConfigItem(
+                provider="openai", model="openai/gpt-5-mini-2025-08-07", temperature=1
+            ),
+            "gpt-4o": LLMConfigItem(
+                provider="openai",
+                model="openai/gpt-4o",
+                temperature=0.8,
+                max_tokens=16000,
+            ),
+            "gpt-4.1": LLMConfigItem(
+                provider="openai",
+                model="openai/gpt-4.1",
+                temperature=0.8,
+                max_tokens=16000,
+            ),
+            "o3-mini": LLMConfigItem(
+                provider="openai",
+                model="openai/o3-mini",
+                temperature=1.0,
+                max_tokens=8000,
+            ),
+            "opus-4": LLMConfigItem(
+                provider="anthropic",
+                model="anthropic/claude-opus-4-20250514",
+                temperature=0.5,
+                max_tokens=32000,
+            ),
+            "sonnet-4": LLMConfigItem(
+                provider="anthropic",
+                model="anthropic/claude-sonnet-4-20250514",
+                temperature=0.5,
+                max_tokens=32000,
+            ),
+            "together-ai-llama-2": LLMConfigItem(
+                provider="together_ai",
+                model="together_ai/togethercomputer/llama-2-70b",
+                temperature=0.8,
+                max_tokens=4000,
+            ),
+            "groq-llama-3": LLMConfigItem(
+                provider="groq",
+                model="groq/llama3-70b-8192",
+                temperature=0.8,
+                max_tokens=4000,
+            ),
+        }
+    )
     default_llm: Optional[str] = None
     extraction_llm: Optional[str] = None
 
-    @model_validator(mode='after')
-    def check_critical_fields(self) -> 'ARAconfig':
+    @model_validator(mode="after")
+    def check_critical_fields(self) -> "ARAconfig":
         """Check for empty critical fields and validate default_llm and extraction_llm."""
         critical_fields = {
-            'ext_code_dirs': [{"source_dir": "./src"}, {"source_dir": "./tests"}],
-            'local_ara_templates_dir': "./ara/.araconfig/templates/",
-            'local_prompt_templates_dir': "./ara/.araconfig",
-            'glossary_dir': "./glossary"
+            "ext_code_dirs": [{"source_dir": "./src"}, {"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:
-                print(f"Warning: Value for '{field}' is missing or empty. Using default.")
+                print(
+                    f"Warning: Value for '{field}' is missing or empty. Using default."
+                )
                 setattr(self, field, default_value)
-        
+
         if not self.llm_config:
-            print("Warning: 'llm_config' is empty. 'default_llm' and 'extraction_llm' cannot be set.")
+            print(
+                "Warning: 'llm_config' is empty. 'default_llm' and 'extraction_llm' cannot be set."
+            )
             self.default_llm = None
             self.extraction_llm = None
             return self
@@ -127,23 +135,34 @@ class ARAconfig(BaseModel):
         first_available_llm = next(iter(self.llm_config))
 
         if not self.default_llm:
-            print(f"Warning: 'default_llm' is not set. Defaulting to the first available model: '{first_available_llm}'.")
+            print(
+                f"Warning: 'default_llm' is not set. Defaulting to the first available model: '{first_available_llm}'."
+            )
             self.default_llm = first_available_llm
         elif self.default_llm not in self.llm_config:
-            print(f"Warning: The configured 'default_llm' ('{self.default_llm}') does not exist in 'llm_config'.")
-            print(f"-> Reverting to the first available model: '{first_available_llm}'.")
+            print(
+                f"Warning: The configured 'default_llm' ('{self.default_llm}') does not exist in 'llm_config'."
+            )
+            print(
+                f"-> Reverting to the first available model: '{first_available_llm}'."
+            )
             self.default_llm = first_available_llm
 
         if not self.extraction_llm:
-            print(f"Warning: 'extraction_llm' is not set. Setting it to the same as 'default_llm': '{self.default_llm}'.")
+            print(
+                f"Warning: 'extraction_llm' is not set. Setting it to the same as 'default_llm': '{self.default_llm}'."
+            )
             self.extraction_llm = self.default_llm
         elif self.extraction_llm not in self.llm_config:
-            print(f"Warning: The configured 'extraction_llm' ('{self.extraction_llm}') does not exist in 'llm_config'.")
+            print(
+                f"Warning: The configured 'extraction_llm' ('{self.extraction_llm}') does not exist in 'llm_config'."
+            )
             print(f"-> Reverting to the 'default_llm' value: '{self.default_llm}'.")
             self.extraction_llm = self.default_llm
-            
+
         return self
 
+
 # Function to ensure the necessary directories exist
 @lru_cache(maxsize=None)
 def ensure_directory_exists(directory: str):
@@ -153,6 +172,7 @@ def ensure_directory_exists(directory: str):
         print(f"New directory created at {directory}")
     return directory
 
+
 def handle_unrecognized_keys(data: dict) -> dict:
     """Removes unrecognized keys from the data and warns the user."""
     known_fields = set(ARAconfig.model_fields.keys())
@@ -211,13 +231,15 @@ def read_data(filepath: str) -> ARAconfig:
         return config
     except ValidationError as e:
         print("--- Configuration Error Detected ---")
-        print("Some settings in your configuration file are invalid. Attempting to fix them.")
-        
+        print(
+            "Some settings in your configuration file are invalid. Attempting to fix them."
+        )
+
         corrected_data = data.copy()
         defaults = ARAconfig().model_dump()
-        
-        error_fields = {err['loc'][0] for err in e.errors() if err['loc']}
-        
+
+        error_fields = {err["loc"][0] for err in e.errors() if err["loc"]}
+
         for field_name in error_fields:
             print(f"-> Field '{field_name}' is invalid and will be reverted to its default value.")
             if field_name in corrected_data:
@@ -228,15 +250,17 @@ def read_data(filepath: str) -> ARAconfig:
         final_config = ARAconfig(**corrected_data)
         save_data(filepath, final_config)
         print(f"Configuration has been corrected and saved to '{filepath}'.")
-        
+
         return final_config
 
+
 # Function to save the modified configuration back to the JSON file
 def save_data(filepath: str, config: ARAconfig):
     """Saves the Pydantic config model to a JSON file."""
     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
@@ -246,9 +270,9 @@ class ConfigManager:
         if cls._config_instance is None:
             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()
+        read_data.cache_clear()

ara_cli/artefact_autofix.py

@@ -1,3 +1,4 @@
+from ara_cli.error_handler import AraError
 from ara_cli.artefact_scan import check_file
 from ara_cli.artefact_fuzzy_search import (
     find_closest_name_matches,
@@ -10,6 +11,7 @@ from ara_cli.artefact_models.artefact_model import Artefact
 from typing import Optional, Dict, List, Tuple
 import difflib
 import os
+import re
 
 
 def populate_classified_artefact_info(
@@ -104,8 +106,9 @@ def determine_artefact_type_and_class(classifier):
 
     artefact_class = artefact_type_mapping.get(artefact_type)
     if not artefact_class:
-        print(f"No artefact class found for {artefact_type}")
-        return None, None
+        raise AraError(f"No artefact class found for {artefact_type}")
+        # print(f"No artefact class found for {artefact_type}")
+        # return None, None
 
     return artefact_type, artefact_class
 
@@ -372,6 +375,131 @@ def set_closest_contribution(
     return artefact, True
 
 
+def fix_scenario_placeholder_mismatch(
+    file_path: str, artefact_text: str, artefact_class, **kwargs
+) -> str:
+    """
+    Converts a regular Scenario with placeholders to a Scenario Outline.
+    This is a deterministic fix that detects placeholders and converts the format.
+    """
+    lines = artefact_text.splitlines()
+    new_lines = []
+    i = 0
+    
+    while i < len(lines):
+        line = lines[i]
+        stripped_line = line.strip()
+        
+        if stripped_line.startswith('Scenario:'):
+            scenario_lines, next_index = _extract_scenario_block(lines, i)
+            processed_lines = _process_scenario_block(scenario_lines)
+            new_lines.extend(processed_lines)
+            i = next_index
+        else:
+            new_lines.append(line)
+            i += 1
+    
+    return "\n".join(new_lines)
+
+
+def _extract_scenario_block(lines: list, start_index: int) -> tuple[list, int]:
+    """Extract all lines belonging to a scenario block."""
+    scenario_lines = [lines[start_index]]
+    j = start_index + 1
+    
+    while j < len(lines):
+        next_line = lines[j].strip()
+        if _is_scenario_boundary(next_line):
+            break
+        scenario_lines.append(lines[j])
+        j += 1
+    
+    return scenario_lines, j
+
+
+def _is_scenario_boundary(line: str) -> bool:
+    """Check if a line marks the boundary of a scenario block."""
+    boundaries = ['Scenario:', 'Scenario Outline:', 'Background:', 'Feature:']
+    return any(line.startswith(boundary) for boundary in boundaries)
+
+
+def _process_scenario_block(scenario_lines: list) -> list:
+    """Process a scenario block and convert to outline if placeholders are found."""
+    if not scenario_lines:
+        return scenario_lines
+    
+    first_line = scenario_lines[0]
+    indentation = _get_line_indentation(first_line)
+    placeholders = _extract_placeholders_from_scenario(scenario_lines[1:])
+    
+    if not placeholders:
+        return scenario_lines
+    
+    return _convert_to_scenario_outline(scenario_lines, placeholders, indentation)
+
+
+def _get_line_indentation(line: str) -> str:
+    """Get the indentation of a line."""
+    return line[:len(line) - len(line.lstrip())]
+
+
+def _extract_placeholders_from_scenario(step_lines: list) -> set:
+    """Extract placeholders from scenario step lines, ignoring docstrings."""
+    placeholders = set()
+    in_docstring = False
+    
+    for line in step_lines:
+        step_line = line.strip()
+        if not step_line:
+            continue
+            
+        in_docstring = _update_docstring_state(step_line, in_docstring)
+        
+        if not in_docstring and '"""' not in step_line:
+            found = re.findall(r'<([^>]+)>', step_line)
+            placeholders.update(found)
+    
+    return placeholders
+
+
+def _update_docstring_state(line: str, current_state: bool) -> bool:
+    """Update the docstring state based on the current line."""
+    if '"""' in line:
+        return not current_state
+    return current_state
+
+
+def _convert_to_scenario_outline(scenario_lines: list, placeholders: set, indentation: str) -> list:
+    """Convert scenario lines to scenario outline format with examples table."""
+    first_line = scenario_lines[0]
+    title = first_line.strip()[len('Scenario:'):].strip()
+    
+    new_lines = [f"{indentation}Scenario Outline: {title}"]
+    new_lines.extend(scenario_lines[1:])
+    new_lines.append("")
+    
+    examples_lines = _create_examples_table(placeholders, indentation)
+    new_lines.extend(examples_lines)
+    
+    return new_lines
+
+
+def _create_examples_table(placeholders: set, base_indentation: str) -> list:
+    """Create the Examples table for the scenario outline."""
+    examples_indentation = base_indentation + "    "
+    table_indentation = examples_indentation + "  "
+    
+    sorted_placeholders = sorted(placeholders)
+    header = "| " + " | ".join(sorted_placeholders) + " |"
+    sample_row = "| " + " | ".join(f"<{p}_value>" for p in sorted_placeholders) + " |"
+    
+    return [
+        f"{examples_indentation}Examples:",
+        f"{table_indentation}{header}",
+        f"{table_indentation}{sample_row}"
+    ]
+
+
 def fix_title_mismatch(
     file_path: str, artefact_text: str, artefact_class, **kwargs
 ) -> str:
@@ -584,6 +712,7 @@ def apply_autofix(
         "Filename-Title Mismatch": fix_title_mismatch,
         "Invalid Contribution Reference": fix_contribution,
         "Rule Mismatch": fix_rule,
+        "Scenario Contains Placeholders": fix_scenario_placeholder_mismatch,
     }
 
     artefact_type, artefact_class = determine_artefact_type_and_class(classifier)

ara_cli/artefact_creator.py

@@ -38,11 +38,9 @@ class ArtefactCreator:
         destination = Path(dir_path) / dest_name
 
         if not source.exists():
-            print("[ERROR] Source file does not exist!")
             raise FileNotFoundError(f"Source file {source} not found!")
 
         if not destination.parent.exists():
-            print("[ERROR] Destination directory does not exist!")
             raise NotADirectoryError(f"Destination directory {destination.parent} does not exist!")
 
         copyfile(source, destination)
@@ -70,9 +68,7 @@ class ArtefactCreator:
     def validate_template(self, template_path, classifier):
         template_name = f"template.{classifier}"
         if not self.template_exists(template_path, template_name):
-            print(f"Template file '{template_name}' not found in the specified template path.")
-            return False
-        return True
+            raise FileNotFoundError(f"Template file '{template_name}' not found in the specified template path.")
 
     def set_artefact_parent(self, artefact, parent_classifier, parent_file_name) -> Artefact:
         classified_artefacts = ArtefactReader.read_artefacts()
@@ -94,8 +90,7 @@ class ArtefactCreator:
         navigator.navigate_to_target()
 
         if not Classifier.is_valid_classifier(classifier):
-            print("Invalid classifier provided. Please provide a valid classifier.")
-            return
+            raise ValueError("Invalid classifier provided. Please provide a valid classifier.")
 
         sub_directory = Classifier.get_sub_directory(classifier)
         file_path = self.file_system.path.join(sub_directory, f"{filename}.{classifier}")

ara_cli/artefact_deleter.py

@@ -20,16 +20,14 @@ class ArtefactDeleter:
         self.navigate_to_target()
 
         if not Classifier.is_valid_classifier(classifier):
-            print("Invalid classifier provided. Please provide a valid classifier.")
-            return
+            raise ValueError("Invalid classifier provided. Please provide a valid classifier.")
 
         sub_directory = Classifier.get_sub_directory(classifier)
         file_path = self.file_system.path.join(sub_directory, f"{filename}.{classifier}")
         dir_path = self.file_system.path.join(sub_directory, f"{filename}.data")
 
         if not self.file_system.path.exists(file_path):
-            print(f"Artefact {file_path} not found.")
-            return
+            raise FileNotFoundError(f"Artefact {file_path} not found.")
         if not force:
             user_choice = input(f"Are you sure you want to delete the file {filename} and data directory if existing? (y/N): ")
 

ara_cli/artefact_fuzzy_search.py

@@ -1,11 +1,16 @@
 import difflib
 from textwrap import indent
 from typing import Optional
+from . import error_handler
+from ara_cli.error_handler import AraError
 
 
-def suggest_close_names(artefact_name: str, all_artefact_names: list[str], message: str, cutoff=0.5):
+def suggest_close_names(artefact_name: str, all_artefact_names: list[str], message: str, cutoff=0.5, report_as_error: bool = False):
     closest_matches = difflib.get_close_matches(artefact_name, all_artefact_names, cutoff=cutoff)
-    print(message)
+    if report_as_error:
+        error_handler.report_error(AraError(message))
+    else:
+        print(message)
     if not closest_matches:
         return
     print("Closest matches:")
@@ -13,23 +18,25 @@ def suggest_close_names(artefact_name: str, all_artefact_names: list[str], messa
         print(f"  - {match}")
 
 
-def suggest_close_name_matches(artefact_name: str, all_artefact_names: list[str]):
+def suggest_close_name_matches(artefact_name: str, all_artefact_names: list[str], report_as_error: bool = False):
     message = f"No match found for artefact with name '{artefact_name}'"
 
     suggest_close_names(
         artefact_name=artefact_name,
         all_artefact_names=all_artefact_names,
-        message=message
+        message=message,
+        report_as_error=report_as_error
     )
 
 
-def suggest_close_name_matches_for_parent(artefact_name: str, all_artefact_names: list[str], parent_name: str):
+def suggest_close_name_matches_for_parent(artefact_name: str, all_artefact_names: list[str], parent_name: str, report_as_error: bool = False):
     message = f"No match found for parent of '{artefact_name}' with name '{parent_name}'"
 
     suggest_close_names(
         artefact_name=parent_name,
         all_artefact_names=all_artefact_names,
-        message=message
+        message=message,
+        report_as_error=report_as_error
     )
 
 

ara_cli/artefact_models/artefact_templates.py

@@ -148,9 +148,9 @@ def _default_feature(title: str, use_default_contribution: bool) -> FeatureArtef
         Scenario(
             title="<descriptive_scenario_title>",
             steps=[
-                "Given <precondition>",
-                "When <action>",
-                "Then <expected result>"
+                "Given [precondition]",
+                "When [action]",
+                "Then [expected result]"
             ],
         ),
         ScenarioOutline(

ara_cli/artefact_models/feature_artefact_model.py

@@ -148,6 +148,30 @@ class Scenario(BaseModel):
             raise ValueError("steps list must not be empty")
         return steps
 
+    @model_validator(mode='after')
+    def check_no_placeholders(cls, values: 'Scenario') -> 'Scenario':
+        """Ensure regular scenarios don't contain placeholders that should be in scenario outlines."""
+        placeholders = set()
+        for step in values.steps:
+            # Skip validation if step contains docstring placeholders (during parsing)
+            if '__DOCSTRING_PLACEHOLDER_' in step:
+                continue
+            
+            # Skip validation if step contains docstring markers (after reinjection)
+            if '"""' in step:
+                continue
+                
+            found = re.findall(r'<([^>]+)>', step)
+            placeholders.update(found)
+        
+        if placeholders:
+            placeholder_list = ', '.join(f"<{p}>" for p in sorted(placeholders))
+            raise ValueError(
+                f"Scenario Contains Placeholders ({placeholder_list}) but is not a Scenario Outline. "
+                f"Use 'Scenario Outline:' instead of 'Scenario:' and provide an Examples table."
+            )
+        return values
+
     @classmethod
     def from_lines(cls, lines: List[str], start_idx: int) -> Tuple['Scenario', int]:
         """Parse a Scenario from a list of lines starting at start_idx."""
@@ -277,6 +301,7 @@ class FeatureArtefact(Artefact):
                 f"FeatureArtefact must have artefact_type of '{ArtefactType.feature}', not '{v}'")
         return v
 
+
     @classmethod
     def _title_prefix(cls) -> str:
         return "Feature:"

ara_cli/artefact_reader.py

@@ -1,3 +1,4 @@
+from . import error_handler
 from ara_cli.classifier import Classifier
 from ara_cli.file_classifier import FileClassifier
 from ara_cli.artefact_models.artefact_model import Artefact
@@ -12,8 +13,7 @@ class ArtefactReader:
     @staticmethod
     def read_artefact_data(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
+            raise ValueError("Invalid classifier provided. Please provide a valid classifier.")
 
         if not classified_file_info:
             file_classifier = FileClassifier(os)
@@ -74,7 +74,6 @@ class ArtefactReader:
 
     @staticmethod
     def read_artefacts(classified_artefacts=None, file_system=os, tags=None) -> Dict[str, List[Artefact]]:
-        from ara_cli.artefact_models.artefact_load import artefact_from_content
 
         if classified_artefacts is None:
             file_classifier = FileClassifier(file_system)
@@ -89,7 +88,7 @@ class ArtefactReader:
                     artefact = ArtefactReader.read_artefact(title, artefact_type, classified_artefacts)
                     artefacts[artefact_type].append(artefact)
                 except Exception as e:
-                    print(f"Failed to read {artefact_type} '{title}' with an error: ", e)
+                    error_handler.report_error(e, f"reading {artefact_type} '{title}'")
                     continue
         return artefacts
 
@@ -143,7 +142,7 @@ class ArtefactReader:
         ArtefactReader._ensure_classifier_key(classifier, artefacts_by_classifier)
 
         artefact = ArtefactReader._find_artefact_by_name(
-            artefact_name, 
+            artefact_name,
             classified_artefacts.get(classifier, [])
         )