ara-cli 0.1.10.1__py3-none-any.whl → 0.1.11.0__py3-none-any.whl

ara_cli/prompt_handler.py

@@ -60,7 +60,12 @@ class LLMSingleton:
         # Check if there was an authentication error
         stderr_output = captured_stderr.getvalue()
         if "Authentication error" in stderr_output:
-            warnings.warn("Invalid Langfuse credentials - prompt tracing disabled and using default prompts. Set environment variables 'ARA_CLI_LANGFUSE_PUBLIC_KEY', 'ARA_CLI_LANGFUSE_SECRET_KEY', 'LANGFUSE_HOST' and restart application to use Langfuse capabilities", UserWarning)
+            warnings.warn(
+                "Invalid Langfuse credentials - prompt tracing disabled and using default prompts. "
+                "Set environment variables 'ARA_CLI_LANGFUSE_PUBLIC_KEY', 'ARA_CLI_LANGFUSE_SECRET_KEY', "
+                "'LANGFUSE_HOST' and restart application to use Langfuse capabilities",
+                UserWarning,
+            )
 
         LLMSingleton._default_model = default_model_id
         LLMSingleton._extraction_model = extraction_model_id
@@ -160,6 +165,50 @@ def _is_valid_message(message: dict) -> bool:
     return False
 
 
+def _norm(p: str) -> str:
+    """Normalize slashes and collapse .. segments."""
+    return os.path.normpath(p) if p else p
+
+
+def resolve_existing_path(rel_or_abs_path: str, anchor_dir: str) -> str:
+    """
+    Resolve a potentially relative path to an existing absolute path.
+
+    Strategy:
+    - If already absolute and exists -> return it.
+    - Else, try from the anchor_dir.
+    - Else, walk up parent directories from anchor_dir and try joining at each level.
+    - If nothing is found, return the normalized original (will fail later with clear message).
+    """
+    if not rel_or_abs_path:
+        return rel_or_abs_path
+
+    candidate = _norm(rel_or_abs_path)
+
+    if os.path.isabs(candidate) and os.path.exists(candidate):
+        return candidate
+
+    anchor_dir = os.path.abspath(anchor_dir or os.getcwd())
+
+    # Try from anchor dir directly
+    direct = _norm(os.path.join(anchor_dir, candidate))
+    if os.path.exists(direct):
+        return direct
+
+    # Walk parents
+    cur = anchor_dir
+    prev = None
+    while cur and cur != prev:
+        test = _norm(os.path.join(cur, candidate))
+        if os.path.exists(test):
+            return test
+        prev = cur
+        cur = os.path.dirname(cur)
+
+    # Give back normalized candidate; open() will raise, but at least path is clean
+    return candidate
+
+
 def send_prompt(prompt, purpose="default"):
     """Prepares and sends a prompt to the LLM, streaming the response."""
     chat_instance = LLMSingleton.get_instance()
