ara-cli 0.1.10.0__py3-none-any.whl → 0.1.13.3__py3-none-any.whl

ara_cli/template_manager.py

@@ -5,6 +5,7 @@ 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
+from ara_cli.constants import VALID_ASPECTS
 
 
 class TemplatePathManager:
@@ -27,7 +28,10 @@ class TemplatePathManager:
         base_path = self.get_template_base_path_aspects()
         return [
             (base_path / f"template.{aspect}.md", f"{aspect}.md"),
-            (base_path / f"template.{aspect}.exploration.md", f"{aspect}.exploration.md")
+            (
+                base_path / f"template.{aspect}.exploration.md",
+                f"{aspect}.exploration.md",
+            ),
         ]
 
     def get_template_content(self, classifier):
@@ -63,7 +67,9 @@ class ArtefactFileManager:
                 os.mkdir(data_dir)
             os.chdir(data_dir)
         else:
-            raise ValueError(f"File {artefact_file_path} does not exist. Please create it first.")
+            raise ValueError(
+                f"File {artefact_file_path} does not exist. Please create it first."
+            )
 
     def copy_aspect_templates_to_directory(self, aspect, print_relative_to=""):
         """Copies the templates for the given aspect to the current directory."""
@@ -84,7 +90,9 @@ class ArtefactFileManager:
         steps_file_path = f"features/steps/{artefact_name}_steps.py"
 
         behave_command = f"behave features/{artefact_name}.feature"
-        result = subprocess.run(behave_command, shell=True, capture_output=True, text=True)
+        result = subprocess.run(
+            behave_command, shell=True, capture_output=True, text=True
+        )
 
         # Stderr command output needs to be reduced to only given-when-then statements
         if len(result.stderr) == 0:
@@ -94,26 +102,34 @@ class ArtefactFileManager:
 
     def format_behave_command_output(self, raw_result):
         # Split the input string by lines
-        lines = raw_result.split('\n')
+        lines = raw_result.split("\n")
 
         # Find the first given/when/then and last raise NotImplementedError line
         keywords = ["@given", "@when", "@then"]
-        start_index = next(i for i, line in enumerate(lines) if any(keyword in line for keyword in keywords))
-        end_index = next(i for i, line in reversed(list(enumerate(lines))) if "raise NotImplementedError" in line)
+        start_index = next(
+            i
+            for i, line in enumerate(lines)
+            if any(keyword in line for keyword in keywords)
+        )
+        end_index = next(
+            i
+            for i, line in reversed(list(enumerate(lines)))
+            if "raise NotImplementedError" in line
+        )
 
         # Extract the relevant given-when-then portion
-        formatted_code = '\n'.join(lines[start_index:end_index + 1])
+        formatted_code = "\n".join(lines[start_index : end_index + 1])
         return formatted_code
 
     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', encoding='utf-8') as file:
+        with open(file_path, "w", encoding="utf-8") as file:
             file.write(behave_steps)
 
 
 class SpecificationBreakdownAspects:
-    VALID_ASPECTS = ['technology', 'concept', 'persona', 'customer', 'step']
+    VALID_ASPECTS = VALID_ASPECTS
 
     def __init__(self):
         self.file_manager = ArtefactFileManager()
@@ -123,34 +139,49 @@ class SpecificationBreakdownAspects:
         if artefact_name in Classifier.valid_classifiers:
             raise ValueError(f"{artefact_name} is not a valid artefact name")
 
-        if not Classifier.is_valid_classifier(classifier) or classifier in self.VALID_ASPECTS:
+        if (
+            not Classifier.is_valid_classifier(classifier)
+            or classifier in self.VALID_ASPECTS
+        ):
             raise ValueError(f"{classifier} is not a valid classifier.")
 
         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'):
+            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()
         navigator.navigate_to_target()
 
         self.validate_input(artefact_name, classifier, aspect)
-        artefact_file_path = self.file_manager.get_artefact_file_path(artefact_name, classifier)
+        artefact_file_path = self.file_manager.get_artefact_file_path(
+            artefact_name, classifier
+        )
         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"):
