ara-cli 0.1.9.50__py3-none-any.whl → 0.1.9.51__py3-none-any.whl

ara_cli/artefact_lister.py

@@ -1,8 +1,7 @@
 from ara_cli.file_classifier import FileClassifier
-from ara_cli.template_manager import DirectoryNavigator
 from ara_cli.artefact_reader import ArtefactReader
 from ara_cli.file_lister import list_files_in_directory
-from ara_cli.artefact import Artefact
+from ara_cli.artefact_models.artefact_model import Artefact
 from ara_cli.list_filter import ListFilter, filter_list
 from ara_cli.artefact_fuzzy_search import suggest_close_name_matches
 import os
@@ -13,16 +12,26 @@ class ArtefactLister:
         self.file_system = file_system or os
 
     @staticmethod
-    def artefact_content_retrieval(artefact):
-        return artefact.content
+    def artefact_content_retrieval(artefact: Artefact):
+        content = artefact.serialize()
+        return content
 
     @staticmethod
-    def artefact_path_retrieval(artefact):
+    def artefact_path_retrieval(artefact: Artefact):
         return artefact.file_path
 
     @staticmethod
-    def artefact_tags_retrieval(artefact):
-        return artefact.tags
+    def artefact_tags_retrieval(artefact: Artefact):
+        final_tags = []
+
+        if not artefact:
+            return []
+
+        final_tags.extend([f"user_{user}" for user in artefact.users])
+        final_tags.append(artefact.status)
+        final_tags.extend(artefact.tags)
+
+        return final_tags
 
     def filter_artefacts(self, classified_files: list, list_filter: ListFilter):
         filtered_list = filter_list(
@@ -40,17 +49,15 @@ class ArtefactLister:
         navigate_to_target=False,
         list_filter: ListFilter | None = None
     ):
-        # make sure this function is always called from the ara top level directory
-        navigator = DirectoryNavigator()
-        if navigate_to_target:
-            navigator.navigate_to_target()
+        artefact_list = ArtefactReader.read_artefacts(tags=tags)
+        artefact_list = self.filter_artefacts(artefact_list, list_filter)
 
+        filtered_artefact_list = {
+            key: [artefact for artefact in value if artefact is not None]
+            for key, value in artefact_list.items()
+        }
         file_classifier = FileClassifier(self.file_system)
-        classified_files = file_classifier.classify_files(tags=tags)
-
-        classified_files = self.filter_artefacts(classified_files, list_filter)
-
-        file_classifier.print_classified_files(classified_files)
+        file_classifier.print_classified_files(filtered_artefact_list)
 
     def list_branch(
         self,
@@ -59,21 +66,23 @@ class ArtefactLister:
         list_filter: ListFilter | None = None
     ):
         file_classifier = FileClassifier(os)
+        classified_artefacts = file_classifier.classify_files_new()
+        artefact_info = classified_artefacts.get(classifier, [])
+        matching_artefact_info = [p for p in artefact_info if p["title"] == artefact_name]
 
-        classified_artefacts = file_classifier.classify_files()
-        all_artefact_names = [artefact.file_name for artefact in classified_artefacts.get(classifier, [])]
-        if artefact_name not in all_artefact_names:
-            suggest_close_name_matches(artefact_name, all_artefact_names)
-            return
+        if not matching_artefact_info:
+            suggest_close_name_matches(
+                artefact_name,
+                [info["title"] for info in artefact_info]
+            )
 
         artefacts_by_classifier = {classifier: []}
         ArtefactReader.step_through_value_chain(
             artefact_name=artefact_name,
             classifier=classifier,
-            artefacts_by_classifier=artefacts_by_classifier
+            artefacts_by_classifier=artefacts_by_classifier,
         )
         artefacts_by_classifier = self.filter_artefacts(artefacts_by_classifier, list_filter)
-
         file_classifier.print_classified_files(artefacts_by_classifier)
 
     def list_children(
@@ -83,22 +92,24 @@ class ArtefactLister:
         list_filter: ListFilter | None = None
     ):
         file_classifier = FileClassifier(os)
+        classified_artefacts = file_classifier.classify_files_new()
+        artefact_info = classified_artefacts.get(classifier, [])
+        matching_artefact_info = [p for p in artefact_info if p["title"] == artefact_name]
 
