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

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
@@ -33,7 +35,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:
@@ -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
@@ -125,12 +130,10 @@ def list_action(args):
         )
         return
 
-    if (args.tags):
-        artefact_lister.list_files(tags=args.tags, list_filter=list_filter)
-        return
     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
@@ -141,20 +144,29 @@ def list_tags_action(args):
     )
 
     tag_extractor = TagExtractor()
-    tags = tag_extractor.extract_tags(
+    tag_groups = tag_extractor.extract_tags(
         filtered_extra_column=getattr(args, "filtered_extra_column", False),
         list_filter=list_filter
     )
 
     if args.json:
-        output = json.dumps({"tags": tags})
+        all_tags = []
+        for group in tag_groups.values():
+            all_tags.extend(group)
+        output = json.dumps({"tags": sorted(all_tags)})
         print(output)
         return
 
-    output = "\n".join(f"- {tag}" for tag in tags)
+    output_lines = []
+    for key in sorted(tag_groups.keys()):
+        line = " ".join(sorted(list(tag_groups[key])))
+        output_lines.append(line)
+
+    output = "\n".join(f"- {tag}" for tag in output_lines)
     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
@@ -165,6 +177,7 @@ def prompt_action(args):
     classifier = args.classifier
     param = args.parameter
     init = args.steps
+    write = getattr(args, 'write', False)
 
     def handle_init():
         from ara_cli.prompt_handler import initialize_prompt_templates
@@ -192,7 +205,7 @@ def prompt_action(args):
     def handle_extract():
         from ara_cli.prompt_extractor import extract_and_save_prompt_results
         from ara_cli.update_config_prompt import update_artefact_config_prompt_files
-        extract_and_save_prompt_results(classifier, param)
+        extract_and_save_prompt_results(classifier, param, write=write)
         print(f"automatic update after extract")
         update_artefact_config_prompt_files(classifier, param, automatic_update=True)
 
@@ -226,6 +239,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
 
@@ -252,6 +266,60 @@ def chat_action(args):
     chat.start()
 
 
+def _find_chat_file(chat_name: str) -> str | None:
+    """Resolves the chat file path based on common naming conventions."""
+    # Logic from setup_chat for finding existing files.
+    if os.path.exists(chat_name) and os.path.isfile(chat_name):
+        return chat_name
+
+    chat_name_md = f"{chat_name}.md"
+    if os.path.exists(chat_name_md) and os.path.isfile(chat_name_md):
+        return chat_name_md
+
+    chat_name_chat_md = f"{chat_name}_chat.md"
+    if os.path.exists(chat_name_chat_md) and os.path.isfile(chat_name_chat_md):
+        return chat_name_chat_md
+
+    return None
+
+
+@handle_errors(context="load action", error_handler=error_handler)
+def load_action(args):
+    from ara_cli.template_loader import TemplateLoader
+
+    chat_name = args.chat_name
+    template_type = args.template_type
+    template_name = args.template_name
+
+    chat_file_path = _find_chat_file(chat_name)
+
+    if not chat_file_path:
+        raise AraError(f"Chat file for '{chat_name}' not found.")
+
+    default_patterns = {
+        "rules": "*.rules.md",
+        "intention": "*.intention.md",
+        "commands": "*.commands.md"
+    }
+
+    default_pattern = default_patterns.get(template_type)
+
+    if not template_name and not default_pattern:
+        raise AraError(f"A template name is required for template type '{template_type}'.")
+
+    loader = TemplateLoader()  # No chat instance for CLI context
+    success = loader.load_template(
+        template_name=template_name,
+        template_type=template_type,
+        chat_file_path=chat_file_path,
+        default_pattern=default_pattern
+    )
+
+    if not success:
+        sys.exit(1)
+
+
+@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
@@ -264,6 +332,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
@@ -293,60 +362,40 @@ 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.artefact_reader import ArtefactReader
-    from ara_cli.file_classifier import FileClassifier
+    from ara_cli.commands.read_command import ReadCommand
+    from ara_cli.list_filter import ListFilter
 
     classifier = args.classifier
     artefact_name = args.parameter
     read_mode = args.read_mode
 
-    file_classifier = FileClassifier(os)
-    classified_artefacts = ArtefactReader.read_artefacts()
-    artefacts = classified_artefacts.get(classifier, [])
-    all_artefact_names = [a.title for a in artefacts]
-
-    if artefact_name not in all_artefact_names:
-        suggest_close_name_matches(
-                artefact_name,
-                all_artefact_names
-            )
-        return
-
-    target_artefact = next(filter(
-        lambda x: x.title == artefact_name, artefacts
-    ))
+    list_filter = ListFilter(
+        include_content=args.include_content,
+        exclude_content=args.exclude_content,
+        include_extension=args.include_extension,
+        exclude_extension=args.exclude_extension,
+        include_tags=args.include_tags,
+        exclude_tags=args.exclude_tags
+    )
 
-    artefacts_by_classifier = {classifier: []}
+    command = ReadCommand(
+        classifier=classifier,
+        artefact_name=artefact_name,
+        read_mode=read_mode,
+        list_filter=list_filter
+    )
 
-    match read_mode:
-        case "branch":
-            ArtefactReader.step_through_value_chain(
-                artefact_name=artefact_name,
-                classifier=classifier,
-                artefacts_by_classifier=artefacts_by_classifier,
-                classified_artefacts=classified_artefacts
-            )
-            file_classifier.print_classified_files(artefacts_by_classifier, print_content=True)
-        case "children":
-            artefacts = ArtefactReader.find_children(
-                artefact_name=artefact_name,
-                classifier=classifier,
-                classified_artefacts=classified_artefacts
-            )
-            file_classifier.print_classified_files(
-                files_by_classifier=artefacts,
-                print_content=True
-            )
-        case _:
-            artefacts_by_classifier[classifier].append(target_artefact)
-            file_classifier.print_classified_files(artefacts_by_classifier, print_content=True)
+    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
     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,30 +408,26 @@ def reconnect_action(args):
 
     feedback_message = f"Updated contribution of {classifier} '{artefact_name}' to {parent_classifier} '{parent_name}'"
 
-    content, artefact_info = ArtefactReader.read_artefact(
+    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:
-        print(read_error_message)
-        return
 
-    parent_content, parent_info = ArtefactReader.read_artefact(
-        artefact_name=parent_name,
-        classifier=parent_classifier
-    )
-    if not parent_content:
-        print(read_error_message)
-        return
+    if not artefact:
+        raise AraError(read_error_message)
 
-    artefact = artefact_from_content(
-        content=content,
+    parent = ArtefactReader.read_artefact(
+        artefact_name=parent_name,
+        classifier=parent_classifier,
+        classified_file_info=classified_file_info
     )
-    artefact._file_path = artefact_info["file_path"]
 
-    parent = artefact_from_content(
-        content=parent_content
-    )
+    if not parent:
+        raise AraError(read_error_message)
 
     contribution = Contribution(
         artefact_name=parent.title,
@@ -390,22 +435,19 @@ 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') as file:
+    with open(artefact.file_path, 'w', encoding='utf-8') as file:
         artefact_content = artefact.serialize()
         file.write(artefact_content)
 
     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
@@ -419,14 +461,14 @@ 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(
         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)
 
@@ -438,6 +480,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
@@ -451,14 +494,14 @@ 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(
         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)
 
@@ -471,6 +514,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
@@ -500,19 +544,20 @@ 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}'.")
 
 
+@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
@@ -537,7 +582,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,12 +590,13 @@ 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}'.")
 
 
+@handle_errors(context="classifier-directory action", error_handler=error_handler)
 def classifier_directory_action(args):
     from ara_cli.classifier import Classifier
 
@@ -559,6 +605,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
@@ -573,8 +620,10 @@ 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
 
     # If the user passes --non-deterministic, only_deterministic_fix becomes False.
     # If the user passes --deterministic, only_non_deterministic_fix becomes False.
@@ -591,6 +640,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}")
@@ -599,9 +651,26 @@ def autofix_action(args):
                 file_path,
                 classifier,
                 reason,
+                single_pass=args.single_pass,
                 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.")
 
+
+@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)
+    command = ExtractCommand(
+        file_name=filename,
+        force=force,
+        write=write,
+        output=lambda msg: print(msg, file=sys.stdout)
+    )
+    command.execute()