@@ -213,8 +262,6 @@ def describe_image(image_path: str) -> str:
     Returns:
         Text description of the image
     """
-    import base64
-
     with LLMSingleton.get_instance().langfuse.start_as_current_span(
         name="ara-cli/describe-image"
     ) as span:
@@ -234,14 +281,19 @@ def describe_image(image_path: str) -> str:
         # Fallback to default prompt if Langfuse prompt is not available
         if not describe_image_prompt:
             logging.info("Using default describe-image prompt.")
-            describe_image_prompt = "Please describe this image in detail. If it contains text, transcribe it exactly. If it's a diagram or chart, explain its structure and content. If it's a photo or illustration, describe what you see."
+            describe_image_prompt = (
+                "Please describe this image in detail. If it contains text, transcribe it exactly. "
+                "If it's a diagram or chart, explain its structure and content. If it's a photo or illustration, "
+                "describe what you see."
+            )
 
-        # Read and encode the image
-        with open(image_path, "rb") as image_file:
+        # Resolve and read the image
+        resolved_image_path = resolve_existing_path(image_path, os.getcwd())
+        with open(resolved_image_path, "rb") as image_file:
             base64_image = base64.b64encode(image_file.read()).decode("utf-8")
 
         # Determine image type
-        image_extension = os.path.splitext(image_path)[1].lower()
+        image_extension = os.path.splitext(resolved_image_path)[1].lower()
         mime_type = {
             ".png": "image/png",
             ".jpg": "image/jpeg",
@@ -256,7 +308,7 @@ def describe_image(image_path: str) -> str:
             "content": [
                 {
                     "type": "text",
-                    "text": "Please describe this image in detail. If it contains text, transcribe it exactly. If it's a diagram or chart, explain its structure and content. If it's a photo or illustration, describe what you see.",
+                    "text": describe_image_prompt,
                 },
                 {
                     "type": "image_url",
@@ -288,7 +340,9 @@ def describe_image(image_path: str) -> str:
 def append_headings(classifier, param, heading_name):
     sub_directory = Classifier.get_sub_directory(classifier)
 
-    artefact_data_path = f"ara/{sub_directory}/{param}.data/{classifier}.prompt_log.md"
+    artefact_data_path = _norm(
+        f"ara/{sub_directory}/{param}.data/{classifier}.prompt_log.md"
+    )
 
     # Check if the file exists, and if not, create an empty file
     if not os.path.exists(artefact_data_path):
@@ -309,15 +363,15 @@ def append_headings(classifier, param, heading_name):
 
 def write_prompt_result(classifier, param, text):
     sub_directory = Classifier.get_sub_directory(classifier)
-
-    # TODO change absolute path to relative path with directory navigator
-    artefact_data_path = f"ara/{sub_directory}/{param}.data/{classifier}.prompt_log.md"
+    artefact_data_path = _norm(
+        f"ara/{sub_directory}/{param}.data/{classifier}.prompt_log.md"
+    )
     write_string_to_file(artefact_data_path, text, "a")
 
 
 def prompt_data_directory_creation(classifier, parameter):
     sub_directory = Classifier.get_sub_directory(classifier)
-    prompt_data_path = f"ara/{sub_directory}/{parameter}.data/prompt.data"
+    prompt_data_path = _norm(f"ara/{sub_directory}/{parameter}.data/prompt.data")
     if not exists(prompt_data_path):
         makedirs(prompt_data_path)
     return prompt_data_path
@@ -347,9 +401,10 @@ def initialize_prompt_templates(classifier, parameter):
         artefact_to_mark=f"{parameter}.{classifier}",
     )
 
-    generate_config_prompt_global_givens_file(prompt_data_path, "config.prompt_global_givens.md")
-
-    generate_config_prompt_global_givens_file(prompt_data_path, "config.prompt_global_givens.md")
+    # Only once (was duplicated before)
+    generate_config_prompt_global_givens_file(
+        prompt_data_path, "config.prompt_global_givens.md"
+    )
 
 
 def write_template_files_to_config(template_type, config_file, base_template_path):
@@ -361,7 +416,7 @@ def write_template_files_to_config(template_type, config_file, base_template_pat
 
 def load_selected_prompt_templates(classifier, parameter):
     sub_directory = Classifier.get_sub_directory(classifier)
-    prompt_data_path = f"ara/{sub_directory}/{parameter}.data/prompt.data"
+    prompt_data_path = _norm(f"ara/{sub_directory}/{parameter}.data/prompt.data")
     config_file_path = os.path.join(prompt_data_path, "config.prompt_templates.md")
 
     if not os.path.exists(config_file_path):
@@ -464,7 +519,9 @@ def move_and_copy_files(source_path, prompt_data_path, prompt_archive_path):
 
 def extract_and_load_markdown_files(md_prompt_file_path):
     """
