Create AGENTS.md Repository Guidelines Document

[TerminallyLazy]

You're given a task to write a collection of rules, context and guidelines on the repository you're provided. Please gather context on the following categories, then write an AGENTS.md file in the root of the repository.

• General Rules: These are general rules any developer/agent should follow when writing code. It should contain rules such as "When creating new XYZ functions, always first search in the XYZ/ directory to see if one exists, and if not, create it and place it in an existing or new file". Additionally, here is where you'd include context about scripts which are commonly executed, such as linter and formatter scripts.
• Repository Structure: This section is where you'll include high level context about how the repository is laid out, any highly useful and not overly obvious information about how the directories/files are structured, different apps/packages/services inside the repository, etc. Do not include every last detail about the repository contents, only a high level technical overview on the repository structure.
• Dependencies and Installation: This section should include high level context about how to install dependencies, where to install them, package managers, etc. Do not include overly verbose context in this section as most repositories typically have straightforward dependency management.
• Testing Instructions: A general guide on testing in this repository. It should include context such as testing frameworks, roughly what types of modules should be tested, how to run tests, and any other context a developer wouldn't be able to infer by looking at test files on how to write & run tests. Do not include every last detail about testing in this section, only the most used/important context necessary to run tests.
• Pull request formatting: Rules and guidelines around how to format pull request titles and descriptions. This should only be populated if you find specific instructions in the repository around how to format pull request titles and descriptions. If the repository does not have specific instructions, leave this section empty. The agent will already generate well thought out titles and descriptions, so unless there are special rules specific to this repository, leave this section empty.

Ensure each category is properly wrapped in opening and closing XML tags. The tags to use are as follows:
<general_rules>
</general_rules>
<repository_structure>
</repository_structure>
<dependencies_and_installation>
</dependencies_and_installation>
<testing_instructions>
</testing_instructions>
<pull_request_formatting>
</pull_request_formatting>

It is incredibly important that you ALWAYS wrap your sections in the opening and closing XML tags. Failure to do so will result in an invalid file and will not be accepted.

The file should not contain any other content besides those tags, and the rules/context/instructions they contain. Ensure your rules are thoughtful, concise and actually useful to a developer who's never contributed to the repository before. You can think of it as a more structured and directed CONTRIBUTING.md file.

With all of this in mind, please explore the repository and write this single AGENTS.md file with the rules/context/instructions gathered!

Agent Context

