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

ara_cli/chat_agent/agent_process_manager.py

@@ -0,0 +1,211 @@
+from ara_cli.chat_agent.agent_workspace_manager import AgentWorkspaceManager
+from ara_cli.error_handler import AraError, ErrorLevel
+from ara_cli.chat_agent.agent_status_manager import AgentStatusManager
+from ara_cli.chat_agent.agent_communicator import AgentCommunicator
+import os
+import subprocess
+import threading
+import psutil
+import queue
+
+
+class AgentProcessManager:
+    _instance = None
+
+    def __new__(cls, chat_instance=None):
+        if cls._instance is None:
+            cls._instance = super(AgentProcessManager, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self, chat_instance=None):
+        if hasattr(self, "_initialized") and self._initialized:
+            if chat_instance:
+                self.chat_instance = chat_instance
+            return
+        if chat_instance is None:
+            raise ValueError(
+                "chat_instance must be provided for the first instantiation"
+            )
+
+        self.chat_instance = chat_instance
+        self.agent_process = None
+        self.agent_reader_thread = None
+        self.agent_output_queue = queue.Queue()
+        self.agent_mode = False
+        self.agent_name = None
+        self.status_manager = AgentStatusManager()
+        self._initialized = True
+
+    def cleanup_agent_process(self):
+        pid = self.status_manager.get_agent_pid()
+        if pid and psutil.pid_exists(pid):
+            try:
+                p = psutil.Process(pid)
+                p.terminate()
+                p.wait(timeout=3)
+            except (psutil.NoSuchProcess, psutil.TimeoutExpired):
+                pass
+
+        self.status_manager.clear_status()
+
+        if self.agent_process:
+            try:
+                self.agent_process.terminate()
+            except:
+                pass
+            self.agent_process = None
+
+        if self.agent_reader_thread and self.agent_reader_thread.is_alive():
+            self.agent_reader_thread = None
+
+        self.agent_mode = False
+        self.agent_name = None
+        if hasattr(self, "chat_instance"):
+            self.chat_instance.prompt = "ara> "
+
+    def start_agent(
+        self, agent_name, initial_prompt, artefact_classifier=None, artefact_name=None
+    ):
+        if self.get_agent_status() != "No agent is currently running.":
+            raise AraError(
+                "An agent is already running. Use AGENT_STOP to stop it first."
+            )
+
+        if agent_name not in self.chat_instance.AVAILABLE_AGENTS:
+            raise AraError(f"Unknown agent: {agent_name}")
+
+        base_work_dir = AgentWorkspaceManager.determine_base_work_dir(
+            self.chat_instance
+        )
+        agent_workspace_dir = AgentWorkspaceManager.determine_agent_workspace(
+            self.chat_instance, artefact_classifier, artefact_name
+        )
+
+        cmd = [
+            "ara-agents",
+            agent_name,
+            "-u",
+            initial_prompt,
+            "-g",
+            "roundrobin",
+            "-b",
+            ".",
+            "-s",
+        ]
+
+        if artefact_classifier and artefact_name:
+            try:
+                artefact_path = self._find_artefact_path(
+                    artefact_classifier, artefact_name
+                )
+                cmd.extend(["-r", artefact_path])
+                print(f"Starting {agent_name} with artefact: {artefact_path}")
+                print(f"Base work directory: {base_work_dir}")
+                print(f"Agent logs directory: {agent_workspace_dir}")
+            except AraError as e:
+                raise AraError(f"Error: {e}")
+        else:
+            print(f"Starting {agent_name}...")
+            print(f"Base work directory: {base_work_dir}")
+            print(f"Agent logs directory: {agent_workspace_dir}")
+
+        env = os.environ.copy()
+        env["CENTRAL_LOG_PATH"] = os.path.join(
+            agent_workspace_dir, "io_context.log")
+
+        try:
+            self.agent_process = subprocess.Popen(
+                cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                cwd=base_work_dir,
+                env=env,
+            )
+            self.agent_name = agent_name
+            self.status_manager.write_status(
+                self.agent_process.pid, self.agent_name, "processing"
+            )
+
+            communicator = AgentCommunicator(self)
+            self.agent_reader_thread = threading.Thread(
+                target=communicator.read_agent_output, daemon=True
+            )
+            self.agent_reader_thread.start()
+
+            print(f"Agent {agent_name} started. Waiting for response...\n")
+            communicator.process_agent_output()
+
+        except FileNotFoundError:
+            raise AraError(
+                "Agent could not started."
+                "\nReason: 'ara-agents' command not found. Make sure ara-agents is locally installed.",
+                level=ErrorLevel.CRITICAL,
+            )
+        except Exception as e:
+            self.cleanup_agent_process()
+            raise AraError(f"Error starting agent: {e}")
+
+    def _find_artefact_path(self, artefact_classifier, artefact_name):
+        from ara_cli.classifier import Classifier
+
+        classifier_dir = Classifier.get_sub_directory(artefact_classifier)
+        if not classifier_dir:
+            raise AraError(f"Unknown classifier: {artefact_classifier}")
+
+        chat_dir = os.path.dirname(self.chat_instance.chat_name)
+        ara_dir = os.path.join(chat_dir, "ara", classifier_dir)
+
+        for ext in [artefact_classifier, "md"]:
+            artefact_path = os.path.join(ara_dir, f"{artefact_name}.{ext}")
+            if os.path.exists(artefact_path):
+                return artefact_path
+
+        raise AraError(
+            f"Artefact not found: {artefact_name}.{artefact_classifier}")
+
+    def send_to_agent(self, text):
+        if not self.agent_process or self.agent_process.poll() is not None:
+            print("Error: Agent process is not running")
+            self.cleanup_agent_process()
+            return
+
+        try:
+            self.agent_process.stdin.write(text + "\n")
+            self.agent_process.stdin.flush()
+
+            self.agent_mode = False
+            self.chat_instance.prompt = "ara> "
+            self.status_manager.update_status_file(mode="processing")
+
+            communicator = AgentCommunicator(self)
+            communicator.process_agent_output()
+
+        except Exception as e:
+            print(f"Error sending to agent: {e}")
+            self.cleanup_agent_process()
+
+    def continue_agent(self):
+        status = self.get_agent_status()
+        if "No agent" in status:
+            print("No agent is currently running.")
+            return
+
+        if not self.agent_process or self.agent_process.poll() is not None:
+            print(
+                "AGENT_CONTINUE can only be used from the chat interface that started the agent."
+            )
+            return
+
+        if not self.agent_mode:
+            print("Agent is not waiting for input. Wait for 'ara-agent>' prompt.")
+            return
+
+        print("Continuing agent with empty input...")
+        self.send_to_agent("")
+
+    def get_agent_status(self):
+        return self.status_manager.get_agent_status()

ara_cli/chat_agent/agent_status_manager.py

@@ -0,0 +1,73 @@
+import os
+import json
+import psutil
+from ara_cli.directory_navigator import DirectoryNavigator
+
+
+class AgentStatusManager:
+    def get_status_file_path(self):
+        ara_root = DirectoryNavigator.find_ara_directory_root()
+        if not ara_root:
+            return None
+        return os.path.join(ara_root, ".araconfig", "agent_status.json")
+
+    def get_agent_pid(self):
+        status_file = self.get_status_file_path()
+        if not status_file or not os.path.exists(status_file):
+            return None
+
+        with open(status_file, "r") as f:
+            try:
+                status = json.load(f)
+                return status.get("pid")
+            except json.JSONDecodeError:
+                return None
+
+    def update_status_file(self, mode):
+        status_file = self.get_status_file_path()
+        if not status_file or not os.path.exists(status_file):
+            return
+
+        try:
+            with open(status_file, "r") as f:
+                status = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            return
+
+        status["mode"] = mode
+
+        with open(status_file, "w") as f:
+            json.dump(status, f)
+
+    def get_agent_status(self):
+        status_file = self.get_status_file_path()
+        if not status_file or not os.path.exists(status_file):
+            return "No agent is currently running."
+
+        with open(status_file, "r") as f:
+            try:
+                status = json.load(f)
+            except json.JSONDecodeError:
+                return "No agent is currently running."
+
+        pid = status.get("pid")
+        if not pid or not psutil.pid_exists(pid):
+            if os.path.exists(status_file):
+                os.remove(status_file)
+            return "No agent is currently running."
+
+        name = status.get("name")
+        mode = status.get("mode")
+        return f"Agent: {name} (running - {mode})"
+
+    def write_status(self, pid, name, mode):
+        status = {"pid": pid, "name": name, "mode": mode}
+        status_file = self.get_status_file_path()
+        if status_file:
+            with open(status_file, "w") as f:
+                json.dump(status, f)
+
+    def clear_status(self):
+        status_file = self.get_status_file_path()
+        if status_file and os.path.exists(status_file):
+            os.remove(status_file)

ara_cli/chat_agent/agent_workspace_manager.py

@@ -0,0 +1,76 @@
+from ara_cli.error_handler import AraError
+
+import os
+
+
+class AgentWorkspaceManager:
+    """Manages workspace directories for agent execution."""
+
+    @staticmethod
+    def determine_agent_workspace(chat_instance, artefact_classifier=None, artefact_name=None):
+        """
+        Determines the appropriate workspace directory for agent logs and data.
+
+        Args:
+            chat_instance: The Chat instance
+            artefact_classifier: Optional artefact classifier (e.g., 'feature')
+            artefact_name: Optional artefact name
+
+        Returns:
+            str: Absolute path to the agent workspace directory (for logs)
+        """
+        base_directory = os.path.dirname(chat_instance.chat_name)
+
+        if artefact_classifier and artefact_name:
+            # Use artefact-specific workspace for logs
+            from ara_cli.classifier import Classifier
+            classifier_dir = Classifier.get_sub_directory(artefact_classifier)
+            if not classifier_dir:
+                raise AraError(f"Unknown classifier: {artefact_classifier}")
+
+            workspace_dir = os.path.join(
+                base_directory,
+                "ara",
+                classifier_dir,
+                f"{artefact_name}.data"
+            )
+        else:
+            # Use chat-specific workspace for logs
+            chat_name_without_ext = os.path.splitext(
+                os.path.basename(chat_instance.chat_name))[0]
+            workspace_dir = os.path.join(
+                base_directory,
+                "ara",
+                f"{chat_name_without_ext}"
+            )
+
+        # Ensure workspace directory exists
+        os.makedirs(workspace_dir, exist_ok=True)
+        return os.path.abspath(workspace_dir)
+
+    @staticmethod
+    def determine_base_work_dir(chat_instance):
+        """
+        Determines the base working directory (project root).
+
+        Args:
+            chat_instance: The Chat instance
+
+        Returns:
+            str: Absolute path to the project root directory
+        """
+
+        return os.path.dirname("./")
+        # The bwd should be the project root, not inside ara/
+        chat_dir = os.path.dirname(chat_instance.chat_name)
+
+        # Find project root by looking for 'ara' directory
+        current_dir = chat_dir
+        while True:
+            if os.path.isdir(os.path.join(current_dir, "ara")):
+                return os.path.abspath(current_dir)
+            parent_dir = os.path.dirname(current_dir)
+            if parent_dir == current_dir:  # Reached filesystem root
+                # Fallback to chat directory if no 'ara' folder found
+                return os.path.abspath(chat_dir)
+            current_dir = parent_dir

ara_cli/directory_navigator.py

@@ -1,4 +1,5 @@
 import os
+import sys
 from os.path import join, exists, isdir, dirname, basename
 # from ara_cli.directory_searcher import DirectorySearcher
 
@@ -23,7 +24,8 @@ class DirectoryNavigator:
             return original_directory
 
         current_directory = original_directory
-        while current_directory != dirname(current_directory):  # Ensure loop breaks at root
+        # Ensure loop breaks at root
+        while current_directory != dirname(current_directory):
             potential_path = join(current_directory, self.target_directory)
             if self.exists(potential_path):
                 os.chdir(potential_path)
@@ -31,7 +33,8 @@ class DirectoryNavigator:
             current_directory = dirname(current_directory)
 
         # If the loop completes, the target directory was not found
-        user_input = input(f"Unable to locate the '{self.target_directory}' directory. Do you want to create an 'ara' folder in the working directory? (y/N): ").strip().lower()
+        user_input = input(
+            f"Unable to locate the '{self.target_directory}' directory. Do you want to create an 'ara' folder in the working directory? (y/N): ").strip().lower()
 
         if user_input == '' or user_input == 'y':
             ara_folder_path = join(original_directory, 'ara')
@@ -40,7 +43,8 @@ class DirectoryNavigator:
             os.chdir(ara_folder_path)
             return original_directory
         else:
-            print(f"Unable to locate the '{self.target_directory}' directory and user declined to create 'ara' folder.")
+            print(
+                f"Unable to locate the '{self.target_directory}' directory and user declined to create 'ara' folder.")
             sys.exit(0)
 
     def navigate_to_relative(self, relative_path):
@@ -56,7 +60,36 @@ class DirectoryNavigator:
         if self.exists(path):
             os.chdir(path)
         else:
-            raise Exception(f"Unable to navigate to '{relative_path}' relative to the target directory.")
+            raise Exception(
+                f"Unable to navigate to '{relative_path}' relative to the target directory.")
+
+    @staticmethod
+    def find_ara_directory_root():
+        """Find the root ara directory by traversing up the directory tree."""
+        current_dir = os.getcwd()
+
+        # Check if we're already inside an ara directory structure
+        path_parts = current_dir.split(os.sep)
+
+        # Look for 'ara' in the path parts
+        if 'ara' in path_parts:
+            ara_index = path_parts.index('ara')
+            # Reconstruct path up to and including 'ara'
+            ara_root_parts = path_parts[:ara_index + 1]
+            potential_ara_root = os.sep.join(ara_root_parts)
+            if os.path.exists(potential_ara_root) and os.path.isdir(potential_ara_root):
+                return potential_ara_root
+
+        # If not inside ara directory, check current directory and parents
+        check_dir = current_dir
+        # Stop at filesystem root
+        while check_dir != os.path.dirname(check_dir):
+            ara_path = os.path.join(check_dir, 'ara')
+            if os.path.exists(ara_path) and os.path.isdir(ara_path):
+                return ara_path
+            check_dir = os.path.dirname(check_dir)
+
+        return None
 
     # debug version
     # def get_ara_directory(self):

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

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.**