@elizaos/sweagent-root 2.0.0-alpha

package/python/tools/windowed/lib/windowed_file.py

@@ -0,0 +1,312 @@
+from pathlib import Path
+
+try:
+    from sweagent import TOOLS_DIR
+except ImportError:
+    pass
+else:
+    import sys
+
+    sys.path.append(str(TOOLS_DIR / "registry" / "lib"))
+
+from registry import registry
+
+
+class FileNotOpened(Exception):
+    """Raised when no file is opened."""
+
+
+class TextNotFound(Exception):
+    """Raised when the text is not found in the window."""
+
+
+def _find_all(a_str: str, sub: str):
+    start = 0
+    while True:
+        start = a_str.find(sub, start)
+        if start == -1:
+            return
+        yield start
+        start += len(sub)
+
+
+class ReplacementInfo:
+    def __init__(self, first_replaced_line: int, n_search_lines: int, n_replace_lines: int, n_replacements: int):
+        self.first_replaced_line = first_replaced_line
+        self.n_search_lines = n_search_lines
+        self.n_replace_lines = n_replace_lines
+        self.n_replacements = n_replacements
+
+    def __repr__(self):
+        return f"ReplacementInfo(first_replaced_line={self.first_replaced_line}, n_search_lines={self.n_search_lines}, n_replace_lines={self.n_replace_lines}, n_replacements={self.n_replacements})"
+
+
+class InsertInfo:
+    def __init__(self, first_inserted_line: int, n_lines_added: int):
+        self.first_inserted_line = first_inserted_line
+        self.n_lines_added = n_lines_added
+
+
+class WindowedFile:
+    def __init__(
+        self,
+        path: Path | None = None,
+        *,
+        first_line: int | None = None,
+        window: int | None = None,
+        exit_on_exception: bool = True,
+    ):
+        """
+
+        Args:
+            path: Path to the file to open.
+            first_line: First line of the display window.
+            window: Number of lines to display.
+            exit_on_exception: If False, will raise exception.
+                If true, will print an error message and exit.
+
+        Will create file if not found.
+
+        Internal convention/notes:
+
+        * All line numbers are 0-indexed.
+        * Previously, we used "current_line" for the internal state
+          of the window position, pointing to the middle of the window.
+          Now, we use `first_line` for this purpose (it's simpler this way).
+        """
+        _path = registry.get_if_none(path, "CURRENT_FILE")
+        self._exit_on_exception = exit_on_exception
+        if not _path:
+            if self._exit_on_exception:
+                print("No file open. Use the open command first.")
+                exit(1)
+            raise FileNotOpened
+        self.path = Path(_path)
+        if self.path.is_dir():
+            msg = f"Error: {self.path} is a directory. You can only open files. Use cd or ls to navigate directories."
+            if self._exit_on_exception:
+                print(msg)
+                exit(1)
+            raise IsADirectoryError(msg)
+        if not self.path.exists():
+            msg = f"Error: File {self.path} not found"
+            if self._exit_on_exception:
+                print(msg)
+                exit(1)
+            raise FileNotFoundError(msg)
+        registry["CURRENT_FILE"] = str(self.path.resolve())
+        self.window = int(registry.get_if_none(window, "WINDOW"))
+        self.overlap = int(registry.get("OVERLAP", 0))
+        # Ensure that we get a valid current line by using the setter
+        self._first_line = 0
+        self.first_line = int(
+            registry.get_if_none(
+                first_line,
+                "FIRST_LINE",
+                0,
+            )
+        )
+        self.offset_multiplier = 1 / 6
+        self._original_text = self.text
+        self._original_first_line = self.first_line
+
+    @property
+    def first_line(self) -> int:
+        return self._first_line
+
+    @first_line.setter
+    def first_line(self, value: int | float):
+        self._original_first_line = self.first_line
+        value = int(value)
+        self._first_line = max(0, min(value, self.n_lines - self.window))
+        registry["FIRST_LINE"] = self.first_line
+
+    @property
+    def text(self) -> str:
+        return self.path.read_text()
+
+    @text.setter
+    def text(self, new_text: str):
+        self._original_text = self.text
+        self.path.write_text(new_text)
+
+    @property
+    def n_lines(self) -> int:
+        return len(self.text.splitlines())
+
+    @property
+    def line_range(self) -> tuple[int, int]:
+        """Return first and last line (inclusive) of the display window, such
+        that exactly `window` many lines are displayed.
+        This means `line_range[1] - line_range[0] == window-1` as long as there are
+        at least `window` lines in the file. `first_line` does the handling
+        of making sure that we don't go out of bounds.
+        """
+        return self.first_line, min(self.first_line + self.window - 1, self.n_lines - 1)
+
+    def get_window_text(
+        self, *, line_numbers: bool = False, status_line: bool = False, pre_post_line: bool = False
+    ) -> str:
+        """Get the text in the current display window with optional status/extra information
+
+        Args:
+            line_numbers: include line numbers in the output
+            status_line: include the status line in the output (file path, total lines)
+            pre_post_line: include the pre/post line in the output (number of lines above/below)
+        """
+        start_line, end_line = self.line_range
+        lines = self.text.split("\n")[start_line : end_line + 1]
+        out_lines = []
+        if status_line:
+            out_lines.append(f"[File: {self.path} ({self.n_lines} lines total)]")
+        if pre_post_line:
+            if start_line > 0:
+                out_lines.append(f"({start_line} more lines above)")
+        if line_numbers:
+            out_lines.extend(f"{i + start_line + 1}:{line}" for i, line in enumerate(lines))
+        else:
+            out_lines.extend(lines)
+        if pre_post_line:
+            if end_line < self.n_lines - 1:
+                out_lines.append(f"({self.n_lines - end_line - 1} more lines below)")
+        return "\n".join(out_lines)
+
+    def set_window_text(self, new_text: str, *, line_range: tuple[int, int] | None = None) -> None:
+        """Replace the text in the current display window with a new string."""
+        text = self.text.split("\n")
+        if line_range is not None:
+            start, stop = line_range
+        else:
+            start, stop = self.line_range
+
+        # Handle empty replacement text (deletion case)
+        new_lines = new_text.split("\n") if new_text else []
+        text[start : stop + 1] = new_lines
+        self.text = "\n".join(text)
+
+    def replace_in_window(
+        self,
+        search: str,
+        replace: str,
+        *,
+        reset_first_line: str = "top",
+    ) -> "ReplacementInfo":
+        """Search and replace in the window.
+
+        Args:
+            search: The string to search for (can be multi-line).
+            replace: The string to replace it with (can be multi-line).
+            reset_first_line: If "keep", we keep the current line. Otherwise, we
+                `goto` the line where the replacement started with this mode.
+        """
+        window_text = self.get_window_text()
+        # Update line number
+        index = window_text.find(search)
+        if index == -1:
+            if self._exit_on_exception:
+                print(f"Error: Text not found: {search}")
+                exit(1)
+            raise TextNotFound
+        window_start_line, _ = self.line_range
+        replace_start_line = window_start_line + len(window_text[:index].split("\n")) - 1
+        new_window_text = window_text.replace(search, replace)
+        self.set_window_text(new_window_text)
+        if reset_first_line == "keep":
+            pass
+        else:
+            self.goto(replace_start_line, mode=reset_first_line)
+        return ReplacementInfo(
+            first_replaced_line=replace_start_line,
+            n_search_lines=len(search.split("\n")),
+            n_replace_lines=len(replace.split("\n")),
+            n_replacements=1,
+        )
+
+    def find_all_occurrences(self, search: str, zero_based: bool = True) -> list[int]:
+        """Returns the line numbers of all occurrences of the search string."""
+        indices = list(_find_all(self.text, search))
+        line_numbers = []
+        for index in indices:
+            line_no = len(self.text[:index].split("\n"))
+            if zero_based:
+                line_numbers.append(line_no - 1)
+            else:
+                line_numbers.append(line_no)
+        return line_numbers
+
+    def replace(self, search: str, replace: str, *, reset_first_line: str = "top") -> "ReplacementInfo":
+        indices = list(_find_all(self.text, search))
+        if not indices:
+            if self._exit_on_exception:
+                print(f"Error: Text not found: {search}")
+                exit(1)
+            raise TextNotFound
+        replace_start_line = len(self.text[: indices[0]].split("\n"))
+        new_text = self.text.replace(search, replace)
+        self.text = new_text
+        if reset_first_line == "keep":
+            pass
+        else:
+            self.goto(replace_start_line, mode=reset_first_line)
+        return ReplacementInfo(
+            first_replaced_line=replace_start_line,
+            n_search_lines=len(search.split("\n")),
+            n_replace_lines=len(replace.split("\n")),
+            n_replacements=len(indices),
+        )
+
+    def print_window(self, *, line_numbers: bool = True, status_line: bool = True, pre_post_line: bool = True):
+        print(self.get_window_text(line_numbers=line_numbers, status_line=status_line, pre_post_line=pre_post_line))
+
+    def goto(self, line: int, mode: str = "top"):
+        if mode == "top":
+            self.first_line = line - self.window * self.offset_multiplier
+        else:
+            raise NotImplementedError
+
+    def scroll(self, n_lines: int):
+        if n_lines > 0:
+            self.first_line += n_lines - self.overlap
+        elif n_lines < 0:
+            self.first_line += n_lines + self.overlap
+
+    def undo_edit(self):
+        self.text = self._original_text
+        self.first_line = self._original_first_line
+
+    def insert(self, text: str, line: int | None = None, *, reset_first_line: str = "top") -> "InsertInfo":
+        # Standardize empty text handling
+        if not text:
+            return InsertInfo(first_inserted_line=(self.n_lines if line is None else line), n_lines_added=0)
+
+        # Remove single trailing newline if it exists
+        text = text[:-1] if text.endswith("\n") else text
+
+        if line is None:
+            # Append to end of file
+            if not self.text:
+                new_text = text
+            else:
+                current_text = self.text[:-1] if self.text.endswith("\n") else self.text
+                new_text = current_text + "\n" + text
+            insert_line = self.n_lines
+        elif line < 0:
+            # Insert at start of file
+            if not self.text:
+                new_text = text
+            else:
+                current_text = self.text[1:] if self.text.startswith("\n") else self.text
+                new_text = text + "\n" + current_text
+            insert_line = 0
+        else:
+            # Insert at specific line
+            lines = self.text.split("\n")
+            lines.insert(line, text)
+            new_text = "\n".join(lines)
+            insert_line = line
+
+        self.text = new_text
+        if reset_first_line != "keep":
+            self.goto(insert_line, mode=reset_first_line)
+
+        return InsertInfo(first_inserted_line=insert_line, n_lines_added=len(text.split("\n")))

