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

ara_cli/prompt_rag.py

@@ -16,7 +16,7 @@ def find_files_in_prompt_config_givens(search_file, prompt_givens_file_path):
     header_stack = []
     modified_lines = []  # To store the modified file content
 
-    with open(prompt_givens_file_path, 'r') as file:
+    with open(prompt_givens_file_path, 'r', encoding='utf-8') as file:
         for line in file:
             if line.strip().startswith('#'):
                 level = line.count('#')
@@ -37,7 +37,7 @@ def find_files_in_prompt_config_givens(search_file, prompt_givens_file_path):
 
     if file_found:
         # Rewrite the file with the modified content if any line was changed
-        with open(prompt_givens_file_path, 'w') as file:
+        with open(prompt_givens_file_path, 'w', encoding='utf-8') as file:
             file.writelines(modified_lines)
 
     return file_found

ara_cli/tag_extractor.py

@@ -1,17 +1,89 @@
 import os
 from ara_cli.list_filter import ListFilter, filter_list
-from ara_cli.artefact_lister import ArtefactLister
-
+from ara_cli.artefact_models.artefact_data_retrieval import (
+    artefact_content_retrieval,
+    artefact_path_retrieval,
+    artefact_tags_retrieval,
+)
 
 class TagExtractor:
     def __init__(self, file_system=None):
         self.file_system = file_system or os
 
+    def filter_column(self, tag_groups, filtered_artefacts):
+        status_tags = {"to-do", "in-progress", "review", "done", "closed"}
+
+        artefacts_to_process = self._get_artefacts_without_status_tags(
+            filtered_artefacts, status_tags
+        )
+        self._add_non_status_tags_to_set(tag_groups, artefacts_to_process, status_tags)
+
+    def _get_artefacts_without_status_tags(self, filtered_artefacts, status_tags):
+        artefacts_to_process = []
+        for artefact_list in filtered_artefacts.values():
+            for artefact in artefact_list:
+                tag_set = self._get_tag_set(artefact)
+                if not tag_set & status_tags:
+                    artefacts_to_process.append(artefact)
+        return artefacts_to_process
+
+    def _get_tag_set(self, artefact):
+        tags = artefact.tags + [artefact.status] if artefact.status else artefact.tags
+        return set(tag for tag in tags if tag is not None)
+
+    def _add_non_status_tags_to_set(self, tag_groups, artefacts, status_tags):
+        for artefact in artefacts:
+            tags = [
+                tag for tag in (artefact.tags + [artefact.status]) if tag is not None
+            ]
+            for tag in tags:
+                if self._is_skipped_tag(tag, status_tags):
+                    continue
+                key = tag.lower()
+                if key not in tag_groups:
+                    tag_groups[key] = set()
+                tag_groups[key].add(tag)
+
+    def _is_skipped_tag(self, tag, status_tags):
+        return (
+            tag in status_tags or tag.startswith("priority_") or tag.startswith("user_")
+        )
+
+    def _collect_all_tags(self, artefact):
+        """Collect all tags from an artefact including user tags and author."""
+        all_tags = []
+        all_tags.extend(artefact.tags)
+        
+        if artefact.status:
+            all_tags.append(artefact.status)
+            
+        user_tags = [f"user_{tag}" for tag in artefact.users]
+        all_tags.extend(user_tags)
+        
+        if hasattr(artefact, 'author') and artefact.author:
+            all_tags.append(artefact.author)
+            
+        return [tag for tag in all_tags if tag is not None]
+
+    def _add_tags_to_groups(self, tag_groups, tags):
+        """Add tags to tag groups."""
+        for tag in tags:
+            key = tag.lower()
+            if key not in tag_groups:
+                tag_groups[key] = set()
+            tag_groups[key].add(tag)
+
+    def add_to_tags_set(self, tag_groups, filtered_artefacts):
+        for artefact_list in filtered_artefacts.values():
+            for artefact in artefact_list:
+                all_tags = self._collect_all_tags(artefact)
+                self._add_tags_to_groups(tag_groups, all_tags)
+
     def extract_tags(
         self,
         navigate_to_target=False,
         filtered_extra_column=False,
-        list_filter: ListFilter | None = None
+        list_filter: ListFilter | None = None,
     ):
         from ara_cli.template_manager import DirectoryNavigator
         from ara_cli.artefact_reader import ArtefactReader
