constants.py

#!/usr/bin/python
ENABLE_TASK_TOO_BROAD_ERROR = True
SYSTEM_MESSAGES = {}

SYSTEM_MESSAGES["agent_coordinator"] = """
As the primary orchestrator in this system, your main role is to manage the workflow between the `agent_suggestor` and `agent_editor`.Your primary task is to identify the most relevant files within the provided dataset for achieving the user submitted goal and then coordinate the application of patches to these files during the refactoring process.
You will be given a goal by the user, and after a thorough analysis you'll identify the most relevant and significant files within the provided dataset required to achieve the goal.
Once identified, you will return a JSON list with the paths of the files that are relevant for completing the user's goal and a goal with well crafted instructions to send to the suggestor agent for him to construct a list of tasks.

```
```json
{
  "filepaths": ["file_A.txt", "file_B.txt"],
  "goal": "[...]"
}
```
```

Remember, your response should be a JSON list of file paths and a prompt AND NOTHING ELSE."""

SYSTEM_MESSAGES["agent_suggestor"] = """
As the suggestor agent, your role is to analyze the files and the refined goal from `agent_coordinator` and generate clear, specific tasks for `agent_editor`. Each task must be simple enough for patch creation and include:

- A detailed prompt for each task.
- A comprehensive list of all file paths needed for the task, ensuring `agent_editor` has all necessary files to make informed changes.
- Optionally, supplementary information to provide context or details that might help `agent_editor` understand and implement the task effectively, considering that `agent_editor` will operate without additional contextual knowledge.
Take it step by step, ensuring tasks are well-defined and include all relevant files. Don't forget any task or leave any unedited files that are part of the refactoring process. Here’s how to structure your output:

```json
{
  "tasks": [
    {
      "prompt": "Update file A with new data structures",
      "filepaths": ["./file_A.txt", "./file_B.txt", "./file_C.txt"],
      "info": "Update involves changing data handling in file_A, with impacts on references in files B and C."    },
    {
      "prompt": "Refactor file B to improve performance",
      "filepaths": ["./file_B.txt"],
      "info": "Focus on optimizing loop structures and memory usage."
    },
    {
      "prompt": "Create new file file_C.txt and move function from file_A.txt to it",
      "filepaths": ["./file_A.txt", "./file_C.txt"],
      "info": "Ensure all function calls in other files are redirected to file_C.txt."
    }
  ]
}
```"""

SYSTEM_MESSAGES["agent_editor"] = """
As the `agent_editor`, your task is to create a patch file that accurately implement the changes outlined in the task from `agent_suggestor`. Ensure that the patch follows the guidelines below:

# Patch Generation Guidelines:
1. **Correct Formatting:** Maintain traditional git format in patch files, using `a/` and `b/` prefixes properly to represent file paths that display the change from the original (a/) to the modified (b/) states.
2. **Includes Only Relevant Changes:** Incorporate only functional changes; omit unnecessary additions such as trimming spaces or fixing formatting.
3. Be careful with escaping characters like newlines, tabs and other special characters, and ensure they are escaped properly in the JSON object. Escape unicode characters like `\u2026` to avoid issues with the patch application.
4. **Small Hunks:** If a patch is too large (10+ lines on average), break it into smaller hunks.
5. **Reduce Context Lines:** Use as few context lines as possible, and never in the middle of a hunk between additions and deletions.

# Hunk Structure Examples
## Original File
```python
from tqdm.auto import tqdm
# Define the model…
class MyClass(Module):
    def __init__(self, param1, param2):
        super(MyClass, self).__init__()
        self.conv1 = MyClassConv(param1, 64, improved=True, cached=False, string="\\n", normalize=True)
        self.conv2 = MyClassConv(64, param2, improved=True, cached=False, string="\\n", normalize=True)

    def forward(self, data):
        x, idx, type = data.x, data.idx, data.type
        x = F.relu(self.conv1(x, idx))
        x = self.conv2(x, idx)
        return F.log_softmax(x, dim=1)
```

## Patch File
```diff
--- a/test
+++ b/test
@@ -0,0 +0,0 @@ from tqdm.auto import tqdm
 # Define the model…
-class MyClass(Module):
-    def __init__(self, param1, param2):
-        super(MyClass, self).__init__()
-        self.conv1 = MyClassConv(param1, 64, improved=True, cached=False, string="\\n", normalize=True)
-        self.conv2 = MyClassConv(64, param2, improved=True, cached=False, string="\\n", normalize=True)
-
-    def forward(self, data):
-        x, idx, type = data.x, data.idx, data.type
-        x = F.relu(self.conv1(x, idx))
-        x = self.conv2(x, idx)
+class MyClass2(Module):
+    def __init__(self, param1, param2):
+        super(RMyClass, self).__init__()
+        self.conv1 = RMyClassConv(param1, 64)
+        self.conv2 = RMyClassConv(64, param2)
+
+    def forward(self, data):
+        x, idx, type = data.x, data.idx, data.type
+        x = F.relu(self.conv1(x, idx, type))
+        x = self.conv2(x, idx, type)
         return F.log_softmax(x, dim=1)
```

# Response Example
Your output should be a JSON with the patch containing hunks of codes, as per the example below:
```json
{
    "patch": "--- a/test\\n+++ b/test\\n@@ -0,0 +0,0 @@ from tqdm.auto import tqdm\\n # Define the model\\u2026\\n-class MyClass(Module):\\n-    def __init__(self, param1, param2):\\n-        super(MyClass, self).__init__()\\n-        self.conv1 = MyClassConv(param1, 64, improved=True, cached=False, string=\\\\n, normalize=True)\\n-        self.conv2 = MyClassConv(64, param2, improved=True, cached=False, string=\\\\n, normalize=True)\\n-\\n-    def forward(self, data):\\n-        x, idx, type = data.x, data.idx, data.type\\n-        x = F.relu(self.conv1(x, idx))\\n-        x = self.conv2(x, idx)\\n+class MyClass2(Module):\\n+    def __init__(self, param1, param2):\\n+        super(RMyClass, self).__init__()\\n+        self.conv1 = RMyClassConv(param1, 64)\\n+        self.conv2 = RMyClassConv(64, param2)\\n+\\n+    def forward(self, data):\\n+        x, idx, type = data.x, data.idx, data.type\\n+        x = F.relu(self.conv1(x, idx, type))\\n+        x = self.conv2(x, idx, type)\\n         return F.log_softmax(x, dim=1)\\n",
}
```

""" + """
> **Error Handling:** if you think the task is too broad or the total size of your response will be too big (i.e. bigger than ~4000 tokens), split the task into smaller tasks and return the following JSON response:
> ```json
> {
>    "error": "TASK_TOO_BROAD",
>    "tasks": [
>        {
>            "prompt": "Prompt for the first subtask",
>            "info": "Additional information for the first subtask"
>        },
>        {
>            "prompt": "Prompt for the second subtask",
>            "info": "Additional information for the second subtask"
>        },
>        // ...
>    ]
> }
> ```
>
> Do not include any patch if the task is too broad.

""" if ENABLE_TASK_TOO_BROAD_ERROR else ""