package/python/tools/windowed_edit_linting/bin/edit

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+
+import argparse
+import sys
+from typing import Tuple, Union
+
+try:
+    from sweagent import TOOLS_DIR
+except ImportError:
+    pass
+else:
+    default_lib = TOOLS_DIR / "windowed" / "lib"
+    assert default_lib.is_dir()
+    sys.path.append(str(default_lib))
+    sys.path.append(str(TOOLS_DIR / "registry" / "lib"))
+
+from windowed_file import FileNotOpened, WindowedFile  # type: ignore
+from flake8_utils import flake8, format_flake8_output  # type: ignore
+
+_USAGE_MSG = """Usage: edit <start_line>:<end_line>
+<replacement_text>
+end_of_edit"""
+
+_EDIT_SUCCESS_MSG = """File updated. Please review the changes and make sure they are correct
+(correct indentation, no duplicate lines, etc). Edit the file again if necessary."""
+
+_LINT_ERROR_TEMPLATE = """Your proposed edit has introduced new syntax error(s). Please read this error message carefully and then retry editing the file.
+
+ERRORS:
+{errors}
+
+This is how your edit would have looked if applied
+------------------------------------------------
+{window_applied}
+------------------------------------------------
+
+This is the original code before your edit
+------------------------------------------------
+{window_original}
+------------------------------------------------
+
+Your changes have NOT been applied. Please fix your edit command and try again.
+DO NOT re-run the same failed edit command. Running it again will lead to the same error."""
+
+
+def get_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("line_range", help="Line range in format start:end")
+    parser.add_argument("replacement_text", help="Text to insert", nargs="?")
+    return parser
+
+
+def parse_line_range(line_range: str) -> Tuple[int, int]:
+    try:
+        start, end = map(int, line_range.split(":"))
+        return start - 1, end - 1
+    except ValueError:
+        print(_USAGE_MSG)
+        exit(1)
+
+
+def main(line_range: str, replacement_text: Union[str, None] = None):
+    # Handle file opening
+    try:
+        wf = WindowedFile(exit_on_exception=False)
+    except FileNotOpened:
+        print("No file opened. Use the `open` command first.")
+        exit(1)
+
+    # Parse line range
+    start_line, end_line = parse_line_range(line_range)
+
+    if replacement_text is None:
+        # Read replacement text from stdin (e.g., when sent via bash heredoc)
+        # if not provided as argument
+        replacement_lines = []
+        while True:
+            try:
+                line = input()
+                if line == "end_of_edit":
+                    break
+                replacement_lines.append(line)
+            except EOFError:
+                break
+        replacement_text = "\n".join(replacement_lines)
+    else:
+        if replacement_text.endswith("\n"):
+            replacement_text = replacement_text[:-1]
+
+    if replacement_text is None:
+        print(_USAGE_MSG)
+        exit(1)
+
+    # Get pre-edit linting errors
+    pre_edit_lint = flake8(wf.path)
+
+    # Perform the edit
+    wf.set_window_text(replacement_text, line_range=(start_line, end_line))
+
+    # Check for new linting errors
+    post_edit_lint = flake8(wf.path)
+    new_flake8_output = format_flake8_output(
+        post_edit_lint,
+        previous_errors_string=pre_edit_lint,
+        replacement_window=(start_line, end_line),
+        replacement_n_lines=len(replacement_text.splitlines()),
+    )
+
+    if new_flake8_output:
+        # Show error and revert changes
+        with_edits = wf.get_window_text(line_numbers=True, status_line=True, pre_post_line=True)
+        wf.undo_edit()
+        without_edits = wf.get_window_text(line_numbers=True, status_line=True, pre_post_line=True)
+        print(
+            _LINT_ERROR_TEMPLATE.format(
+                errors=new_flake8_output, window_applied=with_edits, window_original=without_edits
+            )
+        )
+        exit(1)
+
+    # Success - update window position and show result
+    wf.goto(start_line, mode="top")
+    print(_EDIT_SUCCESS_MSG)
+    wf.print_window()
+
+
+if __name__ == "__main__":
+    main(**vars(get_parser().parse_args()))

