ara-cli 0.1.9.94__py3-none-any.whl → 0.1.9.96__py3-none-any.whl

ara_cli/__init__.py

@@ -1,3 +1,20 @@
-from .version import __version__
+import warnings
+from .error_handler import ErrorHandler
+
 
 whitelisted_commands = ["RERUN", "SEND", "EXTRACT", "LOAD_IMAGE", "CHOOSE_MODEL", "CHOOSE_EXTRACTION_MODEL", "CURRENT_MODEL", "CURRENT_EXTRACTION_MODEL", "LIST_MODELS"]
+
+
+error_handler = ErrorHandler()
+
+
+# ANSI escape codes for coloring
+YELLOW = '\033[93m'
+RESET = '\033[0m'
+
+
+def format_warning(message, category, *args, **kwargs):
+    return f'{YELLOW}{category.__name__}: {message}{RESET}\n'
+
+
+warnings.formatwarning = format_warning

ara_cli/__main__.py

@@ -1,5 +1,6 @@
 # PYTHON_ARGCOMPLETE_OK
 from ara_cli.ara_command_parser import action_parser
+from ara_cli.error_handler import AraError
 from ara_cli.version import __version__
 from ara_cli.ara_command_action import (
     create_action,
@@ -22,8 +23,10 @@ from ara_cli.ara_command_action import (
     autofix_action,
     extract_action
 )
+from . import error_handler
 import argcomplete
 import sys
+from os import getenv
 
 
 def define_action_mapping():
@@ -51,31 +54,74 @@ def define_action_mapping():
 
 
 def handle_invalid_action(args):
-    sys.exit("Invalid action provided. Type ara -h for help")
+    raise AraError("Invalid action provided. Type ara -h for help", error_code=1)
 
 
-def cli():
-    parser = action_parser()
+def is_debug_mode_enabled():
+    """Check if debug mode is enabled via environment variable."""
+    return getenv('ARA_DEBUG', '').lower() in ('1', 'true', 'yes')
 
+
+def setup_parser():
+    """Create and configure the argument parser."""
+    parser = action_parser()
+    
     # Show examples when help is called
     if any(arg in sys.argv for arg in ["-h", "--help"]):
         parser.add_examples = True
-
+    
     parser.add_argument(
         "-v", "--version", action="version", version=f"%(prog)s {__version__}"
     )
+    
+    parser.add_argument(
+        "--debug", action="store_true", help="Enable debug mode for detailed error output"
+    )
+    
+    return parser
 
-    action_mapping = define_action_mapping()
 
-    argcomplete.autocomplete(parser)
+def configure_debug_mode(args, env_debug_mode):
+    """Configure debug mode based on arguments and environment."""
+    if (hasattr(args, 'debug') and args.debug) or env_debug_mode:
+        error_handler.debug_mode = True
 
-    args = parser.parse_args()
-    if not hasattr(args, "action") or not args.action:
-        parser.print_help()
-        return
+
+def should_show_help(args):
+    """Check if help should be displayed."""
+    return not hasattr(args, "action") or not args.action
+
+
+def execute_action(args, action_mapping):
+    """Execute the specified action."""
     action = action_mapping.get(args.action, handle_invalid_action)
     action(args)
 
 
+def cli():
+    debug_mode = is_debug_mode_enabled()
+    
+    try:
+        parser = setup_parser()
+        action_mapping = define_action_mapping()
+        
+        argcomplete.autocomplete(parser)
+        args = parser.parse_args()
+        
+        configure_debug_mode(args, debug_mode)
+        
+        if should_show_help(args):
+            parser.print_help()
+            return
+            
+        execute_action(args, action_mapping)
+        
+    except KeyboardInterrupt:
+        print("\n[INFO] Operation cancelled by user", file=sys.stderr)
+        sys.exit(130)  # Standard exit code for Ctrl+C
+    except Exception as e:
+        error_handler.handle_error(e, context="cli")
+
+
 if __name__ == "__main__":
-    cli()
+    cli()

ara_cli/ara_command_action.py

@@ -2,17 +2,19 @@ from os.path import join
 import os
 import sys
 import json
+from ara_cli.error_handler import AraError
+from ara_cli.error_handler import handle_errors, AraValidationError
 from ara_cli.output_suppressor import suppress_stdout
 from ara_cli.artefact_fuzzy_search import suggest_close_name_matches
-from . import whitelisted_commands
+from . import whitelisted_commands, error_handler
 
 
 def check_validity(condition, error_message):
     if not condition:
-        print(error_message)
-        sys.exit(1)
+        raise AraValidationError(error_message)
 
 
+@handle_errors(context="create action", error_handler=error_handler)
 def create_action(args):
     from ara_cli.artefact_creator import ArtefactCreator
     from ara_cli.classifier import Classifier
@@ -62,6 +64,7 @@ def create_action(args):
     artefact_creator.run(args.parameter, args.classifier, parent_classifier, parent_name, rule)
 
 
+@handle_errors(context="delete action", error_handler=error_handler)
 def delete_action(args):
     from ara_cli.artefact_deleter import ArtefactDeleter
 
@@ -69,6 +72,7 @@ def delete_action(args):
     artefact_deleter.delete(args.parameter, args.classifier, args.force)
 
 
+@handle_errors(context="rename action", error_handler=error_handler)
 def rename_action(args):
     from ara_cli.artefact_renamer import ArtefactRenamer
     from ara_cli.classifier import Classifier
@@ -82,6 +86,7 @@ def rename_action(args):
     artefact_renamer.rename(args.parameter, args.aspect, args.classifier)
 
 
+@handle_errors(context="rename action", error_handler=error_handler)
 def list_action(args):
     from ara_cli.artefact_lister import ArtefactLister
     from ara_cli.list_filter import ListFilter
@@ -131,6 +136,7 @@ def list_action(args):
     artefact_lister.list_files(list_filter=list_filter)
 
 
+@handle_errors(context="list-tags action", error_handler=error_handler)
 def list_tags_action(args):
     from ara_cli.tag_extractor import TagExtractor
     from ara_cli.list_filter import ListFilter
@@ -155,6 +161,7 @@ def list_tags_action(args):
     print(output)
 
 
+@handle_errors(context="prompt action", error_handler=error_handler)
 def prompt_action(args):
     from ara_cli.classifier import Classifier
     from ara_cli.filename_validator import is_valid_filename
@@ -227,6 +234,7 @@ def prompt_action(args):
         raise ValueError(f"Unknown command '{init}' provided.")
 
 
+@handle_errors(context="chat action", error_handler=error_handler)
 def chat_action(args):
     from ara_cli.chat import Chat
 
@@ -253,6 +261,7 @@ def chat_action(args):
     chat.start()
 
 
+@handle_errors(context="template action", error_handler=error_handler)
 def template_action(args):
     from ara_cli.classifier import Classifier
     from ara_cli.template_manager import TemplatePathManager
@@ -265,6 +274,7 @@ def template_action(args):
     print(content)
 
 
+@handle_errors(context="fetch-templates action", error_handler=error_handler)
 def fetch_templates_action(args):
     import shutil
     from ara_cli.ara_config import ConfigManager
@@ -294,6 +304,7 @@ def fetch_templates_action(args):
         os.makedirs(join(local_prompt_modules_dir, subdir), exist_ok=True)
 
 
+@handle_errors(context="read action", error_handler=error_handler)
 def read_action(args):
     from ara_cli.commands.read_command import ReadCommand
     from ara_cli.list_filter import ListFilter
@@ -321,6 +332,7 @@ def read_action(args):
     command.execute()
 
 
+@handle_errors(context="reconnect action", error_handler=error_handler)
 def reconnect_action(args):
     from ara_cli.artefact_models.artefact_load import artefact_from_content
     from ara_cli.artefact_models.artefact_model import Contribution
@@ -348,8 +360,7 @@ def reconnect_action(args):
     )
 
     if not artefact:
-        print(read_error_message)
-        return
+        raise AraError(read_error_message)
 
     parent = ArtefactReader.read_artefact(
         artefact_name=parent_name,
@@ -358,8 +369,7 @@ def reconnect_action(args):
     )
 
     if not parent:
-        print(read_error_message)
-        return
+        raise AraError(read_error_message)
 
     contribution = Contribution(
         artefact_name=parent.title,
@@ -367,13 +377,9 @@ def reconnect_action(args):
     )
 
     if rule:
-        try:
-            closest_rule = find_closest_rule(parent, rule)
-            contribution.rule = closest_rule
-            feedback_message += f" using rule '{closest_rule}'"
-        except TypeError as e:
-            print(f"{type(e).__name__}:", e)
-            exit(1)
+        closest_rule = find_closest_rule(parent, rule)
+        contribution.rule = closest_rule
+        feedback_message += f" using rule '{closest_rule}'"
 
     artefact.contribution = contribution
     with open(artefact.file_path, 'w', encoding='utf-8') as file:
@@ -383,6 +389,7 @@ def reconnect_action(args):
     print(feedback_message + ".")
 
 
+@handle_errors(context="read-status action", error_handler=error_handler)
 def read_status_action(args):
     from ara_cli.file_classifier import FileClassifier
     from ara_cli.artefact_models.artefact_load import artefact_from_content