@@ -25,43 +97,16 @@ class TagExtractor:
         filtered_artefacts = filter_list(
             list_to_filter=artefacts,
             list_filter=list_filter,
-            content_retrieval_strategy=ArtefactLister.artefact_content_retrieval,
-            file_path_retrieval=ArtefactLister.artefact_path_retrieval,
-            tag_retrieval=ArtefactLister.artefact_tags_retrieval
+            content_retrieval_strategy=artefact_content_retrieval,
+            file_path_retrieval=artefact_path_retrieval,
+            tag_retrieval=artefact_tags_retrieval,
         )
 
-        unique_tags = set()
+        tag_groups = {}
 
         if filtered_extra_column:
-            status_tags = {"to-do", "in-progress", "review", "done", "closed"}
-            artefacts_to_process = []
-
-            for artefact_list in filtered_artefacts.values():
-                for artefact in artefact_list:
-                    tags = artefact.tags + \
-                        [artefact.status] if artefact.status else artefact.tags
-                    tag_set = set(tag for tag in tags if tag is not None)
-                    if not tag_set & status_tags:
-                        artefacts_to_process.append(artefact)
-
-            for artefact in artefacts_to_process:
-                tags = [tag for tag in (
-                    artefact.tags + [artefact.status]) if tag is not None]
-                for tag in tags:
-                    if (
-                        tag in status_tags
-                        or tag.startswith("priority_")
-                        or tag.startswith("user_")
-                    ):
-                        continue
-                    unique_tags.add(tag)
-
+            self.filter_column(tag_groups, filtered_artefacts)
         else:
-            for artefact_list in filtered_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)
-        return sorted_tags
+            self.add_to_tags_set(tag_groups, filtered_artefacts)
+
+        return tag_groups

ara_cli/template_loader.py