+        self.file_manager.copy_aspect_templates_to_directory(
+            aspect, print_relative_to=original_directory
+        )
+
+        if aspect == "step":
             # 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:
+                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)
+                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)
+        os.chdir(original_directory)

ara_cli/templates/global-scripts/hello_global.py

@@ -0,0 +1 @@
+print('Hello Global')

ara_cli/templates/prompt-modules/commands/add_scenarios_for_new_behaviour.feature_creation_agent.commands.md

@@ -0,0 +1 @@
+Given the existing feature file {feature_file_path} and the implementation change described in {implementation_change_reference} (for example, a specific source file or change request), create new scenarios and update the feature file directly so that the new behaviour is fully covered.

ara_cli/templates/prompt-modules/commands/align_feature_with_implementation_changes.interview_agent.commands.md

@@ -0,0 +1 @@
+I have changed the implementation file {updated_implementation_file_path} by adding new functionality after the existing comment markers. Update the related feature file {feature_file_path} so that the Then-steps match the new behaviour and, if needed, create additional scenarios to cover the new logic.

ara_cli/templates/prompt-modules/commands/analyze_codebase_and_plan_tasks.interview_agent.commands.md

@@ -0,0 +1 @@
+Analyse the codebase and all related feature files using the semantic search tool {codebase_collector_tool_name} (either codebase_collector_features or codebase_collector_frontend, depending on the project). Use a detailed semantic query {codebase_query_description} derived from the user story in {user_story_task_file_path}. Based on the retrieved context, list which new tasks are needed for code changes, tests, and documentation. Then, use the appropriate agents (autocoder_behavetests_agent, autocoder_agent, documentation_agent, feature_creation_agent, test_generation_agent, web_autocoder_agent) so that the necessary feature files and tests are created or updated according to your findings.

ara_cli/templates/prompt-modules/commands/choose_best_parent_artefact.interview_agent.commands.md

@@ -0,0 +1 @@
+Using the find_the_best_suited_parent_artefact tool for the given artifact, determine which artefact is best suited to capture the value. Explain your reasoning and, if needed, propose concrete artefact names or formats.

ara_cli/templates/prompt-modules/commands/create_tasks_from_artefact_content.interview_agent.commands.md

@@ -0,0 +1 @@
+From the artefact content at {example_artefact_file_path}, create a set of implementation tasks with the exact specified names and content and assign them logically to the responsible user {assignee_identifier}. Do not modify the provided task texts; just materialise them as individual task entries in the appropriate location.

ara_cli/templates/prompt-modules/commands/create_tests_for_uncovered_modules.test_generation_agent.commands.md

@@ -0,0 +1 @@
+Create pytest tests for all modules that currently have 0% coverage according to the coverage report at {coverage_report_path}. Generate test files for each uncovered module in {tests_output_directory}, ensuring that basic behaviour and key error cases are tested.

ara_cli/templates/prompt-modules/commands/derive_features_from_video_description.feature_creation_agent.commands.md

@@ -0,0 +1 @@
+Based on the information provided in the video described in {video_description_source} (or the attached video), derive the matching feature files and their content under {features_directory_path}. Use the parent user story in {user_story_file_path} and the existing matching rules in {matching_rules_file_path}, then update existing feature files or create new ones so that all described behaviours are covered.

ara_cli/templates/prompt-modules/commands/describe_agent_capabilities.agent.commands.md

@@ -0,0 +1 @@
+Describe in detail what this agent can do for the user. Focus on supported capabilities, limitations, and typical workflows, and output the description as user-facing documentation. Do not use any tools.

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/execute_scoped_todos_in_task.interview_agent.commands.md

@@ -0,0 +1 @@
+In the task file at {task_file_path}, there are multiple TODOs. Perform only the TODOs that relate to {todo_scope_description} (for example, Docker image builds, logging clean-up, or UI copy changes), implement the required changes, and then mark only those relevant TODOs as completed inside the task file.

ara_cli/templates/prompt-modules/commands/explain_single_file_purpose.interview_agent.commands.md

@@ -0,0 +1 @@
+What is this file about: {input_file_path}? Read the file using the appropriate tools and return a concise explanation of its purpose, structure, and key domain concepts.