@@ -396,7 +403,7 @@ def read_status_action(args):
 
     all_artefact_names = [artefact_info["title"] for artefact_info in artefact_info_dicts]
     if artefact_name not in all_artefact_names:
-        suggest_close_name_matches(artefact_name, all_artefact_names)
+        suggest_close_name_matches(artefact_name, all_artefact_names, report_as_error=True)
         return
 
     artefact_info = next(filter(
@@ -415,6 +422,7 @@ def read_status_action(args):
     print(status)
 
 
+@handle_errors(context="read-user action", error_handler=error_handler)
 def read_user_action(args):
     from ara_cli.artefact_models.artefact_load import artefact_from_content
     from ara_cli.file_classifier import FileClassifier
@@ -428,7 +436,7 @@ def read_user_action(args):
 
     all_artefact_names = [artefact_info["title"] for artefact_info in artefact_info_dicts]
     if artefact_name not in all_artefact_names:
-        suggest_close_name_matches(artefact_name, all_artefact_names)
+        suggest_close_name_matches(artefact_name, all_artefact_names, report_as_error=True)
         return
 
     artefact_info = next(filter(
@@ -448,6 +456,7 @@ def read_user_action(args):
         print(f" - {tag}")
 
 
+@handle_errors(context="set-status action", error_handler=error_handler)
 def set_status_action(args):
     from ara_cli.artefact_models.artefact_model import ALLOWED_STATUS_VALUES
     from ara_cli.artefact_models.artefact_load import artefact_from_content
@@ -490,6 +499,7 @@ def set_status_action(args):
     print(f"Status of task '{artefact_name}' has been updated to '{new_status}'.")
 
 
+@handle_errors(context="set-user action", error_handler=error_handler)
 def set_user_action(args):
     from ara_cli.file_classifier import FileClassifier
     from ara_cli.artefact_models.artefact_load import artefact_from_content
@@ -528,6 +538,7 @@ def set_user_action(args):
     print(f"User of task '{artefact_name}' has been updated to '{new_user}'.")
 
 
+@handle_errors(context="classifier-directory action", error_handler=error_handler)
 def classifier_directory_action(args):
     from ara_cli.classifier import Classifier
 
@@ -536,6 +547,7 @@ def classifier_directory_action(args):
     print(subdirectory)
 
 
+@handle_errors(context="scan action", error_handler=error_handler)
 def scan_action(args):
     from ara_cli.file_classifier import FileClassifier
     from ara_cli.artefact_scan import find_invalid_files, show_results
@@ -550,6 +562,7 @@ def scan_action(args):
     show_results(invalid_artefacts)
 
 
+@handle_errors(context="autofix_action", error_handler=error_handler)
 def autofix_action(args):
     from ara_cli.artefact_autofix import parse_report, apply_autofix, read_report_file
     from ara_cli.file_classifier import FileClassifier
@@ -589,18 +602,17 @@ def autofix_action(args):
     print("\nAutofix process completed. Please review the changes.")
 
 
+@handle_errors(context="extract action", error_handler=error_handler)
 def extract_action(args):
     from ara_cli.commands.extract_command import ExtractCommand
 
     filename = args.filename
     force = args.force
     write = getattr(args, 'write', False)
-    print(filename)
     command = ExtractCommand(
         file_name=filename,
         force=force,
         write=write,
-        output=lambda msg: print(msg, file=sys.stdout),
-        error_output=lambda msg: print(msg, file=sys.stderr)
+        output=lambda msg: print(msg, file=sys.stdout)
     )
     command.execute()

ara_cli/ara_config.py

@@ -6,6 +6,7 @@ from os.path import exists, dirname
 from os import makedirs
 from functools import lru_cache
 import sys
+import warnings
 
 DEFAULT_CONFIG_LOCATION = "./ara/.araconfig/ara_config.json"
 
@@ -21,6 +22,7 @@ class ARAconfig(BaseModel):
         {"source_dir": "./src"},
         {"source_dir": "./tests"}
     ])
+    global_dirs: Optional[List[Dict[str, str]]] = Field(default=[])
     glossary_dir: str = "./glossary"
     doc_dir: str = "./docs"
     local_prompt_templates_dir: str = "./ara/.araconfig"
@@ -162,6 +164,7 @@ def handle_unrecognized_keys(data: dict) -> dict:
             cleaned_data[key] = value
     return cleaned_data
 
+
 # Function to read the JSON file and return an ARAconfig model
 @lru_cache(maxsize=1)
 def read_data(filepath: str) -> ARAconfig:
@@ -170,6 +173,16 @@ def read_data(filepath: str) -> ARAconfig:
     If the file doesn't exist, it creates a default one.
     If the file is invalid, it corrects only the broken parts.
     """
+
+    def warn_on_duplicate_llm_dict_key(ordered_pairs):
+        """Reject duplicate keys."""
+        d = {}
+        for k, v in ordered_pairs:
+            if k in d:
+                warnings.warn(f"Duplicate LLM configuration identifier '{k}'. The previous entry will be removed.", UserWarning)
+            d[k] = v
+        return d
+
     ensure_directory_exists(dirname(filepath))
 
     if not exists(filepath):
@@ -181,7 +194,8 @@ def read_data(filepath: str) -> ARAconfig:
 
     try:
         with open(filepath, "r", encoding="utf-8") as file:
-            data = json.load(file)
+            content = file.read()
+            data = json.loads(content, object_pairs_hook=warn_on_duplicate_llm_dict_key)
     except json.JSONDecodeError as e:
         print(f"Error: Invalid JSON in configuration file: {e}")
         print("Creating a new configuration with defaults...")
@@ -206,7 +220,8 @@ def read_data(filepath: str) -> ARAconfig:
         
         for field_name in error_fields:
             print(f"-> Field '{field_name}' is invalid and will be reverted to its default value.")
-            corrected_data[field_name] = defaults.get(field_name)
+            if field_name in corrected_data:
+                corrected_data[field_name] = defaults.get(field_name)
 
         print("--- End of Error Report ---")
 

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
 
@@ -144,11 +147,11 @@ def run_agent(prompt, artefact_class):
     # anthropic:claude-4-sonnet-20250514
     agent = Agent(
         model="anthropic:claude-4-sonnet-20250514",
-        result_type=artefact_class,
+        output_type=artefact_class,
         instrument=True,
     )
     result = agent.run_sync(prompt)
-    return result.data
+    return result.output
 
 
 def write_corrected_artefact(file_path, corrected_text):
@@ -196,36 +199,52 @@ def ask_for_correct_contribution(
     return name, classifier
 
 
-def ask_for_contribution_choice(
-    choices, artefact_info: Optional[tuple[str, str]] = None
-) -> Optional[str]:
-    artefact_name, artefact_classifier = (
-        artefact_info if artefact_info else (None, None)
-    )
+def ask_for_contribution_choice(choices: List[str], artefact_info: Optional[tuple[str, str]] = None) -> Optional[str]:
+    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}'"
-    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): "
-    )
+    message += "."
+    return get_user_choice(choices, message)
+
+
+def _has_valid_contribution(artefact: Artefact) -> bool:
+    contribution = artefact.contribution
+    return contribution and contribution.artefact_name and contribution.classifier
+
+
+def get_user_choice(choices: List[str], message: str) -> Optional[str]:
+    """
+    Generic function to present user with a list of choices and return their selection.
+
+    Args:
+        choices: A list of strings representing the choices to display.
+        message: A message to display before listing the choices.
+
+    Returns:
+        The chosen item from the list or None if the input was invalid.
+    """
+    print(message)
+    for i, choice in enumerate(choices):
+        print(f"{i + 1}: {choice}")
+
+    choice_number = input("Please enter your choice (number): ")
+
     try:
         choice_index = int(choice_number) - 1
         if choice_index < 0 or choice_index >= len(choices):
-            print("Invalid choice. Aborting contribution choice.")
+            print("Invalid choice. Aborting operation.")
             return None
-        choice = choices[choice_index]
+        return choices[choice_index]
     except ValueError:
-        print("Invalid input. Aborting contribution choice.")
+        print("Invalid input. Aborting operation.")
         return None
-    return choice
 
 
-def _has_valid_contribution(artefact: Artefact) -> bool:
-    contribution = artefact.contribution
-    return contribution and contribution.artefact_name and contribution.classifier
+def ask_for_rule_choice(matches: List[str]) -> Optional[str]:
+    """Asks the user for a choice between multiple rule matches"""
+    message = "Multiple rule matches found:"
+    return get_user_choice(matches, message)
 
 
 def _update_rule(
@@ -249,6 +268,9 @@ def _update_rule(
         return
     if not closest_rule_match:
         return
+    if len(closest_rule_match) > 1:
+        artefact.contribution.rule = ask_for_rule_choice(closest_rule_match)
+        return
     artefact.contribution.rule = closest_rule_match[0]
 
 
@@ -353,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:
@@ -565,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)