[ "**Implement Planner Agent Tools:**\n- Create the `agents/swe-planner/tools/plan_manager.py` file with the following content to manage the development plan within the `GraphState`:\n```python\nfrom python.helpers.tool import Tool\nfrom python.helpers.tool_response import ToolResponse\nfrom python.helpers.swe_graph_state import GraphState, Plan, Task\n\nclass PlanManager(Tool):\n \"\"\"\n A tool for creating and managing the development plan.\n \"\"\"\n def __init__(self, agent_context):\n super().__init__(agent_context)\n self.register_tool(\n \"create_plan\",\n \"Creates the initial development plan.\",\n {\"goal\": \"The high-level goal of the plan.\"}\n )\n self.register_tool(\n \"add_task\",\n \"Adds a new task to the existing plan.\",\n {\"description\": \"The detailed description of the task.\"}\n )\n\n async def create_plan(self, **kwargs) -> ToolResponse:\n goal = kwargs.get(\"goal\")\n if not goal:\n return ToolResponse.error(\"The 'goal' argument is required.\")\n \n state: GraphState = self.agent_context.get_state()\n state.plan = Plan(goal=goal)\n self.agent_context.set_state(state)\n \n return ToolResponse.success(f\"Successfully created a new plan with the goal: {goal}\")\n\n async def add_task(self, **kwargs) -> ToolResponse:\n description = kwargs.get(\"description\")\n if not description:\n return ToolResponse.error(\"The 'description' argument is required.\")\n \n state: GraphState = self.agent_context.get_state()\n if not state.plan:\n return ToolResponse.error(\"A plan must be created before adding tasks.\")\n \n new_task_id = len(state.plan.tasks) + 1\n new_task = Task(id=new_task_id, description=description)\n state.plan.tasks.append(new_task)\n self.agent_context.set_state(state)\n \n return ToolResponse.success(f\"Successfully added task {new_task_id}: {description}\")\n```\n- Create the `agents/swe-planner/tools/rules_parser.py` file with the following content to parse `AGENTS.md`:\n```python\nimport re\nfrom python.helpers.tool import Tool\nfrom python.helpers.tool_response import ToolResponse\nfrom python.helpers.swe_graph_state import GraphState\n\nclass RulesParser(Tool):\n \"\"\"\n A tool for parsing AGENTS.md and loading custom rules into the GraphState.\n \"\"\"\n def __init__(self, agent_context):\n super().__init__(agent_context)\n self.register_tool(\n \"parse_agents_md\",\n \"Parses the AGENTS.md file from the target repository.\",\n {\"file_content\": \"The full content of the AGENTS.md file.\"}\n )\n\n async def parse_agents_md(self, **kwargs) -> ToolResponse:\n content = kwargs.get(\"file_content\")\n if not content:\n return ToolResponse.error(\"The 'file_content' argument is required.\")\n\n state: GraphState = self.agent_context.get_state()\n \n tags = [\n \"general_rules\", \"repository_structure\", \"dependencies_and_installation\",\n \"testing_instructions\", \"pull_request_formatting\"\n ]\n \n for tag in tags:\n pattern = f\"<{tag}>(.*?)\"\n match = re.search(pattern, content, re.DOTALL)\n if match:\n state.custom_rules.rules[tag] = match.group(1).strip()\n \n self.agent_context.set_state(state)\n return ToolResponse.success(\"Successfully parsed AGENTS.md and updated custom rules in the state.\")\n```", "**Implement Programmer Agent Tools:**\n- Create the `agents/swe-programmer/tools/file_operations.py` file with functions for file manipulation:\n```python\nfrom python.helpers.tool import Tool\nfrom python.helpers.tool_response import ToolResponse\nimport os\n\nclass FileOperations(Tool):\n \"\"\"\n A tool for performing file operations like view, create, and modify.\n \"\"\"\n def __init__(self, agent_context):\n super().__init__(agent_context)\n self.register_tool(\"view_file\", \"Views the content of a file.\", {\"path\": \"The path to the file.\"})\n self.register_tool(\"create_file\", \"Creates a new file with content.\", {\"path\": \"The path to the new file.\", \"content\": \"The content to write.\"})\n self.register_tool(\"replace_in_file\", \"Replaces a string in a file.\", {\"path\": \"The path to the file.\", \"old_string\": \"The string to replace.\", \"new_string\": \"The new string.\"})\n\n async def view_file(self, **kwargs) -> ToolResponse:\n path = kwargs.get(\"path\")\n try:\n with open(path, 'r') as f:\n content = f.read()\n return ToolResponse.success(content)\n except Exception as e:\n return ToolResponse.error(f\"Failed to view file: {e}\")\n\n async def create_file(self, **kwargs) -> ToolResponse:\n path = kwargs.get(\"path\")\n content = kwargs.get(\"content\", \"\")\n try:\n os.makedirs(os.path.dirname(path), exist_ok=True)\n with open(path, 'w') as f:\n f.write(content)\n return ToolResponse.success(f\"File '{path}' created successfully.\")\n except Exception as e:\n return ToolResponse.error(f\"Failed to create file: {e}\")\n\n async def replace_in_file(self, **kwargs) -> ToolResponse:\n path = kwargs.get(\"path\")\n old_string = kwargs.get(\"old_string\")\n new_string = kwargs.get(\"new_string\")\n try:\n with open(path, 'r') as f:\n content = f.read()\n content = content.replace(old_string, new_string)\n with open(path, 'w') as f:\n f.write(content)\n return ToolResponse.success(f\"Replaced string in '{path}'.\")\n except Exception as e:\n return ToolResponse.error(f\"Failed to replace string in file: {e}\")\n```\n- Create the `agents/swe-programmer/tools/task_manager.py` file to update task status:\n```python\nfrom python.helpers.tool import Tool\nfrom python.helpers.tool_response import ToolResponse\nfrom python.helpers.swe_graph_state import GraphState\n\nclass TaskManager(Tool):\n \"\"\"\n A tool for managing the status of tasks in the plan.\n \"\"\"\n def __init__(self, agent_context):\n super().__init__(agent_context)\n self.register_tool(\n \"update_task_status\",\n \"Updates the status of a specific task.\",\n {\"task_id\": \"The ID of the task.\", \"status\": \"The new status (e.g., 'in-progress', 'completed').\"}\n )\n\n async def update_task_status(self, **kwargs) -> ToolResponse:\n task_id = kwargs.get(\"task_id\")\n status = kwargs.get(\"status\")\n if not task_id or not status:\n return ToolResponse.error(\"Both 'task_id' and 'status' are required.\")\n\n state: GraphState = self.agent_context.get_state()\n task_found = False\n for task in state.plan.tasks:\n if task.id == task_id:\n task.status = status\n task_found = True\n break\n \n if not task_found:\n return ToolResponse.error(f\"Task with ID {task_id} not found.\")\n \n self.agent_context.set_state(state)\n return ToolResponse.success(f\"Task {task_id} status updated to '{status}'.\")\n```", "**Implement Orchestration Logic and Update Documentation:**\n- Create a new tool `agents/swe-agent/tools/orchestrator.py` to manage the multi-agent workflow. This tool will use `call_subordinate` to chain the agents together.\n```python\nfrom python.helpers.tool import Tool\nfrom python.helpers.tool_response import ToolResponse\nfrom python.helpers.swe_graph_state import GraphState\nimport json\n\nclass Orchestrator(Tool):\n \"\"\"\n Orchestrates the SWE agent workflow by calling planner, programmer, and reviewer agents in sequence.\n \"\"\"\n def __init__(self, agent_context):\n super().__init__(agent_context)\n self.register_tool(\n \"run_swe_workflow\",\n \"Executes the full software engineering workflow for a given user request.\",\n {\"user_request\": \"The user's request for a software change.\"}\n )\n\n async def run_swe_workflow(self, **kwargs) -> ToolResponse:\n user_request = kwargs.get(\"user_request\")\n if not user_request:\n return ToolResponse.error(\"The 'user_request' argument is required.\")\n\n # Initialize the shared state\n graph_state = GraphState(plan=Plan(goal=user_request))\n state_json = json.dumps(graph_state.__dict__)\n\n # 1. Call Planner\n planner_response = await self.agent_context.call_subordinate(\n profile=\"swe-planner\",\n user_message=f\"Create a development plan for the following request: {user_request}\",\n state=state_json\n )\n if not planner_response.is_success():\n return ToolResponse.error(f\"Planner failed: {planner_response.message}\")\n \n state_json = planner_response.state\n \n # 2. Call Programmer for each task\n current_state = json.loads(state_json)\n tasks = current_state.get(\"plan\", {}).get(\"tasks\", [])\n for task in tasks:\n task_id = task.get(\"id\")\n task_description = task.get(\"description\")\n \n programmer_response = await self.agent_context.call_subordinate(\n profile=\"swe-programmer\",\n user_message=f\"Execute task {task_id}: {task_description}\",\n state=state_json\n )\n if not programmer_response.is_success():\n return ToolResponse.error(f\"Programmer failed on task {task_id}: {programmer_response.message}\")\n state_json = programmer_response.state\n\n # 3. Call Reviewer\n reviewer_response = await self.agent_context.call_subordinate(\n profile=\"swe-reviewer\",\n user_message=\"Review the implemented code against the original goal.\",\n state=state_json\n )\n if not reviewer_response.is_success():\n # Handle review feedback - for now, just report it\n return ToolResponse.warning(f\"Reviewer feedback: {reviewer_response.message}\")\n\n return ToolResponse.success(\"SWE workflow completed successfully.\")\n```\n- Update the `agents/swe-agent/README.md` to include details about the new tools and the orchestration logic.", "**Implement Core Settings Changes:**\n- Modify `python/helpers/settings.py` to recognize the new agent profiles. This involves adding `swe-planner`, `swe-programmer`, and `swe-reviewer` to the list of available profiles, likely within a function responsible for loading agent configurations.\n- A conceptual change to the `get_agent_config` function in `python/helpers/settings.py` would look like this:\n```python\n# This is a conceptual change and might not map directly to the existing code.\n# The goal is to show how the new profiles would be added.\n\ndef get_agent_config(profile_name: str):\n # ... existing logic to load default configs ...\n\n # Add new profiles to the list of valid profiles\n VALID_PROFILES = [\"default\", \"developer\", \"swe-planner\", \"swe-programmer\", \"swe-reviewer\"]\n if profile_name not in VALID_PROFILES:\n raise ValueError(f\"Unknown agent profile: {profile_name}\")\n\n # Load the base configuration for the profile\n profile_config = load_profile_config_from_file(f\"agents/{profile_name}/config.json\")\n \n # Merge with user settings and return\n # ... existing logic ...\n \n return final_config\n```\n- Ensure that the agent loading mechanism in `agent.py` can correctly instantiate an agent with one of the new profiles, loading the corresponding prompts and tools from the correct directories (`agents/swe-planner/`, etc.). This should work automatically if the directory structure is correct and the settings are loaded properly." ]