package/python/tools/windowed_edit_linting/config.yaml

@@ -0,0 +1,31 @@
+tools:
+  edit:
+    signature: |
+      edit <start_line>:<end_line>
+      <replacement_text>
+      end_of_edit
+    # Note: Without function calling we should add back:
+    # The replacement text is terminated by a line with only
+    # end_of_edit on
+    docstring: >
+      Replaces lines <start_line> through <end_line> (inclusive) with the given text
+      in the open file.
+      All of the <replacement text> will be entered, so make
+      sure your indentation is formatted properly.
+
+      Please note that THIS COMMAND REQUIRES PROPER INDENTATION.
+      If you'd like to add the line '        print(x)' you must fully write that out, with all those spaces before the code!
+    end_name: "end_of_edit"
+    arguments:
+      - name: start_line
+        type: integer
+        description: "the line number to start the edit at"
+        required: true
+      - name: end_line
+        type: integer
+        description: "the line number to end the edit at (inclusive)"
+        required: true
+      - name: replacement_text
+        type: string
+        description: "the text to replace the current selection with"
+        required: true

package/python/tools/windowed_edit_linting/install.sh

@@ -0,0 +1,5 @@
+_write_env "CURRENT_FILE" "${CURRENT_FILE:-}"
+_write_env "CURRENT_LINE" "${CURRENT_LINE:-0}"
+_write_env "WINDOW" "$WINDOW"
+
+pip install flake8