-    Extracts markdown files paths based on checked items and constructs proper paths respecting markdown header hierarchy.
+    Extracts markdown files paths based on checked items and constructs proper paths
+    respecting markdown header hierarchy. **Returns normalized relative paths**
+    (not resolved), and resolution happens later relative to the config file dir.
     """
     header_stack = []
     path_accumulator = []
@@ -480,53 +537,73 @@ def extract_and_load_markdown_files(md_prompt_file_path):
                 header_stack.append(header)
             elif "[x]" in line:
                 relative_path = line.split("]")[-1].strip()
-                full_path = os.path.join("/".join(header_stack), relative_path)
-                path_accumulator.append(full_path)
+                # Use os.path.join for OS-safe joining, then normalize
+                full_rel_path = os.path.join(*header_stack, relative_path) if header_stack else relative_path
+                path_accumulator.append(_norm(full_rel_path))
     return path_accumulator
 
 
 def load_givens(file_path):
+    """
+    Reads marked givens from a config markdown and returns:
+      - combined markdown content (including code fences / images)
+      - a list of image data dicts for the multimodal message
+    Paths inside the markdown are resolved robustly relative to the config file directory (and its parents).
+    """
     content = ""
     image_data_list = []
     markdown_items = extract_and_load_markdown_files(file_path)
 
-    # Only proceed and add the header if there are marked items to load.
     if not markdown_items:
         return "", []
 
     content = "### GIVENS\n\n"
 
+    anchor_dir = os.path.dirname(os.path.abspath(file_path))
+
     for item in markdown_items:
-        if item.lower().endswith((".png", ".jpeg", ".jpg")):
-            with open(item, "rb") as image_file:
+        resolved = resolve_existing_path(item, anchor_dir)
+        # Keep the listing line readable, show the original relative item
+        content += item + "\n"
+
+        ext = os.path.splitext(resolved)[1].lower()
+
+        # Image branch
+        if ext in (".png", ".jpeg", ".jpg", ".gif", ".bmp"):
+            with open(resolved, "rb") as image_file:
                 base64_image = base64.b64encode(image_file.read()).decode("utf-8")
+
+            mime_type = {
+                ".png": "image/png",
+                ".jpg": "image/jpeg",
+                ".jpeg": "image/jpeg",
+                ".gif": "image/gif",
+                ".bmp": "image/bmp",
+            }.get(ext, "image/png")
+
             image_data_list.append(
                 {
                     "type": "image_url",
-                    "image_url": {"url": f"data:image/png;base64,{base64_image}"},
+                    "image_url": {"url": f"data:{mime_type};base64,{base64_image}"},
                 }
             )
-            content += item + "\n"
-            content += f"![{item}](data:image/png;base64,{base64_image})" + "\n"
-        else:
-            # Check if the item specifies line ranges
-            # TODO item has currently no trailing [] see extraction and handover method in extract and load
-            # item = f"[10:29] {item}"
-            # print(f"found {item}, check for subsection")
-            # TODO re.match can not split the item with [] correctly and extract the line numbers
-            # TODO logic of subsections is not supported by the update algorithm of the config prompt givens updater
-            # TODO extract in lines of *.md files potential images and add them to the image list
+            # Also embed inline for the prompt markdown (use png as a neutral default for data URI)
+            content += f"![{item}](data:{mime_type};base64,{base64_image})\n"
 
+        else:
+            # Check if the item specifies line ranges: e.g. "[10:20,25:30] filePath"
             match = re.match(r".*?\[(\d+:\d+(?:,\s*\d+:\d+)*)\]\s+(.+)", item)
             if match:
                 line_ranges, file_name = match.groups()
-                content += file_name + "\n" + "```\n"
-                content += get_partial_file_content(file_name, line_ranges) + "\n"
+                resolved_sub = resolve_existing_path(file_name, anchor_dir)
+                content += "```\n"
+                content += get_partial_file_content(resolved_sub, line_ranges) + "\n"
                 content += "```\n\n"
             else:
-                content += item + "\n" + "```\n"
-                content += get_file_content(item) + "\n"
+                content += "```\n"
+                content += get_file_content(resolved) + "\n"
                 content += "```\n\n"
+
     return content, image_data_list
 
 
@@ -535,7 +612,7 @@ def get_partial_file_content(file_name, line_ranges):
     Reads specific lines from a file based on the line ranges provided.
 
     Args:
-    file_name (str): The path to the file.
+    file_name (str): The path to the file (absolute or relative, already resolved by caller).
     line_ranges (str): A string representing the line ranges to read, e.g., '10:20,25:30'.
 
     Returns:
@@ -585,9 +662,7 @@ def prepend_system_prompt(message_list):
     # Fallback to default prompt if Langfuse prompt is not available
     if not system_prompt:
         logging.info("Using default system prompt.")
-        system_prompt = (
-            "You are a helpful assistant that can process both text and images."
-        )
+        system_prompt = "You are a helpful assistant that can process both text and images."
 
     # Prepend the system prompt
     system_prompt_message = {"role": "system", "content": system_prompt}
@@ -597,6 +672,9 @@ def prepend_system_prompt(message_list):
 
 
 def append_images_to_message(message, image_data_list):
+    """
+    Appends image data list to a single message dict (NOT to a list).
+    """
     logger = logging.getLogger(__name__)
 
     logger.debug(
@@ -607,13 +685,17 @@ def append_images_to_message(message, image_data_list):
         logger.debug("No images to append, returning original message")
         return message
 
-    message_content = message["content"]
+    message_content = message.get("content")
     logger.debug(f"Original message content: {message_content}")
 
     if isinstance(message_content, str):
         message["content"] = [{"type": "text", "text": message_content}]
 
-    message["content"].extend(image_data_list)
+    if isinstance(message["content"], list):
+        message["content"].extend(image_data_list)
+    else:
+        # If somehow content is not list or str, coerce to list
+        message["content"] = [{"type": "text", "text": str(message_content)}] + image_data_list
 
     logger.debug(f"Updated message content with {len(image_data_list)} images")
 
@@ -622,11 +704,20 @@ def append_images_to_message(message, image_data_list):
 
 def create_and_send_custom_prompt(classifier, parameter):
     sub_directory = Classifier.get_sub_directory(classifier)
-    prompt_data_path = f"ara/{sub_directory}/{parameter}.data/prompt.data"
+    prompt_data_path = _norm(f"ara/{sub_directory}/{parameter}.data/prompt.data")
     prompt_file_path_markdown = join(prompt_data_path, f"{classifier}.prompt.md")
 
-    extensions = [".blueprint.md", ".rules.md", ".prompt_givens.md", ".prompt_global_givens.md", ".intention.md", ".commands.md"]
-    combined_content_markdown, image_data_list = collect_file_content_by_extension(prompt_data_path, extensions)
+    extensions = [
+        ".blueprint.md",
+        ".rules.md",
+        ".prompt_givens.md",
+        ".prompt_global_givens.md",
+        ".intention.md",
+        ".commands.md",
+    ]
+    combined_content_markdown, image_data_list = collect_file_content_by_extension(
+        prompt_data_path, extensions
+    )
 
     with open(prompt_file_path_markdown, "w", encoding="utf-8") as file:
         file.write(combined_content_markdown)
@@ -635,14 +726,14 @@ def create_and_send_custom_prompt(classifier, parameter):
     append_headings(classifier, parameter, "prompt")
     write_prompt_result(classifier, parameter, prompt)
 
+    # Build message and append images correctly (fixed)
     message = {"role": "user", "content": combined_content_markdown}
-
+    message = append_images_to_message(message, image_data_list)
     message_list = [message]
 
-    message_list = append_images_to_message(message_list, image_data_list)
     append_headings(classifier, parameter, "result")
 
-    artefact_data_path = (
+    artefact_data_path = _norm(
         f"ara/{sub_directory}/{parameter}.data/{classifier}.prompt_log.md"
     )
     with open(artefact_data_path, "a", encoding="utf-8") as file:
@@ -652,7 +743,6 @@ def create_and_send_custom_prompt(classifier, parameter):
                 continue
             file.write(chunk_content)
             file.flush()
-    # write_prompt_result(classifier, parameter, response)
 
 
 def generate_config_prompt_template_file(
@@ -661,7 +751,8 @@ def generate_config_prompt_template_file(
     config_prompt_templates_path = os.path.join(
         prompt_data_path, config_prompt_templates_name
     )
-    config = ConfigManager.get_config()
+    # Use instance method consistently
+    config = ConfigManager().get_config()
     global_prompt_template_path = TemplatePathManager.get_template_base_path()
     dir_list = ["ara/.araconfig/custom-prompt-modules"] + [
         f"{os.path.join(global_prompt_template_path,'prompt-modules')}"
@@ -678,7 +769,7 @@ def generate_config_prompt_givens_file(
     config_prompt_givens_path = os.path.join(
         prompt_data_path, config_prompt_givens_name
     )
-    config = ConfigManager.get_config()
+    config = ConfigManager().get_config()
     dir_list = (
         ["ara"]
         + [path for d in config.ext_code_dirs for path in d.values()]
@@ -712,14 +803,24 @@ def generate_config_prompt_givens_file(
         with open(config_prompt_givens_path, "w", encoding="utf-8") as file:
             file.write("".join(updated_listing))
 
-def generate_config_prompt_global_givens_file(prompt_data_path, config_prompt_givens_name, artefact_to_mark=None):
+
+def generate_config_prompt_global_givens_file(
+    prompt_data_path, config_prompt_givens_name, artefact_to_mark=None
+):
     from ara_cli.global_file_lister import generate_global_markdown_listing
-    config_prompt_givens_path = os.path.join(prompt_data_path, config_prompt_givens_name)
-    config = ConfigManager.get_config()
 
-    if not hasattr(config, 'global_dirs') or not config.global_dirs:
+    config_prompt_givens_path = os.path.join(
+        prompt_data_path, config_prompt_givens_name
+    )
+    config = ConfigManager().get_config()
+
+    if not hasattr(config, "global_dirs") or not config.global_dirs:
         return
 
     dir_list = [path for d in config.global_dirs for path in d.values()]
-    print(f"used {dir_list} for global prompt givens file listing with absolute paths")
-    generate_global_markdown_listing(dir_list, config.ara_prompt_given_list_includes, config_prompt_givens_path)
+    print(
+        f"used {dir_list} for global prompt givens file listing with absolute paths"
+    )
+    generate_global_markdown_listing(
+        dir_list, config.ara_prompt_given_list_includes, config_prompt_givens_path
+    )

ara_cli/tag_extractor.py

@@ -6,7 +6,6 @@ from ara_cli.artefact_models.artefact_data_retrieval import (
     artefact_tags_retrieval,
 )
 
-
 class TagExtractor:
     def __init__(self, file_system=None):
         self.file_system = file_system or os
@@ -50,31 +49,35 @@ class TagExtractor:
             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:
-                user_tags = [f"user_{tag}" for tag in artefact.users]
-                
-                # Build list of all tags, filtering out None values
-                all_tags = []
-                all_tags.extend(artefact.tags)
-                
-                if artefact.status:
-                    all_tags.append(artefact.status)
-                    
-                all_tags.extend(user_tags)
-                
-                # Safely handle author attribute
-                if hasattr(artefact, 'author') and artefact.author:
-                    all_tags.append(artefact.author)
-                
-                # Filter out None values and add to tag groups
-                for tag in all_tags:
-                    if tag is not None:
-                        key = tag.lower()
-                        if key not in tag_groups:
-                            tag_groups[key] = set()
-                        tag_groups[key].add(tag)
+                all_tags = self._collect_all_tags(artefact)
+                self._add_tags_to_groups(tag_groups, all_tags)
 
     def extract_tags(
         self,

ara_cli/template_loader.py

@@ -147,7 +147,7 @@ class TemplateLoader:
             # Direct file loading for CLI usage
             try:
                 with open(file_path, 'r', encoding='utf-8') as template_file:
-                    template_content = template_file.read()
+                    template_content = template_file.read().replace('\r\n', '\n')
 
                 # Add prompt tag if needed
                 self._add_prompt_tag_if_needed(chat_file_path)

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