ara-cli 0.1.10.5__py3-none-any.whl → 0.1.14.0__py3-none-any.whl

ara_cli/file_loaders/file_loaders.py

@@ -1,123 +0,0 @@
-import os
-import base64
-from abc import ABC, abstractmethod
-from typing import Optional
-from ara_cli.file_loaders.markdown_reader import MarkdownReader
-from ara_cli.file_loaders.document_readers import DocumentReaderFactory
-
-
-class FileLoader(ABC):
-    """Abstract base class for file loaders"""
-    
-    def __init__(self, chat_instance):
-        self.chat = chat_instance
-        
-    @abstractmethod
-    def load(self, file_path: str, **kwargs) -> bool:
-        """Load file with specific implementation"""
-        pass
-        
-    def add_prompt_tag_if_needed(self):
-        """Add prompt tag to chat if needed"""
-        self.chat.add_prompt_tag_if_needed(self.chat.chat_name)
-
-
-class TextFileLoader(FileLoader):
-    """Loads text files"""
-    
-    def load(self, file_path: str, prefix: str = "", suffix: str = "", 
-             block_delimiter: str = "", extract_images: bool = False) -> bool:
-        """Load text file with optional markdown image extraction"""
-        
-        is_md_file = file_path.lower().endswith('.md')
-        
-        if is_md_file and extract_images:
-            reader = MarkdownReader(file_path)
-            file_content = reader.read(extract_images=True)
-        else:
-            with open(file_path, 'r', encoding='utf-8', errors="replace") as file:
-                file_content = file.read()
-        
-        if block_delimiter:
-            file_content = f"{block_delimiter}\n{file_content}\n{block_delimiter}"
-        
-        write_content = f"{prefix}{file_content}{suffix}\n"
-        
-        with open(self.chat.chat_name, 'a', encoding='utf-8') as chat_file:
-            chat_file.write(write_content)
-            
-        return True
-
-
-class BinaryFileLoader(FileLoader):
-    """Loads binary files (images)"""
-    
-    def load(self, file_path: str, mime_type: str, prefix: str = "", suffix: str = "") -> bool:
-        """Load binary file as base64"""
-        
-        with open(file_path, 'rb') as file:
-            file_content = file.read()
-            
-        base64_image = base64.b64encode(file_content).decode("utf-8")
-        write_content = f"{prefix}![{os.path.basename(file_path)}](data:{mime_type};base64,{base64_image}){suffix}\n"
-        
-        with open(self.chat.chat_name, 'a', encoding='utf-8') as chat_file:
-            chat_file.write(write_content)
-            
-        return True
-
-
-class DocumentFileLoader(FileLoader):
-    """Loads document files (PDF, DOCX, ODT)"""
-    
-    def load(self, file_path: str, prefix: str = "", suffix: str = "", 
-             block_delimiter: str = "```", extract_images: bool = False) -> bool:
-        """Load document file with optional image extraction"""
-        
-        reader = DocumentReaderFactory.create_reader(file_path)
-        
-        if not reader:
-            print("Unsupported document type.")
-            return False
-        
-        text_content = reader.read(extract_images=extract_images)
-        
-        if block_delimiter:
-            text_content = f"{block_delimiter}\n{text_content}\n{block_delimiter}"
-        
-        write_content = f"{prefix}{text_content}{suffix}\n"
-        
-        with open(self.chat.chat_name, 'a', encoding='utf-8') as chat_file:
-            chat_file.write(write_content)
-            
-        return True
-
-
-class FileLoaderFactory:
-    """Factory for creating appropriate file loaders"""
-    
-    BINARY_TYPE_MAPPING = {
-        ".png": "image/png",
-        ".jpg": "image/jpeg",
-        ".jpeg": "image/jpeg",
-    }
-    
-    DOCUMENT_TYPE_EXTENSIONS = [".docx", ".doc", ".odt", ".pdf"]
-    
-    @staticmethod
-    def create_loader(file_name: str, chat_instance) -> Optional[FileLoader]:
-        """Create appropriate loader based on file type"""
-        
-        file_name_lower = file_name.lower()
-        
-        # Check if it's a binary file
-        for extension, mime_type in FileLoaderFactory.BINARY_TYPE_MAPPING.items():
-            if file_name_lower.endswith(extension):
-                return BinaryFileLoader(chat_instance)
-        
-        # Check if it's a document
-        if any(file_name_lower.endswith(ext) for ext in FileLoaderFactory.DOCUMENT_TYPE_EXTENSIONS):
-            return DocumentFileLoader(chat_instance)
-        
-        # Default to text file loader
-        return TextFileLoader(chat_instance)

