github/OpenHands
1
0
Fork 0
mirror of https://github.com/OpenHands/OpenHands.git synced 2025-12-26 05:48:36 +08:00
Code Issues Packages Projects Releases Wiki Activity

remove swe agent (#2708)

Browse Source
This commit is contained in:
Engel Nyst 2024-07-01 05:27:14 +02:00 committed by GitHub
parent 00542432bd
commit 1975689cd4
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 0 additions and 907 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.github/.codecov.yml vendored
View File

@ -17,6 +17,3 @@ coverage:
comment: false
github_checks:
annotations: false
ignore:
- "agenthub/SWE_agent/**" # SWE agent is deprecated

405
agenthub/SWE_agent/Examples.md
View File

@ -1,405 +0,0 @@
# GPT-4 Examples:
### Notes:
- The final result is not completed as I only gave it 10 steps, but shows very promising use of the tools.
- This whole run costs: $0.35 using gpt-4-turbo
- Input Tokens: 29,734
- Completion Tokens: 1,636
Interesting things:
1. Using comments as an initial placeholder for the next move and then having that output in memory is a very cool behavior.
2. It makes very small iterative changes due to the prompting.
3. A lot of the logic for the game is present but not put together well
4. There are a lot of odd quirks with the code that it has written.
5. Some odd agent behavior with putting random lines of code in random places?
6. The structure of the feedback loop needs some improvement so the agent can see the changes it has made better in context.
7. Might be beneficial to add in some line numbers so the model knows what lines it is looking at.
```
==============
STEP 0
PLAN:
Please make conway's game of life in python using the pygame library. Be sure to use the tools in your workspace to help you out.
Usage(completion_tokens=91, prompt_tokens=2047, total_tokens=2138)
==== RAW OUTPUT ====
Thoughts:
To start implementing Conway's Game of Life in Python using the pygame library, I first need to set up a Python script file where I can write the code. I'll create a new Python file named `game_of_life.py`. This file will serve as the base for writing the game logic and using pygame functionalities.
Action:
"""
write game_of_life.py # This is a placeholder for the game of life implementation using pygame.
"""
==== END RAW ====
ACTION:
FileWriteAction(path='game_of_life.py', content='# This is a placeholder for the game of life implementation using pygame.', start=0, end=-1, thoughts="Thoughts:\nTo start implementing Conway's Game of Life in Python using the pygame library, I first need to set up a Python script file where I can write the code. I'll create a new Python file named `game_of_life.py`. This file will serve as the base for writing the game logic and using pygame functionalities.\n\nAction:", action=<ActionType.WRITE: 'write'>)
OBSERVATION:
WRITE OPERATION:
You have written to "game_of_life.py" on these lines: 0:-1.
==============
STEP 1
PLAN:
Please make conway's game of life in python using the pygame library. Be sure to use the tools in your workspace to help you out.
Usage(completion_tokens=101, prompt_tokens=2351, total_tokens=2452)
==== RAW OUTPUT ====
Thoughts:
The placeholder for the game of life implementation using pygame has been set up in the file `game_of_life.py`. The next step is to start implementing the basic structure of the game. This includes importing necessary libraries, initializing the pygame module, setting up the display window, and defining the main game loop. I will begin by importing pygame and initializing it, which are the foundational steps for any pygame application.
Action:
"""
edit 0 0 import pygame
pygame.init()
"""
==== END RAW ====
ACTION:
FileWriteAction(path='game_of_life.py', content='import pygame\n\npygame.init()', start=0, end=0, thoughts='Thoughts:\nThe placeholder for the game of life implementation using pygame has been set up in the file `game_of_life.py`. The next step is to start implementing the basic structure of the game. This includes importing necessary libraries, initializing the pygame module, setting up the display window, and defining the main game loop. I will begin by importing pygame and initializing it, which are the foundational steps for any pygame application.\n\nAction:', action=<ActionType.WRITE: 'write'>)
OBSERVATION:
WRITE OPERATION:
You have written to "game_of_life.py" on these lines: 0:0.
==============
STEP 2
PLAN:
Please make conway's game of life in python using the pygame library. Be sure to use the tools in your workspace to help you out.
Usage(completion_tokens=123, prompt_tokens=2552, total_tokens=2675)
==== RAW OUTPUT ====
Thoughts:
Previously, I initialized pygame in the `game_of_life.py` file. The next step is to set up the display window for the game. This involves defining the size of the window and setting the title. This is crucial as it provides the visual interface for the game. I will also add a comment to indicate that this is the setup for the display window.
Action:
"""
edit 2 2
# Setup the display window
screen_size = (800, 600)
screen = pygame.display.set_mode(screen_size)
pygame.display.set_caption("Conway's Game of Life")
"""
==== END RAW ====
ACTION:
FileWriteAction(path='game_of_life.py', content='# Setup the display window\nscreen_size = (800, 600)\nscreen = pygame.display.set_mode(screen_size)\npygame.display.set_caption("Conway\'s Game of Life")', start=2, end=2, thoughts='Thoughts:\nPreviously, I initialized pygame in the `game_of_life.py` file. The next step is to set up the display window for the game. This involves defining the size of the window and setting the title. This is crucial as it provides the visual interface for the game. I will also add a comment to indicate that this is the setup for the display window.\n\nAction:', action=<ActionType.WRITE: 'write'>)
OBSERVATION:
WRITE OPERATION:
You have written to "game_of_life.py" on these lines: 2:2.
==============
STEP 3
PLAN:
Please make conway's game of life in python using the pygame library. Be sure to use the tools in your workspace to help you out.
Usage(completion_tokens=144, prompt_tokens=2777, total_tokens=2921)
==== RAW OUTPUT ====
Thoughts:
So far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame and setting up the display window. The next step is to define the main game loop where the game's logic will be continuously updated and rendered. This loop will handle events, update the game state, and redraw the screen. I will start by defining the main loop structure and a basic event handling mechanism to allow for quitting the game when the user presses the close button.
Action:
"""
edit 5 5 # Main game loop
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
"""
==== END RAW ====
ACTION:
FileWriteAction(path='game_of_life.py', content='# Main game loop\nrunning = True\nwhile running:\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n running = False', start=5, end=5, thoughts="Thoughts:\nSo far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame and setting up the display window. The next step is to define the main game loop where the game's logic will be continuously updated and rendered. This loop will handle events, update the game state, and redraw the screen. I will start by defining the main loop structure and a basic event handling mechanism to allow for quitting the game when the user presses the close button.\n\nAction:", action=<ActionType.WRITE: 'write'>)
OBSERVATION:
WRITE OPERATION:
You have written to "game_of_life.py" on these lines: 5:5.
==============
STEP 4
PLAN:
Please make conway's game of life in python using the pygame library. Be sure to use the tools in your workspace to help you out.
Usage(completion_tokens=222, prompt_tokens=3022, total_tokens=3244)
==== RAW OUTPUT ====
Thoughts:
So far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame, setting up the display window, and defining the main game loop. The next step is to implement the logic for Conway's Game of Life. This involves creating a grid to represent the game state, initializing it with a random pattern, and defining the rules for cell survival, birth, and death. I will start by defining the grid size and initializing the grid with random states.
Action:
"""
edit 7 7 # Define grid size and initialize grid
grid_size = (50, 50) # Grid size as a tuple (rows, columns)
grid = [[0 for x in range(grid_size[1])] for y in range(grid_size[0])] # Initialize grid with zeros
import random
for y in range(grid_size[0]):
for x in range(grid_size[1]):
grid[y][x] = random.randint(0, 1) # Randomly assign cells as alive (1) or dead (0)
"""
==== END RAW ====
ACTION:
FileWriteAction(path='game_of_life.py', content='# Define grid size and initialize grid\ngrid_size = (50, 50) # Grid size as a tuple (rows, columns)\ngrid = [[0 for x in range(grid_size[1])] for y in range(grid_size[0])] # Initialize grid with zeros\nimport random\nfor y in range(grid_size[0]):\n for x in range(grid_size[1]):\n grid[y][x] = random.randint(0, 1) # Randomly assign cells as alive (1) or dead (0)', start=7, end=7, thoughts="Thoughts:\nSo far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame, setting up the display window, and defining the main game loop. The next step is to implement the logic for Conway's Game of Life. This involves creating a grid to represent the game state, initializing it with a random pattern, and defining the rules for cell survival, birth, and death. I will start by defining the grid size and initializing the grid with random states.\n\nAction:", action=<ActionType.WRITE: 'write'>)
OBSERVATION:
WRITE OPERATION:
You have written to "game_of_life.py" on these lines: 7:7.
==============
STEP 5
PLAN:
Please make conway's game of life in python using the pygame library. Be sure to use the tools in your workspace to help you out.
Usage(completion_tokens=234, prompt_tokens=3158, total_tokens=3392)
==== RAW OUTPUT ====
Thoughts:
So far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame, setting up the display window, defining the main game loop, and initializing the grid with random states. The next step is to implement the rules for Conway's Game of Life. This involves checking each cell's neighbors to determine its next state based on the number of alive neighbors. I will start by defining a function to count the alive neighbors for a given cell.
Action:
"""
edit 9 9 def count_alive_neighbors(grid, x, y):
directions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
count = 0
for dx, dy in directions:
nx, ny = x + dx, y + dy
if 0 <= nx < grid_size[1] and 0 <= ny < grid_size[0]:
count += grid[ny][nx]
return count
"""
==== END RAW ====
ACTION:
FileWriteAction(path='game_of_life.py', content='def count_alive_neighbors(grid, x, y):\n directions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]\n count = 0\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < grid_size[1] and 0 <= ny < grid_size[0]:\n count += grid[ny][nx]\n return count', start=9, end=9, thoughts="Thoughts:\nSo far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame, setting up the display window, defining the main game loop, and initializing the grid with random states. The next step is to implement the rules for Conway's Game of Life. This involves checking each cell's neighbors to determine its next state based on the number of alive neighbors. I will start by defining a function to count the alive neighbors for a given cell.\n\nAction:", action=<ActionType.WRITE: 'write'>)
OBSERVATION:
WRITE OPERATION:
You have written to "game_of_life.py" on these lines: 9:9.
==============
STEP 6
PLAN:
Please make conway's game of life in python using the pygame library. Be sure to use the tools in your workspace to help you out.
Usage(completion_tokens=257, prompt_tokens=3290, total_tokens=3547)
==== RAW OUTPUT ====
Thoughts:
So far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame, setting up the display window, defining the main game loop, initializing the grid with random states, and creating a function to count alive neighbors. The next step is to implement the rules for Conway's Game of Life. This involves updating the grid state based on the number of alive neighbors each cell has. I will define a function `update_grid` that applies the rules of the game to update the grid for the next generation.
Action:
"""
write game_of_life.py def update_grid(grid):
new_grid = [[0 for x in range(grid_size[1])] for y in range(grid_size[0])]
for y in range(grid_size[0]):
for x in range(grid_size[1]):
alive_neighbors = count_alive_neighbors(grid, x, y)
if grid[y][x] == 1 and (alive_neighbors == 2 or alive_neighbors == 3):
new_grid[y][x] = 1
elif grid[y][x] == 0 and alive_neighbors == 3:
new_grid[y][x] = 1
return new_grid
11
11
"""
==== END RAW ====
ACTION:
FileWriteAction(path='game_of_life.py', content='def update_grid(grid):\n new_grid = [[0 for x in range(grid_size[1])] for y in range(grid_size[0])]\n for y in range(grid_size[0]):\n for x in range(grid_size[1]):\n alive_neighbors = count_alive_neighbors(grid, x, y)\n if grid[y][x] == 1 and (alive_neighbors == 2 or alive_neighbors == 3):\n new_grid[y][x] = 1\n elif grid[y][x] == 0 and alive_neighbors == 3:\n new_grid[y][x] = 1\n return new_grid', start=11, end=11, thoughts="Thoughts:\nSo far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame, setting up the display window, defining the main game loop, initializing the grid with random states, and creating a function to count alive neighbors. The next step is to implement the rules for Conway's Game of Life. This involves updating the grid state based on the number of alive neighbors each cell has. I will define a function `update_grid` that applies the rules of the game to update the grid for the next generation.\n\nAction:", action=<ActionType.WRITE: 'write'>)
OBSERVATION:
WRITE OPERATION:
You have written to "game_of_life.py" on these lines: 11:11.
==============
STEP 7
PLAN:
Please make conway's game of life in python using the pygame library. Be sure to use the tools in your workspace to help you out.
Usage(completion_tokens=124, prompt_tokens=3416, total_tokens=3540)
==== RAW OUTPUT ====
Thoughts:
So far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame, setting up the display window, defining the main game loop, initializing the grid with random states, and creating functions to count alive neighbors and update the grid. The next step is to integrate the `update_grid` function into the main game loop to continuously update the state of the grid based on the game rules. This will allow the game to evolve over time, showing different generations of the cell population.
Action:
"""
edit 6 6
grid = update_grid(grid)
"""
==== END RAW ====
ACTION:
FileWriteAction(path='game_of_life.py', content='grid = update_grid(grid)', start=6, end=6, thoughts="Thoughts:\nSo far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame, setting up the display window, defining the main game loop, initializing the grid with random states, and creating functions to count alive neighbors and update the grid. The next step is to integrate the `update_grid` function into the main game loop to continuously update the state of the grid based on the game rules. This will allow the game to evolve over time, showing different generations of the cell population.\n\nAction:", action=<ActionType.WRITE: 'write'>)
OBSERVATION:
WRITE OPERATION:
You have written to "game_of_life.py" on these lines: 6:6.
==============
STEP 8
PLAN:
Please make conway's game of life in python using the pygame library. Be sure to use the tools in your workspace to help you out.
Usage(completion_tokens=166, prompt_tokens=3393, total_tokens=3559)
==== RAW OUTPUT ====
Thoughts:
So far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame, setting up the display window, defining the main game loop, initializing the grid with random states, and creating functions to count alive neighbors and update the grid. The next step is to integrate the `update_grid` function into the main game loop to continuously update the state of the grid based on the game rules. This will allow the game to evolve over time, showing different generations of the cell population. I need to ensure that the `update_grid` function is called within the main game loop and that the display is updated accordingly. I will start by checking the current content of the main game loop to see where to integrate the `update_grid` function.
Action:
"""
goto 6
"""
==== END RAW ====
ACTION:
FileReadAction(path='game_of_life.py', start=6, end=106, thoughts="Thoughts:\nSo far, I have set up the basic structure for Conway's Game of Life using pygame, including initializing pygame, setting up the display window, defining the main game loop, initializing the grid with random states, and creating functions to count alive neighbors and update the grid. The next step is to integrate the `update_grid` function into the main game loop to continuously update the state of the grid based on the game rules. This will allow the game to evolve over time, showing different generations of the cell population. I need to ensure that the `update_grid` function is called within the main game loop and that the display is updated accordingly. I will start by checking the current content of the main game loop to see where to integrate the `update_grid` function.\n\nAction:", action=<ActionType.READ: 'read'>)
OBSERVATION:
grid = update_grid(grid)
running = True
# Define grid size and initialize grid
grid_size = (50, 50) # Grid size as a tuple (rows, columns)
def count_alive_neighbors(grid, x, y):
directions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
def update_grid(grid):
new_grid = [[0 for x in range(grid_size[1])] for y in range(grid_size[0])]
for y in range(grid_size[0]):
for x in range(grid_size[1]):
alive_neighbors = count_alive_neighbors(grid, x, y)
if grid[y][x] == 1 and (alive_neighbors == 2 or alive_neighbors == 3):
new_grid[y][x] = 1
elif grid[y][x] == 0 and alive_neighbors == 3:
new_grid[y][x] = 1
return new_grid
count = 0
for dx, dy in directions:
nx, ny = x + dx, y + dy
if 0 <= nx < grid_size[1] and 0 <= ny < grid_size[0]:
count += grid[ny][nx]
return count
grid = [[0 for x in range(grid_size[1])] for y in range(grid_size[0])] # Initialize grid with zeros
import random
for y in range(grid_size[0]):
for x in range(grid_size[1]):
grid[y][x] = random.randint(0, 1) # Randomly assign cells as alive (1) or dead (0)
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
pygame.display.set_caption("Conway's Game of Life")
pygame.init()
==============
STEP 9
PLAN:
Please make conway's game of life in python using the pygame library. Be sure to use the tools in your workspace to help you out.
Usage(completion_tokens=174, prompt_tokens=3728, total_tokens=3902)
==== RAW OUTPUT ====
Thoughts:
From the previous actions, it seems that the basic structure for Conway's Game of Life using pygame has been set up, including initializing pygame, setting up the display window, defining the main game loop, initializing the grid with random states, and creating functions to count alive neighbors and update the grid. The next step is to ensure that the game loop properly updates the grid and refreshes the display to show the new state of the grid in each iteration. This involves calling `pygame.display.update()` to update the entire screen and using `pygame.time.Clock()` to control the frame rate. I will start by adding these necessary updates to the game loop.
Action:
"""
edit 95 95
pygame.display.update()
clock = pygame.time.Clock()
clock.tick(10) # Control the frame rate (10 frames per second)
"""
==== END RAW ====
ACTION:
FileWriteAction(path='game_of_life.py', content='pygame.display.update()\n clock = pygame.time.Clock()\n clock.tick(10) # Control the frame rate (10 frames per second)', start=95, end=95, thoughts="Thoughts:\nFrom the previous actions, it seems that the basic structure for Conway's Game of Life using pygame has been set up, including initializing pygame, setting up the display window, defining the main game loop, initializing the grid with random states, and creating functions to count alive neighbors and update the grid. The next step is to ensure that the game loop properly updates the grid and refreshes the display to show the new state of the grid in each iteration. This involves calling `pygame.display.update()` to update the entire screen and using `pygame.time.Clock()` to control the frame rate. I will start by adding these necessary updates to the game loop.\n\nAction:", action=<ActionType.WRITE: 'write'>)
OBSERVATION:
WRITE OPERATION:
You have written to "game_of_life.py" on these lines: 95:95.
16:43:55 - opendevin:INFO: agent_controller.py:125 - Exited before finishing the task.
```
## Result:
```
import pygame
# Setup the display window
screen_size = (800, 600)
screen = pygame.display.set_mode(screen_size)
# Main game loop
grid = update_grid(grid)
running = True
# Define grid size and initialize grid
grid_size = (50, 50) # Grid size as a tuple (rows, columns)
def count_alive_neighbors(grid, x, y):
directions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
def update_grid(grid):
new_grid = [[0 for x in range(grid_size[1])] for y in range(grid_size[0])]
for y in range(grid_size[0]):
for x in range(grid_size[1]):
alive_neighbors = count_alive_neighbors(grid, x, y)
if grid[y][x] == 1 and (alive_neighbors == 2 or alive_neighbors == 3):
new_grid[y][x] = 1
elif grid[y][x] == 0 and alive_neighbors == 3:
new_grid[y][x] = 1
return new_grid
count = 0
for dx, dy in directions:
nx, ny = x + dx, y + dy
if 0 <= nx < grid_size[1] and 0 <= ny < grid_size[0]:
count += grid[ny][nx]
return count
grid = [[0 for x in range(grid_size[1])] for y in range(grid_size[0])] # Initialize grid with zeros
import random
for y in range(grid_size[0]):
for x in range(grid_size[1]):
grid[y][x] = random.randint(0, 1) # Randomly assign cells as alive (1) or dead (0)
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
pygame.display.set_caption("Conway's Game of Life")
pygame.init()
# This is a placeholder for the game of life implementation using pygame.pygame.display.update()
clock = pygame.time.Clock()
clock.tick(10) # Control the frame rate (10 frames per second)
```

5
agenthub/SWE_agent/__init__.py
View File

@ -1,5 +0,0 @@
from opendevin.controller.agent import Agent
from .agent import SWEAgent
Agent.register('SWEAgent', SWEAgent)

117
agenthub/SWE_agent/agent.py
View File

@ -1,117 +0,0 @@
from opendevin.controller.agent import Agent
from opendevin.controller.state.state import State
from opendevin.events.action import (
Action,
FileReadAction,
FileWriteAction,
MessageAction,
)
from opendevin.events.serialization.event import event_to_memory
from opendevin.llm.llm import LLM
from opendevin.runtime.tools import RuntimeTool
from .parser import parse_command
from .prompts import (
CONTEXT_PROMPT,
MEMORY_FORMAT,
NO_ACTION,
STEP_PROMPT,
SYSTEM_MESSAGE,
)
class SWEAgent(Agent):
VERSION = '1.0'
DEPRECATED = True
"""
An attempt to recreate swe_agent with output parsing, prompting style, and Application Computer Interface (ACI).
SWE-agent includes ACI functions like 'goto', 'search_for', 'edit', 'scroll', 'run'
"""
runtime_tools: list[RuntimeTool] = [RuntimeTool.BROWSER]
def __init__(self, llm: LLM):
super().__init__(llm)
self.memory_window = 4
self.max_retries = 2
self.cur_file: str = ''
self.cur_line: int = 0
def _think_act(self, messages: list[dict]) -> tuple[Action, str]:
resp = self.llm.completion(
messages=messages,
temperature=0.05,
)
action_resp = resp['choices'][0]['message']['content']
print(f"\033[1m\033[91m{resp['usage']}\033[0m")
print(
'\n==== RAW OUTPUT ====',
f'\033[96m{action_resp}\033[0m',
'==== END RAW ====\n',
sep='\n',
)
return parse_command(action_resp, self.cur_file, self.cur_line)
def _update(self, action: Action) -> None:
if isinstance(action, (FileReadAction, FileWriteAction)):
self.cur_file = action.path
self.cur_line = action.start
def step(self, state: State) -> Action:
"""
SWE-Agent step:
1. Get context - past actions, custom commands, current step
2. Perform think-act - prompt model for action and reasoning
3. Catch errors - ensure model takes action (5 attempts max)
"""
# retrieve short term memories from state.history, up to memory_window
memory_window = min(self.memory_window, len(state.history))
running_memory: list[str] = []
for prev_action, obs in state.history[-memory_window:]:
running_memory.append(
MEMORY_FORMAT(event_to_memory(prev_action), event_to_memory(obs))
)
goal = state.get_current_user_intent()
# always in the prompt if they exist: file and line
prompt = STEP_PROMPT(goal, self.cur_file, self.cur_line)
# prepare messages
msgs = [
{'content': SYSTEM_MESSAGE, 'role': 'system'},
{'content': prompt, 'role': 'user'},
]
# insert memories
if len(running_memory) > 0:
context = CONTEXT_PROMPT(running_memory, self.memory_window)
msgs.insert(1, {'content': context, 'role': 'user'})
# clrs = [''] * (len(msgs)-2) + ['\033[0;36m', '\033[0;35m']
# print('\n\n'.join([c+m['content']+'\033[0m' for c, m in zip(clrs, msgs)]))
# send it over
action, thought = self._think_act(messages=msgs)
# be robust with malformed responses
start_msg_len = len(msgs)
while not action and len(msgs) < self.max_retries + start_msg_len:
error = NO_ACTION(thought)
error_msg = {'content': error, 'role': 'user'}
msgs.append(error_msg)
action, thought = self._think_act(messages=msgs)
if not action:
action = MessageAction(thought)
self._update(action)
self.latest_action = action
return action
def search_memory(self, query: str) -> list[str]:
# return [item for item in self.running_memory if query in item]
raise NotImplementedError('Search_memory not implemented currently')
def reset(self) -> None:
"""Used to reset the agent"""
super().reset()

167
agenthub/SWE_agent/parser.py
View File

@ -1,167 +0,0 @@
import re
from opendevin.events.action import (
Action,
AgentFinishAction,
BrowseURLAction,
CmdRunAction,
FileReadAction,
FileWriteAction,
MessageAction,
)
from .prompts import COMMAND_USAGE, CUSTOM_DOCS
# commands: exit, read, write, browse, kill, search_file, search_dir
no_open_file_error = MessageAction(
'You are not currently in a file. You can use the read command to open a file and then use goto to navigate through it.'
)
def invalid_error(cmd, docs):
return f"""ERROR:
Invalid command structure for
```
{cmd}
```
You may have caused this error by having multiple commands within your command block.
If so, try again by running only one of the commands:
Try again using this format:
{COMMAND_USAGE[docs]}
"""
def get_action_from_string(
command_string: str, path: str, line: int, thoughts: str = ''
) -> Action | None:
"""
Parses the command string to find which command the agent wants to run
Converts the command into a proper Action and returns
"""
vars = command_string.split(' ')
cmd = vars[0]
args = [] if len(vars) == 1 else vars[1:]
if 'exit' == cmd:
return AgentFinishAction()
elif 'think' == cmd:
return MessageAction(' '.join(args))
elif 'scroll_up' == cmd:
if not path:
return no_open_file_error
return FileReadAction(path, line + 100, line + 200, thoughts)
elif 'scroll_down' == cmd:
if not path:
return no_open_file_error
return FileReadAction(path, line - 100, line, thoughts)
elif 'goto' == cmd:
if not path:
return no_open_file_error
rex = r'^goto\s+(\d+)$'
valid = re.match(rex, command_string)
if valid:
start = int(valid.group(1))
end = start + 100
return FileReadAction(path, start, end, thoughts)
else:
return MessageAction(invalid_error(command_string, 'goto'))
elif 'edit' == cmd:
if not path:
return no_open_file_error
rex = r'^edit\s+(\d+)\s+(-?\d+)\s+(\S.*)$'
valid = re.match(rex, command_string, re.DOTALL)
if valid:
start = int(valid.group(1))
end = int(valid.group(2))
change = valid.group(3)
if '"' == change[-1] and '"' == change[0]:
change = change[1:-1]
return FileWriteAction(path, change, start, end, thoughts)
else:
return MessageAction(invalid_error(command_string, 'edit'))
elif 'read' == cmd:
rex = r'^read\s+(\S+)(?:\s+(\d+))?(?:\s+(-?\d+))?$'
valid = re.match(rex, command_string, re.DOTALL)
if valid:
file = valid.group(1)
start_str = valid.group(2)
end_str = valid.group(3)
start = 0 if not start_str else int(start_str)
end = -1 if not end_str else int(end_str)
return FileReadAction(file, start, end, thoughts)
else:
return MessageAction(invalid_error(command_string, 'read'))
elif 'write' == cmd:
rex = r'^write\s+(\S+)\s+(.*?)\s*(\d+)?\s*(-?\d+)?$'
valid = re.match(rex, command_string, re.DOTALL)
if valid:
file = valid.group(1)
content = valid.group(2)
start_str = valid.group(3)
end_str = valid.group(4)
start = 0 if not start_str else int(start_str)
end = -1 if not end_str else int(end_str)
if '"' == content[-1] and '"' == content[0]:
content = content[1:-1]
return FileWriteAction(file, content, start, end, thoughts)
else:
return MessageAction(invalid_error(command_string, 'write'))
elif 'browse' == cmd:
return BrowseURLAction(args[0].strip())
elif cmd in ['search_file', 'search_dir', 'find_file']:
rex = r'^(search_file|search_dir|find_file)\s+(\S+)(?:\s+(\S+))?$'
valid = re.match(rex, command_string, re.DOTALL)
if valid:
return CmdRunAction(command_string)
else:
return MessageAction(
f'Invalid command structure for\n ```\n{command_string}\n```.\nTry again using this format:\n{CUSTOM_DOCS}'
)
else:
# check bash command
obs = str(CmdRunAction(f'type {cmd}'))
if obs.split(':')[-1].strip() == 'not found':
# echo not found error for llm
return MessageAction(content=obs)
else:
# run valid command
return CmdRunAction(command_string)
def parse_command(input_str: str, path: str, line: int):
"""
Parses a given string and separates the command (enclosed in triple backticks) from any accompanying text.
Args:
input_str (str): The input string to be parsed.
Returns:
tuple: A tuple containing the command and the accompanying text (if any).
"""
input_str = input_str.strip()
if '```' in input_str:
parts = input_str.split('```')
command_str = parts[1].strip()
ind = 2 if len(parts) > 2 else 1
accompanying_text = ''.join(parts[:-ind]).strip()
action = get_action_from_string(command_str, path, line, accompanying_text)
if action:
return action, accompanying_text
return None, input_str # used for retry

208
agenthub/SWE_agent/prompts.py
View File

@ -1,208 +0,0 @@
DEFAULT_COMMANDS_DICT = {
'exit': 'Executed when task is complete',
'read <file_name> [<start_line>] [<end_line>]': "Shows a given file's contents starting from <start_line> up to <end_line>. Default: start_line = 0, end_line = -1. By default the whole file will be read.",
'write <file> <changes> [<start_line>] [<end_line>]': 'Modifies a <file> by replacing the current lines between <start_line> and <end_line> with <changes>. Default start_line = 0 and end_line = -1. Calling this with no line args will replace the whole file.',
'browse <url>': 'Returns the text version of any url, this can be useful to look up documentation or finding issues on github',
'scroll_up': 'Takes no arguments. This will scroll up and show you the 100 lines above your current lines',
'scroll_down': 'Takes no arguments. This will scroll down and show you the 100 lines below your current lines',
'edit <start_line> <end_line> <changes>': 'This will modify lines in the currently open file. use start_line and end_line to designate which lines to change and then write the multiline changes. Set end_line to -1 to denote the end of the file',
'goto <line_num>': 'This will take you directly to a line and show you the 100 lines below it.',
'<bash_command> <args>': 'You can use any bash command you need (cd, ls, rm, grep, dir, mv, wget, git, zip, etc.) with their arguments included',
'pip install <package>': 'You can use this to import python packages. Make sure you include the correct package name when using this command.',
'ls': 'Use the ls command to view all the files in your current directory, this is a good starting point.',
'NOT ALLOWED': 'You cannot use interactive commands like python or node',
}
COMMAND_USAGE = {
'exit': 'Usage:\n```\nexit\n```\nExecuted when task is complete',
'read': "Args:\n<file_name> [<start_line>] [<end_line>]\nUsage:\n```\nread file.py\n```\nor\n```\nread example.py <start_line> <end_line>\n```\nShows a given file's contents starting from <start_line> up to <end_line>. Default: start_line = 0, end_line = -1. by default the whole file will be read.",
'write': 'Args:\n<file> <changes> [<start_line>] [<end_line>]\nUsage:\n```\nwrite "def main():\n print("This is line one")" 0 2\n```\nModifies a <file> by replacing the current lines between <start_line> and <end_line> with <changes>. Default start_line = 0 and end_line = -1. Calling this with no line args will replace the whole file.',
'edit': 'Args:\n<start_line> <end_line> <changes>\nUsage:\n```\nedit 0 1 import pandas as pd\n```\nThis will modify the current file you are in with the changes you make between the line numbers you designate',
'goto': 'Args:\n<line_num>\nUsage:\n```\ngoto <line_num>\n```\nThis will show you the 100 lines below and including the line you specify within your current file.',
'scroll_up': 'Usage:\n```\nscroll_up\n```\nThis will return the 100 lines above where you are currently at',
'scroll_down': 'Usage:\n```\nscroll_down\n```\nThis will return the 100 line below where you are currently at',
'browse': 'Args:\n<url>\nUsage:\n```\nbrowse https://github.com/OpenDevin/OpenDevin\n```\nThis will fetch the Text elements from the given url and show them to you.',
}
DEFAULT_COMMANDS = '\n'.join([k + ' - ' + v for k, v in DEFAULT_COMMANDS_DICT.items()])
# from opendevin.parse_commands import parse_command_file
# USE parse_command_file(filepath) to get the custom commands
CUSTOM_DOCS = None
CUSTOM_COMMANDS = f"""Custom bash commands:
{CUSTOM_DOCS}
"""
DOCUMENTATION = f"""DOCUMENTATION:
It is recommend that you use the commands provided for interacting with files and your directory because they have been specially built for you.
They will make it much easier for you to look at files and make changes. Using these commands will help you be better at your task.
You can open an file by using either the read or write operations.
- If a file already exists you should read it before making any changes. Use the `edit` command to make changes once you have read it.
- If you are creating a new file use the write command. Use the `edit` command to make changes once you have created the new file.
Commands:
{DEFAULT_COMMANDS}
{CUSTOM_COMMANDS}
The following commands require an open file to be used: edit, scroll_up, scroll_down, goto
To modify the current file use 'edit'. To move through the current file use 'goto' or 'scroll_up'/'scroll_down'
when using write and edit do not surround the code with any "" just write the code.
"""
GENERAL_GUIDELINES = """INSTRUCTIONS:
Now, you're going to solve this issue on your own. You can use any bash commands or custom commands you wish to complete your task. Edit all the files you need to and run any checks or tests that you want.
Remember, YOU CAN ONLY ENTER ONE COMMAND AT A TIME. You should always wait for feedback after every command.
When you're satisfied with all of the changes you've made, you can indicate that you are done by running the exit command.
Note however that you cannot use any interactive session commands (e.g. python, vim, node) in this environment, but you can write scripts and run them. E.g. you can write a python script and then run it with `python <script_name>.py`.
NOTE ABOUT THE write COMMAND: Indentation really matters! When editing a file, make sure to insert appropriate indentation before each line!
IMPORTANT TIPS:
1. Reproduce the bug: Always start by trying to replicate the bug that the issue discusses. If the issue includes code for reproducing the bug, we recommend that you re-implement that in your environment and run it to ensure you can reproduce the bug. Then, start trying to fix it. When you think you've fixed the bug, re-run the bug reproduction script to make sure that the issue has indeed been resolved.
If the bug reproduction script does not print anything when it successfully runs, we recommend adding a print("Script completed successfully, no errors.") command at the end of the file, so that you can be sure the script ran fine all the way through.
2. Try different commands: If you run a command and it doesn't work, try running a different command. A command that did not work once will not work the second time unless you modify it.
3. Navigate large files: If you open a file and need to get to an area around a specific line that is not in the first 100 lines, say line 583, you would use the 'read' command like this: 'read <file> 583'. This is a much faster way to read through the file.
4. Handle input files: If the bug reproduction script requires inputting/reading a specific file, such as 'buggy-input.png', and you'd like to understand how to input that file, conduct a search in the existing repository code to see whether someone else has already done that. Do this by running the command: 'search_dir "buggy-input.png"'. If that doesn't work, use the Linux 'find' command.
5. Understand your context: Always make sure to look at the currently open file and the current working directory. The currently open file might be in a different directory than the working directory.
6. Verify your edits: When editing files, it is easy to accidentally specify a wrong line number or to write code with incorrect indentation. Always check the code after you issue an edit to make sure that it reflects what you wanted to accomplish. If it didn't, issue another command to fix it.
7. Thoroughly test your solution: After making any changes to fix a bug, be sure to thoroughly test your solution to ensure the bug has been resolved. Re-run the bug reproduction script and verify that the issue has been addressed.
"""
RESPONSE_FORMAT = """RESPONSE FORMAT:
This is the format of the response you will make in order to solve the current issue.
You will be given multiple iterations to complete this task so break it into steps and solve them one by one.
Your output must contain the following:
- First, thoughts about what your next action should be and plan it out.
- You will have a memory of your thoughts so you can use this to remember things for the next step.
- Use your thoughts to think about what you are currently doing, what you have done on prior steps and how that relates to solving the problem.
- Second, create a piece of code that will execute your next action based on the thoughts you have.
- Remember that you can only have one action for each thought, do not include multiple actions.
Your code MUST be surrounded in triple back ticks EXACTLY like this:
```
<code>
```
Notes:
- Adhere to the format so that the program loop continues smoothly, it is very important to only give one command per output.
- DO NOT give more than one command within the triple backticks. This will just throw an error and nothing will happen as a result.
- Do not give multiple code blocks, if you do only the second one will be captured and run, this might give an error if the first one was necessary.
- To execute multiple commands you should write them down in your thoughts section so you can remember it on the next step and execute them then.
- The only commands you are not capable of executing are interactive commands like `python` or `node` by themselves.
- If you think that you have completed the task that has been given to you based on your previous actions and outputs then use ``` exit ``` as the command to let the system know that you are done.
- DO NOT make any copies of your previous memories, those will be provided to you at each step, making copies just wastes time and energy. Think smarter not harder.
- The write and edit commands requires proper indentation in the content section ex. `write hw.py def hello():\n print(\'Hello World\')` this is how you would have to format your write command.
- The white spaces matter as the code changes will be added to the code so they must have proper syntax.
This is a template using the format described above
Items in <> are suggestions for you, fill them out based on the context of the problem you are solving.
[ FORMAT ]
Thoughts:
<Provide clear and concise thoughts on the next step to take, highlighting any important details or context that should be remembered.>
<You can use multiple lines to express your thoughts>
Action:
```
<command> <params>
```
[ END FORMAT ]
Do not provide anything extra just your thought and action.
"""
SYSTEM_MESSAGE = f"""SYSTEM INFO:
You are an autonomous coding agent, here to provide solutions for coding issues.
You have been designed to assist with a wide range of programming tasks, from code editing and debugging to testing and deployment.
You have access to a variety of tools and commands that you can use to help you solve problems efficiently.
{GENERAL_GUIDELINES}
{DOCUMENTATION}
""".strip()
def NO_ACTION(latest):
return f"""
You did not include any action to take in your most recent output:
===== Output ======
{latest}
==== End Output ===
Remember these are the custom commands you can use:
{DOCUMENTATION}
Lets try that again, it is very important that you adhere to the output format
This time, be sure to use the exact format below, replacing anything in <> with the appropriate value(s):
{RESPONSE_FORMAT}
It is crucial you use the format provided as the output will be parsed automatically.
"""
def file_info(file: str, line: int):
if file:
return f"""CURRENT WORKSPACE:
Open File: {file} on line {line}
You can use these commands with the current file:
Navigation: `scroll_up`, `scroll_down`, and `goto <line>`
Modification: `edit <start_line> <end_line> <changes>`
"""
def STEP_PROMPT(task, file, line_num):
return f"""
{RESPONSE_FORMAT}
You are currently trying to complete this task:
{task}
{file_info(file, line_num)}
Keep all of the guidelines above in mind when you are thinking and making code.
Please come up with a thought and action based on your current task and latest steps.
Make sure that you do not repeat the same actions, there will not be any changes in result if you do not changes anything.
Be very strict about the formatting that you use and make sure you follow the guidelines.
NEVER output multiple commands. ONLY take ONE STEP at a time.
When you have completed your task run the "exit" command.
Begin with your thought about the next step and then come up with an action to perform your thought.
""".strip()
def unpack_dict(data: dict, restrict: list[str] | None = None):
lines = []
restrict = [] if restrict is None else restrict
for key, value in data.items():
if key in restrict:
continue
elif isinstance(value, dict):
nested_str = unpack_dict(value, restrict).replace('\n', '\n ')
val = f'{key}:' + '\n ' + f'{nested_str}'
lines.append(val)
else:
lines.append(f'{key}: {value}')
return '\n'.join(lines)
def MEMORY_FORMAT(act, obs):
return f"""
Previous Action:
{unpack_dict(act, ["content"])}
Output from Action:
{unpack_dict(obs)}
""".strip()
def CONTEXT_PROMPT(memory, window):
res = f'These are your past {window} actions:\n'
window_size = window if len(memory) > window else len(memory)
cur_mems = memory[-window_size:]
res += '===== Previous Actions =====\n'
for idx, mem in enumerate(cur_mems):
res += f'\nMemory {idx}:\n{mem}\n'
res += '======= End Actions =======\n'
res += 'Use these memories to provide additional context to the problem you are solving.\nRemember that you have already completed these steps so you do not need to perform them again.'
return res

2
agenthub/__init__.py
View File

@ -9,7 +9,6 @@ load_dotenv()
from . import ( # noqa: E402
SWE_agent,
browsing_agent,
codeact_agent,
codeact_swe_agent,
@ -24,7 +23,6 @@ __all__ = [
'codeact_agent',
'codeact_swe_agent',
'planner_agent',
'SWE_agent',
'delegator_agent',
'dummy_agent',
'browsing_agent',