@@ -0,0 +1,245 @@
+
+import os
+import glob
+from ara_cli.template_manager import TemplatePathManager
+from ara_cli.ara_config import ConfigManager
+from ara_cli.directory_navigator import DirectoryNavigator
+
+
+class TemplateLoader:
+    """Handles template loading logic shared between CLI and chat commands"""
+
+    def __init__(self, chat_instance=None):
+        self.chat_instance = chat_instance
+
+    def load_template(self, template_name: str, template_type: str, chat_file_path: str, default_pattern: str | None = None) -> bool:
+        if not template_name:
+            if default_pattern:
+                return self.load_template_from_prompt_data(template_type, default_pattern, chat_file_path)
+            else:
+                print(f"A template name is required for template type '{template_type}'.")
+                return False
+        return self.load_template_from_global_or_local(template_name, template_type, chat_file_path)
+
+    def get_plural_template_type(self, template_type: str) -> str:
+        """Determines the plural form of a template type."""
+        plurals = {"commands": "commands", "rules": "rules"}
+        return plurals.get(template_type, f"{template_type}s")
+
+    def load_template_from_global_or_local(self, template_name: str, template_type: str, chat_file_path: str) -> bool:
+        """Load template from global or local directories"""
+        plural = self.get_plural_template_type(template_type)
+
+        if template_name.startswith("global/"):
+            return self._load_global_template(template_name, template_type, plural, chat_file_path)
+        else:
+            return self._load_local_template(template_name, template_type, plural, chat_file_path)
+
+    def _choose_file_for_cli(self, files: list[str], pattern: str) -> str | None:
+        """CLI-compatible file selection method"""
+        if len(files) <= 1:
+            return files[0] if files else None
+
+        if pattern in ["*", "global/*"] or "*" in pattern:
+            files.sort()
+            print("Multiple files found:")
+            for i, file in enumerate(files):
+                print(f"{i + 1}: {os.path.basename(file)}")
+
+            try:
+                choice = input("Please choose a file to load (enter number): ")
+                choice_index = int(choice) - 1
+                if 0 <= choice_index < len(files):
+                    return files[choice_index]
+                else:
+                    print("Invalid choice. Aborting load.")
+                    return None
+            except (ValueError, KeyboardInterrupt):
+                print("Invalid input. Aborting load.")
+                return None
+        else:
+            return files[0]
+
+    def _load_global_template(self, template_name: str, template_type: str, plural: str, chat_file_path: str) -> bool:
+        """Load template from global directory"""
+        directory = f"{TemplatePathManager.get_template_base_path()}/prompt-modules/{plural}/"
+        template_file = template_name.removeprefix("global/")
+        file_pattern = os.path.join(directory, template_file)
+        matching_files = glob.glob(file_pattern)
+
+        if not matching_files:
+            print(f"No {template_type} template '{template_file}' found in global templates.")
+            return False
+
+        # Choose file based on context
+        if self.chat_instance:
+            file_path = self.chat_instance.choose_file_to_load(matching_files, template_file)
+        else:
+            file_path = self._choose_file_for_cli(matching_files, template_file)
+
+        if file_path is None:
+            return False
+
+        return self._load_file_to_chat(file_path, template_type, chat_file_path)
+
+    def _load_local_template(self, template_name: str, template_type: str, plural: str, chat_file_path: str) -> bool:
+        """Load template from local custom directory"""
+        ara_config = ConfigManager.get_config()
+        navigator = DirectoryNavigator()
+
+        original_directory = os.getcwd()
+        navigator.navigate_to_target()
+        local_templates_path = ara_config.local_prompt_templates_dir
+        os.chdir("..")
+        local_templates_path = os.path.join(os.getcwd(), local_templates_path)
+        os.chdir(original_directory)
+
+        custom_prompt_templates_subdir = ara_config.custom_prompt_templates_subdir
+        template_directory = f"{local_templates_path}/{custom_prompt_templates_subdir}/{plural}"
+        file_pattern = os.path.join(template_directory, template_name)
+        matching_files = glob.glob(file_pattern)
+
+        if not matching_files:
+            print(f"No {template_type} template '{template_name}' found in local templates.")
+            return False
+
+        # Choose file based on context
+        if self.chat_instance:
+            file_path = self.chat_instance.choose_file_to_load(matching_files, template_name)
+        else:
+            file_path = self._choose_file_for_cli(matching_files, template_name)
+
+        if file_path is None:
+            return False
+
+        return self._load_file_to_chat(file_path, template_type, chat_file_path)
+
+    def load_template_from_prompt_data(self, template_type: str, default_pattern: str, chat_file_path: str) -> bool:
+        """Load template from prompt.data directory with selection"""
+        directory_path = os.path.join(os.path.dirname(chat_file_path), "prompt.data")
+        file_pattern = os.path.join(directory_path, default_pattern)
+        matching_files = glob.glob(file_pattern)
+
+        if not matching_files:
+            print(f"No {template_type} file found in prompt.data directory.")
+            return False
+
+        # Choose file based on context
+        if self.chat_instance:
+            file_path = self.chat_instance.choose_file_to_load(matching_files, default_pattern)
+        else:
+            file_path = self._choose_file_for_cli(matching_files, "*")
+
+        if file_path is None:
+            return False
+
+        return self._load_file_to_chat(file_path, template_type, chat_file_path)
+
+    def _load_file_to_chat(self, file_path: str, template_type: str, chat_file_path: str) -> bool:
+        """Load a file into the chat file"""
+        if self.chat_instance:
+            # Use chat instance methods
+            self.chat_instance.add_prompt_tag_if_needed(chat_file_path)
+            if self.chat_instance.load_file(file_path):
+                print(f"Loaded {template_type} from {os.path.basename(file_path)} into {os.path.basename(chat_file_path)}")
+                return True
+        else:
+            # Direct file loading for CLI usage
+            try:
+                with open(file_path, 'r', encoding='utf-8') as template_file:
+                    template_content = template_file.read().replace('\r\n', '\n')
+
+                # Add prompt tag if needed
+                self._add_prompt_tag_if_needed(chat_file_path)
+
+                # Append template content with newlines for separation
+                with open(chat_file_path, 'a', encoding='utf-8') as chat_file:
+                    chat_file.write(f"\n{template_content}\n")
+
+                print(f"Loaded {template_type} from {os.path.basename(file_path)} into {os.path.basename(chat_file_path)}")
+                return True
+            except Exception as e:
+                print(f"Error loading {template_type} from {file_path}: {e}")
+                return False
+
+        return False
+
+    def _add_prompt_tag_if_needed(self, chat_file_path: str):
+        """Add prompt tag if needed for CLI usage"""
+        from ara_cli.chat import Chat
+
+        with open(chat_file_path, 'r', encoding='utf-8') as file:
+            lines = file.readlines()
+
+        prompt_tag = f"# {Chat.ROLE_PROMPT}:"
+        if Chat.get_last_role_marker(lines) == prompt_tag:
+            return
+
+        append = prompt_tag
+        if lines:
+            last_line = lines[-1].strip()
+            if last_line != "" and last_line != '\n':
+                append = f"\n{append}"
+
+        with open(chat_file_path, 'a', encoding='utf-8') as file:
+            file.write(append)
+
+    def _find_project_root(self, start_path: str) -> str | None:
+        """
+        Finds the project root by searching for an 'ara' directory,
+        starting from the given path and moving upwards.
+        """
+        current_dir = start_path
+        while True:
+            if os.path.isdir(os.path.join(current_dir, 'ara')):
+                return current_dir
+            parent_dir = os.path.dirname(current_dir)
+            if parent_dir == current_dir:  # Reached the filesystem root
+                return None
+            current_dir = parent_dir
+
+    def _gather_templates_from_path(self, search_path: str, templates_set: set, prefix: str = ""):
+        """
+        Scans a given path for items and adds them to the provided set,
+        optionally prepending a prefix.
+        """
+        if not os.path.isdir(search_path):
+            return
+        for path in glob.glob(os.path.join(search_path, '*')):
+            templates_set.add(f"{prefix}{os.path.basename(path)}")
+
+    def get_available_templates(self, template_type: str, context_path: str) -> list[str]:
+        """
+        Scans for available global and project-local custom templates.
+        This method safely searches for template files without changing the
+        current directory, making it safe for use in autocompleters.
+        Args:
+            template_type: The type of template to search for (e.g., 'rules').
+            context_path: The directory path to start the search for project root from.
+        Returns:
+            A sorted list of unique template names. Global templates are
+            prefixed with 'global/'.
+        """
+        plural_type = self.get_plural_template_type(template_type)
+        templates = set()
+
+        # 1. Find Global Templates
+        try:
+            global_base_path = TemplatePathManager.get_template_base_path()
+            global_template_dir = os.path.join(global_base_path, "prompt-modules", plural_type)
+            self._gather_templates_from_path(global_template_dir, templates, prefix="global/")
+        except Exception:
+            pass  # Silently ignore if global templates are not found
+
+        # 2. Find Local Custom Templates
+        try:
+            project_root = self._find_project_root(context_path)
+            if project_root:
+                config = ConfigManager.get_config()
+                local_templates_base = os.path.join(project_root, config.local_prompt_templates_dir)
+                custom_dir = os.path.join(local_templates_base, config.custom_prompt_templates_subdir, plural_type)
+                self._gather_templates_from_path(custom_dir, templates)
+        except Exception:
+            pass  # Silently ignore if local templates cannot be resolved
+
+        return sorted(list(templates))