ara_cli/file_loaders/text_file_loader.py

@@ -1,187 +0,0 @@
-import os
-import re
-import base64
-import tempfile
-from typing import Optional, Tuple
-import requests
-from charset_normalizer import from_path
-from ara_cli.prompt_handler import describe_image
-from ara_cli.file_loaders.file_loader import FileLoader
-
-
-class TextFileLoader(FileLoader):
-    """Loads text files"""
-    def load(self, file_path: str, prefix: str = "", suffix: str = "",
-             block_delimiter: str = "", extract_images: bool = False, **kwargs) -> bool:
-        """Load text file with optional markdown image extraction"""
-
-        is_md_file = file_path.lower().endswith('.md')
-
-        if is_md_file and extract_images:
-            reader = MarkdownReader(file_path)
-            file_content = reader.read(extract_images=True).replace('\r\n', '\n')
-        else:
-            # Use charset-normalizer to detect encoding
-            encoded_content = from_path(file_path).best()
-            if not encoded_content:
-                print(f"Failed to detect encoding for {file_path}")
-                return False
-            file_content = str(encoded_content).replace('\r\n', '\n')
-
-        if block_delimiter:
-            file_content = f"{block_delimiter}\n{file_content}\n{block_delimiter}"
-
-        write_content = f"{prefix}{file_content}{suffix}\n"
-
-        with open(self.chat.chat_name, 'a', encoding='utf-8') as chat_file:
-            chat_file.write(write_content)
-
-        return True
-
-
-class MarkdownReader:
-    """Handles markdown file reading with optional image extraction"""
-
-    def __init__(self, file_path: str):
-        self.file_path = file_path
-        self.base_dir = os.path.dirname(file_path)
-        self.image_processor = ImageProcessor()
-
-    def read(self, extract_images: bool = False) -> str:
-        """Read markdown file and optionally extract/describe images"""
-        with open(self.file_path, 'r', encoding='utf-8') as file:
-            content = file.read()
-
-        if not extract_images:
-            return content
-
-        return self._process_images(content)
-
-    def _process_images(self, content: str) -> str:
-        """Process all images in markdown content"""
-        # Pattern to match markdown images: ![alt text](url or path)
-        image_pattern = re.compile(r'!\[([^\]]*)\]\(([^\)]+)\)')
-        base64_pattern = re.compile(r'data:image/([^;]+);base64,([^)]+)')
-
-        # Process each image reference
-        for match in image_pattern.finditer(content):
-            image_ref = match.group(2)
-            replacement = self._process_single_image(image_ref, base64_pattern)
-
-            if replacement:
-                content = content.replace(match.group(0), replacement, 1)
-
-        return content
-
-    def _process_single_image(self, image_ref: str, base64_pattern: re.Pattern) -> Optional[str]:
-        """Process a single image reference"""
-        try:
-            # Try base64 first
-            result = self.image_processor.process_base64_image(
-                image_ref, base64_pattern)
-            if result:
-                return result[0]
-
-            # Try URL
-            result, error = self.image_processor.process_url_image(image_ref)
-            if result:
-                if error:
-                    print(f"Warning: {error}")
-                return result
-
-            # Try local file
-            result, error = self.image_processor.process_local_image(
-                image_ref, self.base_dir)
-            if error:
-                print(f"Warning: {error}")
-            return result
-
-        except Exception as e:
-            print(f"Warning: Could not process image {image_ref}: {e}")
-            return None
-
-
-class ImageProcessor:
-    """Handles image processing operations"""
-
-    @staticmethod
-    def process_base64_image(
-        image_ref: str,
-        base64_pattern: re.Pattern
-    ) -> Optional[Tuple[str, str]]:
-        """Process base64 encoded image and return description"""
-        base64_match = base64_pattern.match(image_ref)
-        if not base64_match:
-            return None
-
-        image_format = base64_match.group(1)
-        base64_data = base64_match.group(2)
-        image_data = base64.b64decode(base64_data)
-
-        # Create a temporary file to send to LLM
-        with tempfile.NamedTemporaryFile(suffix=f'.{image_format}', delete=False) as tmp_file:
-            tmp_file.write(image_data)
-            tmp_file_path = tmp_file.name
-
-        try:
-            description = describe_image(tmp_file_path)
-            return f"Image: (base64 embedded {image_format} image)\n[{description}]", None
-        finally:
-            os.unlink(tmp_file_path)
-
-    @staticmethod
-    def process_url_image(image_ref: str) -> Tuple[str, Optional[str]]:
-        """Process image from URL and return description"""
-        if not image_ref.startswith(('http://', 'https://')):
-            return "", None
-
-        try:
-            response = requests.get(image_ref, timeout=10)
-            response.raise_for_status()
-
-            # Determine file extension from content-type
-            content_type = response.headers.get('content-type', '')
-            ext = ImageProcessor._get_extension_from_content_type(
-                content_type, image_ref)
-
-            # Create temporary file
-            with tempfile.NamedTemporaryFile(suffix=ext, delete=False) as tmp_file:
-                tmp_file.write(response.content)
-                tmp_file_path = tmp_file.name
-
-            try:
-                description = describe_image(tmp_file_path)
-                return f"Image: {image_ref}\n[{description}]", None
-            finally:
-                os.unlink(tmp_file_path)
-
-        except Exception as e:
-            error_msg = f"Could not download image: {str(e)}"
-            return f"Image: {image_ref}\n[{error_msg}]", error_msg
-
-    @staticmethod
-    def process_local_image(image_ref: str, base_dir: str) -> Tuple[str, Optional[str]]:
-        """Process local image file and return description"""
-        if os.path.isabs(image_ref):
-            local_image_path = image_ref
-        else:
-            local_image_path = os.path.join(base_dir, image_ref)
-
-        if os.path.exists(local_image_path):
-            description = describe_image(local_image_path)
-            return f"Image: {image_ref}\n[{description}]", None
-        else:
-            error_msg = f"Image file not found"
-            return f"Image: {image_ref}\n[{error_msg}]", f"Local image not found: {local_image_path}"
-
-    @staticmethod
-    def _get_extension_from_content_type(content_type: str, url: str) -> str:
-        """Determine file extension from content type or URL"""
-        if 'image/jpeg' in content_type:
-            return '.jpg'
-        elif 'image/png' in content_type:
-            return '.png'
-        elif 'image/gif' in content_type:
-            return '.gif'
-        else:
-            return os.path.splitext(url)[1] or '.png'