-        classified_artefacts = file_classifier.classify_files()
-        all_artefact_names = [artefact.file_name for artefact in classified_artefacts.get(classifier, [])]
-        if artefact_name not in all_artefact_names:
-            suggest_close_name_matches(artefact_name, all_artefact_names)
-            return
+        if not matching_artefact_info:
+            suggest_close_name_matches(
+                artefact_name,
+                [info["title"] for info in artefact_info]
+            )
 
         child_artefacts = ArtefactReader.find_children(
-                artefact_name=artefact_name,
-                classifier=classifier
+            artefact_name=artefact_name,
+            classifier=classifier
         )
+
         child_artefacts = self.filter_artefacts(child_artefacts, list_filter)
 
-        file_classifier.print_classified_files(
-            files_by_classifier=child_artefacts
-        )
+        file_classifier.print_classified_files(child_artefacts)
 
     def list_data(
         self,
@@ -107,21 +118,21 @@ class ArtefactLister:
         list_filter: ListFilter | None = None
     ):
         file_classifier = FileClassifier(os)
-
         classified_artefacts = file_classifier.classify_files()
-        all_artefact_names = [artefact.file_name for artefact in classified_artefacts.get(classifier, [])]
-        if artefact_name not in all_artefact_names:
-            suggest_close_name_matches(artefact_name, all_artefact_names)
+        artefact_paths = classified_artefacts.get(classifier, [])
+        matching_paths = [p for p in artefact_paths if os.path.basename(p).startswith(artefact_name + '.')]
+
+        if not matching_paths:
+            suggest_close_name_matches(
+                artefact_name,
+                [os.path.basename(f).split('.')[0] for f in artefact_paths]
+            )
+        artefact_paths = classified_artefacts.get(classifier, [])
+        matching_paths = [p for p in artefact_paths if os.path.basename(p).startswith(artefact_name + '.')]
+
+        if len(matching_paths) == 0:
             return
-
-        content, file_path = ArtefactReader.read_artefact(
-            classifier=classifier,
-            artefact_name=artefact_name
-        )
-
-        artefact = Artefact.from_content(content)
-        file_path = next((classified_artefact.file_path for classified_artefact in classified_artefacts.get(classifier, []) if classified_artefact.name == artefact.name), artefact)
-
-        file_path = os.path.splitext(file_path)[0] + '.data'
-        if os.path.exists(file_path):
-            list_files_in_directory(file_path, list_filter)
+        artefact_path = matching_paths[0]
+        data_dir = os.path.splitext(artefact_path)[0] + '.data'
+        if os.path.exists(data_dir):
+            list_files_in_directory(data_dir, list_filter)

ara_cli/artefact_models/artefact_model.py

@@ -90,7 +90,7 @@ class Contribution(BaseModel):
             rule = rule_text
         parent_text_list = parent_text.split(' ')
         classifier = parent_text_list[-1].lower()
-        artefact_name = '_'.join(parent_text_list[:-1])
+        artefact_name = '_'.join([s for s in parent_text_list if s][:-1])
 
         return cls(
             artefact_name=artefact_name,
@@ -165,6 +165,14 @@ class Artefact(BaseModel, ABC):
         default=None,
         description="Optional further description to understand the artefact. It is strongly recommended to add a description to every artefact."
     )
+    _file_path: Optional[str] = None
+
+    @property
+    def file_path(self) -> str:
+        if self._file_path is not None:
+            return self._file_path
+        sub_dir = Classifier.get_sub_directory(self.artefact_type)
+        return f"{sub_dir}/{self.title}.{self.artefact_type}"
 
     @field_validator('artefact_type')
     def validate_artefact_type(cls, v):
@@ -230,12 +238,6 @@ class Artefact(BaseModel, ABC):
     def _artefact_type(cls) -> ArtefactType:    # pragma: no cover
         pass
 
-    def file_location(self) -> str:
-        artefact_type = self.artefact_type
-        sub_directory = Classifier.get_sub_directory(artefact_type)
-        file_path = f"ara/{sub_directory}/{self.title}.{artefact_type}"
-        return file_path
-
     @classmethod
     def _deserialize_tags(cls, lines) -> (Dict[str, str], List[str]):
         assert len(lines) > 0, "Empty lines given, can't extract tags"

ara_cli/artefact_models/feature_artefact_model.py

@@ -85,7 +85,7 @@ class Example(BaseModel):
     def from_row(cls, headers: List[str], row: List[str]) -> 'Example':
         if len(row) != len(headers):
             raise ValueError(
-                f"Row has {len(row)} cells, but expected {len(headers)}")
+                f"Row has {len(row)} cells, but expected {len(headers)}.\nFound row: {row}")
         values = {header: value.strip() for header, value in zip(headers, row)}
         return cls(values=values)
 