ara_cli/templates/prompt-modules/commands/extract_file_information_bullets.interview_agent.commands.md

@@ -0,0 +1 @@
+Read the file at {input_file_path} and extract all key information into bullet points. Group the bullets by topic (for example: decisions, open questions, action items) and avoid repeating minor details.

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

ara_cli/templates/prompt-modules/commands/fix_failing_behave_step_definitions.interview_agent.commands.md

@@ -0,0 +1 @@
+After the feature file {feature_file_path} was updated to reflect the changed functionality in {implementation_file_path}, the step definitions in {step_definitions_file_path} started failing. Run behave for this feature file, observe the failures, fix the step definitions, write the changes to disk, and repeat the cycle until all scenarios pass.

ara_cli/templates/prompt-modules/commands/fix_failing_pytest_tests.interview_agent.commands.md

@@ -0,0 +1 @@
+After the implementation file {implementation_file_path} was updated, the tests in {pytest_file_path} are failing. Run pytest for this test file, observe the results, fix the tests, write the changes to disk, and run pytest again. Continue the cycle until all tests pass.

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

@@ -0,0 +1,47 @@
+You are to generate a response that may include Markdown, code blocks, or content that itself contains backticks.
+
+To ensure correct rendering follow this fencing policy:
+
+- Code files: wrap each file’s output in a triple-backtick fence labeled with the file extension (e.g., ```py, ```js, ```json).
+- Markdown or plain-text files: wrap each file’s output in a five-backtick fence labeled with md or txt (e.g., `````md or `````txt).
+- Do not use dynamic or variable-length fences. Only use:
+  - 3 backticks for code file types.
+  - 5 backticks for .md and .txt files.
+
+File block structure (mandatory, exact)
+- Each file must be returned in its own fenced block with this exact header format as the first two lines:
+  1) "# [x] extract"
+  2) "# filename: <absolute filepath>/<filename>.<extension>"
+- After these two lines, include the exact file content.
+- The first character of line 1 and line 2 inside the fence must be '#'.
+- The "# [x] extract" and "# filename:" headers must appear exactly once per fenced block.
+
+In case of nested code inside file contents
+- If the file content itself needs code blocks:
+  - Use standard triple backticks (```) inside the file content and for the outer fence five backticks (`````).
+  - For Markdown/Text files, this is safe because the outer fence is five backticks.
+  - For Code files, avoid embedding literal triple-backtick sequences inside the file content to prevent fence collisions. If unavoidable, ask the user to approve an .md/.txt wrapper instead.
+
+Template examples
+
+Code file (e.g., Python):
+```py
+# [x] extract
+# filename: /abs/path/app.py
+print("Hello")
+```
+
+Markdown file:
+`````md
+# [x] extract
+# filename: /abs/path/README.md
+# Project Title
+Some docs with a code block:
+
+```js
+console.log("hi");
+```
+`````
+
+
+

ara_cli/templates/prompt-modules/commands/generate_and_fix_pytest_tests.test_generation_agent.commands.md

@@ -0,0 +1 @@
+Generate pytest tests for the modules listed in {target_module_paths}, starting with {primary_module_name}. Aim for high coverage.

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

@@ -0,0 +1,95 @@
+# Tech Stack Prompt Template Transformer
+
+## PROMPT:
+You are a prompt template transformation specialist. Your task is to transform Python-specific prompt templates into equivalent templates for a different technology stack while maintaining the same structure, intent, and quality standards.
+
+### INPUT REQUIREMENTS:
+1. **Target Technology Stack** (MANDATORY): The technology stack to transform to (e.g., 'C#', 'Java', 'React', 'TypeScript', 'Go', 'Rust', etc.)
+2. **Source Prompt Templates** (MANDATORY): One or more Python prompt templates to transform
+
+### TRANSFORMATION RULES:
+1. **Preserve Structure and Intent**:
+   - Maintain the same logical flow and purpose of each prompt template
+   - Keep all sections and their hierarchical organization
+   - Preserve the extract/filename format for code generation
+
+2. **Technology-Specific Adaptations**:
+   - Replace Python-specific references with target technology equivalents
+   - Update file extensions (.py → appropriate extension for target stack)
+   - Adapt coding standards (PEP8 → target language conventions)
+   - Replace Python packages with target language equivalents
+   - Update testing frameworks (pytest/behave → target language testing tools)
+   - Adapt documentation styles (numpy docstrings → target language documentation)
+   - Update logging approaches to target language standards
+   - Adjust line/method/class length limits based on target language best practices. Prefer lower length limits.
+
+3. **Naming Convention**:
+   - Prefix each transformed template filename with the target technology
+   - Example: `python_bug_fixing_code.commands.md` → `csharp_bug_fixing_code.commands.md`
+
+4. **Output Format**:
+   - Return each transformed template as a complete, copy-pastable markdown file in 5-backticks
+   - 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 '#'
+   - Use this format for each transformed template:
+
+`````markdown
+# [ ] extract
+# filename: ara/.araconfig/custom-prompt-modules/commands/{technology}_{original_template_name}
+{transformed template content}
+`````
+
+5. Markdown code block handling in prompt templates
+   The first and the second line of the Markdown code blocks used in the prompt templates serve as extraction control commands. the '#' tags in the first and second line of the code blocks must not be replaced by any other symbols, independent of the technology for which the markdown code block response is defined 
+
+6. **Technology Mapping Guidelines**:
+   **For C#/.NET:**
+   - PEP8 → C# Coding Conventions (Microsoft guidelines)
+   - pytest → NUnit/xUnit/MSTest
+   - behave → SpecFlow
+   - unittest.mock → Moq/NSubstitute
+   - numpy docstrings → XML documentation comments
+   - logging package → ILogger/Serilog/NLog
+
+   **For Java:**
+   - PEP8 → Java Code Conventions (Oracle/Google style)
+   - pytest → JUnit/TestNG
+   - behave → Cucumber-JVM
+   - unittest.mock → Mockito/EasyMock
+   - numpy docstrings → Javadoc
+   - logging package → SLF4J/Log4j
+
+   **For JavaScript/TypeScript:**
+   - PEP8 → ESLint/Prettier standards
+   - pytest → Jest/Mocha/Vitest
+   - behave → Cucumber.js, Selenium
+   - unittest.mock → Jest mocks/Sinon
+   - numpy docstrings → JSDoc/TSDoc
+   - logging package → Winston/Bunyan/Pino
+
+   **For React:**
+   - Include React-specific patterns (components, hooks, state management)
+   - pytest → Jest/React Testing Library
+   - behave → Selenium 
+   - Add component testing guidelines
+   - Include JSX/TSX specific rules
+
+7. **Preserve Key Constraints**:
+   - Maintain separation of concerns and single responsibility principles
+   - Keep modular/extensible design requirements
+   - Preserve testability requirements
+   - Maintain observability/logging requirements
+
+### VALIDATION:
+- Ensure all Python-specific references are properly transformed
+- Verify file paths and extensions match target technology conventions
+- Confirm testing and mocking frameworks are appropriate for target stack
+- Check that documentation styles match target language standards
+
+### OUTPUT SPECIFICATION:
+- Replace '# [ ] extract' with '# [x] extract' in all output blocks
+- Ensure each template is complete and ready for extraction
+- Include a summary of key transformations made for each template
+
+---
+
+**Begin transformation after receiving target technology stack and source templates.**

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

@@ -0,0 +1,34 @@
+### COMMANDS FOR FIXING BUGS
+
+Your job is now to fix the described error:
+
+* Silently analyze the given error description or error log files
+* Silently review the provided source files and if given the provided feature file (specified behavior) to understand the current faulty implementation and draft silently a potential solution to fix the error
+* Develop implementation strategies that minimize code changes, prefer reusing existing methods over new implementations. Also always prefer to use existing python packages over your own implementation.
+
+When you touch code or need to generate code for bug fixing:
+* The max function or method length should not exceed 40 lines.
+* The max class length should not exceed 150 lines.
+* The max file length should not exceed 150 lines.
+* Split implementation files or functions/methods/classes in case they exceed their defined length maximum.
+* Apply as coding and design principle the separation of concerns and single responsibility principle in general and specifically when you need to split.
+
+* Important: you are NOT allowed to do any further refactorings not related to the bug fixing implementation. Refactoring for enhancing the code quality is not allowed.
+* The fixed code must fully implement the specified behavior in an easy testable and modular/extensible way.
+* Follow PEP8 coding guidelines.
+* Use descriptive numpy style docstrings for inline method and class documentation.
+* Use the python logger logging package to implement logging for all application modules that enables a fine granular full observability of the program flow by the log file. Use ./logs/<module_name>.log as filepath for logging.
+
+* Only return full copy pastable file content.
+* Use for every single generated code block this markdown code block format:
+
+```python
+# [ ] extract
+# filename: src/{filename}.py
+{python code}
+```
+
+* The extract and filename statements are only allowed once per 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/python_generate_code.commands.md

@@ -0,0 +1,27 @@
+### COMMANDS FOR IMPLEMENTING ONE OR A SET OF NEW OR CHANGED FEATURE FILES
+
+Your job is now:
+* Silently analyze the given feature files and the specified behavior.
+* Develop implementation strategies that minimize code changes with respect to any given code and test files, prefer reusing existing methods over new implementations.
+* The max function length should not exceed 25 lines. The max file length should not exceed 120 lines.
+* Always prefer to use existing python packages over your own implementation.
+* In case additional implementation instructions are given as:
+  * Specified in files with extensions "*.technology.md" follow strictly the specified mandatory python packages and tech stack
+  * Explicitly specified as example reference implementation: use this reference information as starting point for your own implementation
+* Fully implement the specified behavior in an easy testable and modular/extensible way, fully implement unit tests for your production code (try to achieve at least 90% code coverage) and implement for all given feature files the corresponding step definitions. Follow PEP8 coding guidelines, use numpy style docstrings for inline function documentation, apply as coding and design principle the separation of concerns and single responsibility principle.
+* Generated or reworked python methods must not exceed 25 lines of code. In case methods exceed this length they need to be split according to the single responsibility principle and separation of concerns.
+* Generated or reworked python files must not exceed 120 lines of code. In case files exceed this length they need to be split according to the single responsibility principle and separation of concerns.
+* Use the python logger logging package to implement logging for all application modules that enable a full observability of the program flow over the log file. Use ./logs/<module_name>.log as filepath for logging.
+
+* Only return full copy pastable file content for production code, unit test files and step definition files. Use for every single generated code block this markdown code block 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/python_refactoring_code.commands.md

@@ -0,0 +1,39 @@
+### COMMANDS FOR REFACTORING
+
+Your job is now to refactor the code for enhancing the code quality and the design of the code according to the following guidelines:
+* Refactoring = Changing the internal structure of code
+* Without changing its external behavior
+* Goal = Improve readability, maintainability, and design
+-> "Refactoring is a change made to the internal structure of software to make it easier to understand and cheaper to modify without changing its observable behavior."
+-> "Refactoring changes how code is written, not what it does."
+
+Now do:
+* Silently analyze the given code base
+* Silently analyze the given feature file (specified behavior) to fully understand the flow and logic of the current implementation. Remember: you are not allowed to change specified behavior.
+
+When you refactor the code remember:
+* The max function or method length should not exceed 40 lines.
+* The max class length should not exceed 150 lines.
+* The max file length should not exceed 150 lines.
+* Split implementation files or functions/methods/classes in case they exceed their defined length maximum.
+* Apply as coding and design principle the separation of concerns and single responsibility principle in general and specifically when you need to split.
+* Flatten nested code structures (e.g. if/while/for statements) to only one nesting level.
+* The refactored code must fully implement the specified behavior in an easy testable and modular/extensible way.
+* Follow PEP8 coding guidelines.
+* Use descriptive numpy style docstrings for inline method and class documentation.
+* Use the python logger logging package to implement logging for all application modules that enables a fine granular full observability of the program flow by the log file. Use ./logs/<module_name>.log as filepath for logging.
+
+Your output specification is:
+* Only return full copy pastable file content.
+* Use for every single generated code block this markdown code block 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