[open-swe]

🟠 Plan Ready for Approval 🟠

I've generated a plan for this issue and it's ready for your review.

Plan: Create AGENTS.md File

• Task 1:

Create the `AGENTS.md` file with the following content:

\```markdown
<general_rules>
- When creating new functions, first search in the relevant directory to see if a similar function already exists.
- The project follows PEP 8 style guidelines.
- While no specific linter or formatter is enforced, it is recommended to use tools like `black` for formatting and `ruff` or `pylint` for linting to maintain code quality.
</general_rules>
<repository_structure>
The repository is structured as follows:
- `python/`: Contains the core Python source code for the agent framework.
- `webui/`: Contains the source code for the web-based user interface.
- `docs/`: Contains all the documentation for the project.
- `agents/`: Contains example agent implementations.
- `docker/`: Contains Dockerfiles and related scripts for building and running the application in a containerized environment.
- `knowledge/`: Contains the knowledge base for the agent.
- `tests/`: Contains tests for the Python codebase.
</repository_structure>
<dependencies_and_installation>
- The project uses Python and its dependencies are listed in the `requirements.txt` file.
- To install the dependencies, you can use pip: `pip install -r requirements.txt`.
- For a complete setup, including the development environment, refer to the instructions in `docs/development.md`.
- The recommended way to run the application is by using Docker, as described in `docs/installation.md`.
</dependencies_and_installation>
<testing_instructions>
- The tests for the Python code are located in the `tests/` directory.
- To run the tests, you can execute the individual test files directly. For example: `python tests/test_fasta2a_client.py`
- There is no single command to run all tests, so they need to be run individually.
- When contributing, it is expected that you provide test results for your changes, as mentioned in `docs/contribution.md`.
</testing_instructions>
<pull_request_formatting>
- When submitting a pull request, please target the `development` branch.
- Provide a clear and descriptive title for your pull request.
- In the pull request description, explain the purpose and scope of your changes, including any relevant context and test results.
- There are no strict formatting rules for the pull request title and description, but clarity and detail are encouraged.
</pull_request_formatting>

- Task 2:

Create the AGENTS.md file with repository guidelines.

- Task 3:

Create AGENTS.md File

Please review the plan and let me know if you'd like me to proceed, make changes, or if you have any feedback.





<open-swe-plan-message>

### 🟠 Plan Ready for Approval 🟠

I've generated a plan for this issue and it's ready for your review.

**Plan: Implement Tools, Orchestration, and Settings for SWE-Agent Integration**

- Task 1:

Implement Planner Agent Tools:

• Create the agents/swe-planner/tools/plan_manager.py file with the following content to manage the development plan within the GraphState:
  ```python
  from python.helpers.tool import Tool
  from python.helpers.tool_response import ToolResponse
  from python.helpers.swe_graph_state import GraphState, Plan, Task