@@ -175,6 +175,7 @@ class ScenarioOutline(BaseModel):
     @classmethod
     def from_lines(cls, lines: List[str], start_idx: int) -> Tuple['ScenarioOutline', int]:
         """Parse a ScenarioOutline from a list of lines starting at start_idx."""
+
         if not lines[start_idx].startswith('Scenario Outline:'):
             raise ValueError("Expected 'Scenario Outline:' at start index")
         title = lines[start_idx][len('Scenario Outline:'):].strip()
@@ -190,6 +191,8 @@ class ScenarioOutline(BaseModel):
             headers = [h.strip() for h in lines[idx].split('|') if h.strip()]
             idx += 1
             while idx < len(lines) and lines[idx].strip():
+                if lines[idx].strip().startswith("Scenario:") or lines[idx].strip().startswith("Scenario Outline:"):
+                    break
                 row = [cell.strip()
                        for cell in lines[idx].split('|') if cell.strip()]
                 example = Example.from_row(headers, row)

ara_cli/artefact_reader.py

@@ -1,8 +1,9 @@
 from ara_cli.directory_navigator import DirectoryNavigator
 from ara_cli.classifier import Classifier
 from ara_cli.file_classifier import FileClassifier
-from ara_cli.artefact import Artefact
-from ara_cli.artefact_fuzzy_search import suggest_close_name_matches, suggest_close_name_matches_for_parent
+from ara_cli.artefact_models.artefact_model import Artefact
+from ara_cli.artefact_fuzzy_search import suggest_close_name_matches_for_parent, suggest_close_name_matches
+from typing import Dict, List
 import os
 import re
 
@@ -19,22 +20,25 @@ class ArtefactReader:
             os.chdir(original_directory)
             return None, None
 
-        sub_directory = Classifier.get_sub_directory(classifier)
-        file_path = os.path.join(sub_directory, f"{artefact_name}.{classifier}")
+        file_classifier = FileClassifier(os)
+        classified_files = file_classifier.classify_files()
+        artefact_paths = classified_files.get(classifier, [])
 
-        file_exists = os.path.exists(file_path)
+        for file_path in artefact_paths:
+            if os.path.basename(file_path).startswith(artefact_name + '.'):
+                with open(file_path, 'r') as file:
+                    content = file.read()
+                os.chdir(original_directory)
+                return content, file_path
 
-        if not file_exists:
-            print(f"File \"{file_path}\" not found")
-            os.chdir(original_directory)
-            return None, None
-
-        with open(file_path, 'r') as file:
-            content = file.read()
+        print(f"No match found for artefact with name '{artefact_name}'")
+        suggest_close_name_matches(
+            artefact_name,
+            [os.path.basename(f).split('.')[0] for f in artefact_paths]
+        )
 
         os.chdir(original_directory)
-
-        return content, file_path
+        return None, None
 
     @staticmethod
     def extract_parent_tree(artefact_content):
@@ -53,41 +57,77 @@ class ArtefactReader:
         return parent_name, parent_type
 
     @staticmethod
-    def find_children(artefact_name, classifier, artefacts_by_classifier={}, classified_artefacts=None):
+    def merge_dicts(dict1, dict2):
+        from collections import defaultdict
 
-        def merge_dicts(dict1, dict2):
-            from collections import defaultdict
+        merged = defaultdict(list)
+        for d in [dict1, dict2]:
+            for key, artefacts in d.items():
+                merged[key].extend(artefacts)
+        return dict(merged)
 
-            merged_dict = defaultdict(list)
-
-            # Add items from the first dictionary
-            for key, artefact_list in dict1.items():
-                merged_dict[key].extend(artefact_list)
+    @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
 