ara_cli/templates/prompt-modules/blueprints/complete_pytest_unittest.blueprint.md

@@ -1,27 +0,0 @@
-# Usage: 
-# necessary input and adaption: 
-# replace text snippets in <> with specific context
-# ...
-# expected output: 
-# ...
-Do not use usage information as prompt instructions
-
-
-Given source code
-```python
-<source code for context, skip irrelevant for current task>
-```
-
-Given existing unit tests
-```python
-<existing unit tests>
-```
-
-Given pytest is available
-
-Modify and/or create unit tests so this is fully covered:
-```python
-<snippet you want to cover in the next step>
-```
-
-Give me only what is relevant to testing this snippet. Use parametrization where applicable. Split into multiple tests instead of using if-else blocks. Mock all dependencies of tested code.

ara_cli/templates/prompt-modules/blueprints/pytest_unittest_prompt.blueprint.md

@@ -1,32 +0,0 @@
-MODE: STRICT_GENERATION
-TASK: Produce one complete pytest file for a given Python module.
-
-REQUIREMENTS:
-- Output only valid Python code (no text, no markdown).
-- Target: full behavioral + branch coverage (100%).
-- Tests follow AAA pattern (# Arrange, # Act, # Assert).
-- Exactly ONE assert or ONE pytest.raises() per test.
-- Use tmp_path fixture for filesystem isolation.
-- Include an autouse=True fixture for global patching if needed.
-- No external I/O or network calls.
-- All tests independent, self-contained.
-
-STYLE:
-- File starts with module docstring describing AAA, single assert rule, autouse fixture.
-- Group tests with comment headers: 
-  # --- Success paths --- / # --- Error paths --- / # --- Edge cases ---
-- Function names: test_<function>_<expected_behavior>_<condition>
-- Variables descriptive (rel, path, new_content, etc.).
-- Use direct asserts (assert result is True, assert path.read_text() == "x").
-- For errors: 
-  with pytest.raises(ExceptionType, match=r"text"): function_call()
-
-COVERAGE:
-- Include success, failure, and rare edge branches (e.g., conditional exceptions).
-- Ensure 100% of conditional branches executed.
-
-OUTPUT:
-- Single .py file, runnable via: pytest -v --disable-warnings --maxfail=1 --cov=<target_module>
-- No explanations or prose, only the test code.
-
-END

ara_cli/templates/prompt-modules/blueprints/task_todo_list_implement_feature_BDD_way.blueprint.md

@@ -1,30 +0,0 @@
-### INTENTION and CONTEXT
-My intention is to setup a todo list in my given task that helps me to implement a feature in a BDD way
-
-Now do the following:
-Search for a line starting with `Task: ` defined in the `### GIVENS` section. Just repeat the task_name you have found as confirmation
-* Do not proceed if no task is defined. Return immediatly with the message: "No task defined as prompt control" 
-
-* Focus on the description in the `Description` section of the defined task. Ignore all other sections.
-* Analyze the content of the task description section and adapt your default recipe accordingly. You can add new "[@to-do]s ...", you can delete "[@to-do]s" that are not necessary anymore according to the existing task description content
-
-* the format and formulation of your default recipe implementing a feature in BDD style is
-```
-[@to-do] analyze and understand the given `user story`
-[@to-do] generate an example contributing to the rule `rule of userstory to implement` which should be turned into a scenario or feature description
-[@to-do] use the example and aditional relevant context `{context list}` to formulate the feature file
-[@to-do] use the formulated feature file, relevant existing step implementations and relevant existing production code to implement the new step implementations that will fail
-[@to-do] use the created step definitions, the relevant existing production code to modify existing code and to create new code implementing the requested behavior so that the step implementations will pass 
-```
-
-* append your recipe at the end of task
-* return the extended task in the following format 
-```artefact
-# [ ] extract 
-# filename: ara/tasks/{task_name}.task 
-{initial task content}
-{recipe}
-```
-* 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 formulate the new artefacts" and then explain what kind of information you think is missing and how I could easily retrieve it  

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

@@ -1,9 +0,0 @@
-### COMMANDS FOR THE CORRECT CONTEXTUAL CLASSIFICATION OF ARTIFACTS
-Your job is now:
-* analyze the given files with respect to content and relationship
-* analyze the new artefact with respect to content and the relationship to the given files
-* give me a list of the top 5 artefacts to which the new artefact contributes the most
-* the output format must be a table with the columns
-  | artefact name | contribution rating from 0 (very low) - 1 (very high) | arguments for rating | path to artefact |
-
-* in case you think the relationship of the new artefact is to weak to any given files, return a warning "WARNING: new artefact is not directly related to already existing aretefacts" and then make a proposal with regard of the ara "work orchestration contribution hierarchy" and/or the "specification contribution hierarchy" 

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

@@ -1,17 +0,0 @@
-### COMMANDS FOR EXTENDING EXISTING AGILE REQUIREMENTS ARTIFACTS
-Your job is now:
-* analyze the given files with respect to content and relationship
-* analyze the new or changed behavior with respect to content and the relationship to the existing artefacts
-* Develop formulation strategies that minimize formulation changes of existing changes.
-* generate a formulation proposal that adds the new context and or behavior for the specified documents
-* wrap and return the formulated  in the following format 
-```artefact
-# [ ] extract 
-# filename: {path/filename.filextension} 
-{formulation}
-```
-* the extract and filename statements are only allowed once per code block
-
-* Adhere strictly to established rules for AGILE PRODUCT OWNERS for high-quality specification artefacts.
-
-* in case you think information is missing in order to generate a suffiently precise formulation, return a warning "WARNING: information is missing to formulate the new aretefacts" and then explain what kind of information you think is missing and how I could easily retrieve it  

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

@@ -1,14 +0,0 @@
-### COMMANDS FOR FORMULATING AGILE REQUIREMENTS ARTIFACTS
-Your job is now:
-* analyze the given files with respect to content and relationship
-* analyze the new artefact with respect to content and the relationship to the given files
-* generate a formulation proposal for the specified documents
-* wrap and return the formulated  in the following format 
-```artefact
-# [ ] extract 
-# filename: {path/filename.filextension} 
-{formulation}
-```
-* 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 formulate the new artefacts" and then explain what kind of information you think is missing and how I could easily retrieve it  

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

@@ -1,102 +0,0 @@
-### COMMANDS FOR IMPLEMENTING A STEP IMPLEMENTATION FROM A GIVEN FEATURE FILE
-Your job is now:
-* Silently analyze the given feature file to understand the required step implementations.
-* Silently review any additionally provided source files to check if any reusable step implementations already exist or if the necessary support methods are available.
-* Develop implementation strategies that minimize code changes, prefer reusing existing methods and step definitions over new implementations. 
-* Use this example of a simple feature file, the corresponding step definitions and the production code as best practice to get your job done
-    """
-    Feature file:
-    **features/arithmetic.feature**
-    ```gherkin
-    Feature: Arithmetic Operations
-
-    Contributes to: <Any artefact name to which this feature contributes value> <Classifier of this artefact>
-
-      Scenario: Addition of two numbers
-        Given the CLI is initialized
-        When the user runs the addition command with "2" and "3"
-        Then the result should be "5"
-
-      Scenario Outline: Subtraction of two numbers
-        Given the CLI is initialized
-        When the user runs the subtraction command with "<num1>" and "<num2>"
-        Then the result should be "<result>"
-
-        Examples:
-          | num1 | num2 | result |
-          | 5    | 3    | 2      |
-          | 10   | 4    | 6      |
-          | 0    | 0    | 0      |
-    ```
-
-    Step Definitions in Python with behave as BDD test framework:
-    **features/steps/arithmetic_steps.py**
-    ```python
-    import subprocess
-    from behave import given, when, then
-
-    @given('the CLI is initialized')
-    def step_given_cli_initialized(context):
-        context.cli_command = 'python path/to/your_arithmetic_script.py'
-
-    @when('the user runs the addition command with "{num1}" and "{num2}"')
-    def step_when_user_runs_addition_command(context, num1, num2):
-        context.result = subprocess.run(
-            [context.cli_command, 'add', num1, num2],
-            capture_output=True,
-            text=True
-        ).stdout.strip()
-
-    @when('the user runs the subtraction command with "{num1}" and "{num2}"')
-    def step_when_user_runs_subtraction_command(context, num1, num2):
-        context.result = subprocess.run(
-            [context.cli_command, 'subtract', num1, num2],
-            capture_output=True,
-            text=True
-        ).stdout.strip()
-
-    @then('the result should be "{expected_result}"')
-    def step_then_result_should_be(context, expected_result):
-        assert context.result == expected_result, f"Expected {expected_result} but got {context.result}"
-    ```
-
-    CLI Script as example production code to satisfiy the interfaces defined in the step definitions (DO NOT GENERATE ANY PRODUCTION CODE NOW):
-    **your_arithmetic_script.py**
-    ```python
-    import sys
-
-    def add(a, b):
-        return int(a) + int(b)
-
-    def subtract(a, b):
-        return int(a) - int(b)
-
-    if __name__ == "__main__":
-        if len(sys.argv) != 4:
-            print("Usage: python your_arithmetic_script.py <operation> <num1> <num2>")
-            sys.exit(1)
-
-        operation = sys.argv[1]
-        num1 = sys.argv[2]
-        num2 = sys.argv[3]
-
-        if operation == 'add':
-            print(add(num1, num2))
-        elif operation == 'subtract':
-            print(subtract(num1, num2))
-        else:
-            print(f"Unknown operation: {operation}")
-            sys.exit(1)
-    ```
-    """ 
-* Systematically search and check if any of the new step definitions is already existing in any given step file. It must then be omitted in the new step definitions generation. Otherwise it will create an ambiguous steps error in the behave registry.    
-* return the generated step definitions in this format:
-```python
-# [ ] extract
-# filename: {path/filename}.py
-{python code}
-```
-
-* The extract and filename statements are only allowed once per code block.
-* Adhere strictly to established rules for high-quality Python code and architecture.
-* If essential information is missing for code generation, issue a warning: "WARNING: Information is missing to do a correct step implementation." Specify what information is lacking and suggest how it might be retrieved.

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

@@ -1,20 +0,0 @@
-### COMMANDS FOR IMPLEMENTING THE INTENDED GOAL
-Your job is now:
-* Silently analyze the intended behavior and draft potential new implementations in pseudo code.
-* Silently review the provided source files to understand both the current behavior and the intended new implementation.
-* Develop implementation strategies that minimize code changes, prefer reusing existing methods over new implementations.
-* Output a "change table" listing all necessary changes. Include an example line for reference:
-  | filename       | method                                   | short description of intended changes      |
-  | {filename}.py  | {method name of existing or new method}  | {detailed explanation of the changes serving as code generation prompt}      |
-
-* Implement the changes as specified in the change table, 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
-
-* Adhere strictly to established rules for high-quality Python code and architecture.
-
-* If essential information is missing for code generation, issue a warning: "WARNING: Information is missing to do a correct implementation." Specify what information is lacking and suggest how it might be retrieved.

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

@@ -1,13 +0,0 @@
-### COMMANDS FOR AN OBVIOUS IMPLEMENTATION THE INTENDED GOAL
-Your job is now:
-* remember you are strictly following your given RULES AS EXPERT PYTHON DEVELOPER for code and architectural code quality
-* change only code that must changed
-* Implement the code 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 formulate the new aretefacts" and then explain what kind of information you think is missing and how I could easily retrieve it  

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

@@ -1,20 +0,0 @@
-### COMMANDS FOR ERROR FIXING
-Your job is now to fix the error:
-* Silently analyze the described error and draft a potential solution to the fix the error
-* Silently review the provided source files to understand both the current faulty implementation and the intended changes to fix the error.
-* Develop implementation strategies that minimize code changes, prefer reusing existing methods over new implementations.
-* Output a "change table" listing all necessary changes. Include an example line for reference:
-  | filename       | method                                   | short description of intended changes      |
-  | {filename}.py  | {method name of existing or new method}  | {detailed explanation of the changes serving as code generation prompt}      |
-
-* Implement the changes as specified in the change table, 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
-
-* Adhere strictly to established rules for high-quality Python code and architecture.
-
-* If essential information is missing for code generation, issue a warning: "WARNING: Information is missing to do a correct implementation." Specify what information is lacking and suggest how it might be retrieved.

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

@@ -1,18 +0,0 @@
-### COMMANDS FOR UPDATING THE FORMULATION OF FEATURE FILES
-Your job is now:
-* Examine the designated feature file, ensuring it aligns with the content and its relationships within the context files.
-* If there is a discrepancy between the feature's specifications and the system behavior described in the context files, defer to the behavior outlined in the context files. This also applies to behaviors not yet described in the existing feature file.
-* return a table of your five top rated proposed enhancements sorted by the "Formulation enhancement rating" and formatted in the following way (one example line is given as reference):
-| Number | filename | Scenario name | Line of feature file (from - to) | Formulation enhancement rating (0 - 1) | explanation of enhancement | 
-| 1      | file.feature  | some_scenario | 30-65                    | 0.9                             | {here comes an explanation and reasoning of the updated formulation and a reference to the context source} |
-
-* Propose a revised formulation for the feature file based on the analysis.
-* wrap and return the revised formulation in the following format 
-```artefact
-# [ ] extract 
-# filename: {path/artefac_filename.feature} 
-{formulation}
-```
-* 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 update the formulation of the designated feature file" and then explain what kind of information you think is missing and how I could easily retrieve it