package/python/tools/windowed_edit_replace/bin/edit

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+
+import argparse
+
+try:
+    from sweagent import TOOLS_DIR
+except ImportError:
+    pass
+else:
+    import sys
+
+    default_lib = TOOLS_DIR / "windowed" / "lib"
+    assert default_lib.is_dir()
+    sys.path.append(str(default_lib))
+    sys.path.append(str(TOOLS_DIR / "registry" / "lib"))
+
+from windowed_file import FileNotOpened, TextNotFound, WindowedFile  # type: ignore
+from flake8_utils import flake8, format_flake8_output  # type: ignore
+
+RETRY_WITH_OUTPUT_TOKEN = "###SWE-AGENT-RETRY-WITH-OUTPUT###"
+
+_NOT_FOUND = """Your edit was not applied (file not modified): Text {search!r} not found in displayed lines (or anywhere in the file).
+Please modify your search string. Did you forget to properly handle whitespace/indentation?
+You can also call `open` again to re-display the file with the correct context.
+"""
+
+_NOT_FOUND_IN_WINDOW_MSG = """Your edit was not applied (file not modified): Text {search!r} not found in displayed lines.
+
+However, we found the following occurrences of your search string in the file:
+
+{occurrences}
+
+You can use the `goto` command to navigate to these locations before running the edit command again.
+"""
+
+_MULTIPLE_OCCURRENCES_MSG = """Your edit was not applied (file not modified): Found more than one occurrence of {search!r} in the currently displayed lines.
+Please make your search string more specific (for example, by including more lines of context).
+"""
+
+_NO_CHANGES_MADE_MSG = """Your search and replace strings are the same. No changes were made. Please modify your search or replace strings."""
+
+_SINGLE_EDIT_SUCCESS_MSG = """Text replaced. Please review the changes and make sure they are correct:
+
+1. The edited file is correctly indented
+2. The edited file does not contain duplicate lines
+3. The edit does not break existing functionality
+
+Edit the file again if necessary."""
+
+_MULTIPLE_EDITS_SUCCESS_MSG = """Replaced {n_replacements} occurrences. Please review the changes and make sure they are correct:
+
+1. The edited file is correctly indented
+2. The edited file does not contain duplicate lines
+3. The edit does not break existing functionality
+
+Edit the file again if necessary."""
+
+_LINT_ERROR_TEMPLATE = """Your proposed edit has introduced new syntax error(s). Please read this error message carefully and then retry editing the file.
+
+ERRORS:
+
+{errors}
+
+This is how your edit would have looked if applied
+------------------------------------------------
+{window_applied}
+------------------------------------------------
+
+This is the original code before your edit
+------------------------------------------------
+{window_original}
+------------------------------------------------
+
+Your changes have NOT been applied. Please fix your edit command and try again.
+DO NOT re-run the same failed edit command. Running it again will lead to the same error.
+"""
+
+
+def get_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("search", type=str)
+    parser.add_argument("replace", type=str)
+    parser.add_argument("replace_all", type=bool, nargs="?", default=False)
+    return parser
+
+
+def main(search: str, replace: str, replace_all: bool):
+    try:
+        wf = WindowedFile(exit_on_exception=False)
+    except FileNotOpened:
+        print("No file opened. Either `open` or `create` a file first.")
+        exit(1)
+
+    # Turn \\n into \n etc., i.e., undo the escaping
+    # args.replace = args.replace.encode("utf8").decode("unicode_escape")
+
+    if search == replace:
+        print(_NO_CHANGES_MADE_MSG)
+        print(RETRY_WITH_OUTPUT_TOKEN)
+        exit(2)
+
+    pre_edit_lint = flake8(wf.path)
+
+    try:
+        if not replace_all:
+            window_text = wf.get_window_text()
+            if window_text.count(search) > 1:
+                print(_MULTIPLE_OCCURRENCES_MSG.format(search=search))
+                print(RETRY_WITH_OUTPUT_TOKEN)
+                exit(4)
+            replacement_info = wf.replace_in_window(search, replace)
+            # todo: Should warn if more than one occurrence was found?
+        else:
+            # todo: Give overview of all replaced occurrences/number of replacements
+            replacement_info = wf.replace(search, replace)
+    except TextNotFound:
+        line_no_founds = wf.find_all_occurrences(search, zero_based=False)
+        if line_no_founds:
+            print(
+                _NOT_FOUND_IN_WINDOW_MSG.format(
+                    search=search, occurrences="\n".join([f"- line {line_no}" for line_no in line_no_founds])
+                )
+            )
+        else:
+            print(_NOT_FOUND.format(search=search))
+        print(RETRY_WITH_OUTPUT_TOKEN)
+        exit(3)
+
+    post_edit_lint = flake8(wf.path)
+
+    if not replace_all:
+        # Try to filter out pre-existing errors
+        replacement_window = (
+            replacement_info.first_replaced_line,
+            replacement_info.first_replaced_line + replacement_info.n_search_lines - 1,
+        )
+        # print(f"{replacement_info=}")
+        # print(f"{replacement_window=}")
+        # print(f"{pre_edit_lint=}")
+        # print(f"{post_edit_lint=}")
+        new_flake8_output = format_flake8_output(
+            post_edit_lint,
+            previous_errors_string=pre_edit_lint,
+            replacement_window=replacement_window,
+            replacement_n_lines=replacement_info.n_replace_lines,
+        )
+    else:
+        # Cannot easily compare the error strings, because line number changes are hard to keep track of
+        # So we show all linter errors.
+        new_flake8_output = format_flake8_output(post_edit_lint)
+
+    if new_flake8_output:
+        with_edits = wf.get_window_text(line_numbers=True, status_line=True, pre_post_line=True)
+        wf.undo_edit()
+        without_edits = wf.get_window_text(line_numbers=True, status_line=True, pre_post_line=True)
+        print(
+            _LINT_ERROR_TEMPLATE.format(
+                errors=new_flake8_output, window_applied=with_edits, window_original=without_edits,
+            )
+        )
+        print(RETRY_WITH_OUTPUT_TOKEN)
+        exit(4)
+    if not replace_all:
+        print(_SINGLE_EDIT_SUCCESS_MSG)
+    else:
+        print(_MULTIPLE_EDITS_SUCCESS_MSG.format(n_replacements=replacement_info.n_replacements))
+
+    wf.print_window()
+
+
+if __name__ == "__main__":
+    main(**vars(get_parser().parse_args()))