-            # Add items from the second dictionary
-            for key, artefact_list in dict2.items():
-                merged_dict[key].extend(artefact_list)
+        if classified_artefacts is None:
+            file_classifier = FileClassifier(file_system)
+            classified_artefacts = file_classifier.classify_files_new()
+
+        artefacts = {artefact_type: []
+                     for artefact_type in classified_artefacts.keys()}
+        for artefact_type, artefact_info_dicts in classified_artefacts.items():
+            for artefact_info in artefact_info_dicts:
+                try:
+                    with open(artefact_info["file_path"], 'r') as file:
+                        content = file.read()
+                    artefact = artefact_from_content(content)
+                    if not artefact:
+                        continue
+                    # Store the full file path in the artefact
+                    artefact._file_path = artefact_info["file_path"]
+                    artefacts[artefact_type].append(artefact)
+                    # else:
+                        # Include file path if deserialization fails
+                        # FIXME: LOOK INTO IT
+                        # artefacts[artefact_type].append(file_path)
+                except Exception:
+                    # TODO: catch only specific exceptions
+                    # TODO: implament error message for deserialization or "ara scan" or "ara autofix"
+                    # print(f"Warning: Could not deserialize artefact at {artefact_info}: {e}")
+                    # artefacts[artefact_type].append(file_path)
+                    continue
+        return artefacts
 
-            return dict(merged_dict)
+    @staticmethod
+    def find_children(artefact_name, classifier, artefacts_by_classifier={}, classified_artefacts=None):
+        artefacts_by_classifier = artefacts_by_classifier or {}
+        filtered_artefacts = {k: [] for k in artefacts_by_classifier.keys()}
 
         if classified_artefacts is None:
-            file_classifier = FileClassifier(os)
-            classified_artefacts = file_classifier.classify_files()
+            classified_artefacts = ArtefactReader.read_artefacts()
 
-        filtered_artefacts = {}
-        for key, artefact_list in classified_artefacts.items():
-            filtered_list = [
-                artefact for artefact in artefact_list
-                if artefact.parent and
-                artefact.parent.name == artefact_name and
-                artefact.parent.classifier == classifier
-            ]
-            if filtered_list:
-                filtered_artefacts[key] = filtered_list
+        for artefact_classifier, artefacts in classified_artefacts.items():
+            for artefact in artefacts:
+                if not isinstance(artefact, Artefact):
+                    continue
 
-        merged_dict = merge_dicts(artefacts_by_classifier, filtered_artefacts)
+                try:
+                    contribution = artefact.contribution
+                    if (contribution and
+                        contribution.artefact_name == artefact_name and
+                            contribution.classifier == classifier):
 
-        return merged_dict
+                        file_classifier = artefact._file_path.split('.')[-1]
+
+                        if file_classifier not in filtered_artefacts:
+                            filtered_artefacts[file_classifier] = []
+                        filtered_artefacts[file_classifier].append(artefact)
+
+                except AttributeError as e:
+                    continue
+
+        return ArtefactReader.merge_dicts(artefacts_by_classifier, filtered_artefacts)
 
     @staticmethod
     def step_through_value_chain(
@@ -95,34 +135,41 @@ class ArtefactReader:
             classifier,
             artefacts_by_classifier={},
             classified_artefacts: dict[str, list[Artefact]] | None = None
-            ):
-        if classified_artefacts is None:
-            file_classifier = FileClassifier(os)
-            classified_artefacts = file_classifier.classify_files()
-
-        content, file_path = ArtefactReader.read_artefact(artefact_name, classifier)
-
-        artefact = Artefact.from_content(content)
-        artefact_path = next((classified_artefact.file_path for classified_artefact in classified_artefacts.get(classifier, []) if classified_artefact.name == artefact.name), artefact.file_path)
-        artefact._file_path = artefact_path
+    ):
+        from ara_cli.artefact_models.artefact_load import artefact_from_content
 
+        if classified_artefacts is None:
+            classified_artefacts = ArtefactReader.read_artefacts()
 
         if classifier not in artefacts_by_classifier:
             artefacts_by_classifier[classifier] = []
 
-        matching_artefacts = list(filter(lambda x: x.name == artefact.name, artefacts_by_classifier[classifier]))
-        if len(matching_artefacts) != 0:
+        artefact = next(filter(
+            lambda x: x.title == artefact_name, classified_artefacts[classifier]
+        ))
+
+        if not artefact:
+            return
+        if artefact in artefacts_by_classifier[classifier]:
             return
 
         artefacts_by_classifier[classifier].append(artefact)
-        parent = artefact.parent
-        if parent:
-            parent_name = parent.name
+
+        parent = artefact.contribution
+        if parent and parent.artefact_name and parent.classifier:
+            parent_name = parent.artefact_name
             parent_classifier = parent.classifier
 