ara_cli/template_manager.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from shutil import copy
 from ara_cli.classifier import Classifier
 from ara_cli.directory_navigator import DirectoryNavigator
+from ara_cli.artefact_models.artefact_templates import template_artefact_of_type
 
 
 class TemplatePathManager:
@@ -30,14 +31,8 @@ class TemplatePathManager:
         ]
 
     def get_template_content(self, classifier):
-        base_path = self.get_template_base_path()
-
-        template_path = (base_path / f"template.{classifier}")
-
-        with template_path.open('r') as file:
-            content = file.read()
-
-        return content
+        artefact = template_artefact_of_type(classifier)
+        return artefact.serialize()
 
 
 class ArtefactFileManager:
@@ -113,7 +108,7 @@ class ArtefactFileManager:
     def save_behave_steps_to_file(self, artefact_name, behave_steps):
         self.navigator.navigate_to_target()
         file_path = f"features/steps/{artefact_name}_steps.py"
-        with open(file_path, 'w') as file:
+        with open(file_path, 'w', encoding='utf-8') as file:
             file.write(behave_steps)
 
 
@@ -134,6 +129,7 @@ class SpecificationBreakdownAspects:
         if aspect not in self.VALID_ASPECTS:
             raise ValueError(f"{aspect} does not exist. Please choose one of the {self.VALID_ASPECTS} list.")
 