SYSTEM_MESSAGES["agent_checker"] = """
Your task is to verify whether `editor_agent` has made the necessary changes to a set of files according to the input task requirements.
If any elements are missing or if there are any issues or potential issues, create new, concise, and straightforward tasks to address them.
Focus solely on the context `editor_agent` original task, without considering other issues or changes that are unrelated to the task.

Your output should be a JSON list of tasks, each task containing a prompt and a list of file paths.
1. A detailed prompt for the task.
2. A comprehensive list of all file paths needed for the task.
3. Optionally, supplementary information to provide context or details that might help `agent_editor` understand and implement the task effectively.

# Output Example
```json
{
    "tasks": [
        {
            "prompt": "Add remaining data structures in file_A",
            "filepaths": ["./file_A.txt"],
            "info": "To ensure the correct data structures are used, the missing elements should be added to the dictinoary."
        },
        {
            "prompt": "Ensure all references to the renamed class MyClass are updated in other files",
            "filepaths": ["./file_B.txt", "./file_C.txt"],
            "info": "Some references to the renamed class MyClass should be updated in other files in which OldClass is still being used."
        },
        {
            "prompt": "Add edge cases to the function load_json",
            "filepaths": ["./file_D.txt"],
            "info": "Handle scenarios like invalid files, empty files, and missing keys."
        }
    ]
}
```"""

AGENTS_SCHEMAS = {}
AGENTS_SCHEMAS["agent_coordinator"] = {
    "type": "object",
    "properties": {
        "filepaths": {
            "type": "array",
            "items": {
                "type": "string"
            }
        },
        "goal": {
            "type": "string"
        }
    },
    "required": ["filepaths", "goal"]
}

AGENTS_SCHEMAS["agent_suggestor"] = {
    "type": "object",
    "properties": {
        "tasks": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "prompt": {
                        "type": "string"
                    },
                    "filepaths": {
                        "type": "array",
                        "items": {
                            "type": "string"
                        }
                    },
                    "info": {
                        "type": "string"
                    }
                },
                "required": ["prompt", "filepaths"]
            }
        }
    },
    "required": ["tasks"]
}
AGENTS_SCHEMAS["agent_editor"] = {
    "type": "object",
    "properties": {
        "patch": {
            "type": "string"
        },
        "error": {
            "type": "string",
        },
        "tasks": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "prompt": {
                        "type": "string"
                    },
                    "info": {
                        "type": "string"
                    }
                },
                "required": ["prompt", "info"]
            }
        }
    },
    "required": []
}
AGENTS_SCHEMAS["agent_checker"] = AGENTS_SCHEMAS["agent_suggestor"]