-            all_artefact_names = [artefact.file_name for artefact in classified_artefacts.get(parent_classifier, [])]
+            parent_classifier_artefacts = classified_artefacts[parent_classifier]
+            all_artefact_names = [x.title for x in parent_classifier_artefacts]
+
             if parent_name not in all_artefact_names:
-                suggest_close_name_matches_for_parent(artefact_name, all_artefact_names, parent_name)
+                if parent_name is not None:
+                    suggest_close_name_matches_for_parent(
+                        artefact_name,
+                        all_artefact_names,
+                        parent_name
+                    )
                 print()
                 return
 

ara_cli/artefact_scan.py

@@ -0,0 +1,46 @@
+def check_file(file_path, artefact_class):
+    from pydantic import ValidationError
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+    except OSError as e:
+        return False, f"File error: {e}"
+    try:
+        artefact_class.deserialize(content)
+        return True, None
+    except (ValidationError, ValueError, AssertionError) as e:
+        return False, str(e)
+    except Exception as e:
+        return False, f"Unexpected error: {e!r}"
+
+
+def find_invalid_files(classified_artefact_info, classifier):
+    from ara_cli.artefact_models.artefact_mapping import artefact_type_mapping
+
+    artefact_class = artefact_type_mapping[classifier]
+    invalid_files = []
+    for artefact_info in classified_artefact_info[classifier]:
+        if "templates/" in artefact_info["file_path"]:
+            continue
+        is_valid, reason = check_file(artefact_info["file_path"], artefact_class)
+        if not is_valid:
+            invalid_files.append((artefact_info["file_path"], reason))
+    return invalid_files
+
+
+def show_results(invalid_artefacts):
+    has_issues = False
+    with open("incompatible_artefacts_report.md", "w") as report:
+        report.write("# Artefact Check Report\n\n")
+        for classifier, files in invalid_artefacts.items():
+            if files:
+                has_issues = True
+                print(f"\nIncompatible {classifier} Files:")
+                report.write(f"## {classifier}\n")
+                for file, reason in files:
+                    print(f"\t- {file}")
+                    report.write(f"- `{file}`: {reason}\n")
+                report.write("\n")
+        if not has_issues:
+            print("All files are good!")
+            report.write("No problems found.\n")

ara_cli/file_classifier.py

@@ -4,6 +4,7 @@ from ara_cli.artefact_fuzzy_search import find_closest_name_match
 from functools import lru_cache
 from typing import Optional
 import textwrap
+import os
 
 
 class FileClassifier:
@@ -12,7 +13,8 @@ class FileClassifier:
 
     def find_closest_artefact_name_match(self, name, classifier) -> Optional[str]:
         classified_artefacts = self.classify_files()
-        all_artefact_names = [artefact.file_name for artefact in classified_artefacts.get(classifier, [])]
+        all_artefact_names = [
+            artefact_name for artefact_name in classified_artefacts.get(classifier, [])]
         if name in all_artefact_names:
             return name
         return find_closest_name_match(name, all_artefact_names)
@@ -62,9 +64,13 @@ class FileClassifier:
                 return classifier
         return None
 
-    def classify_files(self, tags=None, read_content=False) -> dict[str, list[Artefact]]:
-        files_by_classifier = {classifier: [] for classifier in Classifier.ordered_classifiers()}
+    def classify_files(self, tags=None, read_content=False) -> dict[str, list]:
+        from ara_cli.artefact_models.artefact_load import artefact_from_content
+
+        files_by_classifier = {classifier: []
+                               for classifier in Classifier.ordered_classifiers()}
 
+        # TODO: file location information inside the artefact.
         for root, _, files in self.file_system.walk("."):
             for file in files:
                 file_path = self.file_system.path.join(root, file)
@@ -73,23 +79,22 @@ class FileClassifier:
                     continue
 
                 if not read_content:
-                    name = file.rsplit('.', 1)[0].replace('_', ' ')
-                    artefact = Artefact(classifier=classifier, name=name, _file_path=file_path)
-                    files_by_classifier[classifier].append(artefact)
+                    files_by_classifier[classifier].append(file_path)
                     continue
 
                 with open(file_path, 'r') as f:
                     content = f.read()
                 try:
-                    artefact = Artefact.from_content(content)
-                    artefact._file_path = file_path
-                    files_by_classifier[classifier].append(artefact)
+                    artefact = artefact_from_content(content)
+                    if artefact:
+                        artefact._file_path = file_path
+                        files_by_classifier[classifier].append(artefact)
                 except ValueError:
                     continue
 
         return files_by_classifier
 