+
     def create(self, artefact_name='artefact_name', classifier='classifier', aspect='specification_breakdown_aspect'):
         original_directory = os.getcwd()
         navigator = DirectoryNavigator()
@@ -144,8 +140,17 @@ class SpecificationBreakdownAspects:
         data_dir = self.file_manager.get_data_directory_path(artefact_name, classifier)
         self.file_manager.create_directory(artefact_file_path, data_dir)
         self.file_manager.copy_aspect_templates_to_directory(aspect, print_relative_to=original_directory)
+        
         if (aspect == "step"):
-            steps = self.file_manager.generate_behave_steps(artefact_name)
-            self.file_manager.save_behave_steps_to_file(artefact_name, steps)
-
-        os.chdir(original_directory)
+            # Instead of generating from behave command, read from the template file
+            template_file_path = f"{aspect}.md"
+            try:
+                with open(template_file_path, 'r', encoding='utf-8') as file:
+                    steps_content = file.read()
+                self.file_manager.save_behave_steps_to_file(artefact_name, steps_content)
+            except FileNotFoundError:
+                # Fallback to the original behavior if template doesn't exist
+                steps = self.file_manager.generate_behave_steps(artefact_name)
+                self.file_manager.save_behave_steps_to_file(artefact_name, steps)
+
+        os.chdir(original_directory)

ara_cli/templates/prompt-modules/commands/empty.commands.md

@@ -1,14 +1,4 @@
 ### COMMANDS FOR ...
 Your job is now:
-* remember you are strictly following your given RULES AS EXPERT <role defined in rules file> for code and architectural code quality
-* ...
-   
-* return your results in the following format, ensuring your generated code blocks are not just code snippets but at complete method levels. Use for every single generated code block this format:
-```python
-# [ ] extract
-# filename: {path/filename}.py
-{python code}
-```
-* the extract and filename statements are only allowed once per code block
-
-* in case you think information is missing in order to generate a suffiently precise formulation, return a warning "WARNING: information is missing to correctly fullfill the job!" and then explain what kind of information you think is missing and how I could easily retrieve it.  
+* <main list for mandotory commands>
+* ...

ara_cli/templates/prompt-modules/commands/extract_general.commands.md

@@ -0,0 +1,12 @@
+# general file generation and file extract instructions
+* return only full copy pastable file content using this markdown codeblock format with 5 backticks:
+`````
+# [ ] extract
+# filename: <absolute filepath>/<filename>.<file_extension>
+{valid file content depending on the given file_extension}
+`````
+
+* The extract and filename statements are only allowed once per markdown code block
+* The first character of the first line inside your code block must be '#' and the first character of the second line inside your code block must be '#'
+* replace the '# [ ] extract' statement of the template with '# [x] extract' in your response
+* in case of files get deprecated give me a list of files that can be safely deleted

ara_cli/templates/prompt-modules/commands/extract_markdown.commands.md

@@ -0,0 +1,11 @@
+# general markdown file generation and file extract instructions
+* return full copy pastable file content using a markdown code block with 5-backticks:
+`````
+# [ ] extract
+# filename: <filepath>/<filename>.md
+{markdown formatted text}
+`````
+* The extract and filename statements are only allowed once per markdown code block
+* The first character of the first line inside your code block must be '#' and the first character of the second line inside your code block must be '#'
+* replace the '# [ ] extract' statement of the template with '# [x] extract' in your response
+* in case of files get deprecated give me a list of files that can be safely deleted

ara_cli/templates/prompt-modules/commands/extract_python.commands.md

@@ -0,0 +1,13 @@
+# general python code file generation and file extract instructions
+* return only full copy pastable file content using this markdown codeblock format:
+
+```python
+# [ ] extract
+# filename: src/{filename}.py
+{python code}
+
+```
+* The extract and filename statements are only allowed once per markdown code block
+* The first character of the first line inside your code block must be '#' and the first character of the second line inside your code block must be '#'
+* replace the '# [ ] extract' statement of the template with '# [x] extract' in your response
+* in case of files get deprecated give me a list of files that can be safely deleted

ara_cli/templates/prompt-modules/commands/feature_add_or_modifiy_specified_behavior.commands.md