class PlanManager(Tool):
"""
A tool for creating and managing the development plan.
"""
def init(self, agent_context):
super().init(agent_context)
self.register_tool(
"create_plan",
"Creates the initial development plan.",
{"goal": "The high-level goal of the plan."}
)
self.register_tool(
"add_task",
"Adds a new task to the existing plan.",
{"description": "The detailed description of the task."}
)

async def create_plan(self, **kwargs) -> ToolResponse:
    goal = kwargs.get("goal")
    if not goal:
        return ToolResponse.error("The 'goal' argument is required.")
    
    state: GraphState = self.agent_context.get_state()
    state.plan = Plan(goal=goal)
    self.agent_context.set_state(state)
    
    return ToolResponse.success(f"Successfully created a new plan with the goal: {goal}")

async def add_task(self, **kwargs) -> ToolResponse:
    description = kwargs.get("description")
    if not description:
        return ToolResponse.error("The 'description' argument is required.")
        
    state: GraphState = self.agent_context.get_state()
    if not state.plan:
        return ToolResponse.error("A plan must be created before adding tasks.")
        
    new_task_id = len(state.plan.tasks) + 1
    new_task = Task(id=new_task_id, description=description)
    state.plan.tasks.append(new_task)
    self.agent_context.set_state(state)
    
    return ToolResponse.success(f"Successfully added task {new_task_id}: {description}")