-    def classify_files_new(self, tags=None) -> dict[str, list[str]]:
+    def classify_files_new(self, tags=None) -> dict[str, list[dict]]:
         files_by_classifier = {classifier: [] for classifier in Classifier.ordered_classifiers()}
 
         for root, _, files in self.file_system.walk("."):
@@ -97,18 +102,21 @@ class FileClassifier:
                 file_path = self.file_system.path.join(root, file)
                 classifier = self.classify_file(file_path, tags)
                 if not classifier:
+                    # no return
                     continue
 
-                files_by_classifier[classifier].append(file_path)
+                file_info = {"file_path": file_path, "title": '.'.join(file.split('.')[:-1])}
+
+                files_by_classifier[classifier].append(file_info)
                 continue
 
         return files_by_classifier
 
     def print_artefact_list(self, artefacts: list[Artefact], print_content=False):
         for artefact in artefacts:
-            print(f"  - {artefact.file_path}")
+            print(f"  - ./{os.path.relpath(artefact.file_path, os.getcwd())}")
             if print_content:
-                indented_content = textwrap.indent(artefact.content, prefix="      ")
+                indented_content = textwrap.indent(artefact.serialize(), prefix="      ")
                 print(f"    Content:\n{indented_content}")
 
     def print_classified_files(self, files_by_classifier, print_content=False):

ara_cli/prompt_extractor.py

@@ -1,5 +1,6 @@
 from ara_cli.prompt_handler import send_prompt, get_file_content
 from ara_cli.classifier import Classifier
+from ara_cli.directory_navigator import DirectoryNavigator
 from ara_cli.artefact_models.artefact_mapping import title_prefix_to_artefact_class
 import re
 import json
@@ -57,6 +58,7 @@ def extract_responses(document_path, relative_to_ara_root=False):
             # Update the markdown content
             updated_content = update_markdown(content, block, file_path)
         else:
+            # Extract artefact
             artefact_class = None
             for line in block_lines[:2]:
                 words = line.strip().split(' ')
@@ -71,13 +73,19 @@ def extract_responses(document_path, relative_to_ara_root=False):
                 continue
             artefact = artefact_class.deserialize('\n'.join(block_lines))
             serialized_artefact = artefact.serialize()
-            # TODO: correct artefact path to be relative to ara directory
-            artefact_path = artefact.file_location()
+
+            original_directory = os.getcwd()
+            directory_navigator = DirectoryNavigator()
+            directory_navigator.navigate_to_target()
+
+            artefact_path = artefact.file_path
             directory = os.path.dirname(artefact_path)
             os.makedirs(directory, exist_ok=True)
             with open(artefact_path, 'w') as file:
                 file.write(serialized_artefact)
 
+            os.chdir(original_directory)
+
             # TODO: make update_markdown work block by block instead of updating the whole document at once
             block_extraction_counter += 1
             updated_content = update_markdown(content, block, None)

ara_cli/tag_extractor.py

@@ -8,30 +8,20 @@ class TagExtractor:
 
     def extract_tags(self, navigate_to_target=False):
         from ara_cli.template_manager import DirectoryNavigator
-        from ara_cli.file_classifier import FileClassifier
+        from ara_cli.artefact_reader import ArtefactReader
 
         navigator = DirectoryNavigator()
         if navigate_to_target:
             navigator.navigate_to_target()
 
-        file_classifier = FileClassifier(self.file_system)
-        classified_files = file_classifier.classify_files_new()
+        artefacts = ArtefactReader.read_artefacts()
 
         unique_tags = set()
 
-        for artefacts in classified_files.values():
-            for artefact in artefacts:
-                with open(artefact, 'r') as file:
-                    artefact_content = file.read()
-                try:
-                    artefact_object = artefact_from_content(artefact_content)
-                except ValueError:
-                    continue
-                if not artefact_object:
-                    continue
-                status_list = ([artefact_object.status] if artefact_object.status is not None else [])
-                users_list = [f"user_{user}" for user in artefact_object.users]
-                tags = artefact_object.tags + users_list + status_list
+        for artefact_list in artefacts.values():
+            for artefact in artefact_list:
+                user_tags = [f"user_{tag}" for tag in artefact.users]
+                tags = [tag for tag in (artefact.tags + [artefact.status] + user_tags) if tag is not None]
                 unique_tags.update(tags)
 
         sorted_tags = sorted(unique_tags)