diff --git a/src/serena/code_editor.py b/src/serena/code_editor.py
new file mode 100644
index 00000000..0f48bb54
--- /dev/null
+++ b/src/serena/code_editor.py
@@ -0,0 +1,911 @@
+import json
+import logging
+import os
+from collections.abc import Iterable, Iterator, Reversible, Sequence
+from contextlib import contextmanager
+from dataclasses import asdict, dataclass, field
+from difflib import SequenceMatcher
+from typing import TYPE_CHECKING, Any, Literal, NamedTuple, Self, Union
+
+from sensai.util.string import ToStringMixin
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls import ReferenceInSymbol as LSPReferenceInSymbol
+from solidlsp.ls_types import Position, SymbolKind, UnifiedSymbolInformation
+
+if TYPE_CHECKING:
+    from .agent import SerenaAgent
+
+log = logging.getLogger(__name__)
+
+
+class LineChange(NamedTuple):
+    """Represents a change to a specific line or range of lines."""
+
+    operation: Literal["insert", "delete", "replace"]
+    original_start: int
+    original_end: int
+    modified_start: int
+    modified_end: int
+    original_lines: list[str]
+    modified_lines: list[str]
+
+
+@dataclass
+class CodeDiff:
+    """
+    Represents the difference between original and modified code.
+    Provides object-oriented access to diff information including line numbers.
+    """
+
+    relative_path: str
+    original_content: str
+    modified_content: str
+    _line_changes: list[LineChange] = field(init=False)
+
+    def __post_init__(self) -> None:
+        """Compute the diff using difflib's SequenceMatcher."""
+        original_lines = self.original_content.splitlines(keepends=True)
+        modified_lines = self.modified_content.splitlines(keepends=True)
+
+        matcher = SequenceMatcher(None, original_lines, modified_lines)
+        self._line_changes = []
+
+        for tag, orig_start, orig_end, mod_start, mod_end in matcher.get_opcodes():
+            if tag == "equal":
+                continue
+            if tag == "insert":
+                self._line_changes.append(
+                    LineChange(
+                        operation="insert",
+                        original_start=orig_start,
+                        original_end=orig_start,
+                        modified_start=mod_start,
+                        modified_end=mod_end,
+                        original_lines=[],
+                        modified_lines=modified_lines[mod_start:mod_end],
+                    )
+                )
+            elif tag == "delete":
+                self._line_changes.append(
+                    LineChange(
+                        operation="delete",
+                        original_start=orig_start,
+                        original_end=orig_end,
+                        modified_start=mod_start,
+                        modified_end=mod_start,
+                        original_lines=original_lines[orig_start:orig_end],
+                        modified_lines=[],
+                    )
+                )
+            elif tag == "replace":
+                self._line_changes.append(
+                    LineChange(
+                        operation="replace",
+                        original_start=orig_start,
+                        original_end=orig_end,
+                        modified_start=mod_start,
+                        modified_end=mod_end,
+                        original_lines=original_lines[orig_start:orig_end],
+                        modified_lines=modified_lines[mod_start:mod_end],
+                    )
+                )
+
+    @property
+    def line_changes(self) -> list[LineChange]:
+        """Get all line changes in the diff."""
+        return self._line_changes
+
+    @property
+    def has_changes(self) -> bool:
+        """Check if there are any changes."""
+        return len(self._line_changes) > 0
+
+    @property
+    def added_lines(self) -> list[tuple[int, str]]:
+        """Get all added lines with their line numbers (0-based) in the modified file."""
+        result = []
+        for change in self._line_changes:
+            if change.operation in ("insert", "replace"):
+                for i, line in enumerate(change.modified_lines):
+                    result.append((change.modified_start + i, line))
+        return result
+
+    @property
+    def deleted_lines(self) -> list[tuple[int, str]]:
+        """Get all deleted lines with their line numbers (0-based) in the original file."""
+        result = []
+        for change in self._line_changes:
+            if change.operation in ("delete", "replace"):
+                for i, line in enumerate(change.original_lines):
+                    result.append((change.original_start + i, line))
+        return result
+
+    @property
+    def modified_line_numbers(self) -> list[int]:
+        """Get all line numbers (0-based) that were modified in the modified file."""
+        line_nums: set[int] = set()
+        for change in self._line_changes:
+            if change.operation in ("insert", "replace"):
+                line_nums.update(range(change.modified_start, change.modified_end))
+        return sorted(line_nums)
+
+    @property
+    def affected_original_line_numbers(self) -> list[int]:
+        """Get all line numbers (0-based) that were affected in the original file."""
+        line_nums: set[int] = set()
+        for change in self._line_changes:
+            if change.operation in ("delete", "replace"):
+                line_nums.update(range(change.original_start, change.original_end))
+        return sorted(line_nums)
+
+    def get_unified_diff(self, context_lines: int = 3) -> str:
+        """Get the unified diff as a string."""
+        import difflib
+
+        original_lines = self.original_content.splitlines(keepends=True)
+        modified_lines = self.modified_content.splitlines(keepends=True)
+
+        diff = difflib.unified_diff(
+            original_lines, modified_lines, fromfile=f"a/{self.relative_path}", tofile=f"b/{self.relative_path}", n=context_lines
+        )
+        return "".join(diff)
+
+    def get_context_diff(self, context_lines: int = 3) -> str:
+        """Get the context diff as a string."""
+        import difflib
+
+        original_lines = self.original_content.splitlines(keepends=True)
+        modified_lines = self.modified_content.splitlines(keepends=True)
+
+        diff = difflib.context_diff(
+            original_lines, modified_lines, fromfile=f"a/{self.relative_path}", tofile=f"b/{self.relative_path}", n=context_lines
+        )
+        return "".join(diff)
+
+
+@dataclass
+class SymbolLocation:
+    """
+    Represents the (start) location of a symbol identifier, which, within Serena, uniquely identifies the symbol.
+    """
+
+    relative_path: str | None
+    """
+    the relative path of the file containing the symbol; if None, the symbol is defined outside of the project's scope
+    """
+    line: int | None
+    """
+    the line number in which the symbol identifier is defined (if the symbol is a function, class, etc.);
+    may be None for some types of symbols (e.g. SymbolKind.File)
+    """
+    column: int | None
+    """
+    the column number in which the symbol identifier is defined (if the symbol is a function, class, etc.);
+    may be None for some types of symbols (e.g. SymbolKind.File)
+    """
+
+    def __post_init__(self) -> None:
+        if self.relative_path is not None:
+            self.relative_path = self.relative_path.replace("/", os.path.sep)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    def has_position_in_file(self) -> bool:
+        return self.relative_path is not None and self.line is not None and self.column is not None
+
+
+class Symbol(ToStringMixin):
+    _NAME_PATH_SEP = "/"
+
+    @staticmethod
+    def match_name_path(
+        name_path: str,
+        symbol_name_path_parts: list[str],
+        substring_matching: bool,
+    ) -> bool:
+        """
+        Checks if a given `name_path` matches a symbol's qualified name parts.
+        See docstring of `Symbol.find` for more details.
+        """
+        assert name_path, "name_path must not be empty"
+        assert symbol_name_path_parts, "symbol_name_path_parts must not be empty"
+        name_path_sep = Symbol._NAME_PATH_SEP
+
+        is_absolute_pattern = name_path.startswith(name_path_sep)
+        pattern_parts = name_path.lstrip(name_path_sep).rstrip(name_path_sep).split(name_path_sep)
+
+        # filtering based on ancestors
+        if len(pattern_parts) > len(symbol_name_path_parts):
+            # can't possibly match if pattern has more parts than symbol
+            return False
+        if is_absolute_pattern and len(pattern_parts) != len(symbol_name_path_parts):
+            # for absolute patterns, the number of parts must match exactly
+            return False
+        if symbol_name_path_parts[-len(pattern_parts) : -1] != pattern_parts[:-1]:
+            # ancestors must match
+            return False
+
+        # matching the last part of the symbol name
+        name_to_match = pattern_parts[-1]
+        symbol_name = symbol_name_path_parts[-1]
+        if substring_matching:
+            return name_to_match in symbol_name
+        else:
+            return name_to_match == symbol_name
+
+    def __init__(self, symbol_root_from_ls: UnifiedSymbolInformation) -> None:
+        self.symbol_root = symbol_root_from_ls
+
+    def _tostring_includes(self) -> list[str]:
+        return []
+
+    def _tostring_additional_entries(self) -> dict[str, Any]:
+        return dict(name=self.name, kind=self.kind, num_children=len(self.symbol_root["children"]))
+
+    @property
+    def name(self) -> str:
+        return self.symbol_root["name"]
+
+    @property
+    def kind(self) -> str:
+        return SymbolKind(self.symbol_kind).name
+
+    @property
+    def symbol_kind(self) -> SymbolKind:
+        return self.symbol_root["kind"]
+
+    def is_neighbouring_definition_separated_by_empty_line(self) -> bool:
+        """
+        :return: whether a symbol definition of this symbol's kind is usually separated from the
+            previous/next definition by at least one empty line.
+        """
+        return self.symbol_kind in (SymbolKind.Function, SymbolKind.Method, SymbolKind.Class, SymbolKind.Interface, SymbolKind.Struct)
+
+    @property
+    def relative_path(self) -> str | None:
+        location = self.symbol_root.get("location")
+        if location:
+            return location.get("relativePath")
+        return None
+
+    @property
+    def location(self) -> SymbolLocation:
+        """
+        :return: the start location of the actual symbol identifier
+        """
+        return SymbolLocation(relative_path=self.relative_path, line=self.line, column=self.column)
+
+    @property
+    def body_start_position(self) -> Position | None:
+        location = self.symbol_root.get("location")
+        if location:
+            range_info = location.get("range")
+            if range_info:
+                start_pos = range_info.get("start")
+                if start_pos:
+                    return start_pos
+        return None
+
+    @property
+    def body_end_position(self) -> Position | None:
+        location = self.symbol_root.get("location")
+        if location:
+            range_info = location.get("range")
+            if range_info:
+                end_pos = range_info.get("end")
+                if end_pos:
+                    return end_pos
+        return None
+
+    def get_body_line_numbers(self) -> tuple[int | None, int | None]:
+        start_pos = self.body_start_position
+        end_pos = self.body_end_position
+        start_line = start_pos["line"] if start_pos else None
+        end_line = end_pos["line"] if end_pos else None
+        return start_line, end_line
+
+    @property
+    def line(self) -> int | None:
+        """
+        :return: the line in which the symbol identifier is defined.
+        """
+        if "selectionRange" in self.symbol_root:
+            return self.symbol_root["selectionRange"]["start"]["line"]
+        else:
+            # line is expected to be undefined for some types of symbols (e.g. SymbolKind.File)
+            return None
+
+    @property
+    def column(self) -> int | None:
+        if "selectionRange" in self.symbol_root:
+            return self.symbol_root["selectionRange"]["start"]["character"]
+        else:
+            # precise location is expected to be undefined for some types of symbols (e.g. SymbolKind.File)
+            return None
+
+    @property
+    def body(self) -> str | None:
+        return self.symbol_root.get("body")
+
+    def get_name_path(self) -> str:
+        """
+        Get the name path of the symbol (e.g. "class/method/inner_function").
+        """
+        return self._NAME_PATH_SEP.join(self.get_name_path_parts())
+
+    def get_name_path_parts(self) -> list[str]:
+        """
+        Get the parts of the name path of the symbol (e.g. ["class", "method", "inner_function"]).
+        """
+        ancestors_within_file = list(self.iter_ancestors(up_to_symbol_kind=SymbolKind.File))
+        ancestors_within_file.reverse()
+        return [a.name for a in ancestors_within_file] + [self.name]
+
+    def iter_children(self) -> Iterator[Self]:
+        for c in self.symbol_root["children"]:
+            yield self.__class__(c)
+
+    def iter_ancestors(self, up_to_symbol_kind: SymbolKind | None = None) -> Iterator[Self]:
+        """
+        Iterate over all ancestors of the symbol, starting with the parent and going up to the root or
+        the given symbol kind.
+
+        :param up_to_symbol_kind: if provided, iteration will stop *before* the first ancestor of the given kind.
+            A typical use case is to pass `SymbolKind.File` or `SymbolKind.Package`.
+        """
+        parent = self.get_parent()
+        if parent is not None:
+            if up_to_symbol_kind is None or parent.symbol_kind != up_to_symbol_kind:
+                yield parent
+                yield from parent.iter_ancestors(up_to_symbol_kind=up_to_symbol_kind)
+
+    def get_parent(self) -> Self | None:
+        parent_root = self.symbol_root.get("parent")
+        if parent_root is None:
+            return None
+        return self.__class__(parent_root)
+
+    def find(
+        self,
+        name_path: str,
+        substring_matching: bool = False,
+        include_kinds: Sequence[SymbolKind] | None = None,
+        exclude_kinds: Sequence[SymbolKind] | None = None,
+    ) -> list[Self]:
+        """
+        Find all symbols within the symbol's subtree that match the given `name_path`.
+        The matching behavior is determined by the structure of `name_path`, which can
+        either be a simple name (e.g. "method") or a name path like "class/method" (relative name path)
+        or "/class/method" (absolute name path).
+
+        Key aspects of the name path matching behavior:
+        - Trailing slashes in `name_path` play no role and are ignored.
+        - The name of the retrieved symbols will match (either exactly or as a substring)
+          the last segment of `name_path`, while other segments will restrict the search to symbols that
+          have a desired sequence of ancestors.
+        - If there is no starting or intermediate slash in `name_path`, there is no
+          restriction on the ancestor symbols. For example, passing `method` will match
+          against symbols with name paths like `method`, `class/method`, `class/nested_class/method`, etc.
+        - If `name_path` contains a `/` but doesn't start with a `/`, the matching is restricted to symbols
+          with the same ancestors as the last segment of `name_path`. For example, passing `class/method` will match against
+          `class/method` as well as `nested_class/class/method` but not `method`.
+        - If `name_path` starts with a `/`, it will be treated as an absolute name path pattern, meaning
+          that the first segment of it must match the first segment of the symbol's name path.
+          For example, passing `/class` will match only against top-level symbols like `class` but not against `nested_class/class`.
+          Passing `/class/method` will match against `class/method` but not `nested_class/class/method` or `method`.
+
+        :param name_path: the name path to match against
+        :param substring_matching: whether to use substring matching (as opposed to exact matching)
+            of the last segment of `name_path` against the symbol name.
+        :param include_kinds: an optional sequence of ints representing the LSP symbol kind.
+            If provided, only symbols of the given kinds will be included in the result.
+        :param exclude_kinds: If provided, symbols of the given kinds will be excluded from the result.
+        """
+        result = []
+
+        def should_include(s: "Symbol") -> bool:
+            if include_kinds is not None and s.symbol_kind not in include_kinds:
+                return False
+            if exclude_kinds is not None and s.symbol_kind in exclude_kinds:
+                return False
+            return Symbol.match_name_path(
+                name_path=name_path,
+                symbol_name_path_parts=s.get_name_path_parts(),
+                substring_matching=substring_matching,
+            )
+
+        def traverse(s: "Symbol") -> None:
+            if should_include(s):
+                result.append(s)
+            for c in s.iter_children():
+                traverse(c)
+
+        traverse(self)
+        return result
+
+    def to_dict(
+        self, kind: bool = False, location: bool = False, depth: int = 0, include_body: bool = False, include_children_body: bool = False
+    ) -> dict[str, Any]:
+        """
+        Converts the symbol to a dictionary.
+
+        :param kind: whether to include the kind of the symbol
+        :param location: whether to include the location of the symbol
+        :param depth: the depth of the symbol
+        :param include_body: whether to include the body of the top-level symbol.
+        :param include_children_body: whether to also include the body of the children.
+            Note that the body of the children is part of the body of the parent symbol,
+            so there is usually no need to set this to True unless you want process the output
+            and pass the children without passing the parent body to the LM.
+        :return: a dictionary representation of the symbol
+        """
+        result: dict[str, Any] = {"name": self.name, "name_path": self.get_name_path()}
+
+        if kind:
+            result["kind"] = self.kind
+
+        if location:
+            result["location"] = self.location.to_dict()
+            body_start_line, body_end_line = self.get_body_line_numbers()
+            result["body_location"] = {"start_line": body_start_line, "end_line": body_end_line}
+
+        if include_body:
+            if self.body is None:
+                log.warning("Requested body for symbol, but it is not present. The symbol might have been loaded with include_body=False.")
+            result["body"] = self.body
+
+        def add_children(s: Self) -> list[dict[str, Any]]:
+            children = []
+            for c in s.iter_children():
+                children.append(
+                    c.to_dict(
+                        kind=kind,
+                        location=location,
+                        depth=depth - 1,
+                        include_body=include_children_body,
+                        include_children_body=include_children_body,
+                    )
+                )
+            return children
+
+        if depth > 0:
+            result["children"] = add_children(self)
+
+        return result
+
+
+@dataclass
+class ReferenceInSymbol(ToStringMixin):
+    """Same as the class of the same name in the language server, but using Serena's Symbol class.
+    Be careful to not confuse it with counterpart!
+    """
+
+    symbol: Symbol
+    line: int
+    character: int
+
+    def get_relative_path(self) -> str | None:
+        return self.symbol.location.relative_path
+
+    @classmethod
+    def from_lsp_reference(cls, reference: LSPReferenceInSymbol) -> Self:
+        return cls(symbol=Symbol(reference.symbol), line=reference.line, character=reference.character)
+
+
+class SymbolManager:
+    def __init__(self, lang_server: SolidLanguageServer, agent: Union["SerenaAgent", None] = None) -> None:
+        """
+        :param lang_server: the language server to use for symbol retrieval as well as editing operations.
+        :param agent: the agent to use (only needed for marking files as modified). You can pass None if you don't
+            need an agent to be aware of file modifications performed by the symbol manager.
+        """
+        self._lang_server = lang_server
+        self.agent = agent
+
+    def set_language_server(self, lang_server: SolidLanguageServer) -> None:
+        """
+        Set the language server to use for symbol retrieval and editing operations.
+        This is useful if you want to change the language server after initializing the SymbolManager.
+        """
+        self._lang_server = lang_server
+
+    def find_by_name(
+        self,
+        name_path: str,
+        include_body: bool = False,
+        include_kinds: Sequence[SymbolKind] | None = None,
+        exclude_kinds: Sequence[SymbolKind] | None = None,
+        substring_matching: bool = False,
+        within_relative_path: str | None = None,
+    ) -> list[Symbol]:
+        """
+        Find all symbols that match the given name. See docstring of `Symbol.find` for more details.
+        The only parameter not mentioned there is `within_relative_path`, which can be used to restrict the search
+        to symbols within a specific file or directory.
+        """
+        symbols: list[Symbol] = []
+        symbol_roots = self._lang_server.request_full_symbol_tree(within_relative_path=within_relative_path, include_body=include_body)
+        for root in symbol_roots:
+            symbols.extend(
+                Symbol(root).find(
+                    name_path, include_kinds=include_kinds, exclude_kinds=exclude_kinds, substring_matching=substring_matching
+                )
+            )
+        return symbols
+
+    def get_document_symbols(self, relative_path: str) -> list[Symbol]:
+        symbol_dicts, roots = self._lang_server.request_document_symbols(relative_path, include_body=False)
+        symbols = [Symbol(s) for s in symbol_dicts]
+        return symbols
+
+    def find_by_location(self, location: SymbolLocation) -> Symbol | None:
+        if location.relative_path is None:
+            return None
+        symbol_dicts, roots = self._lang_server.request_document_symbols(location.relative_path, include_body=False)
+        for symbol_dict in symbol_dicts:
+            symbol = Symbol(symbol_dict)
+            if symbol.location == location:
+                return symbol
+        return None
+
+    def find_referencing_symbols(
+        self,
+        name_path: str,
+        relative_file_path: str,
+        include_body: bool = False,
+        include_kinds: Sequence[SymbolKind] | None = None,
+        exclude_kinds: Sequence[SymbolKind] | None = None,
+    ) -> list[ReferenceInSymbol]:
+        """
+        Find all symbols that reference the symbol with the given name.
+        If multiple symbols fit the name (e.g. for variables that are overwritten), will use the first one.
+
+        :param name_path: the name path of the symbol to find
+        :param relative_file_path: the relative path of the file in which the referenced symbol is defined.
+        :param include_body: whether to include the body of all symbols in the result.
+            Not recommended, as the referencing symbols will often be files, and thus the bodies will be very long.
+        :param include_kinds: which kinds of symbols to include in the result.
+        :param exclude_kinds: which kinds of symbols to exclude from the result.
+        """
+        symbol_candidates = self.find_by_name(name_path, substring_matching=False, within_relative_path=relative_file_path)
+        if len(symbol_candidates) == 0:
+            log.warning(f"No symbol with name {name_path} found in file {relative_file_path}")
+            return []
+        if len(symbol_candidates) > 1:
+            log.error(
+                f"Found {len(symbol_candidates)} symbols with name {name_path} in file {relative_file_path}."
+                f"May be an overwritten variable, in which case you can ignore this error. Proceeding with the first one. "
+                f"Found symbols for {name_path=} in {relative_file_path=}: \n"
+                f"{json.dumps([s.location.to_dict() for s in symbol_candidates], indent=2)}"
+            )
+        symbol = symbol_candidates[0]
+        return self.find_referencing_symbols_by_location(
+            symbol.location, include_body=include_body, include_kinds=include_kinds, exclude_kinds=exclude_kinds
+        )
+
+    def find_referencing_symbols_by_location(
+        self,
+        symbol_location: SymbolLocation,
+        include_body: bool = False,
+        include_kinds: Sequence[SymbolKind] | None = None,
+        exclude_kinds: Sequence[SymbolKind] | None = None,
+    ) -> list[ReferenceInSymbol]:
+        """
+        Find all symbols that reference the symbol at the given location.
+
+        :param symbol_location: the location of the symbol for which to find references.
+            Does not need to include an end_line, as it is unused in the search.
+        :param include_body: whether to include the body of all symbols in the result.
+            Not recommended, as the referencing symbols will often be files, and thus the bodies will be very long.
+            Note: you can filter out the bodies of the children if you set include_children_body=False
+            in the to_dict method.
+        :param include_kinds: an optional sequence of ints representing the LSP symbol kind.
+            If provided, only symbols of the given kinds will be included in the result.
+        :param exclude_kinds: If provided, symbols of the given kinds will be excluded from the result.
+            Takes precedence over include_kinds.
+        :return: a list of symbols that reference the given symbol
+        """
+        if not symbol_location.has_position_in_file():
+            raise ValueError("Symbol location does not contain a valid position in a file")
+        assert symbol_location.relative_path is not None
+        assert symbol_location.line is not None
+        assert symbol_location.column is not None
+        references = self._lang_server.request_referencing_symbols(
+            relative_file_path=symbol_location.relative_path,
+            line=symbol_location.line,
+            column=symbol_location.column,
+            include_imports=False,
+            include_self=False,
+            include_body=include_body,
+            include_file_symbols=True,
+        )
+
+        if include_kinds is not None:
+            references = [s for s in references if s.symbol["kind"] in include_kinds]
+
+        if exclude_kinds is not None:
+            references = [s for s in references if s.symbol["kind"] not in exclude_kinds]
+
+        return [ReferenceInSymbol.from_lsp_reference(r) for r in references]
+
+    @contextmanager
+    def _edited_file(self, relative_path: str) -> Iterator[None]:
+        with self._lang_server.open_file(relative_path) as file_buffer:
+            yield
+            root_path = self._lang_server.language_server.repository_root_path
+            abs_path = os.path.join(root_path, relative_path)
+            with open(abs_path, "w", encoding="utf-8") as f:
+                f.write(file_buffer.contents)
+            if self.agent is not None:
+                self.agent.mark_file_modified(relative_path)
+
+    @contextmanager
+    def _edited_symbol_location(self, location: SymbolLocation) -> Iterator[Symbol]:
+        """
+        Context manager for locating and editing a symbol in a file.
+        """
+        symbol = self.find_by_location(location)
+        if symbol is None:
+            raise ValueError("Symbol not found/has no defined location within a file")
+        assert location.relative_path is not None
+        with self._edited_file(location.relative_path):
+            yield symbol
+
+    def _get_code_file_content(self, relative_path: str) -> str:
+        """Get the content of a file using the language server."""
+        return self._lang_server.language_server.retrieve_full_file_content(relative_path)
+
+    def replace_body(self, name_path: str, relative_file_path: str, body: str, *, use_same_indentation: bool = True) -> None:
+        """
+        Replace the body of the symbol with the given name_path in the given file.
+
+        :param name_path: the name path of the symbol to replace.
+        :param relative_file_path: the relative path of the file in which the symbol is defined.
+        :param body: the new body
+        :param use_same_indentation: whether to use the same indentation as the original body. This means that
+            the user doesn't have to provide the correct indentation, but can just write the body.
+        """
+        symbol_candidates = self.find_by_name(name_path, within_relative_path=relative_file_path)
+        if len(symbol_candidates) == 0:
+            raise ValueError(f"No symbol with name {name_path} found in file {relative_file_path}")
+        if len(symbol_candidates) > 1:
+            raise ValueError(
+                f"Found multiple {len(symbol_candidates)} symbols with name {name_path} in file {relative_file_path}. "
+                "Will not replace the body of any of them, but you can use `replace_body_at_location`, the replace lines tool or other editing "
+                "tools to perform your edits. Their locations are: \n "
+                + json.dumps([s.location.to_dict() for s in symbol_candidates], indent=2)
+            )
+        symbol = symbol_candidates[0]
+        return self.replace_body_at_location(symbol.location, body, use_same_indentation=use_same_indentation)
+
+    def replace_body_at_location(self, location: SymbolLocation, body: str, *, use_same_indentation: bool = True) -> None:
+        """
+        Replace the body of the symbol at the given location with the given body
+
+        :param location: the location of the symbol to replace.
+        :param body: the new body
+        :param use_same_indentation: whether to use the same indentation as the original body. This means that
+            the user doesn't have to provide the correct indentation, but can just write the body.
+        """
+        with self._edited_symbol_location(location) as symbol:
+            assert location.relative_path is not None
+            start_pos = symbol.body_start_position
+            end_pos = symbol.body_end_position
+            if start_pos is None or end_pos is None:
+                raise ValueError(f"Symbol at {location} does not have a defined body range.")
+            start_line, start_col = start_pos["line"], start_pos["character"]
+
+            if use_same_indentation:
+                indent = " " * start_col
+                body_lines = body.splitlines()
+                body = body_lines[0] + "\n" + "\n".join(indent + line for line in body_lines[1:])
+
+            # make sure the replacement adds no additional newlines (before or after) - all newlines
+            # and whitespace before/after should remain the same, so we strip it entirely
+            body = body.strip()
+
+            self._lang_server.delete_text_between_positions(location.relative_path, start_pos, end_pos)
+            self._lang_server.insert_text_at_position(location.relative_path, start_line, start_col, body)
+
+    @staticmethod
+    def _count_leading_newlines(text: Iterable) -> int:
+        cnt = 0
+        for c in text:
+            if c == "\n":
+                cnt += 1
+            elif c == "\r":
+                continue
+            else:
+                break
+        return cnt
+
+    @classmethod
+    def _count_trailing_newlines(cls, text: Reversible) -> int:
+        return cls._count_leading_newlines(reversed(text))
+
+    def insert_after_symbol(self, name_path: str, relative_file_path: str, body: str, *, use_same_indentation: bool = True) -> None:
+        """
+        Inserts content after the symbol with the given name in the given file.
+        """
+        symbol_candidates = self.find_by_name(name_path, within_relative_path=relative_file_path)
+        if len(symbol_candidates) == 0:
+            raise ValueError(f"No symbol with name {name_path} found in file {relative_file_path}")
+        if len(symbol_candidates) > 1:
+            raise ValueError(
+                f"Found multiple {len(symbol_candidates)} symbols with name {name_path} in file {relative_file_path}. "
+                f"May be an overwritten variable, in which case you can ignore this error. Proceeding with the last one. "
+                f"Found symbols at locations: \n" + json.dumps([s.location.to_dict() for s in symbol_candidates], indent=2)
+            )
+        symbol = symbol_candidates[-1]
+        return self.insert_after_symbol_at_location(symbol.location, body, use_same_indentation=use_same_indentation)
+
+    def insert_after_symbol_at_location(self, location: SymbolLocation, body: str, *, use_same_indentation: bool = True) -> None:
+        """
+        Appends content after the given symbol
+
+        :param location: the location of the symbol after which to add new lines
+        :param body: the body of the entity to append
+        """
+        # make sure body always ends with at least one newline
+        if not body.endswith("\n"):
+            body += "\n"
+
+        assert location.relative_path is not None
+
+        # Find the symbol to get its end position
+        symbol = self.find_by_location(location)
+        if symbol is None:
+            raise ValueError("Symbol not found/has no defined location within a file")
+
+        pos = symbol.body_end_position
+        if pos is None:
+            raise ValueError(f"Symbol at {location} does not have a defined end position.")
+
+        # start at the beginning of the next line
+        col = 0
+        line = pos["line"] + 1
+        # make sure a suitable number of leading empty lines is used (at least 0/1 depending on the symbol type,
+        # otherwise as many as the caller wanted to insert)
+        original_leading_newlines = self._count_leading_newlines(body)
+        body = body.lstrip("\r\n")
+        min_empty_lines = 0
+        if symbol.is_neighbouring_definition_separated_by_empty_line():
+            min_empty_lines = 1
+        num_leading_empty_lines = max(min_empty_lines, original_leading_newlines)
+        if num_leading_empty_lines:
+            body = ("\n" * num_leading_empty_lines) + body
+        # make sure the one line break succeeding the original symbol, which we repurposed as prefix via
+        # `line += 1`, is replaced
+        body = body.rstrip("\r\n") + "\n"
+
+        if use_same_indentation:
+            symbol_start_pos = symbol.body_start_position
+            assert symbol_start_pos is not None, f"Symbol at {location=} does not have a defined start position."
+            symbol_identifier_col = symbol_start_pos["character"]
+            indent = " " * (symbol_identifier_col)
+            body = "\n".join(indent + line for line in body.splitlines())
+            # IMPORTANT: without this, the insertion does the wrong thing. See implementation of insert_text_at_position in TextUtils,
+            # it is somewhat counterintuitive (never inserts whitespace)
+            # I am not 100% sure whether col=0 is always the best choice here.
+            #
+            # Without col=0, inserting after dataclass_instance in variables.py:
+            # > dataclass_instance = VariableDataclass(id=1, name="Test")
+            # > test test
+            # > dataclass_instancetest test
+            # > second line
+            # > .status = "active"  # Reassign dataclass field
+            #
+            # With col=0:
+            # > dataclass_instance = VariableDataclass(id=1, name="Test")
+            # > test test
+            # > second line
+            # > dataclass_instance.status = "active"  # Reassign dataclass field
+
+        with self._edited_symbol_location(location):
+            self._lang_server.insert_text_at_position(location.relative_path, line=line, column=col, text_to_be_inserted=body)
+
+    def insert_before_symbol(self, name_path: str, relative_file_path: str, body: str, *, use_same_indentation: bool = True) -> None:
+        """
+        Inserts content before the symbol with the given name in the given file.
+        """
+        symbol_candidates = self.find_by_name(name_path, within_relative_path=relative_file_path)
+        if len(symbol_candidates) == 0:
+            raise ValueError(f"No symbol with name {name_path} found in file {relative_file_path}")
+        if len(symbol_candidates) > 1:
+            raise ValueError(
+                f"Found multiple {len(symbol_candidates)} symbols with name {name_path} in file {relative_file_path}. "
+                f"May be an overwritten variable, in which case you can ignore this error. Proceeding with the first one. "
+                f"Found symbols at locations: \n" + json.dumps([s.location.to_dict() for s in symbol_candidates], indent=2)
+            )
+        symbol = symbol_candidates[0]
+        self.insert_before_symbol_at_location(symbol.location, body, use_same_indentation=use_same_indentation)
+
+    def insert_before_symbol_at_location(self, location: SymbolLocation, body: str, *, use_same_indentation: bool = True) -> None:
+        """
+        Inserts content before the given symbol
+
+        :param location: the location of the symbol before which to add new lines
+        :param body: the body of the entity to insert
+        """
+        with self._edited_symbol_location(location) as symbol:
+            symbol_start_pos = symbol.body_start_position
+            if symbol_start_pos is None:
+                raise ValueError(f"Symbol at {location} does not have a defined start position.")
+
+            if use_same_indentation:
+                indent = " " * (symbol_start_pos["character"])
+                body = "\n".join(indent + line for line in body.splitlines())
+
+            # insert position is the start of line where the symbol is defined
+            line = symbol_start_pos["line"]
+            col = 0
+
+            original_trailing_empty_lines = self._count_trailing_newlines(body) - 1
+
+            # ensure eol is present at end
+            body = body.rstrip() + "\n"
+
+            # add suitable number of trailing empty lines after the body (at least 0/1 depending on the symbol type,
+            # otherwise as many as the caller wanted to insert)
+            min_trailing_empty_lines = 0
+            if symbol.is_neighbouring_definition_separated_by_empty_line():
+                min_trailing_empty_lines = 1
+            num_trailing_newlines = max(min_trailing_empty_lines, original_trailing_empty_lines)
+            body += "\n" * num_trailing_newlines
+
+            assert location.relative_path is not None
+
+            self._lang_server.insert_text_at_position(location.relative_path, line=line, column=col, text_to_be_inserted=body)
+
+    def insert_at_line(self, relative_path: str, line: int, content: str) -> None:
+        """
+        Inserts content at the given line in the given file.
+
+        :param line: the 0-based index of the line to insert content at
+        :param content: the content to insert
+        """
+        with self._edited_file(relative_path):
+            self._lang_server.insert_text_at_position(relative_path, line, 0, content)
+
+    def delete_lines(self, relative_path: str, start_line: int, end_line: int) -> None:
+        """
+        Deletes lines in the given file.
+
+        :param start_line: the 0-based index of the first line to delete (inclusive)
+        :param end_line: the 0-based index of the last line to delete (inclusive)
+        """
+        start_col = 0
+        end_line_for_delete = end_line + 1
+        end_col = 0
+        with self._edited_file(relative_path):
+            start_pos = Position(line=start_line, character=start_col)
+            end_pos = Position(line=end_line_for_delete, character=end_col)
+            self._lang_server.delete_text_between_positions(relative_path, start_pos, end_pos)
+
+    def delete_symbol_at_location(self, location: SymbolLocation) -> None:
+        """
+        Deletes the symbol at the given location.
+        """
+        with self._edited_symbol_location(location) as symbol:
+            assert location.relative_path is not None
+            assert symbol.body_start_position is not None
+            assert symbol.body_end_position is not None
+            self._lang_server.delete_text_between_positions(location.relative_path, symbol.body_start_position, symbol.body_end_position)
+
+    def delete_symbol(self, name_path: str, relative_file_path: str) -> None:
+        """
+        Deletes the symbol with the given name in the given file.
+        """
+        symbol_candidates = self.find_by_name(name_path, within_relative_path=relative_file_path)
+        if len(symbol_candidates) == 0:
+            raise ValueError(f"No symbol with name {name_path} found in file {relative_file_path}")
+        if len(symbol_candidates) > 1:
+            raise ValueError(
+                f"Found multiple {len(symbol_candidates)} symbols with name {name_path} in file {relative_file_path}. "
+                "Will not delete any of them, but you can use `delete_symbol_at_location` or a corresponding tool to perform your edits. "
+                "Their locations are: \n " + json.dumps([s.location.to_dict() for s in symbol_candidates], indent=2)
+            )
+        symbol = symbol_candidates[0]
+        self.delete_symbol_at_location(symbol.location)