- Create the `agents/swe-planner/tools/rules_parser.py` file with the following content to parse `AGENTS.md`:
```python
import re
from python.helpers.tool import Tool
from python.helpers.tool_response import ToolResponse
from python.helpers.swe_graph_state import GraphState

class RulesParser(Tool):
    """
    A tool for parsing AGENTS.md and loading custom rules into the GraphState.
    """
    def __init__(self, agent_context):
        super().__init__(agent_context)
        self.register_tool(
            "parse_agents_md",
            "Parses the AGENTS.md file from the target repository.",
            {"file_content": "The full content of the AGENTS.md file."}
        )

    async def parse_agents_md(self, **kwargs) -> ToolResponse:
        content = kwargs.get("file_content")
        if not content:
            return ToolResponse.error("The 'file_content' argument is required.")

        state: GraphState = self.agent_context.get_state()
        
        tags = [
            "general_rules", "repository_structure", "dependencies_and_installation",
            "testing_instructions", "pull_request_formatting"
        ]
        
        for tag in tags:
            pattern = f"<{tag}>(.*?)</{tag}>"
            match = re.search(pattern, content, re.DOTALL)
            if match:
                state.custom_rules.rules[tag] = match.group(1).strip()
        
        self.agent_context.set_state(state)
        return ToolResponse.success("Successfully parsed AGENTS.md and updated custom rules in the state.")

- Task 2:

Implement Programmer Agent Tools:

• Create the agents/swe-programmer/tools/file_operations.py file with functions for file manipulation:
  ```python
  from python.helpers.tool import Tool
  from python.helpers.tool_response import ToolResponse
  import os

class FileOperations(Tool):
"""
A tool for performing file operations like view, create, and modify.
"""
def init(self, agent_context):
super().init(agent_context)
self.register_tool("view_file", "Views the content of a file.", {"path": "The path to the file."})
self.register_tool("create_file", "Creates a new file with content.", {"path": "The path to the new file.", "content": "The content to write."})
self.register_tool("replace_in_file", "Replaces a string in a file.", {"path": "The path to the file.", "old_string": "The string to replace.", "new_string": "The new string."})

async def view_file(self, **kwargs) -> ToolResponse:
    path = kwargs.get("path")
    try:
        with open(path, 'r') as f:
            content = f.read()
        return ToolResponse.success(content)
    except Exception as e:
        return ToolResponse.error(f"Failed to view file: {e}")

async def create_file(self, **kwargs) -> ToolResponse:
    path = kwargs.get("path")
    content = kwargs.get("content", "")
    try:
        os.makedirs(os.path.dirname(path), exist_ok=True)
        with open(path, 'w') as f:
            f.write(content)
        return ToolResponse.success(f"File '{path}' created successfully.")
    except Exception as e:
        return ToolResponse.error(f"Failed to create file: {e}")

async def replace_in_file(self, **kwargs) -> ToolResponse:
    path = kwargs.get("path")
    old_string = kwargs.get("old_string")
    new_string = kwargs.get("new_string")
    try:
        with open(path, 'r') as f:
            content = f.read()
        content = content.replace(old_string, new_string)
        with open(path, 'w') as f:
            f.write(content)
        return ToolResponse.success(f"Replaced string in '{path}'.")
    except Exception as e:
        return ToolResponse.error(f"Failed to replace string in file: {e}")

- Create the `agents/swe-programmer/tools/task_manager.py` file to update task status:
```python
from python.helpers.tool import Tool
from python.helpers.tool_response import ToolResponse
from python.helpers.swe_graph_state import GraphState

class TaskManager(Tool):
    """
    A tool for managing the status of tasks in the plan.
    """
    def __init__(self, agent_context):
        super().__init__(agent_context)
        self.register_tool(
            "update_task_status",
            "Updates the status of a specific task.",
            {"task_id": "The ID of the task.", "status": "The new status (e.g., 'in-progress', 'completed')."}
        )

    async def update_task_status(self, **kwargs) -> ToolResponse:
        task_id = kwargs.get("task_id")
        status = kwargs.get("status")
        if not task_id or not status:
            return ToolResponse.error("Both 'task_id' and 'status' are required.")

        state: GraphState = self.agent_context.get_state()
        task_found = False
        for task in state.plan.tasks:
            if task.id == task_id:
                task.status = status
                task_found = True
                break
        
        if not task_found:
            return ToolResponse.error(f"Task with ID {task_id} not found.")
            
        self.agent_context.set_state(state)
        return ToolResponse.success(f"Task {task_id} status updated to '{status}'.")

- Task 3:

Implement Orchestration Logic and Update Documentation:

• Create a new tool agents/swe-agent/tools/orchestrator.py to manage the multi-agent workflow. This tool will use call_subordinate to chain the agents together.
  ```python
  from python.helpers.tool import Tool
  from python.helpers.tool_response import ToolResponse
  from python.helpers.swe_graph_state import GraphState
  import json