@@ -0,0 +1,36 @@
+# COMMANDS FOR ADDING OR MODIFYING EXISTING SPECIFIED BEHAVIOR
+
+**At first**: 
+
+Check if a set of feature files is given
+
+* In case no feature files are given:
+  * Stop immediately and respond with: "Error in prompt context: no feature files are given as already specified application behavior"
+
+* Else:
+  * Continue following the given instructions
+
+# Instructions
+Your job is now:
+* Silently analyze the given feature files and the specified behavior.
+* Silently analyze the additionally given information about new wanted behavior or changes of existing behavior
+* Develop adaptation strategies that minimize feature file changes with respect to any given already existing feature files, prefer reusing and adapting existing formulations/scenarios and steps over completely new formulations
+* Now formulate to fully cover the new or changed behavior (one, two or many changed or new feature files)
+
+Follow these feature file quality rules:
+* Each feature file should not consist of more than max 3 scenarios, each feature file should follow the single responsibility principle as well as the feature file formulations should follow the separation of concerns of feature files that fully cover the human user observable behavior described in the specification notes. Consider in your formulation of the Gherkin feature files that, when implementing the graphical user interfaces, the full functionality of the Python package Streamlit can be utilized.
+* Follow strictly the given feature file format in order to structure your feature files. 
+* You are allowed to use scenario outlines where useful. But in case they are not helpful in order to increase the readability you can just use standard scenario formulations.
+
+* Wrap and return the formulated feature files as full copy pastable file content in the following format as markdown code block:
+
+```artefact
+# [ ] extract 
+# filename: ara/features/{filename}.feature
+{formulation, with the valid feature file structure following the given feature files as reference}
+```
+
+* The extract and filename statements are only allowed once per markdown code block
+* The first character of the first line inside your code block must be '#' and the first character of the second line inside your code block must be '#'
+* replace the '# [ ] extract' statement of the template with '# [x] extract' in your response
+* in case of files get deprecated give me a list of files that can be safely deleted

ara_cli/templates/prompt-modules/commands/feature_generate_initial_specified_bevahior.commands.md

@@ -0,0 +1,53 @@
+# COMMANDS FOR INITIALLY SPECIFYING APPLICATION BEHAVIOR USING FEATURE FILES
+
+* Given a description of the wanted application behavior as bullet point list, specification document, ...
+
+* And given this feature template with placeholders in <...>
+
+```
+@creator_Egermeier
+Feature: <descriptive title>
+
+  As a <user>
+  I want to <do something | need something>
+  So that <I can achieve something>
+
+  Contributes to <here comes your parent artefact> <here comes your classifier of the parent artefact>  
+
+  Description: <further optional description to understand
+  the rule, no format defined, the example artefact is only a placeholder>
+
+  Scenario: <descriptive scenario title>
+    Given <precondition>
+    When <action>
+    Then <expected result>
+
+  Scenario Outline: <descriptive scenario title>
+    Given <precondition>
+    When <action>
+    Then <expected result>
+
+    Examples:
+      | descriptive scenario title | precondition         | action             | expected result    |
+      | <example title 1>          | <example precond. 1> | <example action 1> | <example result 1> |
+      | <example title 2>          | <example precond. 2> | <example action 2> | <example result 2> |
+```
+
+# Instructions
+* Now formulate a set (one, two or many, each feature file should not consist of more than max 3 scenarios
+* Each feature file should follow the single responsibility principle as well as the feature file formulations should follow the separation of concerns) of feature files that fully cover the human user observable behavior described in the specification notes. 
+* Consider in your formulation of the Gherkin feature files when specifying the behavior of graphical user interfaces: Describe the behavior of the graphical user interfaces so that I can clearly imagine both how they work and their visual look and feel.
+* Follow strictly the given template format in order to structure your feature files. You are allowed to use scenario outlines where useful. But in case they are not helpful in order to increase the readability you can just use standard scenario formulations.
+
+* Wrap and return the formulated feature files as full copy pastable file content in the following format as markdown code block:
+
+```artefact
+# [ ] extract 
+# filename: ara/features/{filename}.feature 
+{formulation, with the valid feature file structure as given by the feature gherkin template}
+```
+
+* The extract and filename statements are only allowed once per markdown code block
+* The first character of the first line inside your code block must be '#' and the first character of the second line inside your code block must be '#'
+* replace the '# [ ] extract' statement of the template with '# [x] extract' in your response
+* in case of files get deprecated give me a list of files that can be safely deleted