Introducing Delvin: State of the art bug fixing agent

class Action(BaseModel):
    thoughts: str = Field(
        ...,
        description="Step by step reasoning about the action to take. Make sure you have viewed all the necessary code before making an edit. It's always okay to look at more code.",
    )
    learning: Optional[str] = Field(
        ...,
        description="A learned fact about the repo and issue. Could be about a specific function or a pattern in the code.",
    )
    action_name: Literal[
        "search",
        "edits",
        "submit",
        "view_file",
    ] = Field(..., description="The action to take.")
    action_input: Union[
        Search,
        Edits,
        Submit,
        ViewFile,
    ]

class Trajectory(BaseModel):
    """The trajectory of the agent's actions."""

    actions: list[ActionWithResult]
    gained_knowledge: list[str] = Field(default_factory=list)


from opperai import fn
# get_action is called in a loop until the agent decides to submit a patch or the maximum number of actions is reached
@fn()
    async def get_action(
        trajectory: Trajectory, problem: str, other_info: str
    ) -> Action:

class Search(BaseModel):
    """Search for a regex in the repository. Will search through file names and their contents."""

    regex: str = Field(
        ...,
        description="Regex to search for. Matches will be returned",
    )

First 100 files containing def\s+from_json:

- pydicom/dataset.py line 2225 : def from_json(
- pydicom/dataelem.py line 230 : def from_json(

First 100 filenames matching def\s+from_json:

No file names containing def\s+from_json found.

class ViewFile(BaseModel):
    """View a file in the repository. Don't hesitate to call this action multiple times to move around the file and to get more context."""

    file_path: str
    cursor_line: int = Field(
        ...,
        description="The line number to start from.",
    )
    before: int = Field(
        ge=100,
        description="Number of lines to display before the cursor line.",
    )
    after: int = Field(
        ge=100,
        description="Number of lines to display after the cursor line.",
    )

# Outline:

63: class PrivateBlock:
86: def __init__(
109: def get_tag(self, element_offset: int) -> BaseTag:
131: def __contains__(self, element_offset: int) -> bool:
137: def __getitem__(self, element_offset: int) -> DataElement:
160: def __delitem__(self, element_offset: int) -> None:
178: def add_new(self, element_offset: int, VR: str, value: object) -> None:
201: def _dict_equal(
221: class Dataset(Dict[BaseTag, _DatasetValue]):
373: def __init__(
...

# File content:

2126|             The file meta information was added in its own section,
2127|             if :data:`pydicom.config.show_file_meta` is ``True``
2128| 
2129|         """
2130|         return self._pretty_str()
2131| 
2132|     def top(self) -> str:
2133|         """Return a :class:`str` representation of the top level elements. """
2134|         return self._pretty_str(top_level_only=True)
2135| 
2136|     def trait_names(self) -> List[str]:
2137|         """Return a :class:`list` of valid names for auto-completion code.
2138| 
2139|         Used in IPython, so that data element names can be found and offered
2140|         for autocompletion on the IPython command line.
2141|         """
2142|         return dir(self)
2143| 
2144|     def update(
2145|         self, dictionary: Union[Dict[str, object], Dict[TagType, DataElement]]
2146|     ) -> None:
2147|         """Extend :meth:`dict.update` to handle DICOM tags and keywords.
2148| 
2149|         Parameters
...

class Edit(BaseModel):
    """
    Edit a file in the repository by replacing a code block.
    Before applying edits, validate the existence and correct implementation of any new functions or variables introduced.
    Make sure you have seen all the code necessary to make the edit. View entire function bodies first.
    The edited code CANNOT refer to unknown variables or functions. NO TODOS or placeholders.
    Edits can only be done in files and lines that have already been viewed.

    You MUST remove line numbers from the new code and keep indentation intact.
    """

    file_path: str = Field(..., description="Path of the file to edit.")
    seen_all_needed_code: bool = Field(
        ...,
        description="Have you seen all the code needed to make the edit? Did you view the entire body of the function you are about to modify? You must be SURE.",
    )
    no_other_file_viewing_needed: bool = Field(
        ...,
        description="Did you take a good look at other methods/classes in the file that were provided in the file outline? Are you sure you don't need anything else? You must be SURE.",
    )
    edit_contains_all_needed_code: bool = Field(
        ...,
        description="Will you write all the code you need to replace the old code? You must guarantee that you will not take shortcuts and be thorough.",
    )
    short_description: str = Field(
        ...,
        description="A short description of the edit where you identify the lines to edit and what to do.",
    )
    code_to_replace: str = Field(
        ...,
        description="The code that will be replaced. Keep line numbers intact.",
    )
    start_line: int = Field(
        ..., description="The index of the first line that will be replaced."
    )
    end_line: int = Field(
        ...,
        description="Line number to end editing at. All lines betwee start_line and end_line are replaced.",
    )
    new_code: str = Field(
        ...,
        description="The new code to replace the old code with, WITHOUT line numbers. Indentation MUST be correct. Keep all leading whitespaces and newlines intact. Example:'    def new_action(self):\n        pass\n'",
    )
    no_unknowns: bool = Field(
        default=False,
        description="If true, the edited code does not refer to unknown variables or functions. The edited code does not contain placeholders for future implementation.",
    )

@fn
async def smart_code_replace(code_snippet: str, to_replace: str, new_code: str) -> str:
    """
    Given a code snippet, replace the code given in the to_replace variable with the new_code variable and return the fully edited code.

    It is possible that there are slight indentation issues and small mistakes in the provided to_replace and new_code variables.
    Return a fully syntactically correct code snippet. Focus on indentation, it might be incorrect.
    """

class Evaluation(BaseModel):
    """
    Evaluation of the action an agent is going to take given its trajectory.
    """

    observations: str = Field(
        ...,
        description="Detailed observations of where we are and if the action makes sense.",
    )
    right_track: bool = Field(
        ..., description="Whether the action is on the right track."
    )
    feedback: Optional[str] = Field(
        None,
        description="Feedback for the agent if not on the right track. Could be used to course correct.",
    )


@fn
async def evaluate_action(
    trajectory: Trajectory,
    action_to_evaluate: Action,
    possible_actions: str,
    problem: str,
) -> Evaluation:
    """
    Evaluate the action an agent is going to take given its trajectory and the actions it can take.
    You are given the problem it is trying to solve.
    Be very diligent in evaluating the action, especially if it is an edit.
    You can only affect the action that is being evaluated, not the trajectory. Focus on whether the action makes sense and propose
    an alternative if it doesn't.
    """