class Orchestrator(Tool):
"""
Orchestrates the SWE agent workflow by calling planner, programmer, and reviewer agents in sequence.
"""
def init(self, agent_context):
super().init(agent_context)
self.register_tool(
"run_swe_workflow",
"Executes the full software engineering workflow for a given user request.",
{"user_request": "The user's request for a software change."}
)

async def run_swe_workflow(self, **kwargs) -> ToolResponse:
    user_request = kwargs.get("user_request")
    if not user_request:
        return ToolResponse.error("The 'user_request' argument is required.")

    # Initialize the shared state
    graph_state = GraphState(plan=Plan(goal=user_request))
    state_json = json.dumps(graph_state.__dict__)

    # 1. Call Planner
    planner_response = await self.agent_context.call_subordinate(
        profile="swe-planner",
        user_message=f"Create a development plan for the following request: {user_request}",
        state=state_json
    )
    if not planner_response.is_success():
        return ToolResponse.error(f"Planner failed: {planner_response.message}")
    
    state_json = planner_response.state
    
    # 2. Call Programmer for each task
    current_state = json.loads(state_json)
    tasks = current_state.get("plan", {}).get("tasks", [])
    for task in tasks:
        task_id = task.get("id")
        task_description = task.get("description")
        
        programmer_response = await self.agent_context.call_subordinate(
            profile="swe-programmer",
            user_message=f"Execute task {task_id}: {task_description}",
            state=state_json
        )
        if not programmer_response.is_success():
            return ToolResponse.error(f"Programmer failed on task {task_id}: {programmer_response.message}")
        state_json = programmer_response.state

    # 3. Call Reviewer
    reviewer_response = await self.agent_context.call_subordinate(
        profile="swe-reviewer",
        user_message="Review the implemented code against the original goal.",
        state=state_json
    )
    if not reviewer_response.is_success():
        # Handle review feedback - for now, just report it
        return ToolResponse.warning(f"Reviewer feedback: {reviewer_response.message}")

    return ToolResponse.success("SWE workflow completed successfully.")

- Update the `agents/swe-agent/README.md` to include details about the new tools and the orchestration logic.

• Task 4:

**Implement Core Settings Changes:**
- Modify `python/helpers/settings.py` to recognize the new agent profiles. This involves adding `swe-planner`, `swe-programmer`, and `swe-reviewer` to the list of available profiles, likely within a function responsible for loading agent configurations.
- A conceptual change to the `get_agent_config` function in `python/helpers/settings.py` would look like this:
\```python
# This is a conceptual change and might not map directly to the existing code.
# The goal is to show how the new profiles would be added.

def get_agent_config(profile_name: str):
    # ... existing logic to load default configs ...

    # Add new profiles to the list of valid profiles
    VALID_PROFILES = ["default", "developer", "swe-planner", "swe-programmer", "swe-reviewer"]
    if profile_name not in VALID_PROFILES:
        raise ValueError(f"Unknown agent profile: {profile_name}")

    # Load the base configuration for the profile
    profile_config = load_profile_config_from_file(f"agents/{profile_name}/config.json")
    
    # Merge with user settings and return
    # ... existing logic ...
    
    return final_config

• Ensure that the agent loading mechanism in agent.py can correctly instantiate an agent with one of the new profiles, loading the corresponding prompts and tools from the correct directories (agents/swe-planner/, etc.). This should work automatically if the directory structure is correct and the settings are loaded properly.

Please review the plan and let me know if you'd like me to proceed, make changes, or if you have any feedback.

</open-swe-plan-message>

[TerminallyLazy]

I want to integrate the swe-agent into the Agent Zero framework as an Agent profile agents/ equipped witth the necessary prompts, integrated according to the Agent Zero framework build patterns. Given the two build prompts below, create a comprehensive build prompt to feed a coding LLM that will implement the swe-agent into the Agent Zero framework.

Project Overview

Create a complete Open-SWE (Software Engineering) Agent profile for the Agent Zero framework that provides autonomous software engineering capabilities. This integration should follow Agent Zero's established patterns and architecture.

Agent Profile Structure

Directory Structure: Create agents/swe-agent/ following the established pattern agents:1

Required Components:

1. Prompts Directory (agents/swe-agent/prompts/)

   • agent.system.main.role.md - Define the SWE agent's core identity and capabilities
   • agent.system.main.communication.md - Establish communication protocols and JSON response format
   • Tool-specific prompt files for each custom tool

2. Tools Directory (agents/swe-agent/tools/)

   • Custom tools extending the base Tool class architecture
   • Override default tools where SWE-specific behavior is needed

Technical Implementation Requirements

Tool Development Pattern: All tools must inherit from the base Tool class tool.py:14-26 and implement the required methods including async def execute(self, **kwargs) returning Response objects tool.py:9-12 .

Agent Configuration: The profile should be configurable via the AgentConfig.profile field agent.py:213 and loadable through the established agent loading mechanism [agent.py:818-824.

Core SWE Tools Implementation

Repository Analysis Tool:

• Analyze codebase structure, dependencies, and architecture
• Extract key components, interfaces, and data flows
• Identify technical debt and improvement opportunities

Code Generation Tool:

• Generate production-ready code following best practices
• Implement comprehensive error handling and logging
• Include unit tests and documentation

Testing Framework Tool:

• Create automated test suites (unit, integration, e2e)
• Implement CI/CD pipeline configurations
• Generate test coverage reports

Code Review Tool:

• Perform static code analysis
• Identify security vulnerabilities and performance issues
• Suggest refactoring opportunities

Documentation Tool:

• Generate API documentation
• Create architectural decision records
• Produce deployment and operational guides

Integration with Existing Framework

Code Execution Integration: Leverage the existing code execution tool code_execution_tool.py:22-62 for running development commands and scripts.

Subordinate Agent Orchestration: Use the delegation tool pattern call_subordinate.py:5-34 for complex multi-stage development tasks.

Browser Integration: Utilize existing browser tools for researching documentation and accessing web-based development resources.

System Prompt Requirements

Role Definition: Create a comprehensive role prompt similar to the developer agent structure agent.system.main.role.md:1-179 but focused specifically on software engineering tasks.

Communication Protocol: Implement the JSON-based communication pattern agent.system.main.communication.md:55-82 with "thoughts", "tool_name", and "tool_args" fields.

Quality Standards

Error Handling: Comprehensive exception handling following the framework's error management patterns agent.py:457-479.

Tool Integration: Proper tool lifecycle management with before_execution and after_execution hooks tool.py:28-42 .

Logging and Monitoring: Integration with the framework's logging system tool.py:44-49.

Essential Prompt Engineering Tips:

• Avoid prompting for "production-ready" code - this often leads to over-engineering
• Prompt Claude to write scripts to check its work: "After implementing, create a validation script"
• Avoid backwards compatibility unless specifically needed - Claude tends to preserve old code unnecessarily
• Focus on clarity and specific requirements rather than vague quality descriptors

Implementation Notes

The SWE agent should be capable of autonomous software development workflows including requirements analysis, architecture design, implementation, testing, and deployment. It should integrate seamlessly with the Agent Zero ecosystem while providing specialized software engineering capabilities that extend beyond the general-purpose developer agent.

Notes: This build spec is based on the Agent Zero framework patterns found in the codebase. The specific Open-SWE Agent capabilities and integration points would need to be researched from the external documentation links you provided, which I cannot access with my current tools. The framework provides excellent extensibility through its tool and profile system, making it well-suited for specialized agent implementations.

Integration Overview

Create a complete integration of the Open-SWE Agent into the Agent Zero framework as a specialized coding agent profile. Open-SWE is an asynchronous coding agent that autonomously understands codebases, plans solutions, and executes code changes across repositories README.md:13. The integration should maintain Open-SWE's core capabilities while adapting to Agent Zero's architecture.

Core Architecture Requirements

1. Agent Profile Structure

Implement the Open-SWE agent as multiple specialized profiles within Agent Zero, following the established pattern from the original architecture:

Planner Profile: Context gathering and planning specialist prompt.ts:1-10

Programmer Profile: Code execution and modification specialist prompt.ts:4-19

Reviewer Profile: Code review and validation specialist

2. System Prompts Integration

Planner Agent Prompt Structure:

• Identity and role definition prompt.ts:1-7
• Context gathering guidelines prompt.ts:15-37
• Tool usage specifications prompt.ts:39-77
• Custom rules integration prompt.ts:90

Programmer Agent Prompt Structure:

• Multi-component system with identity, behavior, and execution guidelines prompt.ts:4-28
• File and code management protocols prompt.ts:30-36
• Comprehensive tool usage best practices prompt.ts:38-50
• Coding standards and communication guidelines prompt.ts:52-78

3. Tool System Implementation

Implement comprehensive tool suite based on Open-SWE's architecture:

Core Development Tools:

• File operations (view, create, str_replace, insert) tools.ts:557-611
• Shell command execution tools.ts:63-90
• Advanced grep search functionality tools.ts:112-176

Project Management Tools:

• Plan generation and management tools.ts:45-61
• Task completion tracking tools.ts:309-329
• Dependency installation tools.ts:331-354

Context and Documentation Tools:

• URL content fetching tools.ts:408-422
• Document search capabilities tools.ts:452-473
• Scratchpad for note-taking tools.ts:378-394

4. State Management System

Implement comprehensive state tracking based on Open-SWE's GraphState:

Task and Plan Management:

• Task structure with plan revisions types.ts:85-135
• Plan items with completion tracking types.ts:45-63

Repository and Codebase Context:

• Target repository information types.ts:148-153
• Codebase tree tracking types.ts:229-236
• Custom rules support types.ts:155-161

5. Configuration System

Implement model and behavior configuration based on Open-SWE's architecture:

Model Configuration:

• Separate model settings for different roles (planner, programmer, reviewer) types.ts:339-395
• Temperature and token controls types.ts:434-443

Action Limits:

• Context gathering action limits types.ts:314-322
• Review action constraints types.ts:324-332

6. Custom Rules Integration

Implement support for project-specific customization:

AGENTS.md File Processing:

• Support for general rules, repository structure, dependencies, and testing instructions types.ts:155-161
• Dynamic prompt injection based on repository configuration prompt.ts:98-100

7. Dependency and Build System

Integrate Open-SWE's technical stack:

Core Dependencies:

• LangChain ecosystem integration package.json:26-48
• TypeScript with strict mode enforcement AGENTS.md:6

Build and Quality Tools:

• ESLint configuration with no-console restrictions AGENTS.md:8
• Testing framework with Jest and TypeScript support AGENTS.md:56-57

Implementation Requirements

1. Agent Zero Integration Points

• Profile Registration: Create Open-SWE agent profiles within Agent Zero's agent management system
• Tool Bridge: Implement adapters between Open-SWE tools and Agent Zero's tool interface
• State Synchronization: Map Open-SWE's GraphState to Agent Zero's state management
• Configuration Bridge: Adapt Open-SWE's configuration system to Agent Zero's settings framework

2. Workflow Implementation

• Planning Phase: Context gathering with read-only operations and comprehensive codebase analysis
• Execution Phase: Task-by-task implementation with code modifications and testing
• Review Phase: Automated code review and validation cycles
• Integration Phase: Pull request creation and issue management

3. Quality Assurance

• Code Standards: Implement Open-SWE's coding standards including no backup files, proper error handling
• Testing Integration: Support for running tests with proper formatting flags
• Dependency Management: Automatic dependency installation with failure handling

4. User Experience

• Human-in-the-Loop: Support for mid-execution feedback and plan modifications
• Progress Tracking: Clear visibility into current task, plan progress, and completion status
• Error Recovery: Robust error handling with human help requests when needed

Deliverables

1. Complete Agent Profile Definitions: Full Open-SWE planner, programmer, and reviewer profiles integrated into Agent Zero
2. Tool Implementation: All Open-SWE tools adapted and functional within Agent Zero
3. Configuration System: Complete settings management matching Open-SWE capabilities
4. Documentation: Integration guide and usage examples
5. Test Suite: Validation tests ensuring proper integration and functionality

Essential Prompt Engineering Tips:

• Avoid prompting for "production-ready" code - this often leads to over-engineering
• Prompt Claude to write scripts to check its work: "After implementing, create a validation script"
• Avoid backwards compatibility unless specifically needed - Claude tends to preserve old code unnecessarily
• Focus on clarity and specific requirements rather than vague quality descriptors

Notes

This integration maintains Open-SWE's sophisticated multi-agent workflow README.md:27-31 while adapting to Agent Zero's framework architecture. The implementation should preserve key features like parallel execution, end-to-end task management, and the human-in-the-loop capabilities that make Open-SWE effective for autonomous coding tasks. The modular design ensures that each component can be tested and validated independently while maintaining the cohesive workflow that defines Open-SWE's approach to software engineering automation.

[TerminallyLazy]

We need to add the code for the various tools and agents.

[TerminallyLazy]

Dont commit anything just provide the plans please

[TerminallyLazy]

provide all steps and code for the tool files, the orchestration logic, and The necessary changes to the core settings system to